


from __future__ import annotations

import copy
import tempfile
import unittest

from transformers import CONFIG_MAPPING, AutoConfig, BertConfig, GPTaConfig, TaConfig, TapasConfig, is_tf_available
from transformers.testing_utils import (
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tensorflow_probability,
    require_tf,
    slow,
)

from ..bert.test_modeling_bert import BertModelTester


if is_tf_available():
 from transformers import (
     TFAutoModel,
     TFAutoModelForCausalLM,
     TFAutoModelForMaskedLM,
     TFAutoModelForPreTraining,
     TFAutoModelForQuestionAnswering,
     TFAutoModelForSeqaSeqLM,
     TFAutoModelForSequenceClassification,
     TFAutoModelForTableQuestionAnswering,
     TFAutoModelForTokenClassification,
     TFAutoModelWithLMHead,
     TFBertForMaskedLM,
     TFBertForPreTraining,
     TFBertForQuestionAnswering,
     TFBertForSequenceClassification,
     TFBertModel,
     TFFunnelBaseModel,
     TFFunnelModel,
     TFGPTaLMHeadModel,
     TFRobertaForMaskedLM,
     TFTaForConditionalGeneration,
     TFTapasForQuestionAnswering,
 )
 from transformers.models.auto.modeling_tf_auto import (
     TF_MODEL_FOR_CAUSAL_LM_MAPPING,
     TF_MODEL_FOR_MASKED_LM_MAPPING,
     TF_MODEL_FOR_PRETRAINING_MAPPING,
     TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
     TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
     TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
     TF_MODEL_MAPPING,
 )
 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
 from transformers.models.tapas.modeling_tf_tapas import TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST

class   A__ (   snake_case__     ):







     """simple docstring"""

     __magic_name__        =		'new-model'


if is_tf_available():

 class   A__ (   snake_case__     ):







      """simple docstring"""

      __magic_name__        =		NewModelConfig

@require_tf
class   A__ (   unittest.TestCase     ):







     """simple docstring"""

     @slow
     def 		a_      (	self   ):
          snake_case					=    '''bert-base-cased'''
          snake_case					=    AutoConfig.from_pretrained(__snake_case   )
          self.assertIsNotNone(__snake_case   )
          self.assertIsInstance(__snake_case      , __snake_case   )

          snake_case					=    TFAutoModel.from_pretrained(__snake_case   )
          self.assertIsNotNone(__snake_case   )
          self.assertIsInstance(__snake_case      , __snake_case   )
     @slow
     def 		a_      (	self   ):
          snake_case					=    '''bert-base-cased'''
          snake_case					=    AutoConfig.from_pretrained(__snake_case   )
          self.assertIsNotNone(__snake_case   )
          self.assertIsInstance(__snake_case      , __snake_case   )

          snake_case					=    TFAutoModelForPreTraining.from_pretrained(__snake_case   )
          self.assertIsNotNone(__snake_case   )
          self.assertIsInstance(__snake_case      , __snake_case   )
     @slow
     def 		a_      (	self   ):
          for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               snake_case					=    AutoConfig.from_pretrained(__snake_case   )
               self.assertIsNotNone(__snake_case   )
               self.assertIsInstance(__snake_case      , __snake_case   )

               snake_case					=    TFAutoModelForCausalLM.from_pretrained(__snake_case   )
               snake_case			,  snake_case					=    TFAutoModelForCausalLM.from_pretrained(__snake_case      , output_loading_info=__snake_case   )
               self.assertIsNotNone(__snake_case   )
               self.assertIsInstance(__snake_case      , __snake_case   )
     @slow
     def 		a_      (	self   ):
          for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               snake_case					=    AutoConfig.from_pretrained(__snake_case   )
               self.assertIsNotNone(__snake_case   )
               self.assertIsInstance(__snake_case      , __snake_case   )

               snake_case					=    TFAutoModelWithLMHead.from_pretrained(__snake_case   )
               self.assertIsNotNone(__snake_case   )
               self.assertIsInstance(__snake_case      , __snake_case   )
     @slow
     def 		a_      (	self   ):
          for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               snake_case					=    AutoConfig.from_pretrained(__snake_case   )
               self.assertIsNotNone(__snake_case   )
               self.assertIsInstance(__snake_case      , __snake_case   )

               snake_case					=    TFAutoModelForMaskedLM.from_pretrained(__snake_case   )
               snake_case			,  snake_case					=    TFAutoModelForMaskedLM.from_pretrained(__snake_case      , output_loading_info=__snake_case   )
               self.assertIsNotNone(__snake_case   )
               self.assertIsInstance(__snake_case      , __snake_case   )
     @slow
     def 		a_      (	self   ):
          for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               snake_case					=    AutoConfig.from_pretrained(__snake_case   )
               self.assertIsNotNone(__snake_case   )
               self.assertIsInstance(__snake_case      , __snake_case   )

               snake_case					=    TFAutoModelForSeqaSeqLM.from_pretrained(__snake_case   )
               snake_case			,  snake_case					=    TFAutoModelForSeqaSeqLM.from_pretrained(__snake_case      , output_loading_info=__snake_case   )
               self.assertIsNotNone(__snake_case   )
               self.assertIsInstance(__snake_case      , __snake_case   )
     @slow
     def 		a_      (	self   ):
          # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          for model_name in ["bert-base-uncased"]:
               snake_case					=    AutoConfig.from_pretrained(__snake_case   )
               self.assertIsNotNone(__snake_case   )
               self.assertIsInstance(__snake_case      , __snake_case   )

               snake_case					=    TFAutoModelForSequenceClassification.from_pretrained(__snake_case   )
               self.assertIsNotNone(__snake_case   )
               self.assertIsInstance(__snake_case      , __snake_case   )
     @slow
     def 		a_      (	self   ):
          # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          for model_name in ["bert-base-uncased"]:
               snake_case					=    AutoConfig.from_pretrained(__snake_case   )
               self.assertIsNotNone(__snake_case   )
               self.assertIsInstance(__snake_case      , __snake_case   )

               snake_case					=    TFAutoModelForQuestionAnswering.from_pretrained(__snake_case   )
               self.assertIsNotNone(__snake_case   )
               self.assertIsInstance(__snake_case      , __snake_case   )
     @slow
     @require_tensorflow_probability
     def 		a_      (	self   ):
          for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
               snake_case					=    AutoConfig.from_pretrained(__snake_case   )
               self.assertIsNotNone(__snake_case   )
               self.assertIsInstance(__snake_case      , __snake_case   )

               snake_case					=    TFAutoModelForTableQuestionAnswering.from_pretrained(__snake_case   )
               snake_case			,  snake_case					=    TFAutoModelForTableQuestionAnswering.from_pretrained(
                   __snake_case      , output_loading_info=__snake_case   )
               self.assertIsNotNone(__snake_case   )
               self.assertIsInstance(__snake_case      , __snake_case   )
     def 		a_      (	self   ):
          snake_case					=    TFAutoModelWithLMHead.from_pretrained(__snake_case   )
          self.assertIsInstance(__snake_case      , __snake_case   )
          self.assertEqual(model.num_parameters()      , 1_4_4_1_0   )
          self.assertEqual(model.num_parameters(only_trainable=__snake_case   )      , 1_4_4_1_0   )
     def 		a_      (	self   ):
          snake_case					=    TFAutoModelWithLMHead.from_pretrained(__snake_case   )
          self.assertIsInstance(__snake_case      , __snake_case   )
          self.assertEqual(model.num_parameters()      , 1_4_4_1_0   )
          self.assertEqual(model.num_parameters(only_trainable=__snake_case   )      , 1_4_4_1_0   )
     def 		a_      (	self   ):
          # For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel
          snake_case					=    TFAutoModel.from_pretrained('''sgugger/funnel-random-tiny'''   )
          self.assertIsInstance(__snake_case      , __snake_case   )

          snake_case					=    copy.deepcopy(model.config   )
          snake_case					=    ['''FunnelBaseModel''']
          snake_case					=    TFAutoModel.from_config(__snake_case   )
          self.assertIsInstance(__snake_case      , __snake_case   )

          with tempfile.TemporaryDirectory() as tmp_dir:
               model.save_pretrained(__snake_case   )
               snake_case					=    TFAutoModel.from_pretrained(__snake_case   )
               self.assertIsInstance(__snake_case      , __snake_case   )
     def 		a_      (	self   ):
          try:
               AutoConfig.register('''new-model'''      , __snake_case   )

               snake_case					=    [
                   TFAutoModel,
                   TFAutoModelForCausalLM,
                   TFAutoModelForMaskedLM,
                   TFAutoModelForPreTraining,
                   TFAutoModelForQuestionAnswering,
                   TFAutoModelForSequenceClassification,
                   TFAutoModelForTokenClassification,
               ]

               for auto_class in auto_classes:
                    with self.subTest(auto_class.__name__   ):
                         # Wrong config class will raise an error
                         with self.assertRaises(__snake_case   ):
                              auto_class.register(__snake_case      , __snake_case   )
                         auto_class.register(__snake_case      , __snake_case   )
                         # Trying to register something existing in the Transformers library will raise an error
                         with self.assertRaises(__snake_case   ):
                              auto_class.register(__snake_case      , __snake_case   )

                         # Now that the config is registered, it can be used as any other config with the auto-API
                         snake_case					=    BertModelTester(self   ).get_config()
                         snake_case					=    NewModelConfig(**tiny_config.to_dict()   )
                         snake_case					=    auto_class.from_config(__snake_case   )
                         self.assertIsInstance(__snake_case      , __snake_case   )

                         with tempfile.TemporaryDirectory() as tmp_dir:
                              model.save_pretrained(__snake_case   )
                              snake_case					=    auto_class.from_pretrained(__snake_case   )
                              self.assertIsInstance(__snake_case      , __snake_case   )

          finally:
               if "new-model" in CONFIG_MAPPING._extra_content:
                    del CONFIG_MAPPING._extra_content["new-model"]
               for mapping in (
                   TF_MODEL_MAPPING,
                   TF_MODEL_FOR_PRETRAINING_MAPPING,
                   TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
                   TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
                   TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
                   TF_MODEL_FOR_CAUSAL_LM_MAPPING,
                   TF_MODEL_FOR_MASKED_LM_MAPPING,
               ):
                    if NewModelConfig in mapping._extra_content:
                         del mapping._extra_content[NewModelConfig]
     def 		a_      (	self   ):
          with self.assertRaisesRegex(
              __snake_case      , '''bert-base is not a local folder and is not a valid model identifier'''   ):
               snake_case					=    TFAutoModel.from_pretrained('''bert-base'''   )
     def 		a_      (	self   ):
          with self.assertRaisesRegex(
              __snake_case      , R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''   ):
               snake_case					=    TFAutoModel.from_pretrained(__snake_case      , revision='''aaaaaa'''   )
     def 		a_      (	self   ):
          with self.assertRaisesRegex(
              __snake_case      , '''hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin'''      , ):
               snake_case					=    TFAutoModel.from_pretrained('''hf-internal-testing/config-no-model'''   )
     def 		a_      (	self   ):
          with self.assertRaisesRegex(__snake_case      , '''Use `from_pt=True` to load this model'''   ):
               snake_case					=    TFAutoModel.from_pretrained('''hf-internal-testing/tiny-bert-pt-only'''   )




     def 		a_      (	self   ):
          # Make sure we have cached the model.
          snake_case					=    TFAutoModel.from_pretrained('''hf-internal-testing/tiny-random-bert'''   )
          with RequestCounter() as counter:
               snake_case					=    TFAutoModel.from_pretrained('''hf-internal-testing/tiny-random-bert'''   )
               self.assertEqual(counter.get_request_count      , 0   )
               self.assertEqual(counter.head_request_count      , 1   )
               self.assertEqual(counter.other_request_count      , 0   )

          # With a sharded checkpoint
          snake_case					=    TFAutoModel.from_pretrained('''ArthurZ/tiny-random-bert-sharded'''   )
          with RequestCounter() as counter:
               snake_case					=    TFAutoModel.from_pretrained('''ArthurZ/tiny-random-bert-sharded'''   )
               self.assertEqual(counter.get_request_count      , 0   )
               self.assertEqual(counter.head_request_count      , 1   )
               self.assertEqual(counter.other_request_count      , 0   )








# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import sys
import warnings
from os.path import abspath, dirname, join


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
_SCREAMING_SNAKE_CASE      :			Union[str, Any]      				=   abspath(join(dirname(dirname(dirname(__file__))), "src"))
sys.path.insert(1, git_repo_path)


# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action="ignore", category=FutureWarning)
def       UpperCAmelCase__						(UpperCamelCase_    ):



     """simple docstring"""






     from transformers.testing_utils import pytest_addoption_shared

     pytest_addoption_shared(UpperCamelCase_    )

def       UpperCAmelCase__						(UpperCamelCase_    ):



     """simple docstring"""






     from transformers.testing_utils import pytest_terminal_summary_main

     snake_case					=    terminalreporter.config.getoption('''--make-reports'''    )
     if make_reports:
          pytest_terminal_summary_main(UpperCamelCase_							,id=UpperCamelCase_    )




