Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,53 @@
+FROM python:3.10-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    wget \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Clone ComfyUI
+RUN git clone https://github.com/comfyanonymous/ComfyUI.git /app/ComfyUI
+
+# Install ComfyUI dependencies
+WORKDIR /app/ComfyUI
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Install additional packages for API
+RUN pip install --no-cache-dir gradio fastapi uvicorn pillow
+
+# Create custom nodes directory
+RUN mkdir -p /app/ComfyUI/custom_nodes/dgg_nwn_nodes
+
+# Copy custom nodes
+COPY custom_nodes/ /app/ComfyUI/custom_nodes/dgg_nwn_nodes/
+
+# Copy workflows
+RUN mkdir -p /app/ComfyUI/workflows
+COPY workflows/ /app/ComfyUI/workflows/
+
+# Copy API wrapper
+COPY app.py /app/
+
+# Download base model (SD 1.5 for speed on free tier)
+RUN mkdir -p /app/ComfyUI/models/checkpoints && \
+    wget -O /app/ComfyUI/models/checkpoints/v1-5-pruned-emaonly.safetensors \
+    https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.safetensors || true
+
+# Expose ports
+EXPOSE 7860 8188
+
+# Set environment
+ENV PYTHONUNBUFFERED=1
+
+# Run the Gradio wrapper
+WORKDIR /app
+CMD ["python", "app.py"]

README.md

@@ -1,10 +1,37 @@
----
-title: DGG ComfyUI
-emoji: 🌍
-colorFrom: red
-colorTo: pink
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: DGG ComfyUI - NWN Character Enhancement
+emoji: 🎮
+colorFrom: purple
+colorTo: blue
+sdk: docker
+pinned: false
+license: mit
+---
+
+# DGG ComfyUI - NWN Character Enhancement
+
+A ComfyUI deployment optimized for enhancing Neverwinter Nights characters into photorealistic images for MetaHuman conversion.
+
+## Features
+- **NWN Enhancement Workflow**: Pre-configured for game character upscaling
+- **API Access**: Trigger workflows programmatically
+- **Custom Nodes**: Specialized for fantasy character art
+
+## Usage
+
+### Web Interface
+Open the Space and use the ComfyUI interface directly.
+
+### API Access
+```python
+from gradio_client import Client
+client = Client("BenjaminPittsley/DGG-ComfyUI")
+result = client.predict(
+    image="path/to/nwn_screenshot.png",
+    api_name="/enhance"
+)
+```
+
+## Workflows
+- `nwn_enhance.json`: Enhance NWN character screenshots
+- `fantasy_portrait.json`: Generate fantasy character portraits

app.py

@@ -0,0 +1,281 @@
+"""
+DGG ComfyUI API Wrapper for HuggingFace Spaces
+Provides Gradio interface and API endpoints for NWN character enhancement.
+"""
+import os
+import subprocess
+import threading
+import time
+import json
+import base64
+from pathlib import Path
+
+import gradio as gr
+from PIL import Image
+import requests
+
+# Start ComfyUI in background
+COMFYUI_PORT = 8188
+COMFYUI_URL = f"http://127.0.0.1:{COMFYUI_PORT}"
+
+def start_comfyui():
+    """Start ComfyUI server in background."""
+    subprocess.Popen([
+        "python", "ComfyUI/main.py",
+        "--listen", "127.0.0.1",
+        "--port", str(COMFYUI_PORT),
+        "--disable-auto-launch"
+    ])
+
+# Start ComfyUI on import
+comfyui_thread = threading.Thread(target=start_comfyui, daemon=True)
+comfyui_thread.start()
+
+# Wait for ComfyUI to be ready
+def wait_for_comfyui(timeout=60):
+    """Wait for ComfyUI to be ready."""
+    start = time.time()
+    while time.time() - start < timeout:
+        try:
+            r = requests.get(f"{COMFYUI_URL}/system_stats", timeout=2)
+            if r.status_code == 200:
+                print("ComfyUI is ready!")
+                return True
+        except:
+            pass
+        time.sleep(2)
+    return False
+
+# NWN Enhancement Workflow
+NWN_ENHANCE_WORKFLOW = {
+    "3": {
+        "class_type": "KSampler",
+        "inputs": {
+            "seed": 42,
+            "steps": 20,
+            "cfg": 7.5,
+            "sampler_name": "euler_ancestral",
+            "scheduler": "normal",
+            "denoise": 0.65,
+            "model": ["4", 0],
+            "positive": ["6", 0],
+            "negative": ["7", 0],
+            "latent_image": ["5", 0]
+        }
+    },
+    "4": {
+        "class_type": "CheckpointLoaderSimple",
+        "inputs": {
+            "ckpt_name": "v1-5-pruned-emaonly.safetensors"
+        }
+    },
+    "5": {
+        "class_type": "VAEEncode",
+        "inputs": {
+            "pixels": ["10", 0],
+            "vae": ["4", 2]
+        }
+    },
+    "6": {
+        "class_type": "CLIPTextEncode",
+        "inputs": {
+            "text": "photorealistic fantasy character portrait, highly detailed facial features, 8k, cinematic lighting, professional character art, sharp focus, intricate armor details",
+            "clip": ["4", 1]
+        }
+    },
+    "7": {
+        "class_type": "CLIPTextEncode",
+        "inputs": {
+            "text": "blurry, low quality, low poly, pixelated, cartoonish, anime, simple",
+            "clip": ["4", 1]
+        }
+    },
+    "8": {
+        "class_type": "VAEDecode",
+        "inputs": {
+            "samples": ["3", 0],
+            "vae": ["4", 2]
+        }
+    },
+    "9": {
+        "class_type": "SaveImage",
+        "inputs": {
+            "filename_prefix": "nwn_enhanced",
+            "images": ["8", 0]
+        }
+    },
+    "10": {
+        "class_type": "LoadImage",
+        "inputs": {
+            "image": "input.png"
+        }
+    }
+}
+
+def enhance_nwn_character(
+    input_image: Image.Image,
+    prompt: str = "photorealistic fantasy character, detailed skin, cinematic lighting",
+    negative_prompt: str = "blurry, low quality, pixelated",
+    denoise: float = 0.65,
+    steps: int = 20,
+    seed: int = -1
+) -> Image.Image:
+    """
+    Enhance an NWN character screenshot using Stable Diffusion.
+    
+    Args:
+        input_image: PIL Image of NWN character
+        prompt: Enhancement prompt
+        negative_prompt: What to avoid
+        denoise: How much to change (0=none, 1=complete)
+        steps: Sampling steps
+        seed: Random seed (-1 for random)
+        
+    Returns:
+        Enhanced PIL Image
+    """
+    if not wait_for_comfyui(timeout=30):
+        raise Exception("ComfyUI not available")
+    
+    # Save input image
+    input_path = Path("/tmp/input.png")
+    input_image.save(input_path)
+    
+    # Upload image to ComfyUI
+    with open(input_path, "rb") as f:
+        files = {"image": f}
+        r = requests.post(f"{COMFYUI_URL}/upload/image", files=files)
+        if r.status_code != 200:
+            raise Exception(f"Failed to upload image: {r.text}")
+        upload_result = r.json()
+    
+    # Modify workflow
+    workflow = NWN_ENHANCE_WORKFLOW.copy()
+    workflow["6"]["inputs"]["text"] = prompt
+    workflow["7"]["inputs"]["text"] = negative_prompt
+    workflow["3"]["inputs"]["denoise"] = denoise
+    workflow["3"]["inputs"]["steps"] = steps
+    workflow["3"]["inputs"]["seed"] = seed if seed >= 0 else int(time.time() * 1000) % 2**32
+    workflow["10"]["inputs"]["image"] = upload_result.get("name", "input.png")
+    
+    # Queue prompt
+    prompt_data = {"prompt": workflow}
+    r = requests.post(f"{COMFYUI_URL}/prompt", json=prompt_data)
+    if r.status_code != 200:
+        raise Exception(f"Failed to queue prompt: {r.text}")
+    
+    prompt_id = r.json().get("prompt_id")
+    
+    # Wait for completion
+    for _ in range(120):  # 2 minute timeout
+        time.sleep(1)
+        r = requests.get(f"{COMFYUI_URL}/history/{prompt_id}")
+        if r.status_code == 200:
+            history = r.json()
+            if prompt_id in history:
+                outputs = history[prompt_id].get("outputs", {})
+                if "9" in outputs:  # SaveImage node
+                    images = outputs["9"].get("images", [])
+                    if images:
+                        # Get the output image
+                        img_info = images[0]
+                        img_r = requests.get(
+                            f"{COMFYUI_URL}/view",
+                            params={
+                                "filename": img_info["filename"],
+                                "subfolder": img_info.get("subfolder", ""),
+                                "type": img_info.get("type", "output")
+                            }
+                        )
+                        if img_r.status_code == 200:
+                            from io import BytesIO
+                            return Image.open(BytesIO(img_r.content))
+    
+    raise Exception("Timeout waiting for result")
+
+
+# Gradio Interface
+def gradio_enhance(
+    image,
+    character_type: str,
+    denoise: float,
+    steps: int,
+    seed: int
+):
+    """Gradio wrapper for enhancement."""
+    prompt = f"photorealistic {character_type}, highly detailed facial features, 8k, cinematic lighting, professional character art"
+    negative = "blurry, low quality, low poly, pixelated, cartoonish, anime"
+    
+    result = enhance_nwn_character(
+        input_image=image,
+        prompt=prompt,
+        negative_prompt=negative,
+        denoise=denoise,
+        steps=steps,
+        seed=seed
+    )
+    return result
+
+# Create Gradio app
+with gr.Blocks(title="DGG NWN Character Enhancer") as demo:
+    gr.Markdown("# 🎮 DGG NWN Character Enhancer")
+    gr.Markdown("Transform low-poly NWN characters into photorealistic images for MetaHuman conversion.")
+    
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(type="pil", label="NWN Screenshot")
+            character_type = gr.Dropdown(
+                choices=[
+                    "female elf paladin in silver armor",
+                    "male human warrior in plate armor",
+                    "female human mage in robes",
+                    "male dwarf fighter in heavy armor",
+                    "female half-elf ranger in leather armor",
+                    "male elf wizard in arcane robes"
+                ],
+                value="female elf paladin in silver armor",
+                label="Character Type"
+            )
+            denoise = gr.Slider(
+                minimum=0.3, maximum=0.9, value=0.65, step=0.05,
+                label="Enhancement Strength (lower = more faithful to original)"
+            )
+            steps = gr.Slider(
+                minimum=10, maximum=50, value=20, step=5,
+                label="Quality Steps"
+            )
+            seed = gr.Number(value=-1, label="Seed (-1 for random)")
+            enhance_btn = gr.Button("✨ Enhance Character", variant="primary")
+        
+        with gr.Column():
+            output_image = gr.Image(type="pil", label="Enhanced Result")
+    
+    enhance_btn.click(
+        fn=gradio_enhance,
+        inputs=[input_image, character_type, denoise, steps, seed],
+        outputs=output_image
+    )
+    
+    gr.Markdown("""
+    ## API Usage
+    ```python
+    from gradio_client import Client
+    client = Client("BenjaminPittsley/DGG-ComfyUI")
+    result = client.predict(
+        image="screenshot.png",
+        character_type="female elf paladin in silver armor",
+        denoise=0.65,
+        steps=20,
+        seed=-1,
+        api_name="/enhance"
+    )
+    ```
+    """)
+
+if __name__ == "__main__":
+    # Wait for ComfyUI to start
+    print("Waiting for ComfyUI to start...")
+    wait_for_comfyui(timeout=120)
+    
+    # Launch Gradio
+    demo.launch(server_name="0.0.0.0", server_port=7860)

custom_nodes/__init__.py

@@ -0,0 +1,184 @@
+"""
+DGG NWN Custom Nodes for ComfyUI
+Specialized nodes for Neverwinter Nights character enhancement workflow.
+"""
+
+class NWNCharacterEnhancePrompt:
+    """
+    Generate optimized prompts for NWN character enhancement.
+    Automatically creates prompt/negative prompt pairs based on character archetype.
+    """
+    
+    CHARACTER_PRESETS = {
+        "paladin_female": {
+            "base": "female paladin warrior, ornate silver plate armor with golden trim",
+            "features": "noble elven features, determined expression, flowing hair",
+        },
+        "paladin_male": {
+            "base": "male paladin warrior, heavy plate armor with holy symbols",
+            "features": "strong jawline, short hair, battle-worn face",
+        },
+        "mage_female": {
+            "base": "female arcane mage, flowing magical robes with arcane patterns",
+            "features": "intelligent eyes, mysterious aura, elegant features",
+        },
+        "mage_male": {
+            "base": "male wizard, elaborate robes with mystical symbols",
+            "features": "wise expression, aged features, long beard",
+        },
+        "rogue_female": {
+            "base": "female rogue assassin, dark leather armor with hidden blades",
+            "features": "cunning eyes, agile build, sharp features",
+        },
+        "rogue_male": {
+            "base": "male thief, practical leather gear with pouches",
+            "features": "shadowy expression, quick reflexes, scarred face",
+        },
+        "warrior_female": {
+            "base": "female barbarian warrior, fur-lined armor with battle damage",
+            "features": "fierce expression, muscular build, war paint",
+        },
+        "warrior_male": {
+            "base": "male fighter, practical plate mail with sword and shield",
+            "features": "battle-hardened face, strong build, short cropped hair",
+        },
+    }
+    
+    QUALITY_SUFFIXES = {
+        "ultra": "masterpiece, best quality, ultra detailed, 8k uhd, ray tracing, photorealistic",
+        "high": "high quality, detailed, 4k, professional lighting, realistic",
+        "medium": "good quality, detailed, sharp focus",
+    }
+    
+    NEGATIVE_BASE = "low quality, blurry, pixelated, low poly, cartoonish, anime style, deformed, bad anatomy, extra limbs, watermark, signature, text"
+    
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "character_class": (["paladin", "mage", "rogue", "warrior"],),
+                "gender": (["female", "male"],),
+                "race": (["human", "elf", "dwarf", "halfling", "half-elf", "half-orc"],),
+                "quality": (["ultra", "high", "medium"],),
+                "custom_details": ("STRING", {"default": "", "multiline": True}),
+            }
+        }
+    
+    RETURN_TYPES = ("STRING", "STRING")
+    RETURN_NAMES = ("positive_prompt", "negative_prompt")
+    FUNCTION = "generate_prompt"
+    CATEGORY = "DGG/NWN"
+    
+    def generate_prompt(self, character_class, gender, race, quality, custom_details):
+        # Get preset
+        preset_key = f"{character_class}_{gender}"
+        preset = self.CHARACTER_PRESETS.get(preset_key, self.CHARACTER_PRESETS["warrior_male"])
+        
+        # Build prompt
+        race_desc = f"{race} " if race != "human" else ""
+        
+        positive = f"photorealistic {race_desc}{preset['base']}, {preset['features']}"
+        
+        if custom_details.strip():
+            positive += f", {custom_details.strip()}"
+        
+        positive += f", {self.QUALITY_SUFFIXES[quality]}"
+        
+        negative = self.NEGATIVE_BASE
+        
+        return (positive, negative)
+
+
+class NWNImagePreprocess:
+    """
+    Preprocess NWN screenshots for better enhancement results.
+    - Removes UI elements
+    - Normalizes lighting
+    - Isolates character
+    """
+    
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "remove_background": ("BOOLEAN", {"default": True}),
+                "normalize_lighting": ("BOOLEAN", {"default": True}),
+                "upscale_first": ("BOOLEAN", {"default": False}),
+            }
+        }
+    
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "preprocess"
+    CATEGORY = "DGG/NWN"
+    
+    def preprocess(self, image, remove_background, normalize_lighting, upscale_first):
+        import torch
+        import numpy as np
+        
+        # Convert to numpy
+        if isinstance(image, torch.Tensor):
+            img_np = image.cpu().numpy()
+            if img_np.ndim == 4:
+                img_np = img_np[0]  # Remove batch dimension
+        else:
+            img_np = np.array(image)
+        
+        # Normalize to 0-1 if needed
+        if img_np.max() > 1.0:
+            img_np = img_np / 255.0
+        
+        if normalize_lighting:
+            # Simple contrast normalization
+            for c in range(3):
+                channel = img_np[:, :, c]
+                min_val = channel.min()
+                max_val = channel.max()
+                if max_val > min_val:
+                    img_np[:, :, c] = (channel - min_val) / (max_val - min_val)
+        
+        # Convert back to tensor
+        result = torch.from_numpy(img_np).unsqueeze(0)
+        
+        return (result,)
+
+
+class NWNBatchProcessor:
+    """
+    Process multiple NWN character images in batch.
+    Useful for generating front/side/back views consistently.
+    """
+    
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "images": ("IMAGE",),
+                "prompt_template": ("STRING", {"default": "photorealistic fantasy character, {view} view"}),
+                "views": ("STRING", {"default": "front,side,back"}),
+            }
+        }
+    
+    RETURN_TYPES = ("IMAGE", "STRING")
+    RETURN_NAMES = ("images", "view_prompts")
+    FUNCTION = "process_batch"
+    CATEGORY = "DGG/NWN"
+    
+    def process_batch(self, images, prompt_template, views):
+        view_list = [v.strip() for v in views.split(",")]
+        prompts = [prompt_template.format(view=v) for v in view_list]
+        return (images, "\n".join(prompts))
+
+
+# Node mappings for ComfyUI
+NODE_CLASS_MAPPINGS = {
+    "NWNCharacterEnhancePrompt": NWNCharacterEnhancePrompt,
+    "NWNImagePreprocess": NWNImagePreprocess,
+    "NWNBatchProcessor": NWNBatchProcessor,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "NWNCharacterEnhancePrompt": "🎮 NWN Character Prompt",
+    "NWNImagePreprocess": "🎮 NWN Image Preprocess",
+    "NWNBatchProcessor": "🎮 NWN Batch Processor",
+}

workflows/nwn_enhance.json

@@ -0,0 +1,100 @@
+{
+    "last_node_id": 12,
+    "last_link_id": 12,
+    "nodes": [
+        {
+            "id": 1,
+            "type": "LoadImage",
+            "pos": [50, 100],
+            "size": [300, 300],
+            "title": "NWN Screenshot"
+        },
+        {
+            "id": 2,
+            "type": "NWNCharacterEnhancePrompt",
+            "pos": [50, 450],
+            "size": [300, 200],
+            "title": "Character Prompt Generator",
+            "widgets_values": ["paladin", "female", "elf", "ultra", "ornate silver armor, flowing blonde hair"]
+        },
+        {
+            "id": 3,
+            "type": "CheckpointLoaderSimple",
+            "pos": [400, 50],
+            "size": [300, 100],
+            "title": "Load Model"
+        },
+        {
+            "id": 4,
+            "type": "CLIPTextEncode",
+            "pos": [400, 200],
+            "size": [300, 100],
+            "title": "Positive Prompt"
+        },
+        {
+            "id": 5,
+            "type": "CLIPTextEncode",
+            "pos": [400, 350],
+            "size": [300, 100],
+            "title": "Negative Prompt"
+        },
+        {
+            "id": 6,
+            "type": "VAEEncode",
+            "pos": [400, 500],
+            "size": [200, 100],
+            "title": "Encode Image"
+        },
+        {
+            "id": 7,
+            "type": "KSampler",
+            "pos": [750, 200],
+            "size": [300, 250],
+            "title": "Sampler",
+            "widgets_values": [42, "randomize", 25, 7.5, "euler_ancestral", "normal", 0.65]
+        },
+        {
+            "id": 8,
+            "type": "VAEDecode",
+            "pos": [1100, 200],
+            "size": [200, 100],
+            "title": "Decode Image"
+        },
+        {
+            "id": 9,
+            "type": "SaveImage",
+            "pos": [1100, 350],
+            "size": [300, 300],
+            "title": "Save Enhanced"
+        },
+        {
+            "id": 10,
+            "type": "PreviewImage",
+            "pos": [1350, 200],
+            "size": [300, 300],
+            "title": "Preview"
+        }
+    ],
+    "links": [
+        [1, 1, 0, 6, 0, "IMAGE"],
+        [2, 2, 0, 4, 0, "STRING"],
+        [3, 2, 1, 5, 0, "STRING"],
+        [4, 3, 0, 7, 0, "MODEL"],
+        [5, 3, 1, 4, 1, "CLIP"],
+        [6, 3, 1, 5, 1, "CLIP"],
+        [7, 3, 2, 6, 1, "VAE"],
+        [8, 4, 0, 7, 1, "CONDITIONING"],
+        [9, 5, 0, 7, 2, "CONDITIONING"],
+        [10, 6, 0, 7, 3, "LATENT"],
+        [11, 7, 0, 8, 0, "LATENT"],
+        [12, 3, 2, 8, 1, "VAE"],
+        [13, 8, 0, 9, 0, "IMAGE"],
+        [14, 8, 0, 10, 0, "IMAGE"]
+    ],
+    "config": {},
+    "extra": {
+        "workflow_name": "NWN Character Enhancement",
+        "author": "DGG Pipeline",
+        "description": "Enhance NWN character screenshots to photorealistic quality for MetaHuman conversion"
+    }
+}