@oh-story/dsh 0.1.8 → 0.1.9

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

@@ -1,30 +1,10 @@
 """Normalize, split, budget, and de-duplicate narration text."""
 
-import importlib.util
-
 import copy
-
-
 import re
 
-from pathlib import Path
-
-from lib import CONFIG
-
-from lib import log
-
-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
+from lib import CONFIG, log
+from deslop_qc import _sentence_pieces, _text_units
 
 
 def _format_frame_facts(scene):
@@ -32,10 +12,7 @@ def _format_frame_facts(scene):
     facts = scene.get("frame_facts", {})
     if not facts:
         return ""
-    lines = []
-    for ts in sorted(facts.keys(), key=lambda x: float(x)):
-        actions = facts[ts]
-        lines.append(f"    {ts}s: {'; '.join(actions)}")
+    lines = [f"    {ts}s: {'; '.join(facts[ts])}" for ts in sorted(facts, key=float)]
     return "\n  帧动作:\n" + "\n".join(lines)
 
 
@@ -45,50 +22,23 @@ def _text_char_count(text):
         re.sub(
             r'[，。！？、；：…“”‘’《》〈〉\s"\'「」『』（）()【】\[\]—～·,.!?;:\\-]',
             "",
-            text or "",
+            text,
         )
     )
 
 
-def _contains_cjk(text):
-    return bool(re.search(r"[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]", text or ""))
-
-
-def _writing_text_units(text):
-    """Length unit used for ASR writing chunks: CJK chars, otherwise words."""
-    text = str(text or "")
-    if _contains_cjk(text):
-        return len(re.sub(r"\s+", "", text))
-    return len(re.findall(r"\b\w+\b", text))
-
-
-def _sentence_pieces(text):
-    """Split text into sentence-like pieces while keeping terminal punctuation."""
-    text = re.sub(r"\s+", " ", str(text or "")).strip()
-    if not text:
-        return []
-    parts = re.split(r"([。！？!?；;.])", text)
-    cleaned = []
-    for idx in range(0, len(parts), 2):
-        body = parts[idx].strip()
-        punct = parts[idx + 1] if idx + 1 < len(parts) else ""
-        if body or punct:
-            cleaned.append((body + punct).strip())
-    return cleaned or [text]
-
-
 def _split_text_by_sentence_windows(text, min_chars=500, max_chars=800):
     """Clipto-style three-tier sentence boundary splitting for long ASR text."""
-    text = re.sub(r"\s+", " ", str(text or "")).strip()
+    text = re.sub(r"\s+", " ", text).strip()
     if not text:
         return []
-    if _writing_text_units(text) <= max_chars:
+    if _text_units(text) <= max_chars:
         return _sentence_pieces(text)
 
     result = []
     rest = text
     sentence_marks = "。！？!?；;."
-    while _writing_text_units(rest) > max_chars:
+    while _text_units(rest) > max_chars:
         # The min/max thresholds are unit-based but punctuation is char-indexed.
         # For Chinese (the dominant recap target) these are nearly identical; for
         # non-CJK this remains a safe sentence-boundary heuristic around words.
@@ -102,10 +52,7 @@ def _split_text_by_sentence_windows(text, min_chars=500, max_chars=800):
                 if ch in sentence_marks:
                     outside = i
                     break
-            if outside >= 0 and outside + 1 <= len(rest):
-                cut = outside
-            else:
-                cut = char_max - 1
+            cut = outside if outside >= 0 and outside + 1 <= len(rest) else char_max - 1
         piece = rest[: cut + 1].strip()
         if not piece:
             piece = rest[:char_max].strip()
@@ -119,19 +66,13 @@ def _split_text_by_sentence_windows(text, min_chars=500, max_chars=800):
 
 def _timed_sentence_pieces(seg, min_chars, max_chars):
     """Split one ASR segment into timed sentence pieces with approximate spans."""
-    text = str(seg.get("text", "")).strip()
+    text = seg["text"].strip()
     if not text:
         return []
-    try:
-        start = float(seg.get("start", 0))
-        end = float(seg.get("end", start))
-    except (TypeError, ValueError):
-        start = end = 0.0
-    if end < start:
-        end = start
+    start, end = seg["start"], seg["end"]
     pieces = []
     for sentence in _sentence_pieces(text):
-        if _writing_text_units(sentence) > max_chars:
+        if _text_units(sentence) > max_chars:
             pieces.extend(
                 _split_text_by_sentence_windows(
                     sentence, min_chars=min_chars, max_chars=max_chars
@@ -139,20 +80,19 @@ def _timed_sentence_pieces(seg, min_chars, max_chars):
             )
         else:
             pieces.append(sentence)
-    total_units = sum(max(1, _writing_text_units(piece)) for piece in pieces) or 1
-    duration = max(0.0, end - start)
+    total_units = sum(max(1, _text_units(piece)) for piece in pieces)
+    duration = end - start
     cursor = start
     timed = []
     for idx, piece in enumerate(pieces):
-        units = max(1, _writing_text_units(piece))
-        piece_duration = duration * units / total_units if duration else 0.0
-        piece_end = end if idx == len(pieces) - 1 else cursor + piece_duration
+        units = max(1, _text_units(piece))
+        piece_end = end if idx == len(pieces) - 1 else cursor + duration * units / total_units
         timed.append(
             {
                 "start": round(cursor, 2),
                 "end": round(piece_end, 2),
                 "text": piece,
-                "char_count": _writing_text_units(piece),
+                "char_count": _text_units(piece),
             }
         )
         cursor = piece_end
@@ -160,25 +100,18 @@ def _timed_sentence_pieces(seg, min_chars, max_chars):
 
 
 def _scene_ids_for_range(scenes, start, end):
+    duration = max(0.001, end - start)
     scene_ids = []
-    duration = max(0.001, float(end) - float(start))
-    for scene in scenes or []:
-        try:
-            s_start = float(scene.get("start", 0))
-            s_end = float(scene.get("end", s_start))
-        except (TypeError, ValueError):
-            continue
-        overlap = _overlap_seconds(start, end, s_start, s_end)
+    for scene in scenes:
+        overlap = _overlap_seconds(start, end, scene["start"], scene["end"])
         # Ignore tiny boundary tails from approximate ASR sentence timing. A
         # scene id should mean the chunk materially belongs to that scene.
         if overlap and (overlap >= duration * 0.2 or overlap >= 3.0):
-            scene_ids.append(scene.get("scene_id"))
-    return [sid for sid in scene_ids if sid is not None]
+            scene_ids.append(scene["scene_id"])
+    return scene_ids
 
 
-def _chunk_asr_for_writing(
-    segments, scenes_analysis=None, min_chars=None, max_chars=None
-):
+def _chunk_asr_for_writing(segments, scenes_analysis, min_chars=None, max_chars=None):
     """Chunk ASR into semantic windows before an agent writes long-dialogue recaps.
 
     The strategy mirrors Clipto's segment splitter: accumulate a window, prefer
@@ -186,15 +119,13 @@ def _chunk_asr_for_writing(
     boundary outside the window, and fall back to the remaining text. CJK text is
     measured by characters; non-CJK text is measured by words.
     """
-    min_chars = int(min_chars or CONFIG.get("asr_chunk_min_chars", 500))
-    max_chars = int(max_chars or CONFIG.get("asr_chunk_max_chars", 800))
-    min_chars = max(1, min(min_chars, max_chars))
-    max_chars = max(min_chars, max_chars)
-
-    pieces = []
-    for seg in segments or []:
-        if isinstance(seg, dict):
-            pieces.extend(_timed_sentence_pieces(seg, min_chars, max_chars))
+    min_chars = CONFIG["asr_chunk_min_chars"] if min_chars is None else min_chars
+    max_chars = CONFIG["asr_chunk_max_chars"] if max_chars is None else max_chars
+    pieces = [
+        piece
+        for seg in segments
+        for piece in _timed_sentence_pieces(seg, min_chars, max_chars)
+    ]
 
     chunks = []
     current = []
@@ -208,8 +139,8 @@ def _chunk_asr_for_writing(
         chunks.append(
             {
                 "chunk_id": len(chunks),
-                "start": round(float(current[0]["start"]), 2),
-                "end": round(float(current[-1]["end"]), 2),
+                "start": current[0]["start"],
+                "end": current[-1]["end"],
                 "scene_ids": sorted(
                     current_scene_ids, key=lambda sid: (isinstance(sid, str), sid)
                 ),
@@ -223,9 +154,7 @@ def _chunk_asr_for_writing(
         current_scene_ids = set()
 
     for piece in pieces:
-        units = max(
-            1, int(piece.get("char_count", _writing_text_units(piece.get("text", ""))))
-        )
+        units = max(1, piece["char_count"])
         piece_scene_ids = set(
             _scene_ids_for_range(scenes_analysis, piece["start"], piece["end"])
         )
@@ -279,12 +208,6 @@ def _post_dedup_narration(narration):
     result = [narration[0]]
     for seg in narration[1:]:
         prev = result[-1]
-        if (
-            not prev.get("narration", "").strip()
-            or not seg.get("narration", "").strip()
-        ):
-            result.append(seg)
-            continue
         set_a, set_b = _char_bigrams(prev["narration"]), _char_bigrams(seg["narration"])
         if not set_a or not set_b:
             result.append(seg)
@@ -294,20 +217,15 @@ def _post_dedup_narration(narration):
         # bigrams by chance, so a low threshold collapses intentional parallel beats
         # ("他不再试探" / "他直接赌上全力") and silently drops density below target.
         if overlap > 0.6:
-            # Validation is also the handoff boundary for renderer metadata.  When two
-            # near-identical narration beats are merged, retain overlays authored on either
-            # beat instead of silently discarding the second beat's visual instructions.
-            merged_overlays = []
-            for candidate in (prev, seg):
-                raw_overlays = candidate.get("visual_overlays")
-                if isinstance(raw_overlays, list):
-                    merged_overlays.extend(copy.deepcopy(raw_overlays))
+            # Validation is also the handoff boundary for renderer metadata: keep the
+            # overlays authored on either merged beat.
+            merged_overlays = copy.deepcopy(
+                prev.get("visual_overlays", []) + seg.get("visual_overlays", [])
+            )
             if len(seg["narration"]) > len(prev["narration"]):
                 prev["narration"] = seg["narration"]
             prev["end"] = seg["end"]
-            prev["pause_after_ms"] = seg.get(
-                "pause_after_ms", prev.get("pause_after_ms", 600)
-            )
+            prev["pause_after_ms"] = seg["pause_after_ms"]
             if merged_overlays:
                 prev["visual_overlays"] = merged_overlays
             log(f"  去重合并: {prev['start']:.0f}-{prev['end']:.0f}s")
@@ -319,56 +237,39 @@ def _post_dedup_narration(narration):
     return result
 
 
-def _scene_available_seconds(start, end, pause_after_ms=None):
-    del pause_after_ms  # pause_after_ms affects the next segment gap during assembly, not current speech capacity.
-    tail_pad = max(0.0, float(CONFIG.get("narration_tail_pad_seconds", 0.1) or 0.0))
-    return max(0.0, float(end) - float(start) - tail_pad)
+def _scene_available_seconds(start, end):
+    return max(0.0, end - start - CONFIG["narration_tail_pad_seconds"])
 
 
-def _recommended_char_budget(start, end, pause_after_ms=None):
+def _recommended_char_budget(start, end):
     # account for the global narration atempo (CONFIG['narration_speed']) so a beat's text
     # is budgeted against the FINAL sped-up audio, not the raw TTS rate — otherwise windows
     # are over-sized and the bed shows long silent gaps between sentences.
     effective_rate = (
-        CONFIG["speech_rate"]
-        * CONFIG["speech_safety_margin"]
-        * float(CONFIG.get("narration_speed", 1.0) or 1.0)
+        CONFIG["speech_rate"] * CONFIG["speech_safety_margin"] * CONFIG["narration_speed"]
     )
-    available = _scene_available_seconds(start, end, pause_after_ms)
-    return max(0, int(available * effective_rate))
+    return int(_scene_available_seconds(start, end) * effective_rate)
 
 
 def _find_scene_for_midpoint(scenes_analysis, start, end):
-    mid = (float(start) + float(end)) / 2
+    mid = (start + end) / 2
     for scene in scenes_analysis:
         if scene["start"] <= mid <= scene["end"]:
             return scene
     return None
 
 
-def _normalise_narration_segment(seg, scenes_analysis=None):
-    if not isinstance(seg, dict):
-        return None
-    try:
-        start = float(seg.get("start"))
-        end = float(seg.get("end"))
-    except (TypeError, ValueError):
-        return None
-    if end <= start:
-        return None
-    text = str(seg.get("narration", "")).strip()
-    if not text:
-        return None
-    pause = seg.get("pause_after_ms", CONFIG.get("breath_ms", 250))
-    try:
-        pause = int(pause)
-    except (TypeError, ValueError):
-        pause = CONFIG.get("breath_ms", 250)
+def _normalise_narration_segment(seg):
+    """Normalize one lint-validated narration segment for the full-mode rewrite.
+
+    Authored timing is a delivery contract: scene boundaries are approximate
+    visual-analysis buckets, so start/end are never clamped here.
+    """
     item = {
-        "start": round(start, 2),
-        "end": round(end, 2),
-        "narration": text,
-        "pause_after_ms": pause,
+        "start": round(seg["start"], 2),
+        "end": round(seg["end"], 2),
+        "narration": str(seg["narration"]).strip(),
+        "pause_after_ms": int(seg.get("pause_after_ms", CONFIG["breath_ms"])),
         "overlaps_speech": bool(seg.get("overlaps_speech", True)),
     }
     for optional_key in (
@@ -381,30 +282,20 @@ def _normalise_narration_segment(seg, scenes_analysis=None):
         if optional_key in seg:
             item[optional_key] = seg[optional_key]
     # carry the per-beat emotion/tone tag (MiMo TTS instruct) through lint untouched
-    emotion = seg.get("emotion")
-    if isinstance(emotion, str) and emotion.strip():
-        item["emotion"] = emotion.strip()
-    # Preserve renderer-owned metadata across the full-mode validation rewrite.  The recap
-    # orchestrator filters supported overlay kinds later; validation must not erase authored
-    # overlays merely because it normalizes narration timing/text fields.
-    visual_overlays = seg.get("visual_overlays")
-    if isinstance(visual_overlays, list):
-        item["visual_overlays"] = copy.deepcopy(visual_overlays)
-    # Authored timing is a delivery contract. Scene boundaries are approximate
-    # visual-analysis buckets, while source sentence anchors are measured audio
-    # handoff points. Lint may warn when a block crosses a scene, but validation
-    # must never silently clamp start/end and invalidate an audio-safe handoff.
+    if seg.get("emotion"):
+        item["emotion"] = seg["emotion"].strip()
+    # Renderer-owned metadata survives the validation rewrite; the recap orchestrator
+    # filters supported overlay kinds later.
+    if "visual_overlays" in seg:
+        item["visual_overlays"] = copy.deepcopy(seg["visual_overlays"])
     return item
 
 
 def _clean_narration_punctuation(text):
-    text = re.sub(r"\s+", " ", text or "").strip()
+    text = re.sub(r"\s+", " ", text).strip()
     text = re.sub(r'[，：、；,]["\']?[。！？]', "。", text)
-    text = re.sub(r'["\']。$', "。", text)
-    return text
+    return re.sub(r'["\']。$', "。", text)
 
 
 def _overlap_seconds(start, end, other_start, other_end):
-    return max(
-        0.0, min(float(end), float(other_end)) - max(float(start), float(other_start))
-    )
+    return max(0.0, min(end, other_end) - max(start, other_start))

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

@@ -176,8 +176,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):