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
  
  
  __a   				=      logging.get_logger(__name__)
  
  __a   				=      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'''),
      ]
  )
  
  __a   				=      _LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)
  
  
  
  
  def 			__lowercase	(						_UpperCamelCase     )    ->List[str]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
              if class_name in processors:
                    lowercase			:   Tuple					   =		model_type_to_module_name(_UpperCamelCase     )
  
                    lowercase			:   Optional[Any]					   =		importlib.import_module(f""".{module_name}""",    '''transformers.models'''     )
                    try:
                          return getattr(_UpperCamelCase,    _UpperCamelCase     )
                    except AttributeError:
                          continue
  
        for processor in PROCESSOR_MAPPING._extra_content.values():
              if getattr(_UpperCamelCase,    '''__name__''',    _UpperCamelCase     ) == 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.
        lowercase			:   Dict					   =		importlib.import_module('''transformers'''     )
        if hasattr(_UpperCamelCase,    _UpperCamelCase     ):
              return getattr(_UpperCamelCase,    _UpperCamelCase     )
  
        return None
  
  
  
  
  
  
  
  class 				__SCREAMING_SNAKE_CASE   :
  
  
        def __init__(							self		):
              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(SCREAMING_SNAKE_CASE__		)
        def        __lowerCamelCase			(							cls							,						SCREAMING_SNAKE_CASE__							,						**SCREAMING_SNAKE_CASE__		):
              lowercase			:   Dict					   =		kwargs.pop('''config'''							,						SCREAMING_SNAKE_CASE__		)
              lowercase			:   Any					   =		kwargs.pop('''trust_remote_code'''							,						SCREAMING_SNAKE_CASE__		)
              lowercase			:   Dict					   =		True
  
              lowercase			:   Dict					   =		None
              lowercase			:   List[Any]					   =		None
  
              # First, let's see if we have a preprocessor config.
              # Filter the kwargs for `get_file_from_repo`.
              lowercase			:   Union[str, Any]					   =		{
                  key: kwargs[key] for key in inspect.signature(SCREAMING_SNAKE_CASE__		).parameters.keys() if key in kwargs
              }
              # Let's start by checking whether the processor class is saved in an image processor
              lowercase			:   int					   =		get_file_from_repo(
                  SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__							,						**SCREAMING_SNAKE_CASE__		)
              if preprocessor_config_file is not None:
                    lowercase   ,			lowercase			:   Optional[int]					   =		ImageProcessingMixin.get_image_processor_dict(SCREAMING_SNAKE_CASE__							,						**SCREAMING_SNAKE_CASE__		)
                    lowercase			:   Dict					   =		config_dict.get('''processor_class'''							,						SCREAMING_SNAKE_CASE__		)
                    if "AutoProcessor" in config_dict.get('''auto_map'''							,						{}		):
                          lowercase			:   Any					   =		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:
                    lowercase   ,			lowercase			:   Dict					   =		FeatureExtractionMixin.get_feature_extractor_dict(SCREAMING_SNAKE_CASE__							,						**SCREAMING_SNAKE_CASE__		)
                    lowercase			:   Optional[int]					   =		config_dict.get('''processor_class'''							,						SCREAMING_SNAKE_CASE__		)
                    if "AutoProcessor" in config_dict.get('''auto_map'''							,						{}		):
                          lowercase			:   List[str]					   =		config_dict['''auto_map''']['''AutoProcessor''']
  
              if processor_class is None:
                    # Next, let's check whether the processor class is saved in a tokenizer
                    lowercase			:   Optional[Any]					   =		get_file_from_repo(
                        SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__							,						**SCREAMING_SNAKE_CASE__		)
                    if tokenizer_config_file is not None:
                          with open(SCREAMING_SNAKE_CASE__							,						encoding='''utf-8'''		) as reader:
                                lowercase			:   str					   =		json.load(SCREAMING_SNAKE_CASE__		)
  
                          lowercase			:   List[Any]					   =		config_dict.get('''processor_class'''							,						SCREAMING_SNAKE_CASE__		)
                          if "AutoProcessor" in config_dict.get('''auto_map'''							,						{}		):
                                lowercase			:   Any					   =		config_dict['''auto_map''']['''AutoProcessor''']
  
              if processor_class is None:
                    # Otherwise, load config, if it can be loaded.
                    if not isinstance(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		):
                          lowercase			:   str					   =		AutoConfig.from_pretrained(
                              SCREAMING_SNAKE_CASE__							,						trust_remote_code=SCREAMING_SNAKE_CASE__							,						**SCREAMING_SNAKE_CASE__		)
  
                    # And check if the config contains the processor class.
                    lowercase			:   List[Any]					   =		getattr(SCREAMING_SNAKE_CASE__							,						'''processor_class'''							,						SCREAMING_SNAKE_CASE__		)
                    if hasattr(SCREAMING_SNAKE_CASE__							,						'''auto_map'''		) and "AutoProcessor" in config.auto_map:
                          lowercase			:   str					   =		config.auto_map['''AutoProcessor''']
  
              if processor_class is not None:
                    lowercase			:   List[str]					   =		processor_class_from_name(SCREAMING_SNAKE_CASE__		)
  
              lowercase			:   Optional[int]					   =		processor_auto_map is not None
              lowercase			:   int					   =		processor_class is not None or type(SCREAMING_SNAKE_CASE__		) in PROCESSOR_MAPPING
              lowercase			:   Tuple					   =		resolve_trust_remote_code(
                  SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		)
  
              if has_remote_code and trust_remote_code:
                    lowercase			:   Tuple					   =		get_class_from_dynamic_module(
                        SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__							,						**SCREAMING_SNAKE_CASE__		)
                    lowercase			:   List[str]					   =		kwargs.pop('''code_revision'''							,						SCREAMING_SNAKE_CASE__		)
                    if os.path.isdir(SCREAMING_SNAKE_CASE__		):
                          processor_class.register_for_auto_class()
                    return processor_class.from_pretrained(
                        SCREAMING_SNAKE_CASE__							,						trust_remote_code=SCREAMING_SNAKE_CASE__							,						**SCREAMING_SNAKE_CASE__		)
              elif processor_class is not None:
                    return processor_class.from_pretrained(
                        SCREAMING_SNAKE_CASE__							,						trust_remote_code=SCREAMING_SNAKE_CASE__							,						**SCREAMING_SNAKE_CASE__		)
              # Last try: we use the PROCESSOR_MAPPING.
              elif type(SCREAMING_SNAKE_CASE__		) in PROCESSOR_MAPPING:
                    return PROCESSOR_MAPPING[type(SCREAMING_SNAKE_CASE__		)].from_pretrained(SCREAMING_SNAKE_CASE__							,						**SCREAMING_SNAKE_CASE__		)
  
              # 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(
                        SCREAMING_SNAKE_CASE__							,						trust_remote_code=SCREAMING_SNAKE_CASE__							,						**SCREAMING_SNAKE_CASE__		)
              except Exception:
                    try:
                          return AutoImageProcessor.from_pretrained(
                              SCREAMING_SNAKE_CASE__							,						trust_remote_code=SCREAMING_SNAKE_CASE__							,						**SCREAMING_SNAKE_CASE__		)
                    except Exception:
                          pass
  
                    try:
                          return AutoFeatureExtractor.from_pretrained(
                              SCREAMING_SNAKE_CASE__							,						trust_remote_code=SCREAMING_SNAKE_CASE__							,						**SCREAMING_SNAKE_CASE__		)
                    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        __lowerCamelCase			(							SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		):
              PROCESSOR_MAPPING.register(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__		)
  
  
style_context: 
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available
  
  
  __a   				=      {'''configuration_yoso''': ['''YOSO_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''YosoConfig''']}
  
  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    __a   				=      [
        '''YOSO_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''YosoForMaskedLM''',
        '''YosoForMultipleChoice''',
        '''YosoForQuestionAnswering''',
        '''YosoForSequenceClassification''',
        '''YosoForTokenClassification''',
        '''YosoLayer''',
        '''YosoModel''',
        '''YosoPreTrainedModel''',
    ]
  
  
  if TYPE_CHECKING:
    from .configuration_yoso import YOSO_PRETRAINED_CONFIG_ARCHIVE_MAP, YosoConfig
  
    try:
      if not is_torch_available():
        raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
      pass
    else:
      from .modeling_yoso import (
          YOSO_PRETRAINED_MODEL_ARCHIVE_LIST,
          YosoForMaskedLM,
          YosoForMultipleChoice,
          YosoForQuestionAnswering,
          YosoForSequenceClassification,
          YosoForTokenClassification,
          YosoLayer,
          YosoModel,
          YosoPreTrainedModel,
      )
  
  
  else:
    import sys
  
    __a   				=      _LazyModule(__name__, globals()['''__file__'''], _import_structure)
  
  