




"""simple docstring"""

import os
import unittest

from transformers import MobileBertTokenizer, MobileBertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english

@require_tokenizers
class 				lowercase					(			__snake_case   ,		unittest.TestCase):
				__lowerCAmelCase			:			List[str]     				=      MobileBertTokenizer
				__lowerCAmelCase			:			int     				=      MobileBertTokenizerFast
				__lowerCAmelCase			:			Union[str, Any]     				=      True
				__lowerCAmelCase			:			Optional[Any]     				=      True
				__lowerCAmelCase			:			Dict     				=      filter_non_english
				__lowerCAmelCase			:			str     				=      """google/mobilebert-uncased"""







				def     a_     (							self      :    List[str]				):



					"""simple docstring"""

					super().setUp()

					A_     : int		      =						[
					    '''[UNK]''',
					    '''[CLS]''',
					    '''[SEP]''',
					    '''[PAD]''',
					    '''[MASK]''',
					    '''want''',
					    '''##want''',
					    '''##ed''',
					    '''wa''',
					    '''un''',
					    '''runn''',
					    '''##ing''',
					    ''',''',
					    '''low''',
					    '''lowest''',
					]
					A_     : Optional[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]				)				)

					A_     : int		      =						[
					    (tokenizer_def[0], self.pre_trained_model_path, tokenizer_def[2])  # else the 'google/' prefix is stripped
					    for tokenizer_def in self.tokenizers_list
					]







				def     a_     (							self      :    List[Any]					,   _lowerCamelCase      :    Union[str, Any]				):



					"""simple docstring"""

					A_     : Dict		      =						'''UNwant\u00E9d,running'''
					A_     : Optional[int]		      =						'''unwanted, running'''
					return input_text, output_text







				def     a_     (							self      :    Dict				):



					"""simple docstring"""

					A_     : str		      =						self.tokenizer_class(self.vocab_file				)

					A_     : int		      =						tokenizer.tokenize('''UNwant\u00E9d,running'''				)
					self.assertListEqual(__SCREAMING_SNAKE_CASE					,   ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing''']				)
					self.assertListEqual(tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE				)					,   [9, 6, 7, 12, 10, 11]				)







				def     a_     (							self      :    Dict				):



					"""simple docstring"""

					if not self.test_rust_tokenizer:
						return

					A_     : Optional[Any]		      =						self.get_tokenizer()
					A_     : Optional[int]		      =						self.get_rust_tokenizer()

					A_     : Optional[Any]		      =						'''UNwant\u00E9d,running'''

					A_     : List[Any]		      =						tokenizer.tokenize(__SCREAMING_SNAKE_CASE				)
					A_     : Optional[int]		      =						rust_tokenizer.tokenize(__SCREAMING_SNAKE_CASE				)
					self.assertListEqual(__SCREAMING_SNAKE_CASE					,   __SCREAMING_SNAKE_CASE				)

					A_     : str		      =						tokenizer.encode(__SCREAMING_SNAKE_CASE					,   add_special_tokens=__SCREAMING_SNAKE_CASE				)
					A_     : List[str]		      =						rust_tokenizer.encode(__SCREAMING_SNAKE_CASE					,   add_special_tokens=__SCREAMING_SNAKE_CASE				)
					self.assertListEqual(__SCREAMING_SNAKE_CASE					,   __SCREAMING_SNAKE_CASE				)

					A_     : int		      =						self.get_rust_tokenizer()
					A_     : Union[str, Any]		      =						tokenizer.encode(__SCREAMING_SNAKE_CASE				)
					A_     : Union[str, Any]		      =						rust_tokenizer.encode(__SCREAMING_SNAKE_CASE				)
					self.assertListEqual(__SCREAMING_SNAKE_CASE					,   __SCREAMING_SNAKE_CASE				)

					# With lower casing
					A_     : Any		      =						self.get_tokenizer(do_lower_case=__SCREAMING_SNAKE_CASE				)
					A_     : str		      =						self.get_rust_tokenizer(do_lower_case=__SCREAMING_SNAKE_CASE				)

					A_     : Tuple		      =						'''UNwant\u00E9d,running'''

					A_     : Optional[int]		      =						tokenizer.tokenize(__SCREAMING_SNAKE_CASE				)
					A_     : List[str]		      =						rust_tokenizer.tokenize(__SCREAMING_SNAKE_CASE				)
					self.assertListEqual(__SCREAMING_SNAKE_CASE					,   __SCREAMING_SNAKE_CASE				)

					A_     : Any		      =						tokenizer.encode(__SCREAMING_SNAKE_CASE					,   add_special_tokens=__SCREAMING_SNAKE_CASE				)
					A_     : List[Any]		      =						rust_tokenizer.encode(__SCREAMING_SNAKE_CASE					,   add_special_tokens=__SCREAMING_SNAKE_CASE				)
					self.assertListEqual(__SCREAMING_SNAKE_CASE					,   __SCREAMING_SNAKE_CASE				)

					A_     : List[Any]		      =						self.get_rust_tokenizer()
					A_     : Any		      =						tokenizer.encode(__SCREAMING_SNAKE_CASE				)
					A_     : str		      =						rust_tokenizer.encode(__SCREAMING_SNAKE_CASE				)
					self.assertListEqual(__SCREAMING_SNAKE_CASE					,   __SCREAMING_SNAKE_CASE				)







				def     a_     (							self      :    List[str]				):



					"""simple docstring"""

					A_     : Union[str, Any]		      =						BasicTokenizer()

					self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz'''				)					,   ['''ah''', '''\u535A''', '''\u63A8''', '''zz''']				)







				def     a_     (							self      :    List[Any]				):



					"""simple docstring"""

					A_     : Union[str, Any]		      =						BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE				)

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''				)					,   ['''hello''', '''!''', '''how''', '''are''', '''you''', '''?''']				)
					self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''				)					,   ['''hello''']				)







				def     a_     (							self      :    Any				):



					"""simple docstring"""

					A_     : Tuple		      =						BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE					,   strip_accents=__SCREAMING_SNAKE_CASE				)

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''				)					,   ['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?''']				)
					self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''				)					,   ['''h\u00E9llo''']				)







				def     a_     (							self      :    Tuple				):



					"""simple docstring"""

					A_     : Optional[Any]		      =						BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE					,   strip_accents=__SCREAMING_SNAKE_CASE				)

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''				)					,   ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']				)
					self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''				)					,   ['''hello''']				)







				def     a_     (							self      :    Tuple				):



					"""simple docstring"""

					A_     : Optional[Any]		      =						BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE				)

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''				)					,   ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']				)
					self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''				)					,   ['''hello''']				)







				def     a_     (							self      :    Optional[int]				):



					"""simple docstring"""

					A_     : int		      =						BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE				)

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''				)					,   ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']				)







				def     a_     (							self      :    Tuple				):



					"""simple docstring"""

					A_     : Union[str, Any]		      =						BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE					,   strip_accents=__SCREAMING_SNAKE_CASE				)

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''				)					,   ['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']				)







				def     a_     (							self      :    List[str]				):



					"""simple docstring"""

					A_     : str		      =						BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE					,   strip_accents=__SCREAMING_SNAKE_CASE				)

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''				)					,   ['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']				)







				def     a_     (							self      :    Tuple				):



					"""simple docstring"""

					A_     : Union[str, Any]		      =						BasicTokenizer(do_lower_case=__SCREAMING_SNAKE_CASE					,   never_split=['''[UNK]''']				)

					self.assertListEqual(
					    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU? [UNK]'''				)					,   ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]''']				)







				def     a_     (							self      :    List[str]				):



					"""simple docstring"""

					A_     : List[Any]		      =						['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

					A_     : int		      =						{}
					for i, token in enumerate(__SCREAMING_SNAKE_CASE				):
						A_     : Optional[int]		      =						i
					A_     : Dict		      =						WordpieceTokenizer(vocab=__SCREAMING_SNAKE_CASE					,   unk_token='''[UNK]'''				)

					self.assertListEqual(tokenizer.tokenize(''''''				)					,   []				)

					self.assertListEqual(tokenizer.tokenize('''unwanted running'''				)					,   ['''un''', '''##want''', '''##ed''', '''runn''', '''##ing''']				)

					self.assertListEqual(tokenizer.tokenize('''unwantedX running'''				)					,   ['''[UNK]''', '''runn''', '''##ing''']				)







				def     a_     (							self      :    List[Any]				):



					"""simple docstring"""

					self.assertTrue(_is_whitespace(''' '''				)				)
					self.assertTrue(_is_whitespace('''\t'''				)				)
					self.assertTrue(_is_whitespace('''\r'''				)				)
					self.assertTrue(_is_whitespace('''\n'''				)				)
					self.assertTrue(_is_whitespace('''\u00A0'''				)				)

					self.assertFalse(_is_whitespace('''A'''				)				)
					self.assertFalse(_is_whitespace('''-'''				)				)







				def     a_     (							self      :    Union[str, Any]				):



					"""simple docstring"""

					self.assertTrue(_is_control('''\u0005'''				)				)

					self.assertFalse(_is_control('''A'''				)				)
					self.assertFalse(_is_control(''' '''				)				)
					self.assertFalse(_is_control('''\t'''				)				)
					self.assertFalse(_is_control('''\r'''				)				)







				def     a_     (							self      :    str				):



					"""simple docstring"""

					self.assertTrue(_is_punctuation('''-'''				)				)
					self.assertTrue(_is_punctuation('''$'''				)				)
					self.assertTrue(_is_punctuation('''`'''				)				)
					self.assertTrue(_is_punctuation('''.'''				)				)

					self.assertFalse(_is_punctuation('''A'''				)				)
					self.assertFalse(_is_punctuation(''' '''				)				)







				def     a_     (							self      :    int				):



					"""simple docstring"""

					A_     : Dict		      =						self.get_tokenizer()
					A_     : str		      =						self.get_rust_tokenizer()

					# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
					self.assertListEqual([tokenizer.tokenize(__SCREAMING_SNAKE_CASE				) for t in ['''Test''', '''\xad''', '''test''']]					,   [['''[UNK]'''], [], ['''[UNK]''']]				)

					self.assertListEqual(
					    [rust_tokenizer.tokenize(__SCREAMING_SNAKE_CASE				) for t in ['''Test''', '''\xad''', '''test''']]					,   [['''[UNK]'''], [], ['''[UNK]''']]				)







				@slow
				def     a_     (							self      :    Dict				):



					"""simple docstring"""

					A_     : Any		      =						self.tokenizer_class.from_pretrained('''google/mobilebert-uncased'''				)

					A_     : Union[str, Any]		      =						tokenizer.encode('''sequence builders'''					,   add_special_tokens=__SCREAMING_SNAKE_CASE				)
					A_     : Tuple		      =						tokenizer.encode('''multi-sequence build'''					,   add_special_tokens=__SCREAMING_SNAKE_CASE				)

					A_     : Optional[Any]		      =						tokenizer.build_inputs_with_special_tokens(__SCREAMING_SNAKE_CASE				)
					A_     : List[str]		      =						tokenizer.build_inputs_with_special_tokens(__SCREAMING_SNAKE_CASE					,   __SCREAMING_SNAKE_CASE				)

					assert encoded_sentence == [1_01] + text + [1_02]
					assert encoded_pair == [1_01] + text + [1_02] + text_a + [1_02]







				def     a_     (							self      :    Tuple				):



					"""simple docstring"""

					for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
						with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""				):
							A_     : Dict		      =						self.rust_tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE					,   **__SCREAMING_SNAKE_CASE				)

							A_     : Any		      =						F"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
							A_     : List[Any]		      =						tokenizer_r.encode_plus(
							    __SCREAMING_SNAKE_CASE					,   return_attention_mask=__SCREAMING_SNAKE_CASE					,   return_token_type_ids=__SCREAMING_SNAKE_CASE					,   return_offsets_mapping=__SCREAMING_SNAKE_CASE					,   add_special_tokens=__SCREAMING_SNAKE_CASE					,   )

							A_     : List[Any]		      =						tokenizer_r.do_lower_case if hasattr(__SCREAMING_SNAKE_CASE					,   '''do_lower_case'''				) else False
							A_     : Any		      =						(
							    [
							        ((0, 0), tokenizer_r.cls_token),
							        ((0, 1), '''A'''),
							        ((1, 2), ''','''),
							        ((3, 5), '''na'''),
							        ((5, 6), '''##ï'''),
							        ((6, 8), '''##ve'''),
							        ((9, 15), tokenizer_r.mask_token),
							        ((16, 21), '''Allen'''),
							        ((21, 23), '''##NL'''),
							        ((23, 24), '''##P'''),
							        ((25, 33), '''sentence'''),
							        ((33, 34), '''.'''),
							        ((0, 0), tokenizer_r.sep_token),
							    ]
							    if not do_lower_case
							    else [
							        ((0, 0), tokenizer_r.cls_token),
							        ((0, 1), '''a'''),
							        ((1, 2), ''','''),
							        ((3, 8), '''naive'''),
							        ((9, 15), tokenizer_r.mask_token),
							        ((16, 21), '''allen'''),
							        ((21, 23), '''##nl'''),
							        ((23, 24), '''##p'''),
							        ((25, 33), '''sentence'''),
							        ((33, 34), '''.'''),
							        ((0, 0), tokenizer_r.sep_token),
							    ]
							)

							self.assertEqual(
							    [e[1] for e in expected_results]					,   tokenizer_r.convert_ids_to_tokens(tokens['''input_ids''']				)				)
							self.assertEqual([e[0] for e in expected_results]					,   tokens['''offset_mapping''']				)







				def     a_     (							self      :    Any				):



					"""simple docstring"""

					A_     : int		      =						['''的''', '''人''', '''有''']
					A_     : Tuple		      =						''''''.join(__SCREAMING_SNAKE_CASE				)
					for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
						with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""				):
							A_     : List[str]		      =						True
							A_     : Any		      =						self.tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE					,   **__SCREAMING_SNAKE_CASE				)
							A_     : List[Any]		      =						self.rust_tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE					,   **__SCREAMING_SNAKE_CASE				)

							A_     : str		      =						tokenizer_p.encode(__SCREAMING_SNAKE_CASE					,   add_special_tokens=__SCREAMING_SNAKE_CASE				)
							A_     : Dict		      =						tokenizer_r.encode(__SCREAMING_SNAKE_CASE					,   add_special_tokens=__SCREAMING_SNAKE_CASE				)

							A_     : Optional[Any]		      =						tokenizer_r.convert_ids_to_tokens(__SCREAMING_SNAKE_CASE				)
							A_     : Tuple		      =						tokenizer_p.convert_ids_to_tokens(__SCREAMING_SNAKE_CASE				)

							# it is expected that each Chinese character is not preceded by "##"
							self.assertListEqual(__SCREAMING_SNAKE_CASE					,   __SCREAMING_SNAKE_CASE				)
							self.assertListEqual(__SCREAMING_SNAKE_CASE					,   __SCREAMING_SNAKE_CASE				)

							A_     : Any		      =						False
							A_     : Dict		      =						self.rust_tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE					,   **__SCREAMING_SNAKE_CASE				)
							A_     : Optional[Any]		      =						self.tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE					,   **__SCREAMING_SNAKE_CASE				)

							A_     : str		      =						tokenizer_r.encode(__SCREAMING_SNAKE_CASE					,   add_special_tokens=__SCREAMING_SNAKE_CASE				)
							A_     : Tuple		      =						tokenizer_p.encode(__SCREAMING_SNAKE_CASE					,   add_special_tokens=__SCREAMING_SNAKE_CASE				)

							A_     : List[str]		      =						tokenizer_r.convert_ids_to_tokens(__SCREAMING_SNAKE_CASE				)
							A_     : int		      =						tokenizer_p.convert_ids_to_tokens(__SCREAMING_SNAKE_CASE				)

							# it is expected that only the first Chinese character is not preceded by "##".
							A_     : Tuple		      =						[
							    F"""##{token}""" if idx != 0 else token for idx, token in enumerate(__SCREAMING_SNAKE_CASE				)
							]
							self.assertListEqual(__SCREAMING_SNAKE_CASE					,   __SCREAMING_SNAKE_CASE				)
							self.assertListEqual(__SCREAMING_SNAKE_CASE					,   __SCREAMING_SNAKE_CASE				)













"""simple docstring"""





import string







def      lowerCamelCase__       (							_lowerCamelCase       :		str )      ->				None:
  for key in range(len(string.ascii_uppercase ) ):
    lowerCamelCase_         =						''
    for symbol in message:
      if symbol in string.ascii_uppercase:
        lowerCamelCase_         =						string.ascii_uppercase.find(_lowerCamelCase )
        lowerCamelCase_         =						num - key
        if num < 0:
          lowerCamelCase_         =						num + len(string.ascii_uppercase )
        lowerCamelCase_         =						translated + string.ascii_uppercase[num]
      else:
        lowerCamelCase_         =						translated + symbol
    print(F'''Decryption using Key #{key}: {translated}''' )







def      lowerCamelCase__       (							)      ->				None:
  lowerCamelCase_         =						input('Encrypted message: ' )
  lowerCamelCase_         =						message.upper()
  decrypt(_lowerCamelCase )


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  main()




