
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout
import numpy as np

class TestTask(unittest.TestCase):
    def setUp(self):
        self.expected_returns = [
            0.4*0.02 + 0.3*0.015 + 0.2*0.01 + 0.1*(-0.005),
            0.4*0.01 + 0.3*0.02 + 0.2*0.005 + 0.1*0.0,
            0.4*0.015 + 0.3*0.01 + 0.2*0.02 + 0.1*0.01,
            0.4*(-0.005) + 0.3*0.0 + 0.2*0.01 + 0.1*0.02,
            0.4*0.03 + 0.3*0.025 + 0.2*0.015 + 0.1*0.005,
            0.4*0.025 + 0.3*0.02 + 0.2*0.01 + 0.1*0.015
        ]
        self.average_return = np.mean(self.expected_returns)
        self.volatility = np.std(self.expected_returns, ddof=0)
        self.risk_free_rate = 0.005
        self.sharpe_ratio = (self.average_return - self.risk_free_rate) / self.volatility

    def test_portfolio_returns_calculation(self):
        import user_code
        import importlib
        importlib.reload(user_code)
        # Try to get variable portfolio_returns from user code
        portfolio_returns = getattr(user_code, 'portfolio_returns', None)
        if portfolio_returns is None:
            # Try to get as a function result
            returns_df = getattr(user_code, 'returns_df', None)
            weights = getattr(user_code, 'weights', None)
            if returns_df is not None and weights is not None:
                try:
                    portfolio_returns = returns_df.dot(weights)
                except Exception:
                    portfolio_returns = None
        _dynamic_test(
            self,
            portfolio_returns is not None and np.allclose(
                np.array(portfolio_returns), np.array(self.expected_returns), atol=1e-6),
            "Portfolio monthly returns are correctly calculated.",
            f"Expected: {self.expected_returns}, got: {portfolio_returns}"
        )

    def test_average_return(self):
        import user_code
        import importlib
        importlib.reload(user_code)
        average_return = getattr(user_code, 'average_return', None)
        if average_return is None:
            # Try to compute from portfolio_returns
            portfolio_returns = getattr(user_code, 'portfolio_returns', None)
            if portfolio_returns is not None:
                average_return = np.mean(portfolio_returns)
        _dynamic_test(
            self,
            average_return is not None and np.isclose(average_return, self.average_return, atol=1e-6),
            "Average monthly return is correctly calculated.",
            f"Expected: {self.average_return}, got: {average_return}"
        )

    def test_volatility(self):
        import user_code
        import importlib
        importlib.reload(user_code)
        volatility = getattr(user_code, 'volatility', None)
        if volatility is None:
            portfolio_returns = getattr(user_code, 'portfolio_returns', None)
            if portfolio_returns is not None:
                volatility = np.std(portfolio_returns, ddof=0)
        _dynamic_test(
            self,
            volatility is not None and np.isclose(volatility, self.volatility, atol=1e-6),
            "Portfolio volatility (std) is correctly calculated.",
            f"Expected: {self.volatility}, got: {volatility}"
        )

    def test_sharpe_ratio(self):
        import user_code
        import importlib
        importlib.reload(user_code)
        sharpe_ratio = getattr(user_code, 'sharpe_ratio', None)
        if sharpe_ratio is None:
            average_return = getattr(user_code, 'average_return', None)
            volatility = getattr(user_code, 'volatility', None)
            if average_return is not None and volatility is not None:
                sharpe_ratio = (average_return - self.risk_free_rate) / volatility
        _dynamic_test(
            self,
            sharpe_ratio is not None and np.isclose(sharpe_ratio, self.sharpe_ratio, atol=1e-6),
            "Sharpe Ratio is correctly calculated.",
            f"Expected: {self.sharpe_ratio}, got: {sharpe_ratio}"
        )

    def test_printed_summary(self):
        import user_code
        import importlib
        import io
        from contextlib import redirect_stdout
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        expected_avg = f"average monthly return: {self.average_return:.4f}"
        expected_vol = f"portfolio volatility: {self.volatility:.4f}"
        expected_sharpe = f"sharpe ratio: {self.sharpe_ratio:.4f}"
        _dynamic_test(
            self,
            expected_avg in output,
            "Output includes average monthly return.",
            f"Expected average monthly return line: '{expected_avg}', got: '{output}'"
        )
        _dynamic_test(
            self,
            expected_vol in output,
            "Output includes portfolio volatility.",
            f"Expected portfolio volatility line: '{expected_vol}', got: '{output}'"
        )
        _dynamic_test(
            self,
            expected_sharpe in output,
            "Output includes Sharpe Ratio.",
            f"Expected Sharpe Ratio line: '{expected_sharpe}', got: '{output}'"
        )

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: Portfolio Return and Risk Calculation

Ratkaisu