


import argparse

import torch

from transformers import (
    EncodecConfig,
    EncodecFeatureExtractor,
    EncodecModel,
    logging,
)


# checkpoints downloaded from:
# https://dl.fbaipublicfiles.com/encodec/v0/encodec_24khz-d7cc33bc.th
# https://huggingface.co/facebook/musicgen-small/resolve/main/compression_state_dict.bin
# https://dl.fbaipublicfiles.com/encodec/v0/encodec_48khz-7e698e3e.th


logging.set_verbosity_info()
lowerCAmelCase__    :List[Any]       =				logging.get_logger('''transformers.models.encodec''')

lowerCAmelCase__    :Union[str, Any]       =				{
    """quantizer.vq.layers.*._codebook.inited""": """quantizer.layers.*.codebook.inited""",
    """quantizer.vq.layers.*._codebook.cluster_size""": """quantizer.layers.*.codebook.cluster_size""",
    """quantizer.vq.layers.*._codebook.embed""": """quantizer.layers.*.codebook.embed""",
    """quantizer.vq.layers.*._codebook.embed_avg""": """quantizer.layers.*.codebook.embed_avg""",
}
lowerCAmelCase__    :Union[str, Any]       =				{
    """encoder.model.0.conv.conv""": """encoder.layers.0.conv""",
    """encoder.model.1.block.1.conv.conv""": """encoder.layers.1.block.1.conv""",
    """encoder.model.1.block.3.conv.conv""": """encoder.layers.1.block.3.conv""",
    """encoder.model.1.shortcut.conv.conv""": """encoder.layers.1.shortcut.conv""",
    """encoder.model.3.conv.conv""": """encoder.layers.3.conv""",
    """encoder.model.4.block.1.conv.conv""": """encoder.layers.4.block.1.conv""",
    """encoder.model.4.block.3.conv.conv""": """encoder.layers.4.block.3.conv""",
    """encoder.model.4.shortcut.conv.conv""": """encoder.layers.4.shortcut.conv""",
    """encoder.model.6.conv.conv""": """encoder.layers.6.conv""",
    """encoder.model.7.block.1.conv.conv""": """encoder.layers.7.block.1.conv""",
    """encoder.model.7.block.3.conv.conv""": """encoder.layers.7.block.3.conv""",
    """encoder.model.7.shortcut.conv.conv""": """encoder.layers.7.shortcut.conv""",
    """encoder.model.9.conv.conv""": """encoder.layers.9.conv""",
    """encoder.model.10.block.1.conv.conv""": """encoder.layers.10.block.1.conv""",
    """encoder.model.10.block.3.conv.conv""": """encoder.layers.10.block.3.conv""",
    """encoder.model.10.shortcut.conv.conv""": """encoder.layers.10.shortcut.conv""",
    """encoder.model.12.conv.conv""": """encoder.layers.12.conv""",
    """encoder.model.13.lstm""": """encoder.layers.13.lstm""",
    """encoder.model.15.conv.conv""": """encoder.layers.15.conv""",
}
lowerCAmelCase__    :Optional[int]       =				{
    """encoder.model.0.conv.norm""": """encoder.layers.0.norm""",
    """encoder.model.1.block.1.conv.norm""": """encoder.layers.1.block.1.norm""",
    """encoder.model.1.block.3.conv.norm""": """encoder.layers.1.block.3.norm""",
    """encoder.model.1.shortcut.conv.norm""": """encoder.layers.1.shortcut.norm""",
    """encoder.model.3.conv.norm""": """encoder.layers.3.norm""",
    """encoder.model.4.block.1.conv.norm""": """encoder.layers.4.block.1.norm""",
    """encoder.model.4.block.3.conv.norm""": """encoder.layers.4.block.3.norm""",
    """encoder.model.4.shortcut.conv.norm""": """encoder.layers.4.shortcut.norm""",
    """encoder.model.6.conv.norm""": """encoder.layers.6.norm""",
    """encoder.model.7.block.1.conv.norm""": """encoder.layers.7.block.1.norm""",
    """encoder.model.7.block.3.conv.norm""": """encoder.layers.7.block.3.norm""",
    """encoder.model.7.shortcut.conv.norm""": """encoder.layers.7.shortcut.norm""",
    """encoder.model.9.conv.norm""": """encoder.layers.9.norm""",
    """encoder.model.10.block.1.conv.norm""": """encoder.layers.10.block.1.norm""",
    """encoder.model.10.block.3.conv.norm""": """encoder.layers.10.block.3.norm""",
    """encoder.model.10.shortcut.conv.norm""": """encoder.layers.10.shortcut.norm""",
    """encoder.model.12.conv.norm""": """encoder.layers.12.norm""",
    """encoder.model.15.conv.norm""": """encoder.layers.15.norm""",
}
lowerCAmelCase__    :Union[str, Any]       =				{
    """decoder.model.0.conv.conv""": """decoder.layers.0.conv""",
    """decoder.model.1.lstm""": """decoder.layers.1.lstm""",
    """decoder.model.3.convtr.convtr""": """decoder.layers.3.conv""",
    """decoder.model.4.block.1.conv.conv""": """decoder.layers.4.block.1.conv""",
    """decoder.model.4.block.3.conv.conv""": """decoder.layers.4.block.3.conv""",
    """decoder.model.4.shortcut.conv.conv""": """decoder.layers.4.shortcut.conv""",
    """decoder.model.6.convtr.convtr""": """decoder.layers.6.conv""",
    """decoder.model.7.block.1.conv.conv""": """decoder.layers.7.block.1.conv""",
    """decoder.model.7.block.3.conv.conv""": """decoder.layers.7.block.3.conv""",
    """decoder.model.7.shortcut.conv.conv""": """decoder.layers.7.shortcut.conv""",
    """decoder.model.9.convtr.convtr""": """decoder.layers.9.conv""",
    """decoder.model.10.block.1.conv.conv""": """decoder.layers.10.block.1.conv""",
    """decoder.model.10.block.3.conv.conv""": """decoder.layers.10.block.3.conv""",
    """decoder.model.10.shortcut.conv.conv""": """decoder.layers.10.shortcut.conv""",
    """decoder.model.12.convtr.convtr""": """decoder.layers.12.conv""",
    """decoder.model.13.block.1.conv.conv""": """decoder.layers.13.block.1.conv""",
    """decoder.model.13.block.3.conv.conv""": """decoder.layers.13.block.3.conv""",
    """decoder.model.13.shortcut.conv.conv""": """decoder.layers.13.shortcut.conv""",
    """decoder.model.15.conv.conv""": """decoder.layers.15.conv""",
}
lowerCAmelCase__    :Dict       =				{
    """decoder.model.0.conv.norm""": """decoder.layers.0.norm""",
    """decoder.model.3.convtr.norm""": """decoder.layers.3.norm""",
    """decoder.model.4.block.1.conv.norm""": """decoder.layers.4.block.1.norm""",
    """decoder.model.4.block.3.conv.norm""": """decoder.layers.4.block.3.norm""",
    """decoder.model.4.shortcut.conv.norm""": """decoder.layers.4.shortcut.norm""",
    """decoder.model.6.convtr.norm""": """decoder.layers.6.norm""",
    """decoder.model.7.block.1.conv.norm""": """decoder.layers.7.block.1.norm""",
    """decoder.model.7.block.3.conv.norm""": """decoder.layers.7.block.3.norm""",
    """decoder.model.7.shortcut.conv.norm""": """decoder.layers.7.shortcut.norm""",
    """decoder.model.9.convtr.norm""": """decoder.layers.9.norm""",
    """decoder.model.10.block.1.conv.norm""": """decoder.layers.10.block.1.norm""",
    """decoder.model.10.block.3.conv.norm""": """decoder.layers.10.block.3.norm""",
    """decoder.model.10.shortcut.conv.norm""": """decoder.layers.10.shortcut.norm""",
    """decoder.model.12.convtr.norm""": """decoder.layers.12.norm""",
    """decoder.model.13.block.1.conv.norm""": """decoder.layers.13.block.1.norm""",
    """decoder.model.13.block.3.conv.norm""": """decoder.layers.13.block.3.norm""",
    """decoder.model.13.shortcut.conv.norm""": """decoder.layers.13.shortcut.norm""",
    """decoder.model.15.conv.norm""": """decoder.layers.15.norm""",
}
lowerCAmelCase__    :Union[str, Any]       =				{
    **MAPPING_QUANTIZER,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
}
lowerCAmelCase__    :Optional[Any]       =				{
    **MAPPING_QUANTIZER,
    **MAPPING_ENCODER,
    **MAPPING_ENCODER_48K,
    **MAPPING_DECODER,
    **MAPPING_DECODER_48K,
}
lowerCAmelCase__    :List[Any]       =				[]
lowerCAmelCase__    :List[str]       =				[]

def 			lowerCAmelCase__					(     a__:						str     ,    a__:						str     ,    a__:						Optional[int]     ,    a__:						Any     ,    a__:						Optional[Any]			)    ->						str:


							'''simple docstring'''





							for attribute in key.split('.'			):
														_UpperCAmelCase											=     getattr(a__     ,    a__			)

							if weight_type is not None:
														_UpperCAmelCase											=     getattr(a__     ,    a__			).shape
							else:
														_UpperCAmelCase											=     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":
														_UpperCAmelCase											=     value
							elif weight_type == "weight_g":
														_UpperCAmelCase											=     value
							elif weight_type == "weight_v":
														_UpperCAmelCase											=     value
							elif weight_type == "bias":
														_UpperCAmelCase											=     value
							elif weight_type == "running_mean":
														_UpperCAmelCase											=     value
							elif weight_type == "running_var":
														_UpperCAmelCase											=     value
							elif weight_type == "num_batches_tracked":
														_UpperCAmelCase											=     value
							elif weight_type == "weight_ih_l0":
														_UpperCAmelCase											=     value
							elif weight_type == "weight_hh_l0":
														_UpperCAmelCase											=     value
							elif weight_type == "bias_ih_l0":
														_UpperCAmelCase											=     value
							elif weight_type == "bias_hh_l0":
														_UpperCAmelCase											=     value
							elif weight_type == "weight_ih_l1":
														_UpperCAmelCase											=     value
							elif weight_type == "weight_hh_l1":
														_UpperCAmelCase											=     value
							elif weight_type == "bias_ih_l1":
														_UpperCAmelCase											=     value
							elif weight_type == "bias_hh_l1":
														_UpperCAmelCase											=     value
							else:
														_UpperCAmelCase											=     value

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

def 			lowerCAmelCase__					(     a__:						Tuple     ,    a__:						Optional[Any]			)    ->						Dict:


							'''simple docstring'''





							for key in ignore_keys:
														if key.endswith('.*'			):
																					if name.startswith(key[:-1]			):
																												return True
														elif ".*." in key:
																					_UpperCAmelCase											=     key.split('.*.'			)
																					if prefix in name and suffix in name:
																												return True
														elif key in name:
																					return True
							return False

def 			lowerCAmelCase__					(     a__:						Optional[int]     ,    a__:						Tuple     ,    a__:						Union[str, Any]			)    ->						Optional[int]:


							'''simple docstring'''





							_UpperCAmelCase											=     []

							if model_name == "encodec_24khz" or "encodec_32khz":
														_UpperCAmelCase											=     MAPPING_24K
							elif model_name == "encodec_48khz":
														_UpperCAmelCase											=     MAPPING_48K
							else:
														raise ValueError(F'''Unsupported model: {model_name}'''			)

							for name, value in orig_dict.items():
														if should_ignore(a__     ,    a__			):
																					logger.info(F'''{name} was ignored'''			)
																					continue

														_UpperCAmelCase											=     False
														for key, mapped_key in MAPPING.items():
																					if "*" in key:
																												_UpperCAmelCase											=     key.split('.*.'			)
																												if prefix in name and suffix in name:
																																			_UpperCAmelCase											=     suffix

																					if key in name:
																												# HACK otherwise .embed gets initialized with .embed_avg too
																												if key.endswith('embed'			) and name.endswith('embed_avg'			):
																																			continue

																												_UpperCAmelCase											=     True
																												if "*" in mapped_key:
																																			_UpperCAmelCase											=     name.split(a__			)[0].split('.'			)[-2]
																																			_UpperCAmelCase											=     mapped_key.replace('*'     ,    a__			)
																												if "weight_g" in name:
																																			_UpperCAmelCase											=     """weight_g"""
																												elif "weight_v" in name:
																																			_UpperCAmelCase											=     """weight_v"""
																												elif "weight_ih_l0" in name:
																																			_UpperCAmelCase											=     """weight_ih_l0"""
																												elif "weight_hh_l0" in name:
																																			_UpperCAmelCase											=     """weight_hh_l0"""
																												elif "bias_ih_l0" in name:
																																			_UpperCAmelCase											=     """bias_ih_l0"""
																												elif "bias_hh_l0" in name:
																																			_UpperCAmelCase											=     """bias_hh_l0"""
																												elif "weight_ih_l1" in name:
																																			_UpperCAmelCase											=     """weight_ih_l1"""
																												elif "weight_hh_l1" in name:
																																			_UpperCAmelCase											=     """weight_hh_l1"""
																												elif "bias_ih_l1" in name:
																																			_UpperCAmelCase											=     """bias_ih_l1"""
																												elif "bias_hh_l1" in name:
																																			_UpperCAmelCase											=     """bias_hh_l1"""
																												elif "bias" in name:
																																			_UpperCAmelCase											=     """bias"""
																												elif "weight" in name:
																																			_UpperCAmelCase											=     """weight"""
																												elif "running_mean" in name:
																																			_UpperCAmelCase											=     """running_mean"""
																												elif "running_var" in name:
																																			_UpperCAmelCase											=     """running_var"""
																												elif "num_batches_tracked" in name:
																																			_UpperCAmelCase											=     """num_batches_tracked"""
																												else:
																																			_UpperCAmelCase											=     None
																												set_recursively(a__     ,    a__     ,    a__     ,    a__     ,    a__			)
																					continue
														if not is_used:
																					unused_weights.append(a__			)

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

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


							'''simple docstring'''





							if config_path is not None:
														_UpperCAmelCase											=     EncodecConfig.from_pretrained(a__			)
							else:
														_UpperCAmelCase											=     EncodecConfig()

							if model_name == "encodec_24khz":
														pass  # config is already correct
							elif model_name == "encodec_32khz":
														_UpperCAmelCase											=     [8, 5, 4, 4]
														_UpperCAmelCase											=     [2.2]
														_UpperCAmelCase											=     6_4
														_UpperCAmelCase											=     3_2_0_0_0
														_UpperCAmelCase											=     2_0_4_8
														_UpperCAmelCase											=     False
														_UpperCAmelCase											=     False
														_UpperCAmelCase											=     False
							elif model_name == "encodec_48khz":
														_UpperCAmelCase											=     [8, 5, 4, 2]
														_UpperCAmelCase											=     [3.0, 6.0, 12.0, 24.0]
														_UpperCAmelCase											=     4_8_0_0_0
														_UpperCAmelCase											=     2
														_UpperCAmelCase											=     False
														_UpperCAmelCase											=     """time_group_norm"""
														_UpperCAmelCase											=     True
														_UpperCAmelCase											=     1.0
														_UpperCAmelCase											=     0.01
							else:
														raise ValueError(F'''Unknown model name: {model_name}'''			)

							_UpperCAmelCase											=     EncodecModel(a__			)

							_UpperCAmelCase											=     EncodecFeatureExtractor(
							    feature_size=config.audio_channels     ,    sampling_rate=config.sampling_rate     ,    chunk_length_s=config.chunk_length_s     ,    overlap=config.overlap     ,    )
							feature_extractor.save_pretrained(a__			)

							_UpperCAmelCase											=     torch.load(a__			)
							if "best_state" in original_checkpoint:
														# we might have a training state saved, in which case discard the yaml results and just retain the weights
														_UpperCAmelCase											=     original_checkpoint["""best_state"""]
							recursively_load_weights(a__     ,    a__     ,    a__			)
							model.save_pretrained(a__			)

							if repo_id:
														print('Pushing to the hub...'			)
														feature_extractor.push_to_hub(a__			)
														model.push_to_hub(a__			)


if __name__ == "__main__":
		lowerCAmelCase__    :Optional[Any]       =				argparse.ArgumentParser()
		parser.add_argument(
		    '''--model''',
		    default='''encodec_24khz''',
		    type=str,
		    help='''The model to convert. Should be one of \'encodec_24khz\', \'encodec_32khz\', \'encodec_48khz\'.''',
		)
		parser.add_argument('''--checkpoint_path''', required=True, default=None, type=str, help='''Path to original checkpoint''')
		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.'''
		)

		lowerCAmelCase__    :Any       =				parser.parse_args()
		convert_checkpoint(
		    args.model,
		    args.checkpoint_path,
		    args.pytorch_dump_folder_path,
		    args.config_path,
		    args.push_to_hub,
		)



import unittest

from transformers import TrOCRConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers.models.trocr.modeling_trocr import TrOCRDecoder, TrOCRForCausalLM



@require_torch
class        A__:
						"""simple docstring"""






						def __init__(    self  ,      _lowercase  ,      _lowercase=99  ,      _lowercase=13  ,      _lowercase=16  ,      _lowercase=7  ,      _lowercase=True  ,      _lowercase=True  ,      _lowercase=True  ,      _lowercase=False  ,      _lowercase=True  ,      _lowercase=2  ,      _lowercase=32  ,      _lowercase=4  ,      _lowercase=4  ,      _lowercase=30  ,      _lowercase=0  ,      _lowercase=1  ,      _lowercase=2  ,      _lowercase=None  ,      )     -> List[str]:
									a_						:						Union[str, Any] 							= parent
									a_						:						Dict 							= batch_size
									a_						:						Any 							= decoder_seq_length
									# For common tests
									a_						:						Any 							= self.decoder_seq_length
									a_						:						int 							= is_training
									a_						:						List[Any] 							= use_attention_mask
									a_						:						List[str] 							= use_labels

									a_						:						Optional[Any] 							= vocab_size
									a_						:						Dict 							= d_model
									a_						:						Any 							= d_model
									a_						:						List[Any] 							= decoder_layers
									a_						:						List[str] 							= decoder_layers
									a_						:						Union[str, Any] 							= decoder_ffn_dim
									a_						:						Optional[Any] 							= decoder_attention_heads
									a_						:						Optional[Any] 							= decoder_attention_heads
									a_						:						Tuple 							= eos_token_id
									a_						:						Union[str, Any] 							= bos_token_id
									a_						:						Dict 							= pad_token_id
									a_						:						Union[str, Any] 							= decoder_start_token_id
									a_						:						List[Any] 							= use_cache
									a_						:						List[str] 							= max_position_embeddings

									a_						:						int 							= None
									a_						:						Any 							= decoder_seq_length
									a_						:						Union[str, Any] 							= 2
									a_						:						Optional[int] 							= 1





						def 			UpperCamelCase__					(    self    )     -> int:
									a_						:						Optional[int] 							= ids_tensor([self.batch_size, self.decoder_seq_length]  ,      self.vocab_size    )

									a_						:						Optional[int] 							= None
									if self.use_attention_mask:
												a_						:						List[Any] 							= ids_tensor([self.batch_size, self.decoder_seq_length]  ,      vocab_size=2    )

									a_						:						List[Any] 							= None
									if self.use_labels:
												a_						:						Union[str, Any] 							= ids_tensor([self.batch_size, self.decoder_seq_length]  ,      self.vocab_size    )

									a_						:						Any 							= TrOCRConfig(
									    vocab_size=self.vocab_size  ,      d_model=self.d_model  ,      decoder_layers=self.decoder_layers  ,      decoder_ffn_dim=self.decoder_ffn_dim  ,      decoder_attention_heads=self.decoder_attention_heads  ,      eos_token_id=self.eos_token_id  ,      bos_token_id=self.bos_token_id  ,      use_cache=self.use_cache  ,      pad_token_id=self.pad_token_id  ,      decoder_start_token_id=self.decoder_start_token_id  ,      max_position_embeddings=self.max_position_embeddings  ,      )

									return (config, input_ids, attention_mask, lm_labels)





						def 			UpperCamelCase__					(    self  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      )     -> List[Any]:
									a_						:						Optional[int] 							= True
									a_						:						List[str] 							= TrOCRDecoder(config=_lowercase    ).to(_lowercase    ).eval()
									a_						:						str 							= input_ids[:2]

									input_ids[input_ids == 0] += 1
									# first forward pass
									a_						:						Dict 							= model(_lowercase  ,      use_cache=_lowercase    )
									a_						:						Union[str, Any] 							= model(_lowercase    )
									a_						:						Union[str, Any] 							= model(_lowercase  ,      use_cache=_lowercase    )

									self.parent.assertTrue(len(_lowercase    ) == len(_lowercase    )    )
									self.parent.assertTrue(len(_lowercase    ) == len(_lowercase    ) + 1    )

									a_						:						Dict 							= outputs["""past_key_values"""]

									# create hypothetical next token and extent to next_input_ids
									a_						:						List[str] 							= ids_tensor((2, 1)  ,      config.vocab_size - 1    ) + 1

									# append to next input_ids and
									a_						:						int 							= torch.cat([input_ids, next_tokens]  ,      dim=-1    )

									a_						:						Dict 							= model(_lowercase    )["""last_hidden_state"""]
									a_						:						List[str] 							= model(_lowercase  ,      past_key_values=_lowercase    )["""last_hidden_state"""]

									# select random slice
									a_						:						Optional[Any] 							= ids_tensor((1,)  ,      output_from_past.shape[-1]    ).item()
									a_						:						Union[str, Any] 							= output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
									a_						:						Any 							= output_from_past[:, 0, random_slice_idx].detach()

									# test that outputs are equal for slice
									assert torch.allclose(_lowercase  ,      _lowercase  ,      atol=1e-3    )





						def 			UpperCamelCase__					(    self    )     -> Optional[Any]:
									a_						:						List[Any] 							= self.prepare_config_and_inputs()
									a_							,					a_							,					a_							,					a_						:						List[Any] 							= config_and_inputs

									a_						:						str 							= {"""input_ids""": input_ids, """attention_mask""": attention_mask}
									return config, inputs_dict







@require_torch
class        A__(a_,  a_,  a_,  unittest.TestCase							):
						"""simple docstring"""






						_A    :				Optional[Any]       					=			(TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
						_A    :				Optional[int]       					=			(TrOCRForCausalLM,) if is_torch_available() else ()
						_A    :				Tuple       					=			{'''text-generation''': TrOCRForCausalLM} if is_torch_available() else {}
						_A    :				List[str]       					=			True
						_A    :				List[str]       					=			False





						def 			UpperCamelCase__					(    self    )     -> List[Any]:
									a_						:						str 							= TrOCRStandaloneDecoderModelTester(self  ,      is_training=_lowercase    )
									a_						:						str 							= ConfigTester(self  ,      config_class=_lowercase    )





						def 			UpperCamelCase__					(    self    )     -> Tuple:
									pass





						def 			UpperCamelCase__					(    self    )     -> int:
									pass





						def 			UpperCamelCase__					(    self    )     -> str:
									pass





						def 			UpperCamelCase__					(    self    )     -> Dict:
									self.config_tester.run_common_tests()





						def 			UpperCamelCase__					(    self    )     -> List[str]:
									a_						:						int 							= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_decoder_model_past(*_lowercase    )





						def 			UpperCamelCase__					(    self    )     -> Tuple:
									return





						@unittest.skip("""The model doesn't support left padding"""    )  # and it's not used enough to be worth fixing :)
						def 			UpperCamelCase__					(    self    )     -> Optional[Any]:
									pass


