The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
Add MatchType, DynamicCombo, and Autogrow support to V3 Schema (#10832)
Jedrzej Kosinskic120eee5bacc
diff --git a/comfy_api/latest/__init__.py b/comfy_api/latest/__init__.pyindex 176ae36e0..0fa01d1e7 100644--- a/comfy_api/latest/__init__.py+++ b/comfy_api/latest/__init__.py@@ -8,8 +8,8 @@ from comfy_api.internal.async_to_sync import create_sync_classfrom comfy_api.latest._input import ImageInput, AudioInput, MaskInput, LatentInput, VideoInputfrom comfy_api.latest._input_impl import VideoFromFile, VideoFromComponentsfrom comfy_api.latest._util import VideoCodec, VideoContainer, VideoComponents, MESH, VOXEL-from . import _io as io-from . import _ui as ui+from . import _io_public as io+from . import _ui_public as ui# from comfy_api.latest._resources import _RESOURCES as resources #noqa: F401from comfy_execution.utils import get_executing_contextfrom comfy_execution.progress import get_progress_state, PreviewImageTuplediff --git a/comfy_api/latest/_io.py b/comfy_api/latest/_io.pyindex 79c0722a9..257f07c42 100644--- a/comfy_api/latest/_io.py+++ b/comfy_api/latest/_io.py@@ -4,6 +4,7 @@ import copyimport inspectfrom abc import ABC, abstractmethodfrom collections import Counter+from collections.abc import Iterablefrom dataclasses import asdict, dataclassfrom enum import Enumfrom typing import Any, Callable, Literal, TypedDict, TypeVar, TYPE_CHECKING@@ -150,6 +151,9 @@ class _IO_V3:def __init__(self):pass+ def validate(self):+ pass+@propertydef io_type(self):return self.Parent.io_type@@ -182,6 +186,9 @@ class Input(_IO_V3):def get_io_type(self):return _StringIOType(self.io_type)+ def get_all(self) -> list[Input]:+ return [self]+class WidgetInput(Input):'''Base class for a V3 Input with widget.@@ -814,13 +821,61 @@ class MultiType:else:return super().as_dict()+@comfytype(io_type="COMFY_MATCHTYPE_V3")+class MatchType(ComfyTypeIO):+ class Template:+ def __init__(self, template_id: str, allowed_types: _ComfyType | list[_ComfyType] = AnyType):+ self.template_id = template_id+ # account for syntactic sugar+ if not isinstance(allowed_types, Iterable):+ allowed_types = [allowed_types]+ for t in allowed_types:+ if not isinstance(t, type):+ if not isinstance(t, _ComfyType):+ raise ValueError(f"Allowed types must be a ComfyType or a list of ComfyTypes, got {t.__class__.__name__}")+ else:+ if not issubclass(t, _ComfyType):+ raise ValueError(f"Allowed types must be a ComfyType or a list of ComfyTypes, got {t.__name__}")+ self.allowed_types = allowed_types++ def as_dict(self):+ return {+ "template_id": self.template_id,+ "allowed_types": ",".join([t.io_type for t in self.allowed_types]),+ }++ class Input(Input):+ def __init__(self, id: str, template: MatchType.Template,+ display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None, extra_dict=None):+ super().__init__(id, display_name, optional, tooltip, lazy, extra_dict)+ self.template = template++ def as_dict(self):+ return super().as_dict() | prune_dict({+ "template": self.template.as_dict(),+ })++ class Output(Output):+ def __init__(self, template: MatchType.Template, id: str=None, display_name: str=None, tooltip: str=None,+ is_output_list=False):+ super().__init__(id, display_name, tooltip, is_output_list)+ self.template = template++ def as_dict(self):+ return super().as_dict() | prune_dict({+ "template": self.template.as_dict(),+ })+class DynamicInput(Input, ABC):'''Abstract class for dynamic input registration.'''- @abstractmethoddef get_dynamic(self) -> list[Input]:- ...+ return []++ def expand_schema_for_dynamic(self, d: dict[str, Any], live_inputs: dict[str, Any], curr_prefix=''):+ pass+class DynamicOutput(Output, ABC):'''@@ -830,99 +885,223 @@ class DynamicOutput(Output, ABC):is_output_list=False):super().__init__(id, display_name, tooltip, is_output_list)- @abstractmethoddef get_dynamic(self) -> list[Output]:- ...+ return []@comfytype(io_type="COMFY_AUTOGROW_V3")-class AutogrowDynamic(ComfyTypeI):- Type = list[Any]+class Autogrow(ComfyTypeI):+ Type = dict[str, Any]+ _MaxNames = 100 # NOTE: max 100 names for sanity++ class _AutogrowTemplate:+ def __init__(self, input: Input):+ # dynamic inputs are not allowed as the template input+ assert(not isinstance(input, DynamicInput))+ self.input = copy.copy(input)+ if isinstance(self.input, WidgetInput):+ self.input.force_input = True+ self.names: list[str] = []+ self.cached_inputs = {}++ def _create_input(self, input: Input, name: str):+ new_input = copy.copy(self.input)+ new_input.id = name+ return new_input++ def _create_cached_inputs(self):+ for name in self.names:+ self.cached_inputs[name] = self._create_input(self.input, name)++ def get_all(self) -> list[Input]:+ return list(self.cached_inputs.values())++ def as_dict(self):+ return prune_dict({+ "input": create_input_dict_v1([self.input]),+ })++ def validate(self):+ self.input.validate()++ def expand_schema_for_dynamic(self, d: dict[str, Any], live_inputs: dict[str, Any], curr_prefix=''):+ real_inputs = []+ for name, input in self.cached_inputs.items():+ if name in live_inputs:+ real_inputs.append(input)+ add_to_input_dict_v1(d, real_inputs, live_inputs, curr_prefix)+ add_dynamic_id_mapping(d, real_inputs, curr_prefix)++ class TemplatePrefix(_AutogrowTemplate):+ def __init__(self, input: Input, prefix: str, min: int=1, max: int=10):+ super().__init__(input)+ self.prefix = prefix+ assert(min >= 0)+ assert(max >= 1)+ assert(max <= Autogrow._MaxNames)+ self.min = min+ self.max = max+ self.names = [f"{self.prefix}{i}" for i in range(self.max)]+ self._create_cached_inputs()++ def as_dict(self):+ return super().as_dict() | prune_dict({+ "prefix": self.prefix,+ "min": self.min,+ "max": self.max,+ })++ class TemplateNames(_AutogrowTemplate):+ def __init__(self, input: Input, names: list[str], min: int=1):+ super().__init__(input)+ self.names = names[:Autogrow._MaxNames]+ assert(min >= 0)+ self.min = min+ self._create_cached_inputs()++ def as_dict(self):+ return super().as_dict() | prune_dict({+ "names": self.names,+ "min": self.min,+ })+class Input(DynamicInput):- def __init__(self, id: str, template_input: Input, min: int=1, max: int=None,+ def __init__(self, id: str, template: Autogrow.TemplatePrefix | Autogrow.TemplateNames,display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None, extra_dict=None):super().__init__(id, display_name, optional, tooltip, lazy, extra_dict)- self.template_input = template_input- if min is not None:- assert(min >= 1)- if max is not None:- assert(max >= 1)- self.min = min- self.max = max+ self.template = template++ def as_dict(self):+ return super().as_dict() | prune_dict({+ "template": self.template.as_dict(),+ })def get_dynamic(self) -> list[Input]:- curr_count = 1- new_inputs = []- for i in range(self.min):- new_input = copy.copy(self.template_input)- new_input.id = f"{new_input.id}{curr_count}_${self.id}_ag$"- if new_input.display_name is not None:- new_input.display_name = f"{new_input.display_name}{curr_count}"- new_input.optional = self.optional or new_input.optional- if isinstance(self.template_input, WidgetInput):- new_input.force_input = True- new_inputs.append(new_input)- curr_count += 1- # pretend to expand up to max- for i in range(curr_count-1, self.max):- new_input = copy.copy(self.template_input)- new_input.id = f"{new_input.id}{curr_count}_${self.id}_ag$"- if new_input.display_name is not None:- new_input.display_name = f"{new_input.display_name}{curr_count}"- new_input.optional = True- if isinstance(self.template_input, WidgetInput):- new_input.force_input = True- new_inputs.append(new_input)- curr_count += 1- return new_inputs--@comfytype(io_type="COMFY_COMBODYNAMIC_V3")-class ComboDynamic(ComfyTypeI):- class Input(DynamicInput):- def __init__(self, id: str):- pass+ return self.template.get_all()-@comfytype(io_type="COMFY_MATCHTYPE_V3")-class MatchType(ComfyTypeIO):- class Template:- def __init__(self, template_id: str, allowed_types: _ComfyType | list[_ComfyType]):- self.template_id = template_id- self.allowed_types = [allowed_types] if isinstance(allowed_types, _ComfyType) else allowed_types+ def get_all(self) -> list[Input]:+ return [self] + self.template.get_all()++ def validate(self):+ self.template.validate()++ def expand_schema_for_dynamic(self, d: dict[str, Any], live_inputs: dict[str, Any], curr_prefix=''):+ curr_prefix = f"{curr_prefix}{self.id}."+ # need to remove self from expected inputs dictionary; replaced by template inputs in frontend+ for inner_dict in d.values():+ if self.id in inner_dict:+ del inner_dict[self.id]+ self.template.expand_schema_for_dynamic(d, live_inputs, curr_prefix)++@comfytype(io_type="COMFY_DYNAMICCOMBO_V3")+class DynamicCombo(ComfyTypeI):+ Type = dict[str, Any]++ class Option:+ def __init__(self, key: str, inputs: list[Input]):+ self.key = key+ self.inputs = inputsdef as_dict(self):return {- "template_id": self.template_id,- "allowed_types": "".join(t.io_type for t in self.allowed_types),+ "key": self.key,+ "inputs": create_input_dict_v1(self.inputs),}class Input(DynamicInput):- def __init__(self, id: str, template: MatchType.Template,+ def __init__(self, id: str, options: list[DynamicCombo.Option],display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None, extra_dict=None):super().__init__(id, display_name, optional, tooltip, lazy, extra_dict)- self.template = template+ self.options = options++ def expand_schema_for_dynamic(self, d: dict[str, Any], live_inputs: dict[str, Any], curr_prefix=''):+ # check if dynamic input's id is in live_inputs+ if self.id in live_inputs:+ curr_prefix = f"{curr_prefix}{self.id}."+ key = live_inputs[self.id]+ selected_option = None+ for option in self.options:+ if option.key == key:+ selected_option = option+ break+ if selected_option is not None:+ add_to_input_dict_v1(d, selected_option.inputs, live_inputs, curr_prefix)+ add_dynamic_id_mapping(d, selected_option.inputs, curr_prefix, self)def get_dynamic(self) -> list[Input]:- return [self]+ return [input for option in self.options for input in option.inputs]++ def get_all(self) -> list[Input]:+ return [self] + [input for option in self.options for input in option.inputs]def as_dict(self):return super().as_dict() | prune_dict({- "template": self.template.as_dict(),+ "options": [o.as_dict() for o in self.options],})- class Output(DynamicOutput):- def __init__(self, id: str, template: MatchType.Template, display_name: str=None, tooltip: str=None,- is_output_list=False):- super().__init__(id, display_name, tooltip, is_output_list)- self.template = template+ def validate(self):+ # make sure all nested inputs are validated+ for option in self.options:+ for input in option.inputs:+ input.validate()++@comfytype(io_type="COMFY_DYNAMICSLOT_V3")+class DynamicSlot(ComfyTypeI):+ Type = dict[str, Any]++ class Input(DynamicInput):+ def __init__(self, slot: Input, inputs: list[Input],+ display_name: str=None, tooltip: str=None, lazy: bool=None, extra_dict=None):+ assert(not isinstance(slot, DynamicInput))+ self.slot = copy.copy(slot)+ self.slot.display_name = slot.display_name if slot.display_name is not None else display_name+ optional = True+ self.slot.tooltip = slot.tooltip if slot.tooltip is not None else tooltip+ self.slot.lazy = slot.lazy if slot.lazy is not None else lazy+ self.slot.extra_dict = slot.extra_dict if slot.extra_dict is not None else extra_dict+ super().__init__(slot.id, self.slot.display_name, optional, self.slot.tooltip, self.slot.lazy, self.slot.extra_dict)+ self.inputs = inputs+ self.force_input = None+ # force widget inputs to have no widgets, otherwise this would be awkward+ if isinstance(self.slot, WidgetInput):+ self.force_input = True+ self.slot.force_input = True++ def expand_schema_for_dynamic(self, d: dict[str, Any], live_inputs: dict[str, Any], curr_prefix=''):+ if self.id in live_inputs:+ curr_prefix = f"{curr_prefix}{self.id}."+ add_to_input_dict_v1(d, self.inputs, live_inputs, curr_prefix)+ add_dynamic_id_mapping(d, [self.slot] + self.inputs, curr_prefix)++ def get_dynamic(self) -> list[Input]:+ return [self.slot] + self.inputs- def get_dynamic(self) -> list[Output]:- return [self]+ def get_all(self) -> list[Input]:+ return [self] + [self.slot] + self.inputsdef as_dict(self):return super().as_dict() | prune_dict({- "template": self.template.as_dict(),+ "slotType": str(self.slot.get_io_type()),+ "inputs": create_input_dict_v1(self.inputs),+ "forceInput": self.force_input,})+ def validate(self):+ self.slot.validate()+ for input in self.inputs:+ input.validate()++def add_dynamic_id_mapping(d: dict[str, Any], inputs: list[Input], curr_prefix: str, self: DynamicInput=None):+ dynamic = d.setdefault("dynamic_paths", {})+ if self is not None:+ dynamic[self.id] = f"{curr_prefix}{self.id}"+ for i in inputs:+ if not isinstance(i, DynamicInput):+ dynamic[f"{i.id}"] = f"{curr_prefix}{i.id}"++class V3Data(TypedDict):+ hidden_inputs: dict[str, Any]+ dynamic_paths: dict[str, Any]class HiddenHolder:def __init__(self, unique_id: str, prompt: Any,@@ -984,6 +1163,7 @@ class NodeInfoV1:output_is_list: list[bool]=Noneoutput_name: list[str]=Noneoutput_tooltips: list[str]=None+ output_matchtypes: list[str]=Nonename: str=Nonedisplay_name: str=Nonedescription: str=None@@ -1061,7 +1241,11 @@ class Schema:'''Validate the schema:- verify ids on inputs and outputs are unique - both internally and in relation to each other'''- input_ids = [i.id for i in self.inputs] if self.inputs is not None else []+ nested_inputs: list[Input] = []+ if self.inputs is not None:+ for input in self.inputs:+ nested_inputs.extend(input.get_all())+ input_ids = [i.id for i in nested_inputs] if nested_inputs is not None else []output_ids = [o.id for o in self.outputs] if self.outputs is not None else []input_set = set(input_ids)output_set = set(output_ids)@@ -1077,6 +1261,13 @@ class Schema:issues.append(f"Ids must be unique between inputs and outputs, but {intersection} are not.")if len(issues) > 0:raise ValueError("\n".join(issues))+ # validate inputs and outputs+ if self.inputs is not None:+ for input in self.inputs:+ input.validate()+ if self.outputs is not None:+ for output in self.outputs:+ output.validate()def finalize(self):"""Add hidden based on selected schema options, and give outputs without ids default ids."""@@ -1102,19 +1293,10 @@ class Schema:if output.id is None:output.id = f"_{i}_{output.io_type}_"- def get_v1_info(self, cls) -> NodeInfoV1:+ def get_v1_info(self, cls, live_inputs: dict[str, Any]=None) -> NodeInfoV1:+ # NOTE: live_inputs will not be used anymore very soon and this will be done another way# get V1 inputs- input = {- "required": {}- }- if self.inputs:- for i in self.inputs:- if isinstance(i, DynamicInput):- dynamic_inputs = i.get_dynamic()- for d in dynamic_inputs:- add_to_dict_v1(d, input)- else:- add_to_dict_v1(i, input)+ input = create_input_dict_v1(self.inputs, live_inputs)if self.hidden:for hidden in self.hidden:input.setdefault("hidden", {})[hidden.name] = (hidden.value,)@@ -1123,12 +1305,24 @@ class Schema:output_is_list = []output_name = []output_tooltips = []+ output_matchtypes = []+ any_matchtypes = Falseif self.outputs:for o in self.outputs:output.append(o.io_type)output_is_list.append(o.is_output_list)output_name.append(o.display_name if o.display_name else o.io_type)output_tooltips.append(o.tooltip if o.tooltip else None)+ # special handling for MatchType+ if isinstance(o, MatchType.Output):+ output_matchtypes.append(o.template.template_id)+ any_matchtypes = True+ else:+ output_matchtypes.append(None)++ # clear out lists that are all None+ if not any_matchtypes:+ output_matchtypes = Noneinfo = NodeInfoV1(input=input,@@ -1137,6 +1331,7 @@ class Schema:output_is_list=output_is_list,output_name=output_name,output_tooltips=output_tooltips,+ output_matchtypes=output_matchtypes,name=self.node_id,display_name=self.display_name,category=self.category,@@ -1182,16 +1377,57 @@ class Schema:return info-def add_to_dict_v1(i: Input, input: dict):+def create_input_dict_v1(inputs: list[Input], live_inputs: dict[str, Any]=None) -> dict:+ input = {+ "required": {}+ }+ add_to_input_dict_v1(input, inputs, live_inputs)+ return input++def add_to_input_dict_v1(d: dict[str, Any], inputs: list[Input], live_inputs: dict[str, Any]=None, curr_prefix=''):+ for i in inputs:+ if isinstance(i, DynamicInput):+ add_to_dict_v1(i, d)+ if live_inputs is not None:+ i.expand_schema_for_dynamic(d, live_inputs, curr_prefix)+ else:+ add_to_dict_v1(i, d)++def add_to_dict_v1(i: Input, d: dict, dynamic_dict: dict=None):key = "optional" if i.optional else "required"as_dict = i.as_dict()# for v1, we don't want to include the optional keyas_dict.pop("optional", None)- input.setdefault(key, {})[i.id] = (i.get_io_type(), as_dict)+ if dynamic_dict is None:+ value = (i.get_io_type(), as_dict)+ else:+ value = (i.get_io_type(), as_dict, dynamic_dict)+ d.setdefault(key, {})[i.id] = valuedef add_to_dict_v3(io: Input | Output, d: dict):d[io.id] = (io.get_io_type(), io.as_dict())+def build_nested_inputs(values: dict[str, Any], v3_data: V3Data):+ paths = v3_data.get("dynamic_paths", None)+ if paths is None:+ return values+ values = values.copy()+ result = {}++ for key, path in paths.items():+ parts = path.split(".")+ current = result++ for i, p in enumerate(parts):+ is_last = (i == len(parts) - 1)++ if is_last:+ current[p] = values.pop(key, None)+ else:+ current = current.setdefault(p, {})++ values.update(result)+ return valuesclass _ComfyNodeBaseInternal(_ComfyNodeInternal):@@ -1311,12 +1547,12 @@ class _ComfyNodeBaseInternal(_ComfyNodeInternal):@final@classmethod- def PREPARE_CLASS_CLONE(cls, hidden_inputs: dict) -> type[ComfyNode]:+ def PREPARE_CLASS_CLONE(cls, v3_data: V3Data) -> type[ComfyNode]:"""Creates clone of real node class to prevent monkey-patching."""c_type: type[ComfyNode] = cls if is_class(cls) else type(cls)type_clone: type[ComfyNode] = shallow_clone_class(c_type)# set hidden- type_clone.hidden = HiddenHolder.from_dict(hidden_inputs)+ type_clone.hidden = HiddenHolder.from_dict(v3_data["hidden_inputs"])return type_clone@final@@ -1433,14 +1669,18 @@ class _ComfyNodeBaseInternal(_ComfyNodeInternal):@final@classmethod- def INPUT_TYPES(cls, include_hidden=True, return_schema=False) -> dict[str, dict] | tuple[dict[str, dict], Schema]:+ def INPUT_TYPES(cls, include_hidden=True, return_schema=False, live_inputs=None) -> dict[str, dict] | tuple[dict[str, dict], Schema, V3Data]:schema = cls.FINALIZE_SCHEMA()- info = schema.get_v1_info(cls)+ info = schema.get_v1_info(cls, live_inputs)input = info.inputif not include_hidden:input.pop("hidden", None)if return_schema:- return input, schema+ v3_data: V3Data = {}+ dynamic = input.pop("dynamic_paths", None)+ if dynamic is not None:+ v3_data["dynamic_paths"] = dynamic+ return input, schema, v3_datareturn input@final@@ -1513,7 +1753,7 @@ class ComfyNode(_ComfyNodeBaseInternal):raise NotImplementedError@classmethod- def validate_inputs(cls, **kwargs) -> bool:+ def validate_inputs(cls, **kwargs) -> bool | str:"""Optionally, define this function to validate inputs; equivalent to V1's VALIDATE_INPUTS."""raise NotImplementedError@@ -1628,6 +1868,7 @@ __all__ = ["StyleModel","Gligen","UpscaleModel",+ "LatentUpscaleModel","Audio","Video","SVG",@@ -1651,6 +1892,10 @@ __all__ = ["SEGS","AnyType","MultiType",+ # Dynamic Types+ "MatchType",+ # "DynamicCombo",+ # "Autogrow",# Other classes"HiddenHolder","Hidden",@@ -1661,4 +1906,5 @@ __all__ = ["NodeOutput","add_to_dict_v1","add_to_dict_v3",+ "V3Data",]diff --git a/comfy_api/latest/_io_public.py b/comfy_api/latest/_io_public.pynew file mode 100644index 000000000..43c7680f3--- /dev/null+++ b/comfy_api/latest/_io_public.py@@ -0,0 +1 @@+from ._io import * # noqa: F403diff --git a/comfy_api/latest/_ui_public.py b/comfy_api/latest/_ui_public.pynew file mode 100644index 000000000..85b11d78b--- /dev/null+++ b/comfy_api/latest/_ui_public.py@@ -0,0 +1 @@+from ._ui import * # noqa: F403diff --git a/comfy_api/v0_0_2/__init__.py b/comfy_api/v0_0_2/__init__.pyindex de0f95001..c4fa1d971 100644--- a/comfy_api/v0_0_2/__init__.py+++ b/comfy_api/v0_0_2/__init__.py@@ -6,7 +6,7 @@ from comfy_api.latest import ()from typing import Type, TYPE_CHECKINGfrom comfy_api.internal.async_to_sync import create_sync_class-from comfy_api.latest import io, ui, ComfyExtension #noqa: F401+from comfy_api.latest import io, ui, IO, UI, ComfyExtension #noqa: F401class ComfyAPIAdapter_v0_0_2(ComfyAPI_latest):@@ -42,4 +42,8 @@ __all__ = ["InputImpl","Types","ComfyExtension",+ "io",+ "IO",+ "ui",+ "UI",]diff --git a/comfy_execution/validation.py b/comfy_execution/validation.pyindex cec105fc9..24c0b4ed7 100644--- a/comfy_execution/validation.py+++ b/comfy_execution/validation.py@@ -1,4 +1,5 @@from __future__ import annotations+from comfy_api.latest import IOdef validate_node_input(@@ -23,6 +24,11 @@ def validate_node_input(if not received_type != input_type:return True+ # If the received type or input_type is a MatchType, we can return True immediately;+ # validation for this is handled by the frontend+ if received_type == IO.MatchType.io_type or input_type == IO.MatchType.io_type:+ return True+# Not equal, and not stringsif not isinstance(received_type, str) or not isinstance(input_type, str):return Falsediff --git a/comfy_extras/nodes_logic.py b/comfy_extras/nodes_logic.pynew file mode 100644index 000000000..95a6ba788--- /dev/null+++ b/comfy_extras/nodes_logic.py@@ -0,0 +1,155 @@+from typing import TypedDict+from typing_extensions import override+from comfy_api.latest import ComfyExtension, io+from comfy_api.latest import _io++++class SwitchNode(io.ComfyNode):+ @classmethod+ def define_schema(cls):+ template = io.MatchType.Template("switch")+ return io.Schema(+ node_id="ComfySwitchNode",+ display_name="Switch",+ category="logic",+ is_experimental=True,+ inputs=[+ io.Boolean.Input("switch"),+ io.MatchType.Input("on_false", template=template, lazy=True, optional=True),+ io.MatchType.Input("on_true", template=template, lazy=True, optional=True),+ ],+ outputs=[+ io.MatchType.Output(template=template, display_name="output"),+ ],+ )++ @classmethod+ def check_lazy_status(cls, switch, on_false=..., on_true=...):+ # We use ... instead of None, as None is passed for connected-but-unevaluated inputs.+ # This trick allows us to ignore the value of the switch and still be able to run execute().++ # One of the inputs may be missing, in which case we need to evaluate the other input+ if on_false is ...:+ return ["on_true"]+ if on_true is ...:+ return ["on_false"]+ # Normal lazy switch operation+ if switch and on_true is None:+ return ["on_true"]+ if not switch and on_false is None:+ return ["on_false"]++ @classmethod+ def validate_inputs(cls, switch, on_false=..., on_true=...):+ # This check happens before check_lazy_status(), so we can eliminate the case where+ # both inputs are missing.+ if on_false is ... and on_true is ...:+ return "At least one of on_false or on_true must be connected to Switch node"+ return True++ @classmethod+ def execute(cls, switch, on_true=..., on_false=...) -> io.NodeOutput:+ if on_true is ...:+ return io.NodeOutput(on_false)+ if on_false is ...:+ return io.NodeOutput(on_true)+ return io.NodeOutput(on_true if switch else on_false)+++class DCTestNode(io.ComfyNode):+ class DCValues(TypedDict):+ combo: str+ string: str+ integer: int+ image: io.Image.Type+ subcombo: dict[str]++ @classmethod+ def define_schema(cls):+ return io.Schema(+ node_id="DCTestNode",+ display_name="DCTest",+ category="logic",+ is_output_node=True,+ inputs=[_io.DynamicCombo.Input("combo", options=[+ _io.DynamicCombo.Option("option1", [io.String.Input("string")]),+ _io.DynamicCombo.Option("option2", [io.Int.Input("integer")]),+ _io.DynamicCombo.Option("option3", [io.Image.Input("image")]),+ _io.DynamicCombo.Option("option4", [+ _io.DynamicCombo.Input("subcombo", options=[+ _io.DynamicCombo.Option("opt1", [io.Float.Input("float_x"), io.Float.Input("float_y")]),+ _io.DynamicCombo.Option("opt2", [io.Mask.Input("mask1", optional=True)]),+ ])+ ])]+ )],+ outputs=[io.AnyType.Output()],+ )++ @classmethod+ def execute(cls, combo: DCValues) -> io.NodeOutput:+ combo_val = combo["combo"]+ if combo_val == "option1":+ return io.NodeOutput(combo["string"])+ elif combo_val == "option2":+ return io.NodeOutput(combo["integer"])+ elif combo_val == "option3":+ return io.NodeOutput(combo["image"])+ elif combo_val == "option4":+ return io.NodeOutput(f"{combo['subcombo']}")+ else:+ raise ValueError(f"Invalid combo: {combo_val}")+++class AutogrowNamesTestNode(io.ComfyNode):+ @classmethod+ def define_schema(cls):+ template = _io.Autogrow.TemplateNames(input=io.Float.Input("float"), names=["a", "b", "c"])+ return io.Schema(+ node_id="AutogrowNamesTestNode",+ display_name="AutogrowNamesTest",+ category="logic",+ inputs=[+ _io.Autogrow.Input("autogrow", template=template)+ ],+ outputs=[io.String.Output()],+ )++ @classmethod+ def execute(cls, autogrow: _io.Autogrow.Type) -> io.NodeOutput:+ vals = list(autogrow.values())+ combined = ",".join([str(x) for x in vals])+ return io.NodeOutput(combined)++class AutogrowPrefixTestNode(io.ComfyNode):+ @classmethod+ def define_schema(cls):+ template = _io.Autogrow.TemplatePrefix(input=io.Float.Input("float"), prefix="float", min=1, max=10)+ return io.Schema(+ node_id="AutogrowPrefixTestNode",+ display_name="AutogrowPrefixTest",+ category="logic",+ inputs=[+ _io.Autogrow.Input("autogrow", template=template)+ ],+ outputs=[io.String.Output()],+ )++ @classmethod+ def execute(cls, autogrow: _io.Autogrow.Type) -> io.NodeOutput:+ vals = list(autogrow.values())+ combined = ",".join([str(x) for x in vals])+ return io.NodeOutput(combined)++class LogicExtension(ComfyExtension):+ @override+ async def get_node_list(self) -> list[type[io.ComfyNode]]:+ return [+ # SwitchNode,+ # DCTestNode,+ # AutogrowNamesTestNode,+ # AutogrowPrefixTestNode,+ ]++async def comfy_entrypoint() -> LogicExtension:+ return LogicExtension()diff --git a/execution.py b/execution.pyindex 17c77beab..c2186ac98 100644--- a/execution.py+++ b/execution.py@@ -34,7 +34,7 @@ from comfy_execution.validation import validate_node_inputfrom comfy_execution.progress import get_progress_state, reset_progress_state, add_progress_handler, WebUIProgressHandlerfrom comfy_execution.utils import CurrentNodeContextfrom comfy_api.internal import _ComfyNodeInternal, _NodeOutputInternal, first_real_override, is_class, make_locked_method_func-from comfy_api.latest import io+from comfy_api.latest import io, _ioclass ExecutionResult(Enum):@@ -76,7 +76,7 @@ class IsChangedCache:return self.is_changed[node_id]# Intentionally do not use cached outputs here. We only want constants in IS_CHANGED- input_data_all, _, hidden_inputs = get_input_data(node["inputs"], class_def, node_id, None)+ input_data_all, _, v3_data = get_input_data(node["inputs"], class_def, node_id, None)try:is_changed = await _async_map_node_over_list(self.prompt_id, node_id, class_def, input_data_all, is_changed_name)is_changed = await resolve_map_node_over_list_results(is_changed)@@ -146,8 +146,9 @@ SENSITIVE_EXTRA_DATA_KEYS = ("auth_token_comfy_org", "api_key_comfy_org")def get_input_data(inputs, class_def, unique_id, execution_list=None, dynprompt=None, extra_data={}):is_v3 = issubclass(class_def, _ComfyNodeInternal)+ v3_data: io.V3Data = {}if is_v3:- valid_inputs, schema = class_def.INPUT_TYPES(include_hidden=False, return_schema=True)+ valid_inputs, schema, v3_data = class_def.INPUT_TYPES(include_hidden=False, return_schema=True, live_inputs=inputs)else:valid_inputs = class_def.INPUT_TYPES()input_data_all = {}@@ -207,7 +208,8 @@ def get_input_data(inputs, class_def, unique_id, execution_list=None, dynprompt=input_data_all[x] = [extra_data.get("auth_token_comfy_org", None)]if h[x] == "API_KEY_COMFY_ORG":input_data_all[x] = [extra_data.get("api_key_comfy_org", None)]- return input_data_all, missing_keys, hidden_inputs_v3+ v3_data["hidden_inputs"] = hidden_inputs_v3+ return input_data_all, missing_keys, v3_datamap_node_over_list = None #Don't hook this please@@ -223,7 +225,7 @@ async def resolve_map_node_over_list_results(results):raise excreturn [x.result() if isinstance(x, asyncio.Task) else x for x in results]-async def _async_map_node_over_list(prompt_id, unique_id, obj, input_data_all, func, allow_interrupt=False, execution_block_cb=None, pre_execute_cb=None, hidden_inputs=None):+async def _async_map_node_over_list(prompt_id, unique_id, obj, input_data_all, func, allow_interrupt=False, execution_block_cb=None, pre_execute_cb=None, v3_data=None):# check if node wants the listsinput_is_list = getattr(obj, "INPUT_IS_LIST", False)@@ -259,13 +261,16 @@ async def _async_map_node_over_list(prompt_id, unique_id, obj, input_data_all, fif is_class(obj):type_obj = objobj.VALIDATE_CLASS()- class_clone = obj.PREPARE_CLASS_CLONE(hidden_inputs)+ class_clone = obj.PREPARE_CLASS_CLONE(v3_data)# otherwise, use class instance to populate/reuse some fieldselse:type_obj = type(obj)type_obj.VALIDATE_CLASS()- class_clone = type_obj.PREPARE_CLASS_CLONE(hidden_inputs)+ class_clone = type_obj.PREPARE_CLASS_CLONE(v3_data)f = make_locked_method_func(type_obj, func, class_clone)+ # in case of dynamic inputs, restructure inputs to expected nested dict+ if v3_data is not None:+ inputs = _io.build_nested_inputs(inputs, v3_data)# V1else:f = getattr(obj, func)@@ -320,8 +325,8 @@ def merge_result_data(results, obj):output.append([o[i] for o in results])return output-async def get_output_data(prompt_id, unique_id, obj, input_data_all, execution_block_cb=None, pre_execute_cb=None, hidden_inputs=None):- return_values = await _async_map_node_over_list(prompt_id, unique_id, obj, input_data_all, obj.FUNCTION, allow_interrupt=True, execution_block_cb=execution_block_cb, pre_execute_cb=pre_execute_cb, hidden_inputs=hidden_inputs)+async def get_output_data(prompt_id, unique_id, obj, input_data_all, execution_block_cb=None, pre_execute_cb=None, v3_data=None):+ return_values = await _async_map_node_over_list(prompt_id, unique_id, obj, input_data_all, obj.FUNCTION, allow_interrupt=True, execution_block_cb=execution_block_cb, pre_execute_cb=pre_execute_cb, v3_data=v3_data)has_pending_task = any(isinstance(r, asyncio.Task) and not r.done() for r in return_values)if has_pending_task:return return_values, {}, False, has_pending_task@@ -460,7 +465,7 @@ async def execute(server, dynprompt, caches, current_item, extra_data, executed,has_subgraph = Falseelse:get_progress_state().start_progress(unique_id)- input_data_all, missing_keys, hidden_inputs = get_input_data(inputs, class_def, unique_id, execution_list, dynprompt, extra_data)+ input_data_all, missing_keys, v3_data = get_input_data(inputs, class_def, unique_id, execution_list, dynprompt, extra_data)if server.client_id is not None:server.last_node_id = display_node_idserver.send_sync("executing", { "node": unique_id, "display_node": display_node_id, "prompt_id": prompt_id }, server.client_id)@@ -475,7 +480,7 @@ async def execute(server, dynprompt, caches, current_item, extra_data, executed,else:lazy_status_present = getattr(obj, "check_lazy_status", None) is not Noneif lazy_status_present:- required_inputs = await _async_map_node_over_list(prompt_id, unique_id, obj, input_data_all, "check_lazy_status", allow_interrupt=True, hidden_inputs=hidden_inputs)+ required_inputs = await _async_map_node_over_list(prompt_id, unique_id, obj, input_data_all, "check_lazy_status", allow_interrupt=True, v3_data=v3_data)required_inputs = await resolve_map_node_over_list_results(required_inputs)required_inputs = set(sum([r for r in required_inputs if isinstance(r,list)], []))required_inputs = [x for x in required_inputs if isinstance(x,str) and (@@ -507,7 +512,7 @@ async def execute(server, dynprompt, caches, current_item, extra_data, executed,def pre_execute_cb(call_index):# TODO - How to handle this with async functions without contextvars (which requires Python 3.12)?GraphBuilder.set_default_prefix(unique_id, call_index, 0)- output_data, output_ui, has_subgraph, has_pending_tasks = await get_output_data(prompt_id, unique_id, obj, input_data_all, execution_block_cb=execution_block_cb, pre_execute_cb=pre_execute_cb, hidden_inputs=hidden_inputs)+ output_data, output_ui, has_subgraph, has_pending_tasks = await get_output_data(prompt_id, unique_id, obj, input_data_all, execution_block_cb=execution_block_cb, pre_execute_cb=pre_execute_cb, v3_data=v3_data)if has_pending_tasks:pending_async_nodes[unique_id] = output_dataunblock = execution_list.add_external_block(unique_id)@@ -745,18 +750,17 @@ async def validate_inputs(prompt_id, prompt, item, validated):class_type = prompt[unique_id]['class_type']obj_class = nodes.NODE_CLASS_MAPPINGS[class_type]- class_inputs = obj_class.INPUT_TYPES()- valid_inputs = set(class_inputs.get('required',{})).union(set(class_inputs.get('optional',{})))-errors = []valid = Truevalidate_function_inputs = []validate_has_kwargs = Falseif issubclass(obj_class, _ComfyNodeInternal):+ class_inputs, _, _ = obj_class.INPUT_TYPES(include_hidden=False, return_schema=True, live_inputs=inputs)validate_function_name = "validate_inputs"validate_function = first_real_override(obj_class, validate_function_name)else:+ class_inputs = obj_class.INPUT_TYPES()validate_function_name = "VALIDATE_INPUTS"validate_function = getattr(obj_class, validate_function_name, None)if validate_function is not None:@@ -765,6 +769,8 @@ async def validate_inputs(prompt_id, prompt, item, validated):validate_has_kwargs = argspec.varkw is not Nonereceived_types = {}+ valid_inputs = set(class_inputs.get('required',{})).union(set(class_inputs.get('optional',{})))+for x in valid_inputs:input_type, input_category, extra_info = get_input_info(obj_class, x, class_inputs)assert extra_info is not None@@ -935,7 +941,7 @@ async def validate_inputs(prompt_id, prompt, item, validated):continueif len(validate_function_inputs) > 0 or validate_has_kwargs:- input_data_all, _, hidden_inputs = get_input_data(inputs, obj_class, unique_id)+ input_data_all, _, v3_data = get_input_data(inputs, obj_class, unique_id)input_filtered = {}for x in input_data_all:if x in validate_function_inputs or validate_has_kwargs:@@ -943,7 +949,7 @@ async def validate_inputs(prompt_id, prompt, item, validated):if 'input_types' in validate_function_inputs:input_filtered['input_types'] = [received_types]- ret = await _async_map_node_over_list(prompt_id, unique_id, obj_class, input_filtered, validate_function_name, hidden_inputs=hidden_inputs)+ ret = await _async_map_node_over_list(prompt_id, unique_id, obj_class, input_filtered, validate_function_name, v3_data=v3_data)ret = await resolve_map_node_over_list_results(ret)for x in input_filtered:for i, r in enumerate(ret):diff --git a/nodes.py b/nodes.pyindex 4c910a34b..356aa63df 100644--- a/nodes.py+++ b/nodes.py@@ -2355,6 +2355,7 @@ async def init_builtin_extra_nodes():"nodes_easycache.py","nodes_audio_encoder.py","nodes_rope.py",+ "nodes_logic.py","nodes_nop.py",]