
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):
        # Prepare a sample DataFrame for all tests
        self.data = {
            'Date': pd.to_datetime([
                '2024-01-01', '2024-01-02', '2024-01-03', '2024-01-04', '2024-01-05',
                '2024-01-06', '2024-01-07', '2024-01-08', '2024-01-09', '2024-01-10'
            ]),
            'Amount': [100, 120, 110, 115, 105, 300, 95, 102, 99, 500],
            'CustomerID': ['A', 'A', 'B', 'B', 'C', 'C', 'D', 'D', 'E', 'E']
        }
        self.transactions = pd.DataFrame(self.data)

    def test_iqr_outlier_detection(self):
        import user_code
        importlib.reload(user_code)
        q1 = self.transactions['Amount'].quantile(0.25)
        q3 = self.transactions['Amount'].quantile(0.75)
        iqr = q3 - q1
        lower = q1 - 1.5 * iqr
        upper = q3 + 1.5 * iqr
        expected_outliers = self.transactions[(self.transactions['Amount'] < lower) | (self.transactions['Amount'] > upper)]
        # Patch plt.show to prevent plot display
        plt_show_backup = plt.show
        plt.show = lambda: None
        try:
            # Capture outlier mask from user function
            # We'll monkeypatch plt.scatter to capture colors
            scatter_calls = []
            orig_scatter = plt.Axes.scatter
            def fake_scatter(self, x, y, *args, **kwargs):
                scatter_calls.append({'x': list(x), 'y': list(y), 'color': kwargs.get('color', None)})
                return orig_scatter(self, x, y, *args, **kwargs)
            plt.Axes.scatter = fake_scatter
            user_code.visualize_and_highlight_outliers(self.transactions)
            plt.Axes.scatter = orig_scatter
        finally:
            plt.show = plt_show_backup
        # Find scatter calls with color 'red' (outliers)
        outlier_points = []
        for call in scatter_calls:
            if call['color'] == 'red':
                outlier_points.extend(zip(call['x'], call['y']))
        expected_points = list(zip(expected_outliers['Date'], expected_outliers['Amount']))
        _dynamic_test(
            self,
            set(outlier_points) == set(expected_points),
            "Outlier points are correctly detected and highlighted in red.",
            f"Expected outlier points: {expected_points}, got: {outlier_points}"
        )

    def test_scatter_plot_created(self):
        import user_code
        importlib.reload(user_code)
        plt_show_backup = plt.show
        plt.show = lambda: None
        scatter_call_count = {'count': 0}
        orig_scatter = plt.Axes.scatter
        def fake_scatter(self, x, y, *args, **kwargs):
            scatter_call_count['count'] += 1
            return orig_scatter(self, x, y, *args, **kwargs)
        plt.Axes.scatter = fake_scatter
        try:
            user_code.visualize_and_highlight_outliers(self.transactions)
        finally:
            plt.Axes.scatter = orig_scatter
            plt.show = plt_show_backup
        _dynamic_test(
            self,
            scatter_call_count['count'] >= 2,
            "Scatter plot is created for both normal and outlier points.",
            f"Expected at least 2 scatter calls, got {scatter_call_count['count']}"
        )

    def test_boxplot_by_customer(self):
        import user_code
        importlib.reload(user_code)
        plt_show_backup = plt.show
        plt.show = lambda: None
        boxplot_called = {'called': False}
        orig_boxplot = pd.DataFrame.boxplot
        def fake_boxplot(self, *args, **kwargs):
            if 'by' in kwargs and kwargs['by'] == 'CustomerID':
                boxplot_called['called'] = True
            return orig_boxplot(self, *args, **kwargs)
        pd.DataFrame.boxplot = fake_boxplot
        try:
            user_code.visualize_and_highlight_outliers(self.transactions)
        finally:
            pd.DataFrame.boxplot = orig_boxplot
            plt.show = plt_show_backup
        _dynamic_test(
            self,
            boxplot_called['called'],
            "Boxplot is generated grouped by CustomerID.",
            "Boxplot by CustomerID was not generated."
        )

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: Visualize and Highlight Outliers

Ratkaisu