






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   snake_case		(				UpperCAmelCase						:							str ):
				for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
								if class_name in processors:
												A									=   model_type_to_module_name(UpperCAmelCase )

												A									=   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.
				A									=   importlib.import_module('transformers' )
				if hasattr(UpperCAmelCase,    UpperCAmelCase ):
								return getattr(UpperCAmelCase,    UpperCAmelCase )

				return None



class   UpperCamelCase			:







		"""simple docstring"""



		def __init__(	self		:							Optional[Any]		)     -> str:


						'''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(_SCREAMING_SNAKE_CASE		)
		def    A(	cls		:							List[Any]    ,_SCREAMING_SNAKE_CASE		:							List[str]    ,**_SCREAMING_SNAKE_CASE		:							str		)     -> Optional[Any]:


						'''simple docstring'''
						A									=   kwargs.pop('config'    ,_SCREAMING_SNAKE_CASE		)
						A									=   kwargs.pop('trust_remote_code'    ,_SCREAMING_SNAKE_CASE		)
						A									=   True

						A									=   None
						A									=   None

						# First, let's see if we have a preprocessor config.
						# Filter the kwargs for `get_file_from_repo`.
						A									=   {
						    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
						A									=   get_file_from_repo(
						    _SCREAMING_SNAKE_CASE    ,_SCREAMING_SNAKE_CASE    ,**_SCREAMING_SNAKE_CASE		)
						if preprocessor_config_file is not None:
										A			,		A									=   ImageProcessingMixin.get_image_processor_dict(_SCREAMING_SNAKE_CASE    ,**_SCREAMING_SNAKE_CASE		)
										A									=   config_dict.get('processor_class'    ,_SCREAMING_SNAKE_CASE		)
										if "AutoProcessor" in config_dict.get('auto_map'    ,{}		):
														A									=   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:
										A			,		A									=   FeatureExtractionMixin.get_feature_extractor_dict(_SCREAMING_SNAKE_CASE    ,**_SCREAMING_SNAKE_CASE		)
										A									=   config_dict.get('processor_class'    ,_SCREAMING_SNAKE_CASE		)
										if "AutoProcessor" in config_dict.get('auto_map'    ,{}		):
														A									=   config_dict['auto_map']['AutoProcessor']

						if processor_class is None:
										# Next, let's check whether the processor class is saved in a tokenizer
										A									=   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:
																		A									=   json.load(_SCREAMING_SNAKE_CASE		)

														A									=   config_dict.get('processor_class'    ,_SCREAMING_SNAKE_CASE		)
														if "AutoProcessor" in config_dict.get('auto_map'    ,{}		):
																		A									=   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		):
														A									=   AutoConfig.from_pretrained(
														    _SCREAMING_SNAKE_CASE    ,trust_remote_code=_SCREAMING_SNAKE_CASE    ,**_SCREAMING_SNAKE_CASE		)

										# And check if the config contains the processor class.
										A									=   getattr(_SCREAMING_SNAKE_CASE    ,'processor_class'    ,_SCREAMING_SNAKE_CASE		)
										if hasattr(_SCREAMING_SNAKE_CASE    ,'auto_map'		) and "AutoProcessor" in config.auto_map:
														A									=   config.auto_map['AutoProcessor']

						if processor_class is not None:
										A									=   processor_class_from_name(_SCREAMING_SNAKE_CASE		)

						A									=   processor_auto_map is not None
						A									=   processor_class is not None or type(_SCREAMING_SNAKE_CASE		) in PROCESSOR_MAPPING
						A									=   resolve_trust_remote_code(
						    _SCREAMING_SNAKE_CASE    ,_SCREAMING_SNAKE_CASE    ,_SCREAMING_SNAKE_CASE    ,_SCREAMING_SNAKE_CASE		)

						if has_remote_code and trust_remote_code:
										A									=   get_class_from_dynamic_module(
										    _SCREAMING_SNAKE_CASE    ,_SCREAMING_SNAKE_CASE    ,**_SCREAMING_SNAKE_CASE		)
										A									=   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    A(	_SCREAMING_SNAKE_CASE		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							int		)     -> Optional[Any]:


						'''simple docstring'''
						PROCESSOR_MAPPING.register(_SCREAMING_SNAKE_CASE    ,_SCREAMING_SNAKE_CASE		)













import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
					import torch

if is_vision_available():
					from PIL import Image

					from transformers import CLIPImageProcessor
class   UpperCamelCase			(					unittest.TestCase			):







		"""simple docstring"""



		def __init__(	self		:							int    ,_SCREAMING_SNAKE_CASE		:							Any    ,_SCREAMING_SNAKE_CASE		:							Optional[int]=7    ,_SCREAMING_SNAKE_CASE		:							List[Any]=3    ,_SCREAMING_SNAKE_CASE		:							int=1_8    ,_SCREAMING_SNAKE_CASE		:							Tuple=3_0    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]=4_0_0    ,_SCREAMING_SNAKE_CASE		:							Dict=True    ,_SCREAMING_SNAKE_CASE		:							int=None    ,_SCREAMING_SNAKE_CASE		:							Tuple=True    ,_SCREAMING_SNAKE_CASE		:							Any=None    ,_SCREAMING_SNAKE_CASE		:							Dict=True    ,_SCREAMING_SNAKE_CASE		:							List[str]=[0.48145466, 0.4578275, 0.40821073]    ,_SCREAMING_SNAKE_CASE		:							int=[0.26862954, 0.26130258, 0.27577711]    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]=True    ,)     -> List[str]:


						'''simple docstring'''
						A									=   size if size is not None else {'shortest_edge': 2_0}
						A									=   crop_size if crop_size is not None else {'height': 1_8, 'width': 1_8}
						A									=   parent
						A									=   batch_size
						A									=   num_channels
						A									=   image_size
						A									=   min_resolution
						A									=   max_resolution
						A									=   do_resize
						A									=   size
						A									=   do_center_crop
						A									=   crop_size
						A									=   do_normalize
						A									=   image_mean
						A									=   image_std
						A									=   do_convert_rgb
		def    A(	self		:							List[str]		)     -> Optional[int]:


						'''simple docstring'''
						return {
						    "do_resize": self.do_resize,
						    "size": self.size,
						    "do_center_crop": self.do_center_crop,
						    "crop_size": self.crop_size,
						    "do_normalize": self.do_normalize,
						    "image_mean": self.image_mean,
						    "image_std": self.image_std,
						    "do_convert_rgb": self.do_convert_rgb,
						}







		def    A(	self		:							Optional[int]    ,_SCREAMING_SNAKE_CASE		:							str=False    ,_SCREAMING_SNAKE_CASE		:							List[str]=False    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]=False		)     -> str:


						'''simple docstring'''
						assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

						if equal_resolution:
										A									=   []
										for i in range(self.batch_size		):
														image_inputs.append(
														    np.random.randint(
														        2_5_5    ,size=(self.num_channels, self.max_resolution, self.max_resolution)    ,dtype=np.uinta		)		)
						else:
										A									=   []
										for i in range(self.batch_size		):
														A			,		A									=   np.random.choice(np.arange(self.min_resolution    ,self.max_resolution		)    ,2		)
														image_inputs.append(np.random.randint(2_5_5    ,size=(self.num_channels, width, height)    ,dtype=np.uinta		)		)

						if not numpify and not torchify:
										# PIL expects the channel dimension as last dimension
										A									=   [Image.fromarray(np.moveaxis(_SCREAMING_SNAKE_CASE    ,0    ,-1		)		) for x in image_inputs]

						if torchify:
										A									=   [torch.from_numpy(_SCREAMING_SNAKE_CASE		) for x in image_inputs]

						return image_inputs


@require_torch
@require_vision
class   UpperCamelCase			(					snake_case__      ,							unittest.TestCase			):







		"""simple docstring"""



		snake_case			 = CLIPImageProcessor if is_vision_available() else None
		def    A(	self		:							Optional[Any]		)     -> Union[str, Any]:


						'''simple docstring'''
						A									=   CLIPImageProcessingTester(self		)
		@property
		def    A(	self		:							Optional[int]		)     -> Any:


						'''simple docstring'''
						return self.image_processor_tester.prepare_image_processor_dict()
		def    A(	self		:							Optional[int]		)     -> Tuple:


						'''simple docstring'''
						A									=   self.image_processing_class(**self.image_processor_dict		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'do_resize'		)		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'size'		)		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'do_center_crop'		)		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'center_crop'		)		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'do_normalize'		)		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'image_mean'		)		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'image_std'		)		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'do_convert_rgb'		)		)
		def    A(	self		:							Optional[Any]		)     -> int:


						'''simple docstring'''
						A									=   self.image_processing_class.from_dict(self.image_processor_dict		)
						self.assertEqual(image_processor.size    ,{'shortest_edge': 2_0}		)
						self.assertEqual(image_processor.crop_size    ,{'height': 1_8, 'width': 1_8}		)

						A									=   self.image_processing_class.from_dict(self.image_processor_dict    ,size=4_2    ,crop_size=8_4		)
						self.assertEqual(image_processor.size    ,{'shortest_edge': 4_2}		)
						self.assertEqual(image_processor.crop_size    ,{'height': 8_4, 'width': 8_4}		)
		def    A(	self		:							Any		)     -> Union[str, Any]:


						'''simple docstring'''
						pass
		def    A(	self		:							Tuple		)     -> Optional[int]:


						'''simple docstring'''
						# Initialize image_processing
						A									=   self.image_processing_class(**self.image_processor_dict		)
						# create random PIL images
						A									=   self.image_processor_tester.prepare_inputs(equal_resolution=_SCREAMING_SNAKE_CASE		)
						for image in image_inputs:
										self.assertIsInstance(_SCREAMING_SNAKE_CASE    ,Image.Image		)

						# Test not batched input
						A									=   image_processing(image_inputs[0]    ,return_tensors='pt'		).pixel_values
						self.assertEqual(
						    encoded_images.shape    ,(
						        1,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    )    ,)

						# Test batched
						A									=   image_processing(_SCREAMING_SNAKE_CASE    ,return_tensors='pt'		).pixel_values
						self.assertEqual(
						    encoded_images.shape    ,(
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    )    ,)
		def    A(	self		:							int		)     -> Tuple:


						'''simple docstring'''
						# Initialize image_processing
						A									=   self.image_processing_class(**self.image_processor_dict		)
						# create random numpy tensors
						A									=   self.image_processor_tester.prepare_inputs(equal_resolution=_SCREAMING_SNAKE_CASE    ,numpify=_SCREAMING_SNAKE_CASE		)
						for image in image_inputs:
										self.assertIsInstance(_SCREAMING_SNAKE_CASE    ,np.ndarray		)

						# Test not batched input
						A									=   image_processing(image_inputs[0]    ,return_tensors='pt'		).pixel_values
						self.assertEqual(
						    encoded_images.shape    ,(
						        1,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    )    ,)

						# Test batched
						A									=   image_processing(_SCREAMING_SNAKE_CASE    ,return_tensors='pt'		).pixel_values
						self.assertEqual(
						    encoded_images.shape    ,(
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    )    ,)







		def    A(	self		:							str		)     -> str:


						'''simple docstring'''
						# Initialize image_processing
						A									=   self.image_processing_class(**self.image_processor_dict		)
						# create random PyTorch tensors
						A									=   self.image_processor_tester.prepare_inputs(equal_resolution=_SCREAMING_SNAKE_CASE    ,torchify=_SCREAMING_SNAKE_CASE		)
						for image in image_inputs:
										self.assertIsInstance(_SCREAMING_SNAKE_CASE    ,torch.Tensor		)

						# Test not batched input
						A									=   image_processing(image_inputs[0]    ,return_tensors='pt'		).pixel_values
						self.assertEqual(
						    encoded_images.shape    ,(
						        1,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    )    ,)

						# Test batched
						A									=   image_processing(_SCREAMING_SNAKE_CASE    ,return_tensors='pt'		).pixel_values
						self.assertEqual(
						    encoded_images.shape    ,(
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    )    ,)


@require_torch
@require_vision
class   UpperCamelCase			(					snake_case__      ,							unittest.TestCase			):







		"""simple docstring"""



		snake_case			 = CLIPImageProcessor if is_vision_available() else None
		def    A(	self		:							Tuple		)     -> Union[str, Any]:


						'''simple docstring'''
						A									=   CLIPImageProcessingTester(self    ,num_channels=4		)
						A									=   3
		@property
		def    A(	self		:							str		)     -> Dict:


						'''simple docstring'''
						return self.image_processor_tester.prepare_image_processor_dict()
		def    A(	self		:							Any		)     -> int:


						'''simple docstring'''
						A									=   self.image_processing_class(**self.image_processor_dict		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'do_resize'		)		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'size'		)		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'do_center_crop'		)		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'center_crop'		)		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'do_normalize'		)		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'image_mean'		)		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'image_std'		)		)
						self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE    ,'do_convert_rgb'		)		)
		def    A(	self		:							Any		)     -> str:


						'''simple docstring'''
						pass







		def    A(	self		:							Union[str, Any]		)     -> Dict:


						'''simple docstring'''
						# Initialize image_processing
						A									=   self.image_processing_class(**self.image_processor_dict		)
						# create random PIL images
						A									=   self.image_processor_tester.prepare_inputs(equal_resolution=_SCREAMING_SNAKE_CASE		)
						for image in image_inputs:
										self.assertIsInstance(_SCREAMING_SNAKE_CASE    ,Image.Image		)

						# Test not batched input
						A									=   image_processing(image_inputs[0]    ,return_tensors='pt'		).pixel_values
						self.assertEqual(
						    encoded_images.shape    ,(
						        1,
						        self.expected_encoded_image_num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    )    ,)

						# Test batched
						A									=   image_processing(_SCREAMING_SNAKE_CASE    ,return_tensors='pt'		).pixel_values
						self.assertEqual(
						    encoded_images.shape    ,(
						        self.image_processor_tester.batch_size,
						        self.expected_encoded_image_num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    )    ,)





