





'''simple docstring'''

import json
import os
import unittest

from transformers import OpenAIGPTTokenizer, OpenAIGPTTokenizerFast
from transformers.models.openai.tokenization_openai import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_spacy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin






@require_tokenizers
class    UpperCAmelCase	(       __lowercase			,       unittest.TestCase				):
 __lowercase   		=				OpenAIGPTTokenizer
 __lowercase   		=				OpenAIGPTTokenizerFast
 __lowercase   		=				True
 __lowercase   		=				False
 def      UpperCAmelCase_							(				self      :Optional[Any]							)->							int:
     super().setUp()

     # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
     A__				=			[
         "l",
         "o",
         "w",
         "e",
         "r",
         "s",
         "t",
         "i",
         "d",
         "n",
         "w</w>",
         "r</w>",
         "t</w>",
         "lo",
         "low",
         "er</w>",
         "low</w>",
         "lowest</w>",
         "newer</w>",
         "wider</w>",
         "<unk>",
     ]
     A__				=			dict(zip(SCREAMING_SNAKE_CASE__						,       range(len(SCREAMING_SNAKE_CASE__							)							)							)							)
     A__				=			["#version: 0.2", "l o", "lo w", "e r</w>", ""]

     A__				=			os.path.join(self.tmpdirname						,       VOCAB_FILES_NAMES["vocab_file"]							)
     A__				=			os.path.join(self.tmpdirname						,       VOCAB_FILES_NAMES["merges_file"]							)
     with open(self.vocab_file						,       "w"							) as fp:
         fp.write(json.dumps(SCREAMING_SNAKE_CASE__							)							)
     with open(self.merges_file						,       "w"							) as fp:
         fp.write("\n".join(SCREAMING_SNAKE_CASE__							)							)
 def      UpperCAmelCase_							(				self      :Optional[int]						,       lowercase_      :Union[str, Any]							)->							List[str]:
     return "lower newer", "lower newer"
 def      UpperCAmelCase_							(				self      :Optional[Any]							)->							List[str]:
     A__				=			OpenAIGPTTokenizer(self.vocab_file						,       self.merges_file							)

     A__				=			"lower"
     A__				=			["low", "er</w>"]
     A__				=			tokenizer.tokenize(SCREAMING_SNAKE_CASE__							)
     self.assertListEqual(SCREAMING_SNAKE_CASE__						,       SCREAMING_SNAKE_CASE__							)

     A__				=			tokens + ["<unk>"]
     A__				=			[14, 15, 20]
     self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE__							)						,       SCREAMING_SNAKE_CASE__							)
 def      UpperCAmelCase_							(				self      :Tuple						,       lowercase_      :Optional[int]=15							)->							Tuple:
     for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
         with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"							):
             A__				=			self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE__						,       **SCREAMING_SNAKE_CASE__							)

             # Simple input
             A__				=			"This is a simple input"
             A__				=			["This is a simple input 1", "This is a simple input 2"]
             A__				=			("This is a simple input", "This is a pair")
             A__				=			[
                 ("This is a simple input 1", "This is a simple input 2"),
                 ("This is a simple pair 1", "This is a simple pair 2"),
             ]

             # Simple input tests
             self.assertRaises(SCREAMING_SNAKE_CASE__						,       tokenizer_r.encode						,       SCREAMING_SNAKE_CASE__						,       max_length=SCREAMING_SNAKE_CASE__						,       padding="max_length"							)

             # Simple input
             self.assertRaises(SCREAMING_SNAKE_CASE__						,       tokenizer_r.encode_plus						,       SCREAMING_SNAKE_CASE__						,       max_length=SCREAMING_SNAKE_CASE__						,       padding="max_length"							)

             # Simple input
             self.assertRaises(
                 SCREAMING_SNAKE_CASE__						,       tokenizer_r.batch_encode_plus						,       SCREAMING_SNAKE_CASE__						,       max_length=SCREAMING_SNAKE_CASE__						,       padding="max_length"						,       )

             # Pair input
             self.assertRaises(SCREAMING_SNAKE_CASE__						,       tokenizer_r.encode						,       SCREAMING_SNAKE_CASE__						,       max_length=SCREAMING_SNAKE_CASE__						,       padding="max_length"							)

             # Pair input
             self.assertRaises(SCREAMING_SNAKE_CASE__						,       tokenizer_r.encode_plus						,       SCREAMING_SNAKE_CASE__						,       max_length=SCREAMING_SNAKE_CASE__						,       padding="max_length"							)

             # Pair input
             self.assertRaises(
                 SCREAMING_SNAKE_CASE__						,       tokenizer_r.batch_encode_plus						,       SCREAMING_SNAKE_CASE__						,       max_length=SCREAMING_SNAKE_CASE__						,       padding="max_length"						,       )



 def      UpperCAmelCase_							(				self      :Any							)->							Tuple:
     pass






@require_ftfy
@require_spacy
@require_tokenizers
class    UpperCAmelCase	(       __lowercase				):
 pass





import os




def  __magic_name__ (   )			->   str:
				__lowerCamelCase    					=	os.path.join(os.path.dirname(__lowerCAmelCase							)		,  '''num.txt'''							)
				with open(__lowerCAmelCase							) as file_hand:
								return str(sum(int(__lowerCAmelCase							) for line in file_hand							)							)[:10]


if __name__ == "__main__":
					print(solution())



