


import os
import unittest

from transformers import RealmTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.models.realm.tokenization_realm import RealmTokenizer
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english







@require_tokenizers
class      __lowercase  (__SCREAMING_SNAKE_CASE     ,    unittest.TestCase   ):





							"""simple docstring"""







							_UpperCAmelCase     =		RealmTokenizer
							_UpperCAmelCase     =		RealmTokenizerFast
							_UpperCAmelCase     =		True
							_UpperCAmelCase     =		True
							_UpperCAmelCase     =		filter_non_english






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										super().setUp()

										SCREAMING_SNAKE_CASE_						:			int       						= [
										    '[UNK]',
										    '[CLS]',
										    '[SEP]',
										    '[PAD]',
										    '[MASK]',
										    'want',
										    '##want',
										    '##ed',
										    'wa',
										    'un',
										    'runn',
										    '##ing',
										    ',',
										    'low',
										    'lowest',
										]
										SCREAMING_SNAKE_CASE_						:			Tuple       						= os.path.join(self.tmpdirname       ,		VOCAB_FILES_NAMES['vocab_file']    )
										with open(self.vocab_file       ,		'w'       ,		encoding='utf-8'    ) as vocab_writer:
													vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]    )    )






							def  UpperCamelCase__			(	self       ,		lowerCAmelCase__    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= 'UNwant\u00E9d,running'
										SCREAMING_SNAKE_CASE_						:			Any       						= 'unwanted, running'
										return input_text, output_text






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= self.tokenizer_class(self.vocab_file    )

										SCREAMING_SNAKE_CASE_						:			Tuple       						= tokenizer.tokenize('UNwant\u00E9d,running'    )
										self.assertListEqual(lowerCAmelCase__       ,		['un', '##want', '##ed', ',', 'runn', '##ing']    )
										self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase__    )       ,		[9, 6, 7, 1_2, 1_0, 1_1]    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										if not self.test_rust_tokenizer:
													return

										SCREAMING_SNAKE_CASE_						:			List[Any]       						= self.get_tokenizer()
										SCREAMING_SNAKE_CASE_						:			Dict       						= self.get_rust_tokenizer()

										SCREAMING_SNAKE_CASE_						:			Any       						= 'UNwant\u00E9d,running'

										SCREAMING_SNAKE_CASE_						:			Any       						= tokenizer.tokenize(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			str       						= rust_tokenizer.tokenize(lowerCAmelCase__    )
										self.assertListEqual(lowerCAmelCase__       ,		lowerCAmelCase__    )

										SCREAMING_SNAKE_CASE_						:			Dict       						= tokenizer.encode(lowerCAmelCase__       ,		add_special_tokens=lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= rust_tokenizer.encode(lowerCAmelCase__       ,		add_special_tokens=lowerCAmelCase__    )
										self.assertListEqual(lowerCAmelCase__       ,		lowerCAmelCase__    )

										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= self.get_rust_tokenizer()
										SCREAMING_SNAKE_CASE_						:			List[Any]       						= tokenizer.encode(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			str       						= rust_tokenizer.encode(lowerCAmelCase__    )
										self.assertListEqual(lowerCAmelCase__       ,		lowerCAmelCase__    )

										# With lower casing
										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= self.get_tokenizer(do_lower_case=lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			List[str]       						= self.get_rust_tokenizer(do_lower_case=lowerCAmelCase__    )

										SCREAMING_SNAKE_CASE_						:			List[Any]       						= 'UNwant\u00E9d,running'

										SCREAMING_SNAKE_CASE_						:			str       						= tokenizer.tokenize(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= rust_tokenizer.tokenize(lowerCAmelCase__    )
										self.assertListEqual(lowerCAmelCase__       ,		lowerCAmelCase__    )

										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= tokenizer.encode(lowerCAmelCase__       ,		add_special_tokens=lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= rust_tokenizer.encode(lowerCAmelCase__       ,		add_special_tokens=lowerCAmelCase__    )
										self.assertListEqual(lowerCAmelCase__       ,		lowerCAmelCase__    )

										SCREAMING_SNAKE_CASE_						:			Any       						= self.get_rust_tokenizer()
										SCREAMING_SNAKE_CASE_						:			List[str]       						= tokenizer.encode(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Any       						= rust_tokenizer.encode(lowerCAmelCase__    )
										self.assertListEqual(lowerCAmelCase__       ,		lowerCAmelCase__    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Dict       						= BasicTokenizer()

										self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'    )       ,		['ah', '\u535A', '\u63A8', 'zz']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= BasicTokenizer(do_lower_case=lowerCAmelCase__    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '    )       ,		['hello', '!', 'how', 'are', 'you', '?']    )
										self.assertListEqual(tokenizer.tokenize('H\u00E9llo'    )       ,		['hello']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= BasicTokenizer(do_lower_case=lowerCAmelCase__       ,		strip_accents=lowerCAmelCase__    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '    )       ,		['hällo', '!', 'how', 'are', 'you', '?']    )
										self.assertListEqual(tokenizer.tokenize('H\u00E9llo'    )       ,		['h\u00E9llo']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			List[Any]       						= BasicTokenizer(do_lower_case=lowerCAmelCase__       ,		strip_accents=lowerCAmelCase__    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '    )       ,		['hallo', '!', 'how', 'are', 'you', '?']    )
										self.assertListEqual(tokenizer.tokenize('H\u00E9llo'    )       ,		['hello']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Tuple       						= BasicTokenizer(do_lower_case=lowerCAmelCase__    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '    )       ,		['hallo', '!', 'how', 'are', 'you', '?']    )
										self.assertListEqual(tokenizer.tokenize('H\u00E9llo'    )       ,		['hello']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Any       						= BasicTokenizer(do_lower_case=lowerCAmelCase__    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '    )       ,		['HeLLo', '!', 'how', 'Are', 'yoU', '?']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= BasicTokenizer(do_lower_case=lowerCAmelCase__       ,		strip_accents=lowerCAmelCase__    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '    )       ,		['HäLLo', '!', 'how', 'Are', 'yoU', '?']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			List[Any]       						= BasicTokenizer(do_lower_case=lowerCAmelCase__       ,		strip_accents=lowerCAmelCase__    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '    )       ,		['HaLLo', '!', 'how', 'Are', 'yoU', '?']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Any       						= BasicTokenizer(do_lower_case=lowerCAmelCase__       ,		never_split=['[UNK]']    )

										self.assertListEqual(
										    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'    )       ,		['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= {}
										for i, token in enumerate(lowerCAmelCase__    ):
													SCREAMING_SNAKE_CASE_						:			Any       						= i
										SCREAMING_SNAKE_CASE_						:			List[Any]       						= WordpieceTokenizer(vocab=lowerCAmelCase__       ,		unk_token='[UNK]'    )

										self.assertListEqual(tokenizer.tokenize(''    )       ,		[]    )

										self.assertListEqual(tokenizer.tokenize('unwanted running'    )       ,		['un', '##want', '##ed', 'runn', '##ing']    )

										self.assertListEqual(tokenizer.tokenize('unwantedX running'    )       ,		['[UNK]', 'runn', '##ing']    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										self.assertTrue(_is_whitespace(' '    )    )
										self.assertTrue(_is_whitespace('\t'    )    )
										self.assertTrue(_is_whitespace('\r'    )    )
										self.assertTrue(_is_whitespace('\n'    )    )
										self.assertTrue(_is_whitespace('\u00A0'    )    )

										self.assertFalse(_is_whitespace('A'    )    )
										self.assertFalse(_is_whitespace('-'    )    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										self.assertTrue(_is_control('\u0005'    )    )

										self.assertFalse(_is_control('A'    )    )
										self.assertFalse(_is_control(' '    )    )
										self.assertFalse(_is_control('\t'    )    )
										self.assertFalse(_is_control('\r'    )    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										self.assertTrue(_is_punctuation('-'    )    )
										self.assertTrue(_is_punctuation('$'    )    )
										self.assertTrue(_is_punctuation('`'    )    )
										self.assertTrue(_is_punctuation('.'    )    )

										self.assertFalse(_is_punctuation('A'    )    )
										self.assertFalse(_is_punctuation(' '    )    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			List[Any]       						= self.get_tokenizer()

										# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
										self.assertListEqual([tokenizer.tokenize(lowerCAmelCase__    ) for t in ['Test', '\xad', 'test']]       ,		[['[UNK]'], [], ['[UNK]']]    )

										if self.test_rust_tokenizer:
													SCREAMING_SNAKE_CASE_						:			str       						= self.get_rust_tokenizer()
													self.assertListEqual(
													    [rust_tokenizer.tokenize(lowerCAmelCase__    ) for t in ['Test', '\xad', 'test']]       ,		[['[UNK]'], [], ['[UNK]']]    )






							@slow
							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			str       						= self.tokenizer_class.from_pretrained('bert-base-uncased'    )

										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= tokenizer.encode('sequence builders'       ,		add_special_tokens=lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= tokenizer.encode('multi-sequence build'       ,		add_special_tokens=lowerCAmelCase__    )

										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Any       						= tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__       ,		lowerCAmelCase__    )

										assert encoded_sentence == [1_0_1] + text + [1_0_2]
										assert encoded_pair == [1_0_1] + text + [1_0_2] + text_a + [1_0_2]






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
													with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
																SCREAMING_SNAKE_CASE_						:			Optional[int]       						= self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__       ,		**lowerCAmelCase__    )

																SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
																SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= tokenizer_r.encode_plus(
																    lowerCAmelCase__       ,		return_attention_mask=lowerCAmelCase__       ,		return_token_type_ids=lowerCAmelCase__       ,		return_offsets_mapping=lowerCAmelCase__       ,		add_special_tokens=lowerCAmelCase__       ,		)

																SCREAMING_SNAKE_CASE_						:			List[Any]       						= tokenizer_r.do_lower_case if hasattr(lowerCAmelCase__       ,		'do_lower_case'    ) else False
																SCREAMING_SNAKE_CASE_						:			str       						= (
																    [
																        ((0, 0), tokenizer_r.cls_token),
																        ((0, 1), 'A'),
																        ((1, 2), ','),
																        ((3, 5), 'na'),
																        ((5, 6), '##ï'),
																        ((6, 8), '##ve'),
																        ((9, 1_5), tokenizer_r.mask_token),
																        ((1_6, 2_1), 'Allen'),
																        ((2_1, 2_3), '##NL'),
																        ((2_3, 2_4), '##P'),
																        ((2_5, 3_3), 'sentence'),
																        ((3_3, 3_4), '.'),
																        ((0, 0), tokenizer_r.sep_token),
																    ]
																    if not do_lower_case
																    else [
																        ((0, 0), tokenizer_r.cls_token),
																        ((0, 1), 'a'),
																        ((1, 2), ','),
																        ((3, 8), 'naive'),
																        ((9, 1_5), tokenizer_r.mask_token),
																        ((1_6, 2_1), 'allen'),
																        ((2_1, 2_3), '##nl'),
																        ((2_3, 2_4), '##p'),
																        ((2_5, 3_3), 'sentence'),
																        ((3_3, 3_4), '.'),
																        ((0, 0), tokenizer_r.sep_token),
																    ]
																)

																self.assertEqual(
																    [e[1] for e in expected_results]       ,		tokenizer_r.convert_ids_to_tokens(tokens['input_ids']    )    )
																self.assertEqual([e[0] for e in expected_results]       ,		tokens['offset_mapping']    )






							@slow
							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
													with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
																SCREAMING_SNAKE_CASE_						:			str       						= self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__       ,		**lowerCAmelCase__    )
																SCREAMING_SNAKE_CASE_						:			List[Any]       						= self.tokenizer_class.from_pretrained(lowerCAmelCase__       ,		**lowerCAmelCase__    )
																SCREAMING_SNAKE_CASE_						:			Optional[int]       						= [['Hello world!', 'Nice to meet you!'], ['The cute cat.', 'The adorable dog.']]

																SCREAMING_SNAKE_CASE_						:			List[Any]       						= tokenizer_r.batch_encode_candidates(lowerCAmelCase__       ,		max_length=1_0       ,		return_tensors='np'    )
																SCREAMING_SNAKE_CASE_						:			Any       						= tokenizer_p.batch_encode_candidates(lowerCAmelCase__       ,		max_length=1_0       ,		return_tensors='np'    )

																SCREAMING_SNAKE_CASE_						:			Optional[int]       						= (2, 2, 1_0)

																self.assertEqual(encoded_sentence_r['input_ids'].shape       ,		lowerCAmelCase__    )
																self.assertEqual(encoded_sentence_r['attention_mask'].shape       ,		lowerCAmelCase__    )
																self.assertEqual(encoded_sentence_r['token_type_ids'].shape       ,		lowerCAmelCase__    )

																self.assertEqual(encoded_sentence_p['input_ids'].shape       ,		lowerCAmelCase__    )
																self.assertEqual(encoded_sentence_p['attention_mask'].shape       ,		lowerCAmelCase__    )
																self.assertEqual(encoded_sentence_p['token_type_ids'].shape       ,		lowerCAmelCase__    )












"""simple docstring"""





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

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


_lowerCamelCase       =	logging.get_logger(__name__)

_lowerCamelCase       =	{
    '''facebook/m2m100_418M''': '''https://huggingface.co/facebook/m2m100_418M/resolve/main/config.json''',
    # See all M2M100 models at https://huggingface.co/models?filter=m2m_100
}





class 			snake_case		(   __UpperCAmelCase   ):
      lowerCamelCase__						= '''m2m_100'''
      lowerCamelCase__						= ['''past_key_values''']
      lowerCamelCase__						= {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}

      def __init__(			self   :int						,							_lowerCamelCase   :Union[str, Any]=1_2_8_1_1_2						,							_lowerCamelCase   :str=1_0_2_4						,							_lowerCamelCase   :Any=1_2						,							_lowerCamelCase   :Dict=4_0_9_6						,							_lowerCamelCase   :List[str]=1_6						,							_lowerCamelCase   :Union[str, Any]=1_2						,							_lowerCamelCase   :Any=4_0_9_6						,							_lowerCamelCase   :str=1_6						,							_lowerCamelCase   :Union[str, Any]=0.0_5						,							_lowerCamelCase   :Any=0.0_5						,							_lowerCamelCase   :int=True						,							_lowerCamelCase   :Dict=True						,							_lowerCamelCase   :List[str]="relu"						,							_lowerCamelCase   :List[Any]=1_0_2_4						,							_lowerCamelCase   :Dict=0.1						,							_lowerCamelCase   :List[Any]=0.1						,							_lowerCamelCase   :Any=0.0						,							_lowerCamelCase   :Tuple=0.0_2						,							_lowerCamelCase   :Dict=2						,							_lowerCamelCase   :List[str]=True						,							_lowerCamelCase   :Any=1						,							_lowerCamelCase   :Dict=0						,							_lowerCamelCase   :List[Any]=2						,							**_lowerCamelCase   :Optional[Any]						,							):
       __SCREAMING_SNAKE_CASE :			Any												=       vocab_size
       __SCREAMING_SNAKE_CASE :			Any												=       max_position_embeddings
       __SCREAMING_SNAKE_CASE :			int												=       d_model
       __SCREAMING_SNAKE_CASE :			List[Any]												=       encoder_ffn_dim
       __SCREAMING_SNAKE_CASE :			Dict												=       encoder_layers
       __SCREAMING_SNAKE_CASE :			int												=       encoder_attention_heads
       __SCREAMING_SNAKE_CASE :			Dict												=       decoder_ffn_dim
       __SCREAMING_SNAKE_CASE :			Union[str, Any]												=       decoder_layers
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       decoder_attention_heads
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       dropout
       __SCREAMING_SNAKE_CASE :			Union[str, Any]												=       attention_dropout
       __SCREAMING_SNAKE_CASE :			List[str]												=       activation_dropout
       __SCREAMING_SNAKE_CASE :			List[Any]												=       activation_function
       __SCREAMING_SNAKE_CASE :			Any												=       init_std
       __SCREAMING_SNAKE_CASE :			List[Any]												=       encoder_layerdrop
       __SCREAMING_SNAKE_CASE :			Union[str, Any]												=       decoder_layerdrop
       __SCREAMING_SNAKE_CASE :			Union[str, Any]												=       use_cache
       __SCREAMING_SNAKE_CASE :			List[str]												=       encoder_layers
       __SCREAMING_SNAKE_CASE :			str												=       scale_embedding  # scale factor will be sqrt(d_model) if True

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







class 			snake_case		(   __UpperCAmelCase   ):

      @property
      def 						SCREAMING_SNAKE_CASE_			(			self   :int						):
       __SCREAMING_SNAKE_CASE :			str												=       OrderedDict(
           [
               ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
           ]						)

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

       if self.use_past:
        self.fill_with_past_key_values_(_lowerCamelCase						,							direction='''inputs'''						)
       return common_inputs

      def 						SCREAMING_SNAKE_CASE_			(			self   :Tuple						,							_lowerCamelCase   :PreTrainedTokenizer						,							_lowerCamelCase   :int = -1						,							_lowerCamelCase   :int = -1						,							_lowerCamelCase   :bool = False						,							_lowerCamelCase   :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
       __SCREAMING_SNAKE_CASE :			List[Any]												=       compute_effective_axis_dimension(
           _lowerCamelCase						,							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
       __SCREAMING_SNAKE_CASE :			List[str]												=       tokenizer.num_special_tokens_to_add(_lowerCamelCase						)
       __SCREAMING_SNAKE_CASE :			int												=       compute_effective_axis_dimension(
           _lowerCamelCase						,							fixed_dimension=OnnxConfig.default_fixed_sequence						,							num_token_to_add=_lowerCamelCase						)

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

      def 						SCREAMING_SNAKE_CASE_			(			self   :str						,							_lowerCamelCase   :PreTrainedTokenizer						,							_lowerCamelCase   :int = -1						,							_lowerCamelCase   :int = -1						,							_lowerCamelCase   :bool = False						,							_lowerCamelCase   :Optional[TensorType] = None						,							):
       __SCREAMING_SNAKE_CASE :			Dict												=       self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           _lowerCamelCase						,							_lowerCamelCase						,							_lowerCamelCase						,							_lowerCamelCase						,							_lowerCamelCase						)

       # Generate decoder inputs
       __SCREAMING_SNAKE_CASE :			Dict												=       seq_length if not self.use_past else 1
       __SCREAMING_SNAKE_CASE :			Any												=       self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           _lowerCamelCase						,							_lowerCamelCase						,							_lowerCamelCase						,							_lowerCamelCase						,							_lowerCamelCase						)
       __SCREAMING_SNAKE_CASE :			Optional[int]												=       {f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
       __SCREAMING_SNAKE_CASE :			Optional[Any]												=       dict(**_lowerCamelCase						,							**_lowerCamelCase						)

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

        __SCREAMING_SNAKE_CASE :			Any												=       torch.cat(
            [common_inputs['''decoder_attention_mask'''], torch.ones(_lowerCamelCase						,							_lowerCamelCase						)]						,							dim=1						)

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

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



      lowerCamelCase__						= _generate_dummy_inputs_for_default_and_seqaseq_lm

