inline-core 1.1.1__py3-none-any.whl

inline_core/server/run_store.py

@@ -0,0 +1,155 @@
+"""Durable run storage (SQLite, stdlib). A runId and its final state survive a process restart, so
+GET /v1/runs/{id} keeps working after Core is bounced. Runs left mid-flight by a crash are marked
+interrupted on the next start. Live progress ticks are not persisted (they are lost on a crash
+anyway); the record captures structure, terminal status, and takes.
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+import threading
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from ..media import MediaKind
+from ..runtime.run import NodeRuntimeState, NodeState, RunError, RunState, RunStatus
+from ..takes import Take
+
+
+class RunStore(ABC):
+    @abstractmethod
+    def interrupt_stale(self) -> None: ...
+
+    @abstractmethod
+    def create(self, state: RunState, client_run_id: str | None) -> None: ...
+
+    @abstractmethod
+    def update(self, state: RunState) -> None: ...
+
+    @abstractmethod
+    def load(self, run_id: str) -> RunState | None: ...
+
+    @abstractmethod
+    def find_take(self, take_id: str) -> Take | None: ...
+
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS runs (
+  run_id TEXT PRIMARY KEY, target TEXT, status TEXT, fraction REAL,
+  error_message TEXT, error_node TEXT, client_run_id TEXT, created_at INTEGER
+);
+CREATE TABLE IF NOT EXISTS run_nodes (
+  run_id TEXT, node_id TEXT, state TEXT, phase TEXT, fraction REAL,
+  step INTEGER, step_count INTEGER, status TEXT, PRIMARY KEY (run_id, node_id)
+);
+CREATE TABLE IF NOT EXISTS run_takes (
+  take_id TEXT PRIMARY KEY, run_id TEXT, node_id TEXT, kind TEXT, uri TEXT,
+  hash TEXT, params TEXT, created_at INTEGER
+);
+"""
+
+
+class SqliteRunStore(RunStore):
+    def __init__(self, path: Path) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        self._conn = sqlite3.connect(str(path), check_same_thread=False)
+        self._lock = threading.Lock()
+        with self._lock, self._conn:
+            self._conn.executescript(_SCHEMA)
+
+    def interrupt_stale(self) -> None:
+        with self._lock, self._conn:
+            self._conn.execute(
+                "UPDATE runs SET status=?, error_message=? WHERE status IN ('queued','running')",
+                (RunStatus.ERROR.value, "interrupted by a restart"),
+            )
+
+    def create(self, state: RunState, client_run_id: str | None) -> None:
+        with self._lock, self._conn:
+            self._conn.execute(
+                "INSERT OR REPLACE INTO runs VALUES (?,?,?,?,?,?,?,?)",
+                (state.run_id, state.target, state.status.value, state.fraction, None, None,
+                 client_run_id, 0),
+            )
+            self._write_nodes(state)
+
+    def update(self, state: RunState) -> None:
+        error_message = state.error.message if state.error is not None else None
+        error_node = state.error.node_id if state.error is not None else None
+        with self._lock, self._conn:
+            self._conn.execute(
+                "UPDATE runs SET status=?, fraction=?, error_message=?, error_node=? "
+                "WHERE run_id=?",
+                (state.status.value, state.fraction, error_message, error_node, state.run_id),
+            )
+            self._write_nodes(state)
+            self._conn.execute("DELETE FROM run_takes WHERE run_id=?", (state.run_id,))
+            self._conn.executemany(
+                "INSERT OR REPLACE INTO run_takes VALUES (?,?,?,?,?,?,?,?)",
+                [
+                    (t.id, t.run_id, t.node_id, t.kind.value, t.uri, t.hash,
+                     json.dumps(t.params), t.created_at)
+                    for t in state.takes
+                ],
+            )
+
+    def _write_nodes(self, state: RunState) -> None:
+        self._conn.execute("DELETE FROM run_nodes WHERE run_id=?", (state.run_id,))
+        self._conn.executemany(
+            "INSERT OR REPLACE INTO run_nodes VALUES (?,?,?,?,?,?,?,?)",
+            [
+                (state.run_id, node_id, n.state.value, n.phase, n.fraction, n.step, n.step_count,
+                 n.status)
+                for node_id, n in state.nodes.items()
+            ],
+        )
+
+    def load(self, run_id: str) -> RunState | None:
+        with self._lock:
+            row = self._conn.execute(
+                "SELECT target, status, fraction, error_message, error_node FROM runs "
+                "WHERE run_id=?",
+                (run_id,),
+            ).fetchone()
+            if row is None:
+                return None
+            node_rows = self._conn.execute(
+                "SELECT node_id, state, phase, fraction, step, step_count, status FROM run_nodes "
+                "WHERE run_id=?",
+                (run_id,),
+            ).fetchall()
+            take_rows = self._conn.execute(
+                "SELECT take_id, node_id, kind, uri, hash, params, created_at FROM run_takes "
+                "WHERE run_id=?",
+                (run_id,),
+            ).fetchall()
+
+        target, status, fraction, error_message, error_node = row
+        state = RunState(run_id=run_id, target=target, status=RunStatus(status), fraction=fraction)
+        for node_id, node_state, phase, node_fraction, step, step_count, node_status in node_rows:
+            state.nodes[node_id] = NodeRuntimeState(
+                state=NodeState(node_state), phase=phase, fraction=node_fraction,
+                step=step, step_count=step_count, status=node_status,
+            )
+        for take_id, node_id, kind, uri, take_hash, params, created_at in take_rows:
+            state.takes.append(
+                Take(id=take_id, run_id=run_id, node_id=node_id, kind=MediaKind(kind),
+                     uri=uri, hash=take_hash, params=json.loads(params), created_at=created_at)
+            )
+        if error_message is not None:
+            state.error = RunError(message=error_message, node_id=error_node)
+        return state
+
+    def find_take(self, take_id: str) -> Take | None:
+        with self._lock:
+            row = self._conn.execute(
+                "SELECT run_id, node_id, kind, uri, hash, params, created_at FROM run_takes "
+                "WHERE take_id=?",
+                (take_id,),
+            ).fetchone()
+        if row is None:
+            return None
+        run_id, node_id, kind, uri, take_hash, params, created_at = row
+        return Take(id=take_id, run_id=run_id, node_id=node_id, kind=MediaKind(kind),
+                    uri=uri, hash=take_hash, params=json.loads(params), created_at=created_at)

inline_core/server/serialize.py

@@ -0,0 +1,144 @@
+"""Domain objects -> contract JSON (camelCase). The API boundary; keeps the domain types clean."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..graph.descriptor import NodeDescriptor, ParamField, Port
+from ..models.catalog import ModelCatalog
+from ..runtime.progress import (
+    CancelledEvent,
+    NodeDoneEvent,
+    ProgressEvent,
+    RunDoneEvent,
+    RunEvent,
+)
+from ..runtime.run import NodeRuntimeState, RunState
+from ..takes import Take
+
+
+def port_json(port: Port) -> dict[str, Any]:
+    return {"id": port.id, "label": port.label, "kind": port.kind.value, "required": port.required}
+
+
+def param_json(field: ParamField, catalog: ModelCatalog | None = None) -> dict[str, Any]:
+    out: dict[str, Any] = {
+        "key": field.key,
+        "label": field.label,
+        "widget": field.widget.value,
+        "default": field.default,
+    }
+    if field.min is not None:
+        out["min"] = field.min
+    if field.max is not None:
+        out["max"] = field.max
+    if field.step is not None:
+        out["step"] = field.step
+    options = [{"value": o.value, "label": o.label} for o in field.options]
+    if field.options_from is not None:
+        out["optionsFrom"] = field.options_from
+        if catalog is not None:
+            options += [{"value": f, "label": f} for f in catalog.list(field.options_from)]
+    if options:
+        out["options"] = options
+    if field.advanced:
+        out["advanced"] = True
+    return out
+
+
+def descriptor_json(
+    descriptor: NodeDescriptor, catalog: ModelCatalog | None = None
+) -> dict[str, Any]:
+    out: dict[str, Any] = {
+        "type": descriptor.type,
+        "title": descriptor.title,
+        "category": descriptor.category,
+        "icon": descriptor.icon,
+        "source": descriptor.source,
+        "outputKind": descriptor.output_kind.value if descriptor.output_kind else None,
+        "inputs": [port_json(p) for p in descriptor.inputs],
+        "outputs": [port_json(p) for p in descriptor.outputs],
+        "params": [param_json(p, catalog) for p in descriptor.params],
+    }
+    if descriptor.hidden:
+        out["hidden"] = True
+    return out
+
+
+def take_json(take: Take) -> dict[str, Any]:
+    return {
+        "id": take.id,
+        "runId": take.run_id,
+        "nodeId": take.node_id,
+        "kind": take.kind.value,
+        "uri": take.uri,
+        "hash": take.hash,
+        "params": take.params,
+        "createdAt": take.created_at,
+    }
+
+
+def node_json(node: NodeRuntimeState) -> dict[str, Any]:
+    out: dict[str, Any] = {"state": node.state.value, "fraction": node.fraction}
+    if node.phase is not None:
+        out["phase"] = node.phase
+    if node.step is not None:
+        out["step"] = node.step
+    if node.step_count is not None:
+        out["stepCount"] = node.step_count
+    if node.status:
+        out["status"] = node.status
+    return out
+
+
+def run_json(state: RunState) -> dict[str, Any]:
+    return {
+        "runId": state.run_id,
+        "status": state.status.value,
+        "target": state.target,
+        "fraction": state.fraction,
+        "nodes": {node_id: node_json(n) for node_id, n in state.nodes.items()},
+        "takes": [take_json(t) for t in state.takes],
+        "error": (
+            {"nodeId": state.error.node_id, "message": state.error.message}
+            if state.error is not None
+            else None
+        ),
+    }
+
+
+def event_json(event: RunEvent) -> dict[str, Any]:
+    if isinstance(event, ProgressEvent):
+        out: dict[str, Any] = {
+            "type": "progress",
+            "runId": event.run_id,
+            "nodeId": event.node_id,
+            "phase": event.phase.value,
+            "fraction": event.fraction,
+            "status": event.status,
+        }
+        if event.step is not None:
+            out["step"] = event.step
+        if event.step_count is not None:
+            out["stepCount"] = event.step_count
+        if event.eta_ms is not None:
+            out["etaMs"] = event.eta_ms
+        return out
+    if isinstance(event, NodeDoneEvent):
+        return {
+            "type": "node_done",
+            "runId": event.run_id,
+            "nodeId": event.node_id,
+            "cached": event.cached,
+            "takes": [take_json(t) for t in event.takes],
+        }
+    if isinstance(event, RunDoneEvent):
+        return {"type": "run_done", "runId": event.run_id}
+    if isinstance(event, CancelledEvent):
+        return {"type": "cancelled", "runId": event.run_id}
+    return {
+        "type": "error",
+        "runId": event.run_id,
+        "message": event.message,
+        "nodeId": event.node_id,
+    }

inline_core/studio/__init__.py

@@ -0,0 +1,7 @@
+"""The Studio app-backend, ported to Python (Part B of the migration).
+
+This is the former Electron/TypeScript ``electron/main`` backend — projects, the project SQLite DB,
+frames/takes, the moodboard, settings — reimplemented so Inline Core is the single backend the web
+SPA talks to over ``/rpc`` (see ``inline_core.server.rpc``). Ported domain by domain; until the
+storage layer lands, the ``/rpc`` bridge still proxies un-ported channels to the Node backend.
+"""

inline_core/studio/assets.py

@@ -0,0 +1,194 @@
+"""Asset library + folders, ported from the Studio ``electron/main/assets/{store,folders}.ts``.
+
+Physical files live flat under the project's ``assets/`` dir; folders are a logical tree in the DB.
+Operates on an open ``sqlite3.Connection`` plus the project folder (for copying imported files).
+
+Poster/thumbnail/transcode generation (ffmpeg) is deferred and best-effort — the UI renders the
+original meanwhile — so import here just copies the file and inserts the row.
+"""
+
+from __future__ import annotations
+
+import shutil
+import sqlite3
+import time
+import uuid
+from pathlib import Path
+from typing import Any
+
+# Extension -> media kind (mirrors the Studio KIND_BY_EXT).
+_KIND_BY_EXT = {
+    ".png": "image", ".jpg": "image", ".jpeg": "image", ".webp": "image", ".gif": "image",
+    ".bmp": "image", ".tiff": "image", ".avif": "image",
+    ".mp4": "video", ".mov": "video", ".webm": "video", ".mkv": "video", ".avi": "video",
+    ".mp3": "audio", ".wav": "audio", ".m4a": "audio", ".flac": "audio", ".ogg": "audio",
+    ".aac": "audio",
+}
+
+
+def _now() -> int:
+    return int(time.time() * 1000)
+
+
+def _uuid() -> str:
+    return str(uuid.uuid4())
+
+
+def _project_id(conn: sqlite3.Connection) -> str:
+    row = conn.execute("SELECT id FROM project LIMIT 1").fetchone()
+    if row is None:
+        raise RuntimeError("No project is open.")
+    return row["id"]
+
+
+def kind_for_file(path: str) -> str | None:
+    return _KIND_BY_EXT.get(Path(path).suffix.lower())
+
+
+# --- folders ------------------------------------------------------------------------------------
+
+
+def _row_to_folder(row: sqlite3.Row) -> dict[str, Any]:
+    return {
+        "id": row["id"],
+        "projectId": row["project_id"],
+        "name": row["name"],
+        "parentId": row["parent_id"],
+        "createdAt": row["created_at"],
+    }
+
+
+def get_folder(conn: sqlite3.Connection, folder_id: str) -> dict[str, Any]:
+    row = conn.execute("SELECT * FROM asset_folders WHERE id = ?", (folder_id,)).fetchone()
+    if row is None:
+        raise ValueError("Folder not found.")
+    return _row_to_folder(row)
+
+
+def list_folders(conn: sqlite3.Connection) -> list[dict[str, Any]]:
+    rows = conn.execute("SELECT * FROM asset_folders ORDER BY name COLLATE NOCASE").fetchall()
+    return [_row_to_folder(r) for r in rows]
+
+
+def create_folder(conn: sqlite3.Connection, name: str, parent_id: str | None) -> dict[str, Any]:
+    trimmed = name.strip()
+    if not trimmed:
+        raise ValueError("Folder name is required.")
+    if parent_id:
+        get_folder(conn, parent_id)  # validate parent
+    folder = {
+        "id": _uuid(),
+        "projectId": _project_id(conn),
+        "name": trimmed,
+        "parentId": parent_id,
+        "createdAt": _now(),
+    }
+    conn.execute(
+        "INSERT INTO asset_folders (id, project_id, name, parent_id, created_at) "
+        "VALUES (?, ?, ?, ?, ?)",
+        (folder["id"], folder["projectId"], trimmed, parent_id, folder["createdAt"]),
+    )
+    return folder
+
+
+def rename_folder(conn: sqlite3.Connection, folder_id: str, name: str) -> dict[str, Any]:
+    trimmed = name.strip()
+    if not trimmed:
+        raise ValueError("Folder name is required.")
+    get_folder(conn, folder_id)
+    conn.execute("UPDATE asset_folders SET name = ? WHERE id = ?", (trimmed, folder_id))
+    return get_folder(conn, folder_id)
+
+
+def delete_folder(conn: sqlite3.Connection, folder_id: str) -> None:
+    """Delete a folder; its assets and subfolders reparent to its parent."""
+    folder = get_folder(conn, folder_id)
+    parent = folder["parentId"]
+    conn.execute("UPDATE assets SET folder_id = ? WHERE folder_id = ?", (parent, folder_id))
+    conn.execute("UPDATE asset_folders SET parent_id = ? WHERE parent_id = ?", (parent, folder_id))
+    conn.execute("DELETE FROM asset_folders WHERE id = ?", (folder_id,))
+
+
+# --- assets -------------------------------------------------------------------------------------
+
+
+def _row_to_asset(row: sqlite3.Row) -> dict[str, Any]:
+    return {
+        "id": row["id"],
+        "projectId": row["project_id"],
+        "folderId": row["folder_id"],
+        "name": row["name"],
+        "filePath": row["file_path"],
+        "kind": row["kind"],
+        "thumbPath": row["thumb_path"],
+        "previewPath": row["preview_path"],
+        "createdAt": row["created_at"],
+    }
+
+
+def list_assets(conn: sqlite3.Connection) -> list[dict[str, Any]]:
+    rows = conn.execute("SELECT * FROM assets ORDER BY created_at DESC, rowid DESC").fetchall()
+    return [_row_to_asset(r) for r in rows]
+
+
+def asset_file(conn: sqlite3.Connection, asset_id: str) -> dict[str, Any] | None:
+    row = conn.execute(
+        "SELECT file_path, kind, name FROM assets WHERE id = ?", (asset_id,)
+    ).fetchone()
+    if row is None:
+        return None
+    return {"filePath": row["file_path"], "kind": row["kind"], "name": row["name"]}
+
+
+def import_file(
+    conn: sqlite3.Connection, folder: Path, abs_path: str, folder_id: str | None
+) -> dict[str, Any] | None:
+    """Copy a file into the project's assets/ dir + insert its row. None for unknown kinds."""
+    kind = kind_for_file(abs_path)
+    if kind is None:
+        return None
+    asset_id = _uuid()
+    ext = Path(abs_path).suffix.lower()
+    relative = f"assets/{asset_id}{ext}"
+    (folder / "assets").mkdir(parents=True, exist_ok=True)
+    shutil.copyfile(abs_path, folder / relative)
+    asset = {
+        "id": asset_id,
+        "projectId": _project_id(conn),
+        "folderId": folder_id,
+        "name": Path(abs_path).name,
+        "filePath": relative,
+        "kind": kind,
+        "thumbPath": None,
+        "previewPath": None,
+        "createdAt": _now(),
+    }
+    conn.execute(
+        "INSERT INTO assets (id, project_id, folder_id, name, file_path, kind, thumb_path, "
+        "preview_path, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        (
+            asset["id"], asset["projectId"], folder_id, asset["name"], relative, kind, None, None,
+            asset["createdAt"],
+        ),
+    )
+    return asset
+
+
+def delete_asset(conn: sqlite3.Connection, asset_id: str) -> list[str]:
+    """Delete a library asset (blocked if used as a frame input). Returns file paths to unlink."""
+    used = conn.execute(
+        "SELECT COUNT(*) AS n FROM frame_inputs WHERE asset_id = ?", (asset_id,)
+    ).fetchone()["n"]
+    if used > 0:
+        plural = "" if used == 1 else "s"
+        raise ValueError(
+            f"This asset is used by {used} frame{plural} — remove it from those frames first."
+        )
+    row = conn.execute(
+        "SELECT file_path, thumb_path, preview_path FROM assets WHERE id = ?", (asset_id,)
+    ).fetchone()
+    conn.execute("DELETE FROM moodboard_items WHERE asset_id = ?", (asset_id,))
+    conn.execute("DELETE FROM assets WHERE id = ?", (asset_id,))
+    if row is None:
+        return []
+    return [p for p in (row["file_path"], row["thumb_path"], row["preview_path"]) if p]

inline_core/studio/config.py

@@ -0,0 +1,29 @@
+"""App-global config for the Studio backend: where recents/settings live and where new projects are
+created (the browser has no folder picker). Env-driven, mirroring the legacy Node web server.
+
+``INLINE_STUDIO_DATA_DIR``      — app data (recents, settings). Default ``~/.inline-studio-server``
+``INLINE_STUDIO_WORKSPACE_DIR`` — where new projects are created. Default ``~/InlineStudioProjects``
+
+The old ``STORYLINE_*`` names still work as deprecated aliases (see CLAUDE.md).
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+DEFAULT_COMFY_URL = os.environ.get("COMFYUI_URL") or "http://127.0.0.1:8188"
+DEFAULT_CORE_URL = os.environ.get("INLINE_CORE_URL") or "http://127.0.0.1:8848"
+
+
+def _env(name: str) -> str | None:
+    """Read INLINE_STUDIO_<name>, falling back to the deprecated STORYLINE_<name> alias."""
+    return os.environ.get(f"INLINE_STUDIO_{name}") or os.environ.get(f"STORYLINE_{name}")
+
+
+def data_dir() -> Path:
+    return Path(_env("DATA_DIR") or (Path.home() / ".inline-studio-server"))
+
+
+def workspace_dir() -> Path:
+    return Path(_env("WORKSPACE_DIR") or (Path.home() / "InlineStudioProjects"))