






import argparse
import pathlib
from pathlib import Path
from tempfile import TemporaryDirectory

import esm as esm_module
import torch
from esm.esmfold.va.misc import batch_encode_sequences as esmfold_encode_sequences
from esm.esmfold.va.pretrained import esmfold_va

from transformers.models.esm.configuration_esm import EsmConfig, EsmFoldConfig
from transformers.models.esm.modeling_esm import (
    EsmForMaskedLM,
    EsmForSequenceClassification,
    EsmIntermediate,
    EsmLayer,
    EsmOutput,
    EsmSelfAttention,
    EsmSelfOutput,
)
from transformers.models.esm.modeling_esmfold import EsmForProteinFolding
from transformers.models.esm.tokenization_esm import EsmTokenizer
from transformers.utils import logging


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

lowerCAmelCase__							= [
    (
        "protein1",
        "MNGTEGPNFYVPFSNATGVVRSPFEYPQYYLAEPWQFSMLAAYMFLLIVLGFPINFLTLYVTVQHKKLRTPLNYILLNLAVADLFMVLGGFTSTLYTSLHGYFVFGPTGCNLEGFFATLGGEIALWSLVVLAIERYVVVCKPMSNFRFGENHAIMGVAFTWVMALACAAPPLAGWSRYIPEGLQCSCGIDYYTLKPEVNNESFVIYMFVVHFTIPMIIIFFCYGQLVFTVKEAAAQQQESATTQKAEKEVTRMVIIMVIAFLICWVPYASVAFYIFTHQGSNFGPIFMTIPAFFAKSAAIYNPVIYIMMNKQFRNCMLTTICCGKNPLGDDEASATVSKTETSQVAPA",
    ),
    ("protein2", "MKTVRQERLKSIVRILERSKEPVSGAQLAEELSVSRQVIVQDIAYLRSLGYNIVATPRGYVLA"),
    ("protein3", "MKTVRQERLKSI<mask>RILERSKEPVSGAQLAEELS<mask>SRQVIVQDIAYLRSLGYN<mask>VATPRGYVLAGG"),
    ("protein4", "MKTVRQERLKSI<mask>RILERSKEPVSGAQLAEELS<mask>SRQVIVQDIAYLRSLGYN<mask>VATPRGYVLA"),
]

lowerCAmelCase__							= {
    "esm1b_t33_650M_UR50S": esm_module.pretrained.esm1b_t33_650M_UR50S,
    "esm1v_t33_650M_UR90S_1": esm_module.pretrained.esm1v_t33_650M_UR90S_1,
    "esm1v_t33_650M_UR90S_2": esm_module.pretrained.esm1v_t33_650M_UR90S_2,
    "esm1v_t33_650M_UR90S_3": esm_module.pretrained.esm1v_t33_650M_UR90S_3,
    "esm1v_t33_650M_UR90S_4": esm_module.pretrained.esm1v_t33_650M_UR90S_4,
    "esm1v_t33_650M_UR90S_5": esm_module.pretrained.esm1v_t33_650M_UR90S_5,
    "esm2_t48_15B_UR50D": esm_module.pretrained.esm2_t48_15B_UR50D,
    "esm2_t36_3B_UR50D": esm_module.pretrained.esm2_t36_3B_UR50D,
    "esm2_t33_650M_UR50D": esm_module.pretrained.esm2_t33_650M_UR50D,
    "esm2_t30_150M_UR50D": esm_module.pretrained.esm2_t30_150M_UR50D,
    "esm2_t12_35M_UR50D": esm_module.pretrained.esm2_t12_35M_UR50D,
    "esm2_t6_8M_UR50D": esm_module.pretrained.esm2_t6_8M_UR50D,
    "esmfold_v1": esmfold_va,
}

lowerCAmelCase__							= list('ARNDCQEGHILKMFPSTWYV')

lowerCAmelCase__							= restypes + ["X"]
lowerCAmelCase__							= restypes_with_x + ["<pad>", "<mask>", "<cls>", "<sep>", "<eos>"]





def 							lowercase__		(				):






				with TemporaryDirectory() as tempdir:
								_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						'\n'.join(UpperCamelCase_					)
								_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						Path(UpperCamelCase_					) / 'vocab.txt'
								vocab_file.write_text(UpperCamelCase_					)
								_SCREAMING_SNAKE_CASE      :		int							=						EsmTokenizer(vocab_file=str(UpperCamelCase_					)					)
				_SCREAMING_SNAKE_CASE      :		Tuple							=						0  # Overlaps with 'A' but that seems to be what they want
				return hf_tokenizer





def 							lowercase__		(				lowerCamelCase,	lowerCamelCase					):
				_SCREAMING_SNAKE_CASE      :		Dict							=						our_module.load_state_dict(original_module.state_dict()					)
				if status.missing_keys:
								raise ValueError(f"""Missing keys: {status.missing_keys}"""					)
				if status.unexpected_keys:
								raise ValueError(f"""Unexpected keys: {status.unexpected_keys}"""					)





def 							lowercase__		(				lowerCamelCase,	lowerCamelCase,	lowerCamelCase,	lowerCamelCase,	lowerCamelCase					):






				if model.startswith('esmfold'					):
								_SCREAMING_SNAKE_CASE      :		Dict							=						MODEL_MAPPING[model]()
				else:
								_SCREAMING_SNAKE_CASE		,	_SCREAMING_SNAKE_CASE      :		Any							=						MODEL_MAPPING[model]()
				esm.eval()  # disable dropout

				if model.startswith('esmfold'					):
								_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						esm.esm.embed_dim
								_SCREAMING_SNAKE_CASE      :		Tuple							=						esm.esm.num_layers
								_SCREAMING_SNAKE_CASE      :		Tuple							=						esm.esm.attention_heads
								_SCREAMING_SNAKE_CASE      :		List[Any]							=						4 * embed_dim
								_SCREAMING_SNAKE_CASE      :		List[str]							=						esm.esm.token_dropout
								_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						False  # This code path does not exist in ESM-2
								_SCREAMING_SNAKE_CASE      :		Dict							=						'rotary'
								_SCREAMING_SNAKE_CASE      :		Tuple							=						True
								_SCREAMING_SNAKE_CASE      :		List[str]							=						EsmFoldConfig()
								for key, val in esm.cfg.items():
												if hasattr(UpperCamelCase_,	UpperCamelCase_					) and key != "trunk":
																setattr(UpperCamelCase_,	UpperCamelCase_,	UpperCamelCase_					)
								for key, val in esm.cfg.trunk.items():
												if hasattr(esmfold_config.trunk,	UpperCamelCase_					) and key != "structure_module":
																setattr(esmfold_config.trunk,	UpperCamelCase_,	UpperCamelCase_					)
								for key, val in esm.cfg.trunk.structure_module.items():
												if hasattr(esmfold_config.trunk.structure_module,	UpperCamelCase_					):
																setattr(esmfold_config.trunk.structure_module,	UpperCamelCase_,	UpperCamelCase_					)
				elif hasattr(UpperCamelCase_,	'args'					):
								# Indicates an ESM-1b or ESM-1v model
								_SCREAMING_SNAKE_CASE      :		int							=						esm.args.embed_dim
								_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						esm.args.layers
								_SCREAMING_SNAKE_CASE      :		List[str]							=						esm.args.attention_heads
								_SCREAMING_SNAKE_CASE      :		Tuple							=						esm.args.ffn_embed_dim
								_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						esm.args.token_dropout
								_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						True if esm.emb_layer_norm_before else False
								_SCREAMING_SNAKE_CASE      :		Tuple							=						'absolute'
								_SCREAMING_SNAKE_CASE      :		Dict							=						False
								_SCREAMING_SNAKE_CASE      :		Tuple							=						None
				else:
								# Indicates an ESM-2 model
								_SCREAMING_SNAKE_CASE      :		Tuple							=						esm.embed_dim
								_SCREAMING_SNAKE_CASE      :		List[Any]							=						esm.num_layers
								_SCREAMING_SNAKE_CASE      :		Optional[int]							=						esm.attention_heads
								_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						4 * embed_dim  # This is hardcoded in ESM-2
								_SCREAMING_SNAKE_CASE      :		List[Any]							=						esm.token_dropout
								_SCREAMING_SNAKE_CASE      :		str							=						False  # This code path does not exist in ESM-2
								_SCREAMING_SNAKE_CASE      :		Optional[int]							=						'rotary'
								_SCREAMING_SNAKE_CASE      :		List[str]							=						False
								_SCREAMING_SNAKE_CASE      :		Tuple							=						None

				if is_folding_model:
								_SCREAMING_SNAKE_CASE      :		Dict							=						esm.esm.alphabet
				_SCREAMING_SNAKE_CASE      :		str							=						tuple(alphabet.all_toks					)
				_SCREAMING_SNAKE_CASE      :		Any							=						alphabet.mask_idx
				_SCREAMING_SNAKE_CASE      :		List[Any]							=						alphabet.padding_idx

				if is_folding_model:
								_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						esm.esm
				else:
								_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						esm

				_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						EsmConfig(
				    vocab_size=original_esm_model.embed_tokens.num_embeddings,	mask_token_id=UpperCamelCase_,	hidden_size=UpperCamelCase_,	num_hidden_layers=UpperCamelCase_,	num_attention_heads=UpperCamelCase_,	intermediate_size=UpperCamelCase_,	max_position_embeddings=1_026,	layer_norm_eps=1E-5,	attention_probs_dropout_prob=0.0,	hidden_dropout_prob=0.0,	pad_token_id=UpperCamelCase_,	emb_layer_norm_before=UpperCamelCase_,	token_dropout=UpperCamelCase_,	position_embedding_type=UpperCamelCase_,	is_folding_model=UpperCamelCase_,	esmfold_config=UpperCamelCase_,	vocab_list=UpperCamelCase_,	)
				if classification_head:
								_SCREAMING_SNAKE_CASE      :		Tuple							=						esm.classification_heads['mnli'].out_proj.weight.shape[0]
				print('Our ESM config:',	UpperCamelCase_					)

				if model.startswith('esmfold'					):
								_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						EsmForProteinFolding
				elif classification_head:
								_SCREAMING_SNAKE_CASE      :		Dict							=						EsmForSequenceClassification
				else:
								_SCREAMING_SNAKE_CASE      :		List[str]							=						EsmForMaskedLM
				_SCREAMING_SNAKE_CASE      :		List[str]							=						model_class(UpperCamelCase_					)
				model.eval()

				# Now let's copy all the weights.
				# Embeddings
				_SCREAMING_SNAKE_CASE      :		Tuple							=						original_esm_model.embed_tokens.weight
				if position_embedding_type == "absolute":
								_SCREAMING_SNAKE_CASE      :		Any							=						original_esm_model.embed_positions.weight

				if config.emb_layer_norm_before:
								_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						original_esm_model.emb_layer_norm_before.weight
								_SCREAMING_SNAKE_CASE      :		Optional[int]							=						original_esm_model.emb_layer_norm_before.bias

				_SCREAMING_SNAKE_CASE      :		Tuple							=						original_esm_model.emb_layer_norm_after.weight
				_SCREAMING_SNAKE_CASE      :		Tuple							=						original_esm_model.emb_layer_norm_after.bias

				for i in range(config.num_hidden_layers					):
								# Encoder: start of layer
								_SCREAMING_SNAKE_CASE      :		List[str]							=						model.esm.encoder.layer[i]
								# esm_layer: TransformerSentenceEncoderLayer = original_esm_model.layers[i]
								_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						original_esm_model.layers[i]

								# self attention
								_SCREAMING_SNAKE_CASE      :		Optional[int]							=						layer.attention.self
								assert (
								    esm_layer.self_attn.k_proj.weight.data.shape
								    == esm_layer.self_attn.q_proj.weight.data.shape
								    == esm_layer.self_attn.v_proj.weight.data.shape
								    == torch.Size((config.hidden_size, config.hidden_size)					)
								)

								_SCREAMING_SNAKE_CASE      :		int							=						esm_layer.self_attn.q_proj.weight
								_SCREAMING_SNAKE_CASE      :		Any							=						esm_layer.self_attn.q_proj.bias
								_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						esm_layer.self_attn.k_proj.weight
								_SCREAMING_SNAKE_CASE      :		List[Any]							=						esm_layer.self_attn.k_proj.bias
								_SCREAMING_SNAKE_CASE      :		Dict							=						esm_layer.self_attn.v_proj.weight
								_SCREAMING_SNAKE_CASE      :		str							=						esm_layer.self_attn.v_proj.bias

								if getattr(esm_layer.self_attn,	'rot_emb',	UpperCamelCase_					) is not None:
												# Matt: Although inv_freq is not a trainable weight, it is computed at model init and cached.
												# During the training of ESM-2 the model was converted to float16 precision, which also converts
												# the inv_freq tensor, and the loss of precision remains even if the model is loaded later as float32.
												# If we recompute inv_freq without this loss of precision then we will get subtly different rotary
												# embeddings, which are enough to cause significant discrepancies in model outputs. To avoid this,
												# we make sure the new model copies the data from the old inv_freq.
												_SCREAMING_SNAKE_CASE      :		Dict							=						esm_layer.self_attn.rot_emb.inv_freq

								# LayerNorm changes for pre-activation
								_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						esm_layer.self_attn_layer_norm.weight
								_SCREAMING_SNAKE_CASE      :		Any							=						esm_layer.self_attn_layer_norm.bias
								_SCREAMING_SNAKE_CASE      :		Dict							=						esm_layer.final_layer_norm.weight
								_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						esm_layer.final_layer_norm.bias

								# self-attention output
								_SCREAMING_SNAKE_CASE      :		Dict							=						layer.attention.output
								assert self_output.dense.weight.shape == esm_layer.self_attn.out_proj.weight.shape
								_SCREAMING_SNAKE_CASE      :		Optional[int]							=						esm_layer.self_attn.out_proj.weight
								_SCREAMING_SNAKE_CASE      :		Tuple							=						esm_layer.self_attn.out_proj.bias

								# intermediate
								_SCREAMING_SNAKE_CASE      :		List[Any]							=						layer.intermediate
								assert intermediate.dense.weight.shape == esm_layer.fca.weight.shape
								_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						esm_layer.fca.weight
								_SCREAMING_SNAKE_CASE      :		List[str]							=						esm_layer.fca.bias

								# output
								_SCREAMING_SNAKE_CASE      :		List[str]							=						layer.output
								assert bert_output.dense.weight.shape == esm_layer.fca.weight.shape
								_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						esm_layer.fca.weight
								_SCREAMING_SNAKE_CASE      :		Tuple							=						esm_layer.fca.bias
								# end of layer

				if is_folding_model:
								_SCREAMING_SNAKE_CASE      :		Optional[int]							=						esm.esm_s_combine.data
								_SCREAMING_SNAKE_CASE      :		str							=						esm.afa_to_esm.data
								transfer_and_check_weights(esm.embedding,	model.embedding					)
								transfer_and_check_weights(esm.esm_s_mlp,	model.esm_s_mlp					)
								transfer_and_check_weights(esm.trunk,	model.trunk					)
								transfer_and_check_weights(esm.distogram_head,	model.distogram_head					)
								transfer_and_check_weights(esm.ptm_head,	model.ptm_head					)
								transfer_and_check_weights(esm.lm_head,	model.lm_head					)
								transfer_and_check_weights(esm.lddt_head,	model.lddt_head					)

				elif classification_head:
								_SCREAMING_SNAKE_CASE      :		Optional[int]							=						esm.esm.classification_heads['mnli'].dense.weight
								_SCREAMING_SNAKE_CASE      :		List[str]							=						esm.classification_heads['mnli'].dense.bias
								_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						esm.classification_heads['mnli'].out_proj.weight
								_SCREAMING_SNAKE_CASE      :		List[str]							=						esm.classification_heads['mnli'].out_proj.bias
				else:
								# LM Head
								_SCREAMING_SNAKE_CASE      :		List[Any]							=						esm.lm_head.dense.weight
								_SCREAMING_SNAKE_CASE      :		Dict							=						esm.lm_head.dense.bias
								_SCREAMING_SNAKE_CASE      :		int							=						esm.lm_head.layer_norm.weight
								_SCREAMING_SNAKE_CASE      :		Optional[int]							=						esm.lm_head.layer_norm.bias
								_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						esm.lm_head.weight
								_SCREAMING_SNAKE_CASE      :		str							=						esm.lm_head.bias

				# Contact prediction head
				transfer_and_check_weights(esm.contact_head,	model.esm.contact_head					)

				# Prepare data (first 2 sequences from ESMStructuralSplitDataset superfamily / 4)
				if is_folding_model:
								# Folding models aren't trained on masked inputs and don't like mask tokens.
								_SCREAMING_SNAKE_CASE      :		Dict							=						SAMPLE_DATA[:2]
				else:
								_SCREAMING_SNAKE_CASE      :		List[Any]							=						SAMPLE_DATA

				if is_folding_model:
								_SCREAMING_SNAKE_CASE      :		str							=						get_esmfold_tokenizer()
								_SCREAMING_SNAKE_CASE      :		List[str]							=						hf_tokenizer(
								    [row[1] for row in sample_data],	return_tensors='pt',	padding=UpperCamelCase_,	add_special_tokens=UpperCamelCase_					)
								_SCREAMING_SNAKE_CASE		,	_SCREAMING_SNAKE_CASE		,	_SCREAMING_SNAKE_CASE		,	_SCREAMING_SNAKE_CASE		,	_SCREAMING_SNAKE_CASE      :		Optional[int]							=						esmfold_encode_sequences([row[1] for row in sample_data]					)
								_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						torch.all(hf_tokens['input_ids'] == esmfold_aas					) and torch.all(
								    hf_tokens['attention_mask'] == esmfold_mask					)
				else:
								# Let's check that we get the same results.
								_SCREAMING_SNAKE_CASE      :		Any							=						alphabet.get_batch_converter()
								_SCREAMING_SNAKE_CASE		,	_SCREAMING_SNAKE_CASE		,	_SCREAMING_SNAKE_CASE      :		int							=						batch_converter(UpperCamelCase_					)
								# Prepare tokenizer and make sure it matches
								with TemporaryDirectory() as tempdir:
												_SCREAMING_SNAKE_CASE      :		Tuple							=						'\n'.join(alphabet.all_toks					)
												_SCREAMING_SNAKE_CASE      :		str							=						Path(UpperCamelCase_					) / 'vocab.txt'
												vocab_file.write_text(UpperCamelCase_					)
												_SCREAMING_SNAKE_CASE      :		Any							=						EsmTokenizer(vocab_file=str(UpperCamelCase_					)					)

								_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						hf_tokenizer([row[1] for row in sample_data],	return_tensors='pt',	padding=UpperCamelCase_					)
								_SCREAMING_SNAKE_CASE      :		int							=						torch.all(hf_tokens['input_ids'] == batch_tokens					)

				print('Do both models tokenizers output the same tokens?',	'🔥' if success else '💩'					)
				if not success:
								raise Exception('Tokenization does not match!'					)

				with torch.no_grad():
								if is_folding_model:
												# Let's test the model in parts
												# ESMFold always converts the ESM stem to float16, which requires float16 ops
												# that don't exist on CPU. Therefore, to test it we need to run it on GPU. However,
												# ESMFold is what we in the community call a "big boy" and so we desperately avoid putting both the
												# original and the converted model on the GPU at the same time.
												_SCREAMING_SNAKE_CASE      :		str							=						esm.cuda().infer([row[1] for row in sample_data]					)
												_SCREAMING_SNAKE_CASE      :		Dict							=						model.cuda()(
												    input_ids=hf_tokens['input_ids'].cuda(),	attention_mask=hf_tokens['attention_mask'].cuda()					)
								else:
												_SCREAMING_SNAKE_CASE      :		Optional[int]							=						model(**UpperCamelCase_,	output_hidden_states=UpperCamelCase_					)
												_SCREAMING_SNAKE_CASE      :		Dict							=						our_output['logits']
												if classification_head:
																_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						esm.model.classification_heads['mnli'](esm.extract_features(UpperCamelCase_					)					)
												else:
																_SCREAMING_SNAKE_CASE      :		str							=						esm(hf_tokens['input_ids'],	repr_layers=list(range(999					)					)					)
																_SCREAMING_SNAKE_CASE      :		Optional[int]							=						their_output['logits']

								if is_folding_model:
												_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						torch.max(torch.abs(our_output['positions'] - their_output['positions']					)					).item()
												_SCREAMING_SNAKE_CASE      :		List[Any]							=						torch.allclose(our_output['positions'],	their_output['positions'],	atol=1E-5					)
								else:
												_SCREAMING_SNAKE_CASE      :		str							=						torch.max(torch.abs(our_output - their_output					)					).item()
												_SCREAMING_SNAKE_CASE      :		List[Any]							=						torch.allclose(UpperCamelCase_,	UpperCamelCase_,	atol=1E-5					)

								print(f"""max_absolute_diff = {max_absolute_diff}"""					)  # ~ 1e-5
								print('Do both models output the same tensors?',	'🔥' if success else '💩'					)

								if not success:
												raise Exception('Something went wRoNg'					)

								if not is_folding_model:
												# Let's check contact prediction too
												_SCREAMING_SNAKE_CASE      :		List[Any]							=						model.predict_contacts(hf_tokens['input_ids'],	hf_tokens['attention_mask']					)
												_SCREAMING_SNAKE_CASE      :		int							=						esm.predict_contacts(hf_tokens['input_ids']					)
												_SCREAMING_SNAKE_CASE      :		int							=						torch.max(torch.abs(our_output - their_output					)					).item()
												_SCREAMING_SNAKE_CASE      :		Tuple							=						torch.allclose(UpperCamelCase_,	UpperCamelCase_,	atol=1E-5					)

												print('Contact prediction testing:'					)
												print(f"""max_absolute_diff = {max_absolute_diff}"""					)  # ~ 1e-5
												print('Do both models output the same tensors?',	'🔥' if success else '💩'					)

												if not success:
																raise Exception('Something went wRoNg'					)

								pathlib.Path(UpperCamelCase_					).mkdir(parents=UpperCamelCase_,	exist_ok=UpperCamelCase_					)
								print(f"""Saving model to {pytorch_dump_folder_path}"""					)
								model.save_pretrained(UpperCamelCase_					)

								del esm  # Free up some memory before continuing

				print(f"""Saving tokenizer to {pytorch_dump_folder_path}"""					)
				hf_tokenizer.save_pretrained(UpperCamelCase_					)

				if push_to_repo:
								model.push_to_hub(repo_id=UpperCamelCase_,	use_auth_token=UpperCamelCase_					)
								hf_tokenizer.push_to_hub(repo_id=UpperCamelCase_,	use_auth_token=UpperCamelCase_					)


if __name__ == "__main__":
			lowerCAmelCase__							= argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    '--pytorch_dump_folder_path', type=str, required=True, help='Path to the output PyTorch model.'
			)
			parser.add_argument(
			    '--classification_head', action='store_true', help='Whether to convert a final classification head.'
			)
			parser.add_argument('--model', default=None, type=str, required=True, help='Name of model to convert.')
			parser.add_argument('--push_to_repo', type=str, help='Repo to upload to (including username!).')
			parser.add_argument('--auth_token', type=str, help='HuggingFace auth token.')
			lowerCAmelCase__							= parser.parse_args()
			convert_esm_checkpoint_to_pytorch(
			    args.model, args.pytorch_dump_folder_path, args.classification_head, args.push_to_repo, args.auth_token
			)









"""simple docstring"""
def 							lowercase__		(				lowerCamelCase					):
				return -num if num < 0 else num





def 							lowercase__		(				lowerCamelCase					):
				if len(lowerCamelCase					) == 0:
								raise ValueError('abs_min() arg is an empty sequence'					)
				_SCREAMING_SNAKE_CASE      :		List[Any]							=						x[0]
				for i in x:
								if abs_val(lowerCamelCase					) < abs_val(lowerCamelCase					):
												_SCREAMING_SNAKE_CASE      :		List[Any]							=						i
				return j





def 							lowercase__		(				lowerCamelCase					):
				if len(lowerCamelCase					) == 0:
								raise ValueError('abs_max() arg is an empty sequence'					)
				_SCREAMING_SNAKE_CASE      :		Tuple							=						x[0]
				for i in x:
								if abs(lowerCamelCase					) > abs(lowerCamelCase					):
												_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						i
				return j





def 							lowercase__		(				lowerCamelCase					):
				if len(lowerCamelCase					) == 0:
								raise ValueError('abs_max_sort() arg is an empty sequence'					)
				return sorted(lowerCamelCase,	key=lowerCamelCase					)[-1]





def 							lowercase__		(				):
				assert abs_val(0					) == 0
				assert abs_val(34					) == 34
				assert abs_val(-100_000_000_000					) == 100_000_000_000

				_SCREAMING_SNAKE_CASE      :		Tuple							=						[-3, -1, 2, -11]
				assert abs_max(lowerCamelCase					) == -11
				assert abs_max_sort(lowerCamelCase					) == -11
				assert abs_min(lowerCamelCase					) == -1


if __name__ == "__main__":
			import doctest

			doctest.testmod()

			test_abs_val()
			print(abs_val(-34))  # --> 34

