
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():
   lowercase_ 				=			"""pt"""
elif is_tf_available():
   lowercase_ 				=			"""tf"""
else:
   lowercase_ 				=			"""jax"""





class     __UpperCamelCase (							lowerCAmelCase__ ,						unittest.TestCase       ):






     """simple docstring"""







     lowerCAmelCase_							   =			PerceiverTokenizer
     lowerCAmelCase_							   =			False



     def  UpperCAmelCase__							(				self							:							List[str] ):







       """simple docstring"""




       super().setUp()
       __SCREAMING_SNAKE_CASE      :	Any					=		PerceiverTokenizer()
       tokenizer.save_pretrained(self.tmpdirname )



     @cached_property
     def  UpperCAmelCase__							(				self							:							str ):







       """simple docstring"""




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



     def  UpperCAmelCase__							(				self							:							int     ,						**_A							:							Any ):







       """simple docstring"""




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



     def  UpperCAmelCase__							(				self							:							Optional[Any]     ,						_A							:							Any     ,						_A							:							Union[str, Any]=False     ,						_A							:							str=20     ,						_A							:							int=5 ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	List[Any]					=		[]
       for i in range(len(_A ) ):
         try:
           __SCREAMING_SNAKE_CASE      :	Any					=		tokenizer.decode([i]     ,						clean_up_tokenization_spaces=_A )
         except UnicodeDecodeError:
           pass
         toks.append((i, tok) )

       __SCREAMING_SNAKE_CASE      :	int					=		list(filter(lambda _A : re.match(r'''^[ a-zA-Z]+$'''     ,						t[1] )     ,						_A ) )
       __SCREAMING_SNAKE_CASE      :	List[str]					=		list(filter(lambda _A : [t[0]] == tokenizer.encode(t[1]     ,						add_special_tokens=_A )     ,						_A ) )
       if max_length is not None and len(_A ) > max_length:
         __SCREAMING_SNAKE_CASE      :	List[str]					=		toks[:max_length]
       if min_length is not None and len(_A ) < min_length and len(_A ) > 0:
         while len(_A ) < min_length:
           __SCREAMING_SNAKE_CASE      :	Optional[int]					=		toks + toks
        # toks_str = [t[1] for t in toks]
       __SCREAMING_SNAKE_CASE      :	List[str]					=		[t[0] for t in toks]

       # Ensure consistency
       __SCREAMING_SNAKE_CASE      :	List[str]					=		tokenizer.decode(_A     ,						clean_up_tokenization_spaces=_A )
       if " " not in output_txt and len(_A ) > 1:
         __SCREAMING_SNAKE_CASE      :	int					=		(
             tokenizer.decode([toks_ids[0]]     ,						clean_up_tokenization_spaces=_A )
             + ''' '''
             + tokenizer.decode(toks_ids[1:]     ,						clean_up_tokenization_spaces=_A )
         )
       if with_prefix_space:
         __SCREAMING_SNAKE_CASE      :	Optional[int]					=		''' ''' + output_txt
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		tokenizer.encode(_A     ,						add_special_tokens=_A )
       return output_txt, output_ids



     def  UpperCAmelCase__							(				self							:							int ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Tuple					=		self.perceiver_tokenizer
       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		'''Unicode €.'''
       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		tokenizer(_A )
       __SCREAMING_SNAKE_CASE      :	Tuple					=		[4, 91, 116, 111, 105, 117, 106, 107, 38, 232, 136, 178, 52, 5]
       self.assertEqual(encoded['''input_ids''']     ,						_A )

       # decoding
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		tokenizer.decode(_A )
       self.assertEqual(_A     ,						'''[CLS]Unicode €.[SEP]''' )

       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		tokenizer('''e è é ê ë''' )
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		[4, 107, 38, 201, 174, 38, 201, 175, 38, 201, 176, 38, 201, 177, 5]
       self.assertEqual(encoded['''input_ids''']     ,						_A )
       # decoding
       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		tokenizer.decode(_A )
       self.assertEqual(_A     ,						'''[CLS]e è é ê ë[SEP]''' )

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



     def  UpperCAmelCase__							(				self							:							Any ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	List[Any]					=		self.perceiver_tokenizer
       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
       # fmt: off
       __SCREAMING_SNAKE_CASE      :	List[str]					=		[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
       __SCREAMING_SNAKE_CASE      :	Tuple					=		tokenizer(_A     ,						padding=_A     ,						return_tensors=_A )
       self.assertIsInstance(_A     ,						_A )

       if FRAMEWORK != "jax":
         __SCREAMING_SNAKE_CASE      :	List[str]					=		list(batch.input_ids.numpy()[0] )
       else:
         __SCREAMING_SNAKE_CASE      :	Optional[int]					=		list(batch.input_ids.tolist()[0] )

       self.assertListEqual(_A     ,						_A )

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



     def  UpperCAmelCase__							(				self							:							Optional[int] ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		self.perceiver_tokenizer
       __SCREAMING_SNAKE_CASE      :	Tuple					=		['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		tokenizer(_A     ,						padding=_A     ,						return_tensors=_A )
       # check if input_ids are returned and no decoder_input_ids
       self.assertIn('''input_ids'''     ,						_A )
       self.assertIn('''attention_mask'''     ,						_A )
       self.assertNotIn('''decoder_input_ids'''     ,						_A )
       self.assertNotIn('''decoder_attention_mask'''     ,						_A )



     def  UpperCAmelCase__							(				self							:							int ):







       """simple docstring"""




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



     def  UpperCAmelCase__							(				self							:							int ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	List[str]					=		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
       __SCREAMING_SNAKE_CASE      :	List[str]					=		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
           __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		tempfile.mkdtemp()

           __SCREAMING_SNAKE_CASE      :	Dict					=		''' He is very happy, UNwant\u00E9d,running'''
           __SCREAMING_SNAKE_CASE      :	List[str]					=		tokenizer.encode(_A     ,						add_special_tokens=_A )
           tokenizer.save_pretrained(_A )

           __SCREAMING_SNAKE_CASE      :	int					=		tokenizer.__class__.from_pretrained(_A )
           __SCREAMING_SNAKE_CASE      :	List[Any]					=		after_tokenizer.encode(_A     ,						add_special_tokens=_A )
           self.assertListEqual(_A     ,						_A )

           shutil.rmtree(_A )

       __SCREAMING_SNAKE_CASE      :	str					=		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
           __SCREAMING_SNAKE_CASE      :	int					=		tempfile.mkdtemp()

           __SCREAMING_SNAKE_CASE      :	List[Any]					=		''' He is very happy, UNwant\u00E9d,running'''
           tokenizer.add_tokens(['''bim''', '''bambam'''] )
           __SCREAMING_SNAKE_CASE      :	Dict					=		tokenizer.additional_special_tokens
           additional_special_tokens.append('''new_additional_special_token''' )
           tokenizer.add_special_tokens({'''additional_special_tokens''': additional_special_tokens} )
           __SCREAMING_SNAKE_CASE      :	Any					=		tokenizer.encode(_A     ,						add_special_tokens=_A )
           tokenizer.save_pretrained(_A )

           __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		tokenizer.__class__.from_pretrained(_A )
           __SCREAMING_SNAKE_CASE      :	List[Any]					=		after_tokenizer.encode(_A     ,						add_special_tokens=_A )
           self.assertListEqual(_A     ,						_A )
           self.assertIn('''new_additional_special_token'''     ,						after_tokenizer.additional_special_tokens )
           self.assertEqual(after_tokenizer.model_max_length     ,						42 )

           __SCREAMING_SNAKE_CASE      :	Optional[int]					=		tokenizer.__class__.from_pretrained(_A     ,						model_max_length=43 )
           self.assertEqual(tokenizer.model_max_length     ,						43 )

           shutil.rmtree(_A )



     def  UpperCAmelCase__							(				self							:							str ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Any					=		[]
       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(_A )

           with open(os.path.join(_A     ,						'''special_tokens_map.json''' )     ,						encoding='''utf-8''' ) as json_file:
             __SCREAMING_SNAKE_CASE      :	Any					=		json.load(_A )

           with open(os.path.join(_A     ,						'''tokenizer_config.json''' )     ,						encoding='''utf-8''' ) as json_file:
             __SCREAMING_SNAKE_CASE      :	Dict					=		json.load(_A )

           __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		[F'''<extra_id_{i}>''' for i in range(125 )]

           __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		added_tokens_extra_ids + [
               '''an_additional_special_token'''
           ]
           __SCREAMING_SNAKE_CASE      :	Any					=		added_tokens_extra_ids + [
               '''an_additional_special_token'''
           ]

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

           # 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
           __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		tokenizer_class.from_pretrained(
               _A     ,						)
           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
           __SCREAMING_SNAKE_CASE      :	str					=		added_tokens_extra_ids + [AddedToken('''a_new_additional_special_token'''     ,						lstrip=_A )]
           __SCREAMING_SNAKE_CASE      :	Optional[int]					=		tokenizer_class.from_pretrained(
               _A     ,						additional_special_tokens=_A     ,						)

           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  UpperCAmelCase__							(				self							:							Tuple ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Dict					=		self.perceiver_tokenizer
       self.assertEqual(tokenizer.decode([178] )     ,						'''�''' )



     def  UpperCAmelCase__							(				self							:							str ):







       """simple docstring"""




       pass



     def  UpperCAmelCase__							(				self							:							Tuple ):







       """simple docstring"""




       pass



     def  UpperCAmelCase__							(				self							:							Dict ):







       """simple docstring"""




       pass



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







       """simple docstring"""




       pass




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







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		self.get_tokenizers(fast=_A     ,						do_lower_case=_A )
       for tokenizer in tokenizers:
         with self.subTest(F'''{tokenizer.__class__.__name__}''' ):
           __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		['''[CLS]''', '''t''', '''h''', '''i''', '''s''', ''' ''', '''i''', '''s''', ''' ''', '''a''', ''' ''', '''t''', '''e''', '''s''', '''t''', '''[SEP]''']
           __SCREAMING_SNAKE_CASE      :	int					=		tokenizer.convert_tokens_to_string(_A )

           self.assertIsInstance(_A     ,						_A )


import math





def      lowerCamelCase_					(							lowerCamelCase__      ,					lowerCamelCase__       ):
				if 0 not in (x, y):
								# We use the relation x^y = y*log10(x), where 10 is the base.
								return y * math.logaa(lowerCamelCase__       )
				else:
								if x == 0:  # 0 raised to any number is 0
												return 0
								elif y == 0:
												return 1  # any number raised to 0 is 1
				raise AssertionError("This should never happen"       )


if __name__ == "__main__":  # Main function
			# Read two numbers from input and typecast them to int using map function.
			# Here x is the base and y is the power.
			__A							='''Enter the base and the power separated by a comma: '''
			__A,		__A							=map(int, input(prompt).split(''','''))
			__A,		__A							=map(int, input(prompt).split(''','''))

			# We find the log of each number, using the function res(), which takes two
			# arguments.
			__A							=res(xa, ya)
			__A							=res(xa, ya)

			# We check for the largest number
			if resa > resa:
						print('''Largest number is''', xa, '''^''', ya)
			elif resa > resa:
						print('''Largest number is''', xa, '''^''', ya)
			else:
						print('''Both are equal''')


