





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							(      __UpperCamelCase    ):
 UpperCAmelCase__									=	"""new-model"""


if is_tf_available():

    class      lowerCAmelCase							(      __UpperCamelCase    ):
     UpperCAmelCase__									=	NewModelConfig

@require_tf
class      lowerCAmelCase							(      unittest.TestCase    ):
 @slow
 def   A_			(   self						:   Optional[Any]			)    ->			Union[str, Any]:
     lowerCamelCase__					:   str      				=	'bert-base-cased'
     lowerCamelCase__					:   str      				=	AutoConfig.from_pretrained(__A			)
     self.assertIsNotNone(__A			)
     self.assertIsInstance(__A    ,  __A			)

     lowerCamelCase__					:   Tuple      				=	TFAutoModel.from_pretrained(__A			)
     self.assertIsNotNone(__A			)
     self.assertIsInstance(__A    ,  __A			)
 @slow
 def   A_			(   self						:   Optional[int]			)    ->			Any:
     lowerCamelCase__					:   List[str]      				=	'bert-base-cased'
     lowerCamelCase__					:   Union[str, Any]      				=	AutoConfig.from_pretrained(__A			)
     self.assertIsNotNone(__A			)
     self.assertIsInstance(__A    ,  __A			)

     lowerCamelCase__					:   List[Any]      				=	TFAutoModelForPreTraining.from_pretrained(__A			)
     self.assertIsNotNone(__A			)
     self.assertIsInstance(__A    ,  __A			)
 @slow
 def   A_			(   self						:   Dict			)    ->			List[str]:
     for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         lowerCamelCase__					:   str      				=	AutoConfig.from_pretrained(__A			)
         self.assertIsNotNone(__A			)
         self.assertIsInstance(__A    ,  __A			)

         lowerCamelCase__					:   Optional[Any]      				=	TFAutoModelForCausalLM.from_pretrained(__A			)
         lowerCamelCase__				,							lowerCamelCase__					:   List[Any]      				=	TFAutoModelForCausalLM.from_pretrained(__A    ,  output_loading_info=__A			)
         self.assertIsNotNone(__A			)
         self.assertIsInstance(__A    ,  __A			)
 @slow
 def   A_			(   self						:   Tuple			)    ->			str:
     for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         lowerCamelCase__					:   str      				=	AutoConfig.from_pretrained(__A			)
         self.assertIsNotNone(__A			)
         self.assertIsInstance(__A    ,  __A			)

         lowerCamelCase__					:   str      				=	TFAutoModelWithLMHead.from_pretrained(__A			)
         self.assertIsNotNone(__A			)
         self.assertIsInstance(__A    ,  __A			)
 @slow
 def   A_			(   self						:   int			)    ->			int:
     for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         lowerCamelCase__					:   Any      				=	AutoConfig.from_pretrained(__A			)
         self.assertIsNotNone(__A			)
         self.assertIsInstance(__A    ,  __A			)

         lowerCamelCase__					:   Tuple      				=	TFAutoModelForMaskedLM.from_pretrained(__A			)
         lowerCamelCase__				,							lowerCamelCase__					:   int      				=	TFAutoModelForMaskedLM.from_pretrained(__A    ,  output_loading_info=__A			)
         self.assertIsNotNone(__A			)
         self.assertIsInstance(__A    ,  __A			)
 @slow
 def   A_			(   self						:   str			)    ->			Optional[Any]:
     for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         lowerCamelCase__					:   Any      				=	AutoConfig.from_pretrained(__A			)
         self.assertIsNotNone(__A			)
         self.assertIsInstance(__A    ,  __A			)

         lowerCamelCase__					:   int      				=	TFAutoModelForSeqaSeqLM.from_pretrained(__A			)
         lowerCamelCase__				,							lowerCamelCase__					:   int      				=	TFAutoModelForSeqaSeqLM.from_pretrained(__A    ,  output_loading_info=__A			)
         self.assertIsNotNone(__A			)
         self.assertIsInstance(__A    ,  __A			)
 @slow
 def   A_			(   self						:   Union[str, Any]			)    ->			List[Any]:
     # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     for model_name in ["bert-base-uncased"]:
         lowerCamelCase__					:   Dict      				=	AutoConfig.from_pretrained(__A			)
         self.assertIsNotNone(__A			)
         self.assertIsInstance(__A    ,  __A			)

         lowerCamelCase__					:   str      				=	TFAutoModelForSequenceClassification.from_pretrained(__A			)
         self.assertIsNotNone(__A			)
         self.assertIsInstance(__A    ,  __A			)
 @slow
 def   A_			(   self						:   Optional[int]			)    ->			List[Any]:
     # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     for model_name in ["bert-base-uncased"]:
         lowerCamelCase__					:   Tuple      				=	AutoConfig.from_pretrained(__A			)
         self.assertIsNotNone(__A			)
         self.assertIsInstance(__A    ,  __A			)

         lowerCamelCase__					:   Any      				=	TFAutoModelForQuestionAnswering.from_pretrained(__A			)
         self.assertIsNotNone(__A			)
         self.assertIsInstance(__A    ,  __A			)
 @slow
 @require_tensorflow_probability
 def   A_			(   self						:   Any			)    ->			str:
     for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
         lowerCamelCase__					:   Dict      				=	AutoConfig.from_pretrained(__A			)
         self.assertIsNotNone(__A			)
         self.assertIsInstance(__A    ,  __A			)

         lowerCamelCase__					:   List[Any]      				=	TFAutoModelForTableQuestionAnswering.from_pretrained(__A			)
         lowerCamelCase__				,							lowerCamelCase__					:   Tuple      				=	TFAutoModelForTableQuestionAnswering.from_pretrained(
             __A    ,  output_loading_info=__A			)
         self.assertIsNotNone(__A			)
         self.assertIsInstance(__A    ,  __A			)
 def   A_			(   self						:   List[str]			)    ->			Dict:
     lowerCamelCase__					:   Tuple      				=	TFAutoModelWithLMHead.from_pretrained(__A			)
     self.assertIsInstance(__A    ,  __A			)
     self.assertEqual(model.num_parameters()    ,  14410			)
     self.assertEqual(model.num_parameters(only_trainable=__A			)    ,  14410			)
 def   A_			(   self						:   Union[str, Any]			)    ->			Optional[int]:
     lowerCamelCase__					:   Optional[int]      				=	TFAutoModelWithLMHead.from_pretrained(__A			)
     self.assertIsInstance(__A    ,  __A			)
     self.assertEqual(model.num_parameters()    ,  14410			)
     self.assertEqual(model.num_parameters(only_trainable=__A			)    ,  14410			)
 def   A_			(   self						:   Optional[Any]			)    ->			Optional[Any]:
     # For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel
     lowerCamelCase__					:   List[str]      				=	TFAutoModel.from_pretrained('sgugger/funnel-random-tiny'			)
     self.assertIsInstance(__A    ,  __A			)

     lowerCamelCase__					:   List[str]      				=	copy.deepcopy(model.config			)
     lowerCamelCase__					:   List[Any]      				=	['FunnelBaseModel']
     lowerCamelCase__					:   List[str]      				=	TFAutoModel.from_config(__A			)
     self.assertIsInstance(__A    ,  __A			)

     with tempfile.TemporaryDirectory() as tmp_dir:
         model.save_pretrained(__A			)
         lowerCamelCase__					:   Any      				=	TFAutoModel.from_pretrained(__A			)
         self.assertIsInstance(__A    ,  __A			)
 def   A_			(   self						:   Optional[Any]			)    ->			int:
     try:
         AutoConfig.register('new-model'    ,  __A			)

         lowerCamelCase__					:   Dict      				=	[
             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
                 lowerCamelCase__					:   List[Any]      				=	BertModelTester(self			).get_config()
                 lowerCamelCase__					:   Tuple      				=	NewModelConfig(**tiny_config.to_dict()			)
                 lowerCamelCase__					:   Optional[Any]      				=	auto_class.from_config(__A			)
                 self.assertIsInstance(__A    ,  __A			)

                 with tempfile.TemporaryDirectory() as tmp_dir:
                     model.save_pretrained(__A			)
                     lowerCamelCase__					:   List[Any]      				=	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   A_			(   self						:   Optional[Any]			)    ->			int:
     with self.assertRaisesRegex(
         __A    ,  'bert-base is not a local folder and is not a valid model identifier'			):
         lowerCamelCase__					:   Optional[Any]      				=	TFAutoModel.from_pretrained('bert-base'			)
 def   A_			(   self						:   List[str]			)    ->			List[Any]:
     with self.assertRaisesRegex(
         __A    ,  R'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'			):
         lowerCamelCase__					:   str      				=	TFAutoModel.from_pretrained(__A    ,  revision='aaaaaa'			)
 def   A_			(   self						:   Tuple			)    ->			Optional[int]:
     with self.assertRaisesRegex(
         __A    ,  'hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin'    ,  ):
         lowerCamelCase__					:   List[str]      				=	TFAutoModel.from_pretrained('hf-internal-testing/config-no-model'			)
 def   A_			(   self						:   int			)    ->			List[Any]:
     with self.assertRaisesRegex(__A    ,  'Use `from_pt=True` to load this model'			):
         lowerCamelCase__					:   Dict      				=	TFAutoModel.from_pretrained('hf-internal-testing/tiny-bert-pt-only'			)







 def   A_			(   self						:   List[str]			)    ->			List[str]:
     # Make sure we have cached the model.
     lowerCamelCase__					:   Optional[int]      				=	TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert'			)
     with RequestCounter() as counter:
         lowerCamelCase__					:   Union[str, Any]      				=	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__					:   Optional[Any]      				=	TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded'			)
     with RequestCounter() as counter:
         lowerCamelCase__					:   str      				=	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

from collections.abc import Generator


def  SCREAMING_SNAKE_CASE   ( )    ->  Generator[int, None, None]:
    lowerCamelCase__					:   dict[int, int]      				=	{}
    lowerCamelCase__					:   Union[str, Any]      				=	2
    while True:
        lowerCamelCase__					:   Optional[int]      				=	factor_map.pop(_UpperCAmelCase		,			_UpperCAmelCase				)
        if factor:
            lowerCamelCase__					:   Optional[Any]      				=	factor + prime
            while x in factor_map:
                x += factor
            lowerCamelCase__					:   Optional[Any]      				=	factor
        else:
            lowerCamelCase__					:   Union[str, Any]      				=	prime
            yield prime
        prime += 1


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase = 1e10				)    ->  int:
    lowerCamelCase__					:   Tuple      				=	sieve()

    lowerCamelCase__					:   Dict      				=	1
    while True:
        lowerCamelCase__					:   List[Any]      				=	next(_UpperCAmelCase				)
        if (2 * prime * n) > limit:
            return n
        # Ignore the next prime as the reminder will be 2.
        next(_UpperCAmelCase				)
        n += 2


if __name__ == "__main__":
    print(solution())





