Refactor flux_helpers.py to enable or disable Vae

app.py

@@ -1,36 +1,29 @@
 import gradio as gr
 
 from config import css
-from tabs.image_tab import image_tab
-from tabs.audio_tab import audio_tab
-from tabs.video_tab import video_tab
-from tabs.text_tab import text_tab
+from tabs.images.ui import image_tab
 
-def main():
-    with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
-        # Header
-        with gr.Column(elem_classes="center-content"):
-            gr.Markdown("""
-            # 🚀 AAI: All AI
-            Unleash your creativity with our multi-modal AI platform.
-            [![Sync code to HF Space](https://github.com/mantrakp04/aai/actions/workflows/hf-space.yml/badge.svg)](https://github.com/mantrakp04/aai/actions/workflows/hf-space.yml)
-            """)
+with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
+    # Header
+    with gr.Column(elem_classes="center-content"):
+        gr.Markdown("""
+        # 🚀 AAI: All AI
+        Unleash your creativity with our multi-modal AI platform.
+        [![Sync code to HF Space](https://github.com/mantrakp04/aai/actions/workflows/hf-space.yml/badge.svg)](https://github.com/mantrakp04/aai/actions/workflows/hf-space.yml)
+        """)
 
-        # Tabs
-        with gr.Tabs():
-            with gr.Tab(label="🖼️ Image"):
-                image_tab()
-            with gr.Tab(label="🎵 Audio"):
-                audio_tab()
-            with gr.Tab(label="🎥 Video"):
-                video_tab()
-            with gr.Tab(label="📝 Text"):
-                text_tab()
+    # Tabs
+    with gr.Tabs():
+        with gr.Tab(label="🖼️ Image"):
+            image_tab()
+        # with gr.Tab(label="🎵 Audio"):
+        #     audio_tab()
+        # with gr.Tab(label="🎥 Video"):
+        #     video_tab()
+        # with gr.Tab(label="📝 Text"):
+        #     text_tab()
 
-    demo.launch(
-        share=False,
-        debug=True,
-    )
-
-if __name__ == "__main__":
-    main()
+demo.launch(
+    share=False,
+    debug=True,
+)

config.py

@@ -1,7 +1,9 @@
-# config.py
-
+import os
 import json
 
+import torch
+
+
 css = """
 @import url('https://fonts.googleapis.com/css2?family=Poppins:wght@300;400;600&display=swap');
 body {
@@ -23,14 +25,51 @@ body {
 """
 
 
-# Models
-flux_models = ["black-forest-labs/FLUX.1-dev"]
-sdxl_models = ["stabilityai/stable-diffusion-xl-base-1.0"]
-
-
-# Load LoRAs
-with open("data/loras/flux.json", "r") as f:
-    flux_loras = json.load(f)
-
-with open("data/loras/sdxl.json", "r") as f:
-    sdxl_loras = json.load(f)
+class Config:
+    # General
+    SECRET_KEY = os.environ.get('SECRET_KEY', '12345678')
+    
+    # Images
+    # IMAGE_MODELS = ["black-forest-labs/FLUX.1-dev", "stabilityai/stable-diffusion-xl-base-1.0"]
+    IMAGES_MODELS = [{"repo_id": "black-forest-labs/FLUX.1-dev", "loader": "flux", "compute_type": torch.bfloat16,}, {"repo_id": "stabilityai/stable-diffusion-xl-base-1.0", "loader": "sdxl", "compute_type": torch.float16,}]
+    with open('data/loras/sdxl.json') as f:
+        IMAGES_LORAS_SDXL = json.load(f)
+    with open('data/loras/flux.json') as f:
+        IMAGES_LORAS_FLUX = json.load(f)
+    IMAGES_CONTROLNETS = [
+        {
+            "repo_id": "xinsir/controlnet-depth-sdxl-1.0",
+            "name": "depth_xl",
+            "layers": ["depth"],
+            "loader": "sdxl",
+            "compute_type": torch.float16,
+        },
+        {
+            "repo_id": "xinsir/controlnet-canny-sdxl-1.0",
+            "name": "canny_xl",
+            "layers": ["canny"],
+            "loader": "sdxl",
+            "compute_type": torch.float16,
+        },
+        {
+            "repo_id": "xinsir/controlnet-openpose-sdxl-1.0",
+            "name": "openpose_xl",
+            "layers": ["pose"],
+            "loader": "sdxl",
+            "compute_type": torch.float16,
+        },
+        {
+            "repo_id": "xinsir/controlnet-scribble-sdxl-1.0",
+            "name": "scribble_xl",
+            "layers": ["scribble"],
+            "loader": "sdxl",
+            "compute_type": torch.float16,
+        },
+        {
+            "repo_id": "Shakker-Labs/FLUX.1-dev-ControlNet-Union-Pro",
+            "name": "flux1_union_pro",
+            "layers": ["canny", "tile", "depth", "blur", "pose", "gray", "low_quality"],
+            "loader": "flux-multi",
+            "compute_type": torch.bfloat16,
+        }
+    ]

old2/app.py

@@ -0,0 +1,36 @@
+import gradio as gr
+
+from config import css
+from tabs.image_tab import image_tab
+from tabs.audio_tab import audio_tab
+from tabs.video_tab import video_tab
+from tabs.text_tab import text_tab
+
+def main():
+    with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
+        # Header
+        with gr.Column(elem_classes="center-content"):
+            gr.Markdown("""
+            # 🚀 AAI: All AI
+            Unleash your creativity with our multi-modal AI platform.
+            [![Sync code to HF Space](https://github.com/mantrakp04/aai/actions/workflows/hf-space.yml/badge.svg)](https://github.com/mantrakp04/aai/actions/workflows/hf-space.yml)
+            """)
+
+        # Tabs
+        with gr.Tabs():
+            with gr.Tab(label="🖼️ Image"):
+                image_tab()
+            with gr.Tab(label="🎵 Audio"):
+                audio_tab()
+            with gr.Tab(label="🎥 Video"):
+                video_tab()
+            with gr.Tab(label="📝 Text"):
+                text_tab()
+
+    demo.launch(
+        share=False,
+        debug=True,
+    )
+
+if __name__ == "__main__":
+    main()

old2/config.py

@@ -0,0 +1,36 @@
+# config.py
+
+import json
+
+css = """
+@import url('https://fonts.googleapis.com/css2?family=Poppins:wght@300;400;600&display=swap');
+body {
+    font-family: 'Poppins', sans-serif !important;
+}
+.center-content {
+    text-align: center;
+    max-width: 600px;
+    margin: 0 auto;
+    padding: 20px;
+}
+.center-content h1 {
+    font-weight: 600;
+    margin-bottom: 1rem;
+}
+.center-content p {
+    margin-bottom: 1.5rem;
+}
+"""
+
+
+# Models
+flux_models = ["black-forest-labs/FLUX.1-dev"]
+sdxl_models = ["stabilityai/stable-diffusion-xl-base-1.0"]
+
+
+# Load LoRAs
+with open("data/loras/flux.json", "r") as f:
+    flux_loras = json.load(f)
+
+with open("data/loras/sdxl.json", "r") as f:
+    sdxl_loras = json.load(f)

old2/modules/events/common_events.py

@@ -0,0 +1,264 @@
+import gradio as gr
+from huggingface_hub import ModelCard
+
+from config import Config
+
+
+def selected_lora_from_gallery(evt: gr.SelectData):
+    return (
+        gr.update(
+            value=evt.index
+        )
+    )
+
+
+def update_selected_lora(custom_lora):
+    link = custom_lora.split("/")
+    
+    if len(link) == 2:
+        model_card = ModelCard.load(custom_lora)
+        trigger_word = model_card.data.get("instance_prompt", "")
+        image_url = f"""https://huggingface.co/{custom_lora}/resolve/main/{model_card.data.get("widget", [{}])[0].get("output", {}).get("url", None)}"""
+        
+        custom_lora_info_css = """
+        <style>
+            .custom-lora-info {
+                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
+                background: linear-gradient(135deg, #4a90e2, #7b61ff);
+                color: white;
+                padding: 16px;
+                border-radius: 8px;
+                box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+                margin: 16px 0;
+            }
+            .custom-lora-header {
+                font-size: 18px;
+                font-weight: 600;
+                margin-bottom: 12px;
+            }
+            .custom-lora-content {
+                display: flex;
+                align-items: center;
+                background-color: rgba(255, 255, 255, 0.1);
+                border-radius: 6px;
+                padding: 12px;
+            }
+            .custom-lora-image {
+                width: 80px;
+                height: 80px;
+                object-fit: cover;
+                border-radius: 6px;
+                margin-right: 16px;
+            }
+            .custom-lora-text h3 {
+                margin: 0 0 8px 0;
+                font-size: 16px;
+                font-weight: 600;
+            }
+            .custom-lora-text small {
+                font-size: 14px;
+                opacity: 0.9;
+            }
+            .custom-trigger-word {
+                background-color: rgba(255, 255, 255, 0.2);
+                padding: 2px 6px;
+                border-radius: 4px;
+                font-weight: 600;
+            }
+        </style>
+        """
+
+        custom_lora_info_html = f"""
+        <div class="custom-lora-info">
+            <div class="custom-lora-header">Custom LoRA: {custom_lora}</div>
+            <div class="custom-lora-content">
+                <img class="custom-lora-image" src="{image_url}" alt="LoRA preview">
+                <div class="custom-lora-text">
+                    <h3>{link[1].replace("-", " ").replace("_", " ")}</h3>
+                    <small>{"Using: <span class='custom-trigger-word'>"+trigger_word+"</span> as the trigger word" if trigger_word else "No trigger word found. If there's a trigger word, include it in your prompt"}</small>
+                </div>
+            </div>
+        </div>
+        """
+
+        custom_lora_info_html = f"{custom_lora_info_css}{custom_lora_info_html}"
+
+        return (
+            gr.update( # selected_lora
+                value=custom_lora,
+            ),
+            gr.update( # custom_lora_info
+                value=custom_lora_info_html,
+                visible=True
+            )
+        )
+
+    else:
+        return (
+            gr.update( # selected_lora
+                value=custom_lora,
+            ),
+            gr.update( # custom_lora_info
+                value=custom_lora_info_html if len(link) == 0 else "",
+                visible=False
+            )
+        )
+
+
+def update_lora_sliders(enabled_loras):
+    sliders = []
+    remove_buttons = []
+    
+    for lora in enabled_loras:
+        sliders.append(
+            gr.update(
+                label=lora.get("repo_id", ""),
+                info=f"Trigger Word: {lora.get('trigger_word', '')}",
+                visible=True,
+                interactive=True
+            )
+        )
+        remove_buttons.append(
+            gr.update(
+                visible=True,
+                interactive=True
+            )
+        )
+    
+    if len(sliders) < 6:
+        for i in range(len(sliders), 6):
+            sliders.append(
+                gr.update(
+                    visible=False
+                )
+            )
+            remove_buttons.append(
+                gr.update(
+                    visible=False
+                )
+            )
+    
+    return *sliders, *remove_buttons
+
+
+def remove_from_enabled_loras(enabled_loras, index):
+    enabled_loras.pop(index)
+    return (
+        gr.update(
+            value=enabled_loras
+        )
+    )
+
+
+def update_custom_embedding(custom_embedding):
+    link = custom_embedding.split("/")
+    
+    if len(link) == 2:
+        model_card = ModelCard.load(custom_embedding)
+        trigger_word = model_card.data.get("instance_prompt", "")
+        image_url = f"""https://huggingface.co/{custom_embedding}/resolve/main/{model_card.data.get("widget", [{}])[0].get("output", {}).get("url", None)}"""
+        
+        custom_embedding_info_css = """
+        <style>
+            .custom-embedding-info {
+                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
+                background: linear-gradient(135deg, #4a90e2, #7b61ff);
+                color: white;
+                padding: 16px;
+                border-radius: 8px;
+                box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+                margin: 16px 0;
+            }
+            .custom-embedding-header {
+                font-size: 18px;
+                font-weight: 600;
+                margin-bottom: 12px;
+            }
+            .custom-embedding-content {
+                display: flex;
+                align-items: center;
+                background-color: rgba(255, 255, 255, 0.1);
+                border-radius: 6px;
+                padding: 12px;
+            }
+            .custom-embedding-image {
+                width: 80px;
+                height: 80px;
+                object-fit: cover;
+                border-radius: 6px;
+                margin-right: 16px;
+            }
+            .custom-embedding-text h3 {
+                margin: 0 0 8px 0;
+                font-size: 16px;
+                font-weight: 600;
+            }
+            .custom-embedding-text small {
+                font-size: 14px;
+                opacity: 0.9;
+            }
+            .custom-trigger-word {
+                background-color: rgba(255, 255, 255, 0.2);
+                padding: 2px 6px;
+                border-radius: 4px;
+                font-weight: 600;
+            }
+        </style>
+        """
+
+        custom_embedding_info_html = f"""
+        <div class="custom-embedding-info">
+            <div class="custom-embedding-header">Custom Embed Model: {custom_embedding}</div>
+            <div class="custom-embedding-content">
+                <img class="custom-embedding-image" src="{image_url}" alt="Embedding model preview">
+                <div class="custom-embedding-text">
+                    <h3>{link[1].replace("-", " ").replace("_", " ")}</h3>
+                    <small>{"Using: <span class='custom-trigger-word'>"+trigger_word+"</span> as the trigger word" if trigger_word else "No trigger word found. If there's a trigger word, include it in your prompt"}</small>
+                </div>
+            </div>
+        </div>
+        """
+        
+        custom_embedding_info_html = f"{custom_embedding_info_css}{custom_embedding_info_html}"
+        
+        return gr.update( # custom_embedding_info
+            value=custom_embedding_info_html,
+            visible=True
+        )
+
+
+def add_to_embeddings(custom_embedding, embeddings):
+    link = custom_embedding.split("/")
+    
+    if len(link) == 2:
+        model_card = ModelCard.load(custom_embedding)
+        trigger_word = model_card.data.get("instance_prompt", "")
+        image_url = f"""https://huggingface.co/{custom_embedding}/resolve/main/{model_card.data.get("widget", [{}])[0].get("output", {}).get("url", None)}"""
+        
+        embeddings.append({
+            "repo_id": custom_embedding,
+            "trigger_word": trigger_word
+        })
+    
+    return (
+        gr.update( # custom_embedding
+            value=""
+        ),
+        gr.update( # custom_embedding_info
+            value="",
+            visible=False
+        ),
+        gr.update( # embeddings
+            value=embeddings
+        )
+    )
+
+
+def remove_from_embeddings(embeddings, index):
+    embeddings.pop(index)
+    return (
+        gr.update(
+            value=embeddings
+        )
+    )
+

{modules → old2/modules}/events/flux_events.py

@@ -1,6 +1,3 @@
-import json
-from typing import List
-
 import spaces
 import gradio as gr
 from huggingface_hub import ModelCard
@@ -34,107 +31,6 @@ def update_fast_generation(fast_generation):
         )
 
 
-def selected_lora_from_gallery(evt: gr.SelectData):
-    return (
-        gr.update(
-            value=evt.index
-        )
-    )
-
-
-def update_selected_lora(custom_lora):
-    link = custom_lora.split("/")
-    
-    if len(link) == 2:
-        model_card = ModelCard.load(custom_lora)
-        trigger_word = model_card.data.get("instance_prompt", "")
-        image_url = f"""https://huggingface.co/{custom_lora}/resolve/main/{model_card.data.get("widget", [{}])[0].get("output", {}).get("url", None)}"""
-        
-        custom_lora_info_css = """
-        <style>
-            .custom-lora-info {
-                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
-                background: linear-gradient(135deg, #4a90e2, #7b61ff);
-                color: white;
-                padding: 16px;
-                border-radius: 8px;
-                box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-                margin: 16px 0;
-            }
-            .custom-lora-header {
-                font-size: 18px;
-                font-weight: 600;
-                margin-bottom: 12px;
-            }
-            .custom-lora-content {
-                display: flex;
-                align-items: center;
-                background-color: rgba(255, 255, 255, 0.1);
-                border-radius: 6px;
-                padding: 12px;
-            }
-            .custom-lora-image {
-                width: 80px;
-                height: 80px;
-                object-fit: cover;
-                border-radius: 6px;
-                margin-right: 16px;
-            }
-            .custom-lora-text h3 {
-                margin: 0 0 8px 0;
-                font-size: 16px;
-                font-weight: 600;
-            }
-            .custom-lora-text small {
-                font-size: 14px;
-                opacity: 0.9;
-            }
-            .custom-trigger-word {
-                background-color: rgba(255, 255, 255, 0.2);
-                padding: 2px 6px;
-                border-radius: 4px;
-                font-weight: 600;
-            }
-        </style>
-        """
-
-        custom_lora_info_html = f"""
-        <div class="custom-lora-info">
-            <div class="custom-lora-header">Custom LoRA: {custom_lora}</div>
-            <div class="custom-lora-content">
-                <img class="custom-lora-image" src="{image_url}" alt="LoRA preview">
-                <div class="custom-lora-text">
-                    <h3>{link[1].replace("-", " ").replace("_", " ")}</h3>
-                    <small>{"Using: <span class='custom-trigger-word'>"+trigger_word+"</span> as the trigger word" if trigger_word else "No trigger word found. If there's a trigger word, include it in your prompt"}</small>
-                </div>
-            </div>
-        </div>
-        """
-
-        custom_lora_info_html = f"{custom_lora_info_css}{custom_lora_info_html}"
-
-        return (
-            gr.update( # selected_lora
-                value=custom_lora,
-            ),
-            gr.update( # custom_lora_info
-                value=custom_lora_info_html,
-                visible=True
-            )
-        )
-
-    else:
-        return (
-            gr.update( # selected_lora
-                value=custom_lora,
-            ),
-            gr.update( # custom_lora_info
-                value=custom_lora_info_html if len(link) == 0 else "",
-                visible=False
-            )
-        )
-
-
 def add_to_enabled_loras(selected_lora, enabled_loras):
     lora_data = loras
     try:
@@ -170,52 +66,7 @@ def add_to_enabled_loras(selected_lora, enabled_loras):
     )
 
 
-def update_lora_sliders(enabled_loras):
-    sliders = []
-    remove_buttons = []
-    
-    for lora in enabled_loras:
-        sliders.append(
-            gr.update(
-                label=lora.get("repo_id", ""),
-                info=f"Trigger Word: {lora.get('trigger_word', '')}",
-                visible=True,
-                interactive=True
-            )
-        )
-        remove_buttons.append(
-            gr.update(
-                visible=True,
-                interactive=True
-            )
-        )
-    
-    if len(sliders) < 6:
-        for i in range(len(sliders), 6):
-            sliders.append(
-                gr.update(
-                    visible=False
-                )
-            )
-            remove_buttons.append(
-                gr.update(
-                    visible=False
-                )
-            )
-    
-    return *sliders, *remove_buttons
-
-
-def remove_from_enabled_loras(enabled_loras, index):
-    enabled_loras.pop(index)
-    return (
-        gr.update(
-            value=enabled_loras
-        )
-    )
-
-
-@spaces.GPU(duration=120)
+@spaces.GPU(duration=75)
 def generate_image(
         model, prompt, fast_generation, enabled_loras,
         lora_slider_0, lora_slider_1, lora_slider_2, lora_slider_3, lora_slider_4, lora_slider_5,

old2/modules/events/sdxl_events.py

@@ -0,0 +1,170 @@
+import spaces
+import gradio as gr
+from huggingface_hub import ModelCard
+
+from modules.helpers.common_helpers import ControlNetReq, BaseReq, BaseImg2ImgReq, BaseInpaintReq
+from modules.helpers.sdxl_helpers import gen_img
+from config import sdxl_loras
+
+loras = sdxl_loras
+
+# Event functions
+def update_fast_generation(fast_generation):
+    if fast_generation:
+        return (
+            gr.update(
+                value=0.0
+            ),
+            gr.update(
+                value=8
+            )
+        )
+    else:
+        return (
+            gr.update(
+                value=7.0
+            ),
+            gr.update(
+                value=20
+            )
+        )
+
+
+def add_to_enabled_loras(selected_lora, enabled_loras):
+    lora_data = loras
+    try:
+        selected_lora = int(selected_lora)
+        
+        if 0 <= selected_lora: # is the index of the lora in the gallery
+            lora_info = lora_data[selected_lora]
+            enabled_loras.append({
+                "repo_id": lora_info["repo"],
+                "trigger_word": lora_info["trigger_word"]
+            })
+    except ValueError:
+        link = selected_lora.split("/")
+        if len(link) == 2:
+            model_card = ModelCard.load(selected_lora)
+            trigger_word = model_card.data.get("instance_prompt", "")
+            enabled_loras.append({
+                "repo_id": selected_lora,
+                "trigger_word": trigger_word
+            })
+    
+    return (
+        gr.update( # selected_lora
+            value=""
+        ),
+        gr.update( # custom_lora_info
+            value="",
+            visible=False
+        ),
+        gr.update( # enabled_loras
+            value=enabled_loras
+        )
+    )
+
+
+@spaces.GPU(duration=75)
+def generate_image(
+    model, prompt, negative_prompt, fast_generation, enabled_loras, enabled_embeddings, # type: ignore
+    lora_slider_0, lora_slider_1, lora_slider_2, lora_slider_3, lora_slider_4, lora_slider_5, # type: ignore
+    img2img_image, inpaint_image, canny_image, pose_image, depth_image, scribble_image, # type: ignore
+    img2img_strength, inpaint_strength, canny_strength, pose_strength, depth_strength, scribble_strength, # type: ignore
+    resize_mode,
+    scheduler, image_height, image_width, image_num_images_per_prompt, # type: ignore
+    image_num_inference_steps, image_clip_skip, image_guidance_scale, image_seed, # type: ignore
+    refiner, vae
+):
+    try:
+        base_args = {
+            "model": model,
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "fast_generation": fast_generation,
+            "loras": None,
+            "embeddings": None,
+            "resize_mode": resize_mode,
+            "scheduler": scheduler,
+            "height": image_height,
+            "width": image_width,
+            "num_images_per_prompt": image_num_images_per_prompt,
+            "num_inference_steps": image_num_inference_steps,
+            "clip_skip": image_clip_skip,
+            "guidance_scale": image_guidance_scale,
+            "seed": image_seed,
+            "refiner": refiner,
+            "vae": vae,
+            "controlnet_config": None,
+        }
+        base_args = BaseReq(**base_args)
+        
+        if len(enabled_loras) > 0:
+            base_args.loras = []
+            for enabled_lora, slider in zip(enabled_loras, [lora_slider_0, lora_slider_1, lora_slider_2, lora_slider_3, lora_slider_4, lora_slider_5]):
+                if enabled_lora["repo_id"]:
+                    base_args.loras.append({
+                        "repo_id": enabled_lora["repo_id"],
+                        "weight": slider
+                    })
+        
+        if len(enabled_embeddings) > 0:
+            base_args.embeddings = enabled_embeddings
+        
+        image = None
+        mask_image = None
+        strength = None
+        
+        if img2img_image:
+            image = img2img_image
+            strength = float(img2img_strength)
+            
+            base_args = BaseImg2ImgReq(
+                **base_args.__dict__,
+                image=image,
+                strength=strength
+            )
+        elif inpaint_image:
+            image = inpaint_image['background'] if not all(pixel == (0, 0, 0) for pixel in list(inpaint_image['background'].getdata())) else None
+            mask_image = inpaint_image['layers'][0] if image else None
+            strength = float(inpaint_strength)
+            
+            if image and mask_image:
+                base_args = BaseInpaintReq(
+                    **base_args.__dict__,
+                    image=image,
+                    mask_image=mask_image,
+                    strength=strength
+                )
+        elif any([canny_image, pose_image, depth_image]):
+            base_args.controlnet_config = ControlNetReq(
+                controlnets=[],
+                control_images=[],
+                controlnet_conditioning_scale=[]
+            )
+            
+            if canny_image:
+                base_args.controlnet_config.controlnets.append("canny")
+                base_args.controlnet_config.control_images.append(canny_image)
+                base_args.controlnet_config.controlnet_conditioning_scale.append(float(canny_strength))
+            if pose_image:
+                base_args.controlnet_config.controlnets.append("pose")
+                base_args.controlnet_config.control_images.append(pose_image)
+                base_args.controlnet_config.controlnet_conditioning_scale.append(float(pose_strength))
+            if depth_image:
+                base_args.controlnet_config.controlnets.append("depth")
+                base_args.controlnet_config.control_images.append(depth_image)
+                base_args.controlnet_config.controlnet_conditioning_scale.append(float(depth_strength))
+            if scribble_image:
+                base_args.controlnet_config.controlnets.append("scribble")
+                base_args.controlnet_config.control_images.append(scribble_image)
+                base_args.controlnet_config.controlnet_conditioning_scale.append(float(scribble_strength))
+        else:
+            base_args = BaseReq(**base_args.__dict__)
+        
+        return gr.update(
+            value=gen_img(base_args),
+            interactive=True
+        )
+    except Exception as e:
+        raise gr.Error(f"Error: {e}") from e

{modules → old2/modules}/helpers/common_helpers.py

@@ -20,14 +20,17 @@ class ControlNetReq(BaseModel):
 class BaseReq(BaseModel):
     model: str = ""
     prompt: str = ""
+    negative_prompt: Optional[str] = ""
     fast_generation: Optional[bool] = True
     loras: Optional[list] = []
+    embeddings: Optional[list] = None
     resize_mode: Optional[str] = "resize_and_fill" # resize_only, crop_and_resize, resize_and_fill
     scheduler: Optional[str] = "euler_fl"
     height: int = 1024
     width: int = 1024
     num_images_per_prompt: int = 1
     num_inference_steps: int = 8
+    clip_skip: Optional[int] = None
     guidance_scale: float = 3.5
     seed: Optional[int] = 0
     refiner: bool = False

{modules → old2/modules}/helpers/flux_helpers.py

@@ -48,7 +48,7 @@ def get_pipe(request: BaseReq | BaseImg2ImgReq | BaseInpaintReq):
             elif isinstance(request, BaseReq):
                 pipe_args['pipeline'] = AutoPipelineForText2Image.from_pipe(**pipe_args)
 
-            # Enable or Disable Refiner
+            # Enable or Disable Vae
             if request.vae:
                 pipe_args["pipeline"].vae = flux_vae
             elif not request.vae:

old2/modules/helpers/sdxl_helpers.py

@@ -0,0 +1,122 @@
+import random
+
+import gradio as gr
+import torch
+from diffusers import (
+    AutoPipelineForText2Image,
+    AutoPipelineForImage2Image,
+    AutoPipelineForInpainting,
+)
+from huggingface_hub import hf_hub_download
+from diffusers.schedulers import *
+# from sd_embed.embedding_funcs import get_weighted_text_embeddings_flux1
+
+from .common_helpers import ControlNetReq, BaseReq, BaseImg2ImgReq, BaseInpaintReq, cleanup, get_controlnet_images, resize_images
+from modules.pipelines.sdxl_pipelines import device, models, sdxl_vae, controlnets
+from modules.pipelines.common_pipelines import refiner
+
+
+def get_pipe(request: BaseReq | BaseImg2ImgReq | BaseInpaintReq):
+    def get_scheduler(pipeline, scheduler: str):
+        ...
+    
+    for m in models:
+        if m['repo_id'] == request.model:
+            pipe_args = {
+                "pipeline": m['pipeline'],
+            }
+
+            # Set ControlNet config
+            if request.controlnet_config:
+                pipe_args["controlnet"] = [controlnets]
+
+            # Choose Pipeline Mode
+            if isinstance(request, BaseInpaintReq):
+                pipe_args['pipeline'] = AutoPipelineForInpainting.from_pipe(**pipe_args)
+            elif isinstance(request, BaseImg2ImgReq):
+                pipe_args['pipeline'] = AutoPipelineForImage2Image.from_pipe(**pipe_args)
+            elif isinstance(request, BaseReq):
+                pipe_args['pipeline'] = AutoPipelineForText2Image.from_pipe(**pipe_args)
+
+            # Enable or Disable Refiner
+            if request.vae:
+                pipe_args["pipeline"].vae = sdxl_vae
+            elif not request.vae:
+                pipe_args["pipeline"].vae = None
+
+            # Set Scheduler
+            pipe_args["pipeline"].scheduler = get_scheduler(pipe_args["pipeline"], request.scheduler)
+
+            # Set Loras
+            if request.loras:
+                for i, lora in enumerate(request.loras):
+                    pipe_args["pipeline"].load_lora_weights(lora['repo_id'], adapter_name=f"lora_{i}")
+                adapter_names = [f"lora_{i}" for i in range(len(request.loras))]
+                adapter_weights = [lora['weight'] for lora in request.loras]
+
+                if request.fast_generation:
+                    hyper_lora = hf_hub_download("ByteDance/Hyper-SD", "Hyper-FLUX.1-dev-8steps-lora.safetensors")
+                    hyper_weight = 0.125
+                    pipe_args["pipeline"].load_lora_weights(hyper_lora, adapter_name="hyper_lora")
+                    adapter_names.append("hyper_lora")
+                    adapter_weights.append(hyper_weight)
+
+                pipe_args["pipeline"].set_adapters(adapter_names, adapter_weights)
+
+            # Set Embeddings
+            if request.embeddings:
+                ...
+            
+            return pipe_args
+
+
+def get_prompt_attention(pipeline, prompt):
+    return get_weighted_text_embeddings_flux1(pipeline, prompt)
+
+
+# Gen Function
+def gen_img(request: BaseReq | BaseImg2ImgReq | BaseInpaintReq):
+    pipe_args = get_pipe(request)
+    pipeline = pipe_args["pipeline"]
+    try:
+        positive_prompt_embeds, positive_prompt_pooled = get_prompt_attention(pipeline, request.prompt)
+
+        # Common Args
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        args = {
+            'prompt_embeds': positive_prompt_embeds,
+            'pooled_prompt_embeds': positive_prompt_pooled,
+            'height': request.height,
+            'width': request.width,
+            'num_images_per_prompt': request.num_images_per_prompt,
+            'num_inference_steps': request.num_inference_steps,
+            'clip_skip': request.clip_skip,
+            'guidance_scale': request.guidance_scale,
+            'generator': [torch.Generator(device=device).manual_seed(request.seed + i) if not request.seed is any([None, 0, -1]) else torch.Generator(device=device).manual_seed(random.randint(0, 2**32 - 1)) for i in range(request.num_images_per_prompt)],
+        }
+
+        if request.controlnet_config:
+            args['control_mode'] = get_control_mode(request.controlnet_config)
+            args['control_images'] = get_controlnet_images(request.controlnet_config, request.height, request.width, request.resize_mode)
+            args['controlnet_conditioning_scale'] = request.controlnet_config.controlnet_conditioning_scale
+
+        if isinstance(request, (BaseImg2ImgReq, BaseInpaintReq)):
+            args['image'] = resize_images([request.image], request.height, request.width, request.resize_mode)[0]
+            args['strength'] = request.strength
+
+        if isinstance(request, BaseInpaintReq):
+            args['mask_image'] = resize_images([request.mask_image], request.height, request.width, request.resize_mode)[0]
+
+        # Generate
+        images = pipeline(**args).images
+
+        # Refiner
+        if request.refiner:
+            images = refiner(image=images, prompt=request.prompt, num_inference_steps=40, denoising_start=0.7).images
+
+        return images
+    except Exception as e:
+        cleanup(pipeline, request.loras)
+        raise gr.Error(f"Error: {e}")
+    finally:
+        cleanup(pipeline, request.loras)

{tabs → old2/tabs}/image_tab.py

@@ -1,7 +1,9 @@
 # tabs/image_tab.py
+import random
 
 import gradio as gr
 from modules.helpers.common_helpers import *
+from modules.events.common_events import *
 
 
 def image_tab():
@@ -15,11 +17,7 @@ def image_tab():
 def flux_tab():
     from modules.events.flux_events import (
         update_fast_generation,
-        selected_lora_from_gallery,
-        update_selected_lora,
         add_to_enabled_loras,
-        update_lora_sliders,
-        remove_from_enabled_loras,
         generate_image
     )
     from config import flux_models, flux_loras
@@ -188,15 +186,7 @@ def flux_tab():
 def sdxl_tab():
     from modules.events.sdxl_events import (
         update_fast_generation,
-        selected_lora_from_gallery,
-        update_selected_lora,
         add_to_enabled_loras,
-        update_lora_sliders,
-        remove_from_enabled_loras,
-        add_to_embeddings,
-        update_custom_embedding,
-        remove_from_embeddings,
-        generate_image
     )
     from config import sdxl_models, sdxl_loras
     
@@ -206,6 +196,7 @@ def sdxl_tab():
             with gr.Group() as image_options:
                 model = gr.Dropdown(label="Models", choices=sdxl_models, value=sdxl_models[0], interactive=True)
                 prompt = gr.Textbox(lines=5, label="Prompt")
+                negative_prompt = gr.Textbox(lines=5, label="Negative Prompt")
                 fast_generation = gr.Checkbox(label="Fast Generation (Hyper-SD) 🧪")
             
             
@@ -242,7 +233,7 @@ def sdxl_tab():
                 custom_embedding = gr.Textbox(label="Custom Embedding")
                 custom_embedding_info = gr.HTML(visible=False)
                 add_embedding = gr.Button(value="Add Embedding")
-                embeddings = gr.State(value=[])
+                enabled_embeddings = gr.State(value=[])
                 with gr.Group():
                     with gr.Row():
                         for i in range(6):
@@ -357,19 +348,19 @@ def sdxl_tab():
     
     # Embeddings
     custom_embedding.change(update_custom_embedding, custom_embedding, [custom_embedding_info])
-    add_embedding.click(add_to_embeddings, [custom_embedding, embeddings], [custom_embedding, custom_embedding_info, embeddings])
+    add_embedding.click(add_to_embeddings, [custom_embedding, enabled_embeddings], [custom_embedding, custom_embedding_info, enabled_embeddings])
     for i in range(6):
         globals()[f"embedding_remove_{i}"].click(
-            lambda embeddings, index=i: remove_from_embeddings(embeddings, index),
-            [embeddings],
-            [embeddings]
+            lambda enabled_embeddings, index=i: remove_from_embeddings(enabled_embeddings, index),
+            [enabled_embeddings],
+            [enabled_embeddings]
         )
     
     # Generate Image
     generate_images.click(
         generate_image, # type: ignore
         [
-            model, prompt, fast_generation, enabled_loras,
+            model, prompt, negative_prompt, fast_generation, enabled_loras, enabled_embeddings,
             lora_slider_0, lora_slider_1, lora_slider_2, lora_slider_3, lora_slider_4, lora_slider_5, # type: ignore
             img2img_image, inpaint_image, canny_image, pose_image, depth_image, scribble_image, # type: ignore
             img2img_strength, inpaint_strength, canny_strength, pose_strength, depth_strength, scribble_strength, # type: ignore

tabs/images/events.py

@@ -0,0 +1,510 @@
+import spaces
+import gradio as gr
+from huggingface_hub import ModelCard
+
+from config import Config
+from .models import *
+from .handlers import gen_img
+
+# Common
+def update_model_options(model):
+    for m in Config.IMAGES_MODELS:
+        if m['repo_id'] == model:
+            if m['loader'] == 'flux':
+                return (
+                    gr.update( # negative_prompt
+                        visible=False
+                    ),
+                    gr.update( # lora_gallery
+                        value=Config.IMAGES_LORAS_FLUX
+                    ),
+                    gr.update( # embeddings_accordion
+                        visible=False
+                    ),
+                    gr.update( # scribble_tab
+                        visible=False
+                    ),
+                    gr.update( # scheduler
+                        value='fm_euler'
+                    ),
+                    gr.update( # image_clip_skip
+                        visible=False
+                    ),
+                    gr.update( # image_guidance_scale
+                        value=3.5
+                    )
+                )
+                
+            elif m['loader'] == 'sdxl':
+                return (
+                    gr.update( # negative_prompt
+                        visible=True
+                    ),
+                    gr.update( # lora_gallery
+                        value=Config.IMAGES_LORAS_SDXL
+                    ),
+                    gr.update( # embeddings_accordion
+                        visible=True
+                    ),
+                    gr.update( # scribble_tab
+                        visible=True
+                    ),
+                    gr.update( # scheduler
+                        value='dpmpp_2m_sde_k'
+                    ),
+                    gr.update( # image_clip_skip
+                        visible=True
+                    ),
+                    gr.update( # image_guidance_scale
+                        value=7.0
+                    )
+                )
+
+
+def update_fast_generation(model, fast_generation):
+    for m in Config.IMAGES_MODELS:
+        if m['repo_id'] == model:
+            if m['loader'] == 'flux':
+                if fast_generation:
+                    return (
+                        gr.update( # image_num_inference_steps
+                            value=8
+                        ),
+                        gr.update( # image_guidance_scale
+                            value=3.5
+                        )
+                    )
+                else:
+                    return (
+                        gr.update( # image_num_inference_steps
+                            value=20
+                        ),
+                        gr.update( # image_guidance_scale
+                            value=3.5
+                        )
+                    )
+            elif m['loader'] == 'sdxl':
+                if fast_generation:
+                    return (
+                        gr.update( # image_num_inference_steps
+                            value=8
+                        ),
+                        gr.update( # image_guidance_scale
+                            value=1.0
+                        )
+                    )
+                else:
+                    return (
+                        gr.update( # image_num_inference_steps
+                            value=20
+                        ),
+                        gr.update( # image_guidance_scale
+                            value=7.0
+                        )
+                    )
+
+
+# Loras
+def selected_lora_from_gallery(evt: gr.SelectData):
+    return (
+        gr.update(
+            value=evt.index
+        )
+    )
+
+
+def update_selected_lora(custom_lora):
+    link = custom_lora.split("/")
+    
+    if len(link) == 2:
+        model_card = ModelCard.load(custom_lora)
+        trigger_word = model_card.data.get("instance_prompt", "")
+        image_url = f"""https://huggingface.co/{custom_lora}/resolve/main/{model_card.data.get("widget", [{}])[0].get("output", {}).get("url", None)}"""
+        
+        custom_lora_info_css = """
+        <style>
+            .custom-lora-info {
+                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
+                background: linear-gradient(135deg, #4a90e2, #7b61ff);
+                color: white;
+                padding: 16px;
+                border-radius: 8px;
+                box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+                margin: 16px 0;
+            }
+            .custom-lora-header {
+                font-size: 18px;
+                font-weight: 600;
+                margin-bottom: 12px;
+            }
+            .custom-lora-content {
+                display: flex;
+                align-items: center;
+                background-color: rgba(255, 255, 255, 0.1);
+                border-radius: 6px;
+                padding: 12px;
+            }
+            .custom-lora-image {
+                width: 80px;
+                height: 80px;
+                object-fit: cover;
+                border-radius: 6px;
+                margin-right: 16px;
+            }
+            .custom-lora-text h3 {
+                margin: 0 0 8px 0;
+                font-size: 16px;
+                font-weight: 600;
+            }
+            .custom-lora-text small {
+                font-size: 14px;
+                opacity: 0.9;
+            }
+            .custom-trigger-word {
+                background-color: rgba(255, 255, 255, 0.2);
+                padding: 2px 6px;
+                border-radius: 4px;
+                font-weight: 600;
+            }
+        </style>
+        """
+
+        custom_lora_info_html = f"""
+        <div class="custom-lora-info">
+            <div class="custom-lora-header">Custom LoRA: {custom_lora}</div>
+            <div class="custom-lora-content">
+                <img class="custom-lora-image" src="{image_url}" alt="LoRA preview">
+                <div class="custom-lora-text">
+                    <h3>{link[1].replace("-", " ").replace("_", " ")}</h3>
+                    <small>{"Using: <span class='custom-trigger-word'>"+trigger_word+"</span> as the trigger word" if trigger_word else "No trigger word found. If there's a trigger word, include it in your prompt"}</small>
+                </div>
+            </div>
+        </div>
+        """
+
+        custom_lora_info_html = f"{custom_lora_info_css}{custom_lora_info_html}"
+
+        return (
+            gr.update( # selected_lora
+                value=custom_lora,
+            ),
+            gr.update( # custom_lora_info
+                value=custom_lora_info_html,
+                visible=True
+            )
+        )
+
+    else:
+        return (
+            gr.update( # selected_lora
+                value=custom_lora,
+            ),
+            gr.update( # custom_lora_info
+                value=custom_lora_info_html if len(link) == 0 else "",
+                visible=False
+            )
+        )
+
+
+def update_lora_sliders(enabled_loras):
+    sliders = []
+    remove_buttons = []
+    
+    for lora in enabled_loras:
+        sliders.append(
+            gr.update(
+                label=lora.get("repo_id", ""),
+                info=f"Trigger Word: {lora.get('trigger_word', '')}",
+                visible=True,
+                interactive=True
+            )
+        )
+        remove_buttons.append(
+            gr.update(
+                visible=True,
+                interactive=True
+            )
+        )
+    
+    if len(sliders) < 6:
+        for i in range(len(sliders), 6):
+            sliders.append(
+                gr.update(
+                    visible=False
+                )
+            )
+            remove_buttons.append(
+                gr.update(
+                    visible=False
+                )
+            )
+    
+    return *sliders, *remove_buttons
+
+
+def remove_from_enabled_loras(enabled_loras, index):
+    enabled_loras.pop(index)
+    return (
+        gr.update(
+            value=enabled_loras
+        )
+    )
+
+
+def add_to_enabled_loras(model, selected_lora, enabled_loras):
+    
+    for m in Config.IMAGES_MODELS:
+        if m['repo_id'] == model.value:
+            lora_data = []
+            if m['loader'] == 'flux':
+                lora_data = Config.IMAGES_LORAS_FLUX
+            elif m['loader'] == 'sdxl':
+                lora_data = Config.IMAGES_LORAS_SDXL
+    try:
+        selected_lora = int(selected_lora)
+        
+        if 0 <= selected_lora: # is the index of the lora in the gallery
+            lora_info = lora_data[selected_lora]
+            enabled_loras.append({
+                "repo_id": lora_info["repo"],
+                "trigger_word": lora_info["trigger_word"]
+            })
+    except ValueError:
+        link = selected_lora.split("/")
+        if len(link) == 2:
+            model_card = ModelCard.load(selected_lora)
+            trigger_word = model_card.data.get("instance_prompt", "")
+            enabled_loras.append({
+                "repo_id": selected_lora,
+                "trigger_word": trigger_word
+            })
+    
+    return (
+        gr.update( # selected_lora
+            value=""
+        ),
+        gr.update( # custom_lora_info
+            value="",
+            visible=False
+        ),
+        gr.update( # enabled_loras
+            value=enabled_loras
+        )
+    )
+
+
+# Custom Embedding
+def update_custom_embedding(custom_embedding):
+    link = custom_embedding.split("/")
+    
+    if len(link) == 2:
+        model_card = ModelCard.load(custom_embedding)
+        trigger_word = model_card.data.get("instance_prompt", "")
+        image_url = f"""https://huggingface.co/{custom_embedding}/resolve/main/{model_card.data.get("widget", [{}])[0].get("output", {}).get("url", None)}"""
+        
+        custom_embedding_info_css = """
+        <style>
+            .custom-embedding-info {
+                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
+                background: linear-gradient(135deg, #4a90e2, #7b61ff);
+                color: white;
+                padding: 16px;
+                border-radius: 8px;
+                box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+                margin: 16px 0;
+            }
+            .custom-embedding-header {
+                font-size: 18px;
+                font-weight: 600;
+                margin-bottom: 12px;
+            }
+            .custom-embedding-content {
+                display: flex;
+                align-items: center;
+                background-color: rgba(255, 255, 255, 0.1);
+                border-radius: 6px;
+                padding: 12px;
+            }
+            .custom-embedding-image {
+                width: 80px;
+                height: 80px;
+                object-fit: cover;
+                border-radius: 6px;
+                margin-right: 16px;
+            }
+            .custom-embedding-text h3 {
+                margin: 0 0 8px 0;
+                font-size: 16px;
+                font-weight: 600;
+            }
+            .custom-embedding-text small {
+                font-size: 14px;
+                opacity: 0.9;
+            }
+            .custom-trigger-word {
+                background-color: rgba(255, 255, 255, 0.2);
+                padding: 2px 6px;
+                border-radius: 4px;
+                font-weight: 600;
+            }
+        </style>
+        """
+
+        custom_embedding_info_html = f"""
+        <div class="custom-embedding-info">
+            <div class="custom-embedding-header">Custom Embedding: {custom_embedding}</div>
+            <div class="custom-embedding-content">
+                <img class="custom-embedding-image" src="{image_url}" alt="Embedding preview">
+                <div class="custom-embedding-text">
+                    <h3>{link[1].replace("-", " ").replace("_", " ")}</h3>
+                    <small>{"Using: <span class='custom-trigger-word'>"+trigger_word+"</span> as the trigger word" if trigger_word else "No trigger word found. If there's a trigger word, include it in your prompt"}</small>
+                </div>
+            </div>
+        </div>
+        """
+
+        custom_embedding_info_html = f"{custom_embedding_info_css}{custom_embedding_info_html}"
+
+        return gr.update(value=custom_embedding_info_html, visible=True)
+    else:
+        return gr.update(value="", visible=False)
+
+
+def add_to_embeddings(custom_embedding, enabled_embeddings):
+    link = custom_embedding.split("/")
+    if len(link) == 2:
+        if ModelCard.load(custom_embedding):
+            enabled_embeddings.append(custom_embedding)
+        
+        return (
+            gr.update( # custom_embedding
+                value=""
+            ),
+            gr.update( # custom_embedding_info
+                value="",
+                visible=False
+            ),
+            gr.update( # enabled_embeddings
+                value=enabled_embeddings
+            )
+        )
+
+
+def remove_from_embeddings(enabled_embeddings, index):
+    enabled_embeddings.pop(index)
+    return (
+        gr.update(
+            value=enabled_embeddings
+        )
+    )
+
+
+# Generate Image
+@spaces.GPU(duration=75)
+def generate_image(
+    model, prompt, negative_prompt, fast_generation, enabled_loras, enabled_embeddings,
+    lora_slider_0, lora_slider_1, lora_slider_2, lora_slider_3, lora_slider_4, lora_slider_5, # type: ignore
+    img2img_image, inpaint_image, canny_image, pose_image, depth_image, scribble_image, # type: ignore
+    img2img_strength, inpaint_strength, canny_strength, pose_strength, depth_strength, scribble_strength, # type: ignore
+    resize_mode,
+    scheduler, image_height, image_width, image_num_images_per_prompt, # type: ignore
+    image_num_inference_steps, image_clip_skip, image_guidance_scale, image_seed, # type: ignore
+    refiner, vae
+):
+    try:
+        base_args = {
+            "model": model,
+            "prompt": prompt,
+            # "negative_prompt": negative_prompt,
+            "fast_generation": fast_generation,
+            "loras": None,
+            # "embeddings": None,
+            "resize_mode": resize_mode,
+            "scheduler": scheduler,
+            "height": int(image_height),
+            "width": int(image_width),
+            "num_images_per_prompt": float(image_num_images_per_prompt),
+            "num_inference_steps": float(image_num_inference_steps),
+            # "clip_skip": None,
+            "guidance_scale": None,
+            "seed": int(image_seed),
+            "refiner": refiner,
+            "vae": vae,
+            "controlnet_config": None,
+        }
+        base_args = BaseReq(**base_args)
+        
+        if len(enabled_loras) > 0:
+            base_args.loras = []
+            for enabled_lora, slider in zip(enabled_loras, [lora_slider_0, lora_slider_1, lora_slider_2, lora_slider_3, lora_slider_4, lora_slider_5]):
+                if enabled_lora['repo_id']:
+                    base_args.loras.append({
+                        "repo_id": enabled_lora['repo_id'],
+                        "weight": slider
+                    })
+        
+        # Load SDXL related args
+        if model in Config.IMAGES_MODELS:
+            if model['loader'] == 'sdxl':
+                base_args.negative_prompt = negative_prompt
+                base_args.clip_skip = image_clip_skip
+                if len(enabled_embeddings) > 0:
+                    base_args.embeddings = enabled_embeddings
+        
+        image = None
+        mask_image = None
+        strength = None
+        
+        if img2img_image:
+            image = img2img_image
+            strength = float(img2img_strength)
+            
+            base_args = BaseImg2ImgReq(
+                **base_args.__dict__,
+                image=image,
+                strength=strength
+            )
+        elif inpaint_image:
+            image = inpaint_image['background'] if not all(pixel == (0, 0, 0) for pixel in list(inpaint_image['background'].getdata())) else None
+            mask_image = inpaint_image['layers'][0] if image else None
+            strength = float(inpaint_strength)
+            
+            if image and mask_image:
+                base_args = BaseInpaintReq(
+                    **base_args.__dict__,
+                    image=image,
+                    mask_image=mask_image,
+                    strength=strength
+                )
+        elif any([canny_image, pose_image, depth_image]):
+            base_args.controlnet_config = ControlNetReq(
+                controlnets=[],
+                control_images=[],
+                controlnet_conditioning_scale=[]
+            )
+            
+            if canny_image:
+                base_args.controlnet_config.controlnets.append("canny")
+                base_args.controlnet_config.control_images.append(canny_image)
+                base_args.controlnet_config.controlnet_conditioning_scale.append(float(canny_strength))
+            if pose_image:
+                base_args.controlnet_config.controlnets.append("pose")
+                base_args.controlnet_config.control_images.append(pose_image)
+                base_args.controlnet_config.controlnet_conditioning_scale.append(float(pose_strength))
+            if depth_image:
+                base_args.controlnet_config.controlnets.append("depth")
+                base_args.controlnet_config.control_images.append(depth_image)
+                base_args.controlnet_config.controlnet_conditioning_scale.append(float(depth_strength))
+            if model in Config.IMAGES_MODELS and model['loader'] == 'sdxl' and scribble_image:
+                base_args.controlnet_config.controlnets.append("scribble")
+                base_args.controlnet_config.control_images.append(scribble_image)
+                base_args.controlnet_config.controlnet_conditioning_scale.append(float(scribble_strength))
+        else:
+            base_args = BaseReq(**base_args.__dict__)
+        
+        return gr.update(
+            value=gen_img(base_args),
+            interactive=True
+        )
+    except Exception as e:
+        raise gr.Error(f"Error: {e}") from e

tabs/images/handlers.py

@@ -0,0 +1,257 @@
+import gc
+import random
+
+import gradio as gr
+import torch
+from controlnet_aux import Processor
+from safetensors.torch import load_file
+from diffusers import (
+    AutoPipelineForText2Image,
+    AutoPipelineForImage2Image,
+    AutoPipelineForInpainting,
+    FluxPipeline,
+    FluxImg2ImgPipeline,
+    FluxInpaintPipeline,
+    FluxControlNetPipeline,
+    StableDiffusionXLPipeline,
+    StableDiffusionXLImg2ImgPipeline,
+    StableDiffusionXLInpaintPipeline,
+    StableDiffusionXLControlNetPipeline,
+    StableDiffusionXLControlNetImg2ImgPipeline,
+    StableDiffusionXLControlNetInpaintPipeline,
+)
+from sd_embed.embedding_funcs import get_weighted_text_embeddings_flux1, get_weighted_text_embeddings_sdxl
+from huggingface_hub import hf_hub_download
+from diffusers.schedulers import *
+
+from .models import *
+from .load_models import device, models, flux_vae, sdxl_vae, refiner, controlnets
+
+sd_pipes = (StableDiffusionXLPipeline, StableDiffusionXLImg2ImgPipeline, StableDiffusionXLInpaintPipeline,
+            StableDiffusionXLControlNetPipeline, StableDiffusionXLControlNetImg2ImgPipeline, StableDiffusionXLControlNetInpaintPipeline)
+flux_pipes = (FluxPipeline, FluxImg2ImgPipeline, FluxInpaintPipeline, FluxControlNetPipeline)
+
+
+def get_pipe(request: BaseReq | BaseImg2ImgReq | BaseInpaintReq):
+    for model in models:
+        if model['repo_id'] == request.model:
+            pipe_args = {
+                "pipeline": model['pipeline'],
+            }
+            
+            # Set ControlNet config
+            if request.controlnet_config:
+                pipe_args["controlnet"] = []
+                if model['loader'] == 'sdxl' or model['loader'] == 'flux':
+                    for controlnet in controlnets:
+                        if request.controlnet_config.controlnet in controlnet['layers']:
+                            pipe_args["controlnet"].append(controlnet['controlnet'])
+                elif model['loader'] == 'flux-multi':
+                    controlnet = next((controlnet for controlnet in controlnets if controlnet['loader'] == 'flux-multi'), None)
+                    if controlnet is not None:
+                        # control_mode = list of index of layers
+                        pipe_args['control_mode'] = [controlnet['layers'].index(layer) for layer in request.controlnet_config.controlnet]
+                        pipe_args['controlnet'].append(controlnet['controlnet'])
+            
+            # Choose Pipeline Mode
+            if not request.custom_addons:
+                if isinstance(request, BaseInpaintReq):
+                    pipe_args['pipeline'] = AutoPipelineForInpainting.from_pipe(**pipe_args)
+                elif isinstance(request, BaseImg2ImgReq):
+                    pipe_args['pipeline'] = AutoPipelineForImage2Image.from_pipe(**pipe_args)
+                elif isinstance(request, BaseReq):
+                    pipe_args['pipeline'] = AutoPipelineForText2Image.from_pipe(**pipe_args)
+            elif request.custom_addons:
+                ...
+            
+            # Enable or Disable Vae
+            if request.vae:
+                pipe_args["pipeline"].vae = sdxl_vae if model['loader'] == 'sdxl' else flux_vae
+            elif not request.vae:
+                pipe_args["pipeline"].vae = None
+            
+            # Set Scheduler
+            pipe_args["pipeline"].scheduler = get_scheduler(pipe_args["pipeline"], request.scheduler)
+            
+            # Set Loras
+            if request.loras:
+                for i, lora in enumerate(request.loras):
+                    pipe_args["pipeline"].load_lora_weights(lora['repo_id'], adapter_name=f"lora_{i}")
+                adapter_names = [f"lora_{i}" for i in range(len(request.loras))]
+                adapter_weights = [lora['weight'] for lora in request.loras]
+                
+                if request.fast_generation:
+                    hyper_lora = hf_hub_download("ByteDance/Hyper-SD", "Hyper-FLUX.1-dev-8steps-lora.safetensors") if model['loader'] == 'flux' \
+                            else hf_hub_download("ByteDance/Hyper-SD", "Hyper-SDXL-8steps-lora.safetensors")
+                    hyper_weight = 0.125 if model['loader'] == 'flux' else 1.0
+                    pipe_args["pipeline"].load_lora_weights(hyper_lora, adapter_name="hyper_lora")
+                    pipe_args["pipeline"].set_adapters(["hyper_lora"], [hyper_weight])
+                    
+                pipe_args["pipeline"].set_adapters(adapter_names, adapter_weights)
+
+            # Set Embeddings
+            if request.embeddings and model['loader'] == 'sdxl':
+                for embedding in request.embeddings:
+                    state_dict = load_file(hf_hub_download(embedding['repo_id']))
+                    pipe_args["pipeline"].load_textual_inversion(state_dict['clip_g'], token=embedding['token'], text_encoder=pipe_args["pipeline"].text_encoder_2, tokenizer=pipe_args["pipeline"].tokenizer_2)
+                    pipe_args["pipeline"].load_textual_inversion(state_dict["clip_l"], token=embedding['token'], text_encoder=pipe_args["pipeline"].text_encoder, tokenizer=pipe_args["pipeline"].tokenizer)
+
+            return pipe_args
+
+    
+def load_scheduler(pipeline, scheduler):
+    schedulers = {
+        "dpmpp_2m": (DPMSolverMultistepScheduler, {}),
+        "dpmpp_2m_k": (DPMSolverMultistepScheduler, {"use_karras_sigmas": True}),
+        "dpmpp_2m_sde": (DPMSolverMultistepScheduler, {"algorithm_type": "sde-dpmsolver++"}),
+        "dpmpp_2m_sde_k": (DPMSolverMultistepScheduler, {"algorithm_type": "sde-dpmsolver++", "use_karras_sigmas": True}),
+        "dpmpp_sde": (DPMSolverSinglestepScheduler, {}),
+        "dpmpp_sde_k": (DPMSolverSinglestepScheduler, {"use_karras_sigmas": True}),
+        "dpm2": (KDPM2DiscreteScheduler, {}),
+        "dpm2_k": (KDPM2DiscreteScheduler, {"use_karras_sigmas": True}),
+        "dpm2_a": (KDPM2AncestralDiscreteScheduler, {}),
+        "dpm2_a_k": (KDPM2AncestralDiscreteScheduler, {"use_karras_sigmas": True}),
+        "euler": (EulerDiscreteScheduler, {}),
+        "euler_a": (EulerAncestralDiscreteScheduler, {}),
+        "heun": (HeunDiscreteScheduler, {}),
+        "lms": (LMSDiscreteScheduler, {}),
+        "lms_k": (LMSDiscreteScheduler, {"use_karras_sigmas": True}),
+        "deis": (DEISMultistepScheduler, {}),
+        "unipc": (UniPCMultistepScheduler, {}),
+        "fm_euler": (FlowMatchEulerDiscreteScheduler, {}),
+    }
+    scheduler_class, kwargs = schedulers.get(scheduler, (None, {}))
+    
+    if scheduler_class is not None:
+        scheduler = scheduler_class.from_config(pipeline.scheduler.config, **kwargs)
+    else:
+        raise ValueError(f"Unknown scheduler: {scheduler}")
+    
+    return scheduler
+
+
+def resize_images(images: List[Image.Image], height: int, width: int, resize_mode: str):
+    for image in images:
+        if resize_mode == "resize_only":
+            image = image.resize((width, height))
+        elif resize_mode == "crop_and_resize":
+            image = image.crop((0, 0, width, height))
+        elif resize_mode == "resize_and_fill":
+            image = image.resize((width, height), Image.Resampling.LANCZOS)
+
+    return images
+
+
+def get_controlnet_images(controlnets: List[str], control_images: List[Image.Image], height: int, width: int, resize_mode: str):
+    response_images = []
+    control_images = resize_images(control_images, height, width, resize_mode)
+    for controlnet, image in zip(controlnets, control_images):
+        if controlnet == "canny":
+            processor = Processor('canny')
+        elif controlnet == "depth":
+            processor = Processor('depth_midas')
+        elif controlnet == "pose":
+            processor = Processor('openpose_full')
+        elif controlnet == "scribble":
+            processor = Processor('scribble')
+        else:
+            raise ValueError(f"Invalid Controlnet: {controlnet}")
+    
+        response_images.append(processor(image, to_pil=True))
+    
+    return response_images
+
+
+def get_control_mode(controlnet_config: ControlNetReq):
+    control_mode = []
+    for controlnet in controlnets:
+        if controlnet['loader'] == 'flux-multi':
+            layers = controlnet['layers']
+
+    for c in controlnet_config.controlnets:
+        if c in layers:
+            control_mode.append(layers.index(c))
+
+    return control_mode
+
+
+# def check_image_safety(images: List[Image.Image]):
+#     safety_checker_input = feature_extractor(images, return_tensors="pt").to("cuda")
+#     has_nsfw_concepts = safety_checker(
+#         images=[images],
+#         clip_input=safety_checker_input.pixel_values.to("cuda"),
+#     )
+    
+#     return has_nsfw_concepts[1]
+
+
+def get_prompt_attention(pipeline, prompt, negative_prompt):
+    if isinstance(pipeline, flux_pipes):
+        prompt_embeds, pooled_prompt_embeds = get_weighted_text_embeddings_flux1(pipeline, prompt)
+        return prompt_embeds, None, pooled_prompt_embeds, None
+    elif isinstance(pipeline, sd_pipes):
+        prompt_embeds, prompt_neg_embeds, pooled_prompt_embeds, negative_pooled_prompt_embeds = get_weighted_text_embeddings_sdxl(pipeline, prompt, negative_prompt)
+        return prompt_embeds, prompt_neg_embeds, pooled_prompt_embeds, negative_pooled_prompt_embeds
+
+
+def cleanup(pipeline, loras = None, embeddings = None):
+    if loras:
+        pipeline.disable_lora()
+        pipeline.unload_lora_weights()
+    if embeddings:
+        pipeline.unload_textual_inversion()
+    gc.collect()
+    torch.cuda.empty_cache()
+
+
+# Gen Function
+def gen_img(request: BaseReq | BaseImg2ImgReq | BaseInpaintReq):
+    pipeline_args = get_pipe(request)
+    pipeline = pipeline_args["pipeline"]
+    try:
+        positive_prompt_embeds, negative_prompt_embeds, positive_prompt_pooled, negative_prompt_pooled = get_prompt_attention(pipeline, request.prompt, request.negative_prompt)
+
+        # Common Args
+        args = {
+            'prompt_embeds': positive_prompt_embeds,
+            'pooled_prompt_embeds': positive_prompt_pooled,
+            'height': request.height,
+            'width': request.width,
+            'num_images_per_prompt': request.num_images_per_prompt,
+            'num_inference_steps': request.num_inference_steps,
+            'guidance_scale': request.guidance_scale,
+            'generator': [torch.Generator(device=device).manual_seed(request.seed + i) if not request.seed is any([None, 0, -1]) else torch.Generator(device=device).manual_seed(random.randint(0, 2**32 - 1)) for i in range(request.num_images_per_prompt)],
+        }
+        
+        if isinstance(pipeline, sd_pipes):
+            args['clip_skip'] = request.clip_skip
+            args['negative_prompt_embeds'] = negative_prompt_embeds
+            args['negative_pooled_prompt_embeds'] = negative_prompt_pooled
+
+        if request.controlnet_config:
+            args['control_images'] = get_controlnet_images(request.controlnet_config.controlnets, request.controlnet_config.control_images, request.height, request.width, request.resize_mode)
+            args['controlnet_conditioning_scale'] = request.controlnet_config.controlnet_conditioning_scale
+        
+        if request.controlnet_config and isinstance(pipeline, flux_pipes):
+            args['control_mode'] = get_control_mode(request.controlnet_config)
+
+        if isinstance(request, (BaseImg2ImgReq, BaseInpaintReq)):
+            args['image'] = resize_images([request.image], request.height, request.width, request.resize_mode)[0]
+            args['strength'] = request.strength
+
+        if isinstance(request, BaseInpaintReq):
+            args['mask_image'] = resize_images([request.mask_image], request.height, request.width, request.resize_mode)[0]
+
+        # Generate
+        images = pipeline(**args).images
+
+        # Refiner
+        if request.refiner:
+            images = refiner(image=images, prompt=request.prompt, num_inference_steps=40, denoising_start=0.7).images
+
+        return images
+    except Exception as e:
+        cleanup(pipeline, request.loras, request.embeddings)
+        raise gr.Error(f"Error: {e}")
+    finally:
+        cleanup(pipeline, request.loras, request.embeddings)

tabs/images/load_models.py

@@ -0,0 +1,61 @@
+import torch
+from diffusers import (
+    AutoPipelineForText2Image,
+    AutoencoderKL,
+    FluxControlNetModel,
+    FluxMultiControlNetModel,
+)
+from diffusers.schedulers import *
+
+from config import Config
+
+def init_sys():
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    
+    models = Config.IMAGES_MODELS
+    
+    for model in models:
+        try:
+            model['pipeline'] = AutoPipelineForText2Image.from_pretrained(
+                model['repo_id'],
+                vae=None,
+                torch_dtype=model['compute_type'],
+                safety_checker=None,
+                variant="fp16"
+            ).to(device)
+        except:
+            model['pipeline'] = AutoPipelineForText2Image.from_pretrained(
+                model['repo_id'],
+                vae=None,
+                torch_dtype=model['compute_type'],
+                safety_checker=None
+            ).to(device)
+        model['pipeline'].enable_model_cpu_offload()
+    
+    # VAE n Refiner
+    flux_vae = AutoencoderKL.from_pretrained("black-forest-labs/FLUX.1-dev", subfolder="vae", torch_dtype=torch.bfloat16).to(device)
+    sdxl_vae = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16).to(device)
+    refiner = AutoPipelineForText2Image.from_pretrained("stabilityai/stable-diffusion-xl-refiner-1.0", vae=sdxl_vae, torch_dtype=torch.float16).to(device)
+    
+    # ControlNet
+    controlnets = Config.IMAGES_CONTROLNETS
+    for controlnet in controlnets:
+        if controlnet['loader'] == 'flux-multi':
+            controlnet['controlnet'] = FluxMultiControlNetModel([FluxControlNetModel.from_pretrained(
+                controlnet['repo_id'],
+                torch_dtype=controlnet['compute_type']
+            ).to(device)])
+        elif controlnet['loader'] == 'sdxl':
+            controlnet['controlnet'] = FluxControlNetModel.from_pretrained(
+                controlnet['repo_id'],
+                torch_dtype=controlnet['compute_type']
+            ).to(device)
+        elif controlnet['loader'] == 'flux':
+            controlnet['controlnet'] = FluxControlNetModel.from_pretrained(
+                controlnet['repo_id'],
+                torch_dtype=controlnet['compute_type']
+            ).to(device)
+    
+    return device, models, flux_vae, sdxl_vae, refiner, controlnets
+
+device, models, flux_vae, sdxl_vae, refiner, controlnets = init_sys()

tabs/images/models.py

@@ -0,0 +1,72 @@
+from typing import List, Optional, Dict, Any
+
+from pydantic import BaseModel, field_validator
+from PIL import Image
+
+from config import Config as appConfig
+
+
+class ControlNetReq(BaseModel):
+    controlnets: List[str] # ["canny", "tile", "depth", "scribble"]
+    control_images: List[Image.Image]
+    controlnet_conditioning_scale: List[float]
+    
+    class Config:
+        arbitrary_types_allowed=True
+
+
+class BaseReq(BaseModel):
+    model: str = ""
+    prompt: str = ""
+    negative_prompt: Optional[str] = None
+    fast_generation: Optional[bool] = True
+    loras: Optional[list] = []
+    embeddings: Optional[list] = None
+    resize_mode: Optional[str] = "resize_and_fill" # resize_only, crop_and_resize, resize_and_fill
+    scheduler: Optional[str] = "euler_fl"
+    height: int = 1024
+    width: int = 1024
+    num_images_per_prompt: int = 1
+    num_inference_steps: int = 8
+    clip_skip: Optional[int] = None
+    guidance_scale: float = 3.5
+    seed: Optional[int] = 0
+    refiner: bool = False
+    vae: bool = True
+    controlnet_config: Optional[ControlNetReq] = None
+    custom_addons: Optional[Dict[Any, Any]] = None
+    
+    class Config:
+        arbitrary_types_allowed=True
+    
+    @field_validator('model', 'negative_prompt', 'embeddings', 'clip_skip', 'controlnet_config')
+    def check_model(cls, values):
+        for m in appConfig.IMAGES_MODELS:
+            if m.get('repo_id') == values.get('model'):
+                loader = m.get('loader')
+            
+        if loader == "flux" and values.get('negative_prompt'):
+            raise ValueError("Negative prompt is not supported for Flux models.")
+        if loader == "flux" and values.get('embeddings'):
+            raise ValueError("Embeddings are not supported for Flux models.")
+        if loader == "flux" and values.get('clip_skip'):
+            raise ValueError("Clip skip is not supported for Flux models.")
+        if loader == "flux" and values.get('controlnet_config'):
+            if "scribble" in values.get('controlnet_config').controlnets:
+                raise ValueError("Scribble is not supported for Flux models.")
+        return values
+
+
+class BaseImg2ImgReq(BaseReq):
+    image: Image.Image
+    strength: float = 1.0
+    
+    class Config:
+        arbitrary_types_allowed=True
+
+
+class BaseInpaintReq(BaseImg2ImgReq):
+    mask_image: Image.Image
+    
+    class Config:
+        arbitrary_types_allowed=True

tabs/images/ui.py

@@ -0,0 +1,179 @@
+import random
+
+import gradio as gr
+
+from config import Config
+from .events import *
+
+
+def image_tab():
+    with gr.Row():
+        with gr.Column():
+            with gr.Group():
+                model = gr.Dropdown(label='Model', choices=[model['repo_id'] for model in Config.IMAGES_MODELS], value=Config.IMAGES_MODELS[0]['repo_id'], interactive=True)
+                prompt = gr.Textbox(lines=5, label='Prompt', placeholder='Enter your prompt here...', value='A beautiful sunset over the mountains.')
+                negative_prompt = gr.Textbox(lines=2, label='Negative Prompt', placeholder='Enter your negative prompt here...', visible=False)
+                fast_generation = gr.Checkbox(label='Fast Generation (Hyper-SD 🧪)', value=False)
+                
+            
+            with gr.Accordion('Loras', open=True):
+                for m in Config.IMAGES_MODELS:
+                    if m['repo_id'] == model.value:
+                        lora_gallery_values = []
+                        if m['loader'] == 'flux':
+                            lora_gallery_values = [(lora['image'], lora['title']) for lora in Config.IMAGES_LORAS_FLUX]
+                        elif m['loader'] == 'sdxl':
+                            lora_gallery_values = [(lora['image'], lora['title']) for lora in Config.IMAGES_LORAS_SDXL]
+                
+                lora_gallery = gr.Gallery(
+                    label='Loras',
+                    value=lora_gallery_values,
+                    allow_preview=False,
+                    interactive=True,
+                    rows=2,
+                    columns=3,
+                )
+                
+                with gr.Group():
+                    with gr.Column():
+                        with gr.Row():
+                            custom_lora = gr.Textbox(label='Custom Lora', info='Enter a Huggingface repo path')
+                            selected_lora = gr.Textbox(label="Selected Lora", info="Choose from the gallery or enter a custom LoRA")
+                        
+                        custom_lora_info = gr.HTML(visible=False)
+                        add_lora = gr.Button(value="Add LoRA")
+                        
+                        enabled_loras = gr.State(value=[])
+                        with gr.Group():
+                            with gr.Row():
+                                for i in range(6): # only support max 6 loras due to inference time
+                                    with gr.Column():
+                                        with gr.Column(scale=2):
+                                            globals()[f"lora_slider_{i}"] = gr.Slider(label=f"LoRA {i+1}", minimum=0, maximum=1, step=0.01, value=0.8, visible=False, interactive=True)
+                                        with gr.Column():
+                                            globals()[f"lora_remove_{i}"] = gr.Button(value="Remove LoRA", visible=False) 
+
+            
+            with gr.Accordion("Embeddings", open=False) as embeddings_accordion:
+                with gr.Group():
+                    with gr.Row():
+                        with gr.Group():
+                            custom_embedding = gr.Textbox(label="Custom Embedding", info="Enter a Huggingface repo path")
+                            add_embedding = gr.Button(value="Add Embedding")
+                            custom_embedding_info = gr.HTML(visible=False)
+                    with gr.Row():
+                        enabled_embeddings = gr.State(value=[])
+                        enabled_embeddings_list = gr.Checkboxgroup(label="Enabled Embeddings", choices=[], visible=False)
+            
+            
+            with gr.Accordion('Image Options', open=False):
+            
+                with gr.Tabs():
+                    image_options = [
+                        ('img2img', 'Image to Image', 'image', True),
+                        ('inpaint', 'Inpainting', 'imageeditor', True),
+                        ('canny', 'Edge Detection', 'imageeditor', True),
+                        ('pose', 'Pose Detection', 'imageeditor', True),
+                        ('depth', 'Depth Estimation', 'imageeditor', True),
+                        ('scribble', 'Scribble', 'imageeditor', False),
+                    ]
+                    for image_option, label, type, visible in image_options:
+                        with gr.Tab(label=image_option) as globals()[f"{image_option}_tab"]:
+                            if type == 'image':
+                                globals()[f"{image_option}_image"] = gr.Image(label=label, visible=visible, interactive=True, type='pil')
+                            elif type == 'imageeditor':
+                                globals()[f"{image_option}_image"] = gr.ImageEditor(label=label, visible=visible, interactive=True,
+                                                                                    brush=gr.Brush(colors=["#FFFFFF"], color_mode="fixed") if image_option == 'inpaint' else gr.Brush(),
+                                                                                    type='pil', image_mode='RGB', layers=False)
+                            
+                            globals()[f"{image_option}_strength"] = gr.Slider(label="Strength", minimum=0, maximum=1, step=0.01, value=1.0, interactive=True)
+                    
+                    resize_mode = gr.Radio(
+                        label="Resize Mode",
+                        choices=["crop and resize", "resize only", "resize and fill"],
+                        value="resize and fill",
+                        interactive=True
+                    )
+        
+        
+        with gr.Column():
+            with gr.Group():
+                output_images = gr.Gallery(label='Output Image', type='pil', interactive=False, value=[], allow_preview=True)
+                generate = gr.Button(value="Generate", variant="primary")
+            
+            
+            with gr.Accordion('Advance Settings', open=True):
+                scheduler = gr.Dropdown(
+                    label='Scheduler',
+                    choices = [
+                        "dpmpp_2m", "dpmpp_2m_k", "dpmpp_2m_sde", "dpmpp_2m_sde_k",
+                        "dpmpp_sde", "dpmpp_sde_k", "dpm2", "dpm2_k", "dpm2_a",
+                        "dpm2_a_k", "euler", "euler_a", "heun", "lms", "lms_k",
+                        "deis", "unipc", "fm_euler"
+                    ],
+                    value="fm_euler",
+                    interactive=True
+                )
+                
+                with gr.Row():
+                    for column in range(2):
+                        with gr.Column():
+                            options = [
+                                ("Height", "image_height", 64, 2048, 64, 1024, True),
+                                ("Width", "image_width", 64, 2048, 64, 1024, True),
+                                ("Num Images Per Prompt", "image_num_images_per_prompt", 1, 4, 1, 1, True),
+                                ("Num Inference Steps", "image_num_inference_steps", 1, 100, 1, 20, True),
+                                ("Clip Skip", "image_clip_skip", 0, 2, 1, 2, True),
+                                ("Guidance Scale", "image_guidance_scale", 0, 20, 0.5, 7.0, True),
+                                ("Seed", "image_seed", 0, 100000, 1, random.randint(0, 100000), True),
+                            ]
+                            for label, var_name, min_val, max_val, step, value, visible in options[column::2]:
+                                globals()[var_name] = gr.Slider(label=label, minimum=min_val, maximum=max_val, step=step, value=value, visible=visible, interactive=True)
+
+                with gr.Row():
+                    refiner = gr.Checkbox(label="Refiner", value=False)
+                    vae = gr.Checkbox(label="VAE", value=False)
+
+    # Events
+    # Base Options
+    model.change(update_model_options, [model], [negative_prompt, lora_gallery, embeddings_accordion, scribble_tab, scheduler, image_clip_skip, image_guidance_scale]) # type: ignore
+    fast_generation.change(update_fast_generation, [model, fast_generation], [image_num_inference_steps, image_guidance_scale]) # type: ignore
+    
+    # Loras
+    lora_gallery.select(selected_lora_from_gallery, None, selected_lora)
+    custom_lora.change(update_selected_lora, custom_lora, [selected_lora, custom_lora_info])
+    add_lora.click(add_to_enabled_loras, [selected_lora, enabled_loras], [selected_lora, custom_lora_info, enabled_loras])
+    enabled_loras.change(update_lora_sliders, enabled_loras, [lora_slider_0, lora_slider_1, lora_slider_2, lora_slider_3, lora_slider_4, lora_slider_5, lora_remove_0, lora_remove_1, lora_remove_2, lora_remove_3, lora_remove_4, lora_remove_5]) # type: ignore
+    
+    for i in range(6):
+        globals()[f"lora_remove_{i}"].click(
+            lambda enabled_loras, index=i: remove_from_enabled_loras(enabled_loras, index),
+            [enabled_loras],
+            [enabled_loras]
+        )
+    
+    # Embeddings
+    custom_embedding.change(update_custom_embedding, custom_embedding, [custom_embedding_info])
+    add_embedding.click(add_to_embeddings, [custom_embedding, enabled_embeddings], [custom_embedding, custom_embedding_info, enabled_embeddings])
+    for i in range(6):
+        globals()[f"embedding_remove_{i}"].click(
+            lambda enabled_embeddings, index=i: remove_from_embeddings(enabled_embeddings, index),
+            [enabled_embeddings],
+            [enabled_embeddings]
+        )
+    
+    # Generate Image
+    generate.click(
+        generate_image, # type: ignore
+        [
+            model, prompt, negative_prompt, fast_generation, enabled_loras, enabled_embeddings,
+            lora_slider_0, lora_slider_1, lora_slider_2, lora_slider_3, lora_slider_4, lora_slider_5, # type: ignore
+            img2img_image, inpaint_image, canny_image, pose_image, depth_image, scribble_image, # type: ignore
+            img2img_strength, inpaint_strength, canny_strength, pose_strength, depth_strength, scribble_strength, # type: ignore
+            resize_mode,
+            scheduler, image_height, image_width, image_num_images_per_prompt, # type: ignore
+            image_num_inference_steps, image_clip_skip, image_guidance_scale, image_seed, # type: ignore
+            refiner, vae
+        ],
+        [output_images]
+    )