diff --git a/CHANGELOG.md b/CHANGELOG.md index b616d8128..348031027 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,18 @@ history. ## [Unreleased] +### Changed + +- A `connect` into a widget input of an agent-built node is now type-checked. + `comfy workflow add-node` gives every widget input a socket entry (see Fixed + below), so a link into one is an ordinary connect to an existing slot rather + than a `grow` that minted a new slot and took the source's type unchecked. A + mismatched scalar — `INT` into a `FLOAT` widget such as `force_rate`, or + `IMAGE` into a `COMBO` — now fails the existing type check instead of being + accepted silently. A `COMBO` widget socket still accepts `COMBO`, `STRING`, + `INT` and `FLOAT`, because that is how a computed file name or a numeric + option reaches a combo; every other source type is refused. + ### Fixed - `comfy validate` no longer lets a dotted key left over from another @@ -35,6 +47,25 @@ history. same two values adjacently and is now keyword-only for the same reason, before anything is inserted into it. +- `comfy workflow add-node` writes a socket entry for every widget input of the + new node — `INT`, `FLOAT`, `STRING`, `BOOLEAN` and `COMBO` — in the same + `{"name", "type", "widget": {"name"}, "link": null}` shape the frontend + serializes, placed after the link inputs so existing link indices do not move. + Before this, an agent-built node carried no `inputs[]` entry for its widgets, + so a link a human drew into a widget socket on the canvas named a slot the + shared document did not have and was dropped. Sockets are written all or none + per node: a node with a widget that cannot have an entry of its own — a + dynamic combo, a union type such as `FLOAT,INT`, a socketless widget — keeps + the previous convert-on-connect behaviour unchanged. Nodes already present in + existing documents are not migrated. + +- The save-to-API converter no longer drops a `COMBO` value that happens to read + like a control marker. When a node's widget sockets account for every saved + widget value there is no room for a trailing `control_after_generate` marker, + so the positional marker filter is skipped and a value of `"fixed"` stays a + value. Saves with a real marker have one more value than sockets and still go + through the filter. + ## [1.24.0] - 2026-10-29 [Full notes](https://github.com/Comfy-Org/comfy-cli/releases/tag/v1.24.0) · 25 commits since v1.23.0. diff --git a/comfy_cli/link_integrity.py b/comfy_cli/link_integrity.py index 305ccf8e1..1c5bfc737 100644 --- a/comfy_cli/link_integrity.py +++ b/comfy_cli/link_integrity.py @@ -47,7 +47,7 @@ def _rows(links: Any) -> list[list]: def _scope_findings(nodes: list, links: Any, prefix: str | None) -> tuple[list[dict], list[dict]]: - from comfy_cli.workflow_ops import _types_compatible + from comfy_cli.workflow_ops import _input_accepts def addr(nid: Any) -> str: return f"{prefix}/{nid}" if prefix else str(nid) @@ -143,7 +143,7 @@ def fed_from(node: dict, src: Any, slot: Any, except_id: Any) -> str | None: candidates = [ str(i.get("name")) for i in inputs - if i.get("link") is None and i.get("name") and _types_compatible(source_type, i.get("type")) + if i.get("link") is None and i.get("name") and _input_accepts(source_type, i) ] where = ( f"link {link_id} from {'the subgraph input' if src_is_proxy else f'node {addr(src_id)} output {src_slot}'} " diff --git a/comfy_cli/workflow_ops.py b/comfy_cli/workflow_ops.py index 81633b2c6..188acf891 100644 --- a/comfy_cli/workflow_ops.py +++ b/comfy_cli/workflow_ops.py @@ -678,6 +678,21 @@ def _slot_types(t: Any) -> set[str]: return {p.strip() for p in str(t or "").split(",") if p.strip()} +_COMBO_SOCKET_SOURCE_TYPES = frozenset({"STRING", "INT", "FLOAT"}) + + +def _input_accepts(link_type: Any, input_entry: dict) -> bool: + """Whether an output of ``link_type`` may drive ``input_entry``. + + A COMBO widget socket also takes a scalar: that is how a computed file name + or option reaches a combo, and a combo's options can be numbers. + """ + dst_type = input_entry.get("type") + if dst_type == "COMBO" and input_entry.get("widget") and link_type in _COMBO_SOCKET_SOURCE_TYPES: + return True + return _types_compatible(link_type, dst_type) + + def _types_compatible(link_type: Any, dst_type: Any) -> bool: """Whether an output of ``link_type`` may drive an input of ``dst_type``. @@ -2301,7 +2316,7 @@ def _connect_impl( # link. if in_idx is not None: dst_type = (dst.get("inputs") or [])[in_idx].get("type") - if not _types_compatible(link_type, dst_type): + if not _input_accepts(link_type, (dst.get("inputs") or [])[in_idx]): raise ValueError( f"type mismatch: {link_type} output of node {from_node} cannot connect to " f"{dst_type} input {(dst.get('inputs') or [])[in_idx].get('name')!r} of node {to_node}" @@ -2571,7 +2586,7 @@ def _connect_interior( "the node lists; inside a subgraph connect can only wire an existing input" ) dst_type = (dst.get("inputs") or [])[in_idx].get("type") - if not _types_compatible(link_type, dst_type): + if not _input_accepts(link_type, (dst.get("inputs") or [])[in_idx]): raise ValueError( f"type mismatch: {link_type} output of node {'/'.join(scope['path'])}/{src.get('id')} cannot connect " f"to {dst_type} input {(dst.get('inputs') or [])[in_idx].get('name')!r} of node " @@ -4890,7 +4905,34 @@ def strip_internal(workflow: dict) -> dict: # --------------------------------------------------------------------------- +# Widget input types a fresh node gets a socket entry for. The frontend gives +# every non-socketless widget input a socket and serializes it as +# ``{"name", "type", "widget": {"name"}}``; without the entry the shared document +# has no slot for a link a human draws into that socket, so the link never +# reaches the document. +_SOCKETED_WIDGET_TYPES = frozenset({"INT", "FLOAT", "STRING", "BOOLEAN", "COMBO"}) + + +def _widget_input_entries(m, order: list[str]) -> list[dict]: + """Socket entries for every widget in ``order``, or none. + + Without object_info the converter names saved values from these entries by + position, so sockets for only some widgets would misname the rest. A node + with a widget that has no entry of its own (a dynamic combo, a union type, a + socketless widget) keeps the convert-on-connect path instead. + """ + entries = [ + {"name": p.name, "type": p.type, "widget": {"name": p.name}, "link": None} + for p in m.inputs + if not p.is_link and not p.is_socketless and p.type in _SOCKETED_WIDGET_TYPES + ] + if [e["name"] for e in entries] != [name for name in order if name != "control_after_generate"]: + return [] + return entries + + def _build_node(node_id: int, class_type: str, m, graph, pos: list, size: list, title: str | None = None) -> dict: + # Link inputs first, so their indices are unchanged; widget sockets after. inputs = [{"name": p.name, "type": p.type, "link": None} for p in m.inputs if p.is_link] outputs = [{"name": p.name, "type": p.type, "links": []} for p in m.outputs] # Widget values in positional order, including dynamic-combo selectors and @@ -4902,6 +4944,7 @@ def _build_node(node_id: int, class_type: str, m, graph, pos: list, size: list, # it, so neither does a fresh node — no phantom trailing ``null``. while order and order[-1] not in defaults: order = order[:-1] + inputs += _widget_input_entries(m, order) widgets = [defaults.get(name) for name in order] node = { "id": node_id, diff --git a/comfy_cli/workflow_to_api.py b/comfy_cli/workflow_to_api.py index 6e9a77511..e37de62c0 100644 --- a/comfy_cli/workflow_to_api.py +++ b/comfy_cli/workflow_to_api.py @@ -2510,7 +2510,13 @@ def emit(name: str, value: Any) -> Any: # No schema, or the schema declares no widget inputs: fall back to the # positional control-marker heuristic + node-input name inspection, which # matches the reference behavior for unknown node types. - filtered = _filter_control_values(widget_values, node_type=node_type, node=node, object_info=object_info) + # A socket for every value leaves no room for a control marker, so a COMBO + # value that reads "fixed" stays a value. + sockets = [i for i in node.get("inputs") or [] if isinstance(i, dict) and i.get("widget")] + if len(sockets) == len(widget_values): + filtered = widget_values + else: + filtered = _filter_control_values(widget_values, node_type=node_type, node=node, object_info=object_info) names = _fallback_widget_names(node, filtered) if not names: if filtered: diff --git a/tests/comfy_cli/command/test_workflow_edit_nested_autogrow.py b/tests/comfy_cli/command/test_workflow_edit_nested_autogrow.py index 54b155687..c29c617f3 100644 --- a/tests/comfy_cli/command/test_workflow_edit_nested_autogrow.py +++ b/tests/comfy_cli/command/test_workflow_edit_nested_autogrow.py @@ -59,8 +59,12 @@ def _node(wf: dict, node_id: Any) -> dict: return next(n for n in wf["nodes"] if n["id"] == node_id) +def _is_widget_socket(entry: dict) -> bool: + return "widget" in entry and "grow_id" not in entry + + def _inputs(wf: dict, node_id: Any) -> list[str]: - return [i["name"] for i in _node(wf, node_id).get("inputs") or []] + return [i["name"] for i in _node(wf, node_id).get("inputs") or [] if not _is_widget_socket(i)] def _link_of(wf: dict, node_id: Any, name: str): @@ -152,7 +156,7 @@ def _add_loader(wf: dict, graph: Graph, class_type: str) -> tuple[dict, int]: def test_add_node_writes_frontend_width_widgets_and_no_group_inputs(graph): wf, _ = workflow_ops.add_node(_empty(), graph, "MinimaxHailuo03ReferenceNode") node = wf["nodes"][0] - assert node["inputs"] == [] + assert [i for i in node["inputs"] if not _is_widget_socket(i)] == [] order = graph.widget_order_default("MinimaxHailuo03ReferenceNode") assert len(node["widgets_values"]) == len(order) == 8 by_name = dict(zip(order, node["widgets_values"])) @@ -171,7 +175,7 @@ def test_connect_grows_first_nested_slot_by_its_schema_name(graph): wf, b = _add_loader(wf, graph, "GeminiNanoBanana2V2") widgets_before = list(_node(wf, b)["widgets_values"]) wf, op = workflow_ops.connect(wf, graph, a, "IMAGE", b, "model.images.image_1") - grown = _node(wf, b)["inputs"] + grown = [i for i in _node(wf, b)["inputs"] if not _is_widget_socket(i)] assert [i["name"] for i in grown] == ["model.images.image_1"] assert grown[0]["type"] == "IMAGE" assert grown[0]["link"] == op["link_id"] @@ -446,13 +450,29 @@ def test_full_group_reports_full_before_the_next_key_hint(graph): def test_a_real_widget_name_outranks_the_bare_element_guess(): """A node whose group's bare element vocabulary collides with a real - widget name keeps the widget→input conversion (the existing precedence).""" + widget name resolves to that widget's own input, never the group guess.""" oi = json.loads(FIXTURE.read_text()) oi["BatchImagesNode"]["input"]["required"]["image0"] = ["STRING", {"default": ""}] oi["BatchImagesNode"]["input_order"]["required"].append("image0") g = Graph.from_object_info(oi) wf, batch = _add_loader(_empty(), g, "BatchImagesNode") - _idx, grow = workflow_ops._resolve_input_target(_node(wf, batch), g, "image0", "STRING") + node = _node(wf, batch) + idx, grow = workflow_ops._resolve_input_target(node, g, "image0", "STRING") + assert grow is None + assert node["inputs"][idx] == {"name": "image0", "type": "STRING", "widget": {"name": "image0"}, "link": None} + + +def test_a_real_combo_widget_name_outranks_the_bare_element_guess(): + """A node saved before COMBO widgets had socket entries takes the + widget→input conversion, still ahead of the group's element guess.""" + oi = json.loads(FIXTURE.read_text()) + oi["BatchImagesNode"]["input"]["required"]["image0"] = [["a", "b"]] + oi["BatchImagesNode"]["input_order"]["required"].append("image0") + g = Graph.from_object_info(oi) + wf, batch = _add_loader(_empty(), g, "BatchImagesNode") + node = _node(wf, batch) + node["inputs"] = [i for i in node["inputs"] if i["name"] != "image0"] + _idx, grow = workflow_ops._resolve_input_target(node, g, "image0", "STRING") assert grow == {"name": "image0", "type": "STRING", "widget": "image0"} diff --git a/tests/comfy_cli/test_add_node_widget_input_slots.py b/tests/comfy_cli/test_add_node_widget_input_slots.py new file mode 100644 index 000000000..79250ae05 --- /dev/null +++ b/tests/comfy_cli/test_add_node_widget_input_slots.py @@ -0,0 +1,274 @@ +"""Agent-built nodes carry a socket entry for every widget input. + +Reported: the agent said ``frame_load_cap`` on an agent-built Load Video (VHS) +and an agent-made custom node was a plain widget = 1000, while the user had +wired a PrimitiveInt into both on the canvas. ``_build_node`` wrote only LINK +inputs, so the shared document had no ``frame_load_cap`` slot. The frontend +gives every non-socketless widget input a socket, so a human link drawn into +it named an input the document did not hold and never reached it. + +A node the frontend creates serializes those entries +(``{"name", "type", "widget": {"name"}, "link": None}``), so an agent-built +node now does too. A link into such an input is then a CONCRETE connect: one +last-writer-wins register per input, instead of an autogrow-style ``grow`` +that mints a fresh slot per link and leaves two slots when two writers race. +""" + +from __future__ import annotations + +import copy + +import pytest + +from comfy_cli import workflow_ops +from comfy_cli.cql.engine import Graph +from comfy_cli.workflow_print import render_py +from comfy_cli.workflow_to_api import convert_ui_to_api + + +def _node(required: dict, outputs: list[str], optional: dict | None = None, names: list[str] | None = None) -> dict: + spec = {"required": required} + order = {"required": list(required)} + if optional: + spec["optional"] = optional + order["optional"] = list(optional) + return { + "input": spec, + "input_order": order, + "output": outputs, + "output_name": names or outputs, + "category": "test", + "display_name": "x", + "python_module": "custom_nodes.test", + } + + +OBJECT_INFO = { + "PrimitiveInt": _node({"value": ["INT", {"default": 0}]}, ["INT"]), + "PrimitiveString": _node({"value": ["STRING", {"default": ""}]}, ["STRING"]), + "VHS_LoadVideo": _node( + { + "video": [["clip.mp4"]], + "force_rate": ["FLOAT", {"default": 0}], + "frame_load_cap": ["INT", {"default": 0}], + "skip_first_frames": ["INT", {"default": 0}], + }, + ["IMAGE", "INT"], + optional={"meta_batch": ["VHS_BatchManager"], "vae": ["VAE"]}, + names=["IMAGE", "frame_count"], + ), + "CSVCVColumn": _node( + { + "csv_path": ["STRING", {"default": ""}], + "enabled": ["BOOLEAN", {"default": True}], + "frame_load_cap": ["INT", {"default": 0}], + }, + ["FLOAT"], + ), +} + +LOAD_VIDEO_LINK_INPUTS = [("meta_batch", "VHS_BatchManager"), ("vae", "VAE")] + + +@pytest.fixture +def graph() -> Graph: + return Graph.from_object_info(OBJECT_INFO) + + +def _add(workflow: dict, graph: Graph, class_type: str) -> dict: + workflow, op = workflow_ops.add_node(workflow, graph, class_type, pos=[0, 0]) + return next(n for n in workflow["nodes"] if n["id"] == op["node_id"]) + + +def _input(node: dict, name: str) -> list[dict]: + return [i for i in node["inputs"] if i.get("name") == name] + + +def _built(graph: Graph) -> tuple[dict, dict, dict]: + workflow: dict = {"nodes": [], "links": []} + primitive = _add(workflow, graph, "PrimitiveInt") + video = _add(workflow, graph, "VHS_LoadVideo") + return workflow, primitive, video + + +def test_add_node_writes_a_widget_socket_for_each_widget_input(graph): + workflow: dict = {"nodes": [], "links": []} + video = _add(workflow, graph, "VHS_LoadVideo") + csv = _add(workflow, graph, "CSVCVColumn") + + assert [(i["name"], i["type"]) for i in video["inputs"][:2]] == LOAD_VIDEO_LINK_INPUTS + for name, slot_type in [("force_rate", "FLOAT"), ("frame_load_cap", "INT"), ("skip_first_frames", "INT")]: + assert _input(video, name) == [{"name": name, "type": slot_type, "widget": {"name": name}, "link": None}] + assert _input(video, "video") == [{"name": "video", "type": "COMBO", "widget": {"name": "video"}, "link": None}] + for name, slot_type in [("csv_path", "STRING"), ("enabled", "BOOLEAN"), ("frame_load_cap", "INT")]: + assert _input(csv, name) == [{"name": name, "type": slot_type, "widget": {"name": name}, "link": None}] + + +def test_connect_into_a_widget_input_is_a_concrete_connect(graph): + workflow, primitive, video = _built(graph) + + workflow, op = workflow_ops.connect(workflow, graph, primitive["id"], 0, video["id"], "frame_load_cap") + + assert "grow" not in op + assert video["inputs"][op["to_slot"]]["name"] == "frame_load_cap" + assert _input(video, "frame_load_cap") == [ + {"name": "frame_load_cap", "type": "INT", "widget": {"name": "frame_load_cap"}, "link": op["link_id"]} + ] + + +def test_two_racing_links_into_one_widget_input_converge_on_one_slot(graph): + base, primitive, video = _built(graph) + second = _add(base, graph, "PrimitiveInt") + _, first_op = workflow_ops.connect(copy.deepcopy(base), graph, primitive["id"], 0, video["id"], "frame_load_cap") + _, second_op = workflow_ops.connect( + copy.deepcopy(base), graph, second["id"], 0, video["id"], "frame_load_cap", base_version=1 + ) + + converged = [] + for order in ([first_op, second_op], [second_op, first_op]): + replica = copy.deepcopy(base) + for op in order: + workflow_ops.apply_op(replica, op, graph) + node = next(n for n in replica["nodes"] if n["id"] == video["id"]) + converged.append(_input(node, "frame_load_cap")) + + assert converged[0] == converged[1] + assert [slot["link"] for slot in converged[0]] == [second_op["link_id"]] + + +def test_api_prompt_reads_the_widget_value_until_linked_then_the_link(graph): + workflow, primitive, video = _built(graph) + workflow_ops.set_widget(workflow, graph, video["id"], "frame_load_cap", 1000) + + unlinked = convert_ui_to_api(copy.deepcopy(workflow), OBJECT_INFO) + assert unlinked[str(video["id"])]["inputs"]["frame_load_cap"] == 1000 + + workflow_ops.connect(workflow, graph, primitive["id"], 0, video["id"], "frame_load_cap") + linked = convert_ui_to_api(workflow, OBJECT_INFO) + assert linked[str(video["id"])]["inputs"]["frame_load_cap"] == [str(primitive["id"]), 0] + + +def test_the_agent_print_shows_a_human_link_into_frame_load_cap(graph): + workflow, primitive, video = _built(graph) + slot = next(k for k, i in enumerate(video["inputs"]) if i["name"] == "frame_load_cap") + link_id = 501 + video["inputs"][slot]["link"] = link_id + primitive["outputs"][0]["links"] = [link_id] + workflow["links"].append([link_id, primitive["id"], 0, video["id"], slot, "INT"]) + + source = render_py(workflow, graph).source + + assert "frame_load_cap=primitive_int" in source + assert "frame_load_cap=0" not in source + + +def test_a_widget_socket_refuses_a_link_of_another_scalar_type(graph): + workflow, primitive, video = _built(graph) + + with pytest.raises(ValueError, match=r"type mismatch: INT output .* FLOAT input 'force_rate'"): + workflow_ops.connect(workflow, graph, primitive["id"], 0, video["id"], "force_rate") + + +def test_an_agent_built_node_keeps_its_value_names_without_object_info(graph): + """Every widget has a socket, so the sockets alone name the saved values.""" + workflow: dict = {"nodes": [], "links": []} + video = _add(workflow, graph, "VHS_LoadVideo") + video["widgets_values"] = ["clip.mp4", 24.0, 1000, 0] + + api = convert_ui_to_api(workflow, object_info={}) + + assert api[str(video["id"])]["inputs"] == { + "video": "clip.mp4", + "force_rate": 24.0, + "frame_load_cap": 1000, + "skip_first_frames": 0, + } + + +def test_a_string_into_a_combo_socket_is_a_concrete_connect_that_converges(graph): + workflow: dict = {"nodes": [], "links": []} + text = _add(workflow, graph, "PrimitiveString") + video = _add(workflow, graph, "VHS_LoadVideo") + base = copy.deepcopy(workflow) + + _, first_op = workflow_ops.connect(copy.deepcopy(base), graph, text["id"], 0, video["id"], "video") + _, second_op = workflow_ops.connect(copy.deepcopy(base), graph, text["id"], 0, video["id"], "video") + + assert "grow" not in first_op + converged = [] + for order in ([first_op, second_op], [second_op, first_op]): + replica = copy.deepcopy(base) + for op in order: + workflow_ops.apply_op(replica, op, graph) + node = next(n for n in replica["nodes"] if n["id"] == video["id"]) + converged.append(_input(node, "video")) + assert converged[0] == converged[1] + assert len(converged[0]) == 1 + + +def test_a_number_can_drive_a_numeric_combo_socket(): + catalog = dict(OBJECT_INFO, BitDepth=_node({"bits": [[8, 16, 32]]}, ["INT"])) + graph = Graph.from_object_info(catalog) + workflow: dict = {"nodes": [], "links": []} + primitive = _add(workflow, graph, "PrimitiveInt") + bits = _add(workflow, graph, "BitDepth") + + workflow_ops.connect(workflow, graph, primitive["id"], 0, bits["id"], "bits") + + assert _input(next(n for n in workflow["nodes"] if n["id"] == bits["id"]), "bits")[0]["link"] is not None + + +def test_a_combo_socket_still_refuses_a_link_of_another_type(graph): + workflow, _primitive, video = _built(graph) + source = _add(workflow, graph, "VHS_LoadVideo") + + with pytest.raises(ValueError, match=r"type mismatch: IMAGE output .* COMBO input 'video'"): + workflow_ops.connect(workflow, graph, source["id"], 0, video["id"], "video") + + +@pytest.mark.parametrize( + "required", + [ + {"strength": ["FLOAT,INT", {"widgetType": "FLOAT"}], "steps": ["INT", {"default": 0}]}, + {"hidden": ["INT", {"default": 0, "socketless": True}], "steps": ["INT", {"default": 0}]}, + ], +) +def test_a_node_with_a_widget_that_cannot_have_a_socket_gets_none(required): + """Sockets for only some widgets would misname saved values, so it is all or none.""" + workflow: dict = {"nodes": [], "links": []} + + node = _add(workflow, Graph.from_object_info({"Mixed": _node(required, ["INT"])}), "Mixed") + + assert node["inputs"] == [] + + +def test_a_saved_node_with_a_socket_for_every_widget_still_names_its_values(): + node = { + "id": 7, + "type": "NotInCatalog", + "inputs": [ + {"name": "strength", "type": "FLOAT", "widget": {"name": "strength"}, "link": None}, + {"name": "steps", "type": "INT", "widget": {"name": "steps"}, "link": None}, + ], + "outputs": [], + "widgets_values": [0.5, 20], + } + workflow = {"nodes": [node], "links": []} + + api = convert_ui_to_api(workflow, object_info={}) + + assert api["7"]["inputs"] == {"strength": 0.5, "steps": 20} + + +def test_a_combo_value_named_like_a_control_marker_survives_without_object_info(): + """A socket for every value means no value is a control_after_generate marker.""" + graph = Graph.from_object_info( + {"Picker": _node({"mode": [["fixed", "random"]], "steps": ["INT", {"default": 0}]}, ["INT"])} + ) + workflow: dict = {"nodes": [], "links": []} + node = _add(workflow, graph, "Picker") + node["widgets_values"] = ["fixed", 5] + + api = convert_ui_to_api(workflow, object_info={}) + + assert api[str(node["id"])]["inputs"] == {"mode": "fixed", "steps": 5} diff --git a/tests/comfy_cli/test_workflow_print_promoted_autogrow.py b/tests/comfy_cli/test_workflow_print_promoted_autogrow.py index 5a36f3361..ee18527de 100644 --- a/tests/comfy_cli/test_workflow_print_promoted_autogrow.py +++ b/tests/comfy_cli/test_workflow_print_promoted_autogrow.py @@ -530,7 +530,7 @@ def test_cli_print_autogrow_addresses_match_connect(tmp_path, autogrow_graph): # that printed slot name is exactly what connect grows wf2, _ = workflow_ops.connect(wf, autogrow_graph, a, "IMAGE", b, "model.images.image_1") node = next(n for n in wf2["nodes"] if n["id"] == b) - assert [i["name"] for i in node["inputs"]] == ["model.images.image_1"] + assert [i["name"] for i in node["inputs"] if "widget" not in i] == ["model.images.image_1"] def test_no_catalog_still_prints_the_instance_values(promoted_graph):