


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


if is_tf_available():



 class 		snake_case_(       a__			):
      __UpperCamelCase  =					NewModelConfig



@require_tf
class 		snake_case_(       unittest.TestCase			):






     @slow
     def      lowerCamelCase__     (	self  :					str				):
           lowerCAmelCase					:	List[Any]       =   '''bert-base-cased'''
           lowerCAmelCase					:	Tuple       =   AutoConfig.from_pretrained(UpperCamelCase_				)
           self.assertIsNotNone(UpperCamelCase_				)
           self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)

           lowerCAmelCase					:	List[str]       =   TFAutoModel.from_pretrained(UpperCamelCase_				)
           self.assertIsNotNone(UpperCamelCase_				)
           self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)






     @slow
     def      lowerCamelCase__     (	self  :					Dict				):
           lowerCAmelCase					:	Optional[int]       =   '''bert-base-cased'''
           lowerCAmelCase					:	Union[str, Any]       =   AutoConfig.from_pretrained(UpperCamelCase_				)
           self.assertIsNotNone(UpperCamelCase_				)
           self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)

           lowerCAmelCase					:	Optional[Any]       =   TFAutoModelForPreTraining.from_pretrained(UpperCamelCase_				)
           self.assertIsNotNone(UpperCamelCase_				)
           self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)






     @slow
     def      lowerCamelCase__     (	self  :					Union[str, Any]				):
           for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 lowerCAmelCase					:	Any       =   AutoConfig.from_pretrained(UpperCamelCase_				)
                 self.assertIsNotNone(UpperCamelCase_				)
                 self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)

                 lowerCAmelCase					:	List[str]       =   TFAutoModelForCausalLM.from_pretrained(UpperCamelCase_				)
                 lowerCAmelCase,      lowerCAmelCase					:	List[str]       =   TFAutoModelForCausalLM.from_pretrained(UpperCamelCase_					,				output_loading_info=UpperCamelCase_				)
                 self.assertIsNotNone(UpperCamelCase_				)
                 self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)






     @slow
     def      lowerCamelCase__     (	self  :					Union[str, Any]				):
           for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 lowerCAmelCase					:	Tuple       =   AutoConfig.from_pretrained(UpperCamelCase_				)
                 self.assertIsNotNone(UpperCamelCase_				)
                 self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)

                 lowerCAmelCase					:	List[Any]       =   TFAutoModelWithLMHead.from_pretrained(UpperCamelCase_				)
                 self.assertIsNotNone(UpperCamelCase_				)
                 self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)






     @slow
     def      lowerCamelCase__     (	self  :					Union[str, Any]				):
           for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 lowerCAmelCase					:	List[Any]       =   AutoConfig.from_pretrained(UpperCamelCase_				)
                 self.assertIsNotNone(UpperCamelCase_				)
                 self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)

                 lowerCAmelCase					:	Optional[Any]       =   TFAutoModelForMaskedLM.from_pretrained(UpperCamelCase_				)
                 lowerCAmelCase,      lowerCAmelCase					:	Union[str, Any]       =   TFAutoModelForMaskedLM.from_pretrained(UpperCamelCase_					,				output_loading_info=UpperCamelCase_				)
                 self.assertIsNotNone(UpperCamelCase_				)
                 self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)






     @slow
     def      lowerCamelCase__     (	self  :					Optional[Any]				):
           for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 lowerCAmelCase					:	str       =   AutoConfig.from_pretrained(UpperCamelCase_				)
                 self.assertIsNotNone(UpperCamelCase_				)
                 self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)

                 lowerCAmelCase					:	Tuple       =   TFAutoModelForSeqaSeqLM.from_pretrained(UpperCamelCase_				)
                 lowerCAmelCase,      lowerCAmelCase					:	Union[str, Any]       =   TFAutoModelForSeqaSeqLM.from_pretrained(UpperCamelCase_					,				output_loading_info=UpperCamelCase_				)
                 self.assertIsNotNone(UpperCamelCase_				)
                 self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)






     @slow
     def      lowerCamelCase__     (	self  :					str				):
           # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           for model_name in ["bert-base-uncased"]:
                 lowerCAmelCase					:	Tuple       =   AutoConfig.from_pretrained(UpperCamelCase_				)
                 self.assertIsNotNone(UpperCamelCase_				)
                 self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)

                 lowerCAmelCase					:	Tuple       =   TFAutoModelForSequenceClassification.from_pretrained(UpperCamelCase_				)
                 self.assertIsNotNone(UpperCamelCase_				)
                 self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)






     @slow
     def      lowerCamelCase__     (	self  :					Dict				):
           # for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           for model_name in ["bert-base-uncased"]:
                 lowerCAmelCase					:	Optional[int]       =   AutoConfig.from_pretrained(UpperCamelCase_				)
                 self.assertIsNotNone(UpperCamelCase_				)
                 self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)

                 lowerCAmelCase					:	Optional[int]       =   TFAutoModelForQuestionAnswering.from_pretrained(UpperCamelCase_				)
                 self.assertIsNotNone(UpperCamelCase_				)
                 self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)






     @slow
     @require_tensorflow_probability
     def      lowerCamelCase__     (	self  :					int				):
           for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
                 lowerCAmelCase					:	List[Any]       =   AutoConfig.from_pretrained(UpperCamelCase_				)
                 self.assertIsNotNone(UpperCamelCase_				)
                 self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)

                 lowerCAmelCase					:	Any       =   TFAutoModelForTableQuestionAnswering.from_pretrained(UpperCamelCase_				)
                 lowerCAmelCase,      lowerCAmelCase					:	Union[str, Any]       =   TFAutoModelForTableQuestionAnswering.from_pretrained(
                     UpperCamelCase_					,				output_loading_info=UpperCamelCase_				)
                 self.assertIsNotNone(UpperCamelCase_				)
                 self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)






     def      lowerCamelCase__     (	self  :					Optional[Any]				):
           lowerCAmelCase					:	str       =   TFAutoModelWithLMHead.from_pretrained(UpperCamelCase_				)
           self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)
           self.assertEqual(model.num_parameters()					,				1_4_4_1_0				)
           self.assertEqual(model.num_parameters(only_trainable=UpperCamelCase_				)					,				1_4_4_1_0				)






     def      lowerCamelCase__     (	self  :					Any				):
           lowerCAmelCase					:	List[Any]       =   TFAutoModelWithLMHead.from_pretrained(UpperCamelCase_				)
           self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)
           self.assertEqual(model.num_parameters()					,				1_4_4_1_0				)
           self.assertEqual(model.num_parameters(only_trainable=UpperCamelCase_				)					,				1_4_4_1_0				)






     def      lowerCamelCase__     (	self  :					str				):
           # For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel
           lowerCAmelCase					:	Dict       =   TFAutoModel.from_pretrained('''sgugger/funnel-random-tiny'''				)
           self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)

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

           with tempfile.TemporaryDirectory() as tmp_dir:
                 model.save_pretrained(UpperCamelCase_				)
                 lowerCAmelCase					:	Optional[Any]       =   TFAutoModel.from_pretrained(UpperCamelCase_				)
                 self.assertIsInstance(UpperCamelCase_					,				UpperCamelCase_				)






     def      lowerCamelCase__     (	self  :					str				):
           try:
                 AutoConfig.register('''new-model'''					,				UpperCamelCase_				)

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

                             with tempfile.TemporaryDirectory() as tmp_dir:
                                   model.save_pretrained(UpperCamelCase_				)
                                   lowerCAmelCase					:	Optional[Any]       =   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      lowerCamelCase__     (	self  :					List[str]				):
           with self.assertRaisesRegex(
               UpperCamelCase_					,				'''bert-base is not a local folder and is not a valid model identifier'''				):
                 lowerCAmelCase					:	Optional[Any]       =   TFAutoModel.from_pretrained('''bert-base'''				)






     def      lowerCamelCase__     (	self  :					List[str]				):
           with self.assertRaisesRegex(
               UpperCamelCase_					,				r'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''				):
                 lowerCAmelCase					:	List[Any]       =   TFAutoModel.from_pretrained(UpperCamelCase_					,				revision='''aaaaaa'''				)






     def      lowerCamelCase__     (	self  :					str				):
           with self.assertRaisesRegex(
               UpperCamelCase_					,				'''hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin'''					,				):
                 lowerCAmelCase					:	List[Any]       =   TFAutoModel.from_pretrained('''hf-internal-testing/config-no-model'''				)






     def      lowerCamelCase__     (	self  :					List[str]				):
           with self.assertRaisesRegex(UpperCamelCase_					,				'''Use `from_pt=True` to load this model'''				):
                 lowerCAmelCase					:	Union[str, Any]       =   TFAutoModel.from_pretrained('''hf-internal-testing/tiny-bert-pt-only'''				)






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


def      _snake_case						(						_snake_case				:			list[int] ,   _snake_case				:			int			):
      if len(_snake_case			) == 0:
            return False
      lowerCAmelCase					:	List[Any]       =   len(_snake_case			) // 2
      if a_list[midpoint] == item:
            return True
      if item < a_list[midpoint]:
            return binary_search(a_list[:midpoint] ,   _snake_case			)
      else:
            return binary_search(a_list[midpoint + 1 :] ,   _snake_case			)


if __name__ == "__main__":
 snake_case__		:     List[str]    				=				input('''Enter numbers separated by comma:\n''').strip()
 snake_case__		:     Optional[int]    				=				[int(item.strip()) for item in user_input.split(''',''')]
 snake_case__		:     Dict    				=				int(input('''Enter the number to be found in the list:\n''').strip())
 snake_case__		:     str    				=				'''''' if binary_search(sequence, target) else '''not '''
 print(f"""{target} was {not_str}found in {sequence}""")


