inline-core 1.1.1__py3-none-any.whl

inline_core/studio/graph_build.py

@@ -0,0 +1,109 @@
+"""Serialize a canvas subgraph into an Inline Core graph (schemaVersion 1) — ported from the Studio
+``electron/main/core/workflow.ts``. Walks the connector graph upstream from a target node's closure:
+
+- a ``core`` item   -> its Core node type + params (handles are already Core port ids)
+- a ``prompt`` item -> an ``input/text`` source node
+- an ``asset`` item -> an ``input/image`` source node (local path ref)
+
+Connectors become typed edges (source output port -> target input port). Node ids are the canvas
+item ids, so a produced take's ``node_id`` maps straight back to the item that made it.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from . import moodboard as mb
+
+
+def _source_output_port(source: dict[str, Any] | None, source_handle: str | None) -> str:
+    if source and source["type"] == "prompt":
+        return "text"
+    if source and source["type"] == "asset":
+        return "image"
+    return source_handle or "out"  # a 'core' item's handles already are Core port ids
+
+
+def _edges_for(
+    item_id: str, connectors: list[dict[str, Any]], by_id: dict[str, dict[str, Any]]
+) -> dict[str, dict[str, str]]:
+    inputs: dict[str, dict[str, str]] = {}
+    for c in connectors:
+        if c["toItemId"] != item_id:
+            continue
+        data = c.get("data") or {}
+        target_handle = data.get("targetHandle") or "in"
+        inputs[target_handle] = {
+            "from": c["fromItemId"],
+            "output": _source_output_port(by_id.get(c["fromItemId"]), data.get("sourceHandle")),
+        }
+    return inputs
+
+
+def _item_to_node(
+    item: dict[str, Any],
+    connectors: list[dict[str, Any]],
+    by_id: dict[str, dict[str, Any]],
+    resolve_asset_path: Callable[[str], str | None],
+) -> dict[str, Any] | None:
+    data = item.get("data") or {}
+    if item["type"] == "core" and data.get("core"):
+        return {
+            "id": item["id"],
+            "type": data["core"]["type"],
+            "params": data["core"].get("params") or {},
+            "inputs": _edges_for(item["id"], connectors, by_id),
+        }
+    if item["type"] == "prompt":
+        text = data.get("promptText") or ""
+        return {"id": item["id"], "type": "input/text", "params": {"text": text}}
+    if item["type"] == "asset" and item.get("assetId"):
+        path = resolve_asset_path(item["assetId"])
+        if not path:
+            return None
+        return {
+            "id": item["id"],
+            "type": "input/image",
+            "params": {"asset": {"ref": "path", "path": path}},
+        }
+    return None
+
+
+def _upstream_closure(target: str, connectors: list[dict[str, Any]]) -> set[str]:
+    seen: set[str] = set()
+    stack = [target]
+    while stack:
+        node_id = stack.pop()
+        if node_id in seen:
+            continue
+        seen.add(node_id)
+        for c in connectors:
+            if c["toItemId"] == node_id and c["fromItemId"] not in seen:
+                stack.append(c["fromItemId"])
+    return seen
+
+
+def build_workflow_graph(
+    conn: sqlite3.Connection, folder: Path, target_item_id: str
+) -> tuple[dict[str, Any], str]:
+    """Build the Core graph for a canvas node from the open project's board."""
+    board = mb.list_board(conn)
+    items, connectors = board["items"], board["connectors"]
+    by_id = {i["id"]: i for i in items}
+
+    def resolve_asset_path(asset_id: str) -> str | None:
+        row = conn.execute("SELECT file_path FROM assets WHERE id = ?", (asset_id,)).fetchone()
+        return str(folder / row["file_path"]) if row else None
+
+    nodes: list[dict[str, Any]] = []
+    for node_id in _upstream_closure(target_item_id, connectors):
+        item = by_id.get(node_id)
+        if item is None:
+            continue
+        node = _item_to_node(item, connectors, by_id, resolve_asset_path)
+        if node is not None:
+            nodes.append(node)
+    return {"schemaVersion": 1, "nodes": nodes}, target_item_id

inline_core/studio/handlers.py

@@ -0,0 +1,236 @@
+"""Register the Studio InlineStudioApi channels natively on the RpcRouter, backed by ``StudioStore``
+and the domain modules. This is the strangler-fig flip: once these are registered, the SPA's app
+backend is Core (Python), not the legacy Node server.
+
+Channel args arrive as a positional list (the ``{channel, args}`` wire shape). Each handler unpacks
+them and returns the value to wrap in Ok. Not-yet-ported surfaces (generation, timeline,
+export, embedded ComfyUI) register clear stubs so the UI degrades gracefully instead of a
+"no handler".
+"""
+
+from __future__ import annotations
+
+import inspect
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from . import assets as ax
+from . import config as cfg
+from . import fal as _fal
+from . import frames as fr
+from . import moodboard as mb
+from .store import StudioStore
+
+
+def _unlink(folder: Path, relatives: list[str]) -> None:
+    for rel in relatives:
+        try:
+            (folder / rel).unlink(missing_ok=True)
+        except OSError:
+            pass
+
+
+def register_studio_handlers(
+    rpc: Any,
+    store: StudioStore,
+    *,
+    core_models: Callable[[], dict[str, Any]],
+    core_status: Callable[[], dict[str, Any]],
+    generation: Any = None,
+    fal_generation: Any = None,
+    timeline: Any = None,
+    model_downloads: Any = None,
+    app_version: str = "1.0.0",
+) -> None:
+    def reg(channel: str, fn: Callable[..., Any]) -> None:
+        async def handler(args: list[Any]) -> Any:
+            result = fn(*args)
+            if inspect.isawaitable(result):
+                result = await result  # async handlers (e.g. the ffmpeg timeline render)
+            return result
+
+        rpc.register(channel, handler)
+
+    def conn() -> Any:
+        return store.conn()
+
+    def not_wired(feature: str) -> Callable[..., Any]:
+        def fn(*_args: Any) -> Any:
+            raise RuntimeError(f"{feature} isn't available on the single-process path yet.")
+
+        return fn
+
+    # --- project + app-global -------------------------------------------------------------------
+    reg("project:create", lambda inp: store.create_project(inp["name"], inp.get("parentDir")))
+    reg("project:open", lambda path: store.open_project(path))
+    reg("project:openDialog", lambda: None)  # no native folder picker in a browser
+    reg("project:openZip", lambda: None)
+    reg("project:listRecent", store.list_recent)
+    reg("project:current", store.current_project)
+    reg("project:mediaDirs", store.media_dirs)
+    reg("project:export", lambda _path: None)  # zip export: pending (see plan)
+    reg("dialog:pickDirectory", lambda *_: str(cfg.workspace_dir()))
+    reg("app:version", lambda: app_version)
+    reg("settings:get", store.get_settings)
+    reg("settings:setComfyUrl", store.set_comfy_url)
+    reg("settings:setCoreUrl", store.set_core_url)
+    reg("core:status", core_status)
+    reg("core:models", core_models)
+
+    # --- model requirements + explicit downloads (the node's "missing models" popup) ------------
+    if model_downloads is not None:
+        reg("models:requirements", lambda node_type: model_downloads.requirements(node_type))
+        reg("models:download", lambda node_type, cid: model_downloads.download(node_type, cid))
+    else:
+        reg("models:requirements", lambda _node_type: {"components": [], "allPresent": True})
+        reg("models:download", not_wired("Model downloads"))
+
+    # --- folders --------------------------------------------------------------------------------
+    reg("folders:list", lambda: ax.list_folders(conn()))
+    reg("folders:create", lambda inp: ax.create_folder(conn(), inp["name"], inp.get("parentId")))
+    reg("folders:rename", lambda fid, name: ax.rename_folder(conn(), fid, name))
+    reg("folders:delete", lambda fid: ax.delete_folder(conn(), fid))
+
+    # --- assets ---------------------------------------------------------------------------------
+    reg("assets:list", lambda: ax.list_assets(conn()))
+    reg("assets:importDialog", lambda _folder_id=None: [])  # browser uses /upload instead
+    reg(
+        "assets:importPaths",
+        lambda paths, folder_id: [
+            a
+            for a in (ax.import_file(conn(), store.folder(), p, folder_id) for p in paths if p)
+            if a
+        ],
+    )
+
+    def delete_asset(asset_id: str) -> None:
+        paths = ax.delete_asset(conn(), asset_id)
+        _unlink(store.folder(), paths)
+
+    reg("assets:delete", delete_asset)
+
+    # --- frames + takes + inputs ----------------------------------------------------------------
+    reg("frames:list", lambda: fr.list_frames(conn()))
+    reg("frames:importAsFrames", lambda: [])  # browser has no import dialog
+    reg("frames:addFromAsset", lambda asset_id: fr.add_from_asset(conn(), asset_id))
+    reg("frames:rename", lambda fid, name: fr.rename_frame(conn(), fid, name))
+    reg("frames:reorder", lambda ids: fr.reorder_frames(conn(), ids))
+    reg("frames:clone", lambda fid: fr.clone_frame(conn(), fid))
+    reg("frames:unlink", lambda fid: fr.unlink_workflow(conn(), fid))
+    reg("frames:setHero", lambda fid, take_id: fr.set_hero(conn(), fid, take_id))
+    reg("frames:listTakes", lambda fid: fr.list_takes(conn(), fid))
+    reg("frames:heroTakes", lambda: fr.hero_takes(conn()))
+    reg("frames:listInputs", lambda: fr.list_inputs(conn()))
+    reg("frames:addInput", lambda fid, aid: fr.add_input(conn(), fid, aid))
+    reg("frames:addInputs", lambda fid, aids: fr.add_inputs(conn(), fid, aids))
+    reg("frames:addSourceInput", lambda fid, src: fr.add_source_input(conn(), fid, src))
+    reg("frames:removeInput", lambda fid, aid: fr.remove_input(conn(), fid, aid))
+    reg("frames:removeInputById", lambda fid, iid: fr.remove_input_by_id(conn(), fid, iid))
+    reg("frames:reorderInputs", lambda fid, aids: fr.reorder_inputs(conn(), fid, aids))
+    reg("frames:listAllTakes", lambda: fr.list_all_takes(conn()))
+    reg("frames:setFalParams", lambda fid, params: fr.set_fal_params(conn(), fid, params))
+    # Resolve a fal frame's inputs (media data URIs) + prompt so the browser can build the request.
+    reg(
+        "frames:resolveFalInputs",
+        lambda fid: _fal.resolve_fal_inputs(conn(), store.folder(), fid),
+    )
+    # Fal model metadata (kind/params/title) lives studio-side; until the frontend sends it,
+    # sensibly (kind image, empty params). The GenNode UI still renders params from its own def.
+    reg("frames:setModel", lambda fid, mid: fr.set_model(conn(), fid, mid, "image", {}))
+    reg(
+        "frames:setProvider",
+        lambda fid, provider, mid=None: fr.set_provider(
+            conn(), fid, provider, mid, "image" if provider == "fal" else None, {}
+        ),
+    )
+
+    def delete_frame(frame_id: str) -> None:
+        fr.delete_frame(conn(), frame_id)
+
+    reg("frames:delete", delete_frame)
+
+    def delete_take(take_id: str) -> None:
+        path = fr.delete_take(conn(), take_id)
+        if path:
+            _unlink(store.folder(), [path])
+
+    reg("frames:deleteTake", delete_take)
+
+    # --- moodboard ------------------------------------------------------------------------------
+    reg("moodboard:list", lambda: mb.list_board(conn()))
+    reg("moodboard:addAsset", lambda aid, x, y: mb.add_asset(conn(), aid, x, y))
+    reg("moodboard:addText", lambda x, y: mb.add_text(conn(), x, y))
+    reg("moodboard:addFrameFromAsset", lambda aid, x, y: mb.add_frame_from_asset(conn(), aid, x, y))
+    reg("moodboard:addEmptyFrame", lambda x, y: mb.add_empty_frame(conn(), x, y))
+    reg("moodboard:addFrameItem", lambda fid, x, y: mb.add_frame_item(conn(), fid, x, y))
+    reg("moodboard:addPreview", lambda x, y: mb.add_preview(conn(), x, y))
+    reg("moodboard:addLayer", lambda x, y: mb.add_layer(conn(), x, y))
+    reg("moodboard:addDirector", lambda x, y: mb.add_director(conn(), x, y))
+    reg("moodboard:addTrim", lambda x, y: mb.add_trim(conn(), x, y))
+    reg("moodboard:addPrompt", lambda x, y: mb.add_prompt(conn(), x, y))
+    reg("moodboard:addCoreNode", lambda t, x, y: mb.add_core_node(conn(), t, x, y))
+    reg(
+        "moodboard:addGenNode",
+        lambda mid, x, y: mb.add_gen_node(conn(), mid, x, y, kind="image", params={}, title=mid),
+    )
+    reg("moodboard:updateItem", lambda iid, patch: mb.update_item(conn(), iid, patch))
+    reg("moodboard:deleteItem", lambda iid: mb.delete_item(conn(), iid))
+    reg("moodboard:importAndPlace", lambda _x, _y: [])  # browser uses /upload
+    reg(
+        "moodboard:createConnector",
+        lambda f, t, sh=None, th=None: mb.create_connector(conn(), f, t, sh, th),
+    )
+    reg("moodboard:deleteConnector", lambda cid: mb.delete_connector(conn(), cid))
+    reg("moodboard:setConnectorVolume", lambda cid, vol: mb.set_connector_volume(conn(), cid, vol))
+    reg(
+        "moodboard:replaceBoard",
+        lambda items, connectors: mb.replace_board(conn(), items, connectors),
+    )
+
+    # --- generation -----------------------------------------------------------------------------
+    if generation is not None:
+        reg("generation:runWorkflow", lambda item_id: generation.run_workflow(item_id))
+    else:
+        reg("generation:runWorkflow", not_wired("Core-node generation"))
+
+    # Fal: the browser passes a prebuilt request {endpoint, body, outputKind}; Core runs it.
+    if fal_generation is not None:
+        reg("generation:run", lambda frame_id, request: fal_generation.run(frame_id, request))
+    else:
+        reg("generation:run", not_wired("Fal generation"))
+
+    def cancel_generation(frame_id: str | None = None) -> None:
+        if generation is not None:
+            generation.cancel(frame_id)
+        if fal_generation is not None:
+            fal_generation.cancel(frame_id)
+
+    reg("generation:cancel", cancel_generation)
+    reg("generation:resumePending", lambda: None)
+
+    # --- fal settings (key stored server-side) --------------------------------------------------
+    reg("falSettings:status", store.fal_status)
+    reg("falSettings:setApiKey", store.set_fal_key)
+    reg("falSettings:clearApiKey", store.clear_fal_key)
+    reg("comfy:status", lambda: {"reachable": False, "url": ""})
+    for ch in ("linkFrame", "uploadInputs", "pullWorkflow", "saveLiveWorkflow", "pushWorkflow",
+               "pullLatest", "latestRun", "captureOutput"):
+        reg(f"comfy:{ch}", not_wired("Embedded ComfyUI"))
+    # --- timeline (director/trim/export via ffmpeg) + folder export -----------------------------
+    if timeline is not None:
+        from .timeline.render import export_frames
+
+        reg("timeline:resolve", lambda oid: timeline.resolve(oid))
+        reg("timeline:resolveTrim", lambda iid: timeline.resolve_trim(iid))
+        reg("timeline:setVolumes", lambda oid, l1, l2: timeline.set_volumes(oid, l1, l2))
+        reg("timeline:buildPreview", lambda oid: timeline.build_preview(oid))
+        reg("timeline:export", lambda oid: timeline.export(oid))
+        reg("export:exportFrames", lambda: export_frames(conn(), store.folder()))
+    else:
+        for ch in ("resolve", "resolveTrim", "setVolumes", "buildPreview", "export"):
+            reg(f"timeline:{ch}", not_wired("The video timeline"))
+        reg("export:exportFrames", lambda: None)
+
+    reg("updates:check", lambda: None)
+    reg("updates:quitAndInstall", lambda: None)

inline_core/studio/models.py

@@ -0,0 +1,173 @@
+"""Explicit, visible model downloads — the backend for the node's "missing models" popup.
+
+**This is the only place in the engine that fetches a model over the network.** The runner loads
+everything ``local_files_only=True`` (never downloads); here the user explicitly asks for a
+component and we pull it from the reference repo **straight into ``models/<category>/``** (never the
+hidden HF cache), streaming progress over the ``/events`` socket. So a model arrives by exactly two
+paths: the user drops files under ``models/``, or this downloader writes them there.
+
+Fire-and-forget, mirroring ``CoreGeneration``: ``requirements`` answers synchronously; ``download``
+schedules a background thread and returns immediately, emitting ``events:modelDownload*`` frames.
+The blocking Hugging Face calls run off the event loop, so progress is marshalled back with
+``loop.call_soon_threadsafe`` (``EventBroadcaster`` is not thread-safe).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import shutil
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+_ZIMAGE_TYPE = "alibaba/z-image-turbo"
+_SKIP_TOP_LEVEL = {".gitattributes", "readme.md", "license", "license.md", ".gitignore"}
+
+
+class ModelDownloads:
+    """Answers "what's missing" and downloads components into the models dir on request."""
+
+    def __init__(self, events: Any, on_change: Callable[[], None] | None = None) -> None:
+        self._events = events
+        self._on_change = on_change  # rescan the model catalog after a download lands
+
+    # --- requirements (the popup's data) --------------------------------------------------------
+
+    def requirements(self, node_type: str) -> dict[str, Any]:
+        """The node's model components with live presence. ``{components: [...], allPresent}``.
+
+        Returns an empty, all-present view for node types with no requirements (or when the model
+        runtime isn't installed — the node then shows its own "unavailable" state instead)."""
+        components = self._components(node_type)
+        return {
+            "components": [_component_json(c) for c in components],
+            "allPresent": all(c.present for c in components),
+        }
+
+    # --- download (explicit, user-triggered) ----------------------------------------------------
+
+    def download(self, node_type: str, component_id: str) -> None:
+        """Download one component (by id) or ``"all"`` missing ones, in a background thread."""
+        loop = asyncio.get_running_loop()
+        asyncio.create_task(asyncio.to_thread(self._run, node_type, component_id, loop))
+
+    def _run(self, node_type: str, component_id: str, loop: asyncio.AbstractEventLoop) -> None:
+        components = self._components(node_type)
+        if component_id == "all":
+            targets = [c for c in components if not c.present]
+        else:
+            targets = [c for c in components if c.id == component_id]
+        for comp in targets:
+            payload_id = comp.id
+            try:
+                self._download_component(
+                    comp,
+                    lambda frac, status, cid=payload_id: self._emit(
+                        loop,
+                        "events:modelDownloadProgress",
+                        {
+                            "nodeType": node_type,
+                            "componentId": cid,
+                            "fraction": frac,
+                            "status": status,
+                        },
+                    ),
+                )
+                self._rescan()
+                self._emit(
+                    loop,
+                    "events:modelDownloadDone",
+                    {"nodeType": node_type, "componentId": payload_id},
+                )
+            except Exception as error:  # noqa: BLE001 — surface as a UI event, never crash the loop
+                self._emit(
+                    loop,
+                    "events:modelDownloadError",
+                    {"nodeType": node_type, "componentId": payload_id, "error": str(error)},
+                )
+
+    # --- internals ------------------------------------------------------------------------------
+
+    def _components(self, node_type: str) -> list[Any]:
+        if node_type != _ZIMAGE_TYPE:
+            return []
+        try:
+            from ..models.zimage.requirements import zimage_requirements
+        except ImportError:
+            return []  # zimage runtime absent — the node shows "unavailable", no requirements
+        return zimage_requirements()
+
+    def _download_component(self, comp: Any, on_progress: Callable[[float, str], None]) -> None:
+        """Fetch a component's files from its repo into ``models/<category>/…``, flattening any
+        source subfolders. Downloads into a ``.part`` staging dir first, then moves into place, so a
+        half-finished download never looks installed."""
+        from huggingface_hub import HfApi, hf_hub_download
+
+        from ..models.zimage.requirements import download_target
+
+        target: Path = download_target(comp)
+        staging = target.parent / (target.name + ".part")
+        shutil.rmtree(staging, ignore_errors=True)
+
+        files = _wanted_files(HfApi(), comp)
+        total = sum(size for _, size in files) or 1
+        on_progress(0.0, f"Downloading {comp.label}…")
+
+        downloaded = 0
+        for rfilename, size in files:
+            hf_hub_download(comp.repo, rfilename, local_dir=str(staging))
+            downloaded += size
+            on_progress(min(0.99, downloaded / total), f"Downloading {comp.label}…")
+
+        target.mkdir(parents=True, exist_ok=True)
+        for rfilename, _ in files:
+            dest = target / _flatten_rel(rfilename, comp.subfolders)
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.move(str(staging / rfilename), str(dest))
+        shutil.rmtree(staging, ignore_errors=True)
+        on_progress(1.0, f"{comp.label} ready")
+
+    def _rescan(self) -> None:
+        """Refresh the catalog so /v1/models options + the registry version see the new files."""
+        if self._on_change is not None:
+            self._on_change()
+
+    def _emit(self, loop: asyncio.AbstractEventLoop, channel: str, payload: Any) -> None:
+        loop.call_soon_threadsafe(self._events.broadcast, channel, payload)
+
+
+def _component_json(component: Any) -> dict[str, Any]:
+    return {
+        "id": component.id,
+        "label": component.label,
+        "category": component.category,
+        "present": component.present,
+        "localPath": component.local_path,
+        "repo": component.repo,
+    }
+
+
+def _wanted_files(api: Any, comp: Any) -> list[tuple[str, int]]:
+    """(rfilename, size) for the repo files this component needs — a subfolder subset, or the whole
+    repo (minus boilerplate) when it has no subfolders."""
+    info = api.model_info(comp.repo, files_metadata=True)
+    out: list[tuple[str, int]] = []
+    for sibling in info.siblings:
+        name = sibling.rfilename
+        if comp.subfolders:
+            if not any(name.startswith(sf + "/") for sf in comp.subfolders):
+                continue
+        elif "/" not in name and name.lower() in _SKIP_TOP_LEVEL:
+            continue
+        out.append((name, int(sibling.size or 0)))
+    return out
+
+
+def _flatten_rel(rfilename: str, subfolders: tuple[str, ...]) -> str:
+    """Where a downloaded file lands under the target: subfolder components are flattened (strip the
+    leading ``vae/`` etc.); a whole-repo (pipeline) download keeps its layout."""
+    for sf in subfolders:
+        prefix = sf + "/"
+        if rfilename.startswith(prefix):
+            return rfilename[len(prefix) :]
+    return rfilename