Update app.py

app.py

@@ -1,42 +1,402 @@
-import os
-from flask import Flask, request, jsonify
-from flask_cors import CORS
+import gradio as gr
 import requests
+import json
+import os
+import time
+from PIL import Image
+import io
+import base64
+import numpy as np
 
-app = Flask(__name__)
-CORS(app)  # Enable CORS for all routes
-
-# Load API key from Hugging Face secrets
-API_KEY = os.environ.get("PIXAZO_API_KEY")
+# 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
 
-@app.route('/api/generate', methods=['POST'])
-def generate_image():
+# Call Pixazo API
+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.")
+    
+    url = "https://gateway.pixazo.ai/flux-1-schnell/v1/getData"
+    
+    headers = {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-cache',
+        'Ocp-Apim-Subscription-Key': api_key,
+    }
+    
+    # Prepare request body
+    body = {
+        "prompt": prompt,
+        "num_steps": num_steps,
+        "height": height,
+        "width": width,
+    }
+    
+    if seed and seed > 0:
+        body["seed"] = seed
+    if style_preset and style_preset != "none":
+        body["style_preset"] = style_preset
+    if guidance_scale:
+        body["guidance_scale"] = guidance_scale
+    
     try:
-        if not API_KEY:
-            return jsonify({"error": "API key not configured"}), 500
-        
-        # Get data from frontend
-        data = request.json
-        
-        # Call Pixazo API
-        headers = {
-            'Content-Type': 'application/json',
-            'Cache-Control': 'no-cache',
-            'Ocp-Apim-Subscription-Key': API_KEY,
-        }
+        print(f"Sending request to Pixazo API with prompt: {prompt[:50]}...")
         
         response = requests.post(
-            'https://gateway.pixazo.ai/flux-1-schnell/v1/getData',
-            json=data,
-            headers=headers,
-            timeout=30
+            url, 
+            headers=headers, 
+            json=body,
+            timeout=120  # Increase timeout for image generation
         )
         
-        # Return the response from Pixazo
-        return jsonify(response.json()), response.status_code
+        print(f"Response status code: {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 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
+            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
+        
+    except requests.exceptions.Timeout:
+        raise gr.Error("Request timed out. The API might be busy. Please try again.")
+    except requests.exceptions.RequestException as e:
+        raise gr.Error(f"Network error: {str(e)}")
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        raise gr.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 = []
+    
+    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
+            
+            image, result = call_pixazo_api(
+                prompt=prompt,
+                num_steps=num_steps,
+                seed=current_seed,
+                height=height,
+                width=width,
+                style_preset=style_preset,
+                guidance_scale=guidance_scale
+            )
+            
+            if image:
+                images.append(image)
+            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)]
+            
+            # Small delay between requests
+            if i < num_images - 1:
+                time.sleep(1)
+                
+        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)]
+            break
+    
+    if not images:
+        yield [gr.Gallery(visible=False), 
+               "No images were generated successfully.", 
+               json.dumps(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],
+]
+
+# 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
+        """)
+        
+        # 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():
+            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
+            """)
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                # Input Section
+                with gr.Group():
+                    prompt = gr.Textbox(
+                        label="Prompt",
+                        placeholder="Describe the image you want to generate...",
+                        lines=3,
+                        max_lines=6
+                    )
+                
+                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"],
+                        value="none"
+                    )
+                    
+                    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=50,
+                        value=4,
+                        step=1
+                    )
+                    
+                    seed = gr.Number(
+                        label="Seed (0 for random)",
+                        value=0,
+                        minimum=0,
+                        maximum=999999
+                    )
+                
+                with gr.Row():
+                    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
+                    )
+                
+                num_images = gr.Slider(
+                    label="Number of Images",
+                    minimum=1,
+                    maximum=4,
+                    value=1,
+                    step=1
+                )
+                
+                generate_btn = gr.Button("✨ Generate Images", variant="primary", size="lg")
+                
+                # Examples
+                gr.Examples(
+                    examples=example_prompts,
+                    inputs=[prompt, num_steps, seed, height, width, style_preset, num_images, guidance_scale],
+                    label="Try these examples:",
+                    examples_per_page=4
+                )
+            
+            with gr.Column(scale=3):
+                # Output Section
+                status = gr.Textbox(
+                    label="Status",
+                    interactive=False,
+                    value="Ready to generate..."
+                )
+                
+                gallery = gr.Gallery(
+                    label="Generated Images",
+                    show_label=True,
+                    columns=2,
+                    height="auto",
+                    visible=False
+                )
+                
+                with gr.Accordion("API Response Details", open=False):
+                    json_output = gr.JSON(
+                        label="Raw API Response",
+                        visible=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)
+        """)
+        
+        # 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]
+        )
+        
+        # Quick action buttons
+        with gr.Row():
+            gr.Button("📋 Copy Prompt").click(
+                fn=lambda x: x,
+                inputs=[prompt],
+                outputs=[prompt]
+            )
+            
+            clear_btn = gr.Button("🗑️ Clear All")
+            clear_btn.click(
+                fn=lambda: [None, "Ready to generate...", None, None],
+                outputs=[gallery, status, json_output, prompt]
+            )
+    
+    return demo
+
+# Alternative simple interface
+def create_simple_interface():
+    with gr.Blocks(title="Pixazo - Simple Generator") as demo:
+        gr.Markdown("# 🖼️ Simple Pixazo Generator")
+        
+        with gr.Row():
+            with gr.Column():
+                prompt = gr.Textbox(label="Prompt", lines=3)
+                btn = gr.Button("Generate", variant="primary")
+            
+            with gr.Column():
+                output = gr.Image(label="Generated Image")
+                status = gr.Textbox(label="Status", interactive=False)
+        
+        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 configured"
+            
+            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)}"
+        
+        btn.click(
+            fn=simple_generate,
+            inputs=[prompt],
+            outputs=[output, status]
+        )
+    
+    return demo
+
+# Main function
+def main():
+    # Choose which interface to use
+    interface_choice = "advanced"  # Change to "simple" for simpler version
+    
+    if interface_choice == "advanced":
+        demo = create_interface()
+    else:
+        demo = create_simple_interface()
+    
+    # Launch with appropriate settings for Hugging Face Spaces
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=False
+    )
 
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860)
+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()