The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
[fix] Fixes non-async public API access (#10857)
guillf66183a54142
diff --git a/comfy_api/internal/async_to_sync.py b/comfy_api/internal/async_to_sync.pyindex f5f805a62..257ade82e 100644--- a/comfy_api/internal/async_to_sync.py+++ b/comfy_api/internal/async_to_sync.py@@ -8,7 +8,7 @@ import osimport textwrapimport threadingfrom enum import Enum-from typing import Optional, Type, get_origin, get_args+from typing import Optional, Type, get_origin, get_args, get_type_hintsclass TypeTracker:@@ -220,11 +220,18 @@ class AsyncToSyncConverter:self._async_instance = async_class(*args, **kwargs)# Handle annotated class attributes (like execution: Execution)- # Get all annotations from the class hierarchy- all_annotations = {}- for base_class in reversed(inspect.getmro(async_class)):- if hasattr(base_class, "__annotations__"):- all_annotations.update(base_class.__annotations__)+ # Get all annotations from the class hierarchy and resolve string annotations+ try:+ # get_type_hints resolves string annotations to actual type objects+ # This handles classes using 'from __future__ import annotations'+ all_annotations = get_type_hints(async_class)+ except Exception:+ # Fallback to raw annotations if get_type_hints fails+ # (e.g., for undefined forward references)+ all_annotations = {}+ for base_class in reversed(inspect.getmro(async_class)):+ if hasattr(base_class, "__annotations__"):+ all_annotations.update(base_class.__annotations__)# For each annotated attribute, check if it needs to be created or wrappedfor attr_name, attr_type in all_annotations.items():@@ -625,15 +632,19 @@ class AsyncToSyncConverter:"""Extract class attributes that are classes themselves."""class_attributes = []+ # Get resolved type hints to handle string annotations+ try:+ type_hints = get_type_hints(async_class)+ except Exception:+ type_hints = {}+# Look for class attributes that are classesfor name, attr in sorted(inspect.getmembers(async_class)):if isinstance(attr, type) and not name.startswith("_"):class_attributes.append((name, attr))- elif (- hasattr(async_class, "__annotations__")- and name in async_class.__annotations__- ):- annotation = async_class.__annotations__[name]+ elif name in type_hints:+ # Use resolved type hint instead of raw annotation+ annotation = type_hints[name]if isinstance(annotation, type):class_attributes.append((name, annotation))@@ -908,11 +919,15 @@ class AsyncToSyncConverter:attribute_mappings = {}# First check annotations for typed attributes (including from parent classes)- # Collect all annotations from the class hierarchy- all_annotations = {}- for base_class in reversed(inspect.getmro(async_class)):- if hasattr(base_class, "__annotations__"):- all_annotations.update(base_class.__annotations__)+ # Resolve string annotations to actual types+ try:+ all_annotations = get_type_hints(async_class)+ except Exception:+ # Fallback to raw annotations+ all_annotations = {}+ for base_class in reversed(inspect.getmro(async_class)):+ if hasattr(base_class, "__annotations__"):+ all_annotations.update(base_class.__annotations__)for attr_name, attr_type in sorted(all_annotations.items()):for class_name, class_type in class_attributes:diff --git a/tests/execution/test_public_api.py b/tests/execution/test_public_api.pynew file mode 100644index 000000000..52bc2fcd8--- /dev/null+++ b/tests/execution/test_public_api.py@@ -0,0 +1,153 @@+"""+Tests for public ComfyAPI and ComfyAPISync functions.++These tests verify that the public API methods work correctly in both sync and async contexts,+ensuring that the sync wrapper generation (via get_type_hints() in async_to_sync.py) correctly+handles string annotations from 'from __future__ import annotations'.+"""++import pytest+import time+import subprocess+import torch+from pytest import fixture+from comfy_execution.graph_utils import GraphBuilder+from tests.execution.test_execution import ComfyClient+++class TestPublicAPI:+ """Test suite for public ComfyAPI and ComfyAPISync methods."""++ @fixture(scope="class", autouse=True)+ def _server(self, args_pytest):+ """Start ComfyUI server for testing."""+ pargs = [+ 'python', 'main.py',+ '--output-directory', args_pytest["output_dir"],+ '--listen', args_pytest["listen"],+ '--port', str(args_pytest["port"]),+ '--extra-model-paths-config', 'tests/execution/extra_model_paths.yaml',+ '--cpu',+ ]+ p = subprocess.Popen(pargs)+ yield+ p.kill()+ torch.cuda.empty_cache()++ @fixture(scope="class", autouse=True)+ def shared_client(self, args_pytest, _server):+ """Create shared client with connection retry."""+ 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"])+ break+ except ConnectionRefusedError:+ if i == n_tries - 1:+ raise+ yield client+ del client+ torch.cuda.empty_cache()++ @fixture+ def client(self, shared_client, request):+ """Set test name for each test."""+ shared_client.set_test_name(f"public_api[{request.node.name}]")+ yield shared_client++ @fixture+ def builder(self, request):+ """Create GraphBuilder for each test."""+ yield GraphBuilder(prefix=request.node.name)++ def test_sync_progress_update_executes(self, client: ComfyClient, builder: GraphBuilder):+ """Test that TestSyncProgressUpdate executes without errors.++ This test validates that api_sync.execution.set_progress() works correctly,+ which is the primary code path fixed by adding get_type_hints() to async_to_sync.py.+ """+ g = builder+ image = g.node("StubImage", content="BLACK", height=256, width=256, batch_size=1)++ # Use TestSyncProgressUpdate with short sleep+ progress_node = g.node("TestSyncProgressUpdate",+ value=image.out(0),+ sleep_seconds=0.5)+ output = g.node("SaveImage", images=progress_node.out(0))++ # Execute workflow+ result = client.run(g)++ # Verify execution+ assert result.did_run(progress_node), "Progress node should have executed"+ assert result.did_run(output), "Output node should have executed"++ # Verify output+ images = result.get_images(output)+ assert len(images) == 1, "Should have produced 1 image"++ def test_async_progress_update_executes(self, client: ComfyClient, builder: GraphBuilder):+ """Test that TestAsyncProgressUpdate executes without errors.++ This test validates that await api.execution.set_progress() works correctly+ in async contexts.+ """+ g = builder+ image = g.node("StubImage", content="WHITE", height=256, width=256, batch_size=1)++ # Use TestAsyncProgressUpdate with short sleep+ progress_node = g.node("TestAsyncProgressUpdate",+ value=image.out(0),+ sleep_seconds=0.5)+ output = g.node("SaveImage", images=progress_node.out(0))++ # Execute workflow+ result = client.run(g)++ # Verify execution+ assert result.did_run(progress_node), "Async progress node should have executed"+ assert result.did_run(output), "Output node should have executed"++ # Verify output+ images = result.get_images(output)+ assert len(images) == 1, "Should have produced 1 image"++ def test_sync_and_async_progress_together(self, client: ComfyClient, builder: GraphBuilder):+ """Test both sync and async progress updates in same workflow.++ This test ensures that both ComfyAPISync and ComfyAPI can coexist and work+ correctly in the same workflow execution.+ """+ g = builder+ image1 = g.node("StubImage", content="BLACK", height=256, width=256, batch_size=1)+ image2 = g.node("StubImage", content="WHITE", height=256, width=256, batch_size=1)++ # Use both types of progress nodes+ sync_progress = g.node("TestSyncProgressUpdate",+ value=image1.out(0),+ sleep_seconds=0.3)+ async_progress = g.node("TestAsyncProgressUpdate",+ value=image2.out(0),+ sleep_seconds=0.3)++ # Create outputs+ output1 = g.node("SaveImage", images=sync_progress.out(0))+ output2 = g.node("SaveImage", images=async_progress.out(0))++ # Execute workflow+ result = client.run(g)++ # Both should execute successfully+ assert result.did_run(sync_progress), "Sync progress node should have executed"+ assert result.did_run(async_progress), "Async progress node should have executed"+ assert result.did_run(output1), "First output node should have executed"+ assert result.did_run(output2), "Second output node should have executed"++ # Verify outputs+ images1 = result.get_images(output1)+ images2 = result.get_images(output2)+ assert len(images1) == 1, "Should have produced 1 image from sync node"+ assert len(images2) == 1, "Should have produced 1 image from async node"