





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__ (      lowerCAmelCase_   ):



     '''simple docstring'''

     __snake_case    :	Tuple			=			"new-model"


if is_tf_available():

      class 		UpperCamelCase__ (      lowerCAmelCase_   ):



           '''simple docstring'''

           __snake_case    :	List[Any]			=			NewModelConfig

@require_tf
class 		UpperCamelCase__ (      unittest.TestCase   ):



     '''simple docstring'''

     @slow
     def 				SCREAMING_SNAKE_CASE__  (							self						:    Dict       )     ->		int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						"""bert-base-cased"""
           SCREAMING_SNAKE_CASE		=						AutoConfig.from_pretrained(lowerCamelCase__       )
           self.assertIsNotNone(lowerCamelCase__       )
           self.assertIsInstance(lowerCamelCase__						,lowerCamelCase__       )

           SCREAMING_SNAKE_CASE		=						TFAutoModel.from_pretrained(lowerCamelCase__       )
           self.assertIsNotNone(lowerCamelCase__       )
           self.assertIsInstance(lowerCamelCase__						,lowerCamelCase__       )






     @slow
     def 				SCREAMING_SNAKE_CASE__  (							self						:    Tuple       )     ->		Dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						"""bert-base-cased"""
           SCREAMING_SNAKE_CASE		=						AutoConfig.from_pretrained(lowerCamelCase__       )
           self.assertIsNotNone(lowerCamelCase__       )
           self.assertIsInstance(lowerCamelCase__						,lowerCamelCase__       )

           SCREAMING_SNAKE_CASE		=						TFAutoModelForPreTraining.from_pretrained(lowerCamelCase__       )
           self.assertIsNotNone(lowerCamelCase__       )
           self.assertIsInstance(lowerCamelCase__						,lowerCamelCase__       )






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




           '''simple docstring'''


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

                 SCREAMING_SNAKE_CASE		=						TFAutoModelForCausalLM.from_pretrained(lowerCamelCase__       )
                 SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE		=						TFAutoModelForCausalLM.from_pretrained(lowerCamelCase__						,output_loading_info=lowerCamelCase__       )
                 self.assertIsNotNone(lowerCamelCase__       )
                 self.assertIsInstance(lowerCamelCase__						,lowerCamelCase__       )






     @slow
     def 				SCREAMING_SNAKE_CASE__  (							self						:    Any       )     ->		Any:




           '''simple docstring'''


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

                 SCREAMING_SNAKE_CASE		=						TFAutoModelWithLMHead.from_pretrained(lowerCamelCase__       )
                 self.assertIsNotNone(lowerCamelCase__       )
                 self.assertIsInstance(lowerCamelCase__						,lowerCamelCase__       )






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




           '''simple docstring'''


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

                 SCREAMING_SNAKE_CASE		=						TFAutoModelForMaskedLM.from_pretrained(lowerCamelCase__       )
                 SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE		=						TFAutoModelForMaskedLM.from_pretrained(lowerCamelCase__						,output_loading_info=lowerCamelCase__       )
                 self.assertIsNotNone(lowerCamelCase__       )
                 self.assertIsInstance(lowerCamelCase__						,lowerCamelCase__       )






     @slow
     def 				SCREAMING_SNAKE_CASE__  (							self						:    Dict       )     ->		Tuple:




           '''simple docstring'''


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

                 SCREAMING_SNAKE_CASE		=						TFAutoModelForSeqaSeqLM.from_pretrained(lowerCamelCase__       )
                 SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE		=						TFAutoModelForSeqaSeqLM.from_pretrained(lowerCamelCase__						,output_loading_info=lowerCamelCase__       )
                 self.assertIsNotNone(lowerCamelCase__       )
                 self.assertIsInstance(lowerCamelCase__						,lowerCamelCase__       )






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




           '''simple docstring'''


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

                 SCREAMING_SNAKE_CASE		=						TFAutoModelForSequenceClassification.from_pretrained(lowerCamelCase__       )
                 self.assertIsNotNone(lowerCamelCase__       )
                 self.assertIsInstance(lowerCamelCase__						,lowerCamelCase__       )






     @slow
     def 				SCREAMING_SNAKE_CASE__  (							self						:    int       )     ->		Union[str, Any]:




           '''simple docstring'''


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

                 SCREAMING_SNAKE_CASE		=						TFAutoModelForQuestionAnswering.from_pretrained(lowerCamelCase__       )
                 self.assertIsNotNone(lowerCamelCase__       )
                 self.assertIsInstance(lowerCamelCase__						,lowerCamelCase__       )






     @slow
     @require_tensorflow_probability
     def 				SCREAMING_SNAKE_CASE__  (							self						:    Union[str, Any]       )     ->		str:




           '''simple docstring'''


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

                 SCREAMING_SNAKE_CASE		=						TFAutoModelForTableQuestionAnswering.from_pretrained(lowerCamelCase__       )
                 SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE		=						TFAutoModelForTableQuestionAnswering.from_pretrained(
                     lowerCamelCase__						,output_loading_info=lowerCamelCase__       )
                 self.assertIsNotNone(lowerCamelCase__       )
                 self.assertIsInstance(lowerCamelCase__						,lowerCamelCase__       )






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						TFAutoModelWithLMHead.from_pretrained(lowerCamelCase__       )
           self.assertIsInstance(lowerCamelCase__						,lowerCamelCase__       )
           self.assertEqual(model.num_parameters()						,14410       )
           self.assertEqual(model.num_parameters(only_trainable=lowerCamelCase__       )						,14410       )






     def 				SCREAMING_SNAKE_CASE__  (							self						:    List[str]       )     ->		List[str]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						TFAutoModelWithLMHead.from_pretrained(lowerCamelCase__       )
           self.assertIsInstance(lowerCamelCase__						,lowerCamelCase__       )
           self.assertEqual(model.num_parameters()						,14410       )
           self.assertEqual(model.num_parameters(only_trainable=lowerCamelCase__       )						,14410       )






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




           '''simple docstring'''


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

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

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






     def 				SCREAMING_SNAKE_CASE__  (							self						:    Optional[int]       )     ->		str:




           '''simple docstring'''


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

                 SCREAMING_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(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
                             SCREAMING_SNAKE_CASE		=						BertModelTester(self       ).get_config()
                             SCREAMING_SNAKE_CASE		=						NewModelConfig(**tiny_config.to_dict()       )
                             SCREAMING_SNAKE_CASE		=						auto_class.from_config(lowerCamelCase__       )
                             self.assertIsInstance(lowerCamelCase__						,lowerCamelCase__       )

                             with tempfile.TemporaryDirectory() as tmp_dir:
                                   model.save_pretrained(lowerCamelCase__       )
                                   SCREAMING_SNAKE_CASE		=						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 				SCREAMING_SNAKE_CASE__  (							self						:    Union[str, Any]       )     ->		Optional[int]:




           '''simple docstring'''


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






     def 				SCREAMING_SNAKE_CASE__  (							self						:    Dict       )     ->		List[str]:




           '''simple docstring'''


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






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




           '''simple docstring'''


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






     def 				SCREAMING_SNAKE_CASE__  (							self						:    int       )     ->		Optional[Any]:




           '''simple docstring'''


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






     def 				SCREAMING_SNAKE_CASE__  (							self						:    Any       )     ->		str:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						TFAutoModel.from_pretrained("""hf-internal-testing/tiny-random-bert"""       )
           with RequestCounter() as counter:
                 SCREAMING_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
           SCREAMING_SNAKE_CASE		=						TFAutoModel.from_pretrained("""ArthurZ/tiny-random-bert-sharded"""       )
           with RequestCounter() as counter:
                 SCREAMING_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 copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


SCREAMING_SNAKE_CASE_						   =       logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_						   =       {
    """microsoft/git-base""": """https://huggingface.co/microsoft/git-base/resolve/main/config.json""",
}

class 		UpperCamelCase__ (      lowerCAmelCase_   ):



     '''simple docstring'''

     __snake_case    :	Dict			=			"git_vision_model"






     def __init__(							self						:    List[Any]						,lowerCamelCase__						:    Dict=768						,lowerCamelCase__						:    Union[str, Any]=3072						,lowerCamelCase__						:    Optional[int]=12						,lowerCamelCase__						:    Tuple=12						,lowerCamelCase__						:    Tuple=3						,lowerCamelCase__						:    Optional[Any]=224						,lowerCamelCase__						:    Union[str, Any]=16						,lowerCamelCase__						:    List[Any]="quick_gelu"						,lowerCamelCase__						:    Optional[Any]=1e-5						,lowerCamelCase__						:    str=0.0						,lowerCamelCase__						:    Optional[int]=0.02						,**lowerCamelCase__						:    Union[str, Any]						,)     ->		Optional[int]:




           '''simple docstring'''


           super().__init__(**lowerCamelCase__       )

           SCREAMING_SNAKE_CASE		=						hidden_size
           SCREAMING_SNAKE_CASE		=						intermediate_size
           SCREAMING_SNAKE_CASE		=						num_hidden_layers
           SCREAMING_SNAKE_CASE		=						num_attention_heads
           SCREAMING_SNAKE_CASE		=						num_channels
           SCREAMING_SNAKE_CASE		=						patch_size
           SCREAMING_SNAKE_CASE		=						image_size
           SCREAMING_SNAKE_CASE		=						initializer_range
           SCREAMING_SNAKE_CASE		=						attention_dropout
           SCREAMING_SNAKE_CASE		=						layer_norm_eps
           SCREAMING_SNAKE_CASE		=						hidden_act






     @classmethod
     def 				SCREAMING_SNAKE_CASE__  (							cls						:    Tuple						,lowerCamelCase__						:    Union[str, os.PathLike]						,**lowerCamelCase__						:    int       )     ->		"PretrainedConfig":




           '''simple docstring'''


           cls._set_token_in_kwargs(lowerCamelCase__       )

           SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE		=						cls.get_config_dict(lowerCamelCase__						,**lowerCamelCase__       )

           # get the vision config dict if we are loading from GITConfig
           if config_dict.get("""model_type"""       ) == "git":
                 SCREAMING_SNAKE_CASE		=						config_dict["""vision_config"""]

           if "model_type" in config_dict and hasattr(cls						,"""model_type"""       ) and config_dict["model_type"] != cls.model_type:
                 logger.warning(
                     F"""You are using a model of type {config_dict['model_type']} to instantiate a model of type """
                     F"""{cls.model_type}. This is not supported for all configurations of models and can yield errors."""       )

           return cls.from_dict(lowerCamelCase__						,**lowerCamelCase__       )

class 		UpperCamelCase__ (      lowerCAmelCase_   ):



     '''simple docstring'''

     __snake_case    :	Dict			=			"git"






     def __init__(							self						:    Optional[int]						,lowerCamelCase__						:    int=None						,lowerCamelCase__						:    str=30522						,lowerCamelCase__						:    Tuple=768						,lowerCamelCase__						:    Union[str, Any]=6						,lowerCamelCase__						:    str=12						,lowerCamelCase__						:    List[str]=3072						,lowerCamelCase__						:    Dict="gelu"						,lowerCamelCase__						:    Tuple=0.1						,lowerCamelCase__						:    Any=0.1						,lowerCamelCase__						:    List[str]=1024						,lowerCamelCase__						:    List[str]=0.02						,lowerCamelCase__						:    str=1e-1_2						,lowerCamelCase__						:    Optional[int]=0						,lowerCamelCase__						:    Optional[int]="absolute"						,lowerCamelCase__						:    Optional[Any]=True						,lowerCamelCase__						:    str=False						,lowerCamelCase__						:    int=101						,lowerCamelCase__						:    int=102						,lowerCamelCase__						:    Dict=None						,**lowerCamelCase__						:    List[Any]						,)     ->		Optional[Any]:




           '''simple docstring'''


           super().__init__(bos_token_id=lowerCamelCase__						,eos_token_id=lowerCamelCase__						,pad_token_id=lowerCamelCase__						,**lowerCamelCase__       )

           if vision_config is None:
                 SCREAMING_SNAKE_CASE		=						{}
                 logger.info("""vision_config is None. initializing the GitVisionConfig with default values."""       )

           SCREAMING_SNAKE_CASE		=						GitVisionConfig(**lowerCamelCase__       )
           SCREAMING_SNAKE_CASE		=						vocab_size
           SCREAMING_SNAKE_CASE		=						hidden_size
           SCREAMING_SNAKE_CASE		=						num_hidden_layers
           SCREAMING_SNAKE_CASE		=						num_attention_heads
           SCREAMING_SNAKE_CASE		=						hidden_act
           SCREAMING_SNAKE_CASE		=						intermediate_size
           SCREAMING_SNAKE_CASE		=						hidden_dropout_prob
           SCREAMING_SNAKE_CASE		=						attention_probs_dropout_prob
           SCREAMING_SNAKE_CASE		=						max_position_embeddings
           SCREAMING_SNAKE_CASE		=						initializer_range
           SCREAMING_SNAKE_CASE		=						layer_norm_eps
           SCREAMING_SNAKE_CASE		=						position_embedding_type
           SCREAMING_SNAKE_CASE		=						use_cache
           SCREAMING_SNAKE_CASE		=						tie_word_embeddings
           SCREAMING_SNAKE_CASE		=						num_image_with_embedding

           SCREAMING_SNAKE_CASE		=						bos_token_id
           SCREAMING_SNAKE_CASE		=						eos_token_id






     def 				SCREAMING_SNAKE_CASE__  (							self						:    Dict       )     ->		Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						copy.deepcopy(self.__dict__       )
           SCREAMING_SNAKE_CASE		=						self.vision_config.to_dict()
           SCREAMING_SNAKE_CASE		=						self.__class__.model_type
           return output


