


import json
import os
import unittest

from transformers import AutoTokenizer, GPTaTokenizer, GPTaTokenizerFast
from transformers.models.gpta.tokenization_gpta import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin






@require_tokenizers
class      UpperCamelCase(	_a  ,				unittest.TestCase ):
					snake_case_		:					Union[str, Any]    					=						GPTaTokenizer
					snake_case_		:					List[str]    					=						GPTaTokenizerFast
					snake_case_		:					Optional[Any]    					=						True
					snake_case_		:					Optional[Any]    					=						{"""add_prefix_space""": True}
					snake_case_		:					List[str]    					=						False


					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]    )      ->						Union[str, Any]:




											'''simple docstring'''

											super().setUp()

											# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
											__snake_case				=		[
											    "l",
											    "o",
											    "w",
											    "e",
											    "r",
											    "s",
											    "t",
											    "i",
											    "d",
											    "n",
											    "\u0120",
											    "\u0120l",
											    "\u0120n",
											    "\u0120lo",
											    "\u0120low",
											    "er",
											    "\u0120lowest",
											    "\u0120newer",
											    "\u0120wider",
											    "<unk>",
											    "<|endoftext|>",
											]
											__snake_case				=		dict(zip(SCREAMING_SNAKE_CASE  ,     range(len(SCREAMING_SNAKE_CASE    )    )    )    )
											__snake_case				=		["#version: 0.2", "\u0120 l", "\u0120l o", "\u0120lo w", "e r", ""]
											__snake_case				=		{"unk_token": "<unk>"}

											__snake_case				=		os.path.join(self.tmpdirname  ,     VOCAB_FILES_NAMES["vocab_file"]    )
											__snake_case				=		os.path.join(self.tmpdirname  ,     VOCAB_FILES_NAMES["merges_file"]    )
											with open(self.vocab_file  ,     "w"  ,     encoding="utf-8"    ) as fp:
																	fp.write(json.dumps(SCREAMING_SNAKE_CASE    ) + "\n"    )
											with open(self.merges_file  ,     "w"  ,     encoding="utf-8"    ) as fp:
																	fp.write("\n".join(SCREAMING_SNAKE_CASE    )    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]  ,     **SCREAMING_SNAKE_CASE						:		Optional[int]    )      ->						str:




											'''simple docstring'''

											kwargs.update(self.special_tokens_map    )
											return GPTaTokenizer.from_pretrained(self.tmpdirname  ,     **SCREAMING_SNAKE_CASE    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Any  ,     **SCREAMING_SNAKE_CASE						:		List[str]    )      ->						Tuple:




											'''simple docstring'''

											kwargs.update(self.special_tokens_map    )
											return GPTaTokenizerFast.from_pretrained(self.tmpdirname  ,     **SCREAMING_SNAKE_CASE    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		int  ,     SCREAMING_SNAKE_CASE						:		str    )      ->						List[Any]:




											'''simple docstring'''

											__snake_case				=		"lower newer"
											__snake_case				=		"lower newer"
											return input_text, output_text


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[Any]    )      ->						List[Any]:




											'''simple docstring'''

											__snake_case				=		GPTaTokenizer(self.vocab_file  ,     self.merges_file  ,     **self.special_tokens_map    )
											__snake_case				=		"lower newer"
											__snake_case				=		["\u0120low", "er", "\u0120", "n", "e", "w", "er"]
											__snake_case				=		tokenizer.tokenize(SCREAMING_SNAKE_CASE  ,     add_prefix_space=SCREAMING_SNAKE_CASE    )
											self.assertListEqual(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )

											__snake_case				=		tokens + [tokenizer.unk_token]
											__snake_case				=		[1_4, 1_5, 1_0, 9, 3, 2, 1_5, 1_9]
											self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE    )  ,     SCREAMING_SNAKE_CASE    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Any    )      ->						List[Any]:




											'''simple docstring'''

											if not self.test_rust_tokenizer:
																	return

											__snake_case				=		self.get_tokenizer()
											__snake_case				=		self.get_rust_tokenizer(add_prefix_space=SCREAMING_SNAKE_CASE    )

											__snake_case				=		"lower newer"

											# Testing tokenization
											__snake_case				=		tokenizer.tokenize(SCREAMING_SNAKE_CASE  ,     add_prefix_space=SCREAMING_SNAKE_CASE    )
											__snake_case				=		rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE    )
											self.assertListEqual(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )

											# Testing conversion to ids without special tokens
											__snake_case				=		tokenizer.encode(SCREAMING_SNAKE_CASE  ,     add_special_tokens=SCREAMING_SNAKE_CASE  ,     add_prefix_space=SCREAMING_SNAKE_CASE    )
											__snake_case				=		rust_tokenizer.encode(SCREAMING_SNAKE_CASE  ,     add_special_tokens=SCREAMING_SNAKE_CASE    )
											self.assertListEqual(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )

											# Testing conversion to ids with special tokens
											__snake_case				=		self.get_rust_tokenizer(add_prefix_space=SCREAMING_SNAKE_CASE    )
											__snake_case				=		tokenizer.encode(SCREAMING_SNAKE_CASE  ,     add_prefix_space=SCREAMING_SNAKE_CASE    )
											__snake_case				=		rust_tokenizer.encode(SCREAMING_SNAKE_CASE    )
											self.assertListEqual(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )

											# Testing the unknown token
											__snake_case				=		tokens + [rust_tokenizer.unk_token]
											__snake_case				=		[1_4, 1_5, 1_0, 9, 3, 2, 1_5, 1_9]
											self.assertListEqual(rust_tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE    )  ,     SCREAMING_SNAKE_CASE    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Tuple  ,     *SCREAMING_SNAKE_CASE						:		Any  ,     **SCREAMING_SNAKE_CASE						:		int    )      ->						List[str]:




											'''simple docstring'''

											pass


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[int]  ,     SCREAMING_SNAKE_CASE						:		List[str]=1_5    )      ->						Dict:




											'''simple docstring'''

											for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																	with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
																							__snake_case				=		self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE  ,     **SCREAMING_SNAKE_CASE    )

																							# Simple input
																							__snake_case				=		"This is a simple input"
																							__snake_case				=		["This is a simple input 1", "This is a simple input 2"]
																							__snake_case				=		("This is a simple input", "This is a pair")
																							__snake_case				=		[
																							    ("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 				SCREAMING_SNAKE_CASE_	(    self						:		Union[str, Any]    )      ->						int:




											'''simple docstring'''

											__snake_case				=		GPTaTokenizer.from_pretrained(self.tmpdirname  ,     pad_token="<pad>"    )

											# Simple input
											__snake_case				=		"This is a simple input"
											__snake_case				=		["This is a simple input looooooooong", "This is a simple input"]
											__snake_case				=		("This is a simple input", "This is a pair")
											__snake_case				=		[
											    ("This is a simple input loooooong", "This is a simple input"),
											    ("This is a simple pair loooooong", "This is a simple pair"),
											]

											__snake_case				=		tokenizer.pad_token_id

											__snake_case				=		tokenizer(SCREAMING_SNAKE_CASE  ,     padding="max_length"  ,     max_length=3_0  ,     return_tensors="np"    )
											__snake_case				=		tokenizer(SCREAMING_SNAKE_CASE  ,     padding=SCREAMING_SNAKE_CASE  ,     truncate=SCREAMING_SNAKE_CASE  ,     return_tensors="np"    )
											__snake_case				=		tokenizer(*SCREAMING_SNAKE_CASE  ,     padding="max_length"  ,     max_length=6_0  ,     return_tensors="np"    )
											__snake_case				=		tokenizer(SCREAMING_SNAKE_CASE  ,     padding=SCREAMING_SNAKE_CASE  ,     truncate=SCREAMING_SNAKE_CASE  ,     return_tensors="np"    )

											# s
											# test single string max_length padding
											self.assertEqual(out_s["input_ids"].shape[-1]  ,     3_0    )
											self.assertTrue(pad_token_id in out_s["input_ids"]    )
											self.assertTrue(0 in out_s["attention_mask"]    )

											# s2
											# test automatic padding
											self.assertEqual(out_sa["input_ids"].shape[-1]  ,     3_3    )
											# long slice doesn't have padding
											self.assertFalse(pad_token_id in out_sa["input_ids"][0]    )
											self.assertFalse(0 in out_sa["attention_mask"][0]    )
											# short slice does have padding
											self.assertTrue(pad_token_id in out_sa["input_ids"][1]    )
											self.assertTrue(0 in out_sa["attention_mask"][1]    )

											# p
											# test single pair max_length padding
											self.assertEqual(out_p["input_ids"].shape[-1]  ,     6_0    )
											self.assertTrue(pad_token_id in out_p["input_ids"]    )
											self.assertTrue(0 in out_p["attention_mask"]    )

											# p2
											# test automatic padding pair
											self.assertEqual(out_pa["input_ids"].shape[-1]  ,     5_2    )
											# long slice pair doesn't have padding
											self.assertFalse(pad_token_id in out_pa["input_ids"][0]    )
											self.assertFalse(0 in out_pa["attention_mask"][0]    )
											# short slice pair does have padding
											self.assertTrue(pad_token_id in out_pa["input_ids"][1]    )
											self.assertTrue(0 in out_pa["attention_mask"][1]    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Optional[Any]    )      ->						Union[str, Any]:




											'''simple docstring'''

											__snake_case				=		"$$$"
											__snake_case				=		GPTaTokenizer.from_pretrained(self.tmpdirname  ,     bos_token=SCREAMING_SNAKE_CASE  ,     add_bos_token=SCREAMING_SNAKE_CASE    )

											__snake_case				=		"This is a simple input"
											__snake_case				=		["This is a simple input 1", "This is a simple input 2"]

											__snake_case				=		tokenizer.bos_token_id

											__snake_case				=		tokenizer(SCREAMING_SNAKE_CASE    )
											__snake_case				=		tokenizer(SCREAMING_SNAKE_CASE    )

											self.assertEqual(out_s.input_ids[0]  ,     SCREAMING_SNAKE_CASE    )
											self.assertTrue(all(o[0] == bos_token_id for o in out_sa.input_ids    )    )

											__snake_case				=		tokenizer.decode(out_s.input_ids    )
											__snake_case				=		tokenizer.batch_decode(out_sa.input_ids    )

											self.assertEqual(decode_s.split()[0]  ,     SCREAMING_SNAKE_CASE    )
											self.assertTrue(all(d.split()[0] == bos_token for d in decode_sa    )    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		Dict    )      ->						Optional[int]:




											'''simple docstring'''

											pass






					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[Any]    )      ->						str:




											'''simple docstring'''

											__snake_case				=		[self.get_tokenizer(do_lower_case=SCREAMING_SNAKE_CASE  ,     add_bos_token=SCREAMING_SNAKE_CASE    )]
											for tokenizer in tokenizers:
																	with self.subTest(f'''{tokenizer.__class__.__name__}'''    ):
																							__snake_case				=		"Encode this."
																							__snake_case				=		"This one too please."
																							__snake_case				=		tokenizer.encode(SCREAMING_SNAKE_CASE  ,     add_special_tokens=SCREAMING_SNAKE_CASE    )
																							encoded_sequence += tokenizer.encode(SCREAMING_SNAKE_CASE  ,     add_special_tokens=SCREAMING_SNAKE_CASE    )
																							__snake_case				=		tokenizer.encode_plus(
																							    SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE  ,     add_special_tokens=SCREAMING_SNAKE_CASE  ,     return_special_tokens_mask=SCREAMING_SNAKE_CASE  ,     )
																							__snake_case				=		encoded_sequence_dict["input_ids"]
																							__snake_case				=		encoded_sequence_dict["special_tokens_mask"]
																							self.assertEqual(len(SCREAMING_SNAKE_CASE    )  ,     len(SCREAMING_SNAKE_CASE    )    )

																							__snake_case				=		[
																							    (x if not special_tokens_mask[i] else None) for i, x in enumerate(SCREAMING_SNAKE_CASE    )
																							]
																							__snake_case				=		[x for x in filtered_sequence if x is not None]
																							self.assertEqual(SCREAMING_SNAKE_CASE  ,     SCREAMING_SNAKE_CASE    )






@require_tokenizers
class      UpperCamelCase(	unittest.TestCase ):


					def 				SCREAMING_SNAKE_CASE_	(    self						:		str    )      ->						List[str]:




											'''simple docstring'''

											__snake_case				=		AutoTokenizer.from_pretrained("facebook/opt-350m"  ,     from_slow=SCREAMING_SNAKE_CASE    )
											__snake_case				=		"A photo of a cat"

											__snake_case				=		tokenizer.encode(
											    SCREAMING_SNAKE_CASE  ,     )
											self.assertEqual(SCREAMING_SNAKE_CASE  ,     [2, 2_5_0, 1_3_4_5, 9, 1_0, 4_7_5_8]    )
											tokenizer.save_pretrained("test_opt"    )

											__snake_case				=		AutoTokenizer.from_pretrained("./test_opt"    )
											__snake_case				=		tokenizer.encode(
											    SCREAMING_SNAKE_CASE  ,     )
											self.assertEqual(SCREAMING_SNAKE_CASE  ,     [2, 2_5_0, 1_3_4_5, 9, 1_0, 4_7_5_8]    )


					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]    )      ->						str:




											'''simple docstring'''

											__snake_case				=		AutoTokenizer.from_pretrained("facebook/opt-350m"  ,     use_slow=SCREAMING_SNAKE_CASE    )
											__snake_case				=		"A photo of a cat"

											__snake_case				=		tokenizer.encode(
											    SCREAMING_SNAKE_CASE  ,     )
											# Same as above
											self.assertEqual(SCREAMING_SNAKE_CASE  ,     [2, 2_5_0, 1_3_4_5, 9, 1_0, 4_7_5_8]    )






					@unittest.skip("This test is failing because of a bug in the fast tokenizer"    )
					def 				SCREAMING_SNAKE_CASE_	(    self						:		List[str]    )      ->						Dict:




											'''simple docstring'''

											__snake_case				=		AutoTokenizer.from_pretrained("facebook/opt-350m"  ,     from_slow=SCREAMING_SNAKE_CASE    )

											__snake_case				=		"bos"
											__snake_case				=		tokenizer.get_vocab()["bos"]

											__snake_case				=		"A photo of a cat"
											__snake_case				=		tokenizer.encode(
											    SCREAMING_SNAKE_CASE  ,     )
											# We changed the bos token
											self.assertEqual(SCREAMING_SNAKE_CASE  ,     [3_1_9_5_7, 2_5_0, 1_3_4_5, 9, 1_0, 4_7_5_8]    )
											tokenizer.save_pretrained("./tok"    )
											__snake_case				=		AutoTokenizer.from_pretrained("./tok"    )
											self.assertTrue(tokenizer.is_fast    )
											__snake_case				=		tokenizer.encode(
											    SCREAMING_SNAKE_CASE  ,     )
											self.assertEqual(SCREAMING_SNAKE_CASE  ,     [3_1_9_5_7, 2_5_0, 1_3_4_5, 9, 1_0, 4_7_5_8]    )









def 						_lowerCAmelCase							(     _lowerCAmelCase = 1000			)    ->						int:


						'''simple docstring'''






						__snake_case				=		2**power
						__snake_case				=		str(_lowerCAmelCase			)
						__snake_case				=		list(_lowerCAmelCase			)
						__snake_case				=		0

						for i in list_num:
												sum_of_num += int(_lowerCAmelCase			)

						return sum_of_num


if __name__ == "__main__":
	A				:       Optional[Any]      =  int(input('Enter the power of 2: ').strip())
	print('2 ^ ', power, ' = ', 2**power)
	A				:       List[Any]      =  solution(power)
	print('Sum of the digits is: ', result)





