code: 
  
  
  
  
  '''simple docstring'''
  
  import concurrent.futures
  import json
  import os
  import shutil
  import tempfile
  import unittest
  
  from transformers import AutoTokenizer, PreTrainedTokenizerFast
  from transformers.testing_utils import require_tokenizers
  
  from ..test_tokenization_common import TokenizerTesterMixin
  
  
  @require_tokenizers
  class   a_  (__UpperCAmelCase							,			unittest.TestCase    ):
         __lowerCAmelCase    :				List[str]    =      PreTrainedTokenizerFast
         __lowerCAmelCase    :				Tuple    =      False
         __lowerCAmelCase    :				Dict    =      True
         __lowerCAmelCase    :				Any    =      """tokenizer_file"""
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  Union[str, Any]   				=					False  # because we don't have pretrained_vocab_files_map
           super().setUp()
           _lowerCAmelCase       :  Union[str, Any]   				=					True
  
           _lowerCAmelCase       :  List[str]   				=					["""robot-test/dummy-tokenizer-fast""", """robot-test/dummy-tokenizer-wordlevel"""]
           _lowerCAmelCase       :  Dict   				=					"""SaulLu/dummy-tokenizer-bytelevel-bpe"""
  
           # Inclusion of 2 tokenizers to test different types of models (Unigram and WordLevel for the moment)
           _lowerCAmelCase       :  Tuple   				=					[(PreTrainedTokenizerFast, model_path, {}) for model_path in model_paths]
  
           _lowerCAmelCase       :  Optional[int]   				=					PreTrainedTokenizerFast.from_pretrained(model_paths[0]  )
           tokenizer.save_pretrained(self.tmpdirname  )
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           pass
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           pass
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           pass
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           pass
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  List[Any]   				=					self.tmpdirname
           # Here we want to test the 2 available tokenizers that use 2 different types of models: Unigram and WordLevel.
           for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'  ):
               try:
                 _lowerCAmelCase       :  List[Any]   				=					tempfile.mkdtemp()
                 _lowerCAmelCase       :  Optional[Any]   				=					self.rust_tokenizer_class.from_pretrained(lowerCamelCase__   ,   **lowerCamelCase__  )
  
                 tokenizer.save_pretrained(self.tmpdirname  )
                 super().test_training_new_tokenizer()
               finally:
                 # Even if the test fails, we must be sure that the folder is deleted and that the default tokenizer
                 # is restored
                 shutil.rmtree(self.tmpdirname  )
                 _lowerCAmelCase       :  str   				=					tmpdirname_orig
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  Dict   				=					self.tmpdirname
           # Here we want to test the 2 available tokenizers that use 2 different types of models: Unigram and WordLevel.
           for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'  ):
               try:
                 _lowerCAmelCase       :  Optional[int]   				=					tempfile.mkdtemp()
                 _lowerCAmelCase       :  List[str]   				=					self.rust_tokenizer_class.from_pretrained(lowerCamelCase__   ,   **lowerCamelCase__  )
  
                 tokenizer.save_pretrained(self.tmpdirname  )
                 super().test_training_new_tokenizer_with_special_tokens_change()
               finally:
                 # Even if the test fails, we must be sure that the folder is deleted and that the default tokenizer
                 # is restored
                 shutil.rmtree(self.tmpdirname  )
                 _lowerCAmelCase       :  Any   				=					tmpdirname_orig
  
  
  
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  Dict   				=					self.rust_tokenizer_class.from_pretrained(self.bytelevel_bpe_model_name  )
  
           _lowerCAmelCase       :  Union[str, Any]   				=					("""a""" for _ in range(1_0_0_0  ))
           _lowerCAmelCase       :  Any   				=					tokenizer.train_new_from_iterator(text_iterator=lowerCamelCase__   ,   length=1_0_0_0   ,   vocab_size=5_0  )
  
           _lowerCAmelCase       :  str   				=					new_tokenizer.encode("""a🤗"""  )
           self.assertEqual(lowerCamelCase__   ,   [6_4, 1_7_2, 2_5_3, 9_7, 2_4_5]  )
  
  
  
  @require_tokenizers
  class   a_  (unittest.TestCase    ):
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  int   				=					AutoTokenizer.from_pretrained("""bert-base-cased"""  )
           _lowerCAmelCase       :  List[Any]   				=					json.loads(tokenizer._tokenizer.to_str()  )
           _lowerCAmelCase       :  Optional[Any]   				=					len(lowerCamelCase__  )
  
           with tempfile.TemporaryDirectory() as tmp_dir:
             # Hack to save this in the tokenizer_config.json
             _lowerCAmelCase       :  Dict   				=					["""tokenizer.4.0.0.json"""]
             tokenizer.save_pretrained(lowerCamelCase__  )
             json.dump(lowerCamelCase__   ,   open(os.path.join(lowerCamelCase__   ,   """tokenizer.4.0.0.json"""  )   ,   """w"""  )  )
  
             # This should pick the new tokenizer file as the version of Transformers is > 4.0.0
             _lowerCAmelCase       :  List[Any]   				=					AutoTokenizer.from_pretrained(lowerCamelCase__  )
             self.assertEqual(len(lowerCamelCase__  )   ,   len(lowerCamelCase__  ) + 1  )
             _lowerCAmelCase       :  int   				=					json.loads(new_tokenizer._tokenizer.to_str()  )
             self.assertIn("""huggingface"""   ,   json_tokenizer["""model"""]["""vocab"""]  )
  
             # Will need to be adjusted if we reach v42 and this test is still here.
             # Should pick the old tokenizer file as the version of Transformers is < 4.0.0
             shutil.move(os.path.join(lowerCamelCase__   ,   """tokenizer.4.0.0.json"""  )   ,   os.path.join(lowerCamelCase__   ,   """tokenizer.42.0.0.json"""  )  )
             _lowerCAmelCase       :  Any   				=					["""tokenizer.42.0.0.json"""]
             tokenizer.save_pretrained(lowerCamelCase__  )
             _lowerCAmelCase       :  Dict   				=					AutoTokenizer.from_pretrained(lowerCamelCase__  )
             self.assertEqual(len(lowerCamelCase__  )   ,   len(lowerCamelCase__  )  )
             _lowerCAmelCase       :  Tuple   				=					json.loads(new_tokenizer._tokenizer.to_str()  )
             self.assertNotIn("""huggingface"""   ,   json_tokenizer["""model"""]["""vocab"""]  )
  
  
  
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  Dict   				=					"""hf-internal-testing/test-two-tokenizers"""
  
           # This should pick the new tokenizer file as the version of Transformers is > 4.0.0
           _lowerCAmelCase       :  Dict   				=					AutoTokenizer.from_pretrained(lowerCamelCase__  )
           self.assertEqual(len(lowerCamelCase__  )   ,   2_8_9_9_7  )
           _lowerCAmelCase       :  int   				=					json.loads(tokenizer._tokenizer.to_str()  )
           self.assertIn("""huggingface"""   ,   json_tokenizer["""model"""]["""vocab"""]  )
  
           # Testing an older version by monkey-patching the version in the module it's used.
           import transformers as old_transformers
  
           _lowerCAmelCase       :  Dict   				=					"""3.0.0"""
           _lowerCAmelCase       :  List[str]   				=					old_transformers.models.auto.AutoTokenizer.from_pretrained(lowerCamelCase__  )
           self.assertEqual(len(lowerCamelCase__  )   ,   2_8_9_9_6  )
           _lowerCAmelCase       :  List[Any]   				=					json.loads(old_tokenizer._tokenizer.to_str()  )
           self.assertNotIn("""huggingface"""   ,   json_tokenizer["""model"""]["""vocab"""]  )
  
  
  
  @require_tokenizers
  class   a_  (unittest.TestCase    ):
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  Dict   				=					PreTrainedTokenizerFast.from_pretrained("""robot-test/dummy-tokenizer-wordlevel"""  )
           _lowerCAmelCase       :  int   				=					"""The Matrix is a 1999 science fiction action film."""
  
           with concurrent.futures.ThreadPoolExecutor() as executor:
             _lowerCAmelCase       :  Dict   				=					[executor.submit(self.fetch   ,   lowerCamelCase__   ,   lowerCamelCase__  ) for i in range(1_0  )]
             _lowerCAmelCase       :  int   				=					[future.result() for future in futures]
             self.assertEqual(lowerCamelCase__   ,   [[1, 1_0, 0, 8, 0, 1_8, 0, 0, 0, 2] for i in range(1_0  )]  )
  
  
  
  
  
  
  
         def 							__UpperCamelCase       (     self   ,   snake_case_   ,   snake_case_  ):
           return tokenizer.encode(lowerCamelCase__   ,   truncation="""longest_first"""   ,   padding="""longest"""  )
  
  
  
style_context: 
  '''simple docstring'''
  
  import os
  
  
  def 	_UpperCAmelCase				(  )    ->						int:
    _lowerCAmelCase       :  Optional[int]   				=					os.path.dirname(os.path.realpath(_lowerCamelCase		)		)
    _lowerCAmelCase       :  Optional[Any]   				=					os.path.join(_lowerCamelCase  ,      """triangle.txt"""		)
  
    with open(_lowerCamelCase		) as in_file:
      _lowerCAmelCase       :  List[Any]   				=					[[int(_lowerCamelCase		) for i in line.split()] for line in in_file]
  
    while len(_lowerCamelCase		) != 1:
      _lowerCAmelCase       :  Any   				=					triangle.pop()
      _lowerCAmelCase       :  List[str]   				=					triangle[-1]
      for j in range(len(_lowerCamelCase		) - 1		):
        curr_row[j] += max(last_row[j]  ,      last_row[j + 1]		)
    return triangle[0][0]
  
  
  if __name__ == "__main__":
       print(solution())
  
  
  