


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   A__ (   snake_case__     ):







    """simple docstring"""

    __magic_name__        =		'new-model'


if is_tf_available():

 class   A__ (   snake_case__     ):







     """simple docstring"""

     __magic_name__        =		NewModelConfig

@require_tf
class   A__ (   unittest.TestCase     ):







    """simple docstring"""

    @slow
    def 		a_      (	self   ):
         snake_case					=    '''bert-base-cased'''
         snake_case					=    AutoConfig.from_pretrained(__snake_case   )
         self.assertIsNotNone(__snake_case   )
         self.assertIsInstance(__snake_case      , __snake_case   )

         snake_case					=    TFAutoModel.from_pretrained(__snake_case   )
         self.assertIsNotNone(__snake_case   )
         self.assertIsInstance(__snake_case      , __snake_case   )
    @slow
    def 		a_      (	self   ):
         snake_case					=    '''bert-base-cased'''
         snake_case					=    AutoConfig.from_pretrained(__snake_case   )
         self.assertIsNotNone(__snake_case   )
         self.assertIsInstance(__snake_case      , __snake_case   )

         snake_case					=    TFAutoModelForPreTraining.from_pretrained(__snake_case   )
         self.assertIsNotNone(__snake_case   )
         self.assertIsInstance(__snake_case      , __snake_case   )
    @slow
    def 		a_      (	self   ):
         for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              snake_case					=    AutoConfig.from_pretrained(__snake_case   )
              self.assertIsNotNone(__snake_case   )
              self.assertIsInstance(__snake_case      , __snake_case   )

              snake_case					=    TFAutoModelForCausalLM.from_pretrained(__snake_case   )
              snake_case			,  snake_case					=    TFAutoModelForCausalLM.from_pretrained(__snake_case      , output_loading_info=__snake_case   )
              self.assertIsNotNone(__snake_case   )
              self.assertIsInstance(__snake_case      , __snake_case   )
    @slow
    def 		a_      (	self   ):
         for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              snake_case					=    AutoConfig.from_pretrained(__snake_case   )
              self.assertIsNotNone(__snake_case   )
              self.assertIsInstance(__snake_case      , __snake_case   )

              snake_case					=    TFAutoModelWithLMHead.from_pretrained(__snake_case   )
              self.assertIsNotNone(__snake_case   )
              self.assertIsInstance(__snake_case      , __snake_case   )
    @slow
    def 		a_      (	self   ):
         for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              snake_case					=    AutoConfig.from_pretrained(__snake_case   )
              self.assertIsNotNone(__snake_case   )
              self.assertIsInstance(__snake_case      , __snake_case   )

              snake_case					=    TFAutoModelForMaskedLM.from_pretrained(__snake_case   )
              snake_case			,  snake_case					=    TFAutoModelForMaskedLM.from_pretrained(__snake_case      , output_loading_info=__snake_case   )
              self.assertIsNotNone(__snake_case   )
              self.assertIsInstance(__snake_case      , __snake_case   )
    @slow
    def 		a_      (	self   ):
         for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              snake_case					=    AutoConfig.from_pretrained(__snake_case   )
              self.assertIsNotNone(__snake_case   )
              self.assertIsInstance(__snake_case      , __snake_case   )

              snake_case					=    TFAutoModelForSeqaSeqLM.from_pretrained(__snake_case   )
              snake_case			,  snake_case					=    TFAutoModelForSeqaSeqLM.from_pretrained(__snake_case      , output_loading_info=__snake_case   )
              self.assertIsNotNone(__snake_case   )
              self.assertIsInstance(__snake_case      , __snake_case   )
    @slow
    def 		a_      (	self   ):
         # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         for model_name in ["bert-base-uncased"]:
              snake_case					=    AutoConfig.from_pretrained(__snake_case   )
              self.assertIsNotNone(__snake_case   )
              self.assertIsInstance(__snake_case      , __snake_case   )

              snake_case					=    TFAutoModelForSequenceClassification.from_pretrained(__snake_case   )
              self.assertIsNotNone(__snake_case   )
              self.assertIsInstance(__snake_case      , __snake_case   )
    @slow
    def 		a_      (	self   ):
         # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         for model_name in ["bert-base-uncased"]:
              snake_case					=    AutoConfig.from_pretrained(__snake_case   )
              self.assertIsNotNone(__snake_case   )
              self.assertIsInstance(__snake_case      , __snake_case   )

              snake_case					=    TFAutoModelForQuestionAnswering.from_pretrained(__snake_case   )
              self.assertIsNotNone(__snake_case   )
              self.assertIsInstance(__snake_case      , __snake_case   )
    @slow
    @require_tensorflow_probability
    def 		a_      (	self   ):
         for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
              snake_case					=    AutoConfig.from_pretrained(__snake_case   )
              self.assertIsNotNone(__snake_case   )
              self.assertIsInstance(__snake_case      , __snake_case   )

              snake_case					=    TFAutoModelForTableQuestionAnswering.from_pretrained(__snake_case   )
              snake_case			,  snake_case					=    TFAutoModelForTableQuestionAnswering.from_pretrained(
                  __snake_case      , output_loading_info=__snake_case   )
              self.assertIsNotNone(__snake_case   )
              self.assertIsInstance(__snake_case      , __snake_case   )
    def 		a_      (	self   ):
         snake_case					=    TFAutoModelWithLMHead.from_pretrained(__snake_case   )
         self.assertIsInstance(__snake_case      , __snake_case   )
         self.assertEqual(model.num_parameters()      , 1_4_4_1_0   )
         self.assertEqual(model.num_parameters(only_trainable=__snake_case   )      , 1_4_4_1_0   )
    def 		a_      (	self   ):
         snake_case					=    TFAutoModelWithLMHead.from_pretrained(__snake_case   )
         self.assertIsInstance(__snake_case      , __snake_case   )
         self.assertEqual(model.num_parameters()      , 1_4_4_1_0   )
         self.assertEqual(model.num_parameters(only_trainable=__snake_case   )      , 1_4_4_1_0   )
    def 		a_      (	self   ):
         # For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel
         snake_case					=    TFAutoModel.from_pretrained('''sgugger/funnel-random-tiny'''   )
         self.assertIsInstance(__snake_case      , __snake_case   )

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

         with tempfile.TemporaryDirectory() as tmp_dir:
              model.save_pretrained(__snake_case   )
              snake_case					=    TFAutoModel.from_pretrained(__snake_case   )
              self.assertIsInstance(__snake_case      , __snake_case   )
    def 		a_      (	self   ):
         try:
              AutoConfig.register('''new-model'''      , __snake_case   )

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

                        # 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(__snake_case   )
                        self.assertIsInstance(__snake_case      , __snake_case   )

                        with tempfile.TemporaryDirectory() as tmp_dir:
                             model.save_pretrained(__snake_case   )
                             snake_case					=    auto_class.from_pretrained(__snake_case   )
                             self.assertIsInstance(__snake_case      , __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 		a_      (	self   ):
         with self.assertRaisesRegex(
             __snake_case      , '''bert-base is not a local folder and is not a valid model identifier'''   ):
              snake_case					=    TFAutoModel.from_pretrained('''bert-base'''   )
    def 		a_      (	self   ):
         with self.assertRaisesRegex(
             __snake_case      , R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''   ):
              snake_case					=    TFAutoModel.from_pretrained(__snake_case      , revision='''aaaaaa'''   )
    def 		a_      (	self   ):
         with self.assertRaisesRegex(
             __snake_case      , '''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   ):
         with self.assertRaisesRegex(__snake_case      , '''Use `from_pt=True` to load this model'''   ):
              snake_case					=    TFAutoModel.from_pretrained('''hf-internal-testing/tiny-bert-pt-only'''   )




    def 		a_      (	self   ):
         # Make sure we have cached the model.
         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   )








import warnings

from ...utils import logging
from .image_processing_beit import BeitImageProcessor


_SCREAMING_SNAKE_CASE      :			List[str]      				=   logging.get_logger(__name__)

class   A__ (   snake_case__     ):







    """simple docstring"""

    def __init__(	self      , *__snake_case      , **__snake_case   ):
         warnings.warn(
             '''The class BeitFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'''
             ''' use BeitImageProcessor instead.'''      , __snake_case      , )
         super().__init__(*__snake_case      , **__snake_case   )




