feat: add parsing functions for CLAP and FST results in score fusion

app/services/score_fusion.py

@@ -200,64 +200,114 @@ def _parse_external_ses_analizi(data: Optional[dict]) -> Optional[_ExternalScore
     return None
 
 
+def _parse_clap_result(
+    result: Optional[CLAPResult],
+) -> Optional[_ExternalScore]:
+    """Convert CLAPResult to internal score format."""
+    if not result or not result.available:
+        return None
+    return _ExternalScore(
+        available=True,
+        is_ai=result.is_ai,
+        confidence=result.confidence,
+    )
+
+
+def _parse_fst_result(
+    result: Optional[FSTResult],
+) -> Optional[_ExternalScore]:
+    """Convert FSTResult to internal score format."""
+    if not result or not result.available:
+        return None
+    return _ExternalScore(
+        available=True,
+        is_ai=result.is_ai,
+        confidence=result.confidence,
+    )
+
+
 # ═══════════════════════════════════════════════════════════════════════
 # PRIVATE — Score fusion
 # ═══════════════════════════════════════════════════════════════════════
 
 def _fuse(
     local: float,
+    clap: Optional[_ExternalScore],
+    fst: Optional[_ExternalScore],
     ext_mai: Optional[_ExternalScore],
     ext_ses: Optional[_ExternalScore],
 ) -> tuple[float, str, str]:
     """
-    Fuse local + external scores.
+    Fuse local + CLAP + FST + legacy external scores.
+
+    Weight allocation (normalized when layers are missing):
+      Layer 1 (local features+vocals):  0.40
+      Layer 2 (CLAP embedding):         0.20
+      Layer 3 (FST external):           0.25
+      Legacy (music_ai):                0.10
+      Legacy (ses_analizi):             0.05
 
     Returns: (confidence, decision_source, analysis_mode)
     """
-    scores: list[tuple[float, float, str]] = []  # (score, weight, source)
+    scores: list[tuple[float, float, str]] = []
+
+    # Layer 1 — always present
+    scores.append((local, 0.40, "auris_local"))
+
+    # Layer 2 — CLAP embeddings
+    if clap and clap.available:
+        scores.append((clap.confidence, 0.20, "clap"))
 
-    # Local always present
-    scores.append((local, 0.5, "auris_local"))
+    # Layer 3 — FST external (highest individual accuracy)
+    if fst and fst.available:
+        scores.append((fst.confidence, 0.25, "fst"))
 
+    # Legacy external services
     if ext_mai and ext_mai.available:
-        scores.append((ext_mai.confidence, 0.3, "music_ai"))
+        scores.append((ext_mai.confidence, 0.10, "music_ai"))
 
     if ext_ses and ext_ses.available:
-        scores.append((ext_ses.confidence, 0.2, "ses_analizi"))
+        scores.append((ext_ses.confidence, 0.05, "ses_analizi"))
 
     # Normalize weights
     total_weight = sum(w for _, w, _ in scores)
     confidence = sum(s * (w / total_weight) for s, w, _ in scores)
 
-    # Determine primary decision source
-    if ext_mai and ext_mai.available:
-        decision_source = "auris_fusion"
-        mode = "production"
-    elif ext_ses and ext_ses.available:
+    # Determine decision source based on available layers
+    n_layers = sum(1 for _, _, src in scores if src != "auris_local")
+    if n_layers >= 2:
         decision_source = "auris_fusion"
-        mode = "production"
+    elif n_layers == 1:
+        # Name includes the single extra layer
+        extra = [src for _, _, src in scores if src != "auris_local"][0]
+        decision_source = f"auris_fusion_{extra}"
     else:
         decision_source = "auris_local"
-        mode = "production"  # Still production — we have real feature analysis
 
-    # Clamp to valid range (never show 0.50 or 1.00)
+    mode: str = "production"
+
+    # Clamp to valid range
     confidence = max(0.51, min(0.97, confidence))
     confidence = round(confidence, 4)
 
-    # Agreement bonus: if all sources agree, boost confidence toward edges
+    # Agreement bonus
     if len(scores) > 1:
         all_ai = all(s > 0.5 for s, _, _ in scores)
         all_human = all(s <= 0.5 for s, _, _ in scores)
         if all_ai:
-            confidence = min(0.97, confidence * 1.05)
+            # More layers agreeing → bigger boost
+            boost = 1.0 + 0.02 * len(scores)
+            confidence = min(0.97, confidence * boost)
         elif all_human:
-            confidence = max(0.51, confidence * 0.95)
+            dampen = 1.0 - 0.02 * len(scores)
+            confidence = max(0.51, confidence * dampen)
 
     confidence = round(max(0.51, min(0.97, confidence)), 4)
 
+    sources_str = ", ".join(f"{src}={s:.3f}" for s, _, src in scores)
     logger.info(
-        f"Fusion: {len(scores)} sources → confidence={confidence}, "
-        f"source={decision_source}, mode={mode}"
+        f"Fusion: {len(scores)} sources [{sources_str}] "
+        f"-> confidence={confidence}, source={decision_source}"
     )
 
     return confidence, decision_source, mode