@oh-story/dsh 0.1.11 → 0.1.13

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

@@ -21,27 +21,8 @@ class DraftBuildContext:
     total_us: int
     new_id: NewIdFn
     probe: ProbeFn
-    resource_packages: dict = field(default_factory=dict)
-    style_presets: dict = field(default_factory=dict)
     materials: dict[str, list] = field(
-        default_factory=lambda: {
-            key: []
-            for key in (
-                "audios",
-                "chromas",
-                "common_mask",
-                "drafts",
-                "effects",
-                "masks",
-                "speeds",
-                "stickers",
-                "text_templates",
-                "texts",
-                "transitions",
-                "video_effects",
-                "videos",
-            )
-        }
+        default_factory=lambda: {"audios": [], "texts": [], "videos": []}
     )
     tracks: list[dict] = field(default_factory=list)
     notes: list[str] = field(default_factory=list)
@@ -58,8 +39,6 @@ class DraftBuildContext:
             total_us=us(timeline["duration"]),
             new_id=new_id,
             probe=probe,
-            resource_packages=timeline.get("resource_packages", {}),
-            style_presets=timeline.get("style_presets", {}),
         )
 
     def add_segment(self, kind, base_name, start_us, duration_us, segment):

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

@@ -14,9 +14,6 @@ _TEMPLATE_FILES = {
     "text": "empty_yj_material_text.json",
     "text_style": "empty_jy_text_styles.json",
     "segment": "empty_jy_segment.json",
-    "draft": "empty_jy_draft.json",
-    "combination_segment": "empty_jy_combination_segment.json",
-    "combination_video": "empty_jy_combination_video_material.json",
     "meta": "empty_draft_meta_info.json",
     "meta_material": "empty_jy_meta_material_value.json",
 }

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

@@ -1,13 +1,21 @@
-"""Timeline validation and migration at the JianYing adapter boundary."""
+"""Timeline validation at the JianYing adapter boundary."""
 
 import copy
 import math
 
 
 CURRENT_SCHEMA_VERSION = 2
-RESOURCE_TRACK_KINDS = {
-    "face_effect", "sound", "sticker", "text_template", "video_effect",
-}
+# Hand-authoring fields the exporter once mapped to JianYing (speed, reverse,
+# transitions, masks, LUTs, green screen, rich text, resource tracks). No pipeline
+# stage emits them; they are rejected so an old hand-written timeline fails loudly
+# instead of silently exporting a draft without the effect it asked for.
+REMOVED_ITEM_FIELDS = (
+    "chroma", "compound", "flip", "green_background", "lut", "mask", "opacity",
+    "reverse", "reverse_path", "rotation_degrees", "speed", "style", "style_id",
+    "transition", "words",
+)
+REMOVED_ROOT_FIELDS = ("resource_packages", "style_presets")
+
 
 def _error(path, expectation):
     raise ValueError(f"invalid timeline {path}: {expectation}")
@@ -38,6 +46,12 @@ def _require_string(container, key, path):
     return value
 
 
+def _reject_removed(container, fields, path):
+    for field in fields:
+        if field in container:
+            _error(_field_path(path, field), "JianYing authoring extension is no longer supported")
+
+
 def _validate_span(item, path, start_key="timeline_start", end_key="timeline_end"):
     start = _require_number(item, start_key, path, minimum=0)
     end = _require_number(item, end_key, path, minimum=0)
@@ -45,101 +59,30 @@ def _validate_span(item, path, start_key="timeline_start", end_key="timeline_end
         _error(f"{path}.{end_key}", f"must be greater than {start_key}")
 
 
-def _validate_transform(item, path):
-    for field in ("scale", "position", "flip"):
+def _validate_item(item, path):
+    if not isinstance(item, dict):
+        _error(path, "must be an object")
+    _reject_removed(item, REMOVED_ITEM_FIELDS, path)
+    _validate_span(item, path)
+    for field in ("scale", "position"):
         if field in item and not isinstance(item[field], dict):
             _error(f"{path}.{field}", "must be an object")
 
 
-def _validate_resources(resources, path):
-    if not isinstance(resources, list) or any(not isinstance(item, dict) for item in resources):
-        _error(path, "must contain source_path objects")
-    for index, item in enumerate(resources):
-        _require_string(item, "source_path", f"{path}[{index}]")
-
-
 def _validate_video_clip(clip, path):
-    if not isinstance(clip, dict):
-        _error(path, "must be an object")
+    _validate_item(clip, path)
     _require_string(clip, "source_path", path)
-    _validate_span(clip, path)
     _validate_span(clip, path, "source_start", "source_end")
     if "audio" in clip and not isinstance(clip["audio"], dict):
         _error(f"{path}.audio", "must be an object")
-    if "speed" in clip:
-        speed = _require_number(clip, "speed", path)
-        if speed <= 0:
-            _error(f"{path}.speed", "must be greater than 0")
-        source_duration = float(clip["source_end"]) - float(clip["source_start"])
-        target_duration = float(clip["timeline_end"]) - float(clip["timeline_start"])
-        expected_source_duration = target_duration * float(speed)
-        if not math.isclose(source_duration, expected_source_duration, rel_tol=1e-6, abs_tol=1e-4):
-            _error(
-                path,
-                "source duration must equal target duration multiplied by speed "
-                f"({source_duration} != {target_duration} * {speed})",
-            )
-    if "reverse" in clip and not isinstance(clip["reverse"], bool):
-        _error(f"{path}.reverse", "must be a boolean")
-    # A reversed clip may omit reverse_path: export_timeline_to_jianying generates it.
-    if "reverse_path" in clip:
-        _require_string(clip, "reverse_path", path)
-    _validate_transform(clip, path)
-    for field in ("transition", "mask", "lut", "chroma"):
-        if field not in clip:
-            continue
-        spec = clip[field]
-        if isinstance(spec, dict):
-            if "resources" in spec:
-                _validate_resources(spec["resources"], f"{path}.{field}.resources")
-        elif not isinstance(spec, str):
-            _error(f"{path}.{field}", "must be an object or resource-package name")
-    if "compound" in clip and not isinstance(clip["compound"], bool):
-        _error(f"{path}.compound", "must be a boolean")
-    if clip.get("compound") or "green_background" in clip or "chroma" in clip:
-        # Any one of these makes the clip a green-screen compound, which needs both.
-        background = clip.get("green_background")
-        if not isinstance(background, dict):
-            _error(f"{path}.green_background", "must be a local media object")
-        _require_string(background, "source_path", f"{path}.green_background")
-        _validate_transform(background, f"{path}.green_background")
-        if "chroma" not in clip:
-            _error(f"{path}.chroma", "compound green-screen clips require a chroma object")
-
-
-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")
-    _validate_resources(config.get("resources", []), f"{path}.resources")
 
 
 def _validate_segment(segment, path, kind):
-    if not isinstance(segment, dict):
-        _error(path, "must be an object")
-    _validate_span(segment, path)
-    _validate_transform(segment, path)
-    if "speed" in segment:
-        speed = _require_number(segment, "speed", path)
-        if speed <= 0:
-            _error(f"{path}.speed", "must be greater than 0")
+    _validate_item(segment, path)
     if kind in {"audio", "image"}:
         _require_string(segment, "source_path", path)
-    elif kind == "text" and not isinstance(segment.get("text"), str):
+    elif not isinstance(segment.get("text"), str):
         _error(f"{path}.text", "must be a string")
-    elif kind in RESOURCE_TRACK_KINDS:
-        sources = [key for key in ("material", "resource_config", "resource_package") if key in segment]
-        if len(sources) != 1:
-            _error(path, "must define exactly one of material, resource_config, or resource_package")
-        source = segment[sources[0]]
-        if sources[0] == "resource_package":
-            if not isinstance(source, str) or not source:
-                _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":
-            _validate_resource_config(source, f"{path}.resource_config")
 
 
 def _validate_track(track, path):
@@ -157,7 +100,7 @@ def _validate_track(track, path):
             _validate_video_clip(clip, f"{path}.clips[{index}]")
         return
 
-    if kind in {"audio", "image", "text"} | RESOURCE_TRACK_KINDS:
+    if kind in {"audio", "image", "text"}:
         segments = track.get("segments")
         if not isinstance(segments, list):
             _error(f"{path}.segments", "must be an array")
@@ -173,7 +116,7 @@ def _validate_track(track, path):
     _error(f"{path}.kind", f"unsupported track kind {kind!r}")
 
 
-def _validate_v2(timeline):
+def _validate(timeline):
     canvas = timeline.get("canvas")
     if not isinstance(canvas, dict):
         _error("canvas", "must be an object")
@@ -186,13 +129,7 @@ def _validate_v2(timeline):
         _error("canvas.fps", "must be greater than 0")
 
     _require_number(timeline, "duration", "", minimum=0)
-    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")
+    _reject_removed(timeline, REMOVED_ROOT_FIELDS, "")
     tracks = timeline.get("tracks")
     if not isinstance(tracks, list):
         _error("tracks", "must be an array")
@@ -201,23 +138,19 @@ def _validate_v2(timeline):
 
 
 def normalize_timeline(timeline):
-    """Return a validated schema-v2 copy, migrating schema v1 when necessary."""
+    """Return a validated copy of a schema-v2 timeline (the version timeline.py emits)."""
     if not isinstance(timeline, dict):
         _error("root", "must be an object")
     schema_version = timeline.get("schema_version")
     if not isinstance(schema_version, int) or isinstance(schema_version, bool):
-        _error("schema_version", "must be integer 1 or 2")
-    if schema_version not in {1, CURRENT_SCHEMA_VERSION}:
+        _error("schema_version", f"must be integer {CURRENT_SCHEMA_VERSION}")
+    if schema_version != CURRENT_SCHEMA_VERSION:
         raise ValueError(
             f"unsupported timeline schema_version {schema_version}; "
-            f"supported versions are 1 and {CURRENT_SCHEMA_VERSION}"
+            f"only {CURRENT_SCHEMA_VERSION} is supported (a v1 timeline only needs "
+            f"schema_version set to {CURRENT_SCHEMA_VERSION})"
         )
 
     normalized = copy.deepcopy(timeline)
-    if schema_version == 1:
-        # Schema v2 is an additive extension of v1 (local image tracks). The
-        # migration therefore preserves all authored v1 fields and only advances
-        # the version before applying the current contract.
-        normalized["schema_version"] = CURRENT_SCHEMA_VERSION
-    _validate_v2(normalized)
+    _validate(normalized)
     return normalized

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

@@ -20,19 +20,11 @@ SEGMENT_RENDER_INDEX = 2
 
 
 TRACK_LAYOUT_BANDS = {
-    "sound": TrackBand("sound", "audio", 10_000, "sound effects"),
     "audio": TrackBand("audio", "audio", 20_000, "narration, music, and general audio"),
-    "green_screen": TrackBand("green_screen", "video", 30_000, "green-screen background"),
     "video": TrackBand("video", "video", 40_000, "base video"),
     "image": TrackBand("image", "video", 50_000, "image and photo overlays"),
-    "mask": TrackBand("mask", "video", 60_000, "masks"),
-    "effect": TrackBand("effect", "effect", 70_000, "video effects"),
-    "video_effect": TrackBand("video_effect", "effect", 70_000, "video effects"),
-    "face_effect": TrackBand("face_effect", "effect", 70_010, "face effects"),
-    "sticker": TrackBand("sticker", "sticker", 80_000, "stickers"),
     "subtitle": TrackBand("subtitle", "text", 90_000, "subtitles"),
     "text": TrackBand("text", "text", 100_000, "plain text"),
-    "text_template": TrackBand("text_template", "text", 110_000, "text templates"),
 }
 
 

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

@@ -7,7 +7,6 @@ import shutil
 import tempfile
 import time
 import uuid
-import zipfile
 
 from jianying.templates import template
 
@@ -37,19 +36,6 @@ def _resource_kind(material, materials_key):
     return "video", "video"
 
 
-RESOURCE_DIRECTORY_BY_MATERIALS_KEY = {
-    "chromas": "effect",
-    "common_mask": "mask",
-    "effects": "effect",
-    "masks": "mask",
-    "stickers": "sticker",
-    "texts": "text",
-    "text_templates": "text_template",
-    "transitions": "transition",
-    "video_effects": "effect",
-}
-
-
 def _unused_name(directory, basename, used):
     """Return a collision-free filename within one resource directory."""
     name = basename
@@ -96,82 +82,13 @@ def _meta_value(material, relative_path, metetype, copied_path, timestamp_ms):
     return value
 
 
-def _material_sets(content):
-    """Yield root and nested compound-draft material dictionaries."""
-    materials = content["materials"]
-    yield materials
-    for draft in materials["drafts"]:
-        yield from _material_sets(draft["draft"])
-
-
-def _replace_value(value, old, new):
-    if isinstance(value, dict):
-        for key, item in value.items():
-            value[key] = _replace_value(item, old, new)
-    elif isinstance(value, list):
-        for index, item in enumerate(value):
-            value[index] = _replace_value(item, old, new)
-    elif isinstance(value, str):
-        if value == old:
-            return new
-    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):
-        raise ValueError(f"invalid JianYing resource target_path: {target_path}")
-    if normalized == ".." or normalized.startswith("../"):
-        raise ValueError(f"JianYing resource target_path escapes package: {target_path}")
-    return normalized
-
-
-def _extract_zip(source, destination):
-    os.makedirs(destination, exist_ok=False)
-    destination_real = os.path.realpath(destination)
-    with zipfile.ZipFile(source) as archive:
-        for member in archive.infolist():
-            member_path = os.path.realpath(os.path.join(destination, member.filename))
-            if os.path.commonpath((destination_real, member_path)) != destination_real:
-                raise ValueError(f"unsafe path in JianYing resource archive: {member.filename}")
-        archive.extractall(destination)
-
-
-def _copy_resource(source, resource_kind, resources_root, used, target_path=None):
+def _copy_resource(source, resource_kind, resources_root, used):
     resource_dir = os.path.join(resources_root, resource_kind)
     os.makedirs(resource_dir, exist_ok=True)
-    is_zip = os.path.isfile(source) and zipfile.is_zipfile(source)
-    if target_path is None:
-        basename = os.path.basename(source.rstrip(os.sep))
-        if is_zip:
-            basename = os.path.splitext(basename)[0]
-        relative_target = _unused_name(resource_dir, basename, used[resource_kind])
-    else:
-        relative_target = _safe_resource_target(target_path)
+    relative_target = _unused_name(resource_dir, os.path.basename(source), used[resource_kind])
     copied_path = os.path.join(resource_dir, relative_target)
-    copied_real = os.path.realpath(copied_path)
-    if os.path.commonpath((os.path.realpath(resource_dir), copied_real)) != os.path.realpath(resource_dir):
-        raise ValueError(f"JianYing resource target escapes package: {target_path}")
-    os.makedirs(os.path.dirname(copied_path), exist_ok=True)
-    if os.path.exists(copied_path):
-        raise FileExistsError(f"duplicate JianYing resource target: {relative_target}")
-    if is_zip:
-        _extract_zip(source, copied_path)
-    elif os.path.isdir(source):
-        shutil.copytree(source, copied_path)
-    else:
-        shutil.copy2(source, copied_path)
-    relative_path = f"Resources/local/{resource_kind}/{relative_target.replace(os.sep, '/')}"
+    shutil.copy2(source, copied_path)
+    relative_path = f"Resources/local/{resource_kind}/{relative_target}"
     return copied_path, relative_path, f"{DRAFT_PATH_PLACEHOLDER}/{relative_path}"
 
 
@@ -179,41 +96,6 @@ def _is_packaged_path(value):
     return str(value).startswith((DRAFT_PATH_PLACEHOLDER, "Resources/", "./Resources/"))
 
 
-def _descriptor(raw, default_kind, *, required):
-    """`raw` is a contract-validated resource entry: an object with a non-empty source_path."""
-    source = raw["source_path"]
-    resource_kind = raw.get("resource_kind", default_kind)
-    target_path = raw.get("target_path")
-    if not isinstance(resource_kind, str) or resource_kind not in {
-        "audio", "effect", "fonts", "image", "lut", "mask", "sticker",
-        "text", "text_template", "transition", "video",
-    }:
-        raise ValueError(f"invalid JianYing resource kind: {resource_kind}")
-    return {
-        "source_path": source,
-        "resource_kind": resource_kind,
-        "target_path": target_path,
-        "required": required,
-    }
-
-
-def _material_resource_descriptors(material, default_kind):
-    descriptors = [
-        _descriptor(raw, default_kind, required=True)
-        for raw in material.get("_bundle_resources", [])
-    ]
-    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({
-                "source_path": path,
-                "resource_kind": default_kind,
-                "target_path": None,
-                "required": False,
-            })
-    return descriptors
-
-
 def bundle_media(content, meta, draft_dir):
     """Copy media into duo-video's Resources/local contract and index it.
 
@@ -224,83 +106,34 @@ def bundle_media(content, meta, draft_dir):
     """
     resources_root = os.path.join(draft_dir, "Resources", "local")
     copied = {}
-    resource_kinds = {
-        "audio", "effect", "fonts", "image", "lut", "mask", "sticker",
-        "text", "text_template", "transition", "video",
-    }
-    used = {kind: set() for kind in resource_kinds}
+    used = {kind: set() for kind in ("audio", "image", "video")}
     meta_values = []
     notes = []
     timestamp_ms = int(time.time() * 1000)
 
-    material_sets = list(_material_sets(content))
-    for materials in material_sets:
-        for materials_key in ("videos", "audios"):
-            for material in materials.get(materials_key, []):
-                src = material.get("path")
-                if not src:
-                    continue
-                resource_kind, metetype = _resource_kind(material, materials_key)
-                source_key = (resource_kind, os.path.realpath(src))
-                existing = copied.get(source_key)
-                if existing is not None:
-                    material["path"] = existing["draft_path"]
-                    continue
-                if not os.path.isfile(src):
-                    if not _is_packaged_path(src):
-                        notes.append(f"素材缺失，未打包: {src}")
-                    continue
-
-                copied_path, relative_path, draft_path = _copy_resource(
-                    src, resource_kind, resources_root, used
-                )
-                material["path"] = draft_path
-                copied[source_key] = {"draft_path": draft_path}
-                meta_values.append(
-                    _meta_value(material, relative_path, metetype, copied_path, timestamp_ms)
-                )
-
-        for materials_key, resource_kind in RESOURCE_DIRECTORY_BY_MATERIALS_KEY.items():
-            for material in materials.get(materials_key, []):
-                descriptors = _material_resource_descriptors(
-                    material, resource_kind
-                )
-                seen_descriptors = set()
-                for descriptor in descriptors:
-                    src = descriptor["source_path"]
-                    if _is_packaged_path(src):
-                        continue
-                    descriptor_key = (
-                        descriptor["resource_kind"],
-                        os.path.realpath(src),
-                        descriptor["target_path"],
-                    )
-                    if descriptor_key in seen_descriptors:
-                        continue
-                    seen_descriptors.add(descriptor_key)
-                    if not os.path.exists(src):
-                        message = f"声明的剪映资源缺失: {src}"
-                        if descriptor["required"]:
-                            raise ValueError(message)
-                        notes.append(message)
-                        continue
-                    kind = descriptor["resource_kind"]
-                    source_key = (kind, os.path.realpath(src), descriptor["target_path"])
-                    existing = copied.get(source_key)
-                    if existing is None:
-                        _copied_path, _relative_path, draft_path = _copy_resource(
-                            src,
-                            kind,
-                            resources_root,
-                            used,
-                            target_path=descriptor["target_path"],
-                        )
-                        copied[source_key] = {"draft_path": draft_path}
-                    else:
-                        draft_path = existing["draft_path"]
-                    _replace_material_resource_path(
-                        material, materials_key, src, draft_path
-                    )
+    materials = content["materials"]
+    for materials_key in ("videos", "audios"):
+        for material in materials[materials_key]:
+            src = material["path"]
+            resource_kind, metetype = _resource_kind(material, materials_key)
+            source_key = (resource_kind, os.path.realpath(src))
+            existing = copied.get(source_key)
+            if existing is not None:
+                material["path"] = existing
+                continue
+            if not os.path.isfile(src):
+                if not _is_packaged_path(src):
+                    notes.append(f"素材缺失，未打包: {src}")
+                continue
+
+            copied_path, relative_path, draft_path = _copy_resource(
+                src, resource_kind, resources_root, used
+            )
+            material["path"] = draft_path
+            copied[source_key] = draft_path
+            meta_values.append(
+                _meta_value(material, relative_path, metetype, copied_path, timestamp_ms)
+            )
 
     material_group = next(group for group in meta["draft_materials"] if group["type"] == 0)
     material_group["value"] = meta_values
@@ -311,13 +144,6 @@ def bundle_media(content, meta, draft_dir):
     return notes
 
 
-def strip_internal_resource_fields(content):
-    for materials in _material_sets(content):
-        for entries in materials.values():
-            for material in entries:
-                material.pop("_bundle_resources", None)
-
-
 def draft_dir_has_user_content(draft_dir):
     """Return True when writing here could overwrite an existing draft/material."""
     if not os.path.exists(draft_dir):
@@ -359,7 +185,6 @@ def write_draft(content, meta, notes, out_dir, draft_name, bundle_media_enabled=
         os.makedirs(tmp_dir, exist_ok=False)
         if bundle_media_enabled:
             notes.extend(bundle_media(content, meta, tmp_dir))
-        strip_internal_resource_fields(content)
         timestamp_ms = int(time.time() * 1000)
         meta["draft_name"] = actual_name
         meta["draft_fold_path"] = draft_dir