



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__UpperCAmelCase			  =			{
    '''configuration_albert''': ['''ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''AlbertConfig''', '''AlbertOnnxConfig'''],
}

try:
    if not is_sentencepiece_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCAmelCase			  =			['''AlbertTokenizer''']

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCAmelCase			  =			['''AlbertTokenizerFast''']

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCAmelCase			  =			[
        '''ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''AlbertForMaskedLM''',
        '''AlbertForMultipleChoice''',
        '''AlbertForPreTraining''',
        '''AlbertForQuestionAnswering''',
        '''AlbertForSequenceClassification''',
        '''AlbertForTokenClassification''',
        '''AlbertModel''',
        '''AlbertPreTrainedModel''',
        '''load_tf_weights_in_albert''',
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCAmelCase			  =			[
        '''TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''TFAlbertForMaskedLM''',
        '''TFAlbertForMultipleChoice''',
        '''TFAlbertForPreTraining''',
        '''TFAlbertForQuestionAnswering''',
        '''TFAlbertForSequenceClassification''',
        '''TFAlbertForTokenClassification''',
        '''TFAlbertMainLayer''',
        '''TFAlbertModel''',
        '''TFAlbertPreTrainedModel''',
    ]

try:
    if not is_flax_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCAmelCase			  =			[
        '''FlaxAlbertForMaskedLM''',
        '''FlaxAlbertForMultipleChoice''',
        '''FlaxAlbertForPreTraining''',
        '''FlaxAlbertForQuestionAnswering''',
        '''FlaxAlbertForSequenceClassification''',
        '''FlaxAlbertForTokenClassification''',
        '''FlaxAlbertModel''',
        '''FlaxAlbertPreTrainedModel''',
    ]

if TYPE_CHECKING:
    from .configuration_albert import ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig, AlbertOnnxConfig

    try:
        if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_albert import AlbertTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_albert_fast import AlbertTokenizerFast

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_albert import (
            ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
            AlbertForMaskedLM,
            AlbertForMultipleChoice,
            AlbertForPreTraining,
            AlbertForQuestionAnswering,
            AlbertForSequenceClassification,
            AlbertForTokenClassification,
            AlbertModel,
            AlbertPreTrainedModel,
            load_tf_weights_in_albert,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_albert import (
            TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFAlbertForMaskedLM,
            TFAlbertForMultipleChoice,
            TFAlbertForPreTraining,
            TFAlbertForQuestionAnswering,
            TFAlbertForSequenceClassification,
            TFAlbertForTokenClassification,
            TFAlbertMainLayer,
            TFAlbertModel,
            TFAlbertPreTrainedModel,
        )

    try:
        if not is_flax_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_flax_albert import (
            FlaxAlbertForMaskedLM,
            FlaxAlbertForMultipleChoice,
            FlaxAlbertForPreTraining,
            FlaxAlbertForQuestionAnswering,
            FlaxAlbertForSequenceClassification,
            FlaxAlbertForTokenClassification,
            FlaxAlbertModel,
            FlaxAlbertPreTrainedModel,
        )
else:
    import sys

    __UpperCAmelCase			  =			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





from dataclasses import asdict, dataclass
from typing import Optional

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


_lowercase											=    logging.get_logger(__name__)

# TODO Update this
_lowercase											=    {
    """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 			lowercase_		(      A       ):
       __lowerCamelCase				       =						"esm"


       def __init__(    self						,       __A=None						,       __A=None						,       __A=None						,       __A=768						,       __A=12						,       __A=12						,       __A=3_072						,       __A=0.1						,       __A=0.1						,       __A=1_026						,       __A=0.02						,       __A=1e-1_2						,       __A="absolute"						,       __A=True						,       __A=None						,       __A=False						,       __A=False						,       __A=None						,       __A=None						,       **__A						,       )						->    int:
              super().__init__(pad_token_id=__A						,       mask_token_id=__A						,       **__A				)

              SCREAMING_SNAKE_CASE_							:				Any		=vocab_size
              SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=hidden_size
              SCREAMING_SNAKE_CASE_							:				int		=num_hidden_layers
              SCREAMING_SNAKE_CASE_							:				int		=num_attention_heads
              SCREAMING_SNAKE_CASE_							:				List[str]		=intermediate_size
              SCREAMING_SNAKE_CASE_							:				int		=hidden_dropout_prob
              SCREAMING_SNAKE_CASE_							:				int		=attention_probs_dropout_prob
              SCREAMING_SNAKE_CASE_							:				List[Any]		=max_position_embeddings
              SCREAMING_SNAKE_CASE_							:				List[Any]		=initializer_range
              SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=layer_norm_eps
              SCREAMING_SNAKE_CASE_							:				str		=position_embedding_type
              SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=use_cache
              SCREAMING_SNAKE_CASE_							:				Optional[int]		=emb_layer_norm_before
              SCREAMING_SNAKE_CASE_							:				Tuple		=token_dropout
              SCREAMING_SNAKE_CASE_							:				List[Any]		=is_folding_model
              if is_folding_model:
                     if esmfold_config is None:
                            logger.info('''No esmfold_config supplied for folding model, using default values.'''				)
                            SCREAMING_SNAKE_CASE_							:				Optional[int]		=EsmFoldConfig()
                     elif isinstance(__A						,       __A				):
                            SCREAMING_SNAKE_CASE_							:				List[Any]		=EsmFoldConfig(**__A				)
                     SCREAMING_SNAKE_CASE_							:				Optional[int]		=esmfold_config
                     if vocab_list is None:
                            logger.warning('''No vocab_list supplied for folding model, assuming the ESM-2 vocabulary!'''				)
                            SCREAMING_SNAKE_CASE_							:				Tuple		=get_default_vocab_list()
                     else:
                            SCREAMING_SNAKE_CASE_							:				Optional[Any]		=vocab_list
              else:
                     SCREAMING_SNAKE_CASE_							:				List[str]		=None
                     SCREAMING_SNAKE_CASE_							:				Optional[int]		=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 	_snake_case				(    self				)						->    List[Any]:
              SCREAMING_SNAKE_CASE_							:				str		=super().to_dict()
              if isinstance(self.esmfold_config						,       __A				):
                     SCREAMING_SNAKE_CASE_							:				Optional[Any]		=self.esmfold_config.to_dict()
              return output






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

       __lowerCamelCase				       =						True
       __lowerCamelCase				       =						False

       __lowerCamelCase				       =						1_2_8
       __lowerCamelCase				       =						None


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





       def 	_snake_case				(    self				)						->    List[Any]:
              SCREAMING_SNAKE_CASE_							:				int		=asdict(self				)
              SCREAMING_SNAKE_CASE_							:				Tuple		=self.trunk.to_dict()
              return output






@dataclass
class 			lowercase_		:
       __lowerCamelCase				       =						4_8
       __lowerCamelCase				       =						1_0_2_4
       __lowerCamelCase				       =						1_2_8
       __lowerCamelCase				       =						3_2
       __lowerCamelCase				       =						3_2
       __lowerCamelCase				       =						3_2
       __lowerCamelCase				       =						0
       __lowerCamelCase				       =						0
       __lowerCamelCase				       =						False
       __lowerCamelCase				       =						4
       __lowerCamelCase				       =						1_2_8
       __lowerCamelCase				       =						None


       def 	_snake_case				(    self				)						->    int:
              if self.structure_module is None:
                     SCREAMING_SNAKE_CASE_							:				Dict		=StructureModuleConfig()
              elif isinstance(self.structure_module						,       __A				):
                     SCREAMING_SNAKE_CASE_							:				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}.'				)

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






@dataclass
class 			lowercase_		:
       __lowerCamelCase				       =						3_8_4
       __lowerCamelCase				       =						1_2_8
       __lowerCamelCase				       =						1_6
       __lowerCamelCase				       =						1_2_8
       __lowerCamelCase				       =						1_2
       __lowerCamelCase				       =						4
       __lowerCamelCase				       =						8
       __lowerCamelCase				       =						0.1
       __lowerCamelCase				       =						8
       __lowerCamelCase				       =						1
       __lowerCamelCase				       =						2
       __lowerCamelCase				       =						7
       __lowerCamelCase				       =						1_0
       __lowerCamelCase				       =						1E-8
       __lowerCamelCase				       =						1E5


       def 	_snake_case				(    self				)						->    str:
              return asdict(self				)






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