





'''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():
    a__							:							Any ='''pt'''
elif is_tf_available():
    a__							:							Tuple ='''tf'''
else:
    a__							:							List[str] ='''jax'''

class      snake_case     (    __lowerCamelCase			,       unittest.TestCase       ):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_	:					Any					=PerceiverTokenizer
 SCREAMING_SNAKE_CASE_	:					Optional[int]					=False






 def        _lowerCamelCase					(       self       :							int	):
        super().setUp()
        __UpperCamelCase       =  PerceiverTokenizer()
        tokenizer.save_pretrained(self.tmpdirname	)






 @cached_property
 def        _lowerCamelCase					(       self       :							Optional[Any]	):
        return PerceiverTokenizer.from_pretrained('deepmind/language-perceiver'	)






 def        _lowerCamelCase					(       self       :							str							,	**__A       :							Tuple	):
        return self.tokenizer_class.from_pretrained(self.tmpdirname							,	**__A	)






 def        _lowerCamelCase					(       self       :							List[str]							,	__A       :							Union[str, Any]							,	__A       :							Dict=False							,	__A       :							Any=2_0							,	__A       :							Tuple=5	):
        # XXX The default common tokenizer tests assume that every ID is decodable on its own.
        # This assumption is invalid for Perceiver because single bytes might not be
        # valid utf-8 (byte 128 for instance).
        # Here we're overriding the smallest possible method to provide
        # a clean sequence without making the same assumption.

        __UpperCamelCase       =  []
        for i in range(len(__A	)	):
               try:
                      __UpperCamelCase       =  tokenizer.decode([i]							,	clean_up_tokenization_spaces=__A	)
               except UnicodeDecodeError:
                      pass
               toks.append((i, tok)	)

        __UpperCamelCase       =  list(filter(lambda __A	: re.match(R'^[ a-zA-Z]+$'							,	t[1]	)							,	__A	)	)
        __UpperCamelCase       =  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:
               __UpperCamelCase       =  toks[:max_length]
        if min_length is not None and len(__A	) < min_length and len(__A	) > 0:
               while len(__A	) < min_length:
                      __UpperCamelCase       =  toks + toks
        # toks_str = [t[1] for t in toks]
        __UpperCamelCase       =  [t[0] for t in toks]

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






 def        _lowerCamelCase					(       self       :							Union[str, Any]	):
        __UpperCamelCase       =  self.perceiver_tokenizer
        __UpperCamelCase       =  'Unicode €.'
        __UpperCamelCase       =  tokenizer(__A	)
        __UpperCamelCase       =  [4, 9_1, 1_1_6, 1_1_1, 1_0_5, 1_1_7, 1_0_6, 1_0_7, 3_8, 2_3_2, 1_3_6, 1_7_8, 5_2, 5]
        self.assertEqual(encoded['input_ids']							,	__A	)

        # decoding
        __UpperCamelCase       =  tokenizer.decode(__A	)
        self.assertEqual(__A							,	'[CLS]Unicode €.[SEP]'	)

        __UpperCamelCase       =  tokenizer('e è é ê ë'	)
        __UpperCamelCase       =  [4, 1_0_7, 3_8, 2_0_1, 1_7_4, 3_8, 2_0_1, 1_7_5, 3_8, 2_0_1, 1_7_6, 3_8, 2_0_1, 1_7_7, 5]
        self.assertEqual(encoded['input_ids']							,	__A	)
        # decoding
        __UpperCamelCase       =  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        _lowerCamelCase					(       self       :							List[Any]	):
        __UpperCamelCase       =  self.perceiver_tokenizer
        __UpperCamelCase       =  ['A long paragraph for summarization.', 'Another paragraph for summarization.']
        # fmt: off
        __UpperCamelCase       =  [4, 7_1, 3_8, 1_1_4, 1_1_7, 1_1_6, 1_0_9, 3_8, 1_1_8, 1_0_3, 1_2_0, 1_0_3, 1_0_9, 1_2_0, 1_0_3, 1_1_8, 1_1_0, 3_8, 1_0_8, 1_1_7, 1_2_0, 3_8, 1_2_1, 1_2_3, 1_1_5, 1_1_5, 1_0_3, 1_2_0, 1_1_1, 1_2_8, 1_0_3, 1_2_2, 1_1_1, 1_1_7, 1_1_6, 5_2, 5, 0]
        # fmt: on
        __UpperCamelCase       =  tokenizer(__A							,	padding=__A							,	return_tensors=__A	)
        self.assertIsInstance(__A							,	__A	)

        if FRAMEWORK != "jax":
               __UpperCamelCase       =  list(batch.input_ids.numpy()[0]	)
        else:
               __UpperCamelCase       =  list(batch.input_ids.tolist()[0]	)

        self.assertListEqual(__A							,	__A	)

        self.assertEqual((2, 3_8)							,	batch.input_ids.shape	)
        self.assertEqual((2, 3_8)							,	batch.attention_mask.shape	)






 def        _lowerCamelCase					(       self       :							Dict	):
        __UpperCamelCase       =  self.perceiver_tokenizer
        __UpperCamelCase       =  ['A long paragraph for summarization.', 'Another paragraph for summarization.']
        __UpperCamelCase       =  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        _lowerCamelCase					(       self       :							List[Any]	):
        __UpperCamelCase       =  self.perceiver_tokenizer
        __UpperCamelCase       =  [
            'Summary of the text.',
            'Another summary.',
        ]
        __UpperCamelCase       =  tokenizer(
            text_target=__A							,	max_length=3_2							,	padding='max_length'							,	truncation=__A							,	return_tensors=__A	)
        self.assertEqual(3_2							,	targets['input_ids'].shape[1]	)






 def        _lowerCamelCase					(       self       :							Dict	):
        # safety check on max_len default value so we are sure the test works
        __UpperCamelCase       =  self.get_tokenizers()
        for tokenizer in tokenizers:
               with self.subTest(f'''{tokenizer.__class__.__name__}'''	):
                      self.assertNotEqual(tokenizer.model_max_length							,	4_2	)

        # Now let's start the test
        __UpperCamelCase       =  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
                      __UpperCamelCase       =  tempfile.mkdtemp()

                      __UpperCamelCase       =  ' He is very happy, UNwant\u00E9d,running'
                      __UpperCamelCase       =  tokenizer.encode(__A							,	add_special_tokens=__A	)
                      tokenizer.save_pretrained(__A	)

                      __UpperCamelCase       =  tokenizer.__class__.from_pretrained(__A	)
                      __UpperCamelCase       =  after_tokenizer.encode(__A							,	add_special_tokens=__A	)
                      self.assertListEqual(__A							,	__A	)

                      shutil.rmtree(__A	)

        __UpperCamelCase       =  self.get_tokenizers(model_max_length=4_2	)
        for tokenizer in tokenizers:
               with self.subTest(f'''{tokenizer.__class__.__name__}'''	):
                      # Isolate this from the other tests because we save additional tokens/etc
                      __UpperCamelCase       =  tempfile.mkdtemp()

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

                      __UpperCamelCase       =  tokenizer.__class__.from_pretrained(__A	)
                      __UpperCamelCase       =  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							,	4_2	)

                      __UpperCamelCase       =  tokenizer.__class__.from_pretrained(__A							,	model_max_length=4_3	)
                      self.assertEqual(tokenizer.model_max_length							,	4_3	)

                      shutil.rmtree(__A	)






 def        _lowerCamelCase					(       self       :							Any	):
        __UpperCamelCase       =  []
        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:
                             __UpperCamelCase       =  json.load(__A	)

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

                      __UpperCamelCase       =  [f'''<extra_id_{i}>''' for i in range(1_2_5	)]

                      __UpperCamelCase       =  added_tokens_extra_ids + [
                          'an_additional_special_token'
                      ]
                      __UpperCamelCase       =  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
                      __UpperCamelCase       =  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
                      __UpperCamelCase       =  added_tokens_extra_ids + [AddedToken('a_new_additional_special_token'							,	lstrip=__A	)]
                      __UpperCamelCase       =  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        _lowerCamelCase					(       self       :							Dict	):
        __UpperCamelCase       =  self.perceiver_tokenizer
        self.assertEqual(tokenizer.decode([1_7_8]	)							,	'�'	)






 def        _lowerCamelCase					(       self       :							Dict	):
        pass






 def        _lowerCamelCase					(       self       :							List[str]	):
        pass






 def        _lowerCamelCase					(       self       :							Tuple	):
        pass






 def        _lowerCamelCase					(       self       :							Optional[Any]	):
        pass






 def        _lowerCamelCase					(       self       :							str	):
        # The default common tokenizer tests uses invalid tokens for Perceiver that can only accept one-character
        # strings and special added tokens as tokens
        __UpperCamelCase       =  self.get_tokenizers(fast=__A							,	do_lower_case=__A	)
        for tokenizer in tokenizers:
               with self.subTest(f'''{tokenizer.__class__.__name__}'''	):
                      __UpperCamelCase       =  ['[CLS]', 't', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't', '[SEP]']
                      __UpperCamelCase       =  tokenizer.convert_tokens_to_string(__A	)

                      self.assertIsInstance(__A							,	__A	)




'''simple docstring'''
def 			a      (			__a   )  ->	"list[int]":



					'''simple docstring'''






					if upper_limit < 0:
										raise ValueError('''Limit for the Catalan sequence must be ≥ 0'''   )

					UpperCamelCase__   :Optional[Any]												= [0] * (upper_limit + 1)

					# Base case: C(0) = C(1) = 1
					UpperCamelCase__   :int												= 1
					if upper_limit > 0:
										UpperCamelCase__   :int												= 1

					# Recurrence relation: C(i) = sum(C(j).C(i-j-1)), from j = 0 to i
					for i in range(2 ,					upper_limit + 1   ):
										for j in range(__a   ):
															catalan_list[i] += catalan_list[j] * catalan_list[i - j - 1]

					return catalan_list


if __name__ == "__main__":
		print('''\n********* Catalan Numbers Using Dynamic Programming ************\n''')
		print('''\n*** Enter -1 at any time to quit ***''')
		print('''\nEnter the upper limit (≥ 0) for the Catalan number sequence: ''', end='''''')
		try:
				while True:
						__snake_case							      =     int(input().strip())
						if N < 0:
								print('''\n********* Goodbye!! ************''')
								break
						else:
								print(F"""The Catalan numbers from 0 through {N} are:""")
								print(catalan_numbers(N))
								print('''Try another upper limit for the sequence: ''', end='''''')
		except (NameError, ValueError):
				print('''\n********* Invalid input, goodbye! ************\n''')

		import doctest

		doctest.testmod()