comfy-ui-api-workflow 0.0.1__tar.gz → 0.0.2__tar.gz

{comfy_ui_api_workflow-0.0.1 → comfy_ui_api_workflow-0.0.2}/.gitignore

@@ -1,4 +1,5 @@
 #  Custom
+dynamic-nodes.tdd.md
 .venv
 dist
 video_wan2_2_14B_i2v.json

{comfy_ui_api_workflow-0.0.1 → comfy_ui_api_workflow-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: comfy-ui-api-workflow
-Version: 0.0.1
+Version: 0.0.2
 Summary: Run ComfyUI workflows through the ComfyUI API.
 Project-URL: Documentation, https://github.com/fabioantonioastore/comfy-ui-api-workflow#readme
 Project-URL: Issues, https://github.com/fabioantonioastore/comfy-ui-api-workflow/issues
@@ -27,7 +27,7 @@ Description-Content-Type: text/markdown
 Build [ComfyUI](https://github.com/comfyanonymous/ComfyUI) workflows in Python
 and export them in the API format that ComfyUI's `POST /prompt` endpoint runs.
 
-- **618 ComfyUI nodes as Python classes**, from `KSampler` to Wan, LTXV, Flux,
+- **665 ComfyUI nodes as Python classes**, from `KSampler` to Wan, LTXV, Flux,
   3D and partner API nodes.
 - **Checked as you build**: input types, `min`/`max` ranges, combo choices,
   output names, socket types (no `LATENT` into a `CLIP` input) and cycles. A bad

{comfy_ui_api_workflow-0.0.1 → comfy_ui_api_workflow-0.0.2}/README.md

@@ -3,7 +3,7 @@
 Build [ComfyUI](https://github.com/comfyanonymous/ComfyUI) workflows in Python
 and export them in the API format that ComfyUI's `POST /prompt` endpoint runs.
 
-- **618 ComfyUI nodes as Python classes**, from `KSampler` to Wan, LTXV, Flux,
+- **665 ComfyUI nodes as Python classes**, from `KSampler` to Wan, LTXV, Flux,
   3D and partner API nodes.
 - **Checked as you build**: input types, `min`/`max` ranges, combo choices,
   output names, socket types (no `LATENT` into a `CLIP` input) and cycles. A bad

comfy_ui_api_workflow-0.0.2/comfy_ui_api_workflow/__about__.py

@@ -0,0 +1 @@
+version = "0.0.2"

{comfy_ui_api_workflow-0.0.1 → comfy_ui_api_workflow-0.0.2}/comfy_ui_api_workflow/_impl/nodes/audio.py

@@ -2,6 +2,7 @@ from typing import Any, Literal, get_args
 
 from .base import BaseNode
 from .validation import validate_choice, validate_not_empty, validate_range
+from .dynamic import Choice, Combo, DynamicInputs, validate_dynamic
 
 
 class LoadAudio(BaseNode):
@@ -258,3 +259,62 @@ class AudioEqualizer3Band(BaseNode):
         validate_range("mid_q", self.mid_q, 0.1, 10.0)
         validate_range("high_gain_dB", self.high_gain_dB, -24.0, 24.0)
         validate_range("high_freq", self.high_freq, 1000, 15_000)
+
+
+SaveAudioAdvanced_Formats = Literal["flac", "mp3", "opus"]
+
+
+SaveAudioAdvanced_Format_Qualitys = Literal["V0", "128k", "320k", "64k", "96k", "192k"]
+
+
+class SaveAudioAdvanced(DynamicInputs, BaseNode):
+    __slots__ = (
+        "audio",
+        "filename_prefix",
+        "format",
+        "format_quality",
+    )
+    CATEGORY = "audio"
+    OUTPUTS = {"audio": 0}
+    RETURN_TYPES = ("AUDIO",)
+    INPUT_NAMES = {"format_quality": "format.quality"}
+    INPUT_SOCKET_TYPES = {
+        "audio": "AUDIO",
+        "filename_prefix": "STRING",
+        "format": "COMFY_DYNAMICCOMBO_V3",
+        "format_quality": "COMBO",
+    }
+    DYNAMIC_INPUTS = {
+        "format": Combo(
+            {
+                "flac": {},
+                "mp3": {"format_quality": Choice(("V0", "128k", "320k"), default="V0")},
+                "opus": {
+                    "format_quality": Choice(
+                        ("64k", "96k", "128k", "192k", "320k"), default="128k"
+                    )
+                },
+            }
+        )
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        audio: tuple[str, int],
+        filename_prefix: str | tuple[str, int] = "audio/ComfyUI",
+        format: SaveAudioAdvanced_Formats = "flac",
+        format_quality: (
+            SaveAudioAdvanced_Format_Qualitys | tuple[str, int] | None
+        ) = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.audio = audio
+        self.filename_prefix = filename_prefix
+        self.format = format
+        if format_quality is not None:
+            self.format_quality = format_quality
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_dynamic(self)

comfy_ui_api_workflow-0.0.2/comfy_ui_api_workflow/_impl/nodes/dynamic.py

@@ -0,0 +1,222 @@
+from collections.abc import Callable, Iterator
+from typing import Any, ClassVar
+
+from ..errors.node import InvalidNodeParameterValue
+from .base import _api_value
+from .validation import (
+    validate_bool,
+    validate_choice,
+    validate_not_empty,
+    validate_range,
+)
+
+_NO_DEFAULT = object()
+
+
+# An input that only exists inside a branch of a dynamic combo or a row of a
+# dynamic group. One with a default is sent with it when not given, as the
+# ComfyUI frontend does; ComfyUI rejects a prompt missing a required input.
+class Value:
+    __slots__ = ("default", "required", "check")
+
+    def __init__(
+        self,
+        default: Any = _NO_DEFAULT,
+        required: bool = True,
+        check: Callable[[str, Any], None] | None = None,
+    ) -> None:
+        self.default = default
+        self.required = required
+        self.check = check
+
+    def validate(self, name: str, value: Any) -> None:
+        if self.check is not None:
+            self.check(name, value)
+
+
+def Number(
+    default: Any = _NO_DEFAULT,
+    low: int | float | None = None,
+    high: int | float | None = None,
+    required: bool = True,
+) -> Value:
+    def check(name: str, value: Any) -> None:
+        validate_range(name, value, low, high)
+
+    return Value(default, required, check)
+
+
+def Choice(
+    options: tuple[Any, ...], default: Any = _NO_DEFAULT, required: bool = True
+) -> Value:
+    choices = frozenset(options)
+
+    def check(name: str, value: Any) -> None:
+        validate_choice(name, value, choices)
+
+    return Value(default, required, check)
+
+
+def ServerChoice(required: bool = True) -> Value:
+    return Value(required=required, check=validate_not_empty)
+
+
+def Flag(default: Any = _NO_DEFAULT, required: bool = True) -> Value:
+    return Value(default, required, validate_bool)
+
+
+def Text(default: Any = _NO_DEFAULT, required: bool = True) -> Value:
+    return Value(default, required)
+
+
+def Link(required: bool = True) -> Value:
+    return Value(required=required)
+
+
+def _one_of(keys: list[str]) -> str:
+    return repr(keys[0]) if len(keys) == 1 else f"one of {keys}"
+
+
+# A dynamic combo: each option opens its own inputs, sent as "<combo>.<input>"
+# and set here as <combo>_<input>. An attribute can be in several branches, each
+# with its own default and checks; the first option is the default one.
+class Combo:
+    __slots__ = ("branches",)
+
+    def __init__(self, branches: dict[str, dict[str, "Value | Combo"]]) -> None:
+        self.branches = branches
+
+    @property
+    def default(self) -> str:
+        return next(iter(self.branches))
+
+    def attributes(self, branch: str | None = None) -> set[str]:
+        keys = self.branches if branch is None else (branch,)
+        found: set[str] = set()
+        for key in keys:
+            for name, spec in self.branches[key].items():
+                found.add(name)
+                if isinstance(spec, Combo):
+                    found |= spec.attributes()
+        return found
+
+    def validate(self, node: Any, name: str, value: Any) -> None:
+        validate_choice(name, value, frozenset(self.branches))
+        for attribute in sorted(self.attributes() - self.attributes(value)):
+            if getattr(node, attribute, None) is not None:
+                keys = [
+                    key for key in self.branches if attribute in self.attributes(key)
+                ]
+                raise InvalidNodeParameterValue(
+                    f"{attribute} only applies when {name} is {_one_of(keys)}"
+                )
+        for attribute, spec in self.branches[value].items():
+            given = getattr(node, attribute, None)
+            if isinstance(spec, Combo):
+                chosen = spec.default if given is None else given
+                spec.validate(node, attribute, chosen)
+            elif given is not None:
+                spec.validate(attribute, given)
+            elif spec.required and spec.default is _NO_DEFAULT:
+                raise InvalidNodeParameterValue(
+                    f"{attribute} is required when {name} is {value!r}"
+                )
+
+    def defaults(self, node: Any, value: Any) -> Iterator[tuple[str, Any]]:
+        for attribute, spec in self.branches[value].items():
+            given = getattr(node, attribute, None)
+            if isinstance(spec, Combo):
+                if given is None:
+                    given = spec.default
+                    yield attribute, given
+                yield from spec.defaults(node, given)
+            elif given is None and spec.default is not _NO_DEFAULT:
+                yield attribute, spec.default
+
+
+# A dynamic group: rows of the same fields, sent as "<group>.<row>.<field>" and
+# set here as <group>_<row>_<field>. A row is used when any of its fields is set;
+# the rows a node needs at least have their required fields as constructor
+# parameters, so they are always there.
+class Group:
+    __slots__ = ("rows", "fields")
+
+    def __init__(self, rows: int, fields: dict[str, Value]) -> None:
+        self.rows = rows
+        self.fields = fields
+
+    def attribute(self, name: str, row: int, field: str) -> str:
+        return f"{name}_{row}_{field}"
+
+    def used_rows(self, node: Any, name: str) -> list[int]:
+        return [
+            row
+            for row in range(self.rows)
+            if any(
+                getattr(node, self.attribute(name, row, field), None) is not None
+                for field in self.fields
+            )
+        ]
+
+    def validate(self, node: Any, name: str) -> None:
+        for row in self.used_rows(node, name):
+            for field, spec in self.fields.items():
+                attribute = self.attribute(name, row, field)
+                given = getattr(node, attribute, None)
+                if given is not None:
+                    spec.validate(attribute, given)
+                elif spec.required and spec.default is _NO_DEFAULT:
+                    raise InvalidNodeParameterValue(
+                        f"{attribute} is required in row {row} of {name}"
+                    )
+
+    def defaults(self, node: Any, name: str) -> Iterator[tuple[str, Any]]:
+        for row in self.used_rows(node, name):
+            for field, spec in self.fields.items():
+                attribute = self.attribute(name, row, field)
+                if (
+                    getattr(node, attribute, None) is None
+                    and spec.default is not _NO_DEFAULT
+                ):
+                    yield attribute, spec.default
+
+
+def validate_dynamic(node: Any) -> None:
+    for name, spec in type(node).DYNAMIC_INPUTS.items():
+        if isinstance(spec, Group):
+            spec.validate(node, name)
+        else:
+            spec.validate(node, name, getattr(node, name))
+
+
+# Mixed in before BaseNode by the nodes with dynamic combos or groups: the
+# ComfyUI format also carries the defaults of the chosen branches and rows,
+# which are not stored, so changing a branch never leaves stale inputs behind.
+class DynamicInputs:
+    __slots__ = ()
+    DYNAMIC_INPUTS: ClassVar[dict[str, Combo | Group]] = {}
+
+    def get_comfy_ui_workflow_format(self) -> dict[str, Any]:
+        node_type = type(self)
+        values = self.inputs()  # type: ignore
+        for name, spec in node_type.DYNAMIC_INPUTS.items():
+            if isinstance(spec, Group):
+                values.update(spec.defaults(self, name))
+            else:
+                values.update(spec.defaults(self, getattr(self, name)))
+        order = [
+            name
+            for cls in reversed(node_type.__mro__)
+            for name in cls.__dict__.get("__slots__", ())
+        ]
+        inputs = {
+            node_type.INPUT_NAMES.get(name, name): _api_value(values[name])  # type: ignore
+            for name in order
+            if name in values
+        }
+        return {
+            self.node_id: {  # type: ignore
+                "class_type": node_type.CLASS_TYPE,  # type: ignore
+                "inputs": inputs,
+            }
+        }

{comfy_ui_api_workflow-0.0.1 → comfy_ui_api_workflow-0.0.2}/comfy_ui_api_workflow/_impl/nodes/image/__init__.py

@@ -8,6 +8,7 @@ from ..validation import (
     validate_range,
 )
 from ...lazy import submodules_of
+from ..dynamic import Choice, Combo, DynamicInputs, Number, validate_dynamic
 
 
 class SaveImage(BaseNode):
@@ -598,4 +599,138 @@ class SaveImageWebsocket(BaseNode):
         self.images = images
 
 
+SaveImageAdvanced_Formats = Literal["png", "exr", "avif"]
+
+
+SaveImageAdvanced_Format_Bit_Depths = Literal[
+    "8-bit",
+    "16-bit",
+    "32-bit float",
+    "16-bit float",
+    "auto",
+    "8-bit YUV420",
+    "10-bit YUV420",
+]
+
+
+SaveImageAdvanced_Format_Input_Color_Spaces = Literal["sRGB", "HDR", "linear", "HDR PQ"]
+
+
+SaveImageAdvanced_Format_Save_Modes = Literal["still images", "animated"]
+
+
+class SaveImageAdvanced(DynamicInputs, BaseNode):
+    __slots__ = (
+        "images",
+        "filename_prefix",
+        "format",
+        "format_bit_depth",
+        "format_input_color_space",
+        "format_crf",
+        "format_save_mode",
+        "format_save_mode_fps",
+        "format_save_mode_loop_count",
+    )
+    CATEGORY = "image"
+    OUTPUTS = {"images": 0}
+    RETURN_TYPES = ("IMAGE",)
+    INPUT_NAMES = {
+        "format_bit_depth": "format.bit_depth",
+        "format_input_color_space": "format.input_color_space",
+        "format_crf": "format.crf",
+        "format_save_mode": "format.save_mode",
+        "format_save_mode_fps": "format.save_mode.fps",
+        "format_save_mode_loop_count": "format.save_mode.loop_count",
+    }
+    INPUT_SOCKET_TYPES = {
+        "images": "IMAGE",
+        "filename_prefix": "STRING",
+        "format": "COMFY_DYNAMICCOMBO_V3",
+        "format_bit_depth": "COMBO",
+        "format_input_color_space": "COMBO",
+        "format_crf": "INT",
+        "format_save_mode": "COMFY_DYNAMICCOMBO_V3",
+        "format_save_mode_fps": "FLOAT",
+        "format_save_mode_loop_count": "INT",
+    }
+    DYNAMIC_INPUTS = {
+        "format": Combo(
+            {
+                "png": {
+                    "format_bit_depth": Choice(("8-bit", "16-bit"), default="8-bit"),
+                    "format_input_color_space": Choice(("sRGB",), default="sRGB"),
+                },
+                "exr": {
+                    "format_bit_depth": Choice(
+                        ("32-bit float", "16-bit float"), default="16-bit float"
+                    ),
+                    "format_input_color_space": Choice(
+                        ("sRGB", "HDR", "linear"), default="sRGB"
+                    ),
+                },
+                "avif": {
+                    "format_bit_depth": Choice(
+                        ("auto", "8-bit YUV420", "10-bit YUV420"), default="auto"
+                    ),
+                    "format_input_color_space": Choice(
+                        ("sRGB", "HDR", "HDR PQ"), default="sRGB"
+                    ),
+                    "format_crf": Number(default=18, low=1, high=63),
+                    "format_save_mode": Combo(
+                        {
+                            "still images": {},
+                            "animated": {
+                                "format_save_mode_fps": Number(
+                                    default=6.0, low=0.01, high=1000.0
+                                ),
+                                "format_save_mode_loop_count": Number(
+                                    default=0, low=0, high=1000
+                                ),
+                            },
+                        }
+                    ),
+                },
+            }
+        )
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        images: tuple[str, int],
+        filename_prefix: str | tuple[str, int] = "ComfyUI",
+        format: SaveImageAdvanced_Formats = "png",
+        format_bit_depth: (
+            SaveImageAdvanced_Format_Bit_Depths | tuple[str, int] | None
+        ) = None,
+        format_input_color_space: (
+            SaveImageAdvanced_Format_Input_Color_Spaces | tuple[str, int] | None
+        ) = None,
+        format_crf: int | tuple[str, int] | None = None,
+        format_save_mode: SaveImageAdvanced_Format_Save_Modes | None = None,
+        format_save_mode_fps: float | tuple[str, int] | None = None,
+        format_save_mode_loop_count: int | tuple[str, int] | None = None,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.images = images
+        self.filename_prefix = filename_prefix
+        self.format = format
+        if format_bit_depth is not None:
+            self.format_bit_depth = format_bit_depth
+        if format_input_color_space is not None:
+            self.format_input_color_space = format_input_color_space
+        if format_crf is not None:
+            self.format_crf = format_crf
+        if format_save_mode is not None:
+            self.format_save_mode = format_save_mode
+        if format_save_mode_fps is not None:
+            self.format_save_mode_fps = format_save_mode_fps
+        if format_save_mode_loop_count is not None:
+            self.format_save_mode_loop_count = format_save_mode_loop_count
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_dynamic(self)
+
+
 __getattr__ = submodules_of(__name__)