





"""simple docstring"""





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

from tokenizers import pre_tokenizers, processors

from ...tokenization_utils_base import AddedToken, BatchEncoding, EncodedInput
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import PaddingStrategy, logging
from .tokenization_led import LEDTokenizer


_UpperCamelCase					      =   logging.get_logger(__name__)


_UpperCamelCase					      =   {'vocab_file': 'vocab.json', 'merges_file': 'merges.txt', 'tokenizer_file': 'tokenizer.json'}

_UpperCamelCase					      =   {
    'vocab_file': {
        'allenai/led-base-16384': 'https://huggingface.co/allenai/led-base-16384/resolve/main/vocab.json',
    },
    'merges_file': {
        'allenai/led-base-16384': 'https://huggingface.co/allenai/led-base-16384/resolve/main/merges.txt',
    },
    'tokenizer_file': {
        'allenai/led-base-16384': 'https://huggingface.co/allenai/led-base-16384/resolve/main/tokenizer.json',
    },
}

_UpperCamelCase					      =   {
    'allenai/led-base-16384': 1_6384,
}
class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""
				__snake_case :							List[str]									=		VOCAB_FILES_NAMES
				__snake_case :							str									=		PRETRAINED_VOCAB_FILES_MAP
				__snake_case :							List[Any]									=		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				__snake_case :							int									=		LEDTokenizer
				__snake_case :							Union[str, Any]									=		["""input_ids""", """attention_mask"""]




				def __init__(  self	:Union[str, Any]    ,     __lowercase	:Optional[Any]=None    ,     __lowercase	:List[Any]=None    ,     __lowercase	:Union[str, Any]=None    ,     __lowercase	:Dict="replace"    ,     __lowercase	:Optional[Any]="<s>"    ,     __lowercase	:Dict="</s>"    ,     __lowercase	:Dict="</s>"    ,     __lowercase	:Union[str, Any]="<s>"    ,     __lowercase	:int="<unk>"    ,     __lowercase	:List[str]="<pad>"    ,     __lowercase	:Optional[Any]="<mask>"    ,     __lowercase	:Tuple=False    ,     __lowercase	:Optional[int]=True    ,     **__lowercase	:int    ,     ):
											super().__init__(
											    __lowercase    ,     __lowercase    ,     tokenizer_file=__lowercase    ,     errors=__lowercase    ,     bos_token=__lowercase    ,     eos_token=__lowercase    ,     sep_token=__lowercase    ,     cls_token=__lowercase    ,     unk_token=__lowercase    ,     pad_token=__lowercase    ,     mask_token=__lowercase    ,     add_prefix_space=__lowercase    ,     trim_offsets=__lowercase    ,     **__lowercase    ,     )

											__lowerCamelCase   :   Dict       =json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()      )
											if pre_tok_state.get('''add_prefix_space'''    ,     __lowercase      ) != add_prefix_space:
																		__lowerCamelCase   :   str       =getattr(__lowercase    ,     pre_tok_state.pop('''type'''      )      )
																		__lowerCamelCase   :   int       =add_prefix_space
																		__lowerCamelCase   :   Dict       =pre_tok_class(**__lowercase      )

											__lowerCamelCase   :   List[str]       =add_prefix_space

											# the pre_tokenizer is already updated in the GPT2TokenizerFast `__init__`
											__lowerCamelCase   :   int       ='''post_processor'''
											__lowerCamelCase   :   Union[str, Any]       =getattr(self.backend_tokenizer    ,     __lowercase    ,     __lowercase      )
											if tokenizer_component_instance:
																		__lowerCamelCase   :   int       =json.loads(tokenizer_component_instance.__getstate__()      )

																		# The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
																		if "sep" in state:
																									__lowerCamelCase   :   List[str]       =tuple(state['''sep''']      )
																		if "cls" in state:
																									__lowerCamelCase   :   Any       =tuple(state['''cls''']      )

																		__lowerCamelCase   :   List[str]       =False

																		if state.get('''add_prefix_space'''    ,     __lowercase      ) != add_prefix_space:
																									__lowerCamelCase   :   Dict       =add_prefix_space
																									__lowerCamelCase   :   int       =True

																		if state.get('''trim_offsets'''    ,     __lowercase      ) != trim_offsets:
																									__lowerCamelCase   :   List[Any]       =trim_offsets
																									__lowerCamelCase   :   str       =True

																		if changes_to_apply:
																									__lowerCamelCase   :   Optional[Any]       =getattr(__lowercase    ,     state.pop('''type'''      )      )
																									__lowerCamelCase   :   int       =component_class(**__lowercase      )
																									setattr(self.backend_tokenizer    ,     __lowercase    ,     __lowercase      )




				@property
				# Copied from transformers.models.bart.tokenization_bart_fast.BartTokenizerFast.mask_token with BART->LED
				def        __lowercase	(  self	:Tuple      ):
											if self._mask_token is None:
																		if self.verbose:
																									logger.error('''Using mask_token, but it is not set yet.'''      )
																		return None
											return str(self._mask_token      )




				@mask_token.setter
				def        __lowercase	(  self	:Optional[Any]    ,     __lowercase	:Union[str, Any]      ):
											__lowerCamelCase   :   str       =AddedToken(__lowercase    ,     lstrip=__lowercase    ,     rstrip=__lowercase      ) if isinstance(__lowercase    ,     __lowercase      ) else value
											__lowerCamelCase   :   Union[str, Any]       =value




				def        __lowercase	(  self	:Tuple    ,     *__lowercase	:Optional[int]    ,     **__lowercase	:List[Any]      ):
											__lowerCamelCase   :   List[Any]       =kwargs.get('''is_split_into_words'''    ,     __lowercase      )

											if is_split_into_words and not self.add_prefix_space:
																		raise ValueError(
																		    f'You need to instantiate {self.__class__.__name__} with add_prefix_space=True '
																		    '''to use it with pretokenized inputs.'''      )

											return super()._batch_encode_plus(*__lowercase    ,     **__lowercase      )




				def        __lowercase	(  self	:Dict    ,     *__lowercase	:Union[str, Any]    ,     **__lowercase	:Optional[int]      ):
											__lowerCamelCase   :   Dict       =kwargs.get('''is_split_into_words'''    ,     __lowercase      )

											if is_split_into_words and not self.add_prefix_space:
																		raise ValueError(
																		    f'You need to instantiate {self.__class__.__name__} with add_prefix_space=True '
																		    '''to use it with pretokenized inputs.'''      )

											return super()._encode_plus(*__lowercase    ,     **__lowercase      )




				def        __lowercase	(  self	:List[Any]    ,     __lowercase	:str    ,     __lowercase	:Optional[str] = None      ):
											__lowerCamelCase   :   Optional[Any]       =self._tokenizer.model.save(__lowercase    ,     name=__lowercase      )
											return tuple(__lowercase      )




				def        __lowercase	(  self	:str    ,     __lowercase	:Optional[Any]    ,     __lowercase	:List[Any]=None      ):
											__lowerCamelCase   :   Tuple       =[self.bos_token_id] + token_ids_a + [self.eos_token_id]
											if token_ids_a is None:
																		return output

											return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]




				def        __lowercase	(  self	:Optional[int]    ,     __lowercase	:List[int]    ,     __lowercase	:Optional[List[int]] = None      ):
											__lowerCamelCase   :   Tuple       =[self.sep_token_id]
											__lowerCamelCase   :   List[str]       =[self.cls_token_id]

											if token_ids_a is None:
																		return len(cls + token_ids_a + sep      ) * [0]
											return len(cls + token_ids_a + sep + sep + token_ids_a + sep      ) * [0]




				def        __lowercase	(  self	:List[Any]    ,     __lowercase	:Union[Dict[str, EncodedInput], BatchEncoding]    ,     __lowercase	:Optional[int] = None    ,     __lowercase	:PaddingStrategy = PaddingStrategy.DO_NOT_PAD    ,     __lowercase	:Optional[int] = None    ,     __lowercase	:Optional[bool] = None    ,     ):
											__lowerCamelCase   :   Optional[int]       =super()._pad(
											    encoded_inputs=__lowercase    ,     max_length=__lowercase    ,     padding_strategy=__lowercase    ,     pad_to_multiple_of=__lowercase    ,     return_attention_mask=__lowercase    ,     )

											# Load from model defaults
											if return_attention_mask is None:
																		__lowerCamelCase   :   int       ='''attention_mask''' in self.model_input_names

											if return_attention_mask and "global_attention_mask" in encoded_inputs:
																		__lowerCamelCase   :   Dict       =encoded_inputs[self.model_input_names[0]]
																		# `global_attention_mask` need to have the same length as other (sequential) inputs.
																		__lowerCamelCase   :   List[str]       =len(encoded_inputs['''global_attention_mask''']      ) != len(__lowercase      )

																		if needs_to_be_padded:
																									__lowerCamelCase   :   List[str]       =len(__lowercase      ) - len(encoded_inputs['''global_attention_mask''']      )

																									if self.padding_side == "right":
																																# Use `-1` since `0` in `global_attention_mask` means `local attention` instead of `not to attend`
																																__lowerCamelCase   :   str       =(
																																    encoded_inputs['''global_attention_mask'''] + [-1] * difference
																																)
																									elif self.padding_side == "left":
																																__lowerCamelCase   :   Optional[Any]       =[-1] * difference + encoded_inputs[
																																    '''global_attention_mask'''
																																]
																									else:
																																raise ValueError('''Invalid padding strategy:''' + str(self.padding_side      )      )

											return encoded_inputs











"""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					      =   logging.get_logger(__name__)

_UpperCamelCase					      =   {
    'Helsinki-NLP/opus-mt-en-de': 'https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/config.json',
    # See all Marian models at https://huggingface.co/models?filter=marian
}
class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""
				__snake_case :							Tuple									=		"""marian"""
				__snake_case :							Any									=		["""past_key_values"""]
				__snake_case :							Optional[Any]									=		{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}




				def __init__(  self	:List[Any]    ,     __lowercase	:Any=5_8101    ,     __lowercase	:Tuple=None    ,     __lowercase	:Union[str, Any]=1024    ,     __lowercase	:Dict=12    ,     __lowercase	:int=4096    ,     __lowercase	:int=16    ,     __lowercase	:List[Any]=12    ,     __lowercase	:Dict=4096    ,     __lowercase	:Dict=16    ,     __lowercase	:Tuple=0.0    ,     __lowercase	:Tuple=0.0    ,     __lowercase	:List[Any]=True    ,     __lowercase	:int=True    ,     __lowercase	:Tuple="gelu"    ,     __lowercase	:str=1024    ,     __lowercase	:Optional[int]=0.1    ,     __lowercase	:List[str]=0.0    ,     __lowercase	:Union[str, Any]=0.0    ,     __lowercase	:Dict=0.02    ,     __lowercase	:Tuple=5_8100    ,     __lowercase	:Optional[Any]=False    ,     __lowercase	:int=5_8100    ,     __lowercase	:Any=0    ,     __lowercase	:str=0    ,     __lowercase	:str=True    ,     **__lowercase	:Any    ,     ):
											__lowerCamelCase   :   List[Any]       =vocab_size
											__lowerCamelCase   :   Optional[int]       =decoder_vocab_size or vocab_size
											__lowerCamelCase   :   Tuple       =max_position_embeddings
											__lowerCamelCase   :   List[Any]       =d_model
											__lowerCamelCase   :   Any       =encoder_ffn_dim
											__lowerCamelCase   :   str       =encoder_layers
											__lowerCamelCase   :   List[str]       =encoder_attention_heads
											__lowerCamelCase   :   str       =decoder_ffn_dim
											__lowerCamelCase   :   Tuple       =decoder_layers
											__lowerCamelCase   :   Any       =decoder_attention_heads
											__lowerCamelCase   :   List[Any]       =dropout
											__lowerCamelCase   :   Any       =attention_dropout
											__lowerCamelCase   :   Union[str, Any]       =activation_dropout
											__lowerCamelCase   :   Optional[int]       =activation_function
											__lowerCamelCase   :   Dict       =init_std
											__lowerCamelCase   :   List[Any]       =encoder_layerdrop
											__lowerCamelCase   :   Optional[Any]       =decoder_layerdrop
											__lowerCamelCase   :   Any       =use_cache
											__lowerCamelCase   :   Any       =encoder_layers
											__lowerCamelCase   :   Optional[int]       =scale_embedding  # scale factor will be sqrt(d_model) if True
											__lowerCamelCase   :   int       =share_encoder_decoder_embeddings
											super().__init__(
											    pad_token_id=__lowercase    ,     eos_token_id=__lowercase    ,     is_encoder_decoder=__lowercase    ,     decoder_start_token_id=__lowercase    ,     forced_eos_token_id=__lowercase    ,     **__lowercase    ,     )

class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""




				@property
				# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.inputs
				def        __lowercase	(  self	:int      ):
											if self.task in ["default", "seq2seq-lm"]:
																		__lowerCamelCase   :   Tuple       =OrderedDict(
																		    [
																		        ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
																		        ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
																		    ]      )

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

																		if self.use_past:
																									self.fill_with_past_key_values_(__lowercase    ,     direction='''inputs'''      )
											elif self.task == "causal-lm":
																		# TODO: figure this case out.
																		__lowerCamelCase   :   Any       =OrderedDict(
																		    [
																		        ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
																		        ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
																		    ]      )
																		if self.use_past:
																									__lowerCamelCase     ,    __lowerCamelCase   :   str       =self.num_layers
																									for i in range(__lowercase      ):
																																__lowerCamelCase   :   Optional[int]       ={0: '''batch''', 2: '''past_sequence + sequence'''}
																																__lowerCamelCase   :   List[str]       ={0: '''batch''', 2: '''past_sequence + sequence'''}
											else:
																		__lowerCamelCase   :   List[str]       =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
				# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
				def        __lowercase	(  self	:Optional[int]      ):
											if self.task in ["default", "seq2seq-lm"]:
																		__lowerCamelCase   :   Tuple       =super().outputs
											else:
																		__lowerCamelCase   :   List[str]       =super(__lowercase    ,     self      ).outputs
																		if self.use_past:
																									__lowerCamelCase     ,    __lowerCamelCase   :   int       =self.num_layers
																									for i in range(__lowercase      ):
																																__lowerCamelCase   :   Any       ={0: '''batch''', 2: '''past_sequence + sequence'''}
																																__lowerCamelCase   :   Optional[int]       ={0: '''batch''', 2: '''past_sequence + sequence'''}
											return common_outputs




				def        __lowercase	(  self	:str    ,     __lowercase	:PreTrainedTokenizer    ,     __lowercase	:int = -1    ,     __lowercase	:int = -1    ,     __lowercase	:bool = False    ,     __lowercase	:Optional[TensorType] = None    ,     ):
											__lowerCamelCase   :   List[str]       =self._generate_dummy_inputs_for_encoder_and_decoder(
											    __lowercase    ,     __lowercase    ,     __lowercase    ,     __lowercase    ,     __lowercase      )

											# Generate decoder inputs
											__lowerCamelCase   :   Optional[Any]       =seq_length if not self.use_past else 1
											__lowerCamelCase   :   List[Any]       =self._generate_dummy_inputs_for_encoder_and_decoder(
											    __lowercase    ,     __lowercase    ,     __lowercase    ,     __lowercase    ,     __lowercase      )
											__lowerCamelCase   :   Dict       ={f'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
											__lowerCamelCase   :   str       =dict(**__lowercase    ,     **__lowercase      )

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

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

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

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




				def        __lowercase	(  self	:Dict    ,     __lowercase	:PreTrainedTokenizer    ,     __lowercase	:int = -1    ,     __lowercase	:int = -1    ,     __lowercase	:bool = False    ,     __lowercase	:Optional[TensorType] = None    ,     ):
											__lowerCamelCase   :   List[str]       =self._generate_dummy_inputs_for_encoder_and_decoder(
											    __lowercase    ,     __lowercase    ,     __lowercase    ,     __lowercase    ,     __lowercase      )

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

																		__lowerCamelCase   :   Any       =common_inputs['''attention_mask'''].dtype
																		__lowerCamelCase   :   Optional[int]       =torch.cat(
																		    [common_inputs['''attention_mask'''], torch.ones(__lowercase    ,     __lowercase    ,     dtype=__lowercase      )]    ,     dim=1      )
																		__lowerCamelCase   :   List[str]       =[
																		    (torch.zeros(__lowercase      ), torch.zeros(__lowercase      )) for _ in range(__lowercase      )
																		]
											return common_inputs




				def        __lowercase	(  self	:int    ,     __lowercase	:PreTrainedTokenizer    ,     __lowercase	:int = -1    ,     __lowercase	:int = -1    ,     __lowercase	:bool = False    ,     __lowercase	:Optional[TensorType] = None    ,     ):
											# Copied from OnnxConfig.generate_dummy_inputs
											# Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
											# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
											__lowerCamelCase   :   Union[str, Any]       =compute_effective_axis_dimension(
											    __lowercase    ,     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
											__lowerCamelCase   :   Optional[int]       =tokenizer.num_special_tokens_to_add(__lowercase      )
											__lowerCamelCase   :   Optional[int]       =compute_effective_axis_dimension(
											    __lowercase    ,     fixed_dimension=OnnxConfig.default_fixed_sequence    ,     num_token_to_add=__lowercase      )

											# Generate dummy inputs according to compute batch and sequence
											__lowerCamelCase   :   Any       =[''' '''.join([tokenizer.unk_token]      ) * seq_length] * batch_size
											__lowerCamelCase   :   Union[str, Any]       =dict(tokenizer(__lowercase    ,     return_tensors=__lowercase      )      )
											return common_inputs




				def        __lowercase	(  self	:Tuple    ,     __lowercase	:PreTrainedTokenizer    ,     __lowercase	:int = -1    ,     __lowercase	:int = -1    ,     __lowercase	:bool = False    ,     __lowercase	:Optional[TensorType] = None    ,     ):
											if self.task in ["default", "seq2seq-lm"]:
																		__lowerCamelCase   :   int       =self._generate_dummy_inputs_for_default_and_seqaseq_lm(
																		    __lowercase    ,     batch_size=__lowercase    ,     seq_length=__lowercase    ,     is_pair=__lowercase    ,     framework=__lowercase      )

											else:
																		__lowerCamelCase   :   List[Any]       =self._generate_dummy_inputs_for_causal_lm(
																		    __lowercase    ,     batch_size=__lowercase    ,     seq_length=__lowercase    ,     is_pair=__lowercase    ,     framework=__lowercase      )

											return common_inputs




				def        __lowercase	(  self	:Optional[int]    ,     __lowercase	:Tuple    ,     __lowercase	:Tuple    ,     __lowercase	:Dict    ,     __lowercase	:List[str]      ):
											if self.task in ["default", "seq2seq-lm"]:
																		__lowerCamelCase   :   str       =super()._flatten_past_key_values_(__lowercase    ,     __lowercase    ,     __lowercase    ,     __lowercase      )
											else:
																		__lowerCamelCase   :   Optional[Any]       =super(__lowercase    ,     self      )._flatten_past_key_values_(
																		    __lowercase    ,     __lowercase    ,     __lowercase    ,     __lowercase      )




				@property
				def        __lowercase	(  self	:List[str]      ):
											return 1e-4




