






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





	"""simple docstring"""




	_A       :				Union[str, Any]    =				"""new-model"""


if is_tf_available():



							class      SCREAMING_SNAKE_CASE  (				_SCREAMING_SNAKE_CASE						):





								"""simple docstring"""




								_A       :				List[Any]    =				NewModelConfig



@require_tf
class      SCREAMING_SNAKE_CASE  (				unittest.TestCase						):





	"""simple docstring"""




	@slow
	def    lowerCamelCase(self							):
		A_		:						int	    =   """bert-base-cased"""
		A_		:						List[Any]	    =   AutoConfig.from_pretrained(lowerCAmelCase_							)
		self.assertIsNotNone(lowerCAmelCase_							)
		self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)

		A_		:						int	    =   TFAutoModel.from_pretrained(lowerCAmelCase_							)
		self.assertIsNotNone(lowerCAmelCase_							)
		self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)





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

		A_		:						Union[str, Any]	    =   TFAutoModelForPreTraining.from_pretrained(lowerCAmelCase_							)
		self.assertIsNotNone(lowerCAmelCase_							)
		self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)





	@slow
	def    lowerCamelCase(self							):
		for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			A_		:						Optional[int]	    =   AutoConfig.from_pretrained(lowerCAmelCase_							)
			self.assertIsNotNone(lowerCAmelCase_							)
			self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)

			A_		:						List[str]	    =   TFAutoModelForCausalLM.from_pretrained(lowerCAmelCase_							)
			A_    ,     A_		:						List[Any]	    =   TFAutoModelForCausalLM.from_pretrained(lowerCAmelCase_     ,     output_loading_info=lowerCAmelCase_							)
			self.assertIsNotNone(lowerCAmelCase_							)
			self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)





	@slow
	def    lowerCamelCase(self							):
		for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			A_		:						Any	    =   AutoConfig.from_pretrained(lowerCAmelCase_							)
			self.assertIsNotNone(lowerCAmelCase_							)
			self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)

			A_		:						List[Any]	    =   TFAutoModelWithLMHead.from_pretrained(lowerCAmelCase_							)
			self.assertIsNotNone(lowerCAmelCase_							)
			self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)





	@slow
	def    lowerCamelCase(self							):
		for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			A_		:						Optional[int]	    =   AutoConfig.from_pretrained(lowerCAmelCase_							)
			self.assertIsNotNone(lowerCAmelCase_							)
			self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)

			A_		:						Optional[Any]	    =   TFAutoModelForMaskedLM.from_pretrained(lowerCAmelCase_							)
			A_    ,     A_		:						Dict	    =   TFAutoModelForMaskedLM.from_pretrained(lowerCAmelCase_     ,     output_loading_info=lowerCAmelCase_							)
			self.assertIsNotNone(lowerCAmelCase_							)
			self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)





	@slow
	def    lowerCamelCase(self							):
		for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			A_		:						Dict	    =   AutoConfig.from_pretrained(lowerCAmelCase_							)
			self.assertIsNotNone(lowerCAmelCase_							)
			self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)

			A_		:						Tuple	    =   TFAutoModelForSeqaSeqLM.from_pretrained(lowerCAmelCase_							)
			A_    ,     A_		:						Dict	    =   TFAutoModelForSeqaSeqLM.from_pretrained(lowerCAmelCase_     ,     output_loading_info=lowerCAmelCase_							)
			self.assertIsNotNone(lowerCAmelCase_							)
			self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)





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

			A_		:						Dict	    =   TFAutoModelForSequenceClassification.from_pretrained(lowerCAmelCase_							)
			self.assertIsNotNone(lowerCAmelCase_							)
			self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)





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

			A_		:						int	    =   TFAutoModelForQuestionAnswering.from_pretrained(lowerCAmelCase_							)
			self.assertIsNotNone(lowerCAmelCase_							)
			self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)





	@slow
	@require_tensorflow_probability
	def    lowerCamelCase(self							):
		for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
			A_		:						List[str]	    =   AutoConfig.from_pretrained(lowerCAmelCase_							)
			self.assertIsNotNone(lowerCAmelCase_							)
			self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)

			A_		:						Tuple	    =   TFAutoModelForTableQuestionAnswering.from_pretrained(lowerCAmelCase_							)
			A_    ,     A_		:						Optional[int]	    =   TFAutoModelForTableQuestionAnswering.from_pretrained(
			    lowerCAmelCase_     ,     output_loading_info=lowerCAmelCase_							)
			self.assertIsNotNone(lowerCAmelCase_							)
			self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)





	def    lowerCamelCase(self							):
		A_		:						Union[str, Any]	    =   TFAutoModelWithLMHead.from_pretrained(lowerCAmelCase_							)
		self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)
		self.assertEqual(model.num_parameters()     ,     14410							)
		self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase_							)     ,     14410							)





	def    lowerCamelCase(self							):
		A_		:						List[Any]	    =   TFAutoModelWithLMHead.from_pretrained(lowerCAmelCase_							)
		self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)
		self.assertEqual(model.num_parameters()     ,     14410							)
		self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase_							)     ,     14410							)





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

		A_		:						int	    =   copy.deepcopy(model.config							)
		A_		:						Tuple	    =   ["""FunnelBaseModel"""]
		A_		:						str	    =   TFAutoModel.from_config(lowerCAmelCase_							)
		self.assertIsInstance(lowerCAmelCase_     ,     lowerCAmelCase_							)

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





	def    lowerCamelCase(self							):
		try:
			AutoConfig.register("""new-model"""     ,     lowerCAmelCase_							)

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

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





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





	def    lowerCamelCase(self							):
		with self.assertRaisesRegex(
		    lowerCAmelCase_     ,     """hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin"""     ,     ):
			A_		:						Dict	    =   TFAutoModel.from_pretrained("""hf-internal-testing/config-no-model"""							)





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





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









"""simple docstring"""
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding



class      SCREAMING_SNAKE_CASE  (				_SCREAMING_SNAKE_CASE						):





	"""simple docstring"""




	_A       :				Optional[int]    =				["""image_processor""", """tokenizer"""]
	_A       :				str    =				"""AutoImageProcessor"""
	_A       :				Union[str, Any]    =				"""AutoTokenizer"""





	def __init__(self     ,     lowerCAmelCase_     ,     lowerCAmelCase_							):
		super().__init__(lowerCAmelCase_     ,     lowerCAmelCase_							)
		A_		:						Union[str, Any]	    =   self.image_processor





	def __call__(self     ,     lowerCAmelCase_=None     ,     lowerCAmelCase_=None     ,     lowerCAmelCase_=None     ,     **lowerCAmelCase_							):

		if text is None and images is None:
			raise ValueError("""You have to specify either text or images. Both cannot be none."""							)

		if text is not None:
			A_		:						Optional[int]	    =   self.tokenizer(lowerCAmelCase_     ,     return_tensors=lowerCAmelCase_     ,     **lowerCAmelCase_							)

		if images is not None:
			A_		:						List[Any]	    =   self.image_processor(lowerCAmelCase_     ,     return_tensors=lowerCAmelCase_     ,     **lowerCAmelCase_							)

		if text is not None and images is not None:
			A_		:						int	    =   image_features.pixel_values
			return encoding
		elif text is not None:
			return encoding
		else:
			return BatchEncoding(data=dict(**lowerCAmelCase_							)     ,     tensor_type=lowerCAmelCase_							)





	def    lowerCamelCase(self     ,     *lowerCAmelCase_     ,     **lowerCAmelCase_							):
		return self.tokenizer.batch_decode(*lowerCAmelCase_     ,     **lowerCAmelCase_							)





	def    lowerCamelCase(self     ,     *lowerCAmelCase_     ,     **lowerCAmelCase_							):
		return self.tokenizer.decode(*lowerCAmelCase_     ,     **lowerCAmelCase_							)





	@property
	def    lowerCamelCase(self							):
		return ["input_ids", "attention_mask", "pixel_values"]

