






"""simple docstring"""





import argparse

import fairseq
import torch
from torch import nn

from transformers import (
    MBartaaTokenizer,
    MBartConfig,
    MBartForCausalLM,
    SpeechEncoderDecoderConfig,
    SpeechEncoderDecoderModel,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaModel,
    logging,
)


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

__lowerCamelCase							=  {
    'post_extract_proj': 'feature_projection.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.layer_norm': 'encoder.layer_norm',
    'w2v_model.layer_norm': 'feature_projection.layer_norm',
    'quantizer.weight_proj': 'quantizer.weight_proj',
    'quantizer.vars': 'quantizer.codevectors',
    'project_q': 'project_q',
    'final_proj': 'project_hid',
    'w2v_encoder.proj': 'lm_head',
    'mask_emb': 'masked_spec_embed',
}
__lowerCamelCase							=  [
    'lm_head',
    'quantizer.weight_proj',
    'quantizer.codevectors',
    'project_q',
    'project_hid',
]



def   a    (     __UpperCAmelCase      :    List[str]      ,   __UpperCAmelCase      :    Union[str, Any]      ,   __UpperCAmelCase      :    Optional[int]      ,   __UpperCAmelCase      :    Dict      ,   __UpperCAmelCase      :    Union[str, Any]  )    ->							Tuple:
						for attribute in key.split("""."""  ):
												__magic_name__:	Tuple							=       getattr(__UpperCAmelCase      ,   __UpperCAmelCase  )

						if weight_type is not None:
												__magic_name__:	Dict							=       getattr(__UpperCAmelCase      ,   __UpperCAmelCase  ).shape
						else:
												__magic_name__:	Tuple							=       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":
												__magic_name__:	Union[str, Any]							=       value
						elif weight_type == "weight_g":
												__magic_name__:	str							=       value
						elif weight_type == "weight_v":
												__magic_name__:	Optional[Any]							=       value
						elif weight_type == "bias":
												__magic_name__:	Tuple							=       value
						else:
												__magic_name__:	Union[str, Any]							=       value

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



def   a    (     __UpperCAmelCase      :    int      ,   __UpperCAmelCase      :    Optional[Any]  )    ->							Union[str, Any]:
						__magic_name__:	Union[str, Any]							=       []
						__magic_name__:	Tuple							=       fairseq_model.state_dict()

						__magic_name__:	List[str]							=       hf_model.feature_extractor
						__magic_name__:	str							=       hf_model.adapter

						for name, value in fairseq_dict.items():
												__magic_name__:	str							=       False
												if "conv_layers" in name:
																		load_conv_layer(
																		    __UpperCAmelCase      ,   __UpperCAmelCase      ,   __UpperCAmelCase      ,   __UpperCAmelCase      ,   hf_model.config.feat_extract_norm == """group"""      ,   )
																		__magic_name__:	List[Any]							=       True
												elif any(x in name for x in ["""adaptor""", """w2v_encoder.proj.""", """w2v_proj_ln."""]  ):
																		load_adapter(__UpperCAmelCase      ,   __UpperCAmelCase      ,   __UpperCAmelCase      ,   __UpperCAmelCase  )
																		__magic_name__:	Union[str, Any]							=       True
												else:
																		for key, mapped_key in MAPPING.items():
																								if key in name or key.split("""w2v_model."""  )[-1] == name.split("""."""  )[0]:
																														__magic_name__:	str							=       True
																														if "*" in mapped_key:
																																				__magic_name__:	Dict							=       name.split(__UpperCAmelCase  )[0].split("""."""  )[-2]
																																				__magic_name__:	Optional[int]							=       mapped_key.replace("""*"""      ,   __UpperCAmelCase  )
																														if "weight_g" in name:
																																				__magic_name__:	Optional[Any]							=       """weight_g"""
																														elif "weight_v" in name:
																																				__magic_name__:	Dict							=       """weight_v"""
																														elif "bias" in name:
																																				__magic_name__:	List[Any]							=       """bias"""
																														elif "weight" in name:
																																				__magic_name__:	int							=       """weight"""
																														else:
																																				__magic_name__:	Optional[Any]							=       None
																														set_recursively(__UpperCAmelCase      ,   __UpperCAmelCase      ,   __UpperCAmelCase      ,   __UpperCAmelCase      ,   __UpperCAmelCase  )
																								continue
												if not is_used:
																		unused_weights.append(__UpperCAmelCase  )

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



def   a    (     __UpperCAmelCase      :    List[str]      ,   __UpperCAmelCase      :    List[str]      ,   __UpperCAmelCase      :    Any      ,   __UpperCAmelCase      :    Dict      ,   __UpperCAmelCase      :    List[str]  )    ->							Union[str, Any]:
						__magic_name__:	List[Any]							=       full_name.split("""conv_layers."""  )[-1]
						__magic_name__:	str							=       name.split("""."""  )
						__magic_name__:	List[Any]							=       int(items[0]  )
						__magic_name__:	int							=       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.'
																		)
																		__magic_name__:	Dict							=       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.'
																		)
																		__magic_name__:	Any							=       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."
																		)
																		__magic_name__:	int							=       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.'
																		)
																		__magic_name__:	Tuple							=       value
																		logger.info(f'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'  )
						else:
												unused_weights.append(__UpperCAmelCase  )



def   a    (     __UpperCAmelCase      :    Optional[Any]      ,   __UpperCAmelCase      :    List[Any]      ,   __UpperCAmelCase      :    List[str]      ,   __UpperCAmelCase      :    Optional[Any]  )    ->							str:
						__magic_name__:	Dict							=       full_name.split("""adaptor."""  )[-1]
						__magic_name__:	Dict							=       name.split("""."""  )

						if items[1].isdigit():
												__magic_name__:	Optional[int]							=       int(items[1]  )
						else:
												__magic_name__:	Any							=       None

						if "adaptor" not in full_name:
												if "proj_ln" in full_name:
																		# has to be layer norm
																		if "bias" in name:
																								assert (
																								    value.shape == adapter.proj_layer_norm.bias.data.shape
																								), f'{full_name} has size {value.shape}, but {adapter.proj_layer_norm.bias.data.shape} was found.'
																								__magic_name__:	str							=       value
																								logger.info(f'Adapter proj layer norm bias was initialized from {full_name}.'  )
																		if "weight" in name:
																								assert (
																								    value.shape == adapter.proj_layer_norm.weight.data.shape
																								), f'{full_name} has size {value.shape}, but {adapter.proj_layer_norm.weight.data.shape} was found.'
																								__magic_name__:	Tuple							=       value
												else:
																		# has to be projection layer
																		if "bias" in name:
																								assert (
																								    value.shape == adapter.proj.bias.data.shape
																								), f'{full_name} has size {value.shape}, but {adapter.proj.bias.data.shape} was found.'
																								__magic_name__:	Dict							=       value
																								logger.info(f'Adapter proj layer bias was initialized from {full_name}.'  )
																		if "weight" in name:
																								assert (
																								    value.shape == adapter.proj.weight.data.shape
																								), f'{full_name} has size {value.shape}, but {adapter.proj.weight.data.shape} was found.'
																								__magic_name__:	Optional[int]							=       value
																								logger.info(f'Adapter proj layer weight was initialized from {full_name}.'  )
						elif isinstance(__UpperCAmelCase      ,   __UpperCAmelCase  ):
												if "bias" in name:
																		assert (
																		    value.shape == adapter.layers[layer_id].conv.bias.data.shape
																		), f'{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.bias.data.shape} was found.'
																		__magic_name__:	int							=       value
																		logger.info(f'Adapter layer {layer_id} bias was initialized from {full_name}.'  )
												elif "weight" in name:
																		assert (
																		    value.shape == adapter.layers[layer_id].conv.weight.data.shape
																		), f'{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.weight.data.shape} was found.'
																		__magic_name__:	Optional[Any]							=       value
																		logger.info(f'Adapter layer {layer_id} bias was initialized from {full_name}.'  )
						else:
												unused_weights.append(__UpperCAmelCase  )



def   a    (     __UpperCAmelCase      :    List[str]  )    ->							Any:
						__magic_name__,			__magic_name__:	Tuple							=       emb.weight.shape
						__magic_name__:	Union[str, Any]							=       nn.Linear(__UpperCAmelCase      ,   __UpperCAmelCase      ,   bias=__UpperCAmelCase  )
						__magic_name__:	Optional[Any]							=       emb.weight.data
						return lin_layer



@torch.no_grad()
def   a    (     __UpperCAmelCase      :    Tuple      ,   __UpperCAmelCase      :    Optional[int]      ,   __UpperCAmelCase      :    Dict      ,   __UpperCAmelCase      :    Dict      ,   __UpperCAmelCase      :    Union[str, Any]      ,   __UpperCAmelCase      :    List[str]      ,   __UpperCAmelCase      :    Optional[Any]      ,   __UpperCAmelCase      :    Tuple      ,   __UpperCAmelCase      :    str      ,   __UpperCAmelCase      :    List[str]      ,   __UpperCAmelCase      :    Dict      ,   )    ->							Optional[int]:
						__magic_name__:	Optional[int]							=       WavaVecaConfig.from_pretrained(
						    __UpperCAmelCase      ,   add_adapter=__UpperCAmelCase      ,   adapter_stride=__UpperCAmelCase      ,   adapter_kernel_size=__UpperCAmelCase      ,   use_auth_token=__UpperCAmelCase      ,   output_hidden_size=__UpperCAmelCase      ,   )
						__magic_name__:	Optional[int]							=       MBartConfig.from_pretrained(__UpperCAmelCase  )

						# load model
						__magic_name__,			__magic_name__,			__magic_name__:	str							=       fairseq.checkpoint_utils.load_model_ensemble_and_task(
						    [checkpoint_path]      ,   arg_overrides={
						        """config_yaml""": config_yaml_path,
						        """data""": """/""".join(dict_path.split("""/"""  )[:-1]  ),
						        """w2v_path""": checkpoint_path,
						        """load_pretrained_decoder_from""": None,
						    }      ,   )
						__magic_name__:	Tuple							=       model[0].eval()

						# load feature extractor
						__magic_name__:	Tuple							=       WavaVecaFeatureExtractor.from_pretrained(__UpperCAmelCase      ,   use_auth_token=__UpperCAmelCase  )

						# set weights for wav2vec2 encoder
						__magic_name__:	int							=       WavaVecaModel(__UpperCAmelCase  )

						recursively_load_weights_wavaveca(model.encoder      ,   __UpperCAmelCase  )

						# load decoder weights
						__magic_name__:	Optional[Any]							=       MBartForCausalLM(__UpperCAmelCase  )
						__magic_name__,			__magic_name__:	Dict							=       hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()      ,   strict=__UpperCAmelCase  )
						logger.warning(f'The following keys are missing when loading the decoder weights: {missing_keys}'  )
						logger.warning(f'The following keys are unexpected when loading the decoder weights: {unexpected_keys}'  )

						__magic_name__:	List[str]							=       SpeechEncoderDecoderModel(encoder=__UpperCAmelCase      ,   decoder=__UpperCAmelCase  )
						__magic_name__:	Optional[int]							=       False

						__magic_name__:	Union[str, Any]							=       MBartaaTokenizer(__UpperCAmelCase  )
						tokenizer.save_pretrained(__UpperCAmelCase  )

						__magic_name__:	List[Any]							=       hf_wavavec.config.to_dict()
						__magic_name__:	Any							=       tokenizer.pad_token_id
						__magic_name__:	Union[str, Any]							=       tokenizer.bos_token_id
						__magic_name__:	Optional[int]							=       tokenizer.eos_token_id
						__magic_name__:	int							=       """mbart50"""
						__magic_name__:	int							=       """wav2vec2"""

						__magic_name__:	str							=       tokenizer.eos_token_id
						__magic_name__:	Tuple							=       2_5_0_0_0_4
						__magic_name__:	Optional[int]							=       tokenizer.eos_token_id

						__magic_name__:	List[Any]							=       SpeechEncoderDecoderConfig.from_dict(__UpperCAmelCase  )

						hf_wavavec.save_pretrained(__UpperCAmelCase  )
						feature_extractor.save_pretrained(__UpperCAmelCase  )


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_yaml_path', default=None, type=str, help='Path to yaml file of fine-tuned model')
							parser.add_argument(
							    '--encoder_config_path',
							    default='facebook/wav2vec2-xls-r-1b',
							    type=str,
							    help='Path to hf encoder wav2vec2 checkpoint config',
							)
							parser.add_argument(
							    '--decoder_config_path',
							    default='facebook/mbart-large-50-one-to-many-mmt',
							    type=str,
							    help='Path to hf decoder checkpoint config',
							)
							parser.add_argument('--add_adapter', default=True, type=bool, help='whethere to add model adapter layers')
							parser.add_argument('--adapter_stride', default=2, type=int, help='stride of adapter layers')
							parser.add_argument('--adapter_kernel_size', default=3, type=int, help='kernel size of adapter layers')
							parser.add_argument('--encoder_output_dim', default=10_24, type=int, help='encoder output dim')
							parser.add_argument('--start_token_id', default=25_00_04, type=int, help='`decoder_start_token_id` of model config')

							__lowerCamelCase							=  parser.parse_args()
							convert_wavaveca_checkpoint(
							    args.checkpoint_path,
							    args.pytorch_dump_folder_path,
							    args.dict_path,
							    args.config_yaml_path,
							    encoder_config_path=args.encoder_config_path,
							    decoder_config_path=args.decoder_config_path,
							    add_adapter=args.add_adapter,
							    adapter_kernel_size=args.adapter_kernel_size,
							    adapter_stride=args.adapter_stride,
							    decoder_start_token_id=args.start_token_id,
							    encoder_output_dim=args.encoder_output_dim,
							)











"""simple docstring"""





import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers.models.esm.modeling_esmfold import EsmForProteinFolding



class       __A		:

					def __init__(			self  :      str     ,		__snake_case  :      int     ,		__snake_case  :      Dict=1_3     ,		__snake_case  :      Dict=7     ,		__snake_case  :      str=False     ,		__snake_case  :      Dict=True     ,		__snake_case  :      Tuple=False     ,		__snake_case  :      List[Any]=False     ,		__snake_case  :      Dict=1_9     ,		__snake_case  :      Dict=3_2     ,		__snake_case  :      Union[str, Any]=5     ,		__snake_case  :      List[Any]=4     ,		__snake_case  :      List[Any]=3_7     ,		__snake_case  :      Union[str, Any]="gelu"     ,		__snake_case  :      List[str]=0.1     ,		__snake_case  :      Union[str, Any]=0.1     ,		__snake_case  :      List[str]=5_1_2     ,		__snake_case  :      List[str]=1_6     ,		__snake_case  :      Tuple=2     ,		__snake_case  :      Optional[Any]=0.02     ,		__snake_case  :      str=3     ,		__snake_case  :      List[str]=4     ,		__snake_case  :      Optional[int]=None     ,		)			->							Optional[int]:
											__magic_name__:	Any							=       parent
											__magic_name__:	Optional[Any]							=       batch_size
											__magic_name__:	Optional[Any]							=       seq_length
											__magic_name__:	Optional[Any]							=       is_training
											__magic_name__:	str							=       use_input_mask
											__magic_name__:	Optional[Any]							=       use_token_type_ids
											__magic_name__:	List[str]							=       use_labels
											__magic_name__:	List[str]							=       vocab_size
											__magic_name__:	Union[str, Any]							=       hidden_size
											__magic_name__:	List[Any]							=       num_hidden_layers
											__magic_name__:	Dict							=       num_attention_heads
											__magic_name__:	int							=       intermediate_size
											__magic_name__:	List[Any]							=       hidden_act
											__magic_name__:	int							=       hidden_dropout_prob
											__magic_name__:	List[str]							=       attention_probs_dropout_prob
											__magic_name__:	Tuple							=       max_position_embeddings
											__magic_name__:	Any							=       type_vocab_size
											__magic_name__:	Union[str, Any]							=       type_sequence_label_size
											__magic_name__:	List[str]							=       initializer_range
											__magic_name__:	Optional[Any]							=       num_labels
											__magic_name__:	List[str]							=       num_choices
											__magic_name__:	Tuple							=       scope

					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							Any:
											__magic_name__:	Union[str, Any]							=       ids_tensor([self.batch_size, self.seq_length]     ,		self.vocab_size					)

											__magic_name__:	Dict							=       None
											if self.use_input_mask:
																	__magic_name__:	Optional[int]							=       random_attention_mask([self.batch_size, self.seq_length]					)

											__magic_name__:	str							=       None
											__magic_name__:	Optional[Any]							=       None
											__magic_name__:	int							=       None
											if self.use_labels:
																	__magic_name__:	List[Any]							=       ids_tensor([self.batch_size]     ,		self.type_sequence_label_size					)
																	__magic_name__:	str							=       ids_tensor([self.batch_size, self.seq_length]     ,		self.num_labels					)
																	__magic_name__:	Dict							=       ids_tensor([self.batch_size]     ,		self.num_choices					)

											__magic_name__:	Dict							=       self.get_config()

											return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels

					def   lowerCamelCase__   (			self  :      int					)			->							Any:
											__magic_name__:	List[Any]							=       EsmConfig(
											    vocab_size=3_3     ,		hidden_size=self.hidden_size     ,		pad_token_id=1     ,		num_hidden_layers=self.num_hidden_layers     ,		num_attention_heads=self.num_attention_heads     ,		intermediate_size=self.intermediate_size     ,		hidden_act=self.hidden_act     ,		hidden_dropout_prob=self.hidden_dropout_prob     ,		attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,		max_position_embeddings=self.max_position_embeddings     ,		type_vocab_size=self.type_vocab_size     ,		initializer_range=self.initializer_range     ,		is_folding_model=__snake_case     ,		esmfold_config={"""trunk""": {"""num_blocks""": 2}, """fp16_esm""": False}     ,		)
											return config

					def   lowerCamelCase__   (			self  :      Optional[int]     ,		__snake_case  :      Optional[Any]     ,		__snake_case  :      Optional[Any]     ,		__snake_case  :      Any     ,		__snake_case  :      List[Any]     ,		__snake_case  :      Any     ,		__snake_case  :      Union[str, Any]					)			->							Optional[Any]:
											__magic_name__:	str							=       EsmForProteinFolding(config=__snake_case					).float()
											model.to(__snake_case					)
											model.eval()
											__magic_name__:	str							=       model(__snake_case     ,		attention_mask=__snake_case					)
											__magic_name__:	Any							=       model(__snake_case					)
											__magic_name__:	Dict							=       model(__snake_case					)

											self.parent.assertEqual(result.positions.shape     ,		(8, self.batch_size, self.seq_length, 1_4, 3)					)
											self.parent.assertEqual(result.angles.shape     ,		(8, self.batch_size, self.seq_length, 7, 2)					)






					def   lowerCamelCase__   (			self  :      Any					)			->							int:
											__magic_name__:	str							=       self.prepare_config_and_inputs()
											(
											    (
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			
											):	Union[str, Any]							=       config_and_inputs
											__magic_name__:	Any							=       {"""input_ids""": input_ids, """attention_mask""": input_mask}
											return config, inputs_dict



@require_torch
class       __A		(   SCREAMING_SNAKE_CASE_     ,SCREAMING_SNAKE_CASE_     ,unittest.TestCase			):
					UpperCAmelCase__								=				False

					UpperCAmelCase__								=				(EsmForProteinFolding,) if is_torch_available() else ()
					UpperCAmelCase__								=				()
					UpperCAmelCase__								=				{} if is_torch_available() else {}
					UpperCAmelCase__								=				False

					def   lowerCamelCase__   (			self  :      List[Any]					)			->							Optional[Any]:
											__magic_name__:	Optional[int]							=       EsmFoldModelTester(self					)
											__magic_name__:	Optional[Any]							=       ConfigTester(self     ,		config_class=__snake_case     ,		hidden_size=3_7					)

					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							Any:
											self.config_tester.run_common_tests()

					def   lowerCamelCase__   (			self  :      List[str]					)			->							str:
											__magic_name__:	Tuple							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__snake_case					)

					@unittest.skip("""Does not support attention outputs"""					)
					def   lowerCamelCase__   (			self  :      List[str]					)			->							str:
											pass

					@unittest.skip
					def   lowerCamelCase__   (			self  :      List[Any]					)			->							Tuple:
											pass

					@unittest.skip("""Esm does not support embedding resizing"""					)
					def   lowerCamelCase__   (			self  :      List[Any]					)			->							Optional[int]:
											pass

					@unittest.skip("""Esm does not support embedding resizing"""					)
					def   lowerCamelCase__   (			self  :      str					)			->							str:
											pass

					@unittest.skip("""ESMFold does not support passing input embeds!"""					)
					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							List[Any]:
											pass

					@unittest.skip("""ESMFold does not support head pruning."""					)
					def   lowerCamelCase__   (			self  :      Any					)			->							List[str]:
											pass

					@unittest.skip("""ESMFold does not support head pruning."""					)
					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							List[Any]:
											pass

					@unittest.skip("""ESMFold does not support head pruning."""					)
					def   lowerCamelCase__   (			self  :      int					)			->							Tuple:
											pass

					@unittest.skip("""ESMFold does not support head pruning."""					)
					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							Optional[Any]:
											pass

					@unittest.skip("""ESMFold does not support head pruning."""					)
					def   lowerCamelCase__   (			self  :      Optional[Any]					)			->							Optional[Any]:
											pass

					@unittest.skip("""ESMFold does not output hidden states in the normal way."""					)
					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							List[Any]:
											pass

					@unittest.skip("""ESMfold does not output hidden states in the normal way."""					)
					def   lowerCamelCase__   (			self  :      Any					)			->							int:
											pass

					@unittest.skip("""ESMFold only has one output format."""					)
					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							str:
											pass

					@unittest.skip("""This test doesn't work for ESMFold and doesn't test core functionality"""					)
					def   lowerCamelCase__   (			self  :      List[Any]					)			->							Dict:
											pass

					@unittest.skip("""ESMFold does not support input chunking."""					)
					def   lowerCamelCase__   (			self  :      int					)			->							Any:
											pass

					@unittest.skip("""ESMFold doesn't respect you and it certainly doesn't respect your initialization arguments."""					)
					def   lowerCamelCase__   (			self  :      int					)			->							Union[str, Any]:
											pass

					@unittest.skip("""ESMFold doesn't support torchscript compilation."""					)
					def   lowerCamelCase__   (			self  :      Any					)			->							Optional[Any]:
											pass

					@unittest.skip("""ESMFold doesn't support torchscript compilation."""					)
					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							int:
											pass

					@unittest.skip("""ESMFold doesn't support torchscript compilation."""					)
					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							List[str]:
											pass

					@unittest.skip("""ESMFold doesn't support data parallel."""					)
					def   lowerCamelCase__   (			self  :      List[str]					)			->							str:
											pass






					@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""					)
					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							Dict:
											pass



@require_torch
class       __A		(   SCREAMING_SNAKE_CASE_			):

					@slow
					def   lowerCamelCase__   (			self  :      Optional[Any]					)			->							List[Any]:
											__magic_name__:	Any							=       EsmForProteinFolding.from_pretrained("""facebook/esmfold_v1"""					).float()
											model.eval()
											__magic_name__:	Optional[int]							=       torch.tensor([[0, 6, 4, 1_3, 5, 4, 1_6, 1_2, 1_1, 7, 2]]					)
											__magic_name__:	Dict							=       model(__snake_case					)["""positions"""]
											__magic_name__:	Tuple							=       torch.tensor([2.5828, 0.7993, -10.9334]     ,		dtype=torch.floataa					)
											self.assertTrue(torch.allclose(position_outputs[0, 0, 0, 0]     ,		__snake_case     ,		atol=1E-4					)					)



