Extract expression route resolution

row_expression.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 import random
 import re
 from typing import Any
@@ -55,6 +56,61 @@ def disable_row_expression(row: dict[str, Any], source: str = "disabled") -> dic
     return row
 
 
+@dataclass(frozen=True)
+class ExpressionRoute:
+    expression_disabled: bool
+    expression_intensity: float | None
+    expression_intensity_source: str
+
+
+def resolve_expression_route(
+    *,
+    expression_enabled: bool,
+    expression_intensity: float,
+    expression_intensity_source: str,
+    subject_type: str,
+    applied_slot: dict[str, Any] | None = None,
+    character_slots: list[dict[str, Any]] | None = None,
+    character_slot_map: dict[str, dict[str, Any]] | None = None,
+    women_count: int = 1,
+    men_count: int = 1,
+    expression_phase: str = "",
+) -> ExpressionRoute:
+    source = expression_intensity_source or "input"
+    disabled = not bool(expression_enabled)
+    intensity: float | None = expression_intensity
+    if disabled:
+        source = "disabled"
+    elif subject_type in ("woman", "man") and applied_slot:
+        slot_label = "Woman A" if subject_type == "woman" else "Man A"
+        if not character_slot_policy.slot_expression_enabled(applied_slot):
+            disabled = True
+            source = f"character_slot:{slot_label}:disabled"
+        else:
+            slot_expression_intensity = character_slot_policy.slot_expression_intensity_for_phase(
+                applied_slot,
+                expression_phase,
+            )
+            if slot_expression_intensity is not None:
+                intensity = slot_expression_intensity
+                source = f"character_slot:{slot_label}"
+    elif subject_type == "configured_cast" and character_slots:
+        intensity, source = cast_expression_intensity_override(
+            expression_intensity,
+            character_slot_map or {},
+            women_count,
+            men_count,
+            expression_phase,
+        )
+        if intensity is None:
+            disabled = True
+    return ExpressionRoute(
+        expression_disabled=disabled,
+        expression_intensity=intensity,
+        expression_intensity_source=source,
+    )
+
+
 def _clamped_float(value: Any, default: float = 0.5, min_value: float = 0.0, max_value: float = 1.0) -> float:
     try:
         number = float(value)