Update scorer.py

scorer.py

@@ -1,26 +1,37 @@
+from typing import Dict, Any, List, Tuple
+
 import numpy as np
-from typing import Dict, Any
+
+from config import WEIGHT_REGIME, WEIGHT_VOLUME, WEIGHT_STRUCTURE
 
 
 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("volatility_expanding", False)
+    vol_expanding = regime_data.get("vol_expanding", False)
+    vol_contracting = regime_data.get("vol_contracting", False)
+    atr_trend = regime_data.get("atr_trend", "falling")
 
     if trend == "bullish":
-        base = 1.0
+        base = 0.8
     elif trend == "ranging":
         base = 0.4
     else:
         base = 0.1
 
     if structure == 1:
-        base = min(1.0, base + 0.2)
+        base = min(1.0, base + 0.15)
     elif structure == -1:
-        base = max(0.0, base - 0.2)
+        base = max(0.0, base - 0.15)
 
     if vol_expanding:
-        base = max(0.0, base - 0.15)
+        base = max(0.0, base - 0.1)
+
+    if vol_contracting and trend == "bullish":
+        base = max(0.0, base - 0.05)
+
+    if atr_trend == "rising" and trend == "bullish":
+        base = min(1.0, base + 0.05)
 
     return float(np.clip(base, 0.0, 1.0))
 
@@ -42,28 +53,33 @@ def score_token(
     volume_score = float(np.clip(volume_data.get("volume_score", 0.0), 0.0, 1.0))
     structure_score = compute_structure_score(regime_data)
 
-    regime_weight = 0.40
-    volume_weight = 0.35
-    structure_weight = 0.25
-
     total_score = (
-        regime_score * regime_weight
-        + volume_score * volume_weight
-        + structure_score * structure_weight
+        regime_score * WEIGHT_REGIME
+        + volume_score * WEIGHT_VOLUME
+        + structure_score * WEIGHT_STRUCTURE
     )
 
+    climax_penalty = 0.15 if volume_data.get("climax", False) else 0.0
+    total_score = float(np.clip(total_score - climax_penalty, 0.0, 1.0))
+
     return {
         "regime_score": round(regime_score, 4),
         "volume_score": round(volume_score, 4),
         "structure_score": round(structure_score, 4),
-        "total_score": round(float(total_score), 4),
+        "total_score": round(total_score, 4),
     }
 
 
-def rank_tokens(scored_tokens: Dict[str, Dict[str, Any]]) -> list:
-    ranked = sorted(
-        scored_tokens.items(),
-        key=lambda x: x[1].get("total_score", 0.0),
+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,
     )
-    return ranked
+
+
+def format_score_bar(score: float, width: int = 20) -> str:
+    filled = int(round(score * width))
+    return "[" + "█" * filled + "░" * (width - filled) + f"] {score:.2f}"