FINAL STABILITY FIX: Switched to VideoProcessorBase, added 'av', and used @st .cache_resource to eliminate thread/shutdown race conditions.

app.py

@@ -1,56 +1,47 @@
 import streamlit as st
 import cv2  # OpenCV for image processing
 import numpy as np
-import av
-# NOTE: Use VideoProcessorBase as the primary class as VideoTransformerBase is deprecated
+import av # <--- REQUIRED: Must be in requirements.txt (pip install av)
 from streamlit_webrtc import webrtc_streamer, VideoProcessorBase, WebRtcMode 
 
-# --- PLACEHOLDER IMPORTS (UNCOMMENT/ADJUST AS NEEDED) ---
-# NOTE: Make sure these core libraries are in your requirements.txt
-# import deepface 
-# from src.detect import detect_faces
-# from src.recognize import recognize_face
+# --- PLACEHOLDER IMPORTS (Adjust as needed) ---
+# ... 
 
 # --- CONFIGURATION ---
 RECOGNITION_THRESHOLD = 0.6
-FRAME_SKIP = 3  # Process every 3rd frame for performance
+FRAME_SKIP = 3
 
+# --- CACHE THE MODEL/FACTORY (CRITICAL FIX FOR THREADING) ---
+# This ensures the processor and its threads are initialized only ONCE.
+@st.cache_resource
+def get_face_processor_factory():
+    """Returns the processor class, ensuring it is cached."""
+    
+    class FaceRecognitionProcessor(VideoProcessorBase):
+        """Processes video frames using the standard VideoProcessorBase."""
+        def __init__(self):
+            # Initialize models once here (safely cached by @st.cache_resource)
+            self.frame_count = 0
+            # Example: self.detection_model = load_your_model()
+            
+        def recv(self, frame: av.VideoFrame) -> av.VideoFrame:
+            # Convert frame from av.VideoFrame to numpy array (BGR)
+            img = frame.to_ndarray(format="bgr24")
+            
+            self.frame_count += 1
+            if self.frame_count % FRAME_SKIP != 0:
+                return frame # Return the original frame if skipping
+            
+            # --- Your Face Detection and Recognition Logic Goes Here ---
+            h, w, _ = img.shape
+            # Placeholder drawing logic:
+            x, y, w_box, h_box = w//4, h//4, w//2, h//2 
+            cv2.rectangle(img, (x, y), (x + w_box, y + h_box), (0, 0, 255), 2)
+            
+            # Convert back to av.VideoFrame before returning
+            return av.VideoFrame.from_ndarray(img, format="bgr24")
 
-# --- VIDEO PROCESSING CLASS ---
-# Using VideoProcessorBase to align with current streamlit-webrtc practices
-class FaceRecognitionProcessor(VideoProcessorBase):
-    """
-    A class that processes video frames in real-time for face recognition.
-    """
-    def __init__(self):
-        # Initialize models once here
-        self.frame_count = 0
-        # ... your model loading initialization ...
-        
-    def recv(self, frame):
-        # The frame is now an av.VideoFrame object, convert to numpy array
-        img = frame.to_ndarray(format="bgr24")
-        
-        self.frame_count += 1
-        if self.frame_count % FRAME_SKIP != 0:
-            return frame # Return the original frame if skipping
-        
-        # --- Your Face Detection and Recognition Logic Goes Here ---
-        # Example placeholder logic:
-        h, w, _ = img.shape
-        faces = [(w//4, h//4, w//2, h//2)] # Placeholder bounding box
-
-        for (x, y, w, h) in faces:
-            recognized_name = "Unknown" 
-            score = 0.0
-            color = (0, 0, 255) 
-
-            cv2.rectangle(img, (x, y), (x + w, y + h), color, 2)
-            label = f"{recognized_name}: {score:.2f}"
-            cv2.putText(img, label, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, color, 2)
-
-        # Convert back to av.VideoFrame before returning
-        return av.VideoFrame.from_ndarray(img, format="bgr24")
+    return FaceRecognitionProcessor
 
 # --- STREAMLIT UI ---
 
@@ -60,22 +51,14 @@ def main():
     st.title("Smart Office Face Recognition System 📸")
     st.sidebar.title("Configuration")
 
-    RECOGNITION_THRESHOLD = st.sidebar.slider(
-        "Recognition Threshold", min_value=0.0, max_value=1.0, value=0.6, step=0.05
-    )
+    # ... (Sidebar control for threshold) ...
 
-    # Use a stable key
-    STREAMER_KEY = "face-recognition-stream-final" 
-
-    # --- CRITICAL FIX: The webrtc_streamer call itself must be outside the wrapper ---
-    # The fix is to ensure the component is always called/rendered, but the initialization
-    # of heavy resources (models) is safely handled inside a cached function (if needed).
-    
+    # --- FINAL WEBRTC STREAMER CALL ---
     webrtc_streamer(
-        key=STREAMER_KEY,  
+        key="face-recognition-stream-final-cache",  
         mode=WebRtcMode.SENDRECV,
         
-        # --- FIX 2: Enhanced STUN/TURN configuration to resolve aioice errors ---
+        # --- Enhanced STUN/TURN configuration ---
         rtc_configuration={
             "iceServers": [
                 {"urls": ["stun:stun.l.google.com:19302"]},
@@ -83,8 +66,8 @@ def main():
             ]
         },
         
-        # NOTE: Using video_processor_factory and the VideoProcessorBase class
-        video_processor_factory=FaceRecognitionProcessor,  
+        # Use the CACHED factory function
+        video_processor_factory=get_face_processor_factory,  
         async_processing=True                                
     )
 
@@ -93,5 +76,5 @@ def main():
 
 # --- EXECUTION ---
 if __name__ == "__main__":
-    # You MUST also install the package 'av' (pip install av) to use VideoProcessorBase
+    # IMPORTANT: Ensure 'av' is in your requirements.txt
     main()

requirements.txt

@@ -3,4 +3,5 @@ streamlit-webrtc
 opencv-python
 deepface
 numpy
-scikit-learn
+scikit-learn
+av