Merge 59b955ff54 into bbe2c13a70

comfy_api/latest/_io.py

@@ -1252,6 +1252,23 @@ class NodeInfoV1:
     price_badge: dict | None = None
     search_aliases: list[str]=None
 
+@dataclass
+class NodeInfoV3:
+    input: dict=None
+    output: dict=None
+    hidden: list[str]=None
+    name: str=None
+    display_name: str=None
+    description: str=None
+    python_module: Any = None
+    category: str=None
+    output_node: bool=None
+    deprecated: bool=None
+    experimental: bool=None
+    dev_only: bool=None
+    api_node: bool=None
+    price_badge: dict | None = None
+
 
 @dataclass
 class PriceBadgeDepends:
@@ -1480,6 +1497,40 @@ class Schema:
         )
         return info
 
+
+    def get_v3_info(self, cls) -> NodeInfoV3:
+        input_dict = {}
+        output_dict = {}
+        hidden_list = []
+        # TODO: make sure dynamic types will be handled correctly
+        if self.inputs:
+            for input in self.inputs:
+                add_to_dict_v3(input, input_dict)
+        if self.outputs:
+            for output in self.outputs:
+                add_to_dict_v3(output, output_dict)
+        if self.hidden:
+            for hidden in self.hidden:
+                hidden_list.append(hidden.value)
+
+        info = NodeInfoV3(
+            input=input_dict,
+            output=output_dict,
+            hidden=hidden_list,
+            name=self.node_id,
+            display_name=self.display_name,
+            description=self.description,
+            category=self.category,
+            output_node=self.is_output_node,
+            deprecated=self.is_deprecated,
+            experimental=self.is_experimental,
+            dev_only=self.is_dev_only,
+            api_node=self.is_api_node,
+            python_module=getattr(cls, "RELATIVE_PYTHON_MODULE", "nodes"),
+            price_badge=self.price_badge.as_dict(self.inputs) if self.price_badge is not None else None,
+        )
+        return info
+
 def get_finalized_class_inputs(d: dict[str, Any], live_inputs: dict[str, Any], include_hidden=False) -> tuple[dict[str, Any], V3Data]:
     out_dict = {
         "required": {},
@@ -1534,6 +1585,9 @@ def add_to_dict_v1(i: Input, d: dict):
     as_dict.pop("optional", None)
     d.setdefault(key, {})[i.id] = (i.get_io_type(), as_dict)
 
+def add_to_dict_v3(io: Input | Output, d: dict):
+    d[io.id] = (io.get_io_type(), io.as_dict())
+
 class DynamicPathsDefaultValue:
     EMPTY_DICT = "empty_dict"
 
@@ -1694,6 +1748,13 @@ class _ComfyNodeBaseInternal(_ComfyNodeInternal):
         # set hidden
         type_clone.hidden = HiddenHolder.from_v3_data(v3_data)
         return type_clone
+
+    @final
+    @classmethod
+    def GET_NODE_INFO_V3(cls) -> dict[str, Any]:
+        schema = cls.GET_SCHEMA()
+        info = schema.get_v3_info(cls)
+        return asdict(info)
     #############################################
     # V1 Backwards Compatibility code
     #--------------------------------------------
@@ -2046,10 +2107,12 @@ __all__ = [
     "HiddenHolder",
     "Hidden",
     "NodeInfoV1",
+    "NodeInfoV3",
     "Schema",
     "ComfyNode",
     "NodeOutput",
     "add_to_dict_v1",
+    "add_to_dict_v3",
     "V3Data",
     "ImageCompare",
     "PriceBadgeDepends",

comfy_api_nodes/apis/recraft.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
-from enum import Enum
 
-from pydantic import BaseModel, Field
+
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field, conint, confloat
 
 
 class RecraftColor:
@@ -226,24 +229,24 @@ class RecraftColorObject(BaseModel):
 
 
 class RecraftControlsObject(BaseModel):
-    colors: list[RecraftColorObject] | None = Field(None, description='An array of preferable colors')
-    background_color: RecraftColorObject | None = Field(None, description='Use given color as a desired background color')
-    no_text: bool | None = Field(None, description='Do not embed text layouts')
-    artistic_level: int | None = Field(None, description='Defines artistic tone of your image. At a simple level, the person looks straight at the camera in a static and clean style. Dynamic and eccentric levels introduce movement and creativity. The value should be in range [0..5].')
+    colors: Optional[list[RecraftColorObject]] = Field(None, description='An array of preferable colors')
+    background_color: Optional[RecraftColorObject] = Field(None, description='Use given color as a desired background color')
+    no_text: Optional[bool] = Field(None, description='Do not embed text layouts')
+    artistic_level: Optional[conint(ge=0, le=5)] = Field(None, description='Defines artistic tone of your image. At a simple level, the person looks straight at the camera in a static and clean style. Dynamic and eccentric levels introduce movement and creativity. The value should be in range [0..5].')
 
 
 class RecraftImageGenerationRequest(BaseModel):
     prompt: str = Field(..., description='The text prompt describing the image to generate')
-    size: RecraftImageSize | None = Field(None, description='The size of the generated image (e.g., "1024x1024")')
-    n: int = Field(..., description='The number of images to generate')
-    negative_prompt: str | None = Field(None, description='A text description of undesired elements on an image')
-    model: RecraftModel | None = Field(RecraftModel.recraftv3, description='The model to use for generation (e.g., "recraftv3")')
-    style: str | None = Field(None, description='The style to apply to the generated image (e.g., "digital_illustration")')
-    substyle: str | None = Field(None, description='The substyle to apply to the generated image, depending on the style input')
-    controls: RecraftControlsObject | None = Field(None, description='A set of custom parameters to tweak generation process')
-    style_id: str | None = Field(None, description='Use a previously uploaded style as a reference; UUID')
-    strength: float | None = Field(None, description='Defines the difference with the original image, should lie in [0, 1], where 0 means almost identical, and 1 means miserable similarity')
-    random_seed: int | None = Field(None, description="Seed for video generation")
+    size: Optional[RecraftImageSize] = Field(None, description='The size of the generated image (e.g., "1024x1024")')
+    n: conint(ge=1, le=6) = Field(..., description='The number of images to generate')
+    negative_prompt: Optional[str] = Field(None, description='A text description of undesired elements on an image')
+    model: Optional[RecraftModel] = Field(RecraftModel.recraftv3, description='The model to use for generation (e.g., "recraftv3")')
+    style: Optional[str] = Field(None, description='The style to apply to the generated image (e.g., "digital_illustration")')
+    substyle: Optional[str] = Field(None, description='The substyle to apply to the generated image, depending on the style input')
+    controls: Optional[RecraftControlsObject] = Field(None, description='A set of custom parameters to tweak generation process')
+    style_id: Optional[str] = Field(None, description='Use a previously uploaded style as a reference; UUID')
+    strength: Optional[confloat(ge=0.0, le=1.0)] = Field(None, description='Defines the difference with the original image, should lie in [0, 1], where 0 means almost identical, and 1 means miserable similarity')
+    random_seed: Optional[int] = Field(None, description="Seed for video generation")
     # text_layout
 
 
@@ -255,13 +258,5 @@ class RecraftReturnedObject(BaseModel):
 class RecraftImageGenerationResponse(BaseModel):
     created: int = Field(..., description='Unix timestamp when the generation was created')
     credits: int = Field(..., description='Number of credits used for the generation')
-    data: list[RecraftReturnedObject] | None = Field(None, description='Array of generated image information')
-    image: RecraftReturnedObject | None = Field(None, description='Single generated image')
-
-
-class RecraftCreateStyleRequest(BaseModel):
-    style: str = Field(..., description="realistic_image, digital_illustration, vector_illustration, or icon")
-
-
-class RecraftCreateStyleResponse(BaseModel):
-    id: str = Field(..., description="UUID of the created style")
+    data: Optional[list[RecraftReturnedObject]] = Field(None, description='Array of generated image information')
+    image: Optional[RecraftReturnedObject] = Field(None, description='Single generated image')

comfy_api_nodes/nodes_recraft.py

@@ -12,8 +12,6 @@ from comfy_api_nodes.apis.recraft import (
     RecraftColor,
     RecraftColorChain,
     RecraftControls,
-    RecraftCreateStyleRequest,
-    RecraftCreateStyleResponse,
     RecraftImageGenerationRequest,
     RecraftImageGenerationResponse,
     RecraftImageSize,
@@ -325,75 +323,6 @@ class RecraftStyleInfiniteStyleLibrary(IO.ComfyNode):
         return IO.NodeOutput(RecraftStyle(style_id=style_id))
 
 
-class RecraftCreateStyleNode(IO.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="RecraftCreateStyleNode",
-            display_name="Recraft Create Style",
-            category="api node/image/Recraft",
-            description="Create a custom style from reference images. "
-            "Upload 1-5 images to use as style references. "
-            "Total size of all images is limited to 5 MB.",
-            inputs=[
-                IO.Combo.Input(
-                    "style",
-                    options=["realistic_image", "digital_illustration"],
-                    tooltip="The base style of the generated images.",
-                ),
-                IO.Autogrow.Input(
-                    "images",
-                    template=IO.Autogrow.TemplatePrefix(
-                        IO.Image.Input("image"),
-                        prefix="image",
-                        min=1,
-                        max=5,
-                    ),
-                ),
-            ],
-            outputs=[
-                IO.String.Output(display_name="style_id"),
-            ],
-            hidden=[
-                IO.Hidden.auth_token_comfy_org,
-                IO.Hidden.api_key_comfy_org,
-                IO.Hidden.unique_id,
-            ],
-            is_api_node=True,
-            price_badge=IO.PriceBadge(
-                expr="""{"type":"usd","usd": 0.04}""",
-            ),
-        )
-
-    @classmethod
-    async def execute(
-        cls,
-        style: str,
-        images: IO.Autogrow.Type,
-    ) -> IO.NodeOutput:
-        files = []
-        total_size = 0
-        max_total_size = 5 * 1024 * 1024  # 5 MB limit
-        for i, img in enumerate(list(images.values())):
-            file_bytes = tensor_to_bytesio(img, total_pixels=2048 * 2048, mime_type="image/webp").read()
-            total_size += len(file_bytes)
-            if total_size > max_total_size:
-                raise Exception("Total size of all images exceeds 5 MB limit.")
-            files.append((f"file{i + 1}", file_bytes))
-
-        response = await sync_op(
-            cls,
-            endpoint=ApiEndpoint(path="/proxy/recraft/styles", method="POST"),
-            response_model=RecraftCreateStyleResponse,
-            files=files,
-            data=RecraftCreateStyleRequest(style=style),
-            content_type="multipart/form-data",
-            max_retries=1,
-        )
-
-        return IO.NodeOutput(response.id)
-
-
 class RecraftTextToImageNode(IO.ComfyNode):
     @classmethod
     def define_schema(cls):
@@ -466,7 +395,7 @@ class RecraftTextToImageNode(IO.ComfyNode):
         negative_prompt: str = None,
         recraft_controls: RecraftControls = None,
     ) -> IO.NodeOutput:
-        validate_string(prompt, strip_whitespace=False, min_length=1, max_length=1000)
+        validate_string(prompt, strip_whitespace=False, max_length=1000)
         default_style = RecraftStyle(RecraftStyleV3.realistic_image)
         if recraft_style is None:
             recraft_style = default_style
@@ -1095,7 +1024,6 @@ class RecraftExtension(ComfyExtension):
             RecraftStyleV3DigitalIllustrationNode,
             RecraftStyleV3LogoRasterNode,
             RecraftStyleInfiniteStyleLibrary,
-            RecraftCreateStyleNode,
             RecraftColorRGBNode,
             RecraftControlsNode,
         ]

comfy_extras/nodes_glsl.py

@@ -19,15 +19,12 @@ logger = logging.getLogger(__name__)
 
 def _check_opengl_availability():
     """Early check for OpenGL availability. Raises RuntimeError if unlikely to work."""
-    logger.debug("_check_opengl_availability: starting")
     missing = []
 
     # Check Python packages (using find_spec to avoid importing)
-    logger.debug("_check_opengl_availability: checking for glfw package")
     if importlib.util.find_spec("glfw") is None:
         missing.append("glfw")
 
-    logger.debug("_check_opengl_availability: checking for OpenGL package")
     if importlib.util.find_spec("OpenGL") is None:
         missing.append("PyOpenGL")
 
@@ -37,15 +34,11 @@ def _check_opengl_availability():
         )
 
     # On Linux without display, check if headless backends are available
-    logger.debug(f"_check_opengl_availability: platform={sys.platform}")
     if sys.platform.startswith("linux"):
         has_display = os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY")
-        logger.debug(f"_check_opengl_availability: has_display={bool(has_display)}")
         if not has_display:
             # Check for EGL or OSMesa libraries
-            logger.debug("_check_opengl_availability: checking for EGL library")
             has_egl = ctypes.util.find_library("EGL")
-            logger.debug("_check_opengl_availability: checking for OSMesa library")
             has_osmesa = ctypes.util.find_library("OSMesa")
 
             # Error disabled for CI as it fails this check
@@ -56,11 +49,8 @@ def _check_opengl_availability():
             #     )
             logger.debug(f"Headless mode: EGL={'yes' if has_egl else 'no'}, OSMesa={'yes' if has_osmesa else 'no'}")
 
-    logger.debug("_check_opengl_availability: completed")
-
 
 # Run early check at import time
-logger.debug("nodes_glsl: running _check_opengl_availability at import time")
 _check_opengl_availability()
 
 # OpenGL modules - initialized lazily when context is created
@@ -73,10 +63,8 @@ def _import_opengl():
     """Import OpenGL module. Called after context is created."""
     global gl
     if gl is None:
-        logger.debug("_import_opengl: importing OpenGL.GL")
         import OpenGL.GL as _gl
         gl = _gl
-        logger.debug("_import_opengl: import completed")
     return gl
 
 
@@ -148,44 +136,30 @@ def _detect_output_count(source: str) -> int:
 
 def _init_glfw():
     """Initialize GLFW. Returns (window, glfw_module). Raises RuntimeError on failure."""
-    logger.debug("_init_glfw: starting")
-    # On macOS, glfw.init() must be called from main thread or it hangs forever
-    if sys.platform == "darwin":
-        logger.debug("_init_glfw: skipping on macOS")
-        raise RuntimeError("GLFW backend not supported on macOS")
-
-    logger.debug("_init_glfw: importing glfw module")
     import glfw as _glfw
 
-    logger.debug("_init_glfw: calling glfw.init()")
     if not _glfw.init():
         raise RuntimeError("glfw.init() failed")
 
     try:
-        logger.debug("_init_glfw: setting window hints")
         _glfw.window_hint(_glfw.VISIBLE, _glfw.FALSE)
         _glfw.window_hint(_glfw.CONTEXT_VERSION_MAJOR, 3)
         _glfw.window_hint(_glfw.CONTEXT_VERSION_MINOR, 3)
         _glfw.window_hint(_glfw.OPENGL_PROFILE, _glfw.OPENGL_CORE_PROFILE)
 
-        logger.debug("_init_glfw: calling create_window()")
         window = _glfw.create_window(64, 64, "ComfyUI GLSL", None, None)
         if not window:
             raise RuntimeError("glfw.create_window() failed")
 
-        logger.debug("_init_glfw: calling make_context_current()")
         _glfw.make_context_current(window)
-        logger.debug("_init_glfw: completed successfully")
         return window, _glfw
     except Exception:
-        logger.debug("_init_glfw: failed, terminating glfw")
         _glfw.terminate()
         raise
 
 
 def _init_egl():
     """Initialize EGL for headless rendering. Returns (display, context, surface, EGL_module). Raises RuntimeError on failure."""
-    logger.debug("_init_egl: starting")
     from OpenGL import EGL as _EGL
     from OpenGL.EGL import (
         eglGetDisplay, eglInitialize, eglChooseConfig, eglCreateContext,
@@ -196,24 +170,20 @@ def _init_egl():
         EGL_RED_SIZE, EGL_GREEN_SIZE, EGL_BLUE_SIZE, EGL_ALPHA_SIZE, EGL_DEPTH_SIZE,
         EGL_WIDTH, EGL_HEIGHT, EGL_OPENGL_API,
     )
-    logger.debug("_init_egl: imports completed")
 
     display = None
     context = None
     surface = None
 
     try:
-        logger.debug("_init_egl: calling eglGetDisplay()")
         display = eglGetDisplay(EGL_DEFAULT_DISPLAY)
         if display == _EGL.EGL_NO_DISPLAY:
             raise RuntimeError("eglGetDisplay() failed")
 
-        logger.debug("_init_egl: calling eglInitialize()")
         major, minor = _EGL.EGLint(), _EGL.EGLint()
         if not eglInitialize(display, major, minor):
             display = None  # Not initialized, don't terminate
             raise RuntimeError("eglInitialize() failed")
-        logger.debug(f"_init_egl: EGL version {major.value}.{minor.value}")
 
         config_attribs = [
             EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
@@ -226,12 +196,10 @@ def _init_egl():
         if not eglChooseConfig(display, config_attribs, configs, 1, num_configs) or num_configs.value == 0:
             raise RuntimeError("eglChooseConfig() failed")
         config = configs[0]
-        logger.debug(f"_init_egl: config chosen, num_configs={num_configs.value}")
 
         if not eglBindAPI(EGL_OPENGL_API):
             raise RuntimeError("eglBindAPI() failed")
 
-        logger.debug("_init_egl: calling eglCreateContext()")
         context_attribs = [
             _EGL.EGL_CONTEXT_MAJOR_VERSION, 3,
             _EGL.EGL_CONTEXT_MINOR_VERSION, 3,
@@ -242,21 +210,17 @@ def _init_egl():
         if context == EGL_NO_CONTEXT:
             raise RuntimeError("eglCreateContext() failed")
 
-        logger.debug("_init_egl: calling eglCreatePbufferSurface()")
         pbuffer_attribs = [EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE]
         surface = eglCreatePbufferSurface(display, config, pbuffer_attribs)
         if surface == _EGL.EGL_NO_SURFACE:
             raise RuntimeError("eglCreatePbufferSurface() failed")
 
-        logger.debug("_init_egl: calling eglMakeCurrent()")
         if not eglMakeCurrent(display, surface, surface, context):
             raise RuntimeError("eglMakeCurrent() failed")
 
-        logger.debug("_init_egl: completed successfully")
         return display, context, surface, _EGL
 
     except Exception:
-        logger.debug("_init_egl: failed, cleaning up")
         # Clean up any resources on failure
         if surface is not None:
             eglDestroySurface(display, surface)
@@ -271,16 +235,13 @@ def _init_osmesa():
     """Initialize OSMesa for software rendering. Returns (context, buffer). Raises RuntimeError on failure."""
     import ctypes
 
-    logger.debug("_init_osmesa: starting")
     os.environ["PYOPENGL_PLATFORM"] = "osmesa"
 
-    logger.debug("_init_osmesa: importing OpenGL.osmesa")
     from OpenGL import GL as _gl
     from OpenGL.osmesa import (
         OSMesaCreateContextExt, OSMesaMakeCurrent, OSMesaDestroyContext,
         OSMESA_RGBA,
     )
-    logger.debug("_init_osmesa: imports completed")
 
     ctx = OSMesaCreateContextExt(OSMESA_RGBA, 24, 0, 0, None)
     if not ctx:
@@ -289,12 +250,10 @@ def _init_osmesa():
     width, height = 64, 64
     buffer = (ctypes.c_ubyte * (width * height * 4))()
 
-    logger.debug("_init_osmesa: calling OSMesaMakeCurrent()")
     if not OSMesaMakeCurrent(ctx, buffer, _gl.GL_UNSIGNED_BYTE, width, height):
         OSMesaDestroyContext(ctx)
         raise RuntimeError("OSMesaMakeCurrent() failed")
 
-    logger.debug("_init_osmesa: completed successfully")
     return ctx, buffer
 
 
@@ -314,12 +273,9 @@ class GLContext:
 
     def __init__(self):
         if GLContext._initialized:
-            logger.debug("GLContext.__init__: already initialized, skipping")
             return
         GLContext._initialized = True
 
-        logger.debug("GLContext.__init__: starting initialization")
-
         global glfw, EGL
 
         import time
@@ -336,33 +292,24 @@ class GLContext:
         # Try backends in order: GLFW → EGL → OSMesa
         errors = []
 
-        logger.debug("GLContext.__init__: trying GLFW backend")
         try:
             self._window, glfw = _init_glfw()
             self._backend = "glfw"
-            logger.debug("GLContext.__init__: GLFW backend succeeded")
         except Exception as e:
-            logger.debug(f"GLContext.__init__: GLFW backend failed: {e}")
             errors.append(("GLFW", e))
 
         if self._backend is None:
-            logger.debug("GLContext.__init__: trying EGL backend")
             try:
                 self._egl_display, self._egl_context, self._egl_surface, EGL = _init_egl()
                 self._backend = "egl"
-                logger.debug("GLContext.__init__: EGL backend succeeded")
             except Exception as e:
-                logger.debug(f"GLContext.__init__: EGL backend failed: {e}")
                 errors.append(("EGL", e))
 
         if self._backend is None:
-            logger.debug("GLContext.__init__: trying OSMesa backend")
             try:
                 self._osmesa_ctx, self._osmesa_buffer = _init_osmesa()
                 self._backend = "osmesa"
-                logger.debug("GLContext.__init__: OSMesa backend succeeded")
             except Exception as e:
-                logger.debug(f"GLContext.__init__: OSMesa backend failed: {e}")
                 errors.append(("OSMesa", e))
 
         if self._backend is None:
@@ -373,9 +320,7 @@ class GLContext:
                 )
             elif sys.platform == "darwin":
                 platform_help = (
-                    "macOS: GLFW is not supported.\n"
-                    "  Install OSMesa via Homebrew: brew install mesa\n"
-                    "  Then: pip install PyOpenGL PyOpenGL-accelerate"
+                    "macOS: Ensure display is available. For headless, try virtual display."
                 )
             else:
                 platform_help = (
@@ -389,23 +334,20 @@ class GLContext:
             raise RuntimeError(
                 f"Failed to create OpenGL context.\n\n"
                 f"Backend errors:\n{error_details}\n\n"
-                f"{platform_help}"
+                f"{platform_help}\n\n"
+                "Python packages: pip install PyOpenGL PyOpenGL-accelerate glfw"
             )
 
         # Now import OpenGL.GL (after context is current)
-        logger.debug("GLContext.__init__: importing OpenGL.GL")
         _import_opengl()
 
         # Create VAO (required for core profile, but OSMesa may use compat profile)
-        logger.debug("GLContext.__init__: creating VAO")
         self._vao = None
         try:
             vao = gl.glGenVertexArrays(1)
             gl.glBindVertexArray(vao)
             self._vao = vao  # Only store after successful bind
-            logger.debug("GLContext.__init__: VAO created successfully")
-        except Exception as e:
-            logger.debug(f"GLContext.__init__: VAO creation failed (may be expected for OSMesa): {e}")
+        except Exception:
             # OSMesa with older Mesa may not support VAOs
             # Clean up if we created but couldn't bind
             if vao: