Merge branch 'master' into feat/ideogram-prompt-nodes

comfy/ops.py

@@ -1089,19 +1089,6 @@ def _load_quantized_module(module, super_load, state_dict, prefix, local_metadat
             if ts is None or bs is None:
                 raise ValueError(f"Missing NVFP4 scales for layer {layer_name}")
             scales = {"scale": ts, "block_scale": bs}
-        elif module.quant_format == "int8_tensorwise":
-            scale = pop_scale("weight_scale")
-            if scale is None:
-                raise ValueError(f"Missing INT8 weight scale for layer {layer_name}")
-            scales = {"scale": scale}
-            params_conf = layer_conf.get("params", {})
-            if not isinstance(params_conf, dict):
-                params_conf = {}
-            if layer_conf.get("convrot", params_conf.get("convrot", False)):
-                scales["convrot"] = True
-                scales["convrot_groupsize"] = int(
-                    layer_conf.get("convrot_groupsize", params_conf.get("convrot_groupsize", 256))
-                )
         else:
             raise ValueError(f"Unsupported quantization format: {module.quant_format}")
 
@@ -1144,10 +1131,6 @@ def _quantized_weight_state_dict(module, sd, prefix, extra_quant_conf=None, extr
         quant_conf = {"format": module.quant_format}
         if getattr(module, '_full_precision_mm_config', False):
             quant_conf["full_precision_matrix_mult"] = True
-        params = getattr(module.weight, "_params", None)
-        if module.quant_format == "int8_tensorwise" and getattr(params, "convrot", False):
-            quant_conf["convrot"] = True
-            quant_conf["convrot_groupsize"] = getattr(params, "convrot_groupsize", 256)
         if extra_quant_conf:
             quant_conf.update(extra_quant_conf)
         sd[f"{prefix}comfy_quant"] = torch.tensor(list(json.dumps(quant_conf).encode("utf-8")), dtype=torch.uint8)
@@ -1200,33 +1183,8 @@ def mixed_precision_ops(quant_config={}, compute_dtype=torch.bfloat16, full_prec
             def _forward(self, input, weight, bias):
                 return torch.nn.functional.linear(input, weight, bias)
 
-            def forward_comfy_cast_weights(
-                self,
-                input,
-                compute_dtype=None,
-                want_requant=False,
-                weight_only_quant=False,
-            ):
-                if weight_only_quant:
-                    weight, bias, offload_stream = cast_bias_weight(
-                        self,
-                        input=None,
-                        dtype=self.weight.dtype,
-                        device=input.device,
-                        bias_dtype=input.dtype,
-                        offloadable=True,
-                        compute_dtype=compute_dtype,
-                        want_requant=want_requant,
-                    )
-                    weight = weight.to(dtype=input.dtype)
-                else:
-                    weight, bias, offload_stream = cast_bias_weight(
-                        self,
-                        input,
-                        offloadable=True,
-                        compute_dtype=compute_dtype,
-                        want_requant=want_requant,
-                    )
+            def forward_comfy_cast_weights(self, input, compute_dtype=None, want_requant=False):
+                weight, bias, offload_stream = cast_bias_weight(self, input, offloadable=True, compute_dtype=compute_dtype, want_requant=want_requant)
                 x = self._forward(input, weight, bias)
                 uncast_bias_weight(self, weight, bias, offload_stream)
                 return x
@@ -1245,10 +1203,9 @@ def mixed_precision_ops(quant_config={}, compute_dtype=torch.bfloat16, full_prec
                     not getattr(self, 'comfy_force_cast_weights', False) and
                     len(self.weight_function) == 0 and len(self.bias_function) == 0
                 )
-                quantize_input = QUANT_ALGOS.get(getattr(self, 'quant_format', None), {}).get("quantize_input", True)
 
                 # Training path: quantized forward with compute_dtype backward via autograd function
-                if (input.requires_grad and _use_quantized and quantize_input):
+                if (input.requires_grad and _use_quantized):
 
                     weight, bias, offload_stream = cast_bias_weight(
                         self,
@@ -1270,7 +1227,7 @@ def mixed_precision_ops(quant_config={}, compute_dtype=torch.bfloat16, full_prec
                     return output
 
                 # Inference path (unchanged)
-                if _use_quantized and quantize_input:
+                if _use_quantized:
 
                     # Reshape 3D tensors to 2D for quantization (needed for NVFP4 and others)
                     input_reshaped = input.reshape(-1, input_shape[2]) if input.ndim == 3 else input
@@ -1284,13 +1241,7 @@ def mixed_precision_ops(quant_config={}, compute_dtype=torch.bfloat16, full_prec
                             scale = comfy.model_management.cast_to_device(scale, input.device, None)
                         input = QuantizedTensor.from_float(input_reshaped, self.layout_type, scale=scale)
 
-                weight_only_quant = _use_quantized and not quantize_input and isinstance(self.weight, QuantizedTensor)
-                output = self.forward_comfy_cast_weights(
-                    input,
-                    compute_dtype,
-                    want_requant=isinstance(input, QuantizedTensor),
-                    weight_only_quant=weight_only_quant,
-                )
+                output = self.forward_comfy_cast_weights(input, compute_dtype, want_requant=isinstance(input, QuantizedTensor))
 
                 # Reshape output back to 3D if input was 3D
                 if reshaped_3d:

comfy/quant_ops.py

@@ -10,7 +10,6 @@ try:
         QuantizedLayout,
         TensorCoreFP8Layout as _CKFp8Layout,
         TensorCoreNVFP4Layout as _CKNvfp4Layout,
-        TensorWiseINT8Layout as _CKTensorWiseINT8Layout,
         register_layout_op,
         register_layout_class,
         get_layout_class,
@@ -48,9 +47,6 @@ except ImportError as e:
     class _CKNvfp4Layout:
         pass
 
-    class _CKTensorWiseINT8Layout:
-        pass
-
     def register_layout_class(name, cls):
         pass
 
@@ -178,7 +174,6 @@ class TensorCoreFP8E5M2Layout(_TensorCoreFP8LayoutBase):
 
 # Backward compatibility alias - default to E4M3
 TensorCoreFP8Layout = TensorCoreFP8E4M3Layout
-TensorWiseINT8Layout = _CKTensorWiseINT8Layout
 
 
 # ==============================================================================
@@ -189,7 +184,6 @@ register_layout_class("TensorCoreFP8Layout", TensorCoreFP8Layout)
 register_layout_class("TensorCoreFP8E4M3Layout", TensorCoreFP8E4M3Layout)
 register_layout_class("TensorCoreFP8E5M2Layout", TensorCoreFP8E5M2Layout)
 register_layout_class("TensorCoreNVFP4Layout", TensorCoreNVFP4Layout)
-register_layout_class("TensorWiseINT8Layout", _CKTensorWiseINT8Layout)
 if _CK_MXFP8_AVAILABLE:
     register_layout_class("TensorCoreMXFP8Layout", TensorCoreMXFP8Layout)
 
@@ -220,13 +214,6 @@ if _CK_MXFP8_AVAILABLE:
         "group_size": 32,
     }
 
-QUANT_ALGOS["int8_tensorwise"] = {
-    "storage_t": torch.int8,
-    "parameters": {"weight_scale"},
-    "comfy_tensor_layout": "TensorWiseINT8Layout",
-    "quantize_input": False,
-}
-
 
 # ==============================================================================
 # Re-exports for backward compatibility
@@ -239,7 +226,6 @@ __all__ = [
     "TensorCoreFP8E4M3Layout",
     "TensorCoreFP8E5M2Layout",
     "TensorCoreNVFP4Layout",
-    "TensorWiseINT8Layout",
     "QUANT_ALGOS",
     "register_layout_op",
 ]

comfy_api_nodes/apis/bytedance.py

@@ -177,10 +177,6 @@ SEEDANCE2_PRICE_PER_1K_TOKENS = {
     ("dreamina-seedance-2-0-fast-260128", True, "480p"): 0.0033,
     ("dreamina-seedance-2-0-fast-260128", False, "720p"): 0.0056,
     ("dreamina-seedance-2-0-fast-260128", True, "720p"): 0.0033,
-    ("dreamina-seedance-2-0-mini", False, "480p"): 0.0035,
-    ("dreamina-seedance-2-0-mini", True, "480p"): 0.0021,
-    ("dreamina-seedance-2-0-mini", False, "720p"): 0.0035,
-    ("dreamina-seedance-2-0-mini", True, "720p"): 0.0021,
 }
 
 
@@ -282,10 +278,6 @@ SEEDANCE2_REF_VIDEO_PIXEL_LIMITS = {
         "480p": {"min": 409_600, "max": 927_408},
         "720p": {"min": 409_600, "max": 927_408},
     },
-    "dreamina-seedance-2-0-mini": {
-        "480p": {"min": 409_600, "max": 927_408},
-        "720p": {"min": 409_600, "max": 927_408},
-    },
 }
 
 # The time in this dictionary are given for 10 seconds duration.

comfy_api_nodes/nodes_bytedance.py

@@ -89,7 +89,6 @@ BYTEPLUS_SEEDANCE2_TASK_STATUS_ENDPOINT = "/proxy/byteplus-seedance2/api/v3/cont
 SEEDANCE_MODELS = {
     "Seedance 2.0": "dreamina-seedance-2-0-260128",
     "Seedance 2.0 Fast": "dreamina-seedance-2-0-fast-260128",
-    "Seedance 2.0 Mini": "dreamina-seedance-2-0-mini",
 }
 
 DEPRECATED_MODELS = {"seedance-1-0-lite-t2v-250428", "seedance-1-0-lite-i2v-250428"}
@@ -1624,10 +1623,8 @@ class ByteDance2TextToVideoNode(IO.ComfyNode):
                     options=[
                         IO.DynamicCombo.Option("Seedance 2.0", _seedance2_text_inputs(["480p", "720p", "1080p", "4k"])),
                         IO.DynamicCombo.Option("Seedance 2.0 Fast", _seedance2_text_inputs(["480p", "720p"])),
-                        IO.DynamicCombo.Option("Seedance 2.0 Mini", _seedance2_text_inputs(["480p", "720p"])),
                     ],
-                    tooltip="Seedance 2.0 for maximum quality; Fast for speed optimization; "
-                    "Mini for the fastest, lowest-cost generation.",
+                    tooltip="Seedance 2.0 for maximum quality; Seedance 2.0 Fast for speed optimization.",
                 ),
                 IO.Int.Input(
                     "seed",
@@ -1669,7 +1666,6 @@ class ByteDance2TextToVideoNode(IO.ComfyNode):
                   $dur := $lookup(widgets, "model.duration");
                   $pricePer1K := $res = "4k"    ? 0.00572 :
                                  $res = "1080p" ? 0.011011 :
-                                 $contains($m, "mini") ? 0.005005 :
                                  $contains($m, "fast") ? 0.008008 : 0.01001;
                   $rate := $res = "4k"    ? $rate4k :
                            $res = "1080p" ? $rate1080 :
@@ -1738,13 +1734,8 @@ class ByteDance2FirstLastFrameNode(IO.ComfyNode):
                             "Seedance 2.0 Fast",
                             _seedance2_text_inputs(["480p", "720p"], default_ratio="adaptive"),
                         ),
-                        IO.DynamicCombo.Option(
-                            "Seedance 2.0 Mini",
-                            _seedance2_text_inputs(["480p", "720p"], default_ratio="adaptive"),
-                        ),
                     ],
-                    tooltip="Seedance 2.0 for maximum quality; Fast for speed optimization; "
-                    "Mini for the fastest, lowest-cost generation.",
+                    tooltip="Seedance 2.0 for maximum quality; Seedance 2.0 Fast for speed optimization.",
                 ),
                 IO.Image.Input(
                     "first_frame",
@@ -1810,7 +1801,6 @@ class ByteDance2FirstLastFrameNode(IO.ComfyNode):
                   $dur := $lookup(widgets, "model.duration");
                   $pricePer1K := $res = "4k"    ? 0.00572 :
                                  $res = "1080p" ? 0.011011 :
-                                 $contains($m, "mini") ? 0.005005 :
                                  $contains($m, "fast") ? 0.008008 : 0.01001;
                   $rate := $res = "4k"    ? $rate4k :
                            $res = "1080p" ? $rate1080 :
@@ -2034,13 +2024,8 @@ class ByteDance2ReferenceNode(IO.ComfyNode):
                             "Seedance 2.0 Fast",
                             _seedance2_reference_inputs(["480p", "720p"], default_ratio="adaptive"),
                         ),
-                        IO.DynamicCombo.Option(
-                            "Seedance 2.0 Mini",
-                            _seedance2_reference_inputs(["480p", "720p"], default_ratio="adaptive"),
-                        ),
                     ],
-                    tooltip="Seedance 2.0 for maximum quality; Fast for speed optimization; "
-                    "Mini for the fastest, lowest-cost generation.",
+                    tooltip="Seedance 2.0 for maximum quality; Seedance 2.0 Fast for speed optimization.",
                 ),
                 IO.Int.Input(
                     "seed",
@@ -2086,11 +2071,9 @@ class ByteDance2ReferenceNode(IO.ComfyNode):
                   $dur := $lookup(widgets, "model.duration");
                   $noVideoPricePer1K := $res = "4k"    ? 0.00572 :
                                         $res = "1080p" ? 0.011011 :
-                                        $contains($m, "mini") ? 0.005005 :
                                         $contains($m, "fast") ? 0.008008 : 0.01001;
                   $videoPricePer1K := $res = "4k"    ? 0.003432 :
                                       $res = "1080p" ? 0.006721 :
-                                      $contains($m, "mini") ? 0.003003 :
                                       $contains($m, "fast") ? 0.004719 : 0.006149;
                   $rate := $res = "4k"    ? $rate4k :
                            $res = "1080p" ? $rate1080 :

execution.py

@@ -1113,32 +1113,6 @@ def full_type_name(klass):
         return klass.__qualname__
     return module + '.' + klass.__qualname__
 
-def node_not_executable_reason(class_def, class_type):
-    """Return a human-readable reason the node cannot be executed, or None if it's fine.
-
-    Catches a node whose declared entry point doesn't resolve to a real method
-    (e.g. a V1 ``FUNCTION = "invert"`` where the method is misspelled, or a V3 node
-    missing its ``execute`` override). Running this during validation surfaces the
-    problem before execution starts, instead of after upstream nodes have run.
-
-    Only the class is inspected; the node is never instantiated here, so a node's
-    ``__init__`` side effects cannot run (or fail) during validation.
-    """
-    try:
-        if issubclass(class_def, _ComfyNodeInternal):
-            # V3: validates that execute()/define_schema() overrides exist.
-            class_def.VALIDATE_CLASS()
-            return None
-        # V1: FUNCTION names the method to call; it must exist on the class.
-        function_name = getattr(class_def, "FUNCTION", None)
-        if function_name is None:
-            return f"'{class_type}' does not define FUNCTION"
-        if not callable(getattr(class_def, function_name, None)):
-            return f"'{class_type}' has no method '{function_name}' (declared in FUNCTION)"
-        return None
-    except Exception as ex:
-        return str(ex)
-
 async def validate_prompt(prompt_id, prompt, partial_execution_list: Union[list[str], None]):
     outputs = set()
     for x in prompt:
@@ -1174,35 +1148,6 @@ async def validate_prompt(prompt_id, prompt, partial_execution_list: Union[list[
             }
             return (False, error, [], {})
 
-        # Make sure the node is actually executable (its FUNCTION/execute entry
-        # point resolves to a real method) before we touch any schema-derived
-        # attributes below or start execution. Catches code typos up front and
-        # attributes the error to the offending node.
-        not_executable = node_not_executable_reason(class_, class_type)
-        if not_executable is not None:
-            node_title = prompt[x].get('_meta', {}).get('title', class_type)
-            error = {
-                "type": "invalid_node_definition",
-                "message": "Node is not executable",
-                "details": f"{not_executable} (Node ID '#{x}')",
-                "extra_info": {
-                    "node_id": x,
-                    "class_type": class_type,
-                    "node_title": node_title,
-                }
-            }
-            node_errors = {x: {
-                "errors": [{
-                    "type": "invalid_node_definition",
-                    "message": "Node is not executable",
-                    "details": not_executable,
-                    "extra_info": {},
-                }],
-                "dependent_outputs": [],
-                "class_type": class_type,
-            }}
-            return (False, error, [], node_errors)
-
         if hasattr(class_, 'OUTPUT_NODE') and class_.OUTPUT_NODE is True:
             if partial_execution_list is None or x in partial_execution_list:
                 outputs.add(x)

requirements.txt

@@ -1,5 +1,5 @@
 comfyui-frontend-package==1.45.19
-comfyui-workflow-templates==0.10.7
+comfyui-workflow-templates==0.10.2
 comfyui-embedded-docs==0.5.5
 torch
 torchsde
@@ -22,7 +22,7 @@ alembic
 SQLAlchemy>=2.0.0
 filelock
 av>=16.0.0
-comfy-kitchen==0.2.12
+comfy-kitchen==0.2.10
 comfy-aimdo==0.4.10
 requests
 simpleeval>=1.0.0

tests-unit/comfy_quant/test_mixed_precision.py

@@ -228,62 +228,6 @@ class TestMixedPrecisionOps(unittest.TestCase):
         with self.assertRaises(KeyError):
             model.load_state_dict(state_dict, strict=False)
 
-    def test_int8_convrot_metadata_loads_into_params(self):
-        """ConvRot metadata must reach TensorWiseINT8Layout params."""
-        torch.manual_seed(123)
-        layer_quant_config = {
-            "layer": {
-                "format": "int8_tensorwise",
-                "convrot": True,
-                "convrot_groupsize": 256,
-            }
-        }
-        weight = torch.randn(16, 256, dtype=torch.bfloat16)
-        bias = torch.randn(16, dtype=torch.bfloat16)
-        q_weight = QuantizedTensor.from_float(
-            weight,
-            "TensorWiseINT8Layout",
-            per_channel=True,
-            convrot=True,
-            convrot_groupsize=256,
-        )
-        state_dict = {
-            "layer.weight": q_weight._qdata,
-            "layer.bias": bias,
-            "layer.weight_scale": q_weight._params.scale,
-        }
-
-        state_dict, _ = comfy.utils.convert_old_quants(
-            state_dict,
-            metadata={"_quantization_metadata": json.dumps({"layers": layer_quant_config})},
-        )
-        model = torch.nn.Module()
-        model.layer = ops.mixed_precision_ops({}).Linear(256, 16, device="cpu", dtype=torch.bfloat16)
-        model.load_state_dict(state_dict, strict=False)
-
-        self.assertIsInstance(model.layer.weight, QuantizedTensor)
-        self.assertEqual(model.layer.weight._layout_cls, "TensorWiseINT8Layout")
-        self.assertTrue(model.layer.weight._params.convrot)
-        self.assertEqual(model.layer.weight._params.convrot_groupsize, 256)
-
-        input_tensor = torch.randn(4, 256, dtype=torch.bfloat16)
-        loaded_out = model.layer(input_tensor)
-        ref_out = torch.nn.functional.linear(input_tensor, q_weight, bias)
-        self.assertTrue(torch.equal(loaded_out, ref_out))
-
-        fp16_input = input_tensor.to(torch.float16)
-        loaded_fp16_out = model.layer(fp16_input)
-        ref_fp16_out = torch.nn.functional.linear(
-            fp16_input,
-            q_weight.to(dtype=torch.float16),
-            bias.to(dtype=torch.float16),
-        )
-        self.assertTrue(torch.equal(loaded_fp16_out, ref_fp16_out))
-
-        saved = model.state_dict()
-        saved_conf = json.loads(saved["layer.comfy_quant"].numpy().tobytes())
-        self.assertTrue(saved_conf["convrot"])
-        self.assertEqual(saved_conf["convrot_groupsize"], 256)
-
 if __name__ == "__main__":
     unittest.main()
+

tests-unit/execution_test/validate_node_executable_test.py

@@ -1,137 +0,0 @@
-"""Tests for pre-execution validation that a node is actually executable.
-
-validate_prompt rejects a node whose declared entry point does not resolve to a
-real method (a V1 FUNCTION typo, or a V3 node missing its execute override) before
-any node runs, attributing the error to the offending node.
-"""
-import asyncio
-
-import nodes
-from comfy_api.latest import io
-from execution import node_not_executable_reason, validate_prompt
-
-
-class _GoodV1Node:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {"required": {}}
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "run"
-    OUTPUT_NODE = True
-    CATEGORY = "Test"
-
-    def run(self):
-        return (None,)
-
-
-class _TypoV1Node:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {"required": {}}
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "invert"  # method below is misspelled
-    OUTPUT_NODE = True
-    CATEGORY = "Test"
-
-    def invvert(self):
-        return (None,)
-
-
-class _SideEffectInitV1Node:
-    """Valid class-level method, but a constructor that must never run in validation."""
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {"required": {}}
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "run"
-    OUTPUT_NODE = True
-    CATEGORY = "Test"
-
-    def __init__(self):
-        raise RuntimeError("__init__ must not run during validation")
-
-    def run(self):
-        return (None,)
-
-
-def _v3_schema(node_id):
-    return io.Schema(
-        node_id=node_id,
-        display_name=node_id,
-        category="Test",
-        inputs=[],
-        outputs=[io.Image.Output()],
-        is_output_node=True,
-    )
-
-
-class _GoodV3Node(io.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return _v3_schema("GoodV3Node")
-
-    @classmethod
-    def execute(cls):
-        return io.NodeOutput(None)
-
-
-class _TypoV3Node(io.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return _v3_schema("TypoV3Node")
-
-    @classmethod
-    def exicute(cls):  # typo: should be "execute"
-        return io.NodeOutput(None)
-
-
-def _register(class_type, class_def):
-    nodes.NODE_CLASS_MAPPINGS[class_type] = class_def
-
-
-def _validate(class_type):
-    prompt = {"1": {"class_type": class_type, "inputs": {}}}
-    return asyncio.run(validate_prompt("pid", prompt, None))
-
-
-def test_good_node_passes():
-    _register("GoodV1Node", _GoodV1Node)
-    assert node_not_executable_reason(_GoodV1Node, "GoodV1Node") is None
-    valid, _, _, _ = _validate("GoodV1Node")
-    assert valid is True
-
-
-def test_typo_node_rejected_with_node_error():
-    _register("TypoV1Node", _TypoV1Node)
-    valid, error, _, node_errors = _validate("TypoV1Node")
-    assert valid is False
-    assert error["type"] == "invalid_node_definition"
-    assert node_errors["1"]["class_type"] == "TypoV1Node"
-    assert node_errors["1"]["errors"][0]["type"] == "invalid_node_definition"
-    assert "invert" in node_errors["1"]["errors"][0]["details"]
-
-
-def test_validation_does_not_instantiate_node():
-    """A valid node is not constructed during validation, so __init__ never runs."""
-    _register("SideEffectInitV1Node", _SideEffectInitV1Node)
-    assert node_not_executable_reason(_SideEffectInitV1Node, "SideEffectInitV1Node") is None
-    valid, _, _, _ = _validate("SideEffectInitV1Node")
-    assert valid is True
-
-
-def test_good_v3_node_passes():
-    _register("GoodV3Node", _GoodV3Node)
-    assert node_not_executable_reason(_GoodV3Node, "GoodV3Node") is None
-    valid, _, _, _ = _validate("GoodV3Node")
-    assert valid is True
-
-
-def test_typo_v3_node_rejected_with_node_error():
-    _register("TypoV3Node", _TypoV3Node)
-    valid, error, _, node_errors = _validate("TypoV3Node")
-    assert valid is False
-    assert error["type"] == "invalid_node_definition"
-    assert node_errors["1"]["errors"][0]["type"] == "invalid_node_definition"