"""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       ( __UpperCAmelCase				):




					"""simple docstring"""

					snake_case__				    = "new-model"


if is_tf_available():
						class 				snake_case       ( __UpperCAmelCase				):




											"""simple docstring"""

											snake_case__				    = NewModelConfig
@require_tf
class 				snake_case       ( unittest.TestCase				):




					"""simple docstring"""

					@slow
					def 		__lowerCAmelCase						(				self   :	str			):
									UpperCAmelCase__             =							'bert-base-cased'
									UpperCAmelCase__             =							AutoConfig.from_pretrained(lowerCamelCase__			)
									self.assertIsNotNone(lowerCamelCase__			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

									UpperCAmelCase__             =							TFAutoModel.from_pretrained(lowerCamelCase__			)
									self.assertIsNotNone(lowerCamelCase__			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







					@slow
					def 		__lowerCAmelCase						(				self   :	Dict			):
									UpperCAmelCase__             =							'bert-base-cased'
									UpperCAmelCase__             =							AutoConfig.from_pretrained(lowerCamelCase__			)
									self.assertIsNotNone(lowerCamelCase__			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

									UpperCAmelCase__             =							TFAutoModelForPreTraining.from_pretrained(lowerCamelCase__			)
									self.assertIsNotNone(lowerCamelCase__			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







					@slow
					def 		__lowerCAmelCase						(				self   :	int			):
									for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													UpperCAmelCase__             =							AutoConfig.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

													UpperCAmelCase__             =							TFAutoModelForCausalLM.from_pretrained(lowerCamelCase__			)
													UpperCAmelCase__      ,	UpperCAmelCase__             =							TFAutoModelForCausalLM.from_pretrained(lowerCamelCase__    ,output_loading_info=lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







					@slow
					def 		__lowerCAmelCase						(				self   :	Dict			):
									for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													UpperCAmelCase__             =							AutoConfig.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

													UpperCAmelCase__             =							TFAutoModelWithLMHead.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







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

													UpperCAmelCase__             =							TFAutoModelForMaskedLM.from_pretrained(lowerCamelCase__			)
													UpperCAmelCase__      ,	UpperCAmelCase__             =							TFAutoModelForMaskedLM.from_pretrained(lowerCamelCase__    ,output_loading_info=lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







					@slow
					def 		__lowerCAmelCase						(				self   :	str			):
									for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													UpperCAmelCase__             =							AutoConfig.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

													UpperCAmelCase__             =							TFAutoModelForSeqaSeqLM.from_pretrained(lowerCamelCase__			)
													UpperCAmelCase__      ,	UpperCAmelCase__             =							TFAutoModelForSeqaSeqLM.from_pretrained(lowerCamelCase__    ,output_loading_info=lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







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

													UpperCAmelCase__             =							TFAutoModelForSequenceClassification.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







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

													UpperCAmelCase__             =							TFAutoModelForQuestionAnswering.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







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

													UpperCAmelCase__             =							TFAutoModelForTableQuestionAnswering.from_pretrained(lowerCamelCase__			)
													UpperCAmelCase__      ,	UpperCAmelCase__             =							TFAutoModelForTableQuestionAnswering.from_pretrained(
													    lowerCamelCase__    ,output_loading_info=lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







					def 		__lowerCAmelCase						(				self   :	Dict			):
									UpperCAmelCase__             =							TFAutoModelWithLMHead.from_pretrained(lowerCamelCase__			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)
									self.assertEqual(model.num_parameters()    ,14_410			)
									self.assertEqual(model.num_parameters(only_trainable=lowerCamelCase__			)    ,14_410			)







					def 		__lowerCAmelCase						(				self   :	str			):
									UpperCAmelCase__             =							TFAutoModelWithLMHead.from_pretrained(lowerCamelCase__			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)
									self.assertEqual(model.num_parameters()    ,14_410			)
									self.assertEqual(model.num_parameters(only_trainable=lowerCamelCase__			)    ,14_410			)







					def 		__lowerCAmelCase						(				self   :	Optional[Any]			):
									# For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel
									UpperCAmelCase__             =							TFAutoModel.from_pretrained('sgugger/funnel-random-tiny'			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

									UpperCAmelCase__             =							copy.deepcopy(model.config			)
									UpperCAmelCase__             =							['FunnelBaseModel']
									UpperCAmelCase__             =							TFAutoModel.from_config(lowerCamelCase__			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

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







					def 		__lowerCAmelCase						(				self   :	int			):
									try:
													AutoConfig.register('new-model'    ,lowerCamelCase__			)

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

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







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







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







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







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

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__lowercase          =  {
    '''configuration_nezha''': ['''NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''NezhaConfig'''],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase          =  [
						    '''NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''NezhaForNextSentencePrediction''',
						    '''NezhaForMaskedLM''',
						    '''NezhaForPreTraining''',
						    '''NezhaForMultipleChoice''',
						    '''NezhaForQuestionAnswering''',
						    '''NezhaForSequenceClassification''',
						    '''NezhaForTokenClassification''',
						    '''NezhaModel''',
						    '''NezhaPreTrainedModel''',
						]


if TYPE_CHECKING:
						from .configuration_nezha import NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP, NezhaConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_nezha import (
												    NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST,
												    NezhaForMaskedLM,
												    NezhaForMultipleChoice,
												    NezhaForNextSentencePrediction,
												    NezhaForPreTraining,
												    NezhaForQuestionAnswering,
												    NezhaForSequenceClassification,
												    NezhaForTokenClassification,
												    NezhaModel,
												    NezhaPreTrainedModel,
												)


else:
						import sys

						__lowercase          =  _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




