





'''simple docstring'''

import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartTokenizer, MBartTokenizerFast, 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


UpperCAmelCase					:		Dict		=							get_tests_dir('fixtures/test_sentencepiece.model')


if is_torch_available():
   from transformers.models.mbart.modeling_mbart import shift_tokens_right

UpperCAmelCase					:		List[Any]		=							2_5_0_0_0_4
UpperCAmelCase					:		Tuple		=							2_5_0_0_2_0





@require_sentencepiece
@require_tokenizers
class lowerCamelCase						(a__						,      unittest.TestCase					):
  _lowercase  :	str       					=				MBartTokenizer
  _lowercase  :	List[Any]       					=				MBartTokenizerFast
  _lowercase  :	int       					=				True
  _lowercase  :	int       					=				True







  def 				UpperCAmelCase_				(		self		)		->						Any:






        """simple docstring"""





        super().setUp()

        # We have a SentencePiece fixture for testing
        _snake_case		:	str					     =     MBartTokenizer(lowercase__     ,     keep_accents=lowercase__		)
        tokenizer.save_pretrained(self.tmpdirname		)







  def 				UpperCAmelCase_				(		self		)		->						List[str]:






        """simple docstring"""





        _snake_case		:	Tuple					     =     MBartTokenizer(lowercase__     ,     keep_accents=lowercase__		)

        _snake_case		:	Dict					     =     tokenizer.tokenize('''This is a test'''		)
        self.assertListEqual(lowercase__     ,     ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']		)

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

        _snake_case		:	List[str]					     =     tokenizer.tokenize('''I was born in 92000, and this is falsé.'''		)
        self.assertListEqual(
            lowercase__     ,     [
                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''',
                '''é''',
                '''.''',
            ]     ,     )
        _snake_case		:	str					     =     tokenizer.convert_tokens_to_ids(lowercase__		)
        self.assertListEqual(
            lowercase__     ,     [
                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]
                #                                       ^ unk: 2 + 1 = 3                  unk: 2 + 1 = 3 ^
            ]     ,     )

        _snake_case		:	Tuple					     =     tokenizer.convert_ids_to_tokens(lowercase__		)
        self.assertListEqual(
            lowercase__     ,     [
                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		)		->						Any:






        """simple docstring"""





        if not self.test_slow_tokenizer:
              # as we don't have a slow version, we can't compare the outputs between slow and fast versions
              return

        _snake_case		:	Any					     =     (self.rust_tokenizer_class, '''hf-internal-testing/tiny-random-mbart''', {})
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
              with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''		):
                    _snake_case		:	Tuple					     =     self.rust_tokenizer_class.from_pretrained(lowercase__     ,     **lowercase__		)
                    _snake_case		:	List[Any]					     =     self.tokenizer_class.from_pretrained(lowercase__     ,     **lowercase__		)

                    _snake_case		:	Dict					     =     tempfile.mkdtemp()

                    _snake_case		:	int					     =     tokenizer_r.save_pretrained(lowercase__		)
                    _snake_case		:	Dict					     =     tokenizer_p.save_pretrained(lowercase__		)

                    # 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		)		)
                    _snake_case		:	Any					     =     tuple(f for f in tokenizer_r_files if '''tokenizer.json''' not in f		)
                    self.assertSequenceEqual(lowercase__     ,     lowercase__		)

                    # Checks everything loads correctly in the same way
                    _snake_case		:	Tuple					     =     tokenizer_r.from_pretrained(lowercase__		)
                    _snake_case		:	List[str]					     =     tokenizer_p.from_pretrained(lowercase__		)

                    # Check special tokens are set accordingly on Rust and Python
                    for key in tokenizer_pp.special_tokens_map:
                          self.assertTrue(hasattr(lowercase__     ,     lowercase__		)		)
                          # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
                          # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

                    shutil.rmtree(lowercase__		)

                    # Save tokenizer rust, legacy_format=True
                    _snake_case		:	Tuple					     =     tempfile.mkdtemp()

                    _snake_case		:	List[str]					     =     tokenizer_r.save_pretrained(lowercase__     ,     legacy_format=lowercase__		)
                    _snake_case		:	Any					     =     tokenizer_p.save_pretrained(lowercase__		)

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

                    # Checks everything loads correctly in the same way
                    _snake_case		:	Union[str, Any]					     =     tokenizer_r.from_pretrained(lowercase__		)
                    _snake_case		:	Dict					     =     tokenizer_p.from_pretrained(lowercase__		)

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

                    shutil.rmtree(lowercase__		)

                    # Save tokenizer rust, legacy_format=False
                    _snake_case		:	List[str]					     =     tempfile.mkdtemp()

                    _snake_case		:	List[Any]					     =     tokenizer_r.save_pretrained(lowercase__     ,     legacy_format=lowercase__		)
                    _snake_case		:	str					     =     tokenizer_p.save_pretrained(lowercase__		)

                    # 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
                    _snake_case		:	str					     =     tokenizer_r.from_pretrained(lowercase__		)
                    _snake_case		:	Tuple					     =     tokenizer_p.from_pretrained(lowercase__		)

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

                    shutil.rmtree(lowercase__		)





@require_torch
@require_sentencepiece
@require_tokenizers
class lowerCamelCase						(unittest.TestCase					):
  _lowercase  :	Any       					=				"""facebook/mbart-large-en-ro"""
  _lowercase  :	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.""",
  ]
  _lowercase  :	Union[str, Any]       					=				[
      """Ş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.""",
  ]
  _lowercase  :	Any       					=				[8_274, 127_873, 25_916, 7, 8_622, 2_071, 438, 67_485, 53, 187_895, 23, 51_712, 2, EN_CODE]







  @classmethod
  def 				UpperCAmelCase_				(		cls		)		->						Dict:






        """simple docstring"""





        _snake_case		:	MBartTokenizer					     =     MBartTokenizer.from_pretrained(
            cls.checkpoint_name     ,     src_lang='''en_XX'''     ,     tgt_lang='''ro_RO'''		)
        _snake_case		:	int					     =     1
        return cls







  def 				UpperCAmelCase_				(		self		)		->						Dict:






        """simple docstring"""





        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ar_AR''']     ,     250_001		)
        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''en_EN''']     ,     250_004		)
        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ro_RO''']     ,     250_020		)







  def 				UpperCAmelCase_				(		self		)		->						str:






        """simple docstring"""





        _snake_case		:	Dict					     =     self.tokenizer.batch_encode_plus(self.src_text		).input_ids[0]
        self.assertListEqual(self.expected_src_tokens     ,     lowercase__		)







  def 				UpperCAmelCase_				(		self		)		->						List[str]:






        """simple docstring"""





        self.assertIn(lowercase__     ,     self.tokenizer.all_special_ids		)
        _snake_case		:	Dict					     =     [RO_CODE, 884, 9_019, 96, 9, 916, 86_792, 36, 18_743, 15_596, 5, 2]
        _snake_case		:	str					     =     self.tokenizer.decode(lowercase__     ,     skip_special_tokens=lowercase__		)
        _snake_case		:	Tuple					     =     self.tokenizer.decode(generated_ids[1:]     ,     skip_special_tokens=lowercase__		)
        self.assertEqual(lowercase__     ,     lowercase__		)
        self.assertNotIn(self.tokenizer.eos_token     ,     lowercase__		)







  def 				UpperCAmelCase_				(		self		)		->						Union[str, Any]:






        """simple docstring"""





        _snake_case		:	Tuple					     =     ['''this is gunna be a long sentence ''' * 20]
        assert isinstance(src_text[0]     ,     lowercase__		)
        _snake_case		:	str					     =     10
        _snake_case		:	Dict					     =     self.tokenizer(lowercase__     ,     max_length=lowercase__     ,     truncation=lowercase__		).input_ids[0]
        self.assertEqual(ids[-2]     ,     2		)
        self.assertEqual(ids[-1]     ,     lowercase__		)
        self.assertEqual(len(lowercase__		)     ,     lowercase__		)







  def 				UpperCAmelCase_				(		self		)		->						Any:






        """simple docstring"""





        self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['''<mask>''', '''ar_AR''']		)     ,     [250_026, 250_001]		)







  def 				UpperCAmelCase_				(		self		)		->						List[Any]:






        """simple docstring"""





        _snake_case		:	Tuple					     =     tempfile.mkdtemp()
        _snake_case		:	Dict					     =     self.tokenizer.fairseq_tokens_to_ids
        self.tokenizer.save_pretrained(lowercase__		)
        _snake_case		:	Tuple					     =     MBartTokenizer.from_pretrained(lowercase__		)
        self.assertDictEqual(new_tok.fairseq_tokens_to_ids     ,     lowercase__		)







  @require_torch
  def 				UpperCAmelCase_				(		self		)		->						int:






        """simple docstring"""





        _snake_case		:	Optional[Any]					     =     self.tokenizer(self.src_text     ,     text_target=self.tgt_text     ,     padding=lowercase__     ,     return_tensors='''pt'''		)
        _snake_case		:	Union[str, Any]					     =     shift_tokens_right(batch['''labels''']     ,     self.tokenizer.pad_token_id		)

        # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
        assert batch.input_ids[1][-2:].tolist() == [2, EN_CODE]
        assert batch.decoder_input_ids[1][0].tolist() == RO_CODE
        assert batch.decoder_input_ids[1][-1] == 2
        assert batch.labels[1][-2:].tolist() == [2, RO_CODE]







  @require_torch
  def 				UpperCAmelCase_				(		self		)		->						str:






        """simple docstring"""





        _snake_case		:	Tuple					     =     self.tokenizer(
            self.src_text     ,     text_target=self.tgt_text     ,     padding=lowercase__     ,     truncation=lowercase__     ,     max_length=len(self.expected_src_tokens		)     ,     return_tensors='''pt'''     ,     )

        _snake_case		:	Optional[int]					     =     shift_tokens_right(batch['''labels''']     ,     self.tokenizer.pad_token_id		)

        self.assertIsInstance(lowercase__     ,     lowercase__		)

        self.assertEqual((2, 14)     ,     batch.input_ids.shape		)
        self.assertEqual((2, 14)     ,     batch.attention_mask.shape		)
        _snake_case		:	List[Any]					     =     batch.input_ids.tolist()[0]
        self.assertListEqual(self.expected_src_tokens     ,     lowercase__		)
        self.assertEqual(2     ,     batch.decoder_input_ids[0, -1]		)  # EOS
        # Test that special tokens are reset
        self.assertEqual(self.tokenizer.prefix_tokens     ,     []		)
        self.assertEqual(self.tokenizer.suffix_tokens     ,     [self.tokenizer.eos_token_id, EN_CODE]		)







  def 				UpperCAmelCase_				(		self		)		->						Union[str, Any]:






        """simple docstring"""





        _snake_case		:	Dict					     =     self.tokenizer(self.src_text     ,     padding=lowercase__     ,     truncation=lowercase__     ,     max_length=3     ,     return_tensors='''pt'''		)
        _snake_case		:	Tuple					     =     self.tokenizer(
            text_target=self.tgt_text     ,     padding=lowercase__     ,     truncation=lowercase__     ,     max_length=10     ,     return_tensors='''pt'''		)
        _snake_case		:	Any					     =     targets['''input_ids''']
        _snake_case		:	Dict					     =     shift_tokens_right(lowercase__     ,     self.tokenizer.pad_token_id		)

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







  @require_torch
  def 				UpperCAmelCase_				(		self		)		->						Dict:






        """simple docstring"""





        _snake_case		:	List[Any]					     =     self.tokenizer._build_translation_inputs(
            '''A test'''     ,     return_tensors='''pt'''     ,     src_lang='''en_XX'''     ,     tgt_lang='''ar_AR'''		)

        self.assertEqual(
            nested_simplify(lowercase__		)     ,     {
                # A, test, EOS, en_XX
                '''input_ids''': [[62, 3_034, 2, 250_004]],
                '''attention_mask''': [[1, 1, 1, 1]],
                # ar_AR
                '''forced_bos_token_id''': 250_001,
            }     ,     )









'''simple docstring'''

from __future__ import annotations

import unittest

from transformers import is_tf_available, is_torch_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, SMALL_MODEL_IDENTIFIER, is_pt_tf_cross_test, slow


if is_tf_available():
   from transformers import (
       AutoConfig,
       BertConfig,
       GPTaConfig,
       TaConfig,
       TFAutoModel,
       TFAutoModelForCausalLM,
       TFAutoModelForMaskedLM,
       TFAutoModelForPreTraining,
       TFAutoModelForQuestionAnswering,
       TFAutoModelForSeqaSeqLM,
       TFAutoModelForSequenceClassification,
       TFAutoModelWithLMHead,
       TFBertForMaskedLM,
       TFBertForPreTraining,
       TFBertForQuestionAnswering,
       TFBertForSequenceClassification,
       TFBertModel,
       TFGPTaLMHeadModel,
       TFRobertaForMaskedLM,
       TFTaForConditionalGeneration,
   )
   from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
   from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
   from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST

if is_torch_available():
   from transformers import (
       AutoModel,
       AutoModelForCausalLM,
       AutoModelForMaskedLM,
       AutoModelForPreTraining,
       AutoModelForQuestionAnswering,
       AutoModelForSeqaSeqLM,
       AutoModelForSequenceClassification,
       AutoModelWithLMHead,
       BertForMaskedLM,
       BertForPreTraining,
       BertForQuestionAnswering,
       BertForSequenceClassification,
       BertModel,
       GPTaLMHeadModel,
       RobertaForMaskedLM,
       TaForConditionalGeneration,
   )





@is_pt_tf_cross_test
class lowerCamelCase						(unittest.TestCase					):







  @slow
  def 				UpperCAmelCase_				(		self		)		->						List[Any]:






        """simple docstring"""





        for model_name in ["bert-base-uncased"]:
              _snake_case		:	Union[str, Any]					     =     AutoConfig.from_pretrained(lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	Any					     =     TFAutoModel.from_pretrained(lowercase__     ,     from_pt=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	str					     =     AutoModel.from_pretrained(lowercase__     ,     from_tf=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)







  @slow
  def 				UpperCAmelCase_				(		self		)		->						List[str]:






        """simple docstring"""





        for model_name in ["bert-base-uncased"]:
              _snake_case		:	Optional[Any]					     =     AutoConfig.from_pretrained(lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	Dict					     =     TFAutoModelForPreTraining.from_pretrained(lowercase__     ,     from_pt=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	Tuple					     =     AutoModelForPreTraining.from_pretrained(lowercase__     ,     from_tf=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)







  @slow
  def 				UpperCAmelCase_				(		self		)		->						Union[str, Any]:






        """simple docstring"""





        for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              _snake_case		:	Optional[int]					     =     AutoConfig.from_pretrained(lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	List[Any]					     =     TFAutoModelForCausalLM.from_pretrained(lowercase__     ,     from_pt=lowercase__		)
              _snake_case     ,							_snake_case		:	Tuple					     =     TFAutoModelForCausalLM.from_pretrained(
                  lowercase__     ,     output_loading_info=lowercase__     ,     from_pt=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	Optional[int]					     =     AutoModelForCausalLM.from_pretrained(lowercase__     ,     from_tf=lowercase__		)
              _snake_case     ,							_snake_case		:	Optional[Any]					     =     AutoModelForCausalLM.from_pretrained(
                  lowercase__     ,     output_loading_info=lowercase__     ,     from_tf=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)







  @slow
  def 				UpperCAmelCase_				(		self		)		->						Optional[Any]:






        """simple docstring"""





        for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              _snake_case		:	List[Any]					     =     AutoConfig.from_pretrained(lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	Tuple					     =     TFAutoModelWithLMHead.from_pretrained(lowercase__     ,     from_pt=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	int					     =     AutoModelWithLMHead.from_pretrained(lowercase__     ,     from_tf=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)







  @slow
  def 				UpperCAmelCase_				(		self		)		->						Any:






        """simple docstring"""





        for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              _snake_case		:	List[str]					     =     AutoConfig.from_pretrained(lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	Union[str, Any]					     =     TFAutoModelForMaskedLM.from_pretrained(lowercase__     ,     from_pt=lowercase__		)
              _snake_case     ,							_snake_case		:	List[str]					     =     TFAutoModelForMaskedLM.from_pretrained(
                  lowercase__     ,     output_loading_info=lowercase__     ,     from_pt=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	int					     =     AutoModelForMaskedLM.from_pretrained(lowercase__     ,     from_tf=lowercase__		)
              _snake_case     ,							_snake_case		:	Optional[int]					     =     AutoModelForMaskedLM.from_pretrained(
                  lowercase__     ,     output_loading_info=lowercase__     ,     from_tf=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)







  @slow
  def 				UpperCAmelCase_				(		self		)		->						List[str]:






        """simple docstring"""





        for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              _snake_case		:	List[str]					     =     AutoConfig.from_pretrained(lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	Tuple					     =     TFAutoModelForSeqaSeqLM.from_pretrained(lowercase__     ,     from_pt=lowercase__		)
              _snake_case     ,							_snake_case		:	List[str]					     =     TFAutoModelForSeqaSeqLM.from_pretrained(
                  lowercase__     ,     output_loading_info=lowercase__     ,     from_pt=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	List[str]					     =     AutoModelForSeqaSeqLM.from_pretrained(lowercase__     ,     from_tf=lowercase__		)
              _snake_case     ,							_snake_case		:	Dict					     =     AutoModelForSeqaSeqLM.from_pretrained(
                  lowercase__     ,     output_loading_info=lowercase__     ,     from_tf=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)







  @slow
  def 				UpperCAmelCase_				(		self		)		->						Dict:






        """simple docstring"""





        for model_name in ["bert-base-uncased"]:
              _snake_case		:	Any					     =     AutoConfig.from_pretrained(lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	Any					     =     TFAutoModelForSequenceClassification.from_pretrained(lowercase__     ,     from_pt=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	Dict					     =     AutoModelForSequenceClassification.from_pretrained(lowercase__     ,     from_tf=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)







  @slow
  def 				UpperCAmelCase_				(		self		)		->						Optional[int]:






        """simple docstring"""





        for model_name in ["bert-base-uncased"]:
              _snake_case		:	str					     =     AutoConfig.from_pretrained(lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	str					     =     TFAutoModelForQuestionAnswering.from_pretrained(lowercase__     ,     from_pt=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)

              _snake_case		:	Union[str, Any]					     =     AutoModelForQuestionAnswering.from_pretrained(lowercase__     ,     from_tf=lowercase__		)
              self.assertIsNotNone(lowercase__		)
              self.assertIsInstance(lowercase__     ,     lowercase__		)







  def 				UpperCAmelCase_				(		self		)		->						str:






        """simple docstring"""





        _snake_case		:	Union[str, Any]					     =     TFAutoModelWithLMHead.from_pretrained(lowercase__     ,     from_pt=lowercase__		)
        self.assertIsInstance(lowercase__     ,     lowercase__		)
        self.assertEqual(model.num_parameters()     ,     14_410		)
        self.assertEqual(model.num_parameters(only_trainable=lowercase__		)     ,     14_410		)

        _snake_case		:	Tuple					     =     AutoModelWithLMHead.from_pretrained(lowercase__     ,     from_tf=lowercase__		)
        self.assertIsInstance(lowercase__     ,     lowercase__		)
        self.assertEqual(model.num_parameters()     ,     14_410		)
        self.assertEqual(model.num_parameters(only_trainable=lowercase__		)     ,     14_410		)







  def 				UpperCAmelCase_				(		self		)		->						str:






        """simple docstring"""





        _snake_case		:	List[str]					     =     TFAutoModelWithLMHead.from_pretrained(lowercase__     ,     from_pt=lowercase__		)
        self.assertIsInstance(lowercase__     ,     lowercase__		)
        self.assertEqual(model.num_parameters()     ,     14_410		)
        self.assertEqual(model.num_parameters(only_trainable=lowercase__		)     ,     14_410		)

        _snake_case		:	int					     =     AutoModelWithLMHead.from_pretrained(lowercase__     ,     from_tf=lowercase__		)
        self.assertIsInstance(lowercase__     ,     lowercase__		)
        self.assertEqual(model.num_parameters()     ,     14_410		)
        self.assertEqual(model.num_parameters(only_trainable=lowercase__		)     ,     14_410		)


