
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import pandas as pd
import numpy as np

class TestTask(unittest.TestCase):
    def setUp(self):
        # Prepare the expected DataFrame for cumulative returns
        self.data = {
            "Month": ["2023-01", "2023-02", "2023-03", "2023-04", "2023-05", "2023-06"],
            "Asset_A": [0.01, -0.02, 0.03, 0.02, 0.01, 0.04],
            "Asset_B": [0.02, 0.01, 0.00, -0.01, 0.03, 0.02],
            "Asset_C": [0.00, 0.03, -0.01, 0.01, 0.02, 0.03],
            "Portfolio": [0.013, 0.005, 0.01, 0.007, 0.019, 0.03],
        }
        self.df = pd.DataFrame(self.data)
        # Calculate expected cumulative returns
        for col in ["Asset_A", "Asset_B", "Asset_C", "Portfolio"]:
            self.df[f"cum_{col}"] = (1 + self.df[col]).cumprod()

    def test_cumulative_returns(self):
        import user_code
        importlib.reload(user_code)
        # Check that cumulative columns exist and are correct
        for col in ["Asset_A", "Asset_B", "Asset_C", "Portfolio"]:
            user_df = getattr(user_code, 'df', None)
            _dynamic_test(
                self,
                isinstance(user_df, pd.DataFrame),
                f"DataFrame 'df' exists.",
                f"DataFrame 'df' not found or wrong type."
            )
            user_cum = user_df.get(f"cum_{col}", None)
            expected_cum = self.df[f"cum_{col}"]
            _dynamic_test(
                self,
                user_cum is not None and np.allclose(user_cum.values, expected_cum.values, atol=1e-6),
                f"Cumulative returns for {col} are correct.",
                f"Cumulative returns for {col} are incorrect. Expected {expected_cum.values}, got {user_cum.values if user_cum is not None else None}."
            )

    def test_portfolio_outperforms_periods(self):
        import user_code
        importlib.reload(user_code)
        user_df = getattr(user_code, 'df', None)
        _dynamic_test(
            self,
            isinstance(user_df, pd.DataFrame),
            f"DataFrame 'df' exists.",
            f"DataFrame 'df' not found or wrong type."
        )
        # Find periods where portfolio outperforms all assets
        expected_outperform = (
            self.df["cum_Portfolio"] > self.df[["cum_Asset_A", "cum_Asset_B", "cum_Asset_C"]].max(axis=1)
        )
        user_outperform = (
            user_df["cum_Portfolio"] > user_df[["cum_Asset_A", "cum_Asset_B", "cum_Asset_C"]].max(axis=1)
        )
        _dynamic_test(
            self,
            np.all(expected_outperform.values == user_outperform.values),
            "Outperform periods are correctly identified.",
            f"Expected outperform periods {expected_outperform.values}, got {user_outperform.values}."
        )

    def test_plot_lines_exist(self):
        import user_code
        import matplotlib
        import matplotlib.pyplot as plt
        importlib.reload(user_code)
        # After running user_code, check current figure
        fig = plt.gcf()
        ax = plt.gca()
        lines = ax.get_lines()
        labels = [l.get_label() for l in lines]
        for label in ["Asset A", "Asset B", "Asset C", "Portfolio"]:
            _dynamic_test(
                self,
                label in labels,
                f"Plot includes line for {label}.",
                f"Plot missing line for {label}."
            )
        # Check title
        title = ax.get_title()
        _dynamic_test(
            self,
            "portfolio" in title.lower() and "cumulative" in title.lower(),
            "Plot title is descriptive.",
            f"Plot title '{title}' does not reference portfolio and cumulative returns."
        )

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: Plot Portfolio and Asset Growth

Soluzione