Skip to content

The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.

V3 Node Schema Definition - initial (#8656)

Jedrzej Kosinski4887743a2aef
diff --git a/comfy_api/internal/__init__.py b/comfy_api/internal/__init__.py
index c00b1fdbb..4ca02e320 100644
--- a/comfy_api/internal/__init__.py
+++ b/comfy_api/internal/__init__.py
@@ -5,3 +5,146 @@ from .api_registry import (
register_versions as register_versions,
get_all_versions as get_all_versions,
)
+
+import asyncio
+from dataclasses import asdict
+from typing import Callable, Optional
+
+
+def first_real_override(cls: type, name: str, *, base: type=None) -> Optional[Callable]:
+ """Return the *callable* override of `name` visible on `cls`, or None if every
+ implementation up to (and including) `base` is the placeholder defined on `base`.
+
+ If base is not provided, it will assume cls has a GET_BASE_CLASS
+ """
+ if base is None:
+ if not hasattr(cls, "GET_BASE_CLASS"):
+ raise ValueError("base is required if cls does not have a GET_BASE_CLASS; is this a valid ComfyNode subclass?")
+ base = cls.GET_BASE_CLASS()
+ base_attr = getattr(base, name, None)
+ if base_attr is None:
+ return None
+ base_func = base_attr.__func__
+ for c in cls.mro(): # NodeB, NodeA, ComfyNode, object …
+ if c is base: # reached the placeholder – we're done
+ break
+ if name in c.__dict__: # first class that *defines* the attr
+ func = getattr(c, name).__func__
+ if func is not base_func: # real override
+ return getattr(cls, name) # bound to *cls*
+ return None
+
+
+class _ComfyNodeInternal:
+ """Class that all V3-based APIs inherit from for ComfyNode.
+
+ This is intended to only be referenced within execution.py, as it has to handle all V3 APIs going forward."""
+ @classmethod
+ def GET_NODE_INFO_V1(cls):
+ ...
+
+
+class _NodeOutputInternal:
+ """Class that all V3-based APIs inherit from for NodeOutput.
+
+ This is intended to only be referenced within execution.py, as it has to handle all V3 APIs going forward."""
+ ...
+
+
+def as_pruned_dict(dataclass_obj):
+ '''Return dict of dataclass object with pruned None values.'''
+ return prune_dict(asdict(dataclass_obj))
+
+def prune_dict(d: dict):
+ return {k: v for k,v in d.items() if v is not None}
+
+
+def is_class(obj):
+ '''
+ Returns True if is a class type.
+ Returns False if is a class instance.
+ '''
+ return isinstance(obj, type)
+
+
+def copy_class(cls: type) -> type:
+ '''
+ Copy a class and its attributes.
+ '''
+ if cls is None:
+ return None
+ cls_dict = {
+ k: v for k, v in cls.__dict__.items()
+ if k not in ('__dict__', '__weakref__', '__module__', '__doc__')
+ }
+ # new class
+ new_cls = type(
+ cls.__name__,
+ (cls,),
+ cls_dict
+ )
+ # metadata preservation
+ new_cls.__module__ = cls.__module__
+ new_cls.__doc__ = cls.__doc__
+ return new_cls
+
+
+class classproperty(object):
+ def __init__(self, f):
+ self.f = f
+ def __get__(self, obj, owner):
+ return self.f(owner)
+
+
+# NOTE: this was ai generated and validated by hand
+def shallow_clone_class(cls, new_name=None):
+ '''
+ Shallow clone a class while preserving super() functionality.
+ '''
+ new_name = new_name or f"{cls.__name__}Clone"
+ # Include the original class in the bases to maintain proper inheritance
+ new_bases = (cls,) + cls.__bases__
+ return type(new_name, new_bases, dict(cls.__dict__))
+
+# NOTE: this was ai generated and validated by hand
+def lock_class(cls):
+ '''
+ Lock a class so that its top-levelattributes cannot be modified.
+ '''
+ # Locked instance __setattr__
+ def locked_instance_setattr(self, name, value):
+ raise AttributeError(
+ f"Cannot set attribute '{name}' on immutable instance of {type(self).__name__}"
+ )
+ # Locked metaclass
+ class LockedMeta(type(cls)):
+ def __setattr__(cls_, name, value):
+ raise AttributeError(
+ f"Cannot modify class attribute '{name}' on locked class '{cls_.__name__}'"
+ )
+ # Rebuild class with locked behavior
+ locked_dict = dict(cls.__dict__)
+ locked_dict['__setattr__'] = locked_instance_setattr
+
+ return LockedMeta(cls.__name__, cls.__bases__, locked_dict)
+
+
+def make_locked_method_func(type_obj, func, class_clone):
+ """
+ Returns a function that, when called with **inputs, will execute:
+ getattr(type_obj, func).__func__(lock_class(class_clone), **inputs)
+
+ Supports both synchronous and asynchronous methods.
+ """
+ locked_class = lock_class(class_clone)
+ method = getattr(type_obj, func).__func__
+
+ # Check if the original method is async
+ if asyncio.iscoroutinefunction(method):
+ async def wrapped_async_func(**inputs):
+ return await method(locked_class, **inputs)
+ return wrapped_async_func
+ else:
+ def wrapped_func(**inputs):
+ return method(locked_class, **inputs)
+ return wrapped_func
diff --git a/comfy_api/latest/__init__.py b/comfy_api/latest/__init__.py
index e1f3a3655..2cee65aa9 100644
--- a/comfy_api/latest/__init__.py
+++ b/comfy_api/latest/__init__.py
@@ -1,5 +1,6 @@
from __future__ import annotations
+from abc import ABC, abstractmethod
from typing import Type, TYPE_CHECKING
from comfy_api.internal import ComfyAPIBase
from comfy_api.internal.singleton import ProxiedSingleton
@@ -7,6 +8,9 @@ from comfy_api.internal.async_to_sync import create_sync_class
from comfy_api.latest._input import ImageInput, AudioInput, MaskInput, LatentInput, VideoInput
from comfy_api.latest._input_impl import VideoFromFile, VideoFromComponents
from comfy_api.latest._util import VideoCodec, VideoContainer, VideoComponents
+from comfy_api.latest._io import _IO as io #noqa: F401
+from comfy_api.latest._ui import _UI as ui #noqa: F401
+# from comfy_api.latest._resources import _RESOURCES as resources #noqa: F401
from comfy_execution.utils import get_executing_context
from comfy_execution.progress import get_progress_state, PreviewImageTuple
from PIL import Image
@@ -72,6 +76,19 @@ class ComfyAPI_latest(ComfyAPIBase):
execution: Execution
+class ComfyExtension(ABC):
+ async def on_load(self) -> None:
+ """
+ Called when an extension is loaded.
+ This should be used to initialize any global resources neeeded by the extension.
+ """
+
+ @abstractmethod
+ async def get_node_list(self) -> list[type[io.ComfyNode]]:
+ """
+ Returns a list of nodes that this extension provides.
+ """
+
class Input:
Image = ImageInput
Audio = AudioInput
@@ -103,4 +120,5 @@ __all__ = [
"Input",
"InputImpl",
"Types",
+ "ComfyExtension",
]
diff --git a/comfy_api/latest/_io.py b/comfy_api/latest/_io.py
new file mode 100644
index 000000000..ec1efb51d
--- /dev/null
+++ b/comfy_api/latest/_io.py
@@ -0,0 +1,1618 @@
+from __future__ import annotations
+
+import copy
+import inspect
+from abc import ABC, abstractmethod
+from collections import Counter
+from dataclasses import asdict, dataclass
+from enum import Enum
+from typing import Any, Callable, Literal, TypedDict, TypeVar, TYPE_CHECKING
+from typing_extensions import NotRequired, final
+
+# used for type hinting
+import torch
+
+if TYPE_CHECKING:
+ from spandrel import ImageModelDescriptor
+ from comfy.clip_vision import ClipVisionModel
+ from comfy.clip_vision import Output as ClipVisionOutput_
+ from comfy.controlnet import ControlNet
+ from comfy.hooks import HookGroup, HookKeyframeGroup
+ from comfy.model_patcher import ModelPatcher
+ from comfy.samplers import CFGGuider, Sampler
+ from comfy.sd import CLIP, VAE
+ from comfy.sd import StyleModel as StyleModel_
+ from comfy_api.input import VideoInput
+from comfy_api.internal import (_ComfyNodeInternal, _NodeOutputInternal, classproperty, copy_class, first_real_override, is_class,
+ prune_dict, shallow_clone_class)
+from comfy_api.latest._resources import Resources, ResourcesLocal
+from comfy_execution.graph_utils import ExecutionBlocker
+
+# from comfy_extras.nodes_images import SVG as SVG_ # NOTE: needs to be moved before can be imported due to circular reference
+
+class FolderType(str, Enum):
+ input = "input"
+ output = "output"
+ temp = "temp"
+
+
+class UploadType(str, Enum):
+ image = "image_upload"
+ audio = "audio_upload"
+ video = "video_upload"
+ model = "file_upload"
+
+
+class RemoteOptions:
+ def __init__(self, route: str, refresh_button: bool, control_after_refresh: Literal["first", "last"]="first",
+ timeout: int=None, max_retries: int=None, refresh: int=None):
+ self.route = route
+ """The route to the remote source."""
+ self.refresh_button = refresh_button
+ """Specifies whether to show a refresh button in the UI below the widget."""
+ self.control_after_refresh = control_after_refresh
+ """Specifies the control after the refresh button is clicked. If "first", the first item will be automatically selected, and so on."""
+ self.timeout = timeout
+ """The maximum amount of time to wait for a response from the remote source in milliseconds."""
+ self.max_retries = max_retries
+ """The maximum number of retries before aborting the request."""
+ self.refresh = refresh
+ """The TTL of the remote input's value in milliseconds. Specifies the interval at which the remote input's value is refreshed."""
+
+ def as_dict(self):
+ return prune_dict({
+ "route": self.route,
+ "refresh_button": self.refresh_button,
+ "control_after_refresh": self.control_after_refresh,
+ "timeout": self.timeout,
+ "max_retries": self.max_retries,
+ "refresh": self.refresh,
+ })
+
+
+class NumberDisplay(str, Enum):
+ number = "number"
+ slider = "slider"
+
+
+class _StringIOType(str):
+ def __ne__(self, value: object) -> bool:
+ if self == "*" or value == "*":
+ return False
+ if not isinstance(value, str):
+ return True
+ a = frozenset(self.split(","))
+ b = frozenset(value.split(","))
+ return not (b.issubset(a) or a.issubset(b))
+
+class _ComfyType(ABC):
+ Type = Any
+ io_type: str = None
+
+# NOTE: this is a workaround to make the decorator return the correct type
+T = TypeVar("T", bound=type)
+def comfytype(io_type: str, **kwargs):
+ '''
+ Decorator to mark nested classes as ComfyType; io_type will be bound to the class.
+
+ A ComfyType may have the following attributes:
+ - Type = <type hint here>
+ - class Input(Input): ...
+ - class Output(Output): ...
+ '''
+ def decorator(cls: T) -> T:
+ if isinstance(cls, _ComfyType) or issubclass(cls, _ComfyType):
+ # clone Input and Output classes to avoid modifying the original class
+ new_cls = cls
+ if hasattr(new_cls, "Input"):
+ new_cls.Input = copy_class(new_cls.Input)
+ if hasattr(new_cls, "Output"):
+ new_cls.Output = copy_class(new_cls.Output)
+ else:
+ # copy class attributes except for special ones that shouldn't be in type()
+ cls_dict = {
+ k: v for k, v in cls.__dict__.items()
+ if k not in ('__dict__', '__weakref__', '__module__', '__doc__')
+ }
+ # new class
+ new_cls: ComfyTypeIO = type(
+ cls.__name__,
+ (cls, ComfyTypeIO),
+ cls_dict
+ )
+ # metadata preservation
+ new_cls.__module__ = cls.__module__
+ new_cls.__doc__ = cls.__doc__
+ # assign ComfyType attributes, if needed
+ # NOTE: use __ne__ trick for io_type (see node_typing.IO.__ne__ for details)
+ new_cls.io_type = _StringIOType(io_type)
+ if hasattr(new_cls, "Input") and new_cls.Input is not None:
+ new_cls.Input.Parent = new_cls
+ if hasattr(new_cls, "Output") and new_cls.Output is not None:
+ new_cls.Output.Parent = new_cls
+ return new_cls
+ return decorator
+
+def Custom(io_type: str) -> type[ComfyTypeIO]:
+ '''Create a ComfyType for a custom io_type.'''
+ @comfytype(io_type=io_type)
+ class CustomComfyType(ComfyTypeIO):
+ ...
+ return CustomComfyType
+
+class _IO_V3:
+ '''
+ Base class for V3 Inputs and Outputs.
+ '''
+ Parent: _ComfyType = None
+
+ def __init__(self):
+ pass
+
+ @property
+ def io_type(self):
+ return self.Parent.io_type
+
+ @property
+ def Type(self):
+ return self.Parent.Type
+
+class Input(_IO_V3):
+ '''
+ Base class for a V3 Input.
+ '''
+ def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None, extra_dict=None):
+ super().__init__()
+ self.id = id
+ self.display_name = display_name
+ self.optional = optional
+ self.tooltip = tooltip
+ self.lazy = lazy
+ self.extra_dict = extra_dict if extra_dict is not None else {}
+
+ def as_dict(self):
+ return prune_dict({
+ "display_name": self.display_name,
+ "optional": self.optional,
+ "tooltip": self.tooltip,
+ "lazy": self.lazy,
+ }) | prune_dict(self.extra_dict)
+
+ def get_io_type(self):
+ return _StringIOType(self.io_type)
+
+class WidgetInput(Input):
+ '''
+ Base class for a V3 Input with widget.
+ '''
+ def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None,
+ default: Any=None,
+ socketless: bool=None, widget_type: str=None, force_input: bool=None, extra_dict=None):
+ super().__init__(id, display_name, optional, tooltip, lazy, extra_dict)
+ self.default = default
+ self.socketless = socketless
+ self.widget_type = widget_type
+ self.force_input = force_input
+
+ def as_dict(self):
+ return super().as_dict() | prune_dict({
+ "default": self.default,
+ "socketless": self.socketless,
+ "widgetType": self.widget_type,
+ "forceInput": self.force_input,
+ })
+
+ def get_io_type(self):
+ return self.widget_type if self.widget_type is not None else super().get_io_type()
+
+
+class Output(_IO_V3):
+ def __init__(self, id: str=None, display_name: str=None, tooltip: str=None,
+ is_output_list=False):
+ self.id = id
+ self.display_name = display_name
+ self.tooltip = tooltip
+ self.is_output_list = is_output_list
+
+ def as_dict(self):
+ return prune_dict({
+ "display_name": self.display_name,
+ "tooltip": self.tooltip,
+ "is_output_list": self.is_output_list,
+ })
+
+ def get_io_type(self):
+ return self.io_type
+
+
+class ComfyTypeI(_ComfyType):
+ '''ComfyType subclass that only has a default Input class - intended for types that only have Inputs.'''
+ class Input(Input):
+ ...
+
+class ComfyTypeIO(ComfyTypeI):
+ '''ComfyType subclass that has default Input and Output classes; useful for types with both Inputs and Outputs.'''
+ class Output(Output):
+ ...
+
+
+@comfytype(io_type="BOOLEAN")
+class Boolean(ComfyTypeIO):
+ Type = bool
+
+ class Input(WidgetInput):
+ '''Boolean input.'''
+ def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None,
+ default: bool=None, label_on: str=None, label_off: str=None,
+ socketless: bool=None, force_input: bool=None):
+ super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, force_input)
+ self.label_on = label_on
+ self.label_off = label_off
+ self.default: bool
+
+ def as_dict(self):
+ return super().as_dict() | prune_dict({
+ "label_on": self.label_on,
+ "label_off": self.label_off,
+ })
+
+@comfytype(io_type="INT")
+class Int(ComfyTypeIO):
+ Type = int
+
+ class Input(WidgetInput):
+ '''Integer input.'''
+ def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None,
+ default: int=None, min: int=None, max: int=None, step: int=None, control_after_generate: bool=None,
+ display_mode: NumberDisplay=None, socketless: bool=None, force_input: bool=None):
+ super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, force_input)
+ self.min = min
+ self.max = max
+ self.step = step
+ self.control_after_generate = control_after_generate
+ self.display_mode = display_mode
+ self.default: int
+
+ def as_dict(self):
+ return super().as_dict() | prune_dict({
+ "min": self.min,
+ "max": self.max,
+ "step": self.step,
+ "control_after_generate": self.control_after_generate,
+ "display": self.display_mode.value if self.display_mode else None,
+ })
+
+@comfytype(io_type="FLOAT")
+class Float(ComfyTypeIO):
+ Type = float
+
+ class Input(WidgetInput):
+ '''Float input.'''
+ def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None,
+ default: float=None, min: float=None, max: float=None, step: float=None, round: float=None,
+ display_mode: NumberDisplay=None, socketless: bool=None, force_input: bool=None):
+ super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, force_input)
+ self.min = min
+ self.max = max
+ self.step = step
+ self.round = round
+ self.display_mode = display_mode
+ self.default: float
+
+ def as_dict(self):
+ return super().as_dict() | prune_dict({
+ "min": self.min,
+ "max": self.max,
+ "step": self.step,
+ "round": self.round,
+ "display": self.display_mode,
+ })
+
+@comfytype(io_type="STRING")
+class String(ComfyTypeIO):
+ Type = str
+
+ class Input(WidgetInput):
+ '''String input.'''
+ def __init__(self, id: str, display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None,
+ multiline=False, placeholder: str=None, default: str=None, dynamic_prompts: bool=None,
+ socketless: bool=None, force_input: bool=None):
+ super().__init__(id, display_name, optional, tooltip, lazy, default, socketless, None, force_input)
+ self.multiline = multiline
+ self.placeholder = placeholder
+ self.dynamic_prompts = dynamic_prompts
+ self.default: str
+
+ def as_dict(self):
+ return super().as_dict() | prune_dict({
+ "multiline": self.multiline,
+ "placeholder": self.placeholder,
+ "dynamicPrompts": self.dynamic_prompts,
+ })
+
+@comfytype(io_type="COMBO")
+class Combo(ComfyTypeI):
+ Type = str
+ class Input(WidgetInput):
+ """Combo input (dropdown)."""
+ Type = str
+ def __init__(self, id: str, options: list[str]=None, display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None,
+ default: str=None, control_after_generate: bool=None,
+ upload: UploadType=None, image_folder: FolderType=None,
+ remote: RemoteOptions=None,
+ socketless: bool=None):
+ super().__init__(id, display_name, optional, tooltip, lazy, default, socketless)
+ self.multiselect = False
+ self.options = options
+ self.control_after_generate = control_after_generate
+ self.upload = upload
+ self.image_folder = image_folder
+ self.remote = remote
+ self.default: str
+
+ def as_dict(self):
+ return super().as_dict() | prune_dict({
+ "multiselect": self.multiselect,
+ "options": self.options,
+ "control_after_generate": self.control_after_generate,
+ **({self.upload.value: True} if self.upload is not None else {}),
+ "image_folder": self.image_folder.value if self.image_folder else None,
+ "remote": self.remote.as_dict() if self.remote else None,
+ })
+
+
+@comfytype(io_type="COMBO")
+class MultiCombo(ComfyTypeI):
+ '''Multiselect Combo input (dropdown for selecting potentially more than one value).'''
+ # TODO: something is wrong with the serialization, frontend does not recognize it as multiselect
+ Type = list[str]
+ class Input(Combo.Input):
+ def __init__(self, id: str, options: list[str], display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None,
+ default: list[str]=None, placeholder: str=None, chip: bool=None, control_after_generate: bool=None,
+ socketless: bool=None):
+ super().__init__(id, options, display_name, optional, tooltip, lazy, default, control_after_generate, socketless=socketless)
+ self.multiselect = True
+ self.placeholder = placeholder
+ self.chip = chip
+ self.default: list[str]
+
+ def as_dict(self):
+ to_return = super().as_dict() | prune_dict({
+ "multi_select": self.multiselect,
+ "placeholder": self.placeholder,
+ "chip": self.chip,
+ })
+ return to_return
+
+@comfytype(io_type="IMAGE")
+class Image(ComfyTypeIO):
+ Type = torch.Tensor
+
+
+@comfytype(io_type="WAN_CAMERA_EMBEDDING")
+class WanCameraEmbedding(ComfyTypeIO):
+ Type = torch.Tensor
+
+
+@comfytype(io_type="WEBCAM")
+class Webcam(ComfyTypeIO):
+ Type = str
+
+ class Input(WidgetInput):
+ """Webcam input."""
+ Type = str
+ def __init__(
+ self, id: str, display_name: str=None, optional=False,
+ tooltip: str=None, lazy: bool=None, default: str=None, socketless: bool=None
+ ):
+ super().__init__(id, display_name, optional, tooltip, lazy, default, socketless)
+
+
+@comfytype(io_type="MASK")
+class Mask(ComfyTypeIO):
+ Type = torch.Tensor
+
+@comfytype(io_type="LATENT")
+class Latent(ComfyTypeIO):
+ '''Latents are stored as a dictionary.'''
+ class LatentDict(TypedDict):
+ samples: torch.Tensor
+ '''Latent tensors.'''
+ noise_mask: NotRequired[torch.Tensor]
+ batch_index: NotRequired[list[int]]
+ type: NotRequired[str]
+ '''Only needed if dealing with these types: audio, hunyuan3dv2'''
+ Type = LatentDict
+
+@comfytype(io_type="CONDITIONING")
+class Conditioning(ComfyTypeIO):
+ class PooledDict(TypedDict):
+ pooled_output: torch.Tensor
+ '''Pooled output from CLIP.'''
+ control: NotRequired[ControlNet]
+ '''ControlNet to apply to conditioning.'''
+ control_apply_to_uncond: NotRequired[bool]
+ '''Whether to apply ControlNet to matching negative conditioning at sample time, if applicable.'''
+ cross_attn_controlnet: NotRequired[torch.Tensor]
+ '''CrossAttn from CLIP to use for controlnet only.'''
+ pooled_output_controlnet: NotRequired[torch.Tensor]
+ '''Pooled output from CLIP to use for controlnet only.'''
+ gligen: NotRequired[tuple[str, Gligen, list[tuple[torch.Tensor, int, ...]]]]
+ '''GLIGEN to apply to conditioning.'''
+ area: NotRequired[tuple[int, ...] | tuple[str, float, ...]]
+ '''Set area of conditioning. First half of values apply to dimensions, the second half apply to coordinates.
+ By default, the dimensions are based on total pixel amount, but the first value can be set to "percentage" to use a percentage of the image size instead.
+
+ (1024, 1024, 0, 0) would apply conditioning to the top-left 1024x1024 pixels.
+
+ ("percentage", 0.5, 0.5, 0, 0) would apply conditioning to the top-left 50% of the image.''' # TODO: verify its actually top-left
+ strength: NotRequired[float]
+ '''Strength of conditioning. Default strength is 1.0.'''
+ mask: NotRequired[torch.Tensor]
+ '''Mask to apply conditioning to.'''
+ mask_strength: NotRequired[float]
+ '''Strength of conditioning mask. Default strength is 1.0.'''
+ set_area_to_bounds: NotRequired[bool]
+ '''Whether conditioning mask should determine bounds of area - if set to false, latents are sampled at full resolution and result is applied in mask.'''
+ concat_latent_image: NotRequired[torch.Tensor]
+ '''Used for inpainting and specific models.'''
+ concat_mask: NotRequired[torch.Tensor]
+ '''Used for inpainting and specific models.'''
+ concat_image: NotRequired[torch.Tensor]
+ '''Used by SD_4XUpscale_Conditioning.'''
+ noise_augmentation: NotRequired[float]
+ '''Used by SD_4XUpscale_Conditioning.'''
+ hooks: NotRequired[HookGroup]
+ '''Applies hooks to conditioning.'''
+ default: NotRequired[bool]
+ '''Whether to this conditioning is 'default'; default conditioning gets applied to any areas of the image that have no masks/areas applied, assuming at least one area/mask is present during sampling.'''
+ start_percent: NotRequired[float]
+ '''Determines relative step to begin applying conditioning, expressed as a float between 0.0 and 1.0.'''
+ end_percent: NotRequired[float]
+ '''Determines relative step to end applying conditioning, expressed as a float between 0.0 and 1.0.'''
+ clip_start_percent: NotRequired[float]
+ '''Internal variable for conditioning scheduling - start of application, expressed as a float between 0.0 and 1.0.'''
+ clip_end_percent: NotRequired[float]
+ '''Internal variable for conditioning scheduling - end of application, expressed as a float between 0.0 and 1.0.'''
+ attention_mask: NotRequired[torch.Tensor]
+ '''Masks text conditioning; used by StyleModel among others.'''
+ attention_mask_img_shape: NotRequired[tuple[int, ...]]
+ '''Masks text conditioning; used by StyleModel among others.'''
+ unclip_conditioning: NotRequired[list[dict]]
+ '''Used by unCLIP.'''
+ conditioning_lyrics: NotRequired[torch.Tensor]
+ '''Used by AceT5Model.'''
+ seconds_start: NotRequired[float]
+ '''Used by StableAudio.'''
+ seconds_total: NotRequired[float]
+ '''Used by StableAudio.'''
+ lyrics_strength: NotRequired[float]
+ '''Used by AceStepAudio.'''
+ width: NotRequired[int]
+ '''Used by certain models (e.g. CLIPTextEncodeSDXL/Refiner, PixArtAlpha).'''
+ height: NotRequired[int]
+ '''Used by certain models (e.g. CLIPTextEncodeSDXL/Refiner, PixArtAlpha).'''
+ aesthetic_score: NotRequired[float]
+ '''Used by CLIPTextEncodeSDXL/Refiner.'''
+ crop_w: NotRequired[int]
+ '''Used by CLIPTextEncodeSDXL.'''
+ crop_h: NotRequired[int]
+ '''Used by CLIPTextEncodeSDXL.'''
+ target_width: NotRequired[int]
+ '''Used by CLIPTextEncodeSDXL.'''
+ target_height: NotRequired[int]
+ '''Used by CLIPTextEncodeSDXL.'''
+ reference_latents: NotRequired[list[torch.Tensor]]
+ '''Used by ReferenceLatent.'''
+ guidance: NotRequired[float]
+ '''Used by Flux-like models with guidance embed.'''
+ guiding_frame_index: NotRequired[int]
+ '''Used by Hunyuan ImageToVideo.'''
+ ref_latent: NotRequired[torch.Tensor]
+ '''Used by Hunyuan ImageToVideo.'''
+ keyframe_idxs: NotRequired[list[int]]
+ '''Used by LTXV.'''
+ frame_rate: NotRequired[float]
+ '''Used by LTXV.'''
+ stable_cascade_prior: NotRequired[torch.Tensor]
+ '''Used by StableCascade.'''
+ elevation: NotRequired[list[float]]
+ '''Used by SV3D.'''
+ azimuth: NotRequired[list[float]]
+ '''Used by SV3D.'''
+ motion_bucket_id: NotRequired[int]
+ '''Used by SVD-like models.'''
+ fps: NotRequired[int]
+ '''Used by SVD-like models.'''
+ augmentation_level: NotRequired[float]
+ '''Used by SVD-like models.'''
+ clip_vision_output: NotRequired[ClipVisionOutput_]
+ '''Used by WAN-like models.'''
+ vace_frames: NotRequired[torch.Tensor]
+ '''Used by WAN VACE.'''
+ vace_mask: NotRequired[torch.Tensor]
+ '''Used by WAN VACE.'''
+ vace_strength: NotRequired[float]
+ '''Used by WAN VACE.'''
+ camera_conditions: NotRequired[Any] # TODO: assign proper type once defined
+ '''Used by WAN Camera.'''
+ time_dim_concat: NotRequired[torch.Tensor]
+ '''Used by WAN Phantom Subject.'''
+
+ CondList = list[tuple[torch.Tensor, PooledDict]]
+ Type = CondList
+
+@comfytype(io_type="SAMPLER")
+class Sampler(ComfyTypeIO):
+ if TYPE_CHECKING:
+ Type = Sampler
+
+@comfytype(io_type="SIGMAS")
+class Sigmas(ComfyTypeIO):
+ Type = torch.Tensor
+
+@comfytype(io_type="NOISE")
+class Noise(ComfyTypeIO):
+ Type = torch.Tensor
+
+@comfytype(io_type="GUIDER")
+class Guider(ComfyTypeIO):
+ if TYPE_CHECKING:
+ Type = CFGGuider
+
+@comfytype(io_type="CLIP")
+class Clip(ComfyTypeIO):
+ if TYPE_CHECKING:
+ Type = CLIP
+
+@comfytype(io_type="CONTROL_NET")
+class ControlNet(ComfyTypeIO):
+ if TYPE_CHECKING:
+ Type = ControlNet
+
+@comfytype(io_type="VAE")
+class Vae(ComfyTypeIO):
+ if TYPE_CHECKING:
+ Type = VAE
+
+@comfytype(io_type="MODEL")
+class Model(ComfyTypeIO):
+ if TYPE_CHECKING:
+ Type = ModelPatcher
+
+@comfytype(io_type="CLIP_VISION")
+class ClipVision(ComfyTypeIO):
+ if TYPE_CHECKING:
+ Type = ClipVisionModel
+
+@comfytype(io_type="CLIP_VISION_OUTPUT")
+class ClipVisionOutput(ComfyTypeIO):
+ if TYPE_CHECKING:
+ Type = ClipVisionOutput_
+
+@comfytype(io_type="STYLE_MODEL")
+class StyleModel(ComfyTypeIO):
+ if TYPE_CHECKING:
+ Type = StyleModel_
+
+@comfytype(io_type="GLIGEN")
+class Gligen(ComfyTypeIO):
+ '''ModelPatcher that wraps around a 'Gligen' model.'''
+ if TYPE_CHECKING:
+ Type = ModelPatcher
+
+@comfytype(io_type="UPSCALE_MODEL")
+class UpscaleModel(ComfyTypeIO):
+ if TYPE_CHECKING:
+ Type = ImageModelDescriptor
+
+@comfytype(io_type="AUDIO")
+class Audio(ComfyTypeIO):
+ class AudioDict(TypedDict):
+ waveform: torch.Tensor
+ sampler_rate: int
+ Type = AudioDict
+
+@comfytype(io_type="VIDEO")
+class Video(ComfyTypeIO):
+ if TYPE_CHECKING:
+ Type = VideoInput
+
+@comfytype(io_type="SVG")
+class SVG(ComfyTypeIO):
+ Type = Any # TODO: SVG class is defined in comfy_extras/nodes_images.py, causing circular reference; should be moved to somewhere else before referenced directly in v3
+
+@comfytype(io_type="LORA_MODEL")
+class LoraModel(ComfyTypeIO):
+ Type = dict[str, torch.Tensor]
+
+@comfytype(io_type="LOSS_MAP")
+class LossMap(ComfyTypeIO):
+ class LossMapDict(TypedDict):
+ loss: list[torch.Tensor]
+ Type = LossMapDict
+
+@comfytype(io_type="VOXEL")
+class Voxel(ComfyTypeIO):
+ Type = Any # TODO: VOXEL class is defined in comfy_extras/nodes_hunyuan3d.py; should be moved to somewhere else before referenced directly in v3
+
+@comfytype(io_type="MESH")
+class Mesh(ComfyTypeIO):
+ Type = Any # TODO: MESH class is defined in comfy_extras/nodes_hunyuan3d.py; should be moved to somewhere else before referenced directly in v3
+
+@comfytype(io_type="HOOKS")
+class Hooks(ComfyTypeIO):
+ if TYPE_CHECKING:
+ Type = HookGroup
+
+@comfytype(io_type="HOOK_KEYFRAMES")
+class HookKeyframes(ComfyTypeIO):
+ if TYPE_CHECKING:
+ Type = HookKeyframeGroup
+
+@comfytype(io_type="TIMESTEPS_RANGE")
+class TimestepsRange(ComfyTypeIO):
+ '''Range defined by start and endpoint, between 0.0 and 1.0.'''
+ Type = tuple[int, int]
+
+@comfytype(io_type="LATENT_OPERATION")
+class LatentOperation(ComfyTypeIO):
+ Type = Callable[[torch.Tensor], torch.Tensor]
+
+@comfytype(io_type="FLOW_CONTROL")
+class FlowControl(ComfyTypeIO):
+ # NOTE: only used in testing_nodes right now
+ Type = tuple[str, Any]
+
+@comfytype(io_type="ACCUMULATION")
+class Accumulation(ComfyTypeIO):
+ # NOTE: only used in testing_nodes right now
+ class AccumulationDict(TypedDict):
+ accum: list[Any]
+ Type = AccumulationDict
+
+
+@comfytype(io_type="LOAD3D_CAMERA")
+class Load3DCamera(ComfyTypeIO):
+ class CameraInfo(TypedDict):
+ position: dict[str, float | int]
+ target: dict[str, float | int]
+ zoom: int
+ cameraType: str
+
+ Type = CameraInfo
+
+
+@comfytype(io_type="LOAD_3D")
+class Load3D(ComfyTypeIO):
+ """3D models are stored as a dictionary."""
+ class Model3DDict(TypedDict):
+ image: str
+ mask: str
+ normal: str
+ camera_info: Load3DCamera.CameraInfo
+ recording: NotRequired[str]
+
+ Type = Model3DDict
+
+
+@comfytype(io_type="LOAD_3D_ANIMATION")
+class Load3DAnimation(Load3D):
+ ...
+
+
+@comfytype(io_type="PHOTOMAKER")
+class Photomaker(ComfyTypeIO):
+ Type = Any
+
+
+@comfytype(io_type="POINT")
+class Point(ComfyTypeIO):
+ Type = Any # NOTE: I couldn't find any references in core code to POINT io_type. Does this exist?
+
+@comfytype(io_type="FACE_ANALYSIS")
+class FaceAnalysis(ComfyTypeIO):
+ Type = Any # NOTE: I couldn't find any references in core code to POINT io_type. Does this exist?
+
+@comfytype(io_type="BBOX")
+class BBOX(ComfyTypeIO):
+ Type = Any # NOTE: I couldn't find any references in core code to POINT io_type. Does this exist?
+
+@comfytype(io_type="SEGS")
+class SEGS(ComfyTypeIO):
+ Type = Any # NOTE: I couldn't find any references in core code to POINT io_type. Does this exist?
+
+@comfytype(io_type="*")
+class AnyType(ComfyTypeIO):
+ Type = Any
+
+@comfytype(io_type="COMFY_MULTITYPED_V3")
+class MultiType:
+ Type = Any
+ class Input(Input):
+ '''
+ Input that permits more than one input type; if `id` is an instance of `ComfyType.Input`, then that input will be used to create a widget (if applicable) with overridden values.
+ '''
+ def __init__(self, id: str | Input, types: list[type[_ComfyType] | _ComfyType], display_name: str=None, optional=False, tooltip: str=None, lazy: bool=None, extra_dict=None):
+ # if id is an Input, then use that Input with overridden values
+ self.input_override = None
+ if isinstance(id, Input):
+ self.input_override = copy.copy(id)
+ optional = id.optional if id.optional is True else optional
+ tooltip = id.tooltip if id.tooltip is not None else tooltip
+ display_name = id.display_name if id.display_name is not None else display_name
+ lazy = id.lazy if id.lazy is not None else lazy
+ id = id.id
+ # if is a widget input, make sure widget_type is set appropriately
+ if isinstance(self.input_override, WidgetInput):
+ self.input_override.widget_type = self.input_override.get_io_type()
+ super().__init__(id, display_name, optional, tooltip, lazy, extra_dict)
+ self._io_types = types
+
+ @property
+ def io_types(self) -> list[type[Input]]:
+ '''
+ Returns list of Input class types permitted.
+ '''
+ io_types = []
+ for x in self._io_types:
+ if not is_class(x):
+ io_types.append(type(x))
+ else:
+ io_types.append(x)
+ return io_types
+
+ def get_io_type(self):
+ # ensure types are unique and order is preserved
+ str_types = [x.io_type for x in self.io_types]
+ if self.input_override is not None:
+ str_types.insert(0, self.input_override.get_io_type())
+ return ",".join(list(dict.fromkeys(str_types)))
+
+ def as_dict(self):
+ if self.input_override is not None:
+ return self.input_override.as_dict() | super().as_dict()
+ else:
+ return super().as_dict()
+
+class DynamicInput(Input, ABC):
+ '''
+ Abstract class for dynamic input registration.
+ '''
+ @abstractmethod
+ def get_dynamic(self) -> list[Input]:
+ ...
+
+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)
+
+ @abstractmethod
+ def get_dynamic(self) -> list[Output]:
+ ...
+
+
+@comfytype(io_type="COMFY_AUTOGROW_V3")
+class AutogrowDynamic(ComfyTypeI):
+ Type = list[Any]
+ class Input(DynamicInput):
+ def __init__(self, id: str, template_input: Input, min: int=1, max: int=None,
+ 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
+
+ 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
+
+@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 as_dict(self):
+ return {
+ "template_id": self.template_id,
+ "allowed_types": "".join(t.io_type for t in self.allowed_types),
+ }
+
+ class Input(DynamicInput):
+ 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 get_dynamic(self) -> list[Input]:
+ return [self]
+
+ def as_dict(self):
+ return super().as_dict() | prune_dict({
+ "template": self.template.as_dict(),
+ })
+
+ 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 get_dynamic(self) -> list[Output]:
+ return [self]
+
+ def as_dict(self):
+ return super().as_dict() | prune_dict({
+ "template": self.template.as_dict(),
+ })
+
+
+class HiddenHolder:
+ def __init__(self, unique_id: str, prompt: Any,
+ extra_pnginfo: Any, dynprompt: Any,
+ auth_token_comfy_org: str, api_key_comfy_org: str, **kwargs):
+ self.unique_id = unique_id
+ """UNIQUE_ID is the unique identifier of the node, and matches the id property of the node on the client side. It is commonly used in client-server communications (see messages)."""
+ self.prompt = prompt
+ """PROMPT is the complete prompt sent by the client to the server. See the prompt object for a full description."""
+ self.extra_pnginfo = extra_pnginfo
+ """EXTRA_PNGINFO is a dictionary that will be copied into the metadata of any .png files saved. Custom nodes can store additional information in this dictionary for saving (or as a way to communicate with a downstream node)."""
+ self.dynprompt = dynprompt
+ """DYNPROMPT is an instance of comfy_execution.graph.DynamicPrompt. It differs from PROMPT in that it may mutate during the course of execution in response to Node Expansion."""
+ self.auth_token_comfy_org = auth_token_comfy_org
+ """AUTH_TOKEN_COMFY_ORG is a token acquired from signing into a ComfyOrg account on frontend."""
+ self.api_key_comfy_org = api_key_comfy_org
+ """API_KEY_COMFY_ORG is an API Key generated by ComfyOrg that allows skipping signing into a ComfyOrg account on frontend."""
+
+ def __getattr__(self, key: str):
+ '''If hidden variable not found, return None.'''
+ return None
+
+ @classmethod
+ def from_dict(cls, d: dict | None):
+ if d is None:
+ d = {}
+ return cls(
+ unique_id=d.get(Hidden.unique_id, None),
+ prompt=d.get(Hidden.prompt, None),
+ extra_pnginfo=d.get(Hidden.extra_pnginfo, None),
+ dynprompt=d.get(Hidden.dynprompt, None),
+ auth_token_comfy_org=d.get(Hidden.auth_token_comfy_org, None),
+ api_key_comfy_org=d.get(Hidden.api_key_comfy_org, None),
+ )
+
+class Hidden(str, Enum):
+ '''
+ Enumerator for requesting hidden variables in nodes.
+ '''
+ unique_id = "UNIQUE_ID"
+ """UNIQUE_ID is the unique identifier of the node, and matches the id property of the node on the client side. It is commonly used in client-server communications (see messages)."""
+ prompt = "PROMPT"
+ """PROMPT is the complete prompt sent by the client to the server. See the prompt object for a full description."""
+ extra_pnginfo = "EXTRA_PNGINFO"
+ """EXTRA_PNGINFO is a dictionary that will be copied into the metadata of any .png files saved. Custom nodes can store additional information in this dictionary for saving (or as a way to communicate with a downstream node)."""
+ dynprompt = "DYNPROMPT"
+ """DYNPROMPT is an instance of comfy_execution.graph.DynamicPrompt. It differs from PROMPT in that it may mutate during the course of execution in response to Node Expansion."""
+ auth_token_comfy_org = "AUTH_TOKEN_COMFY_ORG"
+ """AUTH_TOKEN_COMFY_ORG is a token acquired from signing into a ComfyOrg account on frontend."""
+ api_key_comfy_org = "API_KEY_COMFY_ORG"
+ """API_KEY_COMFY_ORG is an API Key generated by ComfyOrg that allows skipping signing into a ComfyOrg account on frontend."""
+
+
+@dataclass
+class NodeInfoV1:
+ input: dict=None
+ input_order: dict[str, list[str]]=None
+ output: list[str]=None
+ output_is_list: list[bool]=None
+ output_name: list[str]=None
+ output_tooltips: list[str]=None
+ name: str=None
+ display_name: str=None
+ description: str=None
+ python_module: Any=None
+ category: str=None
+ output_node: bool=None
+ deprecated: bool=None
+ experimental: bool=None
+ api_node: bool=None
+
+@dataclass
+class NodeInfoV3:
+ input: dict=None
+ output: dict=None
+ hidden: list[str]=None
+ name: str=None
+ display_name: str=None
+ description: str=None
+ category: str=None
+ output_node: bool=None
+ deprecated: bool=None
+ experimental: bool=None
+ api_node: bool=None
+
+
+@dataclass
+class Schema:
+ """Definition of V3 node properties."""
+
+ node_id: str
+ """ID of node - should be globally unique. If this is a custom node, add a prefix or postfix to avoid name clashes."""
+ display_name: str = None
+ """Display name of node."""
+ category: str = "sd"
+ """The category of the node, as per the "Add Node" menu."""
+ inputs: list[Input]=None
+ outputs: list[Output]=None
+ hidden: list[Hidden]=None
+ description: str=""
+ """Node description, shown as a tooltip when hovering over the node."""
+ is_input_list: bool = False
+ """A flag indicating if this node implements the additional code necessary to deal with OUTPUT_IS_LIST nodes.
+
+ All inputs of ``type`` will become ``list[type]``, regardless of how many items are passed in. This also affects ``check_lazy_status``.
+
+ From the docs:
+
+ A node can also override the default input behaviour and receive the whole list in a single call. This is done by setting a class attribute `INPUT_IS_LIST` to ``True``.
+
+ Comfy Docs: https://docs.comfy.org/custom-nodes/backend/lists#list-processing
+ """
+ is_output_node: bool=False
+ """Flags this node as an output node, causing any inputs it requires to be executed.
+
+ If a node is not connected to any output nodes, that node will not be executed. Usage::
+
+ From the docs:
+
+ By default, a node is not considered an output. Set ``OUTPUT_NODE = True`` to specify that it is.
+
+ Comfy Docs: https://docs.comfy.org/custom-nodes/backend/server_overview#output-node
+ """
+ is_deprecated: bool=False
+ """Flags a node as deprecated, indicating to users that they should find alternatives to this node."""
+ is_experimental: bool=False
+ """Flags a node as experimental, informing users that it may change or not work as expected."""
+ is_api_node: bool=False
+ """Flags a node as an API node. See: https://docs.comfy.org/tutorials/api-nodes/overview."""
+ not_idempotent: bool=False
+ """Flags a node as not idempotent; when True, the node will run and not reuse the cached outputs when identical inputs are provided on a different node in the graph."""
+ enable_expand: bool=False
+ """Flags a node as expandable, allowing NodeOutput to include 'expand' property."""
+
+ def validate(self):
+ '''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 []
+ 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)
+ issues = []
+ # verify ids are unique per list
+ if len(input_set) != len(input_ids):
+ issues.append(f"Input ids must be unique, but {[item for item, count in Counter(input_ids).items() if count > 1]} are not.")
+ if len(output_set) != len(output_ids):
+ issues.append(f"Output ids must be unique, but {[item for item, count in Counter(output_ids).items() if count > 1]} are not.")
+ # verify ids are unique between lists
+ intersection = input_set & output_set
+ if len(intersection) > 0:
+ issues.append(f"Ids must be unique between inputs and outputs, but {intersection} are not.")
+ if len(issues) > 0:
+ raise ValueError("\n".join(issues))
+
+ def finalize(self):
+ """Add hidden based on selected schema options, and give outputs without ids default ids."""
+ # if is an api_node, will need key-related hidden
+ if self.is_api_node:
+ if self.hidden is None:
+ self.hidden = []
+ if Hidden.auth_token_comfy_org not in self.hidden:
+ self.hidden.append(Hidden.auth_token_comfy_org)
+ if Hidden.api_key_comfy_org not in self.hidden:
+ self.hidden.append(Hidden.api_key_comfy_org)
+ # if is an output_node, will need prompt and extra_pnginfo
+ if self.is_output_node:
+ if self.hidden is None:
+ self.hidden = []
+ if Hidden.prompt not in self.hidden:
+ self.hidden.append(Hidden.prompt)
+ if Hidden.extra_pnginfo not in self.hidden:
+ self.hidden.append(Hidden.extra_pnginfo)
+ # give outputs without ids default ids
+ if self.outputs is not None:
+ for i, output in enumerate(self.outputs):
+ if output.id is None:
+ output.id = f"_{i}_{output.io_type}_"
+
+ def get_v1_info(self, cls) -> NodeInfoV1:
+ # 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)
+ if self.hidden:
+ for hidden in self.hidden:
+ input.setdefault("hidden", {})[hidden.name] = (hidden.value,)
+ # create separate lists from output fields
+ output = []
+ output_is_list = []
+ output_name = []
+ output_tooltips = []
+ if 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)
+
+ info = NodeInfoV1(
+ input=input,
+ input_order={key: list(value.keys()) for (key, value) in input.items()},
+ output=output,
+ output_is_list=output_is_list,
+ output_name=output_name,
+ output_tooltips=output_tooltips,
+ name=self.node_id,
+ display_name=self.display_name,
+ category=self.category,
+ description=self.description,
+ output_node=self.is_output_node,
+ deprecated=self.is_deprecated,
+ experimental=self.is_experimental,
+ api_node=self.is_api_node,
+ python_module=getattr(cls, "RELATIVE_PYTHON_MODULE", "nodes")
+ )
+ return info
+
+
+ def get_v3_info(self, cls) -> NodeInfoV3:
+ input_dict = {}
+ output_dict = {}
+ hidden_list = []
+ # TODO: make sure dynamic types will be handled correctly
+ if self.inputs:
+ for input in self.inputs:
+ add_to_dict_v3(input, input_dict)
+ if self.outputs:
+ for output in self.outputs:
+ add_to_dict_v3(output, output_dict)
+ if self.hidden:
+ for hidden in self.hidden:
+ hidden_list.append(hidden.value)
+
+ info = NodeInfoV3(
+ input=input_dict,
+ output=output_dict,
+ hidden=hidden_list,
+ name=self.node_id,
+ display_name=self.display_name,
+ description=self.description,
+ category=self.category,
+ output_node=self.is_output_node,
+ deprecated=self.is_deprecated,
+ experimental=self.is_experimental,
+ api_node=self.is_api_node,
+ python_module=getattr(cls, "RELATIVE_PYTHON_MODULE", "nodes")
+ )
+ return info
+
+
+def add_to_dict_v1(i: Input, input: dict):
+ key = "optional" if i.optional else "required"
+ as_dict = i.as_dict()
+ # for v1, we don't want to include the optional key
+ as_dict.pop("optional", None)
+ input.setdefault(key, {})[i.id] = (i.get_io_type(), as_dict)
+
+def add_to_dict_v3(io: Input | Output, d: dict):
+ d[io.id] = (io.get_io_type(), io.as_dict())
+
+
+
+class _ComfyNodeBaseInternal(_ComfyNodeInternal):
+ """Common base class for storing internal methods and properties; DO NOT USE for defining nodes."""
+
+ RELATIVE_PYTHON_MODULE = None
+ SCHEMA = None
+
+ # filled in during execution
+ resources: Resources = None
+ hidden: HiddenHolder = None
+
+ @classmethod
+ @abstractmethod
+ def define_schema(cls) -> Schema:
+ """Override this function with one that returns a Schema instance."""
+ raise NotImplementedError
+
+ @classmethod
+ @abstractmethod
+ def execute(cls, **kwargs) -> NodeOutput:
+ """Override this function with one that performs node's actions."""
+ raise NotImplementedError
+
+ @classmethod
+ def validate_inputs(cls, **kwargs) -> bool:
+ """Optionally, define this function to validate inputs; equivalent to V1's VALIDATE_INPUTS."""
+ raise NotImplementedError
+
+ @classmethod
+ def fingerprint_inputs(cls, **kwargs) -> Any:
+ """Optionally, define this function to fingerprint inputs; equivalent to V1's IS_CHANGED."""
+ raise NotImplementedError
+
+ @classmethod
+ def check_lazy_status(cls, **kwargs) -> list[str]:
+ """Optionally, define this function to return a list of input names that should be evaluated.
+
+ This basic mixin impl. requires all inputs.
+
+ :kwargs: All node inputs will be included here. If the input is ``None``, it should be assumed that it has not yet been evaluated. \
+ When using ``INPUT_IS_LIST = True``, unevaluated will instead be ``(None,)``.
+
+ Params should match the nodes execution ``FUNCTION`` (self, and all inputs by name).
+ Will be executed repeatedly until it returns an empty list, or all requested items were already evaluated (and sent as params).
+
+ Comfy Docs: https://docs.comfy.org/custom-nodes/backend/lazy_evaluation#defining-check-lazy-status
+ """
+ return [name for name in kwargs if kwargs[name] is None]
+
+ def __init__(self):
+ self.local_resources: ResourcesLocal = None
+ self.__class__.VALIDATE_CLASS()
+
+ @classmethod
+ def GET_BASE_CLASS(cls):
+ return _ComfyNodeBaseInternal
+
+ @final
+ @classmethod
+ def VALIDATE_CLASS(cls):
+ if first_real_override(cls, "define_schema") is None:
+ raise Exception(f"No define_schema function was defined for node class {cls.__name__}.")
+ if first_real_override(cls, "execute") is None:
+ raise Exception(f"No execute function was defined for node class {cls.__name__}.")
+
+ @classproperty
+ def FUNCTION(cls): # noqa
+ if inspect.iscoroutinefunction(cls.execute):
+ return "EXECUTE_NORMALIZED_ASYNC"
+ return "EXECUTE_NORMALIZED"
+
+ @final
+ @classmethod
+ def EXECUTE_NORMALIZED(cls, *args, **kwargs) -> NodeOutput:
+ to_return = cls.execute(*args, **kwargs)
+ if to_return is None:
+ to_return = NodeOutput()
+ elif isinstance(to_return, NodeOutput):
+ pass
+ elif isinstance(to_return, tuple):
+ to_return = NodeOutput(*to_return)
+ elif isinstance(to_return, dict):
+ to_return = NodeOutput.from_dict(to_return)
+ elif isinstance(to_return, ExecutionBlocker):
+ to_return = NodeOutput(block_execution=to_return.message)
+ else:
+ raise Exception(f"Invalid return type from node: {type(to_return)}")
+ if to_return.expand is not None and not cls.SCHEMA.enable_expand:
+ raise Exception(f"Node {cls.__name__} is not expandable, but expand included in NodeOutput; developer should set enable_expand=True on node's Schema to allow this.")
+ return to_return
+
+ @final
+ @classmethod
+ async def EXECUTE_NORMALIZED_ASYNC(cls, *args, **kwargs) -> NodeOutput:
+ to_return = await cls.execute(*args, **kwargs)
+ if to_return is None:
+ to_return = NodeOutput()
+ elif isinstance(to_return, NodeOutput):
+ pass
+ elif isinstance(to_return, tuple):
+ to_return = NodeOutput(*to_return)
+ elif isinstance(to_return, dict):
+ to_return = NodeOutput.from_dict(to_return)
+ elif isinstance(to_return, ExecutionBlocker):
+ to_return = NodeOutput(block_execution=to_return.message)
+ else:
+ raise Exception(f"Invalid return type from node: {type(to_return)}")
+ if to_return.expand is not None and not cls.SCHEMA.enable_expand:
+ raise Exception(f"Node {cls.__name__} is not expandable, but expand included in NodeOutput; developer should set enable_expand=True on node's Schema to allow this.")
+ return to_return
+
+ @final
+ @classmethod
+ def PREPARE_CLASS_CLONE(cls, hidden_inputs: dict) -> 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)
+ return type_clone
+
+ @final
+ @classmethod
+ def GET_NODE_INFO_V3(cls) -> dict[str, Any]:
+ schema = cls.GET_SCHEMA()
+ info = schema.get_v3_info(cls)
+ return asdict(info)
+ #############################################
+ # V1 Backwards Compatibility code
+ #--------------------------------------------
+ @final
+ @classmethod
+ def GET_NODE_INFO_V1(cls) -> dict[str, Any]:
+ schema = cls.GET_SCHEMA()
+ info = schema.get_v1_info(cls)
+ return asdict(info)
+
+ _DESCRIPTION = None
+ @final
+ @classproperty
+ def DESCRIPTION(cls): # noqa
+ if cls._DESCRIPTION is None:
+ cls.GET_SCHEMA()
+ return cls._DESCRIPTION
+
+ _CATEGORY = None
+ @final
+ @classproperty
+ def CATEGORY(cls): # noqa
+ if cls._CATEGORY is None:
+ cls.GET_SCHEMA()
+ return cls._CATEGORY
+
+ _EXPERIMENTAL = None
+ @final
+ @classproperty
+ def EXPERIMENTAL(cls): # noqa
+ if cls._EXPERIMENTAL is None:
+ cls.GET_SCHEMA()
+ return cls._EXPERIMENTAL
+
+ _DEPRECATED = None
+ @final
+ @classproperty
+ def DEPRECATED(cls): # noqa
+ if cls._DEPRECATED is None:
+ cls.GET_SCHEMA()
+ return cls._DEPRECATED
+
+ _API_NODE = None
+ @final
+ @classproperty
+ def API_NODE(cls): # noqa
+ if cls._API_NODE is None:
+ cls.GET_SCHEMA()
+ return cls._API_NODE
+
+ _OUTPUT_NODE = None
+ @final
+ @classproperty
+ def OUTPUT_NODE(cls): # noqa
+ if cls._OUTPUT_NODE is None:
+ cls.GET_SCHEMA()
+ return cls._OUTPUT_NODE
+
+ _INPUT_IS_LIST = None
+ @final
+ @classproperty
+ def INPUT_IS_LIST(cls): # noqa
+ if cls._INPUT_IS_LIST is None:
+ cls.GET_SCHEMA()
+ return cls._INPUT_IS_LIST
+ _OUTPUT_IS_LIST = None
+
+ @final
+ @classproperty
+ def OUTPUT_IS_LIST(cls): # noqa
+ if cls._OUTPUT_IS_LIST is None:
+ cls.GET_SCHEMA()
+ return cls._OUTPUT_IS_LIST
+
+ _RETURN_TYPES = None
+ @final
+ @classproperty
+ def RETURN_TYPES(cls): # noqa
+ if cls._RETURN_TYPES is None:
+ cls.GET_SCHEMA()
+ return cls._RETURN_TYPES
+
+ _RETURN_NAMES = None
+ @final
+ @classproperty
+ def RETURN_NAMES(cls): # noqa
+ if cls._RETURN_NAMES is None:
+ cls.GET_SCHEMA()
+ return cls._RETURN_NAMES
+
+ _OUTPUT_TOOLTIPS = None
+ @final
+ @classproperty
+ def OUTPUT_TOOLTIPS(cls): # noqa
+ if cls._OUTPUT_TOOLTIPS is None:
+ cls.GET_SCHEMA()
+ return cls._OUTPUT_TOOLTIPS
+
+ _NOT_IDEMPOTENT = None
+ @final
+ @classproperty
+ def NOT_IDEMPOTENT(cls): # noqa
+ if cls._NOT_IDEMPOTENT is None:
+ cls.GET_SCHEMA()
+ return cls._NOT_IDEMPOTENT
+
+ @final
+ @classmethod
+ def INPUT_TYPES(cls, include_hidden=True, return_schema=False) -> dict[str, dict] | tuple[dict[str, dict], Schema]:
+ schema = cls.FINALIZE_SCHEMA()
+ info = schema.get_v1_info(cls)
+ input = info.input
+ if not include_hidden:
+ input.pop("hidden", None)
+ if return_schema:
+ return input, schema
+ return input
+
+ @final
+ @classmethod
+ def FINALIZE_SCHEMA(cls):
+ """Call define_schema and finalize it."""
+ schema = cls.define_schema()
+ schema.finalize()
+ return schema
+
+ @final
+ @classmethod
+ def GET_SCHEMA(cls) -> Schema:
+ """Validate node class, finalize schema, validate schema, and set expected class properties."""
+ cls.VALIDATE_CLASS()
+ schema = cls.FINALIZE_SCHEMA()
+ schema.validate()
+ if cls._DESCRIPTION is None:
+ cls._DESCRIPTION = schema.description
+ if cls._CATEGORY is None:
+ cls._CATEGORY = schema.category
+ if cls._EXPERIMENTAL is None:
+ cls._EXPERIMENTAL = schema.is_experimental
+ if cls._DEPRECATED is None:
+ cls._DEPRECATED = schema.is_deprecated
+ if cls._API_NODE is None:
+ cls._API_NODE = schema.is_api_node
+ if cls._OUTPUT_NODE is None:
+ cls._OUTPUT_NODE = schema.is_output_node
+ if cls._INPUT_IS_LIST is None:
+ cls._INPUT_IS_LIST = schema.is_input_list
+ if cls._NOT_IDEMPOTENT is None:
+ cls._NOT_IDEMPOTENT = schema.not_idempotent
+
+ if cls._RETURN_TYPES is None:
+ output = []
+ output_name = []
+ output_is_list = []
+ output_tooltips = []
+ if schema.outputs:
+ for o in schema.outputs:
+ output.append(o.io_type)
+ output_name.append(o.display_name if o.display_name else o.io_type)
+ output_is_list.append(o.is_output_list)
+ output_tooltips.append(o.tooltip if o.tooltip else None)
+
+ cls._RETURN_TYPES = output
+ cls._RETURN_NAMES = output_name
+ cls._OUTPUT_IS_LIST = output_is_list
+ cls._OUTPUT_TOOLTIPS = output_tooltips
+ cls.SCHEMA = schema
+ return schema
+ #--------------------------------------------
+ #############################################
+
+
+class ComfyNode(_ComfyNodeBaseInternal):
+ """Common base class for all V3 nodes."""
+
+ @classmethod
+ @abstractmethod
+ def define_schema(cls) -> Schema:
+ """Override this function with one that returns a Schema instance."""
+ raise NotImplementedError
+
+ @classmethod
+ @abstractmethod
+ def execute(cls, **kwargs) -> NodeOutput:
+ """Override this function with one that performs node's actions."""
+ raise NotImplementedError
+
+ @classmethod
+ def validate_inputs(cls, **kwargs) -> bool:
+ """Optionally, define this function to validate inputs; equivalent to V1's VALIDATE_INPUTS."""
+ raise NotImplementedError
+
+ @classmethod
+ def fingerprint_inputs(cls, **kwargs) -> Any:
+ """Optionally, define this function to fingerprint inputs; equivalent to V1's IS_CHANGED."""
+ raise NotImplementedError
+
+ @classmethod
+ def check_lazy_status(cls, **kwargs) -> list[str]:
+ """Optionally, define this function to return a list of input names that should be evaluated.
+
+ This basic mixin impl. requires all inputs.
+
+ :kwargs: All node inputs will be included here. If the input is ``None``, it should be assumed that it has not yet been evaluated. \
+ When using ``INPUT_IS_LIST = True``, unevaluated will instead be ``(None,)``.
+
+ Params should match the nodes execution ``FUNCTION`` (self, and all inputs by name).
+ Will be executed repeatedly until it returns an empty list, or all requested items were already evaluated (and sent as params).
+
+ Comfy Docs: https://docs.comfy.org/custom-nodes/backend/lazy_evaluation#defining-check-lazy-status
+ """
+ return [name for name in kwargs if kwargs[name] is None]
+
+ @final
+ @classmethod
+ def GET_BASE_CLASS(cls):
+ """DO NOT override this class. Will break things in execution.py."""
+ return ComfyNode
+
+
+class NodeOutput(_NodeOutputInternal):
+ '''
+ Standardized output of a node; can pass in any number of args and/or a UIOutput into 'ui' kwarg.
+ '''
+ def __init__(self, *args: Any, ui: _UIOutput | dict=None, expand: dict=None, block_execution: str=None):
+ self.args = args
+ self.ui = ui
+ self.expand = expand
+ self.block_execution = block_execution
+
+ @property
+ def result(self):
+ return self.args if len(self.args) > 0 else None
+
+ @classmethod
+ def from_dict(cls, data: dict[str, Any]) -> "NodeOutput":
+ args = ()
+ ui = None
+ expand = None
+ if "result" in data:
+ result = data["result"]
+ if isinstance(result, ExecutionBlocker):
+ return cls(block_execution=result.message)
+ args = result
+ if "ui" in data:
+ ui = data["ui"]
+ if "expand" in data:
+ expand = data["expand"]
+ return cls(args=args, ui=ui, expand=expand)
+
+ def __getitem__(self, index) -> Any:
+ return self.args[index]
+
+class _UIOutput(ABC):
+ def __init__(self):
+ pass
+
+ @abstractmethod
+ def as_dict(self) -> dict:
+ ...
+
+
+class _IO:
+ FolderType = FolderType
+ UploadType = UploadType
+ RemoteOptions = RemoteOptions
+ NumberDisplay = NumberDisplay
+
+ comfytype = staticmethod(comfytype)
+ Custom = staticmethod(Custom)
+ Input = Input
+ WidgetInput = WidgetInput
+ Output = Output
+ ComfyTypeI = ComfyTypeI
+ ComfyTypeIO = ComfyTypeIO
+ #---------------------------------
+ # Supported Types
+ Boolean = Boolean
+ Int = Int
+ Float = Float
+ String = String
+ Combo = Combo
+ MultiCombo = MultiCombo
+ Image = Image
+ WanCameraEmbedding = WanCameraEmbedding
+ Webcam = Webcam
+ Mask = Mask
+ Latent = Latent
+ Conditioning = Conditioning
+ Sampler = Sampler
+ Sigmas = Sigmas
+ Noise = Noise
+ Guider = Guider
+ Clip = Clip
+ ControlNet = ControlNet
+ Vae = Vae
+ Model = Model
+ ClipVision = ClipVision
+ ClipVisionOutput = ClipVisionOutput
+ StyleModel = StyleModel
+ Gligen = Gligen
+ UpscaleModel = UpscaleModel
+ Audio = Audio
+ Video = Video
+ SVG = SVG
+ LoraModel = LoraModel
+ LossMap = LossMap
+ Voxel = Voxel
+ Mesh = Mesh
+ Hooks = Hooks
+ HookKeyframes = HookKeyframes
+ TimestepsRange = TimestepsRange
+ LatentOperation = LatentOperation
+ FlowControl = FlowControl
+ Accumulation = Accumulation
+ Load3DCamera = Load3DCamera
+ Load3D = Load3D
+ Load3DAnimation = Load3DAnimation
+ Photomaker = Photomaker
+ Point = Point
+ FaceAnalysis = FaceAnalysis
+ BBOX = BBOX
+ SEGS = SEGS
+ AnyType = AnyType
+ MultiType = MultiType
+ #---------------------------------
+ HiddenHolder = HiddenHolder
+ Hidden = Hidden
+ NodeInfoV1 = NodeInfoV1
+ NodeInfoV3 = NodeInfoV3
+ Schema = Schema
+ ComfyNode = ComfyNode
+ NodeOutput = NodeOutput
+ add_to_dict_v1 = staticmethod(add_to_dict_v1)
+ add_to_dict_v3 = staticmethod(add_to_dict_v3)
diff --git a/comfy_api/latest/_resources.py b/comfy_api/latest/_resources.py
new file mode 100644
index 000000000..a6bdda972
--- /dev/null
+++ b/comfy_api/latest/_resources.py
@@ -0,0 +1,72 @@
+from __future__ import annotations
+import comfy.utils
+import folder_paths
+import logging
+from abc import ABC, abstractmethod
+from typing import Any
+import torch
+
+class ResourceKey(ABC):
+ Type = Any
+ def __init__(self):
+ ...
+
+class TorchDictFolderFilename(ResourceKey):
+ '''Key for requesting a torch file via file_name from a folder category.'''
+ Type = dict[str, torch.Tensor]
+ def __init__(self, folder_name: str, file_name: str):
+ self.folder_name = folder_name
+ self.file_name = file_name
+
+ def __hash__(self):
+ return hash((self.folder_name, self.file_name))
+
+ def __eq__(self, other: object) -> bool:
+ if not isinstance(other, TorchDictFolderFilename):
+ return False
+ return self.folder_name == other.folder_name and self.file_name == other.file_name
+
+ def __str__(self):
+ return f"{self.folder_name} -> {self.file_name}"
+
+class Resources(ABC):
+ def __init__(self):
+ ...
+
+ @abstractmethod
+ def get(self, key: ResourceKey, default: Any=...) -> Any:
+ pass
+
+class ResourcesLocal(Resources):
+ def __init__(self):
+ super().__init__()
+ self.local_resources: dict[ResourceKey, Any] = {}
+
+ def get(self, key: ResourceKey, default: Any=...) -> Any:
+ cached = self.local_resources.get(key, None)
+ if cached is not None:
+ logging.info(f"Using cached resource '{key}'")
+ return cached
+ logging.info(f"Loading resource '{key}'")
+ to_return = None
+ if isinstance(key, TorchDictFolderFilename):
+ if default is ...:
+ to_return = comfy.utils.load_torch_file(folder_paths.get_full_path_or_raise(key.folder_name, key.file_name), safe_load=True)
+ else:
+ full_path = folder_paths.get_full_path(key.folder_name, key.file_name)
+ if full_path is not None:
+ to_return = comfy.utils.load_torch_file(full_path, safe_load=True)
+
+ if to_return is not None:
+ self.local_resources[key] = to_return
+ return to_return
+ if default is not ...:
+ return default
+ raise Exception(f"Unsupported resource key type: {type(key)}")
+
+
+class _RESOURCES:
+ ResourceKey = ResourceKey
+ TorchDictFolderFilename = TorchDictFolderFilename
+ Resources = Resources
+ ResourcesLocal = ResourcesLocal
diff --git a/comfy_api/latest/_ui.py b/comfy_api/latest/_ui.py
new file mode 100644
index 000000000..6b8a39d58
--- /dev/null
+++ b/comfy_api/latest/_ui.py
@@ -0,0 +1,457 @@
+from __future__ import annotations
+
+import json
+import os
+import random
+from io import BytesIO
+from typing import Type
+
+import av
+import numpy as np
+import torch
+import torchaudio
+from PIL import Image as PILImage
+from PIL.PngImagePlugin import PngInfo
+
+import folder_paths
+
+# used for image preview
+from comfy.cli_args import args
+from comfy_api.latest._io import ComfyNode, FolderType, Image, _UIOutput
+
+
+class SavedResult(dict):
+ def __init__(self, filename: str, subfolder: str, type: FolderType):
+ super().__init__(filename=filename, subfolder=subfolder,type=type.value)
+
+ @property
+ def filename(self) -> str:
+ return self["filename"]
+
+ @property
+ def subfolder(self) -> str:
+ return self["subfolder"]
+
+ @property
+ def type(self) -> FolderType:
+ return FolderType(self["type"])
+
+
+class SavedImages(_UIOutput):
+ """A UI output class to represent one or more saved images, potentially animated."""
+ def __init__(self, results: list[SavedResult], is_animated: bool = False):
+ super().__init__()
+ self.results = results
+ self.is_animated = is_animated
+
+ def as_dict(self) -> dict:
+ data = {"images": self.results}
+ if self.is_animated:
+ data["animated"] = (True,)
+ return data
+
+
+class SavedAudios(_UIOutput):
+ """UI wrapper around one or more audio files on disk (FLAC / MP3 / Opus)."""
+ def __init__(self, results: list[SavedResult]):
+ super().__init__()
+ self.results = results
+
+ def as_dict(self) -> dict:
+ return {"audio": self.results}
+
+
+def _get_directory_by_folder_type(folder_type: FolderType) -> str:
+ if folder_type == FolderType.input:
+ return folder_paths.get_input_directory()
+ if folder_type == FolderType.output:
+ return folder_paths.get_output_directory()
+ return folder_paths.get_temp_directory()
+
+
+class ImageSaveHelper:
+ """A helper class with static methods to handle image saving and metadata."""
+
+ @staticmethod
+ def _convert_tensor_to_pil(image_tensor: torch.Tensor) -> PILImage.Image:
+ """Converts a single torch tensor to a PIL Image."""
+ return PILImage.fromarray(np.clip(255.0 * image_tensor.cpu().numpy(), 0, 255).astype(np.uint8))
+
+ @staticmethod
+ def _create_png_metadata(cls: Type[ComfyNode] | None) -> PngInfo | None:
+ """Creates a PngInfo object with prompt and extra_pnginfo."""
+ if args.disable_metadata or cls is None or not cls.hidden:
+ return None
+ metadata = PngInfo()
+ if cls.hidden.prompt:
+ metadata.add_text("prompt", json.dumps(cls.hidden.prompt))
+ if cls.hidden.extra_pnginfo:
+ for x in cls.hidden.extra_pnginfo:
+ metadata.add_text(x, json.dumps(cls.hidden.extra_pnginfo[x]))
+ return metadata
+
+ @staticmethod
+ def _create_animated_png_metadata(cls: Type[ComfyNode] | None) -> PngInfo | None:
+ """Creates a PngInfo object with prompt and extra_pnginfo for animated PNGs (APNG)."""
+ if args.disable_metadata or cls is None or not cls.hidden:
+ return None
+ metadata = PngInfo()
+ if cls.hidden.prompt:
+ metadata.add(
+ b"comf",
+ "prompt".encode("latin-1", "strict")
+ + b"\0"
+ + json.dumps(cls.hidden.prompt).encode("latin-1", "strict"),
+ after_idat=True,
+ )
+ if cls.hidden.extra_pnginfo:
+ for x in cls.hidden.extra_pnginfo:
+ metadata.add(
+ b"comf",
+ x.encode("latin-1", "strict")
+ + b"\0"
+ + json.dumps(cls.hidden.extra_pnginfo[x]).encode("latin-1", "strict"),
+ after_idat=True,
+ )
+ return metadata
+
+ @staticmethod
+ def _create_webp_metadata(pil_image: PILImage.Image, cls: Type[ComfyNode] | None) -> PILImage.Exif:
+ """Creates EXIF metadata bytes for WebP images."""
+ exif_data = pil_image.getexif()
+ if args.disable_metadata or cls is None or cls.hidden is None:
+ return exif_data
+ if cls.hidden.prompt is not None:
+ exif_data[0x0110] = "prompt:{}".format(json.dumps(cls.hidden.prompt)) # EXIF 0x0110 = Model
+ if cls.hidden.extra_pnginfo is not None:
+ inital_exif_tag = 0x010F # EXIF 0x010f = Make
+ for key, value in cls.hidden.extra_pnginfo.items():
+ exif_data[inital_exif_tag] = "{}:{}".format(key, json.dumps(value))
+ inital_exif_tag -= 1
+ return exif_data
+
+ @staticmethod
+ def save_images(
+ images, filename_prefix: str, folder_type: FolderType, cls: Type[ComfyNode] | None, compress_level = 4,
+ ) -> list[SavedResult]:
+ """Saves a batch of images as individual PNG files."""
+ full_output_folder, filename, counter, subfolder, _ = folder_paths.get_save_image_path(
+ filename_prefix, _get_directory_by_folder_type(folder_type), images[0].shape[1], images[0].shape[0]
+ )
+ results = []
+ metadata = ImageSaveHelper._create_png_metadata(cls)
+ for batch_number, image_tensor in enumerate(images):
+ img = ImageSaveHelper._convert_tensor_to_pil(image_tensor)
+ filename_with_batch_num = filename.replace("%batch_num%", str(batch_number))
+ file = f"{filename_with_batch_num}_{counter:05}_.png"
+ img.save(os.path.join(full_output_folder, file), pnginfo=metadata, compress_level=compress_level)
+ results.append(SavedResult(file, subfolder, folder_type))
+ counter += 1
+ return results
+
+ @staticmethod
+ def get_save_images_ui(images, filename_prefix: str, cls: Type[ComfyNode] | None, compress_level=4) -> SavedImages:
+ """Saves a batch of images and returns a UI object for the node output."""
+ return SavedImages(
+ ImageSaveHelper.save_images(
+ images,
+ filename_prefix=filename_prefix,
+ folder_type=FolderType.output,
+ cls=cls,
+ compress_level=compress_level,
+ )
+ )
+
+ @staticmethod
+ def save_animated_png(
+ images, filename_prefix: str, folder_type: FolderType, cls: Type[ComfyNode] | None, fps: float, compress_level: int
+ ) -> SavedResult:
+ """Saves a batch of images as a single animated PNG."""
+ full_output_folder, filename, counter, subfolder, _ = folder_paths.get_save_image_path(
+ filename_prefix, _get_directory_by_folder_type(folder_type), images[0].shape[1], images[0].shape[0]
+ )
+ pil_images = [ImageSaveHelper._convert_tensor_to_pil(img) for img in images]
+ metadata = ImageSaveHelper._create_animated_png_metadata(cls)
+ file = f"{filename}_{counter:05}_.png"
+ save_path = os.path.join(full_output_folder, file)
+ pil_images[0].save(
+ save_path,
+ pnginfo=metadata,
+ compress_level=compress_level,
+ save_all=True,
+ duration=int(1000.0 / fps),
+ append_images=pil_images[1:],
+ )
+ return SavedResult(file, subfolder, folder_type)
+
+ @staticmethod
+ def get_save_animated_png_ui(
+ images, filename_prefix: str, cls: Type[ComfyNode] | None, fps: float, compress_level: int
+ ) -> SavedImages:
+ """Saves an animated PNG and returns a UI object for the node output."""
+ result = ImageSaveHelper.save_animated_png(
+ images,
+ filename_prefix=filename_prefix,
+ folder_type=FolderType.output,
+ cls=cls,
+ fps=fps,
+ compress_level=compress_level,
+ )
+ return SavedImages([result], is_animated=len(images) > 1)
+
+ @staticmethod
+ def save_animated_webp(
+ images,
+ filename_prefix: str,
+ folder_type: FolderType,
+ cls: Type[ComfyNode] | None,
+ fps: float,
+ lossless: bool,
+ quality: int,
+ method: int,
+ ) -> SavedResult:
+ """Saves a batch of images as a single animated WebP."""
+ full_output_folder, filename, counter, subfolder, _ = folder_paths.get_save_image_path(
+ filename_prefix, _get_directory_by_folder_type(folder_type), images[0].shape[1], images[0].shape[0]
+ )
+ pil_images = [ImageSaveHelper._convert_tensor_to_pil(img) for img in images]
+ pil_exif = ImageSaveHelper._create_webp_metadata(pil_images[0], cls)
+ file = f"{filename}_{counter:05}_.webp"
+ pil_images[0].save(
+ os.path.join(full_output_folder, file),
+ save_all=True,
+ duration=int(1000.0 / fps),
+ append_images=pil_images[1:],
+ exif=pil_exif,
+ lossless=lossless,
+ quality=quality,
+ method=method,
+ )
+ return SavedResult(file, subfolder, folder_type)
+
+ @staticmethod
+ def get_save_animated_webp_ui(
+ images,
+ filename_prefix: str,
+ cls: Type[ComfyNode] | None,
+ fps: float,
+ lossless: bool,
+ quality: int,
+ method: int,
+ ) -> SavedImages:
+ """Saves an animated WebP and returns a UI object for the node output."""
+ result = ImageSaveHelper.save_animated_webp(
+ images,
+ filename_prefix=filename_prefix,
+ folder_type=FolderType.output,
+ cls=cls,
+ fps=fps,
+ lossless=lossless,
+ quality=quality,
+ method=method,
+ )
+ return SavedImages([result], is_animated=len(images) > 1)
+
+
+class AudioSaveHelper:
+ """A helper class with static methods to handle audio saving and metadata."""
+ _OPUS_RATES = [8000, 12000, 16000, 24000, 48000]
+
+ @staticmethod
+ def save_audio(
+ audio: dict,
+ filename_prefix: str,
+ folder_type: FolderType,
+ cls: Type[ComfyNode] | None,
+ format: str = "flac",
+ quality: str = "128k",
+ ) -> list[SavedResult]:
+ full_output_folder, filename, counter, subfolder, _ = folder_paths.get_save_image_path(
+ filename_prefix, _get_directory_by_folder_type(folder_type)
+ )
+
+ metadata = {}
+ if not args.disable_metadata and cls is not None:
+ if cls.hidden.prompt is not None:
+ metadata["prompt"] = json.dumps(cls.hidden.prompt)
+ if cls.hidden.extra_pnginfo is not None:
+ for x in cls.hidden.extra_pnginfo:
+ metadata[x] = json.dumps(cls.hidden.extra_pnginfo[x])
+
+ results = []
+ for batch_number, waveform in enumerate(audio["waveform"].cpu()):
+ filename_with_batch_num = filename.replace("%batch_num%", str(batch_number))
+ file = f"{filename_with_batch_num}_{counter:05}_.{format}"
+ output_path = os.path.join(full_output_folder, file)
+
+ # Use original sample rate initially
+ sample_rate = audio["sample_rate"]
+
+ # Handle Opus sample rate requirements
+ if format == "opus":
+ if sample_rate > 48000:
+ sample_rate = 48000
+ elif sample_rate not in AudioSaveHelper._OPUS_RATES:
+ # Find the next highest supported rate
+ for rate in sorted(AudioSaveHelper._OPUS_RATES):
+ if rate > sample_rate:
+ sample_rate = rate
+ break
+ if sample_rate not in AudioSaveHelper._OPUS_RATES: # Fallback if still not supported
+ sample_rate = 48000
+
+ # Resample if necessary
+ if sample_rate != audio["sample_rate"]:
+ waveform = torchaudio.functional.resample(waveform, audio["sample_rate"], sample_rate)
+
+ # Create output with specified format
+ output_buffer = BytesIO()
+ output_container = av.open(output_buffer, mode="w", format=format)
+
+ # Set metadata on the container
+ for key, value in metadata.items():
+ output_container.metadata[key] = value
+
+ # Set up the output stream with appropriate properties
+ if format == "opus":
+ out_stream = output_container.add_stream("libopus", rate=sample_rate)
+ if quality == "64k":
+ out_stream.bit_rate = 64000
+ elif quality == "96k":
+ out_stream.bit_rate = 96000
+ elif quality == "128k":
+ out_stream.bit_rate = 128000
+ elif quality == "192k":
+ out_stream.bit_rate = 192000
+ elif quality == "320k":
+ out_stream.bit_rate = 320000
+ elif format == "mp3":
+ out_stream = output_container.add_stream("libmp3lame", rate=sample_rate)
+ if quality == "V0":
+ # TODO i would really love to support V3 and V5 but there doesn't seem to be a way to set the qscale level, the property below is a bool
+ out_stream.codec_context.qscale = 1
+ elif quality == "128k":
+ out_stream.bit_rate = 128000
+ elif quality == "320k":
+ out_stream.bit_rate = 320000
+ else: # format == "flac":
+ out_stream = output_container.add_stream("flac", rate=sample_rate)
+
+ frame = av.AudioFrame.from_ndarray(
+ waveform.movedim(0, 1).reshape(1, -1).float().numpy(),
+ format="flt",
+ layout="mono" if waveform.shape[0] == 1 else "stereo",
+ )
+ frame.sample_rate = sample_rate
+ frame.pts = 0
+ output_container.mux(out_stream.encode(frame))
+
+ # Flush encoder
+ output_container.mux(out_stream.encode(None))
+
+ # Close containers
+ output_container.close()
+
+ # Write the output to file
+ output_buffer.seek(0)
+ with open(output_path, "wb") as f:
+ f.write(output_buffer.getbuffer())
+
+ results.append(SavedResult(file, subfolder, folder_type))
+ counter += 1
+
+ return results
+
+ @staticmethod
+ def get_save_audio_ui(
+ audio, filename_prefix: str, cls: Type[ComfyNode] | None, format: str = "flac", quality: str = "128k",
+ ) -> SavedAudios:
+ """Save and instantly wrap for UI."""
+ return SavedAudios(
+ AudioSaveHelper.save_audio(
+ audio,
+ filename_prefix=filename_prefix,
+ folder_type=FolderType.output,
+ cls=cls,
+ format=format,
+ quality=quality,
+ )
+ )
+
+
+class PreviewImage(_UIOutput):
+ def __init__(self, image: Image.Type, animated: bool = False, cls: Type[ComfyNode] = None, **kwargs):
+ self.values = ImageSaveHelper.save_images(
+ image,
+ filename_prefix="ComfyUI_temp_" + ''.join(random.choice("abcdefghijklmnopqrstupvxyz") for _ in range(5)),
+ folder_type=FolderType.temp,
+ cls=cls,
+ compress_level=1,
+ )
+ self.animated = animated
+
+ def as_dict(self):
+ return {
+ "images": self.values,
+ "animated": (self.animated,)
+ }
+
+
+class PreviewMask(PreviewImage):
+ def __init__(self, mask: PreviewMask.Type, animated: bool=False, cls: ComfyNode=None, **kwargs):
+ preview = mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])).movedim(1, -1).expand(-1, -1, -1, 3)
+ super().__init__(preview, animated, cls, **kwargs)
+
+
+class PreviewAudio(_UIOutput):
+ def __init__(self, audio: dict, cls: Type[ComfyNode] = None, **kwargs):
+ self.values = AudioSaveHelper.save_audio(
+ audio,
+ filename_prefix="ComfyUI_temp_" + "".join(random.choice("abcdefghijklmnopqrstuvwxyz") for _ in range(5)),
+ folder_type=FolderType.temp,
+ cls=cls,
+ format="flac",
+ quality="128k",
+ )
+
+ def as_dict(self) -> dict:
+ return {"audio": self.values}
+
+
+class PreviewVideo(_UIOutput):
+ def __init__(self, values: list[SavedResult | dict], **kwargs):
+ self.values = values
+
+ def as_dict(self):
+ return {"images": self.values, "animated": (True,)}
+
+
+class PreviewUI3D(_UIOutput):
+ def __init__(self, model_file, camera_info, **kwargs):
+ self.model_file = model_file
+ self.camera_info = camera_info
+
+ def as_dict(self):
+ return {"result": [self.model_file, self.camera_info]}
+
+
+class PreviewText(_UIOutput):
+ def __init__(self, value: str, **kwargs):
+ self.value = value
+
+ def as_dict(self):
+ return {"text": (self.value,)}
+
+
+class _UI:
+ SavedResult = SavedResult
+ SavedImages = SavedImages
+ SavedAudios = SavedAudios
+ ImageSaveHelper = ImageSaveHelper
+ AudioSaveHelper = AudioSaveHelper
+ PreviewImage = PreviewImage
+ PreviewMask = PreviewMask
+ PreviewAudio = PreviewAudio
+ PreviewVideo = PreviewVideo
+ PreviewUI3D = PreviewUI3D
+ PreviewText = PreviewText
diff --git a/comfy_api/v0_0_2/__init__.py b/comfy_api/v0_0_2/__init__.py
index ea83833fb..de0f95001 100644
--- a/comfy_api/v0_0_2/__init__.py
+++ b/comfy_api/v0_0_2/__init__.py
@@ -6,6 +6,7 @@ from comfy_api.latest import (
)
from typing import Type, TYPE_CHECKING
from comfy_api.internal.async_to_sync import create_sync_class
+from comfy_api.latest import io, ui, ComfyExtension #noqa: F401
class ComfyAPIAdapter_v0_0_2(ComfyAPI_latest):
@@ -40,4 +41,5 @@ __all__ = [
"Input",
"InputImpl",
"Types",
+ "ComfyExtension",
]
diff --git a/comfy_execution/graph.py b/comfy_execution/graph.py
index 60e2ab91e..f4b427265 100644
--- a/comfy_execution/graph.py
+++ b/comfy_execution/graph.py
@@ -4,9 +4,12 @@ from typing import Type, Literal
import nodes
import asyncio
import inspect
-from comfy_execution.graph_utils import is_link
+from comfy_execution.graph_utils import is_link, ExecutionBlocker
from comfy.comfy_types.node_typing import ComfyNodeABC, InputTypeDict, InputTypeOptions
+# NOTE: ExecutionBlocker code got moved to graph_utils.py to prevent torch being imported too soon during unit tests
+ExecutionBlocker = ExecutionBlocker
+
class DependencyCycleError(Exception):
pass
@@ -294,21 +297,3 @@ class ExecutionList(TopologicalSort):
del blocked_by[node_id]
to_remove = [node_id for node_id in blocked_by if len(blocked_by[node_id]) == 0]
return list(blocked_by.keys())
-
-class ExecutionBlocker:
- """
- Return this from a node and any users will be blocked with the given error message.
- If the message is None, execution will be blocked silently instead.
- Generally, you should avoid using this functionality unless absolutely necessary. Whenever it's
- possible, a lazy input will be more efficient and have a better user experience.
- This functionality is useful in two cases:
- 1. You want to conditionally prevent an output node from executing. (Particularly a built-in node
- like SaveImage. For your own output nodes, I would recommend just adding a BOOL input and using
- lazy evaluation to let it conditionally disable itself.)
- 2. You have a node with multiple possible outputs, some of which are invalid and should not be used.
- (I would recommend not making nodes like this in the future -- instead, make multiple nodes with
- different outputs. Unfortunately, there are several popular existing nodes using this pattern.)
- """
- def __init__(self, message):
- self.message = message
-
diff --git a/comfy_execution/graph_utils.py b/comfy_execution/graph_utils.py
index 8595e942d..496d2c634 100644
--- a/comfy_execution/graph_utils.py
+++ b/comfy_execution/graph_utils.py
@@ -137,3 +137,19 @@ def add_graph_prefix(graph, outputs, prefix):
return new_graph, tuple(new_outputs)
+class ExecutionBlocker:
+ """
+ Return this from a node and any users will be blocked with the given error message.
+ If the message is None, execution will be blocked silently instead.
+ Generally, you should avoid using this functionality unless absolutely necessary. Whenever it's
+ possible, a lazy input will be more efficient and have a better user experience.
+ This functionality is useful in two cases:
+ 1. You want to conditionally prevent an output node from executing. (Particularly a built-in node
+ like SaveImage. For your own output nodes, I would recommend just adding a BOOL input and using
+ lazy evaluation to let it conditionally disable itself.)
+ 2. You have a node with multiple possible outputs, some of which are invalid and should not be used.
+ (I would recommend not making nodes like this in the future -- instead, make multiple nodes with
+ different outputs. Unfortunately, there are several popular existing nodes using this pattern.)
+ """
+ def __init__(self, message):
+ self.message = message
diff --git a/execution.py b/execution.py
index cde14c52f..952f0cc5c 100644
--- a/execution.py
+++ b/execution.py
@@ -32,6 +32,8 @@ from comfy_execution.graph_utils import GraphBuilder, is_link
from comfy_execution.validation import validate_node_input
from comfy_execution.progress import get_progress_state, reset_progress_state, add_progress_handler, WebUIProgressHandler
from comfy_execution.utils import CurrentNodeContext
+from comfy_api.internal import _ComfyNodeInternal, _NodeOutputInternal, first_real_override, is_class, make_locked_method_func
+from comfy_api.latest import io
class ExecutionResult(Enum):
@@ -56,7 +58,15 @@ class IsChangedCache:
node = self.dynprompt.get_node(node_id)
class_type = node["class_type"]
class_def = nodes.NODE_CLASS_MAPPINGS[class_type]
- if not hasattr(class_def, "IS_CHANGED"):
+ has_is_changed = False
+ is_changed_name = None
+ if issubclass(class_def, _ComfyNodeInternal) and first_real_override(class_def, "fingerprint_inputs") is not None:
+ has_is_changed = True
+ is_changed_name = "fingerprint_inputs"
+ elif hasattr(class_def, "IS_CHANGED"):
+ has_is_changed = True
+ is_changed_name = "IS_CHANGED"
+ if not has_is_changed:
self.is_changed[node_id] = False
return self.is_changed[node_id]
@@ -65,9 +75,9 @@ 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, _ = get_input_data(node["inputs"], class_def, node_id, None)
+ input_data_all, _, hidden_inputs = 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")
+ 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)
node["is_changed"] = [None if isinstance(x, ExecutionBlocker) else x for x in is_changed]
except Exception as e:
@@ -126,9 +136,14 @@ class CacheSet:
SENSITIVE_EXTRA_DATA_KEYS = ("auth_token_comfy_org", "api_key_comfy_org")
def get_input_data(inputs, class_def, unique_id, outputs=None, dynprompt=None, extra_data={}):
- valid_inputs = class_def.INPUT_TYPES()
+ is_v3 = issubclass(class_def, _ComfyNodeInternal)
+ if is_v3:
+ valid_inputs, schema = class_def.INPUT_TYPES(include_hidden=False, return_schema=True)
+ else:
+ valid_inputs = class_def.INPUT_TYPES()
input_data_all = {}
missing_keys = {}
+ hidden_inputs_v3 = {}
for x in inputs:
input_data = inputs[x]
_, input_category, input_info = get_input_info(class_def, x, valid_inputs)
@@ -153,22 +168,37 @@ def get_input_data(inputs, class_def, unique_id, outputs=None, dynprompt=None, e
elif input_category is not None:
input_data_all[x] = [input_data]
- if "hidden" in valid_inputs:
- h = valid_inputs["hidden"]
- for x in h:
- if h[x] == "PROMPT":
- input_data_all[x] = [dynprompt.get_original_prompt() if dynprompt is not None else {}]
- if h[x] == "DYNPROMPT":
- input_data_all[x] = [dynprompt]
- if h[x] == "EXTRA_PNGINFO":
- input_data_all[x] = [extra_data.get('extra_pnginfo', None)]
- if h[x] == "UNIQUE_ID":
- input_data_all[x] = [unique_id]
- if h[x] == "AUTH_TOKEN_COMFY_ORG":
- 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
+ if is_v3:
+ if schema.hidden:
+ if io.Hidden.prompt in schema.hidden:
+ hidden_inputs_v3[io.Hidden.prompt] = dynprompt.get_original_prompt() if dynprompt is not None else {}
+ if io.Hidden.dynprompt in schema.hidden:
+ hidden_inputs_v3[io.Hidden.dynprompt] = dynprompt
+ if io.Hidden.extra_pnginfo in schema.hidden:
+ hidden_inputs_v3[io.Hidden.extra_pnginfo] = extra_data.get('extra_pnginfo', None)
+ if io.Hidden.unique_id in schema.hidden:
+ hidden_inputs_v3[io.Hidden.unique_id] = unique_id
+ if io.Hidden.auth_token_comfy_org in schema.hidden:
+ hidden_inputs_v3[io.Hidden.auth_token_comfy_org] = extra_data.get("auth_token_comfy_org", None)
+ if io.Hidden.api_key_comfy_org in schema.hidden:
+ hidden_inputs_v3[io.Hidden.api_key_comfy_org] = extra_data.get("api_key_comfy_org", None)
+ else:
+ if "hidden" in valid_inputs:
+ h = valid_inputs["hidden"]
+ for x in h:
+ if h[x] == "PROMPT":
+ input_data_all[x] = [dynprompt.get_original_prompt() if dynprompt is not None else {}]
+ if h[x] == "DYNPROMPT":
+ input_data_all[x] = [dynprompt]
+ if h[x] == "EXTRA_PNGINFO":
+ input_data_all[x] = [extra_data.get('extra_pnginfo', None)]
+ if h[x] == "UNIQUE_ID":
+ input_data_all[x] = [unique_id]
+ if h[x] == "AUTH_TOKEN_COMFY_ORG":
+ 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
map_node_over_list = None #Don't hook this please
@@ -184,7 +214,7 @@ async def resolve_map_node_over_list_results(results):
raise exc
return [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):
+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):
# check if node wants the lists
input_is_list = getattr(obj, "INPUT_IS_LIST", False)
@@ -214,7 +244,22 @@ async def _async_map_node_over_list(prompt_id, unique_id, obj, input_data_all, f
if execution_block is None:
if pre_execute_cb is not None and index is not None:
pre_execute_cb(index)
- f = getattr(obj, func)
+ # V3
+ if isinstance(obj, _ComfyNodeInternal) or (is_class(obj) and issubclass(obj, _ComfyNodeInternal)):
+ # if is just a class, then assign no resources or state, just create clone
+ if is_class(obj):
+ type_obj = obj
+ obj.VALIDATE_CLASS()
+ class_clone = obj.PREPARE_CLASS_CLONE(hidden_inputs)
+ # otherwise, use class instance to populate/reuse some fields
+ else:
+ type_obj = type(obj)
+ type_obj.VALIDATE_CLASS()
+ class_clone = type_obj.PREPARE_CLASS_CLONE(hidden_inputs)
+ f = make_locked_method_func(type_obj, func, class_clone)
+ # V1
+ else:
+ f = getattr(obj, func)
if inspect.iscoroutinefunction(f):
async def async_wrapper(f, prompt_id, unique_id, list_index, args):
with CurrentNodeContext(prompt_id, unique_id, list_index):
@@ -266,8 +311,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):
- 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)
+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)
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
@@ -298,6 +343,26 @@ def get_output_from_returns(return_values, obj):
result = tuple([result] * len(obj.RETURN_TYPES))
results.append(result)
subgraph_results.append((None, result))
+ elif isinstance(r, _NodeOutputInternal):
+ # V3
+ if r.ui is not None:
+ if isinstance(r.ui, dict):
+ uis.append(r.ui)
+ else:
+ uis.append(r.ui.as_dict())
+ if r.expand is not None:
+ has_subgraph = True
+ new_graph = r.expand
+ result = r.result
+ if r.block_execution is not None:
+ result = tuple([ExecutionBlocker(r.block_execution)] * len(obj.RETURN_TYPES))
+ subgraph_results.append((new_graph, result))
+ elif r.result is not None:
+ result = r.result
+ if r.block_execution is not None:
+ result = tuple([ExecutionBlocker(r.block_execution)] * len(obj.RETURN_TYPES))
+ results.append(result)
+ subgraph_results.append((None, result))
else:
if isinstance(r, ExecutionBlocker):
r = tuple([r] * len(obj.RETURN_TYPES))
@@ -381,7 +446,7 @@ async def execute(server, dynprompt, caches, current_item, extra_data, executed,
has_subgraph = False
else:
get_progress_state().start_progress(unique_id)
- input_data_all, missing_keys = get_input_data(inputs, class_def, unique_id, caches.outputs, dynprompt, extra_data)
+ input_data_all, missing_keys, hidden_inputs = get_input_data(inputs, class_def, unique_id, caches.outputs, dynprompt, extra_data)
if server.client_id is not None:
server.last_node_id = display_node_id
server.send_sync("executing", { "node": unique_id, "display_node": display_node_id, "prompt_id": prompt_id }, server.client_id)
@@ -391,8 +456,12 @@ async def execute(server, dynprompt, caches, current_item, extra_data, executed,
obj = class_def()
caches.objects.set(unique_id, obj)
- if hasattr(obj, "check_lazy_status"):
- required_inputs = await _async_map_node_over_list(prompt_id, unique_id, obj, input_data_all, "check_lazy_status", allow_interrupt=True)
+ if issubclass(class_def, _ComfyNodeInternal):
+ lazy_status_present = first_real_override(class_def, "check_lazy_status") is not None
+ else:
+ lazy_status_present = getattr(obj, "check_lazy_status", None) is not None
+ if 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 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 (
@@ -424,7 +493,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)
+ 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)
if has_pending_tasks:
pending_async_nodes[unique_id] = output_data
unblock = execution_list.add_external_block(unique_id)
@@ -672,8 +741,14 @@ async def validate_inputs(prompt_id, prompt, item, validated):
validate_function_inputs = []
validate_has_kwargs = False
- if hasattr(obj_class, "VALIDATE_INPUTS"):
- argspec = inspect.getfullargspec(obj_class.VALIDATE_INPUTS)
+ if issubclass(obj_class, _ComfyNodeInternal):
+ validate_function_name = "validate_inputs"
+ validate_function = first_real_override(obj_class, validate_function_name)
+ else:
+ validate_function_name = "VALIDATE_INPUTS"
+ validate_function = getattr(obj_class, validate_function_name, None)
+ if validate_function is not None:
+ argspec = inspect.getfullargspec(validate_function)
validate_function_inputs = argspec.args
validate_has_kwargs = argspec.varkw is not None
received_types = {}
@@ -848,7 +923,7 @@ async def validate_inputs(prompt_id, prompt, item, validated):
continue
if len(validate_function_inputs) > 0 or validate_has_kwargs:
- input_data_all, _ = get_input_data(inputs, obj_class, unique_id)
+ input_data_all, _, hidden_inputs = 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:
@@ -856,8 +931,7 @@ async def validate_inputs(prompt_id, prompt, item, validated):
if 'input_types' in validate_function_inputs:
input_filtered['input_types'] = [received_types]
- #ret = obj_class.VALIDATE_INPUTS(**input_filtered)
- ret = await _async_map_node_over_list(prompt_id, unique_id, obj_class, input_filtered, "VALIDATE_INPUTS")
+ ret = await _async_map_node_over_list(prompt_id, unique_id, obj_class, input_filtered, validate_function_name, hidden_inputs=hidden_inputs)
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.py
index 54e530388..da4a46366 100644
--- a/nodes.py
+++ b/nodes.py
@@ -6,6 +6,7 @@ import os
import sys
import json
import hashlib
+import inspect
import traceback
import math
import time
@@ -29,6 +30,7 @@ import comfy.controlnet
from comfy.comfy_types import IO, ComfyNodeABC, InputTypeDict, FileLocator
from comfy_api.internal import register_versions, ComfyAPIWithVersion
from comfy_api.version_list import supported_versions
+from comfy_api.latest import io, ComfyExtension
import comfy.clip_vision
@@ -2152,6 +2154,7 @@ async def load_custom_node(module_path: str, ignore=set(), module_parent="custom
if os.path.isdir(web_dir):
EXTENSION_WEB_DIRS[module_name] = web_dir
+ # V1 node definition
if hasattr(module, "NODE_CLASS_MAPPINGS") and getattr(module, "NODE_CLASS_MAPPINGS") is not None:
for name, node_cls in module.NODE_CLASS_MAPPINGS.items():
if name not in ignore:
@@ -2160,8 +2163,38 @@ async def load_custom_node(module_path: str, ignore=set(), module_parent="custom
if hasattr(module, "NODE_DISPLAY_NAME_MAPPINGS") and getattr(module, "NODE_DISPLAY_NAME_MAPPINGS") is not None:
NODE_DISPLAY_NAME_MAPPINGS.update(module.NODE_DISPLAY_NAME_MAPPINGS)
return True
+ # V3 Extension Definition
+ elif hasattr(module, "comfy_entrypoint"):
+ entrypoint = getattr(module, "comfy_entrypoint")
+ if not callable(entrypoint):
+ logging.warning(f"comfy_entrypoint in {module_path} is not callable, skipping.")
+ return False
+ try:
+ if inspect.iscoroutinefunction(entrypoint):
+ extension = await entrypoint()
+ else:
+ extension = entrypoint()
+ if not isinstance(extension, ComfyExtension):
+ logging.warning(f"comfy_entrypoint in {module_path} did not return a ComfyExtension, skipping.")
+ return False
+ node_list = await extension.get_node_list()
+ if not isinstance(node_list, list):
+ logging.warning(f"comfy_entrypoint in {module_path} did not return a list of nodes, skipping.")
+ return False
+ for node_cls in node_list:
+ node_cls: io.ComfyNode
+ schema = node_cls.GET_SCHEMA()
+ if schema.node_id not in ignore:
+ NODE_CLASS_MAPPINGS[schema.node_id] = node_cls
+ node_cls.RELATIVE_PYTHON_MODULE = "{}.{}".format(module_parent, get_module_name(module_path))
+ if schema.display_name is not None:
+ NODE_DISPLAY_NAME_MAPPINGS[schema.node_id] = schema.display_name
+ return True
+ except Exception as e:
+ logging.warning(f"Error while calling comfy_entrypoint in {module_path}: {e}")
+ return False
else:
- logging.warning(f"Skip {module_path} module for custom nodes due to the lack of NODE_CLASS_MAPPINGS.")
+ logging.warning(f"Skip {module_path} module for custom nodes due to the lack of NODE_CLASS_MAPPINGS or NODES_LIST (need one).")
return False
except Exception as e:
logging.warning(traceback.format_exc())
@@ -2286,7 +2319,7 @@ async def init_builtin_extra_nodes():
"nodes_string.py",
"nodes_camera_trajectory.py",
"nodes_edit_model.py",
- "nodes_tcfg.py"
+ "nodes_tcfg.py",
]
import_failed = []
diff --git a/server.py b/server.py
index 3e06d2fbb..0553a0dd7 100644
--- a/server.py
+++ b/server.py
@@ -30,6 +30,7 @@ from comfy_api import feature_flags
import node_helpers
from comfyui_version import __version__
from app.frontend_management import FrontendManager
+from comfy_api.internal import _ComfyNodeInternal
from app.user_manager import UserManager
from app.model_manager import ModelFileManager
@@ -591,6 +592,8 @@ class PromptServer():
def node_info(node_class):
obj_class = nodes.NODE_CLASS_MAPPINGS[node_class]
+ if issubclass(obj_class, _ComfyNodeInternal):
+ return obj_class.GET_NODE_INFO_V1()
info = {}
info['input'] = obj_class.INPUT_TYPES()
info['input_order'] = {key: list(value.keys()) for (key, value) in obj_class.INPUT_TYPES().items()}