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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: inline-core
-Version: 1.2.67
+Version: 1.2.69
 Summary: The generation engine behind Inline Studio.
 License-Expression: GPL-3.0-or-later
 Requires-Python: >=3.11
@@ -10,6 +10,7 @@ Provides-Extra: all
 Requires-Dist: accelerate>=0.30; extra == 'all'
 Requires-Dist: av>=12; extra == 'all'
 Requires-Dist: bitsandbytes>=0.43; (platform_system != 'Darwin') and extra == 'all'
+Requires-Dist: cloudpickle>=3.1; extra == 'all'
 Requires-Dist: controlnet-aux>=0.0.7; extra == 'all'
 Requires-Dist: diffusers==0.39.0; extra == 'all'
 Requires-Dist: einops>=0.7; extra == 'all'
@@ -18,6 +19,7 @@ Requires-Dist: huggingface-hub>=0.32; extra == 'all'
 Requires-Dist: imageio-ffmpeg>=0.4; extra == 'all'
 Requires-Dist: nvidia-ml-py>=12; extra == 'all'
 Requires-Dist: onnxruntime>=1.17; extra == 'all'
+Requires-Dist: openimageio>=3.0; extra == 'all'
 Requires-Dist: peft>=0.11; extra == 'all'
 Requires-Dist: pillow>=10; extra == 'all'
 Requires-Dist: psutil>=5.9; extra == 'all'
@@ -26,7 +28,8 @@ Requires-Dist: scipy>=1.11; extra == 'all'
 Requires-Dist: timm>=1.0; extra == 'all'
 Requires-Dist: torch>=2.2; extra == 'all'
 Requires-Dist: torchao>=0.14; extra == 'all'
-Requires-Dist: transformers>=4.44; extra == 'all'
+Requires-Dist: torchaudio; extra == 'all'
+Requires-Dist: transformers<5.15,>=5.8; extra == 'all'
 Requires-Dist: uvicorn[standard]>=0.29; extra == 'all'
 Provides-Extra: dev
 Requires-Dist: httpx>=0.27; extra == 'dev'
@@ -39,22 +42,25 @@ Requires-Dist: xfuser>=0.4; extra == 'parallel'
 Provides-Extra: runtime
 Requires-Dist: accelerate>=0.30; extra == 'runtime'
 Requires-Dist: av>=12; extra == 'runtime'
+Requires-Dist: cloudpickle>=3.1; extra == 'runtime'
 Requires-Dist: controlnet-aux>=0.0.7; extra == 'runtime'
 Requires-Dist: diffusers==0.39.0; extra == 'runtime'
+Requires-Dist: einops>=0.7; extra == 'runtime'
 Requires-Dist: huggingface-hub>=0.32; extra == 'runtime'
 Requires-Dist: onnxruntime>=1.17; extra == 'runtime'
+Requires-Dist: openimageio>=3.0; extra == 'runtime'
 Requires-Dist: safetensors>=0.4; extra == 'runtime'
 Requires-Dist: scipy>=1.11; extra == 'runtime'
 Requires-Dist: torch>=2.2; extra == 'runtime'
 Requires-Dist: torchao>=0.14; extra == 'runtime'
-Requires-Dist: transformers>=4.44; extra == 'runtime'
+Requires-Dist: torchaudio; extra == 'runtime'
+Requires-Dist: transformers<5.15,>=5.8; extra == 'runtime'
 Provides-Extra: server
 Requires-Dist: fastapi>=0.110; extra == 'server'
 Requires-Dist: imageio-ffmpeg>=0.4; extra == 'server'
 Requires-Dist: uvicorn[standard]>=0.29; extra == 'server'
 Provides-Extra: training
 Requires-Dist: bitsandbytes>=0.43; (platform_system != 'Darwin') and extra == 'training'
-Requires-Dist: einops>=0.7; extra == 'training'
 Requires-Dist: nvidia-ml-py>=12; extra == 'training'
 Requires-Dist: peft>=0.11; extra == 'training'
 Requires-Dist: pillow>=10; extra == 'training'
@@ -76,7 +82,7 @@ start; **Krea 2** (Krea AI), a 12.9B single-stream MMDiT released as an undistil
 its soundtrack in a single pass.
 
 Core also runs the **LoRA trainer** behind Inline Studio's Trainer canvas, so the same engine that
-generates can fine-tune Z-Image, Krea 2, FLUX.2 and MiniMax H3 on your own images without a cloud
+generates can fine-tune Z-Image, Krea 2, FLUX.2, MiniMax H3 and LTX-2.5 on your own images without a cloud
 step. Training is cheaper than generating: Krea 2 fits a 16GB card at 512px with a 4-bit base. Its
 dependencies sit behind the `training` extra. See the
 [LoRA training guide](https://inlinestudio.art/lora-training) for the measured VRAM table.

{inline_core-1.2.67 → inline_core-1.2.69}/README.md

@@ -12,7 +12,7 @@ start; **Krea 2** (Krea AI), a 12.9B single-stream MMDiT released as an undistil
 its soundtrack in a single pass.
 
 Core also runs the **LoRA trainer** behind Inline Studio's Trainer canvas, so the same engine that
-generates can fine-tune Z-Image, Krea 2, FLUX.2 and MiniMax H3 on your own images without a cloud
+generates can fine-tune Z-Image, Krea 2, FLUX.2, MiniMax H3 and LTX-2.5 on your own images without a cloud
 step. Training is cheaper than generating: Krea 2 fits a 16GB card at 512px with a 4-bit base. Its
 dependencies sit behind the `training` extra. See the
 [LoRA training guide](https://inlinestudio.art/lora-training) for the measured VRAM table.

{inline_core-1.2.67 → inline_core-1.2.69}/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.69"
 description = "The generation engine behind Inline Studio."
 readme = "README.md"
 license = "GPL-3.0-or-later"
@@ -21,9 +21,16 @@ runtime = [
   # Pinned, not floored: MiniMax H3 is vendored from an unmerged PR and imports six symbols
   # from the experimental Modular Diffusers surface, which a minor release may rename.
   "diffusers==0.39.0",
-  "transformers>=4.44",
+  # Floored at 5.8 because LTX-2.5's text encoder is Gemma 4, which does not exist below it.
+  # Capped below 5.15 because 5.15 routes config attribute access through the heterogeneity layer
+  # and raises on the global `config.head_dim` that transformers' own Gemma 4 code still reads, so
+  # the encoder cannot be built at all. Lightricks verify against 5.14.1; so do we.
+  "transformers>=5.8,<5.15",
   "accelerate>=0.30",
   "safetensors>=0.4",
+  # LTX-2.5's audio VAE and vocoder; the audio branch raises a bare ImportError without it, which
+  # would leave every LTX node advertising an audio port it cannot fill.
+  "torchaudio",
   # int8 weight-only quant for smart memory; best-effort at load, falls back if absent.
   "torchao>=0.14",
   # Backs the Beta sigma schedule (diffusers gates use_beta_sigmas on scipy).
@@ -41,6 +48,13 @@ runtime = [
   # The blocks raise a plain ImportError without it, so the node would advertise two ports it
   # cannot read. Video output goes out through ffmpeg, not this.
   "av>=12",
+  # Reached only by paths we do not call (LTX's EXR/HDR export and its multi-GPU fleet), but both
+  # are imported at module level by the vendored package roots. Two small wheels are a cheaper
+  # price than deleting files out of `models/ltx25/vendor/` and making every re-sync a merge.
+  "openimageio>=3.0",
+  "cloudpickle>=3.1",
+  # Tensor reshaping throughout LTX-2.5's vendored transformer and VAEs.
+  "einops>=0.7",
 ]
 server = [
   "fastapi>=0.110",
@@ -65,7 +79,6 @@ training = [
   "nvidia-ml-py>=12",
   # Florence-2 auto-captioner is loaded via trust_remote_code and needs these.
   "timm>=1.0",
-  "einops>=0.7",
 ]
 dev = [
   "pytest>=8",
@@ -81,12 +94,16 @@ all = [
   # runtime
   "torch>=2.2",
   "diffusers==0.39.0",
-  "transformers>=4.44",
+  # See the `runtime` extra: floored by LTX-2.5's Gemma 4 encoder, capped by transformers 5.15.
+  "transformers>=5.8,<5.15",
   "accelerate>=0.30",
   "safetensors>=0.4",
+  "torchaudio",
   "torchao>=0.14",
-  # Clip decode for MiniMax H3 LoRA training, and H3's reference node.
+  # Clip decode for MiniMax H3 and LTX-2.5 LoRA training, and H3's reference node.
   "av>=12",
+  "openimageio>=3.0",
+  "cloudpickle>=3.1",
   "scipy>=1.11",
   # 0.32 is where hf_xet became a hard dependency rather than an extra. Below it, Hugging Face
   # refuses the largest files outright ("too large to be downloaded using the regular download

{inline_core-1.2.67 → inline_core-1.2.69}/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.69/src/inline_core/models/catalog.py

@@ -0,0 +1,212 @@
+"""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 collections.abc import Sequence
+from pathlib import Path
+from typing import Any
+
+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.
+CATEGORIES: tuple[str, ...] = (
+    "diffusion_models",
+    "checkpoints",
+    "vae",
+    "text_encoders",
+    "loras",
+    "clip_vision",
+    "controlnet",
+    "upscale_models",
+    # Latent-space upsamplers, kept apart from `upscale_models` (which is pixel-space) because they
+    # are not interchangeable: LTX-2.5's two-stage pipeline upsamples between denoise stages.
+    "latent_upscale_models",
+    # Small weight patches applied to a loaded model rather than loaded as one, e.g. LTX-2.5's
+    # duration head. Mirrors the folder the split packs publish them under.
+    "model_patches",
+    "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.
+_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("*"))
+
+
+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 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. Several roots may be scanned
+    (see ``config.models_dirs``); only the first is ever written to.
+    """
+
+    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:
+        """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 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)
+
+    def rescan(self) -> dict[str, list[str]]:
+        """Re-read every category from every root, cache the result, and return it."""
+        entries: dict[str, list[str]] = {}
+        for category in CATEGORIES:
+            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]]:
+        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 entry.name.startswith("."):
+                continue
+            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)
+
+
+def resolve_picked(category: str, chosen: object) -> Path | None:
+    """A model dropdown's stored value, resolved to a file under ``category``.
+
+    The select serves bare filenames, but projects written before it did store the full relative
+    path, and joining one of those under the category doubles the prefix into a path that cannot
+    exist. So: try the value as given under the category, then its bare name there, then the value
+    as a path in its own right. Returns None when nothing matches, which callers must not stringify
+    (``str(None)`` reaching a loader reads as a corrupt file rather than a stale pick).
+    """
+    name = str(chosen or "").strip()
+    if not name:
+        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.69/src/inline_core/models/ltx25/__init__.py

@@ -0,0 +1,18 @@
+"""LTX-2.5: text, image and keyframe pairs to video with a synchronised soundtrack.
+
+The runner and its descriptors are re-exported here; `pipeline` and `vendor` are imported lazily so
+this package stays importable for the model popup on an install with no ML stack.
+"""
+
+from __future__ import annotations
+
+from .runner import DESCRIPTORS, GRID, VARIANTS, Ltx25Runner, Variant, register_ltx25
+
+__all__ = [
+    "DESCRIPTORS",
+    "GRID",
+    "VARIANTS",
+    "Ltx25Runner",
+    "Variant",
+    "register_ltx25",
+]

inline_core-1.2.69/src/inline_core/models/ltx25/lora_keys.py

@@ -0,0 +1,73 @@
+"""Write an LTX-2.5 adapter in the names and the scaling other LTX tools actually read.
+
+Two things separate what PEFT produces from what the ecosystem expects, and only one of them is a
+rename.
+
+**The prefix.** Published LTX LoRAs key every tensor as ``diffusion_model.<module>.lora_A.weight``.
+Module paths below it already match ours exactly - the published distilled LoRA targets 1660
+modules and the transformer has exactly 1660 Linears, with no mismatch - so the rename is the
+prefix and nothing else.
+
+**The scale, which is the part that bites.** PEFT trains with a scale of ``alpha / rank`` and saves
+the factors raw, expecting the loader to reapply it. Inline's loader does, from the ``.alpha``
+written beside each pair. `ltx_core`'s does **not**: ``_products_for_sd_key`` pairs ``lora_A`` with
+``lora_B`` by exact key and applies only the user's strength, ignoring alpha. Upstream never notices
+because their published adapters ship ``rank == alpha``, so the scale is 1.0.
+
+So an adapter trained at ``alpha != rank`` would load correctly here and at the wrong strength
+everywhere else - silently, because a LoRA at the wrong scale is not an error, just a worse result.
+Folding the scale into ``lora_B`` and dropping ``.alpha`` makes the file mean the same thing to
+every loader, which is what portability has to mean.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+#: Every published LTX LoRA carries it; our loader already strips it on the way back in.
+PREFIX = "diffusion_model."
+
+_DOWN = ".lora_A.weight"
+_UP = ".lora_B.weight"
+_ALPHA = ".alpha"
+
+
+def export_reference(state: dict[str, Any]) -> dict[str, Any]:
+    """PEFT's state dict as a published-convention LTX LoRA.
+
+    Takes the ``.alpha`` scalars ``trainer._save_lora`` has already written, folds ``alpha / rank``
+    into the up-projection, drops them, and prefixes what remains.
+    """
+    scales = _scales(state)
+    out: dict[str, Any] = {}
+    for key, value in state.items():
+        if key.endswith(_ALPHA):
+            continue  # folded into lora_B below; keeping it would double-apply in our own loader
+        if key.endswith(_UP):
+            scale = scales.get(key[: -len(_UP)], 1.0)
+            value = value * scale if scale != 1.0 else value
+        out[f"{PREFIX}{key}"] = value
+    return out
+
+
+def _scales(state: dict[str, Any]) -> dict[str, float]:
+    """``module -> alpha / rank``, from the alpha scalars and the rank of each down-projection.
+
+    Rank is read off ``lora_A``'s own first dimension rather than taken from the run's config, so a
+    resumed or hand-edited adapter is described by what it contains.
+    """
+    scales: dict[str, float] = {}
+    for key, alpha in state.items():
+        if not key.endswith(_ALPHA):
+            continue
+        module = key[: -len(_ALPHA)]
+        down = state.get(f"{module}{_DOWN}")
+        rank = int(getattr(down, "shape", (0,))[0]) if down is not None else 0
+        if rank:
+            scales[module] = float(alpha) / rank
+    return scales
+
+
+def is_reference(state: dict[str, Any]) -> bool:
+    """Whether a state dict is already in the published convention."""
+    return any(key.startswith(PREFIX) for key in state)