

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__ (__snake_case					):
				__lowerCamelCase						:	Tuple														=					"""new-model"""


if is_tf_available():


							class 				SCREAMING_SNAKE_CASE__ (__snake_case					):
											__lowerCamelCase						:	Dict														=					NewModelConfig


@require_tf
class 				SCREAMING_SNAKE_CASE__ (unittest.TestCase					):





				@slow
				def 				snake_case_    (				self):
									lowercase__   :       Optional[int]				=	'bert-base-cased'
									lowercase__   :       Optional[Any]				=	AutoConfig.from_pretrained(a)
									self.assertIsNotNone(a)
									self.assertIsInstance(a						,       a)

									lowercase__   :       str				=	TFAutoModel.from_pretrained(a)
									self.assertIsNotNone(a)
									self.assertIsInstance(a						,       a)





				@slow
				def 				snake_case_    (				self):
									lowercase__   :       Optional[int]				=	'bert-base-cased'
									lowercase__   :       int				=	AutoConfig.from_pretrained(a)
									self.assertIsNotNone(a)
									self.assertIsInstance(a						,       a)

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





				@slow
				def 				snake_case_    (				self):
									for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowercase__   :       int				=	AutoConfig.from_pretrained(a)
														self.assertIsNotNone(a)
														self.assertIsInstance(a						,       a)

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





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

														lowercase__   :       List[Any]				=	TFAutoModelWithLMHead.from_pretrained(a)
														self.assertIsNotNone(a)
														self.assertIsInstance(a						,       a)





				@slow
				def 				snake_case_    (				self):
									for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowercase__   :       Optional[Any]				=	AutoConfig.from_pretrained(a)
														self.assertIsNotNone(a)
														self.assertIsInstance(a						,       a)

														lowercase__   :       Optional[int]				=	TFAutoModelForMaskedLM.from_pretrained(a)
														lowercase__   :       List[str]				=	TFAutoModelForMaskedLM.from_pretrained(a						,       output_loading_info=a)
														self.assertIsNotNone(a)
														self.assertIsInstance(a						,       a)





				@slow
				def 				snake_case_    (				self):
									for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowercase__   :       Tuple				=	AutoConfig.from_pretrained(a)
														self.assertIsNotNone(a)
														self.assertIsInstance(a						,       a)

														lowercase__   :       List[str]				=	TFAutoModelForSeqaSeqLM.from_pretrained(a)
														lowercase__   :       Optional[int]				=	TFAutoModelForSeqaSeqLM.from_pretrained(a						,       output_loading_info=a)
														self.assertIsNotNone(a)
														self.assertIsInstance(a						,       a)





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

														lowercase__   :       Tuple				=	TFAutoModelForSequenceClassification.from_pretrained(a)
														self.assertIsNotNone(a)
														self.assertIsInstance(a						,       a)





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

														lowercase__   :       int				=	TFAutoModelForQuestionAnswering.from_pretrained(a)
														self.assertIsNotNone(a)
														self.assertIsInstance(a						,       a)





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

														lowercase__   :       Tuple				=	TFAutoModelForTableQuestionAnswering.from_pretrained(a)
														lowercase__   :       Any				=	TFAutoModelForTableQuestionAnswering.from_pretrained(
														    a						,       output_loading_info=a)
														self.assertIsNotNone(a)
														self.assertIsInstance(a						,       a)





				def 				snake_case_    (				self):
									lowercase__   :       Union[str, Any]				=	TFAutoModelWithLMHead.from_pretrained(a)
									self.assertIsInstance(a						,       a)
									self.assertEqual(model.num_parameters()						,       1_4410)
									self.assertEqual(model.num_parameters(only_trainable=a)						,       1_4410)





				def 				snake_case_    (				self):
									lowercase__   :       int				=	TFAutoModelWithLMHead.from_pretrained(a)
									self.assertIsInstance(a						,       a)
									self.assertEqual(model.num_parameters()						,       1_4410)
									self.assertEqual(model.num_parameters(only_trainable=a)						,       1_4410)





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

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

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





				def 				snake_case_    (				self):
									try:
														AutoConfig.register('new-model'						,       a)

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

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





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





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





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





				def 				snake_case_    (				self):
									# Make sure we have cached the model.
									lowercase__   :       int				=	TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert')
									with RequestCounter() as counter:
														lowercase__   :       int				=	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__   :       Tuple				=	TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded')
									with RequestCounter() as counter:
														lowercase__   :       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)




import warnings
from typing import List, Optional, Union

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType


class 				SCREAMING_SNAKE_CASE__ (__snake_case					):
    __lowerCamelCase						:	Tuple														=					["""image_processor""", """tokenizer"""]
    __lowerCamelCase						:	int														=					"""ViltImageProcessor"""
    __lowerCamelCase						:	Union[str, Any]														=					("""BertTokenizer""", """BertTokenizerFast""")





    def __init__(				self						,       a=None						,       a=None						,       **a):
         lowercase__   :       Any				=	None
         if "feature_extractor" in kwargs:
              warnings.warn(
                  'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
                  ' instead.'						,       a						,       )
              lowercase__   :       Union[str, Any]				=	kwargs.pop('feature_extractor')

         lowercase__   :       List[Any]				=	image_processor if image_processor is not None else feature_extractor
         if image_processor is None:
              raise ValueError('You need to specify an `image_processor`.')
         if tokenizer is None:
              raise ValueError('You need to specify a `tokenizer`.')

         super().__init__(a						,       a)
         lowercase__   :       str				=	self.image_processor





    def __call__(				self						,       a						,       a = None						,       a = True						,       a = False						,       a = None						,       a = None						,       a = 0						,       a = None						,       a = None						,       a = None						,       a = False						,       a = False						,       a = False						,       a = False						,       a = True						,       a = None						,       **a						,       ):
         lowercase__   :       Optional[Any]				=	self.tokenizer(
             text=a						,       add_special_tokens=a						,       padding=a						,       truncation=a						,       max_length=a						,       stride=a						,       pad_to_multiple_of=a						,       return_token_type_ids=a						,       return_attention_mask=a						,       return_overflowing_tokens=a						,       return_special_tokens_mask=a						,       return_offsets_mapping=a						,       return_length=a						,       verbose=a						,       return_tensors=a						,       **a						,       )
         # add pixel_values + pixel_mask
         lowercase__   :       str				=	self.image_processor(a						,       return_tensors=a)
         encoding.update(a)

         return encoding





    def 				snake_case_    (				self						,       *a						,       **a):
         return self.tokenizer.batch_decode(*a						,       **a)





    def 				snake_case_    (				self						,       *a						,       **a):
         return self.tokenizer.decode(*a						,       **a)





    @property
    def 				snake_case_    (				self):
         lowercase__   :       int				=	self.tokenizer.model_input_names
         lowercase__   :       List[str]				=	self.image_processor.model_input_names
         return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names))





    @property
    def 				snake_case_    (				self):
         warnings.warn(
             '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'						,       a						,       )
         return self.image_processor_class





    @property
    def 				snake_case_    (				self):
         warnings.warn(
             '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'						,       a						,       )
         return self.image_processor

