inline-core 1.2.67__tar.gz → 1.2.68__tar.gz

{inline_core-1.2.67 → inline_core-1.2.68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: inline-core
-Version: 1.2.67
+Version: 1.2.68
 Summary: The generation engine behind Inline Studio.
 License-Expression: GPL-3.0-or-later
 Requires-Python: >=3.11

{inline_core-1.2.67 → inline_core-1.2.68}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 # PyPI name; the import package is `inline_core` (src/inline_core).
 name = "inline-core"
-version = "1.2.67"
+version = "1.2.68"
 description = "The generation engine behind Inline Studio."
 readme = "README.md"
 license = "GPL-3.0-or-later"

{inline_core-1.2.67 → inline_core-1.2.68}/src/inline_core/config.py

@@ -7,12 +7,33 @@ from pathlib import Path
 
 
 def models_dir() -> Path:
-    """The models root scanned on start (category subfolders inside). `INLINE_MODELS_DIR`, else
-    `./models`. Users drop their own weight files here; nothing is downloaded."""
+    """The **writable** models root: where downloads and trained LoRAs land. `INLINE_MODELS_DIR`,
+    else `./models`. Users drop their own weight files here; nothing is downloaded."""
     env = os.environ.get("INLINE_MODELS_DIR")
     return Path(env).expanduser() if env else Path("models")
 
 
+def models_dirs() -> list[Path]:
+    """Every root scanned for installed weights, writable one first.
+
+    Pointing `INLINE_MODELS_DIR` (or `--models-dir`) somewhere else used to hide `./models`
+    entirely, so a user with weights in both places could only ever see one set. The extra roots
+    are read-only: only `models_dir()` is ever written to.
+    """
+    roots = [models_dir()]
+    default = Path("models")
+    for extra in (default, *_extra_models_dirs()):
+        if extra not in roots and extra.is_dir():
+            roots.append(extra)
+    return roots
+
+
+def _extra_models_dirs() -> list[Path]:
+    """Additional read-only roots from `INLINE_EXTRA_MODELS_DIRS` (os.pathsep-separated)."""
+    raw = os.environ.get("INLINE_EXTRA_MODELS_DIRS", "")
+    return [Path(p).expanduser() for p in raw.split(os.pathsep) if p.strip()]
+
+
 def data_dir() -> Path:
     """Engine-owned working data (the run DB, takes). `INLINE_DATA_DIR`, else `./.inline`."""
     env = os.environ.get("INLINE_DATA_DIR")

{inline_core-1.2.67 → inline_core-1.2.68}/src/inline_core/models/catalog.py

@@ -13,9 +13,11 @@ from __future__ import annotations
 
 import hashlib
 import json
+from collections.abc import Sequence
 from pathlib import Path
+from typing import Any
 
-from ..config import models_dir
+from ..config import models_dirs
 
 # 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.
@@ -29,6 +31,9 @@ CATEGORIES: tuple[str, ...] = (
     "controlnet",
     "upscale_models",
     "embeddings",
+    # Written by the preprocess runner rather than the user, but it holds real weights and the
+    # panel is meant to show everything on disk.
+    "annotators",
 )
 
 # Extensions we treat as model weights. A folder counts as a model if it contains one of these.
@@ -45,34 +50,111 @@ def _folder_has_weight(path: Path) -> bool:
     return any(_is_weight(child) for child in path.rglob("*"))
 
 
+def _file_node(path: Path) -> dict[str, Any]:
+    stat = path.stat()
+    return {
+        "name": path.name,
+        "path": str(path),
+        "kind": "file",
+        "sizeBytes": stat.st_size,
+        "mtime": int(stat.st_mtime * 1000),
+    }
+
+
+def _dir_node(path: Path, name: str) -> dict[str, Any] | None:
+    """A directory as a tree node, or None when it holds nothing worth showing."""
+    if not path.is_dir():
+        return None
+    children: list[dict[str, Any]] = []
+    try:
+        entries = sorted(path.iterdir(), key=lambda p: p.name.lower())
+    except OSError:
+        return None
+    for entry in entries:
+        # Caches like loras/.cache and text_encoders/.snap are noise in a panel about weights.
+        if entry.name.startswith("."):
+            continue
+        if _is_weight(entry):
+            children.append(_file_node(entry))
+        elif entry.is_dir():
+            child = _dir_node(entry, entry.name)
+            if child is not None:
+                children.append(child)
+    if not children:
+        return None
+    return {
+        "name": name,
+        "path": str(path),
+        "kind": "dir",
+        "children": children,
+        "fileCount": sum(1 for c in children if c["kind"] == "file"),
+    }
+
+
 class ModelCatalog:
-    """Scans the models root and answers "what's installed" per category.
+    """Scans the models roots 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.
+    are cached so ``list`` and ``fingerprint`` are hits between scans. Several roots may be scanned
+    (see ``config.models_dirs``); only the first is ever written to.
     """
 
-    def __init__(self, root: Path) -> None:
-        self._root = Path(root)
+    def __init__(self, root: Path | Sequence[Path]) -> None:
+        roots = [Path(root)] if isinstance(root, str | Path) else [Path(r) for r in root]
+        self._roots = roots or [Path("models")]
         self._entries: dict[str, list[str]] = {category: [] for category in CATEGORIES}
 
     @property
     def root(self) -> Path:
-        return self._root
+        """The writable root. Downloads and trained LoRAs land here."""
+        return self._roots[0]
+
+    @property
+    def roots(self) -> list[Path]:
+        return list(self._roots)
 
     def ensure_dirs(self) -> None:
-        """Create the root and every category subfolder, so users have somewhere to drop weights."""
+        """Create the writable root and its category subfolders, so drop-in has somewhere to go."""
         for category in CATEGORIES:
-            (self._root / category).mkdir(parents=True, exist_ok=True)
+            (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."""
+        """Re-read every category from every root, cache the result, and return it."""
         entries: dict[str, list[str]] = {}
         for category in CATEGORIES:
-            entries[category] = self._scan_category(self._root / category)
+            names: list[str] = []
+            for root in self._roots:
+                for name in self._scan_category(root / category):
+                    if name not in names:
+                        names.append(name)
+            entries[category] = sorted(names)
         self._entries = entries
         return entries
 
+    def tree(self) -> list[dict[str, Any]]:
+        """Every root as a nested, read-only listing for the Models panel.
+
+        Separate from ``rescan`` because the select only needs flat names, while the panel wants
+        nesting, sizes and mtimes; keeping them apart stops the hot path paying for the detail.
+        """
+        out: list[dict[str, Any]] = []
+        for index, root in enumerate(self._roots):
+            categories = [
+                node
+                for category in CATEGORIES
+                if (node := _dir_node(root / category, category)) is not None
+            ]
+            out.append(
+                {
+                    "path": str(root),
+                    "label": root.name or str(root),
+                    "writable": index == 0,
+                    "exists": root.is_dir(),
+                    "categories": categories,
+                }
+            )
+        return out
+
     # 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]]:
@@ -92,6 +174,8 @@ class ModelCatalog:
             return []
         names: list[str] = []
         for entry in directory.iterdir():
+            if entry.name.startswith("."):
+                continue
             if _is_weight(entry):
                 names.append(entry.name)
             elif entry.is_dir() and _folder_has_weight(entry):
@@ -112,8 +196,11 @@ def resolve_picked(category: str, chosen: object) -> Path | None:
     name = str(chosen or "").strip()
     if not name:
         return None
-    root = models_dir() / category
-    for candidate in (root / name, root / Path(name).name, Path(name)):
-        if candidate.exists():
-            return candidate
-    return None
+    # Every root, writable one first, so a pick resolves wherever the user actually keeps it.
+    for models_root in models_dirs():
+        root = models_root / category
+        for candidate in (root / name, root / Path(name).name):
+            if candidate.exists():
+                return candidate
+    bare = Path(name)
+    return bare if bare.exists() else None

{inline_core-1.2.67 → inline_core-1.2.68}/src/inline_core/models/minimaxh3/pipeline.py

@@ -452,7 +452,7 @@ def _denoiser_name(blocks: Any) -> str:
     raise ComponentError("This MiniMax H3 blockset declares no denoiser component.")
 
 
-def render_staged(pipe: Any, device: Any, **call: Any) -> Any:
+def render_staged(pipe: Any, device: Any, cancel_check: Any = None, **call: Any) -> Any:
     """Encode the prompt, get the conditioner off the card, then denoise with the card to itself.
 
     H3's conditioner is a 32B model that rivals its denoiser, and holding both means the denoiser
@@ -463,21 +463,40 @@ def render_staged(pipe: Any, device: Any, **call: Any) -> Any:
     Falls back to the single call when the pipeline was not built staged, so a caller never has to
     ask which kind it holds.
     """
+    def check() -> None:
+        if cancel_check is not None:
+            cancel_check()
+
     phases = getattr(pipe, "_inline_phases", None)
     if phases is None:
+        check()
         return pipe(**call)
     head, tail = phases
     device = str(device)
 
-    # Every kwarg goes to BOTH halves, not just the first. `set_timesteps` lives in the tail, so a
-    # head-only handoff left it reading the descriptor default: a render that asked for 8 steps
-    # silently took 49. The halves ignore what their own blocks do not declare, so this is safe.
-    state = head(**call)
     # Parked, not released: the next render needs it again, and 19.5 GB across the bus is seconds
     # against the minutes of streaming it buys back.
     denoiser = getattr(pipe, getattr(pipe, "_inline_denoiser", "transformer"))
     resident = getattr(pipe, "_inline_resident_denoiser", True)
 
+    # Each half claims the card *before* it runs rather than the previous one restoring the layout
+    # on its way out. Same two transfers per render in the steady state, but a cancelled denoise no
+    # longer pays ~40 GB of restore traffic before the exception surfaces, which read as the cancel
+    # being ignored for half a minute. A `.to()` onto the device a module already sits on is free.
+    check()
+    if resident:
+        denoiser.to("cpu")
+    pipe.text_encoder.to(device)
+    rt.free_vram()
+
+    # Every kwarg goes to BOTH halves, not just the first. `set_timesteps` lives in the tail, so a
+    # head-only handoff left it reading the descriptor default: a render that asked for 8 steps
+    # silently took 49. The halves ignore what their own blocks do not declare, so this is safe.
+    state = head(**call)
+    # The conditioner is a 32B model, so the encode alone runs for a while with no step hook to
+    # cancel from; without this a cancel there waits for the whole denoise as well.
+    check()
+
     # Parking the conditioner is worth doing either way: it frees the card for activations even when
     # the denoiser is too big to take it. Moving the denoiser across is only right when it fits.
     pipe.text_encoder.to("cpu")
@@ -487,9 +506,6 @@ def render_staged(pipe: Any, device: Any, **call: Any) -> Any:
     try:
         return tail(state, **call)
     finally:
-        if resident:
-            denoiser.to("cpu")
-        pipe.text_encoder.to(device)
         rt.free_vram()
 
 

{inline_core-1.2.67 → inline_core-1.2.68}/src/inline_core/models/minimaxh3/runner.py

@@ -341,7 +341,12 @@ class MiniMaxH3Runner(NodeRunner):
         rt.attach_step_progress(pipe, on_step)
         started = time.perf_counter()
         try:
-            state = render_staged(pipe, self._policy.placement('denoiser').device, **call)
+            state = render_staged(
+                pipe,
+                self._policy.placement('denoiser').device,
+                cancel_check=lambda: rt.raise_if_cancelled(ctx),
+                **call,
+            )
         except CancelledError:
             rt.free_vram()
             raise

{inline_core-1.2.67 → inline_core-1.2.68}/src/inline_core/models/pipeline_runtime.py

@@ -66,6 +66,38 @@ def is_resident(policy: DevicePolicy) -> bool:
     )
 
 
+# VRAM the denoise should still have spare, with the encoder kept resident, before parking is worth
+# its two multi-GB copies. Sized for activations at a large resolution, not for the weights.
+_ENCODER_RESIDENT_HEADROOM_MB = 8 * 1024
+
+
+def module_bytes(module: Any) -> int:
+    """On-device size of a module's parameters and buffers."""
+    try:
+        params = sum(p.numel() * p.element_size() for p in module.parameters())
+        buffers = sum(b.numel() * b.element_size() for b in module.buffers())
+        return params + buffers
+    except Exception:  # noqa: BLE001 - a size estimate must never break a run
+        return 0
+
+
+def should_park_encoder(policy: DevicePolicy, text_encoder: Any) -> bool:
+    """Whether to evict the text encoder to the CPU for the denoise.
+
+    Parking buys VRAM at the cost of a GPU->CPU copy now and a CPU->GPU copy on the next run, which
+    on a large card is seconds of PCIe traffic for headroom that was never contended. So it is only
+    worth it when keeping the encoder would actually crowd the denoise.
+    """
+    if policy.profile is Profile.LOWVRAM:
+        return True
+    free_mb = policy.free_vram_mb()
+    if free_mb is None:
+        return True  # unmeasurable card: keep the conservative behaviour
+    # Measured with the encoder already on the card, so this is exactly what the denoise would get
+    # if it stayed. Parking would hand back its own size on top.
+    return free_mb < _ENCODER_RESIDENT_HEADROOM_MB
+
+
 def configure_pipeline(pipe: Any, policy: DevicePolicy) -> None:
     """Place the pipeline and enable the low-VRAM savers the policy asks for."""
     placement = policy.placement("denoiser")
@@ -340,9 +372,12 @@ def encoded_prompt_kwargs(
         text_encoder.to(device)
         with torch.no_grad():
             kwargs = encode(device)
-        # torchao's .to() round-trip on quantized weights is unreliable, so only the encoder moves.
-        text_encoder.to("cpu")
-        free_vram()
+        park = should_park_encoder(policy, text_encoder)
+        if park:
+            # torchao's .to() round-trip on quantized weights is unreliable, so only the encoder
+            # moves.
+            text_encoder.to("cpu")
+            free_vram()
     except Exception as error:  # noqa: BLE001 - an optimization must never break generation
         logger.warning(
             "Text-encoder GPU encode failed (%s); denoising with the encoder resident.", error
@@ -350,7 +385,17 @@ def encoded_prompt_kwargs(
         try_call(text_encoder.to, device)
         return fallback()
 
-    logger.info("Text encoder parked on the CPU for the denoise | host RAM %.1fGB", host_ram_gb())
+    if park:
+        logger.info(
+            "Text encoder parked on the CPU for the denoise | host RAM %.1fGB", host_ram_gb()
+        )
+    else:
+        logger.info(
+            "Text encoder kept on %s for the denoise (%.1fGB VRAM free) | host RAM %.1fGB",
+            device,
+            (policy.free_vram_mb() or 0) / 1024,
+            host_ram_gb(),
+        )
     return kwargs
 
 
@@ -634,6 +679,7 @@ __all__ = [
     "is_resident",
     "load_image",
     "lora_stack",
+    "module_bytes",
     "oom_message",
     "path_or_none",
     "peak_vram_gb",
@@ -642,6 +688,7 @@ __all__ = [
     "reset_peak_vram",
     "resolve_seed",
     "shrink_vae_tiles",
+    "should_park_encoder",
     "smaller_resolutions",
     "supports_prompt_embeds",
     "text_encoder_detached",

{inline_core-1.2.67 → inline_core-1.2.68}/src/inline_core/runtime/progress.py

@@ -43,6 +43,14 @@ class NodeDoneEvent:
     takes: list[Take] = field(default_factory=list)
 
 
+@dataclass(frozen=True)
+class RunStartedEvent:
+    """A queued run reached the worker. Without it nothing distinguishes queued from running, so a
+    client cannot tell a long model load from a run still waiting behind another."""
+
+    run_id: str
+
+
 @dataclass(frozen=True)
 class RunDoneEvent:
     run_id: str
@@ -60,7 +68,9 @@ class ErrorEvent:
     node_id: str | None = None
 
 
-RunEvent = ProgressEvent | NodeDoneEvent | RunDoneEvent | CancelledEvent | ErrorEvent
+RunEvent = (
+    ProgressEvent | NodeDoneEvent | RunStartedEvent | RunDoneEvent | CancelledEvent | ErrorEvent
+)
 
 
 class ProgressEmitter(ABC):

{inline_core-1.2.67 → inline_core-1.2.68}/src/inline_core/runtime/run.py

@@ -14,6 +14,7 @@ from .progress import (
     ProgressEvent,
     RunDoneEvent,
     RunEvent,
+    RunStartedEvent,
 )
 
 
@@ -89,6 +90,8 @@ def apply_event(state: RunState, event: RunEvent) -> None:
         known = {t.id for t in state.takes}
         state.takes.extend(t for t in event.takes if t.id not in known)
         _recompute_fraction(state)
+    elif isinstance(event, RunStartedEvent):
+        state.status = RunStatus.RUNNING
     elif isinstance(event, RunDoneEvent):
         state.status = RunStatus.DONE
         state.fraction = 1.0

{inline_core-1.2.67 → inline_core-1.2.68}/src/inline_core/server/app.py

@@ -19,7 +19,7 @@ from fastapi import FastAPI, Request, Response, WebSocket, WebSocketDisconnect
 from fastapi.responses import FileResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 
-from ..config import models_dir
+from ..config import models_dirs
 from ..device.memory import MemoryPolicy
 from ..device.policy import DevicePolicy
 from ..errors import GraphValidationError, UnknownNodeType
@@ -34,7 +34,7 @@ from .assets import AssetStore
 from .manager import RunConflict, RunManager
 from .rpc import EventBroadcaster, RpcRouter
 from .run_store import RunStore
-from .serialize import descriptor_json, event_json, run_json, take_json
+from .serialize import descriptor_json, event_json, run_json, run_summary_json, take_json
 
 # GET /v1/runs/<id> (the client's run-status poll) - but not /events or nested paths.
 _RUN_POLL_PATH = re.compile(r"^/v1/runs/[^/]+$")
@@ -135,17 +135,23 @@ def create_app(
     # reports no model requirements, which is what a torch-less install already showed.
     reqs = requirements if requirements is not None else RequirementsRegistry()
     assets = AssetStore(Path(asset_dir or "./.inline-assets"))
-    catalog = ModelCatalog(Path(models_root) if models_root else models_dir())
+    # An explicit models_root is that caller's whole world; otherwise scan every configured root so
+    # a custom --models-dir does not hide ./models.
+    catalog = ModelCatalog([Path(models_root)] if models_root else models_dirs())
     takes_root = Path(takes_dir or "./.inline-takes")
     manager = RunManager(registry, cache, policy, store=run_store, takes=FileTakeStore(takes_root))
     rpc = rpc or RpcRouter()
     events = events or EventBroadcaster()
     # Host/GPU telemetry for the Trainer tab; only meaningful with the SPA (studio) backend wired.
     stats = SystemStats(events) if studio_store is not None else None
+    # Assigned further down with the studio wiring; the lifespan closure reads it at startup.
+    activity_registry: Any = None
 
     @asynccontextmanager
     async def lifespan(app: FastAPI):  # noqa: ANN202
         manager.bind_loop(asyncio.get_running_loop())
+        if activity_registry is not None:
+            activity_registry.bind_loop(asyncio.get_running_loop())
         catalog.ensure_dirs()
         catalog.scan()
         if stats is not None:
@@ -199,9 +205,15 @@ def create_app(
         target = body.get("target")
         if not isinstance(target, str):
             return _error("invalid_request", "'target' is required.", 422)
+        meta = body.get("meta")
         try:
             graph = parse_graph(body.get("graph"))
-            record, created = manager.submit(graph, target, body.get("clientRunId"))
+            record, created = manager.submit(
+                graph,
+                target,
+                body.get("clientRunId"),
+                meta if isinstance(meta, dict) else None,
+            )
         except GraphValidationError as error:
             return _error("invalid_graph", str(error), 422, node_id=error.node_id)
         except RunConflict as error:
@@ -211,6 +223,15 @@ def create_app(
             status_code=201 if created else 200,
         )
 
+    @app.get("/v1/runs")
+    async def list_runs() -> Response:
+        runs = [
+            run_summary_json(r.state, manager.queue_position(r.state.run_id))
+            for r in manager.list_runs()
+            if not r.done
+        ]
+        return JSONResponse({"runs": runs})
+
     @app.get("/v1/runs/{run_id}")
     async def get_run(run_id: str) -> Response:
         record = manager.get(run_id)
@@ -300,6 +321,7 @@ def create_app(
     if studio_store is not None:
         from ..extensions.handlers import register_extension_handlers
         from ..extensions.install import Installer
+        from ..studio.activity import ActivityRegistry
         from ..studio.fal import FalGeneration
         from ..studio.generation import CoreGeneration
         from ..studio.handlers import register_studio_handlers
@@ -318,21 +340,49 @@ def create_app(
         def core_status() -> dict[str, Any]:
             return {"running": True, "url": ""}
 
+        def rescan_models() -> dict[str, Any]:
+            """Re-read the models roots and tell every client the registry moved.
+
+            The catalog caches its scan, and only a download or a finished training run refreshed
+            it - so a weight file dropped in by hand stayed invisible until Core restarted.
+            """
+            catalog.rescan()
+            version = _version(registry, catalog)
+            events.broadcast("events:modelsChanged", {"registryVersion": version})
+            return {"registryVersion": version}
+
+        # Observes the manager, so a run submitted straight to POST /v1/runs is listed and
+        # cancellable here too, not just the ones this UI started.
+        activity = ActivityRegistry(studio_store, events)
+        activity.observe(manager)
+        activity.set_canceller("core", manager.cancel)
+        core_generation = CoreGeneration(studio_store, manager, events, registry, activity)
+        fal_generation = FalGeneration(studio_store, events, activity)
+        training_service = Training(
+            studio_store, events, on_output=catalog.rescan, activity=activity
+        )
+        activity.set_canceller("fal", fal_generation.cancel_run)
+        activity.set_canceller("training", training_service.cancel)
+        activity_registry = activity
+
         register_studio_handlers(
             rpc,
             studio_store,
             core_models=core_models,
             core_status=core_status,
-            generation=CoreGeneration(studio_store, manager, events, registry),
-            fal_generation=FalGeneration(studio_store, events),
+            generation=core_generation,
+            fal_generation=fal_generation,
             timeline=Timeline(studio_store, events),
-            training=Training(studio_store, events, on_output=catalog.rescan),
+            training=training_service,
+            activity=activity,
             # Explicit model downloads write into models/; rescan so new files bump the registry.
             # The policy lets the requirements popup show a memory fit estimate before a load;
             # the requirements registry says which node types have models at all.
             model_downloads=ModelDownloads(
                 events, on_change=catalog.rescan, policy=policy, requirements=reqs
             ),
+            model_tree=catalog.tree,
+            model_rescan=rescan_models,
         )
 
         register_extension_handlers(
@@ -347,6 +397,23 @@ def create_app(
             ),
         )
 
+        @app.get("/download/snapshot/{run_id}/{step}")
+        async def download_snapshot(run_id: str, step: int) -> Response:
+            # A mid-run LoRA lives in the project's working dir, which /media does not surface and
+            # no model picker scans, so a download is the only way to get one out of the browser.
+            try:
+                root = (studio_store.folder() / "training_runs" / run_id / "snapshots").resolve()
+            except RuntimeError:
+                return Response("No project open", status_code=404)
+            target = (root / f"step-{step:06d}.safetensors").resolve()
+            if target.parent != root:  # no traversal out of the run's own folder
+                return Response("Forbidden", status_code=403)
+            if not target.is_file():
+                return Response("Not found", status_code=404)
+            return FileResponse(
+                target, filename=target.name, media_type="application/octet-stream"
+            )
+
         @app.get("/media/{media_path:path}")
         async def media(media_path: str, request: Request) -> Response:
             try: