@oh-story/dsh 0.1.8 → 0.1.9

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

@@ -5,20 +5,19 @@ from pathlib import Path
 from lib import CONFIG, log
 
 def _maybe_export_jianying(work_dir, out_dir, stem):
-    """Lazy-import the optional 剪映 exporter and write a draft from timeline.json."""
-    timeline_path = Path(work_dir) / "timeline.json"
-    if not timeline_path.exists():
-        log("  ⚠️ 跳过剪映导出：未找到 timeline.json")
-        return
+    """Lazy-import the optional 剪映 exporter and write a draft from timeline.json.
+
+    The export is a documented fail-open sidecar: any failure is logged and never
+    fails the already-rendered recap."""
     try:
         from export_jianying import export_timeline_to_jianying
         from timeline import load_timeline
-        parent = out_dir or CONFIG.get("jianying_draft_dir") or str(work_dir)
+        parent = out_dir or CONFIG["jianying_draft_dir"] or str(work_dir)
         draft_dir, notes = export_timeline_to_jianying(
-            load_timeline(timeline_path), parent, draft_name=f"recap_{stem}",
-            bundle_media=CONFIG.get("jianying_bundle_media", False))
+            load_timeline(Path(work_dir) / "timeline.json"), parent, draft_name=f"recap_{stem}",
+            bundle_media=CONFIG["jianying_bundle_media"])
         for n in notes:
             log(f"  注意: {n}")
         log(f"剪映草稿已导出: {draft_dir}")
-    except Exception as exc:  # optional feature must never fail the render
+    except Exception as exc:
         log(f"  ⚠️ 剪映导出失败（不影响成片）: {exc}")

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

@@ -8,15 +8,7 @@ from jianying_templates import template
 
 # The full 剪映 materials object: ~45 parallel arrays. Only arrays backed by a
 # production builder are populated; retaining the full shape preserves compatibility.
-MATERIAL_KEYS = (
-    "ai_translates audio_balances audio_effects audio_fades audio_track_indexes audios "
-    "beats canvases chromas color_curves digital_humans drafts effects flowers green_screens "
-    "handwrites hsl images log_color_wheels loudnesses manual_deformations masks common_mask "
-    "material_animations material_colors multi_language_refs placeholders plugin_effects "
-    "primary_color_wheels realtime_denoises shapes smart_crops smart_relights "
-    "sound_channel_mappings speeds stickers tail_leaders text_templates texts time_marks "
-    "transitions video_effects video_trackings videos vocal_beautifys vocal_separations"
-).split()
+MATERIAL_KEYS = ["ai_translates", "audio_balances", "audio_effects", "audio_fades", "audio_track_indexes", "audios", "beats", "canvases", "chromas", "color_curves", "digital_humans", "drafts", "effects", "flowers", "green_screens", "handwrites", "hsl", "images", "log_color_wheels", "loudnesses", "manual_deformations", "masks", "common_mask", "material_animations", "material_colors", "multi_language_refs", "placeholders", "plugin_effects", "primary_color_wheels", "realtime_denoises", "shapes", "smart_crops", "smart_relights", "sound_channel_mappings", "speeds", "stickers", "tail_leaders", "text_templates", "texts", "time_marks", "transitions", "video_effects", "video_trackings", "videos", "vocal_beautifys", "vocal_separations"]
 
 
 def us(seconds):
@@ -34,11 +26,8 @@ def full_materials(filled):
 def scrub_platform_identity(project):
     """Remove hardware fingerprints carried by the pinned upstream templates."""
     for platform_key in ("last_modified_platform", "platform"):
-        platform = project.get(platform_key)
-        if not isinstance(platform, dict):
-            continue
         for identity_key in ("device_id", "hard_disk_id", "mac_address"):
-            platform[identity_key] = ""
+            project[platform_key][identity_key] = ""
     return project
 
 
@@ -96,7 +85,7 @@ def material_category_registry():
 
 def validate_material_category(category):
     """Return deterministic support metadata for a public or future material kind."""
-    normalized = (category or "").strip().lower()
+    normalized = category.strip().lower()
     registry = material_category_registry()
     info = dict(registry.get(normalized, {"status": "unsupported", "materials_key": None, "track_type": None}))
     info["category"] = normalized

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

@@ -9,18 +9,12 @@ RESOURCE_TRACK_KINDS = {
     "face_effect", "sound", "sticker", "text_template", "video_effect",
 }
 
-
 def _error(path, expectation):
     raise ValueError(f"invalid timeline {path}: {expectation}")
 
 
 def _is_number(value):
-    if not isinstance(value, (int, float)) or isinstance(value, bool):
-        return False
-    try:
-        return math.isfinite(value)
-    except OverflowError:
-        return False
+    return isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value)
 
 
 def _field_path(path, key):
@@ -88,6 +82,19 @@ def _validate_video_clip(clip, path):
         _error(f"{path}.compound", "must be a boolean")
 
 
+def _validate_resource_config(config, path):
+    if not isinstance(config, dict):
+        _error(path, "must be an object")
+    if not isinstance(config.get("main_config"), dict):
+        _error(f"{path}.main_config", "must be an object")
+    resources = config.get("resources", [])
+    if not isinstance(resources, list) or any(
+        not isinstance(item, dict) or not isinstance(item.get("source_path"), str)
+        for item in resources
+    ):
+        _error(f"{path}.resources", "must contain source_path objects")
+
+
 def _validate_segment(segment, path, kind):
     if not isinstance(segment, dict):
         _error(path, "must be an object")
@@ -110,8 +117,8 @@ def _validate_segment(segment, path, kind):
                 _error(f"{path}.resource_package", "must be a non-empty string")
         elif sources[0] == "material" and not isinstance(source, dict):
             _error(f"{path}.material", "must be an object")
-        elif sources[0] == "resource_config" and not isinstance(source, (dict, str)):
-            _error(f"{path}.resource_config", "must be an object or JSON file path")
+        elif sources[0] == "resource_config":
+            _validate_resource_config(source, f"{path}.resource_config")
 
 
 def _validate_track(track, path):
@@ -158,9 +165,13 @@ def _validate_v2(timeline):
         _error("canvas.fps", "must be greater than 0")
 
     _require_number(timeline, "duration", "", minimum=0)
-    for registry_name in ("resource_packages", "style_presets"):
-        if registry_name in timeline and not isinstance(timeline[registry_name], dict):
-            _error(registry_name, "must be an object")
+    resource_packages = timeline.get("resource_packages", {})
+    if not isinstance(resource_packages, dict):
+        _error("resource_packages", "must be an object")
+    for name, config in resource_packages.items():
+        _validate_resource_config(config, f"resource_packages.{name}")
+    if "style_presets" in timeline and not isinstance(timeline["style_presets"], dict):
+        _error("style_presets", "must be an object")
     tracks = timeline.get("tracks")
     if not isinstance(tracks, list):
         _error("tracks", "must be an array")

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

@@ -60,10 +60,7 @@ class TrackAllocator:
         return any(int(start_us) < old_end and end_us > old_start for old_start, old_end in existing)
 
     def allocate(self, kind, base_name, start_us, duration_us):
-        band = TRACK_LAYOUT_BANDS.get(kind)
-        if band is None:
-            band = TrackBand(kind, "video", 120_000, "unregistered fallback")
-        base_name = base_name or kind
+        band = TRACK_LAYOUT_BANDS[kind]
         suffix = 0
         while True:
             name = base_name if suffix == 0 else f"{base_name}-{suffix}"

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

@@ -118,17 +118,19 @@ def _replace_value(value, old, new):
     elif isinstance(value, str):
         if value == old:
             return new
-        stripped = value.lstrip()
-        if stripped.startswith(("{", "[")):
-            try:
-                parsed = json.loads(value)
-            except json.JSONDecodeError:
-                return value
-            replaced = _replace_value(parsed, old, new)
-            return json.dumps(replaced, ensure_ascii=False, separators=(",", ":"))
     return value
 
 
+def _replace_material_resource_path(material, materials_key, old, new):
+    """Rewrite one declared resource, including the known rich-text JSON field."""
+    _replace_value(material, old, new)
+    if materials_key != "texts" or not isinstance(material.get("content"), str):
+        return
+    content = json.loads(material["content"])
+    _replace_value(content, old, new)
+    material["content"] = json.dumps(content, ensure_ascii=False, separators=(",", ":"))
+
+
 def _safe_resource_target(target_path):
     normalized = os.path.normpath(str(target_path).replace("\\", "/"))
     if normalized in {"", "."} or os.path.isabs(normalized):
@@ -182,16 +184,11 @@ def _is_packaged_path(value):
 
 
 def _descriptor(raw, default_kind, *, required):
-    if isinstance(raw, str):
-        source = raw
-        resource_kind = default_kind
-        target_path = None
-    elif isinstance(raw, dict):
-        source = raw.get("source_path") or raw.get("source")
-        resource_kind = raw.get("resource_kind") or raw.get("kind") or default_kind
-        target_path = raw.get("target_path")
-    else:
-        raise ValueError("JianYing resources entries must be paths or objects")
+    if not isinstance(raw, dict):
+        raise ValueError("JianYing resources entries must be objects")
+    source = raw.get("source_path")
+    resource_kind = raw.get("resource_kind", default_kind)
+    target_path = raw.get("target_path")
     if not isinstance(source, str) or not source:
         raise ValueError("JianYing resource source_path must be a non-empty string")
     if not isinstance(resource_kind, str) or resource_kind not in {
@@ -199,11 +196,6 @@ def _descriptor(raw, default_kind, *, required):
         "text", "text_template", "transition", "video",
     }:
         raise ValueError(f"invalid JianYing resource kind: {resource_kind}")
-    suffix = os.path.splitext(source)[1].lower()
-    if suffix == ".cube":
-        resource_kind = "lut"
-    elif suffix in {".ttf", ".otf"}:
-        resource_kind = "fonts"
     return {
         "source_path": source,
         "resource_kind": resource_kind,
@@ -220,7 +212,12 @@ def _material_resource_descriptors(material, default_kind):
     path = material.get("path")
     if isinstance(path, str) and path and not _is_packaged_path(path):
         if not any(item["source_path"] == path for item in descriptors):
-            descriptors.append(_descriptor(path, default_kind, required=False))
+            descriptors.append({
+                "source_path": path,
+                "resource_kind": default_kind,
+                "target_path": None,
+                "required": False,
+            })
     return descriptors
 
 
@@ -308,7 +305,9 @@ def bundle_media(content, meta, draft_dir):
                         copied[source_key] = {"draft_path": draft_path}
                     else:
                         draft_path = existing["draft_path"]
-                    _replace_value(material, src, draft_path)
+                    _replace_material_resource_path(
+                        material, materials_key, src, draft_path
+                    )
 
     material_group = next(group for group in meta["draft_materials"] if group["type"] == 0)
     material_group["value"] = meta_values

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

@@ -1,4 +1,5 @@
 """Self-contained config + utilities for this skill (no cross-skill imports)."""
+import math
 import os
 import subprocess
 from pathlib import Path
@@ -7,85 +8,40 @@ from pathlib import Path
 # ── 配置 ──────────────────────────────────────────────────────────────
 _EXISTING_CONFIG_REF = globals().get("CONFIG")
 
-DEFAULT_MIMO_API_URL = "https://api.xiaomimimo.com/v1"
-DEFAULT_MIMO_TOKEN_PLAN_CLUSTER = "cn"
-MIMO_TOKEN_PLAN_API_URLS = {
-    "cn": "https://token-plan-cn.xiaomimimo.com/v1",
-    "sgp": "https://token-plan-sgp.xiaomimimo.com/v1",
-    "ams": "https://token-plan-ams.xiaomimimo.com/v1",
-}
-DEFAULT_MIMO_MODEL = "mimo-v2.5"          # VLM / chat (vision understanding)
-DEFAULT_MIMO_ASR_MODEL = "mimo-v2.5-asr"  # speech-to-text
-DEFAULT_MIMO_TTS_MODEL = "mimo-v2.5-tts"  # text-to-speech
-
-
-def normalize_api_url(raw_url):
-    """Normalize a MiMo (OpenAI-compatible) base URL or chat/completions endpoint."""
-    url = (raw_url or DEFAULT_MIMO_API_URL).rstrip("/")
-    if url.endswith("/chat/completions"):
-        return url
-    return f"{url}/chat/completions"
-
-
-def is_mimo_token_plan_key(api_key):
-    """Return True for Xiaomi MiMo Token Plan keys, which use token-plan base URLs."""
-    return str(api_key or "").strip().startswith("tp-")
-
-
-def default_mimo_api_url(api_key="", cluster=None):
-    """Pick the correct MiMo base URL for pay-as-you-go vs Token Plan keys.
-
-    MiMo uses independent credentials for pay-as-you-go (`sk-*`) and Token Plan
-    (`tp-*`). Token Plan keys must be sent to the Token Plan cluster base URL,
-    not the pay-as-you-go `api.xiaomimimo.com` endpoint.
-    """
-    if is_mimo_token_plan_key(api_key):
-        cluster_name = (cluster or os.environ.get("MIMO_TOKEN_PLAN_CLUSTER") or DEFAULT_MIMO_TOKEN_PLAN_CLUSTER)
-        cluster_name = str(cluster_name).strip().lower()
-        return MIMO_TOKEN_PLAN_API_URLS.get(cluster_name, MIMO_TOKEN_PLAN_API_URLS[DEFAULT_MIMO_TOKEN_PLAN_CLUSTER])
-    return DEFAULT_MIMO_API_URL
-
 
 def env_int(name, default, *, minimum=None):
-    """Read an integer env var; ignore malformed values instead of crashing import."""
-    raw = os.environ.get(name)
-    if raw is None or raw == "":
+    """Read an integer env var; an unset/empty value yields `default`, a malformed one is an error."""
+    raw = os.environ.get(name, "")
+    if raw == "":
         return default
     try:
         value = int(raw)
-    except (TypeError, ValueError):
-        return default
-    if minimum is not None:
-        value = max(minimum, value)
-    return value
+    except ValueError as exc:
+        raise ValueError(f"环境变量 {name}={raw!r} 不是整数") from exc
+    return value if minimum is None else max(minimum, value)
 
 
 def env_bool(name, default=False):
     """Read common boolean env var forms."""
-    raw = os.environ.get(name)
-    if raw is None or raw == "":
+    raw = os.environ.get(name, "")
+    if raw == "":
         return default
     return raw.strip().lower() in {"1", "true", "yes", "y", "on"}
 
 
 def env_float(name, default, *, minimum=None):
-    """Read a float env var; ignore malformed values instead of crashing import."""
-    raw = os.environ.get(name)
-    if raw is None or raw == "":
+    """Read a float env var; an unset/empty value yields `default`, a malformed one is an error."""
+    raw = os.environ.get(name, "")
+    if raw == "":
         return default
     try:
         value = float(raw)
-    except (TypeError, ValueError):
-        return default
-    if minimum is not None:
-        value = max(minimum, value)
-    return value
-
+    except ValueError as exc:
+        raise ValueError(f"环境变量 {name}={raw!r} 不是数字") from exc
+    if not math.isfinite(value):
+        raise ValueError(f"环境变量 {name}={raw!r} 必须是有限数")
+    return value if minimum is None else max(minimum, value)
 
-# Single MiMo credential powers ASR + VLM + TTS. Per-capability overrides
-# (MIMO_VIDEO_API_KEY / MIMO_TTS_API_KEY / MIMO_ASR_API_KEY and their *_API_URL forms)
-# are optional and fall back to MIMO_API_KEY / MIMO_API_URL. Token-Plan keys (tp-*) auto-
-# route to the Token-Plan cluster base URL; pay-as-you-go keys use api.xiaomimimo.com.
 
 # Cross-language source: when the original audio is in a language the narration is NOT in
 # (e.g. a Japanese drama recapped in Chinese), the original speech bleeding under the narration
@@ -181,9 +137,8 @@ if isinstance(_EXISTING_CONFIG_REF, dict):
     CONFIG = _EXISTING_CONFIG_REF
 
 SCRIPT_DIR = Path(__file__).parent
-PROMPTS_DIR = SCRIPT_DIR.parent / "references"
 
-def narration_tempo_budget(tts_rate_offset=0.0, *, config=None):
+def narration_tempo_budget(tts_rate_offset=0.0):
     """Return the canonical tempo budget shared by voiceover and assemble.
 
     `effective_tempo` is the user-perceived cumulative compression:
@@ -192,13 +147,13 @@ def narration_tempo_budget(tts_rate_offset=0.0, *, config=None):
     offset; callers must fail/shorten instead of time-trimming speech when the
     needed ratio exceeds `segment_tempo_max`.
     """
-    cfg = config or CONFIG
-    global_speed = max(0.01, float(cfg.get("narration_speed", 1.0) or 1.0))
-    rate_factor = max(0.01, 1.0 + float(tts_rate_offset or 0.0))
-    cumulative_max = max(1.0, float(cfg.get("narration_cumulative_tempo_max", 1.35) or 1.35))
-    hard_max = max(cumulative_max, float(cfg.get("narration_cumulative_tempo_hard_max", 1.40) or 1.40))
-    legacy_segment_cap = max(1.0, float(cfg.get("tts_segment_tempo_max", 1.20) or 1.20))
-    segment_tempo_max = max(1.0, min(legacy_segment_cap, cumulative_max / (global_speed * rate_factor)))
+    global_speed = CONFIG["narration_speed"]
+    rate_factor = max(0.01, 1.0 + float(tts_rate_offset))
+    cumulative_max = CONFIG["narration_cumulative_tempo_max"]
+    hard_max = max(cumulative_max, CONFIG["narration_cumulative_tempo_hard_max"])
+    segment_tempo_max = max(1.0, min(
+        CONFIG["tts_segment_tempo_max"], cumulative_max / (global_speed * rate_factor)
+    ))
     return {
         "global_narration_speed": global_speed,
         "tts_rate_factor": rate_factor,
@@ -213,16 +168,10 @@ def log(msg):
 
 def run_cmd(cmd, **kwargs):
     """运行命令，返回 CompletedProcess"""
-    if isinstance(cmd, list):
-        display_parts = []
-        for part in cmd:
-            text = str(part)
-            display_parts.append(text if len(text) <= 240 else text[:237] + "...")
-        display = " ".join(display_parts)
-    else:
-        display = str(cmd)
-        if len(display) > 2000:
-            display = display[:1997] + "..."
+    display = " ".join(
+        text if len(text) <= 240 else text[:237] + "..."
+        for text in map(str, cmd)
+    )
     log(f"运行: {display}")
     return subprocess.run(cmd, capture_output=True, text=True, **kwargs)
 
@@ -232,8 +181,5 @@ def get_video_duration(video_path):
            "-of", "csv=p=0", str(video_path)]
     result = run_cmd(cmd)
     if result.returncode != 0:
-        return 0.0
-    try:
-        return float(result.stdout.strip())
-    except (TypeError, ValueError):
-        return 0.0
+        raise RuntimeError(f"ffprobe 无法读取时长 {video_path}: {result.stderr}")
+    return float(result.stdout.strip())