
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
import sys
import io

class TestTask(unittest.TestCase):
    def setUp(self):
        self.closing_prices = pd.DataFrame({
            'Stock_A': [100, 102, 101, 104, 106, 105, 107, 110, 108, 111],
            'Stock_B': [50, 51, 52, 53, 54, 56, 55, 57, 58, 60],
            'Stock_C': [200, 202, 203, 205, 207, 210, 208, 211, 213, 215]
        })
        # Calculate expected returns
        self.daily_returns = self.closing_prices.pct_change().iloc[1:]
        self.expected_avg = self.daily_returns.mean()
        self.expected_vol = self.daily_returns.std()
        # Prepare expected summary DataFrame for output check
        self.expected_summary = pd.DataFrame({
            'Average Return': self.expected_avg,
            'Volatility': self.expected_vol
        })

    def test_daily_returns_correct(self):
        import user_code
        importlib.reload(user_code)
        # Try to find a variable with daily returns (should be named daily_returns)
        daily_returns = getattr(user_code, 'daily_returns', None)
        _dynamic_test(
            self,
            isinstance(daily_returns, pd.DataFrame),
            "Found daily_returns DataFrame.",
            "Variable 'daily_returns' is missing or not a DataFrame."
        )
        # Check values
        correct = daily_returns is not None and np.allclose(daily_returns.values, self.daily_returns.values, atol=1e-8)
        _dynamic_test(
            self,
            correct,
            "Daily returns computed correctly.",
            f"Daily returns are incorrect. Expected:\\n{self.daily_returns}\\nGot:\\n{daily_returns}"
        )

    def test_summary_table_values(self):
        import user_code
        importlib.reload(user_code)
        summary = getattr(user_code, 'summary', None)
        _dynamic_test(
            self,
            isinstance(summary, pd.DataFrame),
            "Summary is a DataFrame.",
            "Variable 'summary' is missing or not a DataFrame."
        )
        # Check index and columns
        correct_index = list(summary.index) == list(self.expected_summary.index)
        correct_cols = list(summary.columns) == list(self.expected_summary.columns)
        _dynamic_test(
            self,
            correct_index and correct_cols,
            "Summary table has correct index and columns.",
            f"Summary table index or columns incorrect. Expected index: {self.expected_summary.index}, columns: {self.expected_summary.columns}. Got index: {summary.index}, columns: {summary.columns}."
        )
        # Check values
        correct_vals = np.allclose(summary.values, self.expected_summary.values, atol=1e-8)
        _dynamic_test(
            self,
            correct_vals,
            "Summary table values are correct.",
            f"Summary values incorrect. Expected:\\n{self.expected_summary}\\nGot:\\n{summary}"
        )

    def test_output_prints_summary(self):
        import user_code
        import importlib
        f = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f
        importlib.reload(user_code)
        sys.stdout = sys_stdout
        output = f.getvalue()
        # The output should contain the summary table as a string
        expected = self.expected_summary.round(6).to_string()
        # Normalize both for easier matching (ignore whitespace, rounding)
        output_norm = normalize_text(output)
        expected_norm = normalize_text(expected)
        _dynamic_test(
            self,
            all(stock.lower() in output_norm for stock in ['stock_a', 'stock_b', 'stock_c']),
            "Output includes all stock names.",
            f"Output is missing one or more stock names. Output: {output}"
        )
        _dynamic_test(
            self,
            all(col.lower() in output_norm for col in ['average return', 'volatility']),
            "Output includes both column names.",
            f"Output is missing one or both column names. Output: {output}"
        )
        # Check that at least the first row of expected output appears in actual output (rough check)
        first_row = self.expected_summary.round(6).iloc[[0]].to_string()
        first_row_norm = normalize_text(first_row)
        _dynamic_test(
            self,
            first_row_norm.split()[0] in output_norm,
            "Output includes summary table values.",
            f"Output is missing summary table values. Output: {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: Compute Stock Returns and Volatility

Oplossing