Comment driven Development

# main.py
from typing import Any
import pandas as pd
import numpy as np


class Employee:
    def __init__(self, name: str, age: int, salary: float) -> None:
        self.name = name
        self.age = age
        self.salary = salary

    @property
    def name(self) -> str:
        return self._name

    @name.setter
    def name(self, value: str) -> None:
        if not isinstance(value, str):
            raise TypeError("Name must be a string")
        if not value:
            raise ValueError("Name must not be empty")
        self._name = value

    @property
    def age(self) -> int:
        return self._age

    @age.setter
    def age(self, value: int) -> None:
        if not isinstance(value, int):
            raise TypeError("Age must be an integer")
        if value < 0:
            raise ValueError("Age must be non-negative")
        self._age = value

    @property
    def salary(self) -> float:
        return self._salary

    @salary.setter
    def salary(self, value: float) -> None:
        if not isinstance(value, (int, float)):
            raise TypeError("Salary must be a number")
        if value < 0:
            raise ValueError("Salary must be non-negative")
        self._salary = float(value)

    def process_stock_data(self, data: pd.DataFrame) -> pd.DataFrame:
        """
        Calculate moving averages, volatility, and trading signals.
        Handle missing data and outliers in a conservative, example manner.
        - Expects a DataFrame with a 'Close' column.
        - Adds columns: 'SMA_50', 'SMA_200', 'daily_return', 'volatility', 'signal'
        """
        if "Close" not in data.columns:
            raise KeyError("DataFrame must contain a 'Close' column")

        df = data.copy()

        # Handle missing data: forward-fill then drop remaining NaNs
        df["Close"] = df["Close"].ffill()
        df = df.dropna(subset=["Close"])

        # Calculate returns
        df["daily_return"] = df["Close"].pct_change()

        # Handle outliers in returns by clipping to mean +/- 3*std
        ret_mean = df["daily_return"].mean(skipna=True)
        ret_std = df["daily_return"].std(skipna=True)
        if pd.notna(ret_std) and ret_std != 0:
            lower = ret_mean - 3 * ret_std
            upper = ret_mean + 3 * ret_std
            df["daily_return"] = df["daily_return"].clip(lower, upper)

        # Calculate volatility and moving averages (examples: windows 50 and 200)
        df["volatility"] = df["daily_return"].rolling(window=50, min_periods=1).std()
        df["SMA_50"] = df["Close"].rolling(window=50, min_periods=1).mean()
        df["SMA_200"] = df["Close"].rolling(window=200, min_periods=1).mean()

        # Trading signal: 1 when short MA > long MA, -1 when short MA < long MA, else 0
        df["signal"] = np.where(df["SMA_50"] > df["SMA_200"], 1, np.where(df["SMA_50"] < df["SMA_200"], -1, 0))

        return df


def validate_trading_parameters(price: float, volume: int, symbol: str) -> bool:
    """Validate trading parameters before order execution"""
    if not isinstance(price, (int, float)):
        raise TypeError("Price must be a number")
    if not isinstance(volume, int):
        raise TypeError("Volume must be an integer")
    if not isinstance(symbol, str):
        raise TypeError("Symbol must be a string")

    if price <= 0:
        raise ValueError("Price must be positive")
    if volume <= 0:
        raise ValueError("Volume must be positive")

    return True


if __name__ == "__main__":
    employee = Employee("Alice", 30, 50000)
    print(employee.name)
    print(employee.age)
    print(employee.salary)

$ python main.py
Alice
30
50000.0

# test_main.py
import pandas as pd
import numpy as np
import pytest
import main


def test_process_stock_data_structure():
    # Short sample of closing prices (10 datapoints)
    data = pd.DataFrame({
        "Close": [100, 110, 120, 130, 140, 150, 160, 170, 180, 190]
    })
    emp = main.Employee("Alice", 30, 50000)
    processed = emp.process_stock_data(data)

    # Check expected columns exist
    for col in ["SMA_50", "SMA_200", "daily_return", "volatility", "signal"]:
        assert col in processed.columns

    # With only 10 rows, SMA_50 and SMA_200 will be present but many values will be computed using min_periods=1.
    # Ensure signal column contains only -1, 0, or 1
    assert set(processed["signal"].dropna().unique()).issubset({-1, 0, 1})


def test_validate_trading_parameters_valid():
    assert main.validate_trading_parameters(100.0, 10, "AAPL") is True


def test_validate_trading_parameters_invalid():
    with pytest.raises(TypeError):
        main.validate_trading_parameters("100", 10, "AAPL")
    with pytest.raises(ValueError):
        main.validate_trading_parameters(0, 10, "AAPL")