Upload 2 files

app.py

@@ -80,28 +80,17 @@ def call_pixazo_api(prompt, num_steps=4, seed=None, height=512, width=512,
                         if image.mode in ('RGBA', 'LA', 'P'):
                             image = image.convert('RGB')
                         
-                        # Create a simplified result
-                        simplified_result = {
+                        return image, {
                             "success": True,
                             "status_code": 200,
-                            "image_url": image_url,
+                            "image_url": image_url[:100] + "..." if len(image_url) > 100 else 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,
+                            "image_url": image_url[:100] + "..." if len(image_url) > 100 else image_url,
                             "download_status": img_response.status_code,
                             "timestamp": datetime.now().isoformat()
                         }
@@ -109,7 +98,7 @@ def call_pixazo_api(prompt, num_steps=4, seed=None, height=512, width=512,
                 except Exception as e:
                     return None, {
                         "error": f"Error downloading image: {str(e)}",
-                        "image_url": image_url,
+                        "image_url": image_url[:100] + "..." if len(image_url) > 100 else image_url,
                         "timestamp": datetime.now().isoformat()
                     }
             else:
@@ -148,14 +137,14 @@ def call_pixazo_api(prompt, num_steps=4, seed=None, height=512, width=512,
             "timestamp": datetime.now().isoformat()
         }
 
-# Generate images with progress
+# Generate images
 def generate_images(prompt, num_steps, seed, height, width, style_preset, 
-                   num_images, guidance_scale, progress=gr.Progress()):
+                   num_images, guidance_scale):
     
     images = []
     all_results = []
     
-    for i in progress.tqdm(range(num_images), desc="Generating images"):
+    for i in range(num_images):
         try:
             current_seed = seed + i if seed > 0 else 0
             
@@ -171,12 +160,16 @@ def generate_images(prompt, num_steps, seed, height, width, style_preset,
             
             if image:
                 images.append(image)
-                progress((i + 1, num_images), desc=f"✅ Image {i+1}/{num_images} generated")
-            else:
-                progress((i + 1, num_images), desc=f"❌ Image {i+1}/{num_images} failed")
             
             all_results.append(result)
             
+            # Update status
+            yield [
+                images if images else None,
+                f"Progress: {i+1}/{num_images} images",
+                json.dumps(result, indent=2)
+            ]
+            
             # Small delay between requests
             if i < num_images - 1:
                 time.sleep(1)
@@ -184,7 +177,11 @@ def generate_images(prompt, num_steps, seed, height, width, style_preset,
         except Exception as e:
             error_result = {"error": str(e), "image_index": i, "timestamp": datetime.now().isoformat()}
             all_results.append(error_result)
-            progress((i + 1, num_images), desc=f"⚠️ Image {i+1}/{num_images} error")
+            yield [
+                images if images else None,
+                f"Error on image {i+1}: {str(e)[:50]}",
+                json.dumps(error_result, indent=2)
+            ]
             break
     
     # Prepare final output
@@ -192,13 +189,13 @@ def generate_images(prompt, num_steps, seed, height, width, style_preset,
     
     if success_count == 0:
         status = f"❌ No images generated ({success_count}/{num_images} successful)"
-        gallery_visible = False
+        final_images = None
     elif success_count < num_images:
         status = f"⚠️ Partial success: {success_count}/{num_images} images"
-        gallery_visible = True
+        final_images = images
     else:
         status = f"🎉 Success! All {success_count} images generated"
-        gallery_visible = True
+        final_images = images
     
     summary = {
         "total_attempts": num_images,
@@ -214,330 +211,160 @@ def generate_images(prompt, num_steps, seed, height, width, style_preset,
         }
     }
     
-    return (gr.update(value=images, visible=gallery_visible), 
-            status, 
-            summary)
+    yield [final_images, status, json.dumps(summary, indent=2)]
 
-# Create enhanced interface with latest Gradio features
-def create_interface():
-    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
+# Create Gradio interface
+with gr.Blocks(
+    title="Pixazo Image Generator",
+    theme=gr.themes.Soft()
+) as demo:
+    
+    # Header
+    gr.Markdown("""
+    # 🎨 Pixazo Image Generator
+    
+    Generate images using Pixazo's FLUX-1 Schnell AI model
+    """)
+    
+    # API Status
+    api_key = get_api_key()
+    if api_key:
+        gr.Markdown("### ✅ API Key: Configured")
+    else:
         gr.Markdown("""
-        # 🎨 Pixazo AI Image Generator
+        ### ❌ API Key: Not Configured
         
-        Generate stunning images with FLUX-1 Schnell model
+        **To set up:**
+        1. Go to Space Settings → Repository secrets
+        2. Add: `PIXAZO_API_KEY` = your API key
+        3. Click "Restart this Space"
         """)
-        
-        # API Status
-        api_key = get_api_key()
-        if api_key:
-            status_html = """
-            <div class="info-box">
-                <h3>✅ API Status: Connected</h3>
-                <p>Your API key is configured and ready to use.</p>
-            </div>
-            """
-        else:
-            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=1, min_width=400):
-                # Input Section
-                with gr.Group():
-                    prompt = gr.Textbox(
-                        label="🎨 Prompt",
-                        placeholder="Describe the image you want to generate...",
-                        lines=3,
-                        max_lines=5,
-                        show_label=True,
-                        info="Be descriptive for better results"
-                    )
-                
-                with gr.Row():
-                    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"
-                        )
-                    
-                    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():
-                    with gr.Column():
-                        num_steps = gr.Slider(
-                            label="⚡ Steps",
-                            minimum=1,
-                            maximum=50,
-                            value=4,
-                            step=1,
-                            info="Quality vs speed trade-off"
-                        )
-                    
-                    with gr.Column():
-                        seed = gr.Number(
-                            label="🌱 Seed",
-                            value=42,
-                            info="0 = random, same seed = same result"
-                        )
-                
-                with gr.Row():
-                    with gr.Column():
-                        width = gr.Slider(
-                            label="📏 Width",
-                            minimum=256,
-                            maximum=1024,
-                            value=512,
-                            step=64
-                        )
-                    
-                    with gr.Column():
-                        height = gr.Slider(
-                            label="📐 Height",
-                            minimum=256,
-                            maximum=1024,
-                            value=512,
-                            step=64
-                        )
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Input Section
+            with gr.Group():
+                prompt = gr.Textbox(
+                    label="Prompt",
+                    placeholder="Describe the image you want to generate...",
+                    lines=3,
+                    value="A beautiful sunset over mountains"
+                )
+            
+            with gr.Row():
+                style_preset = gr.Dropdown(
+                    label="Style Preset",
+                    choices=[
+                        "none", "cyberpunk", "fantasy", "anime", "photographic", 
+                        "digital-art", "comic", "3d-model", "pixel-art"
+                    ],
+                    value="none"
+                )
                 
-                num_images = gr.Slider(
-                    label="🖼️ Number of Images",
+                guidance_scale = gr.Slider(
+                    label="Guidance Scale",
+                    minimum=1.0,
+                    maximum=20.0,
+                    value=7.5,
+                    step=0.5
+                )
+            
+            with gr.Row():
+                num_steps = gr.Slider(
+                    label="Number of Steps",
                     minimum=1,
-                    maximum=8,
-                    value=1,
-                    step=1,
-                    info="Generate multiple variations"
+                    maximum=50,
+                    value=4,
+                    step=1
                 )
                 
-                with gr.Row():
-                    generate_btn = gr.Button("✨ Generate", variant="primary", scale=2)
-                    clear_btn = gr.Button("🗑️ Clear", variant="secondary")
-                
-                # 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]
-                            )
+                seed = gr.Number(
+                    label="Seed",
+                    value=42,
+                    minimum=0,
+                    maximum=999999
+                )
             
-            with gr.Column(scale=2, min_width=600):
-                # Output Section
-                status_display = gr.HTML(
-                    value="<div class='info-box'><h3>Status: Ready</h3><p>Enter a prompt and click Generate</p></div>"
+            with gr.Row():
+                width = gr.Slider(
+                    label="Width",
+                    minimum=256,
+                    maximum=1024,
+                    value=512,
+                    step=64
                 )
                 
-                gallery = gr.Gallery(
-                    label="Generated Images",
-                    show_label=True,
-                    columns=2,
-                    height="auto",
-                    object_fit="cover",
-                    preview=True,
-                    visible=False
-                )
-                
-                # Response and Info
-                with gr.Tabs():
-                    with gr.TabItem("📊 Generation Summary"):
-                        summary_json = gr.JSON(
-                            label="Summary",
-                            container=True
-                        )
-                    
-                    with gr.TabItem("🔧 Parameters"):
-                        param_display = gr.JSON(
-                            label="Current Parameters",
-                            value={},
-                            container=True
-                        )
-                    
-                    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
-                        """)
-        
-        # 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")
-            }
-        
-        # 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
-            )
-        
-        # 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"}
+                height = gr.Slider(
+                    label="Height",
+                    minimum=256,
+                    maximum=1024,
+                    value=512,
+                    step=64
                 )
             
-            gallery, status, summary = generate_images(
-                prompt, num_steps, seed, height, width, style_preset, num_images, guidance_scale
+            num_images = gr.Slider(
+                label="Number of Images",
+                minimum=1,
+                maximum=4,
+                value=1,
+                step=1
             )
             
-            # 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:
-                status_html = f"<div class='success'><h3>{status}</h3></div>"
+            generate_btn = gr.Button("Generate Images", variant="primary")
             
-            return gallery, status_html, summary
-        
-        generate_btn.click(
-            fn=on_generate,
-            inputs=inputs,
-            outputs=[gallery, status_display, summary_json]
-        )
-        
-        # Clear button
-        clear_btn.click(
-            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]
-        )
+            # Examples
+            gr.Examples(
+                examples=[
+                    ["A cyberpunk cityscape with flying cars and neon lights at night", 4, 123, 512, 512, "cyberpunk", 1, 7.5],
+                    ["A magical dragon in a fantasy landscape, cinematic lighting", 4, 456, 512, 512, "fantasy", 1, 7.5],
+                    ["Cute anime character with magical powers", 4, 789, 512, 512, "anime", 1, 7.5],
+                    ["Photorealistic portrait of an astronaut", 6, 999, 768, 512, "photographic", 1, 8.0]
+                ],
+                inputs=[prompt, num_steps, seed, height, width, style_preset, num_images, guidance_scale],
+                label="Try these examples:"
+            )
         
-        # 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>
-        """)
+        with gr.Column(scale=2):
+            # Output Section
+            status = gr.Textbox(
+                label="Status",
+                value="Ready to generate..."
+            )
+            
+            gallery = gr.Gallery(
+                label="Generated Images",
+                columns=2,
+                height="auto"
+            )
+            
+            # Response viewer
+            with gr.Accordion("API Response", open=False):
+                json_output = gr.JSON(
+                    label="Response"
+                )
     
-    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("=" * 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)
+    # Footer
+    gr.Markdown("""
+    ---
+    **Note:** The Pixazo API returns `{"output": "IMAGE_URL"}`, and the app downloads the image from that URL.
     
-    # Create and launch interface
-    demo = create_interface()
+    Make sure to set `PIXAZO_API_KEY` in your Space secrets for the app to work.
+    """)
     
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True,
-        debug=False
+    # Connect button to 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]
     )
 
+# Launch the app
 if __name__ == "__main__":
-    main()
+    print("Starting Pixazo Image Generator...")
+    print(f"API Key configured: {'Yes' if get_api_key() else 'No'}")
+    
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )

requirements.txt

@@ -1,3 +1,3 @@
-gradio>=4.12.0
+gradio>=3.41.0,<4.0.0
 pillow>=10.0.0
 requests>=2.31.0