

'''simple docstring'''





import argparse

import torch

from transformers import (
    SpeechTaConfig,
    SpeechTaFeatureExtractor,
    SpeechTaForSpeechToSpeech,
    SpeechTaForSpeechToText,
    SpeechTaForTextToSpeech,
    SpeechTaProcessor,
    SpeechTaTokenizer,
    logging,
)
from transformers.tokenization_utils import AddedToken


logging.set_verbosity_info()
UpperCamelCase_    						=       logging.get_logger("""transformers.models.speecht5""")

UpperCamelCase_    						=       {
    """speech_encoder_prenet.layer_norm""": """speecht5.encoder.prenet.feature_projection.layer_norm""",
    """speech_encoder_prenet.post_extract_proj""": """speecht5.encoder.prenet.feature_projection.projection""",
    """speech_encoder_prenet.pos_conv.0""": """speecht5.encoder.prenet.pos_conv_embed.conv""",
    """speech_encoder_prenet.mask_emb""": """speecht5.encoder.prenet.masked_spec_embed""",
}
UpperCamelCase_    						=       {
    """text_encoder_prenet.encoder_prenet.0""": """speecht5.encoder.prenet.embed_tokens""",
    """text_encoder_prenet.encoder_prenet.1.alpha""": """speecht5.encoder.prenet.encode_positions.alpha""",
}
UpperCamelCase_    						=       {
    """speech_decoder_prenet.decoder_prenet.0.0.prenet.0.0""": """speecht5.decoder.prenet.layers.0""",
    """speech_decoder_prenet.decoder_prenet.0.0.prenet.1.0""": """speecht5.decoder.prenet.layers.1""",
    """speech_decoder_prenet.decoder_prenet.0.1""": """speecht5.decoder.prenet.final_layer""",
    """speech_decoder_prenet.decoder_prenet.1.alpha""": """speecht5.decoder.prenet.encode_positions.alpha""",
    """speech_decoder_prenet.spkembs_layer.0""": """speecht5.decoder.prenet.speaker_embeds_layer""",
}
UpperCamelCase_    						=       {
    """speech_decoder_postnet.feat_out""": """speech_decoder_postnet.feat_out""",
    """speech_decoder_postnet.prob_out""": """speech_decoder_postnet.prob_out""",
    """speech_decoder_postnet.postnet.postnet.0.0""": """speech_decoder_postnet.layers.0.conv""",
    """speech_decoder_postnet.postnet.postnet.0.1""": """speech_decoder_postnet.layers.0.batch_norm""",
    """speech_decoder_postnet.postnet.postnet.1.0""": """speech_decoder_postnet.layers.1.conv""",
    """speech_decoder_postnet.postnet.postnet.1.1""": """speech_decoder_postnet.layers.1.batch_norm""",
    """speech_decoder_postnet.postnet.postnet.2.0""": """speech_decoder_postnet.layers.2.conv""",
    """speech_decoder_postnet.postnet.postnet.2.1""": """speech_decoder_postnet.layers.2.batch_norm""",
    """speech_decoder_postnet.postnet.postnet.3.0""": """speech_decoder_postnet.layers.3.conv""",
    """speech_decoder_postnet.postnet.postnet.3.1""": """speech_decoder_postnet.layers.3.batch_norm""",
    """speech_decoder_postnet.postnet.postnet.4.0""": """speech_decoder_postnet.layers.4.conv""",
    """speech_decoder_postnet.postnet.postnet.4.1""": """speech_decoder_postnet.layers.4.batch_norm""",
}
UpperCamelCase_    						=       {
    """text_decoder_prenet.embed_tokens""": """speecht5.decoder.prenet.embed_tokens""",
}
UpperCamelCase_    						=       {
    """text_decoder_postnet.output_projection""": """text_decoder_postnet.lm_head""",
}
UpperCamelCase_    						=       {
    """encoder.layers.*.self_attn.k_proj""": """speecht5.encoder.wrapped_encoder.layers.*.attention.k_proj""",
    """encoder.layers.*.self_attn.v_proj""": """speecht5.encoder.wrapped_encoder.layers.*.attention.v_proj""",
    """encoder.layers.*.self_attn.q_proj""": """speecht5.encoder.wrapped_encoder.layers.*.attention.q_proj""",
    """encoder.layers.*.self_attn.out_proj""": """speecht5.encoder.wrapped_encoder.layers.*.attention.out_proj""",
    """encoder.layers.*.self_attn_layer_norm""": """speecht5.encoder.wrapped_encoder.layers.*.layer_norm""",
    """encoder.layers.*.fc1""": """speecht5.encoder.wrapped_encoder.layers.*.feed_forward.intermediate_dense""",
    """encoder.layers.*.fc2""": """speecht5.encoder.wrapped_encoder.layers.*.feed_forward.output_dense""",
    """encoder.layers.*.final_layer_norm""": """speecht5.encoder.wrapped_encoder.layers.*.final_layer_norm""",
    """encoder.layer_norm""": """speecht5.encoder.wrapped_encoder.layer_norm""",
    """encoder.pos_emb.pe_k""": """speecht5.encoder.wrapped_encoder.embed_positions.pe_k""",
}
UpperCamelCase_    						=       {
    """decoder.layers.*.self_attn.k_proj""": """speecht5.decoder.wrapped_decoder.layers.*.self_attn.k_proj""",
    """decoder.layers.*.self_attn.v_proj""": """speecht5.decoder.wrapped_decoder.layers.*.self_attn.v_proj""",
    """decoder.layers.*.self_attn.q_proj""": """speecht5.decoder.wrapped_decoder.layers.*.self_attn.q_proj""",
    """decoder.layers.*.self_attn.out_proj""": """speecht5.decoder.wrapped_decoder.layers.*.self_attn.out_proj""",
    """decoder.layers.*.self_attn_layer_norm""": """speecht5.decoder.wrapped_decoder.layers.*.self_attn_layer_norm""",
    """decoder.layers.*.encoder_attn.k_proj""": """speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.k_proj""",
    """decoder.layers.*.encoder_attn.v_proj""": """speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.v_proj""",
    """decoder.layers.*.encoder_attn.q_proj""": """speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.q_proj""",
    """decoder.layers.*.encoder_attn.out_proj""": """speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.out_proj""",
    """decoder.layers.*.encoder_attn_layer_norm""": """speecht5.decoder.wrapped_decoder.layers.*.encoder_attn_layer_norm""",
    """decoder.layers.*.fc1""": """speecht5.decoder.wrapped_decoder.layers.*.feed_forward.intermediate_dense""",
    """decoder.layers.*.fc2""": """speecht5.decoder.wrapped_decoder.layers.*.feed_forward.output_dense""",
    """decoder.layers.*.final_layer_norm""": """speecht5.decoder.wrapped_decoder.layers.*.final_layer_norm""",
}
UpperCamelCase_    						=       {
    **MAPPING_SPEECH_ENCODER_PRENET,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
    **MAPPING_TEXT_DECODER_PRENET,
    **MAPPING_TEXT_DECODER_POSTNET,
}
UpperCamelCase_    						=       {
    **MAPPING_TEXT_ENCODER_PRENET,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
    **MAPPING_SPEECH_DECODER_PRENET,
    **MAPPING_SPEECH_DECODER_POSTNET,
}
UpperCamelCase_    						=       {
    **MAPPING_SPEECH_ENCODER_PRENET,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
    **MAPPING_SPEECH_DECODER_PRENET,
    **MAPPING_SPEECH_DECODER_POSTNET,
}
UpperCamelCase_    						=       []
UpperCamelCase_    						=       [
    """encoder.version""",
    """encoder.layers.*.norm_k.weight""",
    """encoder.layers.*.norm_k.bias""",
    """decoder.version""",
    """decoder.layers.*.norm_k.weight""",
    """decoder.layers.*.norm_k.bias""",
    """decoder.pos_emb.pe_k""",
    """speech_encoder_prenet.embed_positions._float_tensor""",
    """text_decoder_prenet.embed_positions._float_tensor""",
]
UpperCamelCase_    						=       IGNORE_KEYS + [
    """encoder.proj""",
    """text_encoder_prenet.*""",
    """speech_decoder_prenet.*""",
    """speech_decoder_postnet.*""",
]
UpperCamelCase_    						=       IGNORE_KEYS + [
    """encoder.proj""",
    """speech_encoder_prenet.*""",
    """text_decoder_prenet.*""",
    """text_decoder_postnet.*""",
]
UpperCamelCase_    						=       IGNORE_KEYS + [
    """encoder.proj""",
    """text_encoder_prenet.*""",
    """text_decoder_prenet.*""",
    """text_decoder_postnet.*""",
]






def 				_lowerCAmelCase			(   __magic_name__						:     List[str]   , __magic_name__						:     List[Any]   , __magic_name__						:     int   , __magic_name__						:     Optional[int]   , __magic_name__						:     Tuple						)				->  List[Any]:
						for attribute in key.split('''.'''						):
												lowercase :							Any    		=getattr(__magic_name__   , __magic_name__						)

						if weight_type is not None:
												lowercase :							Any    		=getattr(__magic_name__   , __magic_name__						).shape
						else:
												lowercase :							int    		=hf_pointer.shape

						if hf_shape != value.shape:
												raise ValueError(
												    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":
												lowercase :							Optional[Any]    		=value
						elif weight_type == "weight_g":
												lowercase :							List[str]    		=value
						elif weight_type == "weight_v":
												lowercase :							Any    		=value
						elif weight_type == "bias":
												lowercase :							Optional[int]    		=value
						elif weight_type == "running_mean":
												lowercase :							List[str]    		=value
						elif weight_type == "running_var":
												lowercase :							List[str]    		=value
						elif weight_type == "num_batches_tracked":
												lowercase :							int    		=value
						else:
												lowercase :							List[Any]    		=value

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






def 				_lowerCAmelCase			(   __magic_name__						:     int   , __magic_name__						:     Optional[Any]						)				->  Dict:
						for key in ignore_keys:
												if key.endswith('''.*'''						):
																		if name.startswith(key[:-1]						):
																								return True
												elif ".*." in key:
																		lowercase		,	lowercase :							int    		=key.split('''.*.'''						)
																		if prefix in name and suffix in name:
																								return True
												elif key in name:
																		return True
						return False






def 				_lowerCAmelCase			(   __magic_name__						:     Optional[Any]   , __magic_name__						:     List[Any]   , __magic_name__						:     Any						)				->  Optional[Any]:
						lowercase :							str    		=[]

						if task == "s2t":
												lowercase :							List[Any]    		=hf_model.speechta.encoder.prenet.feature_encoder
												lowercase :							Optional[int]    		=MAPPING_S2T
												lowercase :							Optional[Any]    		=IGNORE_KEYS_S2T
						elif task == "t2s":
												lowercase :							Optional[Any]    		=None
												lowercase :							Union[str, Any]    		=MAPPING_T2S
												lowercase :							List[Any]    		=IGNORE_KEYS_T2S
						elif task == "s2s":
												lowercase :							Union[str, Any]    		=hf_model.speechta.encoder.prenet.feature_encoder
												lowercase :							str    		=MAPPING_S2S
												lowercase :							List[str]    		=IGNORE_KEYS_S2S
						else:
												raise ValueError(f'''Unsupported task: {task}'''						)

						for name, value in fairseq_dict.items():
												if should_ignore(__magic_name__   , __magic_name__						):
																		logger.info(f'''{name} was ignored'''						)
																		continue

												lowercase :							str    		=False
												if "conv_layers" in name:
																		load_conv_layer(
																		    __magic_name__   , __magic_name__   , __magic_name__   , __magic_name__   , hf_model.config.feat_extract_norm == '''group'''   , )
																		lowercase :							Optional[Any]    		=True
												else:
																		for key, mapped_key in MAPPING.items():
																								# mapped_key = "speecht5." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key

																								if "*" in key:
																														lowercase		,	lowercase :							Optional[int]    		=key.split('''.*.'''						)
																														if prefix in name and suffix in name:
																																				lowercase :							List[str]    		=suffix

                # if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]:
																								if key in name:
																														lowercase :							Dict    		=True
																														if "*" in mapped_key:
																																				lowercase :							Optional[Any]    		=name.split(__magic_name__						)[0].split('''.'''						)[-2]
																																				lowercase :							str    		=mapped_key.replace('''*'''   , __magic_name__						)
																														if "weight_g" in name:
																																				lowercase :							int    		='''weight_g'''
																														elif "weight_v" in name:
																																				lowercase :							Tuple    		='''weight_v'''
																														elif "bias" in name:
																																				lowercase :							Tuple    		='''bias'''
																														elif "weight" in name:
																																				lowercase :							Dict    		='''weight'''
																														elif "running_mean" in name:
																																				lowercase :							Any    		='''running_mean'''
																														elif "running_var" in name:
																																				lowercase :							List[str]    		='''running_var'''
																														elif "num_batches_tracked" in name:
																																				lowercase :							str    		='''num_batches_tracked'''
																														else:
																																				lowercase :							Optional[int]    		=None
																														set_recursively(__magic_name__   , __magic_name__   , __magic_name__   , __magic_name__   , __magic_name__						)
																								continue
												if not is_used:
																		unused_weights.append(__magic_name__						)

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






def 				_lowerCAmelCase			(   __magic_name__						:     Optional[Any]   , __magic_name__						:     Union[str, Any]   , __magic_name__						:     Union[str, Any]   , __magic_name__						:     List[Any]   , __magic_name__						:     Dict						)				->  Optional[int]:
						lowercase :							Tuple    		=full_name.split('''conv_layers.'''						)[-1]
						lowercase :							Dict    		=name.split('''.'''						)
						lowercase :							Union[str, Any]    		=int(items[0]						)
						lowercase :							int    		=int(items[1]						)

						if type_id == 0:
												if "bias" in name:
																		if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
																								raise ValueError(
																								    f'''{full_name} has size {value.shape}, but'''
																								    f''' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.'''						)
																		lowercase :							Any    		=value
																		logger.info(f'''Feat extract conv layer {layer_id} was initialized from {full_name}.'''						)
												elif "weight" in name:
																		if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
																								raise ValueError(
																								    f'''{full_name} has size {value.shape}, but'''
																								    f''' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.'''						)
																		lowercase :							str    		=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:
																		if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
																								raise ValueError(
																								    f'''{full_name} has size {value.shape}, but'''
																								    f''' {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found.'''						)
																		lowercase :							List[str]    		=value
																		logger.info(f'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'''						)
												elif "weight" in name:
																		if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
																								raise ValueError(
																								    f'''{full_name} has size {value.shape}, but'''
																								    f''' {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found.'''						)
																		lowercase :							Any    		=value
																		logger.info(f'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'''						)
						else:
												unused_weights.append(__magic_name__						)






@torch.no_grad()
def 				_lowerCAmelCase			(   __magic_name__						:     Union[str, Any]   , __magic_name__						:     int   , __magic_name__						:     Any   , __magic_name__						:     Union[str, Any]=None   , __magic_name__						:     List[str]=None   , __magic_name__						:     Optional[Any]=None   , )				->  Optional[int]:
						if config_path is not None:
												lowercase :							int    		=SpeechTaConfig.from_pretrained(__magic_name__						)
						else:
												lowercase :							str    		=SpeechTaConfig()

						if task == "s2t":
												lowercase :							List[str]    		=config.max_text_positions
												lowercase :							Union[str, Any]    		=SpeechTaForSpeechToText(__magic_name__						)
						elif task == "t2s":
												lowercase :							Optional[int]    		=1876
												lowercase :							Any    		=600
												lowercase :							List[str]    		=config.max_speech_positions
												lowercase :							List[str]    		=SpeechTaForTextToSpeech(__magic_name__						)
						elif task == "s2s":
												lowercase :							Tuple    		=1876
												lowercase :							Optional[int]    		=config.max_speech_positions
												lowercase :							List[Any]    		=SpeechTaForSpeechToSpeech(__magic_name__						)
						else:
												raise ValueError(f'''Unknown task name: {task}'''						)

						if vocab_path:
												lowercase :							Any    		=SpeechTaTokenizer(__magic_name__   , model_max_length=config.max_text_positions						)

												# Mask token behaves like a normal word, i.e. include the space before it
												lowercase :							str    		=AddedToken('''<mask>'''   , lstrip=__magic_name__   , rstrip=__magic_name__						)
												lowercase :							Tuple    		=mask_token
												tokenizer.add_special_tokens({'''mask_token''': mask_token}						)
												tokenizer.add_tokens(['''<ctc_blank>''']						)

						lowercase :							Tuple    		=SpeechTaFeatureExtractor()
						lowercase :							Union[str, Any]    		=SpeechTaProcessor(tokenizer=__magic_name__   , feature_extractor=__magic_name__						)
						processor.save_pretrained(__magic_name__						)

						lowercase :							List[str]    		=torch.load(__magic_name__						)
						recursively_load_weights(fairseq_checkpoint['''model''']   , __magic_name__   , __magic_name__						)

						model.save_pretrained(__magic_name__						)

						if repo_id:
												print('''Pushing to the hub...'''						)
												processor.push_to_hub(__magic_name__						)
												model.push_to_hub(__magic_name__						)


if __name__ == "__main__":
							UpperCamelCase_    						=       argparse.ArgumentParser()
							parser.add_argument(
							    """--task""",
							    default="""s2t""",
							    type=str,
							    help="""Type of the SpeechT5 model you'd like to convert. Should be one of 's2t', 't2s', 's2s'.""",
							)
							parser.add_argument("""--checkpoint_path""", required=True, default=None, type=str, help="""Path to fairseq checkpoint""")
							parser.add_argument("""--vocab_path""", default=None, type=str, help="""Path to SentencePiece model""")
							parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""")
							parser.add_argument(
							    """--pytorch_dump_folder_path""", required=True, default=None, type=str, help="""Path to the output PyTorch model."""
							)
							parser.add_argument(
							    """--push_to_hub""", default=None, type=str, help="""Where to upload the converted model on the 🤗 hub."""
							)

							UpperCamelCase_    						=       parser.parse_args()
							convert_speechta_checkpoint(
							    args.task,
							    args.checkpoint_path,
							    args.pytorch_dump_folder_path,
							    args.config_path,
							    args.vocab_path,
							    args.push_to_hub,
							)








'''simple docstring'''





from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
							import tensorflow as tf

							from transformers import (
							    TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
							    TFTransfoXLForSequenceClassification,
							    TFTransfoXLLMHeadModel,
							    TFTransfoXLModel,
							)





class 		__SCREAMING_SNAKE_CASE							:







				def __init__(       self     :		List[str]		,					UpperCAmelCase__     :		Dict		,					):
										'''simple docstring'''
										lowercase :							Any    		=parent
										lowercase :							Optional[int]    		=13
										lowercase :							Union[str, Any]    		=7
										lowercase :							str    		=30
										lowercase :							Optional[int]    		=self.seq_length + self.mem_len
										lowercase :							Dict    		=15
										lowercase :							List[str]    		=True
										lowercase :							Optional[int]    		=True
										lowercase :							Tuple    		=99
										lowercase :							str    		=[10, 50, 80]
										lowercase :							List[Any]    		=32
										lowercase :							Optional[int]    		=32
										lowercase :							int    		=4
										lowercase :							Any    		=8
										lowercase :							List[Any]    		=128
										lowercase :							List[str]    		=2
										lowercase :							Tuple    		=2
										lowercase :							int    		=None
										lowercase :							Optional[int]    		=1
										lowercase :							int    		=0
										lowercase :							List[str]    		=3
										lowercase :							str    		=self.vocab_size - 1
										lowercase :							Tuple    		=0.01







				def  lowerCamelCase_	(       self     :		List[Any]   ):
										'''simple docstring'''
										lowercase :							str    		=ids_tensor([self.batch_size, self.seq_length]		,					self.vocab_size   )
										lowercase :							Tuple    		=ids_tensor([self.batch_size, self.seq_length]		,					self.vocab_size   )

										lowercase :							str    		=None
										if self.use_labels:
																lowercase :							Tuple    		=ids_tensor([self.batch_size, self.seq_length]		,					self.vocab_size   )

										lowercase :							Union[str, Any]    		=TransfoXLConfig(
										    vocab_size=self.vocab_size		,					mem_len=self.mem_len		,					clamp_len=self.clamp_len		,					cutoffs=self.cutoffs		,					d_model=self.hidden_size		,					d_embed=self.d_embed		,					n_head=self.num_attention_heads		,					d_head=self.d_head		,					d_inner=self.d_inner		,					div_val=self.div_val		,					n_layer=self.num_hidden_layers		,					eos_token_id=self.eos_token_id		,					pad_token_id=self.vocab_size - 1		,					init_range=self.init_range		,					num_labels=self.num_labels		,					)

										return (config, input_ids_a, input_ids_a, lm_labels)







				def  lowerCamelCase_	(       self     :		Union[str, Any]   ):
										'''simple docstring'''
										random.seed(self.seed   )
										tf.random.set_seed(self.seed   )







				def  lowerCamelCase_	(       self     :		Union[str, Any]		,					UpperCAmelCase__     :		Optional[Any]		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		List[str]		,					UpperCAmelCase__     :		List[str]   ):
										'''simple docstring'''
										lowercase :							Tuple    		=TFTransfoXLModel(UpperCAmelCase__   )

										lowercase		,	lowercase :							Optional[Any]    		=model(UpperCAmelCase__   ).to_tuple()

										lowercase :							List[str]    		={'''input_ids''': input_ids_a, '''mems''': mems_a}

										lowercase		,	lowercase :							Any    		=model(UpperCAmelCase__   ).to_tuple()

										self.parent.assertEqual(hidden_states_a.shape		,					(self.batch_size, self.seq_length, self.hidden_size)   )
										self.parent.assertEqual(hidden_states_a.shape		,					(self.batch_size, self.seq_length, self.hidden_size)   )
										self.parent.assertListEqual(
										    [mem.shape for mem in mems_a]		,					[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,					)
										self.parent.assertListEqual(
										    [mem.shape for mem in mems_a]		,					[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,					)







				def  lowerCamelCase_	(       self     :		int		,					UpperCAmelCase__     :		List[str]		,					UpperCAmelCase__     :		str		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		int   ):
										'''simple docstring'''
										lowercase :							int    		=TFTransfoXLLMHeadModel(UpperCAmelCase__   )

										lowercase		,	lowercase :							Tuple    		=model(UpperCAmelCase__   ).to_tuple()

										lowercase :							Optional[Any]    		={'''input_ids''': input_ids_a, '''labels''': lm_labels}
										lowercase		,	lowercase :							Optional[int]    		=model(UpperCAmelCase__   ).to_tuple()

										lowercase		,	lowercase :							List[str]    		=model([input_ids_a, mems_a]   ).to_tuple()

										lowercase :							int    		={'''input_ids''': input_ids_a, '''mems''': mems_a, '''labels''': lm_labels}

										lowercase		,	lowercase :							str    		=model(UpperCAmelCase__   ).to_tuple()

										self.parent.assertEqual(lm_logits_a.shape		,					(self.batch_size, self.seq_length, self.vocab_size)   )
										self.parent.assertListEqual(
										    [mem.shape for mem in mems_a]		,					[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,					)

										self.parent.assertEqual(lm_logits_a.shape		,					(self.batch_size, self.seq_length, self.vocab_size)   )
										self.parent.assertListEqual(
										    [mem.shape for mem in mems_a]		,					[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,					)







				def  lowerCamelCase_	(       self     :		str		,					UpperCAmelCase__     :		int		,					UpperCAmelCase__     :		Any		,					UpperCAmelCase__     :		List[str]		,					UpperCAmelCase__     :		Union[str, Any]   ):
										'''simple docstring'''
										lowercase :							Optional[int]    		=TFTransfoXLForSequenceClassification(UpperCAmelCase__   )
										lowercase :							Union[str, Any]    		=model(UpperCAmelCase__   )
										self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.num_labels)   )







				def  lowerCamelCase_	(       self     :		List[str]   ):
										'''simple docstring'''
										lowercase :							List[Any]    		=self.prepare_config_and_inputs()
										((lowercase)		,	(lowercase)		,	(lowercase)		,	(lowercase)) :							Optional[Any]    		=config_and_inputs
										lowercase :							Union[str, Any]    		={'''input_ids''': input_ids_a}
										return config, inputs_dict





@require_tf
class 		__SCREAMING_SNAKE_CASE							(			lowercase__						,							lowercase__						,							unittest.TestCase      ):
				lowerCamelCase_		       =    (
				    (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
				)
				lowerCamelCase_		       =    () if is_tf_available() else ()
				lowerCamelCase_		       =    (
				    {
				        'feature-extraction': TFTransfoXLModel,
				        'text-classification': TFTransfoXLForSequenceClassification,
				        'text-generation': TFTransfoXLLMHeadModel,
				        'zero-shot': TFTransfoXLForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				# TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
				lowerCamelCase_		       =    False
				lowerCamelCase_		       =    False
				lowerCamelCase_		       =    False
				lowerCamelCase_		       =    False







				def  lowerCamelCase_	(       self     :		Dict		,					UpperCAmelCase__     :		List[Any]		,					UpperCAmelCase__     :		Optional[int]		,					UpperCAmelCase__     :		int		,					UpperCAmelCase__     :		Optional[int]		,					UpperCAmelCase__     :		int   ):
										'''simple docstring'''
										if pipeline_test_casse_name == "TextGenerationPipelineTests":
																# Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
																# `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
																# tokenizer.
																return True

										return False







				def  lowerCamelCase_	(       self     :		int   ):
										'''simple docstring'''
										lowercase :							Any    		=TFTransfoXLModelTester(self   )
										lowercase :							Optional[int]    		=ConfigTester(self		,					config_class=UpperCAmelCase__		,					d_embed=37   )







				def  lowerCamelCase_	(       self     :		Any   ):
										'''simple docstring'''
										self.config_tester.run_common_tests()







				def  lowerCamelCase_	(       self     :		Optional[int]   ):
										'''simple docstring'''
										self.model_tester.set_seed()
										lowercase :							List[str]    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_transfo_xl_model(*UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		List[str]   ):
										'''simple docstring'''
										self.model_tester.set_seed()
										lowercase :							Any    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_transfo_xl_lm_head(*UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		List[Any]   ):
										'''simple docstring'''
										lowercase :							Dict    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		Optional[Any]   ):
										'''simple docstring'''
										lowercase		,	lowercase :							Tuple    		=self.model_tester.prepare_config_and_inputs_for_common()
										lowercase :							int    		=[TFTransfoXLForSequenceClassification]

										for model_class in self.all_model_classes:
																lowercase :							str    		=model_class(UpperCAmelCase__   )
																assert isinstance(model.get_input_embeddings()		,					tf.keras.layers.Layer   )
																if model_class in list_other_models_with_output_ebd:
																						lowercase :							Union[str, Any]    		=model.get_output_embeddings()
																						assert isinstance(UpperCAmelCase__		,					tf.keras.layers.Layer   )
																						lowercase :							Any    		=model.get_bias()
																						assert name is None
																else:
																						lowercase :							Optional[int]    		=model.get_output_embeddings()
																						assert x is None
																						lowercase :							Optional[int]    		=model.get_bias()
																						assert name is None







				def  lowerCamelCase_	(       self     :		Any   ):
										'''simple docstring'''
										# TODO JP: Make TransfoXL XLA compliant
										pass







				@slow
				def  lowerCamelCase_	(       self     :		Union[str, Any]   ):
										'''simple docstring'''
										for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																lowercase :							int    		=TFTransfoXLModel.from_pretrained(UpperCAmelCase__   )
																self.assertIsNotNone(UpperCAmelCase__   )







				@unittest.skip(reason='''This model doesn\'t play well with fit() due to not returning a single loss.'''   )
				def  lowerCamelCase_	(       self     :		int   ):
										'''simple docstring'''
										pass





@require_tf
class 		__SCREAMING_SNAKE_CASE							(			unittest.TestCase      ):







				@unittest.skip('''Skip test until #12651 is resolved.'''   )
				@slow
				def  lowerCamelCase_	(       self     :		Tuple   ):
										'''simple docstring'''
										lowercase :							Optional[Any]    		=TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103'''   )
										# fmt: off
										lowercase :							Tuple    		=tf.convert_to_tensor([[33,1297,2,1,1009,4,1109,11739,4762,358,5,25,245,22,1706,17,20098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,71477,20098,104447,2,20961,1,2604,4,1,329,3,6224,831,16002,2,8,603,78967,29546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,29546,54,8,3609,5,57211,49,4,1,277,18,8,1755,15691,3,341,25,416,693,42573,71,17,401,94,31,17919,2,29546,7873,18,1,435,23,11011,755,5,5167,3,7983,98,84,2,29546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,29546,824,1400,1868,2,19,160,2,311,8,5496,2,20920,17,25,15097,3,24,24,0]]		,					dtype=tf.intaa   )  # noqa: E231
										# fmt: on
										#  In 1991 , the remains of Russian Tsar Nicholas II and his family
										#  ( except for Alexei and Maria ) are discovered .
										#  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
										#  remainder of the story . 1883 Western Siberia ,
										#  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
										#  Rasputin has a vision and denounces one of the men as a horse thief . Although his
										#  father initially slaps him for making such an accusation , Rasputin watches as the
										#  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
										#  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
										#  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

										# fmt: off
										lowercase :							Optional[int]    		=[33,1297,2,1,1009,4,1109,11739,4762,358,5,25,245,22,1706,17,20098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,71477,20098,104447,2,20961,1,2604,4,1,329,3,6224,831,16002,2,8,603,78967,29546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,29546,54,8,3609,5,57211,49,4,1,277,18,8,1755,15691,3,341,25,416,693,42573,71,17,401,94,31,17919,2,29546,7873,18,1,435,23,11011,755,5,5167,3,7983,98,84,2,29546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,29546,824,1400,1868,2,19,160,2,311,8,5496,2,20920,17,25,15097,3,24,24,0,33,1,1857,2,1,1009,4,1109,11739,4762,358,5,25,245,28,1110,3,13,1041,4,24,603,490,2,71477,20098,104447,2,20961,1,2604,4,1,329,3,0]  # noqa: E231
										# fmt: on
										#  In 1991, the remains of Russian Tsar Nicholas II and his family (
										#  except for Alexei and Maria ) are discovered. The voice of young son,
										#  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
										#  1883 Western Siberia, a young Grigori Rasputin is asked by his father
										#  and a group of men to perform magic. Rasputin has a vision and
										#  denounces one of the men as a horse thief. Although his father initially
										#  slaps him for making such an accusation, Rasputin watches as the man
										#  is chased outside and beaten. Twenty years later, Rasputin sees a vision
										#  of the Virgin Mary, prompting him to become a priest.
										#  Rasputin quickly becomes famous, with people, even a bishop, begging for
										#  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
										# Nicholas II and his family were discovered. The voice of <unk> young son,
										# Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

										lowercase :							int    		=model.generate(UpperCAmelCase__		,					max_length=200		,					do_sample=UpperCAmelCase__   )
										self.assertListEqual(output_ids[0].numpy().tolist()		,					UpperCAmelCase__   )





