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

class TestTask(unittest.TestCase):
    def setUp(self):
        # Prepare reference data
        np.random.seed(42)
        self.asset_returns = np.random.normal(loc=[0.0005, 0.0007, 0.0003], scale=[0.01, 0.012, 0.008], size=(252, 3))
        self.portfolio_weights = np.array([0.4, 0.4, 0.2])
        self.correct_portfolio_returns = np.dot(self.asset_returns, self.portfolio_weights)
        self.correct_mean = np.mean(self.correct_portfolio_returns)
        self.correct_std = np.std(self.correct_portfolio_returns)

    def test_portfolio_returns_correct(self):
        import user_code
        portfolio_returns = getattr(user_code, 'portfolio_returns', None)
        _dynamic_test(
            self,
            portfolio_returns is not None and isinstance(portfolio_returns, np.ndarray) and np.allclose(portfolio_returns, self.correct_portfolio_returns, atol=1e-8),
            'Portfolio returns calculated correctly.',
            f'Portfolio returns not calculated correctly or missing. Got: {portfolio_returns}'
        )

    def test_mean_and_std(self):
        import user_code
        mean_return = getattr(user_code, 'mean_return', None)
        std_return = getattr(user_code, 'std_return', None)
        _dynamic_test(
            self,
            mean_return is not None and np.isclose(mean_return, self.correct_mean, atol=1e-8),
            'Mean of portfolio returns is correct.',
            f'Expected mean: {self.correct_mean}, got: {mean_return}'
        )
        _dynamic_test(
            self,
            std_return is not None and np.isclose(std_return, self.correct_std, atol=1e-8),
            'Standard deviation of portfolio returns is correct.',
            f'Expected std: {self.correct_std}, got: {std_return}'
        )

    def test_histogram_is_plotted(self):
        import user_code
        # Check if plt.hist was called with correct data
        # Monkeypatch plt.hist to intercept calls
        called = {'hist': False}
        orig_hist = plt.hist
        def fake_hist(data, *args, **kwargs):
            if isinstance(data, np.ndarray) and np.allclose(data, self.correct_portfolio_returns, atol=1e-8):
                called['hist'] = True
            return orig_hist(data, *args, **kwargs)
        plt.hist = fake_hist
        try:
            importlib.reload(user_code)
        finally:
            plt.hist = orig_hist
        _dynamic_test(
            self,
            called['hist'],
            'Histogram of portfolio returns is plotted.',
            'Histogram of portfolio returns was not plotted using correct data.'
        )

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: Simulate and Visualize Portfolio Diversification

Soluzione