Update app.py

app.py

@@ -5,31 +5,30 @@ import tempfile
 
 BACKEND_URL = os.environ.get("BACKEND_URL", "").strip()
 
-# Create persistent client
 try:
     client = Client(BACKEND_URL, headers={"ngrok-skip-browser-warning": "true"})
     backend_available = True
-except Exception as e:
+except:
     client = None
     backend_available = False
 
 def process_media(file_obj, webcam_img, model_type, conf_thresh, max_dets, task_type):
-    """Process media using backend API"""
+    """Process media - backend expects both file and webcam paths"""
     if not client:
         return [gr.update()] * 5
     
     try:
-        # Convert webcam PIL to file path
+        # Convert webcam PIL to file path if present
         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
+        # Backend expects both parameters - use None for missing one
         result = client.predict(
-            uploaded_file_obj=file_obj,
-            webcam_image_pil=webcam_path,
+            uploaded_file_obj=file_obj if file_obj else None,
+            webcam_image_pil=webcam_path if webcam_path else None,
             model_type_choice=model_type,
             conf_threshold_ui=conf_thresh,
             max_detections_ui=max_dets,
@@ -37,141 +36,97 @@ def process_media(file_obj, webcam_img, model_type, conf_thresh, max_dets, task_
             api_name="/process_media"
         )
         
-        # Cleanup temp file
+        # Cleanup
         if webcam_path and os.path.exists(webcam_path):
             os.unlink(webcam_path)
         
         return result
         
     except Exception as e:
-        print(f"Error: {e}")
-        return [gr.update()] * 5
+        print(f"Process error: {e}")
+        # Return error message in processed image slot
+        return [
+            gr.update(),  # raw image file
+            gr.update(),  # raw video file  
+            gr.update(),  # raw image webcam
+            gr.update(value=None, visible=True),  # processed image - show error
+            gr.update()   # processed video
+        ]
 
-def handle_file_preview(file_obj):
-    """Handle file upload preview"""
-    if not client or not file_obj:
-        return [gr.update()] * 5
-    
-    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
-        
-        result = client.predict(
-            snapshot_from_feed=temp_path,
-            api_name="/handle_webcam_capture"
-        )
-        
-        # 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
+# Simplified interface without complex preview forwarding
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🐵 PrimateFace Detection, Pose Estimation, and Gaze Demo")
+    gr.Markdown("# 🐵 PrimateFace Detection, Pose & Gaze Demo")
     
     if not backend_available:
         gr.Markdown("### 🔴 GPU Server Offline")
     else:
         with gr.Row():
-            with gr.Column(scale=1):
+            with gr.Column():
                 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("Upload"):
+                        input_file = gr.File(label="Upload Image/Video")
+                        # Simple local preview
+                        preview_img = gr.Image(label="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")
+                clear_btn = gr.Button("Clear All")
             
-            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)
+            with gr.Column():
+                gr.Markdown("### Results")
+                output_image = gr.Image(label="Processed", visible=False)
+                output_video = gr.Video(label="Processed", 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"]
-            ],
+            examples=[["images/" + f] for f in [
+                "allocebus_000003.jpeg",
+                "tarsius_000120.jpeg", 
+                "nasalis_proboscis-monkey.png",
+                "macaca_000032.jpeg",
+                "mandrillus_000011.jpeg",
+                "pongo_000006.jpeg"
+            ]],
             inputs=input_file
         )
         
-        submit_button = gr.Button("Detect Faces", variant="primary")
+        submit_btn = 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"
+            value="Face Detection"
         )
-        conf_threshold = gr.Slider(0.05, 0.95, 0.25, step=0.05, label="Confidence Threshold")
+        conf_threshold = gr.Slider(0.05, 0.95, 0.25, step=0.05, label="Confidence")
         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]
-        )
+        # Simple local preview for uploaded files
+        def show_preview(file):
+            if file and file.name.lower().endswith(('.jpg', '.jpeg', '.png', '.bmp')):
+                return gr.update(value=file, visible=True)
+            return gr.update(visible=False)
         
-        input_webcam.change(
-            handle_webcam_capture,
-            inputs=[input_webcam],
-            outputs=[display_raw_image_webcam, input_webcam,
-                    display_processed_image, display_processed_video]
-        )
+        input_file.change(show_preview, inputs=[input_file], outputs=[preview_img])
+        
+        # Main processing - only use last 3 outputs (skip raw previews)
+        def process_and_extract_outputs(*args):
+            result = process_media(*args)
+            # Return only processed outputs
+            return result[-2:]  # Just processed image and video
         
-        submit_button.click(
-            process_media,
+        submit_btn.click(
+            process_and_extract_outputs,
             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]
+            outputs=[output_image, output_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]
+        # Simple clear
+        clear_btn.click(
+            lambda: [gr.update(value=None), gr.update(value=None), gr.update(visible=False), 
+                    gr.update(visible=False), gr.update(visible=False)],
+            outputs=[input_file, input_webcam, preview_img, output_image, output_video]
         )
 
 demo.launch()