

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 			_SCREAMING_SNAKE_CASE (   __snake_case		):







   '''simple docstring'''




   lowerCamelCase__				=      "new-model"


if is_tf_available():





    class 			_SCREAMING_SNAKE_CASE (   __snake_case		):







       '''simple docstring'''




       lowerCamelCase__				=      NewModelConfig





@require_tf
class 			_SCREAMING_SNAKE_CASE (   unittest.TestCase		):







   '''simple docstring'''




   @slow
   def      _snake_case		(       self					:			int			):
       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      _snake_case		(       self					:			List[str]			):
       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      _snake_case		(       self					:			int			):
       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      _snake_case		(       self					:			Tuple			):
       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      _snake_case		(       self					:			int			):
       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      _snake_case		(       self					:			List[str]			):
       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      _snake_case		(       self					:			Optional[Any]			):
       # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       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      _snake_case		(       self					:			Tuple			):
       # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       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      _snake_case		(       self					:			Union[str, Any]			):
       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      _snake_case		(       self					:			List[Any]			):
       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      _snake_case		(       self					:			List[str]			):
       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      _snake_case		(       self					:			List[Any]			):
       # For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel
       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      _snake_case		(       self					:			List[Any]			):
       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      _snake_case		(       self					:			Optional[int]			):
       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      _snake_case		(       self					:			Any			):
       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      _snake_case		(       self					:			str			):
       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      _snake_case		(       self					:			Tuple			):
       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      _snake_case		(       self					:			int			):
       # Make sure we have cached the model.
       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			)


from collections.abc import Callable

import numpy as np





def 	__a     (      A__			:  Callable			,  A__			:  float			,  A__			:  float			,  A__			:  float			,  A__			:  float       ):
    SCREAMING_SNAKE_CASE										=   int(np.ceil((x_end - xa) / step_size       )       )
    SCREAMING_SNAKE_CASE										=   np.zeros((n + 1,)       )
    SCREAMING_SNAKE_CASE										=   ya
    SCREAMING_SNAKE_CASE										=   xa

    for k in range(A__       ):
        SCREAMING_SNAKE_CASE										=   y[k] + step_size * ode_func(A__			,  y[k]       )
        SCREAMING_SNAKE_CASE										=   y[k] + (
            (step_size / 2) * (ode_func(A__			,  y[k]       ) + ode_func(x + step_size			,  A__       ))
        )
        x += step_size

    return y


if __name__ == "__main__":
    import doctest

    doctest.testmod()