The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
Support for async node functions (#8830)
guill2b653e8c18f1
diff --git a/comfy/utils.py b/comfy/utils.pyindex 47981d8f6..f8e01f713 100644--- a/comfy/utils.py+++ b/comfy/utils.py@@ -998,11 +998,12 @@ def set_progress_bar_global_hook(function):PROGRESS_BAR_HOOK = functionclass ProgressBar:- def __init__(self, total):+ def __init__(self, total, node_id=None):global PROGRESS_BAR_HOOKself.total = totalself.current = 0self.hook = PROGRESS_BAR_HOOK+ self.node_id = node_iddef update_absolute(self, value, total=None, preview=None):if total is not None:@@ -1011,7 +1012,7 @@ class ProgressBar:value = self.totalself.current = valueif self.hook is not None:- self.hook(self.current, self.total, preview)+ self.hook(self.current, self.total, preview, node_id=self.node_id)def update(self, value):self.update_absolute(self.current + value)diff --git a/comfy_api/feature_flags.py b/comfy_api/feature_flags.pynew file mode 100644index 000000000..0d4389a6e--- /dev/null+++ b/comfy_api/feature_flags.py@@ -0,0 +1,69 @@+"""+Feature flags module for ComfyUI WebSocket protocol negotiation.++This module handles capability negotiation between frontend and backend,+allowing graceful protocol evolution while maintaining backward compatibility.+"""++from typing import Any, Dict++from comfy.cli_args import args++# Default server capabilities+SERVER_FEATURE_FLAGS: Dict[str, Any] = {+ "supports_preview_metadata": True,+ "max_upload_size": args.max_upload_size * 1024 * 1024, # Convert MB to bytes+}+++def get_connection_feature(+ sockets_metadata: Dict[str, Dict[str, Any]],+ sid: str,+ feature_name: str,+ default: Any = False+) -> Any:+ """+ Get a feature flag value for a specific connection.++ Args:+ sockets_metadata: Dictionary of socket metadata+ sid: Session ID of the connection+ feature_name: Name of the feature to check+ default: Default value if feature not found++ Returns:+ Feature value or default if not found+ """+ if sid not in sockets_metadata:+ return default++ return sockets_metadata[sid].get("feature_flags", {}).get(feature_name, default)+++def supports_feature(+ sockets_metadata: Dict[str, Dict[str, Any]],+ sid: str,+ feature_name: str+) -> bool:+ """+ Check if a connection supports a specific feature.++ Args:+ sockets_metadata: Dictionary of socket metadata+ sid: Session ID of the connection+ feature_name: Name of the feature to check++ Returns:+ Boolean indicating if feature is supported+ """+ return get_connection_feature(sockets_metadata, sid, feature_name, False) is True+++def get_server_features() -> Dict[str, Any]:+ """+ Get the server's feature flags.++ Returns:+ Dictionary of server feature flags+ """+ return SERVER_FEATURE_FLAGS.copy()diff --git a/comfy_execution/caching.py b/comfy_execution/caching.pyindex dbb37b89f..41224ce3b 100644--- a/comfy_execution/caching.py+++ b/comfy_execution/caching.py@@ -1,6 +1,7 @@import itertoolsfrom typing import Sequence, Mapping, Dictfrom comfy_execution.graph import DynamicPrompt+from abc import ABC, abstractmethodimport nodes@@ -16,12 +17,13 @@ def include_unique_id_in_input(class_type: str) -> bool:NODE_CLASS_CONTAINS_UNIQUE_ID[class_type] = "UNIQUE_ID" in class_def.INPUT_TYPES().get("hidden", {}).values()return NODE_CLASS_CONTAINS_UNIQUE_ID[class_type]-class CacheKeySet:+class CacheKeySet(ABC):def __init__(self, dynprompt, node_ids, is_changed_cache):self.keys = {}self.subcache_keys = {}- def add_keys(self, node_ids):+ @abstractmethod+ async def add_keys(self, node_ids):raise NotImplementedError()def all_node_ids(self):@@ -60,9 +62,8 @@ class CacheKeySetID(CacheKeySet):def __init__(self, dynprompt, node_ids, is_changed_cache):super().__init__(dynprompt, node_ids, is_changed_cache)self.dynprompt = dynprompt- self.add_keys(node_ids)- def add_keys(self, node_ids):+ async def add_keys(self, node_ids):for node_id in node_ids:if node_id in self.keys:continue@@ -77,37 +78,36 @@ class CacheKeySetInputSignature(CacheKeySet):super().__init__(dynprompt, node_ids, is_changed_cache)self.dynprompt = dynpromptself.is_changed_cache = is_changed_cache- self.add_keys(node_ids)def include_node_id_in_input(self) -> bool:return False- def add_keys(self, node_ids):+ async def add_keys(self, node_ids):for node_id in node_ids:if node_id in self.keys:continueif not self.dynprompt.has_node(node_id):continuenode = self.dynprompt.get_node(node_id)- self.keys[node_id] = self.get_node_signature(self.dynprompt, node_id)+ self.keys[node_id] = await self.get_node_signature(self.dynprompt, node_id)self.subcache_keys[node_id] = (node_id, node["class_type"])- def get_node_signature(self, dynprompt, node_id):+ async def get_node_signature(self, dynprompt, node_id):signature = []ancestors, order_mapping = self.get_ordered_ancestry(dynprompt, node_id)- signature.append(self.get_immediate_node_signature(dynprompt, node_id, order_mapping))+ signature.append(await self.get_immediate_node_signature(dynprompt, node_id, order_mapping))for ancestor_id in ancestors:- signature.append(self.get_immediate_node_signature(dynprompt, ancestor_id, order_mapping))+ signature.append(await self.get_immediate_node_signature(dynprompt, ancestor_id, order_mapping))return to_hashable(signature)- def get_immediate_node_signature(self, dynprompt, node_id, ancestor_order_mapping):+ async def get_immediate_node_signature(self, dynprompt, node_id, ancestor_order_mapping):if not dynprompt.has_node(node_id):# This node doesn't exist -- we can't cache it.return [float("NaN")]node = dynprompt.get_node(node_id)class_type = node["class_type"]class_def = nodes.NODE_CLASS_MAPPINGS[class_type]- signature = [class_type, self.is_changed_cache.get(node_id)]+ signature = [class_type, await self.is_changed_cache.get(node_id)]if self.include_node_id_in_input() or (hasattr(class_def, "NOT_IDEMPOTENT") and class_def.NOT_IDEMPOTENT) or include_unique_id_in_input(class_type):signature.append(node_id)inputs = node["inputs"]@@ -150,9 +150,10 @@ class BasicCache:self.cache = {}self.subcaches = {}- def set_prompt(self, dynprompt, node_ids, is_changed_cache):+ async def set_prompt(self, dynprompt, node_ids, is_changed_cache):self.dynprompt = dynpromptself.cache_key_set = self.key_class(dynprompt, node_ids, is_changed_cache)+ await self.cache_key_set.add_keys(node_ids)self.is_changed_cache = is_changed_cacheself.initialized = True@@ -201,13 +202,13 @@ class BasicCache:else:return None- def _ensure_subcache(self, node_id, children_ids):+ async def _ensure_subcache(self, node_id, children_ids):subcache_key = self.cache_key_set.get_subcache_key(node_id)subcache = self.subcaches.get(subcache_key, None)if subcache is None:subcache = BasicCache(self.key_class)self.subcaches[subcache_key] = subcache- subcache.set_prompt(self.dynprompt, children_ids, self.is_changed_cache)+ await subcache.set_prompt(self.dynprompt, children_ids, self.is_changed_cache)return subcachedef _get_subcache(self, node_id):@@ -259,10 +260,10 @@ class HierarchicalCache(BasicCache):assert cache is not Nonecache._set_immediate(node_id, value)- def ensure_subcache_for(self, node_id, children_ids):+ async def ensure_subcache_for(self, node_id, children_ids):cache = self._get_cache_for(node_id)assert cache is not None- return cache._ensure_subcache(node_id, children_ids)+ return await cache._ensure_subcache(node_id, children_ids)class LRUCache(BasicCache):def __init__(self, key_class, max_size=100):@@ -273,8 +274,8 @@ class LRUCache(BasicCache):self.used_generation = {}self.children = {}- def set_prompt(self, dynprompt, node_ids, is_changed_cache):- super().set_prompt(dynprompt, node_ids, is_changed_cache)+ async def set_prompt(self, dynprompt, node_ids, is_changed_cache):+ await super().set_prompt(dynprompt, node_ids, is_changed_cache)self.generation += 1for node_id in node_ids:self._mark_used(node_id)@@ -303,11 +304,11 @@ class LRUCache(BasicCache):self._mark_used(node_id)return self._set_immediate(node_id, value)- def ensure_subcache_for(self, node_id, children_ids):+ async def ensure_subcache_for(self, node_id, children_ids):# Just uses subcaches for tracking 'live' nodes- super()._ensure_subcache(node_id, children_ids)+ await super()._ensure_subcache(node_id, children_ids)- self.cache_key_set.add_keys(children_ids)+ await self.cache_key_set.add_keys(children_ids)self._mark_used(node_id)cache_key = self.cache_key_set.get_data_key(node_id)self.children[cache_key] = []@@ -337,7 +338,7 @@ class DependencyAwareCache(BasicCache):self.ancestors = {} # Maps node_id -> set of ancestor node_idsself.executed_nodes = set() # Tracks nodes that have been executed- def set_prompt(self, dynprompt, node_ids, is_changed_cache):+ async def set_prompt(self, dynprompt, node_ids, is_changed_cache):"""Clear the entire cache and rebuild the dependency graph.@@ -354,7 +355,7 @@ class DependencyAwareCache(BasicCache):self.executed_nodes.clear()# Call the parent method to initialize the cache with the new prompt- super().set_prompt(dynprompt, node_ids, is_changed_cache)+ await super().set_prompt(dynprompt, node_ids, is_changed_cache)# Rebuild the dependency graphself._build_dependency_graph(dynprompt, node_ids)@@ -405,7 +406,7 @@ class DependencyAwareCache(BasicCache):"""return self._get_immediate(node_id)- def ensure_subcache_for(self, node_id, children_ids):+ async def ensure_subcache_for(self, node_id, children_ids):"""Ensure a subcache exists for a node and update dependencies.@@ -416,7 +417,7 @@ class DependencyAwareCache(BasicCache):Returns:The subcache object for the node."""- subcache = super()._ensure_subcache(node_id, children_ids)+ subcache = await super()._ensure_subcache(node_id, children_ids)for child_id in children_ids:self.descendants[node_id].add(child_id)self.ancestors[child_id].add(node_id)diff --git a/comfy_execution/graph.py b/comfy_execution/graph.pyindex a2799b52e..c79243e1e 100644--- a/comfy_execution/graph.py+++ b/comfy_execution/graph.py@@ -2,6 +2,7 @@ from __future__ import annotationsfrom typing import Type, Literalimport nodes+import asynciofrom comfy_execution.graph_utils import is_linkfrom comfy.comfy_types.node_typing import ComfyNodeABC, InputTypeDict, InputTypeOptions@@ -100,6 +101,8 @@ class TopologicalSort:self.pendingNodes = {}self.blockCount = {} # Number of nodes this node is directly blocked byself.blocking = {} # Which nodes are blocked by this node+ self.externalBlocks = 0+ self.unblockedEvent = asyncio.Event()def get_input_info(self, unique_id, input_name):class_type = self.dynprompt.get_node(unique_id)["class_type"]@@ -153,6 +156,16 @@ class TopologicalSort:for link in links:self.add_strong_link(*link)+ def add_external_block(self, node_id):+ assert node_id in self.blockCount, "Can't add external block to a node that isn't pending"+ self.externalBlocks += 1+ self.blockCount[node_id] += 1+ def unblock():+ self.externalBlocks -= 1+ self.blockCount[node_id] -= 1+ self.unblockedEvent.set()+ return unblock+def is_cached(self, node_id):return False@@ -181,11 +194,16 @@ class ExecutionList(TopologicalSort):def is_cached(self, node_id):return self.output_cache.get(node_id) is not None- def stage_node_execution(self):+ async def stage_node_execution(self):assert self.staged_node_id is Noneif self.is_empty():return None, None, Noneavailable = self.get_ready_nodes()+ while len(available) == 0 and self.externalBlocks > 0:+ # Wait for an external block to be released+ await self.unblockedEvent.wait()+ self.unblockedEvent.clear()+ available = self.get_ready_nodes()if len(available) == 0:cycled_nodes = self.get_nodes_in_cycle()# Because cycles composed entirely of static nodes are caught during initial validation,diff --git a/comfy_execution/progress.py b/comfy_execution/progress.pynew file mode 100644index 000000000..5645b3e3c--- /dev/null+++ b/comfy_execution/progress.py@@ -0,0 +1,347 @@+from typing import TypedDict, Dict, Optional+from typing_extensions import override+from PIL import Image+from enum import Enum+from abc import ABC+from tqdm import tqdm+from typing import TYPE_CHECKING+if TYPE_CHECKING:+ from comfy_execution.graph import DynamicPrompt+from protocol import BinaryEventTypes+from comfy_api import feature_flags+++class NodeState(Enum):+ Pending = "pending"+ Running = "running"+ Finished = "finished"+ Error = "error"+++class NodeProgressState(TypedDict):+ """+ A class to represent the state of a node's progress.+ """++ state: NodeState+ value: float+ max: float+++class ProgressHandler(ABC):+ """+ Abstract base class for progress handlers.+ Progress handlers receive progress updates and display them in various ways.+ """++ def __init__(self, name: str):+ self.name = name+ self.enabled = True++ def set_registry(self, registry: "ProgressRegistry"):+ pass++ def start_handler(self, node_id: str, state: NodeProgressState, prompt_id: str):+ """Called when a node starts processing"""+ pass++ def update_handler(+ self,+ node_id: str,+ value: float,+ max_value: float,+ state: NodeProgressState,+ prompt_id: str,+ image: Optional[Image.Image] = None,+ ):+ """Called when a node's progress is updated"""+ pass++ def finish_handler(self, node_id: str, state: NodeProgressState, prompt_id: str):+ """Called when a node finishes processing"""+ pass++ def reset(self):+ """Called when the progress registry is reset"""+ pass++ def enable(self):+ """Enable this handler"""+ self.enabled = True++ def disable(self):+ """Disable this handler"""+ self.enabled = False+++class CLIProgressHandler(ProgressHandler):+ """+ Handler that displays progress using tqdm progress bars in the CLI.+ """++ def __init__(self):+ super().__init__("cli")+ self.progress_bars: Dict[str, tqdm] = {}++ @override+ def start_handler(self, node_id: str, state: NodeProgressState, prompt_id: str):+ # Create a new tqdm progress bar+ if node_id not in self.progress_bars:+ self.progress_bars[node_id] = tqdm(+ total=state["max"],+ desc=f"Node {node_id}",+ unit="steps",+ leave=True,+ position=len(self.progress_bars),+ )++ @override+ def update_handler(+ self,+ node_id: str,+ value: float,+ max_value: float,+ state: NodeProgressState,+ prompt_id: str,+ image: Optional[Image.Image] = None,+ ):+ # Handle case where start_handler wasn't called+ if node_id not in self.progress_bars:+ self.progress_bars[node_id] = tqdm(+ total=max_value,+ desc=f"Node {node_id}",+ unit="steps",+ leave=True,+ position=len(self.progress_bars),+ )+ self.progress_bars[node_id].update(value)+ else:+ # Update existing progress bar+ if max_value != self.progress_bars[node_id].total:+ self.progress_bars[node_id].total = max_value+ # Calculate the update amount (difference from current position)+ current_position = self.progress_bars[node_id].n+ update_amount = value - current_position+ if update_amount > 0:+ self.progress_bars[node_id].update(update_amount)++ @override+ def finish_handler(self, node_id: str, state: NodeProgressState, prompt_id: str):+ # Complete and close the progress bar if it exists+ if node_id in self.progress_bars:+ # Ensure the bar shows 100% completion+ remaining = state["max"] - self.progress_bars[node_id].n+ if remaining > 0:+ self.progress_bars[node_id].update(remaining)+ self.progress_bars[node_id].close()+ del self.progress_bars[node_id]++ @override+ def reset(self):+ # Close all progress bars+ for bar in self.progress_bars.values():+ bar.close()+ self.progress_bars.clear()+++class WebUIProgressHandler(ProgressHandler):+ """+ Handler that sends progress updates to the WebUI via WebSockets.+ """++ def __init__(self, server_instance):+ super().__init__("webui")+ self.server_instance = server_instance++ def set_registry(self, registry: "ProgressRegistry"):+ self.registry = registry++ def _send_progress_state(self, prompt_id: str, nodes: Dict[str, NodeProgressState]):+ """Send the current progress state to the client"""+ if self.server_instance is None:+ return++ # Only send info for non-pending nodes+ active_nodes = {+ node_id: {+ "value": state["value"],+ "max": state["max"],+ "state": state["state"].value,+ "node_id": node_id,+ "prompt_id": prompt_id,+ "display_node_id": self.registry.dynprompt.get_display_node_id(node_id),+ "parent_node_id": self.registry.dynprompt.get_parent_node_id(node_id),+ "real_node_id": self.registry.dynprompt.get_real_node_id(node_id),+ }+ for node_id, state in nodes.items()+ if state["state"] != NodeState.Pending+ }++ # Send a combined progress_state message with all node states+ self.server_instance.send_sync(+ "progress_state", {"prompt_id": prompt_id, "nodes": active_nodes}+ )++ @override+ def start_handler(self, node_id: str, state: NodeProgressState, prompt_id: str):+ # Send progress state of all nodes+ if self.registry:+ self._send_progress_state(prompt_id, self.registry.nodes)++ @override+ def update_handler(+ self,+ node_id: str,+ value: float,+ max_value: float,+ state: NodeProgressState,+ prompt_id: str,+ image: Optional[Image.Image] = None,+ ):+ # Send progress state of all nodes+ if self.registry:+ self._send_progress_state(prompt_id, self.registry.nodes)+ if image:+ # Only send new format if client supports it+ if feature_flags.supports_feature(+ self.server_instance.sockets_metadata,+ self.server_instance.client_id,+ "supports_preview_metadata",+ ):+ metadata = {+ "node_id": node_id,+ "prompt_id": prompt_id,+ "display_node_id": self.registry.dynprompt.get_display_node_id(+ node_id+ ),+ "parent_node_id": self.registry.dynprompt.get_parent_node_id(+ node_id+ ),+ "real_node_id": self.registry.dynprompt.get_real_node_id(node_id),+ }+ self.server_instance.send_sync(+ BinaryEventTypes.PREVIEW_IMAGE_WITH_METADATA,+ (image, metadata),+ self.server_instance.client_id,+ )++ @override+ def finish_handler(self, node_id: str, state: NodeProgressState, prompt_id: str):+ # Send progress state of all nodes+ if self.registry:+ self._send_progress_state(prompt_id, self.registry.nodes)+++class ProgressRegistry:+ """+ Registry that maintains node progress state and notifies registered handlers.+ """++ def __init__(self, prompt_id: str, dynprompt: "DynamicPrompt"):+ self.prompt_id = prompt_id+ self.dynprompt = dynprompt+ self.nodes: Dict[str, NodeProgressState] = {}+ self.handlers: Dict[str, ProgressHandler] = {}++ def register_handler(self, handler: ProgressHandler) -> None:+ """Register a progress handler"""+ self.handlers[handler.name] = handler++ def unregister_handler(self, handler_name: str) -> None:+ """Unregister a progress handler"""+ if handler_name in self.handlers:+ # Allow handler to clean up resources+ self.handlers[handler_name].reset()+ del self.handlers[handler_name]++ def enable_handler(self, handler_name: str) -> None:+ """Enable a progress handler"""+ if handler_name in self.handlers:+ self.handlers[handler_name].enable()++ def disable_handler(self, handler_name: str) -> None:+ """Disable a progress handler"""+ if handler_name in self.handlers:+ self.handlers[handler_name].disable()++ def ensure_entry(self, node_id: str) -> NodeProgressState:+ """Ensure a node entry exists"""+ if node_id not in self.nodes:+ self.nodes[node_id] = NodeProgressState(+ state=NodeState.Pending, value=0, max=1+ )+ return self.nodes[node_id]++ def start_progress(self, node_id: str) -> None:+ """Start progress tracking for a node"""+ entry = self.ensure_entry(node_id)+ entry["state"] = NodeState.Running+ entry["value"] = 0.0+ entry["max"] = 1.0++ # Notify all enabled handlers+ for handler in self.handlers.values():+ if handler.enabled:+ handler.start_handler(node_id, entry, self.prompt_id)++ def update_progress(+ self, node_id: str, value: float, max_value: float, image: Optional[Image.Image]+ ) -> None:+ """Update progress for a node"""+ entry = self.ensure_entry(node_id)+ entry["state"] = NodeState.Running+ entry["value"] = value+ entry["max"] = max_value++ # Notify all enabled handlers+ for handler in self.handlers.values():+ if handler.enabled:+ handler.update_handler(+ node_id, value, max_value, entry, self.prompt_id, image+ )++ def finish_progress(self, node_id: str) -> None:+ """Finish progress tracking for a node"""+ entry = self.ensure_entry(node_id)+ entry["state"] = NodeState.Finished+ entry["value"] = entry["max"]++ # Notify all enabled handlers+ for handler in self.handlers.values():+ if handler.enabled:+ handler.finish_handler(node_id, entry, self.prompt_id)++ def reset_handlers(self) -> None:+ """Reset all handlers"""+ for handler in self.handlers.values():+ handler.reset()++# Global registry instance+global_progress_registry: ProgressRegistry | None = None++def reset_progress_state(prompt_id: str, dynprompt: "DynamicPrompt") -> None:+ global global_progress_registry++ # Reset existing handlers if registry exists+ if global_progress_registry is not None:+ global_progress_registry.reset_handlers()++ # Create new registry+ global_progress_registry = ProgressRegistry(prompt_id, dynprompt)+++def add_progress_handler(handler: ProgressHandler) -> None:+ registry = get_progress_state()+ handler.set_registry(registry)+ registry.register_handler(handler)+++def get_progress_state() -> ProgressRegistry:+ global global_progress_registry+ if global_progress_registry is None:+ from comfy_execution.graph import DynamicPrompt++ global_progress_registry = ProgressRegistry(+ prompt_id="", dynprompt=DynamicPrompt({})+ )+ return global_progress_registrydiff --git a/comfy_execution/utils.py b/comfy_execution/utils.pynew file mode 100644index 000000000..62d32f101--- /dev/null+++ b/comfy_execution/utils.py@@ -0,0 +1,46 @@+import contextvars+from typing import Optional, NamedTuple++class ExecutionContext(NamedTuple):+ """+ Context information about the currently executing node.++ Attributes:+ node_id: The ID of the currently executing node+ list_index: The index in a list being processed (for operations on batches/lists)+ """+ prompt_id: str+ node_id: str+ list_index: Optional[int]++current_executing_context: contextvars.ContextVar[Optional[ExecutionContext]] = contextvars.ContextVar("current_executing_context", default=None)++def get_executing_context() -> Optional[ExecutionContext]:+ return current_executing_context.get(None)++class CurrentNodeContext:+ """+ Context manager for setting the current executing node context.++ Sets the current_executing_context on enter and resets it on exit.++ Example:+ with CurrentNodeContext(node_id="123", list_index=0):+ # Code that should run with the current node context set+ process_image()+ """+ def __init__(self, prompt_id: str, node_id: str, list_index: Optional[int] = None):+ self.context = ExecutionContext(+ prompt_id= prompt_id,+ node_id= node_id,+ list_index= list_index+ )+ self.token = None++ def __enter__(self):+ self.token = current_executing_context.set(self.context)+ return self++ def __exit__(self, exc_type, exc_val, exc_tb):+ if self.token is not None:+ current_executing_context.reset(self.token)diff --git a/execution.py b/execution.pyindex f6006fa12..90cefc023 100644--- a/execution.py+++ b/execution.py@@ -8,12 +8,14 @@ import timeimport tracebackfrom enum import Enumfrom typing import List, Literal, NamedTuple, Optional+import asyncioimport torchimport comfy.model_managementimport nodesfrom comfy_execution.caching import (+ BasicCache,CacheKeySetID,CacheKeySetInputSignature,DependencyAwareCache,@@ -28,6 +30,8 @@ from comfy_execution.graph import ()from comfy_execution.graph_utils import GraphBuilder, is_linkfrom comfy_execution.validation import validate_node_input+from comfy_execution.progress import get_progress_state, reset_progress_state, add_progress_handler, WebUIProgressHandler+from comfy_execution.utils import CurrentNodeContextclass ExecutionResult(Enum):@@ -39,12 +43,13 @@ class DuplicateNodeError(Exception):passclass IsChangedCache:- def __init__(self, dynprompt, outputs_cache):+ def __init__(self, prompt_id: str, dynprompt: DynamicPrompt, outputs_cache: BasicCache):+ self.prompt_id = prompt_idself.dynprompt = dynpromptself.outputs_cache = outputs_cacheself.is_changed = {}- def get(self, node_id):+ async def get(self, node_id):if node_id in self.is_changed:return self.is_changed[node_id]@@ -62,7 +67,8 @@ class IsChangedCache:# Intentionally do not use cached outputs here. We only want constants in IS_CHANGEDinput_data_all, _ = get_input_data(node["inputs"], class_def, node_id, None)try:- is_changed = _map_node_over_list(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")+ 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:logging.warning("WARNING: {}".format(e))@@ -164,7 +170,19 @@ def get_input_data(inputs, class_def, unique_id, outputs=None, dynprompt=None, emap_node_over_list = None #Don't hook this please-def _map_node_over_list(obj, input_data_all, func, allow_interrupt=False, execution_block_cb=None, pre_execute_cb=None):+async def resolve_map_node_over_list_results(results):+ remaining = [x for x in results if isinstance(x, asyncio.Task) and not x.done()]+ if len(remaining) == 0:+ return [x.result() if isinstance(x, asyncio.Task) else x for x in results]+ else:+ done, pending = await asyncio.wait(remaining)+ for task in done:+ exc = task.exception()+ if exc is not None:+ raise exc+ return [x.result() if isinstance(x, asyncio.Task) else x for x in results]++async def _async_map_node_over_list(prompt_id, unique_id, obj, input_data_all, func, allow_interrupt=False, execution_block_cb=None, pre_execute_cb=None):# check if node wants the listsinput_is_list = getattr(obj, "INPUT_IS_LIST", False)@@ -178,7 +196,7 @@ def _map_node_over_list(obj, input_data_all, func, allow_interrupt=False, executreturn {k: v[i if len(v) > i else -1] for k, v in d.items()}results = []- def process_inputs(inputs, index=None, input_is_list=False):+ async def process_inputs(inputs, index=None, input_is_list=False):if allow_interrupt:nodes.before_node_execution()execution_block = None@@ -194,20 +212,37 @@ def _map_node_over_list(obj, input_data_all, func, allow_interrupt=False, executif execution_block is None:if pre_execute_cb is not None and index is not None:pre_execute_cb(index)- results.append(getattr(obj, func)(**inputs))+ 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):+ return await f(**args)+ task = asyncio.create_task(async_wrapper(f, prompt_id, unique_id, index, args=inputs))+ # Give the task a chance to execute without yielding+ await asyncio.sleep(0)+ if task.done():+ result = task.result()+ results.append(result)+ else:+ results.append(task)+ else:+ with CurrentNodeContext(prompt_id, unique_id, index):+ result = f(**inputs)+ results.append(result)else:results.append(execution_block)if input_is_list:- process_inputs(input_data_all, 0, input_is_list=input_is_list)+ await process_inputs(input_data_all, 0, input_is_list=input_is_list)elif max_len_input == 0:- process_inputs({})+ await process_inputs({})else:for i in range(max_len_input):input_dict = slice_dict(input_data_all, i)- process_inputs(input_dict, i)+ await process_inputs(input_dict, i)return results+def merge_result_data(results, obj):# check which outputs need concatenatingoutput = []@@ -229,11 +264,18 @@ def merge_result_data(results, obj):output.append([o[i] for o in results])return output-def get_output_data(obj, input_data_all, execution_block_cb=None, pre_execute_cb=None):+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)+ 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+ output, ui, has_subgraph = get_output_from_returns(return_values, obj)+ return output, ui, has_subgraph, False++def get_output_from_returns(return_values, obj):results = []uis = []subgraph_results = []- return_values = _map_node_over_list(obj, input_data_all, obj.FUNCTION, allow_interrupt=True, execution_block_cb=execution_block_cb, pre_execute_cb=pre_execute_cb)has_subgraph = Falsefor i in range(len(return_values)):r = return_values[i]@@ -267,6 +309,10 @@ def get_output_data(obj, input_data_all, execution_block_cb=None, pre_execute_cbelse:output = []ui = dict()+ # TODO: Think there's an existing bug here+ # If we're performing a subgraph expansion, we probably shouldn't be returning UI values yet.+ # They'll get cached without the completed subgraphs. It's an edge case and I'm not aware of+ # any nodes that use both subgraph expansion and custom UI outputs, but might be a problem in the future.if len(uis) > 0:ui = {k: [y for x in uis for y in x[k]] for k in uis[0].keys()}return output, ui, has_subgraph@@ -279,7 +325,7 @@ def format_value(x):else:return str(x)-def execute(server, dynprompt, caches, current_item, extra_data, executed, prompt_id, execution_list, pending_subgraph_results):+async def execute(server, dynprompt, caches, current_item, extra_data, executed, prompt_id, execution_list, pending_subgraph_results, pending_async_nodes):unique_id = current_itemreal_node_id = dynprompt.get_real_node_id(unique_id)display_node_id = dynprompt.get_display_node_id(unique_id)@@ -291,11 +337,26 @@ def execute(server, dynprompt, caches, current_item, extra_data, executed, prompif server.client_id is not None:cached_output = caches.ui.get(unique_id) or {}server.send_sync("executed", { "node": unique_id, "display_node": display_node_id, "output": cached_output.get("output",None), "prompt_id": prompt_id }, server.client_id)+ get_progress_state().finish_progress(unique_id)return (ExecutionResult.SUCCESS, None, None)input_data_all = Nonetry:- if unique_id in pending_subgraph_results:+ if unique_id in pending_async_nodes:+ results = []+ for r in pending_async_nodes[unique_id]:+ if isinstance(r, asyncio.Task):+ try:+ results.append(r.result())+ except Exception as ex:+ # An async task failed - propagate the exception up+ del pending_async_nodes[unique_id]+ raise ex+ else:+ results.append(r)+ del pending_async_nodes[unique_id]+ output_data, output_ui, has_subgraph = get_output_from_returns(results, class_def)+ elif unique_id in pending_subgraph_results:cached_results = pending_subgraph_results[unique_id]resolved_outputs = []for is_subgraph, result in cached_results:@@ -317,6 +378,7 @@ def execute(server, dynprompt, caches, current_item, extra_data, executed, prompoutput_ui = []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)if server.client_id is not None:server.last_node_id = display_node_id@@ -328,7 +390,8 @@ def execute(server, dynprompt, caches, current_item, extra_data, executed, prompcaches.objects.set(unique_id, obj)if hasattr(obj, "check_lazy_status"):- required_inputs = _map_node_over_list(obj, input_data_all, "check_lazy_status", allow_interrupt=True)+ required_inputs = await _async_map_node_over_list(prompt_id, unique_id, obj, input_data_all, "check_lazy_status", allow_interrupt=True)+ 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 (x not in input_data_all or x in missing_keys@@ -357,8 +420,18 @@ def execute(server, dynprompt, caches, current_item, extra_data, executed, prompelse:return blockdef 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 = get_output_data(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)+ if has_pending_tasks:+ pending_async_nodes[unique_id] = output_data+ unblock = execution_list.add_external_block(unique_id)+ async def await_completion():+ tasks = [x for x in output_data if isinstance(x, asyncio.Task)]+ await asyncio.gather(*tasks, return_exceptions=True)+ unblock()+ asyncio.create_task(await_completion())+ return (ExecutionResult.PENDING, None, None)if len(output_ui) > 0:caches.ui.set(unique_id, {"meta": {@@ -401,7 +474,8 @@ def execute(server, dynprompt, caches, current_item, extra_data, executed, prompcached_outputs.append((True, node_outputs))new_node_ids = set(new_node_ids)for cache in caches.all:- cache.ensure_subcache_for(unique_id, new_node_ids).clean_unused()+ subcache = await cache.ensure_subcache_for(unique_id, new_node_ids)+ subcache.clean_unused()for node_id in new_output_ids:execution_list.add_node(node_id)for link in new_output_links:@@ -446,6 +520,7 @@ def execute(server, dynprompt, caches, current_item, extra_data, executed, prompreturn (ExecutionResult.FAILURE, error_details, ex)+ get_progress_state().finish_progress(unique_id)executed.add(unique_id)return (ExecutionResult.SUCCESS, None, None)@@ -500,6 +575,11 @@ class PromptExecutor:self.add_message("execution_error", mes, broadcast=False)def execute(self, prompt, prompt_id, extra_data={}, execute_outputs=[]):+ asyncio_loop = asyncio.new_event_loop()+ asyncio.set_event_loop(asyncio_loop)+ asyncio.run(self.execute_async(prompt, prompt_id, extra_data, execute_outputs))++ async def execute_async(self, prompt, prompt_id, extra_data={}, execute_outputs=[]):nodes.interrupt_processing(False)if "client_id" in extra_data:@@ -512,9 +592,11 @@ class PromptExecutor:with torch.inference_mode():dynamic_prompt = DynamicPrompt(prompt)- is_changed_cache = IsChangedCache(dynamic_prompt, self.caches.outputs)+ reset_progress_state(prompt_id, dynamic_prompt)+ add_progress_handler(WebUIProgressHandler(self.server))+ is_changed_cache = IsChangedCache(prompt_id, dynamic_prompt, self.caches.outputs)for cache in self.caches.all:- cache.set_prompt(dynamic_prompt, prompt.keys(), is_changed_cache)+ await cache.set_prompt(dynamic_prompt, prompt.keys(), is_changed_cache)cache.clean_unused()cached_nodes = []@@ -527,6 +609,7 @@ class PromptExecutor:{ "nodes": cached_nodes, "prompt_id": prompt_id},broadcast=False)pending_subgraph_results = {}+ pending_async_nodes = {} # TODO - Unify this with pending_subgraph_resultsexecuted = set()execution_list = ExecutionList(dynamic_prompt, self.caches.outputs)current_outputs = self.caches.outputs.all_node_ids()@@ -534,12 +617,13 @@ class PromptExecutor:execution_list.add_node(node_id)while not execution_list.is_empty():- node_id, error, ex = execution_list.stage_node_execution()+ node_id, error, ex = await execution_list.stage_node_execution()if error is not None:self.handle_execution_error(prompt_id, dynamic_prompt.original_prompt, current_outputs, executed, error, ex)break- result, error, ex = execute(self.server, dynamic_prompt, self.caches, node_id, extra_data, executed, prompt_id, execution_list, pending_subgraph_results)+ assert node_id is not None, "Node ID should not be None at this point"+ result, error, ex = await execute(self.server, dynamic_prompt, self.caches, node_id, extra_data, executed, prompt_id, execution_list, pending_subgraph_results, pending_async_nodes)self.success = result != ExecutionResult.FAILUREif result == ExecutionResult.FAILURE:self.handle_execution_error(prompt_id, dynamic_prompt.original_prompt, current_outputs, executed, error, ex)@@ -569,7 +653,7 @@ class PromptExecutor:comfy.model_management.unload_all_models()-def validate_inputs(prompt, item, validated):+async def validate_inputs(prompt_id, prompt, item, validated):unique_id = itemif unique_id in validated:return validated[unique_id]@@ -646,7 +730,7 @@ def validate_inputs(prompt, item, validated):errors.append(error)continuetry:- r = validate_inputs(prompt, o_id, validated)+ r = await validate_inputs(prompt_id, prompt, o_id, validated)if r[0] is False:# `r` will be set in `validated[o_id]` alreadyvalid = False@@ -771,7 +855,8 @@ def validate_inputs(prompt, item, validated):input_filtered['input_types'] = [received_types]#ret = obj_class.VALIDATE_INPUTS(**input_filtered)- ret = _map_node_over_list(obj_class, input_filtered, "VALIDATE_INPUTS")+ ret = await _async_map_node_over_list(prompt_id, unique_id, obj_class, input_filtered, "VALIDATE_INPUTS")+ ret = await resolve_map_node_over_list_results(ret)for x in input_filtered:for i, r in enumerate(ret):if r is not True and not isinstance(r, ExecutionBlocker):@@ -804,7 +889,7 @@ def full_type_name(klass):return klass.__qualname__return module + '.' + klass.__qualname__-def validate_prompt(prompt):+async def validate_prompt(prompt_id, prompt):outputs = set()for x in prompt:if 'class_type' not in prompt[x]:@@ -847,7 +932,7 @@ def validate_prompt(prompt):valid = Falsereasons = []try:- m = validate_inputs(prompt, o, validated)+ m = await validate_inputs(prompt_id, prompt, o, validated)valid = m[0]reasons = m[1]except Exception as ex:diff --git a/main.py b/main.pyindex 0b1987ef4..2b4ffafd4 100644--- a/main.py+++ b/main.py@@ -11,6 +11,9 @@ import itertoolsimport utils.extra_configimport loggingimport sys+from comfy_execution.progress import get_progress_state+from comfy_execution.utils import get_executing_context+from comfy_api import feature_flagsif __name__ == "__main__":#NOTE: These do not do anything on core ComfyUI, they are for custom nodes.@@ -134,7 +137,7 @@ import comfy.utilsimport executionimport server-from server import BinaryEventTypes+from protocol import BinaryEventTypesimport nodesimport comfy.model_managementimport comfyui_version@@ -230,15 +233,34 @@ async def run(server_instance, address='', port=8188, verbose=True, call_on_starserver_instance.start_multi_address(addresses, call_on_start, verbose), server_instance.publish_loop())-def hijack_progress(server_instance):- def hook(value, total, preview_image):+ def hook(value, total, preview_image, prompt_id=None, node_id=None):+ executing_context = get_executing_context()+ if prompt_id is None and executing_context is not None:+ prompt_id = executing_context.prompt_id+ if node_id is None and executing_context is not None:+ node_id = executing_context.node_idcomfy.model_management.throw_exception_if_processing_interrupted()- progress = {"value": value, "max": total, "prompt_id": server_instance.last_prompt_id, "node": server_instance.last_node_id}+ if prompt_id is None:+ prompt_id = server_instance.last_prompt_id+ if node_id is None:+ node_id = server_instance.last_node_id+ progress = {"value": value, "max": total, "prompt_id": prompt_id, "node": node_id}+ get_progress_state().update_progress(node_id, value, total, preview_image)server_instance.send_sync("progress", progress, server_instance.client_id)if preview_image is not None:- server_instance.send_sync(BinaryEventTypes.UNENCODED_PREVIEW_IMAGE, preview_image, server_instance.client_id)+ # Only send old method if client doesn't support preview metadata+ if not feature_flags.supports_feature(+ server_instance.sockets_metadata,+ server_instance.client_id,+ "supports_preview_metadata",+ ):+ server_instance.send_sync(+ BinaryEventTypes.UNENCODED_PREVIEW_IMAGE,+ preview_image,+ server_instance.client_id,+ )comfy.utils.set_progress_bar_global_hook(hook)diff --git a/protocol.py b/protocol.pynew file mode 100644index 000000000..038a0a840--- /dev/null+++ b/protocol.py@@ -0,0 +1,7 @@++class BinaryEventTypes:+ PREVIEW_IMAGE = 1+ UNENCODED_PREVIEW_IMAGE = 2+ TEXT = 3+ PREVIEW_IMAGE_WITH_METADATA = 4+diff --git a/server.py b/server.pyindex 878b5eeb1..e8bad9f4e 100644--- a/server.py+++ b/server.py@@ -26,6 +26,7 @@ import mimetypesfrom comfy.cli_args import argsimport comfy.utilsimport comfy.model_management+from comfy_api import feature_flagsimport node_helpersfrom comfyui_version import __version__from app.frontend_management import FrontendManager@@ -35,11 +36,7 @@ from app.model_manager import ModelFileManagerfrom app.custom_node_manager import CustomNodeManagerfrom typing import Optional, Unionfrom api_server.routes.internal.internal_routes import InternalRoutes--class BinaryEventTypes:- PREVIEW_IMAGE = 1- UNENCODED_PREVIEW_IMAGE = 2- TEXT = 3+from protocol import BinaryEventTypesasync def send_socket_catch_exception(function, message):try:@@ -178,6 +175,7 @@ class PromptServer():max_upload_size = round(args.max_upload_size * 1024 * 1024)self.app = web.Application(client_max_size=max_upload_size, middlewares=middlewares)self.sockets = dict()+ self.sockets_metadata = dict()self.web_root = (FrontendManager.init_frontend(args.front_end_version)if args.front_end_root is None@@ -202,20 +200,53 @@ class PromptServer():else:sid = uuid.uuid4().hex+ # Store WebSocket for backward compatibilityself.sockets[sid] = ws+ # Store metadata separately+ self.sockets_metadata[sid] = {"feature_flags": {}}try:# Send initial state to the new client- await self.send("status", { "status": self.get_queue_info(), 'sid': sid }, sid)+ await self.send("status", {"status": self.get_queue_info(), "sid": sid}, sid)# On reconnect if we are the currently executing client send the current nodeif self.client_id == sid and self.last_node_id is not None:await self.send("executing", { "node": self.last_node_id }, sid)+ # Flag to track if we've received the first message+ first_message = True+async for msg in ws:if msg.type == aiohttp.WSMsgType.ERROR:logging.warning('ws connection closed with exception %s' % ws.exception())+ elif msg.type == aiohttp.WSMsgType.TEXT:+ try:+ data = json.loads(msg.data)+ # Check if first message is feature flags+ if first_message and data.get("type") == "feature_flags":+ # Store client feature flags+ client_flags = data.get("data", {})+ self.sockets_metadata[sid]["feature_flags"] = client_flags++ # Send server feature flags in response+ await self.send(+ "feature_flags",+ feature_flags.get_server_features(),+ sid,+ )++ logging.info(+ f"Feature flags negotiated for client {sid}: {client_flags}"+ )+ first_message = False+ except json.JSONDecodeError:+ logging.warning(+ f"Invalid JSON received from client {sid}: {msg.data}"+ )+ except Exception as e:+ logging.error(f"Error processing WebSocket message: {e}")finally:self.sockets.pop(sid, None)+ self.sockets_metadata.pop(sid, None)return ws@routes.get("/")@@ -548,6 +579,10 @@ class PromptServer():}return web.json_response(system_stats)+ @routes.get("/features")+ async def get_features(request):+ return web.json_response(feature_flags.get_server_features())+@routes.get("/prompt")async def get_prompt(request):return web.json_response(self.get_queue_info())@@ -643,7 +678,8 @@ class PromptServer():if "prompt" in json_data:prompt = json_data["prompt"]- valid = execution.validate_prompt(prompt)+ prompt_id = str(uuid.uuid4())+ valid = await execution.validate_prompt(prompt_id, prompt)extra_data = {}if "extra_data" in json_data:extra_data = json_data["extra_data"]@@ -651,7 +687,6 @@ class PromptServer():if "client_id" in json_data:extra_data["client_id"] = json_data["client_id"]if valid[0]:- prompt_id = str(uuid.uuid4())outputs_to_execute = valid[2]self.prompt_queue.put((number, prompt_id, prompt, extra_data, outputs_to_execute))response = {"prompt_id": prompt_id, "number": number, "node_errors": valid[3]}@@ -766,6 +801,10 @@ class PromptServer():async def send(self, event, data, sid=None):if event == BinaryEventTypes.UNENCODED_PREVIEW_IMAGE:await self.send_image(data, sid=sid)+ elif event == BinaryEventTypes.PREVIEW_IMAGE_WITH_METADATA:+ # data is (preview_image, metadata)+ preview_image, metadata = data+ await self.send_image_with_metadata(preview_image, metadata, sid=sid)elif isinstance(data, (bytes, bytearray)):await self.send_bytes(event, data, sid)else:@@ -804,6 +843,43 @@ class PromptServer():preview_bytes = bytesIO.getvalue()await self.send_bytes(BinaryEventTypes.PREVIEW_IMAGE, preview_bytes, sid=sid)+ async def send_image_with_metadata(self, image_data, metadata=None, sid=None):+ image_type = image_data[0]+ image = image_data[1]+ max_size = image_data[2]+ if max_size is not None:+ if hasattr(Image, 'Resampling'):+ resampling = Image.Resampling.BILINEAR+ else:+ resampling = Image.Resampling.LANCZOS++ image = ImageOps.contain(image, (max_size, max_size), resampling)++ mimetype = "image/png" if image_type == "PNG" else "image/jpeg"++ # Prepare metadata+ if metadata is None:+ metadata = {}+ metadata["image_type"] = mimetype++ # Serialize metadata as JSON+ import json+ metadata_json = json.dumps(metadata).encode('utf-8')+ metadata_length = len(metadata_json)++ # Prepare image data+ bytesIO = BytesIO()+ image.save(bytesIO, format=image_type, quality=95, compress_level=1)+ image_bytes = bytesIO.getvalue()++ # Combine metadata and image+ combined_data = bytearray()+ combined_data.extend(struct.pack(">I", metadata_length))+ combined_data.extend(metadata_json)+ combined_data.extend(image_bytes)++ await self.send_bytes(BinaryEventTypes.PREVIEW_IMAGE_WITH_METADATA, combined_data, sid=sid)+async def send_bytes(self, event, data, sid=None):message = self.encode_bytes(event, data)@@ -845,10 +921,10 @@ class PromptServer():ssl_ctx = Nonescheme = "http"if args.tls_keyfile and args.tls_certfile:- ssl_ctx = ssl.SSLContext(protocol=ssl.PROTOCOL_TLS_SERVER, verify_mode=ssl.CERT_NONE)- ssl_ctx.load_cert_chain(certfile=args.tls_certfile,+ ssl_ctx = ssl.SSLContext(protocol=ssl.PROTOCOL_TLS_SERVER, verify_mode=ssl.CERT_NONE)+ ssl_ctx.load_cert_chain(certfile=args.tls_certfile,keyfile=args.tls_keyfile)- scheme = "https"+ scheme = "https"if verbose:logging.info("Starting server\n")diff --git a/tests-unit/feature_flags_test.py b/tests-unit/feature_flags_test.pynew file mode 100644index 000000000..f2702cfc8--- /dev/null+++ b/tests-unit/feature_flags_test.py@@ -0,0 +1,98 @@+"""Tests for feature flags functionality."""++from comfy_api.feature_flags import (+ get_connection_feature,+ supports_feature,+ get_server_features,+ SERVER_FEATURE_FLAGS,+)+++class TestFeatureFlags:+ """Test suite for feature flags functions."""++ def test_get_server_features_returns_copy(self):+ """Test that get_server_features returns a copy of the server flags."""+ features = get_server_features()+ # Verify it's a copy by modifying it+ features["test_flag"] = True+ # Original should be unchanged+ assert "test_flag" not in SERVER_FEATURE_FLAGS++ def test_get_server_features_contains_expected_flags(self):+ """Test that server features contain expected flags."""+ features = get_server_features()+ assert "supports_preview_metadata" in features+ assert features["supports_preview_metadata"] is True+ assert "max_upload_size" in features+ assert isinstance(features["max_upload_size"], (int, float))++ def test_get_connection_feature_with_missing_sid(self):+ """Test getting feature for non-existent session ID."""+ sockets_metadata = {}+ result = get_connection_feature(sockets_metadata, "missing_sid", "some_feature")+ assert result is False # Default value++ def test_get_connection_feature_with_custom_default(self):+ """Test getting feature with custom default value."""+ sockets_metadata = {}+ result = get_connection_feature(+ sockets_metadata, "missing_sid", "some_feature", default="custom_default"+ )+ assert result == "custom_default"++ def test_get_connection_feature_with_feature_flags(self):+ """Test getting feature from connection with feature flags."""+ sockets_metadata = {+ "sid1": {+ "feature_flags": {+ "supports_preview_metadata": True,+ "custom_feature": "value",+ },+ }+ }+ result = get_connection_feature(sockets_metadata, "sid1", "supports_preview_metadata")+ assert result is True++ result = get_connection_feature(sockets_metadata, "sid1", "custom_feature")+ assert result == "value"++ def test_get_connection_feature_missing_feature(self):+ """Test getting non-existent feature from connection."""+ sockets_metadata = {+ "sid1": {"feature_flags": {"existing_feature": True}}+ }+ result = get_connection_feature(sockets_metadata, "sid1", "missing_feature")+ assert result is False++ def test_supports_feature_returns_boolean(self):+ """Test that supports_feature always returns boolean."""+ sockets_metadata = {+ "sid1": {+ "feature_flags": {+ "bool_feature": True,+ "string_feature": "value",+ "none_feature": None,+ },+ }+ }++ # True boolean feature+ assert supports_feature(sockets_metadata, "sid1", "bool_feature") is True++ # Non-boolean values should return False+ assert supports_feature(sockets_metadata, "sid1", "string_feature") is False+ assert supports_feature(sockets_metadata, "sid1", "none_feature") is False+ assert supports_feature(sockets_metadata, "sid1", "missing_feature") is False++ def test_supports_feature_with_missing_connection(self):+ """Test supports_feature with missing connection."""+ sockets_metadata = {}+ assert supports_feature(sockets_metadata, "missing_sid", "any_feature") is False++ def test_empty_feature_flags_dict(self):+ """Test connection with empty feature flags dictionary."""+ sockets_metadata = {"sid1": {"feature_flags": {}}}+ result = get_connection_feature(sockets_metadata, "sid1", "any_feature")+ assert result is False+ assert supports_feature(sockets_metadata, "sid1", "any_feature") is Falsediff --git a/tests-unit/requirements.txt b/tests-unit/requirements.txtindex d70d00f4b..3a6790ee0 100644--- a/tests-unit/requirements.txt+++ b/tests-unit/requirements.txt@@ -1,3 +1,4 @@pytest>=7.8.0pytest-aiohttppytest-asyncio+websocket-clientdiff --git a/tests-unit/websocket_feature_flags_test.py b/tests-unit/websocket_feature_flags_test.pynew file mode 100644index 000000000..e93b2e1dd--- /dev/null+++ b/tests-unit/websocket_feature_flags_test.py@@ -0,0 +1,77 @@+"""Simplified tests for WebSocket feature flags functionality."""+from comfy_api import feature_flags+++class TestWebSocketFeatureFlags:+ """Test suite for WebSocket feature flags integration."""++ def test_server_feature_flags_response(self):+ """Test server feature flags are properly formatted."""+ features = feature_flags.get_server_features()++ # Check expected server features+ assert "supports_preview_metadata" in features+ assert features["supports_preview_metadata"] is True+ assert "max_upload_size" in features+ assert isinstance(features["max_upload_size"], (int, float))++ def test_progress_py_checks_feature_flags(self):+ """Test that progress.py checks feature flags before sending metadata."""+ # This simulates the check in progress.py+ client_id = "test_client"+ sockets_metadata = {"test_client": {"feature_flags": {}}}++ # The actual check would be in progress.py+ supports_metadata = feature_flags.supports_feature(+ sockets_metadata, client_id, "supports_preview_metadata"+ )++ assert supports_metadata is False++ def test_multiple_clients_different_features(self):+ """Test handling multiple clients with different feature support."""+ sockets_metadata = {+ "modern_client": {+ "feature_flags": {"supports_preview_metadata": True}+ },+ "legacy_client": {+ "feature_flags": {}+ }+ }++ # Check modern client+ assert feature_flags.supports_feature(+ sockets_metadata, "modern_client", "supports_preview_metadata"+ ) is True++ # Check legacy client+ assert feature_flags.supports_feature(+ sockets_metadata, "legacy_client", "supports_preview_metadata"+ ) is False++ def test_feature_negotiation_message_format(self):+ """Test the format of feature negotiation messages."""+ # Client message format+ client_message = {+ "type": "feature_flags",+ "data": {+ "supports_preview_metadata": True,+ "api_version": "1.0.0"+ }+ }++ # Verify structure+ assert client_message["type"] == "feature_flags"+ assert "supports_preview_metadata" in client_message["data"]++ # Server response format (what would be sent)+ server_features = feature_flags.get_server_features()+ server_message = {+ "type": "feature_flags",+ "data": server_features+ }++ # Verify structure+ assert server_message["type"] == "feature_flags"+ assert "supports_preview_metadata" in server_message["data"]+ assert server_message["data"]["supports_preview_metadata"] is Truediff --git a/tests/inference/extra_model_paths.yaml b/tests/inference/extra_model_paths.yamlindex 75b2e1ae4..68e056564 100644--- a/tests/inference/extra_model_paths.yaml+++ b/tests/inference/extra_model_paths.yaml@@ -1,4 +1,4 @@# Config for testing nodestesting:- custom_nodes: tests/inference/testing_nodes+ custom_nodes: testing_nodesdiff --git a/tests/inference/test_async_nodes.py b/tests/inference/test_async_nodes.pynew file mode 100644index 000000000..b243bbca9--- /dev/null+++ b/tests/inference/test_async_nodes.py@@ -0,0 +1,410 @@+import pytest+import time+import torch+import urllib.error+import numpy as np+import subprocess++from pytest import fixture+from comfy_execution.graph_utils import GraphBuilder+from tests.inference.test_execution import ComfyClient+++class TestAsyncNodes:+ @fixture(scope="class", autouse=True, params=[+ (False, 0),+ (True, 0),+ (True, 100),+ ])+ def _server(self, args_pytest, request):+ pargs = [+ 'python','main.py',+ '--output-directory', args_pytest["output_dir"],+ '--listen', args_pytest["listen"],+ '--port', str(args_pytest["port"]),+ '--extra-model-paths-config', 'tests/inference/extra_model_paths.yaml',+ ]+ use_lru, lru_size = request.param+ if use_lru:+ pargs += ['--cache-lru', str(lru_size)]+ # Running server with args: pargs+ p = subprocess.Popen(pargs)+ yield+ p.kill()+ torch.cuda.empty_cache()++ @fixture(scope="class", autouse=True)+ def shared_client(self, args_pytest, _server):+ client = ComfyClient()+ n_tries = 5+ for i in range(n_tries):+ time.sleep(4)+ try:+ client.connect(listen=args_pytest["listen"], port=args_pytest["port"])+ except ConnectionRefusedError:+ # Retrying...+ pass+ else:+ break+ yield client+ del client+ torch.cuda.empty_cache()++ @fixture+ def client(self, shared_client, request):+ shared_client.set_test_name(f"async_nodes[{request.node.name}]")+ yield shared_client++ @fixture+ def builder(self, request):+ yield GraphBuilder(prefix=request.node.name)++ # Happy Path Tests++ def test_basic_async_execution(self, client: ComfyClient, builder: GraphBuilder):+ """Test that a basic async node executes correctly."""+ g = builder+ image = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)+ sleep_node = g.node("TestSleep", value=image.out(0), seconds=0.1)+ output = g.node("SaveImage", images=sleep_node.out(0))++ result = client.run(g)++ # Verify execution completed+ assert result.did_run(sleep_node), "Async sleep node should have executed"+ assert result.did_run(output), "Output node should have executed"++ # Verify the image passed through correctly+ result_images = result.get_images(output)+ assert len(result_images) == 1, "Should have 1 image"+ assert np.array(result_images[0]).min() == 0 and np.array(result_images[0]).max() == 0, "Image should be black"++ def test_multiple_async_parallel_execution(self, client: ComfyClient, builder: GraphBuilder):+ """Test that multiple async nodes execute in parallel."""+ g = builder+ image = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)++ # Create multiple async sleep nodes with different durations+ sleep1 = g.node("TestSleep", value=image.out(0), seconds=0.3)+ sleep2 = g.node("TestSleep", value=image.out(0), seconds=0.4)+ sleep3 = g.node("TestSleep", value=image.out(0), seconds=0.5)++ # Add outputs for each+ _output1 = g.node("PreviewImage", images=sleep1.out(0))+ _output2 = g.node("PreviewImage", images=sleep2.out(0))+ _output3 = g.node("PreviewImage", images=sleep3.out(0))++ start_time = time.time()+ result = client.run(g)+ elapsed_time = time.time() - start_time++ # Should take ~0.5s (max duration) not 1.2s (sum of durations)+ assert elapsed_time < 0.8, f"Parallel execution took {elapsed_time}s, expected < 0.8s"++ # Verify all nodes executed+ assert result.did_run(sleep1) and result.did_run(sleep2) and result.did_run(sleep3)++ def test_async_with_dependencies(self, client: ComfyClient, builder: GraphBuilder):+ """Test async nodes with proper dependency handling."""+ g = builder+ image1 = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)+ image2 = g.node("StubImage", content="WHITE", height=512, width=512, batch_size=1)++ # Chain of async operations+ sleep1 = g.node("TestSleep", value=image1.out(0), seconds=0.2)+ sleep2 = g.node("TestSleep", value=image2.out(0), seconds=0.2)++ # Average depends on both async results+ average = g.node("TestVariadicAverage", input1=sleep1.out(0), input2=sleep2.out(0))+ output = g.node("SaveImage", images=average.out(0))++ result = client.run(g)++ # Verify execution order+ assert result.did_run(sleep1) and result.did_run(sleep2)+ assert result.did_run(average) and result.did_run(output)++ # Verify averaged result+ result_images = result.get_images(output)+ avg_value = np.array(result_images[0]).mean()+ assert abs(avg_value - 127.5) < 1, f"Average value {avg_value} should be ~127.5"++ def test_async_validate_inputs(self, client: ComfyClient, builder: GraphBuilder):+ """Test async VALIDATE_INPUTS function."""+ g = builder+ # Create a test node with async validation+ validation_node = g.node("TestAsyncValidation", value=5.0, threshold=10.0)+ g.node("SaveImage", images=validation_node.out(0))++ # Should pass validation+ result = client.run(g)+ assert result.did_run(validation_node)++ # Test validation failure+ validation_node.inputs['threshold'] = 3.0 # Will fail since value > threshold+ with pytest.raises(urllib.error.HTTPError):+ client.run(g)++ def test_async_lazy_evaluation(self, client: ComfyClient, builder: GraphBuilder):+ """Test async nodes with lazy evaluation."""+ g = builder+ input1 = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)+ input2 = g.node("StubImage", content="WHITE", height=512, width=512, batch_size=1)+ mask = g.node("StubMask", value=0.0, height=512, width=512, batch_size=1)++ # Create async nodes that will be evaluated lazily+ sleep1 = g.node("TestSleep", value=input1.out(0), seconds=0.3)+ sleep2 = g.node("TestSleep", value=input2.out(0), seconds=0.3)++ # Use lazy mix that only needs sleep1 (mask=0.0)+ lazy_mix = g.node("TestLazyMixImages", image1=sleep1.out(0), image2=sleep2.out(0), mask=mask.out(0))+ g.node("SaveImage", images=lazy_mix.out(0))++ start_time = time.time()+ result = client.run(g)+ elapsed_time = time.time() - start_time++ # Should only execute sleep1, not sleep2+ assert elapsed_time < 0.5, f"Should skip sleep2, took {elapsed_time}s"+ assert result.did_run(sleep1), "Sleep1 should have executed"+ assert not result.did_run(sleep2), "Sleep2 should have been skipped"++ def test_async_check_lazy_status(self, client: ComfyClient, builder: GraphBuilder):+ """Test async check_lazy_status function."""+ g = builder+ # Create a node with async check_lazy_status+ lazy_node = g.node("TestAsyncLazyCheck",+ input1="value1",+ input2="value2",+ condition=True)+ g.node("SaveImage", images=lazy_node.out(0))++ result = client.run(g)+ assert result.did_run(lazy_node)++ # Error Handling Tests++ def test_async_execution_error(self, client: ComfyClient, builder: GraphBuilder):+ """Test that async execution errors are properly handled."""+ g = builder+ image = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)+ # Create an async node that will error+ error_node = g.node("TestAsyncError", value=image.out(0), error_after=0.1)+ g.node("SaveImage", images=error_node.out(0))++ try:+ client.run(g)+ assert False, "Should have raised an error"+ except Exception as e:+ assert 'prompt_id' in e.args[0], f"Did not get proper error message: {e}"+ assert e.args[0]['node_id'] == error_node.id, "Error should be from async error node"++ def test_async_validation_error(self, client: ComfyClient, builder: GraphBuilder):+ """Test async validation error handling."""+ g = builder+ # Node with async validation that will fail+ validation_node = g.node("TestAsyncValidationError", value=15.0, max_value=10.0)+ g.node("SaveImage", images=validation_node.out(0))++ with pytest.raises(urllib.error.HTTPError) as exc_info:+ client.run(g)+ # Verify it's a validation error+ assert exc_info.value.code == 400++ def test_async_timeout_handling(self, client: ComfyClient, builder: GraphBuilder):+ """Test handling of async operations that timeout."""+ g = builder+ image = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)+ # Very long sleep that would timeout+ timeout_node = g.node("TestAsyncTimeout", value=image.out(0), timeout=0.5, operation_time=2.0)+ g.node("SaveImage", images=timeout_node.out(0))++ try:+ client.run(g)+ assert False, "Should have raised a timeout error"+ except Exception as e:+ assert 'timeout' in str(e).lower(), f"Expected timeout error, got: {e}"++ def test_concurrent_async_error_recovery(self, client: ComfyClient, builder: GraphBuilder):+ """Test that workflow can recover after async errors."""+ g = builder+ image = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)++ # First run with error+ error_node = g.node("TestAsyncError", value=image.out(0), error_after=0.1)+ g.node("SaveImage", images=error_node.out(0))++ try:+ client.run(g)+ except Exception:+ pass # Expected++ # Second run should succeed+ g2 = GraphBuilder(prefix="recovery_test")+ image2 = g2.node("StubImage", content="WHITE", height=512, width=512, batch_size=1)+ sleep_node = g2.node("TestSleep", value=image2.out(0), seconds=0.1)+ g2.node("SaveImage", images=sleep_node.out(0))++ result = client.run(g2)+ assert result.did_run(sleep_node), "Should be able to run after error"++ def test_sync_error_during_async_execution(self, client: ComfyClient, builder: GraphBuilder):+ """Test handling when sync node errors while async node is executing."""+ g = builder+ image = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)++ # Async node that takes time+ sleep_node = g.node("TestSleep", value=image.out(0), seconds=0.5)++ # Sync node that will error immediately+ error_node = g.node("TestSyncError", value=image.out(0))++ # Both feed into output+ g.node("PreviewImage", images=sleep_node.out(0))+ g.node("PreviewImage", images=error_node.out(0))++ try:+ client.run(g)+ assert False, "Should have raised an error"+ except Exception as e:+ # Verify the sync error was caught even though async was running+ assert 'prompt_id' in e.args[0]++ # Edge Cases++ def test_async_with_execution_blocker(self, client: ComfyClient, builder: GraphBuilder):+ """Test async nodes with execution blockers."""+ g = builder+ image1 = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)+ image2 = g.node("StubImage", content="WHITE", height=512, width=512, batch_size=1)++ # Async sleep nodes+ sleep1 = g.node("TestSleep", value=image1.out(0), seconds=0.2)+ sleep2 = g.node("TestSleep", value=image2.out(0), seconds=0.2)++ # Create list of images+ image_list = g.node("TestMakeListNode", value1=sleep1.out(0), value2=sleep2.out(0))++ # Create list of blocking conditions - [False, True] to block only the second item+ int1 = g.node("StubInt", value=1)+ int2 = g.node("StubInt", value=2)+ block_list = g.node("TestMakeListNode", value1=int1.out(0), value2=int2.out(0))++ # Compare each value against 2, so first is False (1 != 2) and second is True (2 == 2)+ compare = g.node("TestIntConditions", a=block_list.out(0), b=2, operation="==")++ # Block based on the comparison results+ blocker = g.node("TestExecutionBlocker", input=image_list.out(0), block=compare.out(0), verbose=False)++ output = g.node("PreviewImage", images=blocker.out(0))++ result = client.run(g)+ images = result.get_images(output)+ assert len(images) == 1, "Should have blocked second image"++ def test_async_caching_behavior(self, client: ComfyClient, builder: GraphBuilder):+ """Test that async nodes are properly cached."""+ g = builder+ image = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)+ sleep_node = g.node("TestSleep", value=image.out(0), seconds=0.2)+ g.node("SaveImage", images=sleep_node.out(0))++ # First run+ result1 = client.run(g)+ assert result1.did_run(sleep_node), "Should run first time"++ # Second run - should be cached+ start_time = time.time()+ result2 = client.run(g)+ elapsed_time = time.time() - start_time++ assert not result2.did_run(sleep_node), "Should be cached"+ assert elapsed_time < 0.1, f"Cached run took {elapsed_time}s, should be instant"++ def test_async_with_dynamic_prompts(self, client: ComfyClient, builder: GraphBuilder):+ """Test async nodes within dynamically generated prompts."""+ g = builder+ image1 = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)+ image2 = g.node("StubImage", content="WHITE", height=512, width=512, batch_size=1)++ # Node that generates async nodes dynamically+ dynamic_async = g.node("TestDynamicAsyncGeneration",+ image1=image1.out(0),+ image2=image2.out(0),+ num_async_nodes=3,+ sleep_duration=0.2)+ g.node("SaveImage", images=dynamic_async.out(0))++ start_time = time.time()+ result = client.run(g)+ elapsed_time = time.time() - start_time++ # Should execute async nodes in parallel within dynamic prompt+ assert elapsed_time < 0.5, f"Dynamic async execution took {elapsed_time}s"+ assert result.did_run(dynamic_async)++ def test_async_resource_cleanup(self, client: ComfyClient, builder: GraphBuilder):+ """Test that async resources are properly cleaned up."""+ g = builder+ image = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)++ # Create multiple async nodes that use resources+ resource_nodes = []+ for i in range(5):+ node = g.node("TestAsyncResourceUser",+ value=image.out(0),+ resource_id=f"resource_{i}",+ duration=0.1)+ resource_nodes.append(node)+ g.node("PreviewImage", images=node.out(0))++ result = client.run(g)++ # Verify all nodes executed+ for node in resource_nodes:+ assert result.did_run(node)++ # Run again to ensure resources were cleaned up+ result2 = client.run(g)+ # Should be cached but not error due to resource conflicts+ for node in resource_nodes:+ assert not result2.did_run(node), "Should be cached"++ def test_async_cancellation(self, client: ComfyClient, builder: GraphBuilder):+ """Test cancellation of async operations."""+ # This would require implementing cancellation in the client+ # For now, we'll test that long-running async operations can be interrupted+ pass # TODO: Implement when cancellation API is available++ def test_mixed_sync_async_execution(self, client: ComfyClient, builder: GraphBuilder):+ """Test workflows with both sync and async nodes."""+ g = builder+ image1 = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)+ image2 = g.node("StubImage", content="WHITE", height=512, width=512, batch_size=1)+ mask = g.node("StubMask", value=0.5, height=512, width=512, batch_size=1)++ # Mix of sync and async operations+ # Sync: lazy mix images+ sync_op1 = g.node("TestLazyMixImages", image1=image1.out(0), image2=image2.out(0), mask=mask.out(0))+ # Async: sleep+ async_op1 = g.node("TestSleep", value=sync_op1.out(0), seconds=0.2)+ # Sync: custom validation+ sync_op2 = g.node("TestCustomValidation1", input1=async_op1.out(0), input2=0.5)+ # Async: sleep again+ async_op2 = g.node("TestSleep", value=sync_op2.out(0), seconds=0.2)++ output = g.node("SaveImage", images=async_op2.out(0))++ result = client.run(g)++ # Verify all nodes executed in correct order+ assert result.did_run(sync_op1)+ assert result.did_run(async_op1)+ assert result.did_run(sync_op2)+ assert result.did_run(async_op2)++ # Image should be a mix of black and white (gray)+ result_images = result.get_images(output)+ avg_value = np.array(result_images[0]).mean()+ assert abs(avg_value - 63.75) < 5, f"Average value {avg_value} should be ~63.75"diff --git a/tests/inference/test_execution.py b/tests/inference/test_execution.pyindex 5cda5c1ae..9d3d685cc 100644--- a/tests/inference/test_execution.py+++ b/tests/inference/test_execution.py@@ -252,7 +252,7 @@ class TestExecution:@pytest.mark.parametrize("test_type, test_value", [("StubInt", 5),- ("StubFloat", 5.0)+ ("StubMask", 5.0)])def test_validation_error_edge1(self, test_type, test_value, client: ComfyClient, builder: GraphBuilder):g = builder@@ -497,6 +497,69 @@ class TestExecution:assert numpy.array(images[0]).min() == 63 and numpy.array(images[0]).max() == 63, "Image should have value 0.25"assert not result.did_run(test_node), "The execution should have been cached"+ def test_parallel_sleep_nodes(self, client: ComfyClient, builder: GraphBuilder):+ g = builder+ image = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)++ # Create sleep nodes for each duration+ sleep_node1 = g.node("TestSleep", value=image.out(0), seconds=2.8)+ sleep_node2 = g.node("TestSleep", value=image.out(0), seconds=2.9)+ sleep_node3 = g.node("TestSleep", value=image.out(0), seconds=3.0)++ # Add outputs to verify the execution+ _output1 = g.node("PreviewImage", images=sleep_node1.out(0))+ _output2 = g.node("PreviewImage", images=sleep_node2.out(0))+ _output3 = g.node("PreviewImage", images=sleep_node3.out(0))++ start_time = time.time()+ result = client.run(g)+ elapsed_time = time.time() - start_time++ # The test should take around 0.4 seconds (the longest sleep duration)+ # plus some overhead, but definitely less than the sum of all sleeps (0.9s)+ # We'll allow for up to 0.8s total to account for overhead+ assert elapsed_time < 4.0, f"Parallel execution took {elapsed_time}s, expected less than 0.8s"++ # Verify that all nodes executed+ assert result.did_run(sleep_node1), "Sleep node 1 should have run"+ assert result.did_run(sleep_node2), "Sleep node 2 should have run"+ assert result.did_run(sleep_node3), "Sleep node 3 should have run"++ def test_parallel_sleep_expansion(self, client: ComfyClient, builder: GraphBuilder):+ g = builder+ # Create input images with different values+ image1 = g.node("StubImage", content="BLACK", height=512, width=512, batch_size=1)+ image2 = g.node("StubImage", content="WHITE", height=512, width=512, batch_size=1)+ image3 = g.node("StubImage", content="WHITE", height=512, width=512, batch_size=1)++ # Create a TestParallelSleep node that expands into multiple TestSleep nodes+ parallel_sleep = g.node("TestParallelSleep",+ image1=image1.out(0),+ image2=image2.out(0),+ image3=image3.out(0),+ sleep1=0.4,+ sleep2=0.5,+ sleep3=0.6)+ output = g.node("SaveImage", images=parallel_sleep.out(0))++ start_time = time.time()+ result = client.run(g)+ elapsed_time = time.time() - start_time++ # Similar to the previous test, expect parallel execution of the sleep nodes+ # which should complete in less than the sum of all sleeps+ assert elapsed_time < 0.8, f"Expansion execution took {elapsed_time}s, expected less than 0.8s"++ # Verify the parallel sleep node executed+ assert result.did_run(parallel_sleep), "ParallelSleep node should have run"++ # Verify we get an image as output (blend of the three input images)+ result_images = result.get_images(output)+ assert len(result_images) == 1, "Should have 1 image"+ # Average pixel value should be around 170 (255 * 2 // 3)+ avg_value = numpy.array(result_images[0]).mean()+ assert avg_value == 170, f"Image average value {avg_value} should be 170"+# This tests that nodes with OUTPUT_IS_LIST function correctly when they receive an ExecutionBlocker# as input. We also test that when that list (containing an ExecutionBlocker) is passed to a node,# only that one entry in the list is blocked.diff --git a/tests/inference/testing_nodes/testing-pack/__init__.py b/tests/inference/testing_nodes/testing-pack/__init__.pyindex dcc71659a..20f9533c7 100644--- a/tests/inference/testing_nodes/testing-pack/__init__.py+++ b/tests/inference/testing_nodes/testing-pack/__init__.py@@ -1,23 +1,26 @@-from .specific_tests import TEST_NODE_CLASS_MAPPINGS, TEST_NODE_DISPLAY_NAME_MAPPINGS-from .flow_control import FLOW_CONTROL_NODE_CLASS_MAPPINGS, FLOW_CONTROL_NODE_DISPLAY_NAME_MAPPINGS-from .util import UTILITY_NODE_CLASS_MAPPINGS, UTILITY_NODE_DISPLAY_NAME_MAPPINGS-from .conditions import CONDITION_NODE_CLASS_MAPPINGS, CONDITION_NODE_DISPLAY_NAME_MAPPINGS-from .stubs import TEST_STUB_NODE_CLASS_MAPPINGS, TEST_STUB_NODE_DISPLAY_NAME_MAPPINGS--# NODE_CLASS_MAPPINGS = GENERAL_NODE_CLASS_MAPPINGS.update(COMPONENT_NODE_CLASS_MAPPINGS)-# NODE_DISPLAY_NAME_MAPPINGS = GENERAL_NODE_DISPLAY_NAME_MAPPINGS.update(COMPONENT_NODE_DISPLAY_NAME_MAPPINGS)--NODE_CLASS_MAPPINGS = {}-NODE_CLASS_MAPPINGS.update(TEST_NODE_CLASS_MAPPINGS)-NODE_CLASS_MAPPINGS.update(FLOW_CONTROL_NODE_CLASS_MAPPINGS)-NODE_CLASS_MAPPINGS.update(UTILITY_NODE_CLASS_MAPPINGS)-NODE_CLASS_MAPPINGS.update(CONDITION_NODE_CLASS_MAPPINGS)-NODE_CLASS_MAPPINGS.update(TEST_STUB_NODE_CLASS_MAPPINGS)--NODE_DISPLAY_NAME_MAPPINGS = {}-NODE_DISPLAY_NAME_MAPPINGS.update(TEST_NODE_DISPLAY_NAME_MAPPINGS)-NODE_DISPLAY_NAME_MAPPINGS.update(FLOW_CONTROL_NODE_DISPLAY_NAME_MAPPINGS)-NODE_DISPLAY_NAME_MAPPINGS.update(UTILITY_NODE_DISPLAY_NAME_MAPPINGS)-NODE_DISPLAY_NAME_MAPPINGS.update(CONDITION_NODE_DISPLAY_NAME_MAPPINGS)-NODE_DISPLAY_NAME_MAPPINGS.update(TEST_STUB_NODE_DISPLAY_NAME_MAPPINGS)-+from .specific_tests import TEST_NODE_CLASS_MAPPINGS, TEST_NODE_DISPLAY_NAME_MAPPINGS+from .flow_control import FLOW_CONTROL_NODE_CLASS_MAPPINGS, FLOW_CONTROL_NODE_DISPLAY_NAME_MAPPINGS+from .util import UTILITY_NODE_CLASS_MAPPINGS, UTILITY_NODE_DISPLAY_NAME_MAPPINGS+from .conditions import CONDITION_NODE_CLASS_MAPPINGS, CONDITION_NODE_DISPLAY_NAME_MAPPINGS+from .stubs import TEST_STUB_NODE_CLASS_MAPPINGS, TEST_STUB_NODE_DISPLAY_NAME_MAPPINGS+from .async_test_nodes import ASYNC_TEST_NODE_CLASS_MAPPINGS, ASYNC_TEST_NODE_DISPLAY_NAME_MAPPINGS++# NODE_CLASS_MAPPINGS = GENERAL_NODE_CLASS_MAPPINGS.update(COMPONENT_NODE_CLASS_MAPPINGS)+# NODE_DISPLAY_NAME_MAPPINGS = GENERAL_NODE_DISPLAY_NAME_MAPPINGS.update(COMPONENT_NODE_DISPLAY_NAME_MAPPINGS)++NODE_CLASS_MAPPINGS = {}+NODE_CLASS_MAPPINGS.update(TEST_NODE_CLASS_MAPPINGS)+NODE_CLASS_MAPPINGS.update(FLOW_CONTROL_NODE_CLASS_MAPPINGS)+NODE_CLASS_MAPPINGS.update(UTILITY_NODE_CLASS_MAPPINGS)+NODE_CLASS_MAPPINGS.update(CONDITION_NODE_CLASS_MAPPINGS)+NODE_CLASS_MAPPINGS.update(TEST_STUB_NODE_CLASS_MAPPINGS)+NODE_CLASS_MAPPINGS.update(ASYNC_TEST_NODE_CLASS_MAPPINGS)++NODE_DISPLAY_NAME_MAPPINGS = {}+NODE_DISPLAY_NAME_MAPPINGS.update(TEST_NODE_DISPLAY_NAME_MAPPINGS)+NODE_DISPLAY_NAME_MAPPINGS.update(FLOW_CONTROL_NODE_DISPLAY_NAME_MAPPINGS)+NODE_DISPLAY_NAME_MAPPINGS.update(UTILITY_NODE_DISPLAY_NAME_MAPPINGS)+NODE_DISPLAY_NAME_MAPPINGS.update(CONDITION_NODE_DISPLAY_NAME_MAPPINGS)+NODE_DISPLAY_NAME_MAPPINGS.update(TEST_STUB_NODE_DISPLAY_NAME_MAPPINGS)+NODE_DISPLAY_NAME_MAPPINGS.update(ASYNC_TEST_NODE_DISPLAY_NAME_MAPPINGS)+diff --git a/tests/inference/testing_nodes/testing-pack/async_test_nodes.py b/tests/inference/testing_nodes/testing-pack/async_test_nodes.pynew file mode 100644index 000000000..547eea6f4--- /dev/null+++ b/tests/inference/testing_nodes/testing-pack/async_test_nodes.py@@ -0,0 +1,343 @@+import torch+import asyncio+from typing import Dict+from comfy.utils import ProgressBar+from comfy_execution.graph_utils import GraphBuilder+from comfy.comfy_types.node_typing import ComfyNodeABC+from comfy.comfy_types import IO+++class TestAsyncValidation(ComfyNodeABC):+ """Test node with async VALIDATE_INPUTS."""++ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "value": ("FLOAT", {"default": 5.0}),+ "threshold": ("FLOAT", {"default": 10.0}),+ },+ }++ RETURN_TYPES = ("IMAGE",)+ FUNCTION = "process"+ CATEGORY = "_for_testing/async"++ @classmethod+ async def VALIDATE_INPUTS(cls, value, threshold):+ # Simulate async validation (e.g., checking remote service)+ await asyncio.sleep(0.05)++ if value > threshold:+ return f"Value {value} exceeds threshold {threshold}"+ return True++ def process(self, value, threshold):+ # Create image based on value+ intensity = value / 10.0+ image = torch.ones([1, 512, 512, 3]) * intensity+ return (image,)+++class TestAsyncError(ComfyNodeABC):+ """Test node that errors during async execution."""++ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "value": (IO.ANY, {}),+ "error_after": ("FLOAT", {"default": 0.1, "min": 0.0, "max": 10.0}),+ },+ }++ RETURN_TYPES = (IO.ANY,)+ FUNCTION = "error_execution"+ CATEGORY = "_for_testing/async"++ async def error_execution(self, value, error_after):+ await asyncio.sleep(error_after)+ raise RuntimeError("Intentional async execution error for testing")+++class TestAsyncValidationError(ComfyNodeABC):+ """Test node with async validation that always fails."""++ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "value": ("FLOAT", {"default": 5.0}),+ "max_value": ("FLOAT", {"default": 10.0}),+ },+ }++ RETURN_TYPES = ("IMAGE",)+ FUNCTION = "process"+ CATEGORY = "_for_testing/async"++ @classmethod+ async def VALIDATE_INPUTS(cls, value, max_value):+ await asyncio.sleep(0.05)+ # Always fail validation for values > max_value+ if value > max_value:+ return f"Async validation failed: {value} > {max_value}"+ return True++ def process(self, value, max_value):+ # This won't be reached if validation fails+ image = torch.ones([1, 512, 512, 3]) * (value / max_value)+ return (image,)+++class TestAsyncTimeout(ComfyNodeABC):+ """Test node that simulates timeout scenarios."""++ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "value": (IO.ANY, {}),+ "timeout": ("FLOAT", {"default": 1.0, "min": 0.1, "max": 10.0}),+ "operation_time": ("FLOAT", {"default": 2.0, "min": 0.1, "max": 10.0}),+ },+ }++ RETURN_TYPES = (IO.ANY,)+ FUNCTION = "timeout_execution"+ CATEGORY = "_for_testing/async"++ async def timeout_execution(self, value, timeout, operation_time):+ try:+ # This will timeout if operation_time > timeout+ await asyncio.wait_for(asyncio.sleep(operation_time), timeout=timeout)+ return (value,)+ except asyncio.TimeoutError:+ raise RuntimeError(f"Operation timed out after {timeout} seconds")+++class TestSyncError(ComfyNodeABC):+ """Test node that errors synchronously (for mixed sync/async testing)."""++ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "value": (IO.ANY, {}),+ },+ }++ RETURN_TYPES = (IO.ANY,)+ FUNCTION = "sync_error"+ CATEGORY = "_for_testing/async"++ def sync_error(self, value):+ raise RuntimeError("Intentional sync execution error for testing")+++class TestAsyncLazyCheck(ComfyNodeABC):+ """Test node with async check_lazy_status."""++ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "input1": (IO.ANY, {"lazy": True}),+ "input2": (IO.ANY, {"lazy": True}),+ "condition": ("BOOLEAN", {"default": True}),+ },+ }++ RETURN_TYPES = ("IMAGE",)+ FUNCTION = "process"+ CATEGORY = "_for_testing/async"++ async def check_lazy_status(self, condition, input1, input2):+ # Simulate async checking (e.g., querying remote service)+ await asyncio.sleep(0.05)++ needed = []+ if condition and input1 is None:+ needed.append("input1")+ if not condition and input2 is None:+ needed.append("input2")+ return needed++ def process(self, input1, input2, condition):+ # Return a simple image+ return (torch.ones([1, 512, 512, 3]),)+++class TestDynamicAsyncGeneration(ComfyNodeABC):+ """Test node that dynamically generates async nodes."""++ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "image1": ("IMAGE",),+ "image2": ("IMAGE",),+ "num_async_nodes": ("INT", {"default": 3, "min": 1, "max": 10}),+ "sleep_duration": ("FLOAT", {"default": 0.2, "min": 0.1, "max": 1.0}),+ },+ }++ RETURN_TYPES = ("IMAGE",)+ FUNCTION = "generate_async_workflow"+ CATEGORY = "_for_testing/async"++ def generate_async_workflow(self, image1, image2, num_async_nodes, sleep_duration):+ g = GraphBuilder()++ # Create multiple async sleep nodes+ sleep_nodes = []+ for i in range(num_async_nodes):+ image = image1 if i % 2 == 0 else image2+ sleep_node = g.node("TestSleep", value=image, seconds=sleep_duration)+ sleep_nodes.append(sleep_node)++ # Average all results+ if len(sleep_nodes) == 1:+ final_node = sleep_nodes[0]+ else:+ avg_inputs = {"input1": sleep_nodes[0].out(0)}+ for i, node in enumerate(sleep_nodes[1:], 2):+ avg_inputs[f"input{i}"] = node.out(0)+ final_node = g.node("TestVariadicAverage", **avg_inputs)++ return {+ "result": (final_node.out(0),),+ "expand": g.finalize(),+ }+++class TestAsyncResourceUser(ComfyNodeABC):+ """Test node that uses resources during async execution."""++ # Class-level resource tracking for testing+ _active_resources: Dict[str, bool] = {}++ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "value": (IO.ANY, {}),+ "resource_id": ("STRING", {"default": "resource_0"}),+ "duration": ("FLOAT", {"default": 0.1, "min": 0.0, "max": 1.0}),+ },+ }++ RETURN_TYPES = (IO.ANY,)+ FUNCTION = "use_resource"+ CATEGORY = "_for_testing/async"++ async def use_resource(self, value, resource_id, duration):+ # Check if resource is already in use+ if self._active_resources.get(resource_id, False):+ raise RuntimeError(f"Resource {resource_id} is already in use!")++ # Mark resource as in use+ self._active_resources[resource_id] = True++ try:+ # Simulate resource usage+ await asyncio.sleep(duration)+ return (value,)+ finally:+ # Always clean up resource+ self._active_resources[resource_id] = False+++class TestAsyncBatchProcessing(ComfyNodeABC):+ """Test async processing of batched inputs."""++ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "images": ("IMAGE",),+ "process_time_per_item": ("FLOAT", {"default": 0.1, "min": 0.01, "max": 1.0}),+ },+ "hidden": {+ "unique_id": "UNIQUE_ID",+ },+ }++ RETURN_TYPES = ("IMAGE",)+ FUNCTION = "process_batch"+ CATEGORY = "_for_testing/async"++ async def process_batch(self, images, process_time_per_item, unique_id):+ batch_size = images.shape[0]+ pbar = ProgressBar(batch_size, node_id=unique_id)++ # Process each image in the batch+ processed = []+ for i in range(batch_size):+ # Simulate async processing+ await asyncio.sleep(process_time_per_item)++ # Simple processing: invert the image+ processed_image = 1.0 - images[i:i+1]+ processed.append(processed_image)++ pbar.update(1)++ # Stack processed images+ result = torch.cat(processed, dim=0)+ return (result,)+++class TestAsyncConcurrentLimit(ComfyNodeABC):+ """Test concurrent execution limits for async nodes."""++ _semaphore = asyncio.Semaphore(2) # Only allow 2 concurrent executions++ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "value": (IO.ANY, {}),+ "duration": ("FLOAT", {"default": 0.5, "min": 0.1, "max": 2.0}),+ "node_id": ("INT", {"default": 0}),+ },+ }++ RETURN_TYPES = (IO.ANY,)+ FUNCTION = "limited_execution"+ CATEGORY = "_for_testing/async"++ async def limited_execution(self, value, duration, node_id):+ async with self._semaphore:+ # Node {node_id} acquired semaphore+ await asyncio.sleep(duration)+ # Node {node_id} releasing semaphore+ return (value,)+++# Add node mappings+ASYNC_TEST_NODE_CLASS_MAPPINGS = {+ "TestAsyncValidation": TestAsyncValidation,+ "TestAsyncError": TestAsyncError,+ "TestAsyncValidationError": TestAsyncValidationError,+ "TestAsyncTimeout": TestAsyncTimeout,+ "TestSyncError": TestSyncError,+ "TestAsyncLazyCheck": TestAsyncLazyCheck,+ "TestDynamicAsyncGeneration": TestDynamicAsyncGeneration,+ "TestAsyncResourceUser": TestAsyncResourceUser,+ "TestAsyncBatchProcessing": TestAsyncBatchProcessing,+ "TestAsyncConcurrentLimit": TestAsyncConcurrentLimit,+}++ASYNC_TEST_NODE_DISPLAY_NAME_MAPPINGS = {+ "TestAsyncValidation": "Test Async Validation",+ "TestAsyncError": "Test Async Error",+ "TestAsyncValidationError": "Test Async Validation Error",+ "TestAsyncTimeout": "Test Async Timeout",+ "TestSyncError": "Test Sync Error",+ "TestAsyncLazyCheck": "Test Async Lazy Check",+ "TestDynamicAsyncGeneration": "Test Dynamic Async Generation",+ "TestAsyncResourceUser": "Test Async Resource User",+ "TestAsyncBatchProcessing": "Test Async Batch Processing",+ "TestAsyncConcurrentLimit": "Test Async Concurrent Limit",+}diff --git a/tests/inference/testing_nodes/testing-pack/specific_tests.py b/tests/inference/testing_nodes/testing-pack/specific_tests.pyindex 9d05ab14f..657d49f2f 100644--- a/tests/inference/testing_nodes/testing-pack/specific_tests.py+++ b/tests/inference/testing_nodes/testing-pack/specific_tests.py@@ -1,6 +1,11 @@import torch+import time+import asyncio+from comfy.utils import ProgressBarfrom .tools import VariantSupportfrom comfy_execution.graph_utils import GraphBuilder+from comfy.comfy_types.node_typing import ComfyNodeABC+from comfy.comfy_types import IOclass TestLazyMixImages:@classmethod@@ -333,6 +338,131 @@ class TestMixedExpansionReturns:"expand": g.finalize(),}+class TestSamplingInExpansion:+ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "model": ("MODEL",),+ "clip": ("CLIP",),+ "vae": ("VAE",),+ "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),+ "steps": ("INT", {"default": 20, "min": 1, "max": 100}),+ "cfg": ("FLOAT", {"default": 7.0, "min": 0.0, "max": 30.0}),+ "prompt": ("STRING", {"multiline": True, "default": "a beautiful landscape with mountains and trees"}),+ "negative_prompt": ("STRING", {"multiline": True, "default": "blurry, bad quality, worst quality"}),+ },+ }++ RETURN_TYPES = ("IMAGE",)+ FUNCTION = "sampling_in_expansion"++ CATEGORY = "Testing/Nodes"++ def sampling_in_expansion(self, model, clip, vae, seed, steps, cfg, prompt, negative_prompt):+ g = GraphBuilder()++ # Create a basic image generation workflow using the input model, clip and vae+ # 1. Setup text prompts using the provided CLIP model+ positive_prompt = g.node("CLIPTextEncode",+ text=prompt,+ clip=clip)+ negative_prompt = g.node("CLIPTextEncode",+ text=negative_prompt,+ clip=clip)++ # 2. Create empty latent with specified size+ empty_latent = g.node("EmptyLatentImage", width=512, height=512, batch_size=1)++ # 3. Setup sampler and generate image latent+ sampler = g.node("KSampler",+ model=model,+ positive=positive_prompt.out(0),+ negative=negative_prompt.out(0),+ latent_image=empty_latent.out(0),+ seed=seed,+ steps=steps,+ cfg=cfg,+ sampler_name="euler_ancestral",+ scheduler="normal")++ # 4. Decode latent to image using VAE+ output = g.node("VAEDecode", samples=sampler.out(0), vae=vae)++ return {+ "result": (output.out(0),),+ "expand": g.finalize(),+ }++class TestSleep(ComfyNodeABC):+ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "value": (IO.ANY, {}),+ "seconds": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 9999.0, "step": 0.01, "tooltip": "The amount of seconds to sleep."}),+ },+ "hidden": {+ "unique_id": "UNIQUE_ID",+ },+ }+ RETURN_TYPES = (IO.ANY,)+ FUNCTION = "sleep"++ CATEGORY = "_for_testing"++ async def sleep(self, value, seconds, unique_id):+ pbar = ProgressBar(seconds, node_id=unique_id)+ start = time.time()+ expiration = start + seconds+ now = start+ while now < expiration:+ now = time.time()+ pbar.update_absolute(now - start)+ await asyncio.sleep(0.01)+ return (value,)++class TestParallelSleep(ComfyNodeABC):+ @classmethod+ def INPUT_TYPES(cls):+ return {+ "required": {+ "image1": ("IMAGE", ),+ "image2": ("IMAGE", ),+ "image3": ("IMAGE", ),+ "sleep1": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 10.0, "step": 0.01}),+ "sleep2": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 10.0, "step": 0.01}),+ "sleep3": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 10.0, "step": 0.01}),+ },+ "hidden": {+ "unique_id": "UNIQUE_ID",+ },+ }+ RETURN_TYPES = ("IMAGE",)+ FUNCTION = "parallel_sleep"+ CATEGORY = "_for_testing"+ OUTPUT_NODE = True++ def parallel_sleep(self, image1, image2, image3, sleep1, sleep2, sleep3, unique_id):+ # Create a graph dynamically with three TestSleep nodes+ g = GraphBuilder()++ # Create sleep nodes for each duration and image+ sleep_node1 = g.node("TestSleep", value=image1, seconds=sleep1)+ sleep_node2 = g.node("TestSleep", value=image2, seconds=sleep2)+ sleep_node3 = g.node("TestSleep", value=image3, seconds=sleep3)++ # Blend the results using TestVariadicAverage+ blend = g.node("TestVariadicAverage",+ input1=sleep_node1.out(0),+ input2=sleep_node2.out(0),+ input3=sleep_node3.out(0))++ return {+ "result": (blend.out(0),),+ "expand": g.finalize(),+ }+TEST_NODE_CLASS_MAPPINGS = {"TestLazyMixImages": TestLazyMixImages,"TestVariadicAverage": TestVariadicAverage,@@ -345,6 +475,9 @@ TEST_NODE_CLASS_MAPPINGS = {"TestCustomValidation5": TestCustomValidation5,"TestDynamicDependencyCycle": TestDynamicDependencyCycle,"TestMixedExpansionReturns": TestMixedExpansionReturns,+ "TestSamplingInExpansion": TestSamplingInExpansion,+ "TestSleep": TestSleep,+ "TestParallelSleep": TestParallelSleep,}TEST_NODE_DISPLAY_NAME_MAPPINGS = {@@ -359,4 +492,7 @@ TEST_NODE_DISPLAY_NAME_MAPPINGS = {"TestCustomValidation5": "Custom Validation 5","TestDynamicDependencyCycle": "Dynamic Dependency Cycle","TestMixedExpansionReturns": "Mixed Expansion Returns",+ "TestSamplingInExpansion": "Sampling In Expansion",+ "TestSleep": "Test Sleep",+ "TestParallelSleep": "Test Parallel Sleep",}