


'''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      snake_case    (    __lowerCAmelCase			):





  """simple docstring"""




  _lowerCamelCase		    =  "new-model"


if is_tf_available():





     class      snake_case    (    __lowerCAmelCase			):





       """simple docstring"""




       _lowerCamelCase		    =  NewModelConfig





@require_tf
class      snake_case    (    unittest.TestCase			):





  """simple docstring"""




  @slow
  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  'bert-base-cased'
   lowerCamelCase_      =  AutoConfig.from_pretrained(UpperCamelCase     )
   self.assertIsNotNone(UpperCamelCase     )
   self.assertIsInstance(UpperCamelCase			,  UpperCamelCase     )

   lowerCamelCase_      =  TFAutoModel.from_pretrained(UpperCamelCase     )
   self.assertIsNotNone(UpperCamelCase     )
   self.assertIsInstance(UpperCamelCase			,  UpperCamelCase     )






  @slow
  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  'bert-base-cased'
   lowerCamelCase_      =  AutoConfig.from_pretrained(UpperCamelCase     )
   self.assertIsNotNone(UpperCamelCase     )
   self.assertIsInstance(UpperCamelCase			,  UpperCamelCase     )

   lowerCamelCase_      =  TFAutoModelForPreTraining.from_pretrained(UpperCamelCase     )
   self.assertIsNotNone(UpperCamelCase     )
   self.assertIsInstance(UpperCamelCase			,  UpperCamelCase     )






  @slow
  def   snake_case		(    self     ):







   """simple docstring"""





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

    lowerCamelCase_      =  TFAutoModelForCausalLM.from_pretrained(UpperCamelCase     )
    lowerCamelCase_      =  TFAutoModelForCausalLM.from_pretrained(UpperCamelCase			,  output_loading_info=UpperCamelCase     )
    self.assertIsNotNone(UpperCamelCase     )
    self.assertIsInstance(UpperCamelCase			,  UpperCamelCase     )






  @slow
  def   snake_case		(    self     ):







   """simple docstring"""





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

    lowerCamelCase_      =  TFAutoModelWithLMHead.from_pretrained(UpperCamelCase     )
    self.assertIsNotNone(UpperCamelCase     )
    self.assertIsInstance(UpperCamelCase			,  UpperCamelCase     )






  @slow
  def   snake_case		(    self     ):







   """simple docstring"""





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

    lowerCamelCase_      =  TFAutoModelForMaskedLM.from_pretrained(UpperCamelCase     )
    lowerCamelCase_      =  TFAutoModelForMaskedLM.from_pretrained(UpperCamelCase			,  output_loading_info=UpperCamelCase     )
    self.assertIsNotNone(UpperCamelCase     )
    self.assertIsInstance(UpperCamelCase			,  UpperCamelCase     )






  @slow
  def   snake_case		(    self     ):







   """simple docstring"""





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

    lowerCamelCase_      =  TFAutoModelForSeqaSeqLM.from_pretrained(UpperCamelCase     )
    lowerCamelCase_      =  TFAutoModelForSeqaSeqLM.from_pretrained(UpperCamelCase			,  output_loading_info=UpperCamelCase     )
    self.assertIsNotNone(UpperCamelCase     )
    self.assertIsInstance(UpperCamelCase			,  UpperCamelCase     )






  @slow
  def   snake_case		(    self     ):







   """simple docstring"""





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

    lowerCamelCase_      =  TFAutoModelForSequenceClassification.from_pretrained(UpperCamelCase     )
    self.assertIsNotNone(UpperCamelCase     )
    self.assertIsInstance(UpperCamelCase			,  UpperCamelCase     )






  @slow
  def   snake_case		(    self     ):







   """simple docstring"""





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

    lowerCamelCase_      =  TFAutoModelForQuestionAnswering.from_pretrained(UpperCamelCase     )
    self.assertIsNotNone(UpperCamelCase     )
    self.assertIsInstance(UpperCamelCase			,  UpperCamelCase     )






  @slow
  @require_tensorflow_probability
  def   snake_case		(    self     ):







   """simple docstring"""





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

    lowerCamelCase_      =  TFAutoModelForTableQuestionAnswering.from_pretrained(UpperCamelCase     )
    lowerCamelCase_      =  TFAutoModelForTableQuestionAnswering.from_pretrained(
        UpperCamelCase			,  output_loading_info=UpperCamelCase     )
    self.assertIsNotNone(UpperCamelCase     )
    self.assertIsInstance(UpperCamelCase			,  UpperCamelCase     )






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  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   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  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   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  TFAutoModel.from_pretrained("sgugger/funnel-random-tiny"     )
   self.assertIsInstance(UpperCamelCase			,  UpperCamelCase     )

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

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






  def   snake_case		(    self     ):







   """simple docstring"""





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

    lowerCamelCase_      =  [
        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
      lowerCamelCase_      =  BertModelTester(self     ).get_config()
      lowerCamelCase_      =  NewModelConfig(**tiny_config.to_dict()     )
      lowerCamelCase_      =  auto_class.from_config(UpperCamelCase     )
      self.assertIsInstance(UpperCamelCase			,  UpperCamelCase     )

      with tempfile.TemporaryDirectory() as tmp_dir:
       model.save_pretrained(UpperCamelCase     )
       lowerCamelCase_      =  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   snake_case		(    self     ):







   """simple docstring"""





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






  def   snake_case		(    self     ):







   """simple docstring"""





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






  def   snake_case		(    self     ):







   """simple docstring"""





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






  def   snake_case		(    self     ):







   """simple docstring"""





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







  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  TFAutoModel.from_pretrained("hf-internal-testing/tiny-random-bert"     )
   with RequestCounter() as counter:
    lowerCamelCase_      =  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
   lowerCamelCase_      =  TFAutoModel.from_pretrained("ArthurZ/tiny-random-bert-sharded"     )
   with RequestCounter() as counter:
    lowerCamelCase_      =  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"""
import os
from typing import Dict, List, Tuple, TypeVar, Union


lowercase__					       =	TypeVar('T')

lowercase__					       =	Union[List[T], Tuple[T, ...]]
lowercase__					       =	Union[T, List[T], Dict[str, T]]
lowercase__					       =	Union[str, bytes, os.PathLike]


