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
import seaborn as sns

class TestTask(unittest.TestCase):
    def setUp(self):
        self.df = pd.DataFrame({
            "product": ["A", "A", "A", "B", "B", "B", "C", "C", "C"],
            "region": ["East", "West", "South", "East", "West", "South", "East", "West", "South"],
            "sales": [120, 90, 60, 150, 110, 80, 100, 70, 50]
        })
        import user_code
        importlib.reload(user_code)
        self.func = getattr(user_code, 'plot_product_region_sales', None)

    def test_function_exists(self):
        _dynamic_test(
            self,
            self.func is not None and callable(self.func),
            "Function 'plot_product_region_sales' exists and is callable.",
            "Function 'plot_product_region_sales' is missing or not callable."
        )

    def test_chart_type_and_axes(self):
        plt.close('all')
        g = self.func(self.df)
        # sns.catplot returns a FacetGrid — get axes directly from it
        ax = g.ax
        found_bar = any(
            isinstance(patch, matplotlib.patches.Rectangle) and patch.get_height() > 0
            for patch in ax.patches
        )
        xlabel = normalize_text(ax.get_xlabel())
        ylabel = normalize_text(ax.get_ylabel())
        found_x = xlabel == "region"
        found_y = ylabel in ("sales amount", "sales")
        _dynamic_test(
            self,
            found_bar and found_x and found_y,
            "Grouped bar chart with correct axes labels is created.",
            f"Expected grouped bar chart with 'region' x-axis and 'sales' y-axis, got x: '{xlabel}', y: '{ylabel}'."
        )

    def test_legend_title(self):
        plt.close('all')
        g = self.func(self.df)
        # In newer seaborn, add_legend() places legend on FacetGrid level (g.legend),
        # not on ax — check both locations
        leg = getattr(g, 'legend', None) or g.ax.get_legend()
        if leg is None:
            for ax in g.fig.get_axes():
                if ax.get_legend() is not None:
                    leg = ax.get_legend()
                    break
        legend_title = leg.get_title().get_text() if leg is not None else None
        _dynamic_test(
            self,
            legend_title is not None and normalize_text(legend_title) == "product",
            "Legend title is correctly set to 'Product'.",
            f"Legend title is missing or incorrect: '{legend_title}'"
        )

    def test_chart_title(self):
        plt.close('all')
        g = self.func(self.df)
        # suptitle lives on the FacetGrid's fig
        suptitle = g.fig._suptitle.get_text() if g.fig._suptitle else None
        _dynamic_test(
            self,
            suptitle is not None and "product" in normalize_text(suptitle) and "region" in normalize_text(suptitle),
            "Chart title includes 'Product' and 'Region'.",
            f"Chart title is missing or incomplete: '{suptitle}'"
        )

    def test_layout_adjusted(self):
        import user_code
        called = {'tight_layout': False}
        orig_tight_layout = plt.tight_layout
        def fake_tight_layout(*args, **kwargs):
            called['tight_layout'] = True
            return orig_tight_layout(*args, **kwargs)
        plt.tight_layout = fake_tight_layout
        try:
            plt.close('all')
            importlib.reload(user_code)
            func = getattr(user_code, 'plot_product_region_sales', None)
            func(self.df)
        finally:
            plt.tight_layout = orig_tight_layout
        _dynamic_test(
            self,
            called['tight_layout'],
            "Layout is adjusted using tight_layout.",
            "tight_layout was not called to adjust layout."
        )

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
    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 not assign_nodes:
        return code
    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: Visualize Product vs Region Sales

Solution