
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import pandas as pd
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

class TestTask(unittest.TestCase):
    def setUp(self):
        self.user_code = importlib.import_module('user_code')
        self.data = [
            {'date': '2024-01-15', 'type': 'deposit', 'amount': 2000},
            {'date': '2024-01-20', 'type': 'withdrawal', 'amount': 500},
            {'date': '2024-02-10', 'type': 'deposit', 'amount': 2200},
            {'date': '2024-02-12', 'type': 'withdrawal', 'amount': 300},
            {'date': '2024-03-05', 'type': 'deposit', 'amount': 2500},
            {'date': '2024-03-17', 'type': 'withdrawal', 'amount': 700},
            {'date': '2024-03-30', 'type': 'deposit', 'amount': 1000},
            {'date': '2024-01-25', 'type': 'deposit', 'amount': 1800},
            {'date': '2024-02-18', 'type': 'withdrawal', 'amount': 1000},
        ]
        self.df = pd.DataFrame(self.data)

    def test_grouping_and_summing(self):
        # Check that grouping and summing is correct
        importlib.reload(self.user_code)
        df = self.df.copy()
        # Run function but intercept plt.show
        plt.clf()
        orig_show = plt.show
        plt.show = lambda: None
        self.user_code.plot_monthly_transaction_volumes(df)
        # Reproduce expected
        df['date'] = pd.to_datetime(df['date'])
        df['month'] = df['date'].dt.to_period('M').astype(str)
        monthly = df.groupby(['month', 'type'])['amount'].sum().unstack(fill_value=0)
        expected_months = ['2024-01','2024-02','2024-03']
        expected_deposits = [3800, 2200, 3500]
        expected_withdrawals = [500, 1300, 700]
        # Get plotted lines
        ax = plt.gca()
        lines = ax.get_lines()
        found_months = False
        found_deposits = False
        found_withdrawals = False
        # Check that lines match expected x/y
        for line in lines:
            xdata = list(line.get_xdata())
            ydata = list(line.get_ydata())
            label = line.get_label().lower()
            if xdata == expected_months:
                found_months = True
            if label == 'deposits' and ydata == expected_deposits:
                found_deposits = True
            if label == 'withdrawals' and ydata == expected_withdrawals:
                found_withdrawals = True
        _dynamic_test(self, found_months, "Months on x-axis are correct", "Months on x-axis are not correct")
        _dynamic_test(self, found_deposits, "Deposit totals per month are correct", "Deposit totals per month are not correct")
        _dynamic_test(self, found_withdrawals, "Withdrawal totals per month are correct", "Withdrawal totals per month are not correct")
        plt.show = orig_show
        plt.clf()

    def test_handles_missing_data(self):
        # Remove all withdrawals from March, should show 0 for withdrawals in March
        importlib.reload(self.user_code)
        df = self.df.copy()
        df = df[~((df['type']=='withdrawal') & (df['date'].str.startswith('2024-03')))]
        plt.clf()
        orig_show = plt.show
        plt.show = lambda: None
        self.user_code.plot_monthly_transaction_volumes(df)
        ax = plt.gca()
        found_zero_withdrawal = False
        for line in ax.get_lines():
            label = line.get_label().lower()
            xdata = list(line.get_xdata())
            ydata = list(line.get_ydata())
            if label == 'withdrawals' and 0 in ydata:
                found_zero_withdrawal = True
        _dynamic_test(self, found_zero_withdrawal, "Handles missing withdrawal data with zero", "Does not show zero for missing withdrawal month")
        plt.show = orig_show
        plt.clf()

    def test_plot_labels_and_legend(self):
        importlib.reload(self.user_code)
        df = self.df.copy()
        plt.clf()
        orig_show = plt.show
        plt.show = lambda: None
        self.user_code.plot_monthly_transaction_volumes(df)
        ax = plt.gca()
        xlabel = ax.get_xlabel()
        ylabel = ax.get_ylabel()
        title = ax.get_title()
        legend = ax.get_legend()
        legend_labels = [t.get_text().lower() for t in legend.get_texts()] if legend else []
        _dynamic_test(self, xlabel and 'month' in xlabel.lower(), "X-axis labeled with 'Month'", "X-axis label is missing or incorrect")
        _dynamic_test(self, ylabel and 'amount' in ylabel.lower(), "Y-axis labeled with 'Total Amount'", "Y-axis label is missing or incorrect")
        _dynamic_test(self, title and 'monthly' in title.lower(), "Plot has a title with 'Monthly'", "Plot title is missing or incorrect")
        _dynamic_test(self, 'deposits' in legend_labels and 'withdrawals' in legend_labels, "Legend includes both 'Deposits' and 'Withdrawals'", "Legend does not include both 'Deposits' and 'Withdrawals'")
        plt.show = orig_show
        plt.clf()

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: Plot Monthly Transaction Volumes

Рішення