adaptive position sizing - regime-based approach

import numpy as np
import pandas as pd
from typing import Dict, Tuple
from dataclasses import dataclass
from datetime import datetime, timedelta

@dataclass
class RegimeMetrics:
    """Market regime indicators"""
    vix: float
    correlation: float
    volume_ratio: float  # current / 30-day avg
    trend_strength: float
    timestamp: datetime

@dataclass
class PositionSizingConfig:
    """Configuration for adaptive position sizing"""
    base_size: float = 1500.0  # Base position size in dollars
    min_size: float = 600.0    # Minimum position size
    max_size: float = 2000.0   # Maximum position size

    # VIX thresholds
    vix_optimal_low: float = 14.0
    vix_optimal_high: float = 19.0
    vix_danger: float = 25.0

    # Correlation thresholds
    corr_optimal: float = 0.65
    corr_danger: float = 0.80

    # Volume thresholds
    vol_ratio_low: float = 0.75
    vol_ratio_optimal: float = 0.95

    # Confidence weights
    vix_weight: float = 0.35
    corr_weight: float = 0.25
    volume_weight: float = 0.20
    trend_weight: float = 0.20

class AdaptivePositionSizer:
    """
    Adaptive position sizing based on regime metrics

    Core philosophy:
    - Scale position size with market regime confidence
    - Reduce risk during uncertain/volatile periods
    - Increase size during optimal conditions
    - Never exceed hard limits
    """

    def __init__(self, config: PositionSizingConfig = None):
        self.config = config or PositionSizingConfig()
        self.history = []

    def calculate_regime_confidence(self, metrics: RegimeMetrics) -> float:
        """
        Calculate overall regime confidence score (0-1)

        Components:
        - VIX score: optimal range 14-19, penalty outside
        - Correlation score: lower is better (< 0.65 optimal)
        - Volume score: normal to high volume preferred
        - Trend strength: strong trends preferred

        Returns:
        - float: confidence score 0.0 (no confidence) to 1.0 (full confidence)
        """

        # VIX component scoring
        vix_score = self._score_vix(metrics.vix)

        # Correlation component scoring
        corr_score = self._score_correlation(metrics.correlation)

        # Volume component scoring
        vol_score = self._score_volume(metrics.volume_ratio)

        # Trend strength (already 0-1 from regime detection)
        trend_score = min(max(metrics.trend_strength, 0.0), 1.0)

        # Weighted combination
        confidence = (
            vix_score * self.config.vix_weight +
            corr_score * self.config.corr_weight +
            vol_score * self.config.volume_weight +
            trend_score * self.config.trend_weight
        )

        return np.clip(confidence, 0.0, 1.0)

    def _score_vix(self, vix: float) -> float:
        """Score VIX level (0-1, higher is better)"""
        cfg = self.config

        if cfg.vix_optimal_low <= vix <= cfg.vix_optimal_high:
            # Optimal range: full score
            return 1.0
        elif vix < cfg.vix_optimal_low:
            # Too low (complacency risk)
            deviation = cfg.vix_optimal_low - vix
            return max(0.5, 1.0 - (deviation / 5.0))
        elif vix > cfg.vix_danger:
            # Danger zone
            return 0.2
        else:
            # Elevated but not danger
            deviation = vix - cfg.vix_optimal_high
            return max(0.3, 1.0 - (deviation / 8.0))

    def _score_correlation(self, corr: float) -> float:
        """Score correlation (0-1, lower corr = higher score)"""
        cfg = self.config

        if corr <= cfg.corr_optimal:
            # Optimal: low correlation
            return 1.0
        elif corr >= cfg.corr_danger:
            # Danger: everything moving together
            return 0.2
        else:
            # Between optimal and danger
            range_span = cfg.corr_danger - cfg.corr_optimal
            position = (corr - cfg.corr_optimal) / range_span
            return 1.0 - (position * 0.8)  # Linear decay from 1.0 to 0.2

    def _score_volume(self, vol_ratio: float) -> float:
        """Score volume ratio (0-1)"""
        cfg = self.config

        if vol_ratio >= cfg.vol_ratio_optimal:
            # Normal to high volume: full score
            return 1.0
        elif vol_ratio <= cfg.vol_ratio_low:
            # Very low volume: risky
            return 0.3
        else:
            # Between low and optimal: scale linearly
            range_span = cfg.vol_ratio_optimal - cfg.vol_ratio_low
            position = (vol_ratio - cfg.vol_ratio_low) / range_span
            return 0.3 + (position * 0.7)  # Scale from 0.3 to 1.0

    def calculate_position_size(
        self,
        metrics: RegimeMetrics,
        account_value: float
    ) -> Tuple[float, Dict]:
        """
        Calculate adaptive position size

        Args:
            metrics: Current market regime metrics
            account_value: Current account value

        Returns:
            Tuple of (position_size, details_dict)
        """

        # Calculate regime confidence
        confidence = self.calculate_regime_confidence(metrics)

        # Calculate confidence-adjusted size
        adjusted_size = self.config.base_size * confidence

        # Apply hard limits
        final_size = np.clip(
            adjusted_size,
            self.config.min_size,
            self.config.max_size
        )

        # Calculate percentage of account
        pct_of_account = (final_size / account_value) * 100

        # Store in history
        details = {
            'timestamp': metrics.timestamp,
            'regime_confidence': confidence,
            'base_size': self.config.base_size,
            'adjusted_size': adjusted_size,
            'final_size': final_size,
            'pct_of_account': pct_of_account,
            'vix': metrics.vix,
            'correlation': metrics.correlation,
            'volume_ratio': metrics.volume_ratio,
            'trend_strength': metrics.trend_strength,
            'account_value': account_value
        }

        self.history.append(details)

        return final_size, details

    def get_sizing_summary(self, lookback_days: int = 30) -> pd.DataFrame:
        """Get summary of recent position sizing decisions"""
        if not self.history:
            return pd.DataFrame()

        df = pd.DataFrame(self.history)

        # Filter to lookback period
        cutoff = datetime.now() - timedelta(days=lookback_days)
        df = df[df['timestamp'] >= cutoff]

        return df

    def print_current_sizing(self, metrics: RegimeMetrics, account_value: float):
        """Debug helper: print current sizing decision"""
        size, details = self.calculate_position_size(metrics, account_value)

        print(f"\n=== Position Sizing Analysis ===")
        print(f"Timestamp: {metrics.timestamp}")
        print(f"\nMarket Regime:")
        print(f"  VIX: {metrics.vix:.2f}")
        print(f"  Correlation: {metrics.correlation:.2f}")
        print(f"  Volume Ratio: {metrics.volume_ratio:.2f}")
        print(f"  Trend Strength: {metrics.trend_strength:.2f}")
        print(f"\nSizing Decision:")
        print(f"  Regime Confidence: {details['regime_confidence']:.2f}")
        print(f"  Base Size: ${details['base_size']:.0f}")
        print(f"  Adjusted Size: ${details['adjusted_size']:.0f}")
        print(f"  Final Size: ${details['final_size']:.0f}")
        print(f"  % of Account: {details['pct_of_account']:.3f}%")
        print(f"================================\n")


# Example usage
if __name__ == "__main__":
    # Initialize position sizer with default config
    sizer = AdaptivePositionSizer()

    # Example 1: Optimal conditions
    print("Example 1: Optimal Market Conditions")
    optimal_metrics = RegimeMetrics(
        vix=16.5,
        correlation=0.58,
        volume_ratio=1.05,
        trend_strength=0.78,
        timestamp=datetime.now()
    )
    sizer.print_current_sizing(optimal_metrics, account_value=444780)

    # Example 2: Elevated VIX
    print("\nExample 2: Elevated VIX (Week 2 October)")
    elevated_metrics = RegimeMetrics(
        vix=19.8,
        correlation=0.74,
        volume_ratio=0.94,
        trend_strength=0.61,
        timestamp=datetime.now()
    )
    sizer.print_current_sizing(elevated_metrics, account_value=444780)

    # Example 3: Low volume conditions
    print("\nExample 3: Low Volume (August-style)")
    low_vol_metrics = RegimeMetrics(
        vix=16.0,
        correlation=0.54,
        volume_ratio=0.71,
        trend_strength=0.69,
        timestamp=datetime.now()
    )
    sizer.print_current_sizing(low_vol_metrics, account_value=444780)