





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   A      (SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''




			__lowerCamelCase     :	int          =   '''new-model'''


if is_tf_available():


					class   A      (SCREAMING_SNAKE_CASE   ):
								'''simple docstring'''




								__lowerCamelCase     :	Optional[int]          =   NewModelConfig


@require_tf
class   A      (unittest.TestCase   ):
			'''simple docstring'''




			@slow
			def        a_	(      self       :   int       )     ->     Any:







					"""simple docstring"""






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

					A__  				=       TFAutoModel.from_pretrained(__lowerCAmelCase       )
					self.assertIsNotNone(__lowerCAmelCase       )
					self.assertIsInstance(__lowerCAmelCase							,     __lowerCAmelCase       )






			@slow
			def        a_	(      self       :   Tuple       )     ->     Tuple:







					"""simple docstring"""






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

					A__  				=       TFAutoModelForPreTraining.from_pretrained(__lowerCAmelCase       )
					self.assertIsNotNone(__lowerCAmelCase       )
					self.assertIsInstance(__lowerCAmelCase							,     __lowerCAmelCase       )






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







					"""simple docstring"""






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

							A__  				=       TFAutoModelForCausalLM.from_pretrained(__lowerCAmelCase       )
							A__				,      A__  				=       TFAutoModelForCausalLM.from_pretrained(__lowerCAmelCase							,     output_loading_info=__lowerCAmelCase       )
							self.assertIsNotNone(__lowerCAmelCase       )
							self.assertIsInstance(__lowerCAmelCase							,     __lowerCAmelCase       )






			@slow
			def        a_	(      self       :   Optional[Any]       )     ->     Union[str, Any]:







					"""simple docstring"""






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

							A__  				=       TFAutoModelWithLMHead.from_pretrained(__lowerCAmelCase       )
							self.assertIsNotNone(__lowerCAmelCase       )
							self.assertIsInstance(__lowerCAmelCase							,     __lowerCAmelCase       )






			@slow
			def        a_	(      self       :   Optional[int]       )     ->     str:







					"""simple docstring"""






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

							A__  				=       TFAutoModelForMaskedLM.from_pretrained(__lowerCAmelCase       )
							A__				,      A__  				=       TFAutoModelForMaskedLM.from_pretrained(__lowerCAmelCase							,     output_loading_info=__lowerCAmelCase       )
							self.assertIsNotNone(__lowerCAmelCase       )
							self.assertIsInstance(__lowerCAmelCase							,     __lowerCAmelCase       )






			@slow
			def        a_	(      self       :   Optional[Any]       )     ->     int:







					"""simple docstring"""






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

							A__  				=       TFAutoModelForSeqaSeqLM.from_pretrained(__lowerCAmelCase       )
							A__				,      A__  				=       TFAutoModelForSeqaSeqLM.from_pretrained(__lowerCAmelCase							,     output_loading_info=__lowerCAmelCase       )
							self.assertIsNotNone(__lowerCAmelCase       )
							self.assertIsInstance(__lowerCAmelCase							,     __lowerCAmelCase       )






			@slow
			def        a_	(      self       :   Any       )     ->     Optional[Any]:







					"""simple docstring"""






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

							A__  				=       TFAutoModelForSequenceClassification.from_pretrained(__lowerCAmelCase       )
							self.assertIsNotNone(__lowerCAmelCase       )
							self.assertIsInstance(__lowerCAmelCase							,     __lowerCAmelCase       )






			@slow
			def        a_	(      self       :   Dict       )     ->     Optional[int]:







					"""simple docstring"""






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

							A__  				=       TFAutoModelForQuestionAnswering.from_pretrained(__lowerCAmelCase       )
							self.assertIsNotNone(__lowerCAmelCase       )
							self.assertIsInstance(__lowerCAmelCase							,     __lowerCAmelCase       )






			@slow
			@require_tensorflow_probability
			def        a_	(      self       :   List[str]       )     ->     List[Any]:







					"""simple docstring"""






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

							A__  				=       TFAutoModelForTableQuestionAnswering.from_pretrained(__lowerCAmelCase       )
							A__				,      A__  				=       TFAutoModelForTableQuestionAnswering.from_pretrained(
							    __lowerCAmelCase							,     output_loading_info=__lowerCAmelCase       )
							self.assertIsNotNone(__lowerCAmelCase       )
							self.assertIsInstance(__lowerCAmelCase							,     __lowerCAmelCase       )






			def        a_	(      self       :   List[str]       )     ->     Optional[Any]:







					"""simple docstring"""






					A__  				=       TFAutoModelWithLMHead.from_pretrained(__lowerCAmelCase       )
					self.assertIsInstance(__lowerCAmelCase							,     __lowerCAmelCase       )
					self.assertEqual(model.num_parameters()							,     1_44_10       )
					self.assertEqual(model.num_parameters(only_trainable=__lowerCAmelCase       )							,     1_44_10       )






			def        a_	(      self       :   Optional[Any]       )     ->     List[str]:







					"""simple docstring"""






					A__  				=       TFAutoModelWithLMHead.from_pretrained(__lowerCAmelCase       )
					self.assertIsInstance(__lowerCAmelCase							,     __lowerCAmelCase       )
					self.assertEqual(model.num_parameters()							,     1_44_10       )
					self.assertEqual(model.num_parameters(only_trainable=__lowerCAmelCase       )							,     1_44_10       )






			def        a_	(      self       :   str       )     ->     Optional[Any]:







					"""simple docstring"""






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

					A__  				=       copy.deepcopy(model.config       )
					A__  				=       ["""FunnelBaseModel"""]
					A__  				=       TFAutoModel.from_config(__lowerCAmelCase       )
					self.assertIsInstance(__lowerCAmelCase							,     __lowerCAmelCase       )

					with tempfile.TemporaryDirectory() as tmp_dir:
							model.save_pretrained(__lowerCAmelCase       )
							A__  				=       TFAutoModel.from_pretrained(__lowerCAmelCase       )
							self.assertIsInstance(__lowerCAmelCase							,     __lowerCAmelCase       )






			def        a_	(      self       :   int       )     ->     int:







					"""simple docstring"""






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

							A__  				=       [
							    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
											A__  				=       BertModelTester(self       ).get_config()
											A__  				=       NewModelConfig(**tiny_config.to_dict()       )
											A__  				=       auto_class.from_config(__lowerCAmelCase       )
											self.assertIsInstance(__lowerCAmelCase							,     __lowerCAmelCase       )

											with tempfile.TemporaryDirectory() as tmp_dir:
													model.save_pretrained(__lowerCAmelCase       )
													A__  				=       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        a_	(      self       :   Optional[Any]       )     ->     int:







					"""simple docstring"""






					with self.assertRaisesRegex(
					    __lowerCAmelCase							,     """bert-base is not a local folder and is not a valid model identifier"""       ):
							A__  				=       TFAutoModel.from_pretrained("""bert-base"""       )






			def        a_	(      self       :   List[str]       )     ->     List[str]:







					"""simple docstring"""






					with self.assertRaisesRegex(
					    __lowerCAmelCase							,     R"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""       ):
							A__  				=       TFAutoModel.from_pretrained(__lowerCAmelCase							,     revision="""aaaaaa"""       )






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







					"""simple docstring"""






					with self.assertRaisesRegex(
					    __lowerCAmelCase							,     """hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin"""							,     ):
							A__  				=       TFAutoModel.from_pretrained("""hf-internal-testing/config-no-model"""       )






			def        a_	(      self       :   Any       )     ->     List[str]:







					"""simple docstring"""






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







			def        a_	(      self       :   str       )     ->     Optional[Any]:







					"""simple docstring"""






					A__  				=       TFAutoModel.from_pretrained("""hf-internal-testing/tiny-random-bert"""       )
					with RequestCounter() as counter:
							A__  				=       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
					A__  				=       TFAutoModel.from_pretrained("""ArthurZ/tiny-random-bert-sharded"""       )
					with RequestCounter() as counter:
							A__  				=       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 string import ascii_uppercase

A   : List[str]			=				{str(ord(c) - 5_5): c for c in ascii_uppercase}







def        __lowerCamelCase (							__a       :int   ,					__a       :int   )		->    str:






		"""simple docstring"""

		if isinstance(__a   ,					__a   ):
				raise TypeError("""int() can't convert non-string with explicit base"""   )
		if num < 0:
				raise ValueError("""parameter must be positive int"""   )
		if isinstance(__a   ,					__a   ):
				raise TypeError("""'str' object cannot be interpreted as an integer"""   )
		if isinstance(__a   ,					__a   ):
				raise TypeError("""'float' object cannot be interpreted as an integer"""   )
		if base in (0, 1):
				raise ValueError("""base must be >= 2"""   )
		if base > 3_6:
				raise ValueError("""base must be <= 36"""   )
		A__  				=       """"""
		A__  				=       0
		A__  				=       0
		while div != 1:
				A__				,      A__  				=       divmod(__a   ,					__a   )
				if base >= 1_1 and 9 < mod < 3_6:
						A__  				=       ALPHABET_VALUES[str(__a   )]
				else:
						A__  				=       str(__a   )
				new_value += actual_value
				A__  				=       num // base
				A__  				=       div
				if div == 0:
						return str(new_value[::-1]   )
				elif div == 1:
						new_value += str(__a   )
						return str(new_value[::-1]   )

		return new_value[::-1]


if __name__ == "__main__":
					import doctest

					doctest.testmod()

					for base in range(2, 3_7):
										for num in range(1_0_0_0):
															assert int(decimal_to_any(num, base), base) == num, (
															    num,
															    base,
															    decimal_to_any(num, base),
															    int(decimal_to_any(num, base), base),
															)



