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__.pyindex 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_funcdiff --git a/comfy_api/latest/__init__.py b/comfy_api/latest/__init__.pyindex 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, abstractmethodfrom typing import Type, TYPE_CHECKINGfrom comfy_api.internal import ComfyAPIBasefrom comfy_api.internal.singleton import ProxiedSingleton@@ -7,6 +8,9 @@ from comfy_api.internal.async_to_sync import create_sync_classfrom comfy_api.latest._input import ImageInput, AudioInput, MaskInput, LatentInput, VideoInputfrom comfy_api.latest._input_impl import VideoFromFile, VideoFromComponentsfrom comfy_api.latest._util import VideoCodec, VideoContainer, VideoComponents+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: F401from comfy_execution.utils import get_executing_contextfrom comfy_execution.progress import get_progress_state, PreviewImageTuplefrom 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 = ImageInputAudio = AudioInput@@ -103,4 +120,5 @@ __all__ = ["Input","InputImpl","Types",+ "ComfyExtension",]diff --git a/comfy_api/latest/_io.py b/comfy_api/latest/_io.pynew file mode 100644index 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.pynew file mode 100644index 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 = ResourcesLocaldiff --git a/comfy_api/latest/_ui.py b/comfy_api/latest/_ui.pynew file mode 100644index 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 = PreviewTextdiff --git a/comfy_api/v0_0_2/__init__.py b/comfy_api/v0_0_2/__init__.pyindex 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_CHECKINGfrom comfy_api.internal.async_to_sync import create_sync_class+from comfy_api.latest import io, ui, ComfyExtension #noqa: F401class 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.pyindex 60e2ab91e..f4b427265 100644--- a/comfy_execution/graph.py+++ b/comfy_execution/graph.py@@ -4,9 +4,12 @@ from typing import Type, Literalimport nodesimport asyncioimport inspect-from comfy_execution.graph_utils import is_link+from comfy_execution.graph_utils import is_link, ExecutionBlockerfrom 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.pyindex 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 = messagediff --git a/execution.py b/execution.pyindex cde14c52f..952f0cc5c 100644--- a/execution.py+++ b/execution.py@@ -32,6 +32,8 @@ from comfy_execution.graph_utils import GraphBuilder, is_linkfrom comfy_execution.validation import validate_node_inputfrom comfy_execution.progress import get_progress_state, reset_progress_state, add_progress_handler, WebUIProgressHandlerfrom comfy_execution.utils import CurrentNodeContext+from comfy_api.internal import _ComfyNodeInternal, _NodeOutputInternal, first_real_override, is_class, make_locked_method_func+from comfy_api.latest import ioclass 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] = Falsereturn 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, eelif 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_v3map_node_over_list = None #Don't hook this please@@ -184,7 +214,7 @@ async def resolve_map_node_over_list_results(results):raise excreturn [x.result() if isinstance(x, asyncio.Task) else x for x in results]-async def _async_map_node_over_list(prompt_id, unique_id, obj, input_data_all, func, allow_interrupt=False, execution_block_cb=None, pre_execute_cb=None):+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 listsinput_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, fif 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 = Falseelse: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_idserver.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_dataunblock = 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.argsvalidate_has_kwargs = argspec.varkw is not Nonereceived_types = {}@@ -848,7 +923,7 @@ async def validate_inputs(prompt_id, prompt, item, validated):continueif 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.pyindex 54e530388..da4a46366 100644--- a/nodes.py+++ b/nodes.py@@ -6,6 +6,7 @@ import osimport sysimport jsonimport hashlib+import inspectimport tracebackimport mathimport time@@ -29,6 +30,7 @@ import comfy.controlnetfrom comfy.comfy_types import IO, ComfyNodeABC, InputTypeDict, FileLocatorfrom comfy_api.internal import register_versions, ComfyAPIWithVersionfrom comfy_api.version_list import supported_versions+from comfy_api.latest import io, ComfyExtensionimport comfy.clip_vision@@ -2152,6 +2154,7 @@ async def load_custom_node(module_path: str, ignore=set(), module_parent="customif os.path.isdir(web_dir):EXTENSION_WEB_DIRS[module_name] = web_dir+ # V1 node definitionif 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="customif 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 Falseelse:- 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 Falseexcept 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.pyindex 3e06d2fbb..0553a0dd7 100644--- a/server.py+++ b/server.py@@ -30,6 +30,7 @@ from comfy_api import feature_flagsimport node_helpersfrom comfyui_version import __version__from app.frontend_management import FrontendManager+from comfy_api.internal import _ComfyNodeInternalfrom app.user_manager import UserManagerfrom 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()}