Update app.py

app.py

@@ -2,43 +2,25 @@ import gradio as gr
 import requests
 import json
 import os
-import time
 from PIL import Image
 import io
-import base64
-import numpy as np
+import time
 
 # Get API key from Hugging Face secrets
 def get_api_key():
-    # Try multiple environment variable names
-    api_key = os.environ.get("PIXAZO_API_KEY") or \
-              os.environ.get("PIXAZO_KEY") or \
-              os.environ.get("API_KEY")
-    
-    if not api_key:
-        # For local testing, you can set it in .env file
-        # In production on HF Spaces, it should be in secrets
-        print("Warning: API key not found in environment variables")
-        print("Please set PIXAZO_API_KEY in Hugging Face Space secrets")
-        
-        # Try reading from a local file for development (never commit this!)
-        try:
-            with open("api_key.txt", "r") as f:
-                api_key = f.read().strip()
-                print("Using API key from local file (development only)")
-        except:
-            pass
-    
-    return api_key
+    return os.environ.get("PIXAZO_API_KEY")
 
-# Call Pixazo API
+# Call Pixazo API - Now we know the exact response format!
 def call_pixazo_api(prompt, num_steps=4, seed=None, height=512, width=512, 
                    style_preset=None, guidance_scale=None):
     
     api_key = get_api_key()
     
     if not api_key:
-        raise gr.Error("API key not configured. Please set PIXAZO_API_KEY in Hugging Face secrets.")
+        return None, {
+            "error": "API key not configured",
+            "instructions": "Please set PIXAZO_API_KEY in Hugging Face Space secrets"
+        }
     
     url = "https://gateway.pixazo.ai/flux-1-schnell/v1/getData"
     
@@ -64,65 +46,109 @@ def call_pixazo_api(prompt, num_steps=4, seed=None, height=512, width=512,
         body["guidance_scale"] = guidance_scale
     
     try:
-        print(f"Sending request to Pixazo API with prompt: {prompt[:50]}...")
+        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, 
             headers=headers, 
             json=body,
-            timeout=120  # Increase timeout for image generation
+            timeout=120
         )
         
-        print(f"Response status code: {response.status_code}")
+        print(f"✅ Response status: {response.status_code}")
         
-        if response.status_code != 200:
-            error_msg = f"API Error {response.status_code}: {response.text}"
-            print(error_msg)
-            raise gr.Error(f"API returned error: {response.status_code}")
-        
-        result = response.json()
-        print("API call successful")
-        
-        # Handle different response formats
-        # Check for base64 image data
-        if "images" in result and isinstance(result["images"], list) and len(result["images"]) > 0:
-            image_data = result["images"][0]
+        if response.status_code == 200:
+            result = response.json()
+            print(f"📦 Response format: {list(result.keys())}")
             
-            # If it's base64 encoded
-            if isinstance(image_data, str) and image_data.startswith("data:image"):
-                # Extract base64 from data URL
-                image_data = image_data.split(",")[1]
-            
-            # Decode base64 to image
+            # ✅ 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)
+                    
+                    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, {
+                            "success": True,
+                            "status_code": 200,
+                            "image_url": image_url,
+                            "response_summary": {
+                                "keys": list(result.keys()),
+                                "url_length": len(image_url)
+                            }
+                        }
+                    else:
+                        return None, {
+                            "error": f"Failed to download image: HTTP {img_response.status_code}",
+                            "image_url": image_url,
+                            "download_status": img_response.status_code
+                        }
+                        
+                except Exception as e:
+                    return None, {
+                        "error": f"Error downloading image: {str(e)}",
+                        "image_url": image_url,
+                        "response": result
+                    }
+            else:
+                return None, {
+                    "error": "Response missing 'output' field",
+                    "response": result,
+                    "expected_format": '{"output": "IMAGE_URL"}'
+                }
+        else:
+            # Handle non-200 responses
             try:
-                image_bytes = base64.b64decode(image_data)
-                image = Image.open(io.BytesIO(image_bytes))
-                return image, result
-            except Exception as e:
-                print(f"Error decoding base64 image: {e}")
-        
-        # If no image in response, return info message
-        return None, result
-        
+                error_data = response.json()
+            except:
+                error_data = {"text": response.text[:500]}
+            
+            return None, {
+                "error": f"API returned status {response.status_code}",
+                "status_code": response.status_code,
+                "response": error_data
+            }
+            
     except requests.exceptions.Timeout:
-        raise gr.Error("Request timed out. The API might be busy. Please try again.")
+        return None, {
+            "error": "Request timed out after 120 seconds",
+            "suggestion": "Try reducing image size or number of steps"
+        }
     except requests.exceptions.RequestException as e:
-        raise gr.Error(f"Network error: {str(e)}")
+        return None, {
+            "error": f"Network error: {str(e)}"
+        }
     except Exception as e:
-        raise gr.Error(f"Unexpected error: {str(e)}")
+        return None, {
+            "error": f"Unexpected error: {str(e)}"
+        }
 
 # Batch generate images
 def generate_images(prompt, num_steps, seed, height, width, style_preset, 
                    num_images, guidance_scale):
     
     images = []
-    results = []
+    all_results = []
     
     for i in range(num_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,
@@ -135,58 +161,91 @@ def generate_images(prompt, num_steps, seed, height, width, style_preset,
             
             if image:
                 images.append(image)
-            results.append(result)
+                print(f"✅ Image {i+1} generated successfully!")
+            else:
+                print(f"❌ Image {i+1} failed: {result.get('error', 'Unknown error')}")
+            
+            all_results.append(result)
             
             # Update progress
-            yield [gr.Gallery(value=images, visible=True), 
-                   f"Generated {i+1}/{num_images} images...", 
-                   json.dumps(results[-1], indent=2)]
+            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(1)
+                time.sleep(2)
                 
         except Exception as e:
-            yield [gr.Gallery(value=images, visible=True), 
-                   f"Error on image {i+1}: {str(e)}", 
-                   json.dumps({"error": str(e)}, indent=2)]
+            error_result = {"error": str(e), "image_index": i}
+            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)]
             break
     
-    if not images:
+    # Final summary
+    success_count = len(images)
+    total_count = num_images
+    
+    if success_count == 0:
         yield [gr.Gallery(visible=False), 
-               "No images were generated successfully.", 
-               json.dumps(results, indent=2)]
+               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)]
     else:
         yield [gr.Gallery(value=images, visible=True), 
-               f"Successfully generated {len(images)} image(s)!", 
-               json.dumps(results, indent=2)]
-
-# Example prompts
-example_prompts = [
-    ["A sleek futuristic car racing through a neon-lit cyberpunk city at night, with rain reflections and holographic advertisements", 4, 42, 512, 512, "cyberpunk", 1, 7.5],
-    ["A majestic dragon perched on a mountain peak overlooking a fantasy landscape with floating islands, sunset lighting", 4, 123, 512, 512, "fantasy", 1, 7.5],
-    ["A cute anime character with pink hair and magical powers in a cherry blossom garden, studio ghibli style", 4, 456, 512, 512, "anime", 1, 7.5],
-    ["A photorealistic portrait of an astronaut on Mars with detailed spacesuit and red planet landscape", 4, 789, 512, 512, "photographic", 1, 7.5],
-]
+               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)]
 
 # Create Gradio interface
 def create_interface():
     with gr.Blocks(theme=gr.themes.Soft(), title="Pixazo Image Generator") as demo:
         gr.Markdown("""
         # 🎨 Pixazo FLUX-1 Schnell Image Generator
-        Generate stunning AI images using Pixazo's FLUX-1 Schnell model
+        *Now with correct response format handling!*
+        
+        **Response Format Confirmed:** `{"output": "IMAGE_URL"}`
         """)
         
         # API Status Check
-        api_key_status = "✅ Configured" if get_api_key() else "❌ Not Configured"
-        gr.Markdown(f"### API Key Status: {api_key_status}")
-        
-        if not get_api_key():
+        api_key = get_api_key()
+        if api_key:
+            gr.Markdown(f"### ✅ API Key: Configured ({len(api_key)} characters)")
+        else:
+            gr.Markdown("### ❌ API Key: Not configured")
             gr.Markdown("""
-            ⚠️ **Setup Required**: 
-            1. Go to your Space Settings → Repository secrets
-            2. Add a new secret: **Key**: `PIXAZO_API_KEY`, **Value**: your API key
-            3. Restart the Space
+            **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
             """)
         
         with gr.Row():
@@ -197,14 +256,14 @@ def create_interface():
                         label="Prompt",
                         placeholder="Describe the image you want to generate...",
                         lines=3,
-                        max_lines=6
+                        value="A sleek futuristic car racing through a neon-lit cyberpunk city at night"
                     )
                 
                 with gr.Row():
                     style_preset = gr.Dropdown(
                         label="Style Preset",
                         choices=["none", "cyberpunk", "fantasy", "anime", "photographic", 
-                                "digital-art", "comic", "line-art", "3d-model", "pixel-art"],
+                                "digital-art", "comic", "3d-model", "pixel-art", "isometric"],
                         value="none"
                     )
                     
@@ -222,14 +281,14 @@ def create_interface():
                         minimum=1,
                         maximum=50,
                         value=4,
-                        step=1
+                        step=1,
+                        info="Higher = better quality but slower"
                     )
                     
                     seed = gr.Number(
-                        label="Seed (0 for random)",
-                        value=0,
-                        minimum=0,
-                        maximum=999999
+                        label="Seed",
+                        value=42,
+                        info="0 = random, >0 = reproducible"
                     )
                 
                 with gr.Row():
@@ -254,17 +313,22 @@ def create_interface():
                     minimum=1,
                     maximum=4,
                     value=1,
-                    step=1
+                    step=1,
+                    info="Generate multiple variations"
                 )
                 
                 generate_btn = gr.Button("✨ Generate Images", variant="primary", size="lg")
                 
-                # Examples
+                # Quick examples
                 gr.Examples(
-                    examples=example_prompts,
+                    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="Try these examples:",
-                    examples_per_page=4
+                    label="Quick Examples"
                 )
             
             with gr.Column(scale=3):
@@ -280,31 +344,33 @@ def create_interface():
                     show_label=True,
                     columns=2,
                     height="auto",
-                    visible=False
+                    visible=False,
+                    object_fit="contain"
                 )
                 
-                with gr.Accordion("API Response Details", open=False):
+                # Response viewer
+                with gr.Accordion("📊 API Response Details", open=False):
                     json_output = gr.JSON(
-                        label="Raw API Response",
-                        visible=True
+                        label="API Response",
+                        container=True
                     )
                 
-                # Download buttons will be added dynamically
-        
-        # Footer
-        gr.Markdown("""
-        ---
-        ### 📝 Notes:
-        - **API Key**: Set `PIXAZO_API_KEY` in Hugging Face Space secrets
-        - **Generation Time**: Usually takes 10-30 seconds per image
-        - **Image Quality**: Higher steps = better quality but slower generation
-        - **Seed**: Use the same seed with same prompt to get consistent results
-        
-        ### ⚙️ Tips:
-        - Be descriptive in your prompts for better results
-        - Try different style presets for varied artistic effects
-        - Adjust guidance scale for prompt adherence (higher = more strict)
-        """)
+                # Debug info
+                with gr.Accordion("🔍 Debug Information", open=False):
+                    gr.Markdown("""
+                    **Known Response Format:** `{"output": "IMAGE_URL"}`
+                    
+                    **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
+                    
+                    **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
+                    """)
         
         # Generation function
         generate_btn.click(
@@ -313,35 +379,54 @@ def create_interface():
             outputs=[gallery, status, json_output]
         )
         
-        # Quick action buttons
+        # Quick test button
         with gr.Row():
-            gr.Button("📋 Copy Prompt").click(
-                fn=lambda x: x,
-                inputs=[prompt],
-                outputs=[prompt]
+            test_btn = gr.Button("🧪 Test Single Image", variant="secondary")
+            clear_btn = gr.Button("🗑️ Clear Results", variant="secondary")
+        
+        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
             )
             
-            clear_btn = gr.Button("🗑️ Clear All")
-            clear_btn.click(
-                fn=lambda: [None, "Ready to generate...", None, None],
-                outputs=[gallery, status, json_output, prompt]
-            )
+            if image:
+                return [gr.Gallery(value=[image], visible=True), 
+                       "✅ Test successful!", 
+                       json.dumps(result, indent=2)]
+            else:
+                return [gr.Gallery(visible=False), 
+                       f"❌ Test failed: {result.get('error', 'Unknown')}", 
+                       json.dumps(result, indent=2)]
+        
+        test_btn.click(
+            fn=test_single_image,
+            outputs=[gallery, status, json_output]
+        )
+        
+        clear_btn.click(
+            fn=lambda: [None, "Ready to generate...", None],
+            outputs=[gallery, status, json_output]
+        )
     
     return demo
 
-# Alternative simple interface
+# Simple interface for quick testing
 def create_simple_interface():
-    with gr.Blocks(title="Pixazo - Simple Generator") as demo:
-        gr.Markdown("# 🖼️ Simple Pixazo Generator")
+    with gr.Blocks(title="Pixazo Simple") as demo:
+        gr.Markdown("# 🖼️ Pixazo Image Generator")
         
         with gr.Row():
             with gr.Column():
-                prompt = gr.Textbox(label="Prompt", lines=3)
+                prompt = gr.Textbox(label="Prompt", value="A beautiful sunset")
                 btn = gr.Button("Generate", variant="primary")
-            
+                
             with gr.Column():
                 output = gr.Image(label="Generated Image")
-                status = gr.Textbox(label="Status", interactive=False)
+                info = gr.Textbox(label="Info")
         
         def simple_generate(prompt_text):
             if not prompt_text.strip():
@@ -349,54 +434,39 @@ def create_simple_interface():
             
             api_key = get_api_key()
             if not api_key:
-                return None, "API key not configured"
+                return None, "API key not set"
             
-            try:
-                image, result = call_pixazo_api(
-                    prompt=prompt_text,
-                    num_steps=4,
-                    height=512,
-                    width=512
-                )
-                
-                if image:
-                    return image, "Generation successful!"
-                else:
-                    return None, f"API Response: {json.dumps(result, indent=2)[:200]}..."
-                    
-            except Exception as e:
-                return None, f"Error: {str(e)}"
+            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(
-            fn=simple_generate,
-            inputs=[prompt],
-            outputs=[output, status]
-        )
+        btn.click(simple_generate, inputs=[prompt], outputs=[output, info])
     
     return demo
 
 # Main function
 def main():
-    # Choose which interface to use
-    interface_choice = "advanced"  # Change to "simple" for simpler version
+    # 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'}}")
     
-    if interface_choice == "advanced":
-        demo = create_interface()
-    else:
-        demo = create_simple_interface()
+    # Create and launch interface
+    demo = create_interface()
     
-    # Launch with appropriate settings for Hugging Face Spaces
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,
-        debug=False
+        share=False
     )
 
 if __name__ == "__main__":
-    # Check if running on Hugging Face Spaces
-    if os.environ.get("SPACE_ID"):
-        print("Running on Hugging Face Spaces")
-        print(f"Space ID: {os.environ.get('SPACE_ID')}")
-    
     main()