Remove unnecessary id usage in Autogrow test node outputs

comfy_api/latest/_io.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import copy
 import inspect
-import re
 from abc import ABC, abstractmethod
 from collections import Counter
 from collections.abc import Iterable
@@ -822,182 +821,6 @@ class MultiType:
             else:
                 return super().as_dict()
 
-class DynamicInput(Input, ABC):
-    '''
-    Abstract class for dynamic input registration.
-    '''
-    def get_dynamic(self) -> list[Input]:
-        return []
-
-    def add_to_dict_live_inputs(self, d: dict[str], live_inputs: dict[str], curr_prefix=''):
-        pass
-
-
-class DynamicOutput(Output, ABC):
-    '''
-    Abstract class for dynamic output registration.
-    '''
-    def __init__(self, id: str=None, display_name: str=None, tooltip: str=None,
-                 is_output_list=False):
-        super().__init__(id, display_name, tooltip, is_output_list)
-
-    def get_dynamic(self) -> list[Output]:
-        return []
-
-
-@comfytype(io_type="COMFY_AUTOGROW_V3")
-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 = input
-            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 add_to_dict_live_inputs(self, d: dict[str], live_inputs: dict[str], 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=None):
-            super().__init__(input)
-            self.prefix = prefix
-            assert(min >= 1)
-            if not max:
-                max = 10
-            assert(max >= 1)
-            assert(max <= Autogrow._MaxNames)
-            self.min = min
-            self.max = max
-            self.names = [f"{self.prefix}{i+1}" 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 >= 1)
-            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: 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)
-            # raise Exception("AutogrowDynamic is not implemented yet, and will likely be renamed for actual implementation.")
-            self.template = template
-
-        def as_dict(self):
-            return super().as_dict() | prune_dict({
-                "template": self.template.as_dict(),
-            })
-
-        def get_dynamic(self) -> list[Input]:
-            return self.template.get_all()
-
-        def get_all(self) -> list[Input]:
-            return [self] + self.template.get_all()
-
-        def validate(self):
-            self.template.validate()
-
-        def add_to_dict_live_inputs(self, d: dict[str], live_inputs: dict[str], curr_prefix=''):
-            curr_prefix = f"{curr_prefix}{self.id}."
-            self.template.add_to_dict_live_inputs(d, live_inputs, curr_prefix)
-
-@comfytype(io_type="COMFY_DYNAMICCOMBO_V3")
-class DynamicCombo(ComfyTypeI):
-    Type = dict[str]
-
-    class Option:
-        def __init__(self, key: str, inputs: list[Input]):
-            self.key = key
-            self.inputs = inputs
-
-        def as_dict(self):
-            return {
-                "key": self.key,
-                "inputs": create_input_dict_v1(self.inputs),
-            }
-
-    class Input(DynamicInput):
-        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.options = options
-
-        def add_to_dict_live_inputs(self, d: dict[str], live_inputs: dict[str], curr_prefix=''):
-            # check if dynamic input's id is in live_inputs
-            curr_prefix = f"{curr_prefix}{self.id}."
-            if self.id in live_inputs:
-                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 [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({
-                "options": [o.as_dict() for o in self.options],
-            })
-
-        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_MATCHTYPE_V3")
 class MatchType(ComfyTypeIO):
     class Template:
@@ -1043,6 +866,234 @@ class MatchType(ComfyTypeIO):
                 "template": self.template.as_dict(),
             })
 
+class DynamicInput(Input, ABC):
+    '''
+    Abstract class for dynamic input registration.
+    '''
+    def get_dynamic(self) -> list[Input]:
+        return []
+
+    def add_to_dict_live_inputs(self, d: dict[str], live_inputs: dict[str], curr_prefix=''):
+        pass
+
+
+class DynamicOutput(Output, ABC):
+    '''
+    Abstract class for dynamic output registration.
+    '''
+    def __init__(self, id: str=None, display_name: str=None, tooltip: str=None,
+                 is_output_list=False):
+        super().__init__(id, display_name, tooltip, is_output_list)
+
+    def get_dynamic(self) -> list[Output]:
+        return []
+
+
+@comfytype(io_type="COMFY_AUTOGROW_V3")
+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 add_to_dict_live_inputs(self, d: dict[str], live_inputs: dict[str], 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=None):
+            super().__init__(input)
+            self.prefix = prefix
+            assert(min >= 0)
+            if not max:
+                max = 10
+            assert(max >= 2)
+            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: 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)
+            # raise Exception("AutogrowDynamic is not implemented yet, and will likely be renamed for actual implementation.")
+            self.template = template
+
+        def as_dict(self):
+            return super().as_dict() | prune_dict({
+                "template": self.template.as_dict(),
+            })
+
+        def get_dynamic(self) -> list[Input]:
+            return self.template.get_all()
+
+        def get_all(self) -> list[Input]:
+            return [self] + self.template.get_all()
+
+        def validate(self):
+            self.template.validate()
+
+        def add_to_dict_live_inputs(self, d: dict[str], live_inputs: dict[str], 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.add_to_dict_live_inputs(d, live_inputs, curr_prefix)
+
+@comfytype(io_type="COMFY_DYNAMICCOMBO_V3")
+class DynamicCombo(ComfyTypeI):
+    Type = dict[str]
+
+    class Option:
+        def __init__(self, key: str, inputs: list[Input]):
+            self.key = key
+            self.inputs = inputs
+
+        def as_dict(self):
+            return {
+                "key": self.key,
+                "inputs": create_input_dict_v1(self.inputs),
+            }
+
+    class Input(DynamicInput):
+        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.options = options
+
+        def add_to_dict_live_inputs(self, d: dict[str], live_inputs: dict[str], 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 [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({
+                "options": [o.as_dict() for o in self.options],
+            })
+
+        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]
+
+    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 = self.extra_dict if 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 add_to_dict_live_inputs(self, d: dict[str], live_inputs: dict[str], 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_all(self) -> list[Input]:
+            return [self] + [self.slot] + self.inputs
+
+        def as_dict(self):
+            return super().as_dict() | prune_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], inputs: list[Input], curr_prefix: str, self: DynamicInput=None):
     dynamic = d.setdefault("dynamic_paths", {})
     if self is not None:
@@ -1705,7 +1756,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
 
@@ -1820,6 +1871,7 @@ __all__ = [
     "StyleModel",
     "Gligen",
     "UpscaleModel",
+    "LatentUpscaleModel",
     "Audio",
     "Video",
     "SVG",

comfy_extras/nodes_logic.py

@@ -15,8 +15,8 @@ class SwitchNode(io.ComfyNode):
             is_experimental=True,
             inputs=[
                 io.Boolean.Input("switch"),
-                io.MatchType.Input("on_false", template=template, lazy=True),
-                io.MatchType.Input("on_true", template=template, lazy=True),
+                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"),
@@ -24,14 +24,35 @@ class SwitchNode(io.ComfyNode):
         )
 
     @classmethod
-    def check_lazy_status(cls, switch, on_false=None, on_true=None):
+    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 execute(cls, switch, on_true, on_false) -> io.NodeOutput:
+    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)
 
 
@@ -82,7 +103,7 @@ class DCTestNode(io.ComfyNode):
 class AutogrowNamesTestNode(io.ComfyNode):
     @classmethod
     def define_schema(cls):
-        template = io.Autogrow.TemplateNames(input=io.String.Input("string"), names=["a", "b", "c"])
+        template = io.Autogrow.TemplateNames(input=io.Float.Input("float"), names=["a", "b", "c"])
         return io.Schema(
             node_id="AutogrowNamesTestNode",
             display_name="AutogrowNamesTest",
@@ -90,19 +111,19 @@ class AutogrowNamesTestNode(io.ComfyNode):
             inputs=[
                 io.Autogrow.Input("autogrow", template=template)
             ],
-            outputs=[io.String.Output("output")],
+            outputs=[io.String.Output()],
         )
 
     @classmethod
     def execute(cls, autogrow: io.Autogrow.Type) -> io.NodeOutput:
         vals = list(autogrow.values())
-        combined = "".join(vals)
+        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.String.Input("string"), prefix="string", min=1, max=10)
+        template = io.Autogrow.TemplatePrefix(input=io.Float.Input("float"), prefix="float", min=1, max=10)
         return io.Schema(
             node_id="AutogrowPrefixTestNode",
             display_name="AutogrowPrefixTest",
@@ -110,13 +131,13 @@ class AutogrowPrefixTestNode(io.ComfyNode):
             inputs=[
                 io.Autogrow.Input("autogrow", template=template)
             ],
-            outputs=[io.String.Output("output")],
+            outputs=[io.String.Output()],
         )
 
     @classmethod
     def execute(cls, autogrow: io.Autogrow.Type) -> io.NodeOutput:
         vals = list(autogrow.values())
-        combined = "".join(vals)
+        combined = ",".join([str(x) for x in vals])
         return io.NodeOutput(combined)
 
 class LogicExtension(ComfyExtension):