


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


a_											=			logging.get_logger(__name__)

a_											=			{
    "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 snake_case					(     _UpperCamelCase):
		__UpperCamelCase							=	'bigbird_pegasus'
		__UpperCamelCase							=	['past_key_values']
		__UpperCamelCase							=	{
		    'num_attention_heads': 'encoder_attention_heads',
		    'hidden_size': 'd_model',
		    'attention_probs_dropout_prob': 'attention_dropout',
		}







		def __init__(    self					:				Optional[Any]			,      a__					:				Optional[int]=9_61_03			,      a__					:				Optional[Any]=40_96			,      a__					:				Optional[Any]=16			,      a__					:				List[str]=40_96			,      a__					:				List[str]=16			,      a__					:				Tuple=16			,      a__					:				Tuple=40_96			,      a__					:				int=16			,      a__					:				List[str]=0.0			,      a__					:				Dict=0.0			,      a__					:				Optional[Any]=True			,      a__					:				List[Any]=True			,      a__					:				Optional[int]="gelu_new"			,      a__					:				Any=10_24			,      a__					:				List[str]=0.1			,      a__					:				Union[str, Any]=0.0			,      a__					:				List[str]=0.0			,      a__					:				Tuple=0.0_2			,      a__					:				str=2			,      a__					:				Optional[int]=0.0			,      a__					:				Optional[int]=True			,      a__					:				int=0			,      a__					:				Any=2			,      a__					:				List[Any]=1			,      a__					:				Any="block_sparse"			,      a__					:				List[str]=64			,      a__					:				str=3			,      a__					:				Dict=False			,      **a__					:				List[str]			,      )				->  Optional[Any]:





						'''simple docstring'''







						_A         =	vocab_size
						_A         =	max_position_embeddings
						_A         =	d_model
						_A         =	encoder_ffn_dim
						_A         =	encoder_layers
						_A         =	encoder_attention_heads
						_A         =	decoder_ffn_dim
						_A         =	decoder_layers
						_A         =	decoder_attention_heads
						_A         =	dropout
						_A         =	attention_dropout
						_A         =	activation_dropout
						_A         =	activation_function
						_A         =	init_std
						_A         =	encoder_layerdrop
						_A         =	decoder_layerdrop
						_A         =	classifier_dropout
						_A         =	use_cache
						_A         =	encoder_layers
						_A         =	scale_embedding  # scale factor will be sqrt(d_model) if True

						# extra config
						_A         =	attention_type
						_A         =	block_size
						_A         =	num_random_blocks
						_A         =	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 snake_case					(     _UpperCamelCase):







		@property
		def        a_       (    self					:				List[str]						)				->  Mapping[str, Mapping[int, str]]:





						'''simple docstring'''







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

										if self.use_past:
														_A         =	{0: "batch"}
														_A         =	{0: "batch", 1: "past_decoder_sequence + sequence"}
										else:
														_A         =	{0: "batch", 1: "decoder_sequence"}
														_A         =	{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.
										_A         =	OrderedDict(
										    [
										        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
										        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
										    ]						)
										if self.use_past:
														_A     ,						_A         =	self.num_layers
														for i in range(a__						):
																		_A         =	{0: "batch", 2: "past_sequence + sequence"}
																		_A         =	{0: "batch", 2: "past_sequence + sequence"}
						else:
										_A         =	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					:				Dict						)				->  Mapping[str, Mapping[int, str]]:





						'''simple docstring'''







						if self.task in ["default", "seq2seq-lm"]:
										_A         =	super().outputs
						else:
										_A         =	super(a__			,      self						).outputs
										if self.use_past:
														_A     ,						_A         =	self.num_layers
														for i in range(a__						):
																		_A         =	{0: "batch", 2: "past_sequence + sequence"}
																		_A         =	{0: "batch", 2: "past_sequence + sequence"}
						return common_outputs







		def        a_       (    self					:				str			,      a__					:				PreTrainedTokenizer			,      a__					:				int = -1			,      a__					:				int = -1			,      a__					:				bool = False			,      a__					:				Optional[TensorType] = None			,      )				->  Mapping[str, Any]:





						'''simple docstring'''







						_A         =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
						    a__			,      a__			,      a__			,      a__			,      a__						)

						# Generate decoder inputs
						_A         =	seq_length if not self.use_past else 1
						_A         =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
						    a__			,      a__			,      a__			,      a__			,      a__						)
						_A         =	{F"""decoder_{name}""": tensor for name, tensor in decoder_inputs.items()}
						_A         =	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
										_A     ,						_A         =	common_inputs["input_ids"].shape
										_A         =	common_inputs["decoder_input_ids"].shape[1]
										_A     ,						_A         =	self.num_attention_heads
										_A         =	(
										    batch,
										    num_encoder_attention_heads,
										    encoder_seq_length,
										    self._config.hidden_size // num_encoder_attention_heads,
										)
										_A         =	decoder_seq_length + 3
										_A         =	(
										    batch,
										    num_decoder_attention_heads,
										    decoder_past_length,
										    self._config.hidden_size // num_decoder_attention_heads,
										)

										_A         =	torch.cat(
										    [common_inputs["decoder_attention_mask"], torch.ones(a__			,      a__						)]			,      dim=1						)

										_A         =	[]
										# If the number of encoder and decoder layers are present in the model configuration, both are considered
										_A     ,						_A         =	self.num_layers
										_A         =	min(a__			,      a__						)
										_A         =	max(a__			,      a__						) - min_num_layers
										_A         =	"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.
										_A         =	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					:				str			,      a__					:				PreTrainedTokenizer			,      a__					:				int = -1			,      a__					:				int = -1			,      a__					:				bool = False			,      a__					:				Optional[TensorType] = None			,      )				->  Mapping[str, Any]:





						'''simple docstring'''







						_A         =	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
										_A     ,						_A         =	common_inputs["input_ids"].shape
										# Not using the same length for past_key_values
										_A         =	seqlen + 2
										_A     ,						_A         =	self.num_layers
										_A     ,						_A         =	self.num_attention_heads
										_A         =	(
										    batch,
										    num_encoder_attention_heads,
										    past_key_values_length,
										    self._config.hidden_size // num_encoder_attention_heads,
										)

										_A         =	common_inputs["attention_mask"].dtype
										_A         =	torch.cat(
										    [common_inputs["attention_mask"], torch.ones(a__			,      a__			,      dtype=a__						)]			,      dim=1						)
										_A         =	[
										    (torch.zeros(a__						), torch.zeros(a__						)) for _ in range(a__						)
										]
						return common_inputs







		def        a_       (    self					:				Any			,      a__					:				PreTrainedTokenizer			,      a__					:				int = -1			,      a__					:				int = -1			,      a__					:				bool = False			,      a__					:				Optional[TensorType] = None			,      )				->  Mapping[str, Any]:





						'''simple docstring'''







						_A         =	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
						_A         =	tokenizer.num_special_tokens_to_add(a__						)
						_A         =	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
						_A         =	[" ".join([tokenizer.unk_token]						) * seq_length] * batch_size
						_A         =	dict(tokenizer(a__			,      return_tensors=a__						)						)
						return common_inputs







		def        a_       (    self					:				str			,      a__					:				PreTrainedTokenizer			,      a__					:				int = -1			,      a__					:				int = -1			,      a__					:				bool = False			,      a__					:				Optional[TensorType] = None			,      )				->  Mapping[str, Any]:





						'''simple docstring'''







						if self.task in ["default", "seq2seq-lm"]:
										_A         =	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":
										_A         =	self._generate_dummy_inputs_for_causal_lm(
										    a__			,      batch_size=a__			,      seq_length=a__			,      is_pair=a__			,      framework=a__						)
						else:
										_A         =	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					:				Dict			,      a__					:				Optional[int]			,      a__					:				Dict			,      a__					:				Tuple			,      a__					:				Optional[int]						)				->  List[Any]:





						'''simple docstring'''







						if self.task in ["default", "seq2seq-lm"]:
										_A         =	super()._flatten_past_key_values_(a__			,      a__			,      a__			,      a__						)
						else:
										_A         =	super(a__			,      self						)._flatten_past_key_values_(
										    a__			,      a__			,      a__			,      a__						)



"""simple docstring"""


import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin
class snake_case					(     _UpperCamelCase):
		__UpperCamelCase							=	'AutoFeatureExtractor'
		__UpperCamelCase							=	'Speech2Text2Tokenizer'







		def __init__(    self					:				int			,      a__					:				Tuple			,      a__					:				Optional[Any]						)				->  str:





						'''simple docstring'''







						super().__init__(a__			,      a__						)
						_A         =	self.feature_extractor
						_A         =	False







		def __call__(    self					:				Optional[int]			,      *a__					:				List[str]			,      **a__					:				Any						)				->  List[Any]:





						'''simple docstring'''







						if self._in_target_context_manager:
										return self.current_processor(*a__			,      **a__						)

						if "raw_speech" in kwargs:
										warnings.warn("Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead."						)
										_A         =	kwargs.pop("raw_speech"						)
						else:
										_A         =	kwargs.pop("audio"			,      a__						)
						_A         =	kwargs.pop("sampling_rate"			,      a__						)
						_A         =	kwargs.pop("text"			,      a__						)
						if len(a__						) > 0:
										_A         =	args[0]
										_A         =	args[1:]

						if audio is None and text is None:
										raise ValueError("You need to specify either an `audio` or `text` input to process."						)

						if audio is not None:
										_A         =	self.feature_extractor(a__			,      *a__			,      sampling_rate=a__			,      **a__						)
						if text is not None:
										_A         =	self.tokenizer(a__			,      **a__						)

						if text is None:
										return inputs
						elif audio is None:
										return encodings
						else:
										_A         =	encodings["input_ids"]
										return inputs







		def        a_       (    self					:				List[Any]			,      *a__					:				Tuple			,      **a__					:				List[Any]						)				->  List[Any]:





						'''simple docstring'''







						return self.tokenizer.batch_decode(*a__			,      **a__						)







		def        a_       (    self					:				Any			,      *a__					:				Dict			,      **a__					:				Tuple						)				->  Union[str, Any]:





						'''simple docstring'''







						return self.tokenizer.decode(*a__			,      **a__						)







		@contextmanager
		def        a_       (    self					:				Optional[int]						)				->  Optional[int]:





						'''simple docstring'''







						warnings.warn(
						    "`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your "
						    "labels by using the argument `text` of the regular `__call__` method (either in the same call as "
						    "your audio inputs, or in a separate call."						)
						_A         =	True
						_A         =	self.tokenizer
						yield
						_A         =	self.feature_extractor
						_A         =	False