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: 
  
  
  
  
  
  from typing import Dict, List, Optional, Union
  
  import numpy as np
  
  from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
  from ...image_transforms import (
      get_resize_output_image_size,
      normalize,
      pad,
      rescale,
      resize,
      to_channel_dimension_format,
  )
  from ...image_utils import (
      IMAGENET_STANDARD_MEAN,
      IMAGENET_STANDARD_STD,
      ChannelDimension,
      ImageInput,
      PILImageResampling,
      get_image_size,
      make_list_of_images,
      to_numpy_array,
      valid_images,
  )
  from ...utils import TensorType, logging
  from ...utils.import_utils import is_vision_available
  
  
  __lowerCAmelCase     =			logging.get_logger(__name__)
  
  
  if is_vision_available():
  				import PIL
  
  
  
  
  class   _UpperCAmelCase	(   _lowercase					):
  					__A          =   ["pixel_values"]
  
  
  
  
  					def __init__(						self    ,      __lowerCAmelCase = True    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = PILImageResampling.BILINEAR    ,      __lowerCAmelCase = True    ,      __lowerCAmelCase = False    ,      __lowerCAmelCase = True    ,      __lowerCAmelCase = True    ,      __lowerCAmelCase = 1 / 255    ,      __lowerCAmelCase = True    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      **__lowerCAmelCase    ,      )						->  None:
  							super().__init__(**__lowerCAmelCase       )
  
  							UpperCamelCase__         =	size if size is not None else {"""height""": 2_560, """width""": 1_920}
  							if isinstance(__lowerCAmelCase    ,      (tuple, list)       ):
  									# The previous feature extractor size parameter was in (width, height) format
  									UpperCamelCase__         =	size[::-1]
  							UpperCamelCase__         =	get_size_dict(__lowerCAmelCase       )
  
  							UpperCamelCase__         =	do_resize
  							UpperCamelCase__         =	size
  							UpperCamelCase__         =	resample
  							UpperCamelCase__         =	do_thumbnail
  							UpperCamelCase__         =	do_align_long_axis
  							UpperCamelCase__         =	do_pad
  							UpperCamelCase__         =	do_rescale
  							UpperCamelCase__         =	rescale_factor
  							UpperCamelCase__         =	do_normalize
  							UpperCamelCase__         =	image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
  							UpperCamelCase__         =	image_std if image_std is not None else IMAGENET_STANDARD_STD
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase = None       )						->  np.ndarray:
  							UpperCamelCase__  ,			UpperCamelCase__         =	get_image_size(__lowerCAmelCase       )
  							UpperCamelCase__  ,			UpperCamelCase__         =	size["""height"""], size["""width"""]
  
  							if (output_width < output_height and input_width > input_height) or (
  							    output_width > output_height and input_width < input_height
  							):
  									UpperCamelCase__         =	np.rotaa(__lowerCAmelCase    ,      3       )
  
  							if data_format is not None:
  									UpperCamelCase__         =	to_channel_dimension_format(__lowerCAmelCase    ,      __lowerCAmelCase       )
  
  							return image
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase = False    ,      __lowerCAmelCase = None    ,      )						->  np.ndarray:
  							UpperCamelCase__  ,			UpperCamelCase__         =	size["""height"""], size["""width"""]
  							UpperCamelCase__  ,			UpperCamelCase__         =	get_image_size(__lowerCAmelCase       )
  
  							UpperCamelCase__         =	output_width - input_width
  							UpperCamelCase__         =	output_height - input_height
  
  							if random_padding:
  									UpperCamelCase__         =	np.random.randint(low=0    ,      high=delta_height + 1       )
  									UpperCamelCase__         =	np.random.randint(low=0    ,      high=delta_width + 1       )
  							else:
  									UpperCamelCase__         =	delta_height // 2
  									UpperCamelCase__         =	delta_width // 2
  
  							UpperCamelCase__         =	delta_height - pad_top
  							UpperCamelCase__         =	delta_width - pad_left
  
  							UpperCamelCase__         =	((pad_top, pad_bottom), (pad_left, pad_right))
  							return pad(__lowerCAmelCase    ,      __lowerCAmelCase    ,      data_format=__lowerCAmelCase       )
  
  
  
  
  					def 	snake_case_		(						self    ,      *__lowerCAmelCase    ,      **__lowerCAmelCase       )						->  List[Any]:
  							logger.info("""pad is deprecated and will be removed in version 4.27. Please use pad_image instead."""       )
  							return self.pad_image(*__lowerCAmelCase    ,      **__lowerCAmelCase       )
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase = PILImageResampling.BICUBIC    ,      __lowerCAmelCase = None    ,      **__lowerCAmelCase    ,      )						->  np.ndarray:
  							UpperCamelCase__  ,			UpperCamelCase__         =	get_image_size(__lowerCAmelCase       )
  							UpperCamelCase__  ,			UpperCamelCase__         =	size["""height"""], size["""width"""]
  
  							# We always resize to the smallest of either the input or output size.
  							UpperCamelCase__         =	min(__lowerCAmelCase    ,      __lowerCAmelCase       )
  							UpperCamelCase__         =	min(__lowerCAmelCase    ,      __lowerCAmelCase       )
  
  							if height == input_height and width == input_width:
  									return image
  
  							if input_height > input_width:
  									UpperCamelCase__         =	int(input_width * height / input_height       )
  							elif input_width > input_height:
  									UpperCamelCase__         =	int(input_height * width / input_width       )
  
  							return resize(
  							    __lowerCAmelCase    ,      size=(height, width)    ,      resample=__lowerCAmelCase    ,      reducing_gap=2.0    ,      data_format=__lowerCAmelCase    ,      **__lowerCAmelCase       )
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase = PILImageResampling.BICUBIC    ,      __lowerCAmelCase = None    ,      **__lowerCAmelCase    ,      )						->  np.ndarray:
  							UpperCamelCase__         =	get_size_dict(__lowerCAmelCase       )
  							UpperCamelCase__         =	min(size["""height"""]    ,      size["""width"""]       )
  							UpperCamelCase__         =	get_resize_output_image_size(__lowerCAmelCase    ,      size=__lowerCAmelCase    ,      default_to_square=__lowerCAmelCase       )
  							UpperCamelCase__         =	resize(__lowerCAmelCase    ,      size=__lowerCAmelCase    ,      resample=__lowerCAmelCase    ,      data_format=__lowerCAmelCase    ,      **__lowerCAmelCase       )
  							return resized_image
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase = None    ,      **__lowerCAmelCase    ,      )						->  List[str]:
  							return rescale(__lowerCAmelCase    ,      scale=__lowerCAmelCase    ,      data_format=__lowerCAmelCase    ,      **__lowerCAmelCase       )
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase = None    ,      **__lowerCAmelCase    ,      )						->  np.ndarray:
  							return normalize(__lowerCAmelCase    ,      mean=__lowerCAmelCase    ,      std=__lowerCAmelCase    ,      data_format=__lowerCAmelCase    ,      **__lowerCAmelCase       )
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = False    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = ChannelDimension.FIRST    ,      **__lowerCAmelCase    ,      )						->  PIL.Image.Image:
  							UpperCamelCase__         =	do_resize if do_resize is not None else self.do_resize
  							UpperCamelCase__         =	size if size is not None else self.size
  							if isinstance(__lowerCAmelCase    ,      (tuple, list)       ):
  									# Previous feature extractor had size in (width, height) format
  									UpperCamelCase__         =	size[::-1]
  							UpperCamelCase__         =	get_size_dict(__lowerCAmelCase       )
  							UpperCamelCase__         =	resample if resample is not None else self.resample
  							UpperCamelCase__         =	do_thumbnail if do_thumbnail is not None else self.do_thumbnail
  							UpperCamelCase__         =	do_align_long_axis if do_align_long_axis is not None else self.do_align_long_axis
  							UpperCamelCase__         =	do_pad if do_pad is not None else self.do_pad
  							UpperCamelCase__         =	do_rescale if do_rescale is not None else self.do_rescale
  							UpperCamelCase__         =	rescale_factor if rescale_factor is not None else self.rescale_factor
  							UpperCamelCase__         =	do_normalize if do_normalize is not None else self.do_normalize
  							UpperCamelCase__         =	image_mean if image_mean is not None else self.image_mean
  							UpperCamelCase__         =	image_std if image_std is not None else self.image_std
  
  							UpperCamelCase__         =	make_list_of_images(__lowerCAmelCase       )
  
  							if not valid_images(__lowerCAmelCase       ):
  									raise ValueError(
  									    """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
  									    """torch.Tensor, tf.Tensor or jax.ndarray."""       )
  
  							if do_resize and size is None:
  									raise ValueError("""Size must be specified if do_resize is True."""       )
  
  							if do_rescale and rescale_factor is None:
  									raise ValueError("""Rescale factor must be specified if do_rescale is True."""       )
  
  							if do_pad and size is None:
  									raise ValueError("""Size must be specified if do_pad is True."""       )
  
  							if do_normalize and (image_mean is None or image_std is None):
  									raise ValueError("""Image mean and std must be specified if do_normalize is True."""       )
  
  							# All transformations expect numpy arrays.
  							UpperCamelCase__         =	[to_numpy_array(__lowerCAmelCase       ) for image in images]
  
  							if do_align_long_axis:
  									UpperCamelCase__         =	[self.align_long_axis(__lowerCAmelCase    ,      size=__lowerCAmelCase       ) for image in images]
  
  							if do_resize:
  									UpperCamelCase__         =	[self.resize(image=__lowerCAmelCase    ,      size=__lowerCAmelCase    ,      resample=__lowerCAmelCase       ) for image in images]
  
  							if do_thumbnail:
  									UpperCamelCase__         =	[self.thumbnail(image=__lowerCAmelCase    ,      size=__lowerCAmelCase       ) for image in images]
  
  							if do_pad:
  									UpperCamelCase__         =	[self.pad_image(image=__lowerCAmelCase    ,      size=__lowerCAmelCase    ,      random_padding=__lowerCAmelCase       ) for image in images]
  
  							if do_rescale:
  									UpperCamelCase__         =	[self.rescale(image=__lowerCAmelCase    ,      scale=__lowerCAmelCase       ) for image in images]
  
  							if do_normalize:
  									UpperCamelCase__         =	[self.normalize(image=__lowerCAmelCase    ,      mean=__lowerCAmelCase    ,      std=__lowerCAmelCase       ) for image in images]
  
  							UpperCamelCase__         =	[to_channel_dimension_format(__lowerCAmelCase    ,      __lowerCAmelCase       ) for image in images]
  
  							UpperCamelCase__         =	{"""pixel_values""": images}
  							return BatchFeature(data=__lowerCAmelCase    ,      tensor_type=__lowerCAmelCase       )
  
  
  
  
  
  