Comment driven Development

# Create an Employee class with name, age, and salary attributes
# Include type hints and validation for each field

import pandas as pd
import numpy as np

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

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

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

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

    @age.setter
    def age(self, value: int):
        if not isinstance(value, int):
            raise TypeError("Age must be an integer")
        self._age = value

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

    @salary.setter
    def salary(self, value: float):
        if not isinstance(value, (int, float)):
            raise TypeError("Salary must be a number")
        self._salary = value

# main.py
employee = Employee("Alice", 30, 50000.0)
print(employee.name)    # Alice
print(employee.age)     # 30
print(employee.salary)  # 50000.0

(venv) $ python main.py
Alice
30
50000.0

# create a method that processes stock market data
# calculate moving averages, volatility, and trading signals
# handle missing data and outliers
def process_stock_data(self, data: pd.DataFrame) -> pd.DataFrame:
    # calculate moving averages
    data['SMA_50'] = data['Close'].rolling(window=50).mean()
    data['SMA_200'] = data['Close'].rolling(window=200).mean()

    # calculate volatility
    data['daily_return'] = data['Close'].pct_change()
    data['volatility'] = data['daily_return'].rolling(window=50).std()

    # generate signals
    data['signal'] = 0
    data.loc[data['SMA_50'] > data['SMA_200'], 'signal'] = 1
    data.loc[data['SMA_50'] < data['SMA_200'], 'signal'] = -1

    # handle missing values
    data.fillna(method='ffill', inplace=True)
    return data

(venv) $ python main.py
Alice
30
50000.0

# Validate trading parameters before order execution

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

# test process_stock_data function

import pytest
import pandas as pd
import main

def test_process_stock_data():
    data = pd.DataFrame({'Close': list(range(1, 201))})
    emp = main.Employee("Alice", 30, 50000.0)
    processed = emp.process_stock_data(data.copy())

    assert 'SMA_50' in processed
    assert 'SMA_200' in processed
    assert 'volatility' in processed
    assert 'signal' in processed
    assert processed['signal'].iloc[-1] == 1

def test_validate_trading_parameters_success():
    assert main.validate_trading_parameters(100.5, 1000, 'AAPL') is True

@pytest.mark.parametrize("price,volume,symbol,exception", [
    (-1,   100, 'AAPL', ValueError),
    (100.5,   0, 'AAPL', ValueError),
    (100.5, 1000,    123, TypeError),
])
def test_validate_trading_parameters_errors(price, volume, symbol, exception):
    with pytest.raises(exception):
        main.validate_trading_parameters(price, volume, symbol)

(venv) $ pytest -q