

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      super().setUp()

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

      lowerCAmelCase 						=							[
          (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   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE	):





      '''simple docstring'''

      lowerCAmelCase 						=							'''UNwant\u00E9d,running'''
      lowerCAmelCase 						=							'''unwanted, running'''
      return input_text, output_text

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							self.tokenizer_class(self.vocab_file	)

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      if not self.test_rust_tokenizer:
          return

      lowerCAmelCase 						=							self.get_tokenizer()
      lowerCAmelCase 						=							self.get_rust_tokenizer()

      lowerCAmelCase 						=							'''UNwant\u00E9d,running'''

      lowerCAmelCase 						=							tokenizer.tokenize(__lowerCAmelCase	)
      lowerCAmelCase 						=							rust_tokenizer.tokenize(__lowerCAmelCase	)
      self.assertListEqual(__lowerCAmelCase      , __lowerCAmelCase	)

      lowerCAmelCase 						=							tokenizer.encode(__lowerCAmelCase      , add_special_tokens=__lowerCAmelCase	)
      lowerCAmelCase 						=							rust_tokenizer.encode(__lowerCAmelCase      , add_special_tokens=__lowerCAmelCase	)
      self.assertListEqual(__lowerCAmelCase      , __lowerCAmelCase	)

      lowerCAmelCase 						=							self.get_rust_tokenizer()
      lowerCAmelCase 						=							tokenizer.encode(__lowerCAmelCase	)
      lowerCAmelCase 						=							rust_tokenizer.encode(__lowerCAmelCase	)
      self.assertListEqual(__lowerCAmelCase      , __lowerCAmelCase	)

      # With lower casing
      lowerCAmelCase 						=							self.get_tokenizer(do_lower_case=__lowerCAmelCase	)
      lowerCAmelCase 						=							self.get_rust_tokenizer(do_lower_case=__lowerCAmelCase	)

      lowerCAmelCase 						=							'''UNwant\u00E9d,running'''

      lowerCAmelCase 						=							tokenizer.tokenize(__lowerCAmelCase	)
      lowerCAmelCase 						=							rust_tokenizer.tokenize(__lowerCAmelCase	)
      self.assertListEqual(__lowerCAmelCase      , __lowerCAmelCase	)

      lowerCAmelCase 						=							tokenizer.encode(__lowerCAmelCase      , add_special_tokens=__lowerCAmelCase	)
      lowerCAmelCase 						=							rust_tokenizer.encode(__lowerCAmelCase      , add_special_tokens=__lowerCAmelCase	)
      self.assertListEqual(__lowerCAmelCase      , __lowerCAmelCase	)

      lowerCAmelCase 						=							self.get_rust_tokenizer()
      lowerCAmelCase 						=							tokenizer.encode(__lowerCAmelCase	)
      lowerCAmelCase 						=							rust_tokenizer.encode(__lowerCAmelCase	)
      self.assertListEqual(__lowerCAmelCase      , __lowerCAmelCase	)

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							BasicTokenizer()

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							BasicTokenizer(do_lower_case=__lowerCAmelCase	)

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							BasicTokenizer(do_lower_case=__lowerCAmelCase      , strip_accents=__lowerCAmelCase	)

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							BasicTokenizer(do_lower_case=__lowerCAmelCase      , strip_accents=__lowerCAmelCase	)

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							BasicTokenizer(do_lower_case=__lowerCAmelCase	)

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							BasicTokenizer(do_lower_case=__lowerCAmelCase	)

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							BasicTokenizer(do_lower_case=__lowerCAmelCase      , strip_accents=__lowerCAmelCase	)

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							BasicTokenizer(do_lower_case=__lowerCAmelCase      , strip_accents=__lowerCAmelCase	)

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							BasicTokenizer(do_lower_case=__lowerCAmelCase      , never_split=['[UNK]']	)

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

      lowerCAmelCase 						=							{}
      for i, token in enumerate(__lowerCAmelCase	):
          lowerCAmelCase 						=							i
      lowerCAmelCase 						=							WordpieceTokenizer(vocab=__lowerCAmelCase      , 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   _SCREAMING_SNAKE_CASE				(				self	):





      '''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   _SCREAMING_SNAKE_CASE				(				self	):





      '''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   _SCREAMING_SNAKE_CASE				(				self	):





      '''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   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							self.get_tokenizer()
      lowerCAmelCase 						=							self.get_rust_tokenizer()

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

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

  @slow
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							self.tokenizer_class.from_pretrained('google/mobilebert-uncased'	)

      lowerCAmelCase 						=							tokenizer.encode('sequence builders'      , add_special_tokens=__lowerCAmelCase	)
      lowerCAmelCase 						=							tokenizer.encode('multi-sequence build'      , add_special_tokens=__lowerCAmelCase	)

      lowerCAmelCase 						=							tokenizer.build_inputs_with_special_tokens(__lowerCAmelCase	)
      lowerCAmelCase 						=							tokenizer.build_inputs_with_special_tokens(__lowerCAmelCase      , __lowerCAmelCase	)

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
          with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'	):
              lowerCAmelCase 						=							self.rust_tokenizer_class.from_pretrained(__lowerCAmelCase      , **__lowerCAmelCase	)

              lowerCAmelCase 						=							F'A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'
              lowerCAmelCase 						=							tokenizer_r.encode_plus(
                  __lowerCAmelCase      , return_attention_mask=__lowerCAmelCase      , return_token_type_ids=__lowerCAmelCase      , return_offsets_mapping=__lowerCAmelCase      , add_special_tokens=__lowerCAmelCase      , )

              lowerCAmelCase 						=							tokenizer_r.do_lower_case if hasattr(__lowerCAmelCase      , 'do_lower_case'	) else False
              lowerCAmelCase 						=							(
                  [
                      ((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   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							['''的''', '''人''', '''有''']
      lowerCAmelCase 						=							''''''.join(__lowerCAmelCase	)
      for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
          with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'	):
              lowerCAmelCase 						=							True
              lowerCAmelCase 						=							self.tokenizer_class.from_pretrained(__lowerCAmelCase      , **__lowerCAmelCase	)
              lowerCAmelCase 						=							self.rust_tokenizer_class.from_pretrained(__lowerCAmelCase      , **__lowerCAmelCase	)

              lowerCAmelCase 						=							tokenizer_p.encode(__lowerCAmelCase      , add_special_tokens=__lowerCAmelCase	)
              lowerCAmelCase 						=							tokenizer_r.encode(__lowerCAmelCase      , add_special_tokens=__lowerCAmelCase	)

              lowerCAmelCase 						=							tokenizer_r.convert_ids_to_tokens(__lowerCAmelCase	)
              lowerCAmelCase 						=							tokenizer_p.convert_ids_to_tokens(__lowerCAmelCase	)

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

              lowerCAmelCase 						=							False
              lowerCAmelCase 						=							self.rust_tokenizer_class.from_pretrained(__lowerCAmelCase      , **__lowerCAmelCase	)
              lowerCAmelCase 						=							self.tokenizer_class.from_pretrained(__lowerCAmelCase      , **__lowerCAmelCase	)

              lowerCAmelCase 						=							tokenizer_r.encode(__lowerCAmelCase      , add_special_tokens=__lowerCAmelCase	)
              lowerCAmelCase 						=							tokenizer_p.encode(__lowerCAmelCase      , add_special_tokens=__lowerCAmelCase	)

              lowerCAmelCase 						=							tokenizer_r.convert_ids_to_tokens(__lowerCAmelCase	)
              lowerCAmelCase 						=							tokenizer_p.convert_ids_to_tokens(__lowerCAmelCase	)

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













import sys

SCREAMING_SNAKE_CASE__   :      Optional[Any]				=		(
    """73167176531330624919225119674426574742355349194934"""
    """96983520312774506326239578318016984801869478851843"""
    """85861560789112949495459501737958331952853208805511"""
    """12540698747158523863050715693290963295227443043557"""
    """66896648950445244523161731856403098711121722383113"""
    """62229893423380308135336276614282806444486645238749"""
    """30358907296290491560440772390713810515859307960866"""
    """70172427121883998797908792274921901699720888093776"""
    """65727333001053367881220235421809751254540594752243"""
    """52584907711670556013604839586446706324415722155397"""
    """53697817977846174064955149290862569321978468622482"""
    """83972241375657056057490261407972968652414535100474"""
    """82166370484403199890008895243450658541227588666881"""
    """16427171479924442928230863465674813919123162824586"""
    """17866458359124566529476545682848912883142607690042"""
    """24219022671055626321111109370544217506941658960408"""
    """07198403850962455444362981230987879927244284909188"""
    """84580156166097919133875499200524063689912560717606"""
    """05886116467109405077541002256983155200055935729725"""
    """71636269561882670428252483600823257530420752963450"""
)

def   __lowercase       (			snake_case = N			):







				"""simple docstring"""






				__magic_name__		:Optional[int]   =   -sys.maxsize - 1
				for i in range(len(snake_case			) - 1_2			):
								__magic_name__		:List[Any]   =   1
								for j in range(1_3			):
												product *= int(n[i + j]			)
								if product > largest_product:
												__magic_name__		:str   =   product
				return largest_product


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






