inline-core 1.1.1__py3-none-any.whl

inline_core/studio/store.py

@@ -0,0 +1,291 @@
+"""Project lifecycle + app-global settings/recents, ported from the Studio TS backend
+(``electron/main/project/*`` + ``settings/store.ts``). Core owns ``project.db`` once this layer is
+wired into ``/rpc``.
+
+A project on disk is a portable folder::
+
+    MyFilm.inlinestudio/
+      project.db   assets/   takes/   thumbs/
+
+The web SPA has no native folder picker, so new projects are created under a workspace dir (like the
+legacy Node web server did with STORYLINE_WORKSPACE_DIR). Recents + settings are app-global JSON in
+the app data dir.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sqlite3
+import time
+import uuid
+from pathlib import Path
+from typing import Any
+
+from .schema import apply_schema
+
+PROJECT_EXT = ".inlinestudio"
+LEGACY_EXTS = (".storyline",)
+PROJECT_EXTS = (PROJECT_EXT, *LEGACY_EXTS)
+SUBDIRS = ("assets", "takes", "thumbs")
+MAX_RECENTS = 12
+
+
+def _now_ms() -> int:
+    return int(time.time() * 1000)
+
+
+def _sanitize_folder_name(name: str) -> str:
+    base = re.sub(r"^-+|-+$", "", re.sub(r"[^\w.-]+", "-", name.strip()))
+    return base or "untitled"
+
+
+def _is_project_ext(folder: str) -> bool:
+    return any(folder.endswith(ext) for ext in PROJECT_EXTS)
+
+
+class StudioStore:
+    """Owns the single open project (folder + SQLite connection) and app-global settings/recents."""
+
+    def __init__(
+        self,
+        app_data_dir: str | Path,
+        workspace_dir: str | Path,
+        *,
+        default_comfy_url: str = "http://127.0.0.1:8188",
+        default_core_url: str = "http://127.0.0.1:8848",
+    ) -> None:
+        self._app_data = Path(app_data_dir)
+        self._workspace = Path(workspace_dir)
+        self._app_data.mkdir(parents=True, exist_ok=True)
+        self._workspace.mkdir(parents=True, exist_ok=True)
+        self._default_comfy_url = default_comfy_url
+        self._default_core_url = default_core_url
+        self._conn: sqlite3.Connection | None = None
+        self._folder: Path | None = None
+        self._current: dict[str, Any] | None = None
+
+    # --- project db connection ------------------------------------------------------------------
+
+    def _open_db(self, folder: Path) -> sqlite3.Connection:
+        """Open (creating if needed) the project.db inside a project folder, applying the schema."""
+        self.close()
+        db_path = folder / "project.db"
+        # A stale -shm in a copied project is rebuildable; drop it so SQLite regenerates it on open.
+        shm = Path(f"{db_path}-shm")
+        if shm.exists():
+            try:
+                shm.unlink()
+            except OSError:
+                pass
+        # Autocommit (isolation_level=None) so each write persists immediately, matching the Node
+        # backend's better-sqlite3 default — the domain modules don't manage transactions.
+        conn = sqlite3.connect(str(db_path), isolation_level=None)
+        conn.row_factory = sqlite3.Row
+        apply_schema(conn)
+        self._conn = conn
+        self._folder = folder
+        return conn
+
+    def conn(self) -> sqlite3.Connection:
+        if self._conn is None:
+            raise RuntimeError("No project is open.")
+        return self._conn
+
+    # Back-compat internal alias.
+    _db = conn
+
+    def folder(self) -> Path:
+        if self._folder is None:
+            raise RuntimeError("No project is open.")
+        return self._folder
+
+    def close(self) -> None:
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None
+            self._folder = None
+
+    # --- projects -------------------------------------------------------------------------------
+
+    def create_project(self, name: str, parent_dir: str | None = None) -> dict[str, Any]:
+        if not name or not name.strip():
+            raise ValueError("Project name is required.")
+        parent = Path(parent_dir) if parent_dir else self._workspace
+        folder = parent / f"{_sanitize_folder_name(name)}{PROJECT_EXT}"
+        if folder.exists():
+            raise ValueError(f"A project already exists at {folder}")
+        folder.mkdir(parents=True)
+        for sub in SUBDIRS:
+            (folder / sub).mkdir(parents=True, exist_ok=True)
+
+        conn = self._open_db(folder)
+        now = _now_ms()
+        pid = str(uuid.uuid4())
+        conn.execute(
+            "INSERT INTO project (id, name, created_at, updated_at) VALUES (?, ?, ?, ?)",
+            (pid, name, now, now),
+        )
+        conn.commit()
+        # TODO(B2/B3): seed the starter graph (empty frame + Prompt -> Z-Image) once the frames and
+        # moodboard stores are ported. New projects open with an empty board until then.
+        project = {"id": pid, "name": name, "path": str(folder), "createdAt": now, "updatedAt": now}
+        self._current = project
+        self.record_recent(name, str(folder))
+        return project
+
+    def open_project(self, selected: str) -> dict[str, Any]:
+        folder = self.resolve_project_folder(selected)
+        if folder is None:
+            raise ValueError("That folder is not an Inline Studio project (no project.db found).")
+        self._open_db(folder)
+        for sub in SUBDIRS:
+            (folder / sub).mkdir(parents=True, exist_ok=True)
+        project = self._load_project_row(folder)
+        self._current = project
+        self.record_recent(project["name"], str(folder))
+        return project
+
+    def _load_project_row(self, folder: Path) -> dict[str, Any]:
+        row = self._db().execute(
+            "SELECT id, name, created_at, updated_at FROM project LIMIT 1"
+        ).fetchone()
+        if row is None:
+            raise ValueError("project.db is missing its project record.")
+        return {
+            "id": row["id"],
+            "name": row["name"],
+            "path": str(folder),
+            "createdAt": row["created_at"],
+            "updatedAt": row["updated_at"],
+        }
+
+    def current_project(self) -> dict[str, Any] | None:
+        return self._current
+
+    def media_dirs(self) -> dict[str, str]:
+        if self._folder is None:
+            raise RuntimeError("No project is open.")
+        return {
+            "inputDir": str(self._folder / "assets"),
+            "outputDir": str(self._folder / "takes"),
+        }
+
+    def resolve_project_folder(self, folder: str) -> Path | None:
+        """The real project folder for a picked one: itself if it holds project.db, else a child
+        that does (an unzip may wrap the project one level down). Prefers a *.inlinestudio child."""
+        root = Path(folder)
+        try:
+            if (root / "project.db").exists():
+                return root
+            children = [c for c in root.iterdir() if c.is_dir()]
+            preferred = next(
+                (c for c in children if _is_project_ext(c.name) and (c / "project.db").exists()),
+                None,
+            )
+            if preferred is not None:
+                return preferred
+            any_child = next((c for c in children if (c / "project.db").exists()), None)
+            return any_child
+        except OSError:
+            return None
+
+    def is_project_folder(self, folder: str) -> bool:
+        return self.resolve_project_folder(folder) is not None
+
+    # --- recents (app-global JSON) --------------------------------------------------------------
+
+    def _recents_file(self) -> Path:
+        return self._app_data / "recent-projects.json"
+
+    def list_recent(self) -> list[dict[str, Any]]:
+        file = self._recents_file()
+        if not file.exists():
+            return []
+        try:
+            parsed = json.loads(file.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            return []
+        return parsed if isinstance(parsed, list) else []
+
+    def record_recent(self, name: str, path: str) -> None:
+        now = _now_ms()
+        existing = [r for r in self.list_recent() if r.get("path") != path]
+        nxt = [{"name": name, "path": path, "lastOpenedAt": now}, *existing][:MAX_RECENTS]
+        self._recents_file().write_text(json.dumps(nxt, indent=2), encoding="utf-8")
+
+    # --- settings (app-global JSON) -------------------------------------------------------------
+
+    def _settings_file(self) -> Path:
+        return self._app_data / "settings.json"
+
+    def _read_settings(self) -> dict[str, Any]:
+        file = self._settings_file()
+        if not file.exists():
+            return {}
+        try:
+            parsed = json.loads(file.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            return {}
+        return parsed if isinstance(parsed, dict) else {}
+
+    @staticmethod
+    def _non_empty(value: Any) -> str | None:
+        return value if isinstance(value, str) and value else None
+
+    def get_settings(self) -> dict[str, str]:
+        saved = self._read_settings()
+        return {
+            "comfyUrl": self._non_empty(saved.get("comfyUrl")) or self._default_comfy_url,
+            "coreUrl": self._non_empty(saved.get("coreUrl")) or self._default_core_url,
+        }
+
+    def _save_settings(self, settings: dict[str, str]) -> dict[str, str]:
+        self._settings_file().write_text(json.dumps(settings, indent=2), encoding="utf-8")
+        return settings
+
+    def set_comfy_url(self, url: str) -> dict[str, str]:
+        settings = self.get_settings()
+        settings["comfyUrl"] = url.strip() or self._default_comfy_url
+        return self._save_settings(settings)
+
+    def set_core_url(self, url: str) -> dict[str, str]:
+        settings = self.get_settings()
+        settings["coreUrl"] = url.strip() or self._default_core_url
+        return self._save_settings(settings)
+
+    # --- fal API key (app-global, server-side only) ---------------------------------------------
+
+    def _fal_key_file(self) -> Path:
+        return self._app_data / "fal_key"
+
+    def fal_key(self) -> str | None:
+        file = self._fal_key_file()
+        if not file.exists():
+            env = os.environ.get("FAL_KEY", "").strip()
+            return env or None
+        try:
+            return file.read_text(encoding="utf-8").strip() or None
+        except OSError:
+            return None
+
+    def fal_status(self) -> dict[str, bool]:
+        # `encrypted` is False: the key lives in a 0600 file, not OS-encrypted (single-user local).
+        return {"hasKey": self.fal_key() is not None, "encrypted": False}
+
+    def set_fal_key(self, key: str) -> dict[str, bool]:
+        file = self._fal_key_file()
+        file.write_text(key.strip(), encoding="utf-8")
+        try:
+            file.chmod(0o600)  # owner-only: the key never leaves the server side
+        except OSError:
+            pass
+        return self.fal_status()
+
+    def clear_fal_key(self) -> dict[str, bool]:
+        try:
+            self._fal_key_file().unlink(missing_ok=True)
+        except OSError:
+            pass
+        return {"hasKey": False, "encrypted": False}

inline_core/studio/timeline/__init__.py

@@ -0,0 +1,6 @@
+"""The director-node timeline: resolve a wired timeline from the canvas, then render it with ffmpeg.
+
+Ported from the Studio ``electron/main/{timeline,export,media}`` modules. ``compose`` builds the
+ffmpeg arg vector (pure), ``ffmpeg`` runs it, ``resolve`` derives the timeline from the moodboard
+connectors, and ``render`` orchestrates preview/export.
+"""

inline_core/studio/timeline/compose.py

@@ -0,0 +1,130 @@
+"""Build the ffmpeg args to render a director timeline (EDL) into one muxed MP4 — a faithful
+port of the Studio ``electron/main/export/compose.ts``. Pure + deterministic, so unit-tested.
+
+Model: clips reference absolute files at ``start_time``, trimmed to in/out. Track 0 = video
+(images loop for a synthetic duration), track 1 = audio. Heterogeneous sources are normalised to a
+common W×H/fps and 44.1k stereo, then overlaid / mixed onto a base black-video + silent-audio bed.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ResolvedClip:
+    kind: str  # 'video' | 'image' | 'audio'
+    abs_path: str
+    track: int  # 0 = video, 1 = audio
+    start_time: float
+    in_point: float
+    out_point: float
+    has_audio: bool = False
+    muted: bool = False
+    volume: float = 1.0
+
+
+@dataclass
+class ComposeSettings:
+    width: int
+    height: int
+    fps: int
+    preset: str
+    crf: int
+    out_path: str
+
+
+def _clip_duration(c: ResolvedClip) -> float:
+    return max(0.04, c.out_point - c.in_point)
+
+
+def _clip_end(c: ResolvedClip) -> float:
+    return c.start_time + _clip_duration(c)
+
+
+def timeline_duration(clips: list[ResolvedClip]) -> float:
+    """Total timeline length = the furthest clip end (min 0.04s)."""
+    return max((_clip_end(c) for c in clips), default=0.04)
+
+
+def _contributes_audio(c: ResolvedClip) -> bool:
+    if c.volume <= 0:
+        return False
+    if c.track == 1:
+        return True
+    return c.kind == "video" and not c.muted and c.has_audio
+
+
+def build_compose_args(clips: list[ResolvedClip], s: ComposeSettings) -> list[str]:
+    """The full ffmpeg arg vector (excluding the binary). Raises if there are no clips."""
+    if not clips:
+        raise ValueError("Cannot compose an empty timeline.")
+    total_str = f"{timeline_duration(clips):.3f}"
+    args: list[str] = ["-y"]
+
+    # Base beds: a black video and silent audio spanning the whole timeline.
+    args += ["-f", "lavfi", "-t", total_str, "-i",
+             f"color=c=black:s={s.width}x{s.height}:r={s.fps}"]
+    args += ["-f", "lavfi", "-t", total_str, "-i",
+             "anullsrc=channel_layout=stereo:sample_rate=44100"]
+
+    # One input per clip (index starts at 2). Images loop for their duration.
+    for c in clips:
+        dur = f"{_clip_duration(c):.3f}"
+        if c.kind == "image":
+            args += ["-loop", "1", "-t", dur, "-i", c.abs_path]
+        else:
+            args += ["-ss", f"{c.in_point:.3f}", "-t", dur, "-i", c.abs_path]
+
+    filters: list[str] = []
+    video_label = "0:v"
+    for i, c in enumerate(clips):
+        inp = i + 2
+        if c.track == 0 and c.kind in ("video", "image"):
+            v = f"v{i}"
+            filters.append(
+                f"[{inp}:v]scale={s.width}:{s.height}:force_original_aspect_ratio=decrease,"
+                f"pad={s.width}:{s.height}:(ow-iw)/2:(oh-ih)/2,setsar=1,fps={s.fps},"
+                f"setpts=PTS-STARTPTS+{c.start_time:.3f}/TB[{v}]"
+            )
+            out = f"ov{i}"
+            filters.append(
+                f"[{video_label}][{v}]overlay="
+                f"enable='between(t,{c.start_time:.3f},{_clip_end(c):.3f})'[{out}]"
+            )
+            video_label = out
+
+    audio_labels: list[str] = ["1:a"]
+    for i, c in enumerate(clips):
+        inp = i + 2
+        if _contributes_audio(c):
+            ms = round(c.start_time * 1000)
+            dur = _clip_duration(c)
+            fade = min(0.02, dur / 4)
+            fade_out = f"{max(0.0, dur - fade):.3f}"
+            a = f"a{len(audio_labels) - 1}"
+            filters.append(
+                f"[{inp}:a]atrim=0:{dur:.3f},asetpts=PTS-STARTPTS,"
+                f"aformat=sample_rates=44100:channel_layouts=stereo,"
+                f"volume={c.volume:.2f},"
+                f"afade=t=in:st=0:d={fade:.3f},afade=t=out:st={fade_out}:d={fade:.3f},"
+                f"adelay={ms}|{ms}[{a}]"
+            )
+            audio_labels.append(a)
+
+    audio_out = "1:a"
+    if len(audio_labels) > 1:
+        audio_out = "aout"
+        joined = "".join(f"[{lbl}]" for lbl in audio_labels)
+        filters.append(
+            f"{joined}amix=inputs={len(audio_labels)}:normalize=0:dropout_transition=0[{audio_out}]"
+        )
+
+    if filters:
+        args += ["-filter_complex", ";".join(filters)]
+    args += ["-map", "0:v" if video_label == "0:v" else f"[{video_label}]"]
+    args += ["-map", "1:a" if audio_out == "1:a" else f"[{audio_out}]"]
+    args += ["-c:v", "libx264", "-pix_fmt", "yuv420p", "-preset", s.preset, "-crf", str(s.crf),
+             "-c:a", "aac", "-movflags", "+faststart", "-r", str(s.fps), "-t", total_str,
+             s.out_path]
+    return args

inline_core/studio/timeline/ffmpeg.py

@@ -0,0 +1,76 @@
+"""ffmpeg/ffprobe for the timeline: locate the binary, probe media, run a render with progress.
+
+Prefers a bundled ``imageio-ffmpeg`` binary, else a system ``ffmpeg`` on PATH. ffprobe comes from
+PATH only (imageio bundles ffmpeg alone); probing degrades gracefully when it's absent.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import shutil
+import subprocess
+from collections.abc import Callable
+from functools import lru_cache
+
+
+@lru_cache(maxsize=1)
+def ffmpeg_exe() -> str | None:
+    try:
+        import imageio_ffmpeg
+
+        return imageio_ffmpeg.get_ffmpeg_exe()
+    except Exception:  # noqa: BLE001
+        return shutil.which("ffmpeg")
+
+
+@lru_cache(maxsize=1)
+def ffprobe_exe() -> str | None:
+    return shutil.which("ffprobe")
+
+
+def ffmpeg_available() -> bool:
+    return ffmpeg_exe() is not None
+
+
+def probe_media(abs_path: str) -> dict[str, object]:
+    """``{"durationSec", "hasAudio"}`` via ffprobe; conservative defaults if unavailable."""
+    probe = ffprobe_exe()
+    if probe:
+        try:
+            out = subprocess.run(
+                [probe, "-v", "quiet", "-print_format", "json", "-show_format", "-show_streams",
+                 abs_path],
+                capture_output=True, text=True, timeout=30,
+            )
+            data = json.loads(out.stdout or "{}")
+            duration = float(data.get("format", {}).get("duration") or 0)
+            has_audio = any(s.get("codec_type") == "audio" for s in data.get("streams", []))
+            return {"durationSec": duration, "hasAudio": has_audio}
+        except (OSError, ValueError, json.JSONDecodeError, subprocess.SubprocessError):
+            pass
+    return {"durationSec": 0.0, "hasAudio": False}
+
+
+async def compose_render(
+    args: list[str], total: float, on_progress: Callable[[float], None]
+) -> bool:
+    """Run ffmpeg with the arg vector, parsing -progress for a 0..1 fraction. True on success."""
+    exe = ffmpeg_exe()
+    if exe is None:
+        raise RuntimeError("ffmpeg is not available.")
+    proc = await asyncio.create_subprocess_exec(
+        exe, "-progress", "pipe:1", "-nostats", *args,
+        stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.DEVNULL,
+    )
+    assert proc.stdout is not None
+    async for raw in proc.stdout:
+        line = raw.decode(errors="ignore").strip()
+        if line.startswith("out_time_ms="):
+            try:
+                ms = int(line.split("=", 1)[1])
+                on_progress(min(1.0, (ms / 1_000_000) / max(0.04, total)))
+            except ValueError:
+                pass
+    await proc.wait()
+    return proc.returncode == 0

inline_core/studio/timeline/render.py

@@ -0,0 +1,120 @@
+"""Orchestrate rendering a director timeline: preview (low-res proxy) + export (full-res), plus
+the hero-take folder export. Ports ``electron/main/timeline/compose.ts`` + ``export/folder.ts``.
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+import time
+from pathlib import Path
+from typing import Any
+
+from .. import moodboard as mb
+from .compose import ComposeSettings, build_compose_args, timeline_duration
+from .ffmpeg import compose_render, ffmpeg_available
+from .resolve import resolve_timeline, resolve_trim
+
+_DEFAULT = {"width": 1920, "height": 1080, "fps": 30}
+
+
+def _even(n: float) -> int:
+    return max(2, round(n / 2) * 2)
+
+
+def _clamp01(v: Any) -> float:
+    return min(1.0, max(0.0, float(v))) if isinstance(v, (int, float)) else 1.0
+
+
+class Timeline:
+    def __init__(self, store: Any, events: Any) -> None:
+        self._store = store
+        self._events = events
+
+    def resolve(self, owner_item_id: str) -> dict[str, Any]:
+        display, _ = resolve_timeline(self._store.conn(), self._store.folder(), owner_item_id)
+        return display
+
+    def resolve_trim(self, item_id: str) -> dict[str, Any] | None:
+        return resolve_trim(self._store.conn(), self._store.folder(), item_id)
+
+    def set_volumes(self, owner_item_id: str, l1: Any, l2: Any) -> None:
+        conn = self._store.conn()
+        item = mb.get_item(conn, owner_item_id)
+        mb.update_item(
+            conn, owner_item_id,
+            {"data": {**item["data"], "l1Volume": _clamp01(l1), "l2Volume": _clamp01(l2)}},
+        )
+
+    async def build_preview(self, owner_item_id: str) -> str | None:
+        return await self._render(owner_item_id, preview=True)
+
+    async def export(self, owner_item_id: str) -> str | None:
+        return await self._render(owner_item_id, preview=False)
+
+    async def _render(self, owner_item_id: str, *, preview: bool) -> str | None:
+        if not ffmpeg_available():
+            raise RuntimeError("ffmpeg is not available.")
+        conn, folder = self._store.conn(), self._store.folder()
+        _, clips = resolve_timeline(conn, folder, owner_item_id)
+        if not clips:
+            return None
+        settings = (mb.get_item(conn, owner_item_id).get("data") or {}).get("director") or _DEFAULT
+        w, h, fps = settings["width"], settings["height"], settings["fps"]
+        stamp = int(time.time() * 1000)
+        if preview:
+            rel = f"thumbs/director-{owner_item_id}-{stamp}.preview.mp4"
+            cs = ComposeSettings(640, _even(640 * h / w), min(fps, 30), "ultrafast", 30,
+                                 str(folder / rel))
+        else:
+            rel = f"thumbs/director-{owner_item_id}-export-{stamp}.mp4"
+            cs = ComposeSettings(_even(w), _even(h), fps, "veryfast", 20, str(folder / rel))
+        (folder / "thumbs").mkdir(parents=True, exist_ok=True)
+
+        total = timeline_duration(clips)
+        ok = await compose_render(
+            build_compose_args(clips, cs), total,
+            lambda f: self._events.broadcast(
+                "events:timelineProgress", {"ownerItemId": owner_item_id, "fraction": f}
+            ),
+        )
+        self._events.broadcast(
+            "events:timelineProgress", {"ownerItemId": owner_item_id, "fraction": 1}
+        )
+        if not ok:
+            if not preview:
+                raise RuntimeError("Export render failed.")
+            return None
+        item = mb.get_item(conn, owner_item_id)
+        field = "directorPreview" if preview else "directorExport"
+        prev = item["data"].get(field)
+        mb.update_item(conn, owner_item_id, {"data": {**item["data"], field: rel}})
+        if prev and prev != rel:
+            try:
+                (folder / prev).unlink(missing_ok=True)
+            except OSError:
+                pass
+        return rel
+
+
+def export_frames(conn: Any, folder: Path) -> dict[str, Any]:
+    """Copy each frame's hero-take Output, in order, into a numbered export dir (no browser
+    folder picker, so it goes under the project's ``exports/<timestamp>/``)."""
+    out_dir = folder / "exports" / str(int(time.time() * 1000))
+    out_dir.mkdir(parents=True, exist_ok=True)
+    rows = conn.execute(
+        "SELECT s.name AS name, t.file_path AS file_path FROM frames s "
+        "LEFT JOIN takes t ON s.hero_take_id = t.id ORDER BY s.position"
+    ).fetchall()
+    exported = 0
+    skipped: list[str] = []
+    for row in rows:
+        if not row["file_path"]:
+            skipped.append(row["name"])
+            continue
+        exported += 1
+        ext = Path(row["file_path"]).suffix or ".png"
+        safe = re.sub(r"[^\w.-]+", "_", row["name"])
+        dest = out_dir / f"{str(exported).zfill(3)}_{safe}{ext}"
+        shutil.copyfile(folder / row["file_path"], dest)
+    return {"dir": str(out_dir), "exported": exported, "skipped": skipped}