"""simple docstring"""



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 				snake_case__     (   snake_case_   ):
 _snake_case   :			Dict           =		"""new-model"""


if is_tf_available():






   class 				snake_case__     (   snake_case_   ):
    _snake_case   :			List[str]           =		NewModelConfig






@require_tf
class 				snake_case__     (   unittest.TestCase   ):


 @slow
 def 		a__ (				self		):
        __a     				=  "bert-base-cased"
        __a     				=  AutoConfig.from_pretrained(lowerCamelCase		)
        self.assertIsNotNone(lowerCamelCase		)
        self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)

        __a     				=  TFAutoModel.from_pretrained(lowerCamelCase		)
        self.assertIsNotNone(lowerCamelCase		)
        self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)


 @slow
 def 		a__ (				self		):
        __a     				=  "bert-base-cased"
        __a     				=  AutoConfig.from_pretrained(lowerCamelCase		)
        self.assertIsNotNone(lowerCamelCase		)
        self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)

        __a     				=  TFAutoModelForPreTraining.from_pretrained(lowerCamelCase		)
        self.assertIsNotNone(lowerCamelCase		)
        self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)


 @slow
 def 		a__ (				self		):
        for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __a     				=  AutoConfig.from_pretrained(lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)
               self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)

               __a     				=  TFAutoModelForCausalLM.from_pretrained(lowerCamelCase		)
               __a				, __a     				=  TFAutoModelForCausalLM.from_pretrained(lowerCamelCase  ,						output_loading_info=lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)
               self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)


 @slow
 def 		a__ (				self		):
        for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __a     				=  AutoConfig.from_pretrained(lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)
               self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)

               __a     				=  TFAutoModelWithLMHead.from_pretrained(lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)
               self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)


 @slow
 def 		a__ (				self		):
        for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __a     				=  AutoConfig.from_pretrained(lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)
               self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)

               __a     				=  TFAutoModelForMaskedLM.from_pretrained(lowerCamelCase		)
               __a				, __a     				=  TFAutoModelForMaskedLM.from_pretrained(lowerCamelCase  ,						output_loading_info=lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)
               self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)


 @slow
 def 		a__ (				self		):
        for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __a     				=  AutoConfig.from_pretrained(lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)
               self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)

               __a     				=  TFAutoModelForSeqaSeqLM.from_pretrained(lowerCamelCase		)
               __a				, __a     				=  TFAutoModelForSeqaSeqLM.from_pretrained(lowerCamelCase  ,						output_loading_info=lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)
               self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)


 @slow
 def 		a__ (				self		):
        # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        for model_name in ["bert-base-uncased"]:
               __a     				=  AutoConfig.from_pretrained(lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)
               self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)

               __a     				=  TFAutoModelForSequenceClassification.from_pretrained(lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)
               self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)


 @slow
 def 		a__ (				self		):
        # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        for model_name in ["bert-base-uncased"]:
               __a     				=  AutoConfig.from_pretrained(lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)
               self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)

               __a     				=  TFAutoModelForQuestionAnswering.from_pretrained(lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)
               self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)


 @slow
 @require_tensorflow_probability
 def 		a__ (				self		):
        for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
               __a     				=  AutoConfig.from_pretrained(lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)
               self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)

               __a     				=  TFAutoModelForTableQuestionAnswering.from_pretrained(lowerCamelCase		)
               __a				, __a     				=  TFAutoModelForTableQuestionAnswering.from_pretrained(
                   lowerCamelCase  ,						output_loading_info=lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)
               self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)


 def 		a__ (				self		):
        __a     				=  TFAutoModelWithLMHead.from_pretrained(lowerCamelCase		)
        self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)
        self.assertEqual(model.num_parameters()  ,						14410		)
        self.assertEqual(model.num_parameters(only_trainable=lowerCamelCase		)  ,						14410		)


 def 		a__ (				self		):
        __a     				=  TFAutoModelWithLMHead.from_pretrained(lowerCamelCase		)
        self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)
        self.assertEqual(model.num_parameters()  ,						14410		)
        self.assertEqual(model.num_parameters(only_trainable=lowerCamelCase		)  ,						14410		)


 def 		a__ (				self		):
        # For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel
        __a     				=  TFAutoModel.from_pretrained("sgugger/funnel-random-tiny"		)
        self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)

        __a     				=  copy.deepcopy(model.config		)
        __a     				=  ["FunnelBaseModel"]
        __a     				=  TFAutoModel.from_config(lowerCamelCase		)
        self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)

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


 def 		a__ (				self		):
        try:
               AutoConfig.register("new-model"  ,						lowerCamelCase		)

               __a     				=  [
                   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
                             __a     				=  BertModelTester(self		).get_config()
                             __a     				=  NewModelConfig(**tiny_config.to_dict()		)
                             __a     				=  auto_class.from_config(lowerCamelCase		)
                             self.assertIsInstance(lowerCamelCase  ,						lowerCamelCase		)

                             with tempfile.TemporaryDirectory() as tmp_dir:
                                    model.save_pretrained(lowerCamelCase		)
                                    __a     				=  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 		a__ (				self		):
        with self.assertRaisesRegex(
            lowerCamelCase  ,						"bert-base is not a local folder and is not a valid model identifier"		):
               __a     				=  TFAutoModel.from_pretrained("bert-base"		)


 def 		a__ (				self		):
        with self.assertRaisesRegex(
            lowerCamelCase  ,						R"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"		):
               __a     				=  TFAutoModel.from_pretrained(lowerCamelCase  ,						revision="aaaaaa"		)


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


 def 		a__ (				self		):
        with self.assertRaisesRegex(lowerCamelCase  ,						"Use `from_pt=True` to load this model"		):
               __a     				=  TFAutoModel.from_pretrained("hf-internal-testing/tiny-bert-pt-only"		)






 def 		a__ (				self		):
        # Make sure we have cached the model.
        __a     				=  TFAutoModel.from_pretrained("hf-internal-testing/tiny-random-bert"		)
        with RequestCounter() as counter:
               __a     				=  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
        __a     				=  TFAutoModel.from_pretrained("ArthurZ/tiny-random-bert-sharded"		)
        with RequestCounter() as counter:
               __a     				=  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		)

"""simple docstring"""



from ..utils import DummyObject, requires_backends






class 				snake_case__     (   metaclass=snake_case_   ):
 _snake_case   :			Union[str, Any]           =		["""onnx"""]


 def __init__(				self  ,						*lowerCamelCase  ,						**lowerCamelCase		):
        requires_backends(self  ,						["onnx"]		)


 @classmethod
 def 		a__ (				cls  ,						*lowerCamelCase  ,						**lowerCamelCase		):
        requires_backends(cls  ,						["onnx"]		)






 @classmethod
 def 		a__ (				cls  ,						*lowerCamelCase  ,						**lowerCamelCase		):
        requires_backends(cls  ,						["onnx"]		)
