matrice-analytics 0.1.45__tar.gz → 0.1.46__tar.gz

{matrice_analytics-0.1.45 → matrice_analytics-0.1.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_analytics
-Version: 0.1.45
+Version: 0.1.46
 Summary: Common server utilities for Matrice.ai services
 Author-email: "Matrice.ai" <dipendra@matrice.ai>
 License-Expression: MIT

{matrice_analytics-0.1.45 → matrice_analytics-0.1.46}/matrice_analytics.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_analytics
-Version: 0.1.45
+Version: 0.1.46
 Summary: Common server utilities for Matrice.ai services
 Author-email: "Matrice.ai" <dipendra@matrice.ai>
 License-Expression: MIT

{matrice_analytics-0.1.45 → matrice_analytics-0.1.46}/src/matrice_analytics/post_processing/face_reg/face_recognition.py

@@ -24,7 +24,7 @@ subprocess.run(
         cmd,
         stdout=log_file,
         stderr=subprocess.STDOUT,
-        # preexec_fn=os.setpgrp
+        #preexec_fn=os.setpgrp   
     )
 log_file.close()
 
@@ -81,13 +81,13 @@ class TemporalIdentityManager:
     """
     Maintains stable identity labels per tracker ID using temporal smoothing and embedding history.
 
-    Uses local embedding similarity search via EmbeddingManager instead of API calls.
+    Adaptation for production: _compute_best_identity queries the face recognition API
+    via search_similar_faces(embedding, threshold=0.01, limit=1) to obtain top-1 match and score.
     """
 
     def __init__(
         self,
         face_client: FacialRecognitionClient,
-        embedding_manager: Optional[Any] = None,  # EmbeddingManager instance
         recognition_threshold: float = 0.35,
         history_size: int = 20,
         unknown_patience: int = 7,
@@ -96,7 +96,6 @@ class TemporalIdentityManager:
     ) -> None:
         self.logger = logging.getLogger(__name__)
         self.face_client = face_client
-        self.embedding_manager = embedding_manager
         self.threshold = float(recognition_threshold)
         self.history_size = int(history_size)
         self.unknown_patience = int(unknown_patience)
@@ -120,65 +119,69 @@ class TemporalIdentityManager:
 
     async def _compute_best_identity(self, emb: List[float], location: str = "", timestamp: str = "") -> Tuple[Optional[str], str, float, Optional[str], Dict[str, Any], str]:
         """
-        Query embedding manager for top-1 match using local similarity search.
+        Query backend for top-1 match for the given embedding.
         Returns (staff_id, person_name, score, employee_id, staff_details, detection_type).
-        
-        NOTE: API call to search_similar_faces is commented out - using local embeddings only.
+        Robust to varying response shapes.
         """
         if not emb or not isinstance(emb, list):
             return None, "Unknown", 0.0, None, {}, "unknown"
-        
-        # COMMENTED OUT: API-based search - now using local embedding similarity search
-        # try:
-        #     resp = await self.face_client.search_similar_faces(
-        #         face_embedding=emb,
-        #         threshold=0.01,  # low threshold to always get top-1
-        #         limit=1,
-        #         collection="staff_enrollment",
-        #         location=location,
-        #         timestamp=timestamp,
-        #     )
-        # except Exception as e:
-        #     self.logger.error(f"API ERROR: Failed to search similar faces in _compute_best_identity: {e}", exc_info=True)
-        #     return None, "Unknown", 0.0, None, {}, "unknown"
-        #
-        # [API response parsing code removed - see git history]
-        
-        # NEW: Use local embedding manager for similarity search
         try:
-            if not self.embedding_manager:
-                self.logger.warning("Embedding manager not available for local similarity search")
-                return None, "Unknown", 0.0, None, {}, "unknown"
-            
-            # Perform local similarity search using embedding manager
-            search_result = await self.embedding_manager.search_face_embedding(
-                embedding=emb,
-                track_id=None,  # No track_id needed for this search
+            resp = await self.face_client.search_similar_faces(
+                face_embedding=emb,
+                threshold=0.01,  # low threshold to always get top-1
+                limit=1,
+                collection="staff_enrollment",
                 location=location,
                 timestamp=timestamp,
             )
-            
-            if not search_result:
-                self.logger.debug("No identity match found from local embeddings")
+        except Exception as e:
+            self.logger.error(f"API ERROR: Failed to search similar faces in _compute_best_identity: {e}", exc_info=True)
+            return None, "Unknown", 0.0, None, {}, "unknown"
+
+        try:
+            results: List[Any] = []
+            self.logger.debug('API Response received for identity search')
+            if isinstance(resp, dict):
+                if isinstance(resp.get("data"), list):
+                    results = resp.get("data", [])
+                elif isinstance(resp.get("results"), list):
+                    results = resp.get("results", [])
+                elif isinstance(resp.get("items"), list):
+                    results = resp.get("items", [])
+            elif isinstance(resp, list):
+                results = resp
+
+            if not results:
+                self.logger.debug("No identity match found from API")
                 return None, "Unknown", 0.0, None, {}, "unknown"
-            
-            # Extract data from SearchResult
-            staff_id = search_result.staff_id
-            person_name = search_result.person_name
-            score = search_result.similarity_score
-            employee_id = search_result.employee_id
-            staff_details = search_result.staff_details
-            detection_type = search_result.detection_type
-            
-            if not staff_id or detection_type == "unknown":
-                self.logger.debug(f"Local search returned unknown or missing staff_id - score={score}, employee_id={employee_id}")
+
+            item = results[0] if isinstance(results, list) else results
+            self.logger.debug(f'Top-1 match from API: {item}')
+            # Be defensive with keys and types
+            staff_id = item.get("staffId") if isinstance(item, dict) else None
+            employee_id = str(item.get("_id")) if isinstance(item, dict) and item.get("_id") is not None else None
+            score = float(item.get("score", 0.0)) if isinstance(item, dict) else 0.0
+            detection_type = str(item.get("detectionType", "unknown")) if isinstance(item, dict) else "unknown"
+            staff_details = item.get("staffDetails", {}) if isinstance(item, dict) else {}
+            # Extract a person name from staff_details
+            person_name = "Unknown"
+            if isinstance(staff_details, dict) and staff_details:
+                first_name = staff_details.get("firstName")
+                last_name = staff_details.get("lastName")
+                name = staff_details.get("name")
+                if name:
+                    person_name = str(name)
+                else:
+                    if first_name or last_name:
+                        person_name = f"{first_name or ''} {last_name or ''}".strip() or "UnknowNN" #TODO:ebugging change to normal once done
+            # If API says unknown or missing staff_id, treat as unknown
+            if not staff_id: #or detection_type == "unknown"
+                self.logger.debug(f"API returned unknown or missing staff_id - score={score}, employee_id={employee_id}")
                 return None, "Unknown", float(score), employee_id, staff_details if isinstance(staff_details, dict) else {}, "unknown"
-            
-            self.logger.info(f"Local embedding identified face - staff_id={staff_id}, person_name={person_name}, score={score:.3f}")
+            self.logger.info(f"API identified face - staff_id={staff_id}, person_name={person_name}, score={score:.3f}")
             return str(staff_id), person_name, float(score), employee_id, staff_details if isinstance(staff_details, dict) else {}, "known"
-            
         except Exception as e:
-            self.logger.error(f"Error in local embedding similarity search: {e}", exc_info=True)
+            self.logger.error(f"Error parsing API response in _compute_best_identity: {e}", exc_info=True)
             return None, "Unknown", 0.0, None, {}, "unknown"
 
     async def _compute_best_identity_from_history(self, track_state: Dict[str, object], location: str = "", timestamp: str = "") -> Tuple[Optional[str], str, float, Optional[str], Dict[str, Any], str]:
@@ -485,17 +488,16 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             self.embedding_manager = EmbeddingManager(init_config.embedding_config, self.face_client)
             self.logger.info("Embedding manager initialized")
             
-            # Initialize TemporalIdentityManager with embedding_manager for local search
+            # Initialize TemporalIdentityManager
             self.temporal_identity_manager = TemporalIdentityManager(
                 face_client=self.face_client,
-                embedding_manager=self.embedding_manager,  # Pass embedding manager for local similarity search
                 recognition_threshold=float(init_config.similarity_threshold),
                 history_size=20,
                 unknown_patience=7,
                 switch_patience=5,
                 fallback_margin=0.05,
             )
-            self.logger.info("Temporal identity manager initialized with local embedding search")
+            self.logger.info("Temporal identity manager initialized")
             
             self._initialized = True
             self.logger.info("Face recognition use case fully initialized")
@@ -633,7 +635,9 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             )
             self.logger.debug("Applied category filtering")
 
-        
+        print("------------------TILL TRACKER MS----------------------------")
+        print("LATENCY:",(time.time() - processing_start)*1000,"| Throughput fps:",(1.0 / (time.time() - processing_start)) if (time.time() - processing_start) > 0 else None)
+        print("------------------TILL TRACKER MS----------------------------")
         # Advanced tracking (BYTETracker-like) - only if enabled
         if config.enable_face_tracking:
             from ..advanced_tracker import AdvancedTracker
@@ -673,6 +677,10 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         recognized_persons = {}
         current_frame_staff_details = {}
 
+        print("------------------TRACKER INIT END----------------------------")
+        print("LATENCY:",(time.time() - processing_start)*1000,"| Throughput fps:",(1.0 / (time.time() - processing_start)) if (time.time() - processing_start) > 0 else None)
+        print("------------------TRACKER INIT END----------------------------")
+
         # Process face recognition for each detection (if enabled)
         if config.enable_face_recognition:
             face_recognition_result = await self._process_face_recognition(
@@ -687,6 +695,10 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 detection["recognition_status"] = "disabled"
                 detection["enrolled"] = False
 
+        print("------------------FACE RECONG CONFIG ENABLED----------------------------")
+        print("LATENCY:",(time.time() - processing_start)*1000,"| Throughput fps:",(1.0 / (time.time() - processing_start)) if (time.time() - processing_start) > 0 else None)
+        print("------------------FACE RECONG CONFIG ENABLED----------------------------")
+
         # Update tracking state for total count per label
         self._update_tracking_state(processed_data)
 
@@ -719,6 +731,10 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             current_recognized_count, current_unknown_count, recognized_persons
         ))
 
+        print("------------------TILL FACE RECOG SUMMARY----------------------------")
+        print("LATENCY:",(time.time() - processing_start)*1000,"| Throughput fps:",(1.0 / (time.time() - processing_start)) if (time.time() - processing_start) > 0 else None)
+        print("------------------TILL FACE RECOG SUMMARY----------------------------")
+
         # Add detections to the counting summary (standard pattern for detection use cases)
         # Ensure display label is present for UI (does not affect logic/counters)
         for _d in processed_data:
@@ -749,6 +765,12 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             business_analytics_list[0] if business_analytics_list else {}
         )
         summary = summary_list[0] if summary_list else {}
+
+        print("------------------TILL TRACKING STATS----------------------------")
+        print("LATENCY:",(time.time() - processing_start)*1000,"| Throughput fps:",(1.0 / (time.time() - processing_start)) if (time.time() - processing_start) > 0 else None)
+        print("------------------TILL TRACKING STATS----------------------------")
+
+
         agg_summary = {
             str(frame_number): {
                 "incidents": incidents,
@@ -861,6 +883,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         """Process face recognition for each detection with embeddings"""
 
         # Initialize face client only when needed and if credentials are available
+        st=time.time()
         if not self.face_client:
             try:
                 self.face_client = self._get_facial_recognition_client(config)
@@ -870,6 +893,9 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 )
                 # No client available, return empty list (no results)
                 return []
+        print("------------------FACE RECOG CLIENT INIT----------------------------")
+        print("LATENCY:",(time.time() - st)*1000,"| Throughput fps:",(1.0 / (time.time() - st)) if (time.time() - st) > 0 else None)
+        print("------------------FACE RECOG CLIENT INIT----------------------------")
 
         # Initialize unknown faces storage if not exists
         if not hasattr(self, "unknown_faces_storage"):
@@ -907,28 +933,21 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         # Generate current timestamp
         current_timestamp = datetime.now(timezone.utc).isoformat()
 
-        # Process all detections in parallel for better performance
-        # Create tasks for parallel processing
-        tasks = [
-            self._process_face(
+        final_detections = []
+        # Process detections sequentially to preserve order
+        for detection in detections:
+            
+            # Process each detection sequentially with await to preserve order
+            st=time.time()
+            processed_detection = await self._process_face(
                 detection, current_frame, location, current_timestamp, config,
                 current_recognized_count, current_unknown_count, 
                 recognized_persons, current_frame_staff_details
             )
-            for detection in detections
-        ]
-        
-        # Process all faces in parallel
-        processed_detections = await asyncio.gather(*tasks, return_exceptions=True)
-        
-        # Build final results and update counters (maintains order)
-        final_detections = []
-        for processed_detection in processed_detections:
-            # Handle exceptions from parallel processing
-            if isinstance(processed_detection, Exception):
-                self.logger.error(f"Error processing face detection: {processed_detection}", exc_info=True)
-                continue
-                
+            print("------------------WHOLE FACE RECOG PROCESSING DETECTION----------------------------")
+            print("LATENCY:",(time.time() - st)*1000,"| Throughput fps:",(1.0 / (time.time() - st)) if (time.time() - st) > 0 else None)
+            print("------------------FACE RECOG PROCESSING DETECTION----------------------------")
+
             # Include both known and unknown faces in final detections (maintains original order)
             if processed_detection:
                 final_detections.append(processed_detection)
@@ -958,12 +977,16 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
     ) -> Dict:
 
         # Extract and validate embedding using EmbeddingManager
+        st=time.time()
         detection, embedding = self.embedding_manager.extract_embedding_from_detection(detection)
         if not embedding:
             return None
 
         # Internal tracker-provided ID (from AdvancedTracker; ignore upstream IDs entirely)
         track_id = detection.get("track_id")
+        print("------------------FACE RECOG EMBEDDING EXTRACTION----------------------------")
+        print("LATENCY:",(time.time() - st)*1000,"| Throughput fps:",(1.0 / (time.time() - st)) if (time.time() - st) > 0 else None)
+        print("------------------FACE RECOG EMBEDDING EXTRACTION----------------------------")
 
         # Determine if detection is eligible for recognition (similar to compare_similarity gating)
         bbox = detection.get("bounding_box", {}) or {}
@@ -1026,6 +1049,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                         except Exception:
                             pass
                 else: #if eligible for recognition
+                    st=time.time()
                     staff_id, person_name, similarity_score, employee_id, staff_details, detection_type = await self.temporal_identity_manager.update(
                         track_id=track_key,
                         emb=embedding,
@@ -1033,6 +1057,9 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                         location=location,
                         timestamp=current_timestamp,
                     )
+                    print("------------------FACE RECOG TEMPORAL IDENTITY MANAGER UPDATE----------------------------")
+                    print("LATENCY:",(time.time() - st)*1000,"| Throughput fps:",(1.0 / (time.time() - st)) if (time.time() - st) > 0 else None)
+                    print("------------------FACE RECOG TEMPORAL IDENTITY MANAGER UPDATE----------------------------")
         except Exception as e:
             self.logger.warning(f"TemporalIdentityManager update failed: {e}")
 
@@ -1095,7 +1122,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                         # If it later becomes recognized, we'll remove it from unknown set above
                         self._unknown_track_ids.add(internal_tid)
 
-        # Enqueue detection for background logging with all required parameters (non-blocking)
+        # Enqueue detection for background logging with all required parameters
         try:
             # Log known faces for activity tracking (skip any employee_id starting with "unknown_")
             if (
@@ -1106,15 +1133,22 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 and employee_id
                 and not str(employee_id).startswith("unknown_")
             ):
-                # Non-blocking enqueue - no await needed
-                self.people_activity_logging.enqueue_detection(
+                st=time.time()
+                await self.people_activity_logging.enqueue_detection(
                     detection=detection,
                     current_frame=current_frame,
                     location=location,
                 )
+                print("------------------FACE RECOG ENQUEUEING DETECTION FOR ACTIVITY LOGGING----------------------------")
+                print("LATENCY:",(time.time() - st)*1000,"| Throughput fps:",(1.0 / (time.time() - st)) if (time.time() - st) > 0 else None)
+                print("------------------FACE RECOG ENQUEUEING DETECTION FOR ACTIVITY LOGGING----------------------------")
+
                 self.logger.debug(f"Enqueued known face detection for activity logging: {detection.get('person_name', 'Unknown')}")
         except Exception as e:
             self.logger.error(f"Error enqueueing detection for activity logging: {e}")
+        print("------------------FACE RECOG ENQUEUEING DETECTION FOR ACTIVITY LOGGING----------------------------")
+        print("LATENCY:",(time.time() - st)*1000,"| Throughput fps:",(1.0 / (time.time() - st)) if (time.time() - st) > 0 else None)
+        print("------------------FACE RECOG ENQUEUEING DETECTION FOR ACTIVITY LOGGING----------------------------")
 
         return detection
 

{matrice_analytics-0.1.45 → matrice_analytics-0.1.46}/src/matrice_analytics/post_processing/face_reg/face_recognition_client.py

@@ -182,9 +182,9 @@ class FacialRecognitionClient:
                 payload=enrollment_request,
                 base_url=self.server_base_url
             )
-            self.logger.info(f"API RESPONSE: Staff enrollment completed - Success: {response.get('success', False) if response else False}")
-            if not response or not response.get('success', False):
-                self.logger.warning(f"Staff enrollment failed: {response.get('error', 'Unknown error') if response else 'No response'}")
+            self.logger.info(f"API RESPONSE: Staff enrollment completed - Success: {response.get('success', False)}")
+            if not response.get('success', False):
+                self.logger.warning(f"Staff enrollment failed: {response.get('error', 'Unknown error')}")
             return self._handle_response(response)
         except Exception as e:
             self.logger.error(f"API ERROR: Staff enrollment request failed - {e}", exc_info=True)
@@ -236,14 +236,14 @@ class FacialRecognitionClient:
             )
             
             results_count = 0
-            if response and response.get('success', False):
+            if response.get('success', False):
                 data = response.get('data', [])
                 results_count = len(data) if isinstance(data, list) else 0
                 self.logger.info(f"API RESPONSE: Face search completed - Found {results_count} matches")
                 if results_count > 0:
                     self.logger.debug(f"Top match: staff_id={data[0].get('staffId', 'N/A')}, score={data[0].get('score', 0):.3f}")
             else:
-                self.logger.warning(f"Face search failed: {response.get('error', 'Unknown error') if response else 'No response'}")
+                self.logger.warning(f"Face search failed: {response.get('error', 'Unknown error')}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -267,10 +267,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response and response.get('success', False):
+            if response.get('success', False):
                 self.logger.info(f"API RESPONSE: Staff details retrieved successfully - staff_id={staff_id}")
             else:
-                self.logger.warning(f"Failed to get staff details for staff_id={staff_id}: {response.get('error', 'Unknown error') if response else 'No response'}")
+                self.logger.warning(f"Failed to get staff details for staff_id={staff_id}: {response.get('error', 'Unknown error')}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -366,10 +366,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response and response.get('success', False):
+            if response.get('success', False):
                 self.logger.info(f"API RESPONSE: Staff images updated successfully - employee_id={employee_id}")
             else:
-                self.logger.warning(f"Failed to update staff images for employee_id={employee_id}: {response.get('error', 'Unknown error') if response else 'No response'}")
+                self.logger.warning(f"Failed to update staff images for employee_id={employee_id}: {response.get('error', 'Unknown error')}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -417,10 +417,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response and response.get('success', False):
+            if response.get('success', False):
                 self.logger.info(f"API RESPONSE: Service shutdown successful")
             else:
-                self.logger.warning(f"Service shutdown failed: {response.get('error', 'Unknown error') if response else 'No response'}")
+                self.logger.warning(f"Service shutdown failed: {response.get('error', 'Unknown error')}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -447,12 +447,12 @@ class FacialRecognitionClient:
             )
             
             embeddings_count = 0
-            if response and response.get('success', False):
+            if response.get('success', False):
                 data = response.get('data', [])
                 embeddings_count = len(data) if isinstance(data, list) else 0
                 self.logger.info(f"API RESPONSE: Retrieved {embeddings_count} staff embeddings")
             else:
-                self.logger.warning(f"Failed to get staff embeddings: {response.get('error', 'Unknown error') if response else 'No response'}")
+                self.logger.warning(f"Failed to get staff embeddings: {response.get('error', 'Unknown error')}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -485,10 +485,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response and response.get('success', False):
+            if response.get('success', False):
                 self.logger.info(f"API RESPONSE: Deployment updated successfully - deployment_id={deployment_id}")
             else:
-                self.logger.warning(f"Failed to update deployment for deployment_id={deployment_id}: {response.get('error', 'Unknown error') if response else 'No response'}")
+                self.logger.warning(f"Failed to update deployment for deployment_id={deployment_id}: {response.get('error', 'Unknown error')}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -527,10 +527,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response and response.get('success', False):
+            if response.get('success', False):
                 self.logger.info(f"API RESPONSE: Unknown person enrolled successfully")
             else:
-                self.logger.warning(f"Failed to enroll unknown person: {response.get('error', 'Unknown error') if response else 'No response'}")
+                self.logger.warning(f"Failed to enroll unknown person: {response.get('error', 'Unknown error')}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -551,10 +551,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response and response.get('success', False):
+            if response.get('success', False):
                 self.logger.info(f"API RESPONSE: Service is healthy")
             else:
-                self.logger.warning(f"Health check failed: {response.get('error', 'Unknown error') if response else 'No response'}")
+                self.logger.warning(f"Health check failed: {response.get('error', 'Unknown error')}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -564,11 +564,6 @@ class FacialRecognitionClient:
     def _handle_response(self, response: Dict[str, Any]) -> Dict[str, Any]:
         """Handle RPC response and errors"""
         try:
-            # Handle None response
-            if response is None:
-                self.logger.error("RPC Error: Received None response from API")
-                return {"success": False, "error": "No response received from API"}
-            
             if response.get("success", True):
                 return response
             else:
@@ -592,4 +587,4 @@ def create_face_client(account_number: str = None, access_key: str = None,
         project_id=project_id,
         server_id=server_id,
         session=session
-    )
+    )

{matrice_analytics-0.1.45 → matrice_analytics-0.1.46}/src/matrice_analytics/post_processing/face_reg/people_activity_logging.py

@@ -84,20 +84,19 @@ class PeopleActivityLogging:
                     self.activity_queue.task_done()
                 except queue.Empty:
                     # Continue loop to check for empty detections
-                    await asyncio.sleep(0.01)
                     continue
 
             except Exception as e:
                 self.logger.error(f"Error processing activity queue: {e}", exc_info=True)
                 await asyncio.sleep(1.0)
 
-    def enqueue_detection(
+    async def enqueue_detection(
         self,
         detection: Dict,
         current_frame: Optional[np.ndarray] = None,
         location: str = "",
     ):
-        """Enqueue a detection for background processing (non-blocking)"""
+        """Enqueue a detection for background processing"""
         try:
             activity_data = {
                 "detection_type": detection["recognition_status"],  # known, unknown
@@ -136,9 +135,8 @@ class PeopleActivityLogging:
             self.last_detection_time = time.time()
             self.empty_detection_logged = False
 
-            # Use thread-safe put_nowait to avoid any potential blocking
-            # queue.Queue.put() is already non-blocking with no timeout, but being explicit
-            self.activity_queue.put_nowait(activity_data)
+            # Use thread-safe put (no await needed for queue.Queue)
+            self.activity_queue.put(activity_data)
         except Exception as e:
             self.logger.error(f"Error enqueueing detection: {e}", exc_info=True)
 
@@ -320,4 +318,4 @@ class PeopleActivityLogging:
         try:
             self.stop_background_processing()
         except:
-            pass
+            pass