@oh-story/dsh 0.1.10 → 0.1.12

package/lib/video-recap/skills/video-assemble/scripts/adoption/strict_publish.py

@@ -0,0 +1,130 @@
+"""Publish transaction for strict-adoption renders.
+
+An active narration binding renders to a hidden candidate file. Its binding (and,
+for an explicit mix, the audio mix binding) is written, QC gates the candidate,
+the media file is published, and QC runs once more against the published path.
+Any failure removes the candidate, the published file and the bindings written
+by this render, so a strict output never exists without its consumed-input record.
+"""
+
+from pathlib import Path
+
+import assembly_contract
+import adoption.audio_mix_binding as audio_mix_binding
+import adoption.narration_binding as narration_binding
+
+
+def current_narration_binding(work_dir, audio_mode):
+    """Read the narration record only for the explicit narration render path."""
+    if audio_mode != "narration":
+        return None
+    return narration_binding.binding_record(work_dir)
+
+
+def current_audio_mix_binding(work_dir, audio_mode):
+    if audio_mode != "narration":
+        return None
+    return audio_mix_binding.binding_record(work_dir)
+
+
+def publish_render(*, work_dir, binding, explicit_mix, tts_segments, narration_wav,
+                   render_output, published_output, audio_mode, audio_operations,
+                   adopted_audio, loudness_mode, loudnorm_measurement, visual_qc,
+                   source_has_audio, video_duration, render_delivery, source_audio_status):
+    """Gate the rendered candidate on assembly QC and publish it with its bindings.
+
+    Returns the final output path. Inactive-binding renders only write their
+    binding and QC; strict renders write bindings, publish, and re-run QC, or roll
+    everything back.
+    """
+    active = bool(binding and binding["active"])
+    work_dir = Path(work_dir)
+    binding_path = work_dir / narration_binding.FILENAME
+    mix_binding_path = work_dir / audio_mix_binding.FILENAME
+    binding_written = False
+    mix_binding_written = False
+    try:
+        if active:
+            report = narration_binding.finalize_binding(
+                binding, tts_segments,
+                (work_dir / "narration.wav" if explicit_mix is not None else narration_wav),
+                published_output, rendered_output=render_output,
+            )
+            binding_written = True
+            if not binding_path.is_file():
+                raise RuntimeError("narration binding 未写入")
+            narration_record = narration_binding.record_of(report, binding_path)
+            mix_record = None
+            if explicit_mix is not None:
+                audio_mix_binding.finalize_binding(
+                    explicit_mix, narration_record, render_output, published_output, work_dir
+                )
+                mix_binding_written = True
+                mix_record = {"path": str(mix_binding_path.resolve()), "status": "FINALIZED"}
+        elif binding:
+            narration_binding.finalize_binding(
+                binding, tts_segments, narration_wav, render_output
+            )
+            narration_record = current_narration_binding(work_dir, audio_mode)
+            mix_record = None
+        else:
+            narration_record = current_narration_binding(work_dir, audio_mode)
+            mix_record = None
+        assembly_qc = assembly_contract._build_assembly_qc(
+            tts_segments,
+            video_duration,
+            output_path=render_output,
+            source_has_audio=source_has_audio,
+            loudness_mode=loudness_mode,
+            loudnorm_measurement=loudnorm_measurement,
+            visual_qc=visual_qc,
+            audio_mode=audio_mode,
+            audio_operations=audio_operations,
+            adopted_audio=adopted_audio,
+            narration_input_binding=narration_record,
+            audio_mix_binding=mix_record,
+            source_audio_status=source_audio_status,
+            render_delivery=render_delivery,
+        )
+        if active and assembly_qc["blocking"]:
+            assembly_contract._write_assembly_qc(work_dir, assembly_qc)
+            codes = ", ".join(assembly_qc["blocking_codes"])
+            raise RuntimeError(f"身份约束渲染 QC 失败: {codes}")
+        if active:
+            render_output.rename(published_output)
+            render_output = published_output
+            current_binding = current_narration_binding(work_dir, audio_mode)
+            if current_binding is None:
+                raise RuntimeError("已发布 narration binding 未通过终态检查")
+            current_mix_binding = current_audio_mix_binding(work_dir, audio_mode)
+            if explicit_mix is not None and current_mix_binding is None:
+                raise RuntimeError("已发布 audio mix binding 未通过终态检查")
+            assembly_qc = assembly_contract._build_assembly_qc(
+                tts_segments, video_duration, output_path=render_output,
+                source_has_audio=source_has_audio,
+                loudness_mode=loudness_mode, loudnorm_measurement=loudnorm_measurement,
+                visual_qc=visual_qc, audio_mode=audio_mode,
+                audio_operations=audio_operations, adopted_audio=adopted_audio,
+                narration_input_binding=current_binding,
+                audio_mix_binding=current_mix_binding,
+                source_audio_status=source_audio_status,
+                render_delivery=assembly_qc["delivery_qc"],
+            )
+            if assembly_qc["blocking"]:
+                assembly_qc["output"] = {
+                    "path": str(published_output), "exists": False, "bytes": 0,
+                }
+                assembly_contract._write_assembly_qc(work_dir, assembly_qc)
+                codes = ", ".join(assembly_qc["blocking_codes"])
+                raise RuntimeError(f"身份约束渲染终态 QC 失败: {codes}")
+        assembly_contract._write_assembly_qc(work_dir, assembly_qc)
+    except Exception:
+        if active:
+            render_output.unlink(missing_ok=True)
+            published_output.unlink(missing_ok=True)
+            if binding_written:
+                binding_path.unlink(missing_ok=True)
+            if mix_binding_written:
+                mix_binding_path.unlink(missing_ok=True)
+        raise
+    return render_output

package/lib/video-recap/skills/video-assemble/scripts/artifacts.py

@@ -1,73 +1,37 @@
-"""Artifact fingerprints and work-directory JSON helpers for video-assemble."""
+"""File identity and work-directory JSON helpers for video-assemble."""
 
-import hashlib
 import json
 import os
 from pathlib import Path
 
 from lib import CONFIG
 
-def _stable_json_dumps(value):
-    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"), default=str)
 
-
-def _value_fingerprint(value):
-    return hashlib.md5(_stable_json_dumps(value).encode("utf-8")).hexdigest()
-
-
-_FILE_FINGERPRINT_MEMO = {}
-
-
-def _file_identity(path):
-    """(device, inode, size, mtime_ns) — changes whenever the bytes could have changed."""
+def file_identity(path):
+    """``{size, mtime_ns}`` of one input file: enough to notice a rewrite, cheap to take."""
     st = os.stat(os.fspath(path))
-    return (st.st_dev, st.st_ino, st.st_size, st.st_mtime_ns)
+    return {"size": st.st_size, "mtime_ns": st.st_mtime_ns}
 
 
-def _file_fingerprint(path, chunk_size=1024 * 1024):
-    """Return a full-content fingerprint for cache-correct identity checks.
-
-    The digest covers CONTENT only — never the path or mtime — so a copied video or
-    artifact is still recognised as the same asset, while any byte change invalidates
-    the cache even if timestamps, size, head, or tail bytes are misleading.
-
-    Identity metadata is used ONLY to memoize within a single process. One understanding
-    run fingerprints the same source video 8-10 times and the whole extracted frame set
-    2-3 times; on a 40-minute video at fps=1 that is gigabytes of redundant reads before
-    any real work starts. A file rewritten in place gets a new (size, mtime_ns) and is
-    re-hashed, so the memo can never serve a stale digest.
-    """
-    key = _file_identity(path)
-    memoized = _FILE_FINGERPRINT_MEMO.get(key)
-    if memoized is not None:
-        return memoized
-    h = hashlib.sha256()
-    with open(os.fspath(path), "rb") as f:
-        for chunk in iter(lambda: f.read(chunk_size), b""):
-            h.update(chunk)
-    digest = h.hexdigest()
-    _FILE_FINGERPRINT_MEMO[key] = digest
-    return digest
-
-
-def _artifact_fingerprint(path):
+def _artifact_identity(path):
     path = Path(path)
-    return _file_fingerprint(path) if path.exists() else None
+    return file_identity(path) if path.exists() else None
 
 
 def _explicit_source_video():
     """Return the cut-mode source video only when the caller opted in explicitly."""
-    if not CONFIG.get("source_video_explicit", False):
+    if not CONFIG["source_video_explicit"]:
         return ""
     return CONFIG["source_video"]
 
 
 def _source_video_identity():
+    """``{path, size, mtime_ns}`` of the explicit cut-mode source video, else None."""
     source_video = _explicit_source_video()
     if not source_video:
-        return None, None
+        return None
     path = Path(source_video)
-    return str(path.resolve()), _artifact_fingerprint(path)
+    return {"path": str(path.resolve()), **file_identity(path)}
 
 
 def _timeline_provenance_status(work_dir):