comfy-ui-api-workflow 0.0.1__tar.gz

comfy_ui_api_workflow-0.0.1/.gitignore

@@ -0,0 +1,231 @@
+#  Custom
+.venv
+dist
+video_wan2_2_14B_i2v.json
+incremental-dag.tdd.md
+new_object_info.json
+workflow-ksampler.tdd.md
+/docs
+.env
+/runpod_outputs
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+*.lcov
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# uv
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi/*
+!.pixi/config.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule*
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs/Zensical documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore that
+#   can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, you
+#   could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

comfy_ui_api_workflow-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fabio Antonio Astore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

comfy_ui_api_workflow-0.0.1/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.5
+Name: comfy-ui-api-workflow
+Version: 0.0.1
+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
+Project-URL: Source, https://github.com/fabioantonioastore/comfy-ui-api-workflow
+Author: Fabio Antonio Astore
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api,comfyui,workflow
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# comfy-ui-api-workflow
+
+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,
+  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
+  workflow fails in your code with a clear message, not in the ComfyUI queue.
+- **Pipelines**: reusable groups of nodes with typed parameters and named
+  outputs, added all or nothing.
+- **Round trip**: load a workflow saved with ComfyUI's *Export (API)*, change it
+  from Python, export it again.
+- No dependencies. Python 3.10+.
+
+## Installation
+
+```bash
+pip install git+https://github.com/fabioantonioastore/comfy-ui-api-workflow
+```
+
+## Quick start
+
+```python
+import json
+
+from comfy_ui_api_workflow import Workflow, nodes
+
+workflow = Workflow()
+checkpoint = workflow.add_node(
+    nodes.model.loaders.CheckpointLoaderSimple, ckpt_name="sd_xl_base_1.0.safetensors"
+)
+prompt = workflow.add_node(
+    nodes.model.conditioning.CLIPTextEncode,
+    text="a lighthouse at dusk",
+    clip=checkpoint.output["CLIP"],
+)
+negative = workflow.add_node(
+    nodes.model.conditioning.CLIPTextEncode, text="blurry", clip=checkpoint.output["CLIP"]
+)
+latent = workflow.add_node(
+    nodes.model.latent.EmptyLatentImage, width=1024, height=1024, batch_size=1
+)
+sampler = workflow.add_node(
+    nodes.model.sampling.KSampler,
+    model=checkpoint.output["MODEL"],
+    positive=prompt.output["CONDITIONING"],
+    negative=negative.output["CONDITIONING"],
+    latent_image=latent.output["LATENT"],
+    sampler_name="dpmpp_2m",
+    scheduler="karras",
+    steps=25,
+    cfg=7.0,
+)
+image = workflow.add_node(
+    nodes.model.latent.VAEDecode, samples=sampler.output["LATENT"], vae=checkpoint.output["VAE"]
+)
+workflow.add_node(nodes.image.SaveImage, images=image.output["IMAGE"], filename_prefix="lighthouse")
+
+print(json.dumps(workflow.get_comfy_ui_workflow_format(), indent=2))
+```
+
+The printed JSON is what ComfyUI's `/prompt` endpoint takes as `prompt`.
+
+Mistakes are caught right away:
+
+```python
+from comfy_ui_api_workflow import Workflow, errors, nodes
+
+workflow = Workflow()
+latent = workflow.add_node(nodes.model.latent.EmptyLatentImage, width=512, height=512)
+
+try:
+    latent.width = 8
+except errors.node.InvalidNodeParameterValue as error:
+    print(error)  # width must be in closed range: [16, 16384]
+```
+
+## Documentation
+
+- [User guide](docs/guide.md): workflows, links, validation, changing nodes,
+  pipelines, loading and exporting, running on ComfyUI, errors.
+- [API reference](docs/api.md): every public class, method, attribute and error.
+- [Custom nodes](docs/custom_nodes.md): classes for nodes from custom node packs.
+- [Node catalog](docs/nodes.md): every node with its inputs and outputs.
+- [`examples/`](examples): runnable scripts with pipelines and nodes.
+
+## Development
+
+```bash
+hatch test             # unit tests (RunPod tests are skipped)
+hatch test --cover     # with coverage
+hatch test -- --runpod # also send real jobs to the RunPod endpoint in .env (paid GPU)
+```
+
+## License
+
+MIT

comfy_ui_api_workflow-0.0.1/README.md

@@ -0,0 +1,99 @@
+# comfy-ui-api-workflow
+
+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,
+  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
+  workflow fails in your code with a clear message, not in the ComfyUI queue.
+- **Pipelines**: reusable groups of nodes with typed parameters and named
+  outputs, added all or nothing.
+- **Round trip**: load a workflow saved with ComfyUI's *Export (API)*, change it
+  from Python, export it again.
+- No dependencies. Python 3.10+.
+
+## Installation
+
+```bash
+pip install git+https://github.com/fabioantonioastore/comfy-ui-api-workflow
+```
+
+## Quick start
+
+```python
+import json
+
+from comfy_ui_api_workflow import Workflow, nodes
+
+workflow = Workflow()
+checkpoint = workflow.add_node(
+    nodes.model.loaders.CheckpointLoaderSimple, ckpt_name="sd_xl_base_1.0.safetensors"
+)
+prompt = workflow.add_node(
+    nodes.model.conditioning.CLIPTextEncode,
+    text="a lighthouse at dusk",
+    clip=checkpoint.output["CLIP"],
+)
+negative = workflow.add_node(
+    nodes.model.conditioning.CLIPTextEncode, text="blurry", clip=checkpoint.output["CLIP"]
+)
+latent = workflow.add_node(
+    nodes.model.latent.EmptyLatentImage, width=1024, height=1024, batch_size=1
+)
+sampler = workflow.add_node(
+    nodes.model.sampling.KSampler,
+    model=checkpoint.output["MODEL"],
+    positive=prompt.output["CONDITIONING"],
+    negative=negative.output["CONDITIONING"],
+    latent_image=latent.output["LATENT"],
+    sampler_name="dpmpp_2m",
+    scheduler="karras",
+    steps=25,
+    cfg=7.0,
+)
+image = workflow.add_node(
+    nodes.model.latent.VAEDecode, samples=sampler.output["LATENT"], vae=checkpoint.output["VAE"]
+)
+workflow.add_node(nodes.image.SaveImage, images=image.output["IMAGE"], filename_prefix="lighthouse")
+
+print(json.dumps(workflow.get_comfy_ui_workflow_format(), indent=2))
+```
+
+The printed JSON is what ComfyUI's `/prompt` endpoint takes as `prompt`.
+
+Mistakes are caught right away:
+
+```python
+from comfy_ui_api_workflow import Workflow, errors, nodes
+
+workflow = Workflow()
+latent = workflow.add_node(nodes.model.latent.EmptyLatentImage, width=512, height=512)
+
+try:
+    latent.width = 8
+except errors.node.InvalidNodeParameterValue as error:
+    print(error)  # width must be in closed range: [16, 16384]
+```
+
+## Documentation
+
+- [User guide](docs/guide.md): workflows, links, validation, changing nodes,
+  pipelines, loading and exporting, running on ComfyUI, errors.
+- [API reference](docs/api.md): every public class, method, attribute and error.
+- [Custom nodes](docs/custom_nodes.md): classes for nodes from custom node packs.
+- [Node catalog](docs/nodes.md): every node with its inputs and outputs.
+- [`examples/`](examples): runnable scripts with pipelines and nodes.
+
+## Development
+
+```bash
+hatch test             # unit tests (RunPod tests are skipped)
+hatch test --cover     # with coverage
+hatch test -- --runpod # also send real jobs to the RunPod endpoint in .env (paid GPU)
+```
+
+## License
+
+MIT

comfy_ui_api_workflow-0.0.1/comfy_ui_api_workflow/__about__.py

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

comfy_ui_api_workflow-0.0.1/comfy_ui_api_workflow/__init__.py

@@ -0,0 +1,9 @@
+from ._impl import errors, nodes, exceptions, enums
+from ._impl.workflow import Workflow
+from ._impl.pipeline import Pipeline
+from ._impl.lazy import public_modules
+
+
+__all__ = ["errors", "nodes", "exceptions", "enums", "Workflow", "Pipeline"]
+
+public_modules(__name__, ["errors", "nodes", "exceptions", "enums"])

comfy_ui_api_workflow-0.0.1/comfy_ui_api_workflow/_impl/data_structure.py

@@ -0,0 +1,182 @@
+from typing import Any
+
+from .errors.data_structure import CycleError
+
+
+class IncrementalDirectedAcyclicGraphNode:
+    def __init__(self, data: Any) -> None:
+        self.data = data
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.data!r})"
+
+    def __str__(self) -> str:
+        return repr(self.data)
+
+
+class IncrementalDirectedAcyclicGraph:
+    def __init__(self) -> None:
+        self._successors: dict[
+            IncrementalDirectedAcyclicGraphNode,
+            set[IncrementalDirectedAcyclicGraphNode],
+        ] = {}
+        self._predecessors: dict[
+            IncrementalDirectedAcyclicGraphNode,
+            set[IncrementalDirectedAcyclicGraphNode],
+        ] = {}
+        self._order: dict[IncrementalDirectedAcyclicGraphNode, int] = {}
+        self._next = 0
+
+    def add_node(self, node: IncrementalDirectedAcyclicGraphNode) -> None:
+        if node in self._order:
+            return
+        self._successors[node] = set()
+        self._predecessors[node] = set()
+        self._order[node] = self._next
+        self._next += 1
+
+    def remove_node(self, node: IncrementalDirectedAcyclicGraphNode) -> None:
+        if node not in self._order:
+            raise KeyError(node)
+        for successor in self._successors[node]:
+            self._predecessors[successor].discard(node)
+        for predecessor in self._predecessors[node]:
+            self._successors[predecessor].discard(node)
+        del self._successors[node], self._predecessors[node], self._order[node]
+
+    def insert_between(
+        self,
+        a: IncrementalDirectedAcyclicGraphNode,
+        b: IncrementalDirectedAcyclicGraphNode,
+        node: IncrementalDirectedAcyclicGraphNode,
+        remove_original: bool = True,
+    ) -> None:
+        new_nodes = [n for n in (a, b, node) if n not in self]
+        new_edge = node not in self._successors.get(a, ())
+        try:
+            self.add_node(node=node)
+            self.add_edge(x=a, y=node)
+            self.add_edge(x=node, y=b)
+        except CycleError:
+            if new_edge and a in self and node in self:
+                self.remove_edge(x=a, y=node)
+            for new_node in new_nodes:
+                if new_node in self:
+                    self.remove_node(node=new_node)
+            raise
+        if remove_original:
+            self.remove_edge(x=a, y=b)
+
+    def add_edge(
+        self,
+        x: IncrementalDirectedAcyclicGraphNode,
+        y: IncrementalDirectedAcyclicGraphNode,
+    ) -> None:
+        if x == y:
+            raise CycleError([x, x])
+        self.add_node(node=x)
+        self.add_node(node=y)
+        if y in self._successors[x]:
+            return
+        order_x = self._order[x]
+        order_y = self._order[y]
+        if order_x < order_y:
+            self._link(x=x, y=y)
+            return
+        forward = self._forward_search(y=y, x=x, upper_bound=order_x)
+        backward = self._backward_search(x=x, lower_bound=order_y)
+        self._reorder(backward=backward, forward=forward)
+        self._link(x=x, y=y)
+
+    def remove_edge(
+        self,
+        x: IncrementalDirectedAcyclicGraphNode,
+        y: IncrementalDirectedAcyclicGraphNode,
+    ) -> None:
+        self._successors[x].discard(y)
+        self._predecessors[y].discard(x)
+
+    def topological_order(self) -> list[IncrementalDirectedAcyclicGraphNode]:
+        return sorted(self._order, key=self._order.__getitem__)
+
+    def dependencies(
+        self, node: IncrementalDirectedAcyclicGraphNode
+    ) -> set[IncrementalDirectedAcyclicGraphNode]:
+        return set(self._successors[node])
+
+    def dependents(
+        self, node: IncrementalDirectedAcyclicGraphNode
+    ) -> set[IncrementalDirectedAcyclicGraphNode]:
+        return set(self._predecessors[node])
+
+    def __contains__(self, node: object) -> bool:
+        return node in self._order
+
+    def __len__(self) -> int:
+        return len(self._order)
+
+    def _link(
+        self,
+        x: IncrementalDirectedAcyclicGraphNode,
+        y: IncrementalDirectedAcyclicGraphNode,
+    ) -> None:
+        self._successors[x].add(y)
+        self._predecessors[y].add(x)
+
+    def _forward_search(
+        self,
+        y: IncrementalDirectedAcyclicGraphNode,
+        x: IncrementalDirectedAcyclicGraphNode,
+        upper_bound: int,
+    ) -> list[IncrementalDirectedAcyclicGraphNode]:
+        parent: dict[
+            IncrementalDirectedAcyclicGraphNode,
+            IncrementalDirectedAcyclicGraphNode | None,
+        ] = {y: None}
+        stack = [y]
+        while stack:
+            node = stack.pop()
+            for successor in self._successors[node]:
+                if successor == x:
+                    path = [node]
+                    previous = parent[node]
+                    while previous is not None:
+                        path.append(previous)
+                        previous = parent[previous]
+                    path.reverse()
+                    raise CycleError([x] + path + [x])
+                if successor not in parent and self._order[successor] < upper_bound:
+                    parent[successor] = node
+                    stack.append(successor)
+        return list(parent)
+
+    def _backward_search(
+        self,
+        x: IncrementalDirectedAcyclicGraphNode,
+        lower_bound: int,
+    ) -> list[IncrementalDirectedAcyclicGraphNode]:
+        visited = {x}
+        stack = [x]
+        while stack:
+            node = stack.pop()
+            for predecessor in self._predecessors[node]:
+                if (
+                    predecessor not in visited
+                    and self._order[predecessor] > lower_bound
+                ):
+                    visited.add(predecessor)
+                    stack.append(predecessor)
+        return list(visited)
+
+    def _reorder(
+        self,
+        backward: list[IncrementalDirectedAcyclicGraphNode],
+        forward: list[IncrementalDirectedAcyclicGraphNode],
+    ) -> None:
+        key = self._order.__getitem__
+        backward.sort(key=key)
+        forward.sort(key=key)
+        nodes = backward + forward
+        slots = sorted(self._order[node] for node in nodes)
+        for node, position in zip(nodes, slots):
+            self._order[node] = position

comfy_ui_api_workflow-0.0.1/comfy_ui_api_workflow/_impl/enums.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+# Behaves like StrEnum, which only exists from Python 3.11 (the project supports 3.10).
+class OutputTypes(str, Enum):
+    MODEL = "MODEL"
+    CONDITIONING = "CONDITIONING"
+    LATENT = "LATENT"
+    CLIP = "CLIP"
+    VAE = "VAE"
+
+    def __str__(self) -> str:
+        return self.value

comfy_ui_api_workflow-0.0.1/comfy_ui_api_workflow/_impl/errors/__init__.py

@@ -0,0 +1,3 @@
+from ..lazy import submodules_of
+
+__getattr__ = submodules_of(__name__)