





'''simple docstring'''

import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


a   	=    logging.get_logger(__name__)


a   	=    {"vocab_file": "vocab.json", "merges_file": "merges.txt"}

# See all BART models at https://huggingface.co/models?filter=bart
a   	=    {
    "vocab_file": {
        "facebook/bart-base": "https://huggingface.co/facebook/bart-base/resolve/main/vocab.json",
        "facebook/bart-large": "https://huggingface.co/facebook/bart-large/resolve/main/vocab.json",
        "facebook/bart-large-mnli": "https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json",
        "facebook/bart-large-cnn": "https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json",
        "facebook/bart-large-xsum": "https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json",
        "yjernite/bart_eli5": "https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json",
    },
    "merges_file": {
        "facebook/bart-base": "https://huggingface.co/facebook/bart-base/resolve/main/merges.txt",
        "facebook/bart-large": "https://huggingface.co/facebook/bart-large/resolve/main/merges.txt",
        "facebook/bart-large-mnli": "https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt",
        "facebook/bart-large-cnn": "https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt",
        "facebook/bart-large-xsum": "https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt",
        "yjernite/bart_eli5": "https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt",
    },
}

a   	=    {
    "facebook/bart-base": 1024,
    "facebook/bart-large": 1024,
    "facebook/bart-large-mnli": 1024,
    "facebook/bart-large-cnn": 1024,
    "facebook/bart-large-xsum": 1024,
    "yjernite/bart_eli5": 1024,
}

@lru_cache()
def     __magic_name__							(				)    ->       Any:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							(
       list(range(ord("""!"""   )				,						ord("""~"""   ) + 1   )   ) + list(range(ord("""¡"""   )				,						ord("""¬"""   ) + 1   )   ) + list(range(ord("""®"""   )				,						ord("""ÿ"""   ) + 1   )   )
   )
   __SCREAMING_SNAKE_CASE   				=							bs[:]
   __SCREAMING_SNAKE_CASE   				=							0
   for b in range(2**8   ):
      if b not in bs:
         bs.append(__UpperCAmelCase   )
         cs.append(2**8 + n   )
         n += 1
   __SCREAMING_SNAKE_CASE   				=							[chr(__UpperCAmelCase   ) for n in cs]
   return dict(zip(__UpperCAmelCase				,						__UpperCAmelCase   )   )

def     __magic_name__							(				__UpperCAmelCase   )    ->       List[str]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							set()
   __SCREAMING_SNAKE_CASE   				=							word[0]
   for char in word[1:]:
      pairs.add((prev_char, char)   )
      __SCREAMING_SNAKE_CASE   				=							char
   return pairs







class __a			( _snake_case      ):
   __UpperCamelCase :			List[Any]						   =						VOCAB_FILES_NAMES
   __UpperCamelCase :			Any						   =						PRETRAINED_VOCAB_FILES_MAP
   __UpperCamelCase :			int						   =						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   __UpperCamelCase :			List[Any]						   =						['input_ids', 'attention_mask']





   def __init__(       self					:      Any					,lowerCamelCase					:      Tuple					,lowerCamelCase					:      Union[str, Any]					,lowerCamelCase					:      Union[str, Any]="replace"					,lowerCamelCase					:      Optional[Any]="<s>"					,lowerCamelCase					:      Union[str, Any]="</s>"					,lowerCamelCase					:      List[str]="</s>"					,lowerCamelCase					:      List[Any]="<s>"					,lowerCamelCase					:      Tuple="<unk>"					,lowerCamelCase					:      Union[str, Any]="<pad>"					,lowerCamelCase					:      Dict="<mask>"					,lowerCamelCase					:      Union[str, Any]=False					,**lowerCamelCase					:      Any					,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							AddedToken(lowerCamelCase					,lstrip=lowerCamelCase					,rstrip=lowerCamelCase     ) if isinstance(lowerCamelCase					,lowerCamelCase     ) else bos_token
      __SCREAMING_SNAKE_CASE   				=							AddedToken(lowerCamelCase					,lstrip=lowerCamelCase					,rstrip=lowerCamelCase     ) if isinstance(lowerCamelCase					,lowerCamelCase     ) else eos_token
      __SCREAMING_SNAKE_CASE   				=							AddedToken(lowerCamelCase					,lstrip=lowerCamelCase					,rstrip=lowerCamelCase     ) if isinstance(lowerCamelCase					,lowerCamelCase     ) else sep_token
      __SCREAMING_SNAKE_CASE   				=							AddedToken(lowerCamelCase					,lstrip=lowerCamelCase					,rstrip=lowerCamelCase     ) if isinstance(lowerCamelCase					,lowerCamelCase     ) else cls_token
      __SCREAMING_SNAKE_CASE   				=							AddedToken(lowerCamelCase					,lstrip=lowerCamelCase					,rstrip=lowerCamelCase     ) if isinstance(lowerCamelCase					,lowerCamelCase     ) else unk_token
      __SCREAMING_SNAKE_CASE   				=							AddedToken(lowerCamelCase					,lstrip=lowerCamelCase					,rstrip=lowerCamelCase     ) if isinstance(lowerCamelCase					,lowerCamelCase     ) else pad_token

      # Mask token behave like a normal word, i.e. include the space before it
      __SCREAMING_SNAKE_CASE   				=							AddedToken(lowerCamelCase					,lstrip=lowerCamelCase					,rstrip=lowerCamelCase     ) if isinstance(lowerCamelCase					,lowerCamelCase     ) else mask_token

      super().__init__(
          errors=lowerCamelCase					,bos_token=lowerCamelCase					,eos_token=lowerCamelCase					,unk_token=lowerCamelCase					,sep_token=lowerCamelCase					,cls_token=lowerCamelCase					,pad_token=lowerCamelCase					,mask_token=lowerCamelCase					,add_prefix_space=lowerCamelCase					,**lowerCamelCase					,)

      with open(lowerCamelCase					,encoding="""utf-8"""     ) as vocab_handle:
         __SCREAMING_SNAKE_CASE   				=							json.load(lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							{v: k for k, v in self.encoder.items()}
      __SCREAMING_SNAKE_CASE   				=							errors  # how to handle errors in decoding
      __SCREAMING_SNAKE_CASE   				=							bytes_to_unicode()
      __SCREAMING_SNAKE_CASE   				=							{v: k for k, v in self.byte_encoder.items()}
      with open(lowerCamelCase					,encoding="""utf-8"""     ) as merges_handle:
         __SCREAMING_SNAKE_CASE   				=							merges_handle.read().split("""\n"""     )[1:-1]
      __SCREAMING_SNAKE_CASE   				=							[tuple(merge.split()     ) for merge in bpe_merges]
      __SCREAMING_SNAKE_CASE   				=							dict(zip(lowerCamelCase					,range(len(lowerCamelCase     )     )     )     )
      __SCREAMING_SNAKE_CASE   				=							{}
      __SCREAMING_SNAKE_CASE   				=							add_prefix_space

      # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
      __SCREAMING_SNAKE_CASE   				=							re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""     )





   @property
   def   UpperCAmelCase__  (       self					:      Any     ):

      '''simple docstring'''

      return len(self.encoder     )





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

      '''simple docstring'''

      return dict(self.encoder					,**self.added_tokens_encoder     )





   def   UpperCAmelCase__  (       self					:      Any					,lowerCamelCase					:      List[str]     ):

      '''simple docstring'''

      if token in self.cache:
         return self.cache[token]
      __SCREAMING_SNAKE_CASE   				=							tuple(lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							get_pairs(lowerCamelCase     )

      if not pairs:
         return token

      while True:
         __SCREAMING_SNAKE_CASE   				=							min(lowerCamelCase					,key=lambda lowerCamelCase     : self.bpe_ranks.get(lowerCamelCase					,float("""inf"""     )     )     )
         if bigram not in self.bpe_ranks:
            break
         __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							bigram
         __SCREAMING_SNAKE_CASE   				=							[]
         __SCREAMING_SNAKE_CASE   				=							0
         while i < len(lowerCamelCase     ):
            try:
               __SCREAMING_SNAKE_CASE   				=							word.index(lowerCamelCase					,lowerCamelCase     )
            except ValueError:
               new_word.extend(word[i:]     )
               break
            else:
               new_word.extend(word[i:j]     )
               __SCREAMING_SNAKE_CASE   				=							j

            if word[i] == first and i < len(lowerCamelCase     ) - 1 and word[i + 1] == second:
               new_word.append(first + second     )
               i += 2
            else:
               new_word.append(word[i]     )
               i += 1
         __SCREAMING_SNAKE_CASE   				=							tuple(lowerCamelCase     )
         __SCREAMING_SNAKE_CASE   				=							new_word
         if len(lowerCamelCase     ) == 1:
            break
         else:
            __SCREAMING_SNAKE_CASE   				=							get_pairs(lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							""" """.join(lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							word
      return word





   def   UpperCAmelCase__  (       self					:      str					,lowerCamelCase					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							[]
      for token in re.findall(self.pat					,lowerCamelCase     ):
         __SCREAMING_SNAKE_CASE   				=							"""""".join(
             self.byte_encoder[b] for b in token.encode("""utf-8"""     )     )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
         bpe_tokens.extend(bpe_token for bpe_token in self.bpe(lowerCamelCase     ).split(""" """     )     )
      return bpe_tokens





   def   UpperCAmelCase__  (       self					:      int					,lowerCamelCase					:      Tuple     ):

      '''simple docstring'''

      return self.encoder.get(lowerCamelCase					,self.encoder.get(self.unk_token     )     )





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

      '''simple docstring'''

      return self.decoder.get(lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Optional[int]					,lowerCamelCase					:      List[str]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							"""""".join(lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							bytearray([self.byte_decoder[c] for c in text]     ).decode("""utf-8"""					,errors=self.errors     )
      return text





   def   UpperCAmelCase__  (       self					:      Tuple					,lowerCamelCase					:      str					,lowerCamelCase					:      Optional[str] = None     ):

      '''simple docstring'''

      if not os.path.isdir(lowerCamelCase     ):
         logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""     )
         return
      __SCREAMING_SNAKE_CASE   				=							os.path.join(
          lowerCamelCase					,(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]     )
      __SCREAMING_SNAKE_CASE   				=							os.path.join(
          lowerCamelCase					,(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""]     )

      with open(lowerCamelCase					,"""w"""					,encoding="""utf-8"""     ) as f:
         f.write(json.dumps(self.encoder					,indent=2					,sort_keys=lowerCamelCase					,ensure_ascii=lowerCamelCase     ) + """\n"""     )

      __SCREAMING_SNAKE_CASE   				=							0
      with open(lowerCamelCase					,"""w"""					,encoding="""utf-8"""     ) as writer:
         writer.write("""#version: 0.2\n"""     )
         for bpe_tokens, token_index in sorted(self.bpe_ranks.items()					,key=lambda lowerCamelCase     : kv[1]     ):
            if index != token_index:
               logger.warning(
                   f"""Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."""
                   """ Please check that the tokenizer is not corrupted!"""     )
               __SCREAMING_SNAKE_CASE   				=							token_index
            writer.write(""" """.join(lowerCamelCase     ) + """\n"""     )
            index += 1

      return vocab_file, merge_file





   def   UpperCAmelCase__  (       self					:      Optional[int]					,lowerCamelCase					:      List[int]					,lowerCamelCase					:      Optional[List[int]] = None     ):

      '''simple docstring'''

      if token_ids_a is None:
         return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
      __SCREAMING_SNAKE_CASE   				=							[self.cls_token_id]
      __SCREAMING_SNAKE_CASE   				=							[self.sep_token_id]
      return cls + token_ids_a + sep + sep + token_ids_a + sep





   def   UpperCAmelCase__  (       self					:      List[Any]					,lowerCamelCase					:      List[int]					,lowerCamelCase					:      Optional[List[int]] = None					,lowerCamelCase					:      bool = False     ):

      '''simple docstring'''

      if already_has_special_tokens:
         return super().get_special_tokens_mask(
             token_ids_a=lowerCamelCase					,token_ids_a=lowerCamelCase					,already_has_special_tokens=lowerCamelCase     )

      if token_ids_a is None:
         return [1] + ([0] * len(lowerCamelCase     )) + [1]
      return [1] + ([0] * len(lowerCamelCase     )) + [1, 1] + ([0] * len(lowerCamelCase     )) + [1]





   def   UpperCAmelCase__  (       self					:      List[str]					,lowerCamelCase					:      List[int]					,lowerCamelCase					:      Optional[List[int]] = None     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							[self.sep_token_id]
      __SCREAMING_SNAKE_CASE   				=							[self.cls_token_id]

      if token_ids_a is None:
         return len(cls + token_ids_a + sep     ) * [0]
      return len(cls + token_ids_a + sep + sep + token_ids_a + sep     ) * [0]





   def   UpperCAmelCase__  (       self					:      Tuple					,lowerCamelCase					:      List[str]					,lowerCamelCase					:      str=False					,**lowerCamelCase					:      List[str]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							kwargs.pop("""add_prefix_space"""					,self.add_prefix_space     )
      if (is_split_into_words or add_prefix_space) and (len(lowerCamelCase     ) > 0 and not text[0].isspace()):
         __SCREAMING_SNAKE_CASE   				=							""" """ + text
      return (text, kwargs)












'''simple docstring'''

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 __a			( _snake_case      ):
   __UpperCamelCase :			str						   =						'esm'





   def __init__(       self					:      Tuple					,lowerCamelCase					:      List[Any]=None					,lowerCamelCase					:      str=None					,lowerCamelCase					:      Any=None					,lowerCamelCase					:      Union[str, Any]=768					,lowerCamelCase					:      Tuple=12					,lowerCamelCase					:      int=12					,lowerCamelCase					:      Optional[int]=3072					,lowerCamelCase					:      List[Any]=0.1					,lowerCamelCase					:      Optional[int]=0.1					,lowerCamelCase					:      Any=1026					,lowerCamelCase					:      str=0.02					,lowerCamelCase					:      int=1E-1_2					,lowerCamelCase					:      Union[str, Any]="absolute"					,lowerCamelCase					:      Optional[Any]=True					,lowerCamelCase					:      str=None					,lowerCamelCase					:      Optional[int]=False					,lowerCamelCase					:      int=False					,lowerCamelCase					:      Union[str, Any]=None					,lowerCamelCase					:      Any=None					,**lowerCamelCase					:      Any					,):

      '''simple docstring'''

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

      __SCREAMING_SNAKE_CASE   				=							vocab_size
      __SCREAMING_SNAKE_CASE   				=							hidden_size
      __SCREAMING_SNAKE_CASE   				=							num_hidden_layers
      __SCREAMING_SNAKE_CASE   				=							num_attention_heads
      __SCREAMING_SNAKE_CASE   				=							intermediate_size
      __SCREAMING_SNAKE_CASE   				=							hidden_dropout_prob
      __SCREAMING_SNAKE_CASE   				=							attention_probs_dropout_prob
      __SCREAMING_SNAKE_CASE   				=							max_position_embeddings
      __SCREAMING_SNAKE_CASE   				=							initializer_range
      __SCREAMING_SNAKE_CASE   				=							layer_norm_eps
      __SCREAMING_SNAKE_CASE   				=							position_embedding_type
      __SCREAMING_SNAKE_CASE   				=							use_cache
      __SCREAMING_SNAKE_CASE   				=							emb_layer_norm_before
      __SCREAMING_SNAKE_CASE   				=							token_dropout
      __SCREAMING_SNAKE_CASE   				=							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   				=							EsmFoldConfig()
         elif isinstance(lowerCamelCase					,lowerCamelCase     ):
            __SCREAMING_SNAKE_CASE   				=							EsmFoldConfig(**lowerCamelCase     )
         __SCREAMING_SNAKE_CASE   				=							esmfold_config
         if vocab_list is None:
            logger.warning("""No vocab_list supplied for folding model, assuming the ESM-2 vocabulary!"""     )
            __SCREAMING_SNAKE_CASE   				=							get_default_vocab_list()
         else:
            __SCREAMING_SNAKE_CASE   				=							vocab_list
      else:
         __SCREAMING_SNAKE_CASE   				=							None
         __SCREAMING_SNAKE_CASE   				=							None
      if self.esmfold_config is not None and getattr(self.esmfold_config					,"""use_esm_attn_map"""					,lowerCamelCase     ):
         raise ValueError("""The HuggingFace port of ESMFold does not support use_esm_attn_map at this time!"""     )





   def   UpperCAmelCase__  (       self					:      List[str]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							super().to_dict()
      if isinstance(self.esmfold_config					,lowerCamelCase     ):
         __SCREAMING_SNAKE_CASE   				=							self.esmfold_config.to_dict()
      return output







@dataclass
class __a			:
   __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					:      List[str]     ):

      '''simple docstring'''

      if self.trunk is None:
         __SCREAMING_SNAKE_CASE   				=							TrunkConfig()
      elif isinstance(self.trunk					,lowerCamelCase     ):
         __SCREAMING_SNAKE_CASE   				=							TrunkConfig(**self.trunk     )





   def   UpperCAmelCase__  (       self					:      Optional[int]     ):

      '''simple docstring'''

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







@dataclass
class __a			:
   __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					:      List[Any]     ):

      '''simple docstring'''

      if self.structure_module is None:
         __SCREAMING_SNAKE_CASE   				=							StructureModuleConfig()
      elif isinstance(self.structure_module					,lowerCamelCase     ):
         __SCREAMING_SNAKE_CASE   				=							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   				=							self.sequence_state_dim // self.sequence_head_width
      __SCREAMING_SNAKE_CASE   				=							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					:      str     ):

      '''simple docstring'''

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







@dataclass
class __a			:
   __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[Any]     ):

      '''simple docstring'''

      return asdict(self     )





def     __magic_name__							(				)    ->       Dict:

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





