Remove module level lora CACHE and a long module docstring.

.github/workflows/cla.yml

@@ -1,91 +0,0 @@
-name: CLA Assistant
-
-on:
-  issue_comment:
-    types: [created]
-  pull_request_target:
-    types: [opened, synchronize, closed]
-
-permissions:
-  actions: write
-  contents: read # 'read' is enough because signatures live in a REMOTE repo
-  pull-requests: write
-  statuses: write
-
-jobs:
-  cla-assistant:
-    runs-on: ubuntu-latest
-    steps:
-      # The CLA action normally requires every commit author in a PR to sign.
-      # We only want the PR author to sign, so we allowlist all other committers
-      # by computing them from the PR's commits and excluding the PR author.
-      - name: Build author-only allowlist
-        id: allowlist
-        if: >
-          github.event_name == 'pull_request_target' ||
-          (github.event_name == 'issue_comment' && github.event.issue.pull_request && (
-            github.event.comment.body == 'recheck' ||
-            github.event.comment.body == 'I have read and agree to the Contributor License Agreement'
-          ))
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PR_NUMBER: ${{ github.event.pull_request.number || github.event.issue.number }}
-          PR_AUTHOR: ${{ github.event.pull_request.user.login || github.event.issue.user.login }}
-          BASE_ALLOWLIST: action@github.com,actions-user,ampagent,claude,comfy-pr-bot,GitHub Action,github-actions,github-actions[bot],Glary Bot,Glary-Bot,*[bot]
-        run: |
-          others=$(gh api "repos/${{ github.repository }}/pulls/${PR_NUMBER}/commits" --paginate \
-            --jq '.[] | (.author.login // empty), (.committer.login // empty)' \
-            | sort -u | grep -vix "${PR_AUTHOR}" | paste -sd, -)
-          if [ -n "$others" ]; then
-            echo "allowlist=${BASE_ALLOWLIST},${others}" >> "$GITHUB_OUTPUT"
-          else
-            echo "allowlist=${BASE_ALLOWLIST}" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: CLA Assistant
-        # Run on PR events, on "recheck" comment, or when someone posts the exact signing phrase.
-        # IMPORTANT: this phrase must match `custom-pr-sign-comment` below.
-        if: >
-          github.event_name == 'pull_request_target' ||
-          (github.event_name == 'issue_comment' && github.event.issue.pull_request && (
-            github.event.comment.body == 'recheck' ||
-            github.event.comment.body == 'I have read and agree to the Contributor License Agreement'
-          ))
-        uses: contributor-assistant/github-action@ca4a40a7d1004f18d9960b404b97e5f30a505a08 # v2.6.1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          # PAT required to write to the centralized signatures repo.
-          PERSONAL_ACCESS_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
-        with:
-          # Where the CLA document lives (shown to contributors)
-          path-to-document: https://github.com/Comfy-Org/comfy-cla/blob/main/comfyui_icla.md
-
-          # Centralized signature storage
-          remote-organization-name: comfy-org
-          remote-repository-name: comfy-cla
-          path-to-signatures: signatures/cla.json
-          branch: main
-
-          # Only the PR author must sign: bots plus every non-author committer
-          # are allowlisted via the "Build author-only allowlist" step above.
-          # *[bot] is a catch-all for any GitHub App bot account.
-          allowlist: ${{ steps.allowlist.outputs.allowlist }}
-
-          # Custom PR comment messages
-          custom-notsigned-prcomment: |
-            🎉 Thank you for your contribution, we really appreciate it! 🎉
-
-            Like many open source projects, we require contributors to sign our [Contributor License Agreement (CLA)](https://github.com/Comfy-Org/comfy-cla/blob/main/comfyui_icla.md). A CLA makes the ownership of contributions explicit, so contributors and the project share a clear understanding of how the code can be used. By signing, you:
-
-            - Confirm that you own your contribution.
-            - Keep the right to reuse your own code.
-            - Grant us a copyright license to include and share it within our projects.
-
-            CLAs are standard practice across major open source projects including those under the Apache Software Foundation and the Linux Foundation. Ours is based on the Apache Software Foundation's CLA. Most importantly, it would enable us to relicense the project under a more permissive license in the future, giving the project and its community greater flexibility.
-
-            ✍ **To sign, please post a new comment on this PR with exactly the following text:** ✍
-
-          custom-pr-sign-comment: I have read and agree to the Contributor License Agreement
-
-          custom-allsigned-prcomment: |
-            ✅ All contributors have signed the CLA. Thank you! This PR is ready to be merged.

AGENTS.md

@@ -127,8 +127,6 @@
 - Do not add unnecessary `try`/`except` blocks. Use them for optional dependency,
   platform, or backend capability detection only when the program has a useful
   fallback. Prefer specific exception types when changing new code.
-- If a library version is pinned in `requirements.txt`, do not add code to
-  ComfyUI to handle older versions of that library.
 - Remove any workarounds for PyTorch versions that ComfyUI no longer officially
   supports. Deprecated workarounds include catching an exception and rerunning
   the same op with the input cast to float. If a workaround does not have a

CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

README.md

@@ -229,7 +229,7 @@ Python 3.14 works but some custom nodes may have issues. The free threaded varia
 
 Python 3.13 is very well supported. If you have trouble with some custom node dependencies on 3.13 you can try 3.12
 
-torch 2.5 is minimally supported but using a newer version is extremely recommended. Some features and optimizations might only work on newer versions. We generally recommend using the latest major version of pytorch with the latest cuda version unless it is less than 2 weeks old. If your pytorch is more than 6 months old, please update it.
+torch 2.4 and above is supported but some features and optimizations might only work on newer versions. We generally recommend using the latest major version of pytorch with the latest cuda version unless it is less than 2 weeks old.
 
 ### Instructions:
 

comfy/cli_args.py

@@ -225,7 +225,6 @@ parser.add_argument(
 )
 
 parser.add_argument("--user-directory", type=is_valid_directory, default=None, help="Set the ComfyUI user directory with an absolute path. Overrides --base-directory.")
-parser.add_argument("--models-directory", type=is_valid_directory, default=None, help="Set the ComfyUI models directory. Overrides the models folder in --base-directory.")
 
 parser.add_argument("--enable-compress-response-body", action="store_true", help="Enable compressing response body.")
 

comfy/latent_formats.py

@@ -779,10 +779,6 @@ class ACEAudio(LatentFormat):
     latent_channels = 8
     latent_dimensions = 2
 
-class SeedVR2(LatentFormat):
-    latent_channels = 16
-    latent_dimensions = 3
-
 class ACEAudio15(LatentFormat):
     latent_channels = 64
     latent_dimensions = 1

comfy/ldm/ace/ace_step15.py

@@ -217,7 +217,10 @@ class AceStepAttention(nn.Module):
                 cos, sin = position_embeddings
                 query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)
 
-        gqa_kwargs = {"enable_gqa": True} if self.num_heads != self.num_kv_heads else {}
+        n_rep = self.num_heads // self.num_kv_heads
+        if n_rep > 1:
+            key_states = key_states.repeat_interleave(n_rep, dim=1)
+            value_states = value_states.repeat_interleave(n_rep, dim=1)
 
         attn_bias = None
         if self.sliding_window is not None and not self.is_cross_attention:
@@ -241,7 +244,7 @@ class AceStepAttention(nn.Module):
             else:
                 attn_bias = window_bias
 
-        attn_output = optimized_attention(query_states, key_states, value_states, self.num_heads, attn_bias, skip_reshape=True, low_precision_attention=False, **gqa_kwargs)
+        attn_output = optimized_attention(query_states, key_states, value_states, self.num_heads, attn_bias, skip_reshape=True, low_precision_attention=False)
         attn_output = self.o_proj(attn_output)
 
         return attn_output

comfy/ldm/audio/dit.py

@@ -425,16 +425,19 @@ class Attention(nn.Module):
         if n == 1 and causal:
             causal = False
 
-        gqa_kwargs = {"enable_gqa": True} if h != kv_h else {}
+        if h != kv_h:
+            # Repeat interleave kv_heads to match q_heads
+            heads_per_kv_head = h // kv_h
+            k, v = map(lambda t: t.repeat_interleave(heads_per_kv_head, dim = 1), (k, v))
 
         if self.differential:
             q, q_diff = q.unbind(dim=1)
             k, k_diff = k.unbind(dim=1)
-            out      = optimized_attention(q,      k,      v, h, skip_reshape=True, low_precision_attention=False, transformer_options=transformer_options, **gqa_kwargs)
-            out_diff = optimized_attention(q_diff, k_diff, v, h, skip_reshape=True, low_precision_attention=False, transformer_options=transformer_options, **gqa_kwargs)
+            out      = optimized_attention(q,      k,      v, h, skip_reshape=True, low_precision_attention=False, transformer_options=transformer_options)
+            out_diff = optimized_attention(q_diff, k_diff, v, h, skip_reshape=True, low_precision_attention=False, transformer_options=transformer_options)
             out = out - out_diff
         else:
-            out = optimized_attention(q, k, v, h, skip_reshape=True, low_precision_attention=False, transformer_options=transformer_options, **gqa_kwargs)
+            out = optimized_attention(q, k, v, h, skip_reshape=True, low_precision_attention=False, transformer_options=transformer_options)
 
         out = self.to_out(out)
 

comfy/ldm/boogu/model.py

@@ -74,8 +74,11 @@ class BooguDoubleStreamProcessor(nn.Module):
         key = key.transpose(1, 2)
         value = value.transpose(1, 2)
 
-        gqa_kwargs = {"enable_gqa": True} if attn.kv_heads < attn.heads else {}
-        hidden_states = optimized_attention_masked(query, key, value, attn.heads, attention_mask, skip_reshape=True, transformer_options=transformer_options, **gqa_kwargs)
+        if attn.kv_heads < attn.heads:
+            key = key.repeat_interleave(attn.heads // attn.kv_heads, dim=1)
+            value = value.repeat_interleave(attn.heads // attn.kv_heads, dim=1)
+
+        hidden_states = optimized_attention_masked(query, key, value, attn.heads, attention_mask, skip_reshape=True, transformer_options=transformer_options)
 
         # Split back to instruction/image, apply per-stream output projections, recombine.
         instruct_hidden_states = self.instruct_out(hidden_states[:, :L_instruct])

comfy/ldm/modules/attention.py

@@ -1,6 +1,5 @@
 import math
 import sys
-import inspect
 
 import torch
 import torch.nn.functional as F
@@ -15,16 +14,16 @@ from .sub_quadratic_attention import efficient_dot_product_attention
 
 from comfy import model_management
 
+TORCH_HAS_GQA = model_management.torch_version_numeric >= (2, 5)
+
 if model_management.xformers_enabled():
     import xformers
     import xformers.ops
 
 SAGE_ATTENTION_IS_AVAILABLE = False
-SAGE_ATTENTION_SUPPORTS_MASK = False
 try:
     from sageattention import sageattn
     SAGE_ATTENTION_IS_AVAILABLE = True
-    SAGE_ATTENTION_SUPPORTS_MASK = "attn_mask" in inspect.signature(sageattn).parameters
 except ImportError as e:
     if model_management.sage_attention_enabled():
         if e.name == "sageattention":
@@ -90,44 +89,6 @@ def default(val, d):
         return val
     return d
 
-def _gqa_repeat_factor(query_heads, key_heads, value_heads):
-    if key_heads != value_heads:
-        raise ValueError(f"Key/value head count mismatch for GQA: {key_heads} != {value_heads}")
-    if query_heads == key_heads:
-        return 1
-    if query_heads % key_heads != 0:
-        raise ValueError(f"Query heads must be divisible by key/value heads for GQA: {query_heads} vs {key_heads}")
-    return query_heads // key_heads
-
-def _repeat_kv_for_gqa(k, v, query_heads, head_dim):
-    n_rep = _gqa_repeat_factor(query_heads, k.shape[head_dim], v.shape[head_dim])
-    if n_rep > 1:
-        k = k.repeat_interleave(n_rep, dim=head_dim)
-        v = v.repeat_interleave(n_rep, dim=head_dim)
-    return k, v
-
-def _heads_from_dim(tensor, dim_head, name):
-    inner_dim = tensor.shape[-1]
-    if inner_dim % dim_head != 0:
-        raise ValueError(f"{name} inner dimension {inner_dim} is not divisible by head dimension {dim_head}")
-    return inner_dim // dim_head
-
-def _reshape_qkv_to_heads(q, k, v, b, heads, dim_head, enable_gqa=False, expand_kv=True):
-    q = q.unsqueeze(3).reshape(b, -1, heads, dim_head)
-    if enable_gqa:
-        key_heads = _heads_from_dim(k, dim_head, "Key")
-        value_heads = _heads_from_dim(v, dim_head, "Value")
-    else:
-        key_heads = heads
-        value_heads = heads
-    k = k.unsqueeze(3).reshape(b, -1, key_heads, dim_head)
-    v = v.unsqueeze(3).reshape(b, -1, value_heads, dim_head)
-    if enable_gqa:
-        _gqa_repeat_factor(heads, key_heads, value_heads)
-        if expand_kv:
-            k, v = _repeat_kv_for_gqa(k, v, heads, -2)
-    return q, k, v
-
 
 # feedforward
 class GEGLU(nn.Module):
@@ -191,19 +152,28 @@ def attention_basic(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
         b, _, dim_head = q.shape
         dim_head //= heads
 
+    if kwargs.get("enable_gqa", False) and q.shape[-3] != k.shape[-3]:
+        n_rep = q.shape[-3] // k.shape[-3]
+        k = k.repeat_interleave(n_rep, dim=-3)
+        v = v.repeat_interleave(n_rep, dim=-3)
+
     scale = kwargs.get("scale", dim_head ** -0.5)
 
     h = heads
     if skip_reshape:
-        if kwargs.get("enable_gqa", False):
-            k, v = _repeat_kv_for_gqa(k, v, q.shape[-3], -3)
-        q, k, v = map(
+         q, k, v = map(
             lambda t: t.reshape(b * heads, -1, dim_head),
             (q, k, v),
         )
     else:
-        q, k, v = _reshape_qkv_to_heads(q, k, v, b, heads, dim_head, kwargs.get("enable_gqa", False))
-        q, k, v = map(lambda t: t.permute(0, 2, 1, 3).reshape(b * heads, -1, dim_head).contiguous(), (q, k, v))
+        q, k, v = map(
+            lambda t: t.unsqueeze(3)
+            .reshape(b, -1, heads, dim_head)
+            .permute(0, 2, 1, 3)
+            .reshape(b * heads, -1, dim_head)
+            .contiguous(),
+            (q, k, v),
+        )
 
     # force cast to fp32 to avoid overflowing
     if attn_precision == torch.float32:
@@ -261,16 +231,13 @@ def attention_sub_quad(query, key, value, heads, mask=None, attn_precision=None,
         query = query * (kwargs["scale"] * dim_head ** 0.5)
 
     if skip_reshape:
-        if kwargs.get("enable_gqa", False):
-            key, value = _repeat_kv_for_gqa(key, value, query.shape[-3], -3)
         query = query.reshape(b * heads, -1, dim_head)
         value = value.reshape(b * heads, -1, dim_head)
         key = key.reshape(b * heads, -1, dim_head).movedim(1, 2)
     else:
-        query, key, value = _reshape_qkv_to_heads(query, key, value, b, heads, dim_head, kwargs.get("enable_gqa", False))
-        query = query.permute(0, 2, 1, 3).reshape(b * heads, -1, dim_head)
-        value = value.permute(0, 2, 1, 3).reshape(b * heads, -1, dim_head)
-        key = key.permute(0, 2, 3, 1).reshape(b * heads, dim_head, -1)
+        query = query.unsqueeze(3).reshape(b, -1, heads, dim_head).permute(0, 2, 1, 3).reshape(b * heads, -1, dim_head)
+        value = value.unsqueeze(3).reshape(b, -1, heads, dim_head).permute(0, 2, 1, 3).reshape(b * heads, -1, dim_head)
+        key = key.unsqueeze(3).reshape(b, -1, heads, dim_head).permute(0, 2, 3, 1).reshape(b * heads, dim_head, -1)
 
 
     dtype = query.dtype
@@ -337,15 +304,19 @@ def attention_split(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
     scale = kwargs.get("scale", dim_head ** -0.5)
 
     if skip_reshape:
-        if kwargs.get("enable_gqa", False):
-            k, v = _repeat_kv_for_gqa(k, v, q.shape[-3], -3)
-        q, k, v = map(
+         q, k, v = map(
             lambda t: t.reshape(b * heads, -1, dim_head),
             (q, k, v),
         )
     else:
-        q, k, v = _reshape_qkv_to_heads(q, k, v, b, heads, dim_head, kwargs.get("enable_gqa", False))
-        q, k, v = map(lambda t: t.permute(0, 2, 1, 3).reshape(b * heads, -1, dim_head).contiguous(), (q, k, v))
+        q, k, v = map(
+            lambda t: t.unsqueeze(3)
+            .reshape(b, -1, heads, dim_head)
+            .permute(0, 2, 1, 3)
+            .reshape(b * heads, -1, dim_head)
+            .contiguous(),
+            (q, k, v),
+        )
 
     r1 = torch.zeros(q.shape[0], q.shape[1], v.shape[2], device=q.device, dtype=q.dtype)
 
@@ -467,7 +438,7 @@ def attention_xformers(q, k, v, heads, mask=None, attn_precision=None, skip_resh
             disabled_xformers = True
 
     if disabled_xformers:
-        return attention_pytorch(q, k, v, heads, mask, skip_reshape=skip_reshape, skip_output_reshape=skip_output_reshape, **kwargs)
+        return attention_pytorch(q, k, v, heads, mask, skip_reshape=skip_reshape, **kwargs)
 
     if skip_reshape:
         # b h k d -> b k h d
@@ -475,12 +446,13 @@ def attention_xformers(q, k, v, heads, mask=None, attn_precision=None, skip_resh
             lambda t: t.permute(0, 2, 1, 3),
             (q, k, v),
         )
-        if kwargs.get("enable_gqa", False):
-            k, v = _repeat_kv_for_gqa(k, v, q.shape[-2], -2)
     # actually do the reshaping
     else:
         dim_head //= heads
-        q, k, v = _reshape_qkv_to_heads(q, k, v, b, heads, dim_head, kwargs.get("enable_gqa", False))
+        q, k, v = map(
+            lambda t: t.reshape(b, -1, heads, dim_head),
+            (q, k, v),
+        )
 
     if mask is not None:
         # add a singleton batch dimension
@@ -502,7 +474,7 @@ def attention_xformers(q, k, v, heads, mask=None, attn_precision=None, skip_resh
         mask = mask_out[..., :mask.shape[-1]]
         mask = mask.expand(b, heads, -1, -1)
 
-    out = xformers.ops.memory_efficient_attention(q, k, v, attn_bias=mask, scale=kwargs.get("scale", None))
+    out = xformers.ops.memory_efficient_attention(q, k, v, attn_bias=mask)
 
     if skip_output_reshape:
         out = out.permute(0, 2, 1, 3)
@@ -526,8 +498,10 @@ def attention_pytorch(q, k, v, heads, mask=None, attn_precision=None, skip_resha
     else:
         b, _, dim_head = q.shape
         dim_head //= heads
-        q, k, v = _reshape_qkv_to_heads(q, k, v, b, heads, dim_head, kwargs.get("enable_gqa", False), expand_kv=False)
-        q, k, v = map(lambda t: t.transpose(1, 2), (q, k, v))
+        q, k, v = map(
+            lambda t: t.view(b, -1, heads, dim_head).transpose(1, 2),
+            (q, k, v),
+        )
 
     if mask is not None:
         # add a batch dimension if there isn't already one
@@ -537,7 +511,9 @@ def attention_pytorch(q, k, v, heads, mask=None, attn_precision=None, skip_resha
         if mask.ndim == 3:
             mask = mask.unsqueeze(1)
 
-    sdpa_keys = ("scale", "enable_gqa")
+    # Pass through extra SDPA kwargs (scale, enable_gqa) if provided
+    # enable_gqa requires PyTorch 2.5+; older versions use manual KV expansion above
+    sdpa_keys = ("scale", "enable_gqa") if TORCH_HAS_GQA else ("scale",)
     sdpa_extra = {k: v for k, v in kwargs.items() if k in sdpa_keys}
 
     if SDP_BATCH_LIMIT >= b:
@@ -565,19 +541,20 @@ def attention_pytorch(q, k, v, heads, mask=None, attn_precision=None, skip_resha
 
 @wrap_attn
 def attention_sage(q, k, v, heads, mask=None, attn_precision=None, skip_reshape=False, skip_output_reshape=False, **kwargs):
-    if kwargs.get("low_precision_attention", True) is False or (mask is not None and not SAGE_ATTENTION_SUPPORTS_MASK):
+    if kwargs.get("low_precision_attention", True) is False:
         return attention_pytorch(q, k, v, heads, mask=mask, skip_reshape=skip_reshape, skip_output_reshape=skip_output_reshape, **kwargs)
 
     exception_fallback = False
     if skip_reshape:
         b, _, _, dim_head = q.shape
         tensor_layout = "HND"
-        if kwargs.get("enable_gqa", False):
-            k, v = _repeat_kv_for_gqa(k, v, q.shape[-3], -3)
     else:
         b, _, dim_head = q.shape
         dim_head //= heads
-        q, k, v = _reshape_qkv_to_heads(q, k, v, b, heads, dim_head, kwargs.get("enable_gqa", False))
+        q, k, v = map(
+            lambda t: t.view(b, -1, heads, dim_head),
+            (q, k, v),
+        )
         tensor_layout = "NHD"
 
     if mask is not None:
@@ -588,12 +565,8 @@ def attention_sage(q, k, v, heads, mask=None, attn_precision=None, skip_reshape=
         if mask.ndim == 3:
             mask = mask.unsqueeze(1)
 
-    sage_kwargs = {"is_causal": False, "tensor_layout": tensor_layout, "sm_scale": kwargs.get("scale", None), "smooth_k": False}
-    if mask is not None:
-        sage_kwargs["attn_mask"] = mask
-
     try:
-        out = sageattn(q, k, v, **sage_kwargs)
+        out = sageattn(q, k, v, attn_mask=mask, is_causal=False, tensor_layout=tensor_layout)
     except Exception as e:
         logging.error("Error running sage attention: {}, using pytorch attention instead.".format(e))
         exception_fallback = True
@@ -643,6 +616,7 @@ def attention3_sage(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
                 skip_output_reshape=skip_output_reshape,
                 **kwargs
             )
+        q_s, k_s, v_s = q, k, v
         N = q.shape[2]
         dim_head = D
     else:
@@ -668,15 +642,11 @@ def attention3_sage(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
                 **kwargs
             )
 
-    if skip_reshape:
-        q_s = q
-        if kwargs.get("enable_gqa", False):
-            k_s, v_s = _repeat_kv_for_gqa(k, v, H, -3)
-        else:
-            k_s, v_s = k, v
-    else:
-        q_s, k_s, v_s = _reshape_qkv_to_heads(q, k, v, B, heads, dim_head, kwargs.get("enable_gqa", False))
-        q_s, k_s, v_s = map(lambda t: t.permute(0, 2, 1, 3).contiguous(), (q_s, k_s, v_s))
+    if not skip_reshape:
+        q_s, k_s, v_s = map(
+            lambda t: t.view(B, -1, heads, dim_head).permute(0, 2, 1, 3).contiguous(),
+            (q, k, v),
+        )
         B, H, L, D = q_s.shape
 
     try:
@@ -692,7 +662,7 @@ def attention3_sage(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
                 q, k, v, heads,
                 mask=mask,
                 attn_precision=attn_precision,
-                skip_reshape=skip_reshape,
+                skip_reshape=False,
                 skip_output_reshape=skip_output_reshape,
                 **kwargs
             )
@@ -711,20 +681,19 @@ def attention3_sage(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
 try:
     @torch.library.custom_op("flash_attention::flash_attn", mutates_args=())
     def flash_attn_wrapper(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor,
-                    dropout_p: float = 0.0, causal: bool = False, softmax_scale: float = -1.0) -> torch.Tensor:
-        softmax_scale_arg = None if softmax_scale == -1.0 else softmax_scale
-        return flash_attn_func(q, k, v, dropout_p=dropout_p, causal=causal, softmax_scale=softmax_scale_arg)
+                    dropout_p: float = 0.0, causal: bool = False) -> torch.Tensor:
+        return flash_attn_func(q, k, v, dropout_p=dropout_p, causal=causal)
 
 
     @flash_attn_wrapper.register_fake
-    def flash_attn_fake(q, k, v, dropout_p=0.0, causal=False, softmax_scale=-1.0):
+    def flash_attn_fake(q, k, v, dropout_p=0.0, causal=False):
         # Output shape is the same as q
         return q.new_empty(q.shape)
 except AttributeError as error:
     FLASH_ATTN_ERROR = error
 
     def flash_attn_wrapper(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor,
-                    dropout_p: float = 0.0, causal: bool = False, softmax_scale: float = -1.0) -> torch.Tensor:
+                    dropout_p: float = 0.0, causal: bool = False) -> torch.Tensor:
         assert False, f"Could not define flash_attn_wrapper: {FLASH_ATTN_ERROR}"
 
 @wrap_attn
@@ -734,8 +703,10 @@ def attention_flash(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
     else:
         b, _, dim_head = q.shape
         dim_head //= heads
-        q, k, v = _reshape_qkv_to_heads(q, k, v, b, heads, dim_head, kwargs.get("enable_gqa", False), expand_kv=False)
-        q, k, v = map(lambda t: t.transpose(1, 2), (q, k, v))
+        q, k, v = map(
+            lambda t: t.view(b, -1, heads, dim_head).transpose(1, 2),
+            (q, k, v),
+        )
 
     if mask is not None:
         # add a batch dimension if there isn't already one
@@ -754,16 +725,10 @@ def attention_flash(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
             v.transpose(1, 2),
             dropout_p=0.0,
             causal=False,
-            softmax_scale=kwargs.get("scale", -1.0),
         ).transpose(1, 2)
     except Exception as e:
         logging.warning(f"Flash Attention failed, using default SDPA: {e}")
-        sdpa_extra = {}
-        if kwargs.get("enable_gqa", False):
-            sdpa_extra["enable_gqa"] = True
-        if "scale" in kwargs:
-            sdpa_extra["scale"] = kwargs["scale"]
-        out = torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=mask, dropout_p=0.0, is_causal=False, **sdpa_extra)
+        out = torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=mask, dropout_p=0.0, is_causal=False)
     if not skip_output_reshape:
         out = (
             out.transpose(1, 2).reshape(b, -1, heads * dim_head)
@@ -1244,3 +1209,5 @@ class SpatialVideoTransformer(SpatialTransformer):
             x = self.proj_out(x)
         out = x + x_in
         return out
+
+

comfy/ldm/modules/diffusionmodules/model.py

@@ -22,7 +22,7 @@ def torch_cat_if_needed(xl, dim):
     else:
         return None
 
-def get_timestep_embedding(timesteps, embedding_dim, flip_sin_to_cos=False, downscale_freq_shift=1):
+def get_timestep_embedding(timesteps, embedding_dim):
     """
     This matches the implementation in Denoising Diffusion Probabilistic Models:
     From Fairseq.
@@ -33,13 +33,11 @@ def get_timestep_embedding(timesteps, embedding_dim, flip_sin_to_cos=False, down
     assert len(timesteps.shape) == 1
 
     half_dim = embedding_dim // 2
-    emb = math.log(10000) / (half_dim - downscale_freq_shift)
+    emb = math.log(10000) / (half_dim - 1)
     emb = torch.exp(torch.arange(half_dim, dtype=torch.float32) * -emb)
     emb = emb.to(device=timesteps.device)
     emb = timesteps.float()[:, None] * emb[None, :]
     emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1)
-    if flip_sin_to_cos:
-        emb = torch.cat([emb[:, half_dim:], emb[:, :half_dim]], dim=-1)
     if embedding_dim % 2 == 1:  # zero pad
         emb = torch.nn.functional.pad(emb, (0,1,0,0))
     return emb

comfy/ldm/omnigen/omnigen2.py

@@ -141,8 +141,11 @@ class Attention(nn.Module):
         key = key.transpose(1, 2)
         value = value.transpose(1, 2)
 
-        gqa_kwargs = {"enable_gqa": True} if self.kv_heads < self.heads else {}
-        hidden_states = optimized_attention_masked(query, key, value, self.heads, attention_mask, skip_reshape=True, transformer_options=transformer_options, **gqa_kwargs)
+        if self.kv_heads < self.heads:
+            key = key.repeat_interleave(self.heads // self.kv_heads, dim=1)
+            value = value.repeat_interleave(self.heads // self.kv_heads, dim=1)
+
+        hidden_states = optimized_attention_masked(query, key, value, self.heads, attention_mask, skip_reshape=True, transformer_options=transformer_options)
         hidden_states = self.to_out[0](hidden_states)
         return hidden_states
 

comfy/ldm/seedvr/attention.py

@@ -1,51 +0,0 @@
-import torch
-
-from comfy.ldm.modules import attention as _attention
-
-
-def _var_attention_qkv(q, k, v, heads, skip_reshape):
-    if skip_reshape:
-        return q, k, v, q.shape[-1]
-    total_tokens, embed_dim = q.shape
-    head_dim = embed_dim // heads
-    return (
-        q.view(total_tokens, heads, head_dim),
-        k.view(k.shape[0], heads, head_dim),
-        v.view(v.shape[0], heads, head_dim),
-        head_dim,
-    )
-
-
-def _var_attention_output(out, heads, head_dim, skip_output_reshape):
-    if skip_output_reshape:
-        return out
-    return out.reshape(-1, heads * head_dim)
-
-
-def var_attention_optimized_split(q, k, v, heads, cu_seqlens_q, cu_seqlens_k, *args, skip_reshape=False, skip_output_reshape=False, **kwargs):
-    q, k, v, head_dim = _var_attention_qkv(q, k, v, heads, skip_reshape)
-
-    q_split_indices = cu_seqlens_q[1:-1]
-    k_split_indices = cu_seqlens_k[1:-1]
-    if k.shape[0] != v.shape[0]:
-        raise ValueError("cu_seqlens_k does not match v token count")
-
-    q_splits = torch.tensor_split(q, q_split_indices, dim=0)
-    k_splits = torch.tensor_split(k, k_split_indices, dim=0)
-    v_splits = torch.tensor_split(v, k_split_indices, dim=0)
-    if len(q_splits) != len(k_splits) or len(q_splits) != len(v_splits):
-        raise ValueError("cu_seqlens_q and cu_seqlens_k must describe the same sequence count")
-
-    out = []
-    for q_i, k_i, v_i in zip(q_splits, k_splits, v_splits):
-        q_i = q_i.permute(1, 0, 2).unsqueeze(0)
-        k_i = k_i.permute(1, 0, 2).unsqueeze(0)
-        v_i = v_i.permute(1, 0, 2).unsqueeze(0)
-        out_i = _attention.optimized_attention(q_i, k_i, v_i, heads, skip_reshape=True, skip_output_reshape=True)
-        out.append(out_i.squeeze(0).permute(1, 0, 2))
-
-    out = torch.cat(out, dim=0)
-    return _var_attention_output(out, heads, head_dim, skip_output_reshape)
-
-
-optimized_var_attention = var_attention_optimized_split

comfy/ldm/seedvr/color_fix.py

@@ -1,301 +0,0 @@
-import torch
-import torch.nn.functional as F
-from torch import Tensor
-
-from comfy.ldm.seedvr.constants import (
-    CIELAB_DELTA,
-    CIELAB_KAPPA,
-    D65_WHITE_X,
-    D65_WHITE_Z,
-    WAVELET_DECOMP_LEVELS,
-)
-
-
-def wavelet_blur(image: Tensor, radius):
-    max_safe_radius = max(1, min(image.shape[-2:]) // 8)
-    if radius > max_safe_radius:
-        radius = max_safe_radius
-
-    num_channels = image.shape[1]
-
-    kernel_vals = [
-        [0.0625, 0.125, 0.0625],
-        [0.125,  0.25,  0.125],
-        [0.0625, 0.125, 0.0625],
-    ]
-    kernel = torch.tensor(kernel_vals, dtype=image.dtype, device=image.device)
-    kernel = kernel[None, None].repeat(num_channels, 1, 1, 1)
-
-    image = F.pad(image, (radius, radius, radius, radius), mode='replicate')
-    output = F.conv2d(image, kernel, groups=num_channels, dilation=radius)
-
-    return output
-
-def wavelet_decomposition(image: Tensor, levels: int = WAVELET_DECOMP_LEVELS):
-    high_freq = torch.zeros_like(image)
-
-    for i in range(levels):
-        radius = 2 ** i
-        low_freq = wavelet_blur(image, radius)
-        high_freq.add_(image).sub_(low_freq)
-        image = low_freq
-
-    return high_freq, low_freq
-
-def wavelet_reconstruction(content_feat: Tensor, style_feat: Tensor) -> Tensor:
-
-    if content_feat.shape != style_feat.shape:
-        if len(content_feat.shape) >= 3:
-            style_feat = F.interpolate(
-                style_feat,
-                size=content_feat.shape[-2:],
-                mode='bilinear',
-                align_corners=False
-            )
-
-    content_high_freq, content_low_freq = wavelet_decomposition(content_feat)
-    del content_low_freq
-
-    style_high_freq, style_low_freq = wavelet_decomposition(style_feat)
-    del style_high_freq
-
-    if content_high_freq.shape != style_low_freq.shape:
-        style_low_freq = F.interpolate(
-            style_low_freq,
-            size=content_high_freq.shape[-2:],
-            mode='bilinear',
-            align_corners=False
-        )
-
-    content_high_freq.add_(style_low_freq)
-
-    return content_high_freq.clamp_(-1.0, 1.0)
-
-def _histogram_matching_channel(source: Tensor, reference: Tensor) -> Tensor:
-    original_shape = source.shape
-
-    source_flat = source.flatten()
-    reference_flat = reference.flatten()
-
-    source_sorted, source_indices = torch.sort(source_flat)
-    reference_sorted, _ = torch.sort(reference_flat)
-    del reference_flat
-
-    n_source = len(source_sorted)
-    n_reference = len(reference_sorted)
-
-    if n_source == n_reference:
-        matched_sorted = reference_sorted
-    else:
-        source_quantiles = torch.linspace(0, 1, n_source, device=source.device)
-        ref_indices = (source_quantiles * (n_reference - 1)).long()
-        ref_indices.clamp_(0, n_reference - 1)
-        matched_sorted = reference_sorted[ref_indices]
-        del source_quantiles, ref_indices, reference_sorted
-
-    del source_sorted, source_flat
-
-    inverse_indices = torch.argsort(source_indices)
-    del source_indices
-    matched_flat = matched_sorted[inverse_indices]
-    del matched_sorted, inverse_indices
-
-    return matched_flat.reshape(original_shape)
-
-def _lab_to_rgb_batch(lab: Tensor, matrix_inv: Tensor, epsilon: float, kappa: float) -> Tensor:
-    L, a, b = lab[:, 0], lab[:, 1], lab[:, 2]
-
-    fy = (L + 16.0) / 116.0
-    fx = a.div(500.0).add_(fy)
-    fz = fy - b / 200.0
-    del L, a, b
-
-    x = torch.where(
-        fx > epsilon,
-        torch.pow(fx, 3.0),
-        fx.mul(116.0).sub_(16.0).div_(kappa)
-    )
-    y = torch.where(
-        fy > epsilon,
-        torch.pow(fy, 3.0),
-        fy.mul(116.0).sub_(16.0).div_(kappa)
-    )
-    z = torch.where(
-        fz > epsilon,
-        torch.pow(fz, 3.0),
-        fz.mul(116.0).sub_(16.0).div_(kappa)
-    )
-    del fx, fy, fz
-
-    x.mul_(D65_WHITE_X)
-    z.mul_(D65_WHITE_Z)
-
-    xyz = torch.stack([x, y, z], dim=1)
-    del x, y, z
-
-    B, _, H, W = xyz.shape
-    xyz_flat = xyz.permute(0, 2, 3, 1).reshape(-1, 3)
-    del xyz
-
-    xyz_flat = xyz_flat.to(dtype=matrix_inv.dtype)
-    rgb_linear_flat = torch.matmul(xyz_flat, matrix_inv.T)
-    del xyz_flat
-
-    rgb_linear = rgb_linear_flat.reshape(B, H, W, 3).permute(0, 3, 1, 2)
-    del rgb_linear_flat
-
-    mask = rgb_linear > 0.0031308
-    rgb = torch.where(
-        mask,
-        torch.pow(torch.clamp(rgb_linear, min=0.0), 1.0 / 2.4).mul_(1.055).sub_(0.055),
-        rgb_linear * 12.92
-    )
-    del mask, rgb_linear
-
-    return torch.clamp(rgb, 0.0, 1.0)
-
-def _rgb_to_lab_batch(rgb: Tensor, matrix: Tensor, epsilon: float, kappa: float) -> Tensor:
-    mask = rgb > 0.04045
-    rgb_linear = torch.where(
-        mask,
-        torch.pow((rgb + 0.055) / 1.055, 2.4),
-        rgb / 12.92
-    )
-    del mask
-
-    B, _, H, W = rgb_linear.shape
-    rgb_flat = rgb_linear.permute(0, 2, 3, 1).reshape(-1, 3)
-    del rgb_linear
-
-    rgb_flat = rgb_flat.to(dtype=matrix.dtype)
-    xyz_flat = torch.matmul(rgb_flat, matrix.T)
-    del rgb_flat
-
-    xyz = xyz_flat.reshape(B, H, W, 3).permute(0, 3, 1, 2)
-    del xyz_flat
-
-    xyz[:, 0].div_(D65_WHITE_X)
-    xyz[:, 2].div_(D65_WHITE_Z)
-
-    epsilon_cubed = epsilon ** 3
-    mask = xyz > epsilon_cubed
-    f_xyz = torch.where(
-        mask,
-        torch.pow(xyz, 1.0 / 3.0),
-        xyz.mul(kappa).add_(16.0).div_(116.0)
-    )
-    del xyz, mask
-
-    L = f_xyz[:, 1].mul(116.0).sub_(16.0)
-    a = (f_xyz[:, 0] - f_xyz[:, 1]).mul_(500.0)
-    b = (f_xyz[:, 1] - f_xyz[:, 2]).mul_(200.0)
-    del f_xyz
-
-    return torch.stack([L, a, b], dim=1)
-
-def lab_color_transfer(
-    content_feat: Tensor,
-    style_feat: Tensor,
-    luminance_weight: float = 0.8
-) -> Tensor:
-    content_feat = wavelet_reconstruction(content_feat, style_feat)
-
-    if content_feat.shape != style_feat.shape:
-        style_feat = F.interpolate(
-            style_feat,
-            size=content_feat.shape[-2:],
-            mode='bilinear',
-            align_corners=False
-        )
-
-    device = content_feat.device
-    original_dtype = content_feat.dtype
-    content_feat = content_feat.float()
-    style_feat = style_feat.float()
-
-    rgb_to_xyz_matrix = torch.tensor([
-        [0.4124564, 0.3575761, 0.1804375],
-        [0.2126729, 0.7151522, 0.0721750],
-        [0.0193339, 0.1191920, 0.9503041]
-    ], dtype=torch.float32, device=device)
-
-    xyz_to_rgb_matrix = torch.tensor([
-        [ 3.2404542, -1.5371385, -0.4985314],
-        [-0.9692660,  1.8760108,  0.0415560],
-        [ 0.0556434, -0.2040259,  1.0572252]
-    ], dtype=torch.float32, device=device)
-
-    epsilon = CIELAB_DELTA
-    kappa = CIELAB_KAPPA
-
-    content_feat.add_(1.0).mul_(0.5).clamp_(0.0, 1.0)
-    style_feat.add_(1.0).mul_(0.5).clamp_(0.0, 1.0)
-
-    content_lab = _rgb_to_lab_batch(content_feat, rgb_to_xyz_matrix, epsilon, kappa)
-    del content_feat
-
-    style_lab = _rgb_to_lab_batch(style_feat, rgb_to_xyz_matrix, epsilon, kappa)
-    del style_feat, rgb_to_xyz_matrix
-
-    matched_a = _histogram_matching_channel(content_lab[:, 1], style_lab[:, 1])
-    matched_b = _histogram_matching_channel(content_lab[:, 2], style_lab[:, 2])
-
-    if luminance_weight < 1.0:
-        matched_L = _histogram_matching_channel(content_lab[:, 0], style_lab[:, 0])
-        result_L = content_lab[:, 0].mul(luminance_weight).add_(matched_L.mul(1.0 - luminance_weight))
-        del matched_L
-    else:
-        result_L = content_lab[:, 0]
-
-    del content_lab, style_lab
-
-    result_lab = torch.stack([result_L, matched_a, matched_b], dim=1)
-    del result_L, matched_a, matched_b
-
-    result_rgb = _lab_to_rgb_batch(result_lab, xyz_to_rgb_matrix, epsilon, kappa)
-    del result_lab, xyz_to_rgb_matrix
-
-    result = result_rgb.mul_(2.0).sub_(1.0)
-    del result_rgb
-
-    result = result.to(original_dtype)
-
-    return result
-
-
-def wavelet_color_transfer(content_feat: Tensor, style_feat: Tensor) -> Tensor:
-    return wavelet_reconstruction(content_feat, style_feat)
-
-
-def adain_color_transfer(content_feat: Tensor, style_feat: Tensor, eps: float = 1e-5) -> Tensor:
-    if content_feat.shape != style_feat.shape:
-        style_feat = F.interpolate(
-            style_feat,
-            size=content_feat.shape[-2:],
-            mode='bilinear',
-            align_corners=False,
-        )
-
-    original_dtype = content_feat.dtype
-    content_feat = content_feat.float()
-    style_feat = style_feat.float()
-
-    b, c = content_feat.shape[:2]
-    content_flat = content_feat.reshape(b, c, -1)
-    style_flat = style_feat.reshape(b, c, -1)
-
-    content_mean = content_flat.mean(dim=2).reshape(b, c, 1, 1)
-    content_std = (content_flat.var(dim=2, correction=0) + eps).sqrt().reshape(b, c, 1, 1)
-    style_mean = style_flat.mean(dim=2).reshape(b, c, 1, 1)
-    style_std = (style_flat.var(dim=2, correction=0) + eps).sqrt().reshape(b, c, 1, 1)
-    del content_flat, style_flat
-
-    normalized = (content_feat - content_mean) / content_std
-    del content_mean, content_std
-    result = normalized * style_std + style_mean
-    del normalized, style_mean, style_std
-
-    result = result.clamp_(-1.0, 1.0)
-    if result.dtype != original_dtype:
-        result = result.to(original_dtype)
-    return result

comfy/ldm/seedvr/constants.py

@@ -1,48 +0,0 @@
-"""SeedVR2 constants."""
-
-# Temporal chunk-size law: the sampler's activation wall is linear in
-# T_latent * pixel area (17-cell resolution sweep + T bisection, RTX 5090, 3b fp16):
-#   max_latent_frames = (free_GiB - RESERVED - K*SIGMA) / (GIB_PER_MPX_FRAME * megapixels)
-# RESERVED covers model staging plus fixed CUDA/torch overhead; SIGMA is the measured
-# run-to-run spread of the wall; K=4 trades ~10% smaller chunks for ~1e-5 OOM odds.
-SEEDVR2_CHUNK_GIB_PER_MPX_FRAME = 0.55
-SEEDVR2_CHUNK_RESERVED_GIB = 8.5
-SEEDVR2_CHUNK_SIGMA_GIB = 0.55
-SEEDVR2_CHUNK_SIGMA_K = 4
-
-SEEDVR2_7B_VID_DIM = 3072
-SEEDVR2_OOM_BACKOFF_DIVISOR = 2
-SEEDVR2_DTYPE_BYTES_FLOOR = 4
-SEEDVR2_7B_MLP_CHUNK = 8192
-SEEDVR2_ROPE_PARTIAL_CHUNK_TOKENS = 4096  # partial-RoPE application token-chunk.
-SEEDVR2_LATENT_CHANNELS = 16
-
-SEEDVR2_COLOR_MEM_HEADROOM = 0.75
-SEEDVR2_LAB_SCALE_MULTIPLIER = 13
-SEEDVR2_WAVELET_SCALE_MULTIPLIER = 10  # per-frame byte multiplier, wavelet path.
-SEEDVR2_ADAIN_SCALE_MULTIPLIER = 6
-
-BYTEDANCE_VAE_SCALING_FACTOR = 0.9152   # configs_3b/main.yaml:57.
-BYTEDANCE_VAE_SHIFTING_FACTOR = 0.0
-BYTEDANCE_VAE_CONV_MEM_GIB = 0.5
-BYTEDANCE_VAE_NORM_MEM_GIB = 0.5
-BYTEDANCE_LOGVAR_CLAMP_MIN = -30.0      # video_vae_v3/modules/types.py:28.
-BYTEDANCE_LOGVAR_CLAMP_MAX = 20.0       # video_vae_v3/modules/types.py:28.
-BYTEDANCE_GN_CHUNKS_FP16 = 4            # causal_inflation_lib.py:351 (GroupNorm chunk count, fp16).
-BYTEDANCE_GN_CHUNKS_FP32 = 2            # causal_inflation_lib.py:351 (GroupNorm chunk count, fp32).
-BYTEDANCE_BLOCK_OUT_CHANNELS = (128, 256, 512, 512)  # s8_c16_t4_inflation_sd3.yaml:7-11.
-BYTEDANCE_SLICING_SAMPLE_MIN = 4        # s8_c16_t4_inflation_sd3.yaml:22 (slicing_sample_min_size).
-BYTEDANCE_VAE_TEMPORAL_DOWNSAMPLE = 4   # infer.py:230 (temporal_downsample_factor); the 4n+1 factor.
-BYTEDANCE_VAE_SPATIAL_DOWNSAMPLE = 8    # infer.py:231 (spatial_downsample_factor).
-BYTEDANCE_720P_REF_AREA = 45 * 80       # dit_v2/window.py:32 (720p reference area for window scaling).
-BYTEDANCE_MAX_TEMPORAL_WINDOW = 30      # dit_v2/window.py:35 (max temporal window frames).
-BYTEDANCE_ROPE_MAX_FREQ = 256           # dit_v2/rope.py:31 (pixel-RoPE max frequency).
-BYTEDANCE_SINUSOIDAL_DIM = 256          # dit_3b/nadit.py:120 (timestep sinusoidal embed dim).
-
-ROPE_THETA = 10000   # RoPE base; Su et al., "RoFormer", arXiv:2104.09864.
-
-CIELAB_DELTA = 6.0 / 29.0          # CIE 15 (delta).
-CIELAB_KAPPA = (29.0 / 3.0) ** 3   # CIE 15 (kappa).
-D65_WHITE_X = 0.95047              # CIE D65 standard illuminant Xn (Yn = 1).
-D65_WHITE_Z = 1.08883              # CIE D65 standard illuminant Zn.
-WAVELET_DECOMP_LEVELS = 5          # wavelet color-fix decomposition depth (GIMP/Krita; StableSR).

comfy/model_base.py

@@ -55,7 +55,6 @@ import comfy.ldm.pixeldit.model
 import comfy.ldm.pixeldit.pid
 import comfy.ldm.ace.model
 import comfy.ldm.omnigen.omnigen2
-import comfy.ldm.seedvr.model
 import comfy.ldm.boogu.model
 import comfy.ldm.qwen_image.model
 import comfy.ldm.ideogram4.model
@@ -933,17 +932,6 @@ class HunyuanDiT(BaseModel):
         out['image_meta_size'] = comfy.conds.CONDRegular(torch.FloatTensor([[height, width, target_height, target_width, 0, 0]]))
         return out
 
-class SeedVR2(BaseModel):
-    def __init__(self, model_config, model_type=ModelType.FLOW, device=None):
-        super().__init__(model_config, model_type, device=device, unet_model=comfy.ldm.seedvr.model.NaDiT)
-
-    def extra_conds(self, **kwargs):
-        out = super().extra_conds(**kwargs)
-        condition = kwargs.get("condition", None)
-        if condition is not None:
-            out["condition"] = comfy.conds.CONDRegular(condition)
-        return out
-
 class PixArt(BaseModel):
     def __init__(self, model_config, model_type=ModelType.EPS, device=None):
         super().__init__(model_config, model_type, device=device, unet_model=comfy.ldm.pixart.pixartms.PixArtMS)

comfy/model_detection.py

@@ -598,44 +598,6 @@ def detect_unet_config(state_dict, key_prefix, metadata=None):
 
         return dit_config
 
-    seedvr2_7b_separate_key = "{}blocks.35.mlp.vid.proj_out.weight".format(key_prefix)
-    if seedvr2_7b_separate_key in state_dict_keys and state_dict[seedvr2_7b_separate_key].shape[0] == 3072: # seedvr2 7b
-        dit_config = {}
-        dit_config["image_model"] = "seedvr2"
-        dit_config["vid_dim"] = 3072
-        dit_config["heads"] = 24
-        dit_config["num_layers"] = 36
-        # This checkpoint uses separate vid/txt MMModule keys in every block.
-        dit_config["mm_layers"] = 36
-        dit_config["norm_eps"] = 1e-5
-        dit_config["rope_type"] = "rope3d"
-        dit_config["rope_dim"] = 64
-        dit_config["mlp_type"] = "normal"
-        return dit_config
-    if "{}blocks.35.mlp.all.proj_in_gate.weight".format(key_prefix) in state_dict_keys: # seedvr2 7b
-        dit_config = {}
-        dit_config["image_model"] = "seedvr2"
-        dit_config["vid_dim"] = 3072
-        dit_config["heads"] = 24
-        dit_config["num_layers"] = 36
-        # This checkpoint uses shared all.* MMModule keys after the initial blocks.
-        dit_config["mm_layers"] = 10
-        dit_config["norm_eps"] = 1e-5
-        dit_config["rope_type"] = "rope3d"
-        dit_config["rope_dim"] = 64
-        dit_config["mlp_type"] = "swiglu"
-        return dit_config
-    if "{}blocks.31.mlp.all.proj_in_gate.weight".format(key_prefix) in state_dict_keys: # seedvr2 3b
-        dit_config = {}
-        dit_config["image_model"] = "seedvr2"
-        dit_config["vid_dim"] = 2560
-        dit_config["heads"] = 20
-        dit_config["num_layers"] = 32
-        dit_config["norm_eps"] = 1.0e-05
-        dit_config["mlp_type"] = "swiglu"
-        dit_config["vid_out_norm"] = True
-        return dit_config
-
     if '{}head.modulation'.format(key_prefix) in state_dict_keys:  # Wan 2.1
         dit_config = {}
         dit_config["image_model"] = "wan2.1"
@@ -1156,24 +1118,10 @@ def detect_unet_config(state_dict, key_prefix, metadata=None):
         unet_config["heatmap_head"] = True
 
     return unet_config
-def normalize_seedvr2_unet_config(unet_config):
-    if unet_config.get("image_model") != "seedvr2" or "num_heads" not in unet_config:
-        return unet_config
 
-    unet_config = dict(unet_config)
-    num_heads = unet_config.pop("num_heads")
-    if "heads" in unet_config and unet_config["heads"] != num_heads:
-        raise ValueError(
-            f"SeedVR2 config has conflicting heads={unet_config['heads']} and num_heads={num_heads}."
-        )
-    unet_config["heads"] = num_heads
-    return unet_config
-
-
-def model_config_from_unet_config(unet_config, state_dict=None, unet_key_prefix=""):
-    unet_config = normalize_seedvr2_unet_config(unet_config)
+def model_config_from_unet_config(unet_config, state_dict=None):
     for model_config in comfy.supported_models.models:
-        if model_config.matches(unet_config, state_dict, unet_key_prefix=unet_key_prefix):
+        if model_config.matches(unet_config, state_dict):
             return model_config(unet_config)
 
     logging.error("no match {}".format(unet_config))
@@ -1183,7 +1131,7 @@ def model_config_from_unet(state_dict, unet_key_prefix, use_base_if_no_match=Fal
     unet_config = detect_unet_config(state_dict, unet_key_prefix, metadata=metadata)
     if unet_config is None:
         return None
-    model_config = model_config_from_unet_config(unet_config, state_dict, unet_key_prefix)
+    model_config = model_config_from_unet_config(unet_config, state_dict)
     if model_config is None and use_base_if_no_match:
         model_config = comfy.supported_models_base.BASE(unet_config)
 

comfy/ops.py

@@ -174,8 +174,6 @@ def cast_modules_with_vbar(comfy_modules, dtype, device, bias_dtype, non_blockin
                     elif xfer_dest2 is not None:
                         xfer_source.prepare(xfer_dest2, stream, copy=True, commit=False)
                         return
-                    else:
-                        return
                 comfy.model_management.cast_to_gathered(xfer_source, xfer_dest, non_blocking=non_blocking, stream=stream, r2=xfer_dest2)
 
         def handle_pin(m, pin, source, dest, subset="weights", size=None):

comfy/sd.py

@@ -16,7 +16,6 @@ import comfy.ldm.cosmos.vae
 import comfy.ldm.wan.vae
 import comfy.ldm.wan.vae2_2
 import comfy.ldm.hunyuan3d.vae
-import comfy.ldm.seedvr.vae
 import comfy.ldm.triposplat.vae
 import comfy.ldm.ace.vae.music_dcae_pipeline
 import comfy.ldm.cogvideo.vae
@@ -469,13 +468,9 @@ class CLIP:
     def decode(self, token_ids, skip_special_tokens=True):
         return self.tokenizer.decode(token_ids, skip_special_tokens=skip_special_tokens)
 
-    def is_dynamic(self):
-        return self.patcher.is_dynamic()
-
 class VAE:
     def __init__(self, sd=None, device=None, config=None, dtype=None, metadata=None):
-        is_seedvr2_vae = "decoder.up_blocks.2.upsamplers.0.upscale_conv.weight" in sd
-        if not is_seedvr2_vae and 'decoder.up_blocks.0.resnets.0.norm1.weight' in sd.keys(): #diffusers format
+        if 'decoder.up_blocks.0.resnets.0.norm1.weight' in sd.keys(): #diffusers format
             sd = diffusers_convert.convert_vae_state_dict(sd)
 
         if model_management.is_amd():
@@ -502,8 +497,6 @@ class VAE:
         self.upscale_index_formula = None
         self.extra_1d_channel = None
         self.crop_input = True
-        self.handles_tiling = False
-        self.format_encoded = None
 
         self.audio_sample_rate = 44100
 
@@ -550,22 +543,6 @@ class VAE:
                 self.first_stage_model = StageC_coder()
                 self.downscale_ratio = 32
                 self.latent_channels = 16
-            elif "decoder.up_blocks.2.upsamplers.0.upscale_conv.weight" in sd: # seedvr2
-                self.first_stage_model = comfy.ldm.seedvr.vae.VideoAutoencoderKLWrapper()
-                self.latent_channels = comfy.ldm.seedvr.vae.SEEDVR2_LATENT_CHANNELS
-                self.latent_dim = 3
-                self.disable_offload = True
-                self.memory_used_decode = lambda shape, dtype: self.first_stage_model.comfy_memory_used_decode(shape)
-                self.memory_used_encode = lambda shape, dtype: (max(shape[2], 5) * shape[3] * shape[4] * 64) * model_management.dtype_size(dtype)
-                self.working_dtypes = [torch.float16, torch.bfloat16, torch.float32]
-                self.handles_tiling = True
-                self.format_encoded = self.first_stage_model.comfy_format_encoded
-                self.downscale_ratio = (lambda a: max(0, math.floor((a + 3) / 4)), 8, 8)
-                self.downscale_index_formula = (4, 8, 8)
-                self.upscale_ratio = (lambda a: max(0, a * 4 - 3), 8, 8)
-                self.upscale_index_formula = (4, 8, 8)
-                self.process_input = lambda image: image * 2.0 - 1.0
-                self.crop_input = False
             elif "decoder.conv_in.weight" in sd:
                 if sd['decoder.conv_in.weight'].shape[1] == 64:
                     ddconfig = {"block_out_channels": [128, 256, 512, 512, 1024, 1024], "in_channels": 3, "out_channels": 3, "num_res_blocks": 2, "ffactor_spatial": 32, "downsample_match_channel": True, "upsample_match_channel": True}
@@ -1032,10 +1009,6 @@ class VAE:
         decode_fn = lambda a: self.first_stage_model.decode(a.to(self.vae_dtype).to(self.device)).to(dtype=self.vae_output_dtype())
         return self.process_output(comfy.utils.tiled_scale_multidim(samples, decode_fn, tile=(tile_t, tile_x, tile_y), overlap=overlap, upscale_amount=self.upscale_ratio, out_channels=self.output_channels, index_formulas=self.upscale_index_formula, output_device=self.output_device))
 
-    def _decode_tiled_owned(self, samples, **kwargs):
-        out = self.first_stage_model.decode_tiled(samples.to(self.vae_dtype).to(self.device), **kwargs)
-        return self.process_output(out.to(device=self.output_device, dtype=self.vae_output_dtype(), copy=True))
-
     def encode_tiled_(self, pixel_samples, tile_x=512, tile_y=512, overlap = 64):
         steps = pixel_samples.shape[0] * comfy.utils.get_tiled_scale_steps(pixel_samples.shape[3], pixel_samples.shape[2], tile_x, tile_y, overlap)
         steps += pixel_samples.shape[0] * comfy.utils.get_tiled_scale_steps(pixel_samples.shape[3], pixel_samples.shape[2], tile_x // 2, tile_y * 2, overlap)
@@ -1072,25 +1045,6 @@ class VAE:
         encode_fn = lambda a: self.first_stage_model.encode((self.process_input(a)).to(self.vae_dtype).to(self.device)).to(dtype=self.vae_output_dtype())
         return comfy.utils.tiled_scale_multidim(samples, encode_fn, tile=(tile_t, tile_x, tile_y), overlap=overlap, upscale_amount=self.downscale_ratio, out_channels=self.latent_channels, downscale=True, index_formulas=self.downscale_index_formula, output_device=self.output_device)
 
-    def _encode_tiled_owned(self, pixel_samples, **kwargs):
-        x = self.process_input(pixel_samples).to(self.vae_dtype).to(self.device)
-        out = self.first_stage_model.encode_tiled(x, **kwargs)
-        return out.to(device=self.output_device, dtype=self.vae_output_dtype())
-
-    def _owned_tiled_args(self, tile_x=None, tile_y=None, overlap=None, tile_t=None, overlap_t=None):
-        args = {}
-        if tile_x is not None:
-            args["tile_x"] = tile_x
-        if tile_y is not None:
-            args["tile_y"] = tile_y
-        if overlap is not None:
-            args["overlap"] = overlap
-        if tile_t is not None:
-            args["tile_t"] = tile_t
-        if overlap_t is not None:
-            args["overlap_t"] = overlap_t
-        return args
-
     def decode(self, samples_in, vae_options={}):
         self.throw_exception_if_invalid()
         pixel_samples = None
@@ -1138,19 +1092,11 @@ class VAE:
                 if dims == 1 or self.extra_1d_channel is not None:
                     pixel_samples = self.decode_tiled_1d(samples_in)
                 elif dims == 2:
-                    if self.handles_tiling:
-                        tile = 256 // self.spacial_compression_decode()
-                        overlap = tile // 4
-                        pixel_samples = self._decode_tiled_owned(samples_in, tile_x=tile, tile_y=tile, overlap=overlap)
-                    else:
-                        pixel_samples = self.decode_tiled_(samples_in)
+                    pixel_samples = self.decode_tiled_(samples_in)
                 elif dims == 3:
                     tile = 256 // self.spacial_compression_decode()
                     overlap = tile // 4
-                    if self.handles_tiling:
-                        pixel_samples = self._decode_tiled_owned(samples_in, tile_x=tile, tile_y=tile, overlap=overlap)
-                    else:
-                        pixel_samples = self.decode_tiled_3d(samples_in, tile_x=tile, tile_y=tile, overlap=(1, overlap, overlap))
+                    pixel_samples = self.decode_tiled_3d(samples_in, tile_x=tile, tile_y=tile, overlap=(1, overlap, overlap))
 
         pixel_samples = pixel_samples.to(self.output_device).movedim(1,-1)
         return pixel_samples
@@ -1169,9 +1115,7 @@ class VAE:
             args["overlap"] = overlap
 
         with model_management.cuda_device_context(self.device):
-            if self.handles_tiling and dims in (2, 3):
-                output = self._decode_tiled_owned(samples, **self._owned_tiled_args(tile_x, tile_y, overlap, tile_t, overlap_t))
-            elif dims == 1 or self.extra_1d_channel is not None:
+            if dims == 1 or self.extra_1d_channel is not None:
                 args.pop("tile_y")
                 output = self.decode_tiled_1d(samples, **args)
             elif dims == 2:
@@ -1232,17 +1176,12 @@ class VAE:
                 if self.latent_dim == 3:
                     tile = 256
                     overlap = tile // 4
-                    if self.handles_tiling:
-                        samples = self._encode_tiled_owned(pixel_samples, tile_x=tile, tile_y=tile, overlap=overlap)
-                    else:
-                        samples = self.encode_tiled_3d(pixel_samples, tile_x=tile, tile_y=tile, overlap=(1, overlap, overlap))
+                    samples = self.encode_tiled_3d(pixel_samples, tile_x=tile, tile_y=tile, overlap=(1, overlap, overlap))
                 elif self.latent_dim == 1 or self.extra_1d_channel is not None:
                     samples = self.encode_tiled_1d(pixel_samples)
                 else:
                     samples = self.encode_tiled_(pixel_samples)
 
-        if self.format_encoded is not None:
-            samples = self.format_encoded(samples)
         return samples
 
     def encode_tiled(self, pixel_samples, tile_x=None, tile_y=None, overlap=None, tile_t=None, overlap_t=None):
@@ -1250,7 +1189,7 @@ class VAE:
         pixel_samples = self.vae_encode_crop_pixels(pixel_samples)
         dims = self.latent_dim
         pixel_samples = pixel_samples.movedim(-1, 1)
-        if dims == 3 and pixel_samples.ndim < 5:
+        if dims == 3:
             if not self.not_video:
                 pixel_samples = pixel_samples.movedim(1, 0).unsqueeze(0)
             else:
@@ -1274,27 +1213,21 @@ class VAE:
             elif dims == 2:
                 samples = self.encode_tiled_(pixel_samples, **args)
             elif dims == 3:
-                if self.handles_tiling:
-                    samples = self._encode_tiled_owned(pixel_samples, **self._owned_tiled_args(tile_x, tile_y, overlap, tile_t, overlap_t))
+                if tile_t is not None:
+                    tile_t_latent = max(2, self.downscale_ratio[0](tile_t))
                 else:
-                    if tile_t is not None:
-                        tile_t_latent = max(2, self.downscale_ratio[0](tile_t))
-                    else:
-                        tile_t_latent = 9999
-                    args["tile_t"] = self.upscale_ratio[0](tile_t_latent)
+                    tile_t_latent = 9999
+                args["tile_t"] = self.upscale_ratio[0](tile_t_latent)
 
-                    spatial_overlap = overlap if overlap is not None else 64
-                    if overlap_t is None:
-                        args["overlap"] = (1, spatial_overlap, spatial_overlap)
-                    else:
-                        args["overlap"] = (self.upscale_ratio[0](max(1, min(tile_t_latent // 2, self.downscale_ratio[0](overlap_t)))), spatial_overlap, spatial_overlap)
-                    maximum = pixel_samples.shape[2]
-                    maximum = self.upscale_ratio[0](self.downscale_ratio[0](maximum))
+                if overlap_t is None:
+                    args["overlap"] = (1, overlap, overlap)
+                else:
+                    args["overlap"] = (self.upscale_ratio[0](max(1, min(tile_t_latent // 2, self.downscale_ratio[0](overlap_t)))), overlap, overlap)
+                maximum = pixel_samples.shape[2]
+                maximum = self.upscale_ratio[0](self.downscale_ratio[0](maximum))
 
-                    samples = self.encode_tiled_3d(pixel_samples[:,:,:maximum], **args)
+                samples = self.encode_tiled_3d(pixel_samples[:,:,:maximum], **args)
 
-        if self.format_encoded is not None:
-            samples = self.format_encoded(samples)
         return samples
 
     def get_sd(self):
@@ -1318,11 +1251,6 @@ class VAE:
         except:
             return None
 
-    def is_dynamic(self):
-        # A VAE built from a state dict with no detectable VAE weights returns early
-        # from __init__ ("No VAE weights detected") before self.patcher is assigned.
-        patcher = getattr(self, "patcher", None)
-        return patcher is not None and patcher.is_dynamic()
 
 class StyleModel:
     def __init__(self, model, device="cpu"):
@@ -1962,7 +1890,7 @@ def load_state_dict_guess_config(sd, output_vae=True, output_clip=True, output_c
         manual_cast_dtype = model_management.unet_manual_cast(None, load_device, model_config.supported_inference_dtypes)
     else:
         manual_cast_dtype = model_management.unet_manual_cast(unet_dtype, load_device, model_config.supported_inference_dtypes)
-    model_config.set_inference_dtype(unet_dtype, manual_cast_dtype, device=load_device)
+    model_config.set_inference_dtype(unet_dtype, manual_cast_dtype)
 
     if model_config.clip_vision_prefix is not None:
         if output_clipvision:
@@ -2103,7 +2031,7 @@ def load_diffusion_model_state_dict(sd, model_options={}, metadata=None, disable
         manual_cast_dtype = model_management.unet_manual_cast(None, load_device, model_config.supported_inference_dtypes)
     else:
         manual_cast_dtype = model_management.unet_manual_cast(unet_dtype, load_device, model_config.supported_inference_dtypes)
-    model_config.set_inference_dtype(unet_dtype, manual_cast_dtype, device=load_device)
+    model_config.set_inference_dtype(unet_dtype, manual_cast_dtype)
 
     if custom_operations is not None:
         model_config.custom_operations = custom_operations

comfy/supported_models.py

@@ -1685,40 +1685,6 @@ class Chroma(supported_models_base.BASE):
         t5_detect = comfy.text_encoders.sd3_clip.t5_xxl_detect(state_dict, "{}t5xxl.transformer.".format(pref))
         return supported_models_base.ClipTarget(comfy.text_encoders.pixart_t5.PixArtTokenizer, comfy.text_encoders.pixart_t5.pixart_te(**t5_detect))
 
-class SeedVR2(supported_models_base.BASE):
-    unet_config = {
-        "image_model": "seedvr2"
-    }
-    unet_extra_config = {}
-    required_keys = {
-        "{}positive_conditioning",
-        "{}negative_conditioning",
-    }
-    latent_format = comfy.latent_formats.SeedVR2
-
-    vae_key_prefix = ["vae."]
-    text_encoder_key_prefix = ["text_encoders."]
-    supported_inference_dtypes = [torch.bfloat16, torch.float16, torch.float32]
-    sampling_settings = {
-        "shift": 1.0,
-    }
-
-    def set_inference_dtype(self, dtype, manual_cast_dtype, device=None):
-        if (
-            dtype == torch.float16
-            and manual_cast_dtype is None
-            and comfy.model_management.should_use_bf16(device)
-        ):
-            manual_cast_dtype = torch.bfloat16
-        super().set_inference_dtype(dtype, manual_cast_dtype, device=device)
-
-    def get_model(self, state_dict, prefix="", device=None):
-        out = model_base.SeedVR2(self, device=device)
-        return out
-
-    def clip_target(self, state_dict={}):
-        return None
-
 class ChromaRadiance(Chroma):
     unet_config = {
         "image_model": "chroma_radiance",
@@ -2382,7 +2348,6 @@ models = [
     HiDream,
     HiDreamO1,
     Chroma,
-    SeedVR2,
     ChromaRadiance,
     ACEStep,
     ACEStep15,

comfy/supported_models_base.py

@@ -54,13 +54,13 @@ class BASE:
     optimizations = {"fp8": False}
 
     @classmethod
-    def matches(s, unet_config, state_dict=None, unet_key_prefix=""):
+    def matches(s, unet_config, state_dict=None):
         for k in s.unet_config:
             if k not in unet_config or s.unet_config[k] != unet_config[k]:
                 return False
         if state_dict is not None:
             for k in s.required_keys:
-                if k.format(unet_key_prefix) not in state_dict:
+                if k not in state_dict:
                     return False
         return True
 
@@ -115,7 +115,7 @@ class BASE:
         replace_prefix = {"": self.vae_key_prefix[0]}
         return utils.state_dict_prefix_replace(state_dict, replace_prefix)
 
-    def set_inference_dtype(self, dtype, manual_cast_dtype, device=None):
+    def set_inference_dtype(self, dtype, manual_cast_dtype):
         self.unet_config['dtype'] = dtype
         self.manual_cast_dtype = manual_cast_dtype
 

comfy/text_encoders/gpt_oss.py

@@ -12,7 +12,7 @@ import torch.nn.functional as F
 
 import comfy.ops
 from comfy import sd1_clip
-from comfy.ldm.modules.attention import optimized_attention_for_device
+from comfy.ldm.modules.attention import TORCH_HAS_GQA, optimized_attention_for_device
 from comfy.text_encoders.llama import RMSNorm, apply_rope
 
 
@@ -110,6 +110,10 @@ def _attention_with_sinks(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, sin
     putting the sink logit in the mask at that column.
     """
 
+    if num_kv_groups > 1 and not TORCH_HAS_GQA:
+        k = k.repeat_interleave(num_kv_groups, dim=1)
+        v = v.repeat_interleave(num_kv_groups, dim=1)
+
     B, _, S_q, D = q.shape
     H_kv = k.shape[1]
     S_kv = k.shape[-2]

comfy/text_encoders/llama.py

@@ -550,8 +550,10 @@ class Attention(nn.Module):
                 xv = xv[:, :, -sliding_window:]
                 attention_mask = attention_mask[..., -sliding_window:] if attention_mask is not None else None
 
-        gqa_kwargs = {"enable_gqa": True} if self.num_heads != self.num_kv_heads else {}
-        output = optimized_attention(xq, xk, xv, self.num_heads, mask=attention_mask, skip_reshape=True, **gqa_kwargs)
+        xk = xk.repeat_interleave(self.num_heads // self.num_kv_heads, dim=1)
+        xv = xv.repeat_interleave(self.num_heads // self.num_kv_heads, dim=1)
+
+        output = optimized_attention(xq, xk, xv, self.num_heads, mask=attention_mask, skip_reshape=True)
         return self.o_proj(output), present_key_value
 
 class MLP(nn.Module):
@@ -935,41 +937,22 @@ class BaseGenerate:
             return torch.argmax(logits, dim=-1, keepdim=True)
 
         # Sampling mode
-        if len(token_history) > 0 and (repetition_penalty != 1.0 or (presence_penalty is not None and presence_penalty != 0.0)):
-            token_ids = torch.tensor(list(set(token_history)), device=logits.device)
-            token_logits = logits[:, token_ids]
-            if repetition_penalty != 1.0:
-                token_logits = torch.where(token_logits < 0, token_logits * repetition_penalty, token_logits / repetition_penalty)
-            if presence_penalty is not None and presence_penalty != 0.0:
-                token_logits = token_logits - presence_penalty
-            logits[:, token_ids] = token_logits
+        if repetition_penalty != 1.0:
+            for i in range(logits.shape[0]):
+                for token_id in set(token_history):
+                    logits[i, token_id] *= repetition_penalty if logits[i, token_id] < 0 else 1/repetition_penalty
+
+        if presence_penalty is not None and presence_penalty != 0.0:
+            for i in range(logits.shape[0]):
+                for token_id in set(token_history):
+                    logits[i, token_id] -= presence_penalty
 
         if temperature != 1.0:
             logits = logits / temperature
 
         if top_k > 0:
-            top_k = min(top_k, logits.shape[-1])
-            logits, top_indices = torch.topk(logits, top_k)
-
-            if min_p > 0.0:
-                probs_before_filter = torch.nn.functional.softmax(logits, dim=-1)
-                top_probs, _ = probs_before_filter.max(dim=-1, keepdim=True)
-                min_threshold = min_p * top_probs
-                indices_to_remove = probs_before_filter < min_threshold
-                logits[indices_to_remove] = torch.finfo(logits.dtype).min
-
-            if top_p < 1.0:
-                sorted_logits, sorted_indices = torch.sort(logits, descending=True)
-                cumulative_probs = torch.cumsum(torch.nn.functional.softmax(sorted_logits, dim=-1), dim=-1)
-                sorted_indices_to_remove = cumulative_probs > top_p
-                sorted_indices_to_remove[..., 0] = False
-                indices_to_remove = torch.zeros_like(logits, dtype=torch.bool)
-                indices_to_remove.scatter_(1, sorted_indices, sorted_indices_to_remove)
-                logits[indices_to_remove] = torch.finfo(logits.dtype).min
-
-            probs = torch.nn.functional.softmax(logits, dim=-1)
-            next_token = torch.multinomial(probs, num_samples=1, generator=generator)
-            return top_indices.gather(1, next_token)
+            indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
+            logits[indices_to_remove] = torch.finfo(logits.dtype).min
 
         if min_p > 0.0:
             probs_before_filter = torch.nn.functional.softmax(logits, dim=-1)

comfy/text_encoders/qwen35.py

@@ -366,8 +366,12 @@ class GatedAttention(nn.Module):
                     xv = torch.cat((past_value[:, :, :index], xv), dim=2)
                 present_key_value = (xk, xv, index + num_tokens)
 
-        gqa_kwargs = {"enable_gqa": True} if self.num_heads != self.num_kv_heads else {}
-        output = optimized_attention(xq, xk, xv, self.num_heads, mask=attention_mask, skip_reshape=True, **gqa_kwargs)
+        # Expand KV heads for GQA
+        if self.num_heads != self.num_kv_heads:
+            xk = xk.repeat_interleave(self.num_heads // self.num_kv_heads, dim=1)
+            xv = xv.repeat_interleave(self.num_heads // self.num_kv_heads, dim=1)
+
+        output = optimized_attention(xq, xk, xv, self.num_heads, mask=attention_mask, skip_reshape=True)
         output = output * gate.sigmoid()
 
         return self.o_proj(output), present_key_value

comfy_api/latest/_input_impl/video_types.py

@@ -281,18 +281,11 @@ class VideoFromFile(VideoInput):
         video_done = False
         audio_done = True
 
-        # Use the last decodable audio stream. Streams FFmpeg has no decoder for have no codec context,
-        # and decoding their packets crashes the process. (e.g. APAC spatial-audio track in iPhone)
-        audio_stream = next(
-            (s for s in reversed(container.streams.audio) if s.codec_context is not None),
-            None,
-        )
-        if audio_stream is not None:
+        if len(container.streams.audio):
+            audio_stream = container.streams.audio[-1]
             streams += [audio_stream]
             resampler = av.audio.resampler.AudioResampler(format='fltp')
             audio_done = False
-        elif len(container.streams.audio):
-            logging.warning("No decodable audio stream found in video; ignoring audio.")
 
         for packet in container.demux(*streams):
             if video_done and audio_done:
@@ -464,13 +457,10 @@ class VideoFromFile(VideoInput):
                         else:
                             output_container.metadata[key] = json.dumps(value)
 
-                # Add streams to the new container. Streams with no codec context cannot be used as an output template.
+                # Add streams to the new container
                 stream_map = {}
                 for stream in streams:
                     if isinstance(stream, (av.VideoStream, av.AudioStream, SubtitleStream)):
-                        if stream.codec_context is None:
-                            logging.warning("Skipping %s stream %d with unsupported codec", stream.type, stream.index)
-                            continue
                         out_stream = output_container.add_stream_from_template(template=stream, opaque=True)
                         stream_map[stream] = out_stream
 

comfy_api/latest/_io.py

@@ -1261,6 +1261,155 @@ class DynamicSlot(ComfyTypeI):
             out_dict[input_type][finalized_id] = value
             out_dict["dynamic_paths"][finalized_id] = finalize_prefix(curr_prefix, curr_prefix[-1])
 
+@comfytype(io_type="COMFY_DYNAMICGROUP_V3")
+class DynamicGroup(ComfyTypeI):
+    """A repeatable group of widget inputs (e.g. lora_name + strength stacked into N rows).
+
+    At execution time the node receives a ``list[dict]`` where each element is a row.
+
+    Example::
+
+        io.DynamicGroup.Input(
+            "loras",
+            template=[
+                io.Combo.Input("lora_name", options=folder_paths.get_filename_list("loras")),
+                io.Float.Input("strength", default=1.0, min=-100, max=100, step=0.01),
+            ],
+            min=0,
+            max=50,
+        )
+        # execute receives: loras: list[dict] = [{"lora_name": "x.safetensors", "strength": 1.0}, ...]
+    """
+
+    Type = list[dict[str, Any]]
+    _MaxRows = 100
+
+    class Input(DynamicInput):
+        def __init__(
+            self,
+            id: str,
+            template: list["Input"],
+            min: int = 0,
+            max: int = 50,
+            display_name: str = None,
+            optional: bool = False,
+            tooltip: str = None,
+            lazy: bool = None,
+            extra_dict=None,
+            group_name: str = "Group",
+        ):
+            super().__init__(id, display_name, optional, tooltip, lazy, extra_dict)
+            assert len(template) > 0, "DynamicGroup template must have at least one field."
+            for t in template:
+                assert isinstance(t, WidgetInput), (
+                    f"DynamicGroup template field '{t.id}' must be a WidgetInput subclass "
+                    f"(Combo, Float, Int, String, Boolean, Color). Got {type(t).__name__}."
+                )
+                assert not isinstance(t, DynamicInput), (
+                    f"DynamicGroup template field '{t.id}' must not be a DynamicInput. "
+                    "Nesting dynamic inputs inside DynamicGroup is not supported."
+                )
+            field_ids = [t.id for t in template]
+            assert len(field_ids) == len(set(field_ids)), (
+                f"DynamicGroup template field ids must be unique within a row. Got: {field_ids}"
+            )
+            # Reject "." in group id and template field ids: slot_id encoding uses "." as a
+            # delimiter (<group_id>.<row>.<field_id>), so any "." in these names would cause
+            # path.split(".") to produce the wrong number of segments during decoding.
+            assert "." not in id, (
+                f"DynamicGroup id must not contain '.'. Got: '{id}'"
+            )
+            for t in template:
+                assert "." not in t.id, (
+                    f"DynamicGroup template field id must not contain '.'. Got: '{t.id}'"
+                )
+            assert min >= 0, "DynamicGroup min must be >= 0."
+            assert max >= 1, "DynamicGroup max must be >= 1."
+            assert max <= DynamicGroup._MaxRows, f"DynamicGroup max must be <= {DynamicGroup._MaxRows}."
+            assert min <= max, "DynamicGroup min must be <= max."
+            self.template = template
+            self.min = min
+            self.max = max
+            self.group_name = group_name
+
+        def get_all(self) -> list["Input"]:
+            return [self] + list(self.template)
+
+        def as_dict(self):
+            return super().as_dict() | prune_dict({
+                "template": create_input_dict_v1(self.template),
+                "min": self.min,
+                "max": self.max,
+                "group_name": self.group_name,
+            })
+
+        def validate(self):
+            for t in self.template:
+                t.validate()
+
+    @staticmethod
+    def _expand_schema_for_dynamic(
+        out_dict: dict[str, Any],
+        live_inputs: dict[str, Any],
+        value: tuple[str, dict[str, Any]],
+        input_type: str,
+        curr_prefix: list[str] | None,
+    ):
+        info = value[1]
+        min_rows: int = info.get("min", 0)
+        max_rows: int = info.get("max", DynamicGroup._MaxRows)
+        template: dict[str, Any] = info.get("template", {})
+
+        # Collect all template field specs across required/optional sections
+        field_specs: list[tuple[str, tuple[str, dict[str, Any]], bool]] = []
+        for field_required_key in ("required", "optional"):
+            section = template.get(field_required_key, {})
+            is_required_field = field_required_key == "required"
+            for field_id, field_value in section.items():
+                field_specs.append((field_id, field_value, is_required_field))
+
+        # Determine how many rows are currently present by scanning live_inputs
+        finalized_prefix = finalize_prefix(curr_prefix)
+        present_rows = 0
+        for live_key in live_inputs:
+            # Keys look like "<prefix>.<row>.<field_id>"
+            if live_key.startswith(finalized_prefix + "."):
+                remainder = live_key[len(finalized_prefix) + 1:]
+                parts = remainder.split(".", 1)
+                if len(parts) >= 1:
+                    try:
+                        row_idx = int(parts[0])
+                        present_rows = max(present_rows, row_idx + 1)
+                    except ValueError:
+                        pass
+
+        if present_rows > max_rows:
+            raise ValueError(
+                f"DynamicGroup input '{finalized_prefix}' received {present_rows} rows but max is {max_rows}."
+            )
+        row_count = max(min_rows, present_rows)
+
+        for row in range(row_count):
+            for field_id, field_value, is_required_field in field_specs:
+                slot_id = f"{finalized_prefix}.{row}.{field_id}"
+                if row < min_rows and is_required_field:
+                    out_dict["required"][slot_id] = field_value
+                else:
+                    out_dict["optional"][slot_id] = field_value
+                # Register into dynamic_paths so build_nested_inputs places value at the right path
+                out_dict["dynamic_paths"][slot_id] = slot_id
+
+        # Track the list root path so build_nested_inputs can convert the index dict to a list
+        out_dict.setdefault("list_paths", set()).add(finalized_prefix)
+
+        # Handle the empty case (0 rows) – emit an empty-list default for the parent.
+        # This must only fire when there are genuinely no rows; otherwise the parent
+        # path would clobber the per-row dict built from the slot ids above.
+        if row_count == 0:
+            out_dict["dynamic_paths"][finalized_prefix] = finalized_prefix
+            out_dict["dynamic_paths_default_value"][finalized_prefix] = DynamicPathsDefaultValue.EMPTY_LIST
+
+
 @comfytype(io_type="IMAGECOMPARE")
 class ImageCompare(ComfyTypeI):
   Type = dict
@@ -1418,6 +1567,8 @@ def setup_dynamic_input_funcs():
     register_dynamic_input_func(DynamicCombo.io_type, DynamicCombo._expand_schema_for_dynamic)
     # DynamicSlot.Input
     register_dynamic_input_func(DynamicSlot.io_type, DynamicSlot._expand_schema_for_dynamic)
+    # DynamicGroup.Input
+    register_dynamic_input_func(DynamicGroup.io_type, DynamicGroup._expand_schema_for_dynamic)
 
 if len(DYNAMIC_INPUT_LOOKUP) == 0:
     setup_dynamic_input_funcs()
@@ -1429,6 +1580,8 @@ class V3Data(TypedDict):
     'Dictionary where the keys are the input ids and the values dictate how to turn the inputs into a nested dictionary.'
     dynamic_paths_default_value: dict[str, Any]
     'Dictionary where the keys are the input ids and the values are a string from DynamicPathsDefaultValue for the inputs if value is None.'
+    list_paths: set[str]
+    'Set of top-level keys whose index-keyed dict values should be converted to a sorted list[dict] after build_nested_inputs runs.'
     create_dynamic_tuple: bool
     'When True, the value of the dynamic input will be in the format (value, path_key).'
 
@@ -1770,6 +1923,7 @@ def get_finalized_class_inputs(d: dict[str, Any], live_inputs: dict[str, Any], i
         "optional": {},
         "dynamic_paths": {},
         "dynamic_paths_default_value": {},
+        "list_paths": set(),
     }
     d = d.copy()
     # ignore hidden for parsing
@@ -1785,6 +1939,10 @@ def get_finalized_class_inputs(d: dict[str, Any], live_inputs: dict[str, Any], i
     dynamic_paths_default_value = out_dict.pop("dynamic_paths_default_value", None)
     if dynamic_paths_default_value is not None and len(dynamic_paths_default_value) > 0:
         v3_data["dynamic_paths_default_value"] = dynamic_paths_default_value
+    # list_paths: keys whose nested dict should be post-converted to a sorted list[dict]
+    list_paths = out_dict.pop("list_paths", None)
+    if list_paths:
+        v3_data["list_paths"] = list_paths
     return out_dict, hidden, v3_data
 
 def parse_class_inputs(out_dict: dict[str, Any], live_inputs: dict[str, Any], curr_dict: dict[str, Any], curr_prefix: list[str] | None=None) -> None:
@@ -1820,10 +1978,12 @@ def add_to_dict_v1(i: Input, d: dict):
 
 class DynamicPathsDefaultValue:
     EMPTY_DICT = "empty_dict"
+    EMPTY_LIST = "empty_list"
 
 def build_nested_inputs(values: dict[str, Any], v3_data: V3Data):
     paths = v3_data.get("dynamic_paths", None)
     default_value_dict = v3_data.get("dynamic_paths_default_value", {})
+    list_paths: set[str] = v3_data.get("list_paths", set()) or set()
     if paths is None:
         return values
     values = values.copy()
@@ -1846,6 +2006,8 @@ def build_nested_inputs(values: dict[str, Any], v3_data: V3Data):
                     default_option = default_value_dict.get(key, None)
                     if default_option == DynamicPathsDefaultValue.EMPTY_DICT:
                         value = {}
+                    elif default_option == DynamicPathsDefaultValue.EMPTY_LIST:
+                        value = []
                 if create_tuple:
                     value = (value, key)
                 current[p] = value
@@ -1853,6 +2015,34 @@ def build_nested_inputs(values: dict[str, Any], v3_data: V3Data):
                 current = current.setdefault(p, {})
 
     values.update(result)
+
+    # Post-pass: convert index-keyed dicts to sorted lists for io.DynamicGroup fields
+    for list_path in list_paths:
+        parts = list_path.split(".")
+        # Navigate to the parent container, then convert the leaf
+        container = values
+        for part in parts[:-1]:
+            if not isinstance(container, dict) or part not in container:
+                container = None
+                break
+            container = container[part]
+        if container is None:
+            continue
+        leaf_key = parts[-1]
+        leaf = container.get(leaf_key, None)
+        if isinstance(leaf, dict):
+            try:
+                sorted_rows = [leaf[k] for k in sorted(leaf.keys(), key=int)]
+                container[leaf_key] = sorted_rows
+            except (ValueError, TypeError):
+                # Keys are not all integers; leave as-is
+                pass
+        elif isinstance(leaf, list):
+            # Already a list (e.g. the EMPTY_LIST default was applied above)
+            pass
+        elif leaf is None:
+            container[leaf_key] = []
+
     return values
 
 
@@ -2417,7 +2607,9 @@ __all__ = [
     # Dynamic Types
     "MatchType",
     "DynamicCombo",
+    "DynamicSlot",
     "Autogrow",
+    "DynamicGroup",
     # Other classes
     "HiddenHolder",
     "Hidden",

comfy_api_nodes/apis/bytedance.py

@@ -24,8 +24,8 @@ class Seedream4TaskCreationRequest(BaseModel):
     image: list[str] | None = Field(None, description="Image URLs")
     size: str = Field(...)
     seed: int = Field(..., ge=0, le=2147483647)
-    sequential_image_generation: str | None = Field("disabled")
-    sequential_image_generation_options: Seedream4Options | None = Field(Seedream4Options(max_images=15))
+    sequential_image_generation: str = Field("disabled")
+    sequential_image_generation_options: Seedream4Options = Field(Seedream4Options(max_images=15))
     watermark: bool = Field(False)
     output_format: str | None = None
 
@@ -261,19 +261,6 @@ _PRESETS_SEEDREAM_4K = [
 
 _CUSTOM_PRESET = [("Custom", None, None)]
 
-_PRESETS_SEEDREAM_2K_PRO = [
-    ("(2K) 2048x2048 (1:1)", 2048, 2048),
-    ("(2K) 1728x2304 (3:4)", 1728, 2304),
-    ("(2K) 2304x1728 (4:3)", 2304, 1728),
-    # ("(2K) 2848x1600 (16:9)", 2848, 1600),  # 4,556,800 px - temporarily unavailable
-    # ("(2K) 1600x2848 (9:16)", 1600, 2848),  # 4,556,800 px - temporarily unavailable
-    ("(2K) 1664x2496 (2:3)", 1664, 2496),
-    ("(2K) 2496x1664 (3:2)", 2496, 1664),
-    # ("(2K) 3136x1344 (21:9)", 3136, 1344),  # 4,214,784 px - temporarily unavailable
-]
-RECOMMENDED_PRESETS_SEEDREAM_5_PRO = (
-    _PRESETS_SEEDREAM_1K + _PRESETS_SEEDREAM_2K_PRO + _CUSTOM_PRESET
-)
 RECOMMENDED_PRESETS_SEEDREAM_5_LITE = (
     _PRESETS_SEEDREAM_2K + _PRESETS_SEEDREAM_3K + _PRESETS_SEEDREAM_4K + _CUSTOM_PRESET
 )

comfy_api_nodes/nodes_bytedance.py

@@ -16,7 +16,6 @@ from comfy_api_nodes.apis.bytedance import (
     RECOMMENDED_PRESETS_SEEDREAM_4_0,
     RECOMMENDED_PRESETS_SEEDREAM_4_5,
     RECOMMENDED_PRESETS_SEEDREAM_5_LITE,
-    RECOMMENDED_PRESETS_SEEDREAM_5_PRO,
     SEEDANCE2_REF_VIDEO_PIXEL_LIMITS,
     VIDEO_TASKS_EXECUTION_TIME,
     GetAssetResponse,
@@ -81,14 +80,12 @@ _VERIFICATION_POLL_TIMEOUT_SEC = 120
 _VERIFICATION_POLL_INTERVAL_SEC = 3
 
 SEEDREAM_MODELS = {
-    "seedream 5.0 pro": "seedream-5-0-pro-260628",
     "seedream 5.0 lite": "seedream-5-0-260128",
     "seedream-4-5-251128": "seedream-4-5-251128",
     "seedream-4-0-250828": "seedream-4-0-250828",
 }
 
 SEEDREAM_PRESETS = {
-    "seedream-5-0-pro-260628": RECOMMENDED_PRESETS_SEEDREAM_5_PRO,
     "seedream-5-0-260128": RECOMMENDED_PRESETS_SEEDREAM_5_LITE,
     "seedream-4-5-251128": RECOMMENDED_PRESETS_SEEDREAM_4_5,
     "seedream-4-0-250828": RECOMMENDED_PRESETS_SEEDREAM_4_0,
@@ -746,15 +743,8 @@ class ByteDanceSeedreamNode(IO.ComfyNode):
         return IO.NodeOutput(torch.cat([await download_url_to_image_tensor(i) for i in urls]))
 
 
-def _seedream_model_inputs(
-    *,
-    max_ref_images: int,
-    presets: list,
-    max_width: int = 6240,
-    max_height: int = 4992,
-    supports_batch: bool = True,
-):
-    inputs = [
+def _seedream_model_inputs(*, max_ref_images: int, presets: list):
+    return [
         IO.Combo.Input(
             "size_preset",
             options=[label for label, _, _ in presets],
@@ -764,7 +754,7 @@ def _seedream_model_inputs(
             "width",
             default=2048,
             min=1024,
-            max=max_width,
+            max=6240,
             step=2,
             tooltip="Custom width for image. Value is working only if `size_preset` is set to `Custom`",
         ),
@@ -772,27 +762,22 @@ def _seedream_model_inputs(
             "height",
             default=2048,
             min=1024,
-            max=max_height,
+            max=4992,
             step=2,
             tooltip="Custom height for image. Value is working only if `size_preset` is set to `Custom`",
         ),
-    ]
-    if supports_batch:
-        inputs.append(
-            IO.Int.Input(
-                "max_images",
-                default=1,
-                min=1,
-                max=max_ref_images,
-                step=1,
-                display_mode=IO.NumberDisplay.number,
-                tooltip="Maximum number of images to generate. With 1, exactly one image is produced. "
-                "With >1, the model generates between 1 and max_images related images "
-                "(e.g., story scenes, character variations). "
-                "Total images (input + generated) cannot exceed 15.",
-            )
-        )
-    inputs.append(
+        IO.Int.Input(
+            "max_images",
+            default=1,
+            min=1,
+            max=max_ref_images,
+            step=1,
+            display_mode=IO.NumberDisplay.number,
+            tooltip="Maximum number of images to generate. With 1, exactly one image is produced. "
+            "With >1, the model generates between 1 and max_images related images "
+            "(e.g., story scenes, character variations). "
+            "Total images (input + generated) cannot exceed 15.",
+        ),
         IO.Autogrow.Input(
             "images",
             template=IO.Autogrow.TemplateNames(
@@ -802,18 +787,14 @@ def _seedream_model_inputs(
             ),
             tooltip=f"Optional reference image(s) for image-to-image or multi-reference generation. "
             f"Up to {max_ref_images} images.",
-        )
-    )
-    if supports_batch:
-        inputs.append(
-            IO.Boolean.Input(
-                "fail_on_partial",
-                default=False,
-                tooltip="If enabled, abort execution if any requested images are missing or return an error.",
-                advanced=True,
-            )
-        )
-    return inputs
+        ),
+        IO.Boolean.Input(
+            "fail_on_partial",
+            default=False,
+            tooltip="If enabled, abort execution if any requested images are missing or return an error.",
+            advanced=True,
+        ),
+    ]
 
 
 class ByteDanceSeedreamNodeV2(IO.ComfyNode):
@@ -835,16 +816,6 @@ class ByteDanceSeedreamNodeV2(IO.ComfyNode):
                 IO.DynamicCombo.Input(
                     "model",
                     options=[
-                        IO.DynamicCombo.Option(
-                            "seedream 5.0 pro",
-                            _seedream_model_inputs(
-                                max_ref_images=10,
-                                presets=RECOMMENDED_PRESETS_SEEDREAM_5_PRO,
-                                max_width=3136,
-                                max_height=2496,
-                                supports_batch=False,
-                            ),
-                        ),
                         IO.DynamicCombo.Option(
                             "seedream 5.0 lite",
                             _seedream_model_inputs(max_ref_images=14, presets=RECOMMENDED_PRESETS_SEEDREAM_5_LITE),
@@ -886,27 +857,15 @@ class ByteDanceSeedreamNodeV2(IO.ComfyNode):
             ],
             is_api_node=True,
             price_badge=IO.PriceBadge(
-                depends_on=IO.PriceBadgeDepends(
-                    widgets=["model", "model.size_preset", "model.width", "model.height"]
-                ),
+                depends_on=IO.PriceBadgeDepends(widgets=["model"]),
                 expr="""
                 (
-                  $sp := $lookup(widgets, "model.size_preset");
-                  $px := $lookup(widgets, "model.width") * $lookup(widgets, "model.height");
-                  $isPro := $contains(widgets.model, "5.0 pro");
-                  $price := $isPro
-                              ? (
-                                  $contains($sp, "custom")
-                                    ? ($px <= 2360000 ? 0.045 : 0.09)
-                                    : ($contains($sp, "1k") ? 0.045 : 0.09)
-                                )
-                              : $contains(widgets.model, "5.0 lite") ? 0.035
-                              : $contains(widgets.model, "4-5") ? 0.04
-                              : 0.03;
+                  $price := $contains(widgets.model, "5.0 lite") ? 0.035 :
+                            $contains(widgets.model, "4-5") ? 0.04 : 0.03;
                   {
-                    "type": "usd",
+                    "type":"usd",
                     "usd": $price,
-                    "format": { "suffix": $isPro ? "/Image" : " x images/Run", "approximate": true }
+                    "format": { "suffix":" x images/Run", "approximate": true }
                   }
                 )
                 """,
@@ -924,7 +883,6 @@ class ByteDanceSeedreamNodeV2(IO.ComfyNode):
         validate_string(prompt, strip_whitespace=True, min_length=1)
         model_id = SEEDREAM_MODELS[model["model"]]
         presets = SEEDREAM_PRESETS[model_id]
-        is_pro = "seedream-5-0-pro" in model_id
 
         size_preset = model.get("size_preset", presets[0][0])
         width = model.get("width", 2048)
@@ -944,29 +902,19 @@ class ByteDanceSeedreamNodeV2(IO.ComfyNode):
 
         out_num_pixels = w * h
         mp_provided = out_num_pixels / 1_000_000.0
-        if is_pro:
-            if out_num_pixels < 921_600:
-                raise ValueError(
-                    f"Minimum image resolution for the selected model is 0.92MP, but {mp_provided:.2f}MP provided."
-                )
-            if out_num_pixels > 4_194_304:
-                raise ValueError(
-                    f"Maximum image resolution for the selected model is 4.19MP, but {mp_provided:.2f}MP provided."
-                )
-        else:
-            if ("seedream-4-5" in model_id or "seedream-5-0" in model_id) and out_num_pixels < 3_686_400:
-                raise ValueError(
-                    f"Minimum image resolution for the selected model is 3.68MP, but {mp_provided:.2f}MP provided."
-                )
-            if "seedream-4-0" in model_id and out_num_pixels < 921_600:
-                raise ValueError(
-                    f"Minimum image resolution that the selected model can generate is 0.92MP, "
-                    f"but {mp_provided:.2f}MP provided."
-                )
-            if out_num_pixels > 16_777_216:
-                raise ValueError(
-                    f"Maximum image resolution for the selected model is 16.78MP, but {mp_provided:.2f}MP provided."
-                )
+        if ("seedream-4-5" in model_id or "seedream-5-0" in model_id) and out_num_pixels < 3686400:
+            raise ValueError(
+                f"Minimum image resolution for the selected model is 3.68MP, but {mp_provided:.2f}MP provided."
+            )
+        if "seedream-4-0" in model_id and out_num_pixels < 921600:
+            raise ValueError(
+                f"Minimum image resolution that the selected model can generate is 0.92MP, "
+                f"but {mp_provided:.2f}MP provided."
+            )
+        if out_num_pixels > 16_777_216:
+            raise ValueError(
+                f"Maximum image resolution for the selected model is 16.78MP, but {mp_provided:.2f}MP provided."
+            )
 
         image_tensors: list[Input.Image] = [t for t in images_dict.values() if t is not None]
         n_input_images = sum(get_number_of_images(t) for t in image_tensors)
@@ -1002,8 +950,8 @@ class ByteDanceSeedreamNodeV2(IO.ComfyNode):
                 image=reference_images_urls,
                 size=f"{w}x{h}",
                 seed=seed,
-                sequential_image_generation=None if is_pro else sequential_image_generation,
-                sequential_image_generation_options=None if is_pro else Seedream4Options(max_images=max_images),
+                sequential_image_generation=sequential_image_generation,
+                sequential_image_generation_options=Seedream4Options(max_images=max_images),
                 watermark=watermark,
             ),
         )

comfy_api_nodes/util/request_logger.py

@@ -9,7 +9,6 @@ from typing import Any
 import folder_paths
 
 logger = logging.getLogger(__name__)
-_SENSITIVE_HEADERS = {"authorization", "x-api-key"}
 
 
 def get_log_directory():
@@ -74,10 +73,6 @@ def _format_data_for_logging(data: Any) -> str:
     return str(data)
 
 
-def _redact_headers(headers: dict) -> dict:
-    return {k: ("***" if k.lower() in _SENSITIVE_HEADERS else v) for k, v in headers.items()}
-
-
 def log_request_response(
     operation_id: str,
     request_method: str,
@@ -106,7 +101,7 @@ def log_request_response(
         log_content.append(f"Method: {request_method}")
         log_content.append(f"URL: {request_url}")
         if request_headers:
-            log_content.append(f"Headers:\n{_format_data_for_logging(_redact_headers(request_headers))}")
+            log_content.append(f"Headers:\n{_format_data_for_logging(request_headers)}")
         if request_params:
             log_content.append(f"Params:\n{_format_data_for_logging(request_params)}")
         if request_data is not None:

comfy_api_nodes/util/upload_helpers.py

@@ -158,14 +158,7 @@ async def upload_video_to_comfyapi(
 
     # Convert VideoInput to BytesIO using specified container/codec
     video_bytes_io = BytesIO()
-    try:
-        video.save_to(video_bytes_io, format=container, codec=codec)
-    except Exception as e:
-        raise ValueError(
-            f"Could not convert the input video to {container.value.upper()} for upload; "
-            f"the file may be corrupted or use an unsupported codec. "
-            f"Try re-exporting it as MP4 (H.264). Original error: {e}"
-        ) from e
+    video.save_to(video_bytes_io, format=container, codec=codec)
     video_bytes_io.seek(0)
 
     return await upload_file_to_comfyapi(cls, video_bytes_io, filename, upload_mime_type, wait_label)

comfy_execution/caching.py

@@ -503,21 +503,6 @@ RAM_CACHE_DEFAULT_RAM_USAGE = 0.05
 
 RAM_CACHE_OLD_WORKFLOW_OOM_MULTIPLIER = 1.3
 
-
-def all_outputs_dynamic(outputs):
-    if outputs is None:
-        return False
-
-    for output in outputs:
-        if isinstance(output, (list, tuple)):
-            if not all_outputs_dynamic(output):
-                return False
-        elif not hasattr(output, "is_dynamic") or not output.is_dynamic():
-            return False
-
-    return True
-
-
 class RAMPressureCache(LRUCache):
 
     def __init__(self, key_class, enable_providers=False):
@@ -548,11 +533,7 @@ class RAMPressureCache(LRUCache):
         for key, cache_entry in self.cache.items():
             if not free_active and self.used_generation[key] == self.generation:
                 continue
-
-            if all_outputs_dynamic(cache_entry.outputs) and self.used_generation[key] == self.generation:
-                continue
-
-            oom_score = RAM_CACHE_OLD_WORKFLOW_OOM_MULTIPLIER ** (self.generation - self.used_generation[key])
+            oom_score =  RAM_CACHE_OLD_WORKFLOW_OOM_MULTIPLIER ** (self.generation - self.used_generation[key])
 
             ram_usage = RAM_CACHE_DEFAULT_RAM_USAGE
             def scan_list_for_ram_usage(outputs):

comfy_extras/nodes_color.py

@@ -16,30 +16,23 @@ class ColorToRGBInt(io.ComfyNode):
             ],
             outputs=[
                 io.Int.Output(display_name="rgb_int"),
-                io.Color.Output(display_name="hex"),
-                io.Float.Output(display_name="alpha"),
+                io.Color.Output(display_name="hex")
             ],
         )
 
     @classmethod
     def execute(cls, color: str) -> io.NodeOutput:
-        # expect format #RRGGBB or #RRGGBBAA
-        if len(color) not in (7, 9) or color[0] != "#":
-            raise ValueError("Color must be in format #RRGGBB or #RRGGBBAA")
+        # expect format #RRGGBB
+        if len(color) != 7 or color[0] != "#":
+            raise ValueError("Color must be in format #RRGGBB")
         try:
             int(color[1:], 16)
         except ValueError:
-            raise ValueError("Color must be in format #RRGGBB or #RRGGBBAA") from None
-
-        alpha = 1.0
-        if len(color) == 9:
-            alpha = int(color[7:9], 16) / 255.0
-            color = color[:7]
-
+            raise ValueError("Color must be in format #RRGGBB") from None
         r, g, b = hex_to_rgb(color)
 
         rgb_int = r * 256 * 256 + g * 256 + b
-        return io.NodeOutput(rgb_int, color, alpha)
+        return io.NodeOutput(rgb_int, color)
 
 
 class ColorExtension(ComfyExtension):

comfy_extras/nodes_lora_stack.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from typing_extensions import override
+
+import comfy.sd
+import comfy.utils
+import folder_paths
+from comfy_api.latest import ComfyExtension, io
+
+
+def _load_lora_file(lora_name: str):
+    lora_path = folder_paths.get_full_path_or_raise("loras", lora_name)
+    return comfy.utils.load_torch_file(lora_path, safe_load=True, return_metadata=True)
+
+
+def _lora_template() -> list[io.Input]:
+    return [
+        io.Combo.Input("lora_name", options=folder_paths.get_filename_list("loras"),
+                       tooltip="The name of the LoRA file to apply."),
+        io.Float.Input("strength", default=1.0, min=-100.0, max=100.0, step=0.01,
+                       tooltip="How strongly to apply this LoRA. 0 = off, negative inverts the effect."),
+    ]
+
+
+class LoadLoraModel(io.ComfyNode):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id="LoadLoraModel",
+            display_name="Load LoRA (Model)",
+            search_aliases=["lora", "load lora", "apply lora", "lora model", "lora stack"],
+            category="model/loaders",
+            description="Apply a stack of LoRAs to a diffusion model. Add one row per LoRA; "
+                        "each row picks a LoRA file and its strength.",
+            inputs=[
+                io.Model.Input("model", tooltip="The diffusion model the LoRAs will be applied to."),
+                io.DynamicGroup.Input(
+                    "loras",
+                    template=_lora_template(),
+                    min=1,
+                    max=50,
+                    tooltip="Each row applies one LoRA to the model.",
+                    group_name="LoRA",
+                ),
+            ],
+            outputs=[io.Model.Output(tooltip="The modified diffusion model.")],
+        )
+
+    @classmethod
+    def execute(cls, model, loras: list[dict]) -> io.NodeOutput:
+        for row in loras:
+            lora_name = row.get("lora_name")
+            strength = row.get("strength", 1.0)
+            if not lora_name or lora_name == "none" or strength == 0:
+                continue
+            lora, metadata = _load_lora_file(lora_name)
+            model, _ = comfy.sd.load_lora_for_models(model, None, lora, strength, 0, lora_metadata=metadata)
+        return io.NodeOutput(model)
+
+
+class LoadLoraTextEncoder(io.ComfyNode):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id="LoadLoraTextEncoder",
+            display_name="Load LoRA (Text Encoder)",
+            search_aliases=["lora", "load lora", "apply lora", "clip lora", "lora stack"],
+            category="model/loaders",
+            description="Apply a stack of LoRAs to a CLIP text encoder. Add one row per LoRA; "
+                        "each row picks a LoRA file and its strength.",
+            inputs=[
+                io.Clip.Input("clip", tooltip="The CLIP text encoder the LoRAs will be applied to."),
+                io.DynamicGroup.Input(
+                    "loras",
+                    template=_lora_template(),
+                    min=1,
+                    max=50,
+                    tooltip="Each row applies one LoRA to the text encoder.",
+                    group_name="LoRA",
+                ),
+            ],
+            outputs=[io.Clip.Output(tooltip="The modified CLIP text encoder.")],
+        )
+
+    @classmethod
+    def execute(cls, clip, loras: list[dict]) -> io.NodeOutput:
+        for row in loras:
+            lora_name = row.get("lora_name")
+            strength = row.get("strength", 1.0)
+            if not lora_name or lora_name == "none" or strength == 0:
+                continue
+            lora, metadata = _load_lora_file(lora_name)
+            _, clip = comfy.sd.load_lora_for_models(None, clip, lora, 0, strength, lora_metadata=metadata)
+        return io.NodeOutput(clip)
+
+
+class LoraStackExtension(ComfyExtension):
+    @override
+    async def get_node_list(self) -> list[type[io.ComfyNode]]:
+        return [
+            LoadLoraModel,
+            LoadLoraTextEncoder,
+        ]
+
+
+async def comfy_entrypoint() -> LoraStackExtension:
+    return LoraStackExtension()

comfy_extras/nodes_seedvr.py

@@ -1,614 +0,0 @@
-import logging
-
-from typing_extensions import override
-from comfy_api.latest import ComfyExtension, io
-import torch
-
-import comfy.model_management
-from comfy.ldm.seedvr.color_fix import (
-    adain_color_transfer,
-    lab_color_transfer,
-    wavelet_color_transfer,
-)
-from comfy.ldm.seedvr.constants import (
-    BYTEDANCE_VAE_SPATIAL_DOWNSAMPLE,
-    SEEDVR2_ADAIN_SCALE_MULTIPLIER,
-    SEEDVR2_CHUNK_GIB_PER_MPX_FRAME,
-    SEEDVR2_CHUNK_RESERVED_GIB,
-    SEEDVR2_CHUNK_SIGMA_GIB,
-    SEEDVR2_CHUNK_SIGMA_K,
-    SEEDVR2_COLOR_MEM_HEADROOM,
-    SEEDVR2_DTYPE_BYTES_FLOOR,
-    SEEDVR2_LAB_SCALE_MULTIPLIER,
-    SEEDVR2_LATENT_CHANNELS,
-    SEEDVR2_OOM_BACKOFF_DIVISOR,
-    SEEDVR2_WAVELET_SCALE_MULTIPLIER,
-)
-
-from torchvision.transforms import functional as TVF
-from torchvision.transforms.functional import InterpolationMode
-
-
-_SEEDVR2_INVALID_MODEL_MSG_PREFIX = "SeedVR2Conditioning: model object does not match expected SeedVR2 structure"
-_ATTR_MISSING = object()
-
-
-def _resolve_seedvr2_diffusion_model(model):
-    inner = getattr(model, "model", _ATTR_MISSING)
-    if inner is _ATTR_MISSING:
-        raise RuntimeError(
-            f"{_SEEDVR2_INVALID_MODEL_MSG_PREFIX}: input has no 'model' attribute "
-            f"(got type {type(model).__name__})."
-        )
-    if inner is None:
-        raise RuntimeError(
-            f"{_SEEDVR2_INVALID_MODEL_MSG_PREFIX}: input.model is None "
-            f"(input type {type(model).__name__})."
-        )
-    diffusion_model = getattr(inner, "diffusion_model", _ATTR_MISSING)
-    if diffusion_model is _ATTR_MISSING:
-        raise RuntimeError(
-            f"{_SEEDVR2_INVALID_MODEL_MSG_PREFIX}: 'model.model' has no "
-            f"'diffusion_model' attribute (got type {type(inner).__name__})."
-        )
-    if diffusion_model is None:
-        raise RuntimeError(
-            f"{_SEEDVR2_INVALID_MODEL_MSG_PREFIX}: 'model.model.diffusion_model' "
-            f"is None (model.model type {type(inner).__name__})."
-        )
-    return diffusion_model
-
-
-def div_pad(image, factor):
-    height_factor, width_factor = factor
-    height, width = image.shape[-2:]
-
-    pad_height = (height_factor - (height % height_factor)) % height_factor
-    pad_width = (width_factor - (width % width_factor)) % width_factor
-
-    if pad_height == 0 and pad_width == 0:
-        return image
-
-    padding = (0, pad_width, 0, pad_height)
-    return torch.nn.functional.pad(image, padding, mode='constant', value=0.0)
-
-def cut_videos(videos):
-    t = videos.size(1)
-    if t < 1:
-        raise ValueError("SeedVR2Preprocess expected at least one frame.")
-    if t == 1:
-        return videos
-    if t <= 4:
-        padding = videos[:, -1:].repeat(1, 4 - t + 1, 1, 1, 1)
-        return torch.cat([videos, padding], dim=1)
-    if (t - 1) % 4 == 0:
-        return videos
-    padding = videos[:, -1:].repeat(1, 4 - ((t - 1) % 4), 1, 1, 1)
-    videos = torch.cat([videos, padding], dim=1)
-    if (videos.size(1) - 1) % 4 != 0:
-        raise ValueError(f"SeedVR2Preprocess failed to pad video length to 4n+1; got {videos.size(1)} frames.")
-    return videos
-
-def _seedvr2_input_shorter_edge(images, node_name):
-    if images.dim() == 4:
-        return min(images.shape[1], images.shape[2])
-    if images.dim() == 5:
-        return min(images.shape[2], images.shape[3])
-    raise ValueError(
-        f"{node_name}: expected 4-D or 5-D IMAGE tensor, "
-        f"got shape {tuple(images.shape)}"
-    )
-
-
-def _seedvr2_pad(images, upscaled_shorter_edge, node_name):
-    if upscaled_shorter_edge < 2:
-        raise ValueError(
-            f"{node_name}: input shorter edge must be at least 2 pixels; "
-            f"got {upscaled_shorter_edge}."
-        )
-    if images.shape[-1] > 3:
-        images = images[..., :3]
-    if images.dim() == 4:
-        # Comfy video components arrive as a 4-D IMAGE frame sequence:
-        # (frames, H, W, C). SeedVR2 consumes that as one video.
-        images = images.unsqueeze(0)
-    elif images.dim() != 5:
-        raise ValueError(
-            f"{node_name}: expected 4-D or 5-D IMAGE tensor, "
-            f"got shape {tuple(images.shape)}"
-        )
-    images = images.permute(0, 1, 4, 2, 3)
-
-    b, t, c, h, w = images.shape
-    images = images.reshape(b * t, c, h, w)
-
-    images = torch.clamp(images, 0.0, 1.0)
-    images = div_pad(images, (16, 16))
-    _, _, new_h, new_w = images.shape
-
-    images = images.reshape(b, t, c, new_h, new_w)
-    images = cut_videos(images)
-    images_bthwc = images.permute(0, 1, 3, 4, 2).contiguous()
-
-    return io.NodeOutput(images_bthwc)
-
-
-class SeedVR2Preprocess(io.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return io.Schema(
-            node_id="SeedVR2Preprocess",
-            display_name="Pre-Process SeedVR2 Input",
-            category="image/pre-processors",
-            description="Pad a resized image for SeedVR2 model. Alpha channel is dropped. The node Post-Process SeedVR2 Output re-applies it from the original resized image.",
-            search_aliases=["seedvr2", "upscale", "video upscale", "pad", "preprocess"],
-            inputs=[
-                io.Image.Input("resized_images", tooltip="The resized image to process."),
-            ],
-            outputs=[
-                io.Image.Output("images", tooltip="The padded image for VAE encoding."),
-            ]
-        )
-
-    @classmethod
-    def execute(cls, resized_images):
-        upscaled_shorter_edge = _seedvr2_input_shorter_edge(resized_images, "SeedVR2Preprocess")
-        return _seedvr2_pad(
-            resized_images, upscaled_shorter_edge, "SeedVR2Preprocess",
-        )
-
-
-class SeedVR2PostProcessing(io.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return io.Schema(
-            node_id="SeedVR2PostProcessing",
-            display_name="Post-Process SeedVR2 Output",
-            category="image/post-processors",
-            description="Align the generated image with the original resized image and apply color correction.",
-            search_aliases=["seedvr2", "upscale", "color correction", "color match", "postprocess"],
-            inputs=[
-                io.Image.Input("images", tooltip="The generated image to process."),
-                io.Image.Input("original_resized_images", tooltip="The original resized image before pre-processing, used as reference."),
-                io.Combo.Input("color_correction_method", options=["lab", "wavelet", "adain", "none"], default="lab", tooltip="Method to match the generated image colors to the original image. lab: transfer color in CIELAB space, preserving detail (most faithful). wavelet: transfer low-frequency color, keeping upscaled high-frequency detail. adain: match per-channel mean/std (fastest, global tint). none: skip color transfer (geometry alignment only)."),
-            ],
-            outputs=[io.Image.Output(display_name="images", tooltip="The aligned, color-corrected image.")],
-        )
-
-    @classmethod
-    def execute(cls, images, original_resized_images, color_correction_method):
-        alpha_input = None
-        if original_resized_images.shape[-1] == 4:
-            alpha_input = original_resized_images[..., 3:4]
-            original_resized_images = original_resized_images[..., :3]
-        decoded_5d, decoded_was_4d = cls._as_bthwc(images)
-        reference_full, _ = cls._as_bthwc(original_resized_images)
-        decoded_5d = cls._restore_reference_batch_time(decoded_5d, reference_full)
-
-        b = min(decoded_5d.shape[0], reference_full.shape[0])
-        t = min(decoded_5d.shape[1], reference_full.shape[1])
-        reference_h = reference_full.shape[2]
-        reference_w = reference_full.shape[3]
-
-        decoded_5d = decoded_5d[:b, :t, :, :, :]
-        target_h = min(decoded_5d.shape[2], reference_h)
-        target_w = min(decoded_5d.shape[3], reference_w)
-        decoded_5d = decoded_5d[:, :, :target_h, :target_w, :]
-        if color_correction_method in ("lab", "wavelet", "adain"):
-            reference_5d = reference_full[:b, :t, :, :, :]
-            reference_5d = cls._resize_reference(reference_5d, target_h, target_w)
-            output_device = decoded_5d.device
-            decoded_raw = cls._to_seedvr2_raw(decoded_5d)
-            reference_raw = cls._to_seedvr2_raw(reference_5d)
-            decoded_flat = decoded_raw.permute(0, 1, 4, 2, 3).reshape(b * t, decoded_raw.shape[4], target_h, target_w)
-            reference_flat = reference_raw.permute(0, 1, 4, 2, 3).reshape(b * t, reference_raw.shape[4], target_h, target_w)
-            output = cls._color_transfer_chunked(
-                decoded_flat, reference_flat, output_device, color_correction_method,
-            )
-            output = output.reshape(b, t, output.shape[1], output.shape[2], output.shape[3]).permute(0, 1, 3, 4, 2)
-            output = output.add(1.0).div(2.0).clamp(0.0, 1.0)
-        elif color_correction_method == "none":
-            output = decoded_5d
-        else:
-            raise ValueError(f"SeedVR2PostProcessing: unknown color_correction_method {color_correction_method!r}")
-
-        if alpha_input is not None:
-            alpha_5d, _ = cls._as_bthwc(alpha_input)
-            alpha_5d = alpha_5d[:output.shape[0], :output.shape[1], :output.shape[2], :output.shape[3], :]
-            output = torch.cat([output, alpha_5d.to(dtype=output.dtype, device=output.device)], dim=-1)
-        h2 = output.shape[-3] - (output.shape[-3] % 2)
-        w2 = output.shape[-2] - (output.shape[-2] % 2)
-        output = output[:, :, :h2, :w2, :]
-        if decoded_was_4d:
-            output = output.reshape(-1, output.shape[-3], output.shape[-2], output.shape[-1])
-        return io.NodeOutput(output)
-
-    @staticmethod
-    def _as_bthwc(images):
-        if images.ndim == 4:
-            return images.unsqueeze(0), True
-        if images.ndim == 5:
-            return images, False
-        raise ValueError(
-            f"SeedVR2PostProcessing: expected 4-D or 5-D IMAGE tensor, got shape {tuple(images.shape)}"
-        )
-
-    @staticmethod
-    def _restore_reference_batch_time(decoded, reference):
-        if decoded.shape[0] != 1:
-            return decoded
-        ref_b, ref_t = reference.shape[:2]
-        if ref_b < 1 or decoded.shape[1] % ref_b != 0:
-            return decoded
-        decoded_t = decoded.shape[1] // ref_b
-        if decoded_t < ref_t:
-            return decoded
-        return decoded.reshape(ref_b, decoded_t, decoded.shape[2], decoded.shape[3], decoded.shape[4])
-
-    @staticmethod
-    def _to_seedvr2_raw(images):
-        return images.mul(2.0).sub(1.0)
-
-    @staticmethod
-    def _color_transfer_on_vae_device(decoded_flat, reference_flat, output_device, transfer_fn):
-        color_device = comfy.model_management.vae_device()
-        decoded_flat = decoded_flat.to(device=color_device)
-        reference_flat = reference_flat.to(device=color_device)
-        output = transfer_fn(decoded_flat, reference_flat)
-        return output.to(device=output_device)
-
-    @staticmethod
-    def _lab_color_transfer_on_vae_device(decoded_flat, reference_flat, output_device):
-        color_device = comfy.model_management.vae_device()
-        result = None
-        for start in range(decoded_flat.shape[0]):
-            decoded_frame = decoded_flat[start:start + 1].to(device=color_device).clone()
-            reference_frame = reference_flat[start:start + 1].to(device=color_device).clone()
-            output = lab_color_transfer(decoded_frame, reference_frame).to(device=output_device)
-            if result is None:
-                result = torch.empty(
-                    (decoded_flat.shape[0],) + tuple(output.shape[1:]),
-                    device=output_device,
-                    dtype=output.dtype,
-                )
-            result[start:start + 1].copy_(output)
-        if result is None:
-            raise ValueError("SeedVR2PostProcessing: LAB color correction requires at least one frame.")
-        return result
-
-    @classmethod
-    def _color_transfer_chunked(cls, decoded_flat, reference_flat, output_device, color_correction_method):
-        chunk_size = cls._estimate_color_correction_chunk_size(decoded_flat, color_correction_method)
-        while True:
-            try:
-                return cls._run_color_transfer_chunks(
-                    decoded_flat, reference_flat, output_device, color_correction_method, chunk_size,
-                )
-            except Exception as e:
-                comfy.model_management.raise_non_oom(e)
-                if chunk_size <= 1:
-                    raise RuntimeError(
-                        "SeedVR2PostProcessing: color correction OOM at one frame; "
-                        f"color_correction_method={color_correction_method}, shape={tuple(decoded_flat.shape)}."
-                    ) from e
-                chunk_size = max(1, chunk_size // SEEDVR2_OOM_BACKOFF_DIVISOR)
-
-    @classmethod
-    def _run_color_transfer_chunks(cls, decoded_flat, reference_flat, output_device, color_correction_method, chunk_size):
-        result = None
-        for start in range(0, decoded_flat.shape[0], chunk_size):
-            end = min(start + chunk_size, decoded_flat.shape[0])
-            decoded_chunk = decoded_flat[start:end]
-            reference_chunk = reference_flat[start:end]
-            if color_correction_method == "lab":
-                output = cls._lab_color_transfer_on_vae_device(decoded_chunk, reference_chunk, output_device)
-            elif color_correction_method == "wavelet":
-                output = cls._color_transfer_on_vae_device(
-                    decoded_chunk, reference_chunk, output_device, wavelet_color_transfer,
-                )
-            else:
-                output = cls._color_transfer_on_vae_device(
-                    decoded_chunk, reference_chunk, output_device, adain_color_transfer,
-                )
-            if result is None:
-                result = torch.empty(
-                    (decoded_flat.shape[0],) + tuple(output.shape[1:]),
-                    device=output_device,
-                    dtype=output.dtype,
-                )
-            result[start:end].copy_(output)
-        if result is None:
-            raise ValueError("SeedVR2PostProcessing: color correction requires at least one frame.")
-        return result
-
-    @classmethod
-    def _estimate_color_correction_chunk_size(cls, decoded_flat, color_correction_method):
-        multiplier = cls._color_correction_memory_multiplier(color_correction_method)
-        frames = decoded_flat.shape[0]
-        _, channels, height, width = decoded_flat.shape
-        dtype_bytes = max(decoded_flat.element_size(), SEEDVR2_DTYPE_BYTES_FLOOR)
-        bytes_per_frame = height * width * channels * dtype_bytes * multiplier
-        if bytes_per_frame <= 0:
-            return frames
-        color_device = comfy.model_management.vae_device()
-        free_memory = comfy.model_management.get_free_memory(color_device)
-        chunk_size = int((free_memory * SEEDVR2_COLOR_MEM_HEADROOM) // bytes_per_frame)
-        return max(1, min(frames, chunk_size))
-
-    @staticmethod
-    def _color_correction_memory_multiplier(color_correction_method):
-        if color_correction_method == "lab":
-            return SEEDVR2_LAB_SCALE_MULTIPLIER
-        if color_correction_method == "wavelet":
-            return SEEDVR2_WAVELET_SCALE_MULTIPLIER
-        if color_correction_method == "adain":
-            return SEEDVR2_ADAIN_SCALE_MULTIPLIER
-        raise ValueError(f"SeedVR2PostProcessing: unknown color_correction_method {color_correction_method!r}")
-
-    @staticmethod
-    def _resize_reference(reference, height, width):
-        if reference.shape[2] == height and reference.shape[3] == width:
-            return reference
-        b, t = reference.shape[:2]
-        reference_flat = reference.permute(0, 1, 4, 2, 3).reshape(b * t, reference.shape[4], reference.shape[2], reference.shape[3])
-        resized = TVF.resize(
-            reference_flat,
-            size=(height, width),
-            interpolation=InterpolationMode.BICUBIC,
-            antialias=not (isinstance(reference_flat, torch.Tensor) and reference_flat.device.type == "mps"),
-        )
-        return resized.reshape(b, t, resized.shape[1], height, width).permute(0, 1, 3, 4, 2)
-
-
-class SeedVR2Conditioning(io.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return io.Schema(
-            node_id="SeedVR2Conditioning",
-            display_name="Apply SeedVR2 Conditioning",
-            category="model/conditioning",
-            description="Build SeedVR2 positive/negative conditioning from a VAE latent.",
-            search_aliases=["seedvr2", "upscale", "conditioning"],
-            inputs=[
-                io.Model.Input("model", tooltip="The SeedVR2 model."),
-                io.Latent.Input("vae_conditioning", display_name="latent"),
-            ],
-            outputs=[
-                io.Conditioning.Output(display_name="positive", tooltip="The positive conditioning for sampling."),
-                io.Conditioning.Output(display_name="negative", tooltip="The negative conditioning for sampling."),
-            ],
-        )
-
-    @classmethod
-    def execute(cls, model, vae_conditioning) -> io.NodeOutput:
-
-        vae_conditioning = vae_conditioning["samples"]
-        if vae_conditioning.ndim != 5:
-            raise ValueError(
-                "SeedVR2Conditioning expects a 5-D VAE latent in Comfy "
-                f"channel-first layout; got shape {tuple(vae_conditioning.shape)}."
-            )
-        if vae_conditioning.shape[1] != SEEDVR2_LATENT_CHANNELS:
-            if vae_conditioning.shape[-1] == SEEDVR2_LATENT_CHANNELS:
-                raise ValueError(
-                    "SeedVR2Conditioning expects SeedVR2 VAE latents in Comfy "
-                    f"channel-first layout (B, {SEEDVR2_LATENT_CHANNELS}, T, H, W); "
-                    f"got channel-last shape {tuple(vae_conditioning.shape)}."
-                )
-            raise ValueError(
-                "SeedVR2Conditioning expects SeedVR2 VAE latents with "
-                f"{SEEDVR2_LATENT_CHANNELS} channels; got shape {tuple(vae_conditioning.shape)}."
-            )
-        vae_conditioning = vae_conditioning.movedim(1, -1).contiguous()
-        model = _resolve_seedvr2_diffusion_model(model)
-        pos_cond = model.positive_conditioning
-        neg_cond = model.negative_conditioning
-
-        mask = vae_conditioning.new_ones(vae_conditioning.shape[:-1] + (1,))
-        condition = torch.cat((vae_conditioning, mask), dim=-1)
-        condition = condition.movedim(-1, 1)
-
-        negative = [[neg_cond.unsqueeze(0), {"condition": condition}]]
-        positive = [[pos_cond.unsqueeze(0), {"condition": condition}]]
-
-        return io.NodeOutput(positive, negative)
-
-def _seedvr2_chunk_crossfade_weights(overlap, device, dtype):
-    """Descending previous-chunk weights across the overlap (next chunk gets ``1 - w``): a Hann fade over the middle third, flat shoulders on the outer thirds."""
-    ramp = torch.linspace(0.0, 1.0, steps=overlap, device=device, dtype=dtype)
-    ramp = ((ramp - 1.0 / 3.0) / (1.0 / 3.0)).clamp(0.0, 1.0)
-    return 0.5 + 0.5 * torch.cos(torch.pi * ramp)
-
-
-class SeedVR2TemporalChunk(io.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return io.Schema(
-            node_id="SeedVR2TemporalChunk",
-            display_name="Split SeedVR2 Latent",
-            category="model/latent/batch",
-            description="Split a SeedVR2 video latent into overlapping temporal chunks small enough to sample one at a time within VRAM, wiring latents outputs to both Apply SeedVR2 Conditioning and the sampler latent input before recombining with Merge SeedVR2 Latents.",
-            search_aliases=["seedvr2", "split", "chunk", "temporal", "video upscale", "rebatch"],
-            inputs=[
-                io.Latent.Input("latent", tooltip="The VAE-encoded SeedVR2 latent to split."),
-                io.Int.Input("temporal_overlap", default=0, min=0, max=16384,
-                             tooltip="Latent frames shared between adjacent chunks and crossfaded at merge; 0 = no overlap."),
-                io.DynamicCombo.Input("chunking_mode",
-                                      tooltip="manual = use frames_per_chunk exactly; auto = predict the largest chunk that fits free VRAM.",
-                                      options=[
-                                          io.DynamicCombo.Option("auto", []),
-                                          io.DynamicCombo.Option("manual", [
-                                              io.Int.Input("frames_per_chunk", default=21, min=1, max=16384, step=4,
-                                                           tooltip="Pixel frames per temporal chunk (4n+1: 1, 5, 9, 13, ...)."),
-                                          ]),
-                                      ]),
-            ],
-            outputs=[
-                io.Latent.Output(display_name="latents", is_output_list=True,
-                                 tooltip="The temporal chunks in sequence order."),
-                io.Int.Output(display_name="temporal_overlap",
-                              tooltip="The effective latent-frame overlap between adjacent chunks, for Merge SeedVR2 Latents."),
-            ],
-        )
-
-    @classmethod
-    def execute(cls, latent, temporal_overlap, chunking_mode) -> io.NodeOutput:
-        samples = latent["samples"]
-        if samples.ndim != 5:
-            raise ValueError(
-                f"SeedVR2TemporalChunk: expected a 5-D video latent (B, C, T, H, W); "
-                f"got shape {tuple(samples.shape)}."
-            )
-        if samples.shape[1] != SEEDVR2_LATENT_CHANNELS:
-            raise ValueError(
-                f"SeedVR2TemporalChunk: expected {SEEDVR2_LATENT_CHANNELS} latent channels; "
-                f"got shape {tuple(samples.shape)}."
-            )
-        if temporal_overlap < 0:
-            raise ValueError(
-                f"SeedVR2TemporalChunk: temporal_overlap must be >= 0; got {temporal_overlap}."
-            )
-        mode = chunking_mode["chunking_mode"]
-        if mode not in ("auto", "manual"):
-            raise ValueError(
-                f"SeedVR2TemporalChunk: chunking_mode must be 'auto' or 'manual'; "
-                f"got {mode!r}."
-            )
-        t_latent = samples.shape[2]
-        t_pixel = 4 * (t_latent - 1) + 1
-
-        if mode == "auto":
-            free_gb = comfy.model_management.get_free_memory(
-                comfy.model_management.get_torch_device()) / (1024 ** 3)
-            mpx_per_frame = (samples.shape[0] * samples.shape[3] * samples.shape[4]) * (BYTEDANCE_VAE_SPATIAL_DOWNSAMPLE ** 2) / 1e6
-            budget_gb = free_gb - SEEDVR2_CHUNK_RESERVED_GIB - SEEDVR2_CHUNK_SIGMA_K * SEEDVR2_CHUNK_SIGMA_GIB
-            chunk_latent_max = max(1, int(budget_gb / (SEEDVR2_CHUNK_GIB_PER_MPX_FRAME * mpx_per_frame)))
-            frames_per_chunk = min(4 * (chunk_latent_max - 1) + 1, t_pixel)
-            logging.info(
-                "SeedVR2TemporalChunk auto: free=%.2fGiB, %.2fMpx -> frames_per_chunk=%d (t_pixel=%d).",
-                free_gb, mpx_per_frame, frames_per_chunk, t_pixel,
-            )
-        else:
-            frames_per_chunk = chunking_mode["frames_per_chunk"]
-            if frames_per_chunk < 1 or (frames_per_chunk - 1) % 4 != 0:
-                raise ValueError(
-                    f"SeedVR2TemporalChunk: frames_per_chunk must be a 4n+1 pixel-frame count "
-                    f"(1, 5, 9, 13, 17, 21, ...); got {frames_per_chunk}."
-                )
-
-        if t_pixel <= frames_per_chunk:
-            return io.NodeOutput([latent], 0)
-
-        chunk_latent = (frames_per_chunk - 1) // 4 + 1
-        temporal_overlap = min(temporal_overlap, chunk_latent - 1)
-        step = chunk_latent - temporal_overlap
-
-        chunks = []
-        for start in range(0, t_latent, step):
-            end = min(start + chunk_latent, t_latent)
-            chunk = latent.copy()
-            chunk["samples"] = samples[:, :, start:end].contiguous()
-            chunks.append(chunk)
-            if end >= t_latent:
-                break
-        return io.NodeOutput(chunks, temporal_overlap)
-
-
-class SeedVR2TemporalMerge(io.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return io.Schema(
-            node_id="SeedVR2TemporalMerge",
-            display_name="Merge SeedVR2 Latents",
-            category="model/latent/batch",
-            is_input_list=True,
-            description="Recombine sampled SeedVR2 latent temporal chunks into one latent, crossfading each overlap with a Hann window sized by the temporal_overlap wired from Split SeedVR2 Latent.",
-            search_aliases=["seedvr2", "merge", "temporal", "hann", "crossfade"],
-            inputs=[
-                io.Latent.Input("latents", tooltip="The sampled temporal chunks in sequence order."),
-                io.Int.Input("temporal_overlap", default=0, min=0, max=16384, force_input=True,
-                             tooltip="The temporal_overlap output of Split SeedVR2 Latent. 0 = plain concatenation."),
-            ],
-            outputs=[
-                io.Latent.Output(display_name="latent", tooltip="The recombined full-length latent."),
-            ],
-        )
-
-    @classmethod
-    def execute(cls, latents, temporal_overlap) -> io.NodeOutput:
-        temporal_overlap = temporal_overlap[0]
-        if temporal_overlap < 0:
-            raise ValueError(
-                f"SeedVR2TemporalMerge: temporal_overlap must be >= 0; got {temporal_overlap}."
-            )
-        chunks = [entry["samples"] for entry in latents]
-        first = chunks[0]
-        if first.ndim != 5:
-            raise ValueError(
-                f"SeedVR2TemporalMerge: expected 5-D video latents (B, C, T, H, W); "
-                f"chunk 0 has shape {tuple(first.shape)}."
-            )
-        for i, chunk in enumerate(chunks[1:], start=1):
-            if chunk.shape[:2] != first.shape[:2] or chunk.shape[3:] != first.shape[3:]:
-                raise ValueError(
-                    f"SeedVR2TemporalMerge: chunk {i} shape {tuple(chunk.shape)} does not "
-                    f"match chunk 0 shape {tuple(first.shape)} outside the temporal axis."
-                )
-            if i < len(chunks) - 1 and chunk.shape[2] != first.shape[2]:
-                raise ValueError(
-                    f"SeedVR2TemporalMerge: chunk {i} has {chunk.shape[2]} latent frames but "
-                    f"chunk 0 has {first.shape[2]}; only the final chunk may be shorter."
-                )
-
-        out = latents[0].copy()
-        out.pop("noise_mask", None)
-
-        if len(chunks) == 1:
-            out["samples"] = first
-            return io.NodeOutput(out)
-        if temporal_overlap == 0:
-            out["samples"] = torch.cat(chunks, dim=2)
-            return io.NodeOutput(out)
-
-        chunk_latent = first.shape[2]
-        step = chunk_latent - min(temporal_overlap, chunk_latent - 1)
-        t_total = step * (len(chunks) - 1) + chunks[-1].shape[2]
-        b, c, _, h, w = first.shape
-        merged = torch.empty((b, c, t_total, h, w), device=first.device, dtype=first.dtype)
-
-        merged[:, :, :chunk_latent] = first
-        filled = chunk_latent
-        for i, chunk in enumerate(chunks[1:], start=1):
-            start = i * step
-            end = start + chunk.shape[2]
-            # Crossfade width is bounded by the previous fill frontier and by a runt
-            # final chunk shorter than the configured overlap.
-            fade = min(filled - start, chunk.shape[2])
-            if fade > 0:
-                w_prev = _seedvr2_chunk_crossfade_weights(
-                    fade, chunk.device, chunk.dtype).view(1, 1, fade, 1, 1)
-                merged[:, :, start:start + fade] = (
-                    merged[:, :, start:start + fade] * w_prev + chunk[:, :, :fade] * (1.0 - w_prev)
-                )
-                merged[:, :, start + fade:end] = chunk[:, :, fade:]
-            else:
-                merged[:, :, start:end] = chunk
-            filled = end
-
-        out["samples"] = merged
-        return io.NodeOutput(out)
-
-
-class SeedVRExtension(ComfyExtension):
-    @override
-    async def get_node_list(self) -> list[type[io.ComfyNode]]:
-        return [
-            SeedVR2Conditioning,
-            SeedVR2Preprocess,
-            SeedVR2PostProcessing,
-            SeedVR2TemporalChunk,
-            SeedVR2TemporalMerge,
-        ]
-
-async def comfy_entrypoint() -> SeedVRExtension:
-    return SeedVRExtension()

comfy_extras/nodes_text_overlay.py

@@ -1,150 +0,0 @@
-import numpy as np
-import torch
-from PIL import Image as PILImage, ImageColor, ImageDraw, ImageFont
-from typing_extensions import override
-
-from comfy_api.latest import ComfyExtension, IO
-
-
-class TextOverlay(IO.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="TextOverlay",
-            display_name="Draw Text Overlay",
-            category="text",
-            description="Draw text overlay on an image or batch of images.",
-            search_aliases=["text", "label", "caption", "subtitle", "watermark", "title", "addlabel", "overlay"],
-            inputs=[
-                IO.Image.Input("images"),
-                IO.String.Input("text", multiline=True, default=""),
-                IO.Float.Input("font_size", default=5.0, min=0.5, max=50.0, step=0.5, tooltip="Font size as a percentage of the image height."),
-                IO.Color.Input("color", default="#ffffff", tooltip="Color of the text."),
-                IO.Combo.Input("position", options=["top", "bottom"], default="top"),
-                IO.Combo.Input("align", options=["left", "center", "right"], default="left"),
-                IO.Boolean.Input("outline", default=True, tooltip="Draw a black outline around the text."),
-            ],
-            outputs=[IO.Image.Output(display_name="images")],
-        )
-
-    @classmethod
-    def execute(cls, images, text, font_size, color, position, align, outline) -> IO.NodeOutput:
-        if text.strip() == "":
-            return IO.NodeOutput(images)
-
-        text = text.replace("\\n", "\n").replace("\\t", "\t")
-
-        text_rgba = cls.parse_color_to_rgba(color)
-        outline_rgba = (0, 0, 0, 255) if outline else (0, 0, 0, 0)
-
-        # Render the overlay once and composite it across all frames in the batch
-        height = images.shape[1]
-        width = images.shape[2]
-        overlay_rgb, overlay_alpha = cls.render_overlay_text(width, height, text, position, align, font_size, text_rgba, outline_rgba)
-        overlay_rgb = overlay_rgb.to(device=images.device, dtype=images.dtype)
-        overlay_alpha = overlay_alpha.to(device=images.device, dtype=images.dtype)
-
-        result = images * (1.0 - overlay_alpha) + overlay_rgb * overlay_alpha
-        return IO.NodeOutput(result)
-
-    @staticmethod
-    def parse_color_to_rgba(color_string):
-        parsed = ImageColor.getrgb(color_string)
-
-        if len(parsed) == 3:
-            return (*parsed, 255)
-
-        return parsed
-
-    @classmethod
-    def render_overlay_text(cls, width, height, text, position, align, font_size, text_rgba, outline_rgba):
-        line_spacing = 1.2
-        margin_percent = 1.0
-        min_font_percent = 2.0
-        min_font_pixels = 10
-        outline_thickness_factor = 0.04
-
-        # Draw onto a transparent layer so the result can be alpha-composited over any frame.
-        layer = PILImage.new("RGBA", (width, height), (0, 0, 0, 0))
-        draw = ImageDraw.Draw(layer)
-
-        margin = int(round(margin_percent / 100.0 * min(width, height)))
-        max_width = max(1, width - 2 * margin)
-        max_height = max(1, height - 2 * margin)
-
-        # Font scales with resolution, then shrinks to fit the height.
-        size = max(1, int(round(font_size / 100.0 * height)))
-        floor = min(size, max(min_font_pixels, int(round(min_font_percent / 100.0 * height))))
-
-        while True:
-            font = ImageFont.load_default(size=size)
-            stroke = max(1, int(round(size * outline_thickness_factor))) if outline_rgba[3] > 0 else 0
-            block = "\n".join(cls.wrap_text(text, font, max_width))
-            # convert line spacing to pixel spacing
-            single = draw.textbbox((0, 0), "Ay", font=font, stroke_width=stroke)
-            double = draw.multiline_textbbox((0, 0), "Ay\nAy", font=font, spacing=0, stroke_width=stroke)
-            natural_advance = (double[3] - double[1]) - (single[3] - single[1])
-            pixel_spacing = int(round(size * line_spacing - natural_advance))
-            box = draw.multiline_textbbox((0, 0), block, font=font, spacing=pixel_spacing, stroke_width=stroke)
-            block_height = box[3] - box[1]
-
-            if block_height <= max_height or size <= floor:
-                break
-
-            size = max(floor, int(size * 0.9))
-
-        anchor_h, x = {"left": ("l", margin), "center": ("m", width / 2), "right": ("r", width - margin)}[align]
-
-        # Offset y so the rendered text sits flush against the margin
-        if position == "bottom":
-            y = height - margin - box[3]
-        else:
-            y = margin - box[1]
-
-        draw.multiline_text((x, y), block, font=font, fill=text_rgba, anchor=anchor_h + "a",
-                            align=align, spacing=pixel_spacing, stroke_width=stroke, stroke_fill=outline_rgba)
-
-        overlay = np.array(layer).astype(np.float32) / 255.0
-        overlay_rgb = torch.from_numpy(overlay[:, :, :3])
-        overlay_alpha = torch.from_numpy(overlay[:, :, 3:4])
-        return overlay_rgb, overlay_alpha
-
-    @staticmethod
-    def wrap_text(text, font, max_width):
-        lines = []
-        for raw_line in text.split("\n"):
-            words = raw_line.split()
-            if not words:
-                lines.append("")
-                continue
-            current = ""
-            # Break the line into words and split words that are too long
-            for word in words:
-                while font.getlength(word) > max_width and len(word) > 1:
-                    cut = 1
-                    while cut < len(word) and font.getlength(word[:cut + 1]) <= max_width:
-                        cut += 1
-                    if current:
-                        lines.append(current)
-                        current = ""
-                    lines.append(word[:cut])
-                    word = word[cut:]
-                candidate = word if not current else current + " " + word
-                if not current or font.getlength(candidate) <= max_width:
-                    current = candidate
-                else:
-                    lines.append(current)
-                    current = word
-            if current:
-                lines.append(current)
-        return lines
-
-
-class TextOverlayExtension(ComfyExtension):
-    @override
-    async def get_node_list(self) -> list[type[IO.ComfyNode]]:
-        return [TextOverlay]
-
-
-async def comfy_entrypoint() -> TextOverlayExtension:
-    return TextOverlayExtension()

folder_paths.py

@@ -17,11 +17,7 @@ if args.base_directory:
 else:
     base_path = os.path.dirname(os.path.realpath(__file__))
 
-if args.models_directory:
-    models_dir = os.path.abspath(args.models_directory)
-else:
-    models_dir = os.path.join(base_path, "models")
-
+models_dir = os.path.join(base_path, "models")
 folder_names_and_paths["checkpoints"] = ([os.path.join(models_dir, "checkpoints")], supported_pt_extensions)
 folder_names_and_paths["configs"] = ([os.path.join(models_dir, "configs")], [".yaml"])
 

main.py

@@ -131,10 +131,6 @@ def apply_custom_paths():
     if args.base_directory:
         logging.info(f"Setting base directory to: {folder_paths.base_path}")
 
-    # --models-directory
-    if args.models_directory:
-        logging.info(f"Setting models directory to: {folder_paths.models_dir}")
-
     # --output-directory, --input-directory, --user-directory
     if args.output_directory:
         output_dir = os.path.abspath(args.output_directory)

nodes.py

@@ -2458,7 +2458,6 @@ async def init_builtin_extra_nodes():
         "nodes_camera_trajectory.py",
         "nodes_edit_model.py",
         "nodes_tcfg.py",
-        "nodes_seedvr.py",
         "nodes_context_windows.py",
         "nodes_qwen.py",
         "nodes_boogu.py",
@@ -2479,7 +2478,6 @@ async def init_builtin_extra_nodes():
         "nodes_glsl.py",
         "nodes_lora_debug.py",
         "nodes_textgen.py",
-        "nodes_text_overlay.py",
         "nodes_color.py",
         "nodes_toolkit.py",
         "nodes_replacements.py",
@@ -2504,6 +2502,7 @@ async def init_builtin_extra_nodes():
         "nodes_triposplat.py",
         "nodes_depth_anything_3.py",
         "nodes_seed.py",
+        "nodes_lora_stack.py",
     ]
 
     import_failed = []

requirements.txt

@@ -1,6 +1,6 @@
 comfyui-frontend-package==1.45.20
-comfyui-workflow-templates==0.11.6
-comfyui-embedded-docs==0.5.7
+comfyui-workflow-templates==0.11.2
+comfyui-embedded-docs==0.5.6
 torch
 torchsde
 torchvision

tests-unit/comfy_api_test/io_dynamic_group_test.py

@@ -0,0 +1,204 @@
+"""Unit tests for io.DynamicGroup: expansion/reconstruction (0-row and N-row cases)."""
+import sys
+import types
+import pytest
+
+# Stub torch (type-hint only in _io.py; real torch not available in unit-test env)
+if "torch" not in sys.modules:
+    _torch_stub = types.ModuleType("torch")
+    _torch_stub.Tensor = object  # type: ignore[attr-defined]
+    sys.modules["torch"] = _torch_stub
+
+from comfy_api.latest._io import (  # noqa: E402
+    DynamicGroup,
+    Float,
+    Int,
+    String,
+    Boolean,
+    get_finalized_class_inputs,
+    build_nested_inputs,
+    create_input_dict_v1,
+    setup_dynamic_input_funcs,
+)
+
+# Make sure dynamic input funcs are registered (may already be done at import time)
+setup_dynamic_input_funcs()
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_class_inputs(group_input: DynamicGroup.Input) -> dict:
+    """Wrap a DynamicGroup.Input into the required/optional dict structure."""
+    return create_input_dict_v1([group_input])
+
+
+def _run(group_input: DynamicGroup.Input, live_values: dict) -> dict:
+    """End-to-end helper: expand schema + reconstruct values.
+
+    Mirrors the production split in execution.py:
+      1. get_finalized_class_inputs  (schema expansion, line 162)
+      2. build_nested_inputs          (value reconstruction, line 281)
+
+    The two steps are separate in production because the engine resolves
+    linked node outputs between them, but in tests we supply values directly.
+    """
+    class_inputs = _make_class_inputs(group_input)
+    _, _, v3_data = get_finalized_class_inputs(class_inputs, live_values)
+    return build_nested_inputs(dict(live_values), v3_data)
+
+
+# ---------------------------------------------------------------------------
+# Schema construction
+# ---------------------------------------------------------------------------
+
+class TestDynamicGroupInputConstruction:
+    def test_basic_construction(self):
+        inp = DynamicGroup.Input(
+            "loras",
+            template=[
+                Float.Input("strength", default=1.0),
+                String.Input("name"),
+            ],
+            min=0,
+            max=10,
+        )
+        assert inp.id == "loras"
+        assert inp.min == 0
+        assert inp.max == 10
+        assert len(inp.template) == 2
+
+    def test_get_all_includes_self_and_template(self):
+        inp = DynamicGroup.Input(
+            "items",
+            template=[Float.Input("value")],
+        )
+        all_inputs = inp.get_all()
+        assert all_inputs[0] is inp
+        assert all_inputs[1].id == "value"
+
+    def test_as_dict_has_template_min_max(self):
+        inp = DynamicGroup.Input(
+            "items",
+            template=[Float.Input("val", default=0.5)],
+            min=1,
+            max=5,
+        )
+        d = inp.as_dict()
+        assert "template" in d
+        assert d["min"] == 1
+        assert d["max"] == 5
+
+    def test_duplicate_field_ids_raises(self):
+        with pytest.raises(AssertionError):
+            DynamicGroup.Input(
+                "bad",
+                template=[Float.Input("x"), Float.Input("x")],
+            )
+
+    def test_empty_template_raises(self):
+        with pytest.raises(AssertionError):
+            DynamicGroup.Input("bad", template=[])
+
+    def test_min_gt_max_raises(self):
+        with pytest.raises(AssertionError):
+            DynamicGroup.Input("bad", template=[Float.Input("x")], min=5, max=3)
+
+    def test_max_exceeds_limit_raises(self):
+        with pytest.raises(AssertionError):
+            DynamicGroup.Input("bad", template=[Float.Input("x")], max=101)
+
+    def test_dynamic_input_in_template_raises(self):
+        with pytest.raises(AssertionError):
+            DynamicGroup.Input(
+                "bad",
+                template=[DynamicGroup.Input("nested", template=[Float.Input("x")])],
+            )
+
+    def test_validate_calls_through(self):
+        inp = DynamicGroup.Input("items", template=[Float.Input("val", min=-1.0, max=1.0)])
+        inp.validate()  # should not raise
+
+
+# ---------------------------------------------------------------------------
+# 0-row case
+# ---------------------------------------------------------------------------
+
+class TestZeroRows:
+    def test_empty_live_inputs_produces_empty_list(self):
+        """With min=0 and no live values, the result should be an empty list."""
+        inp = DynamicGroup.Input("loras", template=[Float.Input("strength", default=1.0)], min=0, max=10)
+        assert _run(inp, {}).get("loras") == []
+
+    def test_min_zero_with_values(self):
+        """min=0 but 2 rows of live data."""
+        inp = DynamicGroup.Input("loras", template=[Float.Input("strength", default=1.0)], min=0, max=10)
+        result = _run(inp, {"loras.0.strength": 0.8, "loras.1.strength": 0.5})
+        assert result["loras"] == [{"strength": 0.8}, {"strength": 0.5}]
+
+
+# ---------------------------------------------------------------------------
+# N-row case
+# ---------------------------------------------------------------------------
+
+class TestNRows:
+    def test_two_rows_two_fields(self):
+        """Two rows with two fields each produce a list[dict]."""
+        inp = DynamicGroup.Input(
+            "loras",
+            template=[String.Input("lora_name"), Float.Input("strength", default=1.0)],
+            min=0, max=50,
+        )
+        result = _run(inp, {
+            "loras.0.lora_name": "model_a.safetensors", "loras.0.strength": 0.9,
+            "loras.1.lora_name": "model_b.safetensors", "loras.1.strength": 0.4,
+        })
+        assert result["loras"] == [
+            {"lora_name": "model_a.safetensors", "strength": 0.9},
+            {"lora_name": "model_b.safetensors", "strength": 0.4},
+        ]
+
+    def test_rows_are_sorted_by_index(self):
+        """Rows must be in ascending index order even if dict iteration is unordered."""
+        inp = DynamicGroup.Input("items", template=[Int.Input("v", default=0)], min=0, max=10)
+        result = _run(inp, {"items.0.v": 10, "items.2.v": 30, "items.1.v": 20})
+        assert [row["v"] for row in result["items"]] == [10, 20, 30]
+
+    def test_min_rows_schema_slots(self):
+        """With min=2 and no live data, 2 slots must appear in the expanded schema."""
+        inp = DynamicGroup.Input("items", template=[Float.Input("val", default=0.0)], min=2, max=5)
+        out, _, _ = get_finalized_class_inputs(_make_class_inputs(inp), {})
+        all_slots = {**out.get("required", {}), **out.get("optional", {})}
+        assert "items.0.val" in all_slots
+        assert "items.1.val" in all_slots
+
+    def test_min_rows_reconstructs_when_no_values(self):
+        """min=2 with NO live values must still yield a 2-element list,
+        not collapse to [] (regression: parent-path clobber)."""
+        inp = DynamicGroup.Input("items", template=[Float.Input("val", default=0.0)], min=2, max=5)
+        result = _run(inp, {})
+        assert len(result["items"]) == 2
+        assert all("val" in row for row in result["items"])
+
+    def test_min_rows_reconstructs_with_partial_values(self):
+        """min=2 with only the first row's value present still yields 2 rows."""
+        inp = DynamicGroup.Input("items", template=[Float.Input("val", default=0.0)], min=2, max=5)
+        result = _run(inp, {"items.0.val": 0.7})
+        assert len(result["items"]) == 2
+        assert result["items"][0]["val"] == 0.7
+        assert result["items"][1]["val"] is None
+
+    def test_list_paths_in_v3_data(self):
+        """list_paths must contain the group id so build_nested_inputs knows to convert."""
+        inp = DynamicGroup.Input("things", template=[Boolean.Input("flag")], min=0, max=5)
+        _, _, v3_data = get_finalized_class_inputs(_make_class_inputs(inp), {})
+        assert "things" in v3_data.get("list_paths", set())
+
+    def test_no_leftover_flat_keys(self):
+        """Flat keys must be consumed; only the reconstructed list remains."""
+        inp = DynamicGroup.Input("rows", template=[Float.Input("x", default=0.0)], min=0, max=5)
+        result = _run(inp, {"rows.0.x": 1.0, "rows.1.x": 2.0})
+        assert "rows.0.x" not in result
+        assert "rows.1.x" not in result
+        assert isinstance(result["rows"], list)

tests-unit/comfy_extras_test/test_seedvr2_conditioning.py

@@ -1,186 +0,0 @@
-"""SeedVR2 conditioning node regression tests."""
-
-import importlib
-import sys
-from unittest.mock import MagicMock
-
-import pytest
-import torch
-import torch.nn as nn
-
-from comfy.cli_args import args as cli_args
-from comfy.ldm.seedvr.constants import SEEDVR2_LATENT_CHANNELS
-
-if not torch.cuda.is_available():
-    cli_args.cpu = True
-
-
-_SENTINEL = object()
-_TARGETS = (
-    ("comfy.model_management", "comfy"),
-    ("comfy_extras.nodes_seedvr", "comfy_extras"),
-)
-
-
-def _import_nodes_seedvr_isolated():
-    """Import comfy_extras.nodes_seedvr with comfy.model_management mocked."""
-    priors = []
-    for mod_name, parent_name in _TARGETS:
-        prior_mod = sys.modules.get(mod_name, _SENTINEL)
-        parent = sys.modules.get(parent_name)
-        attr = mod_name.split(".")[-1]
-        prior_attr = (
-            getattr(parent, attr, _SENTINEL) if parent is not None else _SENTINEL
-        )
-        priors.append((mod_name, parent_name, attr, prior_mod, prior_attr))
-
-    mock_mm = MagicMock()
-    for fn in (
-        "xformers_enabled", "xformers_enabled_vae",
-        "pytorch_attention_enabled", "pytorch_attention_enabled_vae",
-        "sage_attention_enabled", "flash_attention_enabled",
-        "is_intel_xpu",
-    ):
-        getattr(mock_mm, fn).return_value = False
-    tv = torch.version.__version__.split(".")
-    mock_mm.torch_version_numeric = (int(tv[0]), int(tv[1]))
-    mock_mm.WINDOWS = False
-    sys.modules["comfy.model_management"] = mock_mm
-    if sys.modules.get("comfy") is None:
-        importlib.import_module("comfy")
-    comfy_pkg = sys.modules.get("comfy")
-    if comfy_pkg is not None:
-        setattr(comfy_pkg, "model_management", mock_mm)
-    nodes_seedvr = sys.modules.get("comfy_extras.nodes_seedvr") or (
-        importlib.import_module("comfy_extras.nodes_seedvr")
-    )
-
-    def _restore():
-        for mod_name, parent_name, attr, prior_mod, prior_attr in priors:
-            if prior_mod is _SENTINEL:
-                sys.modules.pop(mod_name, None)
-            else:
-                sys.modules[mod_name] = prior_mod
-            parent = sys.modules.get(parent_name)
-            if parent is None:
-                continue
-            if prior_attr is _SENTINEL:
-                if hasattr(parent, attr):
-                    delattr(parent, attr)
-            else:
-                setattr(parent, attr, prior_attr)
-
-    return nodes_seedvr, _restore
-
-
-class _Rope(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.freqs = nn.Parameter(torch.zeros(4))
-
-
-class _Block(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.rope = _Rope()
-
-
-class _DiffusionModel(nn.Module):
-    def __init__(self, n_blocks=3, conditioning_dtype=torch.float32):
-        super().__init__()
-        self.blocks = nn.ModuleList([_Block() for _ in range(n_blocks)])
-        self.register_buffer("positive_conditioning", torch.ones((2, 4), dtype=conditioning_dtype))
-        self.register_buffer("negative_conditioning", torch.zeros((3, 4), dtype=conditioning_dtype))
-
-
-class _ModelInner:
-    def __init__(self, diffusion_model):
-        self.diffusion_model = diffusion_model
-
-
-class _ModelPatcher:
-    def __init__(self, diffusion_model):
-        self.model = _ModelInner(diffusion_model)
-
-
-def test_seedvr2_conditioning_schema_exposes_conditioning_outputs():
-    nodes_seedvr, restore = _import_nodes_seedvr_isolated()
-    try:
-        schema = nodes_seedvr.SeedVR2Conditioning.define_schema()
-        assert [input_item.id for input_item in schema.inputs] == [
-            "model",
-            "vae_conditioning",
-        ]
-        assert schema.inputs[1].display_name == "latent"
-        assert [output.display_name for output in schema.outputs] == [
-            "positive",
-            "negative",
-        ]
-    finally:
-        restore()
-
-
-def test_seedvr2_conditioning_rejects_wrong_latent_channels():
-    nodes_seedvr, restore = _import_nodes_seedvr_isolated()
-    try:
-        patcher = _ModelPatcher(_DiffusionModel())
-        vae_conditioning = {"samples": torch.zeros(1, 8, 2, 2, 2)}
-
-        with pytest.raises(ValueError, match=f"{SEEDVR2_LATENT_CHANNELS} channels"):
-            nodes_seedvr.SeedVR2Conditioning.execute(patcher, vae_conditioning)
-    finally:
-        restore()
-
-
-def test_seedvr2_conditioning_returns_conditioning_deterministically():
-    nodes_seedvr, restore = _import_nodes_seedvr_isolated()
-    try:
-        diffusion_model = _DiffusionModel()
-        patcher = _ModelPatcher(diffusion_model)
-        samples = torch.arange(
-            1,
-            1 + SEEDVR2_LATENT_CHANNELS * 3 * 2 * 2,
-            dtype=torch.float32,
-        ).reshape(1, SEEDVR2_LATENT_CHANNELS, 3, 2, 2)
-        vae_conditioning = {"samples": samples}
-
-        first_positive, first_negative = (
-            nodes_seedvr.SeedVR2Conditioning.execute(
-                patcher,
-                vae_conditioning,
-            )
-        )
-        second_positive, second_negative = (
-            nodes_seedvr.SeedVR2Conditioning.execute(
-                patcher,
-                vae_conditioning,
-            )
-        )
-
-        channel_last = samples.movedim(1, -1).contiguous()
-        expected_condition = torch.cat(
-            [
-                channel_last,
-                torch.ones((*channel_last.shape[:-1], 1)),
-            ],
-            dim=-1,
-        ).movedim(-1, 1)
-
-        assert torch.equal(
-            first_positive[0][1]["condition"],
-            expected_condition,
-        )
-        assert torch.equal(
-            second_positive[0][1]["condition"],
-            expected_condition,
-        )
-        assert torch.equal(
-            first_negative[0][1]["condition"],
-            expected_condition,
-        )
-        assert torch.equal(
-            second_negative[0][1]["condition"],
-            expected_condition,
-        )
-    finally:
-        restore()

tests-unit/comfy_extras_test/test_seedvr2_nodes.py

@@ -1,55 +0,0 @@
-import importlib
-import inspect
-import sys
-from unittest.mock import MagicMock, patch
-
-import torch
-
-from comfy.cli_args import args as cli_args
-
-if not torch.cuda.is_available():
-    cli_args.cpu = True
-
-
-def test_seedvr_node_signature_matches_schema():
-    mock_mm = MagicMock()
-    mock_mm.xformers_enabled.return_value = False
-    mock_mm.xformers_enabled_vae.return_value = False
-    mock_mm.sage_attention_enabled.return_value = False
-    mock_mm.flash_attention_enabled.return_value = False
-
-    sentinel = object()
-    prior_cpu = cli_args.cpu
-    cli_args.cpu = True
-    prior_module = sys.modules.get("comfy_extras.nodes_seedvr", sentinel)
-    comfy_pkg = sys.modules.get("comfy")
-    prior_mm_attr = getattr(comfy_pkg, "model_management", sentinel) if comfy_pkg else sentinel
-
-    with patch.dict(sys.modules, {"comfy.model_management": mock_mm}):
-        if comfy_pkg is not None:
-            setattr(comfy_pkg, "model_management", mock_mm)
-        sys.modules.pop("comfy_extras.nodes_seedvr", None)
-        try:
-            nodes_seedvr = importlib.import_module("comfy_extras.nodes_seedvr")
-            for node_cls in (nodes_seedvr.SeedVR2Preprocess, nodes_seedvr.SeedVR2PostProcessing, nodes_seedvr.SeedVR2Conditioning):
-                schema_ids = [i.id for i in node_cls.define_schema().inputs]
-                exec_params = [
-                    p for p in inspect.signature(node_cls.execute).parameters.keys()
-                    if p != "cls"
-                ]
-                assert schema_ids == exec_params, (
-                    f"{node_cls.__name__} schema/execute drift: "
-                    f"schema_ids={schema_ids}, exec_params={exec_params}"
-                )
-        finally:
-            cli_args.cpu = prior_cpu
-            if prior_module is sentinel:
-                sys.modules.pop("comfy_extras.nodes_seedvr", None)
-            else:
-                sys.modules["comfy_extras.nodes_seedvr"] = prior_module
-            if comfy_pkg is not None:
-                if prior_mm_attr is sentinel:
-                    if hasattr(comfy_pkg, "model_management"):
-                        delattr(comfy_pkg, "model_management")
-                else:
-                    setattr(comfy_pkg, "model_management", prior_mm_attr)

tests-unit/comfy_extras_test/test_seedvr2_post_processing.py

@@ -1,51 +0,0 @@
-from unittest.mock import patch
-
-import pytest
-import torch
-
-from comfy.cli_args import args as cli_args
-
-if not torch.cuda.is_available():
-    cli_args.cpu = True
-
-from comfy_extras import nodes_seedvr  # noqa: E402
-
-
-def _schema_ids(items):
-    return [item.id for item in items]
-
-
-def test_seedvr2_post_processing_schema():
-    schema = nodes_seedvr.SeedVR2PostProcessing.define_schema()
-
-    assert _schema_ids(schema.inputs) == ["images", "original_resized_images", "color_correction_method"]
-    assert schema.inputs[2].options == ["lab", "wavelet", "adain", "none"]
-    assert schema.inputs[2].default == "lab"
-    assert schema.outputs[0].get_io_type() == "IMAGE"
-
-
-def test_seedvr2_post_processing_oom_error_uses_color_correction_method(monkeypatch):
-    decoded = torch.full((1, 3, 4, 4), 0.25)
-    reference = torch.full((1, 3, 4, 4), 0.75)
-
-    def _lab(content, style):
-        raise torch.cuda.OutOfMemoryError("CUDA out of memory")
-
-    monkeypatch.setattr(nodes_seedvr.comfy.model_management, "vae_device", lambda: torch.device("cpu"))
-    monkeypatch.setattr(nodes_seedvr.comfy.model_management, "get_free_memory", lambda device: 1_000_000)
-
-    with patch.object(nodes_seedvr, "lab_color_transfer", _lab):
-        with pytest.raises(RuntimeError) as excinfo:
-            nodes_seedvr.SeedVR2PostProcessing._color_transfer_chunked(
-                decoded, reference, torch.device("cpu"), "lab",
-            )
-    assert "color_correction_method=lab" in str(excinfo.value)
-    assert " method=lab" not in str(excinfo.value)
-
-
-def test_seedvr2_post_processing_unknown_color_correction_method_raises():
-    decoded = torch.zeros(1, 2, 4, 4, 3)
-    original = torch.zeros(1, 2, 4, 4, 3)
-    with pytest.raises(ValueError) as excinfo:
-        nodes_seedvr.SeedVR2PostProcessing.execute(decoded, original, "bogus")
-    assert "color_correction_method" in str(excinfo.value)

tests-unit/comfy_extras_test/test_seedvr2_temporal_chunk.py

@@ -1,65 +0,0 @@
-"""SeedVR2 temporal chunk/merge node regression tests."""
-
-import pytest
-import torch
-
-from comfy.cli_args import args as cli_args
-from comfy.ldm.seedvr.constants import SEEDVR2_LATENT_CHANNELS
-
-if not torch.cuda.is_available():
-    cli_args.cpu = True
-
-import comfy.model_management  # noqa: E402
-from comfy_extras.nodes_seedvr import SeedVR2TemporalChunk, SeedVR2TemporalMerge, _seedvr2_chunk_crossfade_weights  # noqa: E402
-
-def _latent(t_latent, h=8, w=8, b=1):
-    g = torch.Generator().manual_seed(7)
-    return {"samples": torch.randn(b, SEEDVR2_LATENT_CHANNELS, t_latent, h, w, generator=g)}
-
-def _split(latent, frames_per_chunk, temporal_overlap, chunking_mode="manual"):
-    combo = {"chunking_mode": chunking_mode}
-    if chunking_mode != "auto":
-        combo["frames_per_chunk"] = frames_per_chunk
-    return SeedVR2TemporalChunk.execute(latent, temporal_overlap, combo).args
-
-def _merge(chunks, temporal_overlap):
-    return SeedVR2TemporalMerge.execute(chunks, [temporal_overlap]).args[0]
-
-def test_chunk_temporal_windows_and_validation():
-    with pytest.raises(ValueError, match="4n\\+1"):
-        _split(_latent(9), 20, 0)
-    with pytest.raises(ValueError, match="5-D"):
-        _split({"samples": torch.zeros(1, SEEDVR2_LATENT_CHANNELS * 9, 8, 8)}, 21, 0)
-    with pytest.raises(ValueError, match="chunking_mode"):
-        _split(_latent(13), 21, 0, "adaptive")
-    latent = _latent(13)
-    chunks, overlap = _split(latent, 21, 2)  # chunk_latent=6, step=4 -> [0:6], [4:10], [8:13]
-    assert overlap == 2 and [c["samples"].shape[2] for c in chunks] == [6, 6, 5]
-    assert all(torch.equal(c["samples"], latent["samples"][:, :, s:e]) for c, (s, e) in zip(chunks, [(0, 6), (4, 10), (8, 13)]))
-    assert len(_split(_latent(13), 21, 999)[0]) == 8  # overlap clamps to chunk_latent-1 -> step=1
-    assert (r := _split(_latent(5), 21, 3)) and len(r[0]) == 1 and r[1] == 0  # t_pixel <= 21: passthrough
-
-def test_chunk_auto_mode_applies_vram_law(monkeypatch):
-    monkeypatch.setattr(comfy.model_management, "get_free_memory", lambda dev=None: 10.8 * (1024 ** 3))
-    # budget = 10.8 - 8.5 - 4*0.55 = 0.1 GiB; 32x32 latent = 0.0655 Mpx -> chunk_latent = 5
-    assert [c["samples"].shape[2] for c in _split(_latent(13, h=32, w=32), 1, 0, "auto")[0]] == [5, 5, 3]
-    assert _split(_latent(13, h=32, w=32, b=2), 1, 0, "auto")[0][0]["samples"].shape[2] == 2  # batch halves the chunk
-
-def test_merge_crossfade_and_reassembly():
-    latent = _latent(13)
-    latent["noise_mask"] = torch.rand(1, 1, 13, 8, 8)
-    latent["batch_index"] = [0]
-    merged = _merge(_split(latent, 21, 0)[0], 0)
-    assert torch.equal(merged["samples"], latent["samples"])
-    assert "noise_mask" not in merged and merged["batch_index"] == [0]
-    assert torch.allclose(_merge(_split(latent, 21, 3)[0], 3)["samples"], latent["samples"], atol=1e-6)
-    w = _seedvr2_chunk_crossfade_weights(3, merged["samples"].device, merged["samples"].dtype)
-    assert w[0] == 1.0 and w[-1] == 0.0 and torch.all(w[:-1] >= w[1:])
-    ones, zeros = {"samples": torch.ones(1, SEEDVR2_LATENT_CHANNELS, 6, 8, 8)}, {"samples": torch.zeros(1, SEEDVR2_LATENT_CHANNELS, 6, 8, 8)}
-    fused = _merge([ones, zeros], 3)["samples"]  # overlap equals w: prev fades out, next fades in
-    assert torch.equal(fused[:, :, 3:6], w.view(1, 1, 3, 1, 1).expand(1, SEEDVR2_LATENT_CHANNELS, 3, 8, 8))
-    assert torch.equal(fused[:, :, :3], ones["samples"][:, :, :3]) and torch.equal(fused[:, :, 6:], zeros["samples"][:, :, :3])
-    short = _split(latent, 21, 2)[0]
-    short[0]["samples"] = short[0]["samples"][:, :, :4]
-    with pytest.raises(ValueError, match="only the final chunk may be shorter"):
-        _merge(short, 2)

tests-unit/comfy_test/folder_path_test.py

@@ -163,20 +163,3 @@ def test_base_path_change_clears_old(set_base_dir):
 
     for name in ["controlnet", "diffusion_models", "text_encoders"]:
         assert len(folder_paths.get_folder_paths(name)) == 2
-
-
-def test_models_directory_cli_and_getters(temp_dir):
-    try:
-        with patch.object(sys, 'argv', ["main.py", "--models-directory", temp_dir]):
-            reload(comfy.cli_args)
-            reload(folder_paths)
-
-        assert folder_paths.models_dir == os.path.abspath(temp_dir)
-
-        with pytest.raises(Exception):
-            comfy.cli_args.is_valid_directory(os.path.join(temp_dir, "non_existent_folder_path"))
-    finally:
-        with patch.object(sys, 'argv', ["main.py"]):
-            reload(comfy.cli_args)
-            reload(folder_paths)
-

tests-unit/comfy_test/model_detection_test.py

@@ -2,7 +2,7 @@ from collections import defaultdict
 
 import torch
 
-from comfy.model_detection import detect_unet_config, model_config_from_unet, model_config_from_unet_config
+from comfy.model_detection import detect_unet_config, model_config_from_unet_config
 import comfy.supported_models
 
 
@@ -73,34 +73,6 @@ def _make_flux_schnell_comfyui_sd():
     return sd
 
 
-def _make_seedvr2_7b_separate_mm_sd():
-    return {
-        "blocks.35.mlp.vid.proj_out.weight": torch.empty(3072, 1),
-        "positive_conditioning": torch.empty(58, 5120),
-        "negative_conditioning": torch.empty(64, 5120),
-    }
-
-
-def _make_seedvr2_7b_shared_mm_sd():
-    return {
-        "blocks.35.mlp.all.proj_in_gate.weight": torch.empty(1, 1),
-        "positive_conditioning": torch.empty(58, 5120),
-        "negative_conditioning": torch.empty(64, 5120),
-    }
-
-
-def _make_seedvr2_3b_shared_mm_sd():
-    return {
-        "blocks.31.mlp.all.proj_in_gate.weight": torch.empty(1, 1),
-        "positive_conditioning": torch.empty(58, 5120),
-        "negative_conditioning": torch.empty(64, 5120),
-    }
-
-
-def _add_model_diffusion_prefix(sd):
-    return {f"model.diffusion_model.{k}": v for k, v in sd.items()}
-
-
 class TestModelDetection:
     """Verify that first-match model detection selects the correct model
     based on list ordering and unet_config specificity."""
@@ -153,70 +125,6 @@ class TestModelDetection:
         assert model_config is not None
         assert type(model_config).__name__ == "FluxSchnell"
 
-    def test_seedvr2_7b_separate_mm_detection_config(self):
-        sd = _make_seedvr2_7b_separate_mm_sd()
-        unet_config = detect_unet_config(sd, "")
-
-        assert unet_config is not None
-        assert unet_config["image_model"] == "seedvr2"
-        assert unet_config["vid_dim"] == 3072
-        assert unet_config["heads"] == 24
-        assert unet_config["num_layers"] == 36
-        assert unet_config["mm_layers"] == 36
-        assert unet_config["mlp_type"] == "normal"
-        assert unet_config["rope_type"] == "rope3d"
-        assert unet_config["rope_dim"] == 64
-
-    def test_seedvr2_7b_shared_mm_detection_config(self):
-        sd = _make_seedvr2_7b_shared_mm_sd()
-        unet_config = detect_unet_config(sd, "")
-
-        assert unet_config is not None
-        assert unet_config["image_model"] == "seedvr2"
-        assert unet_config["vid_dim"] == 3072
-        assert unet_config["heads"] == 24
-        assert unet_config["num_layers"] == 36
-        assert unet_config["mm_layers"] == 10
-        assert unet_config["mlp_type"] == "swiglu"
-        assert unet_config["rope_type"] == "rope3d"
-        assert unet_config["rope_dim"] == 64
-
-    def test_seedvr2_3b_shared_mm_detection_config(self):
-        sd = _make_seedvr2_3b_shared_mm_sd()
-        unet_config = detect_unet_config(sd, "")
-
-        assert unet_config is not None
-        assert unet_config["image_model"] == "seedvr2"
-        assert unet_config["vid_dim"] == 2560
-        assert unet_config["heads"] == 20
-        assert unet_config["num_layers"] == 32
-        assert unet_config["mlp_type"] == "swiglu"
-
-    def test_seedvr2_model_match_requires_conditioning_tensors(self):
-        sd = _make_seedvr2_7b_shared_mm_sd()
-        unet_config = detect_unet_config(sd, "")
-
-        assert type(model_config_from_unet_config(unet_config, sd)).__name__ == "SeedVR2"
-
-        del sd["positive_conditioning"]
-        assert model_config_from_unet_config(unet_config, sd) is None
-
-    def test_seedvr2_model_match_normalizes_num_heads(self):
-        sd = _make_seedvr2_7b_shared_mm_sd()
-        unet_config = detect_unet_config(sd, "")
-        unet_config["num_heads"] = unet_config.pop("heads")
-
-        model_config = model_config_from_unet_config(unet_config, sd)
-
-        assert type(model_config).__name__ == "SeedVR2"
-        assert model_config.unet_config["heads"] == 24
-        assert "num_heads" not in model_config.unet_config
-
-    def test_seedvr2_model_match_accepts_full_checkpoint_prefix(self):
-        sd = _add_model_diffusion_prefix(_make_seedvr2_7b_shared_mm_sd())
-
-        assert type(model_config_from_unet(sd, "model.diffusion_model.")).__name__ == "SeedVR2"
-
     def test_unet_config_and_required_keys_combination_is_unique(self):
         """Each model in the registry must have a unique combination of
         ``unet_config`` and ``required_keys``. If two models share the same

tests-unit/comfy_test/seedvr_vae_forward_test.py

@@ -1,74 +0,0 @@
-"""Regression tests for the SeedVR2 VAE forward return contract."""
-
-import pytest
-import torch
-import torch.nn as nn
-
-from comfy.cli_args import args as cli_args
-
-if not torch.cuda.is_available():
-    cli_args.cpu = True
-
-from comfy.ldm.seedvr.vae import SEEDVR2_LATENT_CHANNELS, VideoAutoencoderKL  # noqa: E402
-
-
-_LATENT_SHAPE = (1, SEEDVR2_LATENT_CHANNELS, 2, 2, 2)
-_DECODED_SHAPE = (1, 3, 5, 16, 16)
-_INPUT_ENCODE_SHAPE = (1, 3, 5, 16, 16)
-_INPUT_DECODE_SHAPE = _LATENT_SHAPE
-
-
-class _StubVAE(VideoAutoencoderKL):
-    def __init__(self):
-        nn.Module.__init__(self)
-        self._encode_out = torch.zeros(*_LATENT_SHAPE)
-        self._decode_out = torch.zeros(*_DECODED_SHAPE)
-
-    def encode(self, x, return_dict=True):
-        return self._encode_out
-
-    def decode_(self, z, return_dict=True):
-        return self._decode_out
-
-
-def test_forward_encode_returns_tensor():
-    vae = _StubVAE()
-    x = torch.zeros(*_INPUT_ENCODE_SHAPE)
-    result = vae.forward(x, mode="encode")
-    assert type(result) is torch.Tensor
-    assert result.shape == torch.Size(_LATENT_SHAPE)
-
-
-def test_forward_decode_returns_tensor():
-    vae = _StubVAE()
-    z = torch.zeros(*_INPUT_DECODE_SHAPE)
-    result = vae.forward(z, mode="decode")
-    assert type(result) is torch.Tensor
-    assert result.shape == torch.Size(_DECODED_SHAPE)
-
-
-class _TupleReturningStubVAE(VideoAutoencoderKL):
-    def __init__(self):
-        nn.Module.__init__(self)
-        self._encode_tensor = torch.zeros(*_LATENT_SHAPE)
-        self._decode_tensor = torch.zeros(*_DECODED_SHAPE)
-
-    def encode(self, x, return_dict=True):
-        return (self._encode_tensor,)
-
-    def decode_(self, z, return_dict=True):
-        return (self._decode_tensor,)
-
-
-def test_forward_all_unwraps_one_tuple_at_each_step():
-    vae = _TupleReturningStubVAE()
-    x = torch.zeros(*_INPUT_ENCODE_SHAPE)
-    result = vae.forward(x, mode="all")
-    assert type(result) is torch.Tensor
-    assert result.shape == torch.Size(_DECODED_SHAPE)
-
-
-def test_forward_rejects_unknown_mode():
-    vae = _StubVAE()
-    with pytest.raises(ValueError, match="Unknown SeedVR2 VAE forward mode"):
-        vae.forward(torch.zeros(*_INPUT_ENCODE_SHAPE), mode="bogus")

tests-unit/comfy_test/test_seedvr2_dtype.py

@@ -1,50 +0,0 @@
-import torch
-
-from comfy.cli_args import args as cli_args
-
-if not torch.cuda.is_available():
-    cli_args.cpu = True
-
-import comfy.sd
-import comfy.supported_models
-import comfy.ldm.seedvr.model as seedvr_model
-import comfy.ldm.seedvr.vae as seedvr_vae
-
-
-def test_seedvr2_fp16_manual_cast_only_for_bf16_device(monkeypatch):
-    bf16_device = object()
-    fp16_device = object()
-
-    monkeypatch.setattr(
-        comfy.supported_models.comfy.model_management,
-        "should_use_bf16",
-        lambda device=None: device is bf16_device,
-    )
-
-    bf16_config = comfy.supported_models.SeedVR2({"image_model": "seedvr2"})
-    bf16_config.set_inference_dtype(torch.float16, None, device=bf16_device)
-    assert bf16_config.manual_cast_dtype is torch.bfloat16
-
-    fp16_config = comfy.supported_models.SeedVR2({"image_model": "seedvr2"})
-    fp16_config.set_inference_dtype(torch.float16, None, device=fp16_device)
-    assert fp16_config.manual_cast_dtype is None
-
-
-def test_seedvr2_text_conditioning_accepts_cfg1_single_branch():
-    context = torch.arange(6, dtype=torch.float32).reshape(1, 3, 2)
-
-    txt, txt_shape = seedvr_model.NaDiT._resolve_text_conditioning(object(), context, [0])
-
-    torch.testing.assert_close(txt, context.squeeze(0))
-    torch.testing.assert_close(txt_shape, torch.tensor([[3]], device=context.device))
-
-
-def test_seedvr2_vae_decode_memory_covers_full_frame_lab_transfer():
-    wrapper = seedvr_vae.VideoAutoencoderKLWrapper.__new__(seedvr_vae.VideoAutoencoderKLWrapper)
-    latent_channels = seedvr_vae.SEEDVR2_LATENT_CHANNELS
-    estimate = wrapper.comfy_memory_used_decode((1, latent_channels, 26, 120, 160))
-    old_estimate = latent_channels * 120 * 160 * (4 * 8 * 8) * 2
-
-    assert estimate == 101 * 960 * 1280 * 160
-    assert estimate > 15 * 1024 ** 3
-    assert estimate > old_estimate * 100

tests-unit/comfy_test/test_seedvr2_internals.py

@@ -1,169 +0,0 @@
-"""SeedVR2 internals regression tests."""
-
-from __future__ import annotations
-
-from unittest.mock import patch
-
-import pytest
-import torch
-
-from comfy.cli_args import args
-
-if not torch.cuda.is_available():
-    args.cpu = True
-
-import comfy.ldm.seedvr.model as seedvr_model  # noqa: E402
-import comfy.ldm.seedvr.vae as vae_mod  # noqa: E402
-import comfy.ldm.modules.attention as attention  # noqa: E402
-import comfy.ops as comfy_ops  # noqa: E402
-from comfy.ldm.seedvr.vae import (  # noqa: E402
-    causal_norm_wrapper,
-    set_norm_limit,
-)
-from comfy.ldm.seedvr.attention import var_attention_optimized_split  # noqa: E402
-
-
-_NUM_CHANNELS = 8
-_NUM_GROUPS = 4
-_TENSOR_SHAPE = (1, 8, 2, 4, 4)
-
-_GROUPNORM_SUBCLASSES = [
-    pytest.param(comfy_ops.disable_weight_init.GroupNorm, id="disable_weight_init"),
-    pytest.param(comfy_ops.manual_cast.GroupNorm, id="manual_cast"),
-]
-
-
-@pytest.mark.parametrize("groupnorm_cls", _GROUPNORM_SUBCLASSES)
-def test_seedvr_groupnorm_low_limit_uses_chunked_groupnorm_path(groupnorm_cls):
-    real_group_norm = vae_mod.F.group_norm
-    set_norm_limit(1e-9)
-    try:
-        gn = groupnorm_cls(num_channels=_NUM_CHANNELS, num_groups=_NUM_GROUPS)
-        gn.eval()
-
-        forward_hook_calls = []
-
-        def _hook(module, inputs, output):
-            forward_hook_calls.append(tuple(inputs[0].shape))
-
-        spy_calls = []
-
-        def _group_norm_spy(input_tensor, num_groups_arg, *args, **kwargs):
-            spy_calls.append({"num_groups": int(num_groups_arg)})
-            return real_group_norm(input_tensor, num_groups_arg, *args, **kwargs)
-
-        handle = gn.register_forward_hook(_hook)
-        try:
-            with patch.object(vae_mod.F, "group_norm", side_effect=_group_norm_spy):
-                out_tensor = causal_norm_wrapper(gn, torch.randn(*_TENSOR_SHAPE))
-        finally:
-            handle.remove()
-
-        full_calls = len(forward_hook_calls)
-        chunked_calls = sum(1 for entry in spy_calls if entry["num_groups"] < _NUM_GROUPS)
-
-        assert tuple(int(s) for s in out_tensor.shape) == _TENSOR_SHAPE
-        assert full_calls == 0, (
-            f"low-limit GroupNorm gate must NOT take the full-forward path; got full_calls={full_calls}"
-        )
-        assert chunked_calls > 0, (
-            f"low-limit GroupNorm gate must take the chunked path; got chunked_calls={chunked_calls}"
-        )
-    finally:
-        set_norm_limit(None)
-
-
-def test_seedvr2_7b_swin_attention_forward_uses_optimized_var_attention(monkeypatch):
-    dim = 8
-    heads = 2
-    head_dim = 4
-    attn = seedvr_model.NaSwinAttention(
-        vid_dim=dim,
-        txt_dim=dim,
-        heads=heads,
-        head_dim=head_dim,
-        qk_bias=False,
-        qk_norm=comfy_ops.disable_weight_init.RMSNorm,
-        qk_norm_eps=1e-6,
-        rope_type=None,
-        rope_dim=head_dim,
-        shared_weights=False,
-        window=(2, 1, 1),
-        window_method="720pwin_by_size_bysize",
-        version=True,
-        device="cpu",
-        dtype=torch.float32,
-        operations=comfy_ops.disable_weight_init,
-    )
-    generator = torch.Generator(device="cpu").manual_seed(11)
-    vid = torch.randn(8, dim, generator=generator)
-    txt = torch.randn(3, dim, generator=generator)
-    vid_shape = torch.tensor([[2, 2, 2]], dtype=torch.long)
-    txt_shape = torch.tensor([[3]], dtype=torch.long)
-    calls = []
-
-    def fake_optimized_var_attention(**kwargs):
-        calls.append(kwargs)
-        return kwargs["q"]
-
-    monkeypatch.setattr(seedvr_model, "optimized_var_attention", fake_optimized_var_attention)
-
-    vid_out, txt_out = attn(vid, txt, vid_shape, txt_shape, seedvr_model.Cache(disable=True))
-
-    assert tuple(vid_out.shape) == (8, dim)
-    assert tuple(txt_out.shape) == (3, dim)
-    assert len(calls) == 1
-    call = calls[0]
-    assert tuple(call["q"].shape) == (14, heads, head_dim)
-    assert tuple(call["k"].shape) == (14, heads, head_dim)
-    assert tuple(call["v"].shape) == (14, heads, head_dim)
-    assert call["heads"] == heads
-    assert call["skip_reshape"] is True
-    assert call["skip_output_reshape"] is True
-    assert call["cu_seqlens_q"] == [0, 7, 14]
-    assert call["cu_seqlens_k"] == [0, 7, 14]
-
-
-def test_var_attention_optimized_split_calls_dense_backend_per_window(monkeypatch):
-    heads = 2
-    head_dim = 3
-    q = torch.arange(30, dtype=torch.float32).reshape(5, heads, head_dim)
-    k = q + 100
-    v = q + 200
-    cu = [0, 2, 5]
-    calls = []
-
-    def fake_optimized_attention(q_arg, k_arg, v_arg, heads_arg, **kwargs):
-        calls.append(
-            {
-                "q_shape": tuple(q_arg.shape),
-                "k_shape": tuple(k_arg.shape),
-                "v_shape": tuple(v_arg.shape),
-                "heads": heads_arg,
-                "kwargs": kwargs,
-            }
-        )
-        return q_arg + v_arg
-
-    monkeypatch.setattr(attention, "optimized_attention", fake_optimized_attention)
-
-    out = var_attention_optimized_split(
-        q,
-        k,
-        v,
-        heads,
-        cu,
-        cu,
-        skip_reshape=True,
-        skip_output_reshape=True,
-    )
-
-    assert tuple(out.shape) == (5, heads, head_dim)
-    assert len(calls) == 2
-    assert calls[0]["q_shape"] == (1, heads, 2, head_dim)
-    assert calls[1]["q_shape"] == (1, heads, 3, head_dim)
-    assert all(call["heads"] == heads for call in calls)
-    assert all(call["kwargs"]["skip_reshape"] is True for call in calls)
-    assert all(call["kwargs"]["skip_output_reshape"] is True for call in calls)
-    torch.testing.assert_close(out, q + v, rtol=0, atol=0)
-

tests-unit/comfy_test/test_seedvr2_model.py

@@ -1,320 +0,0 @@
-"""SeedVR2 model, latent-format, and VAE graph regression tests."""
-
-from __future__ import annotations
-
-from unittest.mock import MagicMock
-
-import pytest
-import torch
-from torch import nn
-
-from comfy.cli_args import args
-
-if not torch.cuda.is_available():
-    args.cpu = True
-
-import comfy  # noqa: E402
-import comfy.latent_formats  # noqa: E402
-import comfy.ldm.seedvr.model as seedvr_model  # noqa: E402
-import comfy.ldm.seedvr.vae as seedvr_vae_mod  # noqa: E402
-import comfy.model_management  # noqa: E402
-import comfy.ops as comfy_ops  # noqa: E402
-import comfy.sample  # noqa: E402
-import comfy.sd as sd_mod  # noqa: E402
-import nodes as nodes_mod  # noqa: E402
-from comfy.ldm.seedvr.model import NaDiT  # noqa: E402
-
-
-_LATENT_CHANNELS = seedvr_vae_mod.SEEDVR2_LATENT_CHANNELS
-
-
-def _make_standin(positive_conditioning):
-    class _StandIn(torch.nn.Module):
-        def __init__(self):
-            super().__init__()
-            self.register_buffer(
-                "positive_conditioning", positive_conditioning
-            )
-
-        _resolve_text_conditioning = NaDiT._resolve_text_conditioning
-
-    return _StandIn()
-
-
-class _StubModule(nn.Module):
-    def __init__(self, *args, **kwargs):
-        super().__init__()
-
-
-def _capture_last_layer_flags(monkeypatch, vid_dim: int, txt_in_dim: int) -> list[bool]:
-    flags = []
-
-    class _Block(_StubModule):
-        def __init__(self, *args, **kwargs):
-            flags.append(kwargs["is_last_layer"])
-            super().__init__()
-
-    monkeypatch.setattr(seedvr_model, "NaPatchIn", _StubModule)
-    monkeypatch.setattr(seedvr_model, "NaPatchOut", _StubModule)
-    monkeypatch.setattr(seedvr_model, "TimeEmbedding", _StubModule)
-    monkeypatch.setattr(seedvr_model, "NaMMSRTransformerBlock", _Block)
-
-    seedvr_model.NaDiT(
-        norm_eps=1e-5,
-        num_layers=4,
-        mlp_type="normal",
-        vid_dim=vid_dim,
-        txt_in_dim=txt_in_dim,
-        heads=24,
-        mm_layers=3,
-        operations=comfy_ops.disable_weight_init,
-    )
-
-    return flags
-
-
-class _Model:
-    def __init__(self, latent_format):
-        self._latent_format = latent_format
-
-    def get_model_object(self, name):
-        assert name == "latent_format"
-        return self._latent_format
-
-
-class _Patcher:
-    def get_free_memory(self, device):
-        return 1024 * 1024 * 1024
-
-
-class _EncodeWrapper(seedvr_vae_mod.VideoAutoencoderKLWrapper):
-    def __init__(self, encoded):
-        nn.Module.__init__(self)
-        self.encoded = encoded
-        self.spatial_downsample_factor = 8
-        self.temporal_downsample_factor = 4
-        self.seen = []
-
-    def encode(self, x):
-        self.seen.append(tuple(x.shape))
-        return self.encoded.to(device=x.device, dtype=x.dtype)
-
-
-class _DecodeWrapper(seedvr_vae_mod.VideoAutoencoderKLWrapper):
-    def __init__(self):
-        nn.Module.__init__(self)
-        self.spatial_downsample_factor = 8
-        self.temporal_downsample_factor = 4
-        self.calls = []
-
-    def decode(self, z, seedvr2_tiling=None):
-        self.calls.append({"shape": tuple(z.shape), "seedvr2_tiling": seedvr2_tiling})
-        if z.ndim == 4:
-            b, tc, h, w = z.shape
-            t = tc // _LATENT_CHANNELS
-        else:
-            b, _, t, h, w = z.shape
-        return torch.zeros(b, 3, t, h * 8, w * 8, dtype=z.dtype, device=z.device)
-
-
-def test_seedvr2_wrapper_public_encode_returns_tensor(monkeypatch):
-    raw_latent = torch.full((1, _LATENT_CHANNELS, 1, 4, 5), 2.0)
-    seen_shapes = []
-
-    def base_encode(self, x):
-        seen_shapes.append(tuple(x.shape))
-        return raw_latent.to(device=x.device, dtype=x.dtype)
-
-    monkeypatch.setattr(seedvr_vae_mod.VideoAutoencoderKL, "encode", base_encode)
-
-    vae = seedvr_vae_mod.VideoAutoencoderKLWrapper.__new__(seedvr_vae_mod.VideoAutoencoderKLWrapper)
-    nn.Module.__init__(vae)
-    vae._dummy = nn.Parameter(torch.zeros((), dtype=torch.float32))
-
-    latent = vae.encode(torch.zeros(1, 3, 32, 40))
-
-    assert type(latent) is torch.Tensor
-    assert tuple(latent.shape) == (1, _LATENT_CHANNELS, 4, 5)
-    assert seen_shapes == [(1, 3, 1, 32, 40)]
-
-
-def test_seedvr2_wrapper_private_encode_helper_keeps_raw_latent(monkeypatch):
-    raw_latent = torch.full((1, _LATENT_CHANNELS, 1, 4, 5), 3.0)
-
-    def base_encode(self, x):
-        return raw_latent.to(device=x.device, dtype=x.dtype)
-
-    monkeypatch.setattr(seedvr_vae_mod.VideoAutoencoderKL, "encode", base_encode)
-
-    vae = seedvr_vae_mod.VideoAutoencoderKLWrapper.__new__(seedvr_vae_mod.VideoAutoencoderKLWrapper)
-    nn.Module.__init__(vae)
-    vae._dummy = nn.Parameter(torch.zeros((), dtype=torch.float32))
-
-    latent, raw = vae._encode_with_raw_latent(torch.zeros(1, 3, 32, 40))
-
-    assert tuple(latent.shape) == (1, _LATENT_CHANNELS, 4, 5)
-    assert tuple(raw.shape) == (1, _LATENT_CHANNELS, 1, 4, 5)
-    assert torch.equal(raw, raw_latent)
-
-
-def _make_vae(wrapper):
-    vae = sd_mod.VAE.__new__(sd_mod.VAE)
-    vae.first_stage_model = wrapper
-    vae.device = torch.device("cpu")
-    vae.output_device = torch.device("cpu")
-    vae.vae_dtype = torch.float32
-    vae.latent_channels = _LATENT_CHANNELS
-    vae.latent_dim = 3
-    vae.downscale_ratio = (lambda a: max(0, (a + 3) // 4), 8, 8)
-    vae.upscale_ratio = (lambda a: max(0, a * 4 - 3), 8, 8)
-    vae.output_channels = 3
-    vae.disable_offload = True
-    vae.extra_1d_channel = None
-    vae.crop_input = False
-    vae.not_video = False
-    vae.handles_tiling = isinstance(wrapper, seedvr_vae_mod.VideoAutoencoderKLWrapper)
-    vae.format_encoded = wrapper.comfy_format_encoded
-    vae.patcher = _Patcher()
-    vae.process_input = lambda image: image
-    vae.process_output = lambda image: image.add(1.0).div(2.0).clamp(0.0, 1.0)
-    vae.vae_output_dtype = lambda: torch.float32
-    vae.memory_used_encode = lambda shape, dtype: 1
-    vae.memory_used_decode = lambda shape, dtype: 1
-    vae.throw_exception_if_invalid = lambda: None
-    vae.vae_encode_crop_pixels = lambda pixels: pixels
-    vae.spacial_compression_decode = lambda: 8
-    vae.temporal_compression_decode = lambda: 4
-    return vae
-
-
-def test_missing_context_falls_back_to_positive_buffer():
-    pos_buffer = torch.full((58, 5120), 7.0)
-    standin = _make_standin(pos_buffer)
-    txt, txt_shape = standin._resolve_text_conditioning(None)
-    assert txt.shape == (58, 5120)
-    assert (txt == 7.0).all(), (
-        "fallback path must use the positive_conditioning buffer "
-        "verbatim, not a zero tensor"
-    )
-    assert txt_shape.shape == (1, 1)
-    assert txt_shape[0, 0].item() == 58
-
-
-def test_seedvr2_7b_keeps_final_block_text_path(monkeypatch):
-    assert _capture_last_layer_flags(monkeypatch, vid_dim=3072, txt_in_dim=3072) == [
-        False,
-        False,
-        False,
-        False,
-    ]
-
-
-def test_seedvr2_7b_rope3d_matches_wrapper_oracle():
-    rope = seedvr_model.get_na_rope("rope3d", dim=64)
-    generator = torch.Generator(device="cpu").manual_seed(0)
-    q = torch.randn(4, 2, 128, generator=generator)
-    k = torch.randn(4, 2, 128, generator=generator)
-    shape = torch.tensor([[1, 2, 2]], dtype=torch.long)
-    freqs = rope.get_axial_freqs(1, 2, 2).reshape(4, -1)
-
-    expected_q = seedvr_model._apply_seedvr2_rotary_emb(
-        freqs,
-        q.permute(1, 0, 2).float(),
-    ).to(q.dtype).permute(1, 0, 2)
-    expected_k = seedvr_model._apply_seedvr2_rotary_emb(
-        freqs,
-        k.permute(1, 0, 2).float(),
-    ).to(k.dtype).permute(1, 0, 2)
-
-    actual_q, actual_k = rope(q.clone(), k.clone(), shape, seedvr_model.Cache(disable=True))
-
-    torch.testing.assert_close(actual_q, expected_q, rtol=0, atol=0)
-    torch.testing.assert_close(actual_k, expected_k, rtol=0, atol=0)
-
-
-def test_seedvr2_forward_requires_conditioning_latents():
-    model = NaDiT.__new__(NaDiT)
-    x = torch.zeros(1, _LATENT_CHANNELS, 1, 4, 5)
-
-    with pytest.raises(ValueError, match="requires conditioning latents"):
-        NaDiT.forward(model, x, timestep=torch.tensor([1.0]), context=None)
-
-
-def test_seedvr2_latent_format_uses_native_video_latent_shape():
-    latent_format = comfy.latent_formats.SeedVR2()
-    latent_image = torch.zeros(1, 1, 4, 5)
-
-    fixed = comfy.sample.fix_empty_latent_channels(_Model(latent_format), latent_image)
-
-    assert latent_format.latent_channels == _LATENT_CHANNELS
-    assert latent_format.latent_dimensions == 3
-    assert fixed.shape == (1, _LATENT_CHANNELS, 1, 4, 5)
-
-
-def test_seedvr2_model_requires_native_5d_latent():
-    latent = torch.zeros(1, _LATENT_CHANNELS, 2, 4, 5)
-    assert NaDiT._check_seedvr2_video_latent(latent, _LATENT_CHANNELS, "latent") is latent
-
-    with pytest.raises(ValueError, match="5-D native latent"):
-        NaDiT._check_seedvr2_video_latent(torch.zeros(1, _LATENT_CHANNELS * 2, 4, 5), _LATENT_CHANNELS, "latent")
-
-
-def test_seedvr2_encode_and_encode_tiled_preserve_native_latent_contract(monkeypatch):
-    monkeypatch.setattr(sd_mod.model_management, "load_models_gpu", lambda *a, **k: None)
-
-    encoded = torch.full((1, _LATENT_CHANNELS, 2, 4, 5), 2.0)
-    vae = _make_vae(_EncodeWrapper(encoded))
-    pixels = torch.zeros(1, 5, 32, 40, 3)
-
-    node_output = nodes_mod.VAEEncode().encode(vae, pixels)[0]
-    node_latent = node_output["samples"]
-    assert set(node_output) == {"samples"}
-    assert tuple(node_latent.shape) == (1, _LATENT_CHANNELS, 2, 4, 5)
-    assert node_latent.dtype == torch.float32
-    assert node_latent.stride()[-1] == 1
-    assert torch.equal(node_latent, torch.full_like(node_latent, 2.0 * seedvr_vae_mod.BYTEDANCE_VAE_SCALING_FACTOR))
-
-    tiled = torch.full((1, _LATENT_CHANNELS, 2, 4, 5), 3.0)
-    monkeypatch.setattr(seedvr_vae_mod, "tiled_vae", MagicMock(return_value=tiled))
-    tiled_output = nodes_mod.VAEEncodeTiled().encode(
-        vae,
-        pixels,
-        tile_size=512,
-        overlap=64,
-        temporal_size=16,
-        temporal_overlap=4,
-    )[0]
-    tiled_latent = tiled_output["samples"]
-    assert set(tiled_output) == {"samples"}
-    assert tuple(tiled_latent.shape) == (1, _LATENT_CHANNELS, 2, 4, 5)
-    assert tiled_latent.dtype == torch.float32
-    assert torch.equal(tiled_latent, torch.full_like(tiled_latent, 3.0 * seedvr_vae_mod.BYTEDANCE_VAE_SCALING_FACTOR))
-
-
-def test_vaedecode_tiled_spatial_applies_temporal_discarded(monkeypatch):
-    monkeypatch.setattr(sd_mod.model_management, "load_models_gpu", lambda *a, **k: None)
-    vae = _make_vae(_DecodeWrapper())
-
-    nodes_mod.VAEDecodeTiled().decode(
-        vae,
-        {"samples": torch.zeros(1, _LATENT_CHANNELS, 2, 4, 5)},
-        tile_size=512,
-        overlap=64,
-        temporal_size=16,
-        temporal_overlap=4,
-    )
-
-    # Spatial inputs flow through; temporal inputs are discarded as public tiling
-    # knobs, but SeedVR2's internal MemoryState causal slicing is left intact.
-    assert vae.first_stage_model.calls == [
-        {
-            "shape": (1, _LATENT_CHANNELS, 2, 4, 5),
-            "seedvr2_tiling": {
-                "enable_tiling": True,
-                "tile_size": (512, 512),
-                "tile_overlap": (64, 64),
-                "temporal_size": None,
-                "temporal_overlap": None,
-            },
-        }
-    ]

tests-unit/comfy_test/test_seedvr2_vae_decode.py

@@ -1,94 +0,0 @@
-from unittest.mock import patch
-
-import pytest
-import torch
-import torch.nn as nn
-
-from comfy.cli_args import args as cli_args
-
-if not torch.cuda.is_available():
-    cli_args.cpu = True
-
-import comfy.ldm.seedvr.vae as vae_mod  # noqa: E402
-from comfy_extras import nodes_seedvr  # noqa: E402
-
-
-_LATENT_CHANNELS = vae_mod.SEEDVR2_LATENT_CHANNELS
-
-
-def _make_wrapper() -> vae_mod.VideoAutoencoderKLWrapper:
-    wrapper = vae_mod.VideoAutoencoderKLWrapper.__new__(
-        vae_mod.VideoAutoencoderKLWrapper
-    )
-    nn.Module.__init__(wrapper)
-    return wrapper
-
-
-def _fingerprint_decode_(self, z, return_dict=True):
-    b = int(z.shape[0])
-    t = int(z.shape[2])
-    h = int(z.shape[3])
-    w = int(z.shape[4])
-    out = torch.empty(b, 3, t, h * 8, w * 8)
-    for batch_idx in range(b):
-        out[batch_idx].fill_(float(batch_idx + 1))
-    return out
-
-
-def _decode_with_patches(wrapper, z):
-    with patch.object(vae_mod.VideoAutoencoderKL, "decode_", _fingerprint_decode_):
-        return wrapper.decode(z)
-
-
-def test_decode_b2_t3_multi_frame_batch_unchanged():
-    wrapper = _make_wrapper()
-
-    out = _decode_with_patches(wrapper, torch.zeros(2, _LATENT_CHANNELS * 3, 2, 2))
-
-    assert tuple(out.shape) == (2, 3, 3, 16, 16)
-
-
-class _Wrapper(vae_mod.VideoAutoencoderKLWrapper):
-    def __init__(self):
-        nn.Module.__init__(self)
-        self.calls = []
-
-    def parameters(self):
-        return iter([torch.nn.Parameter(torch.zeros(()))])
-
-def _decode_stub(self, latent):
-    self.calls.append(tuple(latent.shape))
-    return torch.zeros(latent.shape[0], 3, latent.shape[2], latent.shape[3] * 8, latent.shape[4] * 8)
-
-
-def test_seedvr2_wrapper_decode_accepts_5d_channel_first_latents_without_preprocessor_state():
-    wrapper = _Wrapper()
-
-    with patch.object(vae_mod.VideoAutoencoderKL, "decode_", _decode_stub):
-        out = wrapper.decode(torch.zeros(1, _LATENT_CHANNELS, 2, 4, 5))
-
-    assert tuple(out.shape) == (1, 3, 2, 32, 40)
-    assert wrapper.calls == [(1, _LATENT_CHANNELS, 2, 4, 5)]
-
-
-def test_seedvr2_wrapper_decode_rejects_wrong_rank_latents():
-    wrapper = _Wrapper()
-
-    with pytest.raises(RuntimeError, match=r"latent input must be 4-D collapsed .* or 5-D"):
-        wrapper.decode(torch.zeros(1, _LATENT_CHANNELS, 4))
-
-
-def _t_padded(t_in: int) -> int:
-    if t_in == 1:
-        return 1
-    if t_in <= 4:
-        return 5
-    if (t_in - 1) % 4 == 0:
-        return t_in
-    return t_in + (4 - ((t_in - 1) % 4))
-
-
-@pytest.mark.parametrize("t_in", [1, 5, 9])
-def test_t_padded_matches_cut_videos(t_in):
-    dummy = torch.zeros(1, t_in, 1, 1, 1)
-    assert nodes_seedvr.cut_videos(dummy).shape[1] == _t_padded(t_in)

tests-unit/comfy_test/test_seedvr2_vae_tiled.py

@@ -1,382 +0,0 @@
-from contextlib import ExitStack
-from unittest.mock import MagicMock, patch
-
-import pytest
-import torch
-import torch.nn as nn
-
-from comfy.cli_args import args as cli_args
-
-if not torch.cuda.is_available():
-    cli_args.cpu = True
-
-import comfy.ldm.seedvr.vae as vae_mod  # noqa: E402
-import comfy.ldm.seedvr.vae as seedvr_vae_mod  # noqa: E402
-import comfy.sd as sd_mod  # noqa: E402
-from comfy.ldm.seedvr.vae import MemoryState, tiled_vae  # noqa: E402
-
-
-_LATENT_CHANNELS = seedvr_vae_mod.SEEDVR2_LATENT_CHANNELS
-
-
-def test_runtime_decode_zero_temporal_size_preserves_model_slicing():
-    class StubVAEModel(torch.nn.Module):
-        def __init__(self):
-            super().__init__()
-            self.slicing_latent_min_size = 2
-            self.spatial_downsample_factor = 8
-            self.temporal_downsample_factor = 4
-            self.device = torch.device("cpu")
-            self.use_slicing = True
-            self._dummy = torch.nn.Parameter(torch.zeros(1, dtype=torch.float32))
-            self.decode_min_sizes = []
-            self.memory_states = []
-
-        def decode_(self, t_chunk):
-            self.decode_min_sizes.append(self.slicing_latent_min_size)
-            return vae_mod.VideoAutoencoderKL.slicing_decode(self, t_chunk)
-
-        def _decode(self, z, memory_state=MemoryState.DISABLED, memory_cache=None):
-            self.memory_states.append(memory_state)
-            b, c, d, h, w = z.shape
-            return torch.zeros((b, 3, d, h * 8, w * 8), dtype=z.dtype)
-
-    vae = StubVAEModel()
-    z = torch.zeros((1, _LATENT_CHANNELS, 5, 8, 8), dtype=torch.float32)
-
-    tiled_vae(
-        z,
-        vae,
-        tile_size=(64, 64),
-        tile_overlap=(0, 0),
-        temporal_size=0,
-        temporal_overlap=0,
-        encode=False,
-    )
-
-    assert vae.decode_min_sizes == [2]
-    assert vae.memory_states == [MemoryState.INITIALIZING, MemoryState.ACTIVE]
-    assert vae.slicing_latent_min_size == 2
-
-
-def test_zero_temporal_size_preserves_min_size_when_encode_raises():
-    class RaisingVAEModel(torch.nn.Module):
-        def __init__(self):
-            super().__init__()
-            self.slicing_sample_min_size = 4
-            self.spatial_downsample_factor = 8
-            self.temporal_downsample_factor = 4
-            self.device = torch.device("cpu")
-            self._dummy = torch.nn.Parameter(torch.zeros(1, dtype=torch.float32))
-
-        def encode(self, t_chunk):
-            raise RuntimeError("simulated encode failure")
-
-    vae = RaisingVAEModel()
-    x = torch.zeros((1, 3, 12, 64, 64), dtype=torch.float32)
-
-    with pytest.raises(RuntimeError, match="simulated encode failure"):
-        tiled_vae(
-            x,
-            vae,
-            tile_size=(64, 64),
-            tile_overlap=(0, 0),
-            temporal_size=0,
-            temporal_overlap=0,
-            encode=True,
-        )
-
-    assert vae.slicing_sample_min_size == 4
-
-
-def test_tiled_vae_encode_uses_tensor_return_without_indexing():
-    class TensorEncodeVAEModel(torch.nn.Module):
-        def __init__(self):
-            super().__init__()
-            self.slicing_sample_min_size = 4
-            self.spatial_downsample_factor = 8
-            self.temporal_downsample_factor = 4
-            self.device = torch.device("cpu")
-            self._dummy = torch.nn.Parameter(torch.zeros(1, dtype=torch.float32))
-            self.calls = []
-
-        def encode(self, t_chunk):
-            self.calls.append(tuple(t_chunk.shape))
-            b, _, _, h, w = t_chunk.shape
-            return torch.ones((b, _LATENT_CHANNELS, 1, h // 8, w // 8), dtype=t_chunk.dtype)
-
-    vae = TensorEncodeVAEModel()
-    x = torch.zeros((2, 3, 1, 64, 64), dtype=torch.float32)
-
-    out = tiled_vae(
-        x,
-        vae,
-        tile_size=(64, 64),
-        tile_overlap=(0, 0),
-        temporal_size=0,
-        temporal_overlap=0,
-        encode=True,
-    )
-
-    assert vae.calls == [(2, 3, 1, 64, 64)]
-    assert tuple(out.shape) == (2, _LATENT_CHANNELS, 1, 8, 8)
-
-
-def test_tiled_vae_preserves_input_dtype_on_single_tile():
-    class FloatOutputVAEModel(torch.nn.Module):
-        def __init__(self):
-            super().__init__()
-            self.slicing_sample_min_size = 4
-            self.spatial_downsample_factor = 8
-            self.temporal_downsample_factor = 4
-            self.device = torch.device("cpu")
-            self._dummy = torch.nn.Parameter(torch.zeros(1, dtype=torch.float32))
-
-        def encode(self, t_chunk):
-            b, _, _, h, w = t_chunk.shape
-            return torch.ones((b, _LATENT_CHANNELS, 1, h // 8, w // 8), dtype=torch.float32)
-
-    out = tiled_vae(
-        torch.zeros((1, 3, 1, 64, 64), dtype=torch.float16),
-        FloatOutputVAEModel(),
-        tile_size=(64, 64),
-        tile_overlap=(0, 0),
-        temporal_size=0,
-        temporal_overlap=0,
-        encode=True,
-    )
-
-    assert out.dtype == torch.float16
-
-
-class _SlicingDecodeVAE(nn.Module):
-    def __init__(self, slicing_latent_min_size):
-        super().__init__()
-        self.slicing_latent_min_size = slicing_latent_min_size
-        self.spatial_downsample_factor = 8
-        self.temporal_downsample_factor = 4
-        self.device = torch.device("cpu")
-        self.use_slicing = True
-        self._dummy = nn.Parameter(torch.zeros(1, dtype=torch.float32))
-        self.decode_min_sizes = []
-        self.memory_states = []
-
-    def decode_(self, z):
-        self.decode_min_sizes.append(self.slicing_latent_min_size)
-        return vae_mod.VideoAutoencoderKL.slicing_decode(self, z)
-
-    def _decode(self, z, memory_state=MemoryState.DISABLED, memory_cache=None):
-        self.memory_states.append(memory_state)
-        x = z[:, :1].repeat(
-            1,
-            3,
-            1,
-            self.spatial_downsample_factor,
-            self.spatial_downsample_factor,
-        )
-        return x
-
-
-def test_decode_tiled_vae_maps_temporal_args_to_latent_slicing_min_size():
-    vae = _SlicingDecodeVAE(slicing_latent_min_size=2)
-    z = torch.arange(
-        _LATENT_CHANNELS * 5 * 8 * 8,
-        dtype=torch.float32,
-    ).reshape(1, _LATENT_CHANNELS, 5, 8, 8)
-
-    tiled_vae(
-        z,
-        vae,
-        tile_size=(64, 64),
-        tile_overlap=(0, 0),
-        temporal_size=12,
-        temporal_overlap=4,
-        encode=False,
-    )
-
-    assert vae.decode_min_sizes == [2]
-    assert vae.memory_states == [MemoryState.INITIALIZING, MemoryState.ACTIVE]
-    assert vae.slicing_latent_min_size == 2
-
-    wrapper = vae_mod.VideoAutoencoderKLWrapper.__new__(
-        vae_mod.VideoAutoencoderKLWrapper
-    )
-    nn.Module.__init__(wrapper)
-    seedvr2_tiling = {
-        "enable_tiling": True,
-        "tile_size": (64, 64),
-        "tile_overlap": (0, 0),
-        "temporal_size": 8,
-        "temporal_overlap": 7,
-    }
-
-    captured = {}
-
-    def _fake_tiled_vae(latent, model, **kwargs):
-        captured.update(kwargs)
-        return torch.zeros(1, 3, 1, 16, 16)
-
-    with patch.object(vae_mod, "tiled_vae", side_effect=_fake_tiled_vae):
-        wrapper.decode(torch.zeros(1, _LATENT_CHANNELS, 2, 2), seedvr2_tiling=seedvr2_tiling)
-
-    assert captured["temporal_overlap"] == 7
-
-
-def _force_oom(*a, **k):
-    raise torch.cuda.OutOfMemoryError("forced OOM for dispatcher test")
-
-
-def _make_vae(first_stage_model, latent_channels, latent_dim):
-    vae = sd_mod.VAE.__new__(sd_mod.VAE)
-    vae.first_stage_model = first_stage_model
-    vae.patcher = MagicMock()
-    vae.patcher.get_free_memory = MagicMock(return_value=8 * 1024 * 1024 * 1024)
-    vae.device = vae.output_device = torch.device("cpu")
-    vae.vae_dtype = torch.float32
-    vae.disable_offload = True
-    vae.extra_1d_channel = None
-    vae.upscale_ratio = vae.downscale_ratio = 8
-    vae.upscale_index_formula = vae.downscale_index_formula = None
-    vae.output_channels = 3
-    vae.latent_channels = latent_channels
-    vae.latent_dim = latent_dim
-    vae.vae_output_dtype = lambda: torch.float32
-    vae.spacial_compression_decode = lambda: 8
-    vae.handles_tiling = isinstance(first_stage_model, seedvr_vae_mod.VideoAutoencoderKLWrapper)
-    vae.format_encoded = None
-    vae.process_input = lambda x: x
-    vae.process_output = lambda x: x
-    vae.throw_exception_if_invalid = lambda: None
-    vae.memory_used_decode = lambda *a, **k: 1
-    return vae
-
-
-def _dispatch(vae, samples, seedvr2_call, generic_call, patch_wrapper_decode):
-    mm = sd_mod.model_management
-    with ExitStack() as stack:
-        stack.enter_context(patch.object(mm, "raise_non_oom", lambda e: None))
-        stack.enter_context(patch.object(mm, "load_models_gpu", lambda *a, **k: None))
-        stack.enter_context(patch.object(mm, "soft_empty_cache", lambda: None))
-        stack.enter_context(patch.object(sd_mod.VAE, "_decode_tiled_owned", seedvr2_call))
-        stack.enter_context(patch.object(sd_mod.VAE, "decode_tiled_", generic_call))
-        if patch_wrapper_decode:
-            stack.enter_context(patch.object(
-                seedvr_vae_mod.VideoAutoencoderKLWrapper, "decode",
-                side_effect=_force_oom))
-        vae.decode(samples)
-
-
-def test_4d_seedvr2_latent_routes_to_owned_decode_tiled():
-    wrapper = seedvr_vae_mod.VideoAutoencoderKLWrapper.__new__(
-        seedvr_vae_mod.VideoAutoencoderKLWrapper)
-    vae = _make_vae(wrapper, latent_channels=_LATENT_CHANNELS, latent_dim=3)
-    seedvr2_call = MagicMock(return_value=torch.zeros(1, 3, 9, 64, 64))
-    generic_call = MagicMock(return_value=torch.zeros(1, 3, 64, 64))
-    _dispatch(vae, torch.zeros(1, _LATENT_CHANNELS * 3, 8, 8), seedvr2_call, generic_call, True)
-    assert seedvr2_call.call_count == 1
-    assert generic_call.call_count == 0
-
-
-def test_4d_non_seedvr2_latent_still_routes_to_generic_decode_tiled():
-    first_stage = MagicMock()
-    first_stage.decode = MagicMock(side_effect=_force_oom)
-    vae = _make_vae(first_stage, latent_channels=4, latent_dim=2)
-    seedvr2_call = MagicMock(return_value=torch.zeros(1, 3, 9, 64, 64))
-    generic_call = MagicMock(return_value=torch.zeros(1, 3, 64, 64))
-    _dispatch(vae, torch.zeros(1, 4, 8, 8), seedvr2_call, generic_call, False)
-    assert generic_call.call_count == 1
-    assert seedvr2_call.call_count == 0
-
-
-def _populate_common_vae_attrs_fallback(vae):
-    vae.patcher = MagicMock()
-    vae.patcher.get_free_memory = MagicMock(return_value=8 * 1024 * 1024 * 1024)
-    vae.device = torch.device("cpu")
-    vae.output_device = torch.device("cpu")
-    vae.vae_dtype = torch.float32
-    vae.disable_offload = True
-    vae.extra_1d_channel = None
-    vae.upscale_ratio = 8
-    vae.upscale_index_formula = None
-    vae.output_channels = 3
-    vae.latent_channels = _LATENT_CHANNELS
-    vae.latent_dim = 3
-    vae.downscale_ratio = 8
-    vae.downscale_index_formula = None
-    vae.not_video = False
-    vae.crop_input = False
-    vae.pad_channel_value = None
-    vae.handles_tiling = isinstance(vae.first_stage_model, seedvr_vae_mod.VideoAutoencoderKLWrapper)
-    vae.format_encoded = None
-
-    vae.vae_output_dtype = lambda: torch.float32
-    vae.spacial_compression_encode = lambda: 8
-    vae.process_input = lambda x: x
-    vae.process_output = lambda x: x
-    vae.throw_exception_if_invalid = lambda: None
-    vae.memory_used_encode = lambda *a, **k: 1
-
-
-def _make_seedvr2_vae_fallback():
-    vae = sd_mod.VAE.__new__(sd_mod.VAE)
-    wrapper = seedvr_vae_mod.VideoAutoencoderKLWrapper.__new__(
-        seedvr_vae_mod.VideoAutoencoderKLWrapper
-    )
-    vae.first_stage_model = wrapper
-    _populate_common_vae_attrs_fallback(vae)
-    return vae
-
-
-def _make_non_seedvr2_vae_fallback():
-    vae = sd_mod.VAE.__new__(sd_mod.VAE)
-    vae.first_stage_model = MagicMock()
-    _populate_common_vae_attrs_fallback(vae)
-    return vae
-
-
-def _force_regular_encode_oom(*args, **kwargs):
-    raise torch.cuda.OutOfMemoryError("forced OOM for dispatcher test")
-
-
-def test_seedvr2_3d_routes_to_owned_encode_tiled_on_oom():
-    vae = _make_seedvr2_vae_fallback()
-    pixel_samples = torch.zeros((1, 8, 64, 64, 3))
-
-    seedvr2_call = MagicMock(return_value=torch.zeros(1, _LATENT_CHANNELS, 2, 8, 8))
-    generic_call = MagicMock(return_value=torch.zeros(1, _LATENT_CHANNELS, 2, 8, 8))
-
-    with patch.object(sd_mod.model_management, "raise_non_oom",
-                      lambda e: None), \
-         patch.object(sd_mod.model_management, "load_models_gpu",
-                      lambda *a, **k: None), \
-         patch.object(sd_mod.model_management, "soft_empty_cache",
-                      lambda: None), \
-         patch.object(seedvr_vae_mod.VideoAutoencoderKLWrapper, "encode",
-                      side_effect=_force_regular_encode_oom), \
-         patch.object(sd_mod.VAE, "_encode_tiled_owned", seedvr2_call), \
-         patch.object(sd_mod.VAE, "encode_tiled_3d", generic_call):
-        vae.encode(pixel_samples)
-
-    assert seedvr2_call.call_count == 1, (
-        f"Expected _encode_tiled_owned to be called once for a SeedVR2 3D "
-        f"input under OOM fallback; got {seedvr2_call.call_count} calls."
-    )
-    assert generic_call.call_count == 0, (
-        f"encode_tiled_3d must NOT be called for a SeedVR2 input; got "
-        f"{generic_call.call_count} calls."
-    )
-
-
-def test_non_seedvr2_encode_tiled_3d_default_overlap_is_concrete():
-    vae = _make_non_seedvr2_vae_fallback()
-    vae.downscale_ratio = (lambda a: max(1, a // 4), 8, 8)
-    vae.upscale_ratio = (lambda a: a * 4, 8, 8)
-    generic_call = MagicMock(return_value=torch.zeros(1, _LATENT_CHANNELS, 2, 8, 8))
-    pixel_samples = torch.zeros((1, 8, 64, 64, 3))
-
-    with patch.object(sd_mod.model_management, "load_models_gpu",
-                      lambda *a, **k: None), \
-         patch.object(sd_mod.VAE, "encode_tiled_3d", generic_call):
-        vae.encode_tiled(pixel_samples)
-
-    assert generic_call.call_args.kwargs["overlap"] == (1, 64, 64)