comfy-runtime 0.1.0__tar.gz

comfy_runtime-0.1.0/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: comfy-runtime
+Version: 0.1.0
+Summary: Minimal ComfyUI runtime for deploying custom nodes as microservices
+Author: ComfyUI Community
+License: GPL-3.0
+Project-URL: Repository, https://github.com/anyin233/comfy-runtime
+Keywords: comfyui,runtime,nodes,microservice,inference
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: torchaudio
+Requires-Dist: numpy>=1.25.0
+Requires-Dist: pillow
+Requires-Dist: safetensors>=0.4.2
+Requires-Dist: scipy
+Requires-Dist: einops
+Requires-Dist: transformers>=4.50.3
+Requires-Dist: tokenizers>=0.13.3
+Requires-Dist: sentencepiece
+Requires-Dist: typing_extensions
+Requires-Dist: tqdm
+Requires-Dist: psutil
+Requires-Dist: filelock
+Requires-Dist: requests
+Requires-Dist: torchsde
+Requires-Dist: pyyaml
+Requires-Dist: blake3
+Requires-Dist: simpleeval>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+
+# comfy-runtime
+
+Minimal ComfyUI Runtime for Custom Nodes
+
+`comfy-runtime` is a minimal Python runtime for loading and executing ComfyUI nodes outside the full ComfyUI app. It is designed for packaging custom nodes into scripts, workers, and microservices. It is not a server, not a UI, and not a workflow engine.
+
+## Installation
+
+```bash
+pip install comfy-runtime
+# Optional: built-in extra nodes
+pip install comfy-builtin-nodes
+```
+
+## Quick Start
+
+```python
+import comfy_runtime
+
+# Configure model paths (optional — has defaults)
+comfy_runtime.configure(
+    models_dir="/path/to/models",
+    output_dir="/path/to/output",
+)
+
+# Execute a built-in node
+result = comfy_runtime.execute_node(
+    "EmptyLatentImage",
+    width=512, height=512, batch_size=1,
+)
+latent = result[0]
+print(f"Latent shape: {latent['samples'].shape}")
+
+# Load extra nodes from a file
+comfy_runtime.load_nodes_from_path("/path/to/my_custom_node.py")
+
+# List all registered nodes
+print(comfy_runtime.list_nodes())
+
+# Get node info
+info = comfy_runtime.get_node_info("EmptyLatentImage")
+print(info["input_types"])
+```
+
+## API Reference
+
+### `configure(models_dir, output_dir, input_dir, temp_dir, vram_mode, device)`
+
+Configures runtime directories and device flags. This must be called before importing `comfy.model_management`.
+
+### `execute_node(class_type, **kwargs) -> tuple`
+
+Runs one registered node and returns its output tuple. Handles both V1 and V3 node styles transparently.
+
+### `create_node_instance(class_type) -> object`
+
+Creates a reusable instance of a registered node class. Useful for stateful nodes.
+
+### `register_node(class_type, node_cls, display_name)`
+
+Registers a node class manually under a given class type.
+
+### `load_nodes_from_path(path) -> list[str]`
+
+Loads nodes from a `.py` file or a directory of Python files. Supports both V1 mapping based nodes and V3 entrypoint based nodes.
+
+### `list_nodes() -> list[str]`
+
+Returns all registered node class names.
+
+### `get_node_info(class_type) -> dict`
+
+Returns public metadata for a node, including input types, return types, category, and execution method.
+
+### `unregister_node(class_type)`
+
+Removes a registered node from the runtime registry.
+
+### `get_config() -> dict`
+
+Returns the current runtime configuration.
+
+### Exceptions
+
+- `NodeNotFoundError`
+- `NodeExecutionError`
+
+## Microservice Example
+
+```python
+# Example: wrapping a node with FastAPI
+from fastapi import FastAPI
+import comfy_runtime
+
+app = FastAPI()
+comfy_runtime.configure(models_dir="/data/models", output_dir="/data/output")
+
+@app.post("/generate")
+def generate(width: int = 512, height: int = 512):
+    result = comfy_runtime.execute_node(
+        "EmptyLatentImage", width=width, height=height, batch_size=1,
+    )
+    return {"shape": list(result[0]["samples"].shape)}
+```
+
+## Memory Management
+
+```python
+from comfy.model_management import soft_empty_cache, cleanup_models
+soft_empty_cache()  # Free unused VRAM
+```
+
+## Limitations
+
+- Single-node execution only, no workflow graph
+- Single-process only, no interrupt signaling across processes
+- No built-in HTTP server, wrap it with FastAPI or gRPC yourself
+- `configure()` must be called before importing `model_management`
+
+## License
+
+GPL-3.0, same as ComfyUI

comfy_runtime-0.1.0/README.md

@@ -0,0 +1,122 @@
+# comfy-runtime
+
+Minimal ComfyUI Runtime for Custom Nodes
+
+`comfy-runtime` is a minimal Python runtime for loading and executing ComfyUI nodes outside the full ComfyUI app. It is designed for packaging custom nodes into scripts, workers, and microservices. It is not a server, not a UI, and not a workflow engine.
+
+## Installation
+
+```bash
+pip install comfy-runtime
+# Optional: built-in extra nodes
+pip install comfy-builtin-nodes
+```
+
+## Quick Start
+
+```python
+import comfy_runtime
+
+# Configure model paths (optional — has defaults)
+comfy_runtime.configure(
+    models_dir="/path/to/models",
+    output_dir="/path/to/output",
+)
+
+# Execute a built-in node
+result = comfy_runtime.execute_node(
+    "EmptyLatentImage",
+    width=512, height=512, batch_size=1,
+)
+latent = result[0]
+print(f"Latent shape: {latent['samples'].shape}")
+
+# Load extra nodes from a file
+comfy_runtime.load_nodes_from_path("/path/to/my_custom_node.py")
+
+# List all registered nodes
+print(comfy_runtime.list_nodes())
+
+# Get node info
+info = comfy_runtime.get_node_info("EmptyLatentImage")
+print(info["input_types"])
+```
+
+## API Reference
+
+### `configure(models_dir, output_dir, input_dir, temp_dir, vram_mode, device)`
+
+Configures runtime directories and device flags. This must be called before importing `comfy.model_management`.
+
+### `execute_node(class_type, **kwargs) -> tuple`
+
+Runs one registered node and returns its output tuple. Handles both V1 and V3 node styles transparently.
+
+### `create_node_instance(class_type) -> object`
+
+Creates a reusable instance of a registered node class. Useful for stateful nodes.
+
+### `register_node(class_type, node_cls, display_name)`
+
+Registers a node class manually under a given class type.
+
+### `load_nodes_from_path(path) -> list[str]`
+
+Loads nodes from a `.py` file or a directory of Python files. Supports both V1 mapping based nodes and V3 entrypoint based nodes.
+
+### `list_nodes() -> list[str]`
+
+Returns all registered node class names.
+
+### `get_node_info(class_type) -> dict`
+
+Returns public metadata for a node, including input types, return types, category, and execution method.
+
+### `unregister_node(class_type)`
+
+Removes a registered node from the runtime registry.
+
+### `get_config() -> dict`
+
+Returns the current runtime configuration.
+
+### Exceptions
+
+- `NodeNotFoundError`
+- `NodeExecutionError`
+
+## Microservice Example
+
+```python
+# Example: wrapping a node with FastAPI
+from fastapi import FastAPI
+import comfy_runtime
+
+app = FastAPI()
+comfy_runtime.configure(models_dir="/data/models", output_dir="/data/output")
+
+@app.post("/generate")
+def generate(width: int = 512, height: int = 512):
+    result = comfy_runtime.execute_node(
+        "EmptyLatentImage", width=width, height=height, batch_size=1,
+    )
+    return {"shape": list(result[0]["samples"].shape)}
+```
+
+## Memory Management
+
+```python
+from comfy.model_management import soft_empty_cache, cleanup_models
+soft_empty_cache()  # Free unused VRAM
+```
+
+## Limitations
+
+- Single-node execution only, no workflow graph
+- Single-process only, no interrupt signaling across processes
+- No built-in HTTP server, wrap it with FastAPI or gRPC yourself
+- `configure()` must be called before importing `model_management`
+
+## License
+
+GPL-3.0, same as ComfyUI

comfy_runtime-0.1.0/comfy_runtime/__init__.py

@@ -0,0 +1,22 @@
+__version__ = "0.1.0"
+
+from comfy_runtime.bootstrap import bootstrap
+from comfy_runtime.config import configure, get_config
+
+bootstrap()
+
+from comfy_runtime.executor import (
+    NodeExecutionError,
+    NodeNotFoundError,
+    create_node_instance,
+    execute_node,
+    get_node_class,
+    get_node_info,
+    list_nodes,
+)
+from comfy_runtime.registry import (
+    load_nodes_from_path,
+    register_node,
+    register_nodes,
+    unregister_node,
+)

comfy_runtime-0.1.0/comfy_runtime/bootstrap.py

@@ -0,0 +1,166 @@
+"""Register all stub modules in sys.modules before any comfy imports.
+
+Bootstrap order is critical — comfy_aimdo must come first because many
+ComfyUI modules import it at the top level.  The sequence is:
+
+1. comfy_aimdo stubs (7 import sites across ComfyUI)
+2. server stub (nodes_images.py imports PromptServer at module level)
+3. latent_preview stub (avoids torch/PIL/heavy-comfy imports)
+4. comfy.options shim (sets args_parsing = False so cli_args skips argparse)
+5. vendor shims (registers _vendor/ packages under short names in sys.modules)
+"""
+
+import importlib
+from importlib.machinery import ModuleSpec
+import sys
+import types
+
+
+def bootstrap():
+    """Register all stubs in sys.modules BEFORE any comfy imports."""
+    from comfy_runtime.stubs.comfy_aimdo_stub import install_aimdo_stubs
+
+    install_aimdo_stubs()
+
+    import comfy_runtime.stubs.server_stub as server_module
+
+    sys.modules["server"] = server_module
+
+    import comfy_runtime.stubs.latent_preview_stub as latent_preview_module
+
+    sys.modules["latent_preview"] = latent_preview_module
+
+    try:
+        importlib.import_module("torchvision")
+    except Exception:
+
+        def _torchvision_unavailable(*args, **kwargs):
+            raise RuntimeError(
+                "torchvision is unavailable in this comfy_runtime environment"
+            )
+
+        torchvision_module = types.ModuleType("torchvision")
+        torchvision_models = types.ModuleType("torchvision.models")
+        torchvision_ops = types.ModuleType("torchvision.ops")
+        torchvision_transforms = types.ModuleType("torchvision.transforms")
+
+        setattr(
+            torchvision_module,
+            "__spec__",
+            ModuleSpec("torchvision", loader=None, is_package=True),
+        )
+        setattr(torchvision_module, "__path__", [])
+        setattr(
+            torchvision_models,
+            "__spec__",
+            ModuleSpec("torchvision.models", loader=None),
+        )
+        setattr(
+            torchvision_ops,
+            "__spec__",
+            ModuleSpec("torchvision.ops", loader=None),
+        )
+        setattr(
+            torchvision_transforms,
+            "__spec__",
+            ModuleSpec("torchvision.transforms", loader=None),
+        )
+
+        setattr(torchvision_models, "efficientnet_v2_s", _torchvision_unavailable)
+        setattr(torchvision_ops, "box_convert", _torchvision_unavailable)
+        setattr(torchvision_transforms, "Compose", _torchvision_unavailable)
+        setattr(torchvision_transforms, "Normalize", _torchvision_unavailable)
+
+        setattr(torchvision_module, "models", torchvision_models)
+        setattr(torchvision_module, "ops", torchvision_ops)
+        setattr(torchvision_module, "transforms", torchvision_transforms)
+
+        sys.modules["torchvision"] = torchvision_module
+        sys.modules["torchvision.models"] = torchvision_models
+        sys.modules["torchvision.ops"] = torchvision_ops
+        sys.modules["torchvision.transforms"] = torchvision_transforms
+
+    try:
+        importlib.import_module("av")
+    except Exception:
+
+        def _av_unavailable(*args, **kwargs):
+            raise RuntimeError("av is unavailable in this comfy_runtime environment")
+
+        av_module = types.ModuleType("av")
+        av_container = types.ModuleType("av.container")
+        av_subtitles = types.ModuleType("av.subtitles")
+        av_subtitles_stream = types.ModuleType("av.subtitles.stream")
+        input_container = type("InputContainer", (), {})
+        subtitle_stream = type("SubtitleStream", (), {})
+        video_stream = type("VideoStream", (), {})
+
+        setattr(av_module, "__spec__", ModuleSpec("av", loader=None, is_package=True))
+        setattr(av_module, "__path__", [])
+        setattr(av_container, "__spec__", ModuleSpec("av.container", loader=None))
+        setattr(
+            av_subtitles,
+            "__spec__",
+            ModuleSpec("av.subtitles", loader=None, is_package=True),
+        )
+        setattr(av_subtitles, "__path__", [])
+        setattr(
+            av_subtitles_stream,
+            "__spec__",
+            ModuleSpec("av.subtitles.stream", loader=None),
+        )
+
+        setattr(av_container, "InputContainer", input_container)
+        setattr(av_subtitles_stream, "SubtitleStream", subtitle_stream)
+        setattr(av_subtitles, "stream", av_subtitles_stream)
+        setattr(av_module, "container", av_container)
+        setattr(av_module, "subtitles", av_subtitles)
+        setattr(av_module, "VideoStream", video_stream)
+        setattr(av_module, "open", _av_unavailable)
+        setattr(av_module, "time_base", 1)
+
+        sys.modules["av"] = av_module
+        sys.modules["av.container"] = av_container
+        sys.modules["av.subtitles"] = av_subtitles
+        sys.modules["av.subtitles.stream"] = av_subtitles_stream
+
+    if "comfy" not in sys.modules:
+        try:
+            import comfy  # noqa: F401  # type: ignore[import-not-found]
+        except ImportError:
+            comfy_parent = types.ModuleType("comfy")
+            comfy_parent.__path__ = []
+            sys.modules["comfy"] = comfy_parent
+
+    options_module = types.ModuleType("comfy.options")
+    options_module.args_parsing = False  # type: ignore[attr-defined]
+    options_module.enable_args_parsing = lambda enable=True: None  # type: ignore[attr-defined]
+    sys.modules["comfy.options"] = options_module
+    sys.modules["comfy"].options = options_module  # type: ignore[attr-defined]
+
+    from comfy_runtime.shim import install_shims
+
+    try:
+        cli_args_mod = importlib.import_module("comfy_runtime._vendor.comfy.cli_args")
+        torch = importlib.import_module("torch")
+
+        if not torch.cuda.is_available():
+            cli_args_mod.args.cpu = True
+        sys.modules["comfy.cli_args"] = cli_args_mod
+    except Exception:
+        pass
+
+    try:
+        diffusionmodules_mod = importlib.import_module(
+            "comfy_runtime._vendor.comfy.ldm.modules.diffusionmodules"
+        )
+        diffusion_mmdit_mod = importlib.import_module(
+            "comfy_runtime._vendor.comfy.ldm.modules.diffusionmodules.mmdit"
+        )
+        setattr(diffusionmodules_mod, "mmdit", diffusion_mmdit_mod)
+        sys.modules["comfy.ldm.modules.diffusionmodules"] = diffusionmodules_mod
+        sys.modules["comfy.ldm.modules.diffusionmodules.mmdit"] = diffusion_mmdit_mod
+    except Exception:
+        pass
+
+    install_shims()

comfy_runtime-0.1.0/comfy_runtime/config.py

@@ -0,0 +1,105 @@
+"""Runtime configuration API for comfy-runtime."""
+
+
+def configure(
+    models_dir=None,
+    output_dir=None,
+    input_dir=None,
+    temp_dir=None,
+    vram_mode=None,
+    device=None,
+    **kwargs,
+):
+    """Configure model paths and runtime settings.
+
+    Args:
+        models_dir: Base directory that contains Comfy model subdirectories.
+        output_dir: Output directory for generated files.
+        input_dir: Input directory for source files.
+        temp_dir: Temporary directory for intermediate files.
+        vram_mode: VRAM mode flag to enable on comfy.cli_args.args.
+        device: CUDA device index or ``"cpu"`` to force CPU mode.
+        **kwargs: Extra attributes to apply directly to comfy.cli_args.args.
+
+    Returns:
+        None.
+    """
+    from comfy.cli_args import args  # type: ignore[import-not-found]
+
+    if vram_mode == "highvram":
+        args.highvram = True
+    elif vram_mode == "normalvram":
+        args.normalvram = True
+    elif vram_mode == "lowvram":
+        args.lowvram = True
+    elif vram_mode == "novram":
+        args.novram = True
+    elif vram_mode == "cpu":
+        args.cpu = True
+
+    if device is not None:
+        if isinstance(device, int):
+            args.cuda_device = device
+        elif device == "cpu":
+            args.cpu = True
+
+    for key, val in kwargs.items():
+        setattr(args, key, val)
+
+    import folder_paths  # type: ignore[import-not-found]
+
+    if output_dir is not None:
+        folder_paths.output_directory = output_dir
+    if input_dir is not None:
+        folder_paths.input_directory = input_dir
+    if temp_dir is not None:
+        folder_paths.temp_directory = temp_dir
+
+    if models_dir is not None:
+        import os
+
+        model_categories = {
+            "checkpoints": {".ckpt", ".safetensors", ".pt", ".bin", ".pth"},
+            "configs": {".yaml", ".yml", ".json"},
+            "loras": {".safetensors", ".ckpt", ".pt", ".bin"},
+            "vae": {".safetensors", ".pt", ".bin", ".ckpt"},
+            "text_encoders": {".safetensors", ".pt", ".bin", ".ckpt"},
+            "diffusion_models": {".safetensors", ".pt", ".bin", ".ckpt"},
+            "clip_vision": {".safetensors", ".pt", ".bin", ".ckpt"},
+            "style_models": {".safetensors", ".pt", ".bin", ".ckpt"},
+            "embeddings": {".safetensors", ".pt", ".bin", ".ckpt"},
+            "controlnet": {".safetensors", ".pt", ".bin", ".ckpt"},
+            "unet": {".safetensors", ".pt", ".bin", ".ckpt"},
+            "upscale_models": {".safetensors", ".pt", ".bin", ".ckpt"},
+        }
+        for category, extensions in model_categories.items():
+            cat_dir = os.path.join(models_dir, category)
+            if category in folder_paths.folder_names_and_paths:
+                existing_paths, existing_exts = folder_paths.folder_names_and_paths[
+                    category
+                ]
+                folder_paths.folder_names_and_paths[category] = (
+                    [cat_dir] + list(existing_paths),
+                    set(existing_exts) | extensions,
+                )
+            else:
+                folder_paths.folder_names_and_paths[category] = ([cat_dir], extensions)
+
+
+def get_config():
+    """Return current configuration as a dictionary.
+
+    Returns:
+        dict: Selected runtime directories and device-related flags.
+    """
+    from comfy.cli_args import args  # type: ignore[import-not-found]
+    import folder_paths  # type: ignore[import-not-found]
+
+    return {
+        "output_directory": getattr(folder_paths, "output_directory", None),
+        "input_directory": getattr(folder_paths, "input_directory", None),
+        "temp_directory": getattr(folder_paths, "temp_directory", None),
+        "cpu": getattr(args, "cpu", False),
+        "highvram": getattr(args, "highvram", False),
+        "cuda_device": getattr(args, "cuda_device", 0),
+    }