@oh-story/dsh 0.1.8 → 0.1.9

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

@@ -1,7 +1,6 @@
 """Load measured source-speech evidence and classify narration ownership."""
 
 import json
-import math
 from pathlib import Path
 
 from lib import CONFIG, stable_hash
@@ -17,36 +16,16 @@ def _empty_evidence(mode):
 
 
 def _read_json(path):
-    try:
-        return json.loads(Path(path).read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return None
-
-
-def _timed_rows(payload, key):
-    rows = payload.get(key, []) if isinstance(payload, dict) else []
-    out = []
-    for row in rows if isinstance(rows, list) else []:
-        if not isinstance(row, dict):
-            continue
-        try:
-            start, end = float(row.get("start")), float(row.get("end"))
-        except (TypeError, ValueError):
-            continue
-        if math.isfinite(start) and math.isfinite(end) and end > start:
-            out.append({**row, "start": start, "end": end})
-    return out
+    """JSON artifact, or None when the optional file was never written."""
+    return json.loads(path.read_text(encoding="utf-8")) if path.exists() else None
 
 
 def _output_payload_is_current(payload, work_dir):
-    if not isinstance(payload, dict):
-        return False
-    if payload.get("schema_version") != 2 or payload.get("timeline") != "cut_output":
-        return False
     plan = _read_json(Path(work_dir) / "clip_plan_validated.json")
-    return bool(
-        isinstance(plan, dict)
-        and payload.get("clip_plan_fingerprint") == stable_hash(plan)
+    return (
+        payload is not None
+        and plan is not None
+        and payload["clip_plan_fingerprint"] == stable_hash(plan)
     )
 
 
@@ -55,55 +34,31 @@ def load_source_sentence_evidence(work_dir, mode="full"):
     if work_dir is None:
         return _empty_evidence(mode)
     work_dir = Path(work_dir)
-    output_mode = mode in {"cut", "cut_output"}
-    path = work_dir / (
-        "speech_boundary_anchors_output.json"
-        if output_mode
-        else "speech_boundary_anchors.json"
-    )
-    payload = _read_json(path)
-    if mode == "cut_output" and not _output_payload_is_current(payload, work_dir):
-        return _empty_evidence(mode)
-    if not isinstance(payload, dict):
-        payload = {}
-
-    speech_spans = _timed_rows(payload, "speech_spans")
-    quiet_windows = _timed_rows(payload, "quiet_windows")
-    if not output_mode:
-        for name in ("asr_result.json", "asr_clean.json"):
-            raw = _read_json(work_dir / name)
-            if isinstance(raw, list):
-                candidate = {"speech_spans": raw}
-            elif isinstance(raw, dict):
-                candidate = {"speech_spans": raw.get("segments", [])}
-            else:
-                continue
-            speech_spans = _timed_rows(candidate, "speech_spans")
-            if speech_spans:
-                break
-        raw_quiet = _read_json(work_dir / "silence_periods.json")
-        candidate = {
-            "quiet_windows": [
-                row
-                for row in raw_quiet
-                if isinstance(row, dict) and not bool(row.get("has_speech", False))
-            ]
-        } if isinstance(raw_quiet, list) else {}
-        quiet_windows = _timed_rows(candidate, "quiet_windows")
-
-    anchors = []
-    for anchor in payload.get("sentence_anchors", []):
-        if not isinstance(anchor, dict) or anchor.get("confidence") not in {
-            "high",
-            "medium",
-        }:
-            continue
-        try:
-            when = float(anchor.get("time"))
-        except (TypeError, ValueError):
-            continue
-        if math.isfinite(when) and when >= 0:
-            anchors.append({**anchor, "time": round(when, 3)})
+    if mode == "full":
+        payload = _read_json(work_dir / "speech_boundary_anchors.json") or {
+            "sentence_anchors": []
+        }
+        speech_spans = [
+            row for row in _read_json(work_dir / "asr_result.json") or [] if row["text"]
+        ]
+        quiet_windows = [
+            row
+            for row in _read_json(work_dir / "silence_periods.json") or []
+            if not row["has_speech"]
+        ]
+    else:
+        payload = _read_json(work_dir / "speech_boundary_anchors_output.json")
+        if mode == "cut_output" and not _output_payload_is_current(payload, work_dir):
+            return _empty_evidence(mode)
+        if payload is None:
+            payload = {"sentence_anchors": [], "speech_spans": [], "quiet_windows": []}
+        speech_spans = payload["speech_spans"]
+        quiet_windows = payload["quiet_windows"]
+    anchors = [
+        anchor
+        for anchor in payload["sentence_anchors"]
+        if anchor["confidence"] in {"high", "medium"}
+    ]
     return {
         "anchors": sorted(anchors, key=lambda item: item["time"]),
         "speech_spans": speech_spans,
@@ -147,16 +102,9 @@ def _speech_overlap_excluding_quiet(start, end, speech, quiet):
 
 def segment_overlaps_source_speech(seg, evidence):
     """Classify aggregate mix ownership across the complete narration interval."""
-    try:
-        start, end = float(seg.get("start")), float(seg.get("end"))
-    except (AttributeError, TypeError, ValueError):
-        return bool(getattr(seg, "get", lambda *_: True)("overlaps_speech", True))
-    duration = max(0.0, end - start)
+    start, end = seg["start"], seg["end"]
     quiet = evidence["quiet_windows"]
-    quiet_min = max(
-        0.3,
-        duration * float(CONFIG.get("quiet_overlap_min_ratio", 0.8) or 0.8),
-    )
+    quiet_min = max(0.3, (end - start) * CONFIG["quiet_overlap_min_ratio"])
     speech = evidence["speech_spans"]
     if speech:
         return _speech_overlap_excluding_quiet(start, end, speech, quiet) > 0.05
@@ -167,12 +115,8 @@ def segment_overlaps_source_speech(seg, evidence):
     return bool(seg.get("overlaps_speech", True))
 
 
-def entry_overlaps_source_speech(seg, evidence, tolerance=0.05):
+def entry_overlaps_source_speech(start, evidence, *, authored_overlap=True, tolerance=0.05):
     """Classify the entry instant; later quiet time cannot erase an unsafe start."""
-    try:
-        start = float(seg.get("start"))
-    except (AttributeError, TypeError, ValueError):
-        return True
     if any(
         row["start"] - tolerance <= start <= row["end"] + tolerance
         for row in evidence["quiet_windows"]
@@ -187,18 +131,13 @@ def entry_overlaps_source_speech(seg, evidence, tolerance=0.05):
         return False
     if evidence["anchors"] or evidence["require_measured"]:
         return True
-    return bool(seg.get("overlaps_speech", True))
+    return bool(authored_overlap)
 
 
 def measure_narration_speech_ownership(narration, work_dir, mode="full"):
     """Return narration copies with aggregate ownership derived from evidence."""
     evidence = load_source_sentence_evidence(work_dir, mode=mode)
-    measured = []
-    for seg in narration if isinstance(narration, list) else []:
-        if not isinstance(seg, dict):
-            measured.append(seg)
-            continue
-        item = dict(seg)
-        item["overlaps_speech"] = segment_overlaps_source_speech(item, evidence)
-        measured.append(item)
-    return measured
+    return [
+        {**seg, "overlaps_speech": segment_overlaps_source_speech(seg, evidence)}
+        for seg in narration
+    ]

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

@@ -1,88 +1,49 @@
 """Fuse scenes, ASR, and quiet windows for narration planning."""
 
-import importlib.util
-
-
-from pathlib import Path
-
 from lib import CONFIG
-
-
 from agent_text import _overlap_seconds, _recommended_char_budget
 from narration_lint import _validate_narration_budget
 
-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
+
+def _quiet_windows(silence_periods):
+    return [qp for qp in silence_periods if not qp["has_speech"]]
 
 
 def _align_narration_to_quiet(narration, scenes_analysis, silence_periods):
     """Recompute overlaps_speech from real quiet windows; keep the agent's timing.
 
     The dense continuous-bed design places narration ON the pictured beat over a
-    ducked original bed, so we no longer relocate segments into silence gaps. The
-    old shift moved voiceover up to 3s off the moment it was written for and could
-    silently blank a squeezed segment; both fought the design intent. We now only
-    correct the overlaps_speech flag that the ducking stage consumes, leaving the
-    agent's start/end (and text) intact.
-    """
-    if not silence_periods:
-        for n in narration:
-            n["overlaps_speech"] = True
-        return _validate_narration_budget(narration, scenes_analysis)
+    ducked original bed, so segments are never relocated into silence gaps. Only
+    the overlaps_speech flag that the ducking stage consumes is corrected, leaving
+    the agent's start/end (and text) intact.
 
-    quiet_windows = [
-        qp for qp in silence_periods if _silence_window_is_usable_quiet(qp)
-    ]
-    quiet_ratio_min = float(CONFIG.get("quiet_overlap_min_ratio", 0.8) or 0.8)
-
-    # Run budget/dedup FIRST, then set the flag on the final (possibly merged) spans,
-    # so a dedup-merged beat's overlaps_speech reflects its extended timing, not its
-    # original shorter span (which the ducking stage in assemble.py would mis-duck).
+    Budget/dedup runs FIRST so a dedup-merged beat's overlaps_speech reflects its
+    extended timing, not its original shorter span.
+    """
     aligned = _validate_narration_budget(narration, scenes_analysis)
+    quiet_windows = _quiet_windows(silence_periods)
+    quiet_ratio_min = CONFIG["quiet_overlap_min_ratio"]
     for n in aligned:
-        try:
-            seg_start = float(n["start"])
-            seg_end = float(n["end"])
-        except (KeyError, TypeError, ValueError):
-            n["overlaps_speech"] = True
-            continue
-        seg_dur = max(0.0, seg_end - seg_start)
-        quiet_overlap = _quiet_overlap_seconds(seg_start, seg_end, quiet_windows)
+        seg_dur = n["end"] - n["start"]
+        quiet_overlap = sum(
+            _overlap_seconds(n["start"], n["end"], qw["start"], qw["end"])
+            for qw in quiet_windows
+        )
         n["overlaps_speech"] = quiet_overlap < max(0.3, seg_dur * quiet_ratio_min)
-
     return aligned
 
 
 def _scene_asr_lines(asr_result, scene):
     lines = []
-    for seg in asr_result or []:
-        try:
-            start = float(seg.get("start", 0))
-            end = float(seg.get("end", start))
-        except (TypeError, ValueError):
-            continue
-        if scene["start"] < end and scene["end"] > start:
-            text = str(seg.get("text", "")).strip()
-            if text:
-                lines.append(f"    [{start:.1f}-{end:.1f}] {text}")
+    for seg in asr_result:
+        if scene["start"] < seg["end"] and scene["end"] > seg["start"] and seg["text"]:
+            lines.append(f"    [{seg['start']:.1f}-{seg['end']:.1f}] {seg['text']}")
     return lines
 
 
 def _quiet_windows_for_scene(silence_periods, scene):
     windows = []
-    for qp in silence_periods or []:
-        if not _silence_window_is_usable_quiet(qp):
-            continue
+    for qp in _quiet_windows(silence_periods):
         if qp["start"] < scene["end"] and qp["end"] > scene["start"]:
             start = max(qp["start"], scene["start"])
             end = min(qp["end"], scene["end"])
@@ -91,87 +52,35 @@ def _quiet_windows_for_scene(silence_periods, scene):
     return windows
 
 
-def _silence_window_is_usable_quiet(qp):
-    if not isinstance(qp, dict):
-        return False
-    reason = str(qp.get("has_speech_reason", "")).lower()
-    granularity = str(qp.get("asr_granularity", "")).lower()
-    if reason in {
-        "coarse_asr_overlap_ignored",
-        "asr_overlap_low_confidence_quiet",
-        "coarse_asr_no_overlap",
-    }:
-        return True
-    if granularity == "coarse_grid" and qp.get("has_speech") is True:
-        return True
-    return not qp.get("has_speech", False)
-
-
-def _quiet_overlap_seconds(start, end, quiet_windows):
-    overlap_seconds = 0.0
-    for qw in quiet_windows:
-        try:
-            if isinstance(qw, dict):
-                q_start = float(qw.get("start", 0))
-                q_end = float(qw.get("end", q_start))
-            else:
-                q_start, q_end = qw
-                q_start = float(q_start)
-                q_end = float(q_end)
-        except (TypeError, ValueError):
-            continue
-        overlap_seconds += _overlap_seconds(start, end, q_start, q_end)
-    return overlap_seconds
-
-
 def _build_timeline_fusion(scenes, asr_segments, silence_periods):
     """Fuse VLM scenes, ASR dialogue and quiet narration slots on one timeline."""
     fusion = []
-    quiet_windows = [
-        w for w in silence_periods or [] if _silence_window_is_usable_quiet(w)
-    ]
-    for scene in scenes or []:
-        try:
-            start = float(scene.get("start", 0))
-            end = float(scene.get("end", start))
-        except (TypeError, ValueError):
-            continue
+    quiet_windows = _quiet_windows(silence_periods)
+    for scene in scenes:
+        start, end = scene["start"], scene["end"]
         dialogue_segments = []
         dialogue_overlap = 0.0
-        for seg in asr_segments or []:
-            if not isinstance(seg, dict):
-                continue
-            try:
-                seg_start = float(seg.get("start", 0))
-                seg_end = float(seg.get("end", seg_start))
-            except (TypeError, ValueError):
-                continue
-            overlap = _overlap_seconds(start, end, seg_start, seg_end)
+        for seg in asr_segments:
+            overlap = _overlap_seconds(start, end, seg["start"], seg["end"])
             if overlap <= 0:
                 continue
-            text = str(seg.get("text", "")).strip()
             dialogue_overlap += overlap
             dialogue_segments.append(
                 {
-                    "start": round(seg_start, 2),
-                    "end": round(seg_end, 2),
+                    "start": round(seg["start"], 2),
+                    "end": round(seg["end"], 2),
                     "overlap_seconds": round(overlap, 2),
-                    "text": text,
+                    "text": seg["text"],
                 }
             )
 
         narration_slots = []
         for window in quiet_windows:
-            try:
-                w_start = float(window.get("start", 0))
-                w_end = float(window.get("end", w_start))
-            except (TypeError, ValueError):
-                continue
-            overlap = _overlap_seconds(start, end, w_start, w_end)
+            overlap = _overlap_seconds(start, end, window["start"], window["end"])
             if overlap <= 0:
                 continue
-            slot_start = max(start, w_start)
-            slot_end = min(end, w_end)
+            slot_start = max(start, window["start"])
+            slot_end = min(end, window["end"])
             narration_slots.append(
                 {
                     "start": round(slot_start, 2),
@@ -183,9 +92,9 @@ def _build_timeline_fusion(scenes, asr_segments, silence_periods):
 
         fusion.append(
             {
-                "scene_id": scene.get("scene_id"),
+                "scene_id": scene["scene_id"],
                 "time_range": [round(start, 2), round(end, 2)],
-                "visual_description": scene.get("description", ""),
+                "visual_description": scene["description"],
                 "depth_analysis": scene.get("depth_analysis", ""),
                 "frame_facts": scene.get("frame_facts", {}),
                 "dialogue_segments": dialogue_segments,

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

@@ -24,10 +24,7 @@ def _parse_vlm_depth_response(raw_text):
 
     # 提取【描述】
     desc_match = re.search(r'【描述】\s*\n?(.*?)(?=【帧标签】|【深层分析】|$)', raw_text, re.DOTALL)
-    if desc_match:
-        description = desc_match.group(1).strip()
-    else:
-        description = raw_text.strip()
+    description = desc_match.group(1).strip() if desc_match else raw_text.strip()
 
     # 提取【帧标签】
     frame_facts = {}

package/lib/video-recap/skills/video-voiceover/scripts/dub.py

@@ -89,13 +89,13 @@ DUB_ARTIFACT_SCHEMAS = {
 
 
 def _chars_per_second(text, room):
-    room = max(float(room or 0.0), 0.001)
+    room = max(room, 0.001)
     effective = 0
-    for ch in str(text or ""):
+    for ch in text:
         if ch.isspace():
             continue
         cat = unicodedata.category(ch)
-        if cat.startswith("P") or cat.startswith("S"):
+        if cat.startswith(("P", "S")):
             continue
         effective += 1
     return effective / room
@@ -104,15 +104,13 @@ def _chars_per_second(text, room):
 def _issue(severity, code, line, message, start=None, end=None):
     item = {"severity": severity, "code": code, "line": line, "message": message}
     if start is not None:
-        item["start"] = round(float(start), 3)
+        item["start"] = round(start, 3)
     if end is not None:
-        item["end"] = round(float(end), 3)
+        item["end"] = round(end, 3)
     return item
 
 
 def _normalize_dub_script(script):
-    if not isinstance(script, list):
-        raise ValueError("dub_script.json must be a list")
     lines = []
     for i, item in enumerate(script):
         if not isinstance(item, dict):
@@ -212,10 +210,7 @@ def build_dub_review(script, transcript, lint=None):
     """Script-level review scaffold: deterministic timing/naturalness signals for agent review."""
     duration = float(transcript.get("duration", 0.0))
     lint = lint or lint_dub_script(script, duration)
-    try:
-        lines = _normalize_dub_script(script)
-    except ValueError:
-        lines = []  # non-list script already FAILs lint; review is just a scaffold here
+    lines = _normalize_dub_script(script) if isinstance(script, list) else []
     edits = []
     for issue in lint.get("issues", []):
         if issue["severity"] in {"error", "warning"}:
@@ -286,8 +281,7 @@ def _strip_reasoning_residue(text):
     """
     text = re.sub(r"(?is)<think\b.*?</think\s*>", "", text)  # full <think>…</think> block
     text = re.sub(r"(?is)<think\b.*\Z", "", text)            # unclosed/truncated <think tail
-    text = re.sub(r"(?i)^\s*<?/?think\s*>\s*", "", text)     # leading orphan/residual think tag
-    return text
+    return re.sub(r"(?i)^\s*<?/?think\s*>\s*", "", text)     # leading orphan/residual think tag
 
 
 def _run_asr(wav_path, lang="en"):

package/lib/video-recap/skills/video-voiceover/scripts/fish_audio.py

@@ -10,62 +10,50 @@ import urllib.error
 import urllib.request
 from pathlib import Path
 
-from lib import (
-    CONFIG,
-    DEFAULT_FISH_TTS_API_URL,
-    DEFAULT_FISH_TTS_MODEL,
-    _sanitize_api_error,
-)
+from lib import CONFIG, _sanitize_api_error
 
 
-def _fish_payload(text, rate="+0%"):
-    try:
-        speed = 1.0 + float(str(rate).rstrip("%")) / 100.0
-    except (TypeError, ValueError):
-        speed = 1.0
+def _fish_payload(text, rate):
     payload = {
         "text": text,
         "format": "wav",
         "normalize": True,
         "prosody": {
-            "speed": max(0.5, min(2.0, speed)),
+            "speed": 1.0 + float(rate.rstrip("%")) / 100.0,
             "volume": 0,
             "normalize_loudness": True,
         },
     }
-    reference_id = str(CONFIG.get("fish_tts_reference_id") or "").strip()
+    reference_id = CONFIG["fish_tts_reference_id"]
     if reference_id:
         payload["reference_id"] = reference_id
     return payload
 
 
-def synthesize_fish_audio(text, output_path, rate="+0%", **_ignored):
+def synthesize_fish_audio(text, output_path, rate="+0%"):
     """Synthesize one narration block and atomically write the WAV response."""
-    api_key = str(CONFIG.get("fish_api_key") or "").strip()
+    api_key = CONFIG["fish_api_key"]
     if not api_key:
         raise RuntimeError("请设置 FISH_API_KEY 用于 Fish Audio TTS")
 
-    endpoint = str(CONFIG.get("fish_tts_api_url") or DEFAULT_FISH_TTS_API_URL)
-    model = str(CONFIG.get("fish_tts_model") or DEFAULT_FISH_TTS_MODEL)
     body = json.dumps(_fish_payload(text, rate), ensure_ascii=False).encode("utf-8")
     request = urllib.request.Request(
-        endpoint,
+        CONFIG["fish_tts_api_url"],
         data=body,
         headers={
             "Authorization": f"Bearer {api_key}",
             "Content-Type": "application/json",
             "Accept": "audio/wav",
-            "model": model,
+            "model": CONFIG["fish_tts_model"],
             "User-Agent": "video-recap/1.0",
         },
         method="POST",
     )
 
-    timeout = max(1, int(CONFIG.get("tts_timeout", 300) or 300))
     try:
-        with urllib.request.urlopen(request, timeout=timeout) as response:
+        with urllib.request.urlopen(request, timeout=CONFIG["tts_timeout"]) as response:
             audio = response.read()
-            content_type = str(response.headers.get("Content-Type") or "").lower()
+            content_type = response.headers.get("Content-Type", "").lower()
     except urllib.error.HTTPError as exc:
         detail = _sanitize_api_error(
             exc.read().decode("utf-8", errors="replace"),
@@ -99,11 +87,5 @@ def synthesize_fish_audio(text, output_path, rate="+0%", **_ignored):
 
     output = Path(output_path)
     partial = Path(str(output) + ".part")
-    try:
-        partial.write_bytes(audio)
-        os.replace(partial, output)
-    finally:
-        try:
-            partial.unlink(missing_ok=True)
-        except OSError:
-            pass
+    partial.write_bytes(audio)
+    os.replace(partial, output)