stuff

app.py

@@ -1,6 +1,7 @@
 import gradio as gr
 import spaces
 import torch
+from huggingface_hub import hf_hub_download
 
 from diffusers import AutoencoderKL, ControlNetUnionModel, DiffusionPipeline, StableDiffusionXLPipeline, TCDScheduler, UNet2DConditionModel
 
@@ -46,10 +47,11 @@ UNET_MODELS = {
     "Pixel Party XL": "stabilityai/stable-diffusion-xl-base-1.0",
 }
 
-# Models that are single safetensors files (value is the file URL and base model)
+# Models that are single safetensors files (value is the repo, filename, and base model)
 SINGLE_FILE_MODELS = {
     "Fluently XL v3 Inpainting": {
-        "url": "https://huggingface.co/fluently/Fluently-XL-v3-inpainting/resolve/main/FluentlyXL-v3-inpainting.safetensors",
+        "repo_id": "fluently/Fluently-XL-v3-inpainting",
+        "filename": "FluentlyXL-v3-inpainting.safetensors",
         "base": "stabilityai/stable-diffusion-xl-base-1.0",
     },
 }
@@ -70,9 +72,14 @@ def load_pipeline(model_name):
     if model_name in SINGLE_FILE_MODELS:
         # Load single safetensors checkpoint models
         config = SINGLE_FILE_MODELS[model_name]
+        # Download the checkpoint file first
+        checkpoint_path = hf_hub_download(
+            repo_id=config["repo_id"],
+            filename=config["filename"],
+        )
         # Load the single file to extract the UNet
         temp_pipe = StableDiffusionXLPipeline.from_single_file(
-            config["url"],
+            checkpoint_path,
             torch_dtype=torch.float16,
         )
         unet = temp_pipe.unet

client.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+"""REST API client for the diffusers-fast-inpaint Gradio app."""
+
+import argparse
+import base64
+import io
+import json
+import sys
+from pathlib import Path
+
+import requests
+from PIL import Image
+
+
+DEFAULT_SERVER = "http://localhost:7860"
+
+AVAILABLE_MODELS = [
+    "DreamShaper XL Turbo",
+    "RealVisXL V5.0 Lightning",
+    "Playground v2.5",
+    "Juggernaut XL Lightning",
+    "Pixel Party XL",
+    "Fluently XL v3 Inpainting",
+]
+
+
+def image_to_base64(image_path: str) -> str:
+    """Convert an image file to base64 data URL."""
+    with Image.open(image_path) as img:
+        # Convert to RGBA if needed
+        if img.mode != "RGBA":
+            img = img.convert("RGBA")
+        buffer = io.BytesIO()
+        img.save(buffer, format="PNG")
+        b64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
+        return f"data:image/png;base64,{b64}"
+
+
+def create_mask_from_image(mask_path: str) -> str:
+    """Convert a mask image to base64 data URL."""
+    return image_to_base64(mask_path)
+
+
+def base64_to_image(b64_string: str) -> Image.Image:
+    """Convert base64 data URL to PIL Image."""
+    if b64_string.startswith("data:"):
+        b64_string = b64_string.split(",", 1)[1]
+    image_data = base64.b64decode(b64_string)
+    return Image.open(io.BytesIO(image_data))
+
+
+def inpaint(
+    image_path: str,
+    mask_path: str,
+    prompt: str,
+    negative_prompt: str = "",
+    model: str = "DreamShaper XL Turbo",
+    paste_back: bool = True,
+    guidance_scale: float = 1.5,
+    num_steps: int = 8,
+    use_detail_lora: bool = False,
+    detail_lora_weight: float = 1.1,
+    use_pixel_lora: bool = False,
+    pixel_lora_weight: float = 1.2,
+    use_wowifier_lora: bool = False,
+    wowifier_lora_weight: float = 1.0,
+    server_url: str = DEFAULT_SERVER,
+    output_path: str | None = None,
+) -> Image.Image:
+    """
+    Call the inpainting API.
+
+    Args:
+        image_path: Path to the input image
+        mask_path: Path to the mask image (white = inpaint area)
+        prompt: Text prompt for generation
+        negative_prompt: Negative prompt
+        model: Model name to use
+        paste_back: Whether to paste result back onto original
+        guidance_scale: Guidance scale (0.0-10.0)
+        num_steps: Number of inference steps (1-50)
+        use_detail_lora: Enable Add Detail XL LoRA
+        detail_lora_weight: Weight for detail LoRA (0.0-2.0)
+        use_pixel_lora: Enable Pixel Art XL LoRA
+        pixel_lora_weight: Weight for pixel art LoRA (0.0-2.0)
+        use_wowifier_lora: Enable Wowifier XL LoRA
+        wowifier_lora_weight: Weight for wowifier LoRA (0.0-2.0)
+        server_url: Gradio server URL
+        output_path: Optional path to save the output image
+
+    Returns:
+        PIL Image of the result
+    """
+    # Validate model
+    if model not in AVAILABLE_MODELS:
+        raise ValueError(f"Invalid model: {model}. Available: {AVAILABLE_MODELS}")
+
+    # Prepare the image data in Gradio's expected format
+    background_b64 = image_to_base64(image_path)
+    mask_b64 = create_mask_from_image(mask_path)
+
+    # Gradio ImageMask format
+    image_data = {
+        "background": background_b64,
+        "layers": [mask_b64],
+        "composite": background_b64,
+    }
+
+    # Build the API payload
+    payload = {
+        "data": [
+            prompt,                  # prompt
+            negative_prompt,         # negative_prompt
+            image_data,              # input_image (ImageMask)
+            model,                   # model_selection
+            paste_back,              # paste_back
+            guidance_scale,          # guidance_scale
+            num_steps,               # num_steps
+            use_detail_lora,         # use_detail_lora
+            detail_lora_weight,      # detail_lora_weight
+            use_pixel_lora,          # use_pixel_lora
+            pixel_lora_weight,       # pixel_lora_weight
+            use_wowifier_lora,       # use_wowifier_lora
+            wowifier_lora_weight,    # wowifier_lora_weight
+        ]
+    }
+
+    # Call the API
+    api_url = f"{server_url}/api/predict"
+    response = requests.post(api_url, json=payload, timeout=300)
+    response.raise_for_status()
+
+    result = response.json()
+
+    # Extract the output image (ImageSlider returns a tuple of images)
+    if "data" in result and len(result["data"]) > 0:
+        output_data = result["data"][0]
+        # ImageSlider returns [original, generated] tuple
+        if isinstance(output_data, list) and len(output_data) > 1:
+            generated_b64 = output_data[1]
+        else:
+            generated_b64 = output_data
+
+        # Handle dict format (Gradio 4.x)
+        if isinstance(generated_b64, dict):
+            generated_b64 = generated_b64.get("url") or generated_b64.get("path")
+            if generated_b64.startswith("http"):
+                # Fetch from URL
+                img_response = requests.get(generated_b64)
+                img_response.raise_for_status()
+                result_image = Image.open(io.BytesIO(img_response.content))
+            else:
+                result_image = Image.open(generated_b64)
+        else:
+            result_image = base64_to_image(generated_b64)
+
+        if output_path:
+            result_image.save(output_path)
+            print(f"Saved output to: {output_path}")
+
+        return result_image
+
+    raise RuntimeError(f"Unexpected API response: {result}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Inpainting client for diffusers-fast-inpaint",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    # Required arguments
+    parser.add_argument("image", help="Path to input image")
+    parser.add_argument("mask", help="Path to mask image (white = inpaint area)")
+    parser.add_argument("prompt", help="Text prompt for generation")
+
+    # Optional arguments
+    parser.add_argument("-n", "--negative-prompt", default="", help="Negative prompt")
+    parser.add_argument(
+        "-m", "--model",
+        default="DreamShaper XL Turbo",
+        choices=AVAILABLE_MODELS,
+        help="Model to use"
+    )
+    parser.add_argument(
+        "-o", "--output",
+        default="output.png",
+        help="Output image path"
+    )
+    parser.add_argument(
+        "--server",
+        default=DEFAULT_SERVER,
+        help="Gradio server URL"
+    )
+
+    # Generation parameters
+    parser.add_argument(
+        "--guidance-scale",
+        type=float,
+        default=1.5,
+        help="Guidance scale (0.0-10.0)"
+    )
+    parser.add_argument(
+        "--steps",
+        type=int,
+        default=8,
+        help="Number of inference steps (1-50)"
+    )
+    parser.add_argument(
+        "--no-paste-back",
+        action="store_true",
+        help="Don't paste result back onto original"
+    )
+
+    # LoRA options
+    parser.add_argument(
+        "--detail-lora",
+        action="store_true",
+        help="Enable Add Detail XL LoRA"
+    )
+    parser.add_argument(
+        "--detail-lora-weight",
+        type=float,
+        default=1.1,
+        help="Detail LoRA weight (0.0-2.0)"
+    )
+    parser.add_argument(
+        "--pixel-lora",
+        action="store_true",
+        help="Enable Pixel Art XL LoRA"
+    )
+    parser.add_argument(
+        "--pixel-lora-weight",
+        type=float,
+        default=1.2,
+        help="Pixel Art LoRA weight (0.0-2.0)"
+    )
+    parser.add_argument(
+        "--wowifier-lora",
+        action="store_true",
+        help="Enable Wowifier XL LoRA"
+    )
+    parser.add_argument(
+        "--wowifier-lora-weight",
+        type=float,
+        default=1.0,
+        help="Wowifier LoRA weight (0.0-2.0)"
+    )
+
+    args = parser.parse_args()
+
+    # Validate input files
+    if not Path(args.image).exists():
+        print(f"Error: Image file not found: {args.image}", file=sys.stderr)
+        sys.exit(1)
+    if not Path(args.mask).exists():
+        print(f"Error: Mask file not found: {args.mask}", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        inpaint(
+            image_path=args.image,
+            mask_path=args.mask,
+            prompt=args.prompt,
+            negative_prompt=args.negative_prompt,
+            model=args.model,
+            paste_back=not args.no_paste_back,
+            guidance_scale=args.guidance_scale,
+            num_steps=args.steps,
+            use_detail_lora=args.detail_lora,
+            detail_lora_weight=args.detail_lora_weight,
+            use_pixel_lora=args.pixel_lora,
+            pixel_lora_weight=args.pixel_lora_weight,
+            use_wowifier_lora=args.wowifier_lora,
+            wowifier_lora_weight=args.wowifier_lora_weight,
+            server_url=args.server,
+            output_path=args.output,
+        )
+        print("Done!")
+    except requests.exceptions.ConnectionError:
+        print(f"Error: Could not connect to server at {args.server}", file=sys.stderr)
+        print("Make sure the Gradio app is running.", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -7,4 +7,6 @@ accelerate
 diffusers
 peft
 fastapi
-opencv-python
+opencv-python
+requests
+pillow