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

class TestTask(unittest.TestCase):
    def setUp(self):
        # Sample DataFrame for testing
        self.data = {
            'Date': ['2024-06-01', '2024-06-01', '2024-06-02', '2024-06-02', '2024-06-03', '2024-06-03'],
            'Product': ['A', 'B', 'A', 'B', 'A', 'B'],
            'Sales': [120, 150, 130, 160, 140, 170]
        }
        self.df = pd.DataFrame(self.data)
        # Patch plt.show to prevent it from blocking
        self._original_show = plt.show
        plt.show = lambda *args, **kwargs: None

    def tearDown(self):
        plt.show = self._original_show

    def _get_dashboard_fig(self, user_code_module):
        # Clear any existing figures
        plt.close('all')
        # Call the user's function
        user_code_module.create_dashboard(self.df)
        # Get the current figure
        fig = plt.gcf()
        return fig

    def test_line_chart_sales_trend(self):
        import user_code
        importlib.reload(user_code)
        fig = self._get_dashboard_fig(user_code)
        axes = fig.get_axes()
        # First subplot should be line chart
        line_ax = axes[0] if len(axes) > 0 else None
        cond = False
        if line_ax:
            # Check if it has a line (Line2D)
            lines = line_ax.get_lines()
            if len(lines) > 0:
                xdata = lines[0].get_xdata()
                ydata = lines[0].get_ydata()
                # Should match groupby sales by date
                expected = self.df.groupby('Date')['Sales'].sum().values
                cond = all(y1 == y2 for y1, y2 in zip(ydata, expected))
        _dynamic_test(
            self,
            cond,
            "Line chart for sales trend over time is correct.",
            "Line chart for sales trend over time is missing or incorrect.",
        )

    def test_bar_chart_product_sales(self):
        import user_code
        importlib.reload(user_code)
        fig = self._get_dashboard_fig(user_code)
        axes = fig.get_axes()
        # Second subplot should be bar chart
        bar_ax = axes[1] if len(axes) > 1 else None
        cond = False
        if bar_ax:
            bars = bar_ax.patches
            expected = self.df.groupby('Product')['Sales'].sum()
            bar_dict = {bar.get_x() + bar.get_width()/2: bar.get_height() for bar in bars}
            # Get tick labels
            xticklabels = [tick.get_text() for tick in bar_ax.get_xticklabels()]
            heights = [bar.get_height() for bar in bars]
            # Check that the bar heights match expected values (order by label)
            expected_vals = [expected.get(label, None) for label in xticklabels if label in expected.index]
            if len(expected_vals) == len(heights) and all(abs(h - e) < 1e-6 for h, e in zip(heights, expected_vals)):
                cond = True
        _dynamic_test(
            self,
            cond,
            "Bar chart for product sales is correct.",
            "Bar chart for product sales is missing or incorrect.",
        )

    def test_charts_are_side_by_side(self):
        import user_code
        importlib.reload(user_code)
        fig = self._get_dashboard_fig(user_code)
        axes = fig.get_axes()
        cond = False
        if len(axes) == 2:
            pos0 = axes[0].get_position()
            pos1 = axes[1].get_position()
            # Check that the axes are horizontally arranged (side-by-side)
            cond = pos0.y0 == pos1.y0 and pos0.y1 == pos1.y1 and pos0.x1 < pos1.x0
        _dynamic_test(
            self,
            cond,
            "Charts are arranged as side-by-side subplots.",
            "Charts are not arranged as side-by-side subplots.",
        )

    def test_summary_statistics_displayed(self):
        import user_code
        importlib.reload(user_code)
        fig = self._get_dashboard_fig(user_code)
        # Check for a text box with summary stats
        found_stats = False
        for txt in fig.texts:
            val = txt.get_text()
            if (
                "Total Sales" in val
                and "Average Sales" in val
                and "Max Sales" in val
                and "Min Sales" in val
            ):
                found_stats = True
        _dynamic_test(
            self,
            found_stats,
            "Summary statistics are displayed on the dashboard.",
            "Summary statistics are not found on the dashboard.",
        )

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: Build a Visual Metrics Dashboard

解答