





'''simple docstring'''






from __future__ import annotations






def   __A    (				a_    :	float   ,a_    :	float   ,a_    :	float						):






		if days_between_payments <= 0:
				raise ValueError("days_between_payments must be > 0"						)
		if daily_interest_rate < 0:
				raise ValueError("daily_interest_rate must be >= 0"						)
		if principal <= 0:
				raise ValueError("principal must be > 0"						)
		return principal * daily_interest_rate * days_between_payments






def   __A    (				a_    :	float   ,a_    :	float   ,a_    :	float   ,):






		if number_of_compounding_periods <= 0:
				raise ValueError("number_of_compounding_periods must be > 0"						)
		if nominal_annual_interest_rate_percentage < 0:
				raise ValueError("nominal_annual_interest_rate_percentage must be >= 0"						)
		if principal <= 0:
				raise ValueError("principal must be > 0"						)

		return principal * (
		    (1 + nominal_annual_interest_rate_percentage) ** number_of_compounding_periods
		    - 1
		)






def   __A    (				a_    :	float   ,a_    :	float   ,a_    :	float   ,):






		if number_of_years <= 0:
				raise ValueError("number_of_years must be > 0"						)
		if nominal_annual_percentage_rate < 0:
				raise ValueError("nominal_annual_percentage_rate must be >= 0"						)
		if principal <= 0:
				raise ValueError("principal must be > 0"						)

		return compound_interest(
		    _a   ,nominal_annual_percentage_rate / 3_6_5   ,number_of_years * 3_6_5						)


if __name__ == "__main__":
					import doctest

					doctest.testmod()






"""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


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


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

UpperCAmelCase													=50_003
UpperCAmelCase													=50_002





@require_sentencepiece
@require_tokenizers
class lowerCamelCase__   (				SCREAMING_SNAKE_CASE     ,   unittest.TestCase    ):



    '''simple docstring'''




    _lowerCamelCase					=   PLBartTokenizer
    _lowerCamelCase					=   None
    _lowerCamelCase					=   False




    def UpperCamelCase__		( self    )    ->      Tuple:
          super().setUp()

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




    def UpperCamelCase__		( self    )    ->      int:
          A				  =		PLBartTokenizer(lowerCamelCase_ ,language_codes="""base""" ,keep_accents=lowerCamelCase_    )

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

          self.assertListEqual(
              tokenizer.convert_tokens_to_ids(lowerCamelCase_    ) ,[value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]] ,)

          A				  =		tokenizer.tokenize("""I was born in 92000, and this is falsé."""    )
          self.assertListEqual(
              lowerCamelCase_ ,[
                  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""",
                  """é""",
                  """.""",
              ] ,)
          A				  =		tokenizer.convert_tokens_to_ids(lowerCamelCase_    )
          self.assertListEqual(
              lowerCamelCase_ ,[
                  value + tokenizer.fairseq_offset
                  for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
              ] ,)

          A				  =		tokenizer.convert_ids_to_tokens(lowerCamelCase_    )
          self.assertListEqual(
              lowerCamelCase_ ,[
                  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>""",
                  """.""",
              ] ,)

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

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

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




    def UpperCamelCase__		( self    )    ->      Optional[Any]:
          A				  =		PLBartTokenizer(lowerCamelCase_ ,language_codes="""multi""" ,keep_accents=lowerCamelCase_    )

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

          self.assertListEqual(
              tokenizer.convert_tokens_to_ids(lowerCamelCase_    ) ,[value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]] ,)

          A				  =		tokenizer.tokenize("""I was born in 92000, and this is falsé."""    )
          self.assertListEqual(
              lowerCamelCase_ ,[
                  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""",
                  """é""",
                  """.""",
              ] ,)
          A				  =		tokenizer.convert_tokens_to_ids(lowerCamelCase_    )
          self.assertListEqual(
              lowerCamelCase_ ,[
                  value + tokenizer.fairseq_offset
                  for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
              ] ,)

          A				  =		tokenizer.convert_ids_to_tokens(lowerCamelCase_    )
          self.assertListEqual(
              lowerCamelCase_ ,[
                  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>""",
                  """.""",
              ] ,)
          A				  =		tokenizer.vocab_size
          A				  =		[tokenizer.convert_ids_to_tokens(lowerCamelCase_    ) for x in range(end - 7 ,lowerCamelCase_    )]

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





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



    '''simple docstring'''




    _lowerCamelCase					=   '''uclanlp/plbart-python-en_XX'''
    _lowerCamelCase					=   [
        '''def maximum(a,b,c):NEW_LINE_INDENTreturn max([a,b,c])''',
        '''def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])''',
    ]
    _lowerCamelCase					=   [
        '''Returns the maximum value of a b c.''',
        '''Sums the values of a b c.''',
    ]
    _lowerCamelCase					=   [
        134,
        5452,
        33460,
        33441,
        33463,
        33465,
        33463,
        33449,
        988,
        20,
        33456,
        19,
        33456,
        771,
        39,
        4258,
        889,
        3318,
        33441,
        33463,
        33465,
        33463,
        33449,
        2471,
        2,
        PYTHON_CODE,
    ]




    @classmethod
    def UpperCamelCase__		( cls    )    ->      List[str]:
          A				  =		PLBartTokenizer.from_pretrained(
              cls.checkpoint_name ,language_codes="""base""" ,src_lang="""python""" ,tgt_lang="""en_XX"""    )
          A				  =		1
          return cls




    def UpperCamelCase__		( self    )    ->      Optional[int]:
          self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""__java__"""] ,5_0_0_0_1    )
          self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""__python__"""] ,5_0_0_0_2    )
          self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""__en_XX__"""] ,5_0_0_0_3    )




    def UpperCamelCase__		( self    )    ->      Optional[int]:
          A				  =		self.tokenizer.batch_encode_plus(self.src_text    ).input_ids[0]
          self.assertListEqual(self.expected_src_tokens ,lowerCamelCase_    )




    def UpperCamelCase__		( self    )    ->      str:
          self.assertIn(lowerCamelCase_ ,self.tokenizer.all_special_ids    )
          A				  =		[EN_CODE, 9_0_3_7, 3_3_4_4_2, 5_7, 7_5_2, 1_5_3, 1_4, 5_6, 1_8, 9, 2]
          A				  =		self.tokenizer.decode(lowerCamelCase_ ,skip_special_tokens=lowerCamelCase_    )
          A				  =		self.tokenizer.decode(generated_ids[1:] ,skip_special_tokens=lowerCamelCase_    )
          self.assertEqual(lowerCamelCase_ ,lowerCamelCase_    )
          self.assertNotIn(self.tokenizer.eos_token ,lowerCamelCase_    )




    def UpperCamelCase__		( self    )    ->      List[str]:
          A				  =		["""def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])""" * 2_0]
          self.assertIsInstance(src_text[0] ,lowerCamelCase_    )
          A				  =		1_0
          A				  =		self.tokenizer(lowerCamelCase_ ,max_length=lowerCamelCase_ ,truncation=lowerCamelCase_    ).input_ids[0]
          self.assertEqual(ids[-2] ,2    )
          self.assertEqual(ids[-1] ,lowerCamelCase_    )
          self.assertEqual(len(lowerCamelCase_    ) ,lowerCamelCase_    )




    def UpperCamelCase__		( self    )    ->      Any:
          self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["""<mask>""", """__java__"""]    ) ,[5_0_0_0_4, 5_0_0_0_1]    )




    def UpperCamelCase__		( self    )    ->      Optional[int]:
          A				  =		tempfile.mkdtemp()
          A				  =		self.tokenizer.fairseq_tokens_to_ids
          self.tokenizer.save_pretrained(lowerCamelCase_    )
          A				  =		PLBartTokenizer.from_pretrained(lowerCamelCase_    )
          self.assertDictEqual(new_tok.fairseq_tokens_to_ids ,lowerCamelCase_    )




    @require_torch
    def UpperCamelCase__		( self    )    ->      Optional[int]:
          A				  =		self.tokenizer(self.src_text ,text_target=self.tgt_text ,padding=lowerCamelCase_ ,return_tensors="""pt"""    )
          A				  =		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] ,lowerCamelCase_    )
          self.assertEqual(batch.decoder_input_ids[1][-1] ,2    )
          self.assertEqual(batch.labels[1][-2:].tolist() ,[2, EN_CODE]    )




    @require_torch
    def UpperCamelCase__		( self    )    ->      str:
          A				  =		self.tokenizer(
              self.src_text ,text_target=self.tgt_text ,padding=lowerCamelCase_ ,truncation=lowerCamelCase_ ,max_length=len(self.expected_src_tokens    ) ,return_tensors="""pt""" ,)
          A				  =		shift_tokens_right(batch["""labels"""] ,self.tokenizer.pad_token_id    )

          self.assertIsInstance(lowerCamelCase_ ,lowerCamelCase_    )

          self.assertEqual((2, 2_6) ,batch.input_ids.shape    )
          self.assertEqual((2, 2_6) ,batch.attention_mask.shape    )
          A				  =		batch.input_ids.tolist()[0]
          self.assertListEqual(self.expected_src_tokens ,lowerCamelCase_    )
          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 UpperCamelCase__		( self    )    ->      Tuple:
          A				  =		self.tokenizer(self.src_text ,padding=lowerCamelCase_ ,truncation=lowerCamelCase_ ,max_length=3 ,return_tensors="""pt"""    )
          A				  =		self.tokenizer(
              text_target=self.tgt_text ,padding=lowerCamelCase_ ,truncation=lowerCamelCase_ ,max_length=1_0 ,return_tensors="""pt"""    )
          A				  =		targets["""input_ids"""]
          A				  =		shift_tokens_right(lowerCamelCase_ ,self.tokenizer.pad_token_id    )

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




    @require_torch
    def UpperCamelCase__		( self    )    ->      List[Any]:
          A				  =		self.tokenizer._build_translation_inputs(
              """A test""" ,return_tensors="""pt""" ,src_lang="""en_XX""" ,tgt_lang="""java"""    )

          self.assertEqual(
              nested_simplify(lowerCamelCase_    ) ,{
                  # A, test, EOS, en_XX
                  """input_ids""": [[1_5_0, 2_4_2, 2, 5_0_0_0_3]],
                  """attention_mask""": [[1, 1, 1, 1]],
                  # java
                  """forced_bos_token_id""": 5_0_0_0_1,
              } ,)




