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

class TestTask(unittest.TestCase):
    def setUp(self):
        importlib.reload(user_code)
        self.df = getattr(user_code, 'df', None)

    def test_dataframe_shape(self):
        _dynamic_test(
            self,
            self.df is not None and self.df.shape == (15, 5),
            "DataFrame shape is correct (15, 5)",
            f"Expected DataFrame shape (15, 5), got {None if self.df is None else self.df.shape}"
        )

    def test_plot_lines_and_labels(self):
        # Clear previous figures
        plt.close('all')
        importlib.reload(user_code)
        # Get current figure
        fig = plt.gcf()
        ax = fig.axes[0] if fig.axes else None
        _dynamic_test(
            self,
            ax is not None,
            "A matplotlib Axes object was created.",
            "No Axes object found. Did you plot the chart?"
        )
        if ax is None:
            return
        lines = ax.get_lines()
        # There should be 4 lines
        _dynamic_test(
            self,
            len(lines) == 4,
            "Four lines are present on the chart.",
            f"Expected 4 lines on the chart, found {len(lines)}."
        )
        # Check legend labels
        legend = ax.get_legend()
        _dynamic_test(
            self,
            legend is not None,
            "Legend is present on the plot.",
            "Legend is missing. Did you call plt.legend()?"
        )
        if legend is not None:
            legend_labels = [t.get_text() for t in legend.get_texts()]
            expected_labels = {"AAPL", "GOOGL", "AMZN", "MSFT"}
            _dynamic_test(
                self,
                set(legend_labels) == expected_labels,
                "Legend labels are correct.",
                f"Legend labels incorrect. Got {legend_labels}, expected {expected_labels}."
            )
        # Check axis labels and title
        title = ax.get_title()
        xlabel = ax.get_xlabel()
        ylabel = ax.get_ylabel()
        _dynamic_test(
            self,
            len(title.strip()) > 0,
            "Plot has a title.",
            "Plot is missing a title."
        )
        _dynamic_test(
            self,
            len(xlabel.strip()) > 0 and len(ylabel.strip()) > 0,
            "Plot has axis labels.",
            f"Plot is missing axis labels: xlabel='{xlabel}', ylabel='{ylabel}'"
        )

    def test_distinct_lines(self):
        plt.close('all')
        importlib.reload(user_code)
        fig = plt.gcf()
        ax = fig.axes[0] if fig.axes else None
        if ax is None:
            _dynamic_test(
                self, False,
                "Plot is present for line style test.",
                "No plot found for line style test."
            )
            return
        lines = ax.get_lines()
        # Check that lines have distinct colors or line styles
        colors = [line.get_color() for line in lines]
        linestyles = [line.get_linestyle() for line in lines]
        # At least 2 unique colors or linestyles
        unique_colors = len(set(colors))
        unique_styles = len(set(linestyles))
        _dynamic_test(
            self,
            unique_colors > 1 or unique_styles > 1,
            "Lines are visually distinguishable (colors or linestyles).",
            f"Lines are not visually distinguishable: colors={colors}, linestyles={linestyles}"
        )

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

Unlock the power of Python to analyze financial data, evaluate investment opportunities, and automate key investor workflows. This course guides you through practical, real-world scenarios using Python, focusing on data analysis, visualization, and quantitative techniques relevant to investors.

Learn how to use Python to analyze and visualize financial data, focusing on the core skills investors need to interpret market trends and make informed decisions.

Dive deeper into key investment metrics and learn how to analyze and visualize portfolios using Python.

Apply advanced Python techniques to automate investment analysis and leverage statistical and machine learning tools for deeper insights.

Challenge: Visualize Multi-Stock Price Data

Solution