Stock Analysis - Built with AI Assistance

import requests
from typing import Optional, List, Dict
from datetime import datetime, timedelta
import pandas as pd

class StockDataFetcher:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.alpaca.markets/v2"
        self.headers = {
            "APCA-API-KEY-ID": api_key,
            "APCA-API-SECRET-KEY": api_key
        }

    def get_historical_data(
        self,
        symbol: str,
        start_date: datetime,
        end_date: datetime,
        timeframe: str = "1Day"
    ) -> pd.DataFrame:
        """Fetch historical stock data."""
        params = {
            "timeframe": timeframe,
            "start": start_date.isoformat(),
            "end": end_date.isoformat()
        }

        response = requests.get(
            f"{self.base_url}/stocks/{symbol}/bars",
            headers=self.headers,
            params=params
        )
        response.raise_for_status()

        bars = response.json()["bars"]

        df = pd.DataFrame(bars)
        df["timestamp"] = pd.to_datetime(df["t"])
        df.set_index("timestamp", inplace=True)

        return df[["open", "high", "low", "close", "volume"]]

    def get_current_price(self, symbol: str) -> Optional[float]:
        """Get current stock price."""
        params = {"timeframe": "1Min"}
        response = requests.get(
            f"{self.base_url}/stocks/{symbol}/bars",
            headers=self.headers,
            params=params
        )

        if response.status_code == 200:
            bars = response.json()["bars"]
            if bars:
                return bars[-1]["c"]
        return None

import numpy as np

class TechnicalAnalyzer:
    @staticmethod
    def calculate_sma(prices: pd.Series, window: int) -> pd.Series:
        """Calculate Simple Moving Average."""
        return prices.rolling(window=window).mean()

    @staticmethod
    def calculate_ema(prices: pd.Series, window: int) -> pd.Series:
        """Calculate Exponential Moving Average."""
        return prices.ewm(span=window, adjust=False).mean()

    @staticmethod
    def calculate_rsi(prices: pd.Series, window: int = 14) -> pd.Series:
        """Calculate Relative Strength Index."""
        delta = prices.diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=window).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=window).mean()

        rs = gain / loss
        rsi = 100 - (100 / (1 + rs))
        return rsi

    @staticmethod
    def calculate_macd(prices: pd.Series) -> pd.DataFrame:
        """Calculate MACD indicator."""
        ema_12 = prices.ewm(span=12, adjust=False).mean()
        ema_26 = prices.ewm(span=26, adjust=False).mean()

        macd_line = ema_12 - ema_26
        signal_line = macd_line.ewm(span=9, adjust=False).mean()
        histogram = macd_line - signal_line

        return pd.DataFrame({
            "macd": macd_line,
            "signal": signal_line,
            "histogram": histogram
        })

    @staticmethod
    def calculate_bollinger_bands(
        prices: pd.Series,
        window: int = 20,
        num_std: float = 2.0
    ) -> pd.DataFrame:
        """Calculate Bollinger Bands."""
        sma = prices.rolling(window=window).mean()
        std = prices.rolling(window=window).std()

        upper_band = sma + (std * num_std)
        lower_band = sma - (std * num_std)

        return pd.DataFrame({
            "upper": upper_band,
            "middle": sma,
            "lower": lower_band
        })

from dataclasses import dataclass, field
from typing import Dict, List, Optional
from datetime import datetime

@dataclass
class Holding:
    symbol: str
    shares: float
    avg_cost: float
    purchase_date: datetime = field(default_factory=datetime.now)

    @property
    def total_cost(self) -> float:
        return self.shares * self.avg_cost

@dataclass
class Portfolio:
    holdings: Dict[str, Holding] = field(default_factory=dict)
    cash: float = 100000.0

    def add_position(self, symbol: str, shares: float, price: float):
        """Add or increase a position."""
        if symbol in self.holdings:
            existing = self.holdings[symbol]
            total_shares = existing.shares + shares
            total_cost = existing.total_cost + (shares * price)
            new_avg_cost = total_cost / total_shares

            self.holdings[symbol] = Holding(
                symbol=symbol,
                shares=total_shares,
                avg_cost=new_avg_cost,
                purchase_date=existing.purchase_date
            )
        else:
            self.holdings[symbol] = Holding(
                symbol=symbol,
                shares=shares,
                avg_cost=price
            )

        self.cash -= shares * price

    def get_total_value(self, current_prices: Dict[str, float]) -> float:
        """Calculate total portfolio value."""
        stock_value = sum(
            holding.shares * current_prices.get(holding.symbol, 0)
            for holding in self.holdings.values()
        )
        return self.cash + stock_value

    def get_performance(self, current_prices: Dict[str, float]) -> List[Dict]:
        """Get performance for each holding."""
        performance = []

        for symbol, holding in self.holdings.items():
            current_price = current_prices.get(symbol, 0)
            current_value = holding.shares * current_price
            gain_loss = current_value - holding.total_cost
            gain_loss_pct = (gain_loss / holding.total_cost) * 100

            performance.append({
                "symbol": symbol,
                "shares": holding.shares,
                "avg_cost": holding.avg_cost,
                "current_price": current_price,
                "current_value": current_value,
                "gain_loss": gain_loss,
                "gain_loss_pct": gain_loss_pct
            })

        return performance

import matplotlib.pyplot as plt
import matplotlib.dates as mdates

class StockChartGenerator:
    def __init__(self, style: str = "dark"):
        self.style = style
        self.colors = {
            "dark": {
                "background": "#0f172a",
                "grid": "#334155",
                "text": "#e2e8f0",
                "up": "#22c55e",
                "down": "#ef4444"
            },
            "light": {
                "background": "#ffffff",
                "grid": "#e5e7eb",
                "text": "#1f2937",
                "up": "#16a34a",
                "down": "#dc2626"
            }
        }

    def create_price_chart(
        self,
        df: pd.DataFrame,
        symbol: str,
        show_ma: bool = True,
        show_volume: bool = True
    ) -> plt.Figure:
        """Create a comprehensive price chart with indicators."""
        fig, axes = plt.subplots(2, 1, figsize=(14, 8), gridspec_kw={'height_ratios': [3, 1]})

        colors = self.colors[self.style]

        # Price chart
        ax1 = axes[0]
        ax1.plot(df.index, df["close"], color=colors["up"], linewidth=1.5, label="Price")

        if show_ma:
            sma_20 = TechnicalAnalyzer.calculate_sma(df["close"], 20)
            sma_50 = TechnicalAnalyzer.calculate_sma(df["close"], 50)
            ax1.plot(sma_20.index, sma_20, "w--", linewidth=1, label="SMA 20")
            ax1.plot(sma_50.index, sma_50, "w--", linewidth=1, label="SMA 50")

        ax1.set_title(f"{symbol} Price History", fontsize=14, color=colors["text"])
        ax1.set_ylabel("Price", color=colors["text"])
        ax1.grid(True, alpha=0.3, color=colors["grid"])
        ax1.legend(loc="upper left")

        # Volume chart
        if show_volume:
            ax2 = axes[1]
            colors_volume = [colors["up"] if df["close"].iloc[i] >= df["open"].iloc[i]
                           else colors["down"] for i in range(len(df))]

            ax2.bar(df.index, df["volume"], color=colors_volume, alpha=0.5)
            ax2.set_ylabel("Volume", color=colors["text"])
            ax2.grid(True, alpha=0.3, color=colors["grid"])

        # Formatting
        ax1.xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m-%d"))
        plt.xticks(rotation=45)
        plt.tight_layout()

        return fig

I need a Python class for tracking stock portfolio.
It should:
1. Track holdings with symbol, shares, and average cost
2. Allow adding and removing positions
3. Calculate current value and gains/losses
4. Support multiple stocks

Start with the dataclass definitions.