Update app.py

app.py

@@ -1,156 +1,58 @@
 import gradio as gr
 import requests
 import os
-import time
 from PIL import Image, ImageFilter, ImageDraw, ImageFont
 import io
 
+# =========================================================
 # Configuration
+# =========================================================
 HF_TOKEN = os.getenv("HF_TOKEN")
+GEN_MODEL_ID = "runwayml/stable-diffusion-v1-5"
+GEN_API_URL = f"https://api-inference.huggingface.co/models/{GEN_MODEL_ID}?wait_for_model=true"
+GEN_STATUS_URL = f"https://api-inference.huggingface.co/status/{GEN_MODEL_ID}"
 
 # Architectural styles
 ARCH_STYLES = [
-    "Gothic Cathedral", "Japanese Zen", "Modern Minimalist", 
+    "Gothic Cathedral", "Japanese Zen", "Modern Minimalist",
     "Medieval Castle", "Art Deco", "Chinese Palace",
     "Brutalist", "Victorian", "Mediterranean", "Futuristic"
 ]
 
-def create_building_analysis(input_image):
-    """Create building structure analysis"""
+# =========================================================
+# Image utilities
+# =========================================================
+def create_building_analysis(input_image: Image.Image) -> Image.Image:
+    """Create a simple 'edge map' structure analysis visualization."""
     if input_image is None:
         return create_info_image("Upload a building photo to start")
-    
+
     try:
         img = input_image.resize((512, 512))
         grayscale = img.convert('L')
-        
-        # Edge detection
+
+        # Edge detection and threshold
         edges = grayscale.filter(ImageFilter.FIND_EDGES)
         edges = edges.point(lambda x: 255 if x > 25 else 0)
-        
-        # Create blue edges on black background
+
+        # Blue edges on black background
         analysis_img = Image.new('RGB', (512, 512), 'black')
         edge_pixels = edges.load()
         analysis_pixels = analysis_img.load()
-        
+
         for i in range(512):
             for j in range(512):
                 if edge_pixels[i, j] > 50:
                     analysis_pixels[i, j] = (0, 150, 255)  # Blue
-        
-        return analysis_img
-        
-    except Exception as e:
-        return create_info_image(f"Analysis error: {str(e)}")
-
-
-# ✅ FIXED FUNCTION
-def test_huggingface_api():
-    """Test if Hugging Face API is working correctly"""
-    if not HF_TOKEN:
-        return False, "No HF_TOKEN found in environment variables"
-    
-    # Use an image model for testing
-    API_URL = "https://api-inference.huggingface.co/models/google/vit-base-patch16-224"
-    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
-    
-    # ✅ Use a valid image URL instead of a text string
-    payload = {"inputs": "https://huggingface.co/front/assets/huggingface_logo-noborder.svg"}
-    
-    try:
-        response = requests.post(API_URL, headers=headers, json=payload, timeout=10)
-        if response.status_code == 200:
-            return True, "✅ API is working!"
-        else:
-            return False, f"❌ API test failed: {response.status_code} - {response.text[:100]}"
-    except Exception as e:
-        return False, f"❌ API test error: {str(e)}"
-
-
-def generate_architectural_remix(original_image, style_choice):
-    """Main pipeline"""
-    if original_image is None:
-        analysis_img = create_info_image("Please upload a building photo")
-        status = "Waiting for building photo..."
-        result_img = create_demo_building("Upload a photo to see magic!")
-        return analysis_img, status, result_img
-    
-    try:
-        # Test API first
-        api_working, api_status = test_huggingface_api()
-        
-        # Create structure analysis
-        building_analysis = create_building_analysis(original_image)
-        
-        style_name = ARCH_STYLES[style_choice] if style_choice is not None else ARCH_STYLES[0]
-        
-        if api_working:
-            # Try to generate with API
-            generated_image = generate_with_api(style_name)
-            if generated_image:
-                status = f"✅ AI Generated: {style_name} | " + api_status
-                return building_analysis, status, generated_image
-            else:
-                # API test passed but generation failed
-                demo_img = create_demo_building(style_name)
-                status = f"⚠ Generation failed, showing demo | " + api_status
-                return building_analysis, status, demo_img
-        else:
-            # API not working
-            demo_img = create_demo_building(style_name)
-            status = f"🎨 Demo Mode: {style_name} | " + api_status
-            return building_analysis, status, demo_img
-            
-    except Exception as e:
-        error_img = create_info_image(f"Error: {str(e)}")
-        status = f"❌ Pipeline error: {str(e)}"
-        return building_analysis, status, error_img
 
+        return analysis_img
 
-def generate_with_api(style_name):
-    """Try to generate image via API"""
-    if not HF_TOKEN:
-        return None
-    
-    # Simple prompt
-    prompt = f"architectural rendering of a {style_name.lower()} building, professional photography"
-    
-    API_URL = "https://api-inference.huggingface.co/models/runwayml/stable-diffusion-v1-5"
-    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
-    
-    payload = {
-        "inputs": prompt,
-        "parameters": {
-            "guidance_scale": 7.5,
-            "num_inference_steps": 20,
-            "width": 512,
-            "height": 512
-        }
-    }
-    
-    try:
-        print(f"Attempting to generate: {style_name}")
-        response = requests.post(API_URL, headers=headers, json=payload, timeout=45)
-        print(f"Response status: {response.status_code}")
-        
-        if response.status_code == 200:
-            print("✅ Image generated successfully!")
-            return Image.open(io.BytesIO(response.content))
-        elif response.status_code == 503:
-            print("⚠ Model is loading...")
-            return None
-        else:
-            print(f"❌ API error: {response.status_code} - {response.text[:200]}")
-            return None
-            
     except Exception as e:
-        print(f"❌ Request error: {str(e)}")
-        return None
+        return create_info_image(f"Analysis error: {str(e)}")
 
 
-def create_demo_building(style_name):
-    """Create a beautiful demo building"""
-    # Style-based color schemes
+def create_demo_building(style_name: str) -> Image.Image:
+    """Create a decorative demo image when API is unavailable or generation fails."""
     colors = {
         "Gothic Cathedral": ('#2C3E50', '#E74C3C', '#ECF0F1'),
         "Japanese Zen": ('#8B4513', '#2E8B57', '#F5F5DC'),
@@ -164,17 +66,18 @@ def create_demo_building(style_name):
         "Futuristic": ('#1ABC9C', '#9B59B6', '#34495E'),
         "Upload a photo to see magic!": ('#3498DB', '#2C3E50', '#ECF0F1')
     }
-    
-    bg_color, building_color, accent_color = colors.get(style_name, ('#3498DB', '#2C3E50', '#ECF0F1'))
-    
-    # Create image with gradient background
+
+    bg_color, building_color, accent_color = colors.get(
+        style_name, ('#3498DB', '#2C3E50', '#ECF0F1')
+    )
+
     img = Image.new('RGB', (512, 512), bg_color)
     draw = ImageDraw.Draw(img)
-    
-    # Add gradient effect
+
+    # Gradient background
     for y in range(512):
-        shade = int(200 + (y / 512) * 55)
-        if bg_color == '#FFFFFF':  # Modern
+        if bg_color == '#FFFFFF':  # Modern Minimalist special case
+            shade = int(200 + (y / 512) * 55)
             draw.line([(0, y), (512, y)], fill=(shade, shade, shade))
         else:
             r, g, b = int(bg_color[1:3], 16), int(bg_color[3:5], 16), int(bg_color[5:7], 16)
@@ -182,81 +85,192 @@ def create_demo_building(style_name):
             new_g = max(0, min(255, g + (y // 20)))
             new_b = max(0, min(255, b + (y // 20)))
             draw.line([(0, y), (512, y)], fill=(new_r, new_g, new_b))
-    
-    # Draw building
+
+    # Building body
     draw.rectangle([150, 200, 362, 450], fill=building_color, outline=accent_color, width=3)
-    
-    # Draw windows
+
+    # Windows
     window_colors = ['#F1C40F', '#E74C3C', '#1ABC9C', '#9B59B6']
     for i, color in enumerate(window_colors):
         x_pos = 170 + (i % 3) * 70
         y_pos = 230 + (i // 3) * 70
         draw.rectangle([x_pos, y_pos, x_pos + 40, y_pos + 50], fill=color)
-    
-    # Draw roof
+
+    # Roof
     if "Gothic" in style_name:
         draw.polygon([(150, 200), (256, 150), (362, 200)], fill=accent_color)
     elif "Japanese" in style_name:
         draw.polygon([(150, 200), (256, 170), (362, 200)], fill=accent_color)
     else:
         draw.rectangle([150, 190, 362, 200], fill=accent_color)
-    
-    # Add text
+
+    # Titles
     try:
         font = ImageFont.load_default()
         text = f"{style_name}"
         bbox = draw.textbbox((0, 0), text, font=font)
         text_width = bbox[2] - bbox[0]
         x = (512 - text_width) // 2
-        draw.text((x, 50), text, fill='white', stroke_width=2, stroke_fill='black')
-        
+        draw.text((x, 50), text, fill='white', stroke_width=2, stroke_fill='black', font=font)
+
         if "Upload" not in style_name:
-            draw.text((180, 470), "Architectural AI Demo", fill='white')
-    except:
+            draw.text((180, 470), "Architectural AI Demo", fill='white', font=font)
+    except Exception:
         draw.text((200, 50), style_name, fill='white')
-    
+
     return img
 
 
-def create_info_image(message):
-    """Create informational image"""
+def create_info_image(message: str) -> Image.Image:
+    """Create a plain info panel image with wrapped text."""
     img = Image.new('RGB', (512, 512), color='#2C3E50')
     draw = ImageDraw.Draw(img)
-    
     try:
         font = ImageFont.load_default()
-        lines = message.split(' ')
+        words = message.split(' ')
         current_line = ""
         y_text = 200
-        for word in lines:
+
+        for word in words:
             test_line = current_line + word + " "
             bbox = draw.textbbox((0, 0), test_line, font=font)
             text_width = bbox[2] - bbox[0]
-            
+
             if text_width < 500:
                 current_line = test_line
             else:
                 draw.text((10, y_text), current_line, fill='white', font=font)
                 y_text += 30
                 current_line = word + " "
-        
+
         if current_line:
             draw.text((10, y_text), current_line, fill='white', font=font)
-    except:
+    except Exception:
         draw.text((50, 250), message, fill='white')
-    
+
     return img
 
+# =========================================================
+# HF API helpers
+# =========================================================
+def test_huggingface_api() -> str:
+    """Return a single string suitable for a Textbox with model status."""
+    if not HF_TOKEN:
+        return "❌ No HF_TOKEN found in environment variables."
+
+    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+    try:
+        r = requests.get(GEN_STATUS_URL, headers=headers, timeout=10)
+        if r.status_code == 200:
+            j = r.json()
+            loaded = j.get("loaded")
+            state = j.get("state")
+            qlen = (j.get("queue") or {}).get("length")
+            return f"✅ API reachable. loaded={loaded}, state={state}, queue_length={qlen}"
+        elif r.status_code == 404:
+            return "❌ Model not found or gated (check access to runwayml/stable-diffusion-v1-5)."
+        else:
+            return f"❌ API error {r.status_code}: {r.text[:180]}"
+    except Exception as e:
+        return f"❌ API test error: {e}"
+
+
+def generate_with_api(style_name: str):
+    """Try to generate image via HF Inference API. Returns PIL.Image or None."""
+    if not HF_TOKEN:
+        return None
+
+    prompt = f"architectural rendering of a {style_name.lower()} building, professional photography"
+    headers = {
+        "Authorization": f"Bearer {HF_TOKEN}",
+        "Accept": "image/png"
+    }
+    payload = {
+        "inputs": prompt,
+        "parameters": {
+            "guidance_scale": 7.5,
+            "num_inference_steps": 20
+            # Width/height may not be supported across all deployments:
+            # "width": 512,
+            # "height": 512
+        }
+    }
+
+    try:
+        response = requests.post(GEN_API_URL, headers=headers, json=payload, timeout=60)
+        ctype = response.headers.get("content-type", "")
+        if response.status_code == 200 and ctype.startswith("image/"):
+            return Image.open(io.BytesIO(response.content))
+        elif response.status_code == 503:
+            # Model loading or warming up
+            return None
+        else:
+            # Likely JSON error; log a snippet
+            print(f"❌ API error {response.status_code}: {response.text[:200]}")
+            return None
+    except Exception as e:
+        print(f"❌ Request error: {e}")
+        return None
+
+# =========================================================
+# Main pipeline
+# =========================================================
+def generate_architectural_remix(original_image, style_choice):
+    """Pipeline: test API → analyze structure → generate or show demo."""
+    if original_image is None:
+        analysis_img = create_info_image("Please upload a building photo")
+        status = "Waiting for building photo..."
+        result_img = create_demo_building("Upload a photo to see magic!")
+        return analysis_img, status, result_img
 
-# Create Gradio interface
+    # Always keep a safe default analysis ready
+    safe_analysis = create_info_image("Analysis unavailable")
+
+    try:
+        # 1) API status (returns a string now)
+        api_status = test_huggingface_api()
+        api_working = api_status.startswith("✅")
+
+        # 2) Structure analysis (guard any failure)
+        try:
+            building_analysis = create_building_analysis(original_image)
+        except Exception:
+            building_analysis = safe_analysis
+
+        # 3) Style name
+        style_name = ARCH_STYLES[style_choice] if style_choice is not None else ARCH_STYLES[0]
+
+        # 4) Generation (or demo fallback)
+        if api_working:
+            generated_image = generate_with_api(style_name)
+            if generated_image:
+                status = f"✅ AI Generated: {style_name} | {api_status}"
+                return building_analysis, status, generated_image
+            else:
+                demo_img = create_demo_building(style_name)
+                status = f"⚠ Generation failed or model loading, showing demo | {api_status}"
+                return building_analysis, status, demo_img
+        else:
+            demo_img = create_demo_building(style_name)
+            status = f"🎨 Demo Mode: {style_name} | {api_status}"
+            return building_analysis, status, demo_img
+
+    except Exception as e:
+        error_img = create_info_image(f"Error: {str(e)}")
+        status = f"❌ Pipeline error: {str(e)}"
+        return safe_analysis, status, error_img
+
+# =========================================================
+# Gradio UI
+# =========================================================
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
     # 🏛 Architectural Style Remix
-    *AI-Powered Building Transformation*
-    
+    AI-Powered Building Transformation
+
     Upload a building → AI analyzes structure → Generates new style
     """)
-    
+
     with gr.Row():
         with gr.Column():
             input_image = gr.Image(
@@ -264,38 +278,37 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                 type="pil",
                 height=300
             )
-            
+
             style_dropdown = gr.Dropdown(
                 choices=ARCH_STYLES,
                 label="🎨 Select Architectural Style",
                 value=ARCH_STYLES[2],
                 type="index"
             )
-            
-            generate_btn = gr.Button("✨ Generate Style Remix", variant="primary", size="lg")
-            
-            # Add API test button
+
+            generate_btn = gr.Button("✨ Generate Style Remix", variant="primary")
+
+            # API test
             test_api_btn = gr.Button("🔍 Test API Connection", variant="secondary")
             api_status = gr.Textbox(label="API Status", interactive=False)
-        
+
         with gr.Column():
             structure_output = gr.Image(
                 label="📐 Building Structure Analysis",
                 height=300
             )
-            
+
             status_text = gr.Textbox(
                 label="Generation Status",
                 value="Ready - Upload a building photo to start!",
                 interactive=False
             )
-            
+
             result_image = gr.Image(
-                label="🎭 Generated Building", 
+                label="🎭 Generated Building",
                 height=300
             )
-    
-    # Examples
+
     gr.Markdown("### 🏗 Try These Building Examples:")
     gr.Examples(
         examples=[
@@ -308,28 +321,28 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         fn=generate_architectural_remix,
         cache_examples=False
     )
-    
+
     # Button actions
     generate_btn.click(
         fn=generate_architectural_remix,
         inputs=[input_image, style_dropdown],
         outputs=[structure_output, status_text, result_image]
     )
-    
+
     test_api_btn.click(
         fn=test_huggingface_api,
         outputs=api_status
     )
-    
+
     gr.Markdown("""
     ### 🎯 Project Features:
-    - *Structure Analysis*: AI detects architectural features
-    - *Style Transformation*: AI generates buildings in selected styles  
-    - *Demo Mode*: Beautiful fallback images when API is unavailable
-    - *API Testing*: Check Hugging Face connection status
-    
+    - Structure Analysis: AI detects architectural features
+    - Style Transformation: AI generates buildings in selected styles
+    - Demo Mode: Beautiful fallback images when API is unavailable
+    - API Testing: Check Hugging Face connection status
+
     Note: Free Hugging Face API has rate limits. Demo mode ensures the project always works!
     """)
 
 if __name__ == "__main__":
-    demo.launch(debug=True)
+    demo.launch(debug=True)