Upload 3 files

README.md

@@ -1,40 +1,44 @@
 ---
----
 title: Pixazo Image Generator
 emoji: 🎨
 colorFrom: purple
 colorTo: pink
 sdk: gradio
-sdk_version: 4.0.0
+sdk_version: 4.12.0
 app_file: app.py
-pinned: true
+pinned: false
+license: mit
 ---
 
-# Pixazo Image Generator
+# 🎨 Pixazo Image Generator
 
-Generate AI images using Pixazo's FLUX-1 Schnell model.
+Generate stunning AI images using Pixazo's FLUX-1 Schnell model.
 
-## Setup
+## ✨ Features
 
-1. Get your API key from [Pixazo](https://pixazo.ai)
-2. Add it to Hugging Face Space secrets:
-   - Go to Space Settings → Repository secrets
-   - Add new secret: **Key**: `PIXAZO_API_KEY`, **Value**: your key
-3. The app will automatically restart with the key loaded
+- 🖼️ Generate multiple images at once
+- 🎭 Various style presets
+- ⚡ Adjustable quality vs speed
+- 🔒 Secure API key handling
+- 📱 Responsive design
 
-## Features
+## 🔧 Setup
 
-- Generate multiple images at once
-- Adjustable image size and quality
-- Style presets for different art styles
-- Seed control for reproducible results
-- View raw API responses
+1. Get your API key from [Pixazo](https://pixazo.ai)
+2. Add it to Hugging Face Space secrets:
+   - Go to **Settings → Repository secrets**
+   - Add: `PIXAZO_API_KEY = your_key_here`
+3. The app will automatically restart
 
-## Usage Tips
+## 🚀 Usage Tips
 
-- Use descriptive prompts for best results
+- Be descriptive in your prompts
+- Start with 4 steps for quick testing
+- Use seeds for reproducible results
 - Try different style presets
-- Adjust guidance scale for prompt adherence
-- Use same seed for consistent results
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## 📞 API Response Format
+
+The Pixazo API returns:
+```json
+{"output": "https://image-url-here.png"}

app.py

@@ -5,12 +5,14 @@ import os
 from PIL import Image
 import io
 import time
+import base64
+from datetime import datetime
 
 # Get API key from Hugging Face secrets
 def get_api_key():
     return os.environ.get("PIXAZO_API_KEY")
 
-# Call Pixazo API - Now we know the exact response format!
+# Call Pixazo API
 def call_pixazo_api(prompt, num_steps=4, seed=None, height=512, width=512, 
                    style_preset=None, guidance_scale=None):
     
@@ -19,7 +21,8 @@ def call_pixazo_api(prompt, num_steps=4, seed=None, height=512, width=512,
     if not api_key:
         return None, {
             "error": "API key not configured",
-            "instructions": "Please set PIXAZO_API_KEY in Hugging Face Space secrets"
+            "instructions": "Please set PIXAZO_API_KEY in Hugging Face Space secrets",
+            "timestamp": datetime.now().isoformat()
         }
     
     url = "https://gateway.pixazo.ai/flux-1-schnell/v1/getData"
@@ -47,8 +50,6 @@ def call_pixazo_api(prompt, num_steps=4, seed=None, height=512, width=512,
     
     try:
         print(f"🌐 Sending request to Pixazo API...")
-        print(f"   Prompt: {prompt[:50]}...")
-        print(f"   Steps: {num_steps}, Size: {width}x{height}")
         
         response = requests.post(
             url, 
@@ -61,94 +62,103 @@ def call_pixazo_api(prompt, num_steps=4, seed=None, height=512, width=512,
         
         if response.status_code == 200:
             result = response.json()
-            print(f"📦 Response format: {list(result.keys())}")
             
-            # ✅ Now we know the exact format: {"output": "<IMAGE_URL>"}
             if "output" in result:
                 image_url = result["output"]
-                print(f"🖼️ Image URL received: {image_url[:80]}...")
                 
                 # Download the image from the URL
                 try:
                     print(f"⬇️ Downloading image from URL...")
-                    img_response = requests.get(image_url, timeout=30)
+                    img_response = requests.get(image_url, timeout=30, headers={
+                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+                    })
                     
                     if img_response.status_code == 200:
                         image = Image.open(io.BytesIO(img_response.content))
-                        print(f"✅ Image downloaded successfully: {image.size[0]}x{image.size[1]}")
                         
-                        return image, {
+                        # Convert to RGB if necessary
+                        if image.mode in ('RGBA', 'LA', 'P'):
+                            image = image.convert('RGB')
+                        
+                        # Create a simplified result
+                        simplified_result = {
                             "success": True,
                             "status_code": 200,
                             "image_url": image_url,
-                            "response_summary": {
-                                "keys": list(result.keys()),
-                                "url_length": len(image_url)
-                            }
+                            "image_size": f"{image.size[0]}x{image.size[1]}",
+                            "image_mode": image.mode,
+                            "timestamp": datetime.now().isoformat()
                         }
+                        
+                        # Add original response keys (excluding potentially large data)
+                        for key, value in result.items():
+                            if key != "output" and not isinstance(value, (str, int, float, bool, type(None))) or len(str(value)) > 1000:
+                                simplified_result[f"original_{key}"] = type(value).__name__
+                            else:
+                                simplified_result[f"original_{key}"] = value
+                        
+                        return image, simplified_result
                     else:
                         return None, {
                             "error": f"Failed to download image: HTTP {img_response.status_code}",
                             "image_url": image_url,
-                            "download_status": img_response.status_code
+                            "download_status": img_response.status_code,
+                            "timestamp": datetime.now().isoformat()
                         }
                         
                 except Exception as e:
                     return None, {
                         "error": f"Error downloading image: {str(e)}",
                         "image_url": image_url,
-                        "response": result
+                        "timestamp": datetime.now().isoformat()
                     }
             else:
                 return None, {
                     "error": "Response missing 'output' field",
-                    "response": result,
-                    "expected_format": '{"output": "IMAGE_URL"}'
+                    "response_keys": list(result.keys()),
+                    "timestamp": datetime.now().isoformat()
                 }
         else:
-            # Handle non-200 responses
             try:
                 error_data = response.json()
+                error_msg = error_data.get("error", str(error_data))
             except:
-                error_data = {"text": response.text[:500]}
+                error_msg = response.text[:200] if response.text else "No error message"
             
             return None, {
-                "error": f"API returned status {response.status_code}",
+                "error": f"API returned status {response.status_code}: {error_msg}",
                 "status_code": response.status_code,
-                "response": error_data
+                "timestamp": datetime.now().isoformat()
             }
             
     except requests.exceptions.Timeout:
         return None, {
             "error": "Request timed out after 120 seconds",
-            "suggestion": "Try reducing image size or number of steps"
+            "suggestion": "Try reducing image size or number of steps",
+            "timestamp": datetime.now().isoformat()
         }
     except requests.exceptions.RequestException as e:
         return None, {
-            "error": f"Network error: {str(e)}"
+            "error": f"Network error: {str(e)}",
+            "timestamp": datetime.now().isoformat()
         }
     except Exception as e:
         return None, {
-            "error": f"Unexpected error: {str(e)}"
+            "error": f"Unexpected error: {str(e)}",
+            "timestamp": datetime.now().isoformat()
         }
 
-# Batch generate images
+# Generate images with progress
 def generate_images(prompt, num_steps, seed, height, width, style_preset, 
-                   num_images, guidance_scale):
+                   num_images, guidance_scale, progress=gr.Progress()):
     
     images = []
     all_results = []
     
-    for i in range(num_images):
+    for i in progress.tqdm(range(num_images), desc="Generating images"):
         try:
-            # Use different seed for each image if seed is provided
             current_seed = seed + i if seed > 0 else 0
             
-            print(f"\n{'='*50}")
-            print(f"Generating image {i+1}/{num_images}")
-            print(f"Seed: {current_seed}")
-            print(f"{'='*50}")
-            
             image, result = call_pixazo_api(
                 prompt=prompt,
                 num_steps=num_steps,
@@ -161,182 +171,214 @@ def generate_images(prompt, num_steps, seed, height, width, style_preset,
             
             if image:
                 images.append(image)
-                print(f"✅ Image {i+1} generated successfully!")
+                progress((i + 1, num_images), desc=f"✅ Image {i+1}/{num_images} generated")
             else:
-                print(f"❌ Image {i+1} failed: {result.get('error', 'Unknown error')}")
+                progress((i + 1, num_images), desc=f"❌ Image {i+1}/{num_images} failed")
             
             all_results.append(result)
             
-            # Update progress
-            if image:
-                status_msg = f"✅ Generated {i+1}/{num_images} images"
-            else:
-                error_msg = result.get('error', 'Unknown error')
-                status_msg = f"❌ Image {i+1} failed: {error_msg[:50]}..."
-            
-            yield [gr.Gallery(value=images, visible=bool(images)), 
-                   status_msg, 
-                   json.dumps(result, indent=2)]
-            
             # Small delay between requests
             if i < num_images - 1:
-                time.sleep(2)
+                time.sleep(1)
                 
         except Exception as e:
-            error_result = {"error": str(e), "image_index": i}
+            error_result = {"error": str(e), "image_index": i, "timestamp": datetime.now().isoformat()}
             all_results.append(error_result)
-            yield [gr.Gallery(value=images, visible=bool(images)), 
-                   f"⚠️ Exception on image {i+1}: {str(e)[:50]}", 
-                   json.dumps(error_result, indent=2)]
+            progress((i + 1, num_images), desc=f"⚠️ Image {i+1}/{num_images} error")
             break
     
-    # Final summary
+    # Prepare final output
     success_count = len(images)
-    total_count = num_images
     
     if success_count == 0:
-        yield [gr.Gallery(visible=False), 
-               f"❌ No images generated ({success_count}/{total_count} successful)", 
-               json.dumps({
-                   "summary": "All generations failed",
-                   "total_attempts": total_count,
-                   "successful": success_count,
-                   "failed": total_count,
-                   "detailed_results": all_results
-               }, indent=2)]
-    elif success_count < total_count:
-        yield [gr.Gallery(value=images, visible=True), 
-               f"⚠️ Partial success: {success_count}/{total_count} images", 
-               json.dumps({
-                   "summary": "Partial success",
-                   "total_attempts": total_count,
-                   "successful": success_count,
-                   "failed": total_count - success_count,
-                   "detailed_results": all_results
-               }, indent=2)]
+        status = f"❌ No images generated ({success_count}/{num_images} successful)"
+        gallery_visible = False
+    elif success_count < num_images:
+        status = f"⚠️ Partial success: {success_count}/{num_images} images"
+        gallery_visible = True
     else:
-        yield [gr.Gallery(value=images, visible=True), 
-               f"🎉 Success! All {success_count} images generated", 
-               json.dumps({
-                   "summary": "Complete success",
-                   "total_attempts": total_count,
-                   "successful": success_count,
-                   "failed": 0,
-                   "sample_image_url": all_results[0].get("image_url", "N/A") if all_results else "N/A"
-               }, indent=2)]
+        status = f"🎉 Success! All {success_count} images generated"
+        gallery_visible = True
+    
+    summary = {
+        "total_attempts": num_images,
+        "successful": success_count,
+        "failed": num_images - success_count,
+        "timestamp": datetime.now().isoformat(),
+        "parameters": {
+            "prompt_length": len(prompt),
+            "steps": num_steps,
+            "size": f"{width}x{height}",
+            "style": style_preset,
+            "guidance": guidance_scale
+        }
+    }
+    
+    return (gr.update(value=images, visible=gallery_visible), 
+            status, 
+            summary)
 
-# Create Gradio interface
+# Create enhanced interface with latest Gradio features
 def create_interface():
-    with gr.Blocks(theme=gr.themes.Soft(), title="Pixazo Image Generator") as demo:
+    with gr.Blocks(
+        theme=gr.themes.Soft(
+            primary_hue="purple",
+            secondary_hue="pink"
+        ),
+        title="Pixazo AI Image Generator",
+        css="""
+        .success { color: #10b981; font-weight: bold; }
+        .error { color: #ef4444; font-weight: bold; }
+        .warning { color: #f59e0b; font-weight: bold; }
+        .info-box { 
+            background: #f8fafc; 
+            padding: 15px; 
+            border-radius: 10px; 
+            border-left: 4px solid #8b5cf6;
+        }
+        """
+    ) as demo:
+        
+        # Header
         gr.Markdown("""
-        # 🎨 Pixazo FLUX-1 Schnell Image Generator
-        *Now with correct response format handling!*
+        # 🎨 Pixazo AI Image Generator
         
-        **Response Format Confirmed:** `{"output": "IMAGE_URL"}`
+        Generate stunning images with FLUX-1 Schnell model
         """)
         
-        # API Status Check
+        # API Status
         api_key = get_api_key()
         if api_key:
-            gr.Markdown(f"### ✅ API Key: Configured ({len(api_key)} characters)")
+            status_html = """
+            <div class="info-box">
+                <h3>✅ API Status: Connected</h3>
+                <p>Your API key is configured and ready to use.</p>
+            </div>
+            """
         else:
-            gr.Markdown("### ❌ API Key: Not configured")
-            gr.Markdown("""
-            **Setup Required:**
-            1. Go to Space Settings → Repository secrets
-            2. Add secret: **Key**: `PIXAZO_API_KEY`, **Value**: your API key
-            3. The app will automatically reload
-            """)
+            status_html = """
+            <div style="background: #fef2f2; padding: 15px; border-radius: 10px; border-left: 4px solid #ef4444;">
+                <h3>❌ API Status: Not Configured</h3>
+                <p><strong>Setup Required:</strong></p>
+                <ol>
+                    <li>Go to Space Settings → Repository secrets</li>
+                    <li>Add secret: <code>PIXAZO_API_KEY</code> = your API key</li>
+                    <li>Click "Restart this Space" at the bottom of settings</li>
+                </ol>
+            </div>
+            """
+        
+        gr.HTML(status_html)
         
         with gr.Row():
-            with gr.Column(scale=2):
+            with gr.Column(scale=1, min_width=400):
                 # Input Section
                 with gr.Group():
                     prompt = gr.Textbox(
-                        label="Prompt",
+                        label="🎨 Prompt",
                         placeholder="Describe the image you want to generate...",
                         lines=3,
-                        value="A sleek futuristic car racing through a neon-lit cyberpunk city at night"
+                        max_lines=5,
+                        show_label=True,
+                        info="Be descriptive for better results"
                     )
                 
                 with gr.Row():
-                    style_preset = gr.Dropdown(
-                        label="Style Preset",
-                        choices=["none", "cyberpunk", "fantasy", "anime", "photographic", 
-                                "digital-art", "comic", "3d-model", "pixel-art", "isometric"],
-                        value="none"
-                    )
+                    with gr.Column():
+                        style_preset = gr.Dropdown(
+                            label="🎭 Style",
+                            choices=[
+                                "none", "cyberpunk", "fantasy", "anime", "photographic", 
+                                "digital-art", "comic", "3d-model", "pixel-art", "isometric",
+                                "minimalist", "watercolor", "oil-painting", "sketch"
+                            ],
+                            value="none",
+                            info="Optional style preset"
+                        )
                     
-                    guidance_scale = gr.Slider(
-                        label="Guidance Scale",
-                        minimum=1.0,
-                        maximum=20.0,
-                        value=7.5,
-                        step=0.5
-                    )
+                    with gr.Column():
+                        guidance_scale = gr.Slider(
+                            label="🎯 Guidance Scale",
+                            minimum=1.0,
+                            maximum=20.0,
+                            value=7.5,
+                            step=0.5,
+                            info="Higher = more prompt adherence"
+                        )
                 
                 with gr.Row():
-                    num_steps = gr.Slider(
-                        label="Number of Steps",
-                        minimum=1,
-                        maximum=50,
-                        value=4,
-                        step=1,
-                        info="Higher = better quality but slower"
-                    )
+                    with gr.Column():
+                        num_steps = gr.Slider(
+                            label="⚡ Steps",
+                            minimum=1,
+                            maximum=50,
+                            value=4,
+                            step=1,
+                            info="Quality vs speed trade-off"
+                        )
                     
-                    seed = gr.Number(
-                        label="Seed",
-                        value=42,
-                        info="0 = random, >0 = reproducible"
-                    )
+                    with gr.Column():
+                        seed = gr.Number(
+                            label="🌱 Seed",
+                            value=42,
+                            info="0 = random, same seed = same result"
+                        )
                 
                 with gr.Row():
-                    width = gr.Slider(
-                        label="Width",
-                        minimum=256,
-                        maximum=1024,
-                        value=512,
-                        step=64
-                    )
+                    with gr.Column():
+                        width = gr.Slider(
+                            label="📏 Width",
+                            minimum=256,
+                            maximum=1024,
+                            value=512,
+                            step=64
+                        )
                     
-                    height = gr.Slider(
-                        label="Height",
-                        minimum=256,
-                        maximum=1024,
-                        value=512,
-                        step=64
-                    )
+                    with gr.Column():
+                        height = gr.Slider(
+                            label="📐 Height",
+                            minimum=256,
+                            maximum=1024,
+                            value=512,
+                            step=64
+                        )
                 
                 num_images = gr.Slider(
-                    label="Number of Images",
+                    label="🖼️ Number of Images",
                     minimum=1,
-                    maximum=4,
+                    maximum=8,
                     value=1,
                     step=1,
                     info="Generate multiple variations"
                 )
                 
-                generate_btn = gr.Button("✨ Generate Images", variant="primary", size="lg")
+                with gr.Row():
+                    generate_btn = gr.Button("✨ Generate", variant="primary", scale=2)
+                    clear_btn = gr.Button("🗑️ Clear", variant="secondary")
                 
-                # Quick examples
-                gr.Examples(
-                    examples=[
-                        ["A cyberpunk cityscape with flying cars and neon signs, night time, rain", 4, 123, 512, 512, "cyberpunk", 1, 7.5],
-                        ["A magical forest with glowing mushrooms and fairies, soft lighting", 4, 456, 512, 512, "fantasy", 1, 7.5],
-                        ["A cute anime cat wearing a spacesuit on the moon", 4, 789, 512, 512, "anime", 1, 7.5],
-                        ["Photorealistic portrait of an elderly wise man with detailed wrinkles", 6, 999, 768, 512, "photographic", 1, 8.0],
-                    ],
-                    inputs=[prompt, num_steps, seed, height, width, style_preset, num_images, guidance_scale],
-                    label="Quick Examples"
-                )
+                # Examples
+                with gr.Accordion("📚 Example Prompts", open=False):
+                    examples = [
+                        ["A majestic dragon overlooking a fantasy kingdom at sunset, cinematic lighting", "fantasy"],
+                        ["Cyberpunk city street with neon signs and flying cars, rainy night", "cyberpunk"],
+                        ["Cute anime girl with magical powers in a cherry blossom garden", "anime"],
+                        ["Photorealistic portrait of an astronaut on Mars with detailed reflection in visor", "photographic"],
+                        ["Isometric view of a cozy cottage in a magical forest", "isometric"],
+                        ["Watercolor painting of a serene mountain lake at dawn", "watercolor"]
+                    ]
+                    
+                    for example_prompt, example_style in examples:
+                        with gr.Row():
+                            gr.Textbox(value=example_prompt, show_label=False, interactive=False)
+                            gr.Button("📋 Use", size="sm").click(
+                                fn=lambda p=example_prompt, s=example_style: [p, s],
+                                outputs=[prompt, style_preset]
+                            )
             
-            with gr.Column(scale=3):
+            with gr.Column(scale=2, min_width=600):
                 # Output Section
-                status = gr.Textbox(
-                    label="Status",
-                    interactive=False,
-                    value="Ready to generate..."
+                status_display = gr.HTML(
+                    value="<div class='info-box'><h3>Status: Ready</h3><p>Enter a prompt and click Generate</p></div>"
                 )
                 
                 gallery = gr.Gallery(
@@ -344,120 +386,147 @@ def create_interface():
                     show_label=True,
                     columns=2,
                     height="auto",
-                    visible=False,
-                    object_fit="contain"
+                    object_fit="cover",
+                    preview=True,
+                    visible=False
                 )
                 
-                # Response viewer
-                with gr.Accordion("📊 API Response Details", open=False):
-                    json_output = gr.JSON(
-                        label="API Response",
-                        container=True
-                    )
-                
-                # Debug info
-                with gr.Accordion("🔍 Debug Information", open=False):
-                    gr.Markdown("""
-                    **Known Response Format:** `{"output": "IMAGE_URL"}`
+                # Response and Info
+                with gr.Tabs():
+                    with gr.TabItem("📊 Generation Summary"):
+                        summary_json = gr.JSON(
+                            label="Summary",
+                            container=True
+                        )
                     
-                    **Flow:**
-                    1. Send request to Pixazo API with prompt and parameters
-                    2. Receive JSON with image URL in `output` field
-                    3. Download image from that URL
-                    4. Display image in gallery
+                    with gr.TabItem("🔧 Parameters"):
+                        param_display = gr.JSON(
+                            label="Current Parameters",
+                            value={},
+                            container=True
+                        )
                     
-                    **Troubleshooting:**
-                    - Check the JSON response for errors
-                    - If image fails to download, check the URL in the response
-                    - Make sure your API key is valid
-                    """)
+                    with gr.TabItem("ℹ️ About"):
+                        gr.Markdown("""
+                        ### About This App
+                        
+                        This app uses the **Pixazo FLUX-1 Schnell** AI image generation model.
+                        
+                        **API Response Format:**
+                        ```json
+                        {
+                          "output": "https://image-url-here.png"
+                        }
+                        ```
+                        
+                        **How it works:**
+                        1. Your prompt and settings are sent to Pixazo API
+                        2. API returns a JSON with an image URL
+                        3. App downloads and displays the image
+                        
+                        **Tips:**
+                        - Be descriptive in your prompts
+                        - Try different styles for varied results
+                        - Use seeds for reproducible results
+                        - Start with 4 steps for quick testing
+                        """)
         
-        # Generation function
-        generate_btn.click(
-            fn=generate_images,
-            inputs=[prompt, num_steps, seed, height, width, style_preset, num_images, guidance_scale],
-            outputs=[gallery, status, json_output]
-        )
+        # Event handlers
+        def update_param_display(prompt, num_steps, seed, height, width, style_preset, num_images, guidance_scale):
+            return {
+                "prompt": prompt[:100] + "..." if len(prompt) > 100 else prompt,
+                "prompt_length": len(prompt),
+                "steps": num_steps,
+                "seed": seed if seed > 0 else "random",
+                "resolution": f"{width}×{height}",
+                "style": style_preset,
+                "num_images": num_images,
+                "guidance_scale": guidance_scale,
+                "timestamp": datetime.now().strftime("%H:%M:%S")
+            }
         
-        # Quick test button
-        with gr.Row():
-            test_btn = gr.Button("🧪 Test Single Image", variant="secondary")
-            clear_btn = gr.Button("🗑️ Clear Results", variant="secondary")
+        # Update parameters on input change
+        inputs = [prompt, num_steps, seed, height, width, style_preset, num_images, guidance_scale]
+        for inp in inputs:
+            inp.change(
+                update_param_display,
+                inputs=inputs,
+                outputs=param_display
+            )
         
-        def test_single_image():
-            test_prompt = "A simple test image of a red apple on a table"
-            image, result = call_pixazo_api(
-                prompt=test_prompt,
-                num_steps=2,
-                height=256,
-                width=256
+        # Initialize param display
+        demo.load(
+            fn=lambda: update_param_display(*[i.value for i in inputs]),
+            outputs=param_display
+        )
+        
+        # Generate button click
+        def on_generate(prompt, num_steps, seed, height, width, style_preset, num_images, guidance_scale):
+            if not prompt.strip():
+                return (
+                    gr.update(visible=False),
+                    "<div class='error'><h3>❌ Error</h3><p>Please enter a prompt</p></div>",
+                    {"error": "No prompt provided"}
+                )
+            
+            gallery, status, summary = generate_images(
+                prompt, num_steps, seed, height, width, style_preset, num_images, guidance_scale
             )
             
-            if image:
-                return [gr.Gallery(value=[image], visible=True), 
-                       "✅ Test successful!", 
-                       json.dumps(result, indent=2)]
+            # Format status HTML
+            if "❌" in status:
+                status_html = f"<div class='error'><h3>{status}</h3></div>"
+            elif "⚠️" in status:
+                status_html = f"<div class='warning'><h3>{status}</h3></div>"
             else:
-                return [gr.Gallery(visible=False), 
-                       f"❌ Test failed: {result.get('error', 'Unknown')}", 
-                       json.dumps(result, indent=2)]
+                status_html = f"<div class='success'><h3>{status}</h3></div>"
+            
+            return gallery, status_html, summary
         
-        test_btn.click(
-            fn=test_single_image,
-            outputs=[gallery, status, json_output]
+        generate_btn.click(
+            fn=on_generate,
+            inputs=inputs,
+            outputs=[gallery, status_display, summary_json]
         )
         
+        # Clear button
         clear_btn.click(
-            fn=lambda: [None, "Ready to generate...", None],
-            outputs=[gallery, status, json_output]
+            fn=lambda: [
+                gr.update(visible=False),
+                "<div class='info-box'><h3>Status: Ready</h3><p>Enter a prompt and click Generate</p></div>",
+                {"status": "cleared"}
+            ],
+            outputs=[gallery, status_display, summary_json]
         )
-    
-    return demo
-
-# Simple interface for quick testing
-def create_simple_interface():
-    with gr.Blocks(title="Pixazo Simple") as demo:
-        gr.Markdown("# 🖼️ Pixazo Image Generator")
         
-        with gr.Row():
-            with gr.Column():
-                prompt = gr.Textbox(label="Prompt", value="A beautiful sunset")
-                btn = gr.Button("Generate", variant="primary")
-                
-            with gr.Column():
-                output = gr.Image(label="Generated Image")
-                info = gr.Textbox(label="Info")
-        
-        def simple_generate(prompt_text):
-            if not prompt_text.strip():
-                return None, "Please enter a prompt"
-            
-            api_key = get_api_key()
-            if not api_key:
-                return None, "API key not set"
-            
-            image, result = call_pixazo_api(
-                prompt=prompt_text,
-                num_steps=4,
-                height=512,
-                width=512
-            )
-            
-            if image:
-                return image, f"✅ Generated {image.size[0]}x{image.size[1]} image"
-            else:
-                return None, f"❌ Error: {result.get('error', 'Unknown')}"
-        
-        btn.click(simple_generate, inputs=[prompt], outputs=[output, info])
+        # Footer
+        gr.Markdown("""
+        ---
+        <div style="text-align: center; color: #666; font-size: 0.9em;">
+        <p>Built with Gradio • Powered by Pixazo FLUX-1 Schnell</p>
+        <p>API Response Format: <code>{"output": "IMAGE_URL"}</code></p>
+        </div>
+        """)
     
     return demo
 
+# Simple test function
+def test_connection():
+    api_key = get_api_key()
+    return {
+        "api_key_present": bool(api_key),
+        "api_key_length": len(api_key) if api_key else 0,
+        "timestamp": datetime.now().isoformat(),
+        "gradio_version": gr.__version__
+    }
+
 # Main function
 def main():
-    # Print startup info
-    print("🚀 Starting Pixazo Image Generator")
-    print(f"📌 API Key present: {'Yes' if get_api_key() else 'No'}")
-    print(f"📌 Expected response format: {{'output': 'IMAGE_URL'}}")
+    print("=" * 60)
+    print(f"🚀 Pixazo Image Generator")
+    print(f"📦 Gradio Version: {gr.__version__}")
+    print(f"🔑 API Key: {'✅ Present' if get_api_key() else '❌ Missing'}")
+    print("=" * 60)
     
     # Create and launch interface
     demo = create_interface()
@@ -465,7 +534,9 @@ def main():
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False
+        share=False,
+        show_error=True,
+        debug=False
     )
 
 if __name__ == "__main__":

requirements.txt

@@ -1,4 +1,3 @@
-gradio>=4.0
+gradio>=4.12.0
 pillow>=10.0.0
-requests>=2.31.0
-numpy>=1.24.0
+requests>=2.31.0