regime detection improvements - faster market adaptation working

import pandas as pd
import numpy as np
from datetime import datetime, timedelta

class ImprovedRegimeDetection:
    """
    Enhanced regime detection with intraday stability checks
    """

    def __init__(self):
        # VIX thresholds
        self.low_vol_threshold = 15
        self.high_vol_threshold = 20

        # Confirmation settings
        self.daily_confirmation_days = 3
        self.intraday_stability_hours = 2

        # Regime history
        self.daily_regime_history = []
        self.intraday_vix_samples = []

    def classify_regime(self, vix_level):
        """
        Classify volatility regime based on VIX level
        """
        if vix_level < self.low_vol_threshold:
            return 'low_vol'
        elif vix_level < self.high_vol_threshold:
            return 'medium_vol'
        else:
            return 'high_vol'

    def check_intraday_stability(self, current_vix):
        """
        Verify regime is stable intraday before accepting
        """
        # Add current sample
        self.intraday_vix_samples.append({
            'timestamp': datetime.now(),
            'vix': current_vix,
            'regime': self.classify_regime(current_vix)
        })

        # Keep only last 3 hours of samples (one per 15min bar = 12 samples)
        cutoff_time = datetime.now() - timedelta(hours=3)
        self.intraday_vix_samples = [
            s for s in self.intraday_vix_samples
            if s['timestamp'] > cutoff_time
        ]

        # Need at least 2 hours of data (8 samples)
        if len(self.intraday_vix_samples) < 8:
            return None  # Not enough data yet

        # Check if regime has been stable for last 2 hours
        last_8_samples = self.intraday_vix_samples[-8:]
        regimes = [s['regime'] for s in last_8_samples]

        # Calculate regime consistency
        unique_regimes = set(regimes)

        if len(unique_regimes) == 1:
            # Perfect stability - same regime for 2 hours
            return regimes[0], 1.0  # regime, confidence

        elif len(unique_regimes) == 2:
            # Some instability - calculate majority
            regime_counts = {}
            for r in regimes:
                regime_counts[r] = regime_counts.get(r, 0) + 1

            dominant_regime = max(regime_counts, key=regime_counts.get)
            confidence = regime_counts[dominant_regime] / len(regimes)

            # Only accept if 75%+ samples agree
            if confidence >= 0.75:
                return dominant_regime, confidence
            else:
                return None  # Too unstable

        else:
            # High instability - 3+ regimes in 2 hours
            return None  # Reject, too much whipsaw

    def update_daily_regime(self, eod_vix):
        """
        Update daily regime confirmation (end of day only)
        """
        daily_regime = self.classify_regime(eod_vix)

        # Add to daily history
        self.daily_regime_history.append(daily_regime)

        # Keep only last N days
        if len(self.daily_regime_history) > self.daily_confirmation_days:
            self.daily_regime_history.pop(0)

        # Check daily confirmation
        if len(self.daily_regime_history) == self.daily_confirmation_days:
            if all(r == daily_regime for r in self.daily_regime_history):
                return daily_regime, True  # Confirmed

        return daily_regime, False  # Not yet confirmed

    def get_trading_regime(self, current_vix, is_eod=False):
        """
        Get current trading regime with full validation

        Returns:
            regime (str): Current confirmed regime
            confidence (float): Confidence level (0-1)
            source (str): 'intraday' or 'daily'
        """
        # End of day: update daily regime
        if is_eod:
            daily_regime, confirmed = self.update_daily_regime(current_vix)
            if confirmed:
                return daily_regime, 1.0, 'daily'

        # Intraday: check stability
        intraday_result = self.check_intraday_stability(current_vix)

        if intraday_result is not None:
            regime, confidence = intraday_result
            return regime, confidence, 'intraday'

        # Fallback: use daily regime if available
        if len(self.daily_regime_history) > 0:
            return self.daily_regime_history[-1], 0.5, 'daily_fallback'

        # Ultimate fallback: classify current VIX with low confidence
        return self.classify_regime(current_vix), 0.3, 'instant'


# Usage in production
detector = ImprovedRegimeDetection()

def process_trading_signal(prices, current_vix, is_eod=False):
    """
    Process trading signal with regime validation
    """
    # Get regime with confidence
    regime, confidence, source = detector.get_trading_regime(
        current_vix,
        is_eod=is_eod
    )

    print(f"Regime: {regime} (confidence: {confidence:.1%}, source: {source})")

    # Only trade with high confidence regimes
    if confidence >= 0.75:
        # Proceed with strategy using confirmed regime
        print(f"✓ Trading enabled in {regime} regime")
        return True
    else:
        # Skip trading during uncertain regime transitions
        print(f"✗ Trading paused - regime uncertain (confidence: {confidence:.1%})")
        return False