

import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

# Register SEW's fairseq modules
from sew_asapp import tasks  # noqa: F401

from transformers import (
    SEWConfig,
    SEWForCTC,
    SEWModel,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
    logging,
)


logging.set_verbosity_info()
lowerCAmelCase__	   = logging.get_logger(__name__)

lowerCAmelCase__	   = {
    """post_extract_proj""": """feature_projection""",
    """encoder.pos_conv.0""": """encoder.pos_conv_embed.conv""",
    """self_attn.k_proj""": """encoder.layers.*.attention.k_proj""",
    """self_attn.v_proj""": """encoder.layers.*.attention.v_proj""",
    """self_attn.q_proj""": """encoder.layers.*.attention.q_proj""",
    """self_attn.out_proj""": """encoder.layers.*.attention.out_proj""",
    """self_attn_layer_norm""": """encoder.layers.*.layer_norm""",
    """fc1""": """encoder.layers.*.feed_forward.intermediate_dense""",
    """fc2""": """encoder.layers.*.feed_forward.output_dense""",
    """final_layer_norm""": """encoder.layers.*.final_layer_norm""",
    """encoder.upsample.0""": """encoder.upsample.projection""",
    """encoder.layer_norm""": """encoder.layer_norm""",
    """w2v_model.layer_norm""": """layer_norm""",
    """w2v_encoder.proj""": """lm_head""",
    """mask_emb""": """masked_spec_embed""",
}



def 					lowerCAmelCase__							(	SCREAMING_SNAKE_CASE_:							Union[str, Any]	,       SCREAMING_SNAKE_CASE_:							Optional[Any]	,       SCREAMING_SNAKE_CASE_:							List[Any]	,       SCREAMING_SNAKE_CASE_:							Tuple	,       SCREAMING_SNAKE_CASE_:							Tuple      )			->      Dict:




							'''simple docstring'''





							for attribute in key.split("."      ):
														A__        =			getattr(SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_      )

							if weight_type is not None:
														A__        =			getattr(SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_      ).shape
							else:
														A__        =			hf_pointer.shape

							assert hf_shape == value.shape, (
							    F'Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be'
							    F' {value.shape} for {full_name}'
							)

							if weight_type == "weight":
														A__        =			value
							elif weight_type == "weight_g":
														A__        =			value
							elif weight_type == "weight_v":
														A__        =			value
							elif weight_type == "bias":
														A__        =			value
							else:
														A__        =			value

							logger.info(F'{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.'      )



def 					lowerCAmelCase__							(	SCREAMING_SNAKE_CASE_:							Optional[int]	,       SCREAMING_SNAKE_CASE_:							Dict	,       SCREAMING_SNAKE_CASE_:							Union[str, Any]      )			->      int:




							'''simple docstring'''





							A__        =			[]
							A__        =			fairseq_model.state_dict()

							A__        =			hf_model.sew.feature_extractor if is_finetuned else hf_model.feature_extractor

							for name, value in fairseq_dict.items():
														A__        =			False
														if "conv_layers" in name:
																					load_conv_layer(
																					    SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_	,       hf_model.config.feat_extract_norm == "group"	,       )
																					A__        =			True
														else:
																					for key, mapped_key in MAPPING.items():
																												A__        =			"sew." + mapped_key if (is_finetuned and mapped_key != "lm_head") else mapped_key

																												if key in name or key.split("w2v_model."      )[-1] == name.split("."      )[0]:
																																			A__        =			True
																																			if "*" in mapped_key:
																																										A__        =			name.split(SCREAMING_SNAKE_CASE_      )[0].split("."      )[-2]
																																										A__        =			mapped_key.replace("*"	,       SCREAMING_SNAKE_CASE_      )
																																			if "weight_g" in name:
																																										A__        =			"weight_g"
																																			elif "weight_v" in name:
																																										A__        =			"weight_v"
																																			elif "weight" in name:
																																										A__        =			"weight"
																																			elif "bias" in name:
																																										A__        =			"bias"
																																			else:
																																										A__        =			None
																																			set_recursively(SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_      )
																												continue
														if not is_used:
																					unused_weights.append(SCREAMING_SNAKE_CASE_      )

							logger.warning(F'Unused weights: {unused_weights}'      )



def 					lowerCAmelCase__							(	SCREAMING_SNAKE_CASE_:							int	,       SCREAMING_SNAKE_CASE_:							Any	,       SCREAMING_SNAKE_CASE_:							Any	,       SCREAMING_SNAKE_CASE_:							Optional[int]	,       SCREAMING_SNAKE_CASE_:							Any      )			->      Tuple:




							'''simple docstring'''





							A__        =			full_name.split("conv_layers."      )[-1]
							A__        =			name.split("."      )
							A__        =			int(items[0]      )
							A__        =			int(items[1]      )

							if type_id == 0:
														if "bias" in name:
																					assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
																					    F'{full_name} has size {value.shape}, but'
																					    F' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.'
																					)
																					A__        =			value
																					logger.info(F'Feat extract conv layer {layer_id} was initialized from {full_name}.'      )
														elif "weight" in name:
																					assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
																					    F'{full_name} has size {value.shape}, but'
																					    F' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.'
																					)
																					A__        =			value
																					logger.info(F'Feat extract conv layer {layer_id} was initialized from {full_name}.'      )
							elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
														if "bias" in name:
																					assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
																					    F'{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was'
																					    " found."
																					)
																					A__        =			value
																					logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'      )
														elif "weight" in name:
																					assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
																					    F'{full_name} has size {value.shape}, but'
																					    F' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.'
																					)
																					A__        =			value
																					logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'      )
							else:
														unused_weights.append(SCREAMING_SNAKE_CASE_      )



def 					lowerCAmelCase__							(	SCREAMING_SNAKE_CASE_:							Dict	,       SCREAMING_SNAKE_CASE_:							str      )			->      Dict:




							'''simple docstring'''





							A__        =			SEWConfig()
							if is_finetuned:
														A__        =			model.wav_encoder.wav_model.cfg
							else:
														A__        =			model.cfg

							A__        =			fs_config.conv_bias
							A__        =			eval(fs_config.conv_feature_layers      )
							A__        =			[x[0] for x in conv_layers]
							A__        =			[x[1] for x in conv_layers]
							A__        =			[x[2] for x in conv_layers]
							A__        =			"gelu"
							A__        =			"layer" if fs_config.extractor_mode == "layer_norm" else "group"
							A__        =			0.0
							A__        =			fs_config.activation_fn.name
							A__        =			fs_config.encoder_embed_dim
							A__        =			0.02
							A__        =			fs_config.encoder_ffn_embed_dim
							A__        =			1e-5
							A__        =			fs_config.encoder_layerdrop
							A__        =			fs_config.encoder_attention_heads
							A__        =			fs_config.conv_pos_groups
							A__        =			fs_config.conv_pos
							A__        =			len(SCREAMING_SNAKE_CASE_      )
							A__        =			fs_config.encoder_layers
							A__        =			fs_config.squeeze_factor

							# take care of any params that are overridden by the Wav2VecCtc model
							if is_finetuned:
														A__        =			model.cfg
														A__        =			fs_config.final_dropout
														A__        =			fs_config.layerdrop
							A__        =			fs_config.activation_dropout
							A__        =			fs_config.mask_prob > 0 or fs_config.mask_channel_prob > 0
							A__        =			fs_config.attention_dropout
							A__        =			fs_config.dropout_input
							A__        =			fs_config.dropout
							A__        =			fs_config.mask_channel_length
							A__        =			fs_config.mask_channel_prob
							A__        =			fs_config.mask_length
							A__        =			fs_config.mask_prob

							A__        =			"Wav2Vec2FeatureExtractor"
							A__        =			"Wav2Vec2CTCTokenizer"

							return config



@torch.no_grad()
def 					lowerCAmelCase__							(	SCREAMING_SNAKE_CASE_:							Any	,       SCREAMING_SNAKE_CASE_:							Any	,       SCREAMING_SNAKE_CASE_:							List[Any]=None	,       SCREAMING_SNAKE_CASE_:							List[str]=None	,       SCREAMING_SNAKE_CASE_:							Tuple=True      )			->      Tuple:




							'''simple docstring'''





							if is_finetuned:
														A__    ,				A__    ,				A__        =			fairseq.checkpoint_utils.load_model_ensemble_and_task(
														    [checkpoint_path]	,       arg_overrides={"data": "/".join(dict_path.split("/"      )[:-1]      )}      )
							else:
														A__    ,				A__    ,				A__        =			fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]      )

							if config_path is not None:
														A__        =			SEWConfig.from_pretrained(SCREAMING_SNAKE_CASE_      )
							else:
														A__        =			convert_config(model[0]	,       SCREAMING_SNAKE_CASE_      )
							A__        =			model[0].eval()

							A__        =			True if config.feat_extract_norm == "layer" else False
							A__        =			WavaVecaFeatureExtractor(
							    feature_size=1	,       sampling_rate=1_6_0_0_0	,       padding_value=0	,       do_normalize=SCREAMING_SNAKE_CASE_	,       return_attention_mask=SCREAMING_SNAKE_CASE_	,       )

							if is_finetuned:
														if dict_path:
																					A__        =			Dictionary.load(SCREAMING_SNAKE_CASE_      )

																					# important change bos & pad token id since CTC symbol is <pad> and
																					# not <s> as in fairseq
																					A__        =			target_dict.pad_index
																					A__        =			target_dict.bos_index
																					A__        =			target_dict.pad_index
																					A__        =			target_dict.bos_index
																					A__        =			target_dict.eos_index
																					A__        =			len(target_dict.symbols      )
																					A__        =			os.path.join(SCREAMING_SNAKE_CASE_	,       "vocab.json"      )
																					if not os.path.isdir(SCREAMING_SNAKE_CASE_      ):
																												logger.error("--pytorch_dump_folder_path ({}) should be a directory".format(SCREAMING_SNAKE_CASE_      )      )
																												return
																					os.makedirs(SCREAMING_SNAKE_CASE_	,       exist_ok=SCREAMING_SNAKE_CASE_      )
																					with open(SCREAMING_SNAKE_CASE_	,       "w"	,       encoding="utf-8"      ) as vocab_handle:
																												json.dump(target_dict.indices	,       SCREAMING_SNAKE_CASE_      )
																					A__        =			WavaVecaCTCTokenizer(
																					    SCREAMING_SNAKE_CASE_	,       unk_token=target_dict.unk_word	,       pad_token=target_dict.pad_word	,       bos_token=target_dict.bos_word	,       eos_token=target_dict.eos_word	,       word_delimiter_token="|"	,       do_lower_case=SCREAMING_SNAKE_CASE_	,       )
																					A__        =			WavaVecaProcessor(feature_extractor=SCREAMING_SNAKE_CASE_	,       tokenizer=SCREAMING_SNAKE_CASE_      )
																					processor.save_pretrained(SCREAMING_SNAKE_CASE_      )

														A__        =			SEWForCTC(SCREAMING_SNAKE_CASE_      )
							else:
														A__        =			SEWModel(SCREAMING_SNAKE_CASE_      )
														feature_extractor.save_pretrained(SCREAMING_SNAKE_CASE_      )

							recursively_load_weights(SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_      )

							hf_model.save_pretrained(SCREAMING_SNAKE_CASE_      )


if __name__ == "__main__":
	lowerCAmelCase__	   = argparse.ArgumentParser()
	parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
	parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""")
	parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""")
	parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""")
	parser.add_argument(
	    """--is_finetuned""", action="""store_true""", help="""Whether the model to convert is a fine-tuned model or not"""
	)
	lowerCAmelCase__	   = parser.parse_args()
	convert_sew_checkpoint(
	    args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, args.is_finetuned
	)




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 					a__						(					snake_case			):
			"""simple docstring"""







			__lowerCamelCase        =       'new-model'


if is_tf_available():

	class 					a__						(					snake_case			):
				"""simple docstring"""







				__lowerCamelCase        =       NewModelConfig

@require_tf
class 					a__						(					unittest.TestCase			):
			"""simple docstring"""







			@slow
			def      UpperCamelCase		(    self       )  ->						List[Any]:
							'''simple docstring'''






							A__        =			"bert-base-cased"
							A__        =			AutoConfig.from_pretrained(lowercase       )
							self.assertIsNotNone(lowercase       )
							self.assertIsInstance(lowercase      ,      lowercase       )

							A__        =			TFAutoModel.from_pretrained(lowercase       )
							self.assertIsNotNone(lowercase       )
							self.assertIsInstance(lowercase      ,      lowercase       )


			@slow
			def      UpperCamelCase		(    self       )  ->						Optional[Any]:
							'''simple docstring'''






							A__        =			"bert-base-cased"
							A__        =			AutoConfig.from_pretrained(lowercase       )
							self.assertIsNotNone(lowercase       )
							self.assertIsInstance(lowercase      ,      lowercase       )

							A__        =			TFAutoModelForPreTraining.from_pretrained(lowercase       )
							self.assertIsNotNone(lowercase       )
							self.assertIsInstance(lowercase      ,      lowercase       )


			@slow
			def      UpperCamelCase		(    self       )  ->						Dict:
							'''simple docstring'''






							for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											A__        =			AutoConfig.from_pretrained(lowercase       )
											self.assertIsNotNone(lowercase       )
											self.assertIsInstance(lowercase      ,      lowercase       )

											A__        =			TFAutoModelForCausalLM.from_pretrained(lowercase       )
											A__    ,				A__        =			TFAutoModelForCausalLM.from_pretrained(lowercase      ,      output_loading_info=lowercase       )
											self.assertIsNotNone(lowercase       )
											self.assertIsInstance(lowercase      ,      lowercase       )


			@slow
			def      UpperCamelCase		(    self       )  ->						Optional[int]:
							'''simple docstring'''






							for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											A__        =			AutoConfig.from_pretrained(lowercase       )
											self.assertIsNotNone(lowercase       )
											self.assertIsInstance(lowercase      ,      lowercase       )

											A__        =			TFAutoModelWithLMHead.from_pretrained(lowercase       )
											self.assertIsNotNone(lowercase       )
											self.assertIsInstance(lowercase      ,      lowercase       )


			@slow
			def      UpperCamelCase		(    self       )  ->						int:
							'''simple docstring'''






							for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											A__        =			AutoConfig.from_pretrained(lowercase       )
											self.assertIsNotNone(lowercase       )
											self.assertIsInstance(lowercase      ,      lowercase       )

											A__        =			TFAutoModelForMaskedLM.from_pretrained(lowercase       )
											A__    ,				A__        =			TFAutoModelForMaskedLM.from_pretrained(lowercase      ,      output_loading_info=lowercase       )
											self.assertIsNotNone(lowercase       )
											self.assertIsInstance(lowercase      ,      lowercase       )


			@slow
			def      UpperCamelCase		(    self       )  ->						str:
							'''simple docstring'''






							for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											A__        =			AutoConfig.from_pretrained(lowercase       )
											self.assertIsNotNone(lowercase       )
											self.assertIsInstance(lowercase      ,      lowercase       )

											A__        =			TFAutoModelForSeqaSeqLM.from_pretrained(lowercase       )
											A__    ,				A__        =			TFAutoModelForSeqaSeqLM.from_pretrained(lowercase      ,      output_loading_info=lowercase       )
											self.assertIsNotNone(lowercase       )
											self.assertIsInstance(lowercase      ,      lowercase       )


			@slow
			def      UpperCamelCase		(    self       )  ->						Dict:
							'''simple docstring'''






							for model_name in ["bert-base-uncased"]:
											A__        =			AutoConfig.from_pretrained(lowercase       )
											self.assertIsNotNone(lowercase       )
											self.assertIsInstance(lowercase      ,      lowercase       )

											A__        =			TFAutoModelForSequenceClassification.from_pretrained(lowercase       )
											self.assertIsNotNone(lowercase       )
											self.assertIsInstance(lowercase      ,      lowercase       )


			@slow
			def      UpperCamelCase		(    self       )  ->						int:
							'''simple docstring'''






							for model_name in ["bert-base-uncased"]:
											A__        =			AutoConfig.from_pretrained(lowercase       )
											self.assertIsNotNone(lowercase       )
											self.assertIsInstance(lowercase      ,      lowercase       )

											A__        =			TFAutoModelForQuestionAnswering.from_pretrained(lowercase       )
											self.assertIsNotNone(lowercase       )
											self.assertIsInstance(lowercase      ,      lowercase       )


			@slow
			@require_tensorflow_probability
			def      UpperCamelCase		(    self       )  ->						List[str]:
							'''simple docstring'''






							for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
											A__        =			AutoConfig.from_pretrained(lowercase       )
											self.assertIsNotNone(lowercase       )
											self.assertIsInstance(lowercase      ,      lowercase       )

											A__        =			TFAutoModelForTableQuestionAnswering.from_pretrained(lowercase       )
											A__    ,				A__        =			TFAutoModelForTableQuestionAnswering.from_pretrained(
											    lowercase      ,      output_loading_info=lowercase       )
											self.assertIsNotNone(lowercase       )
											self.assertIsInstance(lowercase      ,      lowercase       )


			def      UpperCamelCase		(    self       )  ->						Dict:
							'''simple docstring'''






							A__        =			TFAutoModelWithLMHead.from_pretrained(lowercase       )
							self.assertIsInstance(lowercase      ,      lowercase       )
							self.assertEqual(model.num_parameters()      ,      14410       )
							self.assertEqual(model.num_parameters(only_trainable=lowercase       )      ,      14410       )


			def      UpperCamelCase		(    self       )  ->						Any:
							'''simple docstring'''






							A__        =			TFAutoModelWithLMHead.from_pretrained(lowercase       )
							self.assertIsInstance(lowercase      ,      lowercase       )
							self.assertEqual(model.num_parameters()      ,      14410       )
							self.assertEqual(model.num_parameters(only_trainable=lowercase       )      ,      14410       )


			def      UpperCamelCase		(    self       )  ->						int:
							'''simple docstring'''






							A__        =			TFAutoModel.from_pretrained("sgugger/funnel-random-tiny"       )
							self.assertIsInstance(lowercase      ,      lowercase       )

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

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


			def      UpperCamelCase		(    self       )  ->						Optional[Any]:
							'''simple docstring'''






							try:
											AutoConfig.register("new-model"      ,      lowercase       )

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

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

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

							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       )  ->						str:
							'''simple docstring'''






							with self.assertRaisesRegex(
							    lowercase      ,      "bert-base is not a local folder and is not a valid model identifier"       ):
											A__        =			TFAutoModel.from_pretrained("bert-base"       )


			def      UpperCamelCase		(    self       )  ->						Optional[Any]:
							'''simple docstring'''






							with self.assertRaisesRegex(
							    lowercase      ,      R"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"       ):
											A__        =			TFAutoModel.from_pretrained(lowercase      ,      revision="aaaaaa"       )


			def      UpperCamelCase		(    self       )  ->						Union[str, Any]:
							'''simple docstring'''






							with self.assertRaisesRegex(
							    lowercase      ,      "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      UpperCamelCase		(    self       )  ->						Union[str, Any]:
							'''simple docstring'''






							with self.assertRaisesRegex(lowercase      ,      "Use `from_pt=True` to load this model"       ):
											A__        =			TFAutoModel.from_pretrained("hf-internal-testing/tiny-bert-pt-only"       )


			def      UpperCamelCase		(    self       )  ->						Any:
							'''simple docstring'''






							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       )

