comfy-diffusion 1.2.0__tar.gz → 1.3.0__tar.gz

{comfy_diffusion-1.2.0 → comfy_diffusion-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-diffusion
-Version: 1.2.0
+Version: 1.3.0
 Summary: ComfyUI inference engine as a standalone Python library (no server, no UI).
 Author: Alejandro Quintero
 License: GPL-3.0-only

{comfy_diffusion-1.2.0 → comfy_diffusion-1.3.0}/comfy_diffusion/audio.py

@@ -69,6 +69,17 @@ def _get_ace_step_15_latent_audio_dependencies() -> tuple[Any, Any]:
     return torch, comfy.model_management
 
 
+def _get_concat_av_latent_dependencies() -> tuple[Any, Any]:
+    """Resolve torch and comfy.nested_tensor at call time."""
+    from ._runtime import ensure_comfyui_on_path
+
+    ensure_comfyui_on_path()
+    import comfy.nested_tensor
+    import torch
+
+    return torch, comfy.nested_tensor
+
+
 def _unwrap_node_output(output: Any) -> Any:
     """Return first output for ComfyUI V3 nodes and tuple-style APIs."""
     if hasattr(output, "result"):
@@ -85,11 +96,25 @@ def ltxv_audio_vae_encode(vae: _LtxvAudioVaeEncoder, audio: Any) -> dict[str, An
 
 
 def ltxv_audio_vae_decode(vae: _LtxvAudioVaeDecoder, latent: Any) -> dict[str, Any]:
-    """Decode latent audio with an LTXV audio VAE."""
+    """Decode latent audio with an LTXV audio VAE.
+
+    Decodes on CPU to avoid VRAM contention with the video UNet/VAE.
+    """
+    import torch
+
     latent_tensor = latent["samples"] if isinstance(latent, dict) else latent
     if getattr(latent_tensor, "is_nested", False):
         latent_tensor = latent_tensor.unbind()[-1]
-    audio = vae.decode(latent_tensor).to(latent_tensor.device)
+
+    if hasattr(vae, "to"):
+        vae.to("cpu")
+    if hasattr(latent_tensor, "cpu"):
+        latent_tensor = latent_tensor.cpu()
+
+    with torch.no_grad():
+        audio = vae.decode(latent_tensor)
+    if hasattr(audio, "detach"):
+        audio = audio.detach()
     return {"waveform": audio, "sample_rate": int(vae.output_sample_rate)}
 
 
@@ -151,6 +176,48 @@ def encode_ace_step_15_audio(
     return clip.encode_from_tokens_scheduled(tokens)
 
 
+def ltxv_concat_av_latent(
+    video_latent: dict[str, Any],
+    audio_latent: dict[str, Any],
+) -> dict[str, Any]:
+    """Concatenate video and audio latents into a single NestedTensor latent for joint denoising."""
+    torch, comfy_nested_tensor = _get_concat_av_latent_dependencies()
+
+    output: dict[str, Any] = {}
+    output.update(video_latent)
+    output.update(audio_latent)
+
+    video_noise_mask = video_latent.get("noise_mask", None)
+    audio_noise_mask = audio_latent.get("noise_mask", None)
+
+    if video_noise_mask is not None or audio_noise_mask is not None:
+        if video_noise_mask is None:
+            video_noise_mask = torch.ones_like(video_latent["samples"])
+        if audio_noise_mask is None:
+            audio_noise_mask = torch.ones_like(audio_latent["samples"])
+        output["noise_mask"] = comfy_nested_tensor.NestedTensor((video_noise_mask, audio_noise_mask))
+
+    output["samples"] = comfy_nested_tensor.NestedTensor((video_latent["samples"], audio_latent["samples"]))
+    return output
+
+
+def ltxv_separate_av_latent(
+    av_latent: dict[str, Any],
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    """Separate a joint AV NestedTensor latent into individual video and audio latents."""
+    video_samples, audio_samples = av_latent["samples"].unbind()
+
+    video_latent: dict[str, Any] = {"samples": video_samples}
+    audio_latent: dict[str, Any] = {"samples": audio_samples}
+
+    if "noise_mask" in av_latent:
+        video_mask, audio_mask = av_latent["noise_mask"].unbind()
+        video_latent["noise_mask"] = video_mask
+        audio_latent["noise_mask"] = audio_mask
+
+    return video_latent, audio_latent
+
+
 def empty_ace_step_15_latent_audio(seconds: float, batch_size: int = 1) -> dict[str, Any]:
     """Create empty ACE Step 1.5 latents used as sampler noise input."""
     torch, model_management = _get_ace_step_15_latent_audio_dependencies()
@@ -165,4 +232,6 @@ __all__ = [
     "ltxv_empty_latent_audio",
     "encode_ace_step_15_audio",
     "empty_ace_step_15_latent_audio",
+    "ltxv_concat_av_latent",
+    "ltxv_separate_av_latent",
 ]

{comfy_diffusion-1.2.0 → comfy_diffusion-1.3.0}/comfy_diffusion/conditioning.py

@@ -62,6 +62,19 @@ def _get_wan_conditioning_dependencies() -> tuple[Any, Any, Any, Any]:
     return torch, comfy.model_management, comfy.utils, node_helpers
 
 
+def _get_wan_vace_dependencies() -> tuple[Any, Any, Any, Any, Any]:
+    from ._runtime import ensure_comfyui_on_path
+
+    ensure_comfyui_on_path()
+    import comfy.latent_formats
+    import comfy.model_management
+    import comfy.utils
+    import node_helpers
+    import torch
+
+    return torch, comfy.model_management, comfy.utils, node_helpers, comfy.latent_formats
+
+
 def _get_clip_vision_output_type() -> Any:
     from ._runtime import ensure_comfyui_on_path
 
@@ -290,6 +303,57 @@ def ltxv_conditioning(
     )
 
 
+def ltxv_crop_guides(
+    positive: Any,
+    negative: Any,
+    latent: dict[str, Any],
+) -> tuple[Any, Any, dict[str, Any]]:
+    """Crop keyframe guide frames from LTXV conditioning and latent before the main sampling pass.
+
+    Removes ``keyframe_idxs`` and ``guide_attention_entries`` from both conditioning
+    objects and slices the corresponding frames off the end of the latent tensor.
+    When there are no keyframe guides (``num_keyframes == 0``) the inputs are
+    returned unchanged.
+    """
+    # Extract keyframe_idxs without importing torch so the function is import-safe.
+    keyframe_idxs = None
+    for entry in positive:
+        if "keyframe_idxs" in entry[1]:
+            keyframe_idxs = entry[1]["keyframe_idxs"]
+            break
+
+    if keyframe_idxs is None:
+        return positive, negative, latent
+
+    torch, _, _, node_helpers = _get_ltxv_conditioning_dependencies()
+
+    num_keyframes: int = torch.unique(keyframe_idxs[:, 0, :, 0]).shape[0]
+
+    if num_keyframes == 0:
+        return positive, negative, latent
+
+    latent_image = latent["samples"].clone()
+    noise_mask = latent.get("noise_mask", None)
+    if noise_mask is None:
+        batch_size, _, latent_length, _, _ = latent_image.shape
+        noise_mask = torch.ones(
+            (batch_size, 1, latent_length, 1, 1),
+            dtype=torch.float32,
+            device=latent_image.device,
+        )
+    else:
+        noise_mask = noise_mask.clone()
+
+    latent_image = latent_image[:, :, :-num_keyframes]
+    noise_mask = noise_mask[:, :, :-num_keyframes]
+
+    guide_values: dict[str, Any] = {"keyframe_idxs": None, "guide_attention_entries": None}
+    positive = node_helpers.conditioning_set_values(positive, guide_values)
+    negative = node_helpers.conditioning_set_values(negative, guide_values)
+
+    return positive, negative, {"samples": latent_image, "noise_mask": noise_mask}
+
+
 def conditioning_combine(
     cond_a: Any,
     cond_b: Any | None = None,
@@ -388,6 +452,119 @@ def flux_guidance(conditioning: Any, guidance: float = 3.5) -> list[Any]:
     return output
 
 
+def wan_vace_to_video(
+    positive: Any,
+    negative: Any,
+    vae: _VaeEncoder,
+    width: int = 832,
+    height: int = 480,
+    length: int = 81,
+    batch_size: int = 1,
+    strength: float = 1.0,
+    control_video: Any | None = None,
+    control_masks: Any | None = None,
+    reference_image: Any | None = None,
+) -> tuple[Any, Any, dict[str, Any], int]:
+    """Build WAN VACE conditioning and empty latent samples.
+
+    Args:
+        positive: Positive conditioning.
+        negative: Negative conditioning.
+        vae: VAE model used to encode control frames and reference image.
+        width: Video width in pixels (multiple of 8).
+        height: Video height in pixels (multiple of 8).
+        length: Number of video frames.
+        batch_size: Latent batch size.
+        strength: VACE conditioning strength.
+        control_video: Optional control video tensor ``[T, H, W, C]`` in [0, 1].
+        control_masks: Optional mask tensor ``[T, H, W]`` or ``[T, 1, H, W]`` in [0, 1].
+        reference_image: Optional reference image tensor ``[1, H, W, C]`` in [0, 1].
+
+    Returns:
+        ``(positive, negative, latent, trim_latent)`` where ``trim_latent`` is
+        the number of latent frames prepended for the reference image (0 if none).
+    """
+    torch, model_management, comfy_utils, node_helpers, comfy_latent_formats = _get_wan_vace_dependencies()
+
+    latent_length = ((length - 1) // 4) + 1
+
+    if control_video is not None:
+        control_video = comfy_utils.common_upscale(
+            control_video[:length].movedim(-1, 1), width, height, "bilinear", "center"
+        ).movedim(1, -1)
+        if control_video.shape[0] < length:
+            control_video = torch.nn.functional.pad(
+                control_video, (0, 0, 0, 0, 0, 0, 0, length - control_video.shape[0]), value=0.5
+            )
+    else:
+        control_video = torch.ones((length, height, width, 3)) * 0.5
+
+    if reference_image is not None:
+        reference_image = comfy_utils.common_upscale(
+            reference_image[:1].movedim(-1, 1), width, height, "bilinear", "center"
+        ).movedim(1, -1)
+        ref_latent = vae.encode(reference_image[:, :, :, :3])
+        reference_image = torch.cat(
+            [ref_latent, comfy_latent_formats.Wan21().process_out(torch.zeros_like(ref_latent))], dim=1
+        )
+
+    if control_masks is None:
+        mask = torch.ones((length, height, width, 1))
+    else:
+        mask = control_masks
+        if mask.ndim == 3:
+            mask = mask.unsqueeze(1)
+        mask = comfy_utils.common_upscale(
+            mask[:length], width, height, "bilinear", "center"
+        ).movedim(1, -1)
+        if mask.shape[0] < length:
+            mask = torch.nn.functional.pad(
+                mask, (0, 0, 0, 0, 0, 0, 0, length - mask.shape[0]), value=1.0
+            )
+
+    control_video = control_video - 0.5
+    inactive = (control_video * (1 - mask)) + 0.5
+    reactive = (control_video * mask) + 0.5
+
+    inactive = vae.encode(inactive[:, :, :, :3])
+    reactive = vae.encode(reactive[:, :, :, :3])
+    control_video_latent = torch.cat((inactive, reactive), dim=1)
+    if reference_image is not None:
+        control_video_latent = torch.cat((reference_image, control_video_latent), dim=2)
+
+    vae_stride = 8
+    height_mask = height // vae_stride
+    width_mask = width // vae_stride
+    mask = mask.view(length, height_mask, vae_stride, width_mask, vae_stride)
+    mask = mask.permute(2, 4, 0, 1, 3)
+    mask = mask.reshape(vae_stride * vae_stride, length, height_mask, width_mask)
+    mask = torch.nn.functional.interpolate(
+        mask.unsqueeze(0), size=(latent_length, height_mask, width_mask), mode="nearest-exact"
+    ).squeeze(0)
+
+    trim_latent = 0
+    if reference_image is not None:
+        mask_pad = torch.zeros_like(mask[:, : reference_image.shape[2], :, :])
+        mask = torch.cat((mask_pad, mask), dim=1)
+        latent_length += reference_image.shape[2]
+        trim_latent = reference_image.shape[2]
+
+    mask = mask.unsqueeze(0)
+
+    positive = node_helpers.conditioning_set_values(
+        positive, {"vace_frames": [control_video_latent], "vace_mask": [mask], "vace_strength": [strength]}, append=True
+    )
+    negative = node_helpers.conditioning_set_values(
+        negative, {"vace_frames": [control_video_latent], "vace_mask": [mask], "vace_strength": [strength]}, append=True
+    )
+
+    latent = torch.zeros(
+        [batch_size, 16, latent_length, height // 8, width // 8],
+        device=model_management.intermediate_device(),
+    )
+    return positive, negative, {"samples": latent}, trim_latent
+
+
 __all__ = [
     "encode_prompt",
     "encode_prompt_flux",
@@ -396,6 +573,7 @@ __all__ = [
     "wan_first_last_frame_to_video",
     "ltxv_img_to_video",
     "ltxv_conditioning",
+    "ltxv_crop_guides",
     "conditioning_combine",
     "conditioning_set_mask",
     "conditioning_set_timestep_range",

{comfy_diffusion-1.2.0 → comfy_diffusion-1.3.0}/comfy_diffusion/latent.py

@@ -321,6 +321,56 @@ def latent_composite_masked(
     )
 
 
+def ltxv_empty_latent_video(
+    width: int, height: int, length: int = 97, batch_size: int = 1
+) -> dict[str, Any]:
+    """Create empty LTXV video latents compatible with the LTX-Video model."""
+    import torch
+
+    from ._runtime import ensure_comfyui_on_path
+
+    ensure_comfyui_on_path()
+    import comfy.model_management
+
+    latent = torch.zeros(
+        [batch_size, 128, ((length - 1) // 8) + 1, height // 32, width // 32],
+        device=comfy.model_management.intermediate_device(),
+    )
+    return {"samples": latent}
+
+
+def _load_latent_upscale_model() -> Any:
+    """Resolve LTXVLatentUpsampler node at call time."""
+    from ._runtime import ensure_comfyui_on_path
+
+    ensure_comfyui_on_path()
+    from comfy_extras.nodes_lt_upsampler import LTXVLatentUpsampler
+
+    return LTXVLatentUpsampler
+
+
+def _upsample_latent(samples: dict[str, Any], upscale_model: Any, vae: Any) -> dict[str, Any]:
+    """Delegate to LTXVLatentUpsampler.upsample_latent."""
+    ltxv_upsampler_type = _load_latent_upscale_model()
+    return cast(
+        dict[str, Any],
+        _unwrap_node_output(
+            ltxv_upsampler_type().upsample_latent(
+                samples=samples,
+                upscale_model=upscale_model,
+                vae=vae,
+            )
+        ),
+    )
+
+
+def ltxv_latent_upsample(
+    samples: dict[str, Any], upscale_model: Any, vae: Any
+) -> dict[str, Any]:
+    """Upsample a video latent by factor 2 in latent space using LTXVLatentUpsampler."""
+    return _upsample_latent(samples=samples, upscale_model=upscale_model, vae=vae)
+
+
 def set_latent_noise_mask(latent: dict[str, Any], mask: Any) -> dict[str, Any]:
     """Return a LATENT dict with noise mask metadata for inpainting sampling."""
     torch_tensor_type = _get_torch_tensor_type()
@@ -369,6 +419,7 @@ def inpaint_model_conditioning(
 
 __all__ = [
     "empty_latent_image",
+    "ltxv_empty_latent_video",
     "latent_from_batch",
     "latent_cut_to_batch",
     "repeat_latent_batch",
@@ -381,4 +432,5 @@ __all__ = [
     "latent_composite_masked",
     "set_latent_noise_mask",
     "inpaint_model_conditioning",
+    "ltxv_latent_upsample",
 ]

{comfy_diffusion-1.2.0 → comfy_diffusion-1.3.0}/comfy_diffusion/models.py

@@ -70,6 +70,9 @@ class ModelManager:
         folder_paths.add_model_folder_path(
             "upscale_models", str(self.models_dir / "upscale_models"), is_default=True
         )
+        folder_paths.add_model_folder_path(
+            "latent_upscale_models", str(self.models_dir / "upscale"), is_default=True
+        )
 
     def load_checkpoint(self, filename: str) -> CheckpointResult:
         """Load a checkpoint by filename from the configured checkpoints directory."""
@@ -224,7 +227,7 @@ class ModelManager:
         """Load an LTXV audio VAE checkpoint from a path or filename.
 
         If ``path`` is an absolute path to an existing file, that file is loaded.
-        Otherwise ``path`` is treated as a filename under the ``checkpoints`` folder.
+        Otherwise ``path`` is treated as a filename under the ``vae`` folder.
         """
         ensure_comfyui_on_path()
 
@@ -322,6 +325,101 @@ class ModelManager:
             embedding_directory=folder_paths.get_folder_paths("embeddings"),
         )
 
+    def load_latent_upscale_model(self, path: str | Path) -> Any:
+        """Load a LATENT_UPSCALE_MODEL from a path or filename.
+
+        If ``path`` is an absolute path to an existing file, that file is loaded.
+        Otherwise ``path`` is treated as a filename under the ``upscale`` folder
+        (registered as ``latent_upscale_models`` in folder_paths).
+
+        Returns a latent upscale model (nn.Module) compatible with
+        ``ltxv_latent_upsample()``.
+        """
+        ensure_comfyui_on_path()
+
+        import json
+
+        import folder_paths
+        from comfy import utils as comfy_utils
+
+        p = Path(path)
+        if p.is_absolute() and p.is_file():
+            model_path = str(p.resolve())
+        elif p.is_absolute():
+            raise FileNotFoundError(f"latent upscale model file not found: {p}")
+        else:
+            name = path if isinstance(path, str) else p.name
+            model_path = folder_paths.get_full_path_or_raise("latent_upscale_models", name)
+
+        sd, metadata = comfy_utils.load_torch_file(
+            model_path, safe_load=True, return_metadata=True
+        )
+
+        # Dispatch mirrors LatentUpscaleModelLoader.execute() from nodes_hunyuan.py
+        if "blocks.0.block.0.conv.weight" in sd:
+            from comfy_extras.nodes_hunyuan import HunyuanVideo15SRModel
+
+            config = {
+                "in_channels": sd["in_conv.conv.weight"].shape[1],
+                "out_channels": sd["out_conv.conv.weight"].shape[0],
+                "hidden_channels": sd["in_conv.conv.weight"].shape[0],
+                "num_blocks": len(
+                    [
+                        k
+                        for k in sd.keys()
+                        if k.startswith("blocks.") and k.endswith(".block.0.conv.weight")
+                    ]
+                ),
+                "global_residual": False,
+            }
+            model = HunyuanVideo15SRModel("720p", config)
+            model.load_sd(sd)
+        elif "up.0.block.0.conv1.conv.weight" in sd:
+            from comfy_extras.nodes_hunyuan import HunyuanVideo15SRModel
+
+            sd = {
+                key.replace("nin_shortcut", "nin_shortcut.conv", 1): value
+                for key, value in sd.items()
+            }
+            config = {
+                "z_channels": sd["conv_in.conv.weight"].shape[1],
+                "out_channels": sd["conv_out.conv.weight"].shape[0],
+                "block_out_channels": tuple(
+                    sd[f"up.{i}.block.0.conv1.conv.weight"].shape[0]
+                    for i in range(
+                        len(
+                            [
+                                k
+                                for k in sd.keys()
+                                if k.startswith("up.")
+                                and k.endswith(".block.0.conv1.conv.weight")
+                            ]
+                        )
+                    )
+                ),
+            }
+            model = HunyuanVideo15SRModel("1080p", config)
+            model.load_sd(sd)
+        elif "post_upsample_res_blocks.0.conv2.bias" in sd:
+            import torch
+
+            import comfy.model_management
+            from comfy.ldm.lightricks.latent_upsampler import LatentUpsampler
+
+            config = json.loads(metadata["config"])
+            model = LatentUpsampler.from_config(config).to(
+                dtype=comfy.model_management.vae_dtype(
+                    allowed_dtypes=[torch.bfloat16, torch.float32]
+                )
+            )
+            model.load_state_dict(sd)
+        else:
+            raise ValueError(
+                "unknown latent upscale model type: unrecognized state dict keys"
+            )
+
+        return model
+
     def load_upscale_model(self, path: str | Path) -> Any:
         """Load an upscale (super-resolution) model from a path or filename.
 
@@ -436,6 +534,7 @@ def model_sampling_aura_flow(model: Any, shift: float) -> Any:
 __all__ = [
     "CheckpointResult",
     "ModelManager",
+    "load_latent_upscale_model",
     "model_sampling_aura_flow",
     "model_sampling_flux",
     "model_sampling_sd3",

{comfy_diffusion-1.2.0 → comfy_diffusion-1.3.0}/comfy_diffusion/sampling.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import math
+import re
 from typing import Any
 
 
@@ -316,6 +317,19 @@ def get_sampler(sampler_name: str) -> Any:
     return _unwrap_node_output(ksampler_select_type.execute(sampler_name))
 
 
+def manual_sigmas(sigmas: str) -> Any:
+    """Parse a string of numeric values into a ``torch.FloatTensor`` of sigmas.
+
+    Extracts all numeric tokens (including negative and decimal values) from
+    *sigmas* using a regular expression and returns them as a float tensor
+    suitable for passing directly to ``sample_custom()``.
+    """
+    import torch
+
+    values = [float(m) for m in re.findall(r"-?\d+(?:\.\d+)?", sigmas)]
+    return torch.FloatTensor(values)
+
+
 def sample(
     model: Any,
     positive: Any,
@@ -435,4 +449,5 @@ __all__ = [
     "split_sigmas",
     "split_sigmas_denoise",
     "get_sampler",
+    "manual_sigmas",
 ]

{comfy_diffusion-1.2.0 → comfy_diffusion-1.3.0}/comfy_diffusion/vae.py

@@ -221,30 +221,40 @@ def vae_decode_batch_tiled(
         samples = samples.unbind()[0]
 
     sample_dims = len(samples.shape)
-    was_5d = sample_dims == 5
-    if sample_dims == 5:
-        samples = samples.reshape(-1, samples.shape[-3], samples.shape[-2], samples.shape[-1])
-    elif sample_dims != 4:
+    if sample_dims not in (4, 5):
         raise ValueError("latent samples must be 4D or 5D")
 
     if samples.shape[0] == 0:
         raise ValueError("latent samples must not be empty")
 
+    if sample_dims == 5:
+        samples = samples.reshape(-1, samples.shape[-3], samples.shape[-2], samples.shape[-1])
+        sample_dims = 4
+
     result: list[Image.Image] = []
     for index in range(samples.shape[0]):
         frame_samples = samples[index : index + 1]
-        # Video VAEs in ComfyUI (e.g. Wan) expect 5D in memory_used_decode;
-        # passing 4D causes IndexError. Pass (1, C, 1, H, W) so decode_tiled
-        # receives 5D and can estimate memory and run decode_tiled_3d.
-        if was_5d and hasattr(frame_samples, "unsqueeze"):
+        # 4D latents need a temporal dim for video VAEs (e.g. Wan) that call
+        # decode_tiled_3d internally; 5D latents are passed as-is.
+        if sample_dims == 4 and hasattr(frame_samples, "unsqueeze"):
             # frame_samples: (1, C, H, W) -> (1, C, 1, H, W)
             frame_samples = frame_samples.unsqueeze(2)
-        images = vae.decode_tiled(
-            frame_samples,
-            tile_x=tile_size,
-            tile_y=tile_size,
-            overlap=overlap,
-        )
+        # process_output uses in-place ops that fail on inference tensors produced
+        # by the VAE decoder. Patch the instance attribute temporarily to use
+        # non-in-place equivalents without modifying vendor code.
+        _orig_process_output = getattr(vae, "process_output", None)
+        if _orig_process_output is not None:
+            vae.process_output = lambda image: (image + 1.0).div_(2.0).clamp_(0.0, 1.0)
+        try:
+            images = vae.decode_tiled(
+                frame_samples,
+                tile_x=tile_size,
+                tile_y=tile_size,
+                overlap=overlap,
+            )
+        finally:
+            if _orig_process_output is not None:
+                vae.process_output = _orig_process_output
 
         image_dims = len(images.shape)
         if image_dims == 5:
@@ -255,12 +265,16 @@ def vae_decode_batch_tiled(
         if images.shape[0] == 0:
             raise ValueError("decoded image tensor is empty")
 
-        image = images[0]
-        if hasattr(image, "detach"):
-            image = image.detach()
-        if hasattr(image, "cpu"):
-            image = image.cpu()
-        result.append(_tensor_like_to_pil(image))
+        for frame_index in range(images.shape[0]):
+            image = images[frame_index]
+            if hasattr(image, "detach"):
+                image = image.detach()
+            if hasattr(image, "cpu"):
+                image = image.cpu()
+            result.append(_tensor_like_to_pil(image))
+
+    if not result:
+        raise ValueError("decoded image tensor is empty")
 
     return result
 

{comfy_diffusion-1.2.0 → comfy_diffusion-1.3.0}/comfy_diffusion.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-diffusion
-Version: 1.2.0
+Version: 1.3.0
 Summary: ComfyUI inference engine as a standalone Python library (no server, no UI).
 Author: Alejandro Quintero
 License: GPL-3.0-only

{comfy_diffusion-1.2.0 → comfy_diffusion-1.3.0}/comfy_diffusion.egg-info/SOURCES.txt

@@ -34,12 +34,15 @@ tests/test_esrgan_example_uses_public_api.py
 tests/test_image.py
 tests/test_latent.py
 tests/test_lora.py
+tests/test_ltxv2.py
+tests/test_ltxv2_t2sv_example.py
 tests/test_ltxv_conditioning.py
 tests/test_mask.py
 tests/test_model_manager_checkpoint_loading.py
 tests/test_model_manager_clip_loading.py
 tests/test_model_manager_clip_vision_loading.py
 tests/test_model_manager_init.py
+tests/test_model_manager_latent_upscale_model_loading.py
 tests/test_model_manager_llm_loading.py
 tests/test_model_manager_ltxav_text_encoder_loading.py
 tests/test_model_manager_ltxv_audio_vae_loading.py

{comfy_diffusion-1.2.0 → comfy_diffusion-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "comfy-diffusion"
-version = "1.2.0"
+version = "1.3.0"
 description = "ComfyUI inference engine as a standalone Python library (no server, no UI)."
 readme = "README.md"
 license = { text = "GPL-3.0-only" }