



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 				lowerCAmelCase_		(  a__							):
       UpperCAmelCase__				:					Dict        =  "new-model"


if is_tf_available():



    class 				lowerCAmelCase_		(  a__							):
           UpperCAmelCase__				:					Union[str, Any]        =  NewModelConfig



@require_tf
class 				lowerCAmelCase_		(  unittest.TestCase							):
       @slow
       def 					snake_case_       (			self       )     ->		List[str]:
          UpperCamelCase    :  Any							=	'bert-base-cased'
          UpperCamelCase    :  Tuple							=	AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_       )
          self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
          self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )

          UpperCamelCase    :  Dict							=	TFAutoModel.from_pretrained(SCREAMING_SNAKE_CASE_       )
          self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
          self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
       @slow
       def 					snake_case_       (			self       )     ->		List[Any]:
          UpperCamelCase    :  List[str]							=	'bert-base-cased'
          UpperCamelCase    :  Dict							=	AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_       )
          self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
          self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )

          UpperCamelCase    :  Any							=	TFAutoModelForPreTraining.from_pretrained(SCREAMING_SNAKE_CASE_       )
          self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
          self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
       @slow
       def 					snake_case_       (			self       )     ->		Union[str, Any]:
          for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             UpperCamelCase    :  int							=	AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )

             UpperCamelCase    :  Tuple							=	TFAutoModelForCausalLM.from_pretrained(SCREAMING_SNAKE_CASE_       )
             UpperCamelCase	,     UpperCamelCase    :  Tuple							=	TFAutoModelForCausalLM.from_pretrained(SCREAMING_SNAKE_CASE_,			output_loading_info=SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
       @slow
       def 					snake_case_       (			self       )     ->		Any:
          for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             UpperCamelCase    :  Optional[int]							=	AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )

             UpperCamelCase    :  Optional[Any]							=	TFAutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
       @slow
       def 					snake_case_       (			self       )     ->		Dict:
          for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             UpperCamelCase    :  Dict							=	AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )

             UpperCamelCase    :  str							=	TFAutoModelForMaskedLM.from_pretrained(SCREAMING_SNAKE_CASE_       )
             UpperCamelCase	,     UpperCamelCase    :  Union[str, Any]							=	TFAutoModelForMaskedLM.from_pretrained(SCREAMING_SNAKE_CASE_,			output_loading_info=SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
       @slow
       def 					snake_case_       (			self       )     ->		Any:
          for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             UpperCamelCase    :  Dict							=	AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )

             UpperCamelCase    :  Any							=	TFAutoModelForSeqaSeqLM.from_pretrained(SCREAMING_SNAKE_CASE_       )
             UpperCamelCase	,     UpperCamelCase    :  Any							=	TFAutoModelForSeqaSeqLM.from_pretrained(SCREAMING_SNAKE_CASE_,			output_loading_info=SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
       @slow
       def 					snake_case_       (			self       )     ->		str:
          # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          for model_name in ["bert-base-uncased"]:
             UpperCamelCase    :  Optional[int]							=	AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )

             UpperCamelCase    :  int							=	TFAutoModelForSequenceClassification.from_pretrained(SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
       @slow
       def 					snake_case_       (			self       )     ->		Any:
          # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          for model_name in ["bert-base-uncased"]:
             UpperCamelCase    :  Union[str, Any]							=	AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )

             UpperCamelCase    :  Optional[Any]							=	TFAutoModelForQuestionAnswering.from_pretrained(SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
       @slow
       @require_tensorflow_probability
       def 					snake_case_       (			self       )     ->		Any:
          for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
             UpperCamelCase    :  Any							=	AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )

             UpperCamelCase    :  str							=	TFAutoModelForTableQuestionAnswering.from_pretrained(SCREAMING_SNAKE_CASE_       )
             UpperCamelCase	,     UpperCamelCase    :  List[str]							=	TFAutoModelForTableQuestionAnswering.from_pretrained(
                 SCREAMING_SNAKE_CASE_,			output_loading_info=SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self       )     ->		List[Any]:
          UpperCamelCase    :  Any							=	TFAutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE_       )
          self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
          self.assertEqual(model.num_parameters(),			1_4410       )
          self.assertEqual(model.num_parameters(only_trainable=SCREAMING_SNAKE_CASE_       ),			1_4410       )
       def 					snake_case_       (			self       )     ->		List[str]:
          UpperCamelCase    :  int							=	TFAutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE_       )
          self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
          self.assertEqual(model.num_parameters(),			1_4410       )
          self.assertEqual(model.num_parameters(only_trainable=SCREAMING_SNAKE_CASE_       ),			1_4410       )
       def 					snake_case_       (			self       )     ->		Tuple:
          # For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel
          UpperCamelCase    :  Tuple							=	TFAutoModel.from_pretrained('sgugger/funnel-random-tiny'       )
          self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )

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

          with tempfile.TemporaryDirectory() as tmp_dir:
             model.save_pretrained(SCREAMING_SNAKE_CASE_       )
             UpperCamelCase    :  List[Any]							=	TFAutoModel.from_pretrained(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self       )     ->		int:
          try:
             AutoConfig.register('new-model',			SCREAMING_SNAKE_CASE_       )

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

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

                   with tempfile.TemporaryDirectory() as tmp_dir:
                      model.save_pretrained(SCREAMING_SNAKE_CASE_       )
                      UpperCamelCase    :  Optional[Any]							=	auto_class.from_pretrained(SCREAMING_SNAKE_CASE_       )
                      self.assertIsInstance(SCREAMING_SNAKE_CASE_,			SCREAMING_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 					snake_case_       (			self       )     ->		Tuple:
          with self.assertRaisesRegex(
              SCREAMING_SNAKE_CASE_,			'bert-base is not a local folder and is not a valid model identifier'       ):
             UpperCamelCase    :  List[Any]							=	TFAutoModel.from_pretrained('bert-base'       )
       def 					snake_case_       (			self       )     ->		List[Any]:
          with self.assertRaisesRegex(
              SCREAMING_SNAKE_CASE_,			R'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'       ):
             UpperCamelCase    :  List[Any]							=	TFAutoModel.from_pretrained(SCREAMING_SNAKE_CASE_,			revision='aaaaaa'       )
       def 					snake_case_       (			self       )     ->		Optional[Any]:
          with self.assertRaisesRegex(
              SCREAMING_SNAKE_CASE_,			'hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin',			):
             UpperCamelCase    :  int							=	TFAutoModel.from_pretrained('hf-internal-testing/config-no-model'       )
       def 					snake_case_       (			self       )     ->		List[str]:
          with self.assertRaisesRegex(SCREAMING_SNAKE_CASE_,			'Use `from_pt=True` to load this model'       ):
             UpperCamelCase    :  Optional[int]							=	TFAutoModel.from_pretrained('hf-internal-testing/tiny-bert-pt-only'       )






       def 					snake_case_       (			self       )     ->		Any:
          # Make sure we have cached the model.
          UpperCamelCase    :  Union[str, Any]							=	TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert'       )
          with RequestCounter() as counter:
             UpperCamelCase    :  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
          UpperCamelCase    :  Tuple							=	TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded'       )
          with RequestCounter() as counter:
             UpperCamelCase    :  Optional[int]							=	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       )








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__UpperCAmelCase          =       {
    '''configuration_transfo_xl''': ['''TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''TransfoXLConfig'''],
    '''tokenization_transfo_xl''': ['''TransfoXLCorpus''', '''TransfoXLTokenizer'''],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCAmelCase          =       [
        '''TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''AdaptiveEmbedding''',
        '''TransfoXLForSequenceClassification''',
        '''TransfoXLLMHeadModel''',
        '''TransfoXLModel''',
        '''TransfoXLPreTrainedModel''',
        '''load_tf_weights_in_transfo_xl''',
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCAmelCase          =       [
        '''TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''TFAdaptiveEmbedding''',
        '''TFTransfoXLForSequenceClassification''',
        '''TFTransfoXLLMHeadModel''',
        '''TFTransfoXLMainLayer''',
        '''TFTransfoXLModel''',
        '''TFTransfoXLPreTrainedModel''',
    ]


if TYPE_CHECKING:
    from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig
    from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_transfo_xl import (
            TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
            AdaptiveEmbedding,
            TransfoXLForSequenceClassification,
            TransfoXLLMHeadModel,
            TransfoXLModel,
            TransfoXLPreTrainedModel,
            load_tf_weights_in_transfo_xl,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_transfo_xl import (
            TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFAdaptiveEmbedding,
            TFTransfoXLForSequenceClassification,
            TFTransfoXLLMHeadModel,
            TFTransfoXLMainLayer,
            TFTransfoXLModel,
            TFTransfoXLPreTrainedModel,
        )

else:
    import sys

    __UpperCAmelCase          =       _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



