comfy-diffusion 1.4.0__tar.gz → 2.0.0__tar.gz

comfy_diffusion-2.0.0/PKG-INFO

@@ -0,0 +1,229 @@
+Metadata-Version: 2.4
+Name: comfy-diffusion
+Version: 2.0.0
+Summary: ComfyUI inference engine as a standalone Python library (no server, no UI).
+Author: Alejandro Quintero
+License: GPL-3.0-only
+Project-URL: Homepage, https://github.com/quinteroac/comfy-diffusion
+Project-URL: Repository, https://github.com/quinteroac/comfy-diffusion
+Project-URL: Issues, https://github.com/quinteroac/comfy-diffusion/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: einops>=0.8.2
+Requires-Dist: huggingface_hub>=0.20
+Requires-Dist: numpy>=1.25.0
+Requires-Dist: pillow>=12.1.1
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: requests>=2.32.5
+Requires-Dist: safetensors>=0.4.2
+Requires-Dist: scipy>=1.17.1
+Requires-Dist: sentencepiece>=0.2.1
+Requires-Dist: simpleeval>=1.0.0
+Requires-Dist: tokenizers>=0.13.3
+Requires-Dist: tqdm>=4.67.3
+Requires-Dist: transformers>=4.50.3
+Requires-Dist: typer>=0.24.1
+Requires-Dist: yarl>=1.18.0
+Provides-Extra: cpu
+Requires-Dist: torch; extra == "cpu"
+Requires-Dist: torchvision; extra == "cpu"
+Provides-Extra: cuda
+Requires-Dist: torch; extra == "cuda"
+Requires-Dist: torchvision; extra == "cuda"
+Provides-Extra: audio
+Requires-Dist: torchaudio; extra == "audio"
+Provides-Extra: video
+Requires-Dist: av>=14.2.0; extra == "video"
+Requires-Dist: imageio>=2.37.2; extra == "video"
+Requires-Dist: opencv-python>=4.13.0.92; extra == "video"
+Provides-Extra: comfyui
+Requires-Dist: aiohttp>=3.11.8; extra == "comfyui"
+Requires-Dist: blake3; extra == "comfyui"
+Requires-Dist: comfy-aimdo>=0.2.12; extra == "comfyui"
+Requires-Dist: comfy-kitchen>=0.2.8; extra == "comfyui"
+Requires-Dist: comfyui-embedded-docs==0.4.3; extra == "comfyui"
+Requires-Dist: comfyui-workflow-templates==0.9.26; extra == "comfyui"
+Requires-Dist: glfw>=2.10.0; extra == "comfyui"
+Requires-Dist: httpx[http2]>=0.28.1; extra == "comfyui"
+Requires-Dist: kornia>=0.7.1; extra == "comfyui"
+Requires-Dist: psutil>=7.2.2; extra == "comfyui"
+Requires-Dist: pydantic~=2.0; extra == "comfyui"
+Requires-Dist: pyopengl>=3.1.10; extra == "comfyui"
+Requires-Dist: spandrel>=0.4.2; extra == "comfyui"
+Requires-Dist: torchsde>=0.2.6; extra == "comfyui"
+Provides-Extra: all
+Requires-Dist: torch; extra == "all"
+Requires-Dist: torchvision; extra == "all"
+Requires-Dist: torchaudio; extra == "all"
+Requires-Dist: av>=14.2.0; extra == "all"
+Requires-Dist: imageio>=2.37.2; extra == "all"
+Requires-Dist: opencv-python>=4.13.0.92; extra == "all"
+Requires-Dist: aiohttp>=3.11.8; extra == "all"
+Requires-Dist: blake3; extra == "all"
+Requires-Dist: comfy-aimdo>=0.2.12; extra == "all"
+Requires-Dist: comfy-kitchen>=0.2.8; extra == "all"
+Requires-Dist: comfyui-embedded-docs==0.4.3; extra == "all"
+Requires-Dist: comfyui-workflow-templates==0.9.26; extra == "all"
+Requires-Dist: glfw>=2.10.0; extra == "all"
+Requires-Dist: httpx[http2]>=0.28.1; extra == "all"
+Requires-Dist: kornia>=0.7.1; extra == "all"
+Requires-Dist: psutil>=7.2.2; extra == "all"
+Requires-Dist: pydantic~=2.0; extra == "all"
+Requires-Dist: pyopengl>=3.1.10; extra == "all"
+Requires-Dist: spandrel>=0.4.2; extra == "all"
+Requires-Dist: torchsde>=0.2.6; extra == "all"
+
+# comfy-diffusion
+
+[![PyPI version](https://badge.fury.io/py/comfy-diffusion.svg)](https://pypi.org/project/comfy-diffusion/)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12%2B-blue)](https://pypi.org/project/comfy-diffusion/)
+[![CI](https://github.com/quinteroac/comfy-diffusion/actions/workflows/publish.yml/badge.svg)](https://github.com/quinteroac/comfy-diffusion/actions/workflows/publish.yml)
+[![License: GPL-3.0](https://img.shields.io/badge/License-GPL--3.0-blue.svg)](LICENSE)
+
+`comfy-diffusion` is a standalone Python package that exposes ComfyUI's inference engine as importable modules. It is not a server, node graph runner, web UI, MCP server, daemon, or binary app.
+
+The package vendors ComfyUI at `vendor/ComfyUI` and makes its internal `comfy.*` modules available when runtime APIs need them. Application authors can install this package, import `comfy_diffusion`, and compose inference flows directly in Python.
+
+## Install
+
+Use `uv` for development and dependency resolution:
+
+```bash
+uv sync --extra cpu --extra comfyui
+```
+
+For CUDA environments:
+
+```bash
+uv sync --extra cuda --extra comfyui
+```
+
+Useful extras:
+
+| Extra | Includes | Use |
+| --- | --- | --- |
+| `cpu` | `torch`, `torchvision` | CPU-only development and CI |
+| `cuda` | `torch`, `torchvision` via the configured PyTorch CUDA index | NVIDIA GPU inference |
+| `comfyui` | ComfyUI runtime dependencies | Importing and running ComfyUI internals |
+| `audio` | `torchaudio` | Audio helpers and pipelines |
+| `video` | `av`, `imageio`, `opencv-python` | Video I/O helpers |
+| `all` | CUDA, audio, video, and ComfyUI runtime dependencies | Full local runtime |
+
+## Python API
+
+The public package root intentionally stays small:
+
+```python
+from comfy_diffusion import check_runtime, vae_decode, vae_encode, apply_lora
+```
+
+Most APIs are imported from explicit submodules:
+
+```python
+from comfy_diffusion.models import ModelManager
+from comfy_diffusion.conditioning import encode_prompt
+from comfy_diffusion.sampling import sample
+```
+
+## Quick Start
+
+Call `check_runtime()` before loading models or sampling. On first runtime use, comfy-diffusion can perform an automatic download of the pinned ComfyUI release when the vendored runtime is missing. Expected failures are returned as an error dict instead of being raised; `check_runtime()` returns an error dict for runtime bootstrap problems.
+
+Example:
+
+```python
+from comfy_diffusion import apply_lora, check_runtime, vae_decode
+from comfy_diffusion.conditioning import encode_prompt
+from comfy_diffusion.models import ModelManager
+from comfy_diffusion.sampling import sample
+
+runtime = check_runtime()
+if "error" in runtime:
+    raise RuntimeError(runtime["error"])
+
+manager = ModelManager(models_dir="/path/to/models")
+checkpoint = manager.load_checkpoint("model.safetensors")
+
+model, clip = apply_lora(
+    checkpoint.model,
+    checkpoint.clip,
+    "style.safetensors",
+    0.8,
+    0.8,
+)
+
+positive = encode_prompt(clip, "a portrait, studio lighting")
+negative = encode_prompt(clip, "blurry, low quality")
+
+import torch
+
+latent = {"samples": torch.zeros(1, 4, 64, 64)}
+denoised = sample(
+    model,
+    positive,
+    negative,
+    latent,
+    steps=20,
+    cfg=7.0,
+    sampler_name="euler",
+    scheduler="normal",
+    seed=42,
+)
+image = vae_decode(checkpoint.vae, denoised)
+image.save("output.png")
+```
+
+`comfy_diffusion.pipelines` remains available as an optional helper namespace for explicit ready-made flows, but the main interface is the modular Python API above.
+
+## CLI
+
+The first-party CLI is named `comfy-diffusion` and provides operational package tools only.
+
+```bash
+uv run comfy-diffusion runtime check --json
+uv run comfy-diffusion runtime paths
+uv run comfy-diffusion models list --models-dir /path/to/models
+uv run comfy-diffusion models download --manifest models.json --models-dir /path/to/models
+```
+
+Model manifest shape:
+
+```json
+{
+  "models": [
+    {
+      "type": "hf",
+      "repo_id": "org/model",
+      "filename": "model.safetensors",
+      "dest": "checkpoints",
+      "sha256": null
+    },
+    {
+      "type": "url",
+      "url": "https://example.com/model.safetensors",
+      "dest": "unet/model.safetensors"
+    },
+    {
+      "type": "civitai",
+      "model_id": 12345,
+      "version_id": 67890,
+      "dest": "loras"
+    }
+  ]
+}
+```
+
+The CLI does not start servers, manage services, expose MCP tools, run a web UI, queue background jobs, or provide Parallax commands.
+
+## Development
+
+```bash
+uv sync --extra cpu --extra comfyui
+uv run pytest
+uv run ruff check .
+```
+
+ComfyUI is pinned as a git submodule at `vendor/ComfyUI`. Do not edit vendored ComfyUI code directly.

comfy_diffusion-2.0.0/README.md

@@ -0,0 +1,151 @@
+# comfy-diffusion
+
+[![PyPI version](https://badge.fury.io/py/comfy-diffusion.svg)](https://pypi.org/project/comfy-diffusion/)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12%2B-blue)](https://pypi.org/project/comfy-diffusion/)
+[![CI](https://github.com/quinteroac/comfy-diffusion/actions/workflows/publish.yml/badge.svg)](https://github.com/quinteroac/comfy-diffusion/actions/workflows/publish.yml)
+[![License: GPL-3.0](https://img.shields.io/badge/License-GPL--3.0-blue.svg)](LICENSE)
+
+`comfy-diffusion` is a standalone Python package that exposes ComfyUI's inference engine as importable modules. It is not a server, node graph runner, web UI, MCP server, daemon, or binary app.
+
+The package vendors ComfyUI at `vendor/ComfyUI` and makes its internal `comfy.*` modules available when runtime APIs need them. Application authors can install this package, import `comfy_diffusion`, and compose inference flows directly in Python.
+
+## Install
+
+Use `uv` for development and dependency resolution:
+
+```bash
+uv sync --extra cpu --extra comfyui
+```
+
+For CUDA environments:
+
+```bash
+uv sync --extra cuda --extra comfyui
+```
+
+Useful extras:
+
+| Extra | Includes | Use |
+| --- | --- | --- |
+| `cpu` | `torch`, `torchvision` | CPU-only development and CI |
+| `cuda` | `torch`, `torchvision` via the configured PyTorch CUDA index | NVIDIA GPU inference |
+| `comfyui` | ComfyUI runtime dependencies | Importing and running ComfyUI internals |
+| `audio` | `torchaudio` | Audio helpers and pipelines |
+| `video` | `av`, `imageio`, `opencv-python` | Video I/O helpers |
+| `all` | CUDA, audio, video, and ComfyUI runtime dependencies | Full local runtime |
+
+## Python API
+
+The public package root intentionally stays small:
+
+```python
+from comfy_diffusion import check_runtime, vae_decode, vae_encode, apply_lora
+```
+
+Most APIs are imported from explicit submodules:
+
+```python
+from comfy_diffusion.models import ModelManager
+from comfy_diffusion.conditioning import encode_prompt
+from comfy_diffusion.sampling import sample
+```
+
+## Quick Start
+
+Call `check_runtime()` before loading models or sampling. On first runtime use, comfy-diffusion can perform an automatic download of the pinned ComfyUI release when the vendored runtime is missing. Expected failures are returned as an error dict instead of being raised; `check_runtime()` returns an error dict for runtime bootstrap problems.
+
+Example:
+
+```python
+from comfy_diffusion import apply_lora, check_runtime, vae_decode
+from comfy_diffusion.conditioning import encode_prompt
+from comfy_diffusion.models import ModelManager
+from comfy_diffusion.sampling import sample
+
+runtime = check_runtime()
+if "error" in runtime:
+    raise RuntimeError(runtime["error"])
+
+manager = ModelManager(models_dir="/path/to/models")
+checkpoint = manager.load_checkpoint("model.safetensors")
+
+model, clip = apply_lora(
+    checkpoint.model,
+    checkpoint.clip,
+    "style.safetensors",
+    0.8,
+    0.8,
+)
+
+positive = encode_prompt(clip, "a portrait, studio lighting")
+negative = encode_prompt(clip, "blurry, low quality")
+
+import torch
+
+latent = {"samples": torch.zeros(1, 4, 64, 64)}
+denoised = sample(
+    model,
+    positive,
+    negative,
+    latent,
+    steps=20,
+    cfg=7.0,
+    sampler_name="euler",
+    scheduler="normal",
+    seed=42,
+)
+image = vae_decode(checkpoint.vae, denoised)
+image.save("output.png")
+```
+
+`comfy_diffusion.pipelines` remains available as an optional helper namespace for explicit ready-made flows, but the main interface is the modular Python API above.
+
+## CLI
+
+The first-party CLI is named `comfy-diffusion` and provides operational package tools only.
+
+```bash
+uv run comfy-diffusion runtime check --json
+uv run comfy-diffusion runtime paths
+uv run comfy-diffusion models list --models-dir /path/to/models
+uv run comfy-diffusion models download --manifest models.json --models-dir /path/to/models
+```
+
+Model manifest shape:
+
+```json
+{
+  "models": [
+    {
+      "type": "hf",
+      "repo_id": "org/model",
+      "filename": "model.safetensors",
+      "dest": "checkpoints",
+      "sha256": null
+    },
+    {
+      "type": "url",
+      "url": "https://example.com/model.safetensors",
+      "dest": "unet/model.safetensors"
+    },
+    {
+      "type": "civitai",
+      "model_id": 12345,
+      "version_id": 67890,
+      "dest": "loras"
+    }
+  ]
+}
+```
+
+The CLI does not start servers, manage services, expose MCP tools, run a web UI, queue background jobs, or provide Parallax commands.
+
+## Development
+
+```bash
+uv sync --extra cpu --extra comfyui
+uv run pytest
+uv run ruff check .
+```
+
+ComfyUI is pinned as a git submodule at `vendor/ComfyUI`. Do not edit vendored ComfyUI code directly.

{comfy_diffusion-1.4.0 → comfy_diffusion-2.0.0}/comfy_diffusion/__init__.py

@@ -1,6 +1,5 @@
 """Public package entrypoint for comfy_diffusion."""
 
-from ._runtime import ensure_comfyui_on_path
 from .lora import apply_lora
 from .runtime import check_runtime
 from .vae import (
@@ -15,8 +14,6 @@ from .vae import (
     vae_encode_tiled,
 )
 
-ensure_comfyui_on_path()
-
 __all__ = [
     "check_runtime",
     "vae_decode",

comfy_diffusion-2.0.0/comfy_diffusion/cli/__init__.py

@@ -0,0 +1,2 @@
+"""Command line interface for comfy-diffusion."""
+

comfy_diffusion-2.0.0/comfy_diffusion/cli/__main__.py

@@ -0,0 +1,7 @@
+"""Run the comfy-diffusion CLI with ``python -m comfy_diffusion.cli``."""
+
+from .main import app
+
+if __name__ == "__main__":
+    app()
+

comfy_diffusion-2.0.0/comfy_diffusion/cli/main.py

@@ -0,0 +1,243 @@
+"""Small operational CLI for the comfy-diffusion Python package."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+
+from comfy_diffusion._runtime import COMFYUI_PINNED_TAG, _comfyui_root
+from comfy_diffusion.downloader import (
+    CivitAIModelEntry,
+    HFModelEntry,
+    ModelEntry,
+    URLModelEntry,
+    download_models,
+)
+from comfy_diffusion.runtime import check_runtime
+
+app = typer.Typer(
+    name="comfy-diffusion",
+    help="Operational tools for the comfy-diffusion Python package.",
+    no_args_is_help=True,
+)
+runtime_app = typer.Typer(help="Inspect the local ComfyUI runtime.", no_args_is_help=True)
+models_app = typer.Typer(help="Inspect and download model files.", no_args_is_help=True)
+
+app.add_typer(runtime_app, name="runtime")
+app.add_typer(models_app, name="models")
+
+_MODEL_DIRS = (
+    "checkpoints",
+    "unet",
+    "diffusion_models",
+    "text_encoders",
+    "clip",
+    "vae",
+    "loras",
+    "embeddings",
+    "upscale_models",
+    "upscale",
+    "audio_encoders",
+    "llm",
+    "clip_vision",
+)
+
+
+def _echo_json(payload: Any) -> None:
+    typer.echo(json.dumps(payload, indent=2, sort_keys=True))
+
+
+def _package_root() -> Path:
+    return Path(__file__).resolve().parents[1]
+
+
+def _default_models_dir() -> Path:
+    return Path.home() / ".cache" / "comfy-diffusion" / "models"
+
+
+@runtime_app.command("check")
+def runtime_check(
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print machine-readable JSON."),
+    ] = False,
+) -> None:
+    """Print runtime diagnostics from ``comfy_diffusion.check_runtime()``."""
+    result = check_runtime()
+    if json_output:
+        _echo_json(result)
+        return
+
+    if "error" in result:
+        typer.echo(f"error: {result['error']}")
+    for key in ("comfyui_version", "device", "vram_total_mb", "vram_free_mb", "python_version"):
+        typer.echo(f"{key}: {result.get(key)}")
+
+
+@runtime_app.command("paths")
+def runtime_paths(
+    models_dir: Annotated[
+        Path | None,
+        typer.Option("--models-dir", help="Models directory to resolve."),
+    ] = None,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print machine-readable JSON."),
+    ] = False,
+) -> None:
+    """Print package, runtime, and model paths."""
+    resolved_models_dir = (models_dir or _default_models_dir()).expanduser().resolve()
+    payload = {
+        "package_root": str(_package_root()),
+        "comfyui_root": str(_comfyui_root()),
+        "models_dir": str(resolved_models_dir),
+        "comfyui_pinned_tag": COMFYUI_PINNED_TAG,
+    }
+    if json_output:
+        _echo_json(payload)
+        return
+    for key, value in payload.items():
+        typer.echo(f"{key}: {value}")
+
+
+def _require_str(raw: dict[str, Any], key: str, *, index: int) -> str:
+    value = raw.get(key)
+    if not isinstance(value, str) or not value:
+        raise typer.BadParameter(f"models[{index}].{key} must be a non-empty string")
+    return value
+
+
+def _optional_sha256(raw: dict[str, Any]) -> str | None:
+    value = raw.get("sha256")
+    if value is None:
+        return None
+    if not isinstance(value, str) or not value:
+        raise typer.BadParameter("sha256 must be a non-empty string when provided")
+    return value
+
+
+def _parse_manifest(path: Path) -> list[ModelEntry]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except OSError as exc:
+        raise typer.BadParameter(f"could not read manifest: {exc}") from exc
+    except json.JSONDecodeError as exc:
+        raise typer.BadParameter(f"manifest is not valid JSON: {exc}") from exc
+
+    models = payload.get("models") if isinstance(payload, dict) else None
+    if not isinstance(models, list):
+        raise typer.BadParameter("manifest root must be an object with a models list")
+
+    entries: list[ModelEntry] = []
+    for index, raw_entry in enumerate(models):
+        if not isinstance(raw_entry, dict):
+            raise typer.BadParameter(f"models[{index}] must be an object")
+        entry_type = raw_entry.get("type")
+        dest = _require_str(raw_entry, "dest", index=index)
+        sha256 = _optional_sha256(raw_entry)
+
+        if entry_type == "hf":
+            entries.append(
+                HFModelEntry(
+                    repo_id=_require_str(raw_entry, "repo_id", index=index),
+                    filename=_require_str(raw_entry, "filename", index=index),
+                    dest=dest,
+                    sha256=sha256,
+                )
+            )
+        elif entry_type == "civitai":
+            model_id = raw_entry.get("model_id")
+            if not isinstance(model_id, int):
+                raise typer.BadParameter(f"models[{index}].model_id must be an integer")
+            version_id = raw_entry.get("version_id")
+            if version_id is not None and not isinstance(version_id, int):
+                raise typer.BadParameter(f"models[{index}].version_id must be an integer")
+            entries.append(
+                CivitAIModelEntry(
+                    model_id=model_id,
+                    version_id=version_id,
+                    dest=dest,
+                    sha256=sha256,
+                )
+            )
+        elif entry_type == "url":
+            entries.append(
+                URLModelEntry(
+                    url=_require_str(raw_entry, "url", index=index),
+                    dest=dest,
+                    sha256=sha256,
+                )
+            )
+        else:
+            raise typer.BadParameter(
+                f"models[{index}].type must be one of: hf, civitai, url"
+            )
+    return entries
+
+
+@models_app.command("download")
+def models_download(
+    manifest: Annotated[
+        Path,
+        typer.Option("--manifest", exists=True, dir_okay=False, help="Model manifest JSON file."),
+    ],
+    models_dir: Annotated[
+        Path,
+        typer.Option("--models-dir", help="Base directory for relative model destinations."),
+    ],
+    quiet: Annotated[
+        bool,
+        typer.Option("--quiet", help="Suppress download progress output."),
+    ] = False,
+) -> None:
+    """Download models from a JSON manifest."""
+    entries = _parse_manifest(manifest)
+    download_models(entries, models_dir=models_dir, quiet=quiet)
+    typer.echo(f"Downloaded {len(entries)} model file(s).")
+
+
+@models_app.command("list")
+def models_list(
+    models_dir: Annotated[
+        Path,
+        typer.Option("--models-dir", exists=True, file_okay=False, help="Models directory."),
+    ],
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print machine-readable JSON."),
+    ] = False,
+) -> None:
+    """List known model directories and files without network access."""
+    root = models_dir.expanduser().resolve()
+    payload: dict[str, list[str]] = {}
+    for dirname in _MODEL_DIRS:
+        directory = root / dirname
+        if directory.is_dir():
+            payload[dirname] = sorted(
+                str(path.relative_to(directory))
+                for path in directory.rglob("*")
+                if path.is_file()
+            )
+        else:
+            payload[dirname] = []
+
+    if json_output:
+        _echo_json({"models_dir": str(root), "directories": payload})
+        return
+
+    typer.echo(f"models_dir: {root}")
+    for dirname, files in payload.items():
+        typer.echo(f"{dirname}: {len(files)} file(s)")
+        for file_path in files:
+            typer.echo(f"  {file_path}")
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()