
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import io
import pandas as pd

class TestTask(unittest.TestCase):
    def setUp(self):
        self.df = pd.DataFrame({
            'principal': [10000, 20000, 15000, 25000, 18000],
            'interest_rate': [0.05, 0.07, 0.09, 0.04, 0.08],
            'risk_score': [0.6, 0.8, 0.75, 0.65, 0.9]
        })

    def test_filter_high_risk_loans(self):
        import user_code
        importlib.reload(user_code)
        df = self.df.copy()
        # Capture output
        f = io.StringIO()
        sys.stdout = f
        user_code.analyze_high_risk_loans(df)
        sys.stdout = sys.__stdout__
        output = f.getvalue().strip().split('\\n')
        # High risk loans are rows with risk_score > 0.7: index 1,2,4
        expected_principal = 20000 + 15000 + 18000
        expected_avg_rate = (0.07 + 0.09 + 0.08)/3
        _dynamic_test(
            self,
            str(expected_principal) in output[0],
            "Correct total principal printed for high-risk loans",
            f"Expected total principal {expected_principal}, got {output[0]}"
        )
        _dynamic_test(
            self,
            abs(float(output[1]) - expected_avg_rate) < 1e-6,
            "Correct average interest rate printed for high-risk loans",
            f"Expected average interest rate {expected_avg_rate}, got {output[1]}"
        )

    def test_no_high_risk_loans(self):
        import user_code
        importlib.reload(user_code)
        # All risk_scores <= 0.7
        df = pd.DataFrame({
            'principal': [5000, 8000],
            'interest_rate': [0.03, 0.04],
            'risk_score': [0.5, 0.7]
        })
        f = io.StringIO()
        sys.stdout = f
        user_code.analyze_high_risk_loans(df)
        sys.stdout = sys.__stdout__
        output = f.getvalue().strip().split('\\n')
        # Should print 0 and nan
        _dynamic_test(
            self,
            output[0] == '0',
            "Prints 0 for total principal when no high-risk loans",
            f"Expected 0 for total principal, got {output[0]}"
        )
        _dynamic_test(
            self,
            output[1].lower() == 'nan',
            "Prints nan for average interest rate when no high-risk loans",
            f"Expected nan for average interest rate, got {output[1]}"
        )

    def test_all_high_risk_loans(self):
        import user_code
        importlib.reload(user_code)
        # All risk_scores > 0.7
        df = pd.DataFrame({
            'principal': [3000, 4000],
            'interest_rate': [0.1, 0.12],
            'risk_score': [0.8, 0.9]
        })
        f = io.StringIO()
        sys.stdout = f
        user_code.analyze_high_risk_loans(df)
        sys.stdout = sys.__stdout__
        output = f.getvalue().strip().split('\\n')
        expected_principal = 3000 + 4000
        expected_avg_rate = (0.1 + 0.12)/2
        _dynamic_test(
            self,
            str(expected_principal) in output[0],
            "Correct total principal when all loans are high-risk",
            f"Expected total principal {expected_principal}, got {output[0]}"
        )
        _dynamic_test(
            self,
            abs(float(output[1]) - expected_avg_rate) < 1e-6,
            "Correct average interest rate when all loans are high-risk",
            f"Expected average interest rate {expected_avg_rate}, got {output[1]}"
        )

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: Analyze Loan Portfolio Risk

Løsning