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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: inline-core
-Version: 1.2.68
+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.68 → 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.68 → 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.68"
+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.68 → inline_core-1.2.69}/src/inline_core/models/catalog.py

@@ -30,6 +30,12 @@ CATEGORIES: tuple[str, ...] = (
     "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.

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)

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

@@ -0,0 +1,201 @@
+"""Turn the device policy's verdict into LTX's own quantisation and offload vocabulary.
+
+Every other model runner lowers a `FitEstimate` through `models/offload.py` into a torchao plus
+group-offload recipe. LTX cannot: the vendored pipelines own their loading end to end and have their
+own quantisation policies and weight-streaming modes. So this module is the adapter, and it is the
+only place that knows how our ladder maps onto theirs.
+
+The decision half is pure and torch-free so it can be unit-tested with no GPU and no weights; the
+construction half is a thin lazy wrapper over the vendored builders.
+
+**LTX's streaming changes what "does not fit" means.** Group offload holds the whole model in host
+RAM, so for every other model a card too small is a refusal. LTX's ``DISK`` mode streams from the
+file through a small buffer and needs roughly 5 GB of VRAM and 5 GB of RAM whatever the checkpoint
+weighs. So the ladder here bottoms out in "slow" rather than "no", and the refusal is reserved for
+a card that cannot hold the streaming buffer at all.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+#: What LTX's streaming path needs on the card regardless of checkpoint size, from the OffloadMode
+#: documentation in the vendored `ltx_pipelines/utils/types.py`. Below this there is no plan left.
+_STREAM_VRAM_FLOOR_BYTES = 5 * 1024**3
+
+#: CPU offload pins the weights in host RAM, so it is only offered when they demonstrably fit with
+#: room for the activations and whatever else the box is doing. Otherwise DISK, which re-reads.
+_CPU_OFFLOAD_RAM_HEADROOM_BYTES = 8 * 1024**3
+
+#: fp8-cast stores linear weights at one byte per parameter and upcasts in the matmul, so a bf16
+#: checkpoint halves. It needs no hardware fp8 support: the cast is storage, not arithmetic.
+_FP8_FACTOR = 0.5
+
+#: Working room for the denoise on top of every resident weight. Video activations dwarf an image
+#: model's - a 121-frame clip carries tens of thousands of tokens through attention - so Core's
+#: 2.5 GB image-tuned headroom is not enough. Measured, not guessed: a 960x576 clip peaked at
+#: 7.71 GiB with the weights streamed, and bf16 resident left 0.6 GiB spare on a 44.39 GiB L40S and
+#: OOMed while the transformer was still streaming in.
+_ACTIVATION_RESERVE_BYTES = 8 * 1024**3
+
+#: What a streamed prompt encoder needs on the card while it runs. The encoder is 24.5 GiB resident,
+#: which is what forced the transformer to stream in the first place; streaming the encoder instead
+#: costs a buffer this size and frees the rest of the card for the model that actually denoises.
+_ENCODER_STREAM_BYTES = 5 * 1024**3
+
+QUANT_NONE = ""
+QUANT_FP8_CAST = "fp8-cast"
+QUANT_NVFP4_PREQUANT = "nvfp4-prequant"
+
+OFFLOAD_NONE = "none"
+OFFLOAD_CPU = "cpu"
+OFFLOAD_DISK = "disk"
+
+#: `DevicePolicy.vram_budget_mb` is **not** MiB. The policy stores capacity as decimal GB
+#: (`torch.cuda.mem_get_info()[1] / 1e9`) and multiplies by 1024, so an L40S reports 48811 for a
+#: card holding 44.39 GiB. Reading it as MiB overstates the card by 7.4% - and overstating is the
+#: dangerous direction, because it promises "fully resident" on a card that then has nothing left
+#: for activations. Everything else here is real bytes, so the conversion belongs in one place.
+_VRAM_MB_TO_BYTES = 1e9 / 1024
+
+
+def vram_bytes(policy: Any) -> int:
+    """The accelerator's capacity in real bytes, from the policy's decimal-GB budget."""
+    budget = policy.vram_budget_mb() if policy is not None else None
+    return int(budget * _VRAM_MB_TO_BYTES) if budget else 0
+
+
+def ram_bytes(policy: Any) -> int:
+    """Free host RAM in real bytes. Same convention as ``vram_budget_mb``."""
+    free = policy.free_ram_mb() if policy is not None else None
+    return int(free * _VRAM_MB_TO_BYTES) if free else 0
+
+
+@dataclass(frozen=True)
+class Ltx25Plan:
+    """How to load the transformer on this machine, and how to load the encoder beside it."""
+
+    quantization: str
+    offload: str
+    note: str
+    #: The prompt encoder's own offload mode. Separate from the transformer's on purpose - see
+    #: ``plan_for``. Streaming it is what lets the transformer stay resident.
+    encoder_offload: str = OFFLOAD_CPU
+
+    @property
+    def streams(self) -> bool:
+        return self.offload != OFFLOAD_NONE
+
+
+def plan_for(
+    *,
+    fit_plan: str,
+    model_bytes: int,
+    total_vram_bytes: int,
+    free_ram_bytes: int,
+    fixed_bytes: int = 0,
+    prequantised: bool = False,
+    kernels_available: bool = False,
+) -> Ltx25Plan | None:
+    """The load plan, or None when even the streaming buffer will not fit.
+
+    ``fit_plan`` is the device policy's rung (``resident``, ``int8``, ``nf4``, ``offload`` or
+    ``wont-fit``). It is advice, not an instruction: it was computed against a ladder built for
+    torchao and group offload, and the rungs mean different things here. What carries over is its
+    ordering, which is a statement about how tight this card is.
+
+    A prequantised NVFP4 checkpoint is already in its target form and is never re-quantised, which
+    is the rule `core/CLAUDE.md` states for FLUX.2's prequantised builds and applies unchanged here.
+
+    **The encoder and the transformer get different offload modes**, which is the whole point. They
+    are never both needed at once - Gemma runs, is freed, and only then does the denoise start - but
+    the pipeline holds the transformer from construction, so sizing them as one resident block made
+    a 39 GiB transformer stream on a card with room for it. Measured: the denoise itself peaked at
+    7.71 GiB. Streaming the encoder costs a 5 GiB buffer and buys back 24.5 GiB.
+    """
+    if total_vram_bytes and total_vram_bytes < _STREAM_VRAM_FLOOR_BYTES:
+        return None
+
+    # The transformer never has the card to itself: both VAEs and the spatial upscaler stay
+    # resident beside it, and the denoise needs working room on top. Sizing against the transformer
+    # alone is what promised "fully resident" on a 44 GiB L40S and then OOMed mid-load.
+    budget = max(
+        0,
+        total_vram_bytes - fixed_bytes - _ACTIVATION_RESERVE_BYTES - _ENCODER_STREAM_BYTES,
+    )
+
+    if prequantised:
+        # The file only loads through the NVFP4 path; without the kernels there is nothing to fall
+        # back to, because the weights on disk are packed nibbles rather than a readable dtype.
+        if not kernels_available:
+            return None
+        return _fit(
+            QUANT_NVFP4_PREQUANT, model_bytes, budget, free_ram_bytes,
+            "NVFP4, prequantised.",
+        )
+
+    if fit_plan == "resident" and model_bytes and budget >= model_bytes:
+        return Ltx25Plan(QUANT_NONE, OFFLOAD_NONE, "bf16, fully resident.")
+
+    return _fit(
+        QUANT_FP8_CAST, int(model_bytes * _FP8_FACTOR), budget, free_ram_bytes,
+        "fp8-cast, which halves the transformer and costs a little fidelity.",
+    )
+
+
+def _fit(quant: str, resident_bytes: int, vram: int, ram: int, note: str) -> Ltx25Plan:
+    """Whether a quantised model sits on the card, streams from RAM, or streams from disk.
+
+    ``vram`` is already net of the resident components and the activation reserve.
+    """
+    if vram and resident_bytes and vram >= resident_bytes:
+        return Ltx25Plan(quant, OFFLOAD_NONE, note)
+    if ram and resident_bytes and ram >= resident_bytes + _CPU_OFFLOAD_RAM_HEADROOM_BYTES:
+        return Ltx25Plan(quant, OFFLOAD_CPU, f"{note} Weights stream from system RAM.")
+    return Ltx25Plan(
+        quant, OFFLOAD_DISK,
+        f"{note} Weights stream from disk, which is the slowest path and re-reads every step.",
+    )
+
+
+def offload_mode(plan: Ltx25Plan) -> Any:
+    """``plan.offload`` as the vendored enum."""
+    return offload_mode_for(plan.offload)
+
+
+def offload_mode_for(mode: str) -> Any:
+    """One of our offload names as the vendored enum."""
+    from .vendor.ltx_pipelines.utils.types import OffloadMode
+
+    return {
+        OFFLOAD_NONE: OffloadMode.NONE,
+        OFFLOAD_CPU: OffloadMode.CPU,
+        OFFLOAD_DISK: OffloadMode.DISK,
+    }[mode]
+
+
+def quantization_policy(plan: Ltx25Plan, checkpoint_path: str) -> Any | None:
+    """``plan.quantization`` as a vendored ``QuantizationPolicy``, or None for bf16."""
+    if plan.quantization == QUANT_FP8_CAST:
+        from .vendor.ltx_core.quantization.fp8_cast import build_policy
+
+        return build_policy(checkpoint_path)
+    if plan.quantization == QUANT_NVFP4_PREQUANT:
+        from .vendor.ltx_core.quantization.nvfp4 import build_nvfp4_prequant_policy
+
+        return build_nvfp4_prequant_policy(checkpoint_path)
+    return None
+
+
+def kernels_available() -> bool:
+    """Whether ``ltx-kernels`` can back the NVFP4 path on this machine.
+
+    Not vendored: it compiles CUDA extensions and only builds on Blackwell toolchains, so it stays
+    an opt-in install and its absence is a normal state rather than a broken one.
+    """
+    try:
+        from ltx_kernels import nvfp4  # noqa: F401  # pyright: ignore[reportMissingImports]
+    except (ImportError, OSError):
+        return False
+    return True