@oh-story/dsh 0.1.7 → 0.1.9

package/lib/video-recap/skills/video-understanding/scripts/brief_inputs.py

@@ -1,33 +1,14 @@
 """Validate optional ASR, MiMo, and stage-status inputs for the brief."""
 
 import hashlib
-
-import importlib.util
-
-
 import json
-
-
 from pathlib import Path
 
 from lib import CONFIG, file_fingerprint, stable_hash
-
-
 from brief_context import _clean_asr_prompt_fingerprint, _consolidation_model
 
-try:
-    from deslop_qc import analyze_deslop_qc
-except ModuleNotFoundError:
-    _deslop_qc_path = Path(__file__).with_name("deslop_qc.py")
-    _deslop_qc_spec = importlib.util.spec_from_file_location(
-        "deslop_qc", _deslop_qc_path
-    )
-    if _deslop_qc_spec is None or _deslop_qc_spec.loader is None:
-        raise
-    _deslop_qc_module = importlib.util.module_from_spec(_deslop_qc_spec)
-    _deslop_qc_spec.loader.exec_module(_deslop_qc_module)
-    analyze_deslop_qc = _deslop_qc_module.analyze_deslop_qc
-
+# Shared with consolidate.py, which this byte-identical copy cannot import (the sibling
+# skill ships no consolidate.py). Keep both literals in sync.
 _ASR_SPAN_TOL = 0.05
 
 _MIMO_REJECTION_MARKERS = (
@@ -42,67 +23,61 @@ _MIMO_REJECTION_MARKERS = (
 )
 
 
-def _clean_asr_fresh(out_path, source_path):
-    # Local freshness check kept inline so the separately shipped byte-identical copy
-    # stays self-contained and in lockstep.
-    try:
-        return (
-            out_path.exists()
-            and source_path.exists()
-            and (out_path.stat().st_mtime >= source_path.stat().st_mtime)
-        )
-    except OSError:
-        return False
-
-
 def _load_clean_asr(work_dir, asr_result):
     """Return consolidate.py's cleaned ASR segments, or None to fall back to raw asr_result.
-    Gated on parse + non-empty + freshness + provenance(source_md5) + timing invariant
-    (len== first, then per-segment spans within _ASR_SPAN_TOL)."""
-    base = [s for s in (asr_result or []) if isinstance(s, dict)]
-    if not base:
+
+    Accepted only when the file is at least as fresh as asr_result.json, its provenance
+    (source_md5 / model / prompt_md5) matches, and every segment keeps its original span
+    within _ASR_SPAN_TOL."""
+    if not asr_result:
         return None
     work_dir = Path(work_dir)
     clean_path = work_dir / "asr_clean.json"
     src_path = work_dir / "asr_result.json"
-    if not clean_path.exists() or not _clean_asr_fresh(clean_path, src_path):
+    try:
+        fresh = (
+            clean_path.exists()
+            and clean_path.stat().st_mtime >= src_path.stat().st_mtime
+        )
+    except OSError:
+        return None
+    if not fresh:
         return None
     try:
         payload = json.loads(clean_path.read_text(encoding="utf-8"))
-    except (json.JSONDecodeError, OSError):
+        source_md5 = hashlib.md5(src_path.read_bytes()).hexdigest()
+    except (OSError, json.JSONDecodeError):
         return None
     if not isinstance(payload, dict):
         return None
-    segments = payload.get("segments")
-    if not isinstance(segments, list) or len(segments) != len(base):
-        return None
-    try:
-        if payload.get("source_md5") != hashlib.md5(src_path.read_bytes()).hexdigest():
-            return None
-    except OSError:
-        return None
-    if payload.get("model") != _consolidation_model():
+    provenance = {
+        "source_md5": source_md5,
+        "model": _consolidation_model(),
+        "prompt_md5": _clean_asr_prompt_fingerprint(),
+    }
+    if not payload.items() >= provenance.items():
         return None
-    if payload.get("prompt_md5") != _clean_asr_prompt_fingerprint():
+    segments = payload.get("segments")
+    if not isinstance(segments, list) or len(segments) != len(asr_result):
         return None
-    for orig, clean in zip(base, segments):
-        if not isinstance(clean, dict):
+    for orig, clean in zip(asr_result, segments):
+        if (
+            not isinstance(clean, dict)
+            or not isinstance(clean.get("start"), (int, float))
+            or not isinstance(clean.get("end"), (int, float))
+        ):
             return None
-        try:
-            if (
-                abs(float(clean.get("start")) - float(orig.get("start")))
-                > _ASR_SPAN_TOL
-            ):
-                return None
-            if abs(float(clean.get("end")) - float(orig.get("end"))) > _ASR_SPAN_TOL:
-                return None
-        except (TypeError, ValueError):
+        if (
+            abs(clean["start"] - orig["start"]) > _ASR_SPAN_TOL
+            or abs(clean["end"] - orig["end"]) > _ASR_SPAN_TOL
+        ):
             return None
     return segments
 
 
 def _is_mimo_chunk_usable(content):
-    text = str(content or "").strip()
+    """A chunk is usable only if MiMo returned real analysis (not empty / a moderation refusal)."""
+    text = (content or "").strip()
     if not text:
         return False
     low = text.lower()
@@ -110,28 +85,23 @@ def _is_mimo_chunk_usable(content):
 
 
 def _mimo_video_settings_fingerprint():
+    """Non-secret MiMo video-overview settings that affect generated content."""
     return {
-        "model": CONFIG.get("mimo_video_model")
-        or CONFIG.get("mimo_model")
-        or CONFIG.get("vlm_model"),
-        "mimo_video_api_url": CONFIG.get("mimo_video_api_url"),
-        "mimo_video_fps": CONFIG.get("mimo_video_fps", 2.0),
-        "mimo_media_resolution": CONFIG.get("mimo_media_resolution", "default"),
-        "mimo_video_chunk_max_seconds": CONFIG.get(
-            "mimo_video_chunk_max_seconds", 20.0
-        ),
-        "mimo_video_chunk_min_seconds": CONFIG.get("mimo_video_chunk_min_seconds", 1.0),
-        "mimo_video_base64_max_mb": CONFIG.get("mimo_video_base64_max_mb", 45.0),
-        "mimo_video_prompt": CONFIG.get("mimo_video_prompt", ""),
-        "mimo_disable_thinking": CONFIG.get("mimo_disable_thinking", True),
+        "model": CONFIG["mimo_video_model"],
+        "mimo_video_api_url": CONFIG["mimo_video_api_url"],
+        "mimo_video_fps": CONFIG["mimo_video_fps"],
+        "mimo_media_resolution": CONFIG["mimo_media_resolution"],
+        "mimo_video_chunk_max_seconds": CONFIG["mimo_video_chunk_max_seconds"],
+        "mimo_video_chunk_min_seconds": CONFIG["mimo_video_chunk_min_seconds"],
+        "mimo_video_base64_max_mb": CONFIG["mimo_video_base64_max_mb"],
+        "mimo_video_prompt": CONFIG["mimo_video_prompt"],
+        "mimo_disable_thinking": CONFIG["mimo_disable_thinking"],
     }
 
 
 def _mimo_chunk_cache_key(chunk):
-    return (
-        f"{chunk['chunk_id']}|{chunk['scene_id']}|"
-        f"{float(chunk['start']):.3f}-{float(chunk['end']):.3f}"
-    )
+    """Stable identifier for a MiMo chunk (index + scene span) for partial-cache reuse."""
+    return f"{chunk['chunk_id']}|{chunk['scene_id']}|{chunk['start']:.3f}-{chunk['end']:.3f}"
 
 
 def _mimo_cached_chunks_fingerprint(done):
@@ -144,48 +114,48 @@ def _mimo_overview_payload_fingerprint(overview):
     return stable_hash(payload)
 
 
-def _mimo_video_chunks_for_brief(scenes):
-    max_seconds = float(CONFIG.get("mimo_video_chunk_max_seconds", 20.0) or 20.0)
-    min_seconds = float(CONFIG.get("mimo_video_chunk_min_seconds", 1.0) or 1.0)
+def _mimo_video_chunks(scenes):
+    """Split scene spans into MiMo video chunks. scenes.json rows carry no scene_id, so the
+    row index stands in for it there."""
+    max_seconds = CONFIG["mimo_video_chunk_max_seconds"]
+    min_seconds = CONFIG["mimo_video_chunk_min_seconds"]
     chunks = []
-    for scene_index, scene in enumerate(scenes or []):
-        if not isinstance(scene, dict):
-            continue
-        try:
-            start = float(scene.get("start", 0.0))
-            end = float(scene.get("end", start))
-        except (TypeError, ValueError):
-            continue
-        if end <= start:
-            continue
+    for scene_index, scene in enumerate(scenes):
+        start, end = scene["start"], scene["end"]
         scene_id = scene.get("scene_id", scene_index)
         cursor = start
         while cursor < end:
             chunk_end = min(end, cursor + max_seconds)
             if end - chunk_end < min_seconds and chunk_end < end:
                 chunk_end = end
-            if chunk_end > cursor:
-                chunks.append(
-                    {
-                        "chunk_id": len(chunks),
-                        "scene_id": scene_id,
-                        "start": round(cursor, 3),
-                        "end": round(chunk_end, 3),
-                    }
-                )
+            chunks.append(
+                {
+                    "chunk_id": len(chunks),
+                    "scene_id": scene_id,
+                    "start": round(cursor, 3),
+                    "end": round(chunk_end, 3),
+                }
+            )
             cursor = chunk_end
     return chunks
 
 
-def _mimo_overview_matches_current_inputs(overview, scenes_analysis, video_path=None):
+def _mimo_overview_matches_current_inputs(overview, scenes, video_path=None):
+    """True only when mimo_video_overview.json was produced from the current settings,
+    source video and scene plan, and none of its chunks was moderation-rejected.
+    Provenance keys are read with .get: a stale or partial file simply does not match."""
     if not isinstance(overview, dict) or overview.get("input") != "scene_chunks":
         return False
-    if overview.get("settings") != _mimo_video_settings_fingerprint():
-        return False
-    overview_fingerprint = overview.get("overview_fingerprint")
-    if (
-        not overview_fingerprint
-        or overview_fingerprint != _mimo_overview_payload_fingerprint(overview)
+    settings = _mimo_video_settings_fingerprint()
+    expected_keys = [
+        _mimo_chunk_cache_key(chunk) for chunk in _mimo_video_chunks(scenes)
+    ]
+    chunks = overview.get("chunks")
+    if not isinstance(chunks, list) or not all(
+        isinstance(chunk, dict)
+        and isinstance(chunk.get("content"), str)
+        and _is_mimo_chunk_usable(chunk["content"])
+        for chunk in chunks
     ):
         return False
     if video_path is not None:
@@ -194,73 +164,60 @@ def _mimo_overview_matches_current_inputs(overview, scenes_analysis, video_path=
                 return False
         except OSError:
             return False
-    chunks = overview.get("chunks")
-    if not isinstance(chunks, list) or not all(
-        isinstance(chunk, dict) and _is_mimo_chunk_usable(chunk.get("content"))
-        for chunk in chunks
-    ):
-        return False
-    chunks_fingerprint = overview.get("chunks_fingerprint")
-    if not chunks_fingerprint or chunks_fingerprint != _mimo_cached_chunks_fingerprint(
-        chunks
-    ):
-        return False
-    expected_chunks = _mimo_video_chunks_for_brief(scenes_analysis)
-    if not expected_chunks or len(chunks) != len(expected_chunks):
-        return False
     try:
         cached_keys = [_mimo_chunk_cache_key(chunk) for chunk in chunks]
-        expected_keys = [_mimo_chunk_cache_key(chunk) for chunk in expected_chunks]
     except (KeyError, TypeError, ValueError):
         return False
-    return cached_keys == expected_keys
+    return (
+        overview.get("settings") == settings
+        and overview.get("overview_fingerprint")
+        == _mimo_overview_payload_fingerprint(overview)
+        and overview.get("chunks_fingerprint")
+        == _mimo_cached_chunks_fingerprint(chunks)
+        and cached_keys == expected_keys
+    )
 
 
-def _load_mimo_overview_for_brief(
-    work_dir, scenes_analysis, enabled=None, video_path=None
-):
-    overview_enabled = (
-        CONFIG.get("mimo_video_overview", False) if enabled is None else enabled
-    )
-    if not overview_enabled:
-        return {}
+def _load_mimo_overview_for_brief(work_dir, scenes, enabled=None, video_path=None):
+    """The current MiMo overview for the brief, or None when disabled, absent or stale."""
+    if not (CONFIG["mimo_video_overview"] if enabled is None else enabled):
+        return None
     path = Path(work_dir) / "mimo_video_overview.json"
     if not path.exists():
-        return {}
+        return None
     try:
         overview = json.loads(path.read_text(encoding="utf-8"))
-    except (json.JSONDecodeError, OSError):
-        return {}
-    return (
-        overview
-        if _mimo_overview_matches_current_inputs(
-            overview, scenes_analysis, video_path=video_path
-        )
-        else {}
-    )
+    except (OSError, json.JSONDecodeError):
+        return None
+    if not _mimo_overview_matches_current_inputs(
+        overview, scenes, video_path=video_path
+    ):
+        return None
+    return overview
 
 
 def _load_optional_stage_status(work_dir, filename):
-    """Load optional-stage status sidecars defensively."""
+    """Optional-stage status sidecar, or None when the stage never ran."""
     path = Path(work_dir) / filename
     if not path.exists():
-        return {}
+        return None
     try:
-        data = json.loads(path.read_text(encoding="utf-8"))
-    except (json.JSONDecodeError, OSError):
-        return {}
-    return data if isinstance(data, dict) else {}
-
-
-def _status_message(message, limit=180):
-    text = " ".join(str(message or "").split())
-    return text[:limit]
+        status = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    if not (
+        isinstance(status, dict)
+        and isinstance(status.get("enabled"), bool)
+        and isinstance(status.get("status"), str)
+        and isinstance(status.get("message"), str)
+    ):
+        return None
+    return status
 
 
 def _optional_stage_warning(stage, status, message):
     line = f"- {stage}: {status}"
-    msg = _status_message(message)
-    return f"{line} — {msg}" if msg else line
+    return f"{line} — {message[:180]}" if message else line
 
 
 def _format_optional_stage_warnings(
@@ -275,22 +232,23 @@ def _format_optional_stage_warnings(
     warnings = []
 
     overview_enabled = (
-        bool(CONFIG.get("mimo_video_overview", False))
+        CONFIG["mimo_video_overview"]
         if mimo_overview_enabled is None
-        else bool(mimo_overview_enabled)
+        else mimo_overview_enabled
     )
     overview_status = _load_optional_stage_status(
         work_dir, "mimo_video_overview.status.json"
     )
-    if overview_status.get("enabled") and overview_status.get("status") in {
-        "failed",
-        "skipped_no_key",
-    }:
+    if (
+        overview_status is not None
+        and overview_status["enabled"]
+        and overview_status["status"] in {"failed", "skipped_no_key"}
+    ):
         warnings.append(
             _optional_stage_warning(
                 "mimo_video_overview",
-                overview_status.get("status"),
-                overview_status.get("message"),
+                overview_status["status"],
+                overview_status["message"],
             )
         )
     elif overview_enabled and not mimo_overview:
@@ -305,14 +263,14 @@ def _format_optional_stage_warnings(
     consolidation_status = _load_optional_stage_status(
         work_dir, "consolidation.status.json"
     )
-    if consolidation_status.get("enabled"):
-        if consolidation_status.get("status") == "failed":
+    if consolidation_status is not None and consolidation_status["enabled"]:
+        if consolidation_status["status"] == "failed":
             warnings.append(
                 _optional_stage_warning(
-                    "consolidation", "failed", consolidation_status.get("message")
+                    "consolidation", "failed", consolidation_status["message"]
                 )
             )
-        elif consolidation_status.get("do_index") and not consolidation_index:
+        elif consolidation_status.get("do_index") is True and not consolidation_index:
             warnings.append(
                 _optional_stage_warning(
                     "consolidation",