Update app.py

app.py

@@ -1,73 +1,177 @@
 import gradio as gr
 from gradio_client import Client
 import os
+import tempfile
 
 BACKEND_URL = os.environ.get("BACKEND_URL", "").strip()
 
-# Debug the backend API
+# Create persistent client
 try:
     client = Client(BACKEND_URL, headers={"ngrok-skip-browser-warning": "true"})
     backend_available = True
-    
-    # Print detailed API info
-    print("\n=== BACKEND API INFO ===")
-    api_info = client.view_api(all_endpoints=True)
-    print(api_info)
-    print("========================\n")
-    
 except Exception as e:
     client = None
     backend_available = False
-    print(f"Backend error: {e}")
 
-def test_process():
-    """Test function to debug"""
+def process_media(file_obj, webcam_img, model_type, conf_thresh, max_dets, task_type):
+    """Process media using backend API"""
+    if not client:
+        return [gr.update()] * 5
+    
     try:
-        # Try calling with minimal inputs
+        # Convert webcam PIL to file path
+        webcam_path = None
+        if webcam_img is not None:
+            with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
+                webcam_img.save(tmp, 'PNG')
+                webcam_path = tmp.name
+        
+        # Call backend with proper api_name
         result = client.predict(
-            None,  # file
-            None,  # webcam
-            "MMDetection",  # model
-            0.25,  # conf
-            3,     # max det
-            "Face Detection",  # task
-            fn_index=3
+            uploaded_file_obj=file_obj,
+            webcam_image_pil=webcam_path,
+            model_type_choice=model_type,
+            conf_threshold_ui=conf_thresh,
+            max_detections_ui=max_dets,
+            task_type=task_type,
+            api_name="/process_media"
         )
-        print(f"Result: {result}")
+        
+        # Cleanup temp file
+        if webcam_path and os.path.exists(webcam_path):
+            os.unlink(webcam_path)
+        
         return result
+        
     except Exception as e:
-        print(f"Test error: {e}")
-        return str(e)
+        print(f"Error: {e}")
+        return [gr.update()] * 5
 
-# Minimal test interface
-with gr.Blocks() as demo:
-    gr.Markdown("# PrimateFace Demo - Debug Mode")
+def handle_file_preview(file_obj):
+    """Handle file upload preview"""
+    if not client or not file_obj:
+        return [gr.update()] * 5
     
-    if backend_available:
-        # Show API info
-        with gr.Accordion("API Info", open=True):
-            gr.Code(str(api_info), language="text")
-        
-        # Simple test
-        test_btn = gr.Button("Test Backend Connection")
-        output = gr.Textbox(label="Response")
+    try:
+        return client.predict(
+            file_obj=file_obj,
+            api_name="/handle_file_upload_preview"
+        )
+    except:
+        return [gr.update()] * 5
+
+def handle_webcam_capture(webcam_img):
+    """Handle webcam capture"""
+    if not client or not webcam_img:
+        return [gr.update()] * 4
+    
+    try:
+        # Save PIL to temp file
+        with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
+            webcam_img.save(tmp, 'PNG')
+            temp_path = tmp.name
         
-        test_btn.click(test_process, outputs=output)
+        result = client.predict(
+            snapshot_from_feed=temp_path,
+            api_name="/handle_webcam_capture"
+        )
         
-        # Try using the client's automatic interface loading
-        gr.Markdown("---")
-        gr.Markdown("### Direct Backend Interface:")
-        try:
-            # Load the backend interface directly
-            backend_interface = gr.load(
-                name=BACKEND_URL,
-                src="spaces",
-                hf_token=None
-            )
-            backend_interface.render()
-        except Exception as e:
-            gr.Markdown(f"Could not load interface: {e}")
+        # Cleanup
+        if os.path.exists(temp_path):
+            os.unlink(temp_path)
+            
+        return result
+    except:
+        return [gr.update()] * 4
+
+def clear_all():
+    """Clear all inputs and outputs"""
+    if not client:
+        return [gr.update(value=None)] * 7
+    
+    try:
+        return client.predict(api_name="/clear_all_media_and_outputs")
+    except:
+        return [gr.update(value=None)] * 7
+
+# Build interface
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🐵 PrimateFace Detection, Pose Estimation, and Gaze Demo")
+    
+    if not backend_available:
+        gr.Markdown("### 🔴 GPU Server Offline")
     else:
-        gr.Markdown("### 🔴 Backend Offline")
+        with gr.Row():
+            with gr.Column(scale=1):
+                with gr.Tabs():
+                    with gr.TabItem("Upload File"):
+                        input_file = gr.File(label="Upload Image or Video Here", file_types=["image", "video"])
+                        display_raw_image_file = gr.Image(label="Raw Image Preview", visible=False)
+                        display_raw_video_file = gr.Video(label="Raw Video Preview", visible=False)
+                    
+                    with gr.TabItem("Webcam"):
+                        gr.Markdown("Click on feed or press Enter to capture")
+                        input_webcam = gr.Image(sources=["webcam"], type="pil")
+                        display_raw_image_webcam = gr.Image(label="Captured Snapshot Preview", visible=False)
+                
+                clear_button = gr.Button("Clear All Inputs & Outputs")
+            
+            with gr.Column(scale=1):
+                gr.Markdown("### Processed Output")
+                display_processed_image = gr.Image(label="Processed Image", visible=False)
+                display_processed_video = gr.Video(label="Processed Video", visible=False)
+        
+        # Examples
+        gr.Examples(
+            examples=[
+                ["images/allocebus_000003.jpeg"],
+                ["images/tarsius_000120.jpeg"],
+                ["images/nasalis_proboscis-monkey.png"],
+                ["images/macaca_000032.jpeg"],
+                ["images/mandrillus_000011.jpeg"],
+                ["images/pongo_000006.jpeg"]
+            ],
+            inputs=input_file
+        )
+        
+        submit_button = gr.Button("Detect Faces", variant="primary")
+        
+        # Controls
+        model_choice = gr.Radio(["MMDetection"], value="MMDetection", visible=False)
+        task_type = gr.Dropdown(
+            ["Face Detection", "Face Pose Estimation", "Gaze Estimation [experimental]"],
+            value="Face Detection",
+            label="Select Task"
+        )
+        conf_threshold = gr.Slider(0.05, 0.95, 0.25, step=0.05, label="Confidence Threshold")
+        max_detections = gr.Slider(1, 10, 3, step=1, label="Max Detections")
+        
+        # Wire events
+        input_file.change(
+            handle_file_preview,
+            inputs=[input_file],
+            outputs=[display_raw_image_file, display_raw_video_file, input_file, 
+                    display_processed_image, display_processed_video]
+        )
+        
+        input_webcam.change(
+            handle_webcam_capture,
+            inputs=[input_webcam],
+            outputs=[display_raw_image_webcam, input_webcam,
+                    display_processed_image, display_processed_video]
+        )
+        
+        submit_button.click(
+            process_media,
+            inputs=[input_file, input_webcam, model_choice, conf_threshold, max_detections, task_type],
+            outputs=[display_raw_image_file, display_raw_video_file, display_raw_image_webcam,
+                    display_processed_image, display_processed_video]
+        )
+        
+        clear_button.click(
+            clear_all,
+            outputs=[input_file, input_webcam, display_raw_image_file, display_raw_video_file,
+                    display_raw_image_webcam, display_processed_image, display_processed_video]
+        )
 
 demo.launch()