


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       UpperCAmelCase_   (   __snake_case       ):

   '''simple docstring'''




   __A					: str							=						"new-model"


if is_tf_available():
   class       UpperCAmelCase_   (   __snake_case       ):

      '''simple docstring'''




      __A					: str							=						NewModelConfig
@require_tf
class       UpperCAmelCase_   (   unittest.TestCase       ):

   '''simple docstring'''




   @slow
   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   Optional[int]       =							"bert-base-cased"
     lowerCamelCase					:   str       =							AutoConfig.from_pretrained(__lowerCamelCase					)
     self.assertIsNotNone(__lowerCamelCase					)
     self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)

     lowerCamelCase					:   Optional[Any]       =							TFAutoModel.from_pretrained(__lowerCamelCase					)
     self.assertIsNotNone(__lowerCamelCase					)
     self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)






   @slow
   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   Dict       =							"bert-base-cased"
     lowerCamelCase					:   str       =							AutoConfig.from_pretrained(__lowerCamelCase					)
     self.assertIsNotNone(__lowerCamelCase					)
     self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)

     lowerCamelCase					:   int       =							TFAutoModelForPreTraining.from_pretrained(__lowerCamelCase					)
     self.assertIsNotNone(__lowerCamelCase					)
     self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)






   @slow
   def _snake_case       (						self					):






     """simple docstring"""





     for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       lowerCamelCase					:   List[str]       =							AutoConfig.from_pretrained(__lowerCamelCase					)
       self.assertIsNotNone(__lowerCamelCase					)
       self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)

       lowerCamelCase					:   Union[str, Any]       =							TFAutoModelForCausalLM.from_pretrained(__lowerCamelCase					)
       lowerCamelCase       ,      lowerCamelCase					:   Dict       =							TFAutoModelForCausalLM.from_pretrained(__lowerCamelCase		,							output_loading_info=__lowerCamelCase					)
       self.assertIsNotNone(__lowerCamelCase					)
       self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)






   @slow
   def _snake_case       (						self					):






     """simple docstring"""





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

       lowerCamelCase					:   Optional[int]       =							TFAutoModelWithLMHead.from_pretrained(__lowerCamelCase					)
       self.assertIsNotNone(__lowerCamelCase					)
       self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)






   @slow
   def _snake_case       (						self					):






     """simple docstring"""





     for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       lowerCamelCase					:   int       =							AutoConfig.from_pretrained(__lowerCamelCase					)
       self.assertIsNotNone(__lowerCamelCase					)
       self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)

       lowerCamelCase					:   Union[str, Any]       =							TFAutoModelForMaskedLM.from_pretrained(__lowerCamelCase					)
       lowerCamelCase       ,      lowerCamelCase					:   List[str]       =							TFAutoModelForMaskedLM.from_pretrained(__lowerCamelCase		,							output_loading_info=__lowerCamelCase					)
       self.assertIsNotNone(__lowerCamelCase					)
       self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)






   @slow
   def _snake_case       (						self					):






     """simple docstring"""





     for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       lowerCamelCase					:   Tuple       =							AutoConfig.from_pretrained(__lowerCamelCase					)
       self.assertIsNotNone(__lowerCamelCase					)
       self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)

       lowerCamelCase					:   str       =							TFAutoModelForSeqaSeqLM.from_pretrained(__lowerCamelCase					)
       lowerCamelCase       ,      lowerCamelCase					:   Union[str, Any]       =							TFAutoModelForSeqaSeqLM.from_pretrained(__lowerCamelCase		,							output_loading_info=__lowerCamelCase					)
       self.assertIsNotNone(__lowerCamelCase					)
       self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)






   @slow
   def _snake_case       (						self					):






     """simple docstring"""





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

       lowerCamelCase					:   int       =							TFAutoModelForSequenceClassification.from_pretrained(__lowerCamelCase					)
       self.assertIsNotNone(__lowerCamelCase					)
       self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)






   @slow
   def _snake_case       (						self					):






     """simple docstring"""





     for model_name in ["bert-base-uncased"]:
       lowerCamelCase					:   int       =							AutoConfig.from_pretrained(__lowerCamelCase					)
       self.assertIsNotNone(__lowerCamelCase					)
       self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)

       lowerCamelCase					:   Dict       =							TFAutoModelForQuestionAnswering.from_pretrained(__lowerCamelCase					)
       self.assertIsNotNone(__lowerCamelCase					)
       self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)






   @slow
   @require_tensorflow_probability
   def _snake_case       (						self					):






     """simple docstring"""





     for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
       lowerCamelCase					:   Optional[int]       =							AutoConfig.from_pretrained(__lowerCamelCase					)
       self.assertIsNotNone(__lowerCamelCase					)
       self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)

       lowerCamelCase					:   Dict       =							TFAutoModelForTableQuestionAnswering.from_pretrained(__lowerCamelCase					)
       lowerCamelCase       ,      lowerCamelCase					:   int       =							TFAutoModelForTableQuestionAnswering.from_pretrained(
           __lowerCamelCase		,							output_loading_info=__lowerCamelCase					)
       self.assertIsNotNone(__lowerCamelCase					)
       self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   int       =							TFAutoModelWithLMHead.from_pretrained(__lowerCamelCase					)
     self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)
     self.assertEqual(model.num_parameters()		,							1_4410					)
     self.assertEqual(model.num_parameters(only_trainable=__lowerCamelCase					)		,							1_4410					)






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   Tuple       =							TFAutoModelWithLMHead.from_pretrained(__lowerCamelCase					)
     self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)
     self.assertEqual(model.num_parameters()		,							1_4410					)
     self.assertEqual(model.num_parameters(only_trainable=__lowerCamelCase					)		,							1_4410					)






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   Tuple       =							TFAutoModel.from_pretrained("sgugger/funnel-random-tiny"					)
     self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)

     lowerCamelCase					:   int       =							copy.deepcopy(model.config					)
     lowerCamelCase					:   Optional[Any]       =							["FunnelBaseModel"]
     lowerCamelCase					:   List[Any]       =							TFAutoModel.from_config(__lowerCamelCase					)
     self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)

     with tempfile.TemporaryDirectory() as tmp_dir:
       model.save_pretrained(__lowerCamelCase					)
       lowerCamelCase					:   int       =							TFAutoModel.from_pretrained(__lowerCamelCase					)
       self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)






   def _snake_case       (						self					):






     """simple docstring"""





     try:
       AutoConfig.register("new-model"		,							__lowerCamelCase					)

       lowerCamelCase					:   int       =							[
           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(__lowerCamelCase					):
             auto_class.register(__lowerCamelCase		,							__lowerCamelCase					)
           auto_class.register(__lowerCamelCase		,							__lowerCamelCase					)
           # Trying to register something existing in the Transformers library will raise an error
           with self.assertRaises(__lowerCamelCase					):
             auto_class.register(__lowerCamelCase		,							__lowerCamelCase					)

           # Now that the config is registered, it can be used as any other config with the auto-API
           lowerCamelCase					:   List[str]       =							BertModelTester(self					).get_config()
           lowerCamelCase					:   Optional[Any]       =							NewModelConfig(**tiny_config.to_dict()					)
           lowerCamelCase					:   Tuple       =							auto_class.from_config(__lowerCamelCase					)
           self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)

           with tempfile.TemporaryDirectory() as tmp_dir:
             model.save_pretrained(__lowerCamelCase					)
             lowerCamelCase					:   Union[str, Any]       =							auto_class.from_pretrained(__lowerCamelCase					)
             self.assertIsInstance(__lowerCamelCase		,							__lowerCamelCase					)

     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 _snake_case       (						self					):






     """simple docstring"""





     with self.assertRaisesRegex(
         __lowerCamelCase		,							"bert-base is not a local folder and is not a valid model identifier"					):
       lowerCamelCase					:   Optional[Any]       =							TFAutoModel.from_pretrained("bert-base"					)






   def _snake_case       (						self					):






     """simple docstring"""





     with self.assertRaisesRegex(
         __lowerCamelCase		,							R"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"					):
       lowerCamelCase					:   List[str]       =							TFAutoModel.from_pretrained(__lowerCamelCase		,							revision="aaaaaa"					)






   def _snake_case       (						self					):






     """simple docstring"""





     with self.assertRaisesRegex(
         __lowerCamelCase		,							"hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin"		,							):
       lowerCamelCase					:   Any       =							TFAutoModel.from_pretrained("hf-internal-testing/config-no-model"					)






   def _snake_case       (						self					):






     """simple docstring"""





     with self.assertRaisesRegex(__lowerCamelCase		,							"Use `from_pt=True` to load this model"					):
       lowerCamelCase					:   List[Any]       =							TFAutoModel.from_pretrained("hf-internal-testing/tiny-bert-pt-only"					)






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   Optional[Any]       =							TFAutoModel.from_pretrained("hf-internal-testing/tiny-random-bert"					)
     with RequestCounter() as counter:
       lowerCamelCase					:   int       =							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
     lowerCamelCase					:   int       =							TFAutoModel.from_pretrained("ArthurZ/tiny-random-bert-sharded"					)
     with RequestCounter() as counter:
       lowerCamelCase					:   Tuple       =							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					)






def 	__a     (      A__			:  float			,  A__			:  float       ):
    if mass < 0:
        raise ValueError("The mass of a body cannot be negative"       )
    return 0.5 * mass * abs(A__       ) * abs(A__       )


if __name__ == "__main__":
    import doctest

    doctest.testmod(verbose=True)