






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					):





							"""simple docstring"""

							A_						  =					"new-model"


if is_tf_available():





				class 						SCREAMING_SNAKE_CASE				( snake_case					):





											"""simple docstring"""

											A_						  =					NewModelConfig





@require_tf
class 						SCREAMING_SNAKE_CASE				( unittest.TestCase					):





							"""simple docstring"""

							@slow
							def       __A (  self:   Optional[Any]   )    ->				Union[str, Any]:
												_A								= '''bert-base-cased'''
												_A								= AutoConfig.from_pretrained(__A   )
												self.assertIsNotNone(__A   )
												self.assertIsInstance(__A		,     __A   )

												_A								= TFAutoModel.from_pretrained(__A   )
												self.assertIsNotNone(__A   )
												self.assertIsInstance(__A		,     __A   )

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

												_A								= TFAutoModelForPreTraining.from_pretrained(__A   )
												self.assertIsNotNone(__A   )
												self.assertIsInstance(__A		,     __A   )

							@slow
							def       __A (  self:   Dict   )    ->				List[str]:
												for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	_A								= AutoConfig.from_pretrained(__A   )
																	self.assertIsNotNone(__A   )
																	self.assertIsInstance(__A		,     __A   )

																	_A								= TFAutoModelForCausalLM.from_pretrained(__A   )
																	_A							,_A								= TFAutoModelForCausalLM.from_pretrained(__A		,     output_loading_info=__A   )
																	self.assertIsNotNone(__A   )
																	self.assertIsInstance(__A		,     __A   )

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

																	_A								= TFAutoModelWithLMHead.from_pretrained(__A   )
																	self.assertIsNotNone(__A   )
																	self.assertIsInstance(__A		,     __A   )

							@slow
							def       __A (  self:   int   )    ->				int:
												for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	_A								= AutoConfig.from_pretrained(__A   )
																	self.assertIsNotNone(__A   )
																	self.assertIsInstance(__A		,     __A   )

																	_A								= TFAutoModelForMaskedLM.from_pretrained(__A   )
																	_A							,_A								= TFAutoModelForMaskedLM.from_pretrained(__A		,     output_loading_info=__A   )
																	self.assertIsNotNone(__A   )
																	self.assertIsInstance(__A		,     __A   )

							@slow
							def       __A (  self:   str   )    ->				Optional[Any]:
												for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	_A								= AutoConfig.from_pretrained(__A   )
																	self.assertIsNotNone(__A   )
																	self.assertIsInstance(__A		,     __A   )

																	_A								= TFAutoModelForSeqaSeqLM.from_pretrained(__A   )
																	_A							,_A								= TFAutoModelForSeqaSeqLM.from_pretrained(__A		,     output_loading_info=__A   )
																	self.assertIsNotNone(__A   )
																	self.assertIsInstance(__A		,     __A   )

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

																	_A								= TFAutoModelForSequenceClassification.from_pretrained(__A   )
																	self.assertIsNotNone(__A   )
																	self.assertIsInstance(__A		,     __A   )

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

																	_A								= TFAutoModelForQuestionAnswering.from_pretrained(__A   )
																	self.assertIsNotNone(__A   )
																	self.assertIsInstance(__A		,     __A   )

							@slow
							@require_tensorflow_probability
							def       __A (  self:   Any   )    ->				str:
												for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
																	_A								= AutoConfig.from_pretrained(__A   )
																	self.assertIsNotNone(__A   )
																	self.assertIsInstance(__A		,     __A   )

																	_A								= TFAutoModelForTableQuestionAnswering.from_pretrained(__A   )
																	_A							,_A								= TFAutoModelForTableQuestionAnswering.from_pretrained(
																	    __A		,     output_loading_info=__A   )
																	self.assertIsNotNone(__A   )
																	self.assertIsInstance(__A		,     __A   )

							def       __A (  self:   List[str]   )    ->				Dict:
												_A								= TFAutoModelWithLMHead.from_pretrained(__A   )
												self.assertIsInstance(__A		,     __A   )
												self.assertEqual(model.num_parameters()		,     1_44_10   )
												self.assertEqual(model.num_parameters(only_trainable=__A   )		,     1_44_10   )

							def       __A (  self:   Union[str, Any]   )    ->				Optional[int]:
												_A								= TFAutoModelWithLMHead.from_pretrained(__A   )
												self.assertIsInstance(__A		,     __A   )
												self.assertEqual(model.num_parameters()		,     1_44_10   )
												self.assertEqual(model.num_parameters(only_trainable=__A   )		,     1_44_10   )

							def       __A (  self:   Optional[Any]   )    ->				Optional[Any]:
												# For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel
												_A								= TFAutoModel.from_pretrained('''sgugger/funnel-random-tiny'''   )
												self.assertIsInstance(__A		,     __A   )

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

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

							def       __A (  self:   Optional[Any]   )    ->				int:
												try:
																	AutoConfig.register('''new-model'''		,     __A   )

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

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

							def       __A (  self:   List[str]   )    ->				List[Any]:
												with self.assertRaisesRegex(
												    __A		,     R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''   ):
																	_A								= TFAutoModel.from_pretrained(__A		,     revision='''aaaaaa'''   )

							def       __A (  self:   Tuple   )    ->				Optional[int]:
												with self.assertRaisesRegex(
												    __A		,     '''hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin'''		,     ):
																	_A								= TFAutoModel.from_pretrained('''hf-internal-testing/config-no-model'''   )

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



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











def      __A					(     _lowercase					,			_lowercase					,			_lowercase					,			_lowercase ):

					'''simple docstring'''







					_A							,_A								= len(_lowercase ), len(grid[0] )
					if (
					    min(_lowercase					,			_lowercase ) < 0
					    or row == row_length
					    or col == col_length
					    or (row, col) in visit
					    or grid[row][col] == 1
					):
										return 0
					if row == row_length - 1 and col == col_length - 1:
										return 1

					visit.add((row, col) )

					_A								= 0
					count += depth_first_search(_lowercase					,			row + 1					,			_lowercase					,			_lowercase )
					count += depth_first_search(_lowercase					,			row - 1					,			_lowercase					,			_lowercase )
					count += depth_first_search(_lowercase					,			_lowercase					,			col + 1					,			_lowercase )
					count += depth_first_search(_lowercase					,			_lowercase					,			col - 1					,			_lowercase )

					visit.remove((row, col) )
					return count


if __name__ == "__main__":
				import doctest

				doctest.testmod()



