


from __future__ import annotations







class        UpperCamelCase__   :

					def __init__(     self       :   Dict							,					UpperCamelCase__       :   List[Any]=None       ):






										'''simple docstring'''






										lowercase_  							=			data
										lowercase_  							=			None







					def __repr__(     self       :   Any       ):






										'''simple docstring'''






										lowercase_  							=			[]
										lowercase_  							=			self
										while temp:
															string_rep.append(F'''{temp.data}'''       )
															lowercase_  							=			temp.next
										return "->".join(UpperCamelCase__       )



def 			UpperCAmelCase_				(      UpperCAmelCase__  ):
					if not elements_list:
										raise Exception("""The Elements List is empty"""  )

					lowercase_  							=			lowercase_  							=			Node(elements_list[0]  )
					for i in range(1						,							len(UpperCAmelCase__  )  ):
										lowercase_  							=			Node(elements_list[i]  )
										lowercase_  							=			current.next
					return head


def 			UpperCAmelCase_				(      UpperCAmelCase__  ):
					if head_node is not None and isinstance(UpperCAmelCase__						,							UpperCAmelCase__  ):
										print_reverse(head_node.next  )
										print(head_node.data  )


def 			UpperCAmelCase_				(      ):
					from doctest import testmod

					testmod()

					lowercase_  							=			make_linked_list([1_4, 5_2, 1_4, 1_2, 4_3]  )
					print("""Linked List:"""  )
					print(UpperCAmelCase__  )
					print("""Elements in Reverse:"""  )
					print_reverse(UpperCAmelCase__  )


if __name__ == "__main__":
							main()






from dataclasses import asdict, dataclass
from typing import Optional

from ...configuration_utils import PretrainedConfig
from ...utils import logging


a					  =     logging.get_logger(__name__)

# TODO Update this
a					  =     {
    'facebook/esm-1b': 'https://huggingface.co/facebook/esm-1b/resolve/main/config.json',
    # See all ESM models at https://huggingface.co/models?filter=esm
}







class        UpperCamelCase__   (	__magic_name__   ):
					__SCREAMING_SNAKE_CASE       :  Tuple						=   'esm'

					def __init__(     self       :   Optional[Any]							,					UpperCamelCase__       :   Dict=None							,					UpperCamelCase__       :   Tuple=None							,					UpperCamelCase__       :   List[Any]=None							,					UpperCamelCase__       :   List[Any]=768							,					UpperCamelCase__       :   Tuple=12							,					UpperCamelCase__       :   Optional[int]=12							,					UpperCamelCase__       :   Dict=3_072							,					UpperCamelCase__       :   Union[str, Any]=0.1							,					UpperCamelCase__       :   Dict=0.1							,					UpperCamelCase__       :   Optional[int]=1_026							,					UpperCamelCase__       :   Any=0.02							,					UpperCamelCase__       :   Dict=1e-12							,					UpperCamelCase__       :   List[str]="absolute"							,					UpperCamelCase__       :   Union[str, Any]=True							,					UpperCamelCase__       :   Tuple=None							,					UpperCamelCase__       :   Union[str, Any]=False							,					UpperCamelCase__       :   Optional[int]=False							,					UpperCamelCase__       :   Dict=None							,					UpperCamelCase__       :   str=None							,					**UpperCamelCase__       :   str							,					):






										'''simple docstring'''






										super().__init__(pad_token_id=UpperCamelCase__							,					mask_token_id=UpperCamelCase__							,					**UpperCamelCase__       )

										lowercase_  							=			vocab_size
										lowercase_  							=			hidden_size
										lowercase_  							=			num_hidden_layers
										lowercase_  							=			num_attention_heads
										lowercase_  							=			intermediate_size
										lowercase_  							=			hidden_dropout_prob
										lowercase_  							=			attention_probs_dropout_prob
										lowercase_  							=			max_position_embeddings
										lowercase_  							=			initializer_range
										lowercase_  							=			layer_norm_eps
										lowercase_  							=			position_embedding_type
										lowercase_  							=			use_cache
										lowercase_  							=			emb_layer_norm_before
										lowercase_  							=			token_dropout
										lowercase_  							=			is_folding_model
										if is_folding_model:
															if esmfold_config is None:
																				logger.info("""No esmfold_config supplied for folding model, using default values."""       )
																				lowercase_  							=			EsmFoldConfig()
															elif isinstance(UpperCamelCase__							,					UpperCamelCase__       ):
																				lowercase_  							=			EsmFoldConfig(**UpperCamelCase__       )
															lowercase_  							=			esmfold_config
															if vocab_list is None:
																				logger.warning("""No vocab_list supplied for folding model, assuming the ESM-2 vocabulary!"""       )
																				lowercase_  							=			get_default_vocab_list()
															else:
																				lowercase_  							=			vocab_list
										else:
															lowercase_  							=			None
															lowercase_  							=			None
										if self.esmfold_config is not None and getattr(self.esmfold_config							,					"""use_esm_attn_map"""							,					UpperCamelCase__       ):
															raise ValueError("""The HuggingFace port of ESMFold does not support use_esm_attn_map at this time!"""       )







					def   UpperCAmelCase__       (     self       :   List[Any]       ):






										'''simple docstring'''






										lowercase_  							=			super().to_dict()
										if isinstance(self.esmfold_config							,					UpperCamelCase__       ):
															lowercase_  							=			self.esmfold_config.to_dict()
										return output







@dataclass
class        UpperCamelCase__   :
					__SCREAMING_SNAKE_CASE       :  str						=   None
					__SCREAMING_SNAKE_CASE       :  bool						=   True
					__SCREAMING_SNAKE_CASE       :  bool						=   False
					__SCREAMING_SNAKE_CASE       :  bool						=   False
					__SCREAMING_SNAKE_CASE       :  bool						=   False
					__SCREAMING_SNAKE_CASE       :  float						=   0

					__SCREAMING_SNAKE_CASE       :  bool						=   True
					__SCREAMING_SNAKE_CASE       :  bool						=   False

					__SCREAMING_SNAKE_CASE       :  int						=   128
					__SCREAMING_SNAKE_CASE       :  "TrunkConfig"						=   None

					def   UpperCAmelCase__       (     self       :   Tuple       ):






										'''simple docstring'''






										if self.trunk is None:
															lowercase_  							=			TrunkConfig()
										elif isinstance(self.trunk							,					UpperCamelCase__       ):
															lowercase_  							=			TrunkConfig(**self.trunk       )







					def   UpperCAmelCase__       (     self       :   Union[str, Any]       ):






										'''simple docstring'''






										lowercase_  							=			asdict(self       )
										lowercase_  							=			self.trunk.to_dict()
										return output







@dataclass
class        UpperCamelCase__   :
					__SCREAMING_SNAKE_CASE       :  int						=   48
					__SCREAMING_SNAKE_CASE       :  int						=   1024
					__SCREAMING_SNAKE_CASE       :  int						=   128
					__SCREAMING_SNAKE_CASE       :  int						=   32
					__SCREAMING_SNAKE_CASE       :  int						=   32
					__SCREAMING_SNAKE_CASE       :  int						=   32
					__SCREAMING_SNAKE_CASE       :  float						=   0
					__SCREAMING_SNAKE_CASE       :  float						=   0
					__SCREAMING_SNAKE_CASE       :  bool						=   False
					__SCREAMING_SNAKE_CASE       :  int						=   4
					__SCREAMING_SNAKE_CASE       :  Optional[int]						=   128
					__SCREAMING_SNAKE_CASE       :  "StructureModuleConfig"						=   None

					def   UpperCAmelCase__       (     self       :   Union[str, Any]       ):






										'''simple docstring'''






										if self.structure_module is None:
															lowercase_  							=			StructureModuleConfig()
										elif isinstance(self.structure_module							,					UpperCamelCase__       ):
															lowercase_  							=			StructureModuleConfig(**self.structure_module       )

										if self.max_recycles <= 0:
															raise ValueError(F'''`max_recycles` should be positive, got {self.max_recycles}.'''       )
										if self.sequence_state_dim % self.sequence_state_dim != 0:
															raise ValueError(
															    """`sequence_state_dim` should be a round multiple of `sequence_state_dim`, got"""
															    F''' {self.sequence_state_dim} and {self.sequence_state_dim}.'''       )
										if self.pairwise_state_dim % self.pairwise_state_dim != 0:
															raise ValueError(
															    """`pairwise_state_dim` should be a round multiple of `pairwise_state_dim`, got"""
															    F''' {self.pairwise_state_dim} and {self.pairwise_state_dim}.'''       )

										lowercase_  							=			self.sequence_state_dim // self.sequence_head_width
										lowercase_  							=			self.pairwise_state_dim // self.pairwise_head_width

										if self.sequence_state_dim != sequence_num_heads * self.sequence_head_width:
															raise ValueError(
															    """`sequence_state_dim` should be equal to `sequence_num_heads * sequence_head_width, got"""
															    F''' {self.sequence_state_dim} != {sequence_num_heads} * {self.sequence_head_width}.'''       )
										if self.pairwise_state_dim != pairwise_num_heads * self.pairwise_head_width:
															raise ValueError(
															    """`pairwise_state_dim` should be equal to `pairwise_num_heads * pairwise_head_width, got"""
															    F''' {self.pairwise_state_dim} != {pairwise_num_heads} * {self.pairwise_head_width}.'''       )
										if self.pairwise_state_dim % 2 != 0:
															raise ValueError(F'''`pairwise_state_dim` should be even, got {self.pairwise_state_dim}.'''       )

										if self.dropout >= 0.4:
															raise ValueError(F'''`dropout` should not be greater than 0.4, got {self.dropout}.'''       )







					def   UpperCAmelCase__       (     self       :   Any       ):






										'''simple docstring'''






										lowercase_  							=			asdict(self       )
										lowercase_  							=			self.structure_module.to_dict()
										return output







@dataclass
class        UpperCamelCase__   :
					__SCREAMING_SNAKE_CASE       :  int						=   384
					__SCREAMING_SNAKE_CASE       :  int						=   128
					__SCREAMING_SNAKE_CASE       :  int						=   16
					__SCREAMING_SNAKE_CASE       :  int						=   128
					__SCREAMING_SNAKE_CASE       :  int						=   12
					__SCREAMING_SNAKE_CASE       :  int						=   4
					__SCREAMING_SNAKE_CASE       :  int						=   8
					__SCREAMING_SNAKE_CASE       :  float						=   0.1
					__SCREAMING_SNAKE_CASE       :  int						=   8
					__SCREAMING_SNAKE_CASE       :  int						=   1
					__SCREAMING_SNAKE_CASE       :  int						=   2
					__SCREAMING_SNAKE_CASE       :  int						=   7
					__SCREAMING_SNAKE_CASE       :  int						=   10
					__SCREAMING_SNAKE_CASE       :  float						=   1e-8
					__SCREAMING_SNAKE_CASE       :  float						=   1e5

					def   UpperCAmelCase__       (     self       :   List[str]       ):






										'''simple docstring'''






										return asdict(self       )



def 			UpperCAmelCase_				(      ):
					return (
					    "<cls>",
					    "<pad>",
					    "<eos>",
					    "<unk>",
					    "L",
					    "A",
					    "G",
					    "V",
					    "S",
					    "E",
					    "R",
					    "T",
					    "I",
					    "D",
					    "P",
					    "K",
					    "Q",
					    "N",
					    "F",
					    "Y",
					    "M",
					    "H",
					    "W",
					    "C",
					    "X",
					    "B",
					    "U",
					    "Z",
					    "O",
					    ".",
					    "-",
					    "<null_1>",
					    "<mask>",
					)


