




'''simple docstring'''


from dataclasses import asdict, dataclass
from typing import Optional

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


_snake_case : Optional[Any]  				=						logging.get_logger(__name__)

# TODO Update this
_snake_case : Optional[Any]  				=						{
    "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      A       (						lowerCAmelCase__       ):
							lowercase_							     =							"""esm"""







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


														"""simple docstring"""


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

														_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(__a				,     __a   ):
																												_a      	=							EsmFoldConfig(**__a   )
																					_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'''				,     __a   ):
																					raise ValueError('''The HuggingFace port of ESMFold does not support use_esm_attn_map at this time!'''   )







							def   __lowerCAmelCase     (    self			:    Dict   )     ->				Optional[int]:


														"""simple docstring"""


														_a      	=							super().to_dict()
														if isinstance(self.esmfold_config				,     __a   ):
																					_a      	=							self.esmfold_config.to_dict()
														return output



@dataclass
class      A       :
							lowercase_							     =							None
							lowercase_							     =							True
							lowercase_							     =							False
							lowercase_							     =							False
							lowercase_							     =							False
							lowercase_							     =							0

							lowercase_							     =							True
							lowercase_							     =							False

							lowercase_							     =							128
							lowercase_							     =							None







							def   __lowerCAmelCase     (    self			:    Any   )     ->				Optional[int]:


														"""simple docstring"""


														if self.trunk is None:
																					_a      	=							TrunkConfig()
														elif isinstance(self.trunk				,     __a   ):
																					_a      	=							TrunkConfig(**self.trunk   )







							def   __lowerCAmelCase     (    self			:    List[str]   )     ->				int:


														"""simple docstring"""


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



@dataclass
class      A       :
							lowercase_							     =							48
							lowercase_							     =							1024
							lowercase_							     =							128
							lowercase_							     =							32
							lowercase_							     =							32
							lowercase_							     =							32
							lowercase_							     =							0
							lowercase_							     =							0
							lowercase_							     =							False
							lowercase_							     =							4
							lowercase_							     =							128
							lowercase_							     =							None







							def   __lowerCAmelCase     (    self			:    Tuple   )     ->				List[Any]:


														"""simple docstring"""


														if self.structure_module is None:
																					_a      	=							StructureModuleConfig()
														elif isinstance(self.structure_module				,     __a   ):
																					_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   __lowerCAmelCase     (    self			:    List[Any]   )     ->				Optional[Any]:


														"""simple docstring"""


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



@dataclass
class      A       :
							lowercase_							     =							384
							lowercase_							     =							128
							lowercase_							     =							16
							lowercase_							     =							128
							lowercase_							     =							12
							lowercase_							     =							4
							lowercase_							     =							8
							lowercase_							     =							0.1
							lowercase_							     =							8
							lowercase_							     =							1
							lowercase_							     =							2
							lowercase_							     =							7
							lowercase_							     =							10
							lowercase_							     =							1e-8
							lowercase_							     =							1e5







							def   __lowerCAmelCase     (    self			:    str   )     ->				List[Any]:


														"""simple docstring"""


														return asdict(self   )



def 						snake_case_       ():





							'''simple docstring'''


							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 ..utils import DummyObject, requires_backends
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )


def _lowerCamelCase      (						*_UpperCamelCase       ,					**_UpperCamelCase ):

			'''simple docstring'''




			requires_backends(_UpperCamelCase       ,					["torch"] )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Dict							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       int							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Tuple							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Dict							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       str							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       List[str]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Union[str, Any]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[int]							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )
class     _UpperCamelCase    (  metaclass=lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Any							 =["""torch"""]

							def __init__(	self       ,  *__a       ,  **__a      ):
										requires_backends(self       ,  ["torch"]      )

							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )



							@classmethod
							def      snake_case							(	cls       ,  *__a       ,  **__a      ):
										requires_backends(cls       ,  ["torch"]      )




