





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       )












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       )





