






"""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 (     lowerCAmelCase		,  unittest.TestCase						):
      _a   :     int								=   MobileBertTokenizer
      _a   :     List[Any]								=   MobileBertTokenizerFast
      _a   :     Optional[Any]								=   True
      _a   :     str								=   True
      _a   :     Optional[int]								=   filter_non_english
      _a   :     Tuple								=   '''google/mobilebert-uncased'''


      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            super().setUp()

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

            __snake_case      :    Any  			=[
                (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 _UpperCamelCase						(    self				:	List[str]							,   a				:	int						):





            """simple docstring"""







            __snake_case      :    Union[str, Any]  			='''UNwant\u00E9d,running'''
            __snake_case      :    Any  			='''unwanted, running'''
            return input_text, output_text


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





            """simple docstring"""







            __snake_case      :    Tuple  			=self.tokenizer_class(self.vocab_file						)

            __snake_case      :    Optional[int]  			=tokenizer.tokenize('''UNwant\u00E9d,running'''						)
            self.assertListEqual(a							,   ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing''']						)
            self.assertListEqual(tokenizer.convert_tokens_to_ids(a						)							,   [9, 6, 7, 1_2, 1_0, 1_1]						)


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





            """simple docstring"""







            if not self.test_rust_tokenizer:
                  return

            __snake_case      :    Tuple  			=self.get_tokenizer()
            __snake_case      :    Dict  			=self.get_rust_tokenizer()

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

            __snake_case      :    str  			=tokenizer.tokenize(a						)
            __snake_case      :    str  			=rust_tokenizer.tokenize(a						)
            self.assertListEqual(a							,   a						)

            __snake_case      :    Dict  			=tokenizer.encode(a							,   add_special_tokens=a						)
            __snake_case      :    Optional[int]  			=rust_tokenizer.encode(a							,   add_special_tokens=a						)
            self.assertListEqual(a							,   a						)

            __snake_case      :    List[Any]  			=self.get_rust_tokenizer()
            __snake_case      :    int  			=tokenizer.encode(a						)
            __snake_case      :    str  			=rust_tokenizer.encode(a						)
            self.assertListEqual(a							,   a						)

            # With lower casing
            __snake_case      :    List[str]  			=self.get_tokenizer(do_lower_case=a						)
            __snake_case      :    Dict  			=self.get_rust_tokenizer(do_lower_case=a						)

            __snake_case      :    List[str]  			='''UNwant\u00E9d,running'''

            __snake_case      :    List[str]  			=tokenizer.tokenize(a						)
            __snake_case      :    Any  			=rust_tokenizer.tokenize(a						)
            self.assertListEqual(a							,   a						)

            __snake_case      :    Any  			=tokenizer.encode(a							,   add_special_tokens=a						)
            __snake_case      :    List[str]  			=rust_tokenizer.encode(a							,   add_special_tokens=a						)
            self.assertListEqual(a							,   a						)

            __snake_case      :    Tuple  			=self.get_rust_tokenizer()
            __snake_case      :    str  			=tokenizer.encode(a						)
            __snake_case      :    Optional[Any]  			=rust_tokenizer.encode(a						)
            self.assertListEqual(a							,   a						)


      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            __snake_case      :    Any  			=BasicTokenizer()

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


      def _UpperCamelCase						(    self				:	List[Any]						):





            """simple docstring"""







            __snake_case      :    Tuple  			=BasicTokenizer(do_lower_case=a						)

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


      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            __snake_case      :    Dict  			=BasicTokenizer(do_lower_case=a							,   strip_accents=a						)

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


      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            __snake_case      :    Tuple  			=BasicTokenizer(do_lower_case=a							,   strip_accents=a						)

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


      def _UpperCamelCase						(    self				:	Tuple						):





            """simple docstring"""







            __snake_case      :    str  			=BasicTokenizer(do_lower_case=a						)

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


      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            __snake_case      :    Tuple  			=BasicTokenizer(do_lower_case=a						)

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


      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            __snake_case      :    str  			=BasicTokenizer(do_lower_case=a							,   strip_accents=a						)

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


      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            __snake_case      :    Optional[int]  			=BasicTokenizer(do_lower_case=a							,   strip_accents=a						)

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


      def _UpperCamelCase						(    self				:	int						):





            """simple docstring"""







            __snake_case      :    Optional[Any]  			=BasicTokenizer(do_lower_case=a							,   never_split=['''[UNK]''']						)

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


      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            __snake_case      :    str  			=['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

            __snake_case      :    List[Any]  			={}
            for i, token in enumerate(a						):
                  __snake_case      :    str  			=i
            __snake_case      :    Optional[int]  			=WordpieceTokenizer(vocab=a							,   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 _UpperCamelCase						(    self				:	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 _UpperCamelCase						(    self				:	Optional[int]						):





            """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 _UpperCamelCase						(    self				:	int						):





            """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 _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            __snake_case      :    List[str]  			=self.get_tokenizer()
            __snake_case      :    str  			=self.get_rust_tokenizer()

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

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


      @slow
      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            __snake_case      :    Optional[Any]  			=self.tokenizer_class.from_pretrained('''google/mobilebert-uncased'''						)

            __snake_case      :    Union[str, Any]  			=tokenizer.encode('''sequence builders'''							,   add_special_tokens=a						)
            __snake_case      :    Optional[Any]  			=tokenizer.encode('''multi-sequence build'''							,   add_special_tokens=a						)

            __snake_case      :    Any  			=tokenizer.build_inputs_with_special_tokens(a						)
            __snake_case      :    Optional[Any]  			=tokenizer.build_inputs_with_special_tokens(a							,   a						)

            assert encoded_sentence == [1_0_1] + text + [1_0_2]
            assert encoded_pair == [1_0_1] + text + [1_0_2] + text_a + [1_0_2]


      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







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

                        __snake_case      :    Tuple  			=f'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
                        __snake_case      :    List[str]  			=tokenizer_r.encode_plus(
                            a							,   return_attention_mask=a							,   return_token_type_ids=a							,   return_offsets_mapping=a							,   add_special_tokens=a							,   )

                        __snake_case      :    List[str]  			=tokenizer_r.do_lower_case if hasattr(a							,   '''do_lower_case'''						) else False
                        __snake_case      :    str  			=(
                            [
                                ((0, 0), tokenizer_r.cls_token),
                                ((0, 1), '''A'''),
                                ((1, 2), ''','''),
                                ((3, 5), '''na'''),
                                ((5, 6), '''##ï'''),
                                ((6, 8), '''##ve'''),
                                ((9, 1_5), tokenizer_r.mask_token),
                                ((1_6, 2_1), '''Allen'''),
                                ((2_1, 2_3), '''##NL'''),
                                ((2_3, 2_4), '''##P'''),
                                ((2_5, 3_3), '''sentence'''),
                                ((3_3, 3_4), '''.'''),
                                ((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, 1_5), tokenizer_r.mask_token),
                                ((1_6, 2_1), '''allen'''),
                                ((2_1, 2_3), '''##nl'''),
                                ((2_3, 2_4), '''##p'''),
                                ((2_5, 3_3), '''sentence'''),
                                ((3_3, 3_4), '''.'''),
                                ((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 _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            __snake_case      :    Dict  			=['''的''', '''人''', '''有''']
            __snake_case      :    Optional[int]  			=''''''.join(a						)
            for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                  with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''						):
                        __snake_case      :    str  			=True
                        __snake_case      :    Optional[int]  			=self.tokenizer_class.from_pretrained(a							,   **a						)
                        __snake_case      :    str  			=self.rust_tokenizer_class.from_pretrained(a							,   **a						)

                        __snake_case      :    Optional[Any]  			=tokenizer_p.encode(a							,   add_special_tokens=a						)
                        __snake_case      :    Union[str, Any]  			=tokenizer_r.encode(a							,   add_special_tokens=a						)

                        __snake_case      :    int  			=tokenizer_r.convert_ids_to_tokens(a						)
                        __snake_case      :    List[str]  			=tokenizer_p.convert_ids_to_tokens(a						)

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

                        __snake_case      :    str  			=False
                        __snake_case      :    Dict  			=self.rust_tokenizer_class.from_pretrained(a							,   **a						)
                        __snake_case      :    Union[str, Any]  			=self.tokenizer_class.from_pretrained(a							,   **a						)

                        __snake_case      :    Optional[int]  			=tokenizer_r.encode(a							,   add_special_tokens=a						)
                        __snake_case      :    Optional[int]  			=tokenizer_p.encode(a							,   add_special_tokens=a						)

                        __snake_case      :    Dict  			=tokenizer_r.convert_ids_to_tokens(a						)
                        __snake_case      :    int  			=tokenizer_p.convert_ids_to_tokens(a						)

                        # it is expected that only the first Chinese character is not preceded by "##".
                        __snake_case      :    Optional[Any]  			=[
                            f'''##{token}''' if idx != 0 else token for idx, token in enumerate(a						)
                        ]
                        self.assertListEqual(a							,   a						)
                        self.assertListEqual(a							,   a						)










"""simple docstring"""





def     __lowercase					(    a :				int       ,		a :				int )					->					int:
      return x if y == 0 else greatest_common_divisor(a       ,		x % y )



def     __lowercase					(    a :				int       ,		a :				int )					->					int:
      return (x * y) // greatest_common_divisor(a       ,		a )



def     __lowercase					(    a :				int = 20 )					->					int:
      __snake_case      :    Optional[Any]  			=1
      for i in range(1       ,		n + 1 ):
            __snake_case      :    Optional[int]  			=lcm(a       ,		a )
      return g


if __name__ == "__main__":
    print(F'''{solution() = }''')


