
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import pandas as pd
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def setUp(self):
        self.df = pd.DataFrame({
            'date': ['2024-01-01', '2024-01-02', '2024-01-03', '2024-01-04', '2024-01-05'],
            'value': [100, 110, 90, 92, 130]
        })
        self.df_neg = pd.DataFrame({
            'date': ['2024-01-01', '2024-01-02', '2024-01-03', '2024-01-04', '2024-01-05'],
            'value': [200, 180, 170, 190, 160]
        })
        self.df_none = pd.DataFrame({
            'date': ['2024-01-01', '2024-01-02', '2024-01-03'],
            'value': [50, 52, 51]
        })

    def test_identifies_all_significant_changes(self):
        import user_code
        importlib.reload(user_code)
        changes = user_code.extract_significant_changes(self.df, 15)
        _dynamic_test(
            self,
            isinstance(changes, list) and len(changes) == 2,
            "Function identifies all significant changes above threshold",
            f"Expected 2 significant changes, got {len(changes)}"
        )
        expected = [
            {'index': 2, 'prev_index': 1, 'prev_value': 110, 'current_value': 90, 'change': -20},
            {'index': 4, 'prev_index': 3, 'prev_value': 92, 'current_value': 130, 'change': 38}
        ]
        for i, exp in enumerate(expected):
            chg = changes[i]
            _dynamic_test(
                self,
                all(k in chg for k in exp),
                f"Returned dictionary for change {i} has all required keys",
                f"Missing keys in returned dictionary: {chg}"
            )
            _dynamic_test(
                self,
                chg['index'] == exp['index'] and chg['prev_index'] == exp['prev_index'],
                f"Correct index and prev_index for change {i}",
                f"Expected index {exp['index']}, prev_index {exp['prev_index']} but got {chg['index']}, {chg['prev_index']}"
            )
            _dynamic_test(
                self,
                chg['prev_value'] == exp['prev_value'] and chg['current_value'] == exp['current_value'],
                f"Correct values for change {i}",
                f"Expected prev {exp['prev_value']}, curr {exp['current_value']} but got {chg['prev_value']}, {chg['current_value']}"
            )
            _dynamic_test(
                self,
                chg['change'] == exp['change'],
                f"Correct change value for change {i}",
                f"Expected change {exp['change']}, got {chg['change']}"
            )
    
    def test_positive_and_negative_changes(self):
        import user_code
        importlib.reload(user_code)
        changes = user_code.extract_significant_changes(self.df_neg, 15)
        _dynamic_test(
            self,
            isinstance(changes, list),
            "Function returns a list for negative changes",
            f"Expected a list, got {type(changes)}"
        )
        self.assertGreaterEqual(len(changes), 1)
        found_neg = any(chg['change'] < 0 for chg in changes)
        found_pos = any(chg['change'] > 0 for chg in changes)
        _dynamic_test(
            self,
            found_neg and found_pos,
            "Function handles both positive and negative significant changes",
            "Function did not detect both positive and negative significant changes"
        )

    def test_returns_empty_when_no_significant_change(self):
        import user_code
        importlib.reload(user_code)
        changes = user_code.extract_significant_changes(self.df_none, 15)
        _dynamic_test(
            self,
            isinstance(changes, list) and len(changes) == 0,
            "Function returns empty list when no significant changes are found",
            f"Expected empty list, got {changes}"
        )

    def test_prints_summary_report(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.extract_significant_changes(self.df, 15)
        output = normalize_text(f.getvalue())
        expected1 = normalize_text("At 2, value changed from 110 to 90 (change: -20)")
        expected2 = normalize_text("At 4, value changed from 92 to 130 (change: 38)")
        _dynamic_test(
            self,
            expected1 in output and expected2 in output,
            "Summary report prints all significant changes",
            f"Expected lines not found in output: {output}"
        )

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

Advance your Python automation skills by learning to generate analytical summaries, business reports, and visual dashboards automatically. This course guides you through practical workflows for automating data analysis, reporting, and visualization tasks using Python, pandas, matplotlib, and seaborn.

Learn to automate the generation of analytical summaries, business reports, and visual dashboards using Python. Alternate between concept introduction and hands-on automation tasks for real-world reporting scenarios.

Challenge: Extract and Report Key Insights

Ratkaisu