Update app.py

app.py

@@ -26,8 +26,6 @@ print(f"🖥️  Device: {device} | dtype: {dtype}")
 
 # Lazy import (to avoid long startup if unused)
 from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, StableDiffusionPipeline
-from diffusers import StableDiffusionInstructPix2PixPipeline, AutoPipelineForImage2Image
-from diffusers import FluxPipeline, FluxImg2ImgPipeline
 from controlnet_aux import LineartDetector, LineartAnimeDetector
 
 # Memory optimization
@@ -40,16 +38,13 @@ else:
     print("⚠️  Running on CPU - Image generation will be significantly slower")
 
 # ===== Model & Config =====
+# เปลี่ยนจาก dict เป็นตัวแปรเดี่ยวเพื่อจัดการหน่วยความจำได้ง่ายขึ้น
 CURRENT_CONTROLNET_PIPE = None
 CURRENT_CONTROLNET_KEY = None  # (model_name, is_anime)
 LINEART_DETECTOR = None
 LINEART_ANIME_DETECTOR = None
 CURRENT_T2I_PIPE = None
 CURRENT_T2I_MODEL = None
-CURRENT_PIX2PIX_PIPE = None
-CURRENT_PIX2PIX_MODEL = None
-CURRENT_FLUX_PIPE = None  # New: FLUX model pipeline
-CURRENT_FLUX_MODEL = None  # New: Current FLUX model name
 
 def get_pipeline(model_name: str, anime_model: bool = False):
     """Get or create a ControlNet pipeline for the given model and anime flag"""
@@ -309,267 +304,6 @@ def load_t2i_model(model_name: str):
             CURRENT_T2I_MODEL = None
             raise
 
-def load_pix2pix_model():
-    """Load Instruct-Pix2Pix model for image editing"""
-    global CURRENT_PIX2PIX_PIPE, CURRENT_PIX2PIX_MODEL
-    
-    if CURRENT_PIX2PIX_PIPE is not None:
-        return CURRENT_PIX2PIX_PIPE
-    
-    try:
-        print("Loading Instruct-Pix2Pix model...")
-        CURRENT_PIX2PIX_PIPE = StableDiffusionInstructPix2PixPipeline.from_pretrained(
-            "timbrooks/instruct-pix2pix",
-            torch_dtype=dtype,
-            safety_checker=None,
-            requires_safety_checker=False,
-            use_safetensors=True,
-            variant="fp16" if dtype == torch.float16 else None
-        ).to(device)
-        
-        # Optimizations
-        CURRENT_PIX2PIX_PIPE.enable_attention_slicing(slice_size="max")
-        
-        # Use new API for VAE slicing
-        if hasattr(CURRENT_PIX2PIX_PIPE, 'vae') and hasattr(CURRENT_PIX2PIX_PIPE.vae, 'enable_slicing'):
-            CURRENT_PIX2PIX_PIPE.vae.enable_slicing()
-        else:
-            try:
-                CURRENT_PIX2PIX_PIPE.enable_vae_slicing()
-            except:
-                pass
-        
-        if device.type == "cuda":
-            try:
-                CURRENT_PIX2PIX_PIPE.enable_xformers_memory_efficient_attention()
-                print("✅ xFormers enabled for Pix2Pix")
-            except:
-                pass
-            CURRENT_PIX2PIX_PIPE.enable_model_cpu_offload()
-        
-        # Compile if available
-        if hasattr(torch, 'compile') and device.type == "cuda":
-            try:
-                CURRENT_PIX2PIX_PIPE.unet = torch.compile(CURRENT_PIX2PIX_PIPE.unet, mode="reduce-overhead", fullgraph=True)
-                print("✅ Pix2Pix model compiled")
-            except:
-                pass
-        
-        CURRENT_PIX2PIX_MODEL = "timbrooks/instruct-pix2pix"
-        return CURRENT_PIX2PIX_PIPE
-        
-    except Exception as e:
-        print(f"Error loading Instruct-Pix2Pix model: {e}")
-        print(f"⚠️  Trying to load without use_safetensors...")
-        
-        # Retry without use_safetensors
-        try:
-            CURRENT_PIX2PIX_PIPE = StableDiffusionInstructPix2PixPipeline.from_pretrained(
-                "timbrooks/instruct-pix2pix",
-                torch_dtype=dtype,
-                safety_checker=None,
-                requires_safety_checker=False
-            ).to(device)
-            
-            CURRENT_PIX2PIX_PIPE.enable_attention_slicing(slice_size="max")
-            if hasattr(CURRENT_PIX2PIX_PIPE, 'vae') and hasattr(CURRENT_PIX2PIX_PIPE.vae, 'enable_slicing'):
-                CURRENT_PIX2PIX_PIPE.vae.enable_slicing()
-            else:
-                try:
-                    CURRENT_PIX2PIX_PIPE.enable_vae_slicing()
-                except:
-                    pass
-            
-            if device.type == "cuda":
-                try:
-                    CURRENT_PIX2PIX_PIPE.enable_xformers_memory_efficient_attention()
-                    print("✅ xFormers enabled for Pix2Pix")
-                except:
-                    pass
-                CURRENT_PIX2PIX_PIPE.enable_model_cpu_offload()
-            
-            if hasattr(torch, 'compile') and device.type == "cuda":
-                try:
-                    CURRENT_PIX2PIX_PIPE.unet = torch.compile(CURRENT_PIX2PIX_PIPE.unet, mode="reduce-overhead", fullgraph=True)
-                    print("✅ Pix2Pix model compiled")
-                except:
-                    pass
-            
-            CURRENT_PIX2PIX_MODEL = "timbrooks/instruct-pix2pix"
-            return CURRENT_PIX2PIX_PIPE
-            
-        except Exception as retry_e:
-            print(f"❌ Error loading Instruct-Pix2Pix model (retry): {retry_e}")
-            CURRENT_PIX2PIX_PIPE = None
-            CURRENT_PIX2PIX_MODEL = None
-            raise
-
-def load_flux_model():
-    """Load FLUX.1-Kontext model for image-to-image"""
-    global CURRENT_FLUX_PIPE, CURRENT_FLUX_MODEL
-    
-    model_name = "kpsss34/FLUX.1-Kontext-dev-int4"
-    
-    if CURRENT_FLUX_MODEL == model_name and CURRENT_FLUX_PIPE is not None:
-        return CURRENT_FLUX_PIPE
-    
-    try:
-        if CURRENT_FLUX_PIPE is not None:
-            print(f"🗑️ Unloading old FLUX model: {CURRENT_FLUX_MODEL}")
-            del CURRENT_FLUX_PIPE
-            CURRENT_FLUX_PIPE = None
-            gc.collect()
-            if torch.cuda.is_available():
-                torch.cuda.empty_cache()
-        
-        print(f"📥 Loading FLUX model: {model_name}")
-        
-        # ใช้ FluxPipeline หรือ FluxImg2ImgPipeline ขึ้นอยู่กับว่ามีหรือไม่
-        # FLUX 1.0 ใช้ architecture ใหม่ที่แตกต่างจาก Stable Diffusion
-        
-        try:
-            # ลองใช้ FluxImg2ImgPipeline ก่อน (ถ้ามี)
-            CURRENT_FLUX_PIPE = FluxImg2ImgPipeline.from_pretrained(
-                model_name,
-                torch_dtype=dtype,
-                safety_checker=None,
-                requires_safety_checker=False,
-                use_safetensors=True,
-                variant="fp16" if dtype == torch.float16 else None
-            ).to(device)
-            print("✅ Using FluxImg2ImgPipeline")
-        except:
-            # ถ้าไม่มี FluxImg2ImgPipeline ให้ลองใช้ FluxPipeline
-            try:
-                CURRENT_FLUX_PIPE = FluxPipeline.from_pretrained(
-                    model_name,
-                    torch_dtype=dtype,
-                    safety_checker=None,
-                    requires_safety_checker=False,
-                    use_safetensors=True,
-                    variant="fp16" if dtype == torch.float16 else None
-                ).to(device)
-                print("✅ Using FluxPipeline")
-            except Exception as flux_err:
-                # ถ้าไม่มี FluxPipeline เลย ให้ใช้ AutoPipelineForImage2Image
-                print(f"⚠️  FluxPipeline not available, trying AutoPipelineForImage2Image: {flux_err}")
-                CURRENT_FLUX_PIPE = AutoPipelineForImage2Image.from_pretrained(
-                    model_name,
-                    torch_dtype=dtype,
-                    safety_checker=None,
-                    requires_safety_checker=False,
-                    use_safetensors=True,
-                    variant="fp16" if dtype == torch.float16 else None
-                ).to(device)
-                print("✅ Using AutoPipelineForImage2Image")
-        
-        # Optimizations สำหรับ FLUX
-        if hasattr(CURRENT_FLUX_PIPE, 'enable_attention_slicing'):
-            CURRENT_FLUX_PIPE.enable_attention_slicing(slice_size="max")
-        
-        # สำหรับ FLUX อาจไม่มี VAE จึงต้องตรวจสอบก่อน
-        if hasattr(CURRENT_FLUX_PIPE, 'vae') and hasattr(CURRENT_FLUX_PIPE.vae, 'enable_slicing'):
-            CURRENT_FLUX_PIPE.vae.enable_slicing()
-        elif hasattr(CURRENT_FLUX_PIPE, 'enable_vae_slicing'):
-            try:
-                CURRENT_FLUX_PIPE.enable_vae_slicing()
-            except:
-                pass
-        
-        if device.type == "cuda":
-            if hasattr(CURRENT_FLUX_PIPE, 'enable_xformers_memory_efficient_attention'):
-                try:
-                    CURRENT_FLUX_PIPE.enable_xformers_memory_efficient_attention()
-                    print("✅ xFormers enabled for FLUX")
-                except:
-                    pass
-            
-            if hasattr(CURRENT_FLUX_PIPE, 'enable_model_cpu_offload'):
-                CURRENT_FLUX_PIPE.enable_model_cpu_offload()
-        
-        # Compile if available
-        if hasattr(torch, 'compile') and device.type == "cuda" and hasattr(CURRENT_FLUX_PIPE, 'transformer'):
-            try:
-                CURRENT_FLUX_PIPE.transformer = torch.compile(CURRENT_FLUX_PIPE.transformer, mode="reduce-overhead", fullgraph=True)
-                print("✅ FLUX transformer compiled")
-            except:
-                pass
-        
-        CURRENT_FLUX_MODEL = model_name
-        return CURRENT_FLUX_PIPE
-        
-    except Exception as e:
-        print(f"Error loading FLUX model {model_name}: {e}")
-        print(f"⚠️  Trying to load without use_safetensors...")
-        
-        # Retry without use_safetensors
-        try:
-            try:
-                CURRENT_FLUX_PIPE = FluxImg2ImgPipeline.from_pretrained(
-                    model_name,
-                    torch_dtype=dtype,
-                    safety_checker=None,
-                    requires_safety_checker=False
-                ).to(device)
-                print("✅ Using FluxImg2ImgPipeline (without safetensors)")
-            except:
-                try:
-                    CURRENT_FLUX_PIPE = FluxPipeline.from_pretrained(
-                        model_name,
-                        torch_dtype=dtype,
-                        safety_checker=None,
-                        requires_safety_checker=False
-                    ).to(device)
-                    print("✅ Using FluxPipeline (without safetensors)")
-                except Exception as flux_err:
-                    print(f"⚠️  FluxPipeline not available, trying AutoPipelineForImage2Image: {flux_err}")
-                    CURRENT_FLUX_PIPE = AutoPipelineForImage2Image.from_pretrained(
-                        model_name,
-                        torch_dtype=dtype,
-                        safety_checker=None,
-                        requires_safety_checker=False
-                    ).to(device)
-                    print("✅ Using AutoPipelineForImage2Image (without safetensors)")
-            
-            # Optimizations
-            if hasattr(CURRENT_FLUX_PIPE, 'enable_attention_slicing'):
-                CURRENT_FLUX_PIPE.enable_attention_slicing(slice_size="max")
-            
-            if hasattr(CURRENT_FLUX_PIPE, 'vae') and hasattr(CURRENT_FLUX_PIPE.vae, 'enable_slicing'):
-                CURRENT_FLUX_PIPE.vae.enable_slicing()
-            elif hasattr(CURRENT_FLUX_PIPE, 'enable_vae_slicing'):
-                try:
-                    CURRENT_FLUX_PIPE.enable_vae_slicing()
-                except:
-                    pass
-            
-            if device.type == "cuda":
-                if hasattr(CURRENT_FLUX_PIPE, 'enable_xformers_memory_efficient_attention'):
-                    try:
-                        CURRENT_FLUX_PIPE.enable_xformers_memory_efficient_attention()
-                        print("✅ xFormers enabled for FLUX")
-                    except:
-                        pass
-                
-                if hasattr(CURRENT_FLUX_PIPE, 'enable_model_cpu_offload'):
-                    CURRENT_FLUX_PIPE.enable_model_cpu_offload()
-            
-            if hasattr(torch, 'compile') and device.type == "cuda" and hasattr(CURRENT_FLUX_PIPE, 'transformer'):
-                try:
-                    CURRENT_FLUX_PIPE.transformer = torch.compile(CURRENT_FLUX_PIPE.transformer, mode="reduce-overhead", fullgraph=True)
-                    print("✅ FLUX transformer compiled")
-                except:
-                    pass
-            
-            CURRENT_FLUX_MODEL = model_name
-            return CURRENT_FLUX_PIPE
-            
-        except Exception as retry_e:
-            print(f"❌ Error loading FLUX model (retry): {retry_e}")
-            CURRENT_FLUX_PIPE = None
-            CURRENT_FLUX_MODEL = None
-            raise
-
 # ===== Utils =====
 def is_lineart(img: Image.Image) -> bool:
     arr = np.array(img.convert("L"))
@@ -657,92 +391,11 @@ def t2i(prompt, model, seed, steps, scale, w, h):
         error_img = Image.new('RGB', (int(w), int(h)), color='red')
         return error_img
 
-def pix2pix_edit(image, instruction, seed, steps, scale, image_scale):
-    """Edit image using Instruct-Pix2Pix"""
-    try:
-        pipe = load_pix2pix_model()
-        print(f"🔄 Using Pix2Pix model: {CURRENT_PIX2PIX_MODEL}")
-        
-        image = resize_image(image, max_size=768)
-        gen = torch.Generator(device=device).manual_seed(int(seed))
-        
-        with torch.inference_mode():
-            result = pipe(
-                instruction,
-                image=image,
-                num_inference_steps=int(steps),
-                guidance_scale=float(scale),
-                image_guidance_scale=float(image_scale),
-                generator=gen
-            ).images[0]
-        
-        if device.type == "cuda":
-            torch.cuda.empty_cache()
-        
-        return result
-        
-    except Exception as e:
-        print(f"❌ Error in pix2pix_edit: {e}")
-        if image:
-            error_img = Image.new('RGB', image.size, color='red')
-        else:
-            error_img = Image.new('RGB', (512, 512), color='red')
-        return error_img
-
-def flux_img2img(image, prompt, seed, steps, scale, strength):
-    """Image-to-image generation using FLUX.1-Kontext"""
-    try:
-        pipe = load_flux_model()
-        print(f"🌀 Using FLUX model: {CURRENT_FLUX_MODEL}")
-        
-        # Resize image to optimal size for FLUX (FLUX ทำงานที่ดีที่สุดที่ 1024x1024)
-        image = resize_image(image, max_size=1024)
-        
-        gen = torch.Generator(device=device).manual_seed(int(seed))
-        
-        with torch.inference_mode():
-            # สำหรับ FLUX Pipeline เราต้องตรวจสอบประเภทของ pipeline
-            if isinstance(pipe, FluxImg2ImgPipeline) or hasattr(pipe, '__class__') and 'Img2Img' in pipe.__class__.__name__:
-                # สำหรับ image-to-image pipeline
-                result = pipe(
-                    prompt=prompt,
-                    image=image,
-                    strength=float(strength),
-                    num_inference_steps=int(steps),
-                    guidance_scale=float(scale),
-                    generator=gen
-                ).images[0]
-            else:
-                # สำหรับ text-to-image pipeline (ใช้เป็น img2img ด้วย image prompt)
-                # FLUX สามารถใช้ image เป็น conditioning ได้
-                result = pipe(
-                    prompt=prompt,
-                    image=image,
-                    num_inference_steps=int(steps),
-                    guidance_scale=float(scale),
-                    generator=gen
-                ).images[0]
-        
-        if device.type == "cuda":
-            torch.cuda.empty_cache()
-        
-        return result
-        
-    except Exception as e:
-        print(f"❌ Error in flux_img2img: {e}")
-        if image:
-            error_img = Image.new('RGB', image.size, color='red')
-        else:
-            error_img = Image.new('RGB', (1024, 1024), color='red')
-        return error_img
-
 # ===== Function to unload all models =====
 def unload_all_models():
     global CURRENT_CONTROLNET_PIPE, CURRENT_CONTROLNET_KEY
     global LINEART_DETECTOR, LINEART_ANIME_DETECTOR
     global CURRENT_T2I_PIPE, CURRENT_T2I_MODEL
-    global CURRENT_PIX2PIX_PIPE, CURRENT_PIX2PIX_MODEL
-    global CURRENT_FLUX_PIPE, CURRENT_FLUX_MODEL
     
     print("Unloading all models from memory...")
     
@@ -779,24 +432,6 @@ def unload_all_models():
         pass
     CURRENT_T2I_MODEL = None
     
-    # Unload Pix2Pix model
-    try:
-        if CURRENT_PIX2PIX_PIPE is not None:
-            del CURRENT_PIX2PIX_PIPE
-            CURRENT_PIX2PIX_PIPE = None
-    except:
-        pass
-    CURRENT_PIX2PIX_MODEL = None
-    
-    # Unload FLUX model
-    try:
-        if CURRENT_FLUX_PIPE is not None:
-            del CURRENT_FLUX_PIPE
-            CURRENT_FLUX_PIPE = None
-    except:
-        pass
-    CURRENT_FLUX_MODEL = None
-    
     # Force garbage collection
     gc.collect()
     if torch.cuda.is_available():
@@ -810,7 +445,7 @@ def unload_all_models():
 # ===== Gradio UI =====
 with gr.Blocks(title="🎨 Advanced Image Generation Suite", theme=gr.themes.Soft()) as demo:
     gr.Markdown("# 🎨 Advanced Image Generation & Editing Suite")
-    gr.Markdown("### Powered by Stable Diffusion, ControlNet, Instruct-Pix2Pix & FLUX")
+    gr.Markdown("### Powered by Stable Diffusion & ControlNet")
     
     # Add system info
     if torch.cuda.is_available():
@@ -845,7 +480,9 @@ with gr.Blocks(title="🎨 Advanced Image Generation Suite", theme=gr.themes.Sof
                     "digiplay/ChikMix_V3",
                     "digiplay/chilloutmix_NiPrunedFp16Fix",
                     "gsdf/Counterfeit-V2.5",
-                    "stablediffusionapi/anything-v5"
+                    "stablediffusionapi/anything-v5",
+                    "digiplay/CleanLinearMix_nsfw",
+                    "Laxhar/noobai-XL-1.1"  # เพิ่มโมเดลใหม่
                 ],
                 value="digiplay/ChikMix_V3",
                 label="Base Model"
@@ -892,7 +529,9 @@ with gr.Blocks(title="🎨 Advanced Image Generation Suite", theme=gr.themes.Sof
                     "digiplay/ChikMix_V3",
                     "digiplay/chilloutmix_NiPrunedFp16Fix",
                     "gsdf/Counterfeit-V2.5",
-                    "stablediffusionapi/anything-v5"
+                    "stablediffusionapi/anything-v5",
+                    "digiplay/CleanLinearMix_nsfw",
+                    "Laxhar/noobai-XL-1.1"  # เพิ่มโมเดลใหม่
                 ],
                 value="digiplay/ChikMix_V3",
                 label="Model"
@@ -913,115 +552,6 @@ with gr.Blocks(title="🎨 Advanced Image Generation Suite", theme=gr.themes.Sof
             [t2i_prompt, t2i_model, t2i_seed, t2i_steps, t2i_scale, w, h], 
             t2i_out
         )
-    
-    with gr.Tab("🔄 Instruct-Pix2Pix"):
-        gr.Markdown("""
-        ### Edit Images with Text Instructions
-        Upload an image and describe how you want to change it.
-        Examples: 'make it winter', 'turn day into night', 'add sunglasses', 'make it look like a painting'
-        """)
-        
-        with gr.Row():
-            with gr.Column():
-                pix2pix_input = gr.Image(label="Input Image", type="pil")
-                pix2pix_instruction = gr.Textbox(
-                    label="Edit Instruction",
-                    placeholder="e.g., make it winter, turn day into night, add sunglasses...",
-                    lines=2
-                )
-                
-                with gr.Row():
-                    pix2pix_seed = gr.Number(value=42, label="Seed")
-                    pix2pix_steps = gr.Slider(10, 100, 50, step=5, label="Steps")
-                
-                with gr.Row():
-                    pix2pix_scale = gr.Slider(1, 20, 7.5, step=0.5, label="Text Guidance Scale")
-                    pix2pix_image_scale = gr.Slider(1, 5, 1.5, step=0.1, label="Image Guidance Scale")
-                
-                pix2pix_btn = gr.Button("🔄 Edit Image", variant="primary")
-            
-            with gr.Column():
-                pix2pix_output = gr.Image(label="Edited Image", type="pil")
-        
-        with gr.Row():
-            gr.Examples(
-                examples=[
-                    ["make it winter", 42, 50, 7.5, 1.5],
-                    ["turn day into night", 42, 50, 7.5, 1.5],
-                    ["make it look like a painting", 42, 50, 7.5, 1.5],
-                    ["add sunglasses", 42, 50, 7.5, 1.5],
-                    ["make it cyberpunk style", 42, 50, 7.5, 1.5],
-                    ["change hair color to blue", 42, 50, 7.5, 1.5],
-                ],
-                inputs=[pix2pix_instruction, pix2pix_seed, pix2pix_steps, pix2pix_scale, pix2pix_image_scale],
-                label="Quick Examples"
-            )
-        
-        pix2pix_btn.click(
-            pix2pix_edit,
-            [pix2pix_input, pix2pix_instruction, pix2pix_seed, pix2pix_steps, pix2pix_scale, pix2pix_image_scale],
-            pix2pix_output
-        )
-
-    with gr.Tab("🌀 FLUX Image-to-Image"):
-        gr.Markdown("""
-        ### Image-to-Image with FLUX.1-Kontext
-        **Model:** `kpsss34/FLUX.1-Kontext-dev-int4`
-        
-        Transform your images using FLUX, a powerful image-to-image model.
-        Upload an image and provide a prompt to guide the transformation.
-        
-        **Note:** FLUX 1.0 uses a different architecture than Stable Diffusion and may require more memory.
-        The int4 quantized version is used to reduce memory usage.
-        
-        **Tips:**
-        - Use **strength** to control how much the input image is preserved (lower = more original, higher = more creative)
-        - FLUX works best with high-resolution images (1024x1024 recommended)
-        - The model is quantized (int4) for better performance and lower memory usage
-        """)
-        
-        with gr.Row():
-            with gr.Column():
-                flux_input = gr.Image(label="Input Image", type="pil")
-                flux_prompt = gr.Textbox(
-                    label="Prompt",
-                    placeholder="e.g., a beautiful anime character, cyberpunk style, cinematic lighting...",
-                    lines=3
-                )
-                
-                with gr.Row():
-                    flux_seed = gr.Number(value=42, label="Seed")
-                    flux_steps = gr.Slider(10, 100, 50, step=5, label="Steps")
-                
-                with gr.Row():
-                    flux_scale = gr.Slider(1, 20, 7.5, step=0.5, label="CFG Scale")
-                    flux_strength = gr.Slider(0.1, 1.0, 0.75, step=0.05, 
-                                            label="Strength (higher = more creative, lower = more original)")
-                
-                flux_btn = gr.Button("🌀 Transform with FLUX", variant="primary")
-            
-            with gr.Column():
-                flux_output = gr.Image(label="Transformed Image", type="pil")
-        
-        with gr.Row():
-            gr.Examples(
-                examples=[
-                    ["turn into anime style", 42, 50, 7.5, 0.75],
-                    ["make it look like a painting", 42, 50, 7.5, 0.8],
-                    ["cyberpunk transformation", 42, 50, 7.5, 0.7],
-                    ["fantasy style with magic effects", 42, 50, 7.5, 0.85],
-                    ["realistic photo style", 42, 50, 7.5, 0.6],
-                    ["studio Ghibli art style", 42, 50, 7.5, 0.9],
-                ],
-                inputs=[flux_prompt, flux_seed, flux_steps, flux_scale, flux_strength],
-                label="Quick Examples"
-            )
-        
-        flux_btn.click(
-            flux_img2img,
-            [flux_input, flux_prompt, flux_seed, flux_steps, flux_scale, flux_strength],
-            flux_output
-        )
 
 try:
     demo.launch(