

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__  ):
       """simple docstring"""







       __SCREAMING_SNAKE_CASE				    =							"new-model"


if is_tf_available():

    class     __snake_case    (				snake_case__  ):
           """simple docstring"""







           __SCREAMING_SNAKE_CASE				    =							NewModelConfig

@require_tf
class     __snake_case    (				unittest.TestCase  ):
       """simple docstring"""







       @slow
       def 			a		(		self   )      ->							Optional[Any]:






              """simple docstring"""


              __snake_case       	=							"""bert-base-cased"""
              __snake_case       	=							AutoConfig.from_pretrained(_UpperCamelCase   )
              self.assertIsNotNone(_UpperCamelCase   )
              self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )

              __snake_case       	=							TFAutoModel.from_pretrained(_UpperCamelCase   )
              self.assertIsNotNone(_UpperCamelCase   )
              self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )


       @slow
       def 			a		(		self   )      ->							List[Any]:






              """simple docstring"""


              __snake_case       	=							"""bert-base-cased"""
              __snake_case       	=							AutoConfig.from_pretrained(_UpperCamelCase   )
              self.assertIsNotNone(_UpperCamelCase   )
              self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )

              __snake_case       	=							TFAutoModelForPreTraining.from_pretrained(_UpperCamelCase   )
              self.assertIsNotNone(_UpperCamelCase   )
              self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )


       @slow
       def 			a		(		self   )      ->							Optional[int]:






              """simple docstring"""


              for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                     __snake_case       	=							AutoConfig.from_pretrained(_UpperCamelCase   )
                     self.assertIsNotNone(_UpperCamelCase   )
                     self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )

                     __snake_case       	=							TFAutoModelForCausalLM.from_pretrained(_UpperCamelCase   )
                     __snake_case	,    __snake_case       	=							TFAutoModelForCausalLM.from_pretrained(_UpperCamelCase      , output_loading_info=_UpperCamelCase   )
                     self.assertIsNotNone(_UpperCamelCase   )
                     self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )


       @slow
       def 			a		(		self   )      ->							List[Any]:






              """simple docstring"""


              for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                     __snake_case       	=							AutoConfig.from_pretrained(_UpperCamelCase   )
                     self.assertIsNotNone(_UpperCamelCase   )
                     self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )

                     __snake_case       	=							TFAutoModelWithLMHead.from_pretrained(_UpperCamelCase   )
                     self.assertIsNotNone(_UpperCamelCase   )
                     self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )


       @slow
       def 			a		(		self   )      ->							List[Any]:






              """simple docstring"""


              for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                     __snake_case       	=							AutoConfig.from_pretrained(_UpperCamelCase   )
                     self.assertIsNotNone(_UpperCamelCase   )
                     self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )

                     __snake_case       	=							TFAutoModelForMaskedLM.from_pretrained(_UpperCamelCase   )
                     __snake_case	,    __snake_case       	=							TFAutoModelForMaskedLM.from_pretrained(_UpperCamelCase      , output_loading_info=_UpperCamelCase   )
                     self.assertIsNotNone(_UpperCamelCase   )
                     self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )


       @slow
       def 			a		(		self   )      ->							Optional[Any]:






              """simple docstring"""


              for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                     __snake_case       	=							AutoConfig.from_pretrained(_UpperCamelCase   )
                     self.assertIsNotNone(_UpperCamelCase   )
                     self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )

                     __snake_case       	=							TFAutoModelForSeqaSeqLM.from_pretrained(_UpperCamelCase   )
                     __snake_case	,    __snake_case       	=							TFAutoModelForSeqaSeqLM.from_pretrained(_UpperCamelCase      , output_loading_info=_UpperCamelCase   )
                     self.assertIsNotNone(_UpperCamelCase   )
                     self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )


       @slow
       def 			a		(		self   )      ->							Optional[Any]:






              """simple docstring"""


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

                     __snake_case       	=							TFAutoModelForSequenceClassification.from_pretrained(_UpperCamelCase   )
                     self.assertIsNotNone(_UpperCamelCase   )
                     self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )


       @slow
       def 			a		(		self   )      ->							List[str]:






              """simple docstring"""


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

                     __snake_case       	=							TFAutoModelForQuestionAnswering.from_pretrained(_UpperCamelCase   )
                     self.assertIsNotNone(_UpperCamelCase   )
                     self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )


       @slow
       @require_tensorflow_probability
       def 			a		(		self   )      ->							Any:






              """simple docstring"""


              for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
                     __snake_case       	=							AutoConfig.from_pretrained(_UpperCamelCase   )
                     self.assertIsNotNone(_UpperCamelCase   )
                     self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )

                     __snake_case       	=							TFAutoModelForTableQuestionAnswering.from_pretrained(_UpperCamelCase   )
                     __snake_case	,    __snake_case       	=							TFAutoModelForTableQuestionAnswering.from_pretrained(
                         _UpperCamelCase      , output_loading_info=_UpperCamelCase   )
                     self.assertIsNotNone(_UpperCamelCase   )
                     self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )


       def 			a		(		self   )      ->							Optional[int]:






              """simple docstring"""


              __snake_case       	=							TFAutoModelWithLMHead.from_pretrained(_UpperCamelCase   )
              self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )
              self.assertEqual(model.num_parameters()      , 1_44_10   )
              self.assertEqual(model.num_parameters(only_trainable=_UpperCamelCase   )      , 1_44_10   )


       def 			a		(		self   )      ->							str:






              """simple docstring"""


              __snake_case       	=							TFAutoModelWithLMHead.from_pretrained(_UpperCamelCase   )
              self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )
              self.assertEqual(model.num_parameters()      , 1_44_10   )
              self.assertEqual(model.num_parameters(only_trainable=_UpperCamelCase   )      , 1_44_10   )


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






              """simple docstring"""


              __snake_case       	=							TFAutoModel.from_pretrained("""sgugger/funnel-random-tiny"""   )
              self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )

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

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


       def 			a		(		self   )      ->							int:






              """simple docstring"""


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

                     __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(_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
                                   __snake_case       	=							BertModelTester(self   ).get_config()
                                   __snake_case       	=							NewModelConfig(**tiny_config.to_dict()   )
                                   __snake_case       	=							auto_class.from_config(_UpperCamelCase   )
                                   self.assertIsInstance(_UpperCamelCase      , _UpperCamelCase   )

                                   with tempfile.TemporaryDirectory() as tmp_dir:
                                          model.save_pretrained(_UpperCamelCase   )
                                          __snake_case       	=							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 			a		(		self   )      ->							List[Any]:






              """simple docstring"""


              with self.assertRaisesRegex(
                  _UpperCamelCase      , """bert-base is not a local folder and is not a valid model identifier"""   ):
                     __snake_case       	=							TFAutoModel.from_pretrained("""bert-base"""   )


       def 			a		(		self   )      ->							Dict:






              """simple docstring"""


              with self.assertRaisesRegex(
                  _UpperCamelCase      , r"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""   ):
                     __snake_case       	=							TFAutoModel.from_pretrained(_UpperCamelCase      , revision="""aaaaaa"""   )


       def 			a		(		self   )      ->							int:






              """simple docstring"""


              with self.assertRaisesRegex(
                  _UpperCamelCase      , """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   )      ->							Dict:






              """simple docstring"""


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






       def 			a		(		self   )      ->							List[Any]:






              """simple docstring"""


              __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   )




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


UpperCamelCase__		 =     {
    '''configuration_convnext''': ['''CONVNEXT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ConvNextConfig''', '''ConvNextOnnxConfig''']
}

try:
    if not is_vision_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCamelCase__		 =     ['''ConvNextFeatureExtractor''']
    UpperCamelCase__		 =     ['''ConvNextImageProcessor''']

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCamelCase__		 =     [
        '''CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''ConvNextForImageClassification''',
        '''ConvNextModel''',
        '''ConvNextPreTrainedModel''',
        '''ConvNextBackbone''',
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCamelCase__		 =     [
        '''TFConvNextForImageClassification''',
        '''TFConvNextModel''',
        '''TFConvNextPreTrainedModel''',
    ]

if TYPE_CHECKING:
    from .configuration_convnext import CONVNEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, ConvNextConfig, ConvNextOnnxConfig

    try:
        if not is_vision_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .feature_extraction_convnext import ConvNextFeatureExtractor
        from .image_processing_convnext import ConvNextImageProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_convnext import (
            CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
            ConvNextBackbone,
            ConvNextForImageClassification,
            ConvNextModel,
            ConvNextPreTrainedModel,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_convnext import TFConvNextForImageClassification, TFConvNextModel, TFConvNextPreTrainedModel


else:
    import sys

    UpperCamelCase__		 =     _LazyModule(__name__, globals()['''__file__'''], _import_structure)

