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 							_lowerCamelCase(				__snake_case	)  ->   Union[str, Any]:
  		for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
  				if class_name in processors:
  						__snake_case		       =     model_type_to_module_name(__snake_case	)
  
  						__snake_case		       =     importlib.import_module(f""".{module_name}"""						,						"transformers.models"	)
  						try:
  								return getattr(__snake_case						,						__snake_case	)
  						except AttributeError:
  								continue
  
  		for processor in PROCESSOR_MAPPING._extra_content.values():
  				if getattr(__snake_case						,						"__name__"						,						__snake_case	) == 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.
  		__snake_case		       =     importlib.import_module("transformers"	)
  		if hasattr(__snake_case						,						__snake_case	):
  				return getattr(__snake_case						,						__snake_case	)
  
  		return None
  
  
  
  
  
  class 					UpperCamelCase	:
  
  
  
  
  					def __init__( self :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							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 							UpperCamelCase_						( cls :					Tuple      ,_lowerCAmelCase :					Any      ,**_lowerCAmelCase :					Tuple						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     kwargs.pop("config"      ,_lowerCAmelCase						)
  							__snake_case		       =     kwargs.pop("trust_remote_code"      ,_lowerCAmelCase						)
  							__snake_case		       =     True
  
  							__snake_case		       =     None
  							__snake_case		       =     None
  
  							# First, let's see if we have a preprocessor config.
  							# Filter the kwargs for `get_file_from_repo`.
  							__snake_case		       =     {
  							    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
  							__snake_case		       =     get_file_from_repo(
  							    _lowerCAmelCase      ,_lowerCAmelCase      ,**_lowerCAmelCase						)
  							if preprocessor_config_file is not None:
  									__snake_case       ,       __snake_case		       =     ImageProcessingMixin.get_image_processor_dict(_lowerCAmelCase      ,**_lowerCAmelCase						)
  									__snake_case		       =     config_dict.get("processor_class"      ,_lowerCAmelCase						)
  									if "AutoProcessor" in config_dict.get("auto_map"      ,{}						):
  											__snake_case		       =     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:
  									__snake_case       ,       __snake_case		       =     FeatureExtractionMixin.get_feature_extractor_dict(_lowerCAmelCase      ,**_lowerCAmelCase						)
  									__snake_case		       =     config_dict.get("processor_class"      ,_lowerCAmelCase						)
  									if "AutoProcessor" in config_dict.get("auto_map"      ,{}						):
  											__snake_case		       =     config_dict["auto_map"]["AutoProcessor"]
  
  							if processor_class is None:
  									# Next, let's check whether the processor class is saved in a tokenizer
  									__snake_case		       =     get_file_from_repo(
  									    _lowerCAmelCase      ,_lowerCAmelCase      ,**_lowerCAmelCase						)
  									if tokenizer_config_file is not None:
  											with open(_lowerCAmelCase      ,encoding="utf-8"						) as reader:
  													__snake_case		       =     json.load(_lowerCAmelCase						)
  
  											__snake_case		       =     config_dict.get("processor_class"      ,_lowerCAmelCase						)
  											if "AutoProcessor" in config_dict.get("auto_map"      ,{}						):
  													__snake_case		       =     config_dict["auto_map"]["AutoProcessor"]
  
  							if processor_class is None:
  									# Otherwise, load config, if it can be loaded.
  									if not isinstance(_lowerCAmelCase      ,_lowerCAmelCase						):
  											__snake_case		       =     AutoConfig.from_pretrained(
  											    _lowerCAmelCase      ,trust_remote_code=_lowerCAmelCase      ,**_lowerCAmelCase						)
  
  									# And check if the config contains the processor class.
  									__snake_case		       =     getattr(_lowerCAmelCase      ,"processor_class"      ,_lowerCAmelCase						)
  									if hasattr(_lowerCAmelCase      ,"auto_map"						) and "AutoProcessor" in config.auto_map:
  											__snake_case		       =     config.auto_map["AutoProcessor"]
  
  							if processor_class is not None:
  									__snake_case		       =     processor_class_from_name(_lowerCAmelCase						)
  
  							__snake_case		       =     processor_auto_map is not None
  							__snake_case		       =     processor_class is not None or type(_lowerCAmelCase						) in PROCESSOR_MAPPING
  							__snake_case		       =     resolve_trust_remote_code(
  							    _lowerCAmelCase      ,_lowerCAmelCase      ,_lowerCAmelCase      ,_lowerCAmelCase						)
  
  							if has_remote_code and trust_remote_code:
  									__snake_case		       =     get_class_from_dynamic_module(
  									    _lowerCAmelCase      ,_lowerCAmelCase      ,**_lowerCAmelCase						)
  									__snake_case		       =     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 							UpperCamelCase_						( _lowerCAmelCase :					Any      ,_lowerCAmelCase :					Optional[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							PROCESSOR_MAPPING.register(_lowerCAmelCase      ,_lowerCAmelCase						)
  
  
  
  
  
  
style_context: from __future__ import annotations
  
  from collections.abc import Iterable
  from dataclasses import dataclass
  from typing import Any
  
  
  
  
  class 					UpperCamelCase	:
  					__UpperCamelCase						=   ("""_front""", """_back""", """_len""")
  
  
  
  
  					@dataclass
  					class 					UpperCamelCase	:
  										__UpperCamelCase						=   None
  										__UpperCamelCase						=   None
  										__UpperCamelCase						=   None
  
  
  
  
  					class 					UpperCamelCase	:
  										__UpperCamelCase						=   ("""_cur""",)
  
  
  
  
  										def __init__( self :					Dict      ,_lowerCAmelCase :					Deque._Node | None						):
  
  
  												"""simple docstring"""
  
  
  
  
  												__snake_case		       =     cur
  
  
  
  
  										def __iter__( self :					Dict						):
  
  
  												"""simple docstring"""
  
  
  
  
  												return self
  
  
  
  
  
  
  
  										def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
  												"""simple docstring"""
  
  
  
  
  												if self._cur is None:
  														# finished iterating
  														raise StopIteration
  												__snake_case		       =     self._cur.val
  												__snake_case		       =     self._cur.next_node
  
  												return val
  
  
  
  
  					def __init__( self :					Optional[int]      ,_lowerCAmelCase :					Iterable[Any] | None = None						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     None
  							__snake_case		       =     None
  							__snake_case		       =     0
  
  							if iterable is not None:
  									# append every value to the deque
  									for val in iterable:
  											self.append(_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					int      ,_lowerCAmelCase :					Any						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self._Node(_lowerCAmelCase      ,_lowerCAmelCase      ,_lowerCAmelCase						)
  							if self.is_empty():
  									# front = back
  									__snake_case		       =     __snake_case		       =     node
  									__snake_case		       =     1
  							else:
  									# connect nodes
  									__snake_case		       =     node
  									__snake_case		       =     self._back
  									__snake_case		       =     node  # assign new back to the new node
  
  									self._len += 1
  
  									# make sure there were no errors
  									assert not self.is_empty(), "Error on appending value."
  
  
  
  
  					def 							UpperCamelCase_						( self :					Any      ,_lowerCAmelCase :					Any						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self._Node(_lowerCAmelCase      ,_lowerCAmelCase      ,_lowerCAmelCase						)
  							if self.is_empty():
  									# front = back
  									__snake_case		       =     __snake_case		       =     node
  									__snake_case		       =     1
  							else:
  									# connect nodes
  									__snake_case		       =     self._front
  									__snake_case		       =     node
  									__snake_case		       =     node  # assign new front to the new node
  
  									self._len += 1
  
  									# make sure there were no errors
  									assert not self.is_empty(), "Error on appending value."
  
  
  
  
  					def 							UpperCamelCase_						( self :					int      ,_lowerCAmelCase :					Iterable[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							for val in iterable:
  									self.append(_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[int]      ,_lowerCAmelCase :					Iterable[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							for val in iterable:
  									self.appendleft(_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							assert not self.is_empty(), "Deque is empty."
  
  							__snake_case		       =     self._back
  							__snake_case		       =     self._back.prev_node  # set new back
  							# drop the last node - python will deallocate memory automatically
  							__snake_case		       =     None
  
  							self._len -= 1
  
  							return topop.val
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[str]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							assert not self.is_empty(), "Deque is empty."
  
  							__snake_case		       =     self._front
  							__snake_case		       =     self._front.next_node  # set new front and drop the first node
  							__snake_case		       =     None
  
  							self._len -= 1
  
  							return topop.val
  
  
  
  
  					def 							UpperCamelCase_						( self :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							return self._front is None
  
  
  
  
  					def __len__( self :					Tuple						):
  
  
  							"""simple docstring"""
  
  
  
  
  							return self._len
  
  
  
  
  					def __eq__( self :					Union[str, Any]      ,_lowerCAmelCase :					object						):
  
  
  							"""simple docstring"""
  
  
  
  
  							if not isinstance(_lowerCAmelCase      ,_lowerCAmelCase						):
  									return NotImplemented
  
  							__snake_case		       =     self._front
  							__snake_case		       =     other._front
  
  							# if the length of the dequeues are not the same, they are not equal
  							if len(self						) != len(_lowerCAmelCase						):
  									return False
  
  							while me is not None and oth is not None:
  									# compare every value
  									if me.val != oth.val:
  											return False
  									__snake_case		       =     me.next_node
  									__snake_case		       =     oth.next_node
  
  							return True
  
  
  
  
  					def __iter__( self :					Tuple						):
  
  
  							"""simple docstring"""
  
  
  
  
  							return Deque._Iterator(self._front						)
  
  
  
  
  
  
  
  					def __repr__( self :					List[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     []
  							__snake_case		       =     self._front
  							while aux is not None:
  									# append the values in a list to display
  									values_list.append(aux.val						)
  									__snake_case		       =     aux.next_node
  
  							return F"""[{", ".join(repr(_lowerCAmelCase						) for val in values_list						)}]"""
  
  
  if __name__ == "__main__":
  		import doctest
  
  		doctest.testmod()
  
  
  
  
  
  