code: 
  
  
  
  
  
  '''simple docstring'''
  
  from collections import OrderedDict
  from typing import Mapping
  
  from ...configuration_utils import PretrainedConfig
  from ...onnx import OnnxConfig
  from ...utils import logging
  
  
  __lowerCAmelCase							:			Optional[Any]				=logging.get_logger(__name__)
  
  __lowerCAmelCase							:			Union[str, Any]				={
      "nghuyong/ernie-1.0-base-zh": "https://huggingface.co/nghuyong/ernie-1.0-base-zh/resolve/main/config.json",
      "nghuyong/ernie-2.0-base-en": "https://huggingface.co/nghuyong/ernie-2.0-base-en/resolve/main/config.json",
      "nghuyong/ernie-2.0-large-en": "https://huggingface.co/nghuyong/ernie-2.0-large-en/resolve/main/config.json",
      "nghuyong/ernie-3.0-base-zh": "https://huggingface.co/nghuyong/ernie-3.0-base-zh/resolve/main/config.json",
      "nghuyong/ernie-3.0-medium-zh": "https://huggingface.co/nghuyong/ernie-3.0-medium-zh/resolve/main/config.json",
      "nghuyong/ernie-3.0-mini-zh": "https://huggingface.co/nghuyong/ernie-3.0-mini-zh/resolve/main/config.json",
      "nghuyong/ernie-3.0-micro-zh": "https://huggingface.co/nghuyong/ernie-3.0-micro-zh/resolve/main/config.json",
      "nghuyong/ernie-3.0-nano-zh": "https://huggingface.co/nghuyong/ernie-3.0-nano-zh/resolve/main/config.json",
      "nghuyong/ernie-gram-zh": "https://huggingface.co/nghuyong/ernie-gram-zh/resolve/main/config.json",
      "nghuyong/ernie-health-zh": "https://huggingface.co/nghuyong/ernie-health-zh/resolve/main/config.json",
  }
  
  
  
  
  
  
  class      UpperCAmelCase			( UpperCamelCase__       ):
   __lowercase     	=       """ernie"""
   def __init__(       self   :str		, lowercase_   :Any=3_05_22		, lowercase_   :int=7_68		, lowercase_   :Union[str, Any]=12		, lowercase_   :Optional[int]=12		, lowercase_   :Tuple=30_72		, lowercase_   :int="gelu"		, lowercase_   :Any=0.1		, lowercase_   :Optional[Any]=0.1		, lowercase_   :Optional[int]=5_12		, lowercase_   :Union[str, Any]=2		, lowercase_   :Dict=3		, lowercase_   :List[Any]=False		, lowercase_   :int=0.0_2		, lowercase_   :int=1E-12		, lowercase_   :Optional[int]=0		, lowercase_   :Optional[int]="absolute"		, lowercase_   :str=True		, lowercase_   :List[Any]=None		, **lowercase_   :Tuple		, )->							Union[str, Any]:
       super().__init__(pad_token_id=lowercase_		, **lowercase_							)
  
       A__       =    vocab_size
       A__       =    hidden_size
       A__       =    num_hidden_layers
       A__       =    num_attention_heads
       A__       =    hidden_act
       A__       =    intermediate_size
       A__       =    hidden_dropout_prob
       A__       =    attention_probs_dropout_prob
       A__       =    max_position_embeddings
       A__       =    type_vocab_size
       A__       =    task_type_vocab_size
       A__       =    use_task_id
       A__       =    initializer_range
       A__       =    layer_norm_eps
       A__       =    position_embedding_type
       A__       =    use_cache
       A__       =    classifier_dropout
  
  
  
  
  
  
  class      UpperCAmelCase			( UpperCamelCase__       ):
   @property
   def   UpperCAmelCase_							(       self   :List[str]							)->							Mapping[str, Mapping[int, str]]:
       if self.task == "multiple-choice":
           A__       =    {0: "batch", 1: "choice", 2: "sequence"}
       else:
           A__       =    {0: "batch", 1: "sequence"}
       return OrderedDict(
           [
               ("input_ids", dynamic_axis),
               ("attention_mask", dynamic_axis),
               ("token_type_ids", dynamic_axis),
               ("task_type_ids", dynamic_axis),
           ]							)
  
  
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  import os
  import tempfile
  import unittest
  from typing import List
  
  from transformers.models.esm.tokenization_esm import VOCAB_FILES_NAMES, EsmTokenizer
  from transformers.testing_utils import require_tokenizers
  from transformers.tokenization_utils import PreTrainedTokenizer
  from transformers.tokenization_utils_base import PreTrainedTokenizerBase
  
  
  
  
  
  
  @require_tokenizers
  class      UpperCAmelCase			( unittest.TestCase       ):
   __lowercase     	=       EsmTokenizer
   def   UpperCAmelCase_							(       self   :Any							)->							int:
       super().setUp()
       A__       =    tempfile.mkdtemp()
       # fmt: off
       A__       =    ["<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>"]  # noqa: E501
       # fmt: on
       A__       =    os.path.join(self.tmpdirname		, VOCAB_FILES_NAMES["vocab_file"]							)
       with open(self.vocab_file		, "w"		, encoding="utf-8"							) as vocab_writer:
           vocab_writer.write("".join([x + "\n" for x in vocab_tokens]							)							)
   def   UpperCAmelCase_							(       self   :Any		, **lowercase_   :int							)->							List[PreTrainedTokenizerBase]:
       return [self.get_tokenizer(**lowercase_							)]
   def   UpperCAmelCase_							(       self   :Any		, **lowercase_   :Dict							)->							PreTrainedTokenizer:
       return self.tokenizer_class.from_pretrained(self.tmpdirname		, **lowercase_							)
   def   UpperCAmelCase_							(       self   :int							)->							Dict:
       A__       =    self.tokenizer_class(self.vocab_file							)
  
       A__       =    tokenizer.tokenize("LAGVS"							)
       self.assertListEqual(lowercase_		, ["L", "A", "G", "V", "S"]							)
       self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase_							)		, [4, 5, 6, 7, 8]							)
   def   UpperCAmelCase_							(       self   :Tuple							)->							Tuple:
       A__       =    self.tokenizer_class(self.vocab_file							)
  
       A__       =    "LAGVS"
       self.assertListEqual(tokenizer.encode(lowercase_							)		, [0, 4, 5, 6, 7, 8, 2]							)
   def   UpperCAmelCase_							(       self   :Any							)->							Tuple:
       A__       =    self.tokenizer_class(self.vocab_file							)
  
       A__       =    ["LAGVS", "WCB"]
       A__       =    tokenizer(lowercase_		, padding=lowercase_							)["input_ids"]
  
       self.assertListEqual(lowercase_		, [[0, 4, 5, 6, 7, 8, 2], [0, 22, 23, 25, 2]]							)
   def   UpperCAmelCase_							(       self   :str							)->							Any:
       A__       =    self.tokenizer_class(self.vocab_file							)
  
       A__       =    ["LAGVS", "WCB"]
       A__       =    tokenizer(lowercase_		, padding=lowercase_							)["input_ids"]
  
       self.assertListEqual(lowercase_		, [[0, 4, 5, 6, 7, 8, 2], [0, 22, 23, 25, 2, 1, 1]]							)
  
  
  
   def   UpperCAmelCase_							(       self   :Optional[Any]							)->							List[str]:
       A__       =    self.get_tokenizers(fast=lowercase_							)
       for tokenizer in tokenizers:
           with self.subTest(F"{tokenizer.__class__.__name__}"							):
               A__       =    "<unk>"
               A__       =    "<mask>"
  
               A__       =    tokenizer.tokenize(lowercase_							)
               A__       =    tokenizer.tokenize(lowercase_							)
  
               self.assertEqual(len(lowercase_							)		, 1							)
               self.assertEqual(len(lowercase_							)		, 1							)
               self.assertEqual(token_a[0]		, lowercase_							)
               self.assertEqual(token_a[0]		, lowercase_							)
  
  
  
  