






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 		UpperCAmelCase_						(	SCREAMING_SNAKE_CASE__					):


						'''simple docstring'''




						A     :   int						=					'new-model'


if is_tf_available():




							class 		UpperCAmelCase_						(	SCREAMING_SNAKE_CASE__					):


													'''simple docstring'''




													A     :   Optional[Any]						=					NewModelConfig




@require_tf
class 		UpperCAmelCase_						(	unittest.TestCase					):


						'''simple docstring'''




						@slow
						def       _lowerCAmelCase       (	self				) ->				int:
								snake_case_				:							Union[str, Any]						 =       "bert-base-cased"
								snake_case_				:							Optional[int]						 =       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
								self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
								self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)

								snake_case_				:							Any						 =       TFAutoModel.from_pretrained(_SCREAMING_SNAKE_CASE				)
								self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
								self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)






						@slow
						def       _lowerCAmelCase       (	self				) ->				str:
								snake_case_				:							Union[str, Any]						 =       "bert-base-cased"
								snake_case_				:							Optional[int]						 =       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
								self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
								self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)

								snake_case_				:							Dict						 =       TFAutoModelForPreTraining.from_pretrained(_SCREAMING_SNAKE_CASE				)
								self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
								self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)






						@slow
						def       _lowerCAmelCase       (	self				) ->				str:
								for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										snake_case_				:							Union[str, Any]						 =       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
										self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)

										snake_case_				:							int						 =       TFAutoModelForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE				)
										snake_case_ ,       snake_case_				:							int						 =       TFAutoModelForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE		,				output_loading_info=_SCREAMING_SNAKE_CASE				)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
										self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)






						@slow
						def       _lowerCAmelCase       (	self				) ->				List[str]:
								for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										snake_case_				:							Tuple						 =       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
										self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)

										snake_case_				:							List[Any]						 =       TFAutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE				)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
										self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)






						@slow
						def       _lowerCAmelCase       (	self				) ->				Tuple:
								for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										snake_case_				:							Optional[int]						 =       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
										self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)

										snake_case_				:							Optional[Any]						 =       TFAutoModelForMaskedLM.from_pretrained(_SCREAMING_SNAKE_CASE				)
										snake_case_ ,       snake_case_				:							List[str]						 =       TFAutoModelForMaskedLM.from_pretrained(_SCREAMING_SNAKE_CASE		,				output_loading_info=_SCREAMING_SNAKE_CASE				)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
										self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)






						@slow
						def       _lowerCAmelCase       (	self				) ->				int:
								for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										snake_case_				:							Any						 =       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
										self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)

										snake_case_				:							int						 =       TFAutoModelForSeqaSeqLM.from_pretrained(_SCREAMING_SNAKE_CASE				)
										snake_case_ ,       snake_case_				:							Union[str, Any]						 =       TFAutoModelForSeqaSeqLM.from_pretrained(_SCREAMING_SNAKE_CASE		,				output_loading_info=_SCREAMING_SNAKE_CASE				)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
										self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)






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

										snake_case_				:							int						 =       TFAutoModelForSequenceClassification.from_pretrained(_SCREAMING_SNAKE_CASE				)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
										self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)






						@slow
						def       _lowerCAmelCase       (	self				) ->				Tuple:
								# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								for model_name in ["bert-base-uncased"]:
										snake_case_				:							Optional[int]						 =       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
										self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)

										snake_case_				:							Optional[Any]						 =       TFAutoModelForQuestionAnswering.from_pretrained(_SCREAMING_SNAKE_CASE				)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
										self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)






						@slow
						@require_tensorflow_probability
						def       _lowerCAmelCase       (	self				) ->				int:
								for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
										snake_case_				:							List[str]						 =       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
										self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)

										snake_case_				:							Optional[int]						 =       TFAutoModelForTableQuestionAnswering.from_pretrained(_SCREAMING_SNAKE_CASE				)
										snake_case_ ,       snake_case_				:							Dict						 =       TFAutoModelForTableQuestionAnswering.from_pretrained(
										    _SCREAMING_SNAKE_CASE		,				output_loading_info=_SCREAMING_SNAKE_CASE				)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
										self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)






						def       _lowerCAmelCase       (	self				) ->				Tuple:
								snake_case_				:							Any						 =       TFAutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE				)
								self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)
								self.assertEqual(model.num_parameters()		,				1_4410				)
								self.assertEqual(model.num_parameters(only_trainable=_SCREAMING_SNAKE_CASE				)		,				1_4410				)






						def       _lowerCAmelCase       (	self				) ->				List[Any]:
								snake_case_				:							Optional[Any]						 =       TFAutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE				)
								self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)
								self.assertEqual(model.num_parameters()		,				1_4410				)
								self.assertEqual(model.num_parameters(only_trainable=_SCREAMING_SNAKE_CASE				)		,				1_4410				)






						def       _lowerCAmelCase       (	self				) ->				List[Any]:
								# For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel
								snake_case_				:							List[str]						 =       TFAutoModel.from_pretrained("sgugger/funnel-random-tiny"				)
								self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)

								snake_case_				:							Optional[int]						 =       copy.deepcopy(model.config				)
								snake_case_				:							List[str]						 =       ["FunnelBaseModel"]
								snake_case_				:							Optional[Any]						 =       TFAutoModel.from_config(_SCREAMING_SNAKE_CASE				)
								self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)

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






						def       _lowerCAmelCase       (	self				) ->				List[Any]:
								try:
										AutoConfig.register("new-model"		,				_SCREAMING_SNAKE_CASE				)

										snake_case_				:							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(_SCREAMING_SNAKE_CASE				):
																auto_class.register(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)
														auto_class.register(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)
														# Trying to register something existing in the Transformers library will raise an error
														with self.assertRaises(_SCREAMING_SNAKE_CASE				):
																auto_class.register(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)

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

														with tempfile.TemporaryDirectory() as tmp_dir:
																model.save_pretrained(_SCREAMING_SNAKE_CASE				)
																snake_case_				:							List[str]						 =       auto_class.from_pretrained(_SCREAMING_SNAKE_CASE				)
																self.assertIsInstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)

								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(
								    _SCREAMING_SNAKE_CASE		,				"bert-base is not a local folder and is not a valid model identifier"				):
										snake_case_				:							Dict						 =       TFAutoModel.from_pretrained("bert-base"				)






						def       _lowerCAmelCase       (	self				) ->				str:
								with self.assertRaisesRegex(
								    _SCREAMING_SNAKE_CASE		,				r"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"				):
										snake_case_				:							int						 =       TFAutoModel.from_pretrained(_SCREAMING_SNAKE_CASE		,				revision="aaaaaa"				)






						def       _lowerCAmelCase       (	self				) ->				Any:
								with self.assertRaisesRegex(
								    _SCREAMING_SNAKE_CASE		,				"hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin"		,				):
										snake_case_				:							Optional[Any]						 =       TFAutoModel.from_pretrained("hf-internal-testing/config-no-model"				)






						def       _lowerCAmelCase       (	self				) ->				Dict:
								with self.assertRaisesRegex(_SCREAMING_SNAKE_CASE		,				"Use `from_pt=True` to load this model"				):
										snake_case_				:							Union[str, Any]						 =       TFAutoModel.from_pretrained("hf-internal-testing/tiny-bert-pt-only"				)






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








import fire

from transformers import AutoConfig, AutoModelForSeqaSeqLM, AutoTokenizer

def      lowerCAmelCase__	(    _a       :			str  ,      _a       :			str  ,      **_a       :			Optional[int]    ):
		snake_case_				:							Any						 =       AutoConfig.from_pretrained(_a  ,      **_a    )
		snake_case_				:							str						 =       AutoModelForSeqaSeqLM.from_config(_a    )
		model.save_pretrained(_a    )
		AutoTokenizer.from_pretrained(_a    ).save_pretrained(_a    )
		return model


if __name__ == "__main__":
							fire.Fire(save_randomly_initialized_version)
