





'''simple docstring'''


import json
import os
import re
import shutil
import tempfile
import unittest
from typing import Tuple

from transformers import AddedToken, BatchEncoding, PerceiverTokenizer
from transformers.utils import cached_property, is_tf_available, is_torch_available

from ...test_tokenization_common import TokenizerTesterMixin


if is_torch_available():
 lowerCAmelCase :					str 							='''pt'''
elif is_tf_available():
 lowerCAmelCase :					List[str] 							='''tf'''
else:
 lowerCAmelCase :					int 							='''jax'''
class 				a_       (    _lowerCAmelCase     ,						unittest.TestCase							):
     __A								=      PerceiverTokenizer
     __A								=      False





     def 							lowercase__				(			self		: Any						):





        """simple docstring"""




        super().setUp()
        lowercase_      :Dict         =			PerceiverTokenizer()
        tokenizer.save_pretrained(self.tmpdirname						)





     @cached_property
     def 							lowercase__				(			self		: List[Any]						):





        """simple docstring"""




        return PerceiverTokenizer.from_pretrained("deepmind/language-perceiver"						)





     def 							lowercase__				(			self		: Tuple     ,				**lowercase		: List[str]						):





        """simple docstring"""




        return self.tokenizer_class.from_pretrained(self.tmpdirname     ,				**lowercase						)





     def 							lowercase__				(			self		: Tuple     ,				lowercase		: Tuple     ,				lowercase		: Optional[int]=False     ,				lowercase		: List[Any]=20     ,				lowercase		: str=5						):





        """simple docstring"""




        lowercase_      :str         =			[]
        for i in range(len(lowercase						)						):
           try:
              lowercase_      :Union[str, Any]         =			tokenizer.decode([i]     ,				clean_up_tokenization_spaces=lowercase						)
           except UnicodeDecodeError:
              pass
           toks.append((i, tok)						)

        lowercase_      :Any         =			list(filter(lambda lowercase						: re.match(R"^[ a-zA-Z]+$"     ,				t[1]						)     ,				lowercase						)						)
        lowercase_      :Union[str, Any]         =			list(filter(lambda lowercase						: [t[0]] == tokenizer.encode(t[1]     ,				add_special_tokens=lowercase						)     ,				lowercase						)						)
        if max_length is not None and len(lowercase						) > max_length:
           lowercase_      :Dict         =			toks[:max_length]
        if min_length is not None and len(lowercase						) < min_length and len(lowercase						) > 0:
           while len(lowercase						) < min_length:
              lowercase_      :Union[str, Any]         =			toks + toks
        # toks_str = [t[1] for t in toks]
        lowercase_      :Any         =			[t[0] for t in toks]

        # Ensure consistency
        lowercase_      :str         =			tokenizer.decode(lowercase     ,				clean_up_tokenization_spaces=lowercase						)
        if " " not in output_txt and len(lowercase						) > 1:
           lowercase_      :Tuple         =			(
               tokenizer.decode([toks_ids[0]]     ,				clean_up_tokenization_spaces=lowercase						)
               + " "
               + tokenizer.decode(toks_ids[1:]     ,				clean_up_tokenization_spaces=lowercase						)
           )
        if with_prefix_space:
           lowercase_      :str         =			" " + output_txt
        lowercase_      :List[Any]         =			tokenizer.encode(lowercase     ,				add_special_tokens=lowercase						)
        return output_txt, output_ids





     def 							lowercase__				(			self		: Optional[Any]						):





        """simple docstring"""




        lowercase_      :Optional[Any]         =			self.perceiver_tokenizer
        lowercase_      :Dict         =			"Unicode €."
        lowercase_      :int         =			tokenizer(lowercase						)
        lowercase_      :List[str]         =			[4, 91, 116, 111, 105, 117, 106, 107, 38, 232, 136, 178, 52, 5]
        self.assertEqual(encoded["input_ids"]     ,				lowercase						)

        # decoding
        lowercase_      :Optional[int]         =			tokenizer.decode(lowercase						)
        self.assertEqual(lowercase     ,				"[CLS]Unicode €.[SEP]"						)

        lowercase_      :List[str]         =			tokenizer("e è é ê ë"						)
        lowercase_      :Optional[int]         =			[4, 107, 38, 201, 174, 38, 201, 175, 38, 201, 176, 38, 201, 177, 5]
        self.assertEqual(encoded["input_ids"]     ,				lowercase						)
        # decoding
        lowercase_      :Optional[Any]         =			tokenizer.decode(lowercase						)
        self.assertEqual(lowercase     ,				"[CLS]e è é ê ë[SEP]"						)

        # encode/decode, but with `encode` instead of `__call__`
        self.assertEqual(tokenizer.decode(tokenizer.encode("e è é ê ë"						)						)     ,				"[CLS]e è é ê ë[SEP]"						)





     def 							lowercase__				(			self		: Optional[Any]						):





        """simple docstring"""




        lowercase_      :Any         =			self.perceiver_tokenizer
        lowercase_      :List[Any]         =			["A long paragraph for summarization.", "Another paragraph for summarization."]
        # fmt: off
        lowercase_      :Optional[Any]         =			[4, 71, 38, 114, 117, 116, 109, 38, 118, 103, 120, 103, 109, 120, 103, 118, 110, 38, 108, 117, 120, 38, 121, 123, 115, 115, 103, 120, 111, 128, 103, 122, 111, 117, 116, 52, 5, 0]
        # fmt: on
        lowercase_      :Dict         =			tokenizer(lowercase     ,				padding=lowercase     ,				return_tensors=lowercase						)
        self.assertIsInstance(lowercase     ,				lowercase						)

        if FRAMEWORK != "jax":
           lowercase_      :Union[str, Any]         =			list(batch.input_ids.numpy()[0]						)
        else:
           lowercase_      :Any         =			list(batch.input_ids.tolist()[0]						)

        self.assertListEqual(lowercase     ,				lowercase						)

        self.assertEqual((2, 38)     ,				batch.input_ids.shape						)
        self.assertEqual((2, 38)     ,				batch.attention_mask.shape						)





     def 							lowercase__				(			self		: Tuple						):





        """simple docstring"""




        lowercase_      :Tuple         =			self.perceiver_tokenizer
        lowercase_      :Optional[int]         =			["A long paragraph for summarization.", "Another paragraph for summarization."]
        lowercase_      :List[str]         =			tokenizer(lowercase     ,				padding=lowercase     ,				return_tensors=lowercase						)
        # check if input_ids are returned and no decoder_input_ids
        self.assertIn("input_ids"     ,				lowercase						)
        self.assertIn("attention_mask"     ,				lowercase						)
        self.assertNotIn("decoder_input_ids"     ,				lowercase						)
        self.assertNotIn("decoder_attention_mask"     ,				lowercase						)





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





        """simple docstring"""




        lowercase_      :Tuple         =			self.perceiver_tokenizer
        lowercase_      :int         =			[
            "Summary of the text.",
            "Another summary.",
        ]
        lowercase_      :Union[str, Any]         =			tokenizer(
            text_target=lowercase     ,				max_length=32     ,				padding="max_length"     ,				truncation=lowercase     ,				return_tensors=lowercase						)
        self.assertEqual(32     ,				targets["input_ids"].shape[1]						)





     def 							lowercase__				(			self		: Dict						):





        """simple docstring"""




        lowercase_      :int         =			self.get_tokenizers()
        for tokenizer in tokenizers:
           with self.subTest(F'{tokenizer.__class__.__name__}'						):
              self.assertNotEqual(tokenizer.model_max_length     ,				42						)

        # Now let's start the test
        lowercase_      :Optional[Any]         =			self.get_tokenizers()
        for tokenizer in tokenizers:
           with self.subTest(F'{tokenizer.__class__.__name__}'						):
              # Isolate this from the other tests because we save additional tokens/etc
              lowercase_      :List[Any]         =			tempfile.mkdtemp()

              lowercase_      :Union[str, Any]         =			" He is very happy, UNwant\u00E9d,running"
              lowercase_      :Dict         =			tokenizer.encode(lowercase     ,				add_special_tokens=lowercase						)
              tokenizer.save_pretrained(lowercase						)

              lowercase_      :Dict         =			tokenizer.__class__.from_pretrained(lowercase						)
              lowercase_      :str         =			after_tokenizer.encode(lowercase     ,				add_special_tokens=lowercase						)
              self.assertListEqual(lowercase     ,				lowercase						)

              shutil.rmtree(lowercase						)

        lowercase_      :List[Any]         =			self.get_tokenizers(model_max_length=42						)
        for tokenizer in tokenizers:
           with self.subTest(F'{tokenizer.__class__.__name__}'						):
              # Isolate this from the other tests because we save additional tokens/etc
              lowercase_      :Tuple         =			tempfile.mkdtemp()

              lowercase_      :Optional[int]         =			" He is very happy, UNwant\u00E9d,running"
              tokenizer.add_tokens(["bim", "bambam"]						)
              lowercase_      :str         =			tokenizer.additional_special_tokens
              additional_special_tokens.append("new_additional_special_token"						)
              tokenizer.add_special_tokens({"additional_special_tokens": additional_special_tokens}						)
              lowercase_      :Tuple         =			tokenizer.encode(lowercase     ,				add_special_tokens=lowercase						)
              tokenizer.save_pretrained(lowercase						)

              lowercase_      :int         =			tokenizer.__class__.from_pretrained(lowercase						)
              lowercase_      :Tuple         =			after_tokenizer.encode(lowercase     ,				add_special_tokens=lowercase						)
              self.assertListEqual(lowercase     ,				lowercase						)
              self.assertIn("new_additional_special_token"     ,				after_tokenizer.additional_special_tokens						)
              self.assertEqual(after_tokenizer.model_max_length     ,				42						)

              lowercase_      :Tuple         =			tokenizer.__class__.from_pretrained(lowercase     ,				model_max_length=43						)
              self.assertEqual(tokenizer.model_max_length     ,				43						)

              shutil.rmtree(lowercase						)





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





        """simple docstring"""




        lowercase_      :int         =			[]
        if self.test_slow_tokenizer:
           tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())						)

        if self.test_rust_tokenizer:
           tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())						)

        for tokenizer_class, tokenizer_utils in tokenizer_list:
           with tempfile.TemporaryDirectory() as tmp_dir:
              tokenizer_utils.save_pretrained(lowercase						)

              with open(os.path.join(lowercase     ,				"special_tokens_map.json"						)     ,				encoding="utf-8"						) as json_file:
                 lowercase_      :List[Any]         =			json.load(lowercase						)

              with open(os.path.join(lowercase     ,				"tokenizer_config.json"						)     ,				encoding="utf-8"						) as json_file:
                 lowercase_      :Optional[Any]         =			json.load(lowercase						)

              lowercase_      :List[Any]         =			[F'<extra_id_{i}>' for i in range(125						)]

              lowercase_      :int         =			added_tokens_extra_ids + [
                  "an_additional_special_token"
              ]
              lowercase_      :List[Any]         =			added_tokens_extra_ids + [
                  "an_additional_special_token"
              ]

              with open(os.path.join(lowercase     ,				"special_tokens_map.json"						)     ,				"w"     ,				encoding="utf-8"						) as outfile:
                 json.dump(lowercase     ,				lowercase						)
              with open(os.path.join(lowercase     ,				"tokenizer_config.json"						)     ,				"w"     ,				encoding="utf-8"						) as outfile:
                 json.dump(lowercase     ,				lowercase						)

              # the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
              # into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
              # "special_tokens_map.json" files
              lowercase_      :Optional[int]         =			tokenizer_class.from_pretrained(
                  lowercase     ,				)
              self.assertIn(
                  "an_additional_special_token"     ,				tokenizer_without_change_in_init.additional_special_tokens						)
              self.assertEqual(
                  ["an_additional_special_token"]     ,				tokenizer_without_change_in_init.convert_ids_to_tokens(
                      tokenizer_without_change_in_init.convert_tokens_to_ids(["an_additional_special_token"]						)						)     ,				)

              # Now we test that we can change the value of additional_special_tokens in the from_pretrained
              lowercase_      :Union[str, Any]         =			added_tokens_extra_ids + [AddedToken("a_new_additional_special_token"     ,				lstrip=lowercase						)]
              lowercase_      :Optional[Any]         =			tokenizer_class.from_pretrained(
                  lowercase     ,				additional_special_tokens=lowercase     ,				)

              self.assertIn("a_new_additional_special_token"     ,				tokenizer.additional_special_tokens						)
              self.assertEqual(
                  ["a_new_additional_special_token"]     ,				tokenizer.convert_ids_to_tokens(
                      tokenizer.convert_tokens_to_ids(["a_new_additional_special_token"]						)						)     ,				)





     def 							lowercase__				(			self		: Tuple						):





        """simple docstring"""




        lowercase_      :int         =			self.perceiver_tokenizer
        self.assertEqual(tokenizer.decode([178]						)     ,				"�"						)





     def 							lowercase__				(			self		: Any						):





        """simple docstring"""




        pass





     def 							lowercase__				(			self		: Optional[Any]						):





        """simple docstring"""




        pass





     def 							lowercase__				(			self		: Optional[Any]						):





        """simple docstring"""




        pass





     def 							lowercase__				(			self		: Dict						):





        """simple docstring"""




        pass







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





        """simple docstring"""




        lowercase_      :Optional[int]         =			self.get_tokenizers(fast=lowercase     ,				do_lower_case=lowercase						)
        for tokenizer in tokenizers:
           with self.subTest(F'{tokenizer.__class__.__name__}'						):
              lowercase_      :Tuple         =			["[CLS]", "t", "h", "i", "s", " ", "i", "s", " ", "a", " ", "t", "e", "s", "t", "[SEP]"]
              lowercase_      :int         =			tokenizer.convert_tokens_to_string(lowercase						)

              self.assertIsInstance(lowercase     ,				lowercase						)









'''simple docstring'''


import sys

lowerCAmelCase :					List[Any] 							=(
    '''73167176531330624919225119674426574742355349194934'''
    '''96983520312774506326239578318016984801869478851843'''
    '''85861560789112949495459501737958331952853208805511'''
    '''12540698747158523863050715693290963295227443043557'''
    '''66896648950445244523161731856403098711121722383113'''
    '''62229893423380308135336276614282806444486645238749'''
    '''30358907296290491560440772390713810515859307960866'''
    '''70172427121883998797908792274921901699720888093776'''
    '''65727333001053367881220235421809751254540594752243'''
    '''52584907711670556013604839586446706324415722155397'''
    '''53697817977846174064955149290862569321978468622482'''
    '''83972241375657056057490261407972968652414535100474'''
    '''82166370484403199890008895243450658541227588666881'''
    '''16427171479924442928230863465674813919123162824586'''
    '''17866458359124566529476545682848912883142607690042'''
    '''24219022671055626321111109370544217506941658960408'''
    '''07198403850962455444362981230987879927244284909188'''
    '''84580156166097919133875499200524063689912560717606'''
    '''05886116467109405077541002256983155200055935729725'''
    '''71636269561882670428252483600823257530420752963450'''
)
def 							UpperCAmelCase_  (						__lowerCamelCase : str			):
   lowercase_      :List[str]         =			1
   for digit in s:
      product *= int(__lowerCamelCase			)
   return product
def 							UpperCAmelCase_  (						__lowerCamelCase : str = N			):
   lowercase_      :Any         =			-sys.maxsize - 1
   lowercase_      :int         =			n[:13]
   lowercase_      :Optional[int]         =			13
   while cur_index < len(__lowerCamelCase			) - 13:
      if int(n[cur_index]			) >= int(substr[0]			):
         lowercase_      :str         =			substr[1:] + n[cur_index]
         cur_index += 1
      else:
         lowercase_      :List[str]         =			max(__lowerCamelCase     ,str_eval(__lowerCamelCase			)			)
         lowercase_      :Any         =			n[cur_index : cur_index + 13]
         cur_index += 13
   return largest_product


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


