






import inspect
import re

from transformers.utils import direct_transformers_import


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_config_docstrings.py
lowerCamelCase      :				Any							='''src/transformers'''


# This is to make sure the transformers module imported is the one in the repo.
lowerCamelCase      :				str							=direct_transformers_import(PATH_TO_TRANSFORMERS)

lowerCamelCase      :				Tuple							=transformers.models.auto.configuration_auto.CONFIG_MAPPING

# Regex pattern used to find the checkpoint mentioned in the docstring of `config_class`.
# For example, `[bert-base-uncased](https://huggingface.co/bert-base-uncased)`
lowerCamelCase      :				List[Any]							=re.compile(R'''\[(.+?)\]\((https://huggingface\.co/.+?)\)''')


lowerCamelCase      :				List[str]							={
    '''DecisionTransformerConfig''',
    '''EncoderDecoderConfig''',
    '''MusicgenConfig''',
    '''RagConfig''',
    '''SpeechEncoderDecoderConfig''',
    '''TimmBackboneConfig''',
    '''VisionEncoderDecoderConfig''',
    '''VisionTextDualEncoderConfig''',
    '''LlamaConfig''',
}







def 						SCREAMING_SNAKE_CASE				(   __lowerCAmelCase     )					->      List[Any]:
     UpperCamelCase__     :  List[Any]										=    None

     # source code of `config_class`
     UpperCamelCase__     :  Optional[int]										=    inspect.getsource(UpperCAmelCase_     )
     UpperCamelCase__     :  Dict										=    _re_checkpoint.findall(UpperCAmelCase_     )

     # Each `checkpoint` is a tuple of a checkpoint name and a checkpoint link.
     # For example, `('bert-base-uncased', 'https://huggingface.co/bert-base-uncased')`
     for ckpt_name, ckpt_link in checkpoints:
          # allow the link to end with `/`
          if ckpt_link.endswith("/"     ):
               UpperCamelCase__     :  Optional[int]										=    ckpt_link[:-1]

          # verify the checkpoint name corresponds to the checkpoint link
          UpperCamelCase__     :  str										=    f'https://huggingface.co/{ckpt_name}'
          if ckpt_link == ckpt_link_from_name:
               UpperCamelCase__     :  Optional[Any]										=    ckpt_name
               break

     return checkpoint







def 						SCREAMING_SNAKE_CASE				(   )					->      str:
     UpperCamelCase__     :  Optional[Any]										=    []

     for config_class in list(CONFIG_MAPPING.values()     ):
          # Skip deprecated models
          if "models.deprecated" in config_class.__module__:
               continue
          UpperCamelCase__     :  str										=    get_checkpoint_from_config_class(UpperCAmelCase_     )

          UpperCamelCase__     :  str										=    config_class.__name__
          if checkpoint is None and name not in CONFIG_CLASSES_TO_IGNORE_FOR_DOCSTRING_CHECKPOINT_CHECK:
               configs_without_checkpoint.append(UpperCAmelCase_     )

     if len(UpperCAmelCase_     ) > 0:
          UpperCamelCase__     :  int										=    '''\n'''.join(sorted(UpperCAmelCase_     )     )
          raise ValueError(f'The following configurations don\'t contain any valid checkpoint:\n{message}'     )


if __name__ == "__main__":
 check_config_docstrings_have_checkpoints()

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>",
       )
