
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):
        self.returns = np.array([
            0.001, -0.002, 0.003, -0.004, 0.002, 0.001, -0.003, 0.004, -0.002, 0.003,
            0.002, -0.001, 0.001, -0.002, 0.003, -0.003, 0.002, 0.001, -0.001, 0.002
        ])
        self.confidence_level = 0.95
        self.expected_var = abs(np.percentile(self.returns, 100 * (1 - self.confidence_level)))

    def test_var_calculation_correctness(self):
        import user_code
        importlib.reload(user_code)
        var = user_code.calculate_var(self.returns, self.confidence_level)
        _dynamic_test(
            self,
            isinstance(var, float) or isinstance(var, np.floating),
            "VaR is returned as a float value.",
            f"VaR is not float. Got type: {type(var)}"
        )
        _dynamic_test(
            self,
            np.isclose(var, self.expected_var, atol=1e-8),
            f"VaR is correctly calculated: {var}",
            f"Expected VaR: {self.expected_var}, got: {var}"
        )

    def test_var_is_positive(self):
        import user_code
        importlib.reload(user_code)
        var = user_code.calculate_var(self.returns, self.confidence_level)
        _dynamic_test(
            self,
            var >= 0,
            "VaR is returned as a positive value.",
            f"VaR is not positive: {var}"
        )

    def test_var_with_different_confidence(self):
        import user_code
        importlib.reload(user_code)
        conf = 0.99
        expected = abs(np.percentile(self.returns, 100 * (1 - conf)))
        var = user_code.calculate_var(self.returns, conf)
        _dynamic_test(
            self,
            np.isclose(var, expected, atol=1e-8),
            f"VaR is correct for 99% confidence: {var}",
            f"Expected VaR: {expected}, got: {var}"
        )

    def test_plot_var(self):
        import user_code
        importlib.reload(user_code)
        var = user_code.calculate_var(self.returns, self.confidence_level)
        # Intercept the plotting call
        plt.close('all')
        user_code.plot_var(self.returns, var)
        figs = [plt.figure(i) for i in plt.get_fignums()]
        _dynamic_test(
            self,
            len(figs) > 0,
            "plot_var produces a matplotlib figure.",
            "plot_var did not produce a plot."
        )
        # Check if a vertical line at -VaR is present
        found = False
        for fig in figs:
            for ax in fig.get_axes():
                for line in ax.get_lines():
                    x = line.get_xdata()
                    if np.any(np.isclose(x, -var, atol=1e-8)):
                        found = True
        _dynamic_test(
            self,
            found,
            "plot_var marks the VaR threshold on the plot.",
            "plot_var did not mark the VaR threshold."
        )

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: Calculate and Visualize Portfolio VaR

Soluzione