



'''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


_lowercase       :						str						=logging.get_logger(__name__)

_lowercase       :						List[Any]						=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"),
    ]
)

_lowercase       :						List[Any]						=_LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)


def 							__UpperCAmelCase				(				UpperCamelCase__				:str			)		->						Any:
				for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
								if class_name in processors:
												snake_case__      :   str      =    model_type_to_module_name(snake_case_			)

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

				return None






class 			_SCREAMING_SNAKE_CASE				:



			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 				lowerCAmelCase (     cls		:						Any    ,			__UpperCamelCase		:						List[Any]    ,			**__UpperCamelCase		:						Optional[int]			)      ->      List[str]:
							"""simple docstring"""





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

							snake_case__      :   Tuple      =    None
							snake_case__      :   Dict      =    None

							# First, let's see if we have a preprocessor config.
							# Filter the kwargs for `get_file_from_repo`.
							snake_case__      :   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
							snake_case__      :   str      =    get_file_from_repo(
							    UpperCamelCase_    ,			UpperCamelCase_    ,			**UpperCamelCase_			)
							if preprocessor_config_file is not None:
											snake_case__      :   Optional[Any]      =    ImageProcessingMixin.get_image_processor_dict(UpperCamelCase_    ,			**UpperCamelCase_			)
											snake_case__      :   Optional[int]      =    config_dict.get('''processor_class'''    ,			UpperCamelCase_			)
											if "AutoProcessor" in config_dict.get('''auto_map'''    ,			{}			):
															snake_case__      :   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:
											snake_case__      :   Dict      =    FeatureExtractionMixin.get_feature_extractor_dict(UpperCamelCase_    ,			**UpperCamelCase_			)
											snake_case__      :   Dict      =    config_dict.get('''processor_class'''    ,			UpperCamelCase_			)
											if "AutoProcessor" in config_dict.get('''auto_map'''    ,			{}			):
															snake_case__      :   Dict      =    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__      :   Any      =    get_file_from_repo(
											    UpperCamelCase_    ,			UpperCamelCase_    ,			**UpperCamelCase_			)
											if tokenizer_config_file is not None:
															with open(UpperCamelCase_    ,			encoding='''utf-8'''			) as reader:
																			snake_case__      :   Union[str, Any]      =    json.load(UpperCamelCase_			)

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

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

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

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

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

							if has_remote_code and trust_remote_code:
											snake_case__      :   Optional[Any]      =    get_class_from_dynamic_module(
											    UpperCamelCase_    ,			UpperCamelCase_    ,			**UpperCamelCase_			)
											snake_case__      :   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 				lowerCAmelCase (     __UpperCamelCase		:						List[str]    ,			__UpperCamelCase		:						Any			)      ->      Optional[int]:
							"""simple docstring"""





							PROCESSOR_MAPPING.register(UpperCamelCase_    ,			UpperCamelCase_			)









'''simple docstring'''






import collections

from .utils import ExplicitEnum, is_torch_available, logging


if is_torch_available():
						import torch


lowerCamelCase__	  =		logging.get_logger(__name__)

class 	_lowerCAmelCase     :






		'''simple docstring'''
		def __init__(						self							:       Optional[int]      ,		UpperCamelCase_							:       Optional[Any]      ,		UpperCamelCase_							:       Union[str, Any]=21      ,		UpperCamelCase_							:       Dict=[]      ,		UpperCamelCase_							:       Any=None		)      ->			Any:







									'''simple docstring'''





									_lowercase							:		Optional[Any]				=   model
									_lowercase							:		Tuple				=   trace_batch_nums
									_lowercase							:		Optional[Any]				=   abort_after_batch_num

									# keep a LIFO buffer of frames to dump as soon as inf/nan is encountered to give context to the problem emergence
									_lowercase							:		int				=   collections.deque([]      ,		UpperCamelCase_		)
									_lowercase							:		List[Any]				=   []
									_lowercase							:		List[str]				=   0
									_lowercase							:		Optional[int]				=   0
									_lowercase							:		List[Any]				=   False
									_lowercase							:		List[Any]				=   '''                 '''

									self.analyse_model()

									self.register_forward_hook()
		def 						__lowercase      (						self							:       Union[str, Any]      ,		UpperCamelCase_							:       Optional[Any]=None		)      ->			Optional[Any]:







									'''simple docstring'''





									if frame is not None:
																self.expand_frame(UpperCamelCase_		)
									self.frames.append('''\n'''.join(self.frame		)		)
									_lowercase							:		Dict				=   []  # start a new frame
		def 						__lowercase      (						self							:       Union[str, Any]      ,		UpperCamelCase_							:       Optional[Any]		)      ->			Union[str, Any]:







									'''simple docstring'''





									self.frame.append(UpperCamelCase_		)
		def 						__lowercase      (						self							:       str		)      ->			List[str]:







									'''simple docstring'''





									print('''\n'''.join(self.frames		)		)
									_lowercase							:		Union[str, Any]				=   []
		def 						__lowercase      (						self							:       Optional[int]		)      ->			List[str]:







									'''simple docstring'''





									_lowercase							:		Optional[Any]				=   []
		def 						__lowercase      (						self							:       List[Any]		)      ->			Optional[int]:







									'''simple docstring'''





									print(F"\nDetected inf/nan during batch_number={self.batch_number}"		)
									print(F"Last {len(self.frames		)} forward frames:"		)
									print(F"{'abs min':8} {'abs max':8} metadata"		)
									print('''\n'''.join(self.frames		)		)
									print('''\n\n'''		)
									_lowercase							:		List[Any]				=   []
		def 						__lowercase      (						self							:       List[str]		)      ->			Tuple:







									'''simple docstring'''





									_lowercase							:		int				=   {m: name for name, m in self.model.named_modules()}
									# self.longest_module_name = max(len(v) for v in self.module_names.values())
		def 						__lowercase      (						self							:       Dict      ,		UpperCamelCase_							:       str      ,		UpperCamelCase_							:       Optional[int]		)      ->			int:







									'''simple docstring'''





									if torch.is_tensor(UpperCamelCase_		):
																self.expand_frame(get_abs_min_max(UpperCamelCase_      ,		UpperCamelCase_		)		)
																if detect_overflow(UpperCamelCase_      ,		UpperCamelCase_		):
																							_lowercase							:		Any				=   True
									elif var is None:
																self.expand_frame(F"{'None':>17} {ctx}"		)
									else:
																self.expand_frame(F"{'not a tensor':>17} {ctx}"		)
		def 						__lowercase      (						self							:       Union[str, Any]		)      ->			int:







									'''simple docstring'''





									self.expand_frame(F"\n\n{self.prefix} *** Starting batch number={self.batch_number} ***"		)
									self.expand_frame(F"{'abs min':8} {'abs max':8} metadata"		)
		def 						__lowercase      (						self							:       str		)      ->			Any:







									'''simple docstring'''





									self.expand_frame(F"{self.prefix} *** Finished batch number={self.batch_number-1} ***\n\n"		)
		def 						__lowercase      (						self							:       Tuple      ,		UpperCamelCase_							:       Any      ,		UpperCamelCase_							:       Union[str, Any]      ,		UpperCamelCase_							:       Optional[int]		)      ->			Dict:







									'''simple docstring'''





									self.expand_frame(F"{self.prefix} {self.module_names[module]} {module.__class__.__name__}"		)

									# params
									for name, p in module.named_parameters(recurse=UpperCamelCase_		):
																self.analyse_variable(UpperCamelCase_      ,		UpperCamelCase_		)

									# inputs
									if isinstance(UpperCamelCase_      ,		UpperCamelCase_		):
																for i, x in enumerate(UpperCamelCase_		):
																							self.analyse_variable(UpperCamelCase_      ,		F"input[{i}]"		)
									else:
																self.analyse_variable(UpperCamelCase_      ,		'''input'''		)

									# outputs
									if isinstance(UpperCamelCase_      ,		UpperCamelCase_		):
																for i, x in enumerate(UpperCamelCase_		):
																							# possibly a tuple of tuples
																							if isinstance(UpperCamelCase_      ,		UpperCamelCase_		):
																														for j, y in enumerate(UpperCamelCase_		):
																																					self.analyse_variable(UpperCamelCase_      ,		F"output[{i}][{j}]"		)
																							else:
																														self.analyse_variable(UpperCamelCase_      ,		F"output[{i}]"		)
									else:
																self.analyse_variable(UpperCamelCase_      ,		'''output'''		)

									self.save_frame()
		def 						__lowercase      (						self							:       Optional[int]		)      ->			Dict:







									'''simple docstring'''





									self.model.apply(self._register_forward_hook		)
		def 						__lowercase      (						self							:       Optional[int]      ,		UpperCamelCase_							:       int		)      ->			List[str]:







									'''simple docstring'''





									module.register_forward_hook(self.forward_hook		)





		def 						__lowercase      (						self							:       Optional[int]      ,		UpperCamelCase_							:       Optional[int]      ,		UpperCamelCase_							:       Dict      ,		UpperCamelCase_							:       List[Any]		)      ->			List[Any]:







									'''simple docstring'''





									_lowercase							:		str				=   False

									_lowercase							:		Dict				=   True if self.batch_number in self.trace_batch_nums else False
									if trace_mode:
																self.reset_saved_frames()

									if self.total_calls == 0:
																self.batch_start_frame()
									self.total_calls += 1

									# count batch numbers - the very first forward hook of the batch will be called when the
									# batch completes - i.e. it gets called very last - we know this batch has finished
									if module == self.model:
																self.batch_number += 1
																_lowercase							:		Union[str, Any]				=   True

									self.create_frame(UpperCamelCase_      ,		UpperCamelCase_      ,		UpperCamelCase_		)

									# if last_frame_of_batch:
									#     self.batch_end_frame()

									if trace_mode:
																self.trace_frames()

									if last_frame_of_batch:
																self.batch_start_frame()

									if self.detected_overflow and not trace_mode:
																self.dump_saved_frames()

																# now we can abort, as it's pointless to continue running
																raise ValueError(
																    '''DebugUnderflowOverflow: inf/nan detected, aborting as there is no point running further. '''
																    '''Please scroll up above this traceback to see the activation values prior to this event.'''		)

									# abort after certain batch if requested to do so
									if self.abort_after_batch_num is not None and self.batch_number > self.abort_after_batch_num:
																raise ValueError(
																    F"DebugUnderflowOverflow: aborting after {self.batch_number} batches due to"
																    F" `abort_after_batch_num={self.abort_after_batch_num}` arg"		)





def 				_SCREAMING_SNAKE_CASE(					snake_case_    :     Any ,       snake_case_    :     Dict  )		->Any:






							'''simple docstring'''
							_lowercase							:		Union[str, Any]				=   var.abs()
							return F"{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}"





def 				_SCREAMING_SNAKE_CASE(					snake_case_    :     int ,       snake_case_    :     Any  )		->int:






							'''simple docstring'''
							_lowercase							:		List[Any]				=   False
							if torch.isnan(snake_case_  ).any().item():
														_lowercase							:		Any				=   True
														print(F"{ctx} has nans"  )
							if torch.isinf(snake_case_  ).any().item():
														_lowercase							:		Optional[Any]				=   True
														print(F"{ctx} has infs"  )

							# if needed to monitor large elements can enable the following
							if 0:  # and detected:
														_lowercase							:		List[Any]				=   var[torch.ge(var.abs() ,       1_00  )]
														if naaa.numel() > 0:
																					print(F"{ctx}:  n100={naaa.numel()}"  )
														_lowercase							:		List[str]				=   var[torch.ge(var.abs() ,       10_00  )]
														if naaaa.numel() > 0:
																					print(F"{ctx}: n1000={naaaa.numel()}"  )
														_lowercase							:		Tuple				=   var[torch.ge(var.abs() ,       1_00_00  )]
														if naaaaa.numel() > 0:
																					print(F"{ctx}: n10000={naaaaa.numel()}"  )

							if 0:
														print(F"min={var.min():9.2e} max={var.max():9.2e}"  )

							if 0:
														print(F"min={var.min():9.2e} max={var.max():9.2e} var={var.var():9.2e} mean={var.mean():9.2e} ({ctx})"  )

							return detected




class 	_lowerCAmelCase     (    __A       ):






		'''simple docstring'''
		snake_case_							= 'underflow_overflow'
		snake_case_							= 'tpu_metrics_debug'



