
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					(	__a       ):
				_lowercase					='''new-model'''


if is_tf_available():





			class 	_lowerCAmelCase					(	__a       ):
							_lowercase					=NewModelConfig





@require_tf
class 	_lowerCAmelCase					(	unittest.TestCase       ):




				@slow
				def      __a						(					self     )				->      Union[str, Any]:
							lowerCAmelCase_						=	"bert-base-cased"
							lowerCAmelCase_						=	AutoConfig.from_pretrained(_UpperCamelCase     )
							self.assertIsNotNone(_UpperCamelCase     )
							self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )

							lowerCAmelCase_						=	TFAutoModel.from_pretrained(_UpperCamelCase     )
							self.assertIsNotNone(_UpperCamelCase     )
							self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )




				@slow
				def      __a						(					self     )				->      List[str]:
							lowerCAmelCase_						=	"bert-base-cased"
							lowerCAmelCase_						=	AutoConfig.from_pretrained(_UpperCamelCase     )
							self.assertIsNotNone(_UpperCamelCase     )
							self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )

							lowerCAmelCase_						=	TFAutoModelForPreTraining.from_pretrained(_UpperCamelCase     )
							self.assertIsNotNone(_UpperCamelCase     )
							self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )




				@slow
				def      __a						(					self     )				->      Optional[Any]:
							for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowerCAmelCase_						=	AutoConfig.from_pretrained(_UpperCamelCase     )
										self.assertIsNotNone(_UpperCamelCase     )
										self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )

										lowerCAmelCase_						=	TFAutoModelForCausalLM.from_pretrained(_UpperCamelCase     )
										lowerCAmelCase_	,  lowerCAmelCase_						=	TFAutoModelForCausalLM.from_pretrained(_UpperCamelCase				,				output_loading_info=_UpperCamelCase     )
										self.assertIsNotNone(_UpperCamelCase     )
										self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )




				@slow
				def      __a						(					self     )				->      str:
							for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowerCAmelCase_						=	AutoConfig.from_pretrained(_UpperCamelCase     )
										self.assertIsNotNone(_UpperCamelCase     )
										self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )

										lowerCAmelCase_						=	TFAutoModelWithLMHead.from_pretrained(_UpperCamelCase     )
										self.assertIsNotNone(_UpperCamelCase     )
										self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )




				@slow
				def      __a						(					self     )				->      Any:
							for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowerCAmelCase_						=	AutoConfig.from_pretrained(_UpperCamelCase     )
										self.assertIsNotNone(_UpperCamelCase     )
										self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )

										lowerCAmelCase_						=	TFAutoModelForMaskedLM.from_pretrained(_UpperCamelCase     )
										lowerCAmelCase_	,  lowerCAmelCase_						=	TFAutoModelForMaskedLM.from_pretrained(_UpperCamelCase				,				output_loading_info=_UpperCamelCase     )
										self.assertIsNotNone(_UpperCamelCase     )
										self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )




				@slow
				def      __a						(					self     )				->      int:
							for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowerCAmelCase_						=	AutoConfig.from_pretrained(_UpperCamelCase     )
										self.assertIsNotNone(_UpperCamelCase     )
										self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )

										lowerCAmelCase_						=	TFAutoModelForSeqaSeqLM.from_pretrained(_UpperCamelCase     )
										lowerCAmelCase_	,  lowerCAmelCase_						=	TFAutoModelForSeqaSeqLM.from_pretrained(_UpperCamelCase				,				output_loading_info=_UpperCamelCase     )
										self.assertIsNotNone(_UpperCamelCase     )
										self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )




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

										lowerCAmelCase_						=	TFAutoModelForSequenceClassification.from_pretrained(_UpperCamelCase     )
										self.assertIsNotNone(_UpperCamelCase     )
										self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )




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

										lowerCAmelCase_						=	TFAutoModelForQuestionAnswering.from_pretrained(_UpperCamelCase     )
										self.assertIsNotNone(_UpperCamelCase     )
										self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )




				@slow
				@require_tensorflow_probability
				def      __a						(					self     )				->      Tuple:
							for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
										lowerCAmelCase_						=	AutoConfig.from_pretrained(_UpperCamelCase     )
										self.assertIsNotNone(_UpperCamelCase     )
										self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )

										lowerCAmelCase_						=	TFAutoModelForTableQuestionAnswering.from_pretrained(_UpperCamelCase     )
										lowerCAmelCase_	,  lowerCAmelCase_						=	TFAutoModelForTableQuestionAnswering.from_pretrained(
										    _UpperCamelCase				,				output_loading_info=_UpperCamelCase     )
										self.assertIsNotNone(_UpperCamelCase     )
										self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )




				def      __a						(					self     )				->      Optional[Any]:
							lowerCAmelCase_						=	TFAutoModelWithLMHead.from_pretrained(_UpperCamelCase     )
							self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )
							self.assertEqual(model.num_parameters()				,				14_410     )
							self.assertEqual(model.num_parameters(only_trainable=_UpperCamelCase     )				,				14_410     )




				def      __a						(					self     )				->      Dict:
							lowerCAmelCase_						=	TFAutoModelWithLMHead.from_pretrained(_UpperCamelCase     )
							self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )
							self.assertEqual(model.num_parameters()				,				14_410     )
							self.assertEqual(model.num_parameters(only_trainable=_UpperCamelCase     )				,				14_410     )




				def      __a						(					self     )				->      str:
							# For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel
							lowerCAmelCase_						=	TFAutoModel.from_pretrained("sgugger/funnel-random-tiny"     )
							self.assertIsInstance(_UpperCamelCase				,				_UpperCamelCase     )

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

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




				def      __a						(					self     )				->      str:
							try:
										AutoConfig.register("new-model"				,				_UpperCamelCase     )

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

																with tempfile.TemporaryDirectory() as tmp_dir:
																			model.save_pretrained(_UpperCamelCase     )
																			lowerCAmelCase_						=	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[Any]:
							with self.assertRaisesRegex(
							    _UpperCamelCase				,				"bert-base is not a local folder and is not a valid model identifier"     ):
										lowerCAmelCase_						=	TFAutoModel.from_pretrained("bert-base"     )




				def      __a						(					self     )				->      Any:
							with self.assertRaisesRegex(
							    _UpperCamelCase				,				r"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"     ):
										lowerCAmelCase_						=	TFAutoModel.from_pretrained(_UpperCamelCase				,				revision="aaaaaa"     )




				def      __a						(					self     )				->      List[str]:
							with self.assertRaisesRegex(
							    _UpperCamelCase				,				"hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin"				,				):
										lowerCAmelCase_						=	TFAutoModel.from_pretrained("hf-internal-testing/config-no-model"     )




				def      __a						(					self     )				->      List[Any]:
							with self.assertRaisesRegex(_UpperCamelCase				,				"Use `from_pt=True` to load this model"     ):
										lowerCAmelCase_						=	TFAutoModel.from_pretrained("hf-internal-testing/tiny-bert-pt-only"     )




				def      __a						(					self     )				->      Optional[int]:
							# Make sure we have cached the model.
							lowerCAmelCase_						=	TFAutoModel.from_pretrained("hf-internal-testing/tiny-random-bert"     )
							with RequestCounter() as counter:
										lowerCAmelCase_						=	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
							lowerCAmelCase_						=	TFAutoModel.from_pretrained("ArthurZ/tiny-random-bert-sharded"     )
							with RequestCounter() as counter:
										lowerCAmelCase_						=	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 typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_speech_available,
    is_tf_available,
    is_torch_available,
)


_A   =     {
    "configuration_speech_to_text": ["SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Speech2TextConfig"],
    "processing_speech_to_text": ["Speech2TextProcessor"],
}

try:
			if not is_sentencepiece_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A   =     ["Speech2TextTokenizer"]

try:
			if not is_speech_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A   =     ["Speech2TextFeatureExtractor"]

try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A   =     [
			    "TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST",
			    "TFSpeech2TextForConditionalGeneration",
			    "TFSpeech2TextModel",
			    "TFSpeech2TextPreTrainedModel",
			]

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A   =     [
			    "SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST",
			    "Speech2TextForConditionalGeneration",
			    "Speech2TextModel",
			    "Speech2TextPreTrainedModel",
			]


if TYPE_CHECKING:
			from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig
			from .processing_speech_to_text import SpeechaTextProcessor

			try:
						if not is_sentencepiece_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_speech_to_text import SpeechaTextTokenizer

			try:
						if not is_speech_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor

			try:
						if not is_tf_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_speech_to_text import (
						    TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFSpeechaTextForConditionalGeneration,
						    TFSpeechaTextModel,
						    TFSpeechaTextPreTrainedModel,
						)

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_speech_to_text import (
						    SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
						    SpeechaTextForConditionalGeneration,
						    SpeechaTextModel,
						    SpeechaTextPreTrainedModel,
						)

else:
			import sys

			_A   =     _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



