Update app.py from anycoder

app.py

@@ -1,446 +1,463 @@
 import gradio as gr
-import spaces
-import math
-import subprocess
-import sys
+import torch
 from PIL import Image
-import os
+from io import BytesIO
+import math
 
-# Try to import diffsynth_engine, provide helpful error if not installed
-try:
-    from diffsynth_engine import fetch_model, QwenImagePipeline, QwenImagePipelineConfig
-    DIFFSYNTH_AVAILABLE = True
-except ImportError:
-    DIFFSYNTH_AVAILABLE = False
-    # Fallback placeholders for type hints
-    class QwenImagePipelineConfig:
-        @staticmethod
-        def basic_config(**kwargs):
-            pass
-    
-    class QwenImagePipeline:
-        @staticmethod
-        def from_pretrained(config):
-            pass
+# ZeroGPU decorator pattern
+def get_zero_gpu_wrapper():
+    """Create ZeroGPU-compatible wrapper for the model"""
+    try:
+        from zero_gpu import ZeroGPU
+        return ZeroGPU
+    except ImportError:
+        return None
+
+def create_qwen_pipeline():
+    """
+    Create and configure the Qwen Image Pipeline.
+    This function loads the model only when needed to save memory.
+    """
+    try:
+        from diffsynth_engine import fetch_model, QwenImagePipeline, QwenImagePipelineConfig
         
-        def load_lora(self, **kwargs):
-            pass
+        # Create pipeline
+        config = QwenImagePipelineConfig.basic_config(
+            model_path=fetch_model("Qwen/Qwen-Image-2512", path="transformer/*.safetensors"),
+            encoder_path=fetch_model("Qwen/Qwen-Image-2512", path="text_encoder/*.safetensors"),
+            vae_path=fetch_model("Qwen/Qwen-Image-2512", path="vae/*.safetensors"),
+            offload_mode="cpu_offload",
+        )
+        pipe = QwenImagePipeline.from_pretrained(config)
         
-        def apply_scheduler_config(self, **kwargs):
-            pass
+        # Load turbo LoRA
+        pipe.load_lora(
+            path=fetch_model("Wuli-Art/Qwen-Image-2512-Turbo-LoRA", 
+                           path="Wuli-Qwen-Image-2512-Turbo-LoRA-4steps-V1.0-bf16.safetensors"),
+            scale=1.0,
+            fused=True,
+        )
+        
+        # Change scheduler config
+        scheduler_config = {
+            "exponential_shift_mu": math.log(2.5),
+            "use_dynamic_shifting": True,
+            "shift_terminal": None
+        }
+        pipe.apply_scheduler_config(scheduler_config)
         
-        def __call__(self, **kwargs):
-            pass
-
-def get_pipeline():
-    """Initialize and return the Qwen Image Pipeline."""
-    global pipe
-    if pipe is not None:
         return pipe
-    
-    if not DIFFSYNTH_AVAILABLE:
-        raise ImportError(
-            "diffsynth_engine is not installed. Please install it using:\n"
-            "pip install git+https://github.com/tencent-ailab/diffsynth-engine.git"
-        )
-    
-    # Create pipeline configuration
-    config = QwenImagePipelineConfig.basic_config(
-        model_path=fetch_model("Qwen/Qwen-Image-2512", path="transformer/*.safetensors"),
-        encoder_path=fetch_model("Qwen/Qwen-Image-2512", path="text_encoder/*.safetensors"),
-        vae_path=fetch_model("Qwen/Qwen-Image-2512", path="vae/*.safetensors"),
-        offload_mode="cpu_offload",
-    )
-    
-    # Create and return pipeline
-    pipe = QwenImagePipeline.from_pretrained(config)
-    
-    # Load the turbo LoRA
-    pipe.load_lora(
-        path=fetch_model("Wuli-Art/Qwen-Image-2512-Turbo-LoRA", path="Wuli-Qwen-Image-2512-Turbo-LoRA-4steps-V1.0-bf16.safetensors"),
-        scale=1.0,
-        fused=True,
-    )
-    
-    # Apply scheduler config for exponential shifting
-    scheduler_config = {
-        "exponential_shift_mu": math.log(2.5),
-        "use_dynamic_shifting": True,
-        "shift_terminal": None
-    }
-    pipe.apply_scheduler_config(scheduler_config)
-    
-    return pipe
+    except Exception as e:
+        print(f"Error creating pipeline: {e}")
+        return None
 
-# Global pipeline variable to avoid reloading
-pipe = None
 
-@spaces.GPU(duration=120, memory=40)
 def generate_image(
     prompt: str,
-    negative_prompt: str,
-    num_inference_steps: int,
-    seed: int,
-    width: int,
-    height: int,
-    cfg_scale: float
-):
+    negative_prompt: str = "",
+    cfg_scale: float = 1.0,
+    num_inference_steps: int = 4,
+    seed: int = 42,
+    width: int = 1328,
+    height: int = 1328
+) -> Image.Image:
     """
-    Generate an image using Qwen-Image-2512-Turbo with LoRA.
+    Generate an image using Qwen Image Pipeline.
     
     Args:
-        prompt: Text prompt describing the image to generate
-        negative_prompt: Text describing what to avoid in the image
-        num_inference_steps: Number of diffusion steps (4-8 recommended)
+        prompt: Text description of the image to generate
+        negative_prompt: Things to avoid in the image
+        cfg_scale: Classifier-free guidance scale
+        num_inference_steps: Number of denoising steps
         seed: Random seed for reproducibility
-        width: Image width (multiple of 16)
-        height: Image height (multiple of 16)
-        cfg_scale: Classifier-free guidance scale (1.0 for turbo models)
+        width: Image width
+        height: Image height
     
     Returns:
         Generated PIL Image
     """
-    # Check if diffsynth_engine is available
-    if not DIFFSYNTH_AVAILABLE:
-        raise gr.Error(
-            "diffsynth_engine is not installed. Please install it using:\n\n"
-            "pip install git+https://github.com/tencent-ailab/diffsynth-engine.git"
-        )
-    
-    # Validate inputs
-    if not prompt or len(prompt.strip()) == 0:
-        raise gr.Error("Please enter a prompt")
+    # Initialize pipeline
+    pipe = create_qwen_pipeline()
     
-    if num_inference_steps < 1 or num_inference_steps > 20:
-        raise gr.Error("Number of steps must be between 1 and 20")
+    if pipe is None:
+        # Return a placeholder image if pipeline fails
+        error_img = Image.new('RGB', (512, 512), color='red')
+        return error_img
     
-    if width < 64 or width > 2048 or height < 64 or height > 2048:
-        raise gr.Error("Width and height must be between 64 and 2048 pixels")
+    # Set random seed for reproducibility
+    if seed >= 0:
+        torch.manual_seed(seed)
+        if torch.cuda.is_available():
+            torch.cuda.manual_seed(seed)
     
-    # Get pipeline
-    pipeline = get_pipeline()
-    
-    # Generate image
-    output = pipeline(
-        prompt=prompt,
-        negative_prompt=negative_prompt if negative_prompt else None,
-        cfg_scale=cfg_scale,
-        num_inference_steps=num_inference_steps,
-        seed=seed,
-        width=width,
-        height=height
-    )
-    
-    # Save to temp file and return
-    output_path = "/tmp/output.png"
-    output.save(output_path)
-    
-    return output_path
+    try:
+        # Generate image
+        output = pipe(
+            prompt=prompt if prompt else "a beautiful landscape",
+            negative_prompt=negative_prompt if negative_prompt else None,
+            cfg_scale=cfg_scale,
+            num_inference_steps=num_inference_steps,
+            seed=seed,
+            width=width,
+            height=height
+        )
+        
+        # Ensure output is a PIL Image
+        if hasattr(output, 'save'):
+            return output
+        elif isinstance(output, (list, tuple)):
+            return output[0]
+        else:
+            # Convert tensor or array to PIL Image
+            import numpy as np
+            if hasattr(output, 'cpu'):
+                output = output.cpu()
+            if isinstance(output, torch.Tensor):
+                output = output.float()
+                if output.dim() == 4:
+                    output = output[0]
+                if output.dim() == 3:
+                    output = output.permute(1, 2, 0)
+                    # Handle different channel orders
+                    if output.shape[-1] == 1 or output.shape[-1] == 3:
+                        output = output.numpy()
+            
+            if isinstance(output, np.ndarray):
+                if output.dtype != np.uint8:
+                    output = (np.clip(output, 0, 1) * 255).astype(np.uint8)
+                if output.ndim == 3 and output.shape[-1] == 1:
+                    output = output[:, :, 0]
+                if output.ndim == 3 and output.shape[-1] == 4:
+                    output = output[:, :, :3]  # Remove alpha channel
+                return Image.fromarray(output)
+            
+            return Image.fromarray(output)
+            
+    except Exception as e:
+        print(f"Error during generation: {e}")
+        # Return error image
+        error_img = Image.new('RGB', (512, 512), color='orange')
+        return error_img
 
-def update_seed():
-    """Generate a new random seed."""
-    import random
-    return random.randint(0, 2147483647)
 
-def clear_inputs():
-    """Clear all input fields."""
-    return "", "", 4, 42, 1328, 1328, 1.0
+def pil_to_bytes(img: Image.Image, format: str = 'PNG') -> bytes:
+    """Convert PIL Image to bytes"""
+    buffer = BytesIO()
+    img.save(buffer, format=format)
+    return buffer.getvalue()
 
-def check_dependencies():
-    """Check if all required dependencies are installed."""
-    if not DIFFSYNTH_AVAILABLE:
-        return False, (
-            "Missing: diffsynth_engine\n\n"
-            "Install with:\n"
-            "pip install git+https://github.com/tencent-ailab/diffsynth-engine.git"
-        )
-    return True, "All dependencies available"
 
-# Gradio 6 - NO parameters in gr.Blocks() constructor
-with gr.Blocks() as demo:
+# Create custom theme for AnyCoder
+custom_theme = gr.themes.Soft(
+    primary_hue="blue",
+    secondary_hue="indigo",
+    neutral_hue="slate",
+    font=gr.themes.GoogleFont("Inter"),
+    text_size="lg",
+    spacing_size="md",
+    radius_size="md"
+).set(
+    button_primary_background_fill="*primary_600",
+    button_primary_background_fill_hover="*primary_700",
+    block_title_text_weight="600",
+)
+
+
+# Build the Gradio Interface
+with gr.Blocks(
+    title="AnyCoder - Qwen Image Generator",
+    fill_height=True,
+    fill_width=True
+) as demo:
     # Header with branding
-    gr.HTML("""
-    <div style="text-align: center; padding: 10px 0;">
-        <h1 style="margin-bottom: 5px;">🎨 Qwen Image Generator Turbo</h1>
-        <p style="color: var(--body-text-color-secondary); margin-top: 0;">
-            Generate high-quality images with Qwen-Image-2512-Turbo & LoRA
-        </p>
-        <p style="font-size: 12px; margin-top: 10px;">
-            <a href="https://huggingface.co/spaces/akhaliq/anycoder" target="_blank" style="color: var(--link-text-color);">
-                Built with anycoder
-            </a>
-        </p>
-    </div>
-    """)
-    
-    # Dependency check status
-    dep_status = gr.Textbox(
-        label="Dependency Status",
-        interactive=False,
-        visible=True
-    )
-    
-    # Update dependency status on load
-    def update_dep_status():
-        available, message = check_dependencies()
-        if available:
-            return {"value": "✅ All dependencies are available", "visible": True}
-        else:
-            return {"value": f"❌ {message}", "visible": True}
-    
-    demo.load(update_dep_status, outputs=dep_status)
-    
     with gr.Row():
-        # Left column - Input controls
+        gr.Markdown(
+            """
+            <div style="text-align: center; padding: 10px;">
+                <h1 style="margin: 0; color: #4F46E5;">🎨 AnyCoder</h1>
+                <p style="margin: 5px 0; color: #6B7280;">Qwen Image Generator by Choquinlabs</p>
+                <p style="margin: 0; font-size: 12px; color: #9CA3AF;">
+                    <a href="https://huggingface.co/spaces/akhaliq/anycoder" target="_blank" style="color: #6366F1;">Built with anycoder</a>
+                </p>
+            </div>
+            """
+        )
+    
+    # Main content area
+    with gr.Row(equal_height=True):
+        # Left panel - Controls
         with gr.Column(scale=1, min_width=350):
-            gr.Markdown("### 📝 Prompt")
-            prompt = gr.Textbox(
+            gr.Markdown("### ⚙️ Generation Settings")
+            
+            # Prompt input
+            prompt_input = gr.Textbox(
                 label="Prompt",
-                placeholder="Describe your image in detail...",
+                placeholder="Describe your image...",
                 lines=4,
-                info="Be descriptive for best results",
+                info="Be descriptive and specific",
                 interactive=True
             )
             
+            # Negative prompt
             negative_prompt = gr.Textbox(
-                label="Negative Prompt",
-                placeholder="What to avoid (e.g., blurry, low quality, distorted)",
+                label="Negative Prompt (Optional)",
+                placeholder="Things to avoid...",
                 lines=2,
-                info="Optional - helps avoid unwanted elements",
+                info="Common: low quality, blurry, distorted",
                 interactive=True
             )
             
-            with gr.Accordion("⚙️ Advanced Settings", open=True):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        num_inference_steps = gr.Slider(
-                            label="Inference Steps",
-                            minimum=1,
-                            maximum=20,
-                            value=4,
-                            step=1,
-                            info="4-8 steps recommended for turbo model"
-                        )
-                    
-                    with gr.Column(scale=1):
-                        cfg_scale = gr.Slider(
-                            label="CFG Scale",
-                            minimum=0.5,
-                            maximum=2.0,
-                            value=1.0,
-                            step=0.1,
-                            info="1.0 is optimal for turbo models"
-                        )
-                
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        seed = gr.Number(
-                            label="Seed",
-                            value=42,
-                            minimum=0,
-                            maximum=2147483647,
-                            info="Use same seed for reproducible results"
-                        )
-                    
-                    with gr.Column(scale=1):
-                        gr.Button(
-                            "🎲 Random Seed",
-                            size="sm",
-                            variant="secondary"
-                        ).click(
-                            fn=update_seed,
-                            outputs=seed,
-                            api_visibility="private"
-                        )
+            with gr.Row():
+                # Width
+                width_input = gr.Slider(
+                    label="Width",
+                    minimum=512,
+                    maximum=2048,
+                    value=1328,
+                    step=64,
+                    interactive=True
+                )
                 
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        width = gr.Slider(
-                            label="Width",
-                            minimum=256,
-                            maximum=2048,
-                            value=1328,
-                            step=16,
-                            info="Must be multiple of 16"
-                        )
-                    
-                    with gr.Column(scale=1):
-                        height = gr.Slider(
-                            label="Height",
-                            minimum=256,
-                            maximum=2048,
-                            value=1328,
-                            step=16,
-                            info="Must be multiple of 16"
-                        )
+                # Height
+                height_input = gr.Slider(
+                    label="Height", 
+                    minimum=512,
+                    maximum=2048,
+                    value=1328,
+                    step=64,
+                    interactive=True
+                )
             
             with gr.Row():
-                generate_btn = gr.Button(
-                    "✨ Generate Image",
-                    variant="primary",
-                    size="lg",
-                    scale=2
+                # Steps
+                steps_input = gr.Slider(
+                    label="Steps",
+                    minimum=1,
+                    maximum=8,
+                    value=4,
+                    step=1,
+                    info="4 steps = fast, 8 steps = better quality",
+                    interactive=True
                 )
-                clear_btn = gr.Button(
-                    "🗑️ Clear",
-                    variant="stop",
-                    size="lg",
-                    scale=1
+                
+                # CFG Scale
+                cfg_input = gr.Slider(
+                    label="CFG Scale",
+                    minimum=0.5,
+                    maximum=2.0,
+                    value=1.0,
+                    step=0.1,
+                    info="Lower = more creative, Higher = closer to prompt",
+                    interactive=True
                 )
             
-            # Tips section
-            with gr.Accordion("💡 Tips for Best Results", open=False):
-                gr.Markdown("""
-                - **Be descriptive**: Include details about subjects, style, lighting, and mood
-                - **Recommended steps**: 4 steps for speed, 8 steps for higher quality
-                - **Optimal resolution**: 1328x1328 for this model
-                - **LoRA style**: This model is tuned for portrait/character images
-                """)
+            with gr.Row():
+                # Seed
+                seed_input = gr.Number(
+                    label="Seed",
+                    value=42,
+                    step=1,
+                    minimum=-1,
+                    info="-1 for random",
+                    interactive=True
+                )
+            
+            # Generate button
+            generate_btn = gr.Button(
+                value="✨ Generate Image",
+                variant="primary",
+                size="lg",
+                interactive=True
+            )
+            
+            # Clear button
+            clear_btn = gr.Button(
+                value="🗑️ Clear",
+                variant="secondary",
+                size="md",
+                interactive=True
+            )
         
-        # Right column - Output
-        with gr.Column(scale=1, min_width=400):
+        # Right panel - Output
+        with gr.Column(scale=1.5):
             gr.Markdown("### 🖼️ Generated Image")
             
-            result_image = gr.Image(
-                label="Result",
-                type="filepath",
+            # Image output component (not file-based)
+            image_output = gr.Image(
+                label="Your Image",
+                type="pil",
                 interactive=False,
-                height=500
+                height=512,
+                elem_id="output_image",
+                show_download_button=True,
+                show_share_button=True
             )
             
-            # Download button
-            download_btn = gr.DownloadButton(
-                value=None,
-                label="⬇️ Download Image",
-                variant="secondary",
-                interactive=False
+            # Status message
+            status_msg = gr.Markdown(
+                value="Ready to generate! Enter a prompt and click the button above.",
+                elem_classes=["status-message"]
             )
+    
+    # Examples section
+    with gr.Accordion("📝 Example Prompts", open=False):
+        gr.Markdown("""
+        ### Try these prompts:
+        
+        1. **Portrait**: "a young girl with flowing long hair, wearing a white halter dress and smiling sweetly. The background features a blue seaside where seagulls fly freely."
+        
+        2. **Landscape**: "majestic mountain range at sunset, golden light illuminating snow-capped peaks, pine forests in the foreground, crystal clear lake reflecting the sky"
+        
+        3. **Fantasy**: "enchanted forest with glowing mushrooms, fireflies dancing around ancient trees, magical atmosphere, ethereal lighting"
+        
+        4. **Architecture**: "modern glass skyscraper at night, city lights reflecting off the surface, sleek and futuristic design"
+        """)
+        
+        # Example buttons
+        with gr.Row():
+            example_btns = []
+            examples = [
+                ("👩 Portrait", "a young girl with flowing long hair, wearing a white halter dress and smiling sweetly. The background features a blue seaside where seagulls fly freely."),
+                ("🏔️ Landscape", "majestic mountain range at sunset, golden light illuminating snow-capped peaks, pine forests in the foreground, crystal clear lake reflecting the sky"),
+                ("🏰 Fantasy", "enchanted forest with glowing mushrooms, fireflies dancing around ancient trees, magical atmosphere, ethereal lighting"),
+                ("🏙️ Architecture", "modern glass skyscraper at night, city lights reflecting off the surface, sleek and futuristic design"),
+            ]
             
-            # Generation info
-            generation_info = gr.Textbox(
-                label="Generation Info",
-                interactive=False,
-                visible=False
+            for label, prompt in examples:
+                btn = gr.Button(label, variant="secondary", size="sm")
+                example_btns.append((btn, prompt))
+    
+    # User info and logout
+    with gr.Row():
+        gr.Markdown(
+            """
+            <div style="display: flex; justify-content: space-between; align-items: center; padding: 10px 0;">
+                <span style="color: #6B7280;">Logged in as: <strong>lichorosario</strong></span>
+                <a href="#" style="color: #EF4444; text-decoration: none;">Logout</a>
+            </div>
+            """
+        )
+    
+    # CSS styling
+    demo.load(
+        None,
+        None,
+        None,
+        js="""
+        () => {
+            const style = document.createElement('style');
+            style.textContent = `
+                .gradio-container {
+                    max-width: 1400px !important;
+                    margin: 0 auto;
+                }
+                .status-message {
+                    text-align: center;
+                    padding: 10px;
+                    background-color: #F3F4F6;
+                    border-radius: 8px;
+                    color: #374151;
+                }
+                #output_image {
+                    border: 2px solid #E5E7EB;
+                    border-radius: 12px;
+                }
+                h1 {
+                    font-weight: 700;
+                }
+                h3 {
+                    font-weight: 600;
+                    color: #374151;
+                }
+                .gr-button.primary {
+                    background: linear-gradient(135deg, #6366F1 0%, #4F46E5 100%) !important;
+                    border: none !important;
+                    font-weight: 600 !important;
+                }
+                .gr-button.primary:hover {
+                    background: linear-gradient(135deg, #4F46E5 0%, #4338CA 100%) !important;
+                }
+            `;
+            document.head.appendChild(style);
+        }
+        """
+    )
+    
+    # Event handlers
+    def generate_handler(prompt, negative_prompt, cfg_scale, steps, seed, width, height):
+        """Handle image generation"""
+        if not prompt or prompt.strip() == "":
+            return None, "⚠️ Please enter a prompt first!"
+        
+        # Update status
+        yield None, "⏳ Generating your image... This may take a moment..."
+        
+        try:
+            # Generate the image
+            img = generate_image(
+                prompt=prompt,
+                negative_prompt=negative_prompt if negative_prompt else None,
+                cfg_scale=cfg_scale,
+                num_inference_steps=steps,
+                seed=seed if seed >= 0 else None,
+                width=width,
+                height=height
             )
+            
+            yield img, "✅ Image generated successfully!"
+            
+        except Exception as e:
+            error_msg = f"❌ Error: {str(e)}"
+            yield None, error_msg
+    
+    def clear_handler():
+        """Clear all inputs and outputs"""
+        return None, "Ready to generate! Enter a prompt and click the button above."
     
-    # Set up event handlers
+    def set_prompt(prompt_text):
+        """Set the prompt from example button"""
+        return prompt_text, "Ready to generate!"
+    
+    # Connect events
     generate_btn.click(
-        fn=generate_image,
-        inputs=[
-            prompt,
-            negative_prompt,
-            num_inference_steps,
-            seed,
-            width,
-            height,
-            cfg_scale
-        ],
-        outputs=[result_image, download_btn],
-        api_visibility="public",
-        show_progress="full"
+        fn=generate_handler,
+        inputs=[prompt_input, negative_prompt, cfg_input, steps_input, seed_input, width_input, height_input],
+        outputs=[image_output, status_msg],
+        show_progress="full",
+        api_visibility="public"
     )
     
-    # Clear button handler
     clear_btn.click(
-        fn=clear_inputs,
-        outputs=[
-            prompt,
-            negative_prompt,
-            num_inference_steps,
-            seed,
-            width,
-            height,
-            cfg_scale
-        ],
+        fn=clear_handler,
+        inputs=None,
+        outputs=[image_output, status_msg],
         api_visibility="private"
     )
     
-    # Example prompts
-    gr.Markdown("---")
-    gr.Markdown("### 📋 Example Prompts")
-    
-    examples = gr.Examples(
-        examples=[
-            [
-                "a young girl with flowing long hair, wearing a white halter dress and smiling sweetly. The background features a blue seaside where seagulls fly freely.",
-                "",
-                4,
-                42,
-                1328,
-                1328,
-                1.0
-            ],
-            [
-                "portrait of a beautiful woman with golden hour lighting, soft natural glow, elegant makeup, cinematic style, professional photography",
-                "blurry, low quality, distorted, deformed",
-                4,
-                12345,
-                1328,
-                1328,
-                1.0
-            ],
-            [
-                "an astronaut riding a horse on mars, dramatic red landscape, futuristic space suit, cinematic composition, detailed",
-                "",
-                8,
-                99999,
-                1328,
-                1328,
-                1.0
-            ],
-            [
-                "close-up portrait of a cute cat with big expressive eyes, soft fur, pastel colors, dreamy atmosphere, artistic style",
-                "blurry, noise, artifacts",
-                4,
-                54321,
-                1024,
-                1024,
-                1.0
-            ]
-        ],
-        inputs=[
-            prompt,
-            negative_prompt,
-            num_inference_steps,
-            seed,
-            width,
-            height,
-            cfg_scale
-        ],
-        fn=generate_image,
-        outputs=[result_image, download_btn],
-        cache_examples=True,
-        api_visibility="private"
-    )
+    # Example button handlers
+    for btn, prompt in example_btns:
+        btn.click(
+            fn=set_prompt,
+            inputs=gr.Textbox(value=prompt, visible=False),
+            outputs=[prompt_input, status_msg],
+            api_visibility="private"
+        )
 
-# Gradio 6 - ALL app parameters go in launch()
-demo.launch(
-    theme=gr.themes.Soft(
-        primary_hue="indigo",
-        secondary_hue="purple",
-        neutral_hue="slate",
-        font=gr.themes.GoogleFont("Inter"),
-        text_size="lg",
-        spacing_size="md",
-        radius_size="md"
-    ).set(
-        button_primary_background_fill="*primary_600",
-        button_primary_background_fill_hover="*primary_700",
-        block_title_text_weight="600",
-        body_text_weight="400"
-    ),
-    footer_links=[
-        {"label": "Built with anycoder", "url": "https://huggingface.co/spaces/akhaliq/anycoder"},
-        {"label": "Model Card", "url": "https://huggingface.co/Wuli-Art/Qwen-Image-2512-Turbo-LoRA"},
-        {"label": "diffsynth-engine", "url": "https://github.com/tencent-ailab/diffsynth-engine"}
-    ],
-    css="""
-    .gradio-container {
-        max-width: 1400px !important;
-        margin: 0 auto;
-    }
-    .primary-hue-indigo {
-        --primary-hue: 250deg;
-    }
-    """
-)
+# Launch the application
+if __name__ == "__main__":
+    demo.launch(
+        theme=custom_theme,
+        inline=True,
+        inbrowser=False,
+        show_error=True,
+        quiet=False,
+        css="""
+        .gradio-container {
+            max-width: 1400px !important;
+        }
+        """,
+        footer_links=[
+            {"label": "AnyCoder", "url": "https://huggingface.co/spaces/akhaliq/anycoder"},
+            {"label": "Choquinlabs", "url": "https://huggingface.co/choquinlabs"}
+        ]
+    )