Regime Detection — The Scanner That Adapts to the Market

class RegimeDetector:
    """Detect market regime from 6 macro indicators."""

    def __init__(self):
        self.weights = {
            'spy_trend': 0.30,
            'vix_level': 0.25,
            'dxy_trend': 0.15,
            'credit_spread': 0.15,
            'tlt_trend': 0.10,
            'btc_momentum': 0.05,
        }

    def _score_spy(self, spy_data):
        """Score SPY trend: EMA20 vs EMA50."""
        ema20 = spy_data['ema_20']
        ema50 = spy_data['ema_50']
        spread = (ema20 - ema50) / ema50
        if spread > 0.02: return 1.0
        elif spread > 0.005: return 0.75
        elif spread > -0.005: return 0.5
        elif spread > -0.02: return 0.25
        else: return 0.0

    def _score_vix(self, vix):
        """Score VIX (inverted: low VIX = bullish)."""
        if vix < 15: return 1.0
        elif vix < 20: return 0.75
        elif vix < 25: return 0.5
        elif vix < 35: return 0.25
        else: return 0.0

    def detect(self, market_data):
        """Run all 6 indicators. Return regime + score."""
        scores = {
            'spy_trend': self._score_spy(market_data['SPY']),
            'vix_level': self._score_vix(market_data['VIX']),
            'dxy_trend': self._score_dxy(market_data['DXY']),
            'credit_spread': self._score_credit(market_data),
            'tlt_trend': self._score_tlt(market_data['TLT']),
            'btc_momentum': self._score_btc(market_data['BTC']),
        }

        # Weighted composite
        regime_score = sum(
            scores[k] * self.weights[k] for k in scores
        )

        # Map to regime name
        if regime_score > 0.75: regime = 'risk_on'
        elif regime_score > 0.60: regime = 'recovery'
        elif regime_score > 0.40: regime = 'neutral'
        elif regime_score > 0.25: regime = 'early_risk_off'
        else: regime = 'risk_off'

        return {
            'regime': regime,
            'score': round(regime_score, 3),
            'indicators': scores,
        }

STRATEGY_WEIGHTS = {
    'risk_on':         {'momentum': 45, 'breakout': 30, 'contraction': 20, 'mean_reversion': 5},
    'recovery':        {'momentum': 30, 'breakout': 25, 'contraction': 25, 'mean_reversion': 20},
    'neutral':         {'momentum': 25, 'breakout': 25, 'contraction': 25, 'mean_reversion': 25},
    'early_risk_off': {'momentum': 15, 'breakout': 10, 'contraction': 35, 'mean_reversion': 40},
    'risk_off':        {'momentum': 5,  'breakout': 10, 'contraction': 40, 'mean_reversion': 45},
}

def get_weights(regime):
    """Return strategy weights for detected regime."""
    return STRATEGY_WEIGHTS[regime]

def daily_scan(universe_df, market_data):
    """Full daily scan: regime -> filter -> score -> rank."""

    # Step 1: Detect regime
    detector = RegimeDetector()
    regime_result = detector.detect(market_data)
    regime = regime_result['regime']
    print(f"Regime: {regime} (score: {regime_result['score']})")

    # Step 2: Get strategy weights
    weights = get_weights(regime)
    print(f"Weights: {weights}")

    # Step 3: Run filters (from Part 2)
    pipeline = ScannerPipeline()
    candidates = pipeline.run(universe_df, regime)

    # Step 4: Score candidates (from Part 3)
    scorer = ScoringEngine()
    all_scored = []
    for strategy, weight in weights.items():
        strat_candidates = candidates[candidates['strategy'] == strategy]
        scored = scorer.score_candidates(strat_candidates, strategy, weight)
        all_scored.append(scored)

    # Step 5: Merge and rank
    merged = pd.concat(all_scored)
    merged = merged.sort_values('final_score', ascending=False)
    merged = merged.drop_duplicates(subset=['ticker'], keep='first')

    # Step 6: Take top 10 with diversification
    top10 = enforce_diversification(merged.head(20), max_per_sector=2)

    print(f"\nTop 10 Setups ({regime}):")
    for _, row in top10.head(10).iterrows():
        print(f"  {row['ticker']:6s} | {row['strategy']:15s} | Score: {row['final_score']}")

    return top10.head(10)