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 					lowercase__						(   UpperCamelCase_):
						UpperCamelCase_     =		"""new-model"""


if is_tf_available():





					class 					lowercase__						(   UpperCamelCase_):
											UpperCamelCase_     =		NewModelConfig





@require_tf
class 					lowercase__						(   unittest.TestCase):


						@slow
						def        __A       (       self	:				List[str]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    int							=							'''bert-base-cased'''
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							AutoConfig.from_pretrained(UpperCamelCase__						)
												self.assertIsNotNone(UpperCamelCase__						)
												self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)

												SCREAMING_SNAKE_CASE							:    str							=							TFAutoModel.from_pretrained(UpperCamelCase__						)
												self.assertIsNotNone(UpperCamelCase__						)
												self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)


						@slow
						def        __A       (       self	:				int						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    str							=							'''bert-base-cased'''
												SCREAMING_SNAKE_CASE							:    str							=							AutoConfig.from_pretrained(UpperCamelCase__						)
												self.assertIsNotNone(UpperCamelCase__						)
												self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)

												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							TFAutoModelForPreTraining.from_pretrained(UpperCamelCase__						)
												self.assertIsNotNone(UpperCamelCase__						)
												self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)


						@slow
						def        __A       (       self	:				Union[str, Any]						):





												'''simple docstring'''





												for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		SCREAMING_SNAKE_CASE							:    Any							=							AutoConfig.from_pretrained(UpperCamelCase__						)
																		self.assertIsNotNone(UpperCamelCase__						)
																		self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)

																		SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							TFAutoModelForCausalLM.from_pretrained(UpperCamelCase__						)
																		SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE							:    List[str]							=							TFAutoModelForCausalLM.from_pretrained(UpperCamelCase__    ,		output_loading_info=UpperCamelCase__						)
																		self.assertIsNotNone(UpperCamelCase__						)
																		self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)


						@slow
						def        __A       (       self	:				int						):





												'''simple docstring'''





												for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		SCREAMING_SNAKE_CASE							:    str							=							AutoConfig.from_pretrained(UpperCamelCase__						)
																		self.assertIsNotNone(UpperCamelCase__						)
																		self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)

																		SCREAMING_SNAKE_CASE							:    Any							=							TFAutoModelWithLMHead.from_pretrained(UpperCamelCase__						)
																		self.assertIsNotNone(UpperCamelCase__						)
																		self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)


						@slow
						def        __A       (       self	:				int						):





												'''simple docstring'''





												for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		SCREAMING_SNAKE_CASE							:    List[Any]							=							AutoConfig.from_pretrained(UpperCamelCase__						)
																		self.assertIsNotNone(UpperCamelCase__						)
																		self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)

																		SCREAMING_SNAKE_CASE							:    Dict							=							TFAutoModelForMaskedLM.from_pretrained(UpperCamelCase__						)
																		SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE							:    List[Any]							=							TFAutoModelForMaskedLM.from_pretrained(UpperCamelCase__    ,		output_loading_info=UpperCamelCase__						)
																		self.assertIsNotNone(UpperCamelCase__						)
																		self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)


						@slow
						def        __A       (       self	:				Dict						):





												'''simple docstring'''





												for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		SCREAMING_SNAKE_CASE							:    Any							=							AutoConfig.from_pretrained(UpperCamelCase__						)
																		self.assertIsNotNone(UpperCamelCase__						)
																		self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)

																		SCREAMING_SNAKE_CASE							:    List[str]							=							TFAutoModelForSeqaSeqLM.from_pretrained(UpperCamelCase__						)
																		SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE							:    Any							=							TFAutoModelForSeqaSeqLM.from_pretrained(UpperCamelCase__    ,		output_loading_info=UpperCamelCase__						)
																		self.assertIsNotNone(UpperCamelCase__						)
																		self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)


						@slow
						def        __A       (       self	:				Any						):





												'''simple docstring'''





												for model_name in ["bert-base-uncased"]:
																		SCREAMING_SNAKE_CASE							:    List[str]							=							AutoConfig.from_pretrained(UpperCamelCase__						)
																		self.assertIsNotNone(UpperCamelCase__						)
																		self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)

																		SCREAMING_SNAKE_CASE							:    List[str]							=							TFAutoModelForSequenceClassification.from_pretrained(UpperCamelCase__						)
																		self.assertIsNotNone(UpperCamelCase__						)
																		self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)


						@slow
						def        __A       (       self	:				Union[str, Any]						):





												'''simple docstring'''





												for model_name in ["bert-base-uncased"]:
																		SCREAMING_SNAKE_CASE							:    Optional[int]							=							AutoConfig.from_pretrained(UpperCamelCase__						)
																		self.assertIsNotNone(UpperCamelCase__						)
																		self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)

																		SCREAMING_SNAKE_CASE							:    List[str]							=							TFAutoModelForQuestionAnswering.from_pretrained(UpperCamelCase__						)
																		self.assertIsNotNone(UpperCamelCase__						)
																		self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)


						@slow
						@require_tensorflow_probability
						def        __A       (       self	:				Tuple						):





												'''simple docstring'''





												for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
																		SCREAMING_SNAKE_CASE							:    int							=							AutoConfig.from_pretrained(UpperCamelCase__						)
																		self.assertIsNotNone(UpperCamelCase__						)
																		self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)

																		SCREAMING_SNAKE_CASE							:    Optional[int]							=							TFAutoModelForTableQuestionAnswering.from_pretrained(UpperCamelCase__						)
																		SCREAMING_SNAKE_CASE				,  SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							TFAutoModelForTableQuestionAnswering.from_pretrained(
																		    UpperCamelCase__    ,		output_loading_info=UpperCamelCase__						)
																		self.assertIsNotNone(UpperCamelCase__						)
																		self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)


						def        __A       (       self	:				Any						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    int							=							TFAutoModelWithLMHead.from_pretrained(UpperCamelCase__						)
												self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)
												self.assertEqual(model.num_parameters()    ,		1_4410						)
												self.assertEqual(model.num_parameters(only_trainable=UpperCamelCase__						)    ,		1_4410						)


						def        __A       (       self	:				Optional[int]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Dict							=							TFAutoModelWithLMHead.from_pretrained(UpperCamelCase__						)
												self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)
												self.assertEqual(model.num_parameters()    ,		1_4410						)
												self.assertEqual(model.num_parameters(only_trainable=UpperCamelCase__						)    ,		1_4410						)


						def        __A       (       self	:				Optional[Any]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Optional[int]							=							TFAutoModel.from_pretrained('''sgugger/funnel-random-tiny'''						)
												self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)

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

												with tempfile.TemporaryDirectory() as tmp_dir:
																		model.save_pretrained(UpperCamelCase__						)
																		SCREAMING_SNAKE_CASE							:    Tuple							=							TFAutoModel.from_pretrained(UpperCamelCase__						)
																		self.assertIsInstance(UpperCamelCase__    ,		UpperCamelCase__						)


						def        __A       (       self	:				str						):





												'''simple docstring'''





												try:
																		AutoConfig.register('''new-model'''    ,		UpperCamelCase__						)

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

																														with tempfile.TemporaryDirectory() as tmp_dir:
																																				model.save_pretrained(UpperCamelCase__						)
																																				SCREAMING_SNAKE_CASE							:    str							=							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        __A       (       self	:				Optional[int]						):





												'''simple docstring'''





												with self.assertRaisesRegex(
												    UpperCamelCase__    ,		'''bert-base is not a local folder and is not a valid model identifier'''						):
																		SCREAMING_SNAKE_CASE							:    Any							=							TFAutoModel.from_pretrained('''bert-base'''						)


						def        __A       (       self	:				Tuple						):





												'''simple docstring'''





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


						def        __A       (       self	:				Tuple						):





												'''simple docstring'''





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


						def        __A       (       self	:				List[str]						):





												'''simple docstring'''





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



						def        __A       (       self	:				Any						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[str]							=							TFAutoModel.from_pretrained('''hf-internal-testing/tiny-random-bert'''						)
												with RequestCounter() as counter:
																		SCREAMING_SNAKE_CASE							:    Optional[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
												SCREAMING_SNAKE_CASE							:    List[str]							=							TFAutoModel.from_pretrained('''ArthurZ/tiny-random-bert-sharded'''						)
												with RequestCounter() as counter:
																		SCREAMING_SNAKE_CASE							:    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						)






def       A	(    _lowercase		,  _lowercase		,  _lowercase						):
						return round(float(moles / volume						) * nfactor						)
def       A	(    _lowercase		,  _lowercase		,  _lowercase						):
						return round(float((moles * 0.0821 * temperature) / (volume)						)						)
def       A	(    _lowercase		,  _lowercase		,  _lowercase						):
						return round(float((moles * 0.0821 * temperature) / (pressure)						)						)
def       A	(    _lowercase		,  _lowercase		,  _lowercase						):
						return round(float((pressure * volume) / (0.0821 * moles)						)						)


if __name__ == "__main__":
					import doctest

					doctest.testmod()





