Specification for one modality passed to a diffusion stage. Carries everything needed to build the initial noised latent state and run the den

Owns transformer lifecycle. Builds on each call, frees on exit. Replaces the manual ``model_ledger.transformer()`` / ``del transformer`` patte

Parameters for the multi-modal guider.

Immutable class representing state dict key operations.

Shape of the tensor representing the video pixel array. Assumes BGR channel format.

Dummy registry that does not store state dictionaries.

Adds Gaussian noise to a latent state, scaled by the denoise mask.

Single transformer call, no guidance. Passes ``None`` Modality for absent modalities.

Owns video encoder lifecycle. Builds the encoder, passes it to the user-supplied callable, then frees it.

State of latents during the diffusion denoising process. Attributes: latent: The current noisy latent tensor being denoised.

Owns text encoder + embeddings processor lifecycle. Loads Gemma, encodes prompts, frees Gemma, then loads the embeddings processor to produce

Owns video decoder lifecycle. Returns an iterator that cleans up the decoder after all chunks are consumed.

Container for decoded audio samples and metadata. Attributes: waveform: Audio waveform tensor. sampling_rate: Sampling rate (

Owns audio decoder + vocoder lifecycle.

Default scheduler for LTX-2 diffusion sampling. Generates a sigma schedule with token-count-dependent shifting and optional stretching to

r""" Norm layer adaptive layer norm single (adaLN-single). As proposed in PixArt-Alpha (see: https://arxiv.org/abs/2310.00426; Section 2.3).

Tiling parameters for a single dimension of the patchified grid. Attributes: num_tiles: Number of tiles along this dimension. over

Defines a named operation for matching and mutating PyTorch modules. Used to selectively transform modules in a model (e.g., replacing layers

Multi-modal guider with constant params per instance. For sigma-dependent params, use MultiModalGuiderFactory.build_from_sigma(sigma) to

Builder for PyTorch models residing on a single GPU. The builder is immutable: ``with_*``/``lora`` return modified copies. The ``ModelBui

Owns video encoder + spatial upsampler lifecycle.

Shape of audio in VAE latent space: (batch, channels, frames, mel_bins). mel_bins is the number of frequency bins from the mel-spectrogram en

Input data for a single modality (video or audio) in the transformer. Bundles the latent tokens, timestep embeddings, positional information,

Intervals which a single dimension of the latent space is split into. Each interval is defined by its start, end, left ramp, and right ramp. T

Tuple containing a LoRA path, strength, and SDOps for applying to the LoRA state dict.

A single perturbation specifying which attention type to skip and in which blocks.

Shape of the tensor representing video in VAE latent space. The latent representation is a 5D tensor with dimensions ordered as (batch, c

Pre-encoded media for a single validation condition.

Represents the result of a key-value operation. Contains the new key and value after the operation has been applied.

Per-pixel (per-location) RMS normalization layer. For each element along the chosen dimension, this layer normalizes the tensor by the ro

Immutable container for a PyTorch state dictionary. Contains: - sd: Dictionary of tensors (weights, buffers, etc.) - device: Device w

Tools for building video latent states.

Perturbation configurations for a batch, with utilities for generating attention masks.

Resolves guiders per-step from sigma, then delegates to shared guided logic.

Configuration holding a list of perturbations for a single sample.

N-dimensional pixel shuffle operation for upsampling tensors. Args: dims (int): Number of dimensions to apply pixel shuffle to.

Configuration for dividing each frame into spatial tiles with optional overlap. Args: tile_size_in_pixels (int): Size of each tile in pixe

Configuration for dividing a video into temporal tiles (chunks of frames) with optional overlap. Args: tile_size_in_frames (int): Number o

Conditions video generation by injecting latents at a specific latent frame index. Sets the clean latents at positions corresponding to laten

Conditions video generation on a reference video latent for IC-LoRA inference. IC-LoRAs are trained by concatenating reference (control signa

Context manager and decorator to free GPU memory before and/or after execution. Can be used as a decorator: @free_gpu_memory_context(after

Owns audio encoder lifecycle. Builds the encoder, passes it to the user-supplied callable, then frees it. Mirrors :class:`ImageConditioner` fo

Tools for building audio latent states.

Converts audio waveforms to log-mel spectrograms with optional resampling.

Pre-encoded conditioning media for one validation sample. Keyed by condition index (position in the sample's conditions list).

Fuse an aggregated LoRA delta into one weight key. Each policy supplies its own rule (see ``QuantizationPolicy.fuse_rule``); ``fuse_lora_weigh

Static guiders — handles CFG + STG + isolated modality. Context/guider can be ``None`` for absent modalities (a positive-only guider is substi

LTX model transformer implementation. This class implements the transformer blocks for the LTX model.

Tuple containing a LoRA state dict and strength for applying to the model.

Container for model inputs using the Modality-based interface.

For PixArt-Alpha. Reference: https://github.com/PixArt-alpha/PixArt-alpha/blob/0f55e922376d8b797edd44d25d0e7464b260dcab/diffusion/model/n

r""" A Resnet block. Parameters: in_channels (`int`): The number of channels in the input. out_channels (`int`, *optional*, de

Configuration for splitting video into tiles with optional overlap. Attributes: spatial_config: Configuration for splitting spatial dimens

A 3D UNet mid-block [`UNetMidBlock3D`] with multiple residual blocks. Args: in_channels (`int`): The number of input channels.

X0 model implementation. Returns fully denoised outputs based on the velocities produced by the base model. Applies scaled denoising to t

Pluggable callables consumed by :class:`Attention`.

Fixed pool of pre-allocated raw buffer slots with event-based reuse. Slots are carved from a single contiguous ``uint8`` buffer; each is ``slo

Enum for specifying the causality axis in causal convolutions.

Represents a content matching operation. Used to match a specific prefix and suffix in a state dict key.

Embeddings1DConnector applies a 1D transformer-based processing to sequential embeddings (e.g., for video, audio, or other modalities). It su

First-order Euler method for diffusion sampling. Takes a single step from the current noise level (sigma) to the next by computing veloci

Converts ``[*, C, H, W]`` float ``[0, 1]`` frames to uint8. Carries encoding metadata so ``encode_video`` can derive pixel format, color space

Pure Gemma text encoder — runs the LLM and returns raw hidden states. Prompt enhancement (generate) is also supported since the full Gemma3For

Tokenizer wrapper for Gemma models compatible with LTXV processes. This class wraps HuggingFace's `AutoTokenizer` for use with Gemma text enc

ARRI LogC3 (EI 800) HDR compression. Maps linear [0, ∞) <-> LogC3 [0, 1] via the camera log curve. The log curve allocates more precision to s

A LoRA's ``A``, ``B`` factors and its strength scalar.

Normalization layer types: GROUP (GroupNorm) or PIXEL (per-location RMS norm).

Per-channel statistics for normalizing and denormalizing the latent representation. This statics is computed over the entire dataset and stor

Per-channel statistics for normalizing and denormalizing the latent representation. This statics is computed over the entire dataset and stor

Configuration for model quantization during loading. Attributes: sd_ops: State-dict operations applied to each tensor during load.

Residual block with two convolutional layers, group normalization, and SiLU activation. Args: channels (int): Number of input and out

Loads weights and configuration metadata from safetensors model files. Unlike SafetensorsStateDictLoader, this loader can read model configur

Context for validation sampling progress tracking. Provides a unified progress display showing current video and denoising step. Display forma

Immutable builder for :class:`BlockStreamingWrapper`. Reads block weights from safetensors on demand. ``cpu_slots`` and ``gpu_slots`` control

Conditioning item that sets ``denoise_mask = 0`` outside a time range and ``1`` inside, so only the specified temporal region is regenerated.

Pluggable ops for :class:`BasicAVTransformerBlock`. Use :meth:`from_functions` to construct from enum values or partial overrides without spel