



"""simple docstring"""





def      a__			(   lowerCAmelCase__ = 1000   ):
      UpperCAmelCase_				,					UpperCAmelCase_    				=							1, 1
      UpperCAmelCase_    				=							[]
      for i in range(1			,    n + 1   ):
            UpperCAmelCase_    				=							prev_numerator + 2 * prev_denominator
            UpperCAmelCase_    				=							prev_numerator + prev_denominator
            if len(str(lowerCAmelCase__   )   ) > len(str(lowerCAmelCase__   )   ):
                  result.append(lowerCAmelCase__   )
            UpperCAmelCase_    				=							numerator
            UpperCAmelCase_    				=							denominator

      return len(lowerCAmelCase__   )


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









"""simple docstring"""





import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, PLBartTokenizer, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


lowerCamelCase      =		get_tests_dir("""fixtures/test_sentencepiece.model""")


if is_torch_available():
  from transformers.models.plbart.modeling_plbart import shift_tokens_right

lowerCamelCase      =		50_003
lowerCamelCase      =		50_002
@require_sentencepiece
@require_tokenizers
class    lowercase__     (					SCREAMING_SNAKE_CASE       ,      unittest.TestCase   ):







       '''simple docstring'''


       UpperCamelCase		=  PLBartTokenizer
       UpperCamelCase		=  None
       UpperCamelCase		=  False



       def   lowercase__       (							self    :						str					)				->		List[Any]:


             '''simple docstring'''




             super().setUp()

             # We have a SentencePiece fixture for testing
             UpperCAmelCase_    				=							PLBartTokenizer(_UpperCAmelCase	,       language_codes="base"	,       keep_accents=_UpperCAmelCase					)
             tokenizer.save_pretrained(self.tmpdirname					)



       def   lowercase__       (							self    :						Optional[int]					)				->		Optional[Any]:


             '''simple docstring'''




             UpperCAmelCase_    				=							PLBartTokenizer(_UpperCAmelCase	,       language_codes="base"	,       keep_accents=_UpperCAmelCase					)

             UpperCAmelCase_    				=							tokenizer.tokenize("This is a test"					)
             self.assertListEqual(_UpperCAmelCase	,       ["▁This", "▁is", "▁a", "▁t", "est"]					)

             self.assertListEqual(
                 tokenizer.convert_tokens_to_ids(_UpperCAmelCase					)	,       [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]	,       )

             UpperCAmelCase_    				=							tokenizer.tokenize("I was born in 92000, and this is falsé."					)
             self.assertListEqual(
                 _UpperCAmelCase	,       [
                     SPIECE_UNDERLINE + "I",
                     SPIECE_UNDERLINE + "was",
                     SPIECE_UNDERLINE + "b",
                     "or",
                     "n",
                     SPIECE_UNDERLINE + "in",
                     SPIECE_UNDERLINE + "",
                     "9",
                     "2",
                     "0",
                     "0",
                     "0",
                     ",",
                     SPIECE_UNDERLINE + "and",
                     SPIECE_UNDERLINE + "this",
                     SPIECE_UNDERLINE + "is",
                     SPIECE_UNDERLINE + "f",
                     "al",
                     "s",
                     "é",
                     ".",
                 ]	,       )
             UpperCAmelCase_    				=							tokenizer.convert_tokens_to_ids(_UpperCAmelCase					)
             self.assertListEqual(
                 _UpperCAmelCase	,       [
                     value + tokenizer.fairseq_offset
                     for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
                 ]	,       )

             UpperCAmelCase_    				=							tokenizer.convert_ids_to_tokens(_UpperCAmelCase					)
             self.assertListEqual(
                 _UpperCAmelCase	,       [
                     SPIECE_UNDERLINE + "I",
                     SPIECE_UNDERLINE + "was",
                     SPIECE_UNDERLINE + "b",
                     "or",
                     "n",
                     SPIECE_UNDERLINE + "in",
                     SPIECE_UNDERLINE + "",
                     "<unk>",
                     "2",
                     "0",
                     "0",
                     "0",
                     ",",
                     SPIECE_UNDERLINE + "and",
                     SPIECE_UNDERLINE + "this",
                     SPIECE_UNDERLINE + "is",
                     SPIECE_UNDERLINE + "f",
                     "al",
                     "s",
                     "<unk>",
                     ".",
                 ]	,       )

             UpperCAmelCase_    				=							tokenizer.vocab_size
             UpperCAmelCase_    				=							[tokenizer.convert_ids_to_tokens(_UpperCAmelCase					) for x in range(end - 4	,       _UpperCAmelCase					)]

             self.assertListEqual(_UpperCAmelCase	,       ["__java__", "__python__", "__en_XX__", "<mask>"]					)

             UpperCAmelCase_    				=							"java.lang.Exception, python.lang.Exception, javascript, php, ruby, go"
             UpperCAmelCase_    				=							tokenizer(_UpperCAmelCase					).input_ids
             self.assertEqual(
                 tokenizer.decode(_UpperCAmelCase	,       skip_special_tokens=_UpperCAmelCase	,       clean_up_tokenization_spaces=_UpperCAmelCase					)	,       _UpperCAmelCase	,       )







       def   lowercase__       (							self    :						Optional[Any]					)				->		int:


             '''simple docstring'''




             UpperCAmelCase_    				=							PLBartTokenizer(_UpperCAmelCase	,       language_codes="multi"	,       keep_accents=_UpperCAmelCase					)

             UpperCAmelCase_    				=							tokenizer.tokenize("This is a test"					)
             self.assertListEqual(_UpperCAmelCase	,       ["▁This", "▁is", "▁a", "▁t", "est"]					)

             self.assertListEqual(
                 tokenizer.convert_tokens_to_ids(_UpperCAmelCase					)	,       [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]	,       )

             UpperCAmelCase_    				=							tokenizer.tokenize("I was born in 92000, and this is falsé."					)
             self.assertListEqual(
                 _UpperCAmelCase	,       [
                     SPIECE_UNDERLINE + "I",
                     SPIECE_UNDERLINE + "was",
                     SPIECE_UNDERLINE + "b",
                     "or",
                     "n",
                     SPIECE_UNDERLINE + "in",
                     SPIECE_UNDERLINE + "",
                     "9",
                     "2",
                     "0",
                     "0",
                     "0",
                     ",",
                     SPIECE_UNDERLINE + "and",
                     SPIECE_UNDERLINE + "this",
                     SPIECE_UNDERLINE + "is",
                     SPIECE_UNDERLINE + "f",
                     "al",
                     "s",
                     "é",
                     ".",
                 ]	,       )
             UpperCAmelCase_    				=							tokenizer.convert_tokens_to_ids(_UpperCAmelCase					)
             self.assertListEqual(
                 _UpperCAmelCase	,       [
                     value + tokenizer.fairseq_offset
                     for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
                 ]	,       )

             UpperCAmelCase_    				=							tokenizer.convert_ids_to_tokens(_UpperCAmelCase					)
             self.assertListEqual(
                 _UpperCAmelCase	,       [
                     SPIECE_UNDERLINE + "I",
                     SPIECE_UNDERLINE + "was",
                     SPIECE_UNDERLINE + "b",
                     "or",
                     "n",
                     SPIECE_UNDERLINE + "in",
                     SPIECE_UNDERLINE + "",
                     "<unk>",
                     "2",
                     "0",
                     "0",
                     "0",
                     ",",
                     SPIECE_UNDERLINE + "and",
                     SPIECE_UNDERLINE + "this",
                     SPIECE_UNDERLINE + "is",
                     SPIECE_UNDERLINE + "f",
                     "al",
                     "s",
                     "<unk>",
                     ".",
                 ]	,       )
             UpperCAmelCase_    				=							tokenizer.vocab_size
             UpperCAmelCase_    				=							[tokenizer.convert_ids_to_tokens(_UpperCAmelCase					) for x in range(end - 7	,       _UpperCAmelCase					)]

             self.assertListEqual(
                 _UpperCAmelCase	,       ["__java__", "__python__", "__en_XX__", "__javascript__", "__php__", "__ruby__", "__go__"]					)
             UpperCAmelCase_    				=							"java.lang.Exception, python.lang.Exception, javascript, php, ruby, go"
             UpperCAmelCase_    				=							tokenizer(_UpperCAmelCase					).input_ids
             self.assertEqual(
                 tokenizer.decode(_UpperCAmelCase	,       skip_special_tokens=_UpperCAmelCase	,       clean_up_tokenization_spaces=_UpperCAmelCase					)	,       _UpperCAmelCase	,       )



@require_torch
@require_sentencepiece
@require_tokenizers
class    lowercase__     (					unittest.TestCase   ):







       '''simple docstring'''


       UpperCamelCase		=  '''uclanlp/plbart-python-en_XX'''
       UpperCamelCase		=  [
           '''def maximum(a,b,c):NEW_LINE_INDENTreturn max([a,b,c])''',
           '''def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])''',
       ]
       UpperCamelCase		=  [
           '''Returns the maximum value of a b c.''',
           '''Sums the values of a b c.''',
       ]
       UpperCamelCase		=  [
           1_34,
           54_52,
           3_34_60,
           3_34_41,
           3_34_63,
           3_34_65,
           3_34_63,
           3_34_49,
           9_88,
           20,
           3_34_56,
           19,
           3_34_56,
           7_71,
           39,
           42_58,
           8_89,
           33_18,
           3_34_41,
           3_34_63,
           3_34_65,
           3_34_63,
           3_34_49,
           24_71,
           2,
           PYTHON_CODE,
       ]



       @classmethod
       def   lowercase__       (							cls    :						int					)				->		Dict:


             '''simple docstring'''




             UpperCAmelCase_    				=							PLBartTokenizer.from_pretrained(
                 cls.checkpoint_name	,       language_codes="base"	,       src_lang="python"	,       tgt_lang="en_XX"					)
             UpperCAmelCase_    				=							1
             return cls



       def   lowercase__       (							self    :						List[Any]					)				->		Optional[Any]:


             '''simple docstring'''




             self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["__java__"]	,       50001					)
             self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["__python__"]	,       50002					)
             self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["__en_XX__"]	,       50003					)



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


             '''simple docstring'''




             UpperCAmelCase_    				=							self.tokenizer.batch_encode_plus(self.src_text					).input_ids[0]
             self.assertListEqual(self.expected_src_tokens	,       _UpperCAmelCase					)



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


             '''simple docstring'''




             self.assertIn(_UpperCAmelCase	,       self.tokenizer.all_special_ids					)
             UpperCAmelCase_    				=							[EN_CODE, 9037, 33442, 57, 752, 153, 14, 56, 18, 9, 2]
             UpperCAmelCase_    				=							self.tokenizer.decode(_UpperCAmelCase	,       skip_special_tokens=_UpperCAmelCase					)
             UpperCAmelCase_    				=							self.tokenizer.decode(generated_ids[1:]	,       skip_special_tokens=_UpperCAmelCase					)
             self.assertEqual(_UpperCAmelCase	,       _UpperCAmelCase					)
             self.assertNotIn(self.tokenizer.eos_token	,       _UpperCAmelCase					)



       def   lowercase__       (							self    :						int					)				->		int:


             '''simple docstring'''




             UpperCAmelCase_    				=							["def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])" * 20]
             self.assertIsInstance(src_text[0]	,       _UpperCAmelCase					)
             UpperCAmelCase_    				=							10
             UpperCAmelCase_    				=							self.tokenizer(_UpperCAmelCase	,       max_length=_UpperCAmelCase	,       truncation=_UpperCAmelCase					).input_ids[0]
             self.assertEqual(ids[-2]	,       2					)
             self.assertEqual(ids[-1]	,       _UpperCAmelCase					)
             self.assertEqual(len(_UpperCAmelCase					)	,       _UpperCAmelCase					)



       def   lowercase__       (							self    :						Optional[Any]					)				->		Optional[int]:


             '''simple docstring'''




             self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["<mask>", "__java__"]					)	,       [50004, 50001]					)



       def   lowercase__       (							self    :						Optional[Any]					)				->		List[str]:


             '''simple docstring'''




             UpperCAmelCase_    				=							tempfile.mkdtemp()
             UpperCAmelCase_    				=							self.tokenizer.fairseq_tokens_to_ids
             self.tokenizer.save_pretrained(_UpperCAmelCase					)
             UpperCAmelCase_    				=							PLBartTokenizer.from_pretrained(_UpperCAmelCase					)
             self.assertDictEqual(new_tok.fairseq_tokens_to_ids	,       _UpperCAmelCase					)



       @require_torch
       def   lowercase__       (							self    :						Optional[int]					)				->		List[Any]:


             '''simple docstring'''




             UpperCAmelCase_    				=							self.tokenizer(self.src_text	,       text_target=self.tgt_text	,       padding=_UpperCAmelCase	,       return_tensors="pt"					)
             UpperCAmelCase_    				=							shift_tokens_right(batch["labels"]	,       self.tokenizer.pad_token_id					)

             # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
             self.assertEqual(batch.input_ids[1][-2:].tolist()	,       [2, PYTHON_CODE]					)
             self.assertEqual(batch.decoder_input_ids[1][0]	,       _UpperCAmelCase					)
             self.assertEqual(batch.decoder_input_ids[1][-1]	,       2					)
             self.assertEqual(batch.labels[1][-2:].tolist()	,       [2, EN_CODE]					)



       @require_torch
       def   lowercase__       (							self    :						int					)				->		str:


             '''simple docstring'''




             UpperCAmelCase_    				=							self.tokenizer(
                 self.src_text	,       text_target=self.tgt_text	,       padding=_UpperCAmelCase	,       truncation=_UpperCAmelCase	,       max_length=len(self.expected_src_tokens					)	,       return_tensors="pt"	,       )
             UpperCAmelCase_    				=							shift_tokens_right(batch["labels"]	,       self.tokenizer.pad_token_id					)

             self.assertIsInstance(_UpperCAmelCase	,       _UpperCAmelCase					)

             self.assertEqual((2, 26)	,       batch.input_ids.shape					)
             self.assertEqual((2, 26)	,       batch.attention_mask.shape					)
             UpperCAmelCase_    				=							batch.input_ids.tolist()[0]
             self.assertListEqual(self.expected_src_tokens	,       _UpperCAmelCase					)
             self.assertEqual(2	,       batch.decoder_input_ids[0, -1]					)  # EOS
             # Test that special tokens are reset
             self.assertEqual(self.tokenizer.prefix_tokens	,       []					)
             self.assertEqual(self.tokenizer.suffix_tokens	,       [self.tokenizer.eos_token_id, PYTHON_CODE]					)



       def   lowercase__       (							self    :						List[Any]					)				->		List[Any]:


             '''simple docstring'''




             UpperCAmelCase_    				=							self.tokenizer(self.src_text	,       padding=_UpperCAmelCase	,       truncation=_UpperCAmelCase	,       max_length=3	,       return_tensors="pt"					)
             UpperCAmelCase_    				=							self.tokenizer(
                 text_target=self.tgt_text	,       padding=_UpperCAmelCase	,       truncation=_UpperCAmelCase	,       max_length=10	,       return_tensors="pt"					)
             UpperCAmelCase_    				=							targets["input_ids"]
             UpperCAmelCase_    				=							shift_tokens_right(_UpperCAmelCase	,       self.tokenizer.pad_token_id					)

             self.assertEqual(batch.input_ids.shape[1]	,       3					)
             self.assertEqual(batch.decoder_input_ids.shape[1]	,       10					)







       @require_torch
       def   lowercase__       (							self    :						Tuple					)				->		List[str]:


             '''simple docstring'''




             UpperCAmelCase_    				=							self.tokenizer._build_translation_inputs(
                 "A test"	,       return_tensors="pt"	,       src_lang="en_XX"	,       tgt_lang="java"					)

             self.assertEqual(
                 nested_simplify(_UpperCAmelCase					)	,       {
                     # A, test, EOS, en_XX
                     "input_ids": [[150, 242, 2, 50003]],
                     "attention_mask": [[1, 1, 1, 1]],
                     # java
                     "forced_bos_token_id": 50001,
                 }	,       )




