


"""simple docstring"""






import json
import os
from typing import Dict, List, Optional, Tuple

import regex as re

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


UpperCamelCase__				:int			   =	logging.get_logger(__name__)


UpperCamelCase__				:Union[str, Any]			   =	{
    """vocab_file""": """vocab.json""",
    """merges_file""": """merges.txt""",
    """tokenizer_config_file""": """tokenizer_config.json""",
}

UpperCamelCase__				:Dict			   =	{
    """vocab_file""": {
        """facebook/blenderbot_small-90M""": """https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/vocab.json"""
    },
    """merges_file""": {
        """facebook/blenderbot_small-90M""": """https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/merges.txt"""
    },
    """tokenizer_config_file""": {
        """facebook/blenderbot_small-90M""": (
            """https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/tokenizer_config.json"""
        )
    },
}

UpperCamelCase__				:Optional[Any]			   =	{"""facebook/blenderbot_small-90M""": 512}





def 				A_       ( snake_case__		)					->  Dict:
			_UpperCamelCase					:int					     =	set()
			_UpperCamelCase					:Union[str, Any]					     =	word[0]
			for char in word[1:]:
						pairs.add((prev_char, char)		)
						_UpperCamelCase					:Dict					     =	char

			_UpperCamelCase					:int					     =	set(snake_case__		)
			return pairs






class      A(  lowerCamelCase__		):

		"""simple docstring"""





		A    =							VOCAB_FILES_NAMES
		A    =							PRETRAINED_VOCAB_FILES_MAP
		A    =							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		A    =							["input_ids", "attention_mask"]
		def __init__( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__="__start__"					,				SCREAMING_SNAKE_CASE__="__end__"					,				SCREAMING_SNAKE_CASE__="__unk__"					,				SCREAMING_SNAKE_CASE__="__null__"					,				**SCREAMING_SNAKE_CASE__					,				)      ->	Optional[int]:

					"""simple docstring"""



					super().__init__(unk_token=SCREAMING_SNAKE_CASE__					,				bos_token=SCREAMING_SNAKE_CASE__					,				eos_token=SCREAMING_SNAKE_CASE__					,				pad_token=SCREAMING_SNAKE_CASE__					,				**SCREAMING_SNAKE_CASE__   )

					with open(SCREAMING_SNAKE_CASE__					,				encoding='''utf-8'''   ) as vocab_handle:
								_UpperCamelCase					:List[str]					     =	json.load(SCREAMING_SNAKE_CASE__   )
					_UpperCamelCase					:List[str]					     =	{v: k for k, v in self.encoder.items()}
					with open(SCREAMING_SNAKE_CASE__					,				encoding='''utf-8'''   ) as merges_handle:
								_UpperCamelCase					:List[str]					     =	merges_handle.read().split('''\n'''   )[1:-1]
					_UpperCamelCase					:Tuple					     =	[tuple(merge.split()   ) for merge in merges]
					_UpperCamelCase					:Union[str, Any]					     =	dict(zip(SCREAMING_SNAKE_CASE__					,				range(len(SCREAMING_SNAKE_CASE__   )   )   )   )
					_UpperCamelCase					:Union[str, Any]					     =	{}
		@property
		def   _UpperCamelCase( self   )      ->	int:

					"""simple docstring"""



					return len(self.encoder   )
		def   _UpperCamelCase( self   )      ->	Dict:

					"""simple docstring"""



					return dict(self.encoder					,				**self.added_tokens_encoder   )
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__   )      ->	str:

					"""simple docstring"""



					if token in self.cache:
								return self.cache[token]
					_UpperCamelCase					:str					     =	re.sub('''([.,!?()])'''					,				r''' \1'''					,				SCREAMING_SNAKE_CASE__   )
					_UpperCamelCase					:List[Any]					     =	re.sub('''(\')'''					,				r''' \1 '''					,				SCREAMING_SNAKE_CASE__   )
					_UpperCamelCase					:Dict					     =	re.sub(r'''\s{2,}'''					,				''' '''					,				SCREAMING_SNAKE_CASE__   )
					if "\n" in token:
								_UpperCamelCase					:Tuple					     =	token.replace('''\n'''					,				''' __newln__'''   )

					_UpperCamelCase					:List[Any]					     =	token.split(''' '''   )
					_UpperCamelCase					:List[Any]					     =	[]
					for token in tokens:
								if not len(SCREAMING_SNAKE_CASE__   ):
											continue

								_UpperCamelCase					:int					     =	token.lower()
								_UpperCamelCase					:Tuple					     =	tuple(SCREAMING_SNAKE_CASE__   )
								_UpperCamelCase					:Any					     =	tuple(list(word[:-1]   ) + [word[-1] + '''</w>''']   )
								_UpperCamelCase					:Dict					     =	get_pairs(SCREAMING_SNAKE_CASE__   )

								if not pairs:
											words.append(SCREAMING_SNAKE_CASE__   )
											continue

								while True:
											_UpperCamelCase					:List[str]					     =	min(SCREAMING_SNAKE_CASE__					,				key=lambda SCREAMING_SNAKE_CASE__   : self.bpe_ranks.get(SCREAMING_SNAKE_CASE__					,				float('''inf'''   )   )   )
											if bigram not in self.bpe_ranks:
														break
											_UpperCamelCase     ,      _UpperCamelCase					:Optional[Any]					     =	bigram
											_UpperCamelCase					:str					     =	[]
											_UpperCamelCase					:Optional[int]					     =	0

											while i < len(SCREAMING_SNAKE_CASE__   ):
														try:
																	_UpperCamelCase					:List[str]					     =	word.index(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )
																	new_word.extend(word[i:j]   )
																	_UpperCamelCase					:int					     =	j
														except ValueError:
																	new_word.extend(word[i:]   )
																	break

														if word[i] == first and i < len(SCREAMING_SNAKE_CASE__   ) - 1 and word[i + 1] == second:
																	new_word.append(first + second   )
																	i += 2
														else:
																	new_word.append(word[i]   )
																	i += 1
											_UpperCamelCase					:Dict					     =	tuple(SCREAMING_SNAKE_CASE__   )
											_UpperCamelCase					:Union[str, Any]					     =	new_word
											if len(SCREAMING_SNAKE_CASE__   ) == 1:
														break
											else:
														_UpperCamelCase					:Dict					     =	get_pairs(SCREAMING_SNAKE_CASE__   )
								_UpperCamelCase					:Tuple					     =	'''@@ '''.join(SCREAMING_SNAKE_CASE__   )
								_UpperCamelCase					:Dict					     =	word[:-4]

								_UpperCamelCase					:Any					     =	word
								words.append(SCREAMING_SNAKE_CASE__   )
					return " ".join(SCREAMING_SNAKE_CASE__   )
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__   )      ->	List[str]:

					"""simple docstring"""



					_UpperCamelCase					:int					     =	[]

					_UpperCamelCase					:Dict					     =	re.findall(r'''\S+\n?'''					,				SCREAMING_SNAKE_CASE__   )

					for token in words:
								split_tokens.extend(list(self.bpe(SCREAMING_SNAKE_CASE__   ).split(''' '''   )   )   )
					return split_tokens
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__   )      ->	int:

					"""simple docstring"""



					_UpperCamelCase					:List[Any]					     =	token.lower()
					return self.encoder.get(SCREAMING_SNAKE_CASE__					,				self.encoder.get(self.unk_token   )   )
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__   )      ->	str:

					"""simple docstring"""



					return self.decoder.get(SCREAMING_SNAKE_CASE__					,				self.unk_token   )
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__   )      ->	str:

					"""simple docstring"""



					_UpperCamelCase					:int					     =	''' '''.join(SCREAMING_SNAKE_CASE__   ).replace('''@@ '''					,				''''''   ).strip()
					return out_string





		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = None   )      ->	Tuple[str]:

					"""simple docstring"""



					if not os.path.isdir(SCREAMING_SNAKE_CASE__   ):
								logger.error(f"Vocabulary path ({save_directory}) should be a directory"   )
								return
					_UpperCamelCase					:int					     =	os.path.join(
					    SCREAMING_SNAKE_CASE__					,				(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']   )
					_UpperCamelCase					:int					     =	os.path.join(
					    SCREAMING_SNAKE_CASE__					,				(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file''']   )

					with open(SCREAMING_SNAKE_CASE__					,				'''w'''					,				encoding='''utf-8'''   ) as f:
								f.write(json.dumps(self.encoder					,				indent=2					,				sort_keys=SCREAMING_SNAKE_CASE__					,				ensure_ascii=SCREAMING_SNAKE_CASE__   ) + '''\n'''   )

					_UpperCamelCase					:List[str]					     =	0
					with open(SCREAMING_SNAKE_CASE__					,				'''w'''					,				encoding='''utf-8'''   ) as writer:
								writer.write('''#version: 0.2\n'''   )
								for bpe_tokens, token_index in sorted(self.bpe_ranks.items()					,				key=lambda SCREAMING_SNAKE_CASE__   : kv[1]   ):
											if index != token_index:
														logger.warning(
														    f"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."
														    ''' Please check that the tokenizer is not corrupted!'''   )
														_UpperCamelCase					:Union[str, Any]					     =	token_index
											writer.write(''' '''.join(SCREAMING_SNAKE_CASE__   ) + '''\n'''   )
											index += 1

					return vocab_file, merge_file





"""simple docstring"""






import warnings
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__				:Dict			   =	logging.get_logger(__name__)

UpperCamelCase__				:int			   =	{
    """facebook/bart-large""": """https://huggingface.co/facebook/bart-large/resolve/main/config.json""",
    # See all BART models at https://huggingface.co/models?filter=bart
}






class      A(  lowerCamelCase__		):

		"""simple docstring"""





		A    =							"bart"
		A    =							["past_key_values"]
		A    =							{"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}
		def __init__( self					,				SCREAMING_SNAKE_CASE__=5_02_65					,				SCREAMING_SNAKE_CASE__=10_24					,				SCREAMING_SNAKE_CASE__=12					,				SCREAMING_SNAKE_CASE__=40_96					,				SCREAMING_SNAKE_CASE__=16					,				SCREAMING_SNAKE_CASE__=12					,				SCREAMING_SNAKE_CASE__=40_96					,				SCREAMING_SNAKE_CASE__=16					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__="gelu"					,				SCREAMING_SNAKE_CASE__=10_24					,				SCREAMING_SNAKE_CASE__=0.1					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__=0.0_2					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__=False					,				SCREAMING_SNAKE_CASE__=True					,				SCREAMING_SNAKE_CASE__=3					,				SCREAMING_SNAKE_CASE__=1					,				SCREAMING_SNAKE_CASE__=0					,				SCREAMING_SNAKE_CASE__=2					,				SCREAMING_SNAKE_CASE__=True					,				SCREAMING_SNAKE_CASE__=2					,				SCREAMING_SNAKE_CASE__=2					,				**SCREAMING_SNAKE_CASE__					,				)      ->	Optional[Any]:

					"""simple docstring"""



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

					super().__init__(
					    num_labels=SCREAMING_SNAKE_CASE__					,				pad_token_id=SCREAMING_SNAKE_CASE__					,				bos_token_id=SCREAMING_SNAKE_CASE__					,				eos_token_id=SCREAMING_SNAKE_CASE__					,				is_encoder_decoder=SCREAMING_SNAKE_CASE__					,				decoder_start_token_id=SCREAMING_SNAKE_CASE__					,				forced_eos_token_id=SCREAMING_SNAKE_CASE__					,				**SCREAMING_SNAKE_CASE__					,				)

					# ensure backward compatibility for BART CNN models
					if self.forced_bos_token_id is None and kwargs.get('''force_bos_token_to_be_generated'''					,				SCREAMING_SNAKE_CASE__   ):
								_UpperCamelCase					:Any					     =	self.bos_token_id
								warnings.warn(
								    f"Please make sure the config includes `forced_bos_token_id={self.bos_token_id}` in future versions. "
								    '''The config can simply be saved and uploaded again to be fixed.'''   )






class      A(  lowerCamelCase__		):

		"""simple docstring"""





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

					"""simple docstring"""



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

								if self.use_past:
											_UpperCamelCase					:Optional[Any]					     =	{0: '''batch'''}
											_UpperCamelCase					:int					     =	{0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
								else:
											_UpperCamelCase					:Optional[Any]					     =	{0: '''batch''', 1: '''decoder_sequence'''}
											_UpperCamelCase					:Optional[Any]					     =	{0: '''batch''', 1: '''decoder_sequence'''}

								if self.use_past:
											self.fill_with_past_key_values_(SCREAMING_SNAKE_CASE__					,				direction='''inputs'''   )
					elif self.task == "causal-lm":
								# TODO: figure this case out.
								_UpperCamelCase					:Tuple					     =	OrderedDict(
								    [
								        ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
								        ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
								    ]   )
								if self.use_past:
											_UpperCamelCase     ,      _UpperCamelCase					:List[str]					     =	self.num_layers
											for i in range(SCREAMING_SNAKE_CASE__   ):
														_UpperCamelCase					:int					     =	{0: '''batch''', 2: '''past_sequence + sequence'''}
														_UpperCamelCase					:List[Any]					     =	{0: '''batch''', 2: '''past_sequence + sequence'''}
					else:
								_UpperCamelCase					: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   _UpperCamelCase( self   )      ->	Mapping[str, Mapping[int, str]]:

					"""simple docstring"""



					if self.task in ["default", "seq2seq-lm"]:
								_UpperCamelCase					:Optional[int]					     =	super().outputs
					else:
								_UpperCamelCase					:List[str]					     =	super(SCREAMING_SNAKE_CASE__					,				self   ).outputs
								if self.use_past:
											_UpperCamelCase     ,      _UpperCamelCase					:int					     =	self.num_layers
											for i in range(SCREAMING_SNAKE_CASE__   ):
														_UpperCamelCase					:Optional[Any]					     =	{0: '''batch''', 2: '''past_sequence + sequence'''}
														_UpperCamelCase					:Optional[Any]					     =	{0: '''batch''', 2: '''past_sequence + sequence'''}
					return common_outputs
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = False					,				SCREAMING_SNAKE_CASE__ = None					,				)      ->	Mapping[str, Any]:

					"""simple docstring"""



					_UpperCamelCase					:str					     =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )

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

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

								_UpperCamelCase					:Optional[int]					     =	torch.cat(
								    [common_inputs['''decoder_attention_mask'''], torch.ones(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )]					,				dim=1   )

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

								for _ in range(SCREAMING_SNAKE_CASE__   ):
											common_inputs["past_key_values"].append(
											    (
											        torch.zeros(SCREAMING_SNAKE_CASE__   ),
											        torch.zeros(SCREAMING_SNAKE_CASE__   ),
											        torch.zeros(SCREAMING_SNAKE_CASE__   ),
											        torch.zeros(SCREAMING_SNAKE_CASE__   ),
											    )   )
								# TODO: test this.
								_UpperCamelCase					:Optional[int]					     =	encoder_shape if remaining_side_name == '''encoder''' else decoder_shape
								for _ in range(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   ):
											common_inputs["past_key_values"].append((torch.zeros(SCREAMING_SNAKE_CASE__   ), torch.zeros(SCREAMING_SNAKE_CASE__   ))   )
					return common_inputs
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = False					,				SCREAMING_SNAKE_CASE__ = None					,				)      ->	Mapping[str, Any]:

					"""simple docstring"""



					_UpperCamelCase					:Dict					     =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )

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

								_UpperCamelCase					:Tuple					     =	common_inputs['''attention_mask'''].dtype
								_UpperCamelCase					:List[Any]					     =	torch.cat(
								    [common_inputs['''attention_mask'''], torch.ones(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				dtype=SCREAMING_SNAKE_CASE__   )]					,				dim=1   )
								_UpperCamelCase					:int					     =	[
								    (torch.zeros(SCREAMING_SNAKE_CASE__   ), torch.zeros(SCREAMING_SNAKE_CASE__   )) for _ in range(SCREAMING_SNAKE_CASE__   )
								]
					return common_inputs
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = False					,				SCREAMING_SNAKE_CASE__ = None					,				)      ->	Mapping[str, Any]:

					"""simple docstring"""



					_UpperCamelCase					:List[str]					     =	compute_effective_axis_dimension(
					    SCREAMING_SNAKE_CASE__					,				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
					_UpperCamelCase					:str					     =	tokenizer.num_special_tokens_to_add(SCREAMING_SNAKE_CASE__   )
					_UpperCamelCase					:str					     =	compute_effective_axis_dimension(
					    SCREAMING_SNAKE_CASE__					,				fixed_dimension=OnnxConfig.default_fixed_sequence					,				num_token_to_add=SCREAMING_SNAKE_CASE__   )

					# Generate dummy inputs according to compute batch and sequence
					_UpperCamelCase					:List[Any]					     =	[''' '''.join([tokenizer.unk_token]   ) * seq_length] * batch_size
					_UpperCamelCase					:Optional[Any]					     =	dict(tokenizer(SCREAMING_SNAKE_CASE__					,				return_tensors=SCREAMING_SNAKE_CASE__   )   )
					return common_inputs
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = False					,				SCREAMING_SNAKE_CASE__ = None					,				)      ->	Mapping[str, Any]:

					"""simple docstring"""



					if self.task in ["default", "seq2seq-lm"]:
								_UpperCamelCase					:str					     =	self._generate_dummy_inputs_for_default_and_seqaseq_lm(
								    SCREAMING_SNAKE_CASE__					,				batch_size=SCREAMING_SNAKE_CASE__					,				seq_length=SCREAMING_SNAKE_CASE__					,				is_pair=SCREAMING_SNAKE_CASE__					,				framework=SCREAMING_SNAKE_CASE__   )

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

					return common_inputs





		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )      ->	Dict:

					"""simple docstring"""



					if self.task in ["default", "seq2seq-lm"]:
								_UpperCamelCase					:Union[str, Any]					     =	super()._flatten_past_key_values_(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )
					else:
								_UpperCamelCase					:Tuple					     =	super(SCREAMING_SNAKE_CASE__					,				self   )._flatten_past_key_values_(
								    SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )

