"""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        UpperCamelCase		(			lowercase_  ):
   lowercase							=  'new-model'


if is_tf_available():







       class        UpperCamelCase		(			lowercase_  ):
          lowercase							=  NewModelConfig







@require_tf
class        UpperCamelCase		(			unittest.TestCase  ):
   @slow
   def 			_UpperCAmelCase   (			self			)	->      Optional[int]:


        '''simple docstring'''


        lowercase_	:				Optional[int]													=	'bert-base-cased'
        lowercase_	:				List[str]													=	AutoConfig.from_pretrained(__UpperCamelCase			)
        self.assertIsNotNone(__UpperCamelCase			)
        self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)

        lowercase_	:				List[Any]													=	TFAutoModel.from_pretrained(__UpperCamelCase			)
        self.assertIsNotNone(__UpperCamelCase			)
        self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)
   @slow
   def 			_UpperCAmelCase   (			self			)	->      Optional[int]:


        '''simple docstring'''


        lowercase_	:				Dict													=	'bert-base-cased'
        lowercase_	:				Optional[Any]													=	AutoConfig.from_pretrained(__UpperCamelCase			)
        self.assertIsNotNone(__UpperCamelCase			)
        self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)

        lowercase_	:				Optional[Any]													=	TFAutoModelForPreTraining.from_pretrained(__UpperCamelCase			)
        self.assertIsNotNone(__UpperCamelCase			)
        self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)
   @slow
   def 			_UpperCAmelCase   (			self			)	->      Any:


        '''simple docstring'''


        for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowercase_	:				Dict													=	AutoConfig.from_pretrained(__UpperCamelCase			)
             self.assertIsNotNone(__UpperCamelCase			)
             self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)

             lowercase_	:				Optional[int]													=	TFAutoModelForCausalLM.from_pretrained(__UpperCamelCase			)
             lowercase_							,  lowercase_	:				Dict													=	TFAutoModelForCausalLM.from_pretrained(__UpperCamelCase     ,output_loading_info=__UpperCamelCase			)
             self.assertIsNotNone(__UpperCamelCase			)
             self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)
   @slow
   def 			_UpperCAmelCase   (			self			)	->      Dict:


        '''simple docstring'''


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

             lowercase_	:				Dict													=	TFAutoModelWithLMHead.from_pretrained(__UpperCamelCase			)
             self.assertIsNotNone(__UpperCamelCase			)
             self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)
   @slow
   def 			_UpperCAmelCase   (			self			)	->      Dict:


        '''simple docstring'''


        for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowercase_	:				Tuple													=	AutoConfig.from_pretrained(__UpperCamelCase			)
             self.assertIsNotNone(__UpperCamelCase			)
             self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)

             lowercase_	:				Dict													=	TFAutoModelForMaskedLM.from_pretrained(__UpperCamelCase			)
             lowercase_							,  lowercase_	:				Any													=	TFAutoModelForMaskedLM.from_pretrained(__UpperCamelCase     ,output_loading_info=__UpperCamelCase			)
             self.assertIsNotNone(__UpperCamelCase			)
             self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)
   @slow
   def 			_UpperCAmelCase   (			self			)	->      Any:


        '''simple docstring'''


        for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowercase_	:				Optional[int]													=	AutoConfig.from_pretrained(__UpperCamelCase			)
             self.assertIsNotNone(__UpperCamelCase			)
             self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)

             lowercase_	:				Union[str, Any]													=	TFAutoModelForSeqaSeqLM.from_pretrained(__UpperCamelCase			)
             lowercase_							,  lowercase_	:				int													=	TFAutoModelForSeqaSeqLM.from_pretrained(__UpperCamelCase     ,output_loading_info=__UpperCamelCase			)
             self.assertIsNotNone(__UpperCamelCase			)
             self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)
   @slow
   def 			_UpperCAmelCase   (			self			)	->      List[Any]:


        '''simple docstring'''


        for model_name in ["bert-base-uncased"]:
             lowercase_	:				Dict													=	AutoConfig.from_pretrained(__UpperCamelCase			)
             self.assertIsNotNone(__UpperCamelCase			)
             self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)

             lowercase_	:				Optional[int]													=	TFAutoModelForSequenceClassification.from_pretrained(__UpperCamelCase			)
             self.assertIsNotNone(__UpperCamelCase			)
             self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)
   @slow
   def 			_UpperCAmelCase   (			self			)	->      Union[str, Any]:


        '''simple docstring'''


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

             lowercase_	:				List[Any]													=	TFAutoModelForQuestionAnswering.from_pretrained(__UpperCamelCase			)
             self.assertIsNotNone(__UpperCamelCase			)
             self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)
   @slow
   @require_tensorflow_probability
   def 			_UpperCAmelCase   (			self			)	->      Optional[int]:


        '''simple docstring'''


        for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
             lowercase_	:				Any													=	AutoConfig.from_pretrained(__UpperCamelCase			)
             self.assertIsNotNone(__UpperCamelCase			)
             self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)

             lowercase_	:				int													=	TFAutoModelForTableQuestionAnswering.from_pretrained(__UpperCamelCase			)
             lowercase_							,  lowercase_	:				Tuple													=	TFAutoModelForTableQuestionAnswering.from_pretrained(
                 __UpperCamelCase     ,output_loading_info=__UpperCamelCase			)
             self.assertIsNotNone(__UpperCamelCase			)
             self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)
   def 			_UpperCAmelCase   (			self			)	->      Tuple:


        '''simple docstring'''


        lowercase_	:				Optional[Any]													=	TFAutoModelWithLMHead.from_pretrained(__UpperCamelCase			)
        self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)
        self.assertEqual(model.num_parameters()     ,1_4410			)
        self.assertEqual(model.num_parameters(only_trainable=__UpperCamelCase			)     ,1_4410			)
   def 			_UpperCAmelCase   (			self			)	->      Union[str, Any]:


        '''simple docstring'''


        lowercase_	:				str													=	TFAutoModelWithLMHead.from_pretrained(__UpperCamelCase			)
        self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)
        self.assertEqual(model.num_parameters()     ,1_4410			)
        self.assertEqual(model.num_parameters(only_trainable=__UpperCamelCase			)     ,1_4410			)
   def 			_UpperCAmelCase   (			self			)	->      Union[str, Any]:


        '''simple docstring'''


        lowercase_	:				Optional[int]													=	TFAutoModel.from_pretrained('sgugger/funnel-random-tiny'			)
        self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)

        lowercase_	:				Union[str, Any]													=	copy.deepcopy(model.config			)
        lowercase_	:				Tuple													=	['FunnelBaseModel']
        lowercase_	:				Tuple													=	TFAutoModel.from_config(__UpperCamelCase			)
        self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)

        with tempfile.TemporaryDirectory() as tmp_dir:
             model.save_pretrained(__UpperCamelCase			)
             lowercase_	:				Optional[int]													=	TFAutoModel.from_pretrained(__UpperCamelCase			)
             self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)
   def 			_UpperCAmelCase   (			self			)	->      List[Any]:


        '''simple docstring'''


        try:
             AutoConfig.register('new-model'     ,__UpperCamelCase			)

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

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

                       with tempfile.TemporaryDirectory() as tmp_dir:
                            model.save_pretrained(__UpperCamelCase			)
                            lowercase_	:				Optional[int]													=	auto_class.from_pretrained(__UpperCamelCase			)
                            self.assertIsInstance(__UpperCamelCase     ,__UpperCamelCase			)

        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 			_UpperCAmelCase   (			self			)	->      Optional[int]:


        '''simple docstring'''


        with self.assertRaisesRegex(
            __UpperCamelCase     ,'bert-base is not a local folder and is not a valid model identifier'			):
             lowercase_	:				Union[str, Any]													=	TFAutoModel.from_pretrained('bert-base'			)
   def 			_UpperCAmelCase   (			self			)	->      Union[str, Any]:


        '''simple docstring'''


        with self.assertRaisesRegex(
            __UpperCamelCase     ,r'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'			):
             lowercase_	:				Dict													=	TFAutoModel.from_pretrained(__UpperCamelCase     ,revision='aaaaaa'			)
   def 			_UpperCAmelCase   (			self			)	->      Any:


        '''simple docstring'''


        with self.assertRaisesRegex(
            __UpperCamelCase     ,'hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin'     ,):
             lowercase_	:				Union[str, Any]													=	TFAutoModel.from_pretrained('hf-internal-testing/config-no-model'			)
   def 			_UpperCAmelCase   (			self			)	->      Optional[Any]:


        '''simple docstring'''


        with self.assertRaisesRegex(__UpperCamelCase     ,'Use `from_pt=True` to load this model'			):
             lowercase_	:				str													=	TFAutoModel.from_pretrained('hf-internal-testing/tiny-bert-pt-only'			)







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


        '''simple docstring'''


        lowercase_	:				Any													=	TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert'			)
        with RequestCounter() as counter:
             lowercase_	:				str													=	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
        lowercase_	:				List[str]													=	TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded'			)
        with RequestCounter() as counter:
             lowercase_	:				Dict													=	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 __future__ import annotations



def 			lowercase__(       __SCREAMING_SNAKE_CASE							:     list      ):
     if not nums:
          raise ValueError('List is empty'      )
     return sum(__SCREAMING_SNAKE_CASE      ) / len(__SCREAMING_SNAKE_CASE      )


if __name__ == "__main__":
       import doctest

       doctest.testmod()

