Sync with adamelliotfields/diffusion

DOCS.md

@@ -1,8 +1,8 @@
-# Diffusion XL
+## Usage
 
 TL;DR: Enter a prompt or roll the `🎲` and press `Generate`.
 
-## Prompting
+### Prompting
 
 Positive and negative prompts are embedded by [Compel](https://github.com/damian0815/compel) for weighting. See [syntax features](https://github.com/damian0815/compel/blob/main/doc/syntax.md) to learn more.
 
@@ -10,52 +10,30 @@ Use `+` or `-` to increase the weight of a token. The weight grows exponentially
 
 For groups of tokens, wrap them in parentheses and multiply by a float between 0 and 2. For example, `a (birthday cake)1.3 on a table` will increase the weight of both `birthday` and `cake` by 1.3x. This also means the entire scene will be more birthday-like, not just the cake. To counteract this, you can use `-` inside the parentheses on specific tokens, e.g., `a (birthday-- cake)1.3`, to reduce the birthday aspect.
 
-This is the same syntax used in [InvokeAI](https://invoke-ai.github.io/InvokeAI/features/PROMPTS/) and it differs from AUTOMATIC1111:
-
-| Compel      | AUTOMATIC1111 |
-| ----------- | ------------- |
-| `blue++`    | `((blue))`    |
-| `blue--`    | `[[blue]]`    |
-| `(blue)1.2` | `(blue:1.2)`  |
-| `(blue)0.8` | `(blue:0.8)`  |
-
-### Arrays
-
-Arrays allow you to generate multiple different images from a single prompt. For example, `an adult [[blonde,brunette]] [[man,woman]]` will expand into **4** different prompts. This implementation was inspired by [Fooocus](https://github.com/lllyasviel/Fooocus/pull/1503).
-
-> NB: Make sure to set `Images` to the number of images you want to generate. Otherwise, only the first prompt will be used.
-
-## Models
+### Models
 
 Each model checkpoint has a different aesthetic:
 
-* [cagliostrolab/animagine-xl-3.1](https://huggingface.co/cagliostrolab/animagine-xl-3.1): anime
 * [cyberdelia/CyberRealisticXL](https://huggingface.co/cyberdelia/CyberRealsticXL): photorealistic
 * [fluently/Fluently-XL-Final](https://huggingface.co/fluently/Fluently-XL-Final): general purpose
 * [segmind/Segmind-Vega](https://huggingface.co/segmind/Segmind-Vega): lightweight general purpose (default)
 * [SG161222/RealVisXL_V5.0](https://huggingface.co/SG161222/RealVisXL_V5.0): photorealistic
 * [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0): base
 
-## Styles
-
-[Styles](https://huggingface.co/spaces/adamelliotfields/diffusion/blob/main/data/styles.json) are prompt templates that wrap your positive and negative prompts. They were originally derived from the [twri/sdxl_prompt_styler](https://github.com/twri/sdxl_prompt_styler) Comfy node, but have since been entirely rewritten.
-
-Start by framing a simple subject like `portrait of a young adult woman` or `landscape of a mountain range` and experiment.
-
-## Scale
+### Scale
 
 Rescale up to 4x using [Real-ESRGAN](https://github.com/xinntao/Real-ESRGAN) with weights from [ai-forever](ai-forever/Real-ESRGAN). Necessary for high-resolution images.
 
-## Advanced
+### Advanced
 
-### DeepCache
+#### DeepCache
 
-[DeepCache](https://github.com/horseee/DeepCache) caches lower UNet layers and reuses them every `Interval` steps. Trade quality for speed:
+[DeepCache](https://github.com/horseee/DeepCache) caches lower UNet layers and reuses them every _n_ steps. Trade quality for speed:
 * `1`: no caching (default)
 * `2`: more quality
 * `3`: balanced
 * `4`: more speed
 
-### Refiner
+#### Refiner
 
 Use the [ensemble of expert denoisers](https://research.nvidia.com/labs/dir/eDiff-I/) technique, where the first 80% of timesteps are denoised by the base model and the remaining 80% by the [refiner](https://huggingface.co/stabilityai/stable-diffusion-xl-refiner-1.0). Not available with image-to-image pipelines.

README.md

@@ -6,16 +6,15 @@ emoji: 🦣
 colorFrom: gray
 colorTo: red
 sdk: gradio
-sdk_version: 4.41.0
+sdk_version: 4.44.1
 python_version: 3.11.9
 app_file: app.py
 fullWidth: false
-pinned: false
+pinned: true
 header: mini
 license: apache-2.0
 models:
 - ai-forever/Real-ESRGAN
-- cagliostrolab/animagine-xl-3.1
 - cyberdelia/CyberRealsticXL
 - fluently/Fluently-XL-Final
 - madebyollin/sdxl-vae-fp16-fix
@@ -25,7 +24,6 @@ models:
 - stabilityai/stable-diffusion-xl-refiner-1.0
 preload_from_hub:
 - ai-forever/Real-ESRGAN RealESRGAN_x2.pth,RealESRGAN_x4.pth
-- cagliostrolab/animagine-xl-3.1 animagine-xl-3.1.safetensors
 - cyberdelia/CyberRealsticXL CyberRealisticXLPlay_V1.0.safetensors
 - fluently/Fluently-XL-Final FluentlyXL-Final.safetensors
 - madebyollin/sdxl-vae-fp16-fix config.json,diffusion_pytorch_model.safetensors
@@ -46,9 +44,7 @@ preload_from_hub:
 Gradio app for Stable Diffusion XL featuring:
 
 * txt2img pipeline with refiner (img2img with IP-Adapter and ControlNet coming soon)
-* Curated models (LoRAs and TIs coming soon)
-* Compel prompt weighting
-* Dozens of styles and starter prompts
+* Compel prompt weighting and blending
 * Multiple samplers with Karras scheduling
 * DeepCache available
 * Real-ESRGAN upscaling

app.css

@@ -26,7 +26,7 @@
   overflow-y: auto;
 }
 .gallery, .gallery .grid-wrap {
-  height: calc(100vh - 422px);
+  height: calc(100vh - 430px);
   max-height: none;
 }
 
@@ -59,24 +59,6 @@
 #intro > div > svg:is(.dark *) {
   fill: #10b981 !important;
 }
-#intro nav {
-  display: flex;
-  column-gap: 0.5rem;
-}
-#intro nav a, #intro nav span {
-  white-space: nowrap;
-  font-family: monospace;
-}
-#intro nav span {
-  font-weight: 500;
-  color: var(--body-text-color);
-}
-#intro nav a {
-  color: var(--body-text-color-subdued);
-}
-#intro nav a:hover {
-  color: var(--body-text-color);
-}
 
 .popover {
   position: relative;
@@ -100,12 +82,17 @@
   content: 'Random prompt';
 }
 .popover#clear:hover::after {
-  content: 'Clear gallery';
+  content: 'Clear';
 }
 .popover#refresh:hover::after {
   content: var(--seed, "-1");
 }
 
+#settings h3 {
+  color: var(--block-title-text-color) !important;
+  margin-top: 8px !important;
+}
+
 .tabs, .tabitem, .tab-nav, .tab-nav > .selected {
   border-width: 0px;
 }

app.py

@@ -1,12 +1,19 @@
 import argparse
-import json
-import random
 
 import gradio as gr
 
-from lib import Config, async_call, disable_progress_bars, download_repo_files, generate, read_file
+from lib import Config, async_call, disable_progress_bars, download_repo_files, generate, read_file, read_json
 
-# the CSS `content` attribute expects a string so we need to wrap the number in quotes
+# Update refresh button hover text
+seed_js = """
+(seed) => {
+    const button = document.getElementById("refresh");
+    button.style.setProperty("--seed", `"${seed}"`);
+    return seed;
+}
+"""
+
+# The CSS `content` attribute expects a string so we need to wrap the number in quotes
 refresh_seed_js = """
 () => {
     const n = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
@@ -16,14 +23,7 @@ refresh_seed_js = """
 }
 """
 
-seed_js = """
-(seed) => {
-    const button = document.getElementById("refresh");
-    button.style.setProperty("--seed", `"${seed}"`);
-    return seed;
-}
-"""
-
+# Update width and height on aspect ratio change
 aspect_ratio_js = """
 (ar, w, h) => {
     if (!ar) return [w, h];
@@ -32,13 +32,29 @@ aspect_ratio_js = """
 }
 """
 
+# Show "Custom" aspect ratio when manually changing width or height, or one of the predefined ones
+custom_aspect_ratio_js = """
+(w, h) => {
+    if (w === 768 && h === 1344) return "768,1344";
+    if (w === 896 && h === 1152) return "896,1152";
+    if (w === 1024 && h === 1024) return "1024,1024"; 
+    if (w === 1152 && h === 896) return "1152,896";
+    if (w === 1344 && h === 768) return "1344,768";
+    return null;
+}
+"""
 
-def random_fn():
-    prompts = read_file("data/prompts.json")
-    prompts = json.loads(prompts)
-    return gr.Textbox(value=random.choice(prompts))
+# Inject prompts into random function
+random_prompt_js = f"""
+(prompt) => {{
+    const prompts = {read_json("data/prompts.json")};
+    const filtered = prompts.filter(p => p !== prompt);
+    return filtered[Math.floor(Math.random() * filtered.length)];
+}}
+"""
 
 
+# Transform the raw inputs before generation
 async def generate_fn(*args, progress=gr.Progress(track_tqdm=True)):
     if len(args) > 0:
         prompt = args[0]
@@ -59,7 +75,7 @@ async def generate_fn(*args, progress=gr.Progress(track_tqdm=True)):
             progress=progress,
         )
     except RuntimeError:
-        raise gr.Error("Please try again later")
+        raise gr.Error("Error: Please try again")
 
     return images
 
@@ -78,8 +94,8 @@ with gr.Blocks(
         radius_size=gr.themes.sizes.radius_sm,
         spacing_size=gr.themes.sizes.spacing_md,
         # fonts
-        font=[gr.themes.GoogleFont("Inter"), *Config.SANS_FONTS],
-        font_mono=[gr.themes.GoogleFont("Ubuntu Mono"), *Config.MONO_FONTS],
+        font=[gr.themes.GoogleFont("Inter"), "sans-serif"],
+        font_mono=[gr.themes.GoogleFont("Ubuntu Mono"), "monospace"],
     ).set(
         layout_gap="8px",
         block_shadow="0 0 #0000",
@@ -93,27 +109,24 @@ with gr.Blocks(
     with gr.Tabs():
         with gr.TabItem("🏠 Home"):
             with gr.Column():
-                with gr.Group():
-                    output_images = gr.Gallery(
-                        elem_classes=["gallery"],
-                        show_share_button=False,
-                        object_fit="cover",
-                        interactive=False,
-                        show_label=False,
-                        label="Output",
-                        format="png",
-                        columns=2,
-                    )
-                    prompt = gr.Textbox(
-                        placeholder="What do you want to see?",
-                        autoscroll=False,
-                        show_label=False,
-                        label="Prompt",
-                        max_lines=3,
-                        lines=3,
-                    )
-
-                # Buttons
+                output_images = gr.Gallery(
+                    elem_classes=["gallery"],
+                    show_share_button=False,
+                    object_fit="cover",
+                    interactive=False,
+                    show_label=False,
+                    label="Output",
+                    format="png",
+                    columns=2,
+                )
+                prompt = gr.Textbox(
+                    placeholder="What do you want to see?",
+                    autoscroll=False,
+                    show_label=False,
+                    label="Prompt",
+                    max_lines=3,
+                    lines=3,
+                )
                 with gr.Row():
                     generate_btn = gr.Button("Generate", variant="primary")
                     random_btn = gr.Button(
@@ -139,145 +152,130 @@ with gr.Blocks(
                         value="🗑️",
                     )
 
-        with gr.TabItem("⚙️ Menu"):
-            with gr.Group():
+        with gr.TabItem("⚙️ Settings", elem_id="settings"):
+            # Prompt settings
+            gr.HTML("<h3>Prompt</h3>")
+            with gr.Row():
                 negative_prompt = gr.Textbox(
-                    value="nsfw+",
+                    value="nsfw",
                     label="Negative Prompt",
-                    lines=2,
+                    lines=1,
                 )
 
-                with gr.Row():
-                    model = gr.Dropdown(
-                        choices=Config.MODELS,
-                        filterable=False,
-                        value=Config.MODEL,
-                        label="Model",
-                        min_width=240,
-                    )
-                    scheduler = gr.Dropdown(
-                        choices=Config.SCHEDULERS.keys(),
-                        value=Config.SCHEDULER,
-                        elem_id="scheduler",
-                        label="Scheduler",
-                        filterable=False,
-                    )
-
-                with gr.Row():
-                    styles = json.loads(read_file("data/styles.json"))
-                    style_ids = list(styles.keys())
-                    style_ids = [sid for sid in style_ids if not sid.startswith("_")]
-                    style = gr.Dropdown(
-                        value=Config.STYLE,
-                        label="Style",
-                        min_width=240,
-                        choices=[("None", None)] + [(styles[sid]["name"], sid) for sid in style_ids],
-                    )
-
-                with gr.Row():
-                    guidance_scale = gr.Slider(
-                        value=Config.GUIDANCE_SCALE,
-                        label="Guidance Scale",
-                        minimum=1.0,
-                        maximum=15.0,
-                        step=0.1,
-                    )
-                    inference_steps = gr.Slider(
-                        value=Config.INFERENCE_STEPS,
-                        label="Inference Steps",
-                        minimum=1,
-                        maximum=50,
-                        step=1,
-                    )
-                    deepcache_interval = gr.Slider(
-                        value=Config.DEEPCACHE_INTERVAL,
-                        label="DeepCache",
-                        minimum=1,
-                        maximum=4,
-                        step=1,
-                    )
-
-                with gr.Row():
-                    width = gr.Slider(
-                        value=Config.WIDTH,
-                        label="Width",
-                        minimum=512,
-                        maximum=1536,
-                        step=64,
-                    )
-                    height = gr.Slider(
-                        value=Config.HEIGHT,
-                        label="Height",
-                        minimum=512,
-                        maximum=1536,
-                        step=64,
-                    )
-                    aspect_ratio = gr.Dropdown(
-                        value=f"{Config.WIDTH},{Config.HEIGHT}",
-                        label="Aspect Ratio",
-                        filterable=False,
-                        choices=[
-                            ("Custom", None),
-                            ("4:7 (768x1344)", "768,1344"),
-                            ("7:9 (896x1152)", "896,1152"),
-                            ("1:1 (1024x1024)", "1024,1024"),
-                            ("9:7 (1152x896)", "1152,896"),
-                            ("7:4 (1344x768)", "1344,768"),
-                        ],
-                    )
+            # Model settings
+            gr.HTML("<h3>Settings</h3>")
+            with gr.Row():
+                model = gr.Dropdown(
+                    choices=Config.MODELS,
+                    value=Config.MODEL,
+                    filterable=False,
+                    label="Checkpoint",
+                    min_width=240,
+                )
+                scheduler = gr.Dropdown(
+                    choices=Config.SCHEDULERS.keys(),
+                    value=Config.SCHEDULER,
+                    elem_id="scheduler",
+                    label="Scheduler",
+                    filterable=False,
+                )
 
-                with gr.Row():
-                    file_format = gr.Dropdown(
-                        choices=["png", "jpeg", "webp"],
-                        label="File Format",
-                        filterable=False,
-                        value="png",
-                    )
-                    num_images = gr.Dropdown(
-                        choices=list(range(1, 5)),
-                        value=Config.NUM_IMAGES,
-                        filterable=False,
-                        label="Images",
-                    )
-                    scale = gr.Dropdown(
-                        choices=[(f"{s}x", s) for s in Config.SCALES],
-                        filterable=False,
-                        value=Config.SCALE,
-                        label="Scale",
-                    )
-                    seed = gr.Number(
-                        value=Config.SEED,
-                        label="Seed",
-                        minimum=-1,
-                        maximum=(2**64) - 1,
-                    )
+            # Generation settings
+            gr.HTML("<h3>Generation</h3>")
+            with gr.Row():
+                guidance_scale = gr.Slider(
+                    value=Config.GUIDANCE_SCALE,
+                    label="Guidance Scale",
+                    minimum=1.0,
+                    maximum=15.0,
+                    step=0.1,
+                )
+                inference_steps = gr.Slider(
+                    value=Config.INFERENCE_STEPS,
+                    label="Inference Steps",
+                    minimum=1,
+                    maximum=50,
+                    step=1,
+                )
+                deepcache_interval = gr.Slider(
+                    value=Config.DEEPCACHE_INTERVAL,
+                    label="DeepCache",
+                    minimum=1,
+                    maximum=4,
+                    step=1,
+                )
+            with gr.Row():
+                width = gr.Slider(
+                    value=Config.WIDTH,
+                    label="Width",
+                    minimum=512,
+                    maximum=1536,
+                    step=64,
+                )
+                height = gr.Slider(
+                    value=Config.HEIGHT,
+                    label="Height",
+                    minimum=512,
+                    maximum=1536,
+                    step=64,
+                )
+                aspect_ratio = gr.Dropdown(
+                    value=f"{Config.WIDTH},{Config.HEIGHT}",
+                    label="Aspect Ratio",
+                    filterable=False,
+                    choices=[
+                        ("Custom", None),
+                        ("4:7 (768x1344)", "768,1344"),
+                        ("7:9 (896x1152)", "896,1152"),
+                        ("1:1 (1024x1024)", "1024,1024"),
+                        ("9:7 (1152x896)", "1152,896"),
+                        ("7:4 (1344x768)", "1344,768"),
+                    ],
+                )
+            with gr.Row():
+                num_images = gr.Dropdown(
+                    choices=list(range(1, 5)),
+                    value=Config.NUM_IMAGES,
+                    filterable=False,
+                    label="Images",
+                )
+                scale = gr.Dropdown(
+                    choices=[(f"{s}x", s) for s in Config.SCALES],
+                    filterable=False,
+                    value=Config.SCALE,
+                    label="Scale",
+                )
+                seed = gr.Number(
+                    value=Config.SEED,
+                    label="Seed",
+                    minimum=-1,
+                    maximum=(2**64) - 1,
+                )
+            with gr.Row():
+                use_karras = gr.Checkbox(
+                    elem_classes=["checkbox"],
+                    label="Karras σ",
+                    value=True,
+                )
+                use_refiner = gr.Checkbox(
+                    elem_classes=["checkbox"],
+                    label="Refiner",
+                    value=False,
+                )
 
-                with gr.Row():
-                    use_karras = gr.Checkbox(
-                        elem_classes=["checkbox"],
-                        label="Karras σ",
-                        value=True,
-                    )
-                    use_refiner = gr.Checkbox(
-                        elem_classes=["checkbox"],
-                        label="Refiner",
-                        value=False,
-                    )
+        with gr.TabItem("ℹ️ Info"):
+            gr.Markdown(read_file("DOCS.md"))
 
-    random_btn.click(random_fn, inputs=[], outputs=[prompt], show_api=False)
+    # Random prompt on click
+    random_btn.click(None, inputs=[prompt], outputs=[prompt], js=random_prompt_js)
 
+    # Update seed on click
     refresh_btn.click(None, inputs=[], outputs=[seed], js=refresh_seed_js)
 
+    # Update seed button hover text
     seed.change(None, inputs=[seed], outputs=[], js=seed_js)
 
-    file_format.change(
-        lambda f: gr.Gallery(format=f),
-        inputs=[file_format],
-        outputs=[output_images],
-        show_api=False,
-    )
-
-    # input events are only user input; change events are both user and programmatic
+    # Update width and height on aspect ratio change
     aspect_ratio.input(
         None,
         inputs=[aspect_ratio, width, height],
@@ -285,15 +283,16 @@ with gr.Blocks(
         js=aspect_ratio_js,
     )
 
-    # show "Custom" aspect ratio when manually changing width or height
+    # Show "Custom" aspect ratio when manually changing width or height
     gr.on(
         triggers=[width.input, height.input],
         fn=None,
-        inputs=[],
+        inputs=[width, height],
         outputs=[aspect_ratio],
-        js="() => { return null; }",
+        js=custom_aspect_ratio_js,
     )
 
+    # Generate images
     gr.on(
         triggers=[generate_btn.click, prompt.submit],
         fn=generate_fn,
@@ -302,7 +301,6 @@ with gr.Blocks(
         inputs=[
             prompt,
             negative_prompt,
-            style,
             seed,
             model,
             scheduler,

data/prompts.json

@@ -1,48 +1,25 @@
 [
-  "stunning sunset over a futuristic city, with towering skyscrapers, dramatic clouds, golden-hour lighting, atmospheric",
-  "epic dragon perched atop a cliff, detailed claws, fiery landscape, plumes of smoke",
-  "serene beach with crystal clear water and white sand, tropical palm trees swaying in the breeze, paradise",
-  "post-apocalyptic wasteland with rusted and abandoned vehicles, dust storms and towering dust clouds in the distance, dark, gritty, dramatic",
-  "mysterious underwater world with vibrant coral and a school of colorful fish, sun beams shining through the water, magical, enchanting, otherworldly",
-  "snowy winter wonderland with a lone cabin in the distance, surrounded by frosty trees and fresh snowfall, peaceful, serene",
-  "mysterious and abandoned temple in the jungle, surrounded by lush vegetation and tall trees, ancient, atmospheric",
-  "vibrant and bustling city street, busy traffic, bright lights, fast-paced, intense",
-  "gothic cathedral on a stormy night, lightning illuminating the sky, rain pouring down, epic, dramatic, atmospheric",
-  "fantasy castle on a hilltop, surrounded by rolling hills, breathtaking sunset, magical, enchanting, charming, romantic",
-  "vast desert with sand dunes, a lone oasis in the distance, hot sun, blue sky, peaceful, serene",
-  "beautiful waterfall in a lush jungle, sunlight shining through the trees, tropical, peaceful, serene",
-  "enchanted forest with a babbling brook, glowing fireflies, towering trees, shrouded in mist, magical, ethereal, dreamlike, fantasy",
-  "volcanic island with a boiling crater, clouds of ash rise from the peak, intense, dramatic, atmospheric",
-  "lonely lighthouse on a rocky cliff overlooking the sea, stormy sky, crashing waves, ominous, intense, dramatic, atmospheric",
-  "mysterious underground cave with glowing crystals, underground stream, dark, mysterious, otherworldly",
-  "glowing aurora borealis over a frozen lake, with towering mountains in the distance, ethereal, magical, peaceful, serene",
-  "vibrant flower field in the spring, surrounded by rolling hills, brilliant blue sky, full-bloom, colorful, peaceful, serene",
-  "tranquil pond surrounded by tall trees, with a beautiful lily pad garden and calm reflection of the sky, peaceful, serene",
-  "stunning sunset over an ocean horizon, orange and pink hues spread across the sky, peaceful, serene",
-  "abandoned temple in a mountain range, surrounded by misty clouds and tall peaks, mysterious, ancient",
-  "steam locomotive in a snowy mountain range, surrounded by tall peaks, frosted trees, nostalgic",
-  "radiant nebula, star clusters and gas clouds shining brightly, celestial, otherworldly, abstract, space art",
-  "beautiful Santorini island, iconic white buildings, pristine beach, Mediterranean, charming, romantic",
-  "breathtaking Grand Canyon, vast, awe-inspiring, otherworldly, iconic, historic landmark",
-  "breathtaking Machu Picchu, set against a backdrop of towering mountains, iconic, historic landmark",
-  "iconic New York City skyline, with towering skyscrapers, golden-hour lighting, dramatic, atmospheric",
-  "iconic Great Wall of China, stretching along the countryside, historic landmark",
-  "iconic Sydney Opera House, with the harbor and cityscape in the background, stunning, historic landmark",
-  "iconic Taj Mahal, set against a backdrop of lush greenery, stunning, historic landmark",
-  "bowl of steaming hot ramen with a sliced egg, thin slices of meat, green onions, noodles, chopsticks, solo, minimal",
-  "large pizza with melted cheese, seared pepperoni, crispy crust, solo, minimal",
-  "sizzling hot sirloin steak with a perfect crust, seared to perfection, served with a side of roasted vegetables and mashed potatoes, solo, minimal",
-  "wedding cake, white frosting, colorful accent flowers, fresh berry garnish, tiers, layers, elegant, minimal",
-  "baked salmon fillet with a perfectly crispy skin and flaky flesh, side of steamed vegetables and quinoa, healthy, fresh, solo, minimal",
-  "steaming bowl of hearty chili with tender chunks of beef, rich tomato sauce, topped with grated cheddar cheese and green onions, solo, minimal",
-  "platter of sushi rolls, tuna, salmon, california maki, rainbow, colorful, beautiful arrangement, solo, minimal",
-  "stuffed bell pepper filled with browned ground beef, rice, melted cheese, parsley garnish, solo, minimal",
-  "pair of tacos filled with shredded chicken, red onions, cilantro, a drizzle of cream, white plate, blue tablecloth, solo, minimal",
-  "contemporary living room, floor-to-ceiling windows, neutral color palette, minimalistic design, modern furniture, wall-mounted television, ceiling fan, recessed lighting, open floor plan",
-  "rustic kitchen with reclaimed wood cabinetry, large farmhouse sink, industrial lighting fixtures, open shelving, cast iron cookware, exposed brick wall",
-  "luxurious bathroom with freestanding bathtub, marble tiles, brass fixtures, double-sink floating vanity, spa-like atmosphere",
-  "cozy bedroom with a four-poster bed, decorative throw pillows, plush bedding, single large window with natural light, statement wallpaper, relaxing atmosphere",
-  "formula one race car, aerodynamic design, captured in a high speed motion blur, shallow depth-of-field, dramatic lighting, epic, intense",
-  "luxury supercar with aerodynamic curves, high-key lighting, depth-of-field, exotic",
-  "stunning yacht with sleek lines, golden-hour lighting, depth-of-field, breathtaking"
+  "portrait of a blonde woman, detailed facial features, soft natural lighting, bokeh, professional photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "portrait of a young adult woman, freckled complexion, vibrant red hair, smiling, under tree, golden hour lighting, professional photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "portrait of an elderly woman, weathered features, gentle smile, natural window lighting, professional photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "headshot of a middle-aged man, salt and pepper hair, confident expression, studio lighting, neutral backdrop, professional photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+
+  "portrait of a majestic Norwegian forest cat, soft fur detail, green eyes, natural lighting, professional photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "portrait of a British shorthair cat, yellow eyes, gentle expression, soft lighting, bokeh, professional photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "adorable Siamese kitten, blue eyes, soft natural lighting, shallow depth of field, professional photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "portrait of a regal German shepherd, alert ears, noble expression, natural background, golden hour lighting, bokeh, professional photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "Welsh corgi in a colorful garden, cheerful expression, daylight, shallow depth of field, professional photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+
+  "Porsche 911 Turbo (991), front 3/4 view, motion blur, dramatic lighting, professional photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "BMW E92 M3 on mountain road, side profile, motion blur, daylight, professional photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+
+  "tropical beach at sunset, light sand, azure water, swaying palm trees, scattered clouds, distant volcano, ultra wide angle lens, HDR photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "lighthouse on rocky coast at dawn, crashing waves, pastel sky, cumulus clouds, soft morning light, HDR photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "California vineyard at sunset, rows of grapevines stretching to horizon, golden hour lighting, rolling hills, scattered oak trees, ultra wide angle lens, HDR photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "mountain stream in autumn, moss-covered rocks, fallen maple leaves, dappled sunlight through canopy, HDR photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "tranquil alpine lake at night, snow-capped mountain range in distance, scattered evergreens along shoreline, aurora borealis in sky, HDR photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "desert ranch house at dusk, saguaro cactus, purple mountain backdrop, last rays of sunlight, HDR photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "Japanese pagoda between cherry blossom trees, misty mountain backdrop, golden hour lighting, HDR photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "red Dutch barn, colorful tulip rows in front, low evening sun, scattered clouds, HDR photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd",
+  "lavender field in Provence, ancient stone farmhouse, sunset lighting, scattered clouds, distant mountains, HDR photography, breathtaking, masterpiece, highly detailed, best quality, sharp focus, 8k, uhd"
 ]

data/styles.json

@@ -1,136 +0,0 @@
-{
-  "_base": {
-    "positive": "good, perfect, accurate, precise, professional, highly detailed, best quality, masterpiece",
-    "negative": "watermark, trademark, signature, autograph, artifacts, deformed, mutated, bad, ugly, unattractive, noisy, grainy, blurry, distorted, oversaturated, undersaturated, overexposed, underexposed, amateur, sloppy, cluttered, low detail, worst quality"
-  },
-  "abstract": {
-    "name": "Abstract",
-    "positive": "({prompt}), in an abstract art style, non-representational colors and shapes, expressive, imaginative, vibrant, {_base}",
-    "negative": "({prompt}), discrete, objective, realism, photographic, monochrome, muted, {_base}"
-  },
-  "anime_josei": {
-    "name": "Anime: Josei",
-    "positive": "({prompt}), in a josei anime style, inspired by Paradise Kiss, by Ai Yazawa, manga, mature, emotional, sophisticated, soft colors, refined lines, {_base}",
-    "negative": "({prompt}), shonen, shoujo, seinen, dark, gritty, realism, photographic, {_base}"
-  },
-  "anime_seinen": {
-    "name": "Anime: Seinen",
-    "positive": "({prompt}), in a seinen anime style, inspired by Ghost in the Shell, by Masamune Shirow, manga, adult, mature, dark, gritty, intricate design, dramatic lighting, high contrast, {_base}",
-    "negative": "({prompt}), shonen, shoujo, josei, realism, photographic, dull, plain, low contrast, {_base}"
-  },
-  "anime_shojo": {
-    "name": "Anime: Shoujo",
-    "positive": "({prompt}), in a shoujo anime style, manga, romantic, emotional, pastel colors, soft lines, {_base}",
-    "negative": "({prompt}), shonen, seinen, josei, dark, gritty, realism, photographic, {_base}"
-  },
-  "anime_shonen": {
-    "name": "Anime: Shonen",
-    "positive": "({prompt}), in a shonen anime style, manga, action, adventure, heroic, youthful, vibrant, high contrast, {_base}",
-    "negative": "({prompt}), shoujo, seinen, josei, realism, photographic, dull, plain, monochrome, muted, low contrast, {_base}"
-  },
-  "art_deco": {
-    "name": "Art Deco",
-    "positive": "({prompt}), in an art deco style, inspired by Tamara de Lempicka, geometric shapes, bold colors, luxurious, elegant, sleek, streamlined, symmetrical, vibrant, high contrast, {_base}",
-    "negative": "({prompt}), realism, photographic, asymmetrical, monochrome, muted, low contrast, {_base}"
-  },
-  "biomechanical": {
-    "name": "Biomechanical",
-    "positive": "({prompt}), in a biomechanical style, organic and mechanical, flesh and metal, cyborg, cybernetic, intricate design, futuristic, sci-fi, {_base}",
-    "negative": "({prompt}), natural, rustic, primitive, medieval, {_base}"
-  },
-  "cubism": {
-    "name": "Cubism",
-    "positive": "({prompt}), in a cubist style, inspired by Picasso, fragmented shapes and planes, abstract forms, collage, {_base}",
-    "negative": "({prompt}), discrete, objective, {_base}"
-  },
-  "cyberpunk": {
-    "name": "Cyberpunk",
-    "positive": "({prompt}), in a cyberpunk style, 2077, synthwave, neon, digital, high-tech, futuristic, dystopian, vibrant, high contrast, {_base}",
-    "negative": "({prompt}), rustic, primitive, medieval, monochrome, muted, low contrast, {_base}"
-  },
-  "enhance": {
-    "name": "Enhance",
-    "positive": "({prompt}), {_base}",
-    "negative": "({prompt}), {_base}"
-  },
-  "expressionism": {
-    "name": "Expressionism",
-    "positive": "({prompt}), in an expressionist style, energetic brushwork, bold colors, abstract forms, vibrant, expressive, imaginative, high contrast, {_base}",
-    "negative": "({prompt}), discrete, objective, realism, photographic, dull, plain, monochrome, muted, low contrast, {_base}"
-  },
-  "fantasy": {
-    "name": "Fantasy",
-    "positive": "({prompt}), in a fantasy style, digital concept art, by Greg Rutkowski, trending on ArtStation, magical, enchanting, ethereal, dreamlike, graphic, illustration, high contrast, {_base}",
-    "negative": "({prompt}), realism, photographic, ordinary, mundane, monochrome, muted, low contrast, {_base}"
-  },
-  "graffiti": {
-    "name": "Graffiti",
-    "positive": "({prompt}), in a graffiti style, street art, creative composition, dynamic lines, spray paint, hip-hop, stylized, bold, vibrant, urban, mural, high contrast, {_base}",
-    "negative": "({prompt}), dull, plain, monochrome, muted, low contrast, {_base}"
-  },
-  "line_art": {
-    "name": "Line Art",
-    "positive": "({prompt}), in a line art drawing style, graphic, illustration, sleek, streamlined, centered composition, solo subject, isolated subject, white background, minimalist arrangement, {_base}",
-    "negative": "({prompt}), off-center, oil, acrylic, watercolor, {_base}"
-  },
-  "papercraft": {
-    "name": "Papercraft",
-    "positive": "({prompt}), as a papercraft model, Kirigami style, folded paper, papercut, sharp edges, intricate design, 3d, layered, textural, color block, centered composition, minimalist arrangement, {_base}",
-    "negative": "({prompt}), 2d, flat, {_base}"
-  },
-  "photography_food": {
-    "name": "Photography: Food",
-    "positive": "({prompt}), food photography style, fresh ingredients, delicious, culinary, real, authentic, macro details, soft natural lighting, high resolution, uhd, centered composition, minimalist arrangement, {_base}",
-    "negative": "({prompt}), unappetizing, fake, artificial, low resolution, {_base}"
-  },
-  "photography_hdr": {
-    "name": "Photography: HDR",
-    "positive": "({prompt}), breathtaking HDR photography, high dynamic range, vivid colors, shadows and highlights, dramatic lighting, high contrast, high resolution, uhd, {_base}",
-    "negative": "({prompt}), flat colors, plain, dull, low dynamic range, low contrast, low resolution, {_base}"
-  },
-  "photography_iphone": {
-    "name": "Photography: iPhone",
-    "positive": "({prompt}), taken by iPhone ProRAW camera, XDR, Retina, depth-of-field, vivid colors, dynamic range, dramatic lighting, real, authentic, high contrast, high resolution, uhd, {_base}",
-    "negative": "({prompt}), shallow depth-of-field, bokeh, fake, artificial, low contrast, low resolution, {_base}"
-  },
-  "photography_iphone_portrait": {
-    "name": "Photography: iPhone Portrait",
-    "positive": "({prompt}), taken by iPhone Portrait Mode, XDR, Retina, shallow depth-of-field, bokeh, vivid colors, dramatic lighting, real, authentic, high contrast, high resolution, uhd, {_base}",
-    "negative": "({prompt}), fake, artificial, low contrast, low resolution, {_base}"
-  },
-  "photography_real_estate": {
-    "name": "Photography: Real Estate",
-    "positive": "({prompt}), real estate photography style, on Zillow, inviting, staged, well-lit, real, authentic, high resolution, uhd, {_base}",
-    "negative": "({prompt}), dark, fake, artificial, low resolution, {_base}"
-  },
-  "photography_street": {
-    "name": "Photography: Street",
-    "positive": "({prompt}), street photography style, taken on Fujifilm X100V, f2 aperture, 35mm, RAW format, candid, authentic, gritty, urban, high contrast, high resolution, uhd, {_base}",
-    "negative": "({prompt}), staged, fake, artificial, low contrast, low resolution, {_base}"
-  },
-  "pointillism": {
-    "name": "Pointillism",
-    "positive": "({prompt}), pointillism style, composed of small dots, inspired by Georges Seurat, intricate design, vibrant, {_base}",
-    "negative": "({prompt}), line drawing, smooth shading, wide color gamut, dull, plain, monochrome, muted, {_base}"
-  },
-  "pop_art": {
-    "name": "Pop Art",
-    "positive": "({prompt}), in a pop art style, inspired by Warhol, bright colors, bold outlines, popular culture, kitsch, vibrant, high contrast, {_base}",
-    "negative": "({prompt}), discrete, objective, dull, plain, monochrome, muted, low contrast, {_base}"
-  },
-  "render": {
-    "name": "Render",
-    "positive": "({prompt}), Octane render, Unreal Engine, volumetric lighting, ray tracing, ambient occlusion, subsurface scattering, high resolution, uhd, {_base}",
-    "negative": "({prompt}), glitch, error, painting, sketch, low resolution, {_base}"
-  },
-  "vaporwave": {
-    "name": "Vaporwave",
-    "positive": "({prompt}), in a vaporwave style, retro aesthetic, neon colors, vibrant, high contrast, {_base}",
-    "negative": "({prompt}), dark, monochrome, muted, low contrast, {_base}"
-  },
-  "watercolor": {
-    "name": "Watercolor",
-    "positive": "({prompt}), painted with watercolors, colorful, painterly, artistic, fluid, {_base}",
-    "negative": "({prompt}), realism, photographic, oil, acrylic, digital, {_base}"
-  }
-}

lib/__init__.py

@@ -1,29 +1,19 @@
 from .config import Config
 from .inference import generate
-from .loader import Loader
-from .upscaler import RealESRGAN
 from .utils import (
     async_call,
     disable_progress_bars,
-    download_civit_file,
     download_repo_files,
-    enable_progress_bars,
-    load_json,
     read_file,
-    timer,
+    read_json,
 )
 
 __all__ = [
     "Config",
-    "Loader",
-    "RealESRGAN",
     "async_call",
     "disable_progress_bars",
-    "download_civit_file",
     "download_repo_files",
-    "enable_progress_bars",
     "generate",
-    "load_json",
     "read_file",
-    "timer",
+    "read_json",
 ]

lib/config.py

@@ -16,10 +16,10 @@ from diffusers import (
 from diffusers.utils import logging as diffusers_logging
 from transformers import logging as transformers_logging
 
-# improved GPU handling and progress bars; set before importing spaces
+# Improved GPU handling and progress bars; set before importing spaces
 os.environ["ZEROGPU_V2"] = "1"
 
-# use Rust downloader
+# Use Rust-based downloader; errors if enabled and not installed
 if find_spec("hf_transfer"):
     os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
 
@@ -29,6 +29,7 @@ filterwarnings("ignore", category=FutureWarning, module="transformers")
 diffusers_logging.set_verbosity_error()
 transformers_logging.set_verbosity_error()
 
+# Standard refiner structure
 _sdxl_refiner_files = [
     "scheduler/scheduler_config.json",
     "text_encoder_2/config.json",
@@ -44,6 +45,7 @@ _sdxl_refiner_files = [
     "model_index.json",
 ]
 
+# Standard SDXL structure
 _sdxl_files = [
     *_sdxl_refiner_files,
     "text_encoder/config.json",
@@ -54,39 +56,30 @@ _sdxl_files = [
     "tokenizer/vocab.json",
 ]
 
+# Using namespace instead of dataclass for simplicity
 Config = SimpleNamespace(
     HF_TOKEN=os.environ.get("HF_TOKEN", None),
-    CIVIT_TOKEN=os.environ.get("CIVIT_TOKEN", None),
     ZERO_GPU=import_module("spaces").config.Config.zero_gpu,
-    MONO_FONTS=["monospace"],
-    SANS_FONTS=[
-        "sans-serif",
-        "Apple Color Emoji",
-        "Segoe UI Emoji",
-        "Segoe UI Symbol",
-        "Noto Color Emoji",
-    ],
-    PIPELINES={
-        "txt2img": StableDiffusionXLPipeline,
-        "img2img": StableDiffusionXLImg2ImgPipeline,
-    },
     HF_MODELS={
         "segmind/Segmind-Vega": [*_sdxl_files],
         "stabilityai/stable-diffusion-xl-base-1.0": [*_sdxl_files, "vae_1_0/config.json"],
         "stabilityai/stable-diffusion-xl-refiner-1.0": [*_sdxl_refiner_files],
     },
+    PIPELINES={
+        "txt2img": StableDiffusionXLPipeline,
+        "img2img": StableDiffusionXLImg2ImgPipeline,
+    },
     MODEL="segmind/Segmind-Vega",
     MODELS=[
-        "cagliostrolab/animagine-xl-3.1",
         "cyberdelia/CyberRealsticXL",
         "fluently/Fluently-XL-Final",
         "segmind/Segmind-Vega",
         "SG161222/RealVisXL_V5.0",
         "stabilityai/stable-diffusion-xl-base-1.0",
     ],
+    # Single-file model weights
     MODEL_CHECKPOINTS={
-        # keep keys lowercase
-        "cagliostrolab/animagine-xl-3.1": "animagine-xl-3.1.safetensors",
+        # keep keys lowercase for case-insensitive matching in the loader
         "cyberdelia/cyberrealsticxl": "CyberRealisticXLPlay_V1.0.safetensors",  # typo in "realistic"
         "fluently/fluently-xl-final": "FluentlyXL-Final.safetensors",
         "sg161222/realvisxl_v5.0": "RealVisXL_V5.0_fp16.safetensors",
@@ -101,12 +94,11 @@ Config = SimpleNamespace(
         "Euler": EulerDiscreteScheduler,
         "Euler a": EulerAncestralDiscreteScheduler,
     },
-    STYLE="enhance",
     WIDTH=1024,
     HEIGHT=1024,
     NUM_IMAGES=1,
     SEED=-1,
-    GUIDANCE_SCALE=7.5,
+    GUIDANCE_SCALE=6,
     INFERENCE_STEPS=40,
     DEEPCACHE_INTERVAL=1,
     SCALE=1,

lib/inference.py

@@ -1,8 +1,5 @@
-import gc
-import re
 import time
 from datetime import datetime
-from itertools import product
 
 import torch
 from compel import Compel, ReturnedEmbeddingsType
@@ -11,45 +8,11 @@ from spaces import GPU
 
 from .config import Config
 from .loader import Loader
-from .utils import load_json
+from .logger import Logger
+from .utils import clear_cuda_cache, safe_progress, timer
 
 
-def parse_prompt_with_arrays(prompt: str) -> list[str]:
-    arrays = re.findall(r"\[\[(.*?)\]\]", prompt)
-
-    if not arrays:
-        return [prompt]
-
-    tokens = [item.split(",") for item in arrays]  # [("a", "b"), (1, 2)]
-    combinations = list(product(*tokens))  # [("a", 1), ("a", 2), ("b", 1), ("b", 2)]
-
-    # find all the arrays in the prompt and replace them with tokens
-    prompts = []
-    for combo in combinations:
-        current_prompt = prompt
-        for i, token in enumerate(combo):
-            current_prompt = current_prompt.replace(f"[[{arrays[i]}]]", token.strip(), 1)
-        prompts.append(current_prompt)
-    return prompts
-
-
-def apply_style(positive_prompt, negative_prompt, style_id="none"):
-    if style_id.lower() == "none":
-        return (positive_prompt, negative_prompt)
-
-    styles = load_json("./data/styles.json")
-    style = styles.get(style_id)
-    if style is None:
-        return (positive_prompt, negative_prompt)
-
-    style_base = style.get("_base", {})
-    return (
-        style.get("positive").format(prompt=positive_prompt, _base=style_base.get("positive")).strip(),
-        style.get("negative").format(prompt=negative_prompt, _base=style_base.get("negative")).strip(),
-    )
-
-
-# max 60s per image
+# Dynamic signature for the GPU duration function; max 60s per image
 def gpu_duration(**kwargs):
     loading = 15
     duration = 15
@@ -76,13 +39,12 @@ def gpu_duration(**kwargs):
 def generate(
     positive_prompt,
     negative_prompt="",
-    style=None,
     seed=None,
     model="stabilityai/stable-diffusion-xl-base-1.0",
-    scheduler="DDIM",
+    scheduler="Euler",
     width=1024,
     height=1024,
-    guidance_scale=7.5,
+    guidance_scale=6.0,
     inference_steps=40,
     deepcache=1,
     scale=1,
@@ -93,6 +55,13 @@ def generate(
     Info=None,
     progress=None,
 ):
+    start = time.perf_counter()
+    log = Logger("generate")
+    log.info(f"Generating {num_images} image{'s' if num_images > 1 else ''}...")
+
+    if Config.ZERO_GPU:
+        safe_progress(progress, 100, 100, "ZeroGPU init")
+
     if not torch.cuda.is_available():
         raise Error("CUDA not available")
 
@@ -108,7 +77,6 @@ def generate(
     # custom progress bar for multiple images
     def callback_on_step_end(pipeline, step, timestep, latents):
         nonlocal CURRENT_IMAGE, CURRENT_STEP
-
         if progress is not None:
             # calculate total steps for img2img based on denoising strength
             strength = 1
@@ -121,19 +89,12 @@ def generate(
             else:
                 refining = True
                 CURRENT_STEP += 1
-
             progress(
                 (CURRENT_STEP, total_steps),
                 desc=f"{'Refining' if refining else 'Generating'} image {CURRENT_IMAGE}/{num_images}",
             )
         return latents
 
-    start = time.perf_counter()
-    print(f"Generating {num_images} image{'s' if num_images > 1 else ''}")
-
-    if Config.ZERO_GPU and progress is not None:
-        progress((100, 100), desc="ZeroGPU init")
-
     loader = Loader()
     loader.load(
         KIND,
@@ -173,19 +134,13 @@ def generate(
 
     images = []
     current_seed = seed
-    for i in range(num_images):
-        generator = torch.Generator(device=pipe.device).manual_seed(current_seed)
+    safe_progress(progress, 0, num_images, f"Generating image 0/{num_images}")
 
+    for i in range(num_images):
         try:
-            positive_prompts = parse_prompt_with_arrays(positive_prompt)
-            index = i % len(positive_prompts)
-            positive_styled, negative_styled = apply_style(positive_prompts[index], negative_prompt, style)
-
-            if negative_styled.startswith("(), "):
-                negative_styled = negative_styled[4:]
-
-            conditioning_1, pooled_1 = compel_1([positive_styled, negative_styled])
-            conditioning_2, pooled_2 = compel_2([positive_styled, negative_styled])
+            generator = torch.Generator(device=pipe.device).manual_seed(current_seed)
+            conditioning_1, pooled_1 = compel_1([positive_prompt, negative_prompt])
+            conditioning_2, pooled_2 = compel_2([positive_prompt, negative_prompt])
         except PromptParser.ParsingException:
             raise Error("Invalid prompt")
 
@@ -214,46 +169,52 @@ def generate(
             "negative_pooled_prompt_embeds": pooled_1[1:2],
         }
 
+        refiner_kwargs = {
+            "denoising_start": 0.8,
+            "generator": generator,
+            "output_type": refiner_output_type,
+            "guidance_scale": guidance_scale,
+            "num_inference_steps": inference_steps,
+            "prompt_embeds": conditioning_2[0:1],
+            "pooled_prompt_embeds": pooled_2[0:1],
+            "negative_prompt_embeds": conditioning_2[1:2],
+            "negative_pooled_prompt_embeds": pooled_2[1:2],
+        }
+
         if progress is not None:
             pipe_kwargs["callback_on_step_end"] = callback_on_step_end
+            refiner_kwargs["callback_on_step_end"] = callback_on_step_end
 
         try:
             image = pipe(**pipe_kwargs).images[0]
-
-            refiner_kwargs = {
-                "image": image,
-                "denoising_start": 0.8,
-                "generator": generator,
-                "output_type": refiner_output_type,
-                "guidance_scale": guidance_scale,
-                "num_inference_steps": inference_steps,
-                "prompt_embeds": conditioning_2[0:1],
-                "pooled_prompt_embeds": pooled_2[0:1],
-                "negative_prompt_embeds": conditioning_2[1:2],
-                "negative_pooled_prompt_embeds": pooled_2[1:2],
-            }
-
-            if progress is not None:
-                refiner_kwargs["callback_on_step_end"] = callback_on_step_end
             if use_refiner:
+                refiner_kwargs["image"] = image
                 image = refiner(**refiner_kwargs).images[0]
-            if scale > 1:
-                image = upscaler.predict(image)
             images.append((image, str(current_seed)))
             current_seed += 1
-        except Exception as e:
-            raise Error(f"{e}")
         finally:
             CURRENT_STEP = 0
             CURRENT_IMAGE += 1
 
-    # cleanup
-    loader.collect()
-    gc.collect()
+    # Upscale
+    if scale > 1:
+        msg = f"Upscaling {scale}x"
+        with timer(msg):
+            safe_progress(progress, 0, num_images, desc=msg)
+            for i, image in enumerate(images):
+                images = upscaler.predict(image[0])
+                images[i] = image
+                safe_progress(progress, i + 1, num_images, desc=msg)
+
+    # Flush memory after generating
+    clear_cuda_cache()
 
     end = time.perf_counter()
     msg = f"Generated {len(images)} image{'s' if len(images) > 1 else ''} in {end - start:.2f}s"
-    print(msg)
+    log.info(msg)
+
+    # Alert if notifier provided
     if Info:
         Info(msg)
+
     return images

lib/loader.py

@@ -6,8 +6,9 @@ from DeepCache import DeepCacheSDHelper
 from diffusers.models import AutoencoderKL
 
 from .config import Config
+from .logger import Logger
 from .upscaler import RealESRGAN
-from .utils import timer
+from .utils import clear_cuda_cache, timer
 
 
 class Loader:
@@ -22,17 +23,9 @@ class Loader:
                 cls._instance.model = None
                 cls._instance.refiner = None
                 cls._instance.upscaler = None
+                cls._instance.log = Logger("Loader")
         return cls._instance
 
-    # switching models
-    def _should_reset_refiner(self, model=""):
-        if self.refiner is None:
-            return False
-        if self.model and self.model.lower() != model.lower():
-            return True
-        return False
-
-    # switching refiner
     def _should_unload_refiner(self, refiner=False):
         if self.refiner is None:
             return False
@@ -60,13 +53,6 @@ class Loader:
             return True
         return False
 
-    def _reset_refiner(self):
-        if self.refiner is not None:
-            self.refiner.vae = None
-            self.refiner.scheduler = None
-            self.refiner.tokenizer_2 = None
-            self.refiner.text_encoder_2 = None
-
     def _unload_refiner(self):
         if self.refiner is not None:
             with timer("Unloading refiner"):
@@ -79,7 +65,7 @@ class Loader:
 
     def _unload_deepcache(self):
         if self.pipe.deepcache is not None:
-            print("Disabling DeepCache")
+            self.log.info("Disabling DeepCache")
             self.pipe.deepcache.disable()
             delattr(self.pipe, "deepcache")
             if self.refiner is not None:
@@ -91,15 +77,17 @@ class Loader:
         if self.pipe is not None:
             with timer(f"Unloading {self.model}"):
                 self.pipe.to("cpu", silence_dtype_warnings=True)
+                if self.refiner is not None:
+                    self.refiner.vae = None
+                    self.refiner.scheduler = None
+                    self.refiner.tokenizer_2 = None
+                    self.refiner.text_encoder_2 = None
 
     def _unload(self, model, refiner, deepcache, scale):
         to_unload = []
         if self._should_unload_deepcache(deepcache):  # remove deepcache first
             self._unload_deepcache()
 
-        if self._should_reset_refiner(model):
-            self._reset_refiner()
-
         if self._should_unload_refiner(refiner):
             self._unload_refiner()
             to_unload.append("refiner")
@@ -113,59 +101,73 @@ class Loader:
             to_unload.append("model")
             to_unload.append("pipe")
 
-        self.collect()
+        # Flush cache and run garbage collector
+        clear_cuda_cache()
         for component in to_unload:
             setattr(self, component, None)
-            gc.collect()
+        gc.collect()
+
+    def _should_load_refiner(self, refiner=False):
+        if self.refiner is None and refiner:
+            return True
+        return False
+
+    def _should_load_upscaler(self, scale=1):
+        if self.upscaler is None and scale > 1:
+            return True
+        return False
+
+    def _should_load_deepcache(self, interval=1):
+        has_deepcache = hasattr(self.pipe, "deepcache")
+        if not has_deepcache and interval != 1:
+            return True
+        if has_deepcache and self.pipe.deepcache.params["cache_interval"] != interval:
+            return True
+        return False
+
+    def _should_load_pipeline(self):
+        if self.pipe is None:
+            return True
+        return False
 
     def _load_refiner(self, refiner, progress, **kwargs):
-        if refiner and self.refiner is None:
+        if self._should_load_refiner(refiner):
             model = Config.REFINER_MODEL
             pipeline = Config.PIPELINES["img2img"]
             try:
                 with timer(f"Loading {model}"):
                     self.refiner = pipeline.from_pretrained(model, **kwargs).to("cuda")
             except Exception as e:
-                print(f"Error loading {model}: {e}")
+                self.log.error(f"Error loading {model}: {e}")
                 self.refiner = None
                 return
         if self.refiner is not None:
             self.refiner.set_progress_bar_config(disable=progress is not None)
 
     def _load_upscaler(self, scale=1):
-        if self.upscaler is None and scale > 1:
+        if self._should_load_upscaler(scale):
             try:
                 with timer(f"Loading {scale}x upscaler"):
                     self.upscaler = RealESRGAN(scale, device=self.pipe.device)
                     self.upscaler.load_weights()
             except Exception as e:
-                print(f"Error loading {scale}x upscaler: {e}")
+                self.log.error(f"Error loading {scale}x upscaler: {e}")
                 self.upscaler = None
 
     def _load_deepcache(self, interval=1):
-        pipe_has_deepcache = hasattr(self.pipe, "deepcache")
-        if not pipe_has_deepcache and interval == 1:
-            return
-        if pipe_has_deepcache and self.pipe.deepcache.params["cache_interval"] == interval:
-            return
-        print("Enabling DeepCache")
-        self.pipe.deepcache = DeepCacheSDHelper(pipe=self.pipe)
-        self.pipe.deepcache.set_params(cache_interval=interval)
-        self.pipe.deepcache.enable()
-
-        if self.refiner is not None:
-            refiner_has_deepcache = hasattr(self.refiner, "deepcache")
-            if not refiner_has_deepcache and interval == 1:
-                return
-            if refiner_has_deepcache and self.refiner.deepcache.params["cache_interval"] == interval:
-                return
-            self.refiner.deepcache = DeepCacheSDHelper(pipe=self.refiner)
-            self.refiner.deepcache.set_params(cache_interval=interval)
-            self.refiner.deepcache.enable()
+        if self._should_load_deepcache(interval):
+            self.log.info("Enabling DeepCache")
+            self.pipe.deepcache = DeepCacheSDHelper(pipe=self.pipe)
+            self.pipe.deepcache.set_params(cache_interval=interval)
+            self.pipe.deepcache.enable()
+            if self.refiner is not None:
+                self.refiner.deepcache = DeepCacheSDHelper(pipe=self.refiner)
+                self.refiner.deepcache.set_params(cache_interval=interval)
+                self.refiner.deepcache.enable()
 
     def _load_pipeline(self, kind, model, progress, **kwargs):
         pipeline = Config.PIPELINES[kind]
-        if self.pipe is None:
+        if self._should_load_pipeline():
             try:
                 with timer(f"Loading {model}"):
                     self.model = model
@@ -183,21 +185,16 @@ class Loader:
                         self.refiner.text_encoder_2 = self.pipe.text_encoder_2
                         self.refiner.to(self.pipe.device)
             except Exception as e:
-                print(f"Error loading {model}: {e}")
+                self.log.error(f"Error loading {model}: {e}")
                 self.model = None
                 self.pipe = None
+                self.refiner = None
                 return
         if not isinstance(self.pipe, pipeline):
             self.pipe = pipeline.from_pipe(self.pipe).to("cuda")
         if self.pipe is not None:
             self.pipe.set_progress_bar_config(disable=progress is not None)
 
-    def collect(self):
-        torch.cuda.empty_cache()
-        torch.cuda.ipc_collect()
-        torch.cuda.reset_peak_memory_stats()
-        torch.cuda.synchronize()
-
     def load(self, kind, model, scheduler, deepcache, scale, karras, refiner, progress):
         scheduler_kwargs = {
             "beta_start": 0.00085,
@@ -245,27 +242,31 @@ class Loader:
         # same model, different scheduler
         if self.model.lower() == model.lower():
             if not same_scheduler:
-                print(f"Switching to {scheduler}")
+                self.log.info(f"Enabling {scheduler}")
             if not same_karras:
-                print(f"{'Enabling' if karras else 'Disabling'} Karras sigmas")
+                self.log.info(f"{'Enabling' if karras else 'Disabling'} Karras sigmas")
             if not same_scheduler or not same_karras:
                 self.pipe.scheduler = Config.SCHEDULERS[scheduler](**scheduler_kwargs)
                 if self.refiner is not None:
                     self.refiner.scheduler = self.pipe.scheduler
 
-        # https://huggingface.co/stabilityai/stable-diffusion-xl-refiner-1.0/blob/main/model_index.json
-        refiner_kwargs = {
-            "variant": "fp16",
-            "torch_dtype": dtype,
-            "add_watermarker": False,
-            "requires_aesthetics_score": True,
-            "force_zeros_for_empty_prompt": False,
-            "vae": self.pipe.vae,
-            "scheduler": self.pipe.scheduler,
-            "tokenizer_2": self.pipe.tokenizer_2,
-            "text_encoder_2": self.pipe.text_encoder_2,
-        }
-
-        self._load_refiner(refiner, progress, **refiner_kwargs)  # load refiner before deepcache
-        self._load_deepcache(deepcache)
-        self._load_upscaler(scale)
+        if self._should_load_refiner(refiner):
+            # https://huggingface.co/stabilityai/stable-diffusion-xl-refiner-1.0/blob/main/model_index.json
+            refiner_kwargs = {
+                "variant": "fp16",
+                "torch_dtype": dtype,
+                "add_watermarker": False,
+                "requires_aesthetics_score": True,
+                "force_zeros_for_empty_prompt": False,
+                "vae": self.pipe.vae,
+                "scheduler": self.pipe.scheduler,
+                "tokenizer_2": self.pipe.tokenizer_2,
+                "text_encoder_2": self.pipe.text_encoder_2,
+            }
+            self._load_refiner(refiner, progress, **refiner_kwargs)  # load refiner before deepcache
+
+        if self._should_load_deepcache(deepcache):
+            self._load_deepcache(deepcache)
+
+        if self._should_load_upscaler(scale):
+            self._load_upscaler(scale)

lib/logger.py

@@ -0,0 +1,55 @@
+import logging
+from threading import Lock
+
+
+class Logger:
+    _instances = {}
+    _lock = Lock()
+
+    def __new__(cls, name="root"):
+        with cls._lock:
+            if name not in cls._instances:
+                instance = super().__new__(cls)
+                instance._init(name)
+                cls._instances[name] = instance
+            return cls._instances[name]
+
+    def _init(self, name):
+        self.logger = logging.getLogger(name)
+        self.logger.setLevel(logging.DEBUG)
+        self.logger.propagate = False
+
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.INFO)
+
+        file_handler = logging.FileHandler("app.log")
+        file_handler.setLevel(logging.DEBUG)
+
+        formatter = logging.Formatter(
+            "%(asctime)s [%(threadName)s] %(levelname)-5s %(name)s - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",  # no milliseconds
+        )
+        console_handler.setFormatter(formatter)
+        file_handler.setFormatter(formatter)
+
+        self.logger.addHandler(console_handler)
+        self.logger.addHandler(file_handler)
+
+    def _log(self, level, message):
+        log_message = f"{message}".strip()
+        self.logger.log(level, log_message)
+
+    def debug(self, message, **kwargs):
+        self._log(logging.DEBUG, message, **kwargs)
+
+    def info(self, message, **kwargs):
+        self._log(logging.INFO, message, **kwargs)
+
+    def warning(self, message, **kwargs):
+        self._log(logging.WARNING, message, **kwargs)
+
+    def error(self, message, **kwargs):
+        self._log(logging.ERROR, message, **kwargs)
+
+    def critical(self, message, **kwargs):
+        self._log(logging.CRITICAL, message, **kwargs)

lib/utils.py

@@ -1,13 +1,12 @@
 import functools
 import inspect
 import json
-import os
 import time
 from contextlib import contextmanager
 from typing import Callable, TypeVar
 
 import anyio
-import httpx
+import torch
 from anyio import Semaphore
 from diffusers.utils import logging as diffusers_logging
 from huggingface_hub._snapshot_download import snapshot_download
@@ -34,9 +33,10 @@ def timer(message="Operation", logger=print):
 
 
 @functools.lru_cache()
-def load_json(path: str) -> dict:
+def read_json(path: str) -> dict:
     with open(path, "r", encoding="utf-8") as file:
-        return json.load(file)
+        data = json.load(file)
+        return json.dumps(data, indent=4)
 
 
 @functools.lru_cache()
@@ -56,6 +56,19 @@ def enable_progress_bars():
     diffusers_logging.enable_progress_bar()
 
 
+def safe_progress(progress, current=0, total=0, desc=""):
+    if progress is not None:
+        progress((current, total), desc=desc)
+
+
+def clear_cuda_cache():
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        torch.cuda.ipc_collect()
+        torch.cuda.reset_peak_memory_stats()
+        torch.cuda.synchronize()
+
+
 def download_repo_files(repo_id, allow_patterns, token=None):
     was_disabled = are_progress_bars_disabled()
     enable_progress_bars()
@@ -72,34 +85,7 @@ def download_repo_files(repo_id, allow_patterns, token=None):
     return snapshot_path
 
 
-def download_civit_file(lora_id, version_id, file_path=".", token=None):
-    base_url = "https://civitai.com/api/download/models"
-    file = f"{file_path}/{lora_id}.{version_id}.safetensors"
-
-    if os.path.exists(file):
-        return
-
-    try:
-        params = {"token": token}
-        response = httpx.get(
-            f"{base_url}/{version_id}",
-            timeout=None,
-            params=params,
-            follow_redirects=True,
-        )
-
-        response.raise_for_status()
-        os.makedirs(file_path, exist_ok=True)
-
-        with open(file, "wb") as f:
-            f.write(response.content)
-    except httpx.HTTPStatusError as e:
-        print(f"HTTPError: {e.response.status_code} {e.response.text}")
-    except httpx.RequestError as e:
-        print(f"RequestError: {e}")
-
-
-# like the original but supports args and kwargs instead of a dict
+# Like the original but supports args and kwargs instead of a dict
 # https://github.com/huggingface/huggingface-inference-toolkit/blob/0.2.0/src/huggingface_inference_toolkit/async_utils.py
 async def async_call(fn: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
     async with MAX_THREADS_GUARD:

partials/intro.html

@@ -7,18 +7,7 @@
       <path d="M7.48877 6.75C7.29015 6.75 7.09967 6.82902 6.95923 6.96967C6.81879 7.11032 6.73989 7.30109 6.73989 7.5C6.73989 7.69891 6.81879 7.88968 6.95923 8.03033C7.09967 8.17098 7.29015 8.25 7.48877 8.25C7.68738 8.25 7.87786 8.17098 8.0183 8.03033C8.15874 7.88968 8.23764 7.69891 8.23764 7.5C8.23764 7.30109 8.15874 7.11032 8.0183 6.96967C7.87786 6.82902 7.68738 6.75 7.48877 6.75ZM7.8632 0C11.2331 0 11.3155 2.6775 9.54818 3.5625C8.80679 3.93 8.47728 4.7175 8.335 5.415C8.69446 5.565 9.00899 5.7975 9.24863 6.0975C12.0195 4.5975 15 5.19 15 7.875C15 11.25 12.3265 11.325 11.4428 9.5475C11.0684 8.805 10.2746 8.475 9.57813 8.3325C9.42836 8.6925 9.19621 9 8.89665 9.255C10.3869 12.0225 9.79531 15 7.11433 15C3.74438 15 3.67698 12.315 5.44433 11.43C6.17823 11.0625 6.50774 10.2825 6.65751 9.5925C6.29056 9.4425 5.96855 9.2025 5.72891 8.9025C2.96555 10.3875 0 9.8025 0 7.125C0 3.75 2.666 3.6675 3.54967 5.445C3.92411 6.1875 4.71043 6.51 5.40689 6.6525C5.54918 6.2925 5.78882 5.9775 6.09586 5.7375C4.60559 2.97 5.1972 0 7.8632 0Z"></path>
     </svg>
   </div>
-  <div>
-    <nav>
-      <a href="https://huggingface.co/spaces/adamelliotfields/diffusion" target="_blank" rel="noopener noreferrer">1.5</a>
-      <span>XL</span>
-      <a href="https://huggingface.co/spaces/adamelliotfields/diffusion-flux" target="_blank" rel="noopener noreferrer">FLUX.1</a>
-      <a href="https://huggingface.co/spaces/adamelliotfields/diffusion-xl/blob/main/DOCS.md" target="_blank" rel="noopener noreferrer">Docs</a>
-      <a href="https://adamelliotfields-diffusion-xl.hf.space" target="_blank" rel="noopener noreferrer">
-        <svg style="display: inline-block" width="16px" height="16px" viewBox="0 0 12 12" fill="currentColor" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid meet">
-          <path fill-rule="evenodd" clip-rule="evenodd" d="M7.5 1.75H9.75C9.88807 1.75 10 1.86193 10 2V4.25C10 4.38807 9.88807 4.5 9.75 4.5C9.61193 4.5 9.5 4.38807 9.5 4.25V2.60355L6.42678 5.67678C6.32915 5.77441 6.17085 5.77441 6.07322 5.67678C5.97559 5.57915 5.97559 5.42085 6.07322 5.32322L9.14645 2.25H7.5C7.36193 2.25 7.25 2.13807 7.25 2C7.25 1.86193 7.36193 1.75 7.5 1.75Z" fill="currentColor"></path>
-          <path fill-rule="evenodd" clip-rule="evenodd" d="M6 2.5C6 2.22386 5.77614 2 5.5 2H2.69388C2.50985 2 2.33336 2.07311 2.20323 2.20323C2.0731 2.33336 2 2.50986 2 2.69389V8.93885C2 9.12288 2.0731 9.29933 2.20323 9.42953C2.33336 9.55963 2.50985 9.63273 2.69388 9.63273H8.93884C9.12287 9.63273 9.29941 9.55963 9.42951 9.42953C9.55961 9.29933 9.63271 9.12288 9.63271 8.93885V6.5C9.63271 6.22386 9.40885 6 9.13271 6C8.85657 6 8.63271 6.22386 8.63271 6.5V8.63273H3V3H5.5C5.77614 3 6 2.77614 6 2.5Z" fill="currentColor" fill-opacity="0.3"></path>
-        </svg>
-      </a>
-    </nav>
-  </div>
+  <p>
+    Image generation studio for Stable Diffusion XL.
+  </p>
 </div>

requirements.txt

@@ -1,19 +1,12 @@
-anyio==4.4.0
-accelerate
-einops==0.8.0
+anyio==4.6.1
 compel==2.0.3
 deepcache==0.1.1
-diffusers==0.30.2
-h2
+diffusers==0.30.3
+einops==0.8.0
+gradio==4.44.1
 hf-transfer
-httpx
-gradio==4.41.0
 numpy==1.26.4
-ruff==0.5.7
-spaces
+ruff==0.6.9
+spaces==0.30.4
 torch==2.2.0
 torchvision==0.17.0
-transformers==4.43.4
-# TODO: unpin once fixed upstream
-# https://github.com/gradio-app/gradio/issues/9278
-fastapi==0.112.2