



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


__UpperCAmelCase      :      List[Any]   					=					logging.get_logger(__name__)

__UpperCAmelCase      :      Union[str, 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'),
    ]
)

__UpperCAmelCase      :      Union[str, Any]   					=					_LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)
def      A      (			_A							):




					"""simple docstring"""
					for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
										if class_name in processors:
															snake_case_						:Dict								=						model_type_to_module_name(_A							)

															snake_case_						:Optional[int]								=						importlib.import_module(F'''.{module_name}''',     "transformers.models"							)
															try:
																				return getattr(_A,     _A							)
															except AttributeError:
																				continue

					for processor in PROCESSOR_MAPPING._extra_content.values():
										if getattr(_A,     "__name__",     _A							) == 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_						:Union[str, Any]								=						importlib.import_module("transformers"							)
					if hasattr(_A,     _A							):
										return getattr(_A,     _A							)

					return None

class 	__lowerCAmelCase							:


					'''simple docstring'''


					def __init__(      self   ):




										"""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(a   )
					def 		_a (      cls    ,       a    ,       **a   ):




										"""simple docstring"""





										snake_case_						:Optional[Any]								=						kwargs.pop("config"    ,       a   )
										snake_case_						:int								=						kwargs.pop("trust_remote_code"    ,       a   )
										snake_case_						:List[str]								=						True

										snake_case_						:Dict								=						None
										snake_case_						:Optional[int]								=						None

										# First, let's see if we have a preprocessor config.
										# Filter the kwargs for `get_file_from_repo`.
										snake_case_						:str								=						{
										    key: kwargs[key] for key in inspect.signature(a   ).parameters.keys() if key in kwargs
										}
										# Let's start by checking whether the processor class is saved in an image processor
										snake_case_						:Any								=						get_file_from_repo(
										    a    ,       a    ,       **a   )
										if preprocessor_config_file is not None:
															snake_case_						:Tuple								=						ImageProcessingMixin.get_image_processor_dict(a    ,       **a   )
															snake_case_						:Dict								=						config_dict.get("processor_class"    ,       a   )
															if "AutoProcessor" in config_dict.get("auto_map"    ,       {}   ):
																				snake_case_						:Optional[Any]								=						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_						:List[Any]								=						FeatureExtractionMixin.get_feature_extractor_dict(a    ,       **a   )
															snake_case_						:Union[str, Any]								=						config_dict.get("processor_class"    ,       a   )
															if "AutoProcessor" in config_dict.get("auto_map"    ,       {}   ):
																				snake_case_						:Optional[Any]								=						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_						:Optional[Any]								=						get_file_from_repo(
															    a    ,       a    ,       **a   )
															if tokenizer_config_file is not None:
																				with open(a    ,       encoding="utf-8"   ) as reader:
																									snake_case_						:List[Any]								=						json.load(a   )

																				snake_case_						:Any								=						config_dict.get("processor_class"    ,       a   )
																				if "AutoProcessor" in config_dict.get("auto_map"    ,       {}   ):
																									snake_case_						:List[Any]								=						config_dict["auto_map"]["AutoProcessor"]

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

															# And check if the config contains the processor class.
															snake_case_						:Dict								=						getattr(a    ,       "processor_class"    ,       a   )
															if hasattr(a    ,       "auto_map"   ) and "AutoProcessor" in config.auto_map:
																				snake_case_						:Optional[Any]								=						config.auto_map["AutoProcessor"]

										if processor_class is not None:
															snake_case_						:int								=						processor_class_from_name(a   )

										snake_case_						:str								=						processor_auto_map is not None
										snake_case_						:Union[str, Any]								=						processor_class is not None or type(a   ) in PROCESSOR_MAPPING
										snake_case_						:List[Any]								=						resolve_trust_remote_code(
										    a    ,       a    ,       a    ,       a   )

										if has_remote_code and trust_remote_code:
															snake_case_						:str								=						get_class_from_dynamic_module(
															    a    ,       a    ,       **a   )
															snake_case_						:List[str]								=						kwargs.pop("code_revision"    ,       a   )
															if os.path.isdir(a   ):
																				processor_class.register_for_auto_class()
															return processor_class.from_pretrained(
															    a    ,       trust_remote_code=a    ,       **a   )
										elif processor_class is not None:
															return processor_class.from_pretrained(
															    a    ,       trust_remote_code=a    ,       **a   )
										# Last try: we use the PROCESSOR_MAPPING.
										elif type(a   ) in PROCESSOR_MAPPING:
															return PROCESSOR_MAPPING[type(a   )].from_pretrained(a    ,       **a   )

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

															try:
																				return AutoFeatureExtractor.from_pretrained(
																				    a    ,       trust_remote_code=a    ,       **a   )
															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 (      a    ,       a   ):




										"""simple docstring"""





										PROCESSOR_MAPPING.register(a    ,       a   )






"""simple docstring"""






from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


__UpperCAmelCase      :      Union[str, Any]   					=					logging.get_logger(__name__)

__UpperCAmelCase      :      str   					=					{
    'google/bigbird-pegasus-large-arxiv': (
        'https://huggingface.co/google/bigbird-pegasus-large-arxiv/resolve/main/config.json'
    ),
    'google/bigbird-pegasus-large-pubmed': (
        'https://huggingface.co/google/bigbird-pegasus-large-pubmed/resolve/main/config.json'
    ),
    'google/bigbird-pegasus-large-bigpatent': (
        'https://huggingface.co/google/bigbird-pegasus-large-bigpatent/resolve/main/config.json'
    ),
    # See all BigBirdPegasus models at https://huggingface.co/models?filter=bigbird_pegasus
}

class 	__lowerCAmelCase							(__UpperCamelCase  ):


					'''simple docstring'''


					a__        =     'bigbird_pegasus'
					a__        =     ['past_key_values']
					a__        =     {
					    'num_attention_heads': 'encoder_attention_heads',
					    'hidden_size': 'd_model',
					    'attention_probs_dropout_prob': 'attention_dropout',
					}







					def __init__(      self    ,       a=9_61_03    ,       a=40_96    ,       a=16    ,       a=40_96    ,       a=16    ,       a=16    ,       a=40_96    ,       a=16    ,       a=0.0    ,       a=0.0    ,       a=True    ,       a=True    ,       a="gelu_new"    ,       a=10_24    ,       a=0.1    ,       a=0.0    ,       a=0.0    ,       a=0.02    ,       a=2    ,       a=0.0    ,       a=True    ,       a=0    ,       a=2    ,       a=1    ,       a="block_sparse"    ,       a=64    ,       a=3    ,       a=False    ,       **a    ,       ):




										"""simple docstring"""





										snake_case_						:Optional[int]								=						vocab_size
										snake_case_						:Any								=						max_position_embeddings
										snake_case_						:List[Any]								=						d_model
										snake_case_						:Any								=						encoder_ffn_dim
										snake_case_						:str								=						encoder_layers
										snake_case_						:Union[str, Any]								=						encoder_attention_heads
										snake_case_						:Any								=						decoder_ffn_dim
										snake_case_						:Dict								=						decoder_layers
										snake_case_						:List[Any]								=						decoder_attention_heads
										snake_case_						:Any								=						dropout
										snake_case_						:Union[str, Any]								=						attention_dropout
										snake_case_						:Optional[int]								=						activation_dropout
										snake_case_						:int								=						activation_function
										snake_case_						:int								=						init_std
										snake_case_						:Union[str, Any]								=						encoder_layerdrop
										snake_case_						:Dict								=						decoder_layerdrop
										snake_case_						:Any								=						classifier_dropout
										snake_case_						:Any								=						use_cache
										snake_case_						:Any								=						encoder_layers
										snake_case_						:int								=						scale_embedding  # scale factor will be sqrt(d_model) if True

										# extra config
										snake_case_						:Optional[int]								=						attention_type
										snake_case_						:int								=						block_size
										snake_case_						:Optional[int]								=						num_random_blocks
										snake_case_						:List[str]								=						use_bias

										super().__init__(
										    pad_token_id=a    ,       bos_token_id=a    ,       eos_token_id=a    ,       is_encoder_decoder=a    ,       decoder_start_token_id=a    ,       **a    ,       )



class 	__lowerCAmelCase							(__UpperCamelCase  ):


					'''simple docstring'''


					@property
					def 		_a (      self   ):




										"""simple docstring"""





										if self.task in ["default", "seq2seq-lm"]:
															snake_case_						:int								=						OrderedDict(
															    [
															        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
															        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
															    ]   )

															if self.use_past:
																				snake_case_						:int								=						{0: "batch"}
																				snake_case_						:List[str]								=						{0: "batch", 1: "past_decoder_sequence + sequence"}
															else:
																				snake_case_						:Optional[int]								=						{0: "batch", 1: "decoder_sequence"}
																				snake_case_						:Optional[Any]								=						{0: "batch", 1: "decoder_sequence"}

															if self.use_past:
																				self.fill_with_past_key_values_(a    ,       direction="inputs"   )
										elif self.task == "causal-lm":
															# TODO: figure this case out.
															snake_case_						:List[str]								=						OrderedDict(
															    [
															        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
															        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
															    ]   )
															if self.use_past:
																				snake_case_	,  snake_case_						:Tuple								=						self.num_layers
																				for i in range(a   ):
																									snake_case_						:int								=						{0: "batch", 2: "past_sequence + sequence"}
																									snake_case_						:List[Any]								=						{0: "batch", 2: "past_sequence + sequence"}
										else:
															snake_case_						:List[Any]								=						OrderedDict(
															    [
															        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
															        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
															        ("decoder_input_ids", {0: "batch", 1: "decoder_sequence"}),
															        ("decoder_attention_mask", {0: "batch", 1: "decoder_sequence"}),
															    ]   )

										return common_inputs







					@property
					def 		_a (      self   ):




										"""simple docstring"""





										if self.task in ["default", "seq2seq-lm"]:
															snake_case_						:Optional[int]								=						super().outputs
										else:
															snake_case_						:List[str]								=						super(a    ,       self   ).outputs
															if self.use_past:
																				snake_case_	,  snake_case_						:int								=						self.num_layers
																				for i in range(a   ):
																									snake_case_						:Optional[Any]								=						{0: "batch", 2: "past_sequence + sequence"}
																									snake_case_						:Tuple								=						{0: "batch", 2: "past_sequence + sequence"}
										return common_outputs







					def 		_a (      self    ,       a    ,       a = -1    ,       a = -1    ,       a = False    ,       a = None    ,       ):




										"""simple docstring"""





										snake_case_						:int								=						self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
										    a    ,       a    ,       a    ,       a    ,       a   )

										# Generate decoder inputs
										snake_case_						:List[str]								=						seq_length if not self.use_past else 1
										snake_case_						:str								=						self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
										    a    ,       a    ,       a    ,       a    ,       a   )
										snake_case_						:Union[str, Any]								=						{F'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
										snake_case_						:Tuple								=						dict(**a    ,       **a   )

										if self.use_past:
															if not is_torch_available():
																				raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."   )
															else:
																				import torch
															snake_case_	,  snake_case_						:Optional[int]								=						common_inputs["input_ids"].shape
															snake_case_						:Optional[int]								=						common_inputs["decoder_input_ids"].shape[1]
															snake_case_	,  snake_case_						:Optional[int]								=						self.num_attention_heads
															snake_case_						:str								=						(
															    batch,
															    num_encoder_attention_heads,
															    encoder_seq_length,
															    self._config.hidden_size // num_encoder_attention_heads,
															)
															snake_case_						:Any								=						decoder_seq_length + 3
															snake_case_						:int								=						(
															    batch,
															    num_decoder_attention_heads,
															    decoder_past_length,
															    self._config.hidden_size // num_decoder_attention_heads,
															)

															snake_case_						:Union[str, Any]								=						torch.cat(
															    [common_inputs["decoder_attention_mask"], torch.ones(a    ,       a   )]    ,       dim=1   )

															snake_case_						:Union[str, Any]								=						[]
															# If the number of encoder and decoder layers are present in the model configuration, both are considered
															snake_case_	,  snake_case_						:Tuple								=						self.num_layers
															snake_case_						:int								=						min(a    ,       a   )
															snake_case_						:Optional[Any]								=						max(a    ,       a   ) - min_num_layers
															snake_case_						:List[Any]								=						"encoder" if num_encoder_layers > num_decoder_layers else "decoder"

															for _ in range(a   ):
																				common_inputs["past_key_values"].append(
																				    (
																				        torch.zeros(a   ),
																				        torch.zeros(a   ),
																				        torch.zeros(a   ),
																				        torch.zeros(a   ),
																				    )   )
															# TODO: test this.
															snake_case_						:Any								=						encoder_shape if remaining_side_name == "encoder" else decoder_shape
															for _ in range(a    ,       a   ):
																				common_inputs["past_key_values"].append((torch.zeros(a   ), torch.zeros(a   ))   )
										return common_inputs







					def 		_a (      self    ,       a    ,       a = -1    ,       a = -1    ,       a = False    ,       a = None    ,       ):




										"""simple docstring"""





										snake_case_						:List[str]								=						self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
										    a    ,       a    ,       a    ,       a    ,       a   )

										if self.use_past:
															if not is_torch_available():
																				raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."   )
															else:
																				import torch
															snake_case_	,  snake_case_						:Union[str, Any]								=						common_inputs["input_ids"].shape
															# Not using the same length for past_key_values
															snake_case_						:str								=						seqlen + 2
															snake_case_	,  snake_case_						:Union[str, Any]								=						self.num_layers
															snake_case_	,  snake_case_						:Any								=						self.num_attention_heads
															snake_case_						:List[str]								=						(
															    batch,
															    num_encoder_attention_heads,
															    past_key_values_length,
															    self._config.hidden_size // num_encoder_attention_heads,
															)

															snake_case_						:Optional[Any]								=						common_inputs["attention_mask"].dtype
															snake_case_						:Tuple								=						torch.cat(
															    [common_inputs["attention_mask"], torch.ones(a    ,       a    ,       dtype=a   )]    ,       dim=1   )
															snake_case_						:Optional[int]								=						[
															    (torch.zeros(a   ), torch.zeros(a   )) for _ in range(a   )
															]
										return common_inputs







					def 		_a (      self    ,       a    ,       a = -1    ,       a = -1    ,       a = False    ,       a = None    ,       ):




										"""simple docstring"""





										snake_case_						:Optional[int]								=						compute_effective_axis_dimension(
										    a    ,       fixed_dimension=OnnxConfig.default_fixed_batch    ,       num_token_to_add=0   )

										# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
										snake_case_						:List[Any]								=						tokenizer.num_special_tokens_to_add(a   )
										snake_case_						:Tuple								=						compute_effective_axis_dimension(
										    a    ,       fixed_dimension=OnnxConfig.default_fixed_sequence    ,       num_token_to_add=a   )

										# Generate dummy inputs according to compute batch and sequence
										snake_case_						:Any								=						[" ".join([tokenizer.unk_token]   ) * seq_length] * batch_size
										snake_case_						:List[str]								=						dict(tokenizer(a    ,       return_tensors=a   )   )
										return common_inputs







					def 		_a (      self    ,       a    ,       a = -1    ,       a = -1    ,       a = False    ,       a = None    ,       ):




										"""simple docstring"""





										if self.task in ["default", "seq2seq-lm"]:
															snake_case_						:Dict								=						self._generate_dummy_inputs_for_default_and_seqaseq_lm(
															    a    ,       batch_size=a    ,       seq_length=a    ,       is_pair=a    ,       framework=a   )

										elif self.task == "causal-lm":
															snake_case_						:Optional[Any]								=						self._generate_dummy_inputs_for_causal_lm(
															    a    ,       batch_size=a    ,       seq_length=a    ,       is_pair=a    ,       framework=a   )
										else:
															snake_case_						:List[Any]								=						self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
															    a    ,       batch_size=a    ,       seq_length=a    ,       is_pair=a    ,       framework=a   )

										return common_inputs







					def 		_a (      self    ,       a    ,       a    ,       a    ,       a   ):




										"""simple docstring"""





										if self.task in ["default", "seq2seq-lm"]:
															snake_case_						:str								=						super()._flatten_past_key_values_(a    ,       a    ,       a    ,       a   )
										else:
															snake_case_						:Any								=						super(a    ,       self   )._flatten_past_key_values_(
															    a    ,       a    ,       a    ,       a   )

