mirror of
https://github.com/Comfy-Org/ComfyUI.git
synced 2026-08-25 02:20:18 +08:00
DynamicOutputs.ByKey: schema, type resolver, and execution wiring
Introduce a per-prompt finalized output list for V3 nodes whose active
output shape depends on a literal input. First slice:
* Schema:
- io.DynamicOutputs.ByKey(id, selector, options=[io.DynamicOutputs.Option(...)])
- Validates: selector input exists; output ids unique within and across
static + dynamic branches; no overlap between branches.
- get_v1_info() advertises dynamic groups separately via NodeInfoV1.dynamic_outputs;
static RETURN_TYPES / OUTPUT_IS_LIST stay as the always-present prefix.
* NodeOutput:
- New NodeOutput.from_named({id: value}) for dynamic nodes; engine reorders
against the finalized active output list. Mixing positional+named raises.
* Execution:
- execute() computes FinalizedOutputs once per attempt and threads it
through initial / pending-async / pending-subgraph output paths.
- merge_result_data / get_output_data / get_output_from_returns size
blocker tuples and concat behaviour against the finalized list.
- validate_inputs rejects positional links whose slot index is outside
the upstream node's active output count as 'bad_linked_output'.
* TypeResolver:
- resolve_output_type and is_output_list consult the finalized output
list when present; finalized_output_count() exposes the active count
for validation.
Covered by new unit tests under tests-unit/comfy_api_test and
tests-unit/execution_test.
Amp-Thread-ID: https://ampcode.com/threads/T-019e8568-f382-743d-a97f-0de3ff29d501
Co-authored-by: Amp <amp@ampcode.com>
This commit is contained in:
Jedrzej Kosinski
207
tests-unit/comfy_api_test/test_dynamic_outputs.py
Normal file
207
tests-unit/comfy_api_test/test_dynamic_outputs.py
Normal file
@@ -0,0 +1,207 @@
|
||||
"""Unit tests for ``DynamicOutputs.ByKey`` and the finalized-outputs path."""
|
||||
|
||||
import pytest
|
||||
|
||||
from comfy_api.latest import _io as io
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Schema-level construction and validation
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def _byke():
|
||||
return io.DynamicOutputs.ByKey(
|
||||
id="result",
|
||||
selector="mode",
|
||||
options=[
|
||||
io.DynamicOutputs.Option(key="image",
|
||||
outputs=[io.Image.Output("image"), io.Mask.Output("mask")]),
|
||||
io.DynamicOutputs.Option(key="latent",
|
||||
outputs=[io.Latent.Output("latent")]),
|
||||
],
|
||||
)
|
||||
|
||||
|
||||
def test_option_rejects_empty_key():
|
||||
with pytest.raises(ValueError, match="non-empty string"):
|
||||
io.DynamicOutputs.Option(key="", outputs=[])
|
||||
|
||||
|
||||
def test_option_rejects_non_output_entry():
|
||||
with pytest.raises(ValueError, match="Output instances"):
|
||||
io.DynamicOutputs.Option(key="x", outputs=["not an output"])
|
||||
|
||||
|
||||
def test_option_requires_explicit_output_ids():
|
||||
with pytest.raises(ValueError, match="declare an id"):
|
||||
io.DynamicOutputs.Option(key="x", outputs=[io.Image.Output()]) # no id
|
||||
|
||||
|
||||
def test_bykey_rejects_empty_options():
|
||||
with pytest.raises(ValueError, match="at least one Option"):
|
||||
io.DynamicOutputs.ByKey(id="r", selector="m", options=[])
|
||||
|
||||
|
||||
def test_bykey_rejects_duplicate_keys():
|
||||
with pytest.raises(ValueError, match="duplicate option key"):
|
||||
io.DynamicOutputs.ByKey(
|
||||
id="r", selector="m",
|
||||
options=[
|
||||
io.DynamicOutputs.Option(key="x", outputs=[io.Image.Output("a")]),
|
||||
io.DynamicOutputs.Option(key="x", outputs=[io.Latent.Output("b")]),
|
||||
],
|
||||
)
|
||||
|
||||
|
||||
def test_bykey_rejects_duplicate_output_ids_across_options():
|
||||
with pytest.raises(ValueError, match="appears in more than one option"):
|
||||
io.DynamicOutputs.ByKey(
|
||||
id="r", selector="m",
|
||||
options=[
|
||||
io.DynamicOutputs.Option(key="x", outputs=[io.Image.Output("dup")]),
|
||||
io.DynamicOutputs.Option(key="y", outputs=[io.Latent.Output("dup")]),
|
||||
],
|
||||
)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Schema integration
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def _make_node(extra_outputs=None):
|
||||
"""Build a V3 node class with a selector input + DynamicOutputs group."""
|
||||
extras = extra_outputs or []
|
||||
|
||||
class DynNode(io.ComfyNode):
|
||||
@classmethod
|
||||
def define_schema(cls):
|
||||
return io.Schema(
|
||||
node_id="DynNode",
|
||||
inputs=[io.Combo.Input("mode", options=["image", "latent"], default="image")],
|
||||
outputs=[*extras, _byke()],
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def execute(cls, **kwargs):
|
||||
return io.NodeOutput.from_named({"image": None, "mask": None})
|
||||
|
||||
return DynNode
|
||||
|
||||
|
||||
def test_schema_validate_rejects_unknown_selector():
|
||||
class BadSelector(io.ComfyNode):
|
||||
@classmethod
|
||||
def define_schema(cls):
|
||||
return io.Schema(
|
||||
node_id="BadSelector",
|
||||
inputs=[io.Combo.Input("not_mode", options=["a"])],
|
||||
outputs=[
|
||||
io.DynamicOutputs.ByKey(
|
||||
id="r", selector="mode",
|
||||
options=[io.DynamicOutputs.Option(key="a", outputs=[io.Image.Output("a")])],
|
||||
),
|
||||
],
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def execute(cls, **kwargs):
|
||||
return io.NodeOutput.from_named({"a": None})
|
||||
|
||||
with pytest.raises(ValueError, match="selector input 'mode' does not exist"):
|
||||
BadSelector.GET_SCHEMA()
|
||||
|
||||
|
||||
def test_schema_validate_rejects_id_collision_with_static_output():
|
||||
class Collision(io.ComfyNode):
|
||||
@classmethod
|
||||
def define_schema(cls):
|
||||
return io.Schema(
|
||||
node_id="Collision",
|
||||
inputs=[io.Combo.Input("mode", options=["a"])],
|
||||
outputs=[
|
||||
io.Image.Output("shared"),
|
||||
io.DynamicOutputs.ByKey(
|
||||
id="r", selector="mode",
|
||||
options=[io.DynamicOutputs.Option(key="a", outputs=[io.Latent.Output("shared")])],
|
||||
),
|
||||
],
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def execute(cls, **kwargs):
|
||||
return io.NodeOutput.from_named({"shared": None})
|
||||
|
||||
with pytest.raises(ValueError, match="Output ids must be unique"):
|
||||
Collision.GET_SCHEMA()
|
||||
|
||||
|
||||
def test_schema_get_v1_info_emits_dynamic_outputs_field():
|
||||
DynNode = _make_node()
|
||||
DynNode.GET_SCHEMA()
|
||||
info = DynNode.SCHEMA.get_v1_info(DynNode)
|
||||
assert info.dynamic_outputs is not None and len(info.dynamic_outputs) == 1
|
||||
group = info.dynamic_outputs[0]
|
||||
assert group["kind"] == "by_key"
|
||||
assert group["selector"] == "mode"
|
||||
assert {opt["key"] for opt in group["options"]} == {"image", "latent"}
|
||||
# Static output arrays are empty — only the dynamic group is declared.
|
||||
assert info.output == []
|
||||
assert info.output_is_list == []
|
||||
|
||||
|
||||
def test_schema_static_outputs_stable_prefix_in_v1_arrays():
|
||||
"""A static output before a dynamic group still surfaces in RETURN_TYPES etc."""
|
||||
DynNode = _make_node(extra_outputs=[io.String.Output("status")])
|
||||
DynNode.GET_SCHEMA()
|
||||
# Class-level static arrays are the always-present prefix.
|
||||
assert list(DynNode.RETURN_TYPES) == ["STRING"]
|
||||
assert list(DynNode.RETURN_NAMES) == ["status"]
|
||||
assert list(DynNode.OUTPUT_IS_LIST) == [False]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# get_finalized_class_outputs
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def test_finalize_picks_active_branch():
|
||||
schema_outputs = [_byke()]
|
||||
finalized = io.get_finalized_class_outputs(schema_outputs, {"mode": "latent"})
|
||||
assert finalized.output_ids == ["latent"]
|
||||
assert finalized.return_types == ["LATENT"]
|
||||
assert finalized.output_is_list == [False]
|
||||
|
||||
|
||||
def test_finalize_unknown_selector_yields_empty():
|
||||
schema_outputs = [_byke()]
|
||||
finalized = io.get_finalized_class_outputs(schema_outputs, {"mode": "nonexistent"})
|
||||
assert len(finalized) == 0
|
||||
|
||||
|
||||
def test_finalize_link_selector_yields_empty():
|
||||
"""Link as selector value is treated as 'not finalizable' — no branch."""
|
||||
schema_outputs = [_byke()]
|
||||
finalized = io.get_finalized_class_outputs(schema_outputs, {"mode": ["src", 0]})
|
||||
assert len(finalized) == 0
|
||||
|
||||
|
||||
def test_finalize_static_prefix_preserved():
|
||||
schema_outputs = [io.String.Output("status"), _byke()]
|
||||
finalized = io.get_finalized_class_outputs(schema_outputs, {"mode": "image"})
|
||||
assert finalized.output_ids == ["status", "image", "mask"]
|
||||
assert finalized.return_types == ["STRING", "IMAGE", "MASK"]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# NodeOutput.from_named
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def test_nodeoutput_from_named_stores_dict():
|
||||
out = io.NodeOutput.from_named({"a": 1, "b": 2})
|
||||
assert out.named == {"a": 1, "b": 2}
|
||||
assert out.args == ()
|
||||
assert out.result is None # `.result` is the positional tuple
|
||||
|
||||
|
||||
def test_nodeoutput_rejects_mixed_positional_and_named():
|
||||
with pytest.raises(ValueError, match="cannot mix positional"):
|
||||
io.NodeOutput(1, 2, named={"a": 1})
|
||||
218
tests-unit/execution_test/test_dynamic_outputs_resolver.py
Normal file
218
tests-unit/execution_test/test_dynamic_outputs_resolver.py
Normal file
@@ -0,0 +1,218 @@
|
||||
"""TypeResolver + execution-helper tests for ``DynamicOutputs.ByKey``.
|
||||
|
||||
Covers the wiring between the per-prompt finalized output list and the
|
||||
execution layer:
|
||||
|
||||
* type resolver returns the active branch's declared type
|
||||
* type resolver reports the active output count for stale-link validation
|
||||
* ``is_output_list`` reflects the active branch
|
||||
* execution helpers refuse to consume ``NodeOutput(named=...)`` against a
|
||||
non-dynamic node, and reorder against the finalized list for dynamic ones
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
import types as _pytypes
|
||||
|
||||
import pytest
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Shared fixtures (mirror tests-unit/execution_test/test_type_resolver.py)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
@pytest.fixture
|
||||
def fake_nodes_module():
|
||||
real_nodes = sys.modules.get("nodes")
|
||||
fake = _pytypes.ModuleType("nodes")
|
||||
fake.NODE_CLASS_MAPPINGS = {}
|
||||
sys.modules["nodes"] = fake
|
||||
try:
|
||||
yield fake.NODE_CLASS_MAPPINGS
|
||||
finally:
|
||||
if real_nodes is not None:
|
||||
sys.modules["nodes"] = real_nodes
|
||||
else:
|
||||
del sys.modules["nodes"]
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def TypeResolver(fake_nodes_module):
|
||||
from comfy_execution.type_resolver import TypeResolver as TR
|
||||
return TR
|
||||
|
||||
|
||||
def _v1_node(return_types: tuple[str, ...]):
|
||||
class _V1:
|
||||
RETURN_TYPES = return_types
|
||||
|
||||
@classmethod
|
||||
def INPUT_TYPES(cls):
|
||||
return {"required": {}}
|
||||
|
||||
return _V1
|
||||
|
||||
|
||||
def _make_dyn_node():
|
||||
"""V3 node: ``mode`` selector with two branches."""
|
||||
from comfy_api.latest import _io as io
|
||||
|
||||
class DynBranch(io.ComfyNode):
|
||||
@classmethod
|
||||
def define_schema(cls):
|
||||
return io.Schema(
|
||||
node_id="DynBranch",
|
||||
inputs=[io.Combo.Input("mode", options=["image", "latent"], default="image")],
|
||||
outputs=[
|
||||
io.DynamicOutputs.ByKey(
|
||||
id="result", selector="mode",
|
||||
options=[
|
||||
io.DynamicOutputs.Option(key="image", outputs=[
|
||||
io.Image.Output("image"),
|
||||
io.Mask.Output("mask"),
|
||||
]),
|
||||
io.DynamicOutputs.Option(key="latent", outputs=[
|
||||
io.Latent.Output("latent"),
|
||||
]),
|
||||
],
|
||||
),
|
||||
],
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def execute(cls, mode):
|
||||
if mode == "latent":
|
||||
return io.NodeOutput.from_named({"latent": None})
|
||||
return io.NodeOutput.from_named({"image": None, "mask": None})
|
||||
|
||||
DynBranch.GET_SCHEMA()
|
||||
return DynBranch
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# TypeResolver against finalized outputs
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def test_dynamic_resolve_picks_active_branch_image(fake_nodes_module, TypeResolver):
|
||||
fake_nodes_module["DynBranch"] = _make_dyn_node()
|
||||
prompt = {"n1": {"class_type": "DynBranch", "inputs": {"mode": "image"}}}
|
||||
r = TypeResolver(prompt)
|
||||
assert r.resolve_output_type("n1", 0) == "IMAGE"
|
||||
assert r.resolve_output_type("n1", 1) == "MASK"
|
||||
|
||||
|
||||
def test_dynamic_resolve_picks_active_branch_latent(fake_nodes_module, TypeResolver):
|
||||
fake_nodes_module["DynBranch"] = _make_dyn_node()
|
||||
prompt = {"n1": {"class_type": "DynBranch", "inputs": {"mode": "latent"}}}
|
||||
r = TypeResolver(prompt)
|
||||
assert r.resolve_output_type("n1", 0) == "LATENT"
|
||||
|
||||
|
||||
def test_dynamic_finalized_output_count(fake_nodes_module, TypeResolver):
|
||||
fake_nodes_module["DynBranch"] = _make_dyn_node()
|
||||
fake_nodes_module["Static"] = _v1_node(("INT", "FLOAT"))
|
||||
prompt = {
|
||||
"img": {"class_type": "DynBranch", "inputs": {"mode": "image"}},
|
||||
"lat": {"class_type": "DynBranch", "inputs": {"mode": "latent"}},
|
||||
"stat": {"class_type": "Static", "inputs": {}},
|
||||
}
|
||||
r = TypeResolver(prompt)
|
||||
assert r.finalized_output_count("img") == 2 # image + mask
|
||||
assert r.finalized_output_count("lat") == 1
|
||||
assert r.finalized_output_count("stat") == 2 # static V1 falls through
|
||||
|
||||
|
||||
def test_dynamic_is_output_list_reflects_branch(fake_nodes_module, TypeResolver):
|
||||
from comfy_api.latest import _io as io
|
||||
|
||||
class DynList(io.ComfyNode):
|
||||
@classmethod
|
||||
def define_schema(cls):
|
||||
return io.Schema(
|
||||
node_id="DynList",
|
||||
inputs=[io.Combo.Input("mode", options=["one", "many"], default="one")],
|
||||
outputs=[
|
||||
io.DynamicOutputs.ByKey(
|
||||
id="r", selector="mode",
|
||||
options=[
|
||||
io.DynamicOutputs.Option(key="one", outputs=[
|
||||
io.Image.Output("img"),
|
||||
]),
|
||||
io.DynamicOutputs.Option(key="many", outputs=[
|
||||
io.Image.Output("imgs", is_output_list=True),
|
||||
]),
|
||||
],
|
||||
),
|
||||
],
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def execute(cls, mode):
|
||||
return io.NodeOutput.from_named({"img": None} if mode == "one" else {"imgs": [None]})
|
||||
|
||||
DynList.GET_SCHEMA()
|
||||
fake_nodes_module["DynList"] = DynList
|
||||
prompt = {
|
||||
"one": {"class_type": "DynList", "inputs": {"mode": "one"}},
|
||||
"many": {"class_type": "DynList", "inputs": {"mode": "many"}},
|
||||
}
|
||||
r = TypeResolver(prompt)
|
||||
assert r.is_output_list("one", 0) is False
|
||||
assert r.is_output_list("many", 0) is True
|
||||
|
||||
|
||||
def test_dynamic_out_of_range_returns_any(fake_nodes_module, TypeResolver):
|
||||
"""Slot index beyond the finalized branch resolves to AnyType (validation rejects separately)."""
|
||||
fake_nodes_module["DynBranch"] = _make_dyn_node()
|
||||
prompt = {"n1": {"class_type": "DynBranch", "inputs": {"mode": "latent"}}}
|
||||
r = TypeResolver(prompt)
|
||||
assert r.resolve_output_type("n1", 5) == "*"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Execution-side helpers
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def test_normalize_named_result_reorders_to_finalized():
|
||||
from comfy_api.latest import _io as io
|
||||
from execution import _normalize_named_result
|
||||
|
||||
finalized = io.get_finalized_class_outputs(
|
||||
[io.DynamicOutputs.ByKey(
|
||||
id="r", selector="mode",
|
||||
options=[io.DynamicOutputs.Option(key="x", outputs=[
|
||||
io.Image.Output("a"), io.Mask.Output("b"), io.Latent.Output("c"),
|
||||
])],
|
||||
)],
|
||||
{"mode": "x"},
|
||||
)
|
||||
node_output = io.NodeOutput.from_named({"c": 30, "a": 10, "b": 20})
|
||||
assert _normalize_named_result(node_output, finalized) == (10, 20, 30)
|
||||
|
||||
|
||||
def test_normalize_named_result_rejects_unknown_or_missing_ids():
|
||||
from comfy_api.latest import _io as io
|
||||
from execution import _normalize_named_result
|
||||
|
||||
finalized = io.get_finalized_class_outputs(
|
||||
[io.DynamicOutputs.ByKey(
|
||||
id="r", selector="mode",
|
||||
options=[io.DynamicOutputs.Option(key="x", outputs=[
|
||||
io.Image.Output("a"), io.Mask.Output("b"),
|
||||
])],
|
||||
)],
|
||||
{"mode": "x"},
|
||||
)
|
||||
with pytest.raises(Exception, match="missing"):
|
||||
_normalize_named_result(io.NodeOutput.from_named({"a": 1}), finalized)
|
||||
with pytest.raises(Exception, match="unknown"):
|
||||
_normalize_named_result(io.NodeOutput.from_named({"a": 1, "b": 2, "z": 3}), finalized)
|
||||
|
||||
|
||||
def test_normalize_named_result_requires_dynamic_node():
|
||||
from comfy_api.latest import _io as io
|
||||
from execution import _normalize_named_result
|
||||
|
||||
with pytest.raises(Exception, match="DynamicOutputs"):
|
||||
_normalize_named_result(io.NodeOutput.from_named({"a": 1}), None)
|
||||
Reference in New Issue
Block a user