code: 
  
  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    __A				(							unittest.TestCase ):
      lowerCAmelCase_							:		Union[str, Any]						=							EsmTokenizer
  
  
  
  
  
  
      def 	lowercase__ (	self			:    List[Any]    ):
          super().setUp()
          lowerCAmelCase				:			str    			=      tempfile.mkdtemp()
          # fmt: off
          lowerCAmelCase				:			List[str]    			=      ["<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
          lowerCAmelCase				:			Union[str, Any]    			=      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 	lowercase__ (	self			:    str    ,				**UpperCAmelCase_			:    Dict    ):
          return [self.get_tokenizer(**UpperCAmelCase_    )]
  
  
  
  
  
  
      def 	lowercase__ (	self			:    Dict    ,				**UpperCAmelCase_			:    List[Any]    ):
          return self.tokenizer_class.from_pretrained(self.tmpdirname    ,				**UpperCAmelCase_    )
  
  
  
  
  
  
      def 	lowercase__ (	self			:    Any    ):
          lowerCAmelCase				:			Optional[Any]    			=      self.tokenizer_class(self.vocab_file    )
  
          lowerCAmelCase				:			Tuple    			=      tokenizer.tokenize('LAGVS'    )
          self.assertListEqual(UpperCAmelCase_    ,				['L', 'A', 'G', 'V', 'S']    )
          self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCAmelCase_    )    ,				[4, 5, 6, 7, 8]    )
  
  
  
  
  
  
      def 	lowercase__ (	self			:    Dict    ):
          lowerCAmelCase				:			Union[str, Any]    			=      self.tokenizer_class(self.vocab_file    )
  
          lowerCAmelCase				:			int    			=      'LAGVS'
          self.assertListEqual(tokenizer.encode(UpperCAmelCase_    )    ,				[0, 4, 5, 6, 7, 8, 2]    )
  
  
  
  
  
  
      def 	lowercase__ (	self			:    Tuple    ):
          lowerCAmelCase				:			Any    			=      self.tokenizer_class(self.vocab_file    )
  
          lowerCAmelCase				:			Optional[Any]    			=      ['LAGVS', 'WCB']
          lowerCAmelCase				:			List[Any]    			=      tokenizer(UpperCAmelCase_    ,				padding=UpperCAmelCase_    )['input_ids']
  
          self.assertListEqual(UpperCAmelCase_    ,				[[0, 4, 5, 6, 7, 8, 2], [0, 22, 23, 25, 2]]    )
  
  
  
  
  
  
      def 	lowercase__ (	self			:    Any    ):
          lowerCAmelCase				:			Tuple    			=      self.tokenizer_class(self.vocab_file    )
  
          lowerCAmelCase				:			Optional[Any]    			=      ['LAGVS', 'WCB']
          lowerCAmelCase				:			Tuple    			=      tokenizer(UpperCAmelCase_    ,				padding=UpperCAmelCase_    )['input_ids']
  
          self.assertListEqual(UpperCAmelCase_    ,				[[0, 4, 5, 6, 7, 8, 2], [0, 22, 23, 25, 2, 1, 1]]    )
  
  
  
  
  
  
      def 	lowercase__ (	self			:    Any    ):
          lowerCAmelCase				:			Union[str, Any]    			=      self.get_tokenizers(fast=UpperCAmelCase_    )
          for tokenizer in tokenizers:
              with self.subTest(f"{tokenizer.__class__.__name__}"    ):
                  lowerCAmelCase				:			int    			=      '<unk>'
                  lowerCAmelCase				:			Any    			=      '<mask>'
  
                  lowerCAmelCase				:			Optional[Any]    			=      tokenizer.tokenize(UpperCAmelCase_    )
                  lowerCAmelCase				:			Dict    			=      tokenizer.tokenize(UpperCAmelCase_    )
  
                  self.assertEqual(len(UpperCAmelCase_    )    ,				1    )
                  self.assertEqual(len(UpperCAmelCase_    )    ,				1    )
                  self.assertEqual(token_a[0]    ,				UpperCAmelCase_    )
                  self.assertEqual(token_a[0]    ,				UpperCAmelCase_    )
  
  
  
  
  
  
style_context: 
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
  
  
  __A   :     List[Any]      =			{'''configuration_umt5''': ['''UMT5Config''', '''UMT5OnnxConfig''']}
  
  
  try:
   if not is_torch_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   __A   :     Tuple      =			[
       '''UMT5EncoderModel''',
       '''UMT5ForConditionalGeneration''',
       '''UMT5ForQuestionAnswering''',
       '''UMT5Model''',
       '''UMT5PreTrainedModel''',
   ]
  
  if TYPE_CHECKING:
   from .configuration_umta import UMTaConfig, UMTaOnnxConfig
  
   try:
    if not is_torch_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_umta import (
        UMTaEncoderModel,
        UMTaForConditionalGeneration,
        UMTaForQuestionAnswering,
        UMTaModel,
        UMTaPreTrainedModel,
    )
  else:
   import sys
  
   __A   :     Any      =			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  
  
  
  
  