Update clipchamp_export.py

clipchamp_export.py

@@ -1,19 +1,103 @@
-# clipchamp_export.py (improved)
 import os
 import json
 import zlib
-import time
+import uuid
+import hashlib
 import datetime
 import mimetypes
 from typing import Dict, Optional
 
 CLIPCHAMP_OUTPUT_FOLDER = os.environ.get("CLIPCHAMP_OUTPUT_FOLDER", "clipchamp_projects")
 
+# -------------------------
+# Configuration / Namespace
+# -------------------------
+# Use a fixed namespace UUID so uuid5 outputs are deterministic across runs/machines.
+_DETERMINISTIC_NAMESPACE = uuid.UUID("11111111-2222-3333-4444-555555555555")
 
+# -------------------------
+# Helpers
+# -------------------------
 def _now_iso():
-    return datetime.datetime.utcnow().replace(microsecond=0).isoformat() + "Z"
+    # milliseconds precision
+    return datetime.datetime.utcnow().isoformat(timespec="milliseconds") + "Z"
 
 
+def _file_meta(path):
+    size = None
+    mime = None
+    if path:
+        # Accept URIs like file:///... or plain paths
+        if path.startswith("file://"):
+            p = path[7:]
+        else:
+            p = path
+        try:
+            if os.path.exists(p):
+                size = os.path.getsize(p)
+        except Exception:
+            size = None
+        try:
+            mime = mimetypes.guess_type(p)[0]
+        except Exception:
+            mime = None
+    return {"size": size, "mimeType": mime}
+
+
+def _sha1_of_file(path):
+    if not path:
+        return None
+    if path.startswith("file://"):
+        p = path[7:]
+    else:
+        p = path
+    try:
+        if not os.path.exists(p):
+            return None
+        h = hashlib.sha1()
+        with open(p, "rb") as f:
+            for chunk in iter(lambda: f.read(8192), b""):
+                h.update(chunk)
+        return h.hexdigest()
+    except Exception:
+        return None
+
+
+def _guess_type(mime, filename):
+    if mime and mime.startswith("video"):
+        return "video"
+    ext = os.path.splitext(filename)[1].lower()
+    if ext in (".mp4", ".mov", ".m4v", ".avi", ".webm"):
+        return "video"
+    if ext in (".mp3", ".wav", ".aac"):
+        return "audio"
+    if ext in (".png", ".jpg", ".jpeg", ".gif", ".webp"):
+        return "image"
+    return "file"
+
+
+# deterministic id functions (uuid5)
+def deterministic_project_id(project_name: str) -> str:
+    return str(uuid.uuid5(_DETERMINISTIC_NAMESPACE, f"project:{project_name}"))
+
+
+def deterministic_asset_id(key_or_path: str) -> str:
+    # key_or_path should be unique per asset (e.g. "video_1" or absolute path)
+    return str(uuid.uuid5(_DETERMINISTIC_NAMESPACE, f"asset:{key_or_path}"))
+
+
+def deterministic_item_id(project_id: str, index: int, source_key: str, start_ms: Optional[int]) -> str:
+    base = f"item:{project_id}:{index}:{source_key}:{start_ms}"
+    return str(uuid.uuid5(_DETERMINISTIC_NAMESPACE, base))
+
+
+def deterministic_track_id(project_id: str, track_label: str = "video_track_1") -> str:
+    return str(uuid.uuid5(_DETERMINISTIC_NAMESPACE, f"track:{project_id}:{track_label}"))
+
+
+# -------------------------
+# Main builder
+# -------------------------
 def build_clipchamp_bytes(
     project_name: str,
     ai_json: Dict,
@@ -21,144 +105,177 @@ def build_clipchamp_bytes(
     source_to_duration: Dict = None,
     aspect_ratio: Optional[str] = "16:9",
     render_settings: Optional[Dict] = None,
-    schema_version: str = "1.0.0",
+    schema_version: str = "8.6.4",
 ) -> bytes:
     """
-    Serialize AI editing plan into a zlib-compressed .clipchamp project file.
-    Produces a richer structure (assets.allIds, items.allIds, tracks, createdAt/updatedAt, renderSettings).
+    Build a zlib-compressed JSON blob that closely matches Clipchamp's export shape.
+    Deterministic IDs are produced via uuid5 so repeated runs with identical inputs
+    will produce stable IDs.
     """
+
     if source_to_duration is None:
         source_to_duration = {}
 
     created_at = _now_iso()
-    updated_at = created_at
+    project_id = deterministic_project_id(project_name)
 
-    # Base project skeleton (richer metadata than the minimal version)
+    # Base project skeleton using keys observed in Clipchamp exports
     project = {
-        "version": "1.0",
+        "version": 7,
         "schemaVersion": schema_version,
+        "id": project_id,
         "name": project_name,
         "createdAt": created_at,
-        "updatedAt": updated_at,
+        "updatedAt": created_at,
         "aspectRatio": aspect_ratio,
         "renderSettings": render_settings or {
             "format": "mp4",
             "resolution": {"width": 1920, "height": 1080},
             "frameRate": 30
         },
-        "metadata": {"description": ai_json.get("description"), "projectName": project_name},
-        # assets/items/tracks use both byId and allIds for predictable ordering
+        # keep containers expected by Clipchamp
+        "entities": {},
+        "flavor": {},
+        "groups": {},
         "assets": {"byId": {}, "allIds": []},
         "items": {"byId": {}, "allIds": []},
         "tracks": {"byId": {}, "allIds": []},
-        # timeline will include tracks and duration
-        "timeline": {"duration": 0, "tracks": {}}
     }
 
-    # Helper to resolve file metadata when available
-    def _file_meta(path):
-        try:
-            if os.path.exists(path):
-                size = os.path.getsize(path)
-            else:
-                size = None
-        except Exception:
-            size = None
-        mime = mimetypes.guess_type(path)[0] or None
-        return {"size": size, "mimeType": mime}
-
-    # Build assets
+    # Build assets deterministically
+    asset_id_map = {}
     for key, fname in source_to_filename.items():
-        aid = f"asset_{key}"
+        # Use provided key (if available) to derive deterministic ID; fallback to filename
+        id_seed = key if key else (os.path.basename(fname) if fname else str(uuid.uuid4()))
+        aid = deterministic_asset_id(id_seed)
+        asset_id_map[key] = aid
+
         meta = _file_meta(fname)
+        sha1 = _sha1_of_file(fname)
+        filename = os.path.basename(fname) if fname else (key or "unknown")
+
         asset_obj = {
             "id": aid,
-            "fileName": os.path.basename(fname),
-            "originalFileName": os.path.basename(fname),
-            "assetKey": key,
+            "name": filename,
+            "type": _guess_type(meta["mimeType"], filename),
+            "loop": False,
+            "hidden": False,
+            # include sha1 if available
+            "fileHashes": {"sha1": sha1} if sha1 else {},
             "metadata": {
                 "duration": source_to_duration.get(key),
                 "size": meta["size"],
                 "mimeType": meta["mimeType"],
             },
-            # uri kept as given so Clipchamp can find it; you can change to absolute path if you prefer
-            "uri": fname,
-            # importedSize kept for compatibility with some exports
-            "importedSize": meta["size"],
+            # richer extData: preserve originalFileName, uri, importedAt and importedSize
+            "extData": {
+                "originalFileName": filename,
+                "uri": fname,
+                "importedAt": created_at,
+                "importedSize": meta["size"],
+                # keep a deterministic file id too (useful for Clipchamp internals)
+                "fileId": deterministic_asset_id(f"file:{filename}:{meta.get('size')}"),
+            },
         }
+
         project["assets"]["byId"][aid] = asset_obj
         project["assets"]["allIds"].append(aid)
 
-    # single video track for now (expandable)
-    track_id = "track_1"
+    # Single default video track (deterministic id)
+    track_id = deterministic_track_id(project_id, "video_track_1")
     project["tracks"]["byId"][track_id] = {
         "id": track_id,
         "type": "video",
         "index": 0,
-        "items": [],       # ordered list of item IDs on this track
+        "items": [],
         "muted": False
     }
     project["tracks"]["allIds"].append(track_id)
 
-    # Build timeline items in order
+    # Build timeline items from ai_json['clips'] preserving order
     sorted_clips = sorted(ai_json.get("clips", []), key=lambda c: (c.get("order") or 0))
     cursor = 0.0
-    for n, c in enumerate(sorted_clips, start=1):
-        # ensure types
-        start = float(c["start_time"])
-        end = float(c["end_time"])
+
+    for idx, c in enumerate(sorted_clips, start=1):
+        # Defensive conversions - ensure fields exist
+        source_key = c.get("source")
+        if source_key is None:
+            # skip invalid entry
+            continue
+
+        # start/end times may be provided as floats or strings
+        start = float(c.get("start_time", 0.0))
+        end = float(c.get("end_time", start))
         duration = max(0.0, end - start)
 
-        item_id = f"item_{n}"
-        asset_id = f"asset_{c['source']}"
+        # deterministic item id based on project, index, source and source start (ms)
+        start_ms = int(c.get("start_time_ms", round(start * 1000)))
+        item_id = deterministic_item_id(project_id, idx, source_key, start_ms)
+
+        # map asset id
+        asset_id = asset_id_map.get(source_key)
+        # fallback: try to find asset that matches filename basename
+        if asset_id is None:
+            # try match by basename
+            for k, fname in source_to_filename.items():
+                if k == source_key or os.path.basename(fname) == source_key:
+                    asset_id = asset_id_map.get(k)
+                    break
 
         item_obj = {
             "id": item_id,
             "assetId": asset_id,
-            "trackId": track_id,
+            "type": "timeline_item",
             # position on timeline (seconds)
             "startTime": cursor,
             "duration": duration,
             # trim ranges on the source asset (seconds)
             "trim": {"from": start, "to": end},
-            # source ms fields for accuracy
-            "source_start_ms": int(c.get("start_time_ms", round(start * 1000))),
+            # source ms fields
+            "source_start_ms": start_ms,
             "source_end_ms": int(c.get("end_time_ms", round(end * 1000))),
-            # playback settings
-            "speed": 1.0,
-            "volume": 0.0 if c.get("mute") else 1.0,
-            # boolean flags commonly present in project files
-            "enabled": True,
-            "locked": False,
-            # decorative/position data (Clipchamp sometimes stores this)
-            "position": {"x": 0, "y": 0, "scale": 1.0, "rotation": 0},
+            "speed": float(c.get("speed", 1.0)),
+            "volume": 0.0 if c.get("mute") else float(c.get("volume", 1.0)),
+            "enabled": bool(c.get("enabled", True)),
+            "locked": bool(c.get("locked", False)),
+            "position": c.get("position", {"x": 0, "y": 0, "scale": 1.0, "rotation": 0}),
             "order": c.get("order"),
+            # extData for traceability: include original clip payload and deterministic local id
+            "extData": {
+                "orig_source_key": source_key,
+                "orig_index": idx,
+            }
         }
 
         project["items"]["byId"][item_id] = item_obj
         project["items"]["allIds"].append(item_id)
 
-        # append item id to track ordering
+        # add to track
         project["tracks"]["byId"][track_id]["items"].append(item_id)
 
+        # advance cursor
         cursor += duration
 
-    # timeline info
-    project["timeline"]["duration"] = cursor
-    project["timeline"]["tracks"][track_id] = {
-        "id": track_id,
-        "items": project["tracks"]["byId"][track_id]["items"],
-        "duration": cursor,
-    }
+    # timeline (duration and per-track mapping)
+    project["timeline"] = {"duration": cursor, "tracks": {}}
+    for tid, t in project["tracks"]["byId"].items():
+        project["timeline"]["tracks"][tid] = {
+            "id": tid,
+            "items": t["items"],
+            "duration": cursor
+        }
 
-    # update updatedAt timestamp
+    # finalize updated timestamp
     project["updatedAt"] = _now_iso()
 
-    # ensure stable pretty JSON to ease differences/debugging
+    # stable pretty JSON
     json_bytes = json.dumps(project, indent=2, ensure_ascii=False).encode("utf-8")
     return zlib.compress(json_bytes)
 
 
+# -------------------------
+# File-saving wrapper
+# -------------------------
 def save_clipchamp_project(
     project_name: str,
     ai_json: Dict,
@@ -168,8 +285,8 @@ def save_clipchamp_project(
     **build_kwargs
 ) -> str:
     """
-    Build a .clipchamp project from the AI JSON and save it to a local folder.
-    Returns the absolute path of the saved file.
+    Build a .clipchamp project from AI JSON and save it to disk.
+    Returns absolute path of saved file.
     """
     folder = output_folder or CLIPCHAMP_OUTPUT_FOLDER
     os.makedirs(folder, exist_ok=True)
@@ -182,4 +299,4 @@ def save_clipchamp_project(
     with open(out_path, "wb") as f:
         f.write(clip_bytes)
 
-    return os.path.abspath(out_path)
+    return os.path.abspath(out_path)