quantmind.py

# QuantMind - Systematic Trading Thinking Framework
# Not a bot, a discipline

from typing import Callable, Optional
from enum import Enum

class MarketRegime(Enum):
    TRENDING_UP = "trending_up"
    TRENDING_DOWN = "trending_down"
    RANGING = "ranging"
    VOLATILE = "volatile"

class SignalStrength(Enum):
    STRONG_BUY = 5
    BUY = 4
    NEUTRAL = 3
    SELL = 2
    STRONG_SELL = 1

class MarketAnalyzer:
    """
    Multi-factor market analysis framework.
    
    Factors:
    - Price action (trend, support/resistance)
    - Momentum (RSI, MACD)
    - Sentiment (volume, breadth)
    - Macro context
    """

    def __init__(self):
        self.regime = MarketRegime.RANGING
        self.factors = {}

    def analyze(self, price_data: dict) -> dict:
        """Analyze market and return regime + signals."""
        trend = self._detect_trend(price_data)
        momentum = self._calc_momentum(price_data)
        regime = self._classify_regime(trend, momentum)
        self.regime = regime
        
        return {
            "regime": regime.value,
            "trend": trend,
            "momentum": momentum,
            "signal": self._generate_signal(trend, momentum, regime),
            "confidence": 0.75
        }

    def _detect_trend(self, data: dict) -> str:
        # Simplified trend detection
        prices = data.get("prices", [])
        if len(prices) < 2:
            return "neutral"
        if prices[-1] > prices[0]:
            return "up"
        return "down"

    def _calc_momentum(self, data: dict) -> float:
        # Simplified RSI-like calculation
        return 50.0  # Neutral

    def _classify_regime(self, trend: str, momentum: float):
        if trend == "up" and momentum > 55:
            return MarketRegime.TRENDING_UP
        if trend == "down" and momentum < 45:
            return MarketRegime.TRENDING_DOWN
        return MarketRegime.RANGING

    def _generate_signal(self, trend: str, momentum: float, regime: MarketRegime) -> dict:
        if regime == MarketRegime.TRENDING_UP:
            return {"direction": "buy", "strength": SignalStrength.BUY.value}
        if regime == MarketRegime.TRENDING_DOWN:
            return {"direction": "sell", "strength": SignalStrength.SELL.value}
        return {"direction": "hold", "strength": SignalStrength.NEUTRAL.value}


class RiskManager:
    """
    Position sizing and risk control.
    
    Rules:
    - Never risk more than 2% per trade
    - Maximum 5 positions at once
    - Stop loss at 1.5x ATR
    """

    def __init__(self, max_risk_pct: float = 0.02, max_positions: int = 5):
        self.max_risk_pct = max_risk_pct
        self.max_positions = max_positions
        self.positions = []

    def calculate_size(self, account_value: float, entry: float, stop: float) -> float:
        """Calculate position size based on risk."""
        risk_amount = account_value * self.max_risk_pct
        risk_per_share = abs(entry - stop)
        if risk_per_share == 0:
            return 0
        return risk_amount / risk_per_share

    def can_open(self) -> bool:
        return len(self.positions) < self.max_positions


class TradingJournal:
    """Track all trades for learning and improvement."""

    def __init__(self):
        self.trades = []

    def record(self, trade: dict):
        trade["id"] = len(self.trades) + 1
        self.trades.append(trade)

    def summary(self) -> dict:
        if not self.trades:
            return {"total": 0, "win_rate": 0}
        wins = sum(1 for t in self.trades if t.get("pnl", 0) > 0)
        return {
            "total": len(self.trades),
            "wins": wins,
            "losses": len(self.trades) - wins,
            "win_rate": wins / len(self.trades)
        }


if __name__ == "__main__":
    analyzer = MarketAnalyzer()
    data = {"prices": [100, 102, 101, 103, 105]}
    result = analyzer.analyze(data)
    print("Market:", result)