
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import pandas as pd
import math

class TestTask(unittest.TestCase):
    def setUp(self):
        self.user_code = importlib.import_module("user_code")

    def test_dataframe_row_count(self):
        importlib.reload(self.user_code)
        df = self.user_code.generate_amortization_schedule(10000, 5, 12)
        _dynamic_test(
            self,
            isinstance(df, pd.DataFrame) and len(df) == 12,
            "DataFrame has correct number of rows for 12 months",
            f"Expected 12 rows, got {len(df) if isinstance(df, pd.DataFrame) else 'not a DataFrame'}",
        )

    def test_monthly_payment_formula(self):
        importlib.reload(self.user_code)
        principal = 5000
        annual_rate = 6
        months = 18
        df = self.user_code.generate_amortization_schedule(principal, annual_rate, months)
        monthly_rate = annual_rate / 12 / 100
        expected_payment = principal * monthly_rate * (1 + monthly_rate) ** months / ((1 + monthly_rate) ** months - 1)
        if isinstance(df, pd.DataFrame) and "Payment" in df.columns:
            payments = df["Payment"].unique()
            _dynamic_test(
                self,
                len(payments) == 1 and math.isclose(payments[0], round(expected_payment, 2), abs_tol=0.01),
                "Monthly payment calculated using amortization formula",
                f"Expected payment: {round(expected_payment,2)}, got: {payments[0] if len(payments) > 0 else 'no payment column'}",
            )
        else:
            _dynamic_test(
                self,
                False,
                "DataFrame has 'Payment' column",
                "DataFrame missing 'Payment' column or not a DataFrame",
            )

    def test_payment_column_consistency(self):
        importlib.reload(self.user_code)
        principal = 8000
        annual_rate = 4.5
        months = 10
        df = self.user_code.generate_amortization_schedule(principal, annual_rate, months)
        monthly_rate = annual_rate / 12 / 100
        expected_payment = principal * monthly_rate * (1 + monthly_rate) ** months / ((1 + monthly_rate) ** months - 1)
        if isinstance(df, pd.DataFrame) and "Payment" in df.columns:
            correct = all(math.isclose(p, round(expected_payment, 2), abs_tol=0.01) for p in df["Payment"])
            _dynamic_test(
                self,
                correct,
                "Each row's 'Payment' column matches computed monthly payment (rounded to two decimals)",
                f"Some payment values do not match expected {round(expected_payment,2)}",
            )
        else:
            _dynamic_test(
                self,
                False,
                "DataFrame has 'Payment' column",
                "DataFrame missing 'Payment' column or not a DataFrame",
            )

    def test_sum_principal_equals_loan(self):
        importlib.reload(self.user_code)
        principal = 15000
        annual_rate = 7
        months = 36
        df = self.user_code.generate_amortization_schedule(principal, annual_rate, months)
        if isinstance(df, pd.DataFrame) and "Principal" in df.columns:
            principal_sum = df["Principal"].sum()
            _dynamic_test(
                self,
                math.isclose(principal_sum, principal, abs_tol=0.1),
                "Sum of all 'Principal' payments equals original principal (within rounding)",
                f"Expected sum {principal}, got {principal_sum}",
            )
        else:
            _dynamic_test(
                self,
                False,
                "DataFrame has 'Principal' column",
                "DataFrame missing 'Principal' column or not a DataFrame",
            )

    def test_final_balance_zero(self):
        importlib.reload(self.user_code)
        principal = 23000
        annual_rate = 3.2
        months = 48
        df = self.user_code.generate_amortization_schedule(principal, annual_rate, months)
        if isinstance(df, pd.DataFrame) and "Remaining Balance" in df.columns:
            last_balance = df["Remaining Balance"].iloc[-1]
            _dynamic_test(
                self,
                abs(last_balance) < 0.1,
                "Last row's 'Remaining Balance' is zero (within rounding)",
                f"Expected 0, got {last_balance}",
            )
        else:
            _dynamic_test(
                self,
                False,
                "DataFrame has 'Remaining Balance' column",
                "DataFrame missing 'Remaining Balance' column or not a DataFrame",
            )

    def test_interest_and_principal_breakdown(self):
        importlib.reload(self.user_code)
        principal = 10000
        annual_rate = 5
        months = 12
        df = self.user_code.generate_amortization_schedule(principal, annual_rate, months)
        monthly_rate = annual_rate / 12 / 100
        if isinstance(df, pd.DataFrame) and all(col in df.columns for col in ["Payment", "Principal", "Interest", "Remaining Balance"]):
            # Test first month breakdown
            interest1 = principal * monthly_rate
            payment = df["Payment"].iloc[0]
            principal1 = payment - interest1
            _dynamic_test(
                self,
                math.isclose(df["Interest"].iloc[0], round(interest1,2), abs_tol=0.01) and math.isclose(df["Principal"].iloc[0], round(principal1,2), abs_tol=0.01),
                "Interest and principal breakdowns are correct for first month",
                f"First month: Expected interest {round(interest1,2)}, principal {round(principal1,2)}; got {df['Interest'].iloc[0]}, {df['Principal'].iloc[0]}",
            )
        else:
            _dynamic_test(
                self,
                False,
                "DataFrame has all required columns",
                "DataFrame missing required columns or not a DataFrame",
            )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

A practical Python course tailored for banking professionals, focusing on real-world financial data analysis, risk assessment, and automation tasks. Learn how Python can streamline banking operations, analyze financial data, and solve common problems faced by bankers.

Learn how to use Python to analyze, manipulate, and visualize financial data relevant to banking operations.

Apply Python to assess credit risk, analyze loan portfolios, and perform key calculations relevant to banking risk management.

Explore how Python can automate banking tasks and help detect fraudulent activities using data analysis techniques.

Challenge: Generate Amortization Schedule

Oplossing