

'''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 						lowerCAmelCase__   (      a					):



 """simple docstring"""



 lowerCAmelCase__  					=      "new-model"


if is_tf_available():







  class 						lowerCAmelCase__   (      a					):



   """simple docstring"""



   lowerCAmelCase__  					=      NewModelConfig







@require_tf
class 						lowerCAmelCase__   (      unittest.TestCase					):



 """simple docstring"""



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


      """simple docstring"""




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

      __SCREAMING_SNAKE_CASE     =      TFAutoModel.from_pretrained(__SCREAMING_SNAKE_CASE			)
      self.assertIsNotNone(__SCREAMING_SNAKE_CASE			)
      self.assertIsInstance(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
 @slow
 def       UpperCAmelCase__		(		self					:       str			)  -> List[Any]:


      """simple docstring"""




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

      __SCREAMING_SNAKE_CASE     =      TFAutoModelForPreTraining.from_pretrained(__SCREAMING_SNAKE_CASE			)
      self.assertIsNotNone(__SCREAMING_SNAKE_CASE			)
      self.assertIsInstance(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
 @slow
 def       UpperCAmelCase__		(		self					:       Optional[int]			)  -> List[str]:


      """simple docstring"""




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

           __SCREAMING_SNAKE_CASE     =      TFAutoModelForCausalLM.from_pretrained(__SCREAMING_SNAKE_CASE			)
           __SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE     =      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       UpperCAmelCase__		(		self					:       Tuple			)  -> Union[str, Any]:


      """simple docstring"""




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

           __SCREAMING_SNAKE_CASE     =      TFAutoModelWithLMHead.from_pretrained(__SCREAMING_SNAKE_CASE			)
           self.assertIsNotNone(__SCREAMING_SNAKE_CASE			)
           self.assertIsInstance(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
 @slow
 def       UpperCAmelCase__		(		self					:       Dict			)  -> Optional[Any]:


      """simple docstring"""




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

           __SCREAMING_SNAKE_CASE     =      TFAutoModelForMaskedLM.from_pretrained(__SCREAMING_SNAKE_CASE			)
           __SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE     =      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       UpperCAmelCase__		(		self					:       int			)  -> Union[str, Any]:


      """simple docstring"""




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

           __SCREAMING_SNAKE_CASE     =      TFAutoModelForSeqaSeqLM.from_pretrained(__SCREAMING_SNAKE_CASE			)
           __SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE     =      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       UpperCAmelCase__		(		self					:       List[str]			)  -> Optional[int]:


      """simple docstring"""




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

           __SCREAMING_SNAKE_CASE     =      TFAutoModelForSequenceClassification.from_pretrained(__SCREAMING_SNAKE_CASE			)
           self.assertIsNotNone(__SCREAMING_SNAKE_CASE			)
           self.assertIsInstance(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
 @slow
 def       UpperCAmelCase__		(		self					:       str			)  -> Union[str, Any]:


      """simple docstring"""




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

           __SCREAMING_SNAKE_CASE     =      TFAutoModelForQuestionAnswering.from_pretrained(__SCREAMING_SNAKE_CASE			)
           self.assertIsNotNone(__SCREAMING_SNAKE_CASE			)
           self.assertIsInstance(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
 @slow
 @require_tensorflow_probability
 def       UpperCAmelCase__		(		self					:       List[Any]			)  -> Optional[Any]:


      """simple docstring"""




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

           __SCREAMING_SNAKE_CASE     =      TFAutoModelForTableQuestionAnswering.from_pretrained(__SCREAMING_SNAKE_CASE			)
           __SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE     =      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       UpperCAmelCase__		(		self					:       Optional[int]			)  -> Optional[int]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      TFAutoModelWithLMHead.from_pretrained(__SCREAMING_SNAKE_CASE			)
      self.assertIsInstance(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
      self.assertEqual(model.num_parameters()					,							14_410			)
      self.assertEqual(model.num_parameters(only_trainable=__SCREAMING_SNAKE_CASE			)					,							14_410			)
 def       UpperCAmelCase__		(		self					:       Tuple			)  -> str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      TFAutoModelWithLMHead.from_pretrained(__SCREAMING_SNAKE_CASE			)
      self.assertIsInstance(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
      self.assertEqual(model.num_parameters()					,							14_410			)
      self.assertEqual(model.num_parameters(only_trainable=__SCREAMING_SNAKE_CASE			)					,							14_410			)
 def       UpperCAmelCase__		(		self					:       Dict			)  -> str:


      """simple docstring"""




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

      __SCREAMING_SNAKE_CASE     =      copy.deepcopy(model.config			)
      __SCREAMING_SNAKE_CASE     =      ["""FunnelBaseModel"""]
      __SCREAMING_SNAKE_CASE     =      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			)
           __SCREAMING_SNAKE_CASE     =      TFAutoModel.from_pretrained(__SCREAMING_SNAKE_CASE			)
           self.assertIsInstance(__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)
 def       UpperCAmelCase__		(		self					:       Any			)  -> Union[str, Any]:


      """simple docstring"""




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

           __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(__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
                     __SCREAMING_SNAKE_CASE     =      BertModelTester(self			).get_config()
                     __SCREAMING_SNAKE_CASE     =      NewModelConfig(**tiny_config.to_dict()			)
                     __SCREAMING_SNAKE_CASE     =      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			)
                          __SCREAMING_SNAKE_CASE     =      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       UpperCAmelCase__		(		self					:       str			)  -> Optional[int]:


      """simple docstring"""




      with self.assertRaisesRegex(
          __SCREAMING_SNAKE_CASE					,							"""bert-base is not a local folder and is not a valid model identifier"""			):
           __SCREAMING_SNAKE_CASE     =      TFAutoModel.from_pretrained("""bert-base"""			)
 def       UpperCAmelCase__		(		self					:       str			)  -> List[str]:


      """simple docstring"""




      with self.assertRaisesRegex(
          __SCREAMING_SNAKE_CASE					,							r"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""			):
           __SCREAMING_SNAKE_CASE     =      TFAutoModel.from_pretrained(__SCREAMING_SNAKE_CASE					,							revision="""aaaaaa"""			)
 def       UpperCAmelCase__		(		self					:       List[str]			)  -> int:


      """simple docstring"""




      with self.assertRaisesRegex(
          __SCREAMING_SNAKE_CASE					,							"""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       UpperCAmelCase__		(		self					:       Tuple			)  -> List[str]:


      """simple docstring"""




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


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


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









'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase :       Union[str, Any]			   =     {'configuration_sew': ['SEW_PRETRAINED_CONFIG_ARCHIVE_MAP', 'SEWConfig']}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase :       Union[str, Any]			   =     [
      'SEW_PRETRAINED_MODEL_ARCHIVE_LIST',
      'SEWForCTC',
      'SEWForSequenceClassification',
      'SEWModel',
      'SEWPreTrainedModel',
  ]

if TYPE_CHECKING:
  from .configuration_sew import SEW_PRETRAINED_CONFIG_ARCHIVE_MAP, SEWConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_sew import (
        SEW_PRETRAINED_MODEL_ARCHIVE_LIST,
        SEWForCTC,
        SEWForSequenceClassification,
        SEWModel,
        SEWPreTrainedModel,
    )


else:
  import sys

  UpperCAmelCase :       int			   =     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






