Upload REAL ComfyUI backend that connects to the local server

fix/backend_comfyui.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python3
+"""
+ComfyUI local image generation backend for PPT Master.
+Connects to a running ComfyUI server and generates real images via the API.
+"""
+import io, json, os, random, subprocess, sys, time, uuid, threading
+from pathlib import Path
+
+import requests
+from PIL import Image, ImageDraw, ImageFont, ImageFilter
+
+from image_backends.backend_common import (
+    MAX_RETRIES, normalize_image_size, resolve_output_path, save_image_bytes
+)
+
+DEFAULT_SERVER = "http://127.0.0.1:8188"
+VALID_ASPECT_RATIOS = ["1:1","2:3","3:2","3:4","4:3","4:5","5:4","9:16","16:9","21:9"]
+VALID_IMAGE_SIZES = ["512px","1K","2K","4K","0.5K"]
+
+
+def _bool_env(name, default=False):
+    v = os.environ.get(name)
+    if v is None: return default
+    return v.strip().lower() in ("1","true","yes","y","on")
+
+
+def _server():
+    return os.environ.get("COMFYUI_SERVER", DEFAULT_SERVER).rstrip("/")
+
+
+def _ping(server):
+    try:
+        r = requests.get(f"{server}/system_stats", timeout=3)
+        return r.status_code == 200
+    except:
+        return False
+
+
+def _dimensions(aspect_ratio, image_size):
+    image_size = normalize_image_size(image_size)
+    long_edge = {"0.5K":512,"512px":512,"1K":1024,"2K":1536,"4K":2048}.get(image_size, 1024)
+    w_r, h_r = [int(x) for x in aspect_ratio.split(":")]
+    if w_r >= h_r:
+        width, height = long_edge, round(long_edge * h_r / w_r)
+    else:
+        height, width = long_edge, round(long_edge * w_r / h_r)
+    # SD checkpoints want multiples of 8
+    width = max(256, (width // 8) * 8)
+    height = max(256, (height // 8) * 8)
+    return width, height
+
+
+def _build_workflow(prompt, negative, width, height, model):
+    """Build a standard txt2img workflow for ComfyUI API."""
+    seed = random.randint(1, 2**31 - 1)
+
+    # Check if user has a custom workflow JSON
+    workflow_path = os.environ.get("COMFYUI_WORKFLOW")
+    if workflow_path and Path(workflow_path).exists():
+        data = json.loads(Path(workflow_path).read_text(encoding="utf-8"))
+        raw = json.dumps(data)
+        for k, v in {"{{prompt}}": prompt, "{{negative_prompt}}": negative,
+                     "{{width}}": str(width), "{{height}}": str(height),
+                     "{{seed}}": str(seed), "{{model}}": model or ""}.items():
+            raw = raw.replace(k, v)
+        return json.loads(raw)
+
+    # Default workflow: CheckpointLoader -> CLIP -> KSampler -> VAEDecode -> SaveImage
+    if not model:
+        raise RuntimeError(
+            "No COMFYUI_MODEL or COMFYUI_WORKFLOW set. "
+            "Set COMFYUI_MODEL to the checkpoint filename in ComfyUI/models/checkpoints/."
+        )
+
+    return {
+        "1": {
+            "class_type": "CheckpointLoaderSimple",
+            "inputs": {"ckpt_name": model}
+        },
+        "2": {
+            "class_type": "CLIPTextEncode",
+            "inputs": {"text": prompt, "clip": ["1", 1]}
+        },
+        "3": {
+            "class_type": "CLIPTextEncode",
+            "inputs": {"text": negative, "clip": ["1", 1]}
+        },
+        "4": {
+            "class_type": "EmptyLatentImage",
+            "inputs": {"width": width, "height": height, "batch_size": 1}
+        },
+        "5": {
+            "class_type": "KSampler",
+            "inputs": {
+                "seed": seed,
+                "steps": 25,
+                "cfg": 7.0,
+                "sampler_name": "euler_ancestral",
+                "scheduler": "normal",
+                "denoise": 1.0,
+                "model": ["1", 0],
+                "positive": ["2", 0],
+                "negative": ["3", 0],
+                "latent_image": ["4", 0]
+            }
+        },
+        "6": {
+            "class_type": "VAEDecode",
+            "inputs": {"samples": ["5", 0], "vae": ["1", 2]}
+        },
+        "7": {
+            "class_type": "SaveImage",
+            "inputs": {"filename_prefix": "pptmaster", "images": ["6", 0]}
+        }
+    }
+
+
+def _queue_and_wait(server, workflow, timeout=600):
+    """Queue prompt on ComfyUI and wait for the result image."""
+    client_id = str(uuid.uuid4())
+
+    # Queue the prompt
+    resp = requests.post(
+        f"{server}/prompt",
+        json={"prompt": workflow, "client_id": client_id},
+        timeout=30
+    )
+    if resp.status_code >= 400:
+        raise RuntimeError(f"ComfyUI /prompt error {resp.status_code}: {resp.text[:500]}")
+
+    prompt_id = resp.json()["prompt_id"]
+    print(f"  Queued prompt_id: {prompt_id}")
+
+    # Poll history until done
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        try:
+            hist = requests.get(f"{server}/history/{prompt_id}", timeout=10)
+            if hist.status_code == 200:
+                data = hist.json()
+                if prompt_id in data:
+                    outputs = data[prompt_id].get("outputs", {})
+                    for node_output in outputs.values():
+                        images = node_output.get("images", [])
+                        for img_info in images:
+                            # Download the generated image
+                            params = {
+                                "filename": img_info["filename"],
+                                "subfolder": img_info.get("subfolder", ""),
+                                "type": img_info.get("type", "output")
+                            }
+                            img_resp = requests.get(f"{server}/view", params=params, timeout=60)
+                            img_resp.raise_for_status()
+                            return img_resp.content
+                    # If outputs exist but no images, there was an error
+                    if outputs:
+                        raise RuntimeError(f"ComfyUI completed but no images in output: {json.dumps(outputs)[:500]}")
+        except requests.RequestException:
+            pass
+        time.sleep(1.5)
+
+    raise RuntimeError(f"Timeout ({timeout}s) waiting for ComfyUI generation.")
+
+
+def _placeholder(prompt, width, height):
+    """Fallback: generate a deterministic placeholder image."""
+    rng = random.Random(hash(prompt) & 0xFFFFFFFF)
+    img = Image.new("RGB", (width, height), (9, 12, 24))
+    d = ImageDraw.Draw(img, "RGBA")
+    pal = [(28,38,70),(52,67,105),(121,33,48),(186,137,64),(30,90,96),(88,20,60)]
+    for i in range(30):
+        c = pal[i % len(pal)] + (rng.randint(50, 140),)
+        x0, y0 = rng.randint(-width//4, width), rng.randint(-height//4, height)
+        r = rng.randint(max(60, width//10), max(160, width//3))
+        d.ellipse((x0-r, y0-r, x0+r, y0+r), fill=c)
+    img = img.filter(ImageFilter.GaussianBlur(radius=max(8, width//100)))
+    d = ImageDraw.Draw(img, "RGBA")
+    for i in range(60):
+        d.rectangle((i, i, width-i, height-i), outline=(0,0,0,max(0,140-int(2.5*i))), width=2)
+    try:
+        fb = ImageFont.truetype("DejaVuSans-Bold.ttf", max(28, width//22))
+        fs = ImageFont.truetype("DejaVuSans.ttf", max(14, width//50))
+    except:
+        fb = fs = ImageFont.load_default()
+    pad = max(24, width//30)
+    bh = max(100, height//5)
+    d.rounded_rectangle((pad, height-bh-pad, width-pad, height-pad), radius=18,
+                        fill=(0,0,0,130), outline=(200,160,80,200), width=2)
+    d.text((pad*1.6, height-bh-pad+18), "PLACEHOLDER (ComfyUI offline)", fill=(240,220,170,255), font=fb)
+    d.text((pad*1.6, height-bh-pad+60), prompt[:120], fill=(230,235,245,220), font=fs)
+    buf = io.BytesIO()
+    img.save(buf, format="PNG")
+    return buf.getvalue()
+
+
+def generate(prompt, aspect_ratio="1:1", image_size="1K",
+             output_dir=None, filename=None, model=None, max_retries=MAX_RETRIES):
+    """Main entry point called by image_gen.py."""
+
+    if aspect_ratio not in VALID_ASPECT_RATIOS:
+        raise ValueError(f"Invalid aspect ratio '{aspect_ratio}'. Valid: {VALID_ASPECT_RATIOS}")
+    image_size = normalize_image_size(image_size)
+    if image_size not in VALID_IMAGE_SIZES:
+        raise ValueError(f"Invalid image size '{image_size}'. Valid: {VALID_IMAGE_SIZES}")
+
+    width, height = _dimensions(aspect_ratio, image_size)
+    path = resolve_output_path(prompt, output_dir, filename, ".png")
+    server = _server()
+    model = model or os.environ.get("COMFYUI_MODEL")
+    negative = os.environ.get("COMFYUI_NEGATIVE_PROMPT",
+        "low quality, blurry, watermark, text, distorted, deformed, ugly, nsfw")
+    fallback = os.environ.get("COMFYUI_FALLBACK", "error").strip().lower()
+
+    print(f"[ComfyUI]")
+    print(f"  Server:       {server}")
+    print(f"  Model:        {model or '(not set)'}")
+    print(f"  Prompt:       {prompt[:100]}{'...' if len(prompt)>100 else ''}")
+    print(f"  Size:         {width}x{height}")
+    print(f"  Aspect Ratio: {aspect_ratio}")
+    print()
+
+    # Check if server is reachable
+    if not _ping(server):
+        msg = (f"ComfyUI server not reachable at {server}.\n"
+               f"  Launch ComfyUI first: python main.py --listen 127.0.0.1 --port 8188")
+        if fallback == "placeholder":
+            print(f"  [WARN] {msg}")
+            print(f"  [WARN] Using placeholder image.")
+            return save_image_bytes(_placeholder(prompt, width, height), path)
+        raise RuntimeError(msg)
+
+    # Build and queue workflow
+    try:
+        workflow = _build_workflow(prompt, negative, width, height, model)
+
+        start = time.time()
+        print(f"  Generating...", end="", flush=True)
+
+        # Heartbeat
+        stop_evt = threading.Event()
+        def heartbeat():
+            while not stop_evt.is_set():
+                stop_evt.wait(5)
+                if not stop_evt.is_set():
+                    print(f" {time.time()-start:.0f}s...", end="", flush=True)
+        hb = threading.Thread(target=heartbeat, daemon=True)
+        hb.start()
+
+        try:
+            image_bytes = _queue_and_wait(server, workflow)
+        finally:
+            stop_evt.set()
+            hb.join(timeout=1)
+
+        elapsed = time.time() - start
+        print(f"\n  [DONE] Generated in {elapsed:.1f}s")
+        return save_image_bytes(image_bytes, path)
+
+    except Exception as e:
+        if fallback == "placeholder":
+            print(f"\n  [WARN] Generation failed: {e}")
+            print(f"  [WARN] Using placeholder image.")
+            return save_image_bytes(_placeholder(prompt, width, height), path)
+        raise