comfy-ui-api-workflow 0.0.1__py3-none-any.whl

comfy_ui_api_workflow/__about__.py

@@ -0,0 +1 @@
+version = "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/_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/_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/_impl/errors/__init__.py

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

comfy_ui_api_workflow/_impl/errors/data_structure.py

@@ -0,0 +1,34 @@
+from typing import TYPE_CHECKING
+
+from ..exceptions import DataStructureException
+
+if TYPE_CHECKING:
+    from ..data_structure import IncrementalDirectedAcyclicGraphNode
+
+
+class CycleError(DataStructureException):
+    def __init__(self, cycle: list["IncrementalDirectedAcyclicGraphNode"]) -> None:
+        super().__init__(cycle)
+        self.cycle = cycle
+
+    @property
+    def edge(
+        self,
+    ) -> tuple[
+        "IncrementalDirectedAcyclicGraphNode", "IncrementalDirectedAcyclicGraphNode"
+    ]:
+        return self.cycle[0], self.cycle[1]
+
+    @property
+    def path(self) -> list["IncrementalDirectedAcyclicGraphNode"]:
+        return self.cycle[1:]
+
+    def __str__(self) -> str:
+        source, target = self.edge
+        if source == target:
+            return f"Cannot add edge {source} -> {target}: a node cannot have an edge to itself."
+        return (
+            f"Cannot add edge {source} -> {target}: a path from {target} back to {source} already exists "
+            f"({' -> '.join(map(str, self.path))}), "
+            f"so the new edge would create the cycle {' -> '.join(map(str, self.cycle))}."
+        )

comfy_ui_api_workflow/_impl/errors/node.py

@@ -0,0 +1,63 @@
+from ..exceptions import NodeException
+
+
+def quote_names(names: list[str]) -> str:
+    quoted = [repr(name) for name in names]
+    if len(quoted) == 1:
+        return quoted[0]
+    return f"{', '.join(quoted[:-1])} and {quoted[-1]}"
+
+
+def describe_dependents(dependents: list[str]) -> str:
+    if len(dependents) == 1:
+        return f"node {quote_names(dependents)} depends on it"
+    return f"nodes {quote_names(dependents)} depend on it"
+
+
+class InvalidNodeParameterValue(NodeException):
+    pass
+
+
+class NodeNotHaveOutput(NodeException):
+    pass
+
+
+class NodeNotFoundError(NodeException):
+    pass
+
+
+class NodeHasDependentsError(NodeException):
+    def __init__(self, node_id: str, dependents: list[str]) -> None:
+        super().__init__(node_id, dependents)
+        self.node_id = node_id
+        self.dependents = dependents
+
+    def __str__(self) -> str:
+        return (
+            f"Cannot remove node {self.node_id!r}: "
+            f"{describe_dependents(self.dependents)}."
+        )
+
+
+class InvalidNodeChangeError(NodeException):
+    def __init__(self, node_id: str, name: str, reason: str) -> None:
+        super().__init__(node_id, name, reason)
+        self.node_id = node_id
+        self.name = name
+        self.reason = reason
+
+    def __str__(self) -> str:
+        return f"Cannot change {self.name!r} of node {self.node_id!r}: {self.reason}."
+
+
+class InvalidLinkError(NodeException):
+    def __init__(self, node_id: str, name: str, reason: str) -> None:
+        super().__init__(node_id, name, reason)
+        self.node_id = node_id
+        self.name = name
+        self.reason = reason
+
+    def __str__(self) -> str:
+        return (
+            f"Cannot add node {self.node_id!r}: input {self.name!r} uses {self.reason}."
+        )

comfy_ui_api_workflow/_impl/errors/output.py

@@ -0,0 +1,5 @@
+from ..exceptions import OutputException
+
+
+class OutputNotFoundError(OutputException):
+    pass

comfy_ui_api_workflow/_impl/errors/pipeline.py

@@ -0,0 +1,14 @@
+from ..exceptions import PipelineException
+
+
+class PipelineError(PipelineException):
+    def __init__(self, pipeline: str, reason: str) -> None:
+        super().__init__(pipeline, reason)
+        self.pipeline = pipeline
+        self.reason = reason
+
+    def __str__(self) -> str:
+        return (
+            f"Cannot add pipeline {self.pipeline!r}: {self.reason}. "
+            "No node of the pipeline was added."
+        )

comfy_ui_api_workflow/_impl/errors/workflow.py

@@ -0,0 +1,13 @@
+from ..exceptions import WorkflowException
+
+
+class InvalidWorkflowError(WorkflowException):
+    def __init__(self, node_id: str | None, reason: str) -> None:
+        super().__init__(node_id, reason)
+        self.node_id = node_id
+        self.reason = reason
+
+    def __str__(self) -> str:
+        if self.node_id is None:
+            return f"Cannot load the workflow: {self.reason}."
+        return f"Cannot load node {self.node_id!r}: {self.reason}."

comfy_ui_api_workflow/_impl/exceptions.py

@@ -0,0 +1,22 @@
+class ComfyUIAPIWorkflowException(Exception):
+    pass
+
+
+class DataStructureException(ComfyUIAPIWorkflowException):
+    pass
+
+
+class WorkflowException(ComfyUIAPIWorkflowException):
+    pass
+
+
+class NodeException(ComfyUIAPIWorkflowException):
+    pass
+
+
+class PipelineException(ComfyUIAPIWorkflowException):
+    pass
+
+
+class OutputException(ComfyUIAPIWorkflowException):
+    pass

comfy_ui_api_workflow/_impl/lazy.py

@@ -0,0 +1,71 @@
+import importlib
+import importlib.abc
+import importlib.util
+import sys
+from collections.abc import Callable, Iterable, Sequence
+from importlib.machinery import ModuleSpec
+from types import ModuleType
+
+
+def submodules_of(package: str) -> Callable[[str], ModuleType]:
+    """A module __getattr__ that imports the package's submodules on first use."""
+
+    def __getattr__(name: str) -> ModuleType:
+        module = f"{package}.{name}"
+        try:
+            return importlib.import_module(module)
+        except ModuleNotFoundError as error:
+            # Only a missing submodule is a missing attribute; a broken import
+            # inside an existing module still raises as it is.
+            if error.name != module:
+                raise
+            raise AttributeError(
+                f"module {package!r} has no attribute {name!r}"
+            ) from None
+
+    return __getattr__
+
+
+class _PublicModules(importlib.abc.MetaPathFinder, importlib.abc.Loader):
+    """Imports package.<name>... as the module package._impl.<name>... it stands for."""
+
+    def __init__(self, package: str, names: Iterable[str]) -> None:
+        self.prefixes = tuple(f"{package}.{name}" for name in names)
+        self.package = package
+
+    def find_spec(
+        self, fullname: str, path: Sequence[str] | None = None, target: object = None
+    ) -> ModuleSpec | None:
+        if not any(
+            fullname == prefix or fullname.startswith(f"{prefix}.")
+            for prefix in self.prefixes
+        ):
+            return None
+        private = f"{self.package}._impl{fullname.removeprefix(self.package)}"
+        spec = importlib.util.find_spec(private)
+        if spec is None:
+            return None
+        return importlib.util.spec_from_loader(
+            fullname, self, is_package=spec.submodule_search_locations is not None
+        )
+
+    def create_module(self, spec: ModuleSpec) -> ModuleType:
+        # The public name gets the module already loaded under _impl, so each
+        # class exists once whichever path imported it.
+        private = f"{self.package}._impl{spec.name.removeprefix(self.package)}"
+        return importlib.import_module(private)
+
+    def exec_module(self, module: ModuleType) -> None:
+        pass
+
+
+def public_modules(package: str, names: Iterable[str]) -> None:
+    """Lets package.<name> be imported by its path, for each name the root exports."""
+    finder = _PublicModules(package, names)
+    if not any(
+        isinstance(other, _PublicModules) and other.package == package
+        for other in sys.meta_path
+    ):
+        # First in line, or the path finder would load a second copy of each
+        # submodule from the __path__ of the module the public name stands for.
+        sys.meta_path.insert(0, finder)

comfy_ui_api_workflow/_impl/nodes/__init__.py

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

comfy_ui_api_workflow/_impl/nodes/advanced/__init__.py

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

comfy_ui_api_workflow/_impl/nodes/advanced/debug.py

@@ -0,0 +1,103 @@
+from typing import Literal, get_args
+
+from ..base import BaseNode
+from ..validation import validate_bool, validate_choice, validate_range
+
+ModelComputeDtype_Dtypes = Literal["default", "fp32", "fp16", "bf16"]
+MODELCOMPUTEDTYPE_DTYPES = frozenset(get_args(ModelComputeDtype_Dtypes))
+
+
+class ModelComputeDtype(BaseNode):
+    __slots__ = ("model", "dtype")
+    CATEGORY = "advanced/debug"
+    OUTPUTS = {"MODEL": 0}
+    RETURN_TYPES = ("MODEL",)
+    INPUT_SOCKET_TYPES = {"model": "MODEL", "dtype": "V1 COMBO"}
+
+    def __init__(
+        self,
+        node_id: str,
+        model: tuple[str, int],
+        dtype: ModelComputeDtype_Dtypes | tuple[str, int],
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.model = model
+        self.dtype = dtype
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_choice("dtype", self.dtype, MODELCOMPUTEDTYPE_DTYPES)
+
+
+class EasyCache(BaseNode):
+    __slots__ = ("model", "reuse_threshold", "start_percent", "end_percent", "verbose")
+    CATEGORY = "advanced/debug"
+    OUTPUTS = {"MODEL": 0}
+    RETURN_TYPES = ("MODEL",)
+    INPUT_SOCKET_TYPES = {
+        "model": "MODEL",
+        "reuse_threshold": "FLOAT",
+        "start_percent": "FLOAT",
+        "end_percent": "FLOAT",
+        "verbose": "BOOLEAN",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        model: tuple[str, int],
+        reuse_threshold: float | tuple[str, int] = 0.2,
+        start_percent: float | tuple[str, int] = 0.15,
+        end_percent: float | tuple[str, int] = 0.95,
+        verbose: bool | tuple[str, int] = False,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.model = model
+        self.reuse_threshold = reuse_threshold
+        self.start_percent = start_percent
+        self.end_percent = end_percent
+        self.verbose = verbose
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_range("reuse_threshold", self.reuse_threshold, 0.0, 3.0)
+        validate_range("start_percent", self.start_percent, 0.0, 1.0)
+        validate_range("end_percent", self.end_percent, 0.0, 1.0)
+        validate_bool("verbose", self.verbose)
+
+
+class LazyCache(BaseNode):
+    __slots__ = ("model", "reuse_threshold", "start_percent", "end_percent", "verbose")
+    CATEGORY = "advanced/debug"
+    OUTPUTS = {"MODEL": 0}
+    RETURN_TYPES = ("MODEL",)
+    INPUT_SOCKET_TYPES = {
+        "model": "MODEL",
+        "reuse_threshold": "FLOAT",
+        "start_percent": "FLOAT",
+        "end_percent": "FLOAT",
+        "verbose": "BOOLEAN",
+    }
+
+    def __init__(
+        self,
+        node_id: str,
+        model: tuple[str, int],
+        reuse_threshold: float | tuple[str, int] = 0.2,
+        start_percent: float | tuple[str, int] = 0.15,
+        end_percent: float | tuple[str, int] = 0.95,
+        verbose: bool | tuple[str, int] = False,
+    ) -> None:
+        super().__init__(node_id=node_id)
+        self.model = model
+        self.reuse_threshold = reuse_threshold
+        self.start_percent = start_percent
+        self.end_percent = end_percent
+        self.verbose = verbose
+        self.__validate()
+
+    def __validate(self) -> None:
+        validate_range("reuse_threshold", self.reuse_threshold, 0.0, 3.0)
+        validate_range("start_percent", self.start_percent, 0.0, 1.0)
+        validate_range("end_percent", self.end_percent, 0.0, 1.0)
+        validate_bool("verbose", self.verbose)