Update app.py

app.py

@@ -3,6 +3,7 @@ import os
 import cv2
 import time
 
+# Ensure the correct predictor class is imported
 from src.EmotionRecognition.pipeline.hf_predictor import HFPredictor
 
 # --- INITIALIZE THE MODEL ---
@@ -23,11 +24,13 @@ body {
     animation: gradient 15s ease infinite;
 }
 @keyframes gradient { 0% { background-position: 0% 50%; } 50% { background-position: 100% 50%; } 100% { background-position: 0% 50%; } }
+
 /* General Layout & Typography */
 .gradio-container { max-width: 1320px !important; margin: auto !important; }
 #title { text-align: center; font-size: 3rem !important; font-weight: 700; color: #FFF; margin-bottom: 0.5rem; }
 #subtitle { text-align: center; color: #bebebe; margin-top: 0; margin-bottom: 40px; font-size: 1.2rem; font-weight: 300; }
 .gr-button { font-weight: bold !important; }
+
 /* Prediction Bar Styling */
 #predictions-column { background-color: rgba(255, 255, 255, 0.05); border-radius: 12px; padding: 1.5rem; }
 #predictions-column > .gr-label { display: none; }
@@ -51,6 +54,7 @@ This entire application, from data processing to training and deployment, was bu
 """
 
 # --- BACKEND LOGIC ---
+
 def create_prediction_html(probabilities):
     if not probabilities:
         return "<div style='padding: 2rem; text-align: center; color: #999;'>Waiting for prediction...</div>"
@@ -67,35 +71,13 @@ def create_prediction_html(probabilities):
     html += "</ul>"
     return html
 
-# --- THIS IS THE FIX ---
-# The function MUST accept the 'stream_state' argument that Gradio sends to it.
-def live_detection_stream(stream_state):
-    if stream_state != "Start":
-        yield None, create_prediction_html({})
-        return
-
-    cap = cv2.VideoCapture(0)
-    if not cap.isOpened():
-        print("[ERROR] Cannot open webcam")
-        return
+def live_detection_stream(frame):
+    """The main function for the live feed. Receives a frame, returns annotated frame and predictions."""
+    if frame is None:
+        return None, create_prediction_html({})
     
-    try:
-        while True:
-            # We need to check the state inside the loop as well for the 'cancels' to work
-            if gr.State.is_yield_break():
-                break
-            ret, frame = cap.read()
-            if not ret:
-                time.sleep(0.01)
-                continue
-            
-            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            annotated_frame, probabilities = predictor.process_frame(frame_rgb)
-            yield annotated_frame, create_prediction_html(probabilities)
-    finally:
-        print("[INFO] Live feed stopped. Releasing webcam.")
-        cap.release()
-# --- END FIX ---
+    annotated_frame, probabilities = predictor.process_frame(frame)
+    return annotated_frame, create_prediction_html(probabilities)
 
 def process_image(image):
     if image is None: return None, create_prediction_html({})
@@ -103,8 +85,29 @@ def process_image(image):
     return annotated_frame, create_prediction_html(probabilities)
 
 def process_video(video_path, progress=gr.Progress(track_tqdm=True)):
-    # ... (this function is correct)
-    pass
+    if video_path is None: return None
+    try:
+        cap = cv2.VideoCapture(video_path)
+        frame_count = int(cap.get(cv.CAP_PROP_FRAME_COUNT))
+        output_path = "processed_video.mp4"
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        width = int(cap.get(cv.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT))
+        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+        for _ in progress.tqdm(range(frame_count), desc="Processing Video"):
+            ret, frame = cap.read()
+            if not ret: break
+            frame_rgb = cv2.cvtColor(frame, cv.COLOR_BGR2RGB)
+            annotated_frame, _ = predictor.process_frame(frame_rgb)
+            if annotated_frame is not None:
+                out.write(cv2.cvtColor(annotated_frame, cv.COLOR_RGB2BGR))
+        cap.release()
+        out.release()
+        return output_path
+    except Exception as e:
+        print(f"[ERROR] Video processing failed: {e}")
+        return None
 
 # --- GRADIO UI ---
 with gr.Blocks(css=CSS, theme=gr.themes.Base()) as demo:
@@ -115,41 +118,45 @@ with gr.Blocks(css=CSS, theme=gr.themes.Base()) as demo:
         with gr.TabItem("Live Detection"):
             with gr.Row(equal_height=True):
                 with gr.Column(scale=3):
-                    live_output = gr.Image(label="Live Feed", interactive=False, height=550)
+                    # The definitive, simple, and correct way to do a live feed in Gradio v3
+                    live_feed = gr.Image(source="webcam", streaming=True, type="numpy", label="Live Feed", interactive=False, height=550)
                 with gr.Column(scale=2, elem_id="predictions-column"):
                     gr.Markdown("### Emotion Probabilities")
                     live_predictions = gr.HTML()
-            with gr.Row():
-                start_button = gr.Button("Start Webcam", variant="primary", scale=1)
-                stop_button = gr.Button("Stop Webcam", variant="secondary", scale=1)
-            stream_state = gr.State("Start") # Default to Start, will be triggered by button
-
-        # ... (Other tabs are correct)
+        
         with gr.TabItem("Upload Image"):
             with gr.Row(equal_height=True):
                 with gr.Column(scale=3):
                     image_input = gr.Image(type="numpy", label="Upload an Image", height=550)
                 with gr.Column(scale=2, elem_id="predictions-column"):
                     image_predictions = gr.HTML()
-            # This line needs to be indented to be part of the "Upload Image" TabItem
             image_button = gr.Button("Analyze Image", variant="primary")
 
+        with gr.TabItem("Upload Video"):
+            with gr.Row(equal_height=True):
+                video_input = gr.Video(label="Upload a Video File")
+                video_output = gr.Video(label="Processed Video")
+            video_button = gr.Button("Analyze Video", variant="primary")
+        
+        with gr.TabItem("About"):
+            gr.Markdown(ABOUT_MARKDOWN)
+
     # --- EVENT LISTENERS ---
-    # We assign the event to a variable so we can cancel it
-    live_event = start_button.click(
+    
+    # The .stream() event is the correct way to link a streaming input.
+    # It automatically handles starting and stopping. There is no need for separate buttons.
+    live_feed.stream(
         fn=live_detection_stream, 
-        inputs=stream_state,
-        outputs=[live_output, live_predictions],
-        # No 'cancels' on the start event
+        inputs=[live_feed],
+        outputs=[live_feed, live_predictions],
     )
-    # The stop button's only job is to cancel the running live_event
-    stop_button.click(fn=None, inputs=None, outputs=None, cancels=[live_event])
 
     image_button.click(process_image, [image_input], [image_input, image_predictions])
+    video_button.click(process_video, [video_input], [video_output])
 
 # --- LAUNCH THE APP ---
 if predictor:
-    # Remove share=True as it's not needed and causes a warning on Spaces
+    # Enabling the queue is essential for the video processing progress bar
     demo.queue().launch(debug=True)
 else:
     print("\n[FATAL ERROR] Could not start the application.")