

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					):
    __lowerCamelCase						:	Tuple														=					"""new-model"""


if is_tf_available():


       class 				SCREAMING_SNAKE_CASE__ (__snake_case					):
           __lowerCamelCase						:	Dict														=					NewModelConfig


@require_tf
class 				SCREAMING_SNAKE_CASE__ (unittest.TestCase					):





    @slow
    def 				snake_case_    (				self):
         lowercase__   :       Optional[int]				=	'bert-base-cased'
         lowercase__   :       Optional[Any]				=	AutoConfig.from_pretrained(a)
         self.assertIsNotNone(a)
         self.assertIsInstance(a						,       a)

         lowercase__   :       str				=	TFAutoModel.from_pretrained(a)
         self.assertIsNotNone(a)
         self.assertIsInstance(a						,       a)





    @slow
    def 				snake_case_    (				self):
         lowercase__   :       Optional[int]				=	'bert-base-cased'
         lowercase__   :       int				=	AutoConfig.from_pretrained(a)
         self.assertIsNotNone(a)
         self.assertIsInstance(a						,       a)

         lowercase__   :       Union[str, Any]				=	TFAutoModelForPreTraining.from_pretrained(a)
         self.assertIsNotNone(a)
         self.assertIsInstance(a						,       a)





    @slow
    def 				snake_case_    (				self):
         for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              lowercase__   :       int				=	AutoConfig.from_pretrained(a)
              self.assertIsNotNone(a)
              self.assertIsInstance(a						,       a)

              lowercase__   :       List[Any]				=	TFAutoModelForCausalLM.from_pretrained(a)
              lowercase__				,			lowercase__   :       List[str]				=	TFAutoModelForCausalLM.from_pretrained(a						,       output_loading_info=a)
              self.assertIsNotNone(a)
              self.assertIsInstance(a						,       a)





    @slow
    def 				snake_case_    (				self):
         for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              lowercase__   :       List[str]				=	AutoConfig.from_pretrained(a)
              self.assertIsNotNone(a)
              self.assertIsInstance(a						,       a)

              lowercase__   :       List[Any]				=	TFAutoModelWithLMHead.from_pretrained(a)
              self.assertIsNotNone(a)
              self.assertIsInstance(a						,       a)





    @slow
    def 				snake_case_    (				self):
         for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              lowercase__   :       Optional[Any]				=	AutoConfig.from_pretrained(a)
              self.assertIsNotNone(a)
              self.assertIsInstance(a						,       a)

              lowercase__   :       Optional[int]				=	TFAutoModelForMaskedLM.from_pretrained(a)
              lowercase__				,			lowercase__   :       List[str]				=	TFAutoModelForMaskedLM.from_pretrained(a						,       output_loading_info=a)
              self.assertIsNotNone(a)
              self.assertIsInstance(a						,       a)





    @slow
    def 				snake_case_    (				self):
         for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              lowercase__   :       Tuple				=	AutoConfig.from_pretrained(a)
              self.assertIsNotNone(a)
              self.assertIsInstance(a						,       a)

              lowercase__   :       List[str]				=	TFAutoModelForSeqaSeqLM.from_pretrained(a)
              lowercase__				,			lowercase__   :       Optional[int]				=	TFAutoModelForSeqaSeqLM.from_pretrained(a						,       output_loading_info=a)
              self.assertIsNotNone(a)
              self.assertIsInstance(a						,       a)





    @slow
    def 				snake_case_    (				self):
         # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         for model_name in ["bert-base-uncased"]:
              lowercase__   :       Dict				=	AutoConfig.from_pretrained(a)
              self.assertIsNotNone(a)
              self.assertIsInstance(a						,       a)

              lowercase__   :       Tuple				=	TFAutoModelForSequenceClassification.from_pretrained(a)
              self.assertIsNotNone(a)
              self.assertIsInstance(a						,       a)





    @slow
    def 				snake_case_    (				self):
         # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         for model_name in ["bert-base-uncased"]:
              lowercase__   :       Any				=	AutoConfig.from_pretrained(a)
              self.assertIsNotNone(a)
              self.assertIsInstance(a						,       a)

              lowercase__   :       int				=	TFAutoModelForQuestionAnswering.from_pretrained(a)
              self.assertIsNotNone(a)
              self.assertIsInstance(a						,       a)





    @slow
    @require_tensorflow_probability
    def 				snake_case_    (				self):
         for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
              lowercase__   :       Any				=	AutoConfig.from_pretrained(a)
              self.assertIsNotNone(a)
              self.assertIsInstance(a						,       a)

              lowercase__   :       Tuple				=	TFAutoModelForTableQuestionAnswering.from_pretrained(a)
              lowercase__				,			lowercase__   :       Any				=	TFAutoModelForTableQuestionAnswering.from_pretrained(
                  a						,       output_loading_info=a)
              self.assertIsNotNone(a)
              self.assertIsInstance(a						,       a)





    def 				snake_case_    (				self):
         lowercase__   :       Union[str, Any]				=	TFAutoModelWithLMHead.from_pretrained(a)
         self.assertIsInstance(a						,       a)
         self.assertEqual(model.num_parameters()						,       1_4410)
         self.assertEqual(model.num_parameters(only_trainable=a)						,       1_4410)





    def 				snake_case_    (				self):
         lowercase__   :       int				=	TFAutoModelWithLMHead.from_pretrained(a)
         self.assertIsInstance(a						,       a)
         self.assertEqual(model.num_parameters()						,       1_4410)
         self.assertEqual(model.num_parameters(only_trainable=a)						,       1_4410)





    def 				snake_case_    (				self):
         # For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel
         lowercase__   :       Tuple				=	TFAutoModel.from_pretrained('sgugger/funnel-random-tiny')
         self.assertIsInstance(a						,       a)

         lowercase__   :       List[str]				=	copy.deepcopy(model.config)
         lowercase__   :       Tuple				=	['FunnelBaseModel']
         lowercase__   :       Union[str, Any]				=	TFAutoModel.from_config(a)
         self.assertIsInstance(a						,       a)

         with tempfile.TemporaryDirectory() as tmp_dir:
              model.save_pretrained(a)
              lowercase__   :       str				=	TFAutoModel.from_pretrained(a)
              self.assertIsInstance(a						,       a)





    def 				snake_case_    (				self):
         try:
              AutoConfig.register('new-model'						,       a)

              lowercase__   :       List[str]				=	[
                  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(a):
                             auto_class.register(a						,       a)
                        auto_class.register(a						,       a)
                        # Trying to register something existing in the Transformers library will raise an error
                        with self.assertRaises(a):
                             auto_class.register(a						,       a)

                        # Now that the config is registered, it can be used as any other config with the auto-API
                        lowercase__   :       List[str]				=	BertModelTester(self).get_config()
                        lowercase__   :       Dict				=	NewModelConfig(**tiny_config.to_dict())
                        lowercase__   :       str				=	auto_class.from_config(a)
                        self.assertIsInstance(a						,       a)

                        with tempfile.TemporaryDirectory() as tmp_dir:
                             model.save_pretrained(a)
                             lowercase__   :       Tuple				=	auto_class.from_pretrained(a)
                             self.assertIsInstance(a						,       a)

         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):
         with self.assertRaisesRegex(
             a						,       'bert-base is not a local folder and is not a valid model identifier'):
              lowercase__   :       int				=	TFAutoModel.from_pretrained('bert-base')





    def 				snake_case_    (				self):
         with self.assertRaisesRegex(
             a						,       r'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'):
              lowercase__   :       Optional[int]				=	TFAutoModel.from_pretrained(a						,       revision='aaaaaa')





    def 				snake_case_    (				self):
         with self.assertRaisesRegex(
             a						,       'hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin'						,       ):
              lowercase__   :       int				=	TFAutoModel.from_pretrained('hf-internal-testing/config-no-model')





    def 				snake_case_    (				self):
         with self.assertRaisesRegex(a						,       'Use `from_pt=True` to load this model'):
              lowercase__   :       Tuple				=	TFAutoModel.from_pretrained('hf-internal-testing/tiny-bert-pt-only')





    def 				snake_case_    (				self):
         # Make sure we have cached the model.
         lowercase__   :       int				=	TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert')
         with RequestCounter() as counter:
              lowercase__   :       int				=	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
         lowercase__   :       Tuple				=	TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded')
         with RequestCounter() as counter:
              lowercase__   :       Any				=	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 __future__ import annotations

import math

def      snake_case__      (   SCREAMING_SNAKE_CASE_		:   int      ):



     '''simple docstring'''





     if 1 < number < 4:
          # 2 and 3 are primes
          return True
     elif number < 2 or number % 2 == 0 or number % 3 == 0:
          # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
          return False

     # All primes number are in format of 6k +/- 1
     for i in range(5     ,					int(math.sqrt(SCREAMING_SNAKE_CASE_      ) + 1      )     ,					6      ):
          if number % i == 0 or number % (i + 2) == 0:
               return False
     return True

def      snake_case__      (   SCREAMING_SNAKE_CASE_		:   int      ):



     '''simple docstring'''





     lowercase__   :       int				=	str(SCREAMING_SNAKE_CASE_      )
     lowercase__   :       Union[str, Any]				=	[n]
     for i in range(1     ,					len(SCREAMING_SNAKE_CASE_      )      ):
          list_nums.append(int(str_num[i:]      )      )
          list_nums.append(int(str_num[:-i]      )      )
     return list_nums

def      snake_case__      (   SCREAMING_SNAKE_CASE_		:   int      ):



     '''simple docstring'''





     if len(str(SCREAMING_SNAKE_CASE_      )      ) > 3:
          if not is_prime(int(str(SCREAMING_SNAKE_CASE_      )[-3:]      )      ) or not is_prime(int(str(SCREAMING_SNAKE_CASE_      )[:3]      )      ):
               return False
     return True

def      snake_case__      (   SCREAMING_SNAKE_CASE_		:   int = 11      ):



     '''simple docstring'''





     lowercase__   :       list[int]				=	[]
     lowercase__   :       Tuple				=	13
     while len(SCREAMING_SNAKE_CASE_      ) != count:
          if validate(SCREAMING_SNAKE_CASE_      ):
               lowercase__   :       Optional[int]				=	list_truncated_nums(SCREAMING_SNAKE_CASE_      )
               if all(is_prime(SCREAMING_SNAKE_CASE_      ) for i in list_nums      ):
                    list_truncated_primes.append(SCREAMING_SNAKE_CASE_      )
          num += 2
     return list_truncated_primes

def      snake_case__      (   ):



     '''simple docstring'''





     return sum(compute_truncated_primes(11      )      )


if __name__ == "__main__":
       print(F'''{sum(compute_truncated_primes(11)) = }''')

