
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 (		_SCREAMING_SNAKE_CASE       ):
		__lowercase	:	Optional[int]     					=    "new-model"


if is_tf_available():


					class     lowercase (		_SCREAMING_SNAKE_CASE       ):
							__lowercase	:	List[Any]     					=    NewModelConfig


@require_tf
class     lowercase (		unittest.TestCase       ):



		@slow
		def __UpperCamelCase			(			self	)  -> Union[str, Any]:
				"""simple docstring"""
				UpperCamelCase          =					'bert-base-cased'
				UpperCamelCase          =					AutoConfig.from_pretrained(A_	)
				self.assertIsNotNone(A_	)
				self.assertIsInstance(A_    ,  A_	)

				UpperCamelCase          =					TFAutoModel.from_pretrained(A_	)
				self.assertIsNotNone(A_	)
				self.assertIsInstance(A_    ,  A_	)



		@slow
		def __UpperCamelCase			(			self	)  -> Tuple:
				"""simple docstring"""
				UpperCamelCase          =					'bert-base-cased'
				UpperCamelCase          =					AutoConfig.from_pretrained(A_	)
				self.assertIsNotNone(A_	)
				self.assertIsInstance(A_    ,  A_	)

				UpperCamelCase          =					TFAutoModelForPreTraining.from_pretrained(A_	)
				self.assertIsNotNone(A_	)
				self.assertIsInstance(A_    ,  A_	)



		@slow
		def __UpperCamelCase			(			self	)  -> Tuple:
				"""simple docstring"""
				for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						UpperCamelCase          =					AutoConfig.from_pretrained(A_	)
						self.assertIsNotNone(A_	)
						self.assertIsInstance(A_    ,  A_	)

						UpperCamelCase          =					TFAutoModelForCausalLM.from_pretrained(A_	)
						UpperCamelCase     ,  UpperCamelCase          =					TFAutoModelForCausalLM.from_pretrained(A_    ,  output_loading_info=A_	)
						self.assertIsNotNone(A_	)
						self.assertIsInstance(A_    ,  A_	)



		@slow
		def __UpperCamelCase			(			self	)  -> int:
				"""simple docstring"""
				for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						UpperCamelCase          =					AutoConfig.from_pretrained(A_	)
						self.assertIsNotNone(A_	)
						self.assertIsInstance(A_    ,  A_	)

						UpperCamelCase          =					TFAutoModelWithLMHead.from_pretrained(A_	)
						self.assertIsNotNone(A_	)
						self.assertIsInstance(A_    ,  A_	)



		@slow
		def __UpperCamelCase			(			self	)  -> Optional[int]:
				"""simple docstring"""
				for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						UpperCamelCase          =					AutoConfig.from_pretrained(A_	)
						self.assertIsNotNone(A_	)
						self.assertIsInstance(A_    ,  A_	)

						UpperCamelCase          =					TFAutoModelForMaskedLM.from_pretrained(A_	)
						UpperCamelCase     ,  UpperCamelCase          =					TFAutoModelForMaskedLM.from_pretrained(A_    ,  output_loading_info=A_	)
						self.assertIsNotNone(A_	)
						self.assertIsInstance(A_    ,  A_	)



		@slow
		def __UpperCamelCase			(			self	)  -> Optional[int]:
				"""simple docstring"""
				for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						UpperCamelCase          =					AutoConfig.from_pretrained(A_	)
						self.assertIsNotNone(A_	)
						self.assertIsInstance(A_    ,  A_	)

						UpperCamelCase          =					TFAutoModelForSeqaSeqLM.from_pretrained(A_	)
						UpperCamelCase     ,  UpperCamelCase          =					TFAutoModelForSeqaSeqLM.from_pretrained(A_    ,  output_loading_info=A_	)
						self.assertIsNotNone(A_	)
						self.assertIsInstance(A_    ,  A_	)



		@slow
		def __UpperCamelCase			(			self	)  -> List[Any]:
				"""simple docstring"""
				# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
				for model_name in ["bert-base-uncased"]:
						UpperCamelCase          =					AutoConfig.from_pretrained(A_	)
						self.assertIsNotNone(A_	)
						self.assertIsInstance(A_    ,  A_	)

						UpperCamelCase          =					TFAutoModelForSequenceClassification.from_pretrained(A_	)
						self.assertIsNotNone(A_	)
						self.assertIsInstance(A_    ,  A_	)



		@slow
		def __UpperCamelCase			(			self	)  -> List[str]:
				"""simple docstring"""
				# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
				for model_name in ["bert-base-uncased"]:
						UpperCamelCase          =					AutoConfig.from_pretrained(A_	)
						self.assertIsNotNone(A_	)
						self.assertIsInstance(A_    ,  A_	)

						UpperCamelCase          =					TFAutoModelForQuestionAnswering.from_pretrained(A_	)
						self.assertIsNotNone(A_	)
						self.assertIsInstance(A_    ,  A_	)



		@slow
		@require_tensorflow_probability
		def __UpperCamelCase			(			self	)  -> Optional[int]:
				"""simple docstring"""
				for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
						UpperCamelCase          =					AutoConfig.from_pretrained(A_	)
						self.assertIsNotNone(A_	)
						self.assertIsInstance(A_    ,  A_	)

						UpperCamelCase          =					TFAutoModelForTableQuestionAnswering.from_pretrained(A_	)
						UpperCamelCase     ,  UpperCamelCase          =					TFAutoModelForTableQuestionAnswering.from_pretrained(
						    A_    ,  output_loading_info=A_	)
						self.assertIsNotNone(A_	)
						self.assertIsInstance(A_    ,  A_	)



		def __UpperCamelCase			(			self	)  -> List[Any]:
				"""simple docstring"""
				UpperCamelCase          =					TFAutoModelWithLMHead.from_pretrained(A_	)
				self.assertIsInstance(A_    ,  A_	)
				self.assertEqual(model.num_parameters()    ,  14_410	)
				self.assertEqual(model.num_parameters(only_trainable=A_	)    ,  14_410	)



		def __UpperCamelCase			(			self	)  -> Optional[int]:
				"""simple docstring"""
				UpperCamelCase          =					TFAutoModelWithLMHead.from_pretrained(A_	)
				self.assertIsInstance(A_    ,  A_	)
				self.assertEqual(model.num_parameters()    ,  14_410	)
				self.assertEqual(model.num_parameters(only_trainable=A_	)    ,  14_410	)



		def __UpperCamelCase			(			self	)  -> int:
				"""simple docstring"""
				UpperCamelCase          =					TFAutoModel.from_pretrained('sgugger/funnel-random-tiny'	)
				self.assertIsInstance(A_    ,  A_	)

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

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



		def __UpperCamelCase			(			self	)  -> List[str]:
				"""simple docstring"""
				try:
						AutoConfig.register('new-model'    ,  A_	)

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

										# 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(A_	)
										self.assertIsInstance(A_    ,  A_	)

										with tempfile.TemporaryDirectory() as tmp_dir:
												model.save_pretrained(A_	)
												UpperCamelCase          =					auto_class.from_pretrained(A_	)
												self.assertIsInstance(A_    ,  A_	)

				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 __UpperCamelCase			(			self	)  -> Any:
				"""simple docstring"""
				with self.assertRaisesRegex(
				    A_    ,  'bert-base is not a local folder and is not a valid model identifier'	):
						UpperCamelCase          =					TFAutoModel.from_pretrained('bert-base'	)



		def __UpperCamelCase			(			self	)  -> Dict:
				"""simple docstring"""
				with self.assertRaisesRegex(
				    A_    ,  r'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'	):
						UpperCamelCase          =					TFAutoModel.from_pretrained(A_    ,  revision='aaaaaa'	)



		def __UpperCamelCase			(			self	)  -> List[Any]:
				"""simple docstring"""
				with self.assertRaisesRegex(
				    A_    ,  '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 __UpperCamelCase			(			self	)  -> Tuple:
				"""simple docstring"""
				with self.assertRaisesRegex(A_    ,  'Use `from_pt=True` to load this model'	):
						UpperCamelCase          =					TFAutoModel.from_pretrained('hf-internal-testing/tiny-bert-pt-only'	)



		def __UpperCamelCase			(			self	)  -> str:
				"""simple docstring"""
				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	)


from ...utils import (
    OptionalDependencyNotAvailable,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)


try:
					if not (is_transformers_available() and is_torch_available() and is_transformers_version(">=", "4.25.0")):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from ...utils.dummy_torch_and_transformers_objects import UnCLIPImageVariationPipeline, UnCLIPPipeline
else:
					from .pipeline_unclip import UnCLIPPipeline
					from .pipeline_unclip_image_variation import UnCLIPImageVariationPipeline
					from .text_proj import UnCLIPTextProjModel
