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

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

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

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

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

{matrice_analytics-0.1.43 → matrice_analytics-0.1.45}/matrice_analytics.egg-info/SOURCES.txt

@@ -88,6 +88,7 @@ src/matrice_analytics/post_processing/test_cases/test_customer_service.py
 src/matrice_analytics/post_processing/test_cases/test_data_generators.py
 src/matrice_analytics/post_processing/test_cases/test_people_counting.py
 src/matrice_analytics/post_processing/test_cases/test_processor.py
+src/matrice_analytics/post_processing/test_cases/test_usecases.py
 src/matrice_analytics/post_processing/test_cases/test_utilities.py
 src/matrice_analytics/post_processing/test_cases/test_utils.py
 src/matrice_analytics/post_processing/usecases/Histopathological_Cancer_Detection_img.py

{matrice_analytics-0.1.43 → matrice_analytics-0.1.45}/src/matrice_analytics/post_processing/config.py

@@ -143,4 +143,4 @@ def get_usecase_from_app_name(app_name: str) -> str:
 
 def get_category_from_app_name(app_name: str) -> str:
     normalized_app_name = app_name.lower().replace(" ", "_").replace("-", "_")
-    return APP_NAME_TO_CATEGORY.get(app_name, APP_NAME_TO_CATEGORY.get(normalized_app_name))
+    return APP_NAME_TO_CATEGORY.get(app_name, APP_NAME_TO_CATEGORY.get(normalized_app_name))

{matrice_analytics-0.1.43 → matrice_analytics-0.1.45}/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.
 
-    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.
+    Uses local embedding similarity search via EmbeddingManager instead of API calls.
     """
 
     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,6 +96,7 @@ 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)
@@ -119,69 +120,65 @@ 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 backend for top-1 match for the given embedding.
+        Query embedding manager for top-1 match using local similarity search.
         Returns (staff_id, person_name, score, employee_id, staff_details, detection_type).
-        Robust to varying response shapes.
+        
+        NOTE: API call to search_similar_faces is commented out - using local embeddings only.
         """
         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:
-            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",
+            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
                 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"
-
-        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")
+            
+            if not search_result:
+                self.logger.debug("No identity match found from local embeddings")
                 return None, "Unknown", 0.0, None, {}, "unknown"
-
-            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}")
+            
+            # 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}")
                 return None, "Unknown", float(score), employee_id, staff_details if isinstance(staff_details, dict) else {}, "unknown"
-            self.logger.info(f"API identified face - staff_id={staff_id}, person_name={person_name}, score={score:.3f}")
+            
+            self.logger.info(f"Local embedding 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 parsing API response in _compute_best_identity: {e}", exc_info=True)
+            self.logger.error(f"Error in local embedding similarity search: {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]:
@@ -488,16 +485,17 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             self.embedding_manager = EmbeddingManager(init_config.embedding_config, self.face_client)
             self.logger.info("Embedding manager initialized")
             
-            # Initialize TemporalIdentityManager
+            # Initialize TemporalIdentityManager with embedding_manager for local search
             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")
+            self.logger.info("Temporal identity manager initialized with local embedding search")
             
             self._initialized = True
             self.logger.info("Face recognition use case fully initialized")
@@ -909,16 +907,28 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         # Generate current timestamp
         current_timestamp = datetime.now(timezone.utc).isoformat()
 
-        final_detections = []
-        # Process detections sequentially to preserve order
-        for detection in detections:
-            
-            # Process each detection sequentially with await to preserve order
-            processed_detection = await self._process_face(
+        # Process all detections in parallel for better performance
+        # Create tasks for parallel processing
+        tasks = [
+            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
+                
             # Include both known and unknown faces in final detections (maintains original order)
             if processed_detection:
                 final_detections.append(processed_detection)
@@ -1085,7 +1095,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
+        # Enqueue detection for background logging with all required parameters (non-blocking)
         try:
             # Log known faces for activity tracking (skip any employee_id starting with "unknown_")
             if (
@@ -1096,7 +1106,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 and employee_id
                 and not str(employee_id).startswith("unknown_")
             ):
-                await self.people_activity_logging.enqueue_detection(
+                # Non-blocking enqueue - no await needed
+                self.people_activity_logging.enqueue_detection(
                     detection=detection,
                     current_frame=current_frame,
                     location=location,
@@ -1743,56 +1754,57 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         return f"{hours:02d}:{minutes:02d}:{seconds:.1f}"
 
     def _format_timestamp(self, timestamp: Any) -> str:
-        """Format a timestamp so that exactly two digits follow the decimal point (milliseconds).
+        """Format a timestamp to match the current timestamp format: YYYY:MM:DD HH:MM:SS.
 
         The input can be either:
-        1. A numeric Unix timestamp (``float`` / ``int``) – it will first be converted to a
-           string in the format ``YYYY-MM-DD-HH:MM:SS.ffffff UTC``.
-        2. A string already following the same layout.
+        1. A numeric Unix timestamp (``float`` / ``int``) – it will be converted to datetime.
+        2. A string in the format ``YYYY-MM-DD-HH:MM:SS.ffffff UTC``.
 
-        The returned value preserves the overall format of the input but truncates or pads
-        the fractional seconds portion to **exactly two digits**.
+        The returned value will be in the format: YYYY:MM:DD HH:MM:SS (no milliseconds, no UTC suffix).
 
         Example
         -------
-        >>> self._format_timestamp("2025-08-19-04:22:47.187574 UTC")
-        '2025-08-19-04:22:47.18 UTC'
+        >>> self._format_timestamp("2025-10-27-19:31:20.187574 UTC")
+        '2025:10:27 19:31:20'
         """
 
-        # Convert numeric timestamps to the expected string representation first
+        # Convert numeric timestamps to datetime first
         if isinstance(timestamp, (int, float)):
-            timestamp = datetime.fromtimestamp(timestamp, timezone.utc).strftime(
-                '%Y-%m-%d-%H:%M:%S.%f UTC'
-            )
+            dt = datetime.fromtimestamp(timestamp, timezone.utc)
+            return dt.strftime('%Y:%m:%d %H:%M:%S')
 
         # Ensure we are working with a string from here on
         if not isinstance(timestamp, str):
             return str(timestamp)
 
-        # If there is no fractional component, simply return the original string
-        if '.' not in timestamp:
-            return timestamp
+        # Remove ' UTC' suffix if present
+        timestamp_clean = timestamp.replace(' UTC', '').strip()
 
-        # Split out the main portion (up to the decimal point)
-        main_part, fractional_and_suffix = timestamp.split('.', 1)
+        # Remove milliseconds if present (everything after the last dot)
+        if '.' in timestamp_clean:
+            timestamp_clean = timestamp_clean.split('.')[0]
 
-        # Separate fractional digits from the suffix (typically ' UTC')
-        if ' ' in fractional_and_suffix:
-            fractional_part, suffix = fractional_and_suffix.split(' ', 1)
-            suffix = ' ' + suffix  # Re-attach the space removed by split
-        else:
-            fractional_part, suffix = fractional_and_suffix, ''
-
-        # Guarantee exactly two digits for the fractional part
-        fractional_part = (fractional_part + '00')[:2]
+        # Parse the timestamp string and convert to desired format
+        try:
+            # Handle format: YYYY-MM-DD-HH:MM:SS
+            if timestamp_clean.count('-') >= 2:
+                # Replace first two dashes with colons for date part, third with space
+                parts = timestamp_clean.split('-')
+                if len(parts) >= 4:
+                    # parts = ['2025', '10', '27', '19:31:20']
+                    formatted = f"{parts[0]}:{parts[1]}:{parts[2]} {'-'.join(parts[3:])}"
+                    return formatted
+        except Exception:
+            pass
 
-        return f"{main_part}.{fractional_part}{suffix}"
+        # If parsing fails, return the cleaned string as-is
+        return timestamp_clean
 
     def _get_current_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False, frame_id: Optional[str]=None) -> str:
         """Get formatted current timestamp based on stream type."""
+        
         if not stream_info:
             return "00:00:00.00"
-
         if precision:
             if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
                 if frame_id:
@@ -1801,7 +1813,6 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                     start_time = stream_info.get("input_settings", {}).get("start_frame", 30)/stream_info.get("input_settings", {}).get("original_fps", 30)
                 stream_time_str = self._format_timestamp_for_video(start_time)
                 
-
                 return self._format_timestamp(stream_info.get("input_settings", {}).get("stream_time", "NA"))
             else:
                 return datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
@@ -1813,7 +1824,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 start_time = stream_info.get("input_settings", {}).get("start_frame", 30)/stream_info.get("input_settings", {}).get("original_fps", 30)
 
             stream_time_str = self._format_timestamp_for_video(start_time)
-            
+           
+
             return self._format_timestamp(stream_info.get("input_settings", {}).get("stream_time", "NA"))
         else:
             stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
@@ -1835,23 +1847,57 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         
         if precision:
             if self.start_timer is None:
-                self.start_timer = stream_info.get("input_settings", {}).get("stream_time", "NA")
+                candidate = stream_info.get("input_settings", {}).get("stream_time")
+                if not candidate or candidate == "NA":
+                    candidate = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+                self.start_timer = candidate
                 return self._format_timestamp(self.start_timer)
             elif stream_info.get("input_settings", {}).get("start_frame", "na") == 1:
-                self.start_timer = stream_info.get("input_settings", {}).get("stream_time", "NA")
+                candidate = stream_info.get("input_settings", {}).get("stream_time")
+                if not candidate or candidate == "NA":
+                    candidate = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+                self.start_timer = candidate
                 return self._format_timestamp(self.start_timer)
             else:
                 return self._format_timestamp(self.start_timer)
 
         if self.start_timer is None:
-            self.start_timer = stream_info.get("input_settings", {}).get("stream_time", "NA")
+            # Prefer direct input_settings.stream_time if available and not NA
+            candidate = stream_info.get("input_settings", {}).get("stream_time")
+            if not candidate or candidate == "NA":
+                # Fallback to nested stream_info.stream_time used by current timestamp path
+                stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
+                if stream_time_str:
+                    try:
+                        timestamp_str = stream_time_str.replace(" UTC", "")
+                        dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
+                        self._tracking_start_time = dt.replace(tzinfo=timezone.utc).timestamp()
+                        candidate = datetime.fromtimestamp(self._tracking_start_time, timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+                    except:
+                        candidate = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+                else:
+                    candidate = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+            self.start_timer = candidate
             return self._format_timestamp(self.start_timer)
         elif stream_info.get("input_settings", {}).get("start_frame", "na") == 1:
-            self.start_timer = stream_info.get("input_settings", {}).get("stream_time", "NA")
+            candidate = stream_info.get("input_settings", {}).get("stream_time")
+            if not candidate or candidate == "NA":
+                stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
+                if stream_time_str:
+                    try:
+                        timestamp_str = stream_time_str.replace(" UTC", "")
+                        dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
+                        ts = dt.replace(tzinfo=timezone.utc).timestamp()
+                        candidate = datetime.fromtimestamp(ts, timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+                    except:
+                        candidate = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+                else:
+                    candidate = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+            self.start_timer = candidate
             return self._format_timestamp(self.start_timer)
         
         else:
-            if self.start_timer is not None:
+            if self.start_timer is not None and self.start_timer != "NA":
                 return self._format_timestamp(self.start_timer)
 
             if self._tracking_start_time is None:

{matrice_analytics-0.1.43 → matrice_analytics-0.1.45}/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 not response.get('success', False):
-                self.logger.warning(f"Staff enrollment failed: {response.get('error', 'Unknown error')}")
+            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'}")
             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.get('success', False):
+            if response and 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')}")
+                self.logger.warning(f"Face search failed: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -267,10 +267,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response.get('success', False):
+            if response and 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')}")
+                self.logger.warning(f"Failed to get staff details for staff_id={staff_id}: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -366,10 +366,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response.get('success', False):
+            if response and 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')}")
+                self.logger.warning(f"Failed to update staff images for employee_id={employee_id}: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -417,10 +417,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response.get('success', False):
+            if response and 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')}")
+                self.logger.warning(f"Service shutdown failed: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -447,12 +447,12 @@ class FacialRecognitionClient:
             )
             
             embeddings_count = 0
-            if response.get('success', False):
+            if response and 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')}")
+                self.logger.warning(f"Failed to get staff embeddings: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -485,10 +485,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response.get('success', False):
+            if response and 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')}")
+                self.logger.warning(f"Failed to update deployment for deployment_id={deployment_id}: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -527,10 +527,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response.get('success', False):
+            if response and 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')}")
+                self.logger.warning(f"Failed to enroll unknown person: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -551,10 +551,10 @@ class FacialRecognitionClient:
                 base_url=self.server_base_url
             )
             
-            if response.get('success', False):
+            if response and 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')}")
+                self.logger.warning(f"Health check failed: {response.get('error', 'Unknown error') if response else 'No response'}")
             
             return self._handle_response(response)
         except Exception as e:
@@ -564,6 +564,11 @@ 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:

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

@@ -84,19 +84,20 @@ 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)
 
-    async def enqueue_detection(
+    def enqueue_detection(
         self,
         detection: Dict,
         current_frame: Optional[np.ndarray] = None,
         location: str = "",
     ):
-        """Enqueue a detection for background processing"""
+        """Enqueue a detection for background processing (non-blocking)"""
         try:
             activity_data = {
                 "detection_type": detection["recognition_status"],  # known, unknown
@@ -135,8 +136,9 @@ class PeopleActivityLogging:
             self.last_detection_time = time.time()
             self.empty_detection_logged = False
 
-            # Use thread-safe put (no await needed for queue.Queue)
-            self.activity_queue.put(activity_data)
+            # 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)
         except Exception as e:
             self.logger.error(f"Error enqueueing detection: {e}", exc_info=True)
 

{matrice_analytics-0.1.43 → matrice_analytics-0.1.45}/src/matrice_analytics/post_processing/ocr/easyocr_extractor.py

@@ -1,6 +1,7 @@
 import easyocr
 import numpy as np
 import torch
+from matrice_common.utils import log_errors
 
 class EasyOCRExtractor:
     def __init__(self, lang=['en', 'hi', 'ar'], gpu=False, model_storage_directory=None, 
@@ -30,7 +31,8 @@ class EasyOCRExtractor:
         self.recognizer = recognizer
         self.verbose = verbose
         self.reader = None
-    
+        
+    @log_errors(default_return=None, raise_exception=True, service_name="py_analytics", log_error=True)
     def setup(self):
         """
         Initializes the EasyOCR reader if not already initialized.