





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       __lowerCAmelCase					(       _UpperCamelCase      ):


	'''simple docstring'''





	_A													=				"new-model"


if is_tf_available():


			class       __lowerCAmelCase					(       _UpperCamelCase      ):


				'''simple docstring'''





				_A													=				NewModelConfig


@require_tf
class       __lowerCAmelCase					(       unittest.TestCase      ):


	'''simple docstring'''





	@slow
	def    snake_case__(						self:						Union[str, Any]			):
			lowercase__					:      Dict      =		'bert-base-cased'
			lowercase__					:      List[Any]      =		AutoConfig.from_pretrained(lowerCamelCase_			)
			self.assertIsNotNone(lowerCamelCase_			)
			self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

			lowercase__					:      Dict      =		TFAutoModel.from_pretrained(lowerCamelCase_			)
			self.assertIsNotNone(lowerCamelCase_			)
			self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

	@slow
	def    snake_case__(						self:						List[Any]			):
			lowercase__					:      List[str]      =		'bert-base-cased'
			lowercase__					:      str      =		AutoConfig.from_pretrained(lowerCamelCase_			)
			self.assertIsNotNone(lowerCamelCase_			)
			self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

			lowercase__					:      Tuple      =		TFAutoModelForPreTraining.from_pretrained(lowerCamelCase_			)
			self.assertIsNotNone(lowerCamelCase_			)
			self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

	@slow
	def    snake_case__(						self:						Optional[Any]			):
			for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowercase__					:      str      =		AutoConfig.from_pretrained(lowerCamelCase_			)
					self.assertIsNotNone(lowerCamelCase_			)
					self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

					lowercase__					:      List[Any]      =		TFAutoModelForCausalLM.from_pretrained(lowerCamelCase_			)
					lowercase__   ,				lowercase__					:      int      =		TFAutoModelForCausalLM.from_pretrained(lowerCamelCase_,					output_loading_info=lowerCamelCase_			)
					self.assertIsNotNone(lowerCamelCase_			)
					self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

	@slow
	def    snake_case__(						self:						Dict			):
			for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowercase__					:      List[str]      =		AutoConfig.from_pretrained(lowerCamelCase_			)
					self.assertIsNotNone(lowerCamelCase_			)
					self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

					lowercase__					:      Tuple      =		TFAutoModelWithLMHead.from_pretrained(lowerCamelCase_			)
					self.assertIsNotNone(lowerCamelCase_			)
					self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

	@slow
	def    snake_case__(						self:						int			):
			for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowercase__					:      Any      =		AutoConfig.from_pretrained(lowerCamelCase_			)
					self.assertIsNotNone(lowerCamelCase_			)
					self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

					lowercase__					:      Union[str, Any]      =		TFAutoModelForMaskedLM.from_pretrained(lowerCamelCase_			)
					lowercase__   ,				lowercase__					:      str      =		TFAutoModelForMaskedLM.from_pretrained(lowerCamelCase_,					output_loading_info=lowerCamelCase_			)
					self.assertIsNotNone(lowerCamelCase_			)
					self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

	@slow
	def    snake_case__(						self:						Dict			):
			for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowercase__					:      int      =		AutoConfig.from_pretrained(lowerCamelCase_			)
					self.assertIsNotNone(lowerCamelCase_			)
					self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

					lowercase__					:      Dict      =		TFAutoModelForSeqaSeqLM.from_pretrained(lowerCamelCase_			)
					lowercase__   ,				lowercase__					:      Optional[Any]      =		TFAutoModelForSeqaSeqLM.from_pretrained(lowerCamelCase_,					output_loading_info=lowerCamelCase_			)
					self.assertIsNotNone(lowerCamelCase_			)
					self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

	@slow
	def    snake_case__(						self:						Union[str, Any]			):
			# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			for model_name in ["bert-base-uncased"]:
					lowercase__					:      str      =		AutoConfig.from_pretrained(lowerCamelCase_			)
					self.assertIsNotNone(lowerCamelCase_			)
					self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

					lowercase__					:      int      =		TFAutoModelForSequenceClassification.from_pretrained(lowerCamelCase_			)
					self.assertIsNotNone(lowerCamelCase_			)
					self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

	@slow
	def    snake_case__(						self:						str			):
			# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			for model_name in ["bert-base-uncased"]:
					lowercase__					:      List[Any]      =		AutoConfig.from_pretrained(lowerCamelCase_			)
					self.assertIsNotNone(lowerCamelCase_			)
					self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

					lowercase__					:      Union[str, Any]      =		TFAutoModelForQuestionAnswering.from_pretrained(lowerCamelCase_			)
					self.assertIsNotNone(lowerCamelCase_			)
					self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

	@slow
	@require_tensorflow_probability
	def    snake_case__(						self:						Dict			):
			for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
					lowercase__					:      List[Any]      =		AutoConfig.from_pretrained(lowerCamelCase_			)
					self.assertIsNotNone(lowerCamelCase_			)
					self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

					lowercase__					:      List[Any]      =		TFAutoModelForTableQuestionAnswering.from_pretrained(lowerCamelCase_			)
					lowercase__   ,				lowercase__					:      List[Any]      =		TFAutoModelForTableQuestionAnswering.from_pretrained(
					    lowerCamelCase_,					output_loading_info=lowerCamelCase_			)
					self.assertIsNotNone(lowerCamelCase_			)
					self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

	def    snake_case__(						self:						Optional[int]			):
			lowercase__					:      List[str]      =		TFAutoModelWithLMHead.from_pretrained(lowerCamelCase_			)
			self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)
			self.assertEqual(model.num_parameters(),					14410			)
			self.assertEqual(model.num_parameters(only_trainable=lowerCamelCase_			),					14410			)

	def    snake_case__(						self:						Optional[int]			):
			lowercase__					:      Tuple      =		TFAutoModelWithLMHead.from_pretrained(lowerCamelCase_			)
			self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)
			self.assertEqual(model.num_parameters(),					14410			)
			self.assertEqual(model.num_parameters(only_trainable=lowerCamelCase_			),					14410			)

	def    snake_case__(						self:						Tuple			):
			# For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel
			lowercase__					:      Optional[int]      =		TFAutoModel.from_pretrained('sgugger/funnel-random-tiny'			)
			self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

			lowercase__					:      str      =		copy.deepcopy(model.config			)
			lowercase__					:      Dict      =		['FunnelBaseModel']
			lowercase__					:      Union[str, Any]      =		TFAutoModel.from_config(lowerCamelCase_			)
			self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

			with tempfile.TemporaryDirectory() as tmp_dir:
					model.save_pretrained(lowerCamelCase_			)
					lowercase__					:      Dict      =		TFAutoModel.from_pretrained(lowerCamelCase_			)
					self.assertIsInstance(lowerCamelCase_,					lowerCamelCase_			)

	def    snake_case__(						self:						Dict			):
			try:
					AutoConfig.register('new-model',					lowerCamelCase_			)

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

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

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

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

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





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


class       __lowerCAmelCase					(       metaclass=_UpperCamelCase      ):


	'''simple docstring'''





	_A													=				["note_seq"]

	def __init__(						self:						int,					*lowerCamelCase_:						Optional[int],					**lowerCamelCase_:						Tuple			):
			requires_backends(self,					['note_seq']			)

	@classmethod
	def    snake_case__(						cls:						Optional[Any],					*lowerCamelCase_:						Tuple,					**lowerCamelCase_:						Optional[Any]			):
			requires_backends(cls,					['note_seq']			)





	@classmethod
	def    snake_case__(						cls:						Any,					*lowerCamelCase_:						Dict,					**lowerCamelCase_:						str			):
			requires_backends(cls,					['note_seq']			)


