matrice-analytics 0.1.56__tar.gz → 0.1.82__tar.gz

{matrice_analytics-0.1.56 → matrice_analytics-0.1.82}/PKG-INFO

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

{matrice_analytics-0.1.56 → matrice_analytics-0.1.82}/matrice_analytics.egg-info/PKG-INFO

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

{matrice_analytics-0.1.56 → matrice_analytics-0.1.82}/matrice_analytics.egg-info/SOURCES.txt

@@ -188,12 +188,15 @@ src/matrice_analytics/post_processing/utils/__init__.py
 src/matrice_analytics/post_processing/utils/advanced_counting_utils.py
 src/matrice_analytics/post_processing/utils/advanced_helper_utils.py
 src/matrice_analytics/post_processing/utils/advanced_tracking_utils.py
+src/matrice_analytics/post_processing/utils/alert_instance_utils.py
 src/matrice_analytics/post_processing/utils/alerting_utils.py
+src/matrice_analytics/post_processing/utils/business_metrics_manager_utils.py
 src/matrice_analytics/post_processing/utils/category_mapping_utils.py
 src/matrice_analytics/post_processing/utils/color_utils.py
 src/matrice_analytics/post_processing/utils/counting_utils.py
 src/matrice_analytics/post_processing/utils/filter_utils.py
 src/matrice_analytics/post_processing/utils/format_utils.py
 src/matrice_analytics/post_processing/utils/geometry_utils.py
+src/matrice_analytics/post_processing/utils/incident_manager_utils.py
 src/matrice_analytics/post_processing/utils/smoothing_utils.py
 src/matrice_analytics/post_processing/utils/tracking_utils.py

{matrice_analytics-0.1.56 → matrice_analytics-0.1.82}/src/matrice_analytics/post_processing/core/base.py

@@ -286,7 +286,7 @@ class BaseProcessor(ABC):
             "incident_id": incident_id,
             "incident_type": incident_type,
             "severity_level": severity_level,
-            "human_text": human_text or f"{incident_type} detected @ {timestamp} [Severity Level: {severity_level}]",
+            "human_text": human_text or f"{incident_type} detected. [Severity Level: {severity_level}]",
             "start_time": timestamp,
             "end_time": end_time or timestamp,
             "camera_info": camera_info or self.get_default_camera_info(),

{matrice_analytics-0.1.56 → matrice_analytics-0.1.82}/src/matrice_analytics/post_processing/face_reg/embedding_manager.py

@@ -56,7 +56,26 @@ class EmbeddingConfig:
 
 
 class EmbeddingManager:
-    """Manages face embeddings, search operations, and caching."""
+    """
+    Manages face embeddings, search operations, and caching.
+    
+    CRITICAL INITIALIZATION FLOW:
+    1. __init__() creates the manager but does NOT load embeddings or start background refresh
+    2. External caller MUST call await _load_staff_embeddings() to load embeddings synchronously
+    3. After successful load, caller SHOULD call start_background_refresh() for periodic updates
+    4. The _embeddings_loaded flag tracks whether embeddings are ready for use
+    5. All search operations check _embeddings_loaded before proceeding
+    
+    This design prevents race conditions where:
+    - Background thread tries to load while main thread is loading
+    - Search operations are called before embeddings are loaded
+    - Multiple threads compete for the embeddings_lock during initialization
+    
+    Thread Safety:
+    - _embeddings_lock protects embeddings_matrix and embedding_metadata
+    - _cache_lock protects track_id_cache
+    - _embeddings_loaded is set only after successful load under lock
+    """
     
     def __init__(self, config: EmbeddingConfig, face_client: FacialRecognitionClient = None):
         self.config = config
@@ -89,11 +108,47 @@ class EmbeddingManager:
         self._is_running = False
         self._stop_event = threading.Event()
         
-        # Start background refresh if enabled
-        if self.config.enable_background_refresh and self.face_client:
-            self.start_background_refresh()
-            self.logger.info(f"Background embedding refresh enabled - interval: {self.config.background_refresh_interval}s")
+        # Initialization status flag
+        self._embeddings_loaded = False
+        
+        # DON'T start background refresh yet - wait for initial load in initialize()
+        # This prevents race conditions where background thread interferes with main init
+        self.logger.info(f"EmbeddingManager created - background refresh will start after initial load (interval: {self.config.background_refresh_interval}s)")
         
+    def is_ready(self) -> bool:
+        """
+        Check if embeddings are loaded and ready for use.
+        
+        Returns:
+            True if embeddings are loaded and matrix is valid, False otherwise
+        """
+        return (
+            self._embeddings_loaded 
+            and self.embeddings_matrix is not None 
+            and len(self.embedding_metadata) > 0
+        )
+    
+    def get_status(self) -> Dict[str, Any]:
+        """
+        Get detailed status of embedding manager for debugging and health checks.
+        
+        Returns:
+            Dictionary with status information
+        """
+        with self._embeddings_lock:
+            matrix_shape = self.embeddings_matrix.shape if self.embeddings_matrix is not None else None
+            
+        return {
+            "embeddings_loaded": self._embeddings_loaded,
+            "embeddings_count": len(self.staff_embeddings),
+            "matrix_shape": matrix_shape,
+            "metadata_count": len(self.embedding_metadata),
+            "cache_size": len(self.track_id_cache),
+            "last_update": self.staff_embeddings_last_update,
+            "is_running": self._is_running,
+            "is_ready": self.is_ready(),
+        }
+    
     def set_face_client(self, face_client: FacialRecognitionClient):
         """Set the face recognition client."""
         self.face_client = face_client
@@ -179,10 +234,10 @@ class EmbeddingManager:
             return False
             
         try:
-            self.logger.info("Loading staff embeddings from API...")
-            print("=============== LOADING STAFF EMBEDDINGS FROM API ===============")
+            #self.logger.info("Loading staff embeddings from API...")
+            #print("=============== LOADING STAFF EMBEDDINGS FROM API ===============")
             response = await self.face_client.get_all_staff_embeddings()
-            print(f"API RESPONSE TYPE: {type(response)}, IS_LIST: {isinstance(response, list)}, LEN: {len(response) if isinstance(response, list) else 'N/A'}")
+            #print(f"API RESPONSE TYPE: {type(response)}, IS_LIST: {isinstance(response, list)}, LEN: {len(response) if isinstance(response, list) else 'N/A'}")
             
             # Robust response handling: accept dict with data or raw list
             embeddings_data: List[Dict[str, Any]] = []
@@ -272,14 +327,16 @@ class EmbeddingManager:
                     
                     self.embedding_metadata = self.staff_embeddings.copy()
                     self.staff_embeddings_last_update = time.time()
+                    self._embeddings_loaded = True  # Mark as successfully loaded
+                    
                     self.logger.info(f"Successfully loaded and cached {len(self.staff_embeddings)} staff embeddings (dim={self.embeddings_matrix.shape[1]})")
-                    print(f"=============== SUCCESS: LOADED {len(self.staff_embeddings)} EMBEDDINGS, MATRIX SHAPE: {self.embeddings_matrix.shape} ===============")
+                    #print(f"=============== SUCCESS: LOADED {len(self.staff_embeddings)} EMBEDDINGS, MATRIX SHAPE: {self.embeddings_matrix.shape} ===============")
                     try:
                         # Quick sanity metrics
                         row0_sum = float(np.sum(self.embeddings_matrix[0])) if self.embeddings_matrix.shape[0] > 0 else 0.0
                         row0_norm = float(np.linalg.norm(self.embeddings_matrix[0])) if self.embeddings_matrix.shape[0] > 0 else 0.0
-                        print(f"SANITY CHECK: row0_sum={row0_sum:.4f}, row0_norm={row0_norm:.4f} (should be ~1.0 after normalization)")
-                        self.logger.debug(f"Embeddings matrix shape: {self.embeddings_matrix.shape}, dtype={self.embeddings_matrix.dtype}, row0_sum={row0_sum:.4f}")
+                        #print(f"SANITY CHECK: row0_sum={row0_sum:.4f}, row0_norm={row0_norm:.4f} (should be ~1.0 after normalization)")
+                        #self.logger.debug(f"Embeddings matrix shape: {self.embeddings_matrix.shape}, dtype={self.embeddings_matrix.dtype}, row0_sum={row0_sum:.4f}")
                     except Exception as e:
                         print(f"ERROR in sanity check: {e}")
                     return True
@@ -336,9 +393,16 @@ class EmbeddingManager:
     
     def _find_best_local_match(self, query_embedding: List[float]) -> Optional[Tuple[StaffEmbedding, float]]:
         """Find best matching staff member using optimized matrix operations (thread-safe)."""
+        # Check if embeddings are loaded at all
+        if not self._embeddings_loaded:
+            #print(f"ERROR: _find_best_local_match called but embeddings not loaded yet (_embeddings_loaded={self._embeddings_loaded})")
+            self.logger.error("Embeddings not loaded - _find_best_local_match cannot proceed")
+            return None
+            
         with self._embeddings_lock:
             if self.embeddings_matrix is None or len(self.embedding_metadata) == 0:
-                print(f"ERROR: _find_best_local_match - embeddings_matrix is None={self.embeddings_matrix is None}, metadata_len={len(self.embedding_metadata)}")
+                #print(f"ERROR: _find_best_local_match - embeddings_matrix is None={self.embeddings_matrix is None}, metadata_len={len(self.embedding_metadata)}, _embeddings_loaded={self._embeddings_loaded}")
+                self.logger.error(f"Embeddings matrix is None despite _embeddings_loaded={self._embeddings_loaded}")
                 return None
                 
             # Create local copies to avoid issues with concurrent modifications
@@ -346,6 +410,7 @@ class EmbeddingManager:
             embedding_metadata = self.embedding_metadata.copy()
             
         if embeddings_matrix is None:
+            print("ERROR: _find_best_local_match - embeddings_matrix copy is None")
             return None
             
         try: