import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs




class    a__				(       snake_case_			):






     def __init__(			self		:		List[Any]  ,    a		:		int  ,    a		:		Tuple=None  ,    a		:		Optional[int]=True  ,    a		:		List[Any]=None  ,    **a		:		Optional[Any]   ):





         """simple docstring"""



         __lowerCamelCase          =  parent
         __lowerCamelCase          =  config_class
         __lowerCamelCase          =  has_text_modality
         __lowerCamelCase          =  kwargs
         __lowerCamelCase          =  common_properties






     def        SCREAMING_SNAKE_CASE__       (			self		:		List[str]   ):





         """simple docstring"""



         __lowerCamelCase          =  self.config_class(**self.inputs_dict   )
         __lowerCamelCase          =  (
             ['hidden_size', 'num_attention_heads', 'num_hidden_layers']
             if self.common_properties is None
             else self.common_properties
         )

         # Add common fields for text models
         if self.has_text_modality:
             common_properties.extend(['''vocab_size''']   )

         # Test that config has the common properties as getters
         for prop in common_properties:
             self.parent.assertTrue(hasattr(_A  ,    _A   )  ,    msg=f"""`{prop}` does not exist"""   )

         # Test that config has the common properties as setter
         for idx, name in enumerate(_A   ):
             try:
                 setattr(_A  ,    _A  ,    _A   )
                 self.parent.assertEqual(
                     getattr(_A  ,    _A   )  ,    _A  ,    msg=f"""`{name} value {idx} expected, but was {getattr(_A  ,    _A   )}"""   )
             except NotImplementedError:
                 # Some models might not be able to implement setters for common_properties
                 # In that case, a NotImplementedError is raised
                 pass

        # Test if config class can be called with Config(prop_name=..)
         for idx, name in enumerate(_A   ):
             try:
                 __lowerCamelCase          =  self.config_class(**{name: idx}   )
                 self.parent.assertEqual(
                     getattr(_A  ,    _A   )  ,    _A  ,    msg=f"""`{name} value {idx} expected, but was {getattr(_A  ,    _A   )}"""   )
             except NotImplementedError:
                 # Some models might not be able to implement setters for common_properties
                 # In that case, a NotImplementedError is raised
                 pass






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





         """simple docstring"""



         __lowerCamelCase          =  self.config_class(**self.inputs_dict   )
         __lowerCamelCase          =  json.loads(config.to_json_string()   )
         for key, value in self.inputs_dict.items():
             self.parent.assertEqual(obj[key]  ,    _A   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[int]   ):





         """simple docstring"""



         __lowerCamelCase          =  self.config_class(**self.inputs_dict   )

         with tempfile.TemporaryDirectory() as tmpdirname:
             __lowerCamelCase          =  os.path.join(_A  ,    '''config.json'''   )
             config_first.to_json_file(_A   )
             __lowerCamelCase          =  self.config_class.from_json_file(_A   )

         self.parent.assertEqual(config_second.to_dict()  ,    config_first.to_dict()   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Dict   ):





         """simple docstring"""



         __lowerCamelCase          =  self.config_class(**self.inputs_dict   )

         with tempfile.TemporaryDirectory() as tmpdirname:
             config_first.save_pretrained(_A   )
             __lowerCamelCase          =  self.config_class.from_pretrained(_A   )

         self.parent.assertEqual(config_second.to_dict()  ,    config_first.to_dict()   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Any   ):





         """simple docstring"""



         __lowerCamelCase          =  self.config_class(**self.inputs_dict   )

         __lowerCamelCase          =  'test'
         with tempfile.TemporaryDirectory() as tmpdirname:
             __lowerCamelCase          =  os.path.join(_A  ,    _A   )
             config_first.save_pretrained(_A   )
             __lowerCamelCase          =  self.config_class.from_pretrained(_A  ,    subfolder=_A   )

         self.parent.assertEqual(config_second.to_dict()  ,    config_first.to_dict()   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[int]   ):





         """simple docstring"""



         __lowerCamelCase          =  self.config_class(**self.inputs_dict  ,    num_labels=5   )
         self.parent.assertEqual(len(config.idalabel   )  ,    5   )
         self.parent.assertEqual(len(config.labelaid   )  ,    5   )

         __lowerCamelCase          =  3
         self.parent.assertEqual(len(config.idalabel   )  ,    3   )
         self.parent.assertEqual(len(config.labelaid   )  ,    3   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[int]   ):





         """simple docstring"""



         if self.config_class.is_composition:
             return
         __lowerCamelCase          =  self.config_class()
         self.parent.assertIsNotNone(_A   )






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





         """simple docstring"""



         __lowerCamelCase          =  copy.deepcopy(_A   )
         __lowerCamelCase          =  self.config_class(**_A   )
         __lowerCamelCase          =  []
         for key, value in config_common_kwargs.items():
             if key == "torch_dtype":
                 if not is_torch_available():
                     continue
                 else:
                     import torch

                     if config.torch_dtype != torch.floataa:
                         wrong_values.append(('''torch_dtype''', config.torch_dtype, torch.floataa)   )
             elif getattr(_A  ,    _A   ) != value:
                 wrong_values.append((key, getattr(_A  ,    _A   ), value)   )

         if len(_A   ) > 0:
             __lowerCamelCase          =  '\n'.join([f"""- {v[0]}: got {v[1]} instead of {v[2]}""" for v in wrong_values]   )
             raise ValueError(f"""The following keys were not properly set in the config:\n{errors}"""   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		int   ):





         """simple docstring"""



         self.create_and_test_config_common_properties()
         self.create_and_test_config_to_json_string()
         self.create_and_test_config_to_json_file()
         self.create_and_test_config_from_and_save_pretrained()
         self.create_and_test_config_from_and_save_pretrained_subfolder()
         self.create_and_test_config_with_num_labels()
         self.check_config_can_be_init_without_params()
         self.check_config_arguments_init()

'''simple docstring'''




def __lowerCAmelCase			(							UpperCamelCase__    ,  UpperCamelCase__    ,  UpperCamelCase__    )     ->   float:
    if principal <= 0:
        raise Exception('''Principal borrowed must be > 0'''    )
    if rate_per_annum < 0:
        raise Exception('''Rate of interest must be >= 0'''    )
    if years_to_repay <= 0 or not isinstance(UpperCamelCase__    ,  UpperCamelCase__    ):
        raise Exception('''Years to repay must be an integer > 0'''    )

    # Yearly rate is divided by 12 to get monthly rate
    __lowerCamelCase          =  rate_per_annum / 12

    # Years to repay is multiplied by 12 to get number of payments as payment is monthly
    __lowerCamelCase          =  years_to_repay * 12

    return (
        principal
        * rate_per_month
        * (1 + rate_per_month) ** number_of_payments
        / ((1 + rate_per_month) ** number_of_payments - 1)
    )


if __name__ == "__main__":
  import doctest

  doctest.testmod()
