comfy-diffusion 0.1.0__tar.gz

comfy_diffusion-0.1.0/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: comfy-diffusion
+Version: 0.1.0
+Summary: ComfyUI inference engine as a standalone Python library (no server, no UI).
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pillow>=12.1.1
+Requires-Dist: psutil
+Provides-Extra: cpu
+Requires-Dist: torch; extra == "cpu"
+Provides-Extra: cuda
+Requires-Dist: torch; extra == "cuda"
+Provides-Extra: comfyui
+Requires-Dist: aiohttp>=3.11.8; extra == "comfyui"
+Requires-Dist: alembic>=1.18.4; extra == "comfyui"
+Requires-Dist: av>=14.2.0; extra == "comfyui"
+Requires-Dist: comfy-aimdo>=0.2.7; extra == "comfyui"
+Requires-Dist: comfy-kitchen>=0.2.7; extra == "comfyui"
+Requires-Dist: comfyui-embedded-docs==0.4.3; extra == "comfyui"
+Requires-Dist: comfyui-frontend-package==1.39.19; extra == "comfyui"
+Requires-Dist: comfyui-workflow-templates==0.9.10; extra == "comfyui"
+Requires-Dist: einops>=0.8.2; extra == "comfyui"
+Requires-Dist: glfw>=2.10.0; extra == "comfyui"
+Requires-Dist: kornia>=0.7.1; extra == "comfyui"
+Requires-Dist: numpy>=1.25.0; extra == "comfyui"
+Requires-Dist: pillow>=12.1.1; extra == "comfyui"
+Requires-Dist: psutil>=7.2.2; extra == "comfyui"
+Requires-Dist: pydantic~=2.0; extra == "comfyui"
+Requires-Dist: pydantic-settings~=2.0; extra == "comfyui"
+Requires-Dist: pyopengl>=3.1.10; extra == "comfyui"
+Requires-Dist: pyyaml>=6.0.3; extra == "comfyui"
+Requires-Dist: requests>=2.32.5; extra == "comfyui"
+Requires-Dist: safetensors>=0.4.2; extra == "comfyui"
+Requires-Dist: scipy>=1.17.1; extra == "comfyui"
+Requires-Dist: sentencepiece>=0.2.1; extra == "comfyui"
+Requires-Dist: spandrel>=0.4.2; extra == "comfyui"
+Requires-Dist: sqlalchemy>=2.0.48; extra == "comfyui"
+Requires-Dist: tokenizers>=0.13.3; extra == "comfyui"
+Requires-Dist: torch>=2.10.0; extra == "comfyui"
+Requires-Dist: torchaudio>=2.10.0; extra == "comfyui"
+Requires-Dist: torchsde>=0.2.6; extra == "comfyui"
+Requires-Dist: torchvision>=0.25.0; extra == "comfyui"
+Requires-Dist: tqdm>=4.67.3; extra == "comfyui"
+Requires-Dist: transformers>=4.50.3; extra == "comfyui"
+Requires-Dist: yarl>=1.18.0; extra == "comfyui"
+
+# comfy-diffusion
+
+A Python library that exposes ComfyUI's inference engine as importable modules — no server, no node graph, no UI.
+
+```python
+from comfy_diffusion import check_runtime
+
+print(check_runtime())
+# {"comfyui_version": "0.9.x", "device": "cuda:0", "vram_total_mb": 8192, ...}
+```
+
+---
+
+## Why I built this
+
+I've been building creative AI applications — tools that generate music, visuals, and video for streaming platforms. For a while I used `diffusers` and `DiffSynth-Studio` as my inference backends. They're great libraries, well-documented, easy to import. But I kept hitting the same wall: the best models, the best fine-tunes, the ones that actually produce good results, are all built for ComfyUI.
+
+The LoRAs on Civitai, the checkpoints people spend months training, the workflows the community shares — they're tested on ComfyUI. When I used them through diffusers I'd get inconsistent results, or they just wouldn't work the way they were intended. ComfyUI's sampler implementations, its VRAM management, its model loading logic — these aren't just UI conveniences, they're the reason the outputs look the way they do.
+
+The problem is ComfyUI wasn't built to be a library. It's an application. The only way to use it programmatically is to run it as a server and talk to it over HTTP — which means every project I build needs to depend on a full ComfyUI backend running somewhere. That's a separate process to manage, a separate service to deploy, and a monolith that loads every node and capability whether my app needs them or not.
+
+`comfy-diffusion` is my answer to that. ComfyUI's inference engine — `comfy.model_management`, `comfy.samplers`, `comfy.sd`, all of it — is perfectly importable Python code. It just was never packaged as a library. So I'm packaging it as one.
+
+I built this for myself, to use in my own projects. But I'm building it in the open because I suspect I'm not the only one who wants to write `import comfy_diffusion` instead of running a server.
+
+---
+
+## What it is
+
+`comfy-diffusion` imports ComfyUI's internal modules directly — no server, no HTTP, no node system. ComfyUI is vendored as a git submodule and its internals are made transparently importable when you `import comfy_diffusion`.
+
+The API exposes ComfyUI's building blocks as plain Python functions. You compose them directly — the same way you'd wire nodes in ComfyUI, but in code:
+
+```python
+from comfy_diffusion.models import ModelManager
+from comfy_diffusion.conditioning import encode_prompt
+from comfy_diffusion.sampling import sample
+from comfy_diffusion import vae_decode, vae_encode, apply_lora
+
+manager = ModelManager(models_dir="/path/to/models")
+checkpoint = manager.load_checkpoint("animagine-xl.safetensors")
+
+# Apply a LoRA
+model, clip = apply_lora(checkpoint.model, checkpoint.clip, "style.safetensors", 0.8, 0.8)
+
+# Encode prompts
+positive = encode_prompt(clip, "a portrait of a woman, studio lighting")
+negative = encode_prompt(clip, "blurry, low quality")
+
+# txt2img
+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")
+
+# img2img
+source = Image.open("input.png")
+latent = vae_encode(checkpoint.vae, source)
+denoised = sample(
+    model, positive, negative, latent,
+    steps=20, cfg=7.0, sampler_name="euler",
+    scheduler="normal", seed=42, denoise=0.75,
+)
+image = vae_decode(checkpoint.vae, denoised)
+image.save("output_img2img.png")
+```
+
+The modularity is the point. Every building block is explicit — you see exactly what's happening at each step, and you can swap any piece without fighting a pipeline abstraction.
+
+---
+
+## What it is not
+
+- Not a ComfyUI wrapper that talks to a running server
+- Not a node system or workflow runner
+- Not a replacement for ComfyUI — it depends on it
+- Not a general-purpose diffusion library — it's opinionated toward ComfyUI's engine
+- Not an opinionated pipeline — there is no `ImagePipeline`. You compose the blocks yourself.
+
+---
+
+## Status
+
+Early development. Built iteratively, one capability block at a time. The full node inventory and iteration plan is in [`ROADMAP.md`](ROADMAP.md).
+
+| # | Module | Goal | Status |
+|---|--------|------|--------|
+| 01 | `_runtime` / `check_runtime()` | Package foundation + ComfyUI vendoring | ✅ Done |
+| 02 | `models` | Checkpoint loading (`ModelManager`, `CheckpointResult`) | ✅ Done |
+| 03 | `conditioning` | Prompt encoding via `encode_prompt` | ✅ Done |
+| 04 | `sampling` | KSampler wrapper via `sample()` | ✅ Done |
+| 05 | `vae` | VAE decode latent→PIL via `vae_decode()` | ✅ Done |
+| 06 | `lora` | LoRA loading and stacking via `apply_lora()` | ✅ Done |
+| 07 | `vae` + `models` | VAE encode + standalone loaders (`load_vae`, `load_clip`, `load_unet`) | ✅ Done |
+| 08 | `vae` — tiled | Tiled VAE encode/decode for large images without OOM | ⬜ Next |
+| 09 | `vae` — batch/video | Batch VAE encode/decode for video frame sequences | ⬜ |
+| 10 | `sampling` — advanced | `SamplerCustomAdvanced`, schedulers, sigma manipulation | ⬜ |
+| 11 | `audio` | Stable Audio, WAN sound-to-video, LTXV audio, ACE Step | ⬜ |
+| — | **`v0.1.0-preview`** | **Preview release milestone** | ⬜ |
+| 12–18 | conditioning, controlnet, latent, image, mask, model patches, packaging | Post-preview | ⬜ |
+
+---
+
+## Installation
+
+The package is **not published on PyPI yet**. Install from the repo (clone + submodule + uv).
+
+ComfyUI deps come from `vendor/ComfyUI/requirements.txt` (extra `comfyui`).
+
+**Note:** `uv.lock` is kept with the CPU variant of torch so CI (no GPU) can run `uv sync` and get reproducible tests. One sync installs CPU torch for everyone; GPU users replace torch with the step below.
+
+```bash
+# 1. ComfyUI submodule (required after clone)
+git submodule update --init
+
+# 2. Same for everyone (installs CPU torch)
+uv sync --extra comfyui
+
+# 3. GPU only: replace torch with CUDA build (required after every uv sync)
+uv pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124 --force-reinstall
+# RTX 50xx (Blackwell): use cu128
+uv pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128 --force-reinstall
+# Verify: uv run python -c "import torch; print(torch.__version__, torch.cuda.is_available())"
+```
+
+> Requires Python 3.12+. ComfyUI is vendored — no separate installation needed. Once the package is on PyPI you can use `pip install comfy-diffusion[cuda]` or `uv add comfy-diffusion[cuda]`.
+
+---
+
+## License
+
+GPL-3.0 — same as ComfyUI, which this project depends on.

comfy_diffusion-0.1.0/README.md

@@ -0,0 +1,137 @@
+# comfy-diffusion
+
+A Python library that exposes ComfyUI's inference engine as importable modules — no server, no node graph, no UI.
+
+```python
+from comfy_diffusion import check_runtime
+
+print(check_runtime())
+# {"comfyui_version": "0.9.x", "device": "cuda:0", "vram_total_mb": 8192, ...}
+```
+
+---
+
+## Why I built this
+
+I've been building creative AI applications — tools that generate music, visuals, and video for streaming platforms. For a while I used `diffusers` and `DiffSynth-Studio` as my inference backends. They're great libraries, well-documented, easy to import. But I kept hitting the same wall: the best models, the best fine-tunes, the ones that actually produce good results, are all built for ComfyUI.
+
+The LoRAs on Civitai, the checkpoints people spend months training, the workflows the community shares — they're tested on ComfyUI. When I used them through diffusers I'd get inconsistent results, or they just wouldn't work the way they were intended. ComfyUI's sampler implementations, its VRAM management, its model loading logic — these aren't just UI conveniences, they're the reason the outputs look the way they do.
+
+The problem is ComfyUI wasn't built to be a library. It's an application. The only way to use it programmatically is to run it as a server and talk to it over HTTP — which means every project I build needs to depend on a full ComfyUI backend running somewhere. That's a separate process to manage, a separate service to deploy, and a monolith that loads every node and capability whether my app needs them or not.
+
+`comfy-diffusion` is my answer to that. ComfyUI's inference engine — `comfy.model_management`, `comfy.samplers`, `comfy.sd`, all of it — is perfectly importable Python code. It just was never packaged as a library. So I'm packaging it as one.
+
+I built this for myself, to use in my own projects. But I'm building it in the open because I suspect I'm not the only one who wants to write `import comfy_diffusion` instead of running a server.
+
+---
+
+## What it is
+
+`comfy-diffusion` imports ComfyUI's internal modules directly — no server, no HTTP, no node system. ComfyUI is vendored as a git submodule and its internals are made transparently importable when you `import comfy_diffusion`.
+
+The API exposes ComfyUI's building blocks as plain Python functions. You compose them directly — the same way you'd wire nodes in ComfyUI, but in code:
+
+```python
+from comfy_diffusion.models import ModelManager
+from comfy_diffusion.conditioning import encode_prompt
+from comfy_diffusion.sampling import sample
+from comfy_diffusion import vae_decode, vae_encode, apply_lora
+
+manager = ModelManager(models_dir="/path/to/models")
+checkpoint = manager.load_checkpoint("animagine-xl.safetensors")
+
+# Apply a LoRA
+model, clip = apply_lora(checkpoint.model, checkpoint.clip, "style.safetensors", 0.8, 0.8)
+
+# Encode prompts
+positive = encode_prompt(clip, "a portrait of a woman, studio lighting")
+negative = encode_prompt(clip, "blurry, low quality")
+
+# txt2img
+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")
+
+# img2img
+source = Image.open("input.png")
+latent = vae_encode(checkpoint.vae, source)
+denoised = sample(
+    model, positive, negative, latent,
+    steps=20, cfg=7.0, sampler_name="euler",
+    scheduler="normal", seed=42, denoise=0.75,
+)
+image = vae_decode(checkpoint.vae, denoised)
+image.save("output_img2img.png")
+```
+
+The modularity is the point. Every building block is explicit — you see exactly what's happening at each step, and you can swap any piece without fighting a pipeline abstraction.
+
+---
+
+## What it is not
+
+- Not a ComfyUI wrapper that talks to a running server
+- Not a node system or workflow runner
+- Not a replacement for ComfyUI — it depends on it
+- Not a general-purpose diffusion library — it's opinionated toward ComfyUI's engine
+- Not an opinionated pipeline — there is no `ImagePipeline`. You compose the blocks yourself.
+
+---
+
+## Status
+
+Early development. Built iteratively, one capability block at a time. The full node inventory and iteration plan is in [`ROADMAP.md`](ROADMAP.md).
+
+| # | Module | Goal | Status |
+|---|--------|------|--------|
+| 01 | `_runtime` / `check_runtime()` | Package foundation + ComfyUI vendoring | ✅ Done |
+| 02 | `models` | Checkpoint loading (`ModelManager`, `CheckpointResult`) | ✅ Done |
+| 03 | `conditioning` | Prompt encoding via `encode_prompt` | ✅ Done |
+| 04 | `sampling` | KSampler wrapper via `sample()` | ✅ Done |
+| 05 | `vae` | VAE decode latent→PIL via `vae_decode()` | ✅ Done |
+| 06 | `lora` | LoRA loading and stacking via `apply_lora()` | ✅ Done |
+| 07 | `vae` + `models` | VAE encode + standalone loaders (`load_vae`, `load_clip`, `load_unet`) | ✅ Done |
+| 08 | `vae` — tiled | Tiled VAE encode/decode for large images without OOM | ⬜ Next |
+| 09 | `vae` — batch/video | Batch VAE encode/decode for video frame sequences | ⬜ |
+| 10 | `sampling` — advanced | `SamplerCustomAdvanced`, schedulers, sigma manipulation | ⬜ |
+| 11 | `audio` | Stable Audio, WAN sound-to-video, LTXV audio, ACE Step | ⬜ |
+| — | **`v0.1.0-preview`** | **Preview release milestone** | ⬜ |
+| 12–18 | conditioning, controlnet, latent, image, mask, model patches, packaging | Post-preview | ⬜ |
+
+---
+
+## Installation
+
+The package is **not published on PyPI yet**. Install from the repo (clone + submodule + uv).
+
+ComfyUI deps come from `vendor/ComfyUI/requirements.txt` (extra `comfyui`).
+
+**Note:** `uv.lock` is kept with the CPU variant of torch so CI (no GPU) can run `uv sync` and get reproducible tests. One sync installs CPU torch for everyone; GPU users replace torch with the step below.
+
+```bash
+# 1. ComfyUI submodule (required after clone)
+git submodule update --init
+
+# 2. Same for everyone (installs CPU torch)
+uv sync --extra comfyui
+
+# 3. GPU only: replace torch with CUDA build (required after every uv sync)
+uv pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124 --force-reinstall
+# RTX 50xx (Blackwell): use cu128
+uv pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128 --force-reinstall
+# Verify: uv run python -c "import torch; print(torch.__version__, torch.cuda.is_available())"
+```
+
+> Requires Python 3.12+. ComfyUI is vendored — no separate installation needed. Once the package is on PyPI you can use `pip install comfy-diffusion[cuda]` or `uv add comfy-diffusion[cuda]`.
+
+---
+
+## License
+
+GPL-3.0 — same as ComfyUI, which this project depends on.

comfy_diffusion-0.1.0/comfy_diffusion/__init__.py

@@ -0,0 +1,30 @@
+"""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 (
+    vae_decode,
+    vae_decode_batch,
+    vae_decode_batch_tiled,
+    vae_decode_tiled,
+    vae_encode,
+    vae_encode_batch,
+    vae_encode_batch_tiled,
+    vae_encode_tiled,
+)
+
+ensure_comfyui_on_path()
+
+__all__ = [
+    "check_runtime",
+    "vae_decode",
+    "vae_decode_batch",
+    "vae_decode_batch_tiled",
+    "vae_decode_tiled",
+    "vae_encode",
+    "vae_encode_batch",
+    "vae_encode_batch_tiled",
+    "vae_encode_tiled",
+    "apply_lora",
+]

comfy_diffusion-0.1.0/comfy_diffusion/_runtime.py

@@ -0,0 +1,26 @@
+"""Internal runtime bootstrap for comfy_diffusion.
+
+Path insertion is intentionally lightweight and import-safe: this module must not
+import torch or comfy internals just to make ComfyUI discoverable.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+def _comfyui_root() -> Path:
+    """Return the absolute path to the vendored ComfyUI directory."""
+    return Path(__file__).resolve().parents[1] / "vendor" / "ComfyUI"
+
+
+def ensure_comfyui_on_path() -> Path:
+    """Ensure vendored ComfyUI is importable and return the inserted path."""
+    comfyui_root = _comfyui_root()
+    comfyui_root_str = str(comfyui_root)
+
+    if comfyui_root_str not in sys.path:
+        sys.path.insert(0, comfyui_root_str)
+
+    return comfyui_root

comfy_diffusion-0.1.0/comfy_diffusion/audio.py

@@ -0,0 +1,168 @@
+"""Audio helpers."""
+
+from __future__ import annotations
+
+from typing import Any, Protocol, cast
+
+
+class _LtxvAudioVaeEncoder(Protocol):
+    sample_rate: int
+
+    def encode(self, audio: Any) -> Any: ...
+
+
+class _LtxvAudioVaeDecoder(Protocol):
+    output_sample_rate: int
+
+    def decode(self, latent: Any) -> Any: ...
+
+
+class _LtxvAudioVae(Protocol):
+    sample_rate: int
+    latent_channels: int
+    latent_frequency_bins: int
+
+    def num_of_latents_from_frames(self, frames_number: int, frame_rate: int) -> int: ...
+
+
+class _AceStep15Clip(Protocol):
+    def tokenize(
+        self,
+        tags: str,
+        *,
+        lyrics: str,
+        bpm: int,
+        duration: float,
+        timesignature: int,
+        language: str,
+        keyscale: str,
+        seed: int,
+        generate_audio_codes: bool,
+        cfg_scale: float,
+        temperature: float,
+        top_p: float,
+        top_k: int,
+        min_p: float,
+    ) -> Any: ...
+
+    def encode_from_tokens_scheduled(self, tokens: Any) -> Any: ...
+
+
+def _get_ltxv_empty_latent_audio_type() -> Any:
+    """Resolve ComfyUI LTXVEmptyLatentAudio node at call time."""
+    from ._runtime import ensure_comfyui_on_path
+
+    ensure_comfyui_on_path()
+    from comfy_extras.nodes_lt_audio import LTXVEmptyLatentAudio
+
+    return LTXVEmptyLatentAudio
+
+
+def _get_ace_step_15_latent_audio_dependencies() -> tuple[Any, Any]:
+    """Resolve torch and ComfyUI model management at call time."""
+    from ._runtime import ensure_comfyui_on_path
+
+    ensure_comfyui_on_path()
+    import comfy.model_management
+    import torch
+
+    return torch, comfy.model_management
+
+
+def _unwrap_node_output(output: Any) -> Any:
+    """Return first output for ComfyUI V3 nodes and tuple-style APIs."""
+    if hasattr(output, "result"):
+        return output.result[0]
+    if isinstance(output, tuple):
+        return output[0]
+    return output
+
+
+def ltxv_audio_vae_encode(vae: _LtxvAudioVaeEncoder, audio: Any) -> dict[str, Any]:
+    """Encode raw audio with an LTXV audio VAE."""
+    audio_latents = vae.encode(audio)
+    return {"samples": audio_latents, "sample_rate": int(vae.sample_rate), "type": "audio"}
+
+
+def ltxv_audio_vae_decode(vae: _LtxvAudioVaeDecoder, latent: Any) -> dict[str, Any]:
+    """Decode latent audio with an LTXV audio VAE."""
+    latent_tensor = latent["samples"] if isinstance(latent, dict) else latent
+    if getattr(latent_tensor, "is_nested", False):
+        latent_tensor = latent_tensor.unbind()[-1]
+    audio = vae.decode(latent_tensor).to(latent_tensor.device)
+    return {"waveform": audio, "sample_rate": int(vae.output_sample_rate)}
+
+
+def ltxv_empty_latent_audio(
+    audio_vae: _LtxvAudioVae,
+    frames_number: int,
+    frame_rate: int = 25,
+    batch_size: int = 1,
+) -> dict[str, Any]:
+    """Create empty LTXV audio latents compatible with ComfyUI's audio pipeline."""
+    ltxv_empty_latent_audio_type = _get_ltxv_empty_latent_audio_type()
+    return cast(
+        dict[str, Any],
+        _unwrap_node_output(
+            ltxv_empty_latent_audio_type.execute(
+                frames_number=frames_number,
+                frame_rate=frame_rate,
+                batch_size=batch_size,
+                audio_vae=audio_vae,
+            )
+        )
+    )
+
+
+def encode_ace_step_15_audio(
+    clip: _AceStep15Clip,
+    tags: str,
+    lyrics: str = "",
+    seed: int = 0,
+    bpm: int = 120,
+    duration: float = 120.0,
+    timesignature: str = "4",
+    language: str = "en",
+    keyscale: str = "C major",
+    generate_audio_codes: bool = True,
+    cfg_scale: float = 2.0,
+    temperature: float = 0.85,
+    top_p: float = 0.9,
+    top_k: int = 0,
+    min_p: float = 0.0,
+) -> Any:
+    """Encode ACE Step 1.5 text/audio metadata conditioning."""
+    tokens = clip.tokenize(
+        tags,
+        lyrics=lyrics,
+        bpm=bpm,
+        duration=duration,
+        timesignature=int(timesignature),
+        language=language,
+        keyscale=keyscale,
+        seed=seed,
+        generate_audio_codes=generate_audio_codes,
+        cfg_scale=cfg_scale,
+        temperature=temperature,
+        top_p=top_p,
+        top_k=top_k,
+        min_p=min_p,
+    )
+    return clip.encode_from_tokens_scheduled(tokens)
+
+
+def empty_ace_step_15_latent_audio(seconds: float, batch_size: int = 1) -> dict[str, Any]:
+    """Create empty ACE Step 1.5 latents used as sampler noise input."""
+    torch, model_management = _get_ace_step_15_latent_audio_dependencies()
+    length = round(seconds * 48000 / 1920)
+    latent = torch.zeros([batch_size, 64, length], device=model_management.intermediate_device())
+    return {"samples": latent, "type": "audio"}
+
+
+__all__ = [
+    "ltxv_audio_vae_encode",
+    "ltxv_audio_vae_decode",
+    "ltxv_empty_latent_audio",
+    "encode_ace_step_15_audio",
+    "empty_ace_step_15_latent_audio",
+]

comfy_diffusion-0.1.0/comfy_diffusion/conditioning.py

@@ -0,0 +1,25 @@
+"""Prompt conditioning helpers."""
+
+from __future__ import annotations
+
+from typing import Any, Protocol
+
+
+class _ClipTextEncoder(Protocol):
+    def tokenize(self, text: str) -> Any: ...
+
+    def encode_from_tokens_scheduled(self, tokens: Any) -> Any: ...
+
+
+def encode_prompt(clip: _ClipTextEncoder, text: str) -> Any:
+    """Encode prompt text with a ComfyUI-compatible CLIP object.
+
+    Positive and negative prompts use the same encoding path; prompt
+    semantics are owned by the caller.
+    """
+    normalized_text = " " if text == "" else text
+    tokens = clip.tokenize(normalized_text)
+    return clip.encode_from_tokens_scheduled(tokens)
+
+
+__all__ = ["encode_prompt"]

comfy_diffusion-0.1.0/comfy_diffusion/lora.py

@@ -0,0 +1,34 @@
+"""LoRA application helpers."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, cast
+
+
+def apply_lora(
+    model: Any,
+    clip: Any,
+    path: str | Path,
+    strength_model: float,
+    strength_clip: float,
+) -> tuple[Any, Any]:
+    """Apply a LoRA file to a model/CLIP pair and return patched copies.
+
+    The returned pair can be passed back into ``apply_lora`` to stack
+    multiple LoRAs by chaining calls.
+    """
+    from ._runtime import ensure_comfyui_on_path
+
+    ensure_comfyui_on_path()
+
+    import comfy.sd
+    import comfy.utils
+
+    lora_path = str(Path(path))
+    lora = comfy.utils.load_torch_file(lora_path, safe_load=True)
+    patched = comfy.sd.load_lora_for_models(model, clip, lora, strength_model, strength_clip)
+    return cast(tuple[Any, Any], patched)
+
+
+__all__ = ["apply_lora"]