code: 
  
  
  
  import importlib
  import inspect
  import json
  import os
  from collections import OrderedDict
  
  # Build the list of all feature extractors
  from ...configuration_utils import PretrainedConfig
  from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
  from ...feature_extraction_utils import FeatureExtractionMixin
  from ...image_processing_utils import ImageProcessingMixin
  from ...tokenization_utils import TOKENIZER_CONFIG_FILE
  from ...utils import FEATURE_EXTRACTOR_NAME, get_file_from_repo, logging
  from .auto_factory import _LazyAutoMapping
  from .configuration_auto import (
      CONFIG_MAPPING_NAMES,
      AutoConfig,
      model_type_to_module_name,
      replace_list_option_in_docstrings,
  )
  from .feature_extraction_auto import AutoFeatureExtractor
  from .image_processing_auto import AutoImageProcessor
  from .tokenization_auto import AutoTokenizer
  
  
  __lowerCAmelCase     =			logging.get_logger(__name__)
  
  __lowerCAmelCase     =			OrderedDict(
      [
          ("align", "AlignProcessor"),
          ("altclip", "AltCLIPProcessor"),
          ("bark", "BarkProcessor"),
          ("blip", "BlipProcessor"),
          ("blip-2", "Blip2Processor"),
          ("bridgetower", "BridgeTowerProcessor"),
          ("chinese_clip", "ChineseCLIPProcessor"),
          ("clap", "ClapProcessor"),
          ("clip", "CLIPProcessor"),
          ("clipseg", "CLIPSegProcessor"),
          ("flava", "FlavaProcessor"),
          ("git", "GitProcessor"),
          ("groupvit", "CLIPProcessor"),
          ("hubert", "Wav2Vec2Processor"),
          ("instructblip", "InstructBlipProcessor"),
          ("layoutlmv2", "LayoutLMv2Processor"),
          ("layoutlmv3", "LayoutLMv3Processor"),
          ("markuplm", "MarkupLMProcessor"),
          ("mctct", "MCTCTProcessor"),
          ("mgp-str", "MgpstrProcessor"),
          ("oneformer", "OneFormerProcessor"),
          ("owlvit", "OwlViTProcessor"),
          ("pix2struct", "Pix2StructProcessor"),
          ("sam", "SamProcessor"),
          ("sew", "Wav2Vec2Processor"),
          ("sew-d", "Wav2Vec2Processor"),
          ("speech_to_text", "Speech2TextProcessor"),
          ("speech_to_text_2", "Speech2Text2Processor"),
          ("speecht5", "SpeechT5Processor"),
          ("trocr", "TrOCRProcessor"),
          ("tvlt", "TvltProcessor"),
          ("unispeech", "Wav2Vec2Processor"),
          ("unispeech-sat", "Wav2Vec2Processor"),
          ("vilt", "ViltProcessor"),
          ("vision-text-dual-encoder", "VisionTextDualEncoderProcessor"),
          ("wav2vec2", "Wav2Vec2Processor"),
          ("wav2vec2-conformer", "Wav2Vec2Processor"),
          ("wavlm", "Wav2Vec2Processor"),
          ("whisper", "WhisperProcessor"),
          ("xclip", "XCLIPProcessor"),
      ]
  )
  
  __lowerCAmelCase     =			_LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)
  
  def     a						(      _lowercase   :     str       )     ->int:
  		for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
  				if class_name in processors:
  						UpperCamelCase__         =	model_type_to_module_name(_lowercase       )
  
  						UpperCamelCase__         =	importlib.import_module(F""".{module_name}""" ,						"""transformers.models"""       )
  						try:
  								return getattr(_lowercase ,						_lowercase       )
  						except AttributeError:
  								continue
  
  		for processor in PROCESSOR_MAPPING._extra_content.values():
  				if getattr(_lowercase ,						"""__name__""" ,						_lowercase       ) == class_name:
  						return processor
  
      # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
      # init and we return the proper dummy to get an appropriate error message.
  		UpperCamelCase__         =	importlib.import_module("""transformers"""       )
  		if hasattr(_lowercase ,						_lowercase       ):
  				return getattr(_lowercase ,						_lowercase       )
  
  		return None
  
  
  
  
  class   _UpperCAmelCase	:
  
  
  
  
  					def __init__(						self       )						->  int:
  							raise EnvironmentError(
  							    """AutoProcessor is designed to be instantiated """
  							    """using the `AutoProcessor.from_pretrained(pretrained_model_name_or_path)` method."""       )
  
  
  
  
  					@classmethod
  					@replace_list_option_in_docstrings(__lowerCAmelCase       )
  					def 	snake_case_		(						cls    ,      __lowerCAmelCase    ,      **__lowerCAmelCase       )						->  List[Any]:
  							UpperCamelCase__         =	kwargs.pop("""config"""    ,      __lowerCAmelCase       )
  							UpperCamelCase__         =	kwargs.pop("""trust_remote_code"""    ,      __lowerCAmelCase       )
  							UpperCamelCase__         =	True
  
  							UpperCamelCase__         =	None
  							UpperCamelCase__         =	None
  
  							# First, let's see if we have a preprocessor config.
  							# Filter the kwargs for `get_file_from_repo`.
  							UpperCamelCase__         =	{
  							    key: kwargs[key] for key in inspect.signature(__lowerCAmelCase       ).parameters.keys() if key in kwargs
  							}
  							# Let's start by checking whether the processor class is saved in an image processor
  							UpperCamelCase__         =	get_file_from_repo(
  							    __lowerCAmelCase    ,      __lowerCAmelCase    ,      **__lowerCAmelCase       )
  							if preprocessor_config_file is not None:
  									UpperCamelCase__  ,			UpperCamelCase__         =	ImageProcessingMixin.get_image_processor_dict(__lowerCAmelCase    ,      **__lowerCAmelCase       )
  									UpperCamelCase__         =	config_dict.get("""processor_class"""    ,      __lowerCAmelCase       )
  									if "AutoProcessor" in config_dict.get("""auto_map"""    ,      {}       ):
  											UpperCamelCase__         =	config_dict["""auto_map"""]["""AutoProcessor"""]
  
          # If not found, let's check whether the processor class is saved in a feature extractor config
  							if preprocessor_config_file is not None and processor_class is None:
  									UpperCamelCase__  ,			UpperCamelCase__         =	FeatureExtractionMixin.get_feature_extractor_dict(__lowerCAmelCase    ,      **__lowerCAmelCase       )
  									UpperCamelCase__         =	config_dict.get("""processor_class"""    ,      __lowerCAmelCase       )
  									if "AutoProcessor" in config_dict.get("""auto_map"""    ,      {}       ):
  											UpperCamelCase__         =	config_dict["""auto_map"""]["""AutoProcessor"""]
  
  							if processor_class is None:
  									# Next, let's check whether the processor class is saved in a tokenizer
  									UpperCamelCase__         =	get_file_from_repo(
  									    __lowerCAmelCase    ,      __lowerCAmelCase    ,      **__lowerCAmelCase       )
  									if tokenizer_config_file is not None:
  											with open(__lowerCAmelCase    ,      encoding="""utf-8"""       ) as reader:
  													UpperCamelCase__         =	json.load(__lowerCAmelCase       )
  
  											UpperCamelCase__         =	config_dict.get("""processor_class"""    ,      __lowerCAmelCase       )
  											if "AutoProcessor" in config_dict.get("""auto_map"""    ,      {}       ):
  													UpperCamelCase__         =	config_dict["""auto_map"""]["""AutoProcessor"""]
  
  							if processor_class is None:
  									# Otherwise, load config, if it can be loaded.
  									if not isinstance(__lowerCAmelCase    ,      __lowerCAmelCase       ):
  											UpperCamelCase__         =	AutoConfig.from_pretrained(
  											    __lowerCAmelCase    ,      trust_remote_code=__lowerCAmelCase    ,      **__lowerCAmelCase       )
  
  									# And check if the config contains the processor class.
  									UpperCamelCase__         =	getattr(__lowerCAmelCase    ,      """processor_class"""    ,      __lowerCAmelCase       )
  									if hasattr(__lowerCAmelCase    ,      """auto_map"""       ) and "AutoProcessor" in config.auto_map:
  											UpperCamelCase__         =	config.auto_map["""AutoProcessor"""]
  
  							if processor_class is not None:
  									UpperCamelCase__         =	processor_class_from_name(__lowerCAmelCase       )
  
  							UpperCamelCase__         =	processor_auto_map is not None
  							UpperCamelCase__         =	processor_class is not None or type(__lowerCAmelCase       ) in PROCESSOR_MAPPING
  							UpperCamelCase__         =	resolve_trust_remote_code(
  							    __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase       )
  
  							if has_remote_code and trust_remote_code:
  									UpperCamelCase__         =	get_class_from_dynamic_module(
  									    __lowerCAmelCase    ,      __lowerCAmelCase    ,      **__lowerCAmelCase       )
  									UpperCamelCase__         =	kwargs.pop("""code_revision"""    ,      __lowerCAmelCase       )
  									if os.path.isdir(__lowerCAmelCase       ):
  											processor_class.register_for_auto_class()
  									return processor_class.from_pretrained(
  									    __lowerCAmelCase    ,      trust_remote_code=__lowerCAmelCase    ,      **__lowerCAmelCase       )
  							elif processor_class is not None:
  									return processor_class.from_pretrained(
  									    __lowerCAmelCase    ,      trust_remote_code=__lowerCAmelCase    ,      **__lowerCAmelCase       )
  							# Last try: we use the PROCESSOR_MAPPING.
  							elif type(__lowerCAmelCase       ) in PROCESSOR_MAPPING:
  									return PROCESSOR_MAPPING[type(__lowerCAmelCase       )].from_pretrained(__lowerCAmelCase    ,      **__lowerCAmelCase       )
  
  							# At this stage, there doesn't seem to be a `Processor` class available for this model, so let's try a
  							# tokenizer.
  							try:
  									return AutoTokenizer.from_pretrained(
  									    __lowerCAmelCase    ,      trust_remote_code=__lowerCAmelCase    ,      **__lowerCAmelCase       )
  							except Exception:
  									try:
  											return AutoImageProcessor.from_pretrained(
  											    __lowerCAmelCase    ,      trust_remote_code=__lowerCAmelCase    ,      **__lowerCAmelCase       )
  									except Exception:
  											pass
  
  									try:
  											return AutoFeatureExtractor.from_pretrained(
  											    __lowerCAmelCase    ,      trust_remote_code=__lowerCAmelCase    ,      **__lowerCAmelCase       )
  									except Exception:
  											pass
  
  							raise ValueError(
  							    F"""Unrecognized processing class in {pretrained_model_name_or_path}. Can't instantiate a processor, a """
  							    """tokenizer, an image processor or a feature extractor for this model. Make sure the repository contains"""
  							    """the files of at least one of those processing classes."""       )
  
  
  
  
  					@staticmethod
  					def 	snake_case_		(						__lowerCAmelCase    ,      __lowerCAmelCase       )						->  Union[str, Any]:
  							PROCESSOR_MAPPING.register(__lowerCAmelCase    ,      __lowerCAmelCase       )
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round((float(_lowercase       ) * 9 / 5) + 3_2 ,						_lowercase       )
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round(float(_lowercase       ) + 273.15 ,						_lowercase       )
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round((float(_lowercase       ) * 9 / 5) + 491.67 ,						_lowercase       )
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round((float(_lowercase       ) - 3_2) * 5 / 9 ,						_lowercase       )
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round(((float(_lowercase       ) - 3_2) * 5 / 9) + 273.15 ,						_lowercase       )
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round(float(_lowercase       ) + 459.67 ,						_lowercase       )
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round(float(_lowercase       ) - 273.15 ,						_lowercase       )
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round(((float(_lowercase       ) - 273.15) * 9 / 5) + 3_2 ,						_lowercase       )
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round((float(_lowercase       ) * 9 / 5) ,						_lowercase       )
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round((float(_lowercase       ) - 491.67) * 5 / 9 ,						_lowercase       )
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round(float(_lowercase       ) - 459.67 ,						_lowercase       )
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round((float(_lowercase       ) * 5 / 9) ,						_lowercase       )
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round((float(_lowercase       ) * 1.25 + 273.15) ,						_lowercase       )
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round((float(_lowercase       ) * 2.25 + 3_2) ,						_lowercase       )
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round((float(_lowercase       ) * 1.25) ,						_lowercase       )
  
  def     a						(      _lowercase   :     float ,						_lowercase   :     int = 2       )     ->float:
  		return round((float(_lowercase       ) * 2.25 + 3_2 + 459.67) ,						_lowercase       )
  
  
  if __name__ == "__main__":
  				import doctest
  
  				doctest.testmod()
  
  
  
  
  
  