Delete scorer.py

scorer.py

@@ -1,144 +0,0 @@
-"""
-scorer.py — Multi-factor scoring with regime confidence as 4th dimension.
-
-Key fixes vs prior version:
-- WEIGHT_CONFIDENCE (0.15) added as explicit 4th score axis
-- Absorption hard-zeroes volume_score regardless of other signals
-- Failed breakout penalty applied at scoring level (defence in depth)
-- Structure score uses ADX to weight trend quality, not just HH/HL
-- format_score_bar returns richer display with quality tier label
-"""
-
-from typing import Dict, Any, List, Tuple
-
-import numpy as np
-
-from config import (
-    WEIGHT_REGIME,
-    WEIGHT_VOLUME,
-    WEIGHT_STRUCTURE,
-    WEIGHT_CONFIDENCE,
-    ADX_TREND_THRESHOLD,
-    ADX_STRONG_THRESHOLD,
-    REGIME_CONFIDENCE_MIN,
-)
-
-
-def compute_structure_score(regime_data: Dict[str, Any]) -> float:
-    trend = regime_data.get("trend", "ranging")
-    structure = regime_data.get("structure", 0)
-    vol_expanding = regime_data.get("vol_expanding", False)
-    vol_contracting = regime_data.get("vol_contracting", False)
-    adx = regime_data.get("adx", 0.0)
-    vol_expanding_from_base = regime_data.get("vol_expanding_from_base", False)
-
-    if trend == "bullish":
-        base = 0.75
-    elif trend == "ranging":
-        base = 0.35
-    else:
-        base = 0.10
-
-    # ADX quality modifier
-    if adx >= ADX_STRONG_THRESHOLD:
-        base = min(1.0, base + 0.15)
-    elif adx < ADX_TREND_THRESHOLD:
-        base = max(0.0, base - 0.20)
-
-    # Structure alignment
-    if structure == 1 and trend == "bullish":
-        base = min(1.0, base + 0.12)
-    elif structure == -1 and trend == "bullish":
-        base = max(0.0, base - 0.20)
-    elif structure == -1 and trend == "bearish":
-        base = min(1.0, base + 0.12)
-
-    # Volatility context
-    if vol_expanding_from_base:
-        base = min(1.0, base + 0.08)
-    if vol_expanding and not vol_expanding_from_base:
-        base = max(0.0, base - 0.10)
-    if vol_contracting:
-        base = max(0.0, base - 0.05)
-
-    return float(np.clip(base, 0.0, 1.0))
-
-
-def score_token(
-    regime_data: Dict[str, Any],
-    volume_data: Dict[str, Any],
-    vetoed: bool,
-) -> Dict[str, float]:
-    if vetoed:
-        return {
-            "regime_score": 0.0,
-            "volume_score": 0.0,
-            "structure_score": 0.0,
-            "confidence_score": 0.0,
-            "total_score": 0.0,
-        }
-
-    regime_score = float(np.clip(regime_data.get("regime_score", 0.0), 0.0, 1.0))
-    confidence_score = float(np.clip(regime_data.get("regime_confidence", 0.0), 0.0, 1.0))
-    structure_score = compute_structure_score(regime_data)
-
-    raw_volume_score = float(np.clip(volume_data.get("volume_score", 0.0), 0.0, 1.0))
-
-    # Absorption hard-zeroes the volume signal regardless of other factors
-    if volume_data.get("absorption", False):
-        volume_score = 0.0
-    elif volume_data.get("failed_breakout", False):
-        # Failed breakout halves the volume score
-        volume_score = raw_volume_score * 0.5
-    else:
-        volume_score = raw_volume_score
-
-    # Climax penalty (not a veto here — defence in depth after veto layer)
-    if volume_data.get("climax", False):
-        volume_score = min(volume_score, 0.30)
-
-    total_score = (
-        regime_score * WEIGHT_REGIME
-        + volume_score * WEIGHT_VOLUME
-        + structure_score * WEIGHT_STRUCTURE
-        + confidence_score * WEIGHT_CONFIDENCE
-    )
-
-    # Confidence multiplier: low confidence compresses total score
-    if confidence_score < REGIME_CONFIDENCE_MIN:
-        total_score *= confidence_score / REGIME_CONFIDENCE_MIN
-
-    return {
-        "regime_score": round(regime_score, 4),
-        "volume_score": round(volume_score, 4),
-        "structure_score": round(structure_score, 4),
-        "confidence_score": round(confidence_score, 4),
-        "total_score": round(float(np.clip(total_score, 0.0, 1.0)), 4),
-    }
-
-
-def rank_tokens(scored_map: Dict[str, Dict[str, Any]]) -> List[Tuple[str, Dict[str, Any]]]:
-    return sorted(
-        scored_map.items(),
-        key=lambda item: item[1].get("total_score", 0.0),
-        reverse=True,
-    )
-
-
-def quality_tier(score: float) -> str:
-    if score >= 0.80:
-        return "A+"
-    if score >= 0.65:
-        return "A"
-    if score >= 0.50:
-        return "B"
-    if score >= 0.35:
-        return "C"
-    return "D"
-
-
-def format_score_bar(score: float, width: int = 18) -> str:
-    filled = int(round(score * width))
-    bar = "█" * filled + "░" * (width - filled)
-    tier = quality_tier(score)
-    return f"[{bar}] {score:.3f} ({tier})"