



'''simple docstring'''






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 				_SCREAMING_SNAKE_CASE(					snake_case_    :     str  )		->Any:






							'''simple docstring'''
							for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
														if class_name in processors:
																					_lowercase							:		str				=   model_type_to_module_name(snake_case_  )

																					_lowercase							:		Union[str, Any]				=   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.
							_lowercase							:		Optional[Any]				=   importlib.import_module('''transformers'''  )
							if hasattr(snake_case_ ,       snake_case_  ):
														return getattr(snake_case_ ,       snake_case_  )

							return None




class 	_lowerCAmelCase     :






		'''simple docstring'''
		def __init__(						self							:       Any		)      ->			List[Any]:







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







									'''simple docstring'''





									_lowercase							:		Optional[int]				=   kwargs.pop('''config'''      ,		UpperCamelCase_		)
									_lowercase							:		List[str]				=   kwargs.pop('''trust_remote_code'''      ,		UpperCamelCase_		)
									_lowercase							:		Optional[Any]				=   True

									_lowercase							:		Tuple				=   None
									_lowercase							:		Dict				=   None

									# First, let's see if we have a preprocessor config.
									# Filter the kwargs for `get_file_from_repo`.
									_lowercase							:		List[str]				=   {
									    key: kwargs[key] for key in inspect.signature(UpperCamelCase_		).parameters.keys() if key in kwargs
									}
									# Let's start by checking whether the processor class is saved in an image processor
									_lowercase							:		str				=   get_file_from_repo(
									    UpperCamelCase_      ,		UpperCamelCase_      ,		**UpperCamelCase_		)
									if preprocessor_config_file is not None:
																_lowercase			, _lowercase							:		Optional[Any]				=   ImageProcessingMixin.get_image_processor_dict(UpperCamelCase_      ,		**UpperCamelCase_		)
																_lowercase							:		Optional[int]				=   config_dict.get('''processor_class'''      ,		UpperCamelCase_		)
																if "AutoProcessor" in config_dict.get('''auto_map'''      ,		{}		):
																							_lowercase							:		Optional[int]				=   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(UpperCamelCase_      ,		**UpperCamelCase_		)
																_lowercase							:		Dict				=   config_dict.get('''processor_class'''      ,		UpperCamelCase_		)
																if "AutoProcessor" in config_dict.get('''auto_map'''      ,		{}		):
																							_lowercase							:		Dict				=   config_dict['''auto_map''']['''AutoProcessor''']

									if processor_class is None:
																# Next, let's check whether the processor class is saved in a tokenizer
																_lowercase							:		Any				=   get_file_from_repo(
																    UpperCamelCase_      ,		UpperCamelCase_      ,		**UpperCamelCase_		)
																if tokenizer_config_file is not None:
																							with open(UpperCamelCase_      ,		encoding='''utf-8'''		) as reader:
																														_lowercase							:		Union[str, Any]				=   json.load(UpperCamelCase_		)

																							_lowercase							:		str				=   config_dict.get('''processor_class'''      ,		UpperCamelCase_		)
																							if "AutoProcessor" in config_dict.get('''auto_map'''      ,		{}		):
																														_lowercase							:		Tuple				=   config_dict['''auto_map''']['''AutoProcessor''']

									if processor_class is None:
																# Otherwise, load config, if it can be loaded.
																if not isinstance(UpperCamelCase_      ,		UpperCamelCase_		):
																							_lowercase							:		Tuple				=   AutoConfig.from_pretrained(
																							    UpperCamelCase_      ,		trust_remote_code=UpperCamelCase_      ,		**UpperCamelCase_		)

																# And check if the config contains the processor class.
																_lowercase							:		int				=   getattr(UpperCamelCase_      ,		'''processor_class'''      ,		UpperCamelCase_		)
																if hasattr(UpperCamelCase_      ,		'''auto_map'''		) and "AutoProcessor" in config.auto_map:
																							_lowercase							:		Union[str, Any]				=   config.auto_map['''AutoProcessor''']

									if processor_class is not None:
																_lowercase							:		Tuple				=   processor_class_from_name(UpperCamelCase_		)

									_lowercase							:		int				=   processor_auto_map is not None
									_lowercase							:		Tuple				=   processor_class is not None or type(UpperCamelCase_		) in PROCESSOR_MAPPING
									_lowercase							:		Tuple				=   resolve_trust_remote_code(
									    UpperCamelCase_      ,		UpperCamelCase_      ,		UpperCamelCase_      ,		UpperCamelCase_		)

									if has_remote_code and trust_remote_code:
																_lowercase							:		Optional[Any]				=   get_class_from_dynamic_module(
																    UpperCamelCase_      ,		UpperCamelCase_      ,		**UpperCamelCase_		)
																_lowercase							:		Any				=   kwargs.pop('''code_revision'''      ,		UpperCamelCase_		)
																if os.path.isdir(UpperCamelCase_		):
																							processor_class.register_for_auto_class()
																return processor_class.from_pretrained(
																    UpperCamelCase_      ,		trust_remote_code=UpperCamelCase_      ,		**UpperCamelCase_		)
									elif processor_class is not None:
																return processor_class.from_pretrained(
																    UpperCamelCase_      ,		trust_remote_code=UpperCamelCase_      ,		**UpperCamelCase_		)
									# Last try: we use the PROCESSOR_MAPPING.
									elif type(UpperCamelCase_		) in PROCESSOR_MAPPING:
																return PROCESSOR_MAPPING[type(UpperCamelCase_		)].from_pretrained(UpperCamelCase_      ,		**UpperCamelCase_		)

									# 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(
																    UpperCamelCase_      ,		trust_remote_code=UpperCamelCase_      ,		**UpperCamelCase_		)
									except Exception:
																try:
																							return AutoImageProcessor.from_pretrained(
																							    UpperCamelCase_      ,		trust_remote_code=UpperCamelCase_      ,		**UpperCamelCase_		)
																except Exception:
																							pass

																try:
																							return AutoFeatureExtractor.from_pretrained(
																							    UpperCamelCase_      ,		trust_remote_code=UpperCamelCase_      ,		**UpperCamelCase_		)
																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 						__lowercase      (						UpperCamelCase_							:       List[str]      ,		UpperCamelCase_							:       Any		)      ->			Optional[int]:







									'''simple docstring'''





									PROCESSOR_MAPPING.register(UpperCamelCase_      ,		UpperCamelCase_		)








'''simple docstring'''






import warnings

from .generation import FlaxGenerationMixin

class 	_lowerCAmelCase     (    __A       ):






		'''simple docstring'''
		# warning at import time
		warnings.warn(
		    'Importing `FlaxGenerationMixin` from `src/transformers/generation_flax_utils.py` is deprecated and will '
		    'be removed in Transformers v5. Import as `from transformers import FlaxGenerationMixin` instead.'     ,		__A     ,		)



