





import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    is_torch_available,
)
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


snake_case 				=       get_tests_dir("""fixtures/test_sentencepiece.model""")


if is_torch_available():
      from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

snake_case 				=       2_5_6_0_4_7
snake_case 				=       2_5_6_1_4_5





@require_sentencepiece
@require_tokenizers
class 				A_				(      UpperCAmelCase					,	unittest.TestCase	):







       """simple docstring"""





       SCREAMING_SNAKE_CASE_      : Optional[Any]      =  NllbTokenizer
       SCREAMING_SNAKE_CASE_      : Dict      =  NllbTokenizerFast
       SCREAMING_SNAKE_CASE_      : Optional[Any]      =  True
       SCREAMING_SNAKE_CASE_      : Dict      =  True
       SCREAMING_SNAKE_CASE_      : Optional[int]      =  {}







       def    __UpperCAmelCase (    self	:	Dict  )						->					Union[str, Any]:
         super().setUp()

         # We have a SentencePiece fixture for testing
         _lowercase							= NllbTokenizer(__A						,keep_accents=__A  )
         tokenizer.save_pretrained(self.tmpdirname  )







       def    __UpperCAmelCase (    self	:	List[str]  )						->					Optional[Any]:
         _lowercase							= NllbTokenizer(__A						,keep_accents=__A  )

         _lowercase							= tokenizer.tokenize('This is a test'  )
         self.assertListEqual(__A						,['▁This', '▁is', '▁a', '▁t', 'est']  )

         self.assertListEqual(
             tokenizer.convert_tokens_to_ids(__A  )						,[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]						,)

         _lowercase							= tokenizer.tokenize('I was born in 92000, and this is falsé.'  )
         self.assertListEqual(
             __A						,[
                 SPIECE_UNDERLINE + 'I',
                 SPIECE_UNDERLINE + 'was',
                 SPIECE_UNDERLINE + 'b',
                 'or',
                 'n',
                 SPIECE_UNDERLINE + 'in',
                 SPIECE_UNDERLINE + '',
                 '9',
                 '2',
                 '0',
                 '0',
                 '0',
                 ',',
                 SPIECE_UNDERLINE + 'and',
                 SPIECE_UNDERLINE + 'this',
                 SPIECE_UNDERLINE + 'is',
                 SPIECE_UNDERLINE + 'f',
                 'al',
                 's',
                 'é',
                 '.',
             ]						,)
         _lowercase							= tokenizer.convert_tokens_to_ids(__A  )
         self.assertListEqual(
             __A						,[
                 value + tokenizer.fairseq_offset
                 for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
             ]						,)

         _lowercase							= tokenizer.convert_ids_to_tokens(__A  )
         self.assertListEqual(
             __A						,[
                 SPIECE_UNDERLINE + 'I',
                 SPIECE_UNDERLINE + 'was',
                 SPIECE_UNDERLINE + 'b',
                 'or',
                 'n',
                 SPIECE_UNDERLINE + 'in',
                 SPIECE_UNDERLINE + '',
                 '<unk>',
                 '2',
                 '0',
                 '0',
                 '0',
                 ',',
                 SPIECE_UNDERLINE + 'and',
                 SPIECE_UNDERLINE + 'this',
                 SPIECE_UNDERLINE + 'is',
                 SPIECE_UNDERLINE + 'f',
                 'al',
                 's',
                 '<unk>',
                 '.',
             ]						,)







       def    __UpperCAmelCase (    self	:	Dict  )						->					str:
         _lowercase							= (self.rust_tokenizer_class, 'hf-internal-testing/tiny-random-nllb', {})
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""  ):
             _lowercase							= self.rust_tokenizer_class.from_pretrained(__A						,**__A  )
             _lowercase							= self.tokenizer_class.from_pretrained(__A						,**__A  )

             _lowercase							= tempfile.mkdtemp()

             _lowercase							= tokenizer_r.save_pretrained(__A  )
             _lowercase							= tokenizer_p.save_pretrained(__A  )

             # Checks it save with the same files + the tokenizer.json file for the fast one
             self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files  )  )
             _lowercase							= tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f  )
             self.assertSequenceEqual(__A						,__A  )

             # Checks everything loads correctly in the same way
             _lowercase							= tokenizer_r.from_pretrained(__A  )
             _lowercase							= tokenizer_p.from_pretrained(__A  )

             # Check special tokens are set accordingly on Rust and Python
             for key in tokenizer_pp.special_tokens_map:
               self.assertTrue(hasattr(__A						,__A  )  )

             shutil.rmtree(__A  )

             # Save tokenizer rust, legacy_format=True
             _lowercase							= tempfile.mkdtemp()

             _lowercase							= tokenizer_r.save_pretrained(__A						,legacy_format=__A  )
             _lowercase							= tokenizer_p.save_pretrained(__A  )

             # Checks it save with the same files
             self.assertSequenceEqual(__A						,__A  )

             # Checks everything loads correctly in the same way
             _lowercase							= tokenizer_r.from_pretrained(__A  )
             _lowercase							= tokenizer_p.from_pretrained(__A  )

             # Check special tokens are set accordingly on Rust and Python
             for key in tokenizer_pp.special_tokens_map:
               self.assertTrue(hasattr(__A						,__A  )  )

             shutil.rmtree(__A  )

             # Save tokenizer rust, legacy_format=False
             _lowercase							= tempfile.mkdtemp()

             _lowercase							= tokenizer_r.save_pretrained(__A						,legacy_format=__A  )
             _lowercase							= tokenizer_p.save_pretrained(__A  )

             # Checks it saved the tokenizer.json file
             self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files  )  )

             # Checks everything loads correctly in the same way
             _lowercase							= tokenizer_r.from_pretrained(__A  )
             _lowercase							= tokenizer_p.from_pretrained(__A  )

             # Check special tokens are set accordingly on Rust and Python
             for key in tokenizer_pp.special_tokens_map:
               self.assertTrue(hasattr(__A						,__A  )  )

             shutil.rmtree(__A  )







       @require_torch
       def    __UpperCAmelCase (    self	:	str  )						->					Any:
         if not self.test_seqaseq:
           return

         _lowercase							= self.get_tokenizers()
         for tokenizer in tokenizers:
           with self.subTest(F"""{tokenizer.__class__.__name__}"""  ):
             # Longer text that will definitely require truncation.
             _lowercase							= [
                 ' UN Chief Says There Is No Military Solution in Syria',
                 ' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for'
                 ' Syria is that \'there is no military solution\' to the nearly five-year conflict and more weapons'
                 ' will only worsen the violence and misery for millions of people.',
             ]
             _lowercase							= [
                 'Şeful ONU declară că nu există o soluţie militară în Siria',
                 'Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al'
                 ' Rusiei pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi'
                 ' că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.',
             ]
             try:
               _lowercase							= tokenizer.prepare_seqaseq_batch(
                   src_texts=__A						,tgt_texts=__A						,max_length=3						,max_target_length=10						,return_tensors='pt'						,src_lang='eng_Latn'						,tgt_lang='ron_Latn'						,)
             except NotImplementedError:
               return
             self.assertEqual(batch.input_ids.shape[1]						,3  )
             self.assertEqual(batch.labels.shape[1]						,10  )
             # max_target_length will default to max_length if not specified
             _lowercase							= tokenizer.prepare_seqaseq_batch(
                 __A						,tgt_texts=__A						,max_length=3						,return_tensors='pt'  )
             self.assertEqual(batch.input_ids.shape[1]						,3  )
             self.assertEqual(batch.labels.shape[1]						,3  )

             _lowercase							= tokenizer.prepare_seqaseq_batch(
                 src_texts=__A						,max_length=3						,max_target_length=10						,return_tensors='pt'  )
             self.assertEqual(batch_encoder_only.input_ids.shape[1]						,3  )
             self.assertEqual(batch_encoder_only.attention_mask.shape[1]						,3  )
             self.assertNotIn('decoder_input_ids'						,__A  )







       @unittest.skip('Unfortunately way too slow to build a BPE with SentencePiece.'  )
       def    __UpperCAmelCase (    self	:	Any  )						->					Optional[int]:
         pass







       def    __UpperCAmelCase (    self	:	Union[str, Any]  )						->					Any:
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""  ):
             _lowercase							= [AddedToken('<special>'						,lstrip=__A  )]

             _lowercase							= self.rust_tokenizer_class.from_pretrained(
                 __A						,additional_special_tokens=__A						,**__A  )
             _lowercase							= tokenizer_r.encode('Hey this is a <special> token'  )

             _lowercase							= tokenizer_r.encode('<special>'						,add_special_tokens=__A  )[0]

             self.assertTrue(special_token_id in r_output  )

             if self.test_slow_tokenizer:
               _lowercase							= self.rust_tokenizer_class.from_pretrained(
                   __A						,additional_special_tokens=__A						,**__A						,)
               _lowercase							= self.tokenizer_class.from_pretrained(
                   __A						,additional_special_tokens=__A						,**__A  )

               _lowercase							= tokenizer_p.encode('Hey this is a <special> token'  )

               _lowercase							= tokenizer_cr.encode('Hey this is a <special> token'  )

               self.assertEqual(__A						,__A  )
               self.assertEqual(__A						,__A  )
               self.assertTrue(special_token_id in p_output  )
               self.assertTrue(special_token_id in cr_output  )





@require_torch
@require_sentencepiece
@require_tokenizers
class 				A_				(      unittest.TestCase	):







       """simple docstring"""





       SCREAMING_SNAKE_CASE_      : Any      =  '''facebook/nllb-200-distilled-600M'''
       SCREAMING_SNAKE_CASE_      : str      =  [
           ''' UN Chief Says There Is No Military Solution in Syria''',
           ''' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for Syria is that "there is no military solution" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.''',
       ]
       SCREAMING_SNAKE_CASE_      : List[str]      =  [
           '''Şeful ONU declară că nu există o soluţie militară în Siria''',
           '''Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei'''
           ''' pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi că noi arme nu vor'''
           ''' face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.''',
       ]
       SCREAMING_SNAKE_CASE_      : List[Any]      =  [
           2_5_6_0_4_7,
           1_6_2_9_7,
           1_3_4_4_0_8,
           8_1_6_5,
           2_4_8_0_6_6,
           1_4_7_3_4,
           9_5_0,
           1_1_3_5,
           1_0_5_7_2_1,
           3_5_7_3,
           8_3,
           2_7_3_5_2,
           1_0_8,
           4_9_4_8_6,
           2,
       ]







       @classmethod
       def    __UpperCAmelCase (    cls	:	List[Any]  )						->					Tuple:
         _lowercase							= NllbTokenizer.from_pretrained(
             cls.checkpoint_name						,src_lang='eng_Latn'						,tgt_lang='ron_Latn'  )
         _lowercase							= 1
         return cls







       def    __UpperCAmelCase (    self	:	Union[str, Any]  )						->					Optional[int]:
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Arab']						,25_6001  )
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Latn']						,25_6002  )
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['fra_Latn']						,25_6057  )







       def    __UpperCAmelCase (    self	:	Any  )						->					int:
         _lowercase							= self.tokenizer.batch_encode_plus(self.src_text  ).input_ids[0]
         self.assertListEqual(self.expected_src_tokens						,__A  )







       def    __UpperCAmelCase (    self	:	Optional[int]  )						->					Optional[int]:
         self.assertIn(__A						,self.tokenizer.all_special_ids  )
         # fmt: off
         _lowercase							= [RO_CODE, 4254, 9_8068, 11_2923, 3_9072, 3909, 713, 10_2767, 26, 1_7314, 3_5642, 1_4683, 3_3118, 2022, 6_6987, 2, 25_6047]
         # fmt: on

         _lowercase							= self.tokenizer.decode(__A						,skip_special_tokens=__A  )
         _lowercase							= self.tokenizer.decode(generated_ids[1:]						,skip_special_tokens=__A  )
         self.assertEqual(__A						,__A  )
         self.assertNotIn(self.tokenizer.eos_token						,__A  )







       def    __UpperCAmelCase (    self	:	Optional[Any]  )						->					int:
         _lowercase							= ['this is gunna be a long sentence ' * 20]
         assert isinstance(src_text[0]						,__A  )
         _lowercase							= 10
         _lowercase							= self.tokenizer(__A						,max_length=__A						,truncation=__A  ).input_ids[0]
         self.assertEqual(ids[-1]						,2  )
         self.assertEqual(ids[0]						,__A  )
         self.assertEqual(len(__A  )						,__A  )







       def    __UpperCAmelCase (    self	:	List[Any]  )						->					List[str]:
         self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR']  )						,[25_6203, 3]  )







       def    __UpperCAmelCase (    self	:	int  )						->					Union[str, Any]:
         _lowercase							= tempfile.mkdtemp()
         _lowercase							= self.tokenizer.fairseq_tokens_to_ids
         self.tokenizer.save_pretrained(__A  )
         _lowercase							= NllbTokenizer.from_pretrained(__A  )
         self.assertDictEqual(new_tok.fairseq_tokens_to_ids						,__A  )







       @require_torch
       def    __UpperCAmelCase (    self	:	str  )						->					List[Any]:
         _lowercase							= self.tokenizer(
             self.src_text						,text_target=self.tgt_text						,padding=__A						,truncation=__A						,max_length=len(self.expected_src_tokens  )						,return_tensors='pt'						,)
         _lowercase							= shift_tokens_right(
             batch['labels']						,self.tokenizer.pad_token_id						,self.tokenizer.lang_code_to_id['ron_Latn']  )

         self.assertIsInstance(__A						,__A  )

         self.assertEqual((2, 15)						,batch.input_ids.shape  )
         self.assertEqual((2, 15)						,batch.attention_mask.shape  )
         _lowercase							= batch.input_ids.tolist()[0]
         self.assertListEqual(self.expected_src_tokens						,__A  )
         self.assertEqual(__A						,batch.decoder_input_ids[0, 0]  )  # EOS
         # Test that special tokens are reset
         self.assertEqual(self.tokenizer.prefix_tokens						,[EN_CODE]  )
         self.assertEqual(self.tokenizer.suffix_tokens						,[self.tokenizer.eos_token_id]  )







       def    __UpperCAmelCase (    self	:	Dict  )						->					Any:
         _lowercase							= self.tokenizer(self.src_text						,padding=__A						,truncation=__A						,max_length=3						,return_tensors='pt'  )
         _lowercase							= self.tokenizer(
             text_target=self.tgt_text						,padding=__A						,truncation=__A						,max_length=10						,return_tensors='pt'  )
         _lowercase							= targets['input_ids']
         _lowercase							= shift_tokens_right(
             __A						,self.tokenizer.pad_token_id						,decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang]						,)

         self.assertEqual(batch.input_ids.shape[1]						,3  )
         self.assertEqual(batch.decoder_input_ids.shape[1]						,10  )







       @require_torch
       def    __UpperCAmelCase (    self	:	Tuple  )						->					Optional[int]:
         _lowercase							= self.tokenizer._build_translation_inputs(
             'A test'						,return_tensors='pt'						,src_lang='eng_Latn'						,tgt_lang='fra_Latn'  )

         self.assertEqual(
             nested_simplify(__A  )						,{
                 # A, test, EOS, en_XX
                 'input_ids': [[25_6047, 70, 7356, 2]],
                 'attention_mask': [[1, 1, 1, 1]],
                 # ar_AR
                 'forced_bos_token_id': 25_6057,
             }						,)







       @require_torch
       def    __UpperCAmelCase (    self	:	List[Any]  )						->					int:
         _lowercase							= True
         _lowercase							= self.tokenizer(
             'UN Chief says there is no military solution in Syria'						,src_lang='eng_Latn'						,tgt_lang='fra_Latn'  )
         self.assertEqual(
             inputs.input_ids						,[1_6297, 13_4408, 2_5653, 6370, 248, 254, 10_3929, 9_4995, 108, 4_9486, 2, 25_6047]  )

         _lowercase							= False
         _lowercase							= self.tokenizer(
             'UN Chief says there is no military solution in Syria'						,src_lang='eng_Latn'						,tgt_lang='fra_Latn'  )
         self.assertEqual(
             inputs.input_ids						,[25_6047, 1_6297, 13_4408, 2_5653, 6370, 248, 254, 10_3929, 9_4995, 108, 4_9486, 2]  )






import unittest

from transformers import BertGenerationConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch

      from transformers import BertGenerationDecoder, BertGenerationEncoder





class 				A_				:







       """simple docstring"""





       def __init__(    self	:	List[Any]						,__A	:	str						,__A	:	Dict=13						,__A	:	Dict=7						,__A	:	List[Any]=True						,__A	:	Union[str, Any]=True						,__A	:	Any=99						,__A	:	Optional[Any]=32						,__A	:	Any=5						,__A	:	int=4						,__A	:	Dict=37						,__A	:	Dict="gelu"						,__A	:	Union[str, Any]=0.1						,__A	:	List[Any]=0.1						,__A	:	str=50						,__A	:	str=0.02						,__A	:	str=True						,__A	:	List[Any]=None						,)						->					Optional[Any]:
         _lowercase							= parent
         _lowercase							= batch_size
         _lowercase							= seq_length
         _lowercase							= is_training
         _lowercase							= use_input_mask
         _lowercase							= vocab_size
         _lowercase							= hidden_size
         _lowercase							= num_hidden_layers
         _lowercase							= num_attention_heads
         _lowercase							= intermediate_size
         _lowercase							= hidden_act
         _lowercase							= hidden_dropout_prob
         _lowercase							= attention_probs_dropout_prob
         _lowercase							= max_position_embeddings
         _lowercase							= initializer_range
         _lowercase							= use_labels
         _lowercase							= scope







       def    __UpperCAmelCase (    self	:	int  )						->					Optional[Any]:
         _lowercase							= ids_tensor([self.batch_size, self.seq_length]						,self.vocab_size  )

         _lowercase							= None
         if self.use_input_mask:
           _lowercase							= random_attention_mask([self.batch_size, self.seq_length]  )

         if self.use_labels:
           _lowercase							= ids_tensor([self.batch_size, self.seq_length]						,self.vocab_size  )

         _lowercase							= self.get_config()

         return config, input_ids, input_mask, token_labels







       def    __UpperCAmelCase (    self	:	Optional[int]  )						->					int:
         return BertGenerationConfig(
             vocab_size=self.vocab_size						,hidden_size=self.hidden_size						,num_hidden_layers=self.num_hidden_layers						,num_attention_heads=self.num_attention_heads						,intermediate_size=self.intermediate_size						,hidden_act=self.hidden_act						,hidden_dropout_prob=self.hidden_dropout_prob						,attention_probs_dropout_prob=self.attention_probs_dropout_prob						,max_position_embeddings=self.max_position_embeddings						,is_decoder=__A						,initializer_range=self.initializer_range						,)







       def    __UpperCAmelCase (    self	:	Union[str, Any]  )						->					int:
         (
             (
             _lowercase
         )						,		(
             _lowercase
         )						,		(
             _lowercase
         )						,		(
             _lowercase
         )						,		
         )							= self.prepare_config_and_inputs()

         _lowercase							= True
         _lowercase							= floats_tensor([self.batch_size, self.seq_length, self.hidden_size]  )
         _lowercase							= ids_tensor([self.batch_size, self.seq_length]						,vocab_size=2  )

         return (
             config,
             input_ids,
             input_mask,
             token_labels,
             encoder_hidden_states,
             encoder_attention_mask,
         )







       def    __UpperCAmelCase (    self	:	Dict						,__A	:	List[Any]						,__A	:	Optional[int]						,__A	:	Optional[int]						,__A	:	int						,**__A	:	Union[str, Any]						,)						->					List[Any]:
         _lowercase							= BertGenerationEncoder(config=__A  )
         model.to(__A  )
         model.eval()
         _lowercase							= model(__A						,attention_mask=__A  )
         _lowercase							= model(__A  )
         self.parent.assertEqual(result.last_hidden_state.shape						,(self.batch_size, self.seq_length, self.hidden_size)  )







       def    __UpperCAmelCase (    self	:	List[str]						,__A	:	Optional[Any]						,__A	:	int						,__A	:	Dict						,__A	:	int						,__A	:	Tuple						,__A	:	str						,**__A	:	int						,)						->					Optional[Any]:
         _lowercase							= True
         _lowercase							= BertGenerationEncoder(config=__A  )
         model.to(__A  )
         model.eval()
         _lowercase							= model(
             __A						,attention_mask=__A						,encoder_hidden_states=__A						,encoder_attention_mask=__A						,)
         _lowercase							= model(
             __A						,attention_mask=__A						,encoder_hidden_states=__A						,)
         self.parent.assertEqual(result.last_hidden_state.shape						,(self.batch_size, self.seq_length, self.hidden_size)  )







       def    __UpperCAmelCase (    self	:	List[str]						,__A	:	List[str]						,__A	:	List[str]						,__A	:	Optional[Any]						,__A	:	List[Any]						,__A	:	Optional[int]						,__A	:	Optional[int]						,**__A	:	Dict						,)						->					List[Any]:
         _lowercase							= True
         _lowercase							= True
         _lowercase							= BertGenerationDecoder(config=__A  ).to(__A  ).eval()

         # first forward pass
         _lowercase							= model(
             __A						,attention_mask=__A						,encoder_hidden_states=__A						,encoder_attention_mask=__A						,use_cache=__A						,)
         _lowercase							= outputs.past_key_values

         # create hypothetical multiple next token and extent to next_input_ids
         _lowercase							= ids_tensor((self.batch_size, 3)						,config.vocab_size  )
         _lowercase							= ids_tensor((self.batch_size, 3)						,vocab_size=2  )

         # append to next input_ids and
         _lowercase							= torch.cat([input_ids, next_tokens]						,dim=-1  )
         _lowercase							= torch.cat([input_mask, next_mask]						,dim=-1  )

         _lowercase							= model(
             __A						,attention_mask=__A						,encoder_hidden_states=__A						,encoder_attention_mask=__A						,output_hidden_states=__A						,)['hidden_states'][0]
         _lowercase							= model(
             __A						,attention_mask=__A						,encoder_hidden_states=__A						,encoder_attention_mask=__A						,past_key_values=__A						,output_hidden_states=__A						,)['hidden_states'][0]

         # select random slice
         _lowercase							= ids_tensor((1,)						,output_from_past.shape[-1]  ).item()
         _lowercase							= output_from_no_past[:, -3:, random_slice_idx].detach()
         _lowercase							= output_from_past[:, :, random_slice_idx].detach()

         self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]  )

         # test that outputs are equal for slice
         self.parent.assertTrue(torch.allclose(__A						,__A						,atol=1e-3  )  )







       def    __UpperCAmelCase (    self	:	List[str]						,__A	:	List[str]						,__A	:	List[str]						,__A	:	List[Any]						,__A	:	List[str]						,*__A	:	List[Any]						,)						->					Tuple:
         _lowercase							= BertGenerationDecoder(__A  )
         model.to(__A  )
         model.eval()
         _lowercase							= model(__A						,attention_mask=__A						,labels=__A  )
         self.parent.assertEqual(result.logits.shape						,(self.batch_size, self.seq_length, self.vocab_size)  )







       def    __UpperCAmelCase (    self	:	List[Any]  )						->					Dict:
         _lowercase						,		_lowercase						,		_lowercase						,		_lowercase							= self.prepare_config_and_inputs()
         _lowercase							= {'input_ids': input_ids, 'attention_mask': input_mask}
         return config, inputs_dict





@require_torch
class 				A_				(      UpperCAmelCase					,	UpperCAmelCase					,	UpperCAmelCase					,	unittest.TestCase	):







       """simple docstring"""





       SCREAMING_SNAKE_CASE_      : List[str]      =  (BertGenerationEncoder, BertGenerationDecoder) if is_torch_available() else ()
       SCREAMING_SNAKE_CASE_      : Union[str, Any]      =  (BertGenerationDecoder,) if is_torch_available() else ()
       SCREAMING_SNAKE_CASE_      : Dict      =  (
           {'''feature-extraction''': BertGenerationEncoder, '''text-generation''': BertGenerationDecoder}
           if is_torch_available()
           else {}
       )







       def    __UpperCAmelCase (    self	:	Any  )						->					Union[str, Any]:
         _lowercase							= BertGenerationEncoderTester(self  )
         _lowercase							= ConfigTester(self						,config_class=__A						,hidden_size=37  )







       def    __UpperCAmelCase (    self	:	int  )						->					int:
         self.config_tester.run_common_tests()







       def    __UpperCAmelCase (    self	:	Tuple  )						->					Any:
         _lowercase							= self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__A  )







       def    __UpperCAmelCase (    self	:	Union[str, Any]  )						->					Dict:
         _lowercase						,		_lowercase						,		_lowercase						,		_lowercase							= self.model_tester.prepare_config_and_inputs()
         _lowercase							= 'bert'
         self.model_tester.create_and_check_model(__A						,__A						,__A						,__A  )







       def    __UpperCAmelCase (    self	:	Tuple  )						->					List[Any]:
         _lowercase							= self.model_tester.prepare_config_and_inputs_for_decoder()
         self.model_tester.create_and_check_model_as_decoder(*__A  )







       def    __UpperCAmelCase (    self	:	Tuple  )						->					Union[str, Any]:
         _lowercase							= self.model_tester.prepare_config_and_inputs_for_decoder()
         self.model_tester.create_and_check_decoder_model_past_large_inputs(*__A  )







       def    __UpperCAmelCase (    self	:	Any  )						->					Union[str, Any]:
         # This regression test was failing with PyTorch < 1.3
         (
             (
             _lowercase
         )						,		(
             _lowercase
         )						,		(
             _lowercase
         )						,		(
             _lowercase
         )						,		(
             _lowercase
         )						,		(
             _lowercase
         )						,		
         )							= self.model_tester.prepare_config_and_inputs_for_decoder()

         _lowercase							= None

         self.model_tester.create_and_check_model_as_decoder(
             __A						,__A						,__A						,__A						,__A						,__A						,)







       def    __UpperCAmelCase (    self	:	Optional[Any]  )						->					Union[str, Any]:
         _lowercase							= self.model_tester.prepare_config_and_inputs_for_decoder()
         self.model_tester.create_and_check_for_causal_lm(*__A  )







       @slow
       def    __UpperCAmelCase (    self	:	List[Any]  )						->					str:
         _lowercase							= BertGenerationEncoder.from_pretrained('google/bert_for_seq_generation_L-24_bbc_encoder'  )
         self.assertIsNotNone(__A  )





@require_torch
class 				A_				(      unittest.TestCase	):







       """simple docstring"""





       @slow
       def    __UpperCAmelCase (    self	:	Tuple  )						->					Union[str, Any]:
         _lowercase							= BertGenerationEncoder.from_pretrained('google/bert_for_seq_generation_L-24_bbc_encoder'  )
         _lowercase							= torch.tensor([[101, 7592, 1010, 2026, 3899, 2003, 1_0140, 102]]  )
         with torch.no_grad():
           _lowercase							= model(__A  )[0]
         _lowercase							= torch.Size([1, 8, 1024]  )
         self.assertEqual(output.shape						,__A  )
         _lowercase							= torch.tensor(
             [[[0.1775, 0.0083, -0.0321], [1.6002, 0.1287, 0.3912], [2.1473, 0.5791, 0.6066]]]  )
         self.assertTrue(torch.allclose(output[:, :3, :3]						,__A						,atol=1e-4  )  )





@require_torch
class 				A_				(      unittest.TestCase	):







       """simple docstring"""





       @slow
       def    __UpperCAmelCase (    self	:	Optional[Any]  )						->					Union[str, Any]:
         _lowercase							= BertGenerationDecoder.from_pretrained('google/bert_for_seq_generation_L-24_bbc_encoder'  )
         _lowercase							= torch.tensor([[101, 7592, 1010, 2026, 3899, 2003, 1_0140, 102]]  )
         with torch.no_grad():
           _lowercase							= model(__A  )[0]
         _lowercase							= torch.Size([1, 8, 5_0358]  )
         self.assertEqual(output.shape						,__A  )
         _lowercase							= torch.tensor(
             [[[-0.5788, -2.5994, -3.7054], [0.0438, 4.7997, 1.8795], [1.5862, 6.6409, 4.4638]]]  )
         self.assertTrue(torch.allclose(output[:, :3, :3]						,__A						,atol=1e-4  )  )