inline-core 1.1.1__py3-none-any.whl

inline_core/graph/validate.py

@@ -0,0 +1,56 @@
+"""Up-front graph validation (contract section 3). Reject before running, never mid-graph."""
+
+from __future__ import annotations
+
+from ..errors import PortTypeError, UnknownNodeType
+from .registry import Registry
+from .schema import Graph, PortKind, port_satisfies
+from .topo import topo_sort, upstream_closure
+
+
+def validate(graph: Graph, target: str, registry: Registry) -> None:
+    """Raise GraphValidationError (with node/port) on the first problem; return None if valid."""
+    graph.node(target)
+
+    for node in graph.nodes:
+        if not registry.has(node.type):
+            raise UnknownNodeType(f"Unknown node type {node.type!r}.", node_id=node.id)
+
+    for node in graph.nodes:
+        descriptor = registry.get(node.type)
+        for port in descriptor.inputs:
+            if port.required and port.id not in node.inputs:
+                raise PortTypeError(
+                    f"{descriptor.title} needs an input wired to {port.label!r}.",
+                    node_id=node.id,
+                    port=port.id,
+                )
+        for port_id, edges in node.inputs.items():
+            in_port = descriptor.input(port_id)
+            if in_port is None:
+                raise PortTypeError(
+                    f"{node.type!r} has no input port {port_id!r}.", node_id=node.id, port=port_id
+                )
+            if len(edges) > 1 and in_port.kind is not PortKind.IMAGE_LIST:
+                raise PortTypeError(
+                    f"Input {port_id!r} takes a single edge.", node_id=node.id, port=port_id
+                )
+            for edge in edges:
+                source = graph.node(edge.from_node)
+                out_port = registry.get(source.type).output(edge.output)
+                if out_port is None:
+                    raise PortTypeError(
+                        f"{source.type!r} has no output port {edge.output!r}.",
+                        node_id=node.id,
+                        port=port_id,
+                    )
+                if not port_satisfies(out_port.kind, in_port.kind):
+                    raise PortTypeError(
+                        f"Cannot wire {out_port.kind.value} into {in_port.kind.value} "
+                        f"at {node.id}.{port_id}.",
+                        node_id=node.id,
+                        port=port_id,
+                    )
+
+    closure = list(upstream_closure(target, graph.input_sources))
+    topo_sort(closure, graph.input_sources)

inline_core/importer/__init__.py

@@ -0,0 +1 @@
+"""Best-effort importers that map foreign workflow formats onto our primitive node vocabulary."""

inline_core/importer/comfy.py

@@ -0,0 +1,162 @@
+"""Best-effort ComfyUI workflow importer: maps Comfy's API/prompt format onto our primitive
+vocabulary (not LiteGraph). Comfy's shape is `{nodeId: {class_type, inputs}}`.
+
+Comfy inputs are either literals (widget values) or edges `[nodeId, outputIndex]`. Two structural
+gaps we bridge: Comfy bundles model+clip+vae in one `CheckpointLoaderSimple` (we split it into three
+`load/*` nodes), and puts prompt text in a widget (lifted into an `input/text` node). Only known
+node types map; unknown ones are reported in `skipped`, never silently dropped.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class ImportResult:
+    graph: dict[str, Any]
+    skipped: list[str] = field(default_factory=list)
+
+
+@dataclass
+class _Ctx:
+    nodes: list[dict[str, Any]] = field(default_factory=list)
+    # (comfy_id, output_index) -> our edge {"from", "output"}
+    outputs: dict[tuple[str, int], dict[str, str]] = field(default_factory=dict)
+    # (our_node, our_input_port, comfy_edge) resolved after all nodes exist
+    pending: list[tuple[dict[str, Any], str, tuple[str, int]]] = field(default_factory=list)
+
+
+def _is_edge(value: Any) -> bool:
+    return isinstance(value, list) and len(value) == 2 and isinstance(value[0], str)
+
+
+def _wire(node: dict[str, Any], port: str, value: Any, ctx: _Ctx) -> None:
+    if _is_edge(value):
+        ctx.pending.append((node, port, (value[0], int(value[1]))))
+
+
+def _checkpoint(comfy_id: str, inputs: dict[str, Any], ctx: _Ctx) -> None:
+    ckpt = inputs.get("ckpt_name", "")
+    model_id, clip_id, vae_id = f"{comfy_id}:model", f"{comfy_id}:clip", f"{comfy_id}:vae"
+    ctx.nodes.append({"id": model_id, "type": "load/diffusion-model", "params": {"file": ckpt}})
+    ctx.nodes.append({"id": clip_id, "type": "load/text-encoder", "params": {"file": ckpt}})
+    ctx.nodes.append({"id": vae_id, "type": "load/vae", "params": {"file": ckpt}})
+    ctx.outputs[(comfy_id, 0)] = {"from": model_id, "output": "model"}
+    ctx.outputs[(comfy_id, 1)] = {"from": clip_id, "output": "text_encoder"}
+    ctx.outputs[(comfy_id, 2)] = {"from": vae_id, "output": "vae"}
+
+
+def _clip_encode(comfy_id: str, inputs: dict[str, Any], ctx: _Ctx) -> None:
+    text_id = f"{comfy_id}:text"
+    ctx.nodes.append(
+        {"id": text_id, "type": "input/text", "params": {"text": inputs.get("text", "")}}
+    )
+    node: dict[str, Any] = {
+        "id": comfy_id,
+        "type": "encode/text",
+        "params": {},
+        "inputs": {"prompt": {"from": text_id, "output": "text"}},
+    }
+    ctx.nodes.append(node)
+    _wire(node, "text_encoder", inputs.get("clip"), ctx)
+    ctx.outputs[(comfy_id, 0)] = {"from": comfy_id, "output": "conditioning"}
+
+
+def _empty_latent(comfy_id: str, inputs: dict[str, Any], ctx: _Ctx) -> None:
+    ctx.nodes.append(
+        {
+            "id": comfy_id,
+            "type": "latent/empty",
+            "params": {
+                "width": inputs.get("width", 1024),
+                "height": inputs.get("height", 1024),
+                "batch": inputs.get("batch_size", 1),
+            },
+        }
+    )
+    ctx.outputs[(comfy_id, 0)] = {"from": comfy_id, "output": "latent"}
+
+
+def _ksampler(comfy_id: str, inputs: dict[str, Any], ctx: _Ctx) -> None:
+    node: dict[str, Any] = {
+        "id": comfy_id,
+        "type": "sample",
+        "params": {
+            "steps": inputs.get("steps", 20),
+            "cfg": inputs.get("cfg", 5.0),
+            "sampler": inputs.get("sampler_name", "euler"),
+            "scheduler": inputs.get("scheduler", "simple"),
+            "seed": inputs.get("seed", -1),
+        },
+        "inputs": {},
+    }
+    ctx.nodes.append(node)
+    _wire(node, "model", inputs.get("model"), ctx)
+    _wire(node, "positive", inputs.get("positive"), ctx)
+    _wire(node, "negative", inputs.get("negative"), ctx)
+    _wire(node, "latent", inputs.get("latent_image"), ctx)
+    ctx.outputs[(comfy_id, 0)] = {"from": comfy_id, "output": "latent"}
+
+
+def _vae_decode(comfy_id: str, inputs: dict[str, Any], ctx: _Ctx) -> None:
+    node: dict[str, Any] = {"id": comfy_id, "type": "vae/decode", "params": {}, "inputs": {}}
+    ctx.nodes.append(node)
+    _wire(node, "latent", inputs.get("samples"), ctx)
+    _wire(node, "vae", inputs.get("vae"), ctx)
+    ctx.outputs[(comfy_id, 0)] = {"from": comfy_id, "output": "image"}
+
+
+def _vae_encode(comfy_id: str, inputs: dict[str, Any], ctx: _Ctx) -> None:
+    node: dict[str, Any] = {"id": comfy_id, "type": "vae/encode", "params": {}, "inputs": {}}
+    ctx.nodes.append(node)
+    _wire(node, "vae", inputs.get("vae"), ctx)
+    _wire(node, "image", inputs.get("pixels"), ctx)
+    ctx.outputs[(comfy_id, 0)] = {"from": comfy_id, "output": "latent"}
+
+
+def _vae_loader(comfy_id: str, inputs: dict[str, Any], ctx: _Ctx) -> None:
+    ctx.nodes.append(
+        {"id": comfy_id, "type": "load/vae", "params": {"file": inputs.get("vae_name", "")}}
+    )
+    ctx.outputs[(comfy_id, 0)] = {"from": comfy_id, "output": "vae"}
+
+
+_Handler = Callable[[str, dict[str, Any], _Ctx], None]
+
+_HANDLERS: dict[str, _Handler] = {
+    "CheckpointLoaderSimple": _checkpoint,
+    "CLIPTextEncode": _clip_encode,
+    "EmptyLatentImage": _empty_latent,
+    "KSampler": _ksampler,
+    "VAEDecode": _vae_decode,
+    "VAEEncode": _vae_encode,
+    "VAELoader": _vae_loader,
+}
+
+# Display sinks with no equivalent in our model (the decoded image is already the output/Frame).
+_SINKS = {"SaveImage", "PreviewImage"}
+
+
+def import_comfy_prompt(prompt: dict[str, Any]) -> ImportResult:
+    """Convert a Comfy prompt-format workflow into our graph JSON (schemaVersion 1)."""
+    ctx = _Ctx()
+    skipped: list[str] = []
+    for comfy_id, node in prompt.items():
+        class_type = str(node.get("class_type", ""))
+        if class_type in _SINKS:
+            continue
+        handler = _HANDLERS.get(class_type)
+        if handler is None:
+            skipped.append(class_type)
+            continue
+        handler(comfy_id, node.get("inputs", {}), ctx)
+
+    for node, port, (src_id, src_index) in ctx.pending:
+        edge = ctx.outputs.get((src_id, src_index))
+        if edge is not None:
+            node.setdefault("inputs", {})[port] = edge
+
+    return ImportResult(graph={"schemaVersion": 1, "nodes": ctx.nodes}, skipped=skipped)

inline_core/media.py

@@ -0,0 +1,11 @@
+"""The media kinds a take or a model output can be."""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+class MediaKind(str, Enum):
+    IMAGE = "image"
+    VIDEO = "video"
+    AUDIO = "audio"

inline_core/models/__init__.py

@@ -0,0 +1,8 @@
+"""Installed-model catalog and the model runners.
+
+`catalog.py` scans the models root (category subfolders of weight files the user drops in) and feeds
+the dynamic `options_from` selects on node params. Runner subpackages (e.g. `zimage`) are optional
+and imported best-effort by `server.bootstrap`, so a core install without their deps still boots.
+"""
+
+from __future__ import annotations

inline_core/models/catalog.py

@@ -0,0 +1,98 @@
+"""The installed-model catalog: what the user has dropped under the models root.
+
+The root holds one subfolder per category (``diffusion_models``, ``vae``, ``loras``, ...). A scan
+lists, per category, the weight files present (by filename) plus any subfolder that itself contains
+weights (by folder name, e.g. a sharded ``qwen3-4b/`` text encoder). Non-weight files are ignored.
+
+Two consumers: ``serialize.param_json`` fills a param's ``options_from`` select from ``list()``, and
+the server folds ``fingerprint()`` into the registry version so dropping a weight in bumps it and
+clients refetch ``/v1/models``. Nothing is downloaded; users place their own files.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+# Category subfolders scanned under the models root. These are the keys a param's `options_from`
+# may reference (see graph/primitives.py); ensure_dirs() creates them so drop-in is obvious.
+CATEGORIES: tuple[str, ...] = (
+    "diffusion_models",
+    "checkpoints",
+    "vae",
+    "text_encoders",
+    "loras",
+    "clip_vision",
+    "controlnet",
+    "upscale_models",
+    "embeddings",
+)
+
+# Extensions we treat as model weights. A folder counts as a model if it contains one of these.
+_WEIGHT_SUFFIXES: frozenset[str] = frozenset(
+    {".safetensors", ".ckpt", ".pt", ".pth", ".bin", ".gguf", ".onnx"}
+)
+
+
+def _is_weight(path: Path) -> bool:
+    return path.is_file() and path.suffix.lower() in _WEIGHT_SUFFIXES
+
+
+def _folder_has_weight(path: Path) -> bool:
+    return any(_is_weight(child) for child in path.rglob("*"))
+
+
+class ModelCatalog:
+    """Scans the models root and answers "what's installed" per category.
+
+    Cheap to construct; nothing touches disk until ``ensure_dirs`` or ``rescan``/``scan``. Results
+    are cached so ``list`` and ``fingerprint`` are hits between scans.
+    """
+
+    def __init__(self, root: Path) -> None:
+        self._root = Path(root)
+        self._entries: dict[str, list[str]] = {category: [] for category in CATEGORIES}
+
+    @property
+    def root(self) -> Path:
+        return self._root
+
+    def ensure_dirs(self) -> None:
+        """Create the root and every category subfolder, so users have somewhere to drop weights."""
+        for category in CATEGORIES:
+            (self._root / category).mkdir(parents=True, exist_ok=True)
+
+    def rescan(self) -> dict[str, list[str]]:
+        """Re-read every category from disk, cache the result, and return it."""
+        entries: dict[str, list[str]] = {}
+        for category in CATEGORIES:
+            entries[category] = self._scan_category(self._root / category)
+        self._entries = entries
+        return entries
+
+    # app.py calls scan() in the lifespan; rescan() is the same work exposed for tests/callers that
+    # want the mapping back. Keep both so neither call site has to know about the other.
+    def scan(self) -> dict[str, list[str]]:
+        return self.rescan()
+
+    def list(self, category: str) -> list[str]:
+        """The installed entries for a category (empty for an unknown or empty one)."""
+        return list(self._entries.get(category, []))
+
+    def fingerprint(self) -> str:
+        """A short, stable digest of the cached scan; changes iff the installed set changes."""
+        payload = json.dumps(self._entries, sort_keys=True)
+        return hashlib.sha256(payload.encode()).hexdigest()[:16]
+
+    def _scan_category(self, directory: Path) -> list[str]:
+        if not directory.is_dir():
+            return []
+        names: list[str] = []
+        for entry in directory.iterdir():
+            if _is_weight(entry):
+                names.append(entry.name)
+            elif entry.is_dir() and _folder_has_weight(entry):
+                # A sharded model (config + shards) is one entry, named for its folder.
+                names.append(entry.name)
+        return sorted(names)

inline_core/models/zimage/__init__.py

@@ -0,0 +1,11 @@
+"""The Z-Image (Alibaba Tongyi) runtime: a diffusers-backed text-to-image / img2img runner.
+
+Optional subpackage. `server.bootstrap` imports `register_zimage` best-effort, so a core install
+without the ``zimage`` extra (torch + diffusers) still boots and serves the source nodes.
+"""
+
+from __future__ import annotations
+
+from .runner import register_zimage
+
+__all__ = ["register_zimage"]

inline_core/models/zimage/requirements.py

@@ -0,0 +1,180 @@
+"""What Z-Image needs on disk, and whether it's present — the data behind the node's model popup.
+
+**No hidden downloads.** A component is "present" only if the user placed it under ``models/`` or
+downloaded it through the popup (which also writes into ``models/``). Nothing here or in the runner
+ever fetches a model as a side effect of loading — a missing component is reported, not silently
+pulled from Hugging Face.
+
+This module is deliberately **torch-free** (pure filesystem + config), so the requirements check and
+the download planning work without the heavy ``zimage`` runtime loaded. The runner imports the
+resolution helpers from here so the "what/where" logic lives in one place.
+
+Z-Image is a single diffusers repo (``Tongyi-MAI/Z-Image-Turbo``) with ``transformer/``, ``vae/``,
+``text_encoder/`` and ``tokenizer/`` subfolders. The user's common path is to drop a single
+diffusion ``.safetensors`` in ``diffusion_models/`` and download the small VAE + text-encoder; the
+popup can also fetch the whole pipeline as one diffusers folder.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from ...config import models_dir
+
+#: The reference repo. Used only as an explicit download source (never as an implicit load source).
+BASE_REPO = "Tongyi-MAI/Z-Image-Turbo"
+
+_WEIGHT_SUFFIXES = (".safetensors", ".ckpt", ".pt", ".sft")
+_LOCAL_NAMES = ("Z-Image-Turbo", "z-image-turbo", "Z-Image", "z-image")
+#: Folder name new downloads land under, inside each category dir (so re-downloads are idempotent).
+_LOCAL_DIR = "z-image-turbo"
+
+
+# --- filesystem resolution (shared with the runner) ---------------------------------------------
+
+
+def diffusion_root() -> Path:
+    return models_dir() / "diffusion_models"
+
+
+def find_weight_file(root: Path) -> Path | None:
+    """The single diffusion weight file to load: prefer a z-image-named file, else the first one."""
+    if not root.is_dir():
+        return None
+    weights = sorted(
+        p for p in root.iterdir() if p.is_file() and p.suffix.lower() in _WEIGHT_SUFFIXES
+    )
+    named = [p for p in weights if "z" in p.name.lower() and "image" in p.name.lower()]
+    return (named or weights or [None])[0]
+
+
+def pipeline_dir(root: Path) -> Path | None:
+    """A local diffusers folder (has ``model_index.json``) that holds the whole Z-Image pipeline."""
+    if not root.is_dir():
+        return None
+    for name in _LOCAL_NAMES:
+        candidate = root / name
+        if (candidate / "model_index.json").is_file():
+            return candidate
+    # Any subfolder that looks like a diffusers pipeline also counts (e.g. a popup download).
+    for child in sorted(p for p in root.iterdir() if p.is_dir()):
+        if (child / "model_index.json").is_file():
+            return child
+    return None
+
+
+def local_component(category: str, env_var: str) -> Path | None:
+    """A local supporting-model file/dir under ``models/<category>/`` (or an env override), or None.
+    Prefers an explicit env path, then a single weight file, then a subdir (HF snapshot)."""
+    env = os.environ.get(env_var, "").strip()
+    if env:
+        path = Path(env)
+        return path if path.exists() else None
+    root = models_dir() / category
+    if not root.is_dir():
+        return None
+    files = sorted(
+        p for p in root.iterdir() if p.is_file() and p.suffix.lower() in _WEIGHT_SUFFIXES
+    )
+    if files:
+        return files[0]
+    dirs = sorted(p for p in root.iterdir() if p.is_dir())
+    return dirs[0] if dirs else None
+
+
+def resolve_diffusion(params: dict[str, object] | None = None) -> tuple[str, str] | None:
+    """Pick the Z-Image diffusion source without ever inventing a remote one.
+
+    Returns ``(mode, path)`` where ``mode`` is ``"single_file"`` (a lone transformer file — VAE and
+    text-encoder come from local files) or ``"pipeline"`` (a whole diffusers folder). Returns
+    ``None`` when nothing is present locally — reported as missing (no repo-id fallback). Priority:
+    node ``model`` param, ``INLINE_ZIMAGE_MODEL`` env, a single weight file, then a diffusers dir.
+    """
+    root = diffusion_root()
+
+    chosen = str((params or {}).get("model") or "").strip()
+    if chosen:
+        path = root / chosen
+        if path.is_file():
+            return "single_file", str(path)
+
+    env = os.environ.get("INLINE_ZIMAGE_MODEL", "").strip()
+    if env:
+        # An explicit override is trusted: a file is a single-file source, anything else a pipeline.
+        return ("single_file", env) if Path(env).is_file() else ("pipeline", env)
+
+    single = find_weight_file(root)
+    if single is not None:
+        return "single_file", str(single)
+
+    pipe = pipeline_dir(root)
+    if pipe is not None:
+        return "pipeline", str(pipe)
+
+    return None
+
+
+# --- the requirements view (the popup's data) ---------------------------------------------------
+
+
+@dataclass(frozen=True)
+class ModelComponent:
+    """One required model component, whether it's present, and how the popup would download it."""
+
+    id: str  # "diffusion" | "vae" | "text_encoder"
+    label: str
+    category: str  # models/ subfolder it belongs to
+    present: bool
+    local_path: str  # where it's expected / would land (relative to the models root)
+    repo: str  # HF repo the popup downloads from
+    subfolders: tuple[str, ...]  # repo subfolders to fetch & flatten; () = whole repo, keep layout
+
+
+def zimage_requirements(params: dict[str, object] | None = None) -> list[ModelComponent]:
+    """The three Z-Image components with live presence, for the node's model popup.
+
+    VAE and text-encoder count as present when the diffusion source is a whole-pipeline folder (it
+    already contains them) or when a local file/dir is provided under their category.
+    """
+    diffusion = resolve_diffusion(params)
+    is_pipeline = diffusion is not None and diffusion[0] == "pipeline"
+
+    vae_local = local_component("vae", "INLINE_ZIMAGE_VAE")
+    te_local = local_component("text_encoders", "INLINE_ZIMAGE_TEXT_ENCODER")
+
+    return [
+        ModelComponent(
+            id="diffusion",
+            label="Diffusion model",
+            category="diffusion_models",
+            present=diffusion is not None,
+            local_path=f"diffusion_models/{_LOCAL_DIR}",
+            repo=BASE_REPO,
+            subfolders=(),  # the whole diffusers pipeline as one folder
+        ),
+        ModelComponent(
+            id="vae",
+            label="VAE",
+            category="vae",
+            present=is_pipeline or vae_local is not None,
+            local_path=f"vae/{_LOCAL_DIR}",
+            repo=BASE_REPO,
+            subfolders=("vae",),
+        ),
+        ModelComponent(
+            id="text_encoder",
+            label="Text encoder",
+            category="text_encoders",
+            present=is_pipeline or (te_local is not None and te_local.is_dir()),
+            local_path=f"text_encoders/{_LOCAL_DIR}",
+            repo=BASE_REPO,
+            subfolders=("text_encoder", "tokenizer"),
+        ),
+    ]
+
+
+def download_target(component: ModelComponent) -> Path:
+    """Absolute local dir a component downloads into (under the models root, never the HF cache)."""
+    return models_dir() / component.local_path