


'''simple docstring'''
from dataclasses import asdict, dataclass
from typing import Optional

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


__SCREAMING_SNAKE_CASE					:				List[str]									=		logging.get_logger(__name__)

# TODO Update this
__SCREAMING_SNAKE_CASE					:				Tuple									=		{
    """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 					__lowerCAmelCase   (   _UpperCAmelCase						):

						"""simple docstring"""






						_UpperCAmelCase		:       Tuple   						='esm'






						def __init__(  self							:      List[Any] ,  lowerCAmelCase							:      str=None ,  lowerCAmelCase							:      int=None ,  lowerCAmelCase							:      int=None ,  lowerCAmelCase							:      Union[str, Any]=7_68 ,  lowerCAmelCase							:      List[Any]=12 ,  lowerCAmelCase							:      Tuple=12 ,  lowerCAmelCase							:      Tuple=30_72 ,  lowerCAmelCase							:      Dict=0.1 ,  lowerCAmelCase							:      Optional[Any]=0.1 ,  lowerCAmelCase							:      Tuple=10_26 ,  lowerCAmelCase							:      Union[str, Any]=0.0_2 ,  lowerCAmelCase							:      List[str]=1e-12 ,  lowerCAmelCase							:      Optional[Any]="absolute" ,  lowerCAmelCase							:      Tuple=True ,  lowerCAmelCase							:      Optional[Any]=None ,  lowerCAmelCase							:      Any=False ,  lowerCAmelCase							:      str=False ,  lowerCAmelCase							:      Union[str, Any]=None ,  lowerCAmelCase							:      Union[str, Any]=None ,  **lowerCAmelCase							:      List[str] ,  ):
													super().__init__(pad_token_id=SCREAMING_SNAKE_CASE_ ,  mask_token_id=SCREAMING_SNAKE_CASE_ ,  **SCREAMING_SNAKE_CASE_	)

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






						def 				_UpperCAmelCase       (  self							:      List[Any]	):
													A_			    =		super().to_dict()
													if isinstance(self.esmfold_config ,  SCREAMING_SNAKE_CASE_	):
																				A_			    =		self.esmfold_config.to_dict()
													return output






@dataclass
class 					__lowerCAmelCase   :

						"""simple docstring"""






						_UpperCAmelCase		:       str   						=None
						_UpperCAmelCase		:       bool   						=True
						_UpperCAmelCase		:       bool   						=False
						_UpperCAmelCase		:       bool   						=False
						_UpperCAmelCase		:       bool   						=False
						_UpperCAmelCase		:       float   						=0

						_UpperCAmelCase		:       bool   						=True
						_UpperCAmelCase		:       bool   						=False

						_UpperCAmelCase		:       int   						=128
						_UpperCAmelCase		:       "TrunkConfig"   						=None






						def 				_UpperCAmelCase       (  self							:      Optional[int]	):
													if self.trunk is None:
																				A_			    =		TrunkConfig()
													elif isinstance(self.trunk ,  SCREAMING_SNAKE_CASE_	):
																				A_			    =		TrunkConfig(**self.trunk	)






						def 				_UpperCAmelCase       (  self							:      Optional[int]	):
													A_			    =		asdict(self	)
													A_			    =		self.trunk.to_dict()
													return output






@dataclass
class 					__lowerCAmelCase   :

						"""simple docstring"""






						_UpperCAmelCase		:       int   						=48
						_UpperCAmelCase		:       int   						=1024
						_UpperCAmelCase		:       int   						=128
						_UpperCAmelCase		:       int   						=32
						_UpperCAmelCase		:       int   						=32
						_UpperCAmelCase		:       int   						=32
						_UpperCAmelCase		:       float   						=0
						_UpperCAmelCase		:       float   						=0
						_UpperCAmelCase		:       bool   						=False
						_UpperCAmelCase		:       int   						=4
						_UpperCAmelCase		:       Optional[int]   						=128
						_UpperCAmelCase		:       "StructureModuleConfig"   						=None






						def 				_UpperCAmelCase       (  self							:      Any	):
													if self.structure_module is None:
																				A_			    =		StructureModuleConfig()
													elif isinstance(self.structure_module ,  SCREAMING_SNAKE_CASE_	):
																				A_			    =		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}."	)

													A_			    =		self.sequence_state_dim // self.sequence_head_width
													A_			    =		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							:      Optional[int]	):
													A_			    =		asdict(self	)
													A_			    =		self.structure_module.to_dict()
													return output






@dataclass
class 					__lowerCAmelCase   :

						"""simple docstring"""






						_UpperCAmelCase		:       int   						=384
						_UpperCAmelCase		:       int   						=128
						_UpperCAmelCase		:       int   						=16
						_UpperCAmelCase		:       int   						=128
						_UpperCAmelCase		:       int   						=12
						_UpperCAmelCase		:       int   						=4
						_UpperCAmelCase		:       int   						=8
						_UpperCAmelCase		:       float   						=0.1
						_UpperCAmelCase		:       int   						=8
						_UpperCAmelCase		:       int   						=1
						_UpperCAmelCase		:       int   						=2
						_UpperCAmelCase		:       int   						=7
						_UpperCAmelCase		:       int   						=10
						_UpperCAmelCase		:       float   						=1e-8
						_UpperCAmelCase		:       float   						=1e5






						def 				_UpperCAmelCase       (  self							:      List[str]	):
													return asdict(self	)







def       a_				(	):
							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>",
							)









'''simple docstring'''



from dataclasses import asdict, dataclass
from typing import Optional

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


A__						:   List[str]				=    logging.get_logger(__name__)

# TODO Update this
A__						:   Tuple				=    {
    """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_    (_UpperCAmelCase    ):





    """simple docstring"""






    lowerCamelCase    :   Tuple					=     'esm'







    def __init__(				self     ,	SCREAMING_SNAKE_CASE_=None     ,	SCREAMING_SNAKE_CASE_=None     ,	SCREAMING_SNAKE_CASE_=None     ,	SCREAMING_SNAKE_CASE_=7_68     ,	SCREAMING_SNAKE_CASE_=12     ,	SCREAMING_SNAKE_CASE_=12     ,	SCREAMING_SNAKE_CASE_=30_72     ,	SCREAMING_SNAKE_CASE_=0.1     ,	SCREAMING_SNAKE_CASE_=0.1     ,	SCREAMING_SNAKE_CASE_=10_26     ,	SCREAMING_SNAKE_CASE_=0.0_2     ,	SCREAMING_SNAKE_CASE_=1E-12     ,	SCREAMING_SNAKE_CASE_="absolute"     ,	SCREAMING_SNAKE_CASE_=True     ,	SCREAMING_SNAKE_CASE_=None     ,	SCREAMING_SNAKE_CASE_=False     ,	SCREAMING_SNAKE_CASE_=False     ,	SCREAMING_SNAKE_CASE_=None     ,	SCREAMING_SNAKE_CASE_=None     ,	**SCREAMING_SNAKE_CASE_     ,	)							->	List[str]:
         super().__init__(pad_token_id=SCREAMING_SNAKE_CASE_     ,	mask_token_id=SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_      )

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







    def  lowercase_							(				self      )							->	Any:
         __lowerCamelCase  :      Any														=						super().to_dict()
         if isinstance(self.esmfold_config     ,	SCREAMING_SNAKE_CASE_      ):
              __lowerCamelCase  :      int														=						self.esmfold_config.to_dict()
         return output







@dataclass
class   UpperCAmelCase_    :





    """simple docstring"""






    lowerCamelCase    :   str					=     None
    lowerCamelCase    :   bool					=     True
    lowerCamelCase    :   bool					=     False
    lowerCamelCase    :   bool					=     False
    lowerCamelCase    :   bool					=     False
    lowerCamelCase    :   float					=     0

    lowerCamelCase    :   bool					=     True
    lowerCamelCase    :   bool					=     False

    lowerCamelCase    :   int					=     1_2_8
    lowerCamelCase    :   "TrunkConfig"					=     None







    def  lowercase_							(				self      )							->	Any:
         if self.trunk is None:
              __lowerCamelCase  :      List[str]														=						TrunkConfig()
         elif isinstance(self.trunk     ,	SCREAMING_SNAKE_CASE_      ):
              __lowerCamelCase  :      Any														=						TrunkConfig(**self.trunk      )







    def  lowercase_							(				self      )							->	int:
         __lowerCamelCase  :      Optional[int]														=						asdict(self      )
         __lowerCamelCase  :      str														=						self.trunk.to_dict()
         return output







@dataclass
class   UpperCAmelCase_    :





    """simple docstring"""






    lowerCamelCase    :   int					=     4_8
    lowerCamelCase    :   int					=     1_0_2_4
    lowerCamelCase    :   int					=     1_2_8
    lowerCamelCase    :   int					=     3_2
    lowerCamelCase    :   int					=     3_2
    lowerCamelCase    :   int					=     3_2
    lowerCamelCase    :   float					=     0
    lowerCamelCase    :   float					=     0
    lowerCamelCase    :   bool					=     False
    lowerCamelCase    :   int					=     4
    lowerCamelCase    :   Optional[int]					=     1_2_8
    lowerCamelCase    :   "StructureModuleConfig"					=     None







    def  lowercase_							(				self      )							->	Optional[int]:
         if self.structure_module is None:
              __lowerCamelCase  :      Dict														=						StructureModuleConfig()
         elif isinstance(self.structure_module     ,	SCREAMING_SNAKE_CASE_      ):
              __lowerCamelCase  :      Optional[Any]														=						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}.'      )

         __lowerCamelCase  :      Tuple														=						self.sequence_state_dim // self.sequence_head_width
         __lowerCamelCase  :      str														=						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  lowercase_							(				self      )							->	List[Any]:
         __lowerCamelCase  :      List[str]														=						asdict(self      )
         __lowerCamelCase  :      int														=						self.structure_module.to_dict()
         return output







@dataclass
class   UpperCAmelCase_    :





    """simple docstring"""






    lowerCamelCase    :   int					=     3_8_4
    lowerCamelCase    :   int					=     1_2_8
    lowerCamelCase    :   int					=     1_6
    lowerCamelCase    :   int					=     1_2_8
    lowerCamelCase    :   int					=     1_2
    lowerCamelCase    :   int					=     4
    lowerCamelCase    :   int					=     8
    lowerCamelCase    :   float					=     0.1
    lowerCamelCase    :   int					=     8
    lowerCamelCase    :   int					=     1
    lowerCamelCase    :   int					=     2
    lowerCamelCase    :   int					=     7
    lowerCamelCase    :   int					=     1_0
    lowerCamelCase    :   float					=     1e-8
    lowerCamelCase    :   float					=     1e5







    def  lowercase_							(				self      )							->	Any:
         return asdict(self      )







def      UpperCAmelCase__   (      )	->						Optional[Any]:
     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>",
     )






