CLI entry point for retake (regenerate a time region).

Compute log-mel spectrogram and auxiliary spectral quantities. Args: y: Waveform tensor of shape (B, T). Returns:

Build the transformer, yield it, then free its memory on exit. Keyword arguments are forwarded to the underlying builder (e.g. ``video

Per-token RMSNorm normalization for V2 models. Args: encoded_text: [B, T, D, L] attention_mask: [B, T] binary mask Returns:

Pack Y and UV planes into I420 layout for pyav. I420 packs the three planes into a single 2D array of height ``H * 3 // 2`` and width ``W``.

Return params effective for the given sigma (getter; single source of truth).

Rearrange spatial dimensions into channels. Divides image into patch_size x patch_size blocks and moves pixels from each block into separate

Flattens the audio latent tensor along time. Use `get_patch_grid_bounds` to derive timestamps for each latent frame based on the conf

Patchify audio VAE latents and build RoPE positions (optional negative shift for reference).

Compute φⱼ(z) where z = -h (negative step size in log-space) φ₁(z) = (e^z - 1) / z φ₂(z) = (e^z - 1 - z) / z² φⱼ(z) = (e^z - Σₖ₌₀^(j-

Prepare tiles for VAE encoding. Args: video: Input video tensor (B, 3, F, H, W) in range [-1, 1] tiling_config: Tiling configurati

Prepare training inputs by processing video and audio modalities.

Run the preprocessing pipeline with convention-based column detection.

Print configuration as a nicely formatted table with sections.

Process videos and images to compute condition on videos. Args: input_path: Path to input video/image file or directory output_pat

Push the trained LoRA weights to HuggingFace Hub.

Quantize a model using optimum-quanto. For large models with transformer_blocks, this function quantizes block-by-block on GPU then moves

Quantize a weight tensor to ``float8_e4m3fn`` with a per-tensor scale.

Read HDR config from LoRA safetensors metadata. Returns ``None`` when the LoRA has no HDR metadata.

Read ``reference_temporal_scale_factor`` from LoRA safetensors metadata (default 1).

Return a raw slot to the free list. The *buffer* must be the exact tensor object returned by :meth:`acquire` (reuse is keyed on its id

Resample audio to the processor's target sample rate if needed.

Resize image preserving aspect ratio (filling target long side). Preserves the input dimensions order. Args: image: Input image t

Resolve a dotted attribute path like ``'model.language_model.layers'``.

Convert an attention_mask (scalar or tensor) to a (B, M) cross_mask tensor. Args: attention_mask: Scalar value applied uniformly, 1D tenso

Convert an RGB image to YUV. The image data is assumed to be in the range of ``[0, 1]``. Uses a single matrix multiply for better memory local

Convert an RGB image to YUV 4:2:0 with chroma subsampling. Chroma is subsampled by averaging 2x2 pixel blocks (chroma siting ``(128, 128)``).

Save an image tensor to a file. Args: image_tensor: Image tensor of shape [C, H, W] or [C, 1, H, W] in range [0, 1] or [0, 255].

Build a ``ModuleOps`` that overrides the attention callables on every ``Attention`` submodule of a model. Applied via ``create_meta_model`` so

Enable or disable gradient checkpointing for transformer blocks. Gradient checkpointing trades compute for memory by recomputing activations

Split a temporal axis in video frame space into overlapping tiles. Args: tile_size_frames: Tile length in frames. overlap_frames:

Start validation sampling progress tracking. Creates a task that shows current video and denoising step progress. Format: "Sampling X/

Start tracking a new video (resets step progress).

Apply a list of conditionings to a latent state. Iterates through the conditioning items and applies each one to the latent state in sequence.

Remove hooks and release all resources.

VAE-aligned temporal subsampling: keep frame 0, then every Nth frame.

Slice *modality* to the tokens covered by *tile*. Selects generated tokens belonging to the tile's spatial region and conditioning tok

Build dict suitable for torch.save -- recurses BaseModel sub-models, passes tensors/dicts through.

Map [0, 1] to [-1, 1] (VAE input convention).

Tokenize the given text and return token IDs and attention weights. Args: text (str): The input string to tokenize.

Start the training process. Args: disable_progress_bars: Disable Rich progress bars (useful for multi-process runs).

Update the training progress display. Args: loss: Current training loss lr: Current learning rate step_tim

Apply upsampling to the latent representation using the provided upsampler, with normalization and un-normalization based on the video encode

Validate and create output directory if it doesn't exist. Args: output_dir: Path to the output directory Returns: Path object

Base argument parser for video-editing pipelines (retake, extension, inpainting, sticker movement). Uses the same actions and conventions as basic

Load video from a file, and construct the video latent conforming to video output shape. Args: video_encoder: Model used to encode pixel f

Return a copy of this builder with the given LoRA fuse rule (e.g. from a quantization policy).

Return a copy of this builder with the given LoRAs to fuse at build time.

Return a copy of this builder with the given state-dict key remapping ops.

Generate video with IC-LoRA conditioning. Args: prompt: Text prompt for video generation. seed: Random seed f

Generate video with IC-LoRA conditioning and HDR output. Returns a linear HDR float tensor ``[f, h, w, c]``. Args: seed: R

Regenerate ``[start_time, end_time]`` of the source video (retake). Parameters ---------- video_path : str Path to

Build transformer -> run denoising loop -> free transformer. Returns ``(video_state | None, audio_state | None)`` with cleared conditi

Encode *prompts* through Gemma -> embeddings processor, freeing each model after use.

Build video encoder → call *fn(encoder)* → free encoder.

Upsample *latent* using video encoder + spatial upsampler, then free both.

Decode *latent* to pixel-space video chunks. Decoder freed after exhaustion.

Decode audio *latent* through VAE decoder + vocoder, then free both.

Build audio encoder → call *fn(encoder)* → free encoder.