Update clipchamp_export.py

clipchamp_export.py

@@ -1,61 +1,172 @@
-# clipchamp_export.py
-import os, json, zlib
-from typing import Dict
+# clipchamp_export.py (improved)
+import os
+import json
+import zlib
+import time
+import datetime
+import mimetypes
+from typing import Dict, Optional
 
 CLIPCHAMP_OUTPUT_FOLDER = os.environ.get("CLIPCHAMP_OUTPUT_FOLDER", "clipchamp_projects")
 
 
-def build_clipchamp_bytes(project_name: str, ai_json: Dict, source_to_filename: Dict, source_to_duration: Dict = None) -> bytes:
-    """Serialize AI editing plan into a zlib-compressed .clipchamp project file."""
+def _now_iso():
+    return datetime.datetime.utcnow().replace(microsecond=0).isoformat() + "Z"
+
+
+def build_clipchamp_bytes(
+    project_name: str,
+    ai_json: Dict,
+    source_to_filename: Dict,
+    source_to_duration: Dict = None,
+    aspect_ratio: Optional[str] = "16:9",
+    render_settings: Optional[Dict] = None,
+    schema_version: str = "1.0.0",
+) -> bytes:
+    """
+    Serialize AI editing plan into a zlib-compressed .clipchamp project file.
+    Produces a richer structure (assets.allIds, items.allIds, tracks, createdAt/updatedAt, renderSettings).
+    """
     if source_to_duration is None:
         source_to_duration = {}
 
+    created_at = _now_iso()
+    updated_at = created_at
+
+    # Base project skeleton (richer metadata than the minimal version)
     project = {
         "version": "1.0",
-        "assets": {"byId": {}},
-        "items": {"byId": {}},
-        "tracks": {"byId": {"track_1": {"id": "track_1", "type": "video", "index": 0}}},
-        "metadata": {"description": ai_json.get("description"), "projectName": project_name}
+        "schemaVersion": schema_version,
+        "name": project_name,
+        "createdAt": created_at,
+        "updatedAt": updated_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
+        "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
     for key, fname in source_to_filename.items():
         aid = f"asset_{key}"
-        project["assets"]["byId"][aid] = {
-            "id": aid, "fileName": fname, "originalFileName": fname,
-            "assetKey": key, "metadata": {"duration": source_to_duration.get(key)},
-            "importedSize": None, "uri": fname
+        meta = _file_meta(fname)
+        asset_obj = {
+            "id": aid,
+            "fileName": os.path.basename(fname),
+            "originalFileName": os.path.basename(fname),
+            "assetKey": key,
+            "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"],
         }
+        project["assets"]["byId"][aid] = asset_obj
+        project["assets"]["allIds"].append(aid)
+
+    # single video track for now (expandable)
+    track_id = "track_1"
+    project["tracks"]["byId"][track_id] = {
+        "id": track_id,
+        "type": "video",
+        "index": 0,
+        "items": [],       # ordered list of item IDs on this track
+        "muted": False
+    }
+    project["tracks"]["allIds"].append(track_id)
 
     # Build timeline items in 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"])
         duration = max(0.0, end - start)
+
         item_id = f"item_{n}"
-        project["items"]["byId"][item_id] = {
+        asset_id = f"asset_{c['source']}"
+
+        item_obj = {
             "id": item_id,
-            "assetId": f"asset_{c['source']}",
-            "trackId": "track_1",
+            "assetId": asset_id,
+            "trackId": track_id,
+            # 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_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},
             "order": c.get("order"),
-            "source_start_ms": int(c.get("start_time_ms", round(start * 1000))),
-            "source_end_ms": int(c.get("end_time_ms", round(end * 1000)))
         }
+
+        project["items"]["byId"][item_id] = item_obj
+        project["items"]["allIds"].append(item_id)
+
+        # append item id to track ordering
+        project["tracks"]["byId"][track_id]["items"].append(item_id)
+
         cursor += duration
 
-    project["timeline"] = {"duration": cursor}
-    return zlib.compress(json.dumps(project, indent=2).encode("utf-8"))
+    # timeline info
+    project["timeline"]["duration"] = cursor
+    project["timeline"]["tracks"][track_id] = {
+        "id": track_id,
+        "items": project["tracks"]["byId"][track_id]["items"],
+        "duration": cursor,
+    }
+
+    # update updatedAt timestamp
+    project["updatedAt"] = _now_iso()
+
+    # ensure stable pretty JSON to ease differences/debugging
+    json_bytes = json.dumps(project, indent=2, ensure_ascii=False).encode("utf-8")
+    return zlib.compress(json_bytes)
 
 
-def save_clipchamp_project(project_name: str, ai_json: Dict, source_to_filename: Dict,
-                           source_to_duration: Dict = None, output_folder: str = None) -> str:
+def save_clipchamp_project(
+    project_name: str,
+    ai_json: Dict,
+    source_to_filename: Dict,
+    source_to_duration: Dict = None,
+    output_folder: str = None,
+    **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.
@@ -63,10 +174,12 @@ def save_clipchamp_project(project_name: str, ai_json: Dict, source_to_filename:
     folder = output_folder or CLIPCHAMP_OUTPUT_FOLDER
     os.makedirs(folder, exist_ok=True)
 
-    clip_bytes = build_clipchamp_bytes(project_name, ai_json, source_to_filename, source_to_duration)
+    clip_bytes = build_clipchamp_bytes(project_name, ai_json, source_to_filename, source_to_duration, **build_kwargs)
 
-    out_path = os.path.join(folder, f"{project_name}.clipchamp")
+    # sanitize project_name for filename
+    safe_name = "".join(c if c.isalnum() or c in (" ", "_", "-") else "_" for c in project_name).strip()
+    out_path = os.path.join(folder, f"{safe_name}.clipchamp")
     with open(out_path, "wb") as f:
         f.write(clip_bytes)
 
-    return os.path.abspath(out_path)
+    return os.path.abspath(out_path)