



'''simple docstring'''



import os
import pickle
import tempfile
import unittest
from typing import Callable, Optional

import numpy as np

from transformers import (
    BatchEncoding,
    BertTokenizer,
    BertTokenizerFast,
    PreTrainedTokenizer,
    PreTrainedTokenizerFast,
    TensorType,
    TokenSpan,
    is_tokenizers_available,
)
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import CaptureStderr, require_flax, require_tf, require_tokenizers, require_torch, slow


if is_tokenizers_available():
				from tokenizers import Tokenizer
				from tokenizers.models import WordPiece






class 			_SCREAMING_SNAKE_CASE				(unittest.TestCase      ):



			def 				lowerCAmelCase (     self		:						Optional[int]    ,			__UpperCamelCase		:						Optional[Any]			)      ->      str:
							"""simple docstring"""





							snake_case__      :   int      =    list(tokenizer_class.max_model_input_sizes.keys()			)
							for model_name in sa_models[:1]:
											snake_case__      :   int      =    tokenizer_class.from_pretrained(__UpperCamelCase			)
											self.assertIsNotNone(__UpperCamelCase			)
											self.assertIsInstance(__UpperCamelCase    ,			__UpperCamelCase			)
											self.assertIsInstance(__UpperCamelCase    ,			__UpperCamelCase			)

											for special_tok in tokenizer.all_special_tokens:
															self.assertIsInstance(__UpperCamelCase    ,			__UpperCamelCase			)
															snake_case__      :   Optional[Any]      =    tokenizer.convert_tokens_to_ids(__UpperCamelCase			)
															self.assertIsInstance(__UpperCamelCase    ,			__UpperCamelCase			)



			def 				lowerCAmelCase (     self		:						Dict    ,			__UpperCamelCase		:						BatchEncoding    ,			__UpperCamelCase		:						Optional[Callable] = None			)      ->      List[Any]:
							"""simple docstring"""





							snake_case__      :   List[Any]      =    pickle.dumps(__UpperCamelCase			)
							self.assertIsNotNone(__UpperCamelCase			)

							snake_case__      :   Union[str, Any]      =    pickle.loads(__UpperCamelCase			)

							# Ensure is_fast is correctly restored
							self.assertEqual(be_restored.is_fast    ,			be_original.is_fast			)

							# Ensure encodings are potentially correctly restored
							if be_original.is_fast:
											self.assertIsNotNone(be_restored.encodings			)
							else:
											self.assertIsNone(be_restored.encodings			)

							# Ensure the keys are the same
							for original_v, restored_v in zip(be_original.values()    ,			be_restored.values()			):
											if equal_op:
															self.assertTrue(equal_op(__UpperCamelCase    ,			__UpperCamelCase			)			)
											else:
															self.assertEqual(__UpperCamelCase    ,			__UpperCamelCase			)



			@slow
			def 				lowerCAmelCase (     self		:						Optional[Any]			)      ->      Tuple:
							"""simple docstring"""





							self.check_tokenizer_from_pretrained(__UpperCamelCase			)



			def 				lowerCAmelCase (     self		:						Union[str, Any]			)      ->      Tuple:
							"""simple docstring"""





							self.assertEqual(TensorType('''tf'''			)    ,			TensorType.TENSORFLOW			)
							self.assertEqual(TensorType('''pt'''			)    ,			TensorType.PYTORCH			)
							self.assertEqual(TensorType('''np'''			)    ,			TensorType.NUMPY			)



			@require_tokenizers
			def 				lowerCAmelCase (     self		:						Union[str, Any]			)      ->      Dict:
							"""simple docstring"""





							import numpy as np

							snake_case__      :   Union[str, Any]      =    BertTokenizer.from_pretrained('''bert-base-cased'''			)
							snake_case__      :   str      =    BertTokenizerFast.from_pretrained('''bert-base-cased'''			)

							# Python no tensor
							with self.subTest('''BatchEncoding (Python, return_tensors=None)'''			):
											self.assert_dump_and_restore(tokenizer_p('''Small example to encode'''			)			)

							with self.subTest('''BatchEncoding (Python, return_tensors=NUMPY)'''			):
											self.assert_dump_and_restore(
											    tokenizer_p('''Small example to encode'''    ,			return_tensors=TensorType.NUMPY			)    ,			np.array_equal			)

							with self.subTest('''BatchEncoding (Rust, return_tensors=None)'''			):
											self.assert_dump_and_restore(tokenizer_r('''Small example to encode'''			)			)

							with self.subTest('''BatchEncoding (Rust, return_tensors=NUMPY)'''			):
											self.assert_dump_and_restore(
											    tokenizer_r('''Small example to encode'''    ,			return_tensors=TensorType.NUMPY			)    ,			np.array_equal			)



			@require_tf
			@require_tokenizers
			def 				lowerCAmelCase (     self		:						Tuple			)      ->      Tuple:
							"""simple docstring"""





							import tensorflow as tf

							def tf_array_equals(__UpperCamelCase		:						Optional[Any]    ,			__UpperCamelCase		:						Any			):
											return tf.reduce_all(tf.equal(__UpperCamelCase    ,			__UpperCamelCase			)			)

							snake_case__      :   List[str]      =    BertTokenizer.from_pretrained('''bert-base-cased'''			)
							snake_case__      :   List[Any]      =    BertTokenizerFast.from_pretrained('''bert-base-cased'''			)

							with self.subTest('''BatchEncoding (Python, return_tensors=TENSORFLOW)'''			):
											self.assert_dump_and_restore(
											    tokenizer_p('''Small example to encode'''    ,			return_tensors=TensorType.TENSORFLOW			)    ,			__UpperCamelCase			)

							with self.subTest('''BatchEncoding (Rust, return_tensors=TENSORFLOW)'''			):
											self.assert_dump_and_restore(
											    tokenizer_r('''Small example to encode'''    ,			return_tensors=TensorType.TENSORFLOW			)    ,			__UpperCamelCase			)



			@require_torch
			@require_tokenizers
			def 				lowerCAmelCase (     self		:						Union[str, Any]			)      ->      Union[str, Any]:
							"""simple docstring"""





							import torch

							snake_case__      :   Union[str, Any]      =    BertTokenizer.from_pretrained('''bert-base-cased'''			)
							snake_case__      :   Dict      =    BertTokenizerFast.from_pretrained('''bert-base-cased'''			)

							with self.subTest('''BatchEncoding (Python, return_tensors=PYTORCH)'''			):
											self.assert_dump_and_restore(
											    tokenizer_p('''Small example to encode'''    ,			return_tensors=TensorType.PYTORCH			)    ,			torch.equal			)

							with self.subTest('''BatchEncoding (Rust, return_tensors=PYTORCH)'''			):
											self.assert_dump_and_restore(
											    tokenizer_r('''Small example to encode'''    ,			return_tensors=TensorType.PYTORCH			)    ,			torch.equal			)



			@require_tokenizers
			def 				lowerCAmelCase (     self		:						Dict			)      ->      List[str]:
							"""simple docstring"""





							snake_case__      :   Tuple      =    BertTokenizer.from_pretrained('''bert-base-cased'''			)
							snake_case__      :   List[str]      =    BertTokenizerFast.from_pretrained('''bert-base-cased'''			)

							with self.subTest('''Python Tokenizer'''			):
											self.assertFalse(tokenizer_p('''Small example to_encode'''			).is_fast			)

							with self.subTest('''Rust Tokenizer'''			):
											self.assertTrue(tokenizer_r('''Small example to_encode'''			).is_fast			)



			@require_tokenizers
			def 				lowerCAmelCase (     self		:						Any			)      ->      int:
							"""simple docstring"""





							snake_case__      :   List[Any]      =    BertTokenizerFast.from_pretrained('''bert-base-cased'''			)
							snake_case__      :   Optional[int]      =    tokenizer_r(['''Test''', '''\xad''', '''test''']    ,			is_split_into_words=__UpperCamelCase			)

							self.assertEqual(encoded.word_to_tokens(0			)    ,			TokenSpan(start=1    ,			end=2			)			)
							self.assertEqual(encoded.word_to_tokens(1			)    ,			__UpperCamelCase			)
							self.assertEqual(encoded.word_to_tokens(2			)    ,			TokenSpan(start=2    ,			end=3			)			)



			def 				lowerCAmelCase (     self		:						Tuple			)      ->      Any:
							"""simple docstring"""





							snake_case__      :   Optional[Any]      =    BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}			)
							snake_case__      :   Union[str, Any]      =    batch.convert_to_tensors(tensor_type='''np'''			)
							self.assertEqual(tensor_batch['''inputs'''].shape    ,			(2, 3)			)
							self.assertEqual(tensor_batch['''labels'''].shape    ,			(2,)			)
							# test converting the converted
							with CaptureStderr() as cs:
											snake_case__      :   Any      =    batch.convert_to_tensors(tensor_type='''np'''			)
							self.assertFalse(len(cs.err			)    ,			msg=F'''should have no warning, but got {cs.err}'''			)

							snake_case__      :   List[Any]      =    BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}			)
							snake_case__      :   Dict      =    batch.convert_to_tensors(tensor_type='''np'''    ,			prepend_batch_axis=__UpperCamelCase			)
							self.assertEqual(tensor_batch['''inputs'''].shape    ,			(1, 3)			)
							self.assertEqual(tensor_batch['''labels'''].shape    ,			(1,)			)



			@require_torch
			def 				lowerCAmelCase (     self		:						int			)      ->      Dict:
							"""simple docstring"""





							snake_case__      :   Tuple      =    BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}			)
							snake_case__      :   Tuple      =    batch.convert_to_tensors(tensor_type='''pt'''			)
							self.assertEqual(tensor_batch['''inputs'''].shape    ,			(2, 3)			)
							self.assertEqual(tensor_batch['''labels'''].shape    ,			(2,)			)
							# test converting the converted
							with CaptureStderr() as cs:
											snake_case__      :   Dict      =    batch.convert_to_tensors(tensor_type='''pt'''			)
							self.assertFalse(len(cs.err			)    ,			msg=F'''should have no warning, but got {cs.err}'''			)

							snake_case__      :   Optional[Any]      =    BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}			)
							snake_case__      :   int      =    batch.convert_to_tensors(tensor_type='''pt'''    ,			prepend_batch_axis=__UpperCamelCase			)
							self.assertEqual(tensor_batch['''inputs'''].shape    ,			(1, 3)			)
							self.assertEqual(tensor_batch['''labels'''].shape    ,			(1,)			)



			@require_tf
			def 				lowerCAmelCase (     self		:						List[Any]			)      ->      Union[str, Any]:
							"""simple docstring"""





							snake_case__      :   Dict      =    BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}			)
							snake_case__      :   Optional[Any]      =    batch.convert_to_tensors(tensor_type='''tf'''			)
							self.assertEqual(tensor_batch['''inputs'''].shape    ,			(2, 3)			)
							self.assertEqual(tensor_batch['''labels'''].shape    ,			(2,)			)
							# test converting the converted
							with CaptureStderr() as cs:
											snake_case__      :   Union[str, Any]      =    batch.convert_to_tensors(tensor_type='''tf'''			)
							self.assertFalse(len(cs.err			)    ,			msg=F'''should have no warning, but got {cs.err}'''			)

							snake_case__      :   int      =    BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}			)
							snake_case__      :   str      =    batch.convert_to_tensors(tensor_type='''tf'''    ,			prepend_batch_axis=__UpperCamelCase			)
							self.assertEqual(tensor_batch['''inputs'''].shape    ,			(1, 3)			)
							self.assertEqual(tensor_batch['''labels'''].shape    ,			(1,)			)



			@require_flax
			def 				lowerCAmelCase (     self		:						Optional[int]			)      ->      Optional[int]:
							"""simple docstring"""





							snake_case__      :   Optional[int]      =    BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}			)
							snake_case__      :   Tuple      =    batch.convert_to_tensors(tensor_type='''jax'''			)
							self.assertEqual(tensor_batch['''inputs'''].shape    ,			(2, 3)			)
							self.assertEqual(tensor_batch['''labels'''].shape    ,			(2,)			)
							# test converting the converted
							with CaptureStderr() as cs:
											snake_case__      :   Dict      =    batch.convert_to_tensors(tensor_type='''jax'''			)
							self.assertFalse(len(cs.err			)    ,			msg=F'''should have no warning, but got {cs.err}'''			)

							snake_case__      :   Any      =    BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}			)
							snake_case__      :   str      =    batch.convert_to_tensors(tensor_type='''jax'''    ,			prepend_batch_axis=__UpperCamelCase			)
							self.assertEqual(tensor_batch['''inputs'''].shape    ,			(1, 3)			)
							self.assertEqual(tensor_batch['''labels'''].shape    ,			(1,)			)



			def 				lowerCAmelCase (     self		:						Optional[Any]			)      ->      int:
							"""simple docstring"""





							snake_case__      :   str      =    [{'''input_ids''': np.array([0, 1, 2]			)}, {'''input_ids''': np.array([0, 1, 2, 3]			)}]
							snake_case__      :   Optional[Any]      =    BertTokenizer.from_pretrained('''bert-base-cased'''			)

							snake_case__      :   List[str]      =    tokenizer.pad(__UpperCamelCase    ,			padding=__UpperCamelCase			)
							self.assertTrue(isinstance(batch['''input_ids''']    ,			np.ndarray			)			)
							self.assertEqual(batch['''input_ids'''].tolist()    ,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]			)
							snake_case__      :   Tuple      =    tokenizer.pad(__UpperCamelCase    ,			padding=__UpperCamelCase    ,			return_tensors='''np'''			)
							self.assertTrue(isinstance(batch['''input_ids''']    ,			np.ndarray			)			)
							self.assertEqual(batch['''input_ids'''].tolist()    ,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]			)



			@require_torch
			def 				lowerCAmelCase (     self		:						List[Any]			)      ->      List[str]:
							"""simple docstring"""





							import torch

							snake_case__      :   str      =    [{'''input_ids''': torch.tensor([0, 1, 2]			)}, {'''input_ids''': torch.tensor([0, 1, 2, 3]			)}]
							snake_case__      :   str      =    BertTokenizer.from_pretrained('''bert-base-cased'''			)

							snake_case__      :   Union[str, Any]      =    tokenizer.pad(__UpperCamelCase    ,			padding=__UpperCamelCase			)
							self.assertTrue(isinstance(batch['''input_ids''']    ,			torch.Tensor			)			)
							self.assertEqual(batch['''input_ids'''].tolist()    ,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]			)
							snake_case__      :   Optional[Any]      =    tokenizer.pad(__UpperCamelCase    ,			padding=__UpperCamelCase    ,			return_tensors='''pt'''			)
							self.assertTrue(isinstance(batch['''input_ids''']    ,			torch.Tensor			)			)
							self.assertEqual(batch['''input_ids'''].tolist()    ,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]			)



			@require_tf
			def 				lowerCAmelCase (     self		:						Optional[Any]			)      ->      Union[str, Any]:
							"""simple docstring"""





							import tensorflow as tf

							snake_case__      :   str      =    [{'''input_ids''': tf.constant([0, 1, 2]			)}, {'''input_ids''': tf.constant([0, 1, 2, 3]			)}]
							snake_case__      :   Dict      =    BertTokenizer.from_pretrained('''bert-base-cased'''			)

							snake_case__      :   int      =    tokenizer.pad(__UpperCamelCase    ,			padding=__UpperCamelCase			)
							self.assertTrue(isinstance(batch['''input_ids''']    ,			tf.Tensor			)			)
							self.assertEqual(batch['''input_ids'''].numpy().tolist()    ,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]			)
							snake_case__      :   Union[str, Any]      =    tokenizer.pad(__UpperCamelCase    ,			padding=__UpperCamelCase    ,			return_tensors='''tf'''			)
							self.assertTrue(isinstance(batch['''input_ids''']    ,			tf.Tensor			)			)
							self.assertEqual(batch['''input_ids'''].numpy().tolist()    ,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]			)



			@require_tokenizers
			def 				lowerCAmelCase (     self		:						Tuple			)      ->      str:
							"""simple docstring"""





							snake_case__      :   Any      =    Tokenizer(WordPiece(unk_token='''[UNK]'''			)			)
							PreTrainedTokenizerFast(tokenizer_object=__UpperCamelCase			)







			@require_tokenizers
			def 				lowerCAmelCase (     self		:						Optional[Any]			)      ->      Union[str, Any]:
							"""simple docstring"""





							snake_case__      :   str      =    Tokenizer(WordPiece(unk_token='''[UNK]'''			)			)
							with tempfile.TemporaryDirectory() as tmpdirname:
											bert_tokenizer.save(os.path.join(__UpperCamelCase    ,			'''tokenizer.json'''			)			)
											PreTrainedTokenizerFast(tokenizer_file=os.path.join(__UpperCamelCase    ,			'''tokenizer.json'''			)			)









"""simple docstring"""






def 	snake_case__  (						__lowerCamelCase							:       str				,						__lowerCamelCase							:       int = 13      ):
			"""simple docstring"""
			lowerCamelCase__						:						List[str]						      =''''''
			for c in s:
						if "A" <= c <= "Z":
									out += chr(ord('''A'''      ) + (ord(__lowerCamelCase      ) - ord('''A'''      ) + n) % 26      )
						elif "a" <= c <= "z":
									out += chr(ord('''a'''      ) + (ord(__lowerCamelCase      ) - ord('''a'''      ) + n) % 26      )
						else:
									out += c
			return out






def 	snake_case__  (						):
			"""simple docstring"""
			lowerCamelCase__						:						List[str]						      =input('''Enter message: '''      )

			lowerCamelCase__						:						str						      =dencrypt(__lowerCamelCase				,						13      )
			print('''Encryption:'''				,						__lowerCamelCase      )

			lowerCamelCase__						:						Any						      =dencrypt(__lowerCamelCase				,						13      )
			print('''Decryption: '''				,						__lowerCamelCase      )


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		main()




