matrice-analytics 0.1.3__py3-none-any.whl → 0.1.32__py3-none-any.whl

matrice_analytics/post_processing/advanced_tracker/matching.py

@@ -93,8 +93,8 @@ def iou_distance(atracks: list, btracks: list) -> np.ndarray:
     Compute cost based on Intersection over Union (IoU) between tracks.
 
     Args:
-        atracks (List[STrack] | List[np.ndarray]): List of tracks 'a' or bounding boxes.
-        btracks (List[STrack] | List[np.ndarray]): List of tracks 'b' or bounding boxes.
+        atracks (List[STrack] or List[np.ndarray]): List of tracks 'a' or bounding boxes.
+        btracks (List[STrack] or List[np.ndarray]): List of tracks 'b' or bounding boxes.
 
     Returns:
         (np.ndarray): Cost matrix computed based on IoU with shape (len(atracks), len(btracks)).
@@ -139,7 +139,7 @@ def embedding_distance(tracks: list, detections: list, metric: str = "cosine") -
     Compute distance between tracks and detections based on embeddings.
 
     Args:
-        tracks (List[STrack]): List of tracks, where each track contains embedding features.
+        tracks (List[STrack] or List[np.ndarray]): List of tracks, where each track contains embedding features.
         detections (List[BaseTrack]): List of detections, where each detection contains embedding features.
         metric (str): Metric for distance computation. Supported metrics include 'cosine', 'euclidean', etc.
 

matrice_analytics/post_processing/advanced_tracker/strack.py

@@ -46,7 +46,7 @@ class STrack(BaseTrack):
         idx (int): Index or identifier for the object.
         frame_id (int): Current frame ID.
         start_frame (int): Frame where the object was first detected.
-        angle (float | None): Optional angle information for oriented bounding boxes.
+        angle (float or None): Optional angle information for oriented bounding boxes.
     """
 
     shared_kalman = KalmanFilterXYAH()

matrice_analytics/post_processing/config.py

@@ -53,7 +53,9 @@ APP_NAME_TO_USECASE = {
     "abandoned_object_detection" : "abandoned_object_detection",
     "gas_leak_detection": "gas_leak_detection",
     "color_detection": "color_detection",
+    "Color Detection": "color_detection",
     "License Plate Recognition" : "license_plate_monitor",
+    "License Plate Monitoring" : "license_plate_monitor",
     "cell_microscopy_segmentation": "cell_microscopy_segmentation",
     "Dwell Detection": "dwell",
     "age_gender_detection": "age_gender_detection",
@@ -120,7 +122,9 @@ APP_NAME_TO_CATEGORY = {
     "abandoned_object_detection" : "security",
     "gas_leak_detection": "oil_gas",
     "color_detection": "visual_appearance",
+    "Color Detection": "visual_appearance",
     "License Plate Recognition" : "license_plate_monitor",
+    "License Plate Monitoring" : "license_plate_monitor",
     "cell_microscopy_segmentation" : "healthcare",
     "Dwell Detection": "general",
     "age_gender_detection": "age_gender_detection",

matrice_analytics/post_processing/core/config.py

@@ -10,10 +10,13 @@ from typing import Any, Dict, List, Optional, Union, get_type_hints
 from pathlib import Path
 import json
 import yaml
+import logging
 from abc import ABC, abstractmethod
 
 from .base import ConfigProtocol
 
+logger = logging.getLogger(__name__)
+
 
 class ConfigValidationError(Exception):
     """Raised when configuration validation fails."""
@@ -786,6 +789,43 @@ class PeopleTrackingConfig:
         return errors
 
 
+def filter_config_kwargs(config_class: type, kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Filter kwargs to only include parameters that are valid for the config class.
+    
+    Args:
+        config_class: The config class to create
+        kwargs: Dictionary of parameters to filter
+        
+    Returns:
+        Dict[str, Any]: Filtered kwargs containing only valid parameters
+    """
+    if not hasattr(config_class, '__dataclass_fields__'):
+        # Not a dataclass, return kwargs as-is
+        return kwargs
+    
+    # Get valid field names from the dataclass
+    valid_fields = set(config_class.__dataclass_fields__.keys())
+    
+    # Filter kwargs to only include valid fields
+    filtered_kwargs = {}
+    ignored_params = []
+    
+    for key, value in kwargs.items():
+        if key in valid_fields:
+            filtered_kwargs[key] = value
+        else:
+            ignored_params.append(key)
+    
+    # Log ignored parameters for debugging
+    if ignored_params:
+        logger.debug(
+            f"Ignoring non-config parameters for {config_class.__name__}: {ignored_params}"
+        )
+    
+    return filtered_kwargs
+
+
 class ConfigManager:
     """Centralized configuration management for post-processing operations."""
     
@@ -1423,6 +1463,19 @@ class ConfigManager:
         except ImportError:
             return None
 
+    def _filter_kwargs_for_config(self, config_class: type, kwargs: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Filter kwargs to only include valid parameters for the config class.
+        
+        Args:
+            config_class: The config class
+            kwargs: Dictionary of parameters
+            
+        Returns:
+            Filtered kwargs
+        """
+        return filter_config_kwargs(config_class, kwargs)
+    
     def create_config(self, usecase: str, category: Optional[str] = None, **kwargs) -> BaseConfig:
         """
         Create configuration for a specific use case.
@@ -1438,6 +1491,17 @@ class ConfigManager:
         Raises:
             ConfigValidationError: If configuration is invalid
         """
+        # Filter out common non-config parameters that should never be passed to configs
+        common_non_config_params = [
+            'deployment_id', 'stream_key', 'stream_id', 'camera_id', 'server_id',
+            'inference_id', 'timestamp', 'frame_id', 'frame_number', 'request_id',
+            'user_id', 'tenant_id', 'organization_id', 'app_name', 'app_id'
+        ]
+        for param in common_non_config_params:
+            if param in kwargs:
+                logger.debug(f"Removing non-config parameter '{param}' from config creation")
+                kwargs.pop(param, None)
+        
         if usecase == "people_counting":
             # Handle nested configurations
             zone_config = kwargs.pop("zone_config", None)
@@ -1448,12 +1512,15 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(PeopleCountingConfig, kwargs)
+            
             config = PeopleCountingConfig(
                 category=category or "general",
                 usecase=usecase,
                 zone_config=zone_config,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
 
 
@@ -1467,12 +1534,15 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(PeopleTrackingConfig, kwargs)
+            
             config = PeopleTrackingConfig(
                 category=category or "general",
                 usecase=usecase,
                 zone_config=zone_config,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
         
         elif usecase == "intrusion_detection":
@@ -1485,12 +1555,15 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(IntrusionConfig, kwargs)
+            
             config = IntrusionConfig(
                 category=category or "security",
                 usecase=usecase,
                 zone_config=zone_config,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
         
         elif usecase == "proximity_detection":
@@ -1503,12 +1576,15 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(ProximityConfig, kwargs)
+            
             config = ProximityConfig(
                 category=category or "security",
                 usecase=usecase,
                 zone_config=zone_config,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
 
         elif usecase in ["customer_service", "advanced_customer_service"]:
@@ -1521,12 +1597,15 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(CustomerServiceConfig, kwargs)
+            
             config = CustomerServiceConfig(
                 category=category or "sales",
                 usecase=usecase,
                 tracking_config=tracking_config,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
         elif usecase == "basic_counting_tracking":
             # Import here to avoid circular import
@@ -1552,6 +1631,9 @@ class ConfigManager:
             alert_cooldown = kwargs.pop("alert_cooldown", 60.0)
             enable_unique_counting = kwargs.pop("enable_unique_counting", True)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(BasicCountingTrackingConfig, kwargs)
+            
             config = BasicCountingTrackingConfig(
                 category=category or "general",
                 usecase=usecase,
@@ -1564,7 +1646,7 @@ class ConfigManager:
                 zone_thresholds=zone_thresholds,
                 alert_cooldown=alert_cooldown,
                 enable_unique_counting=enable_unique_counting,
-                **kwargs
+                **filtered_kwargs
             )
         elif usecase == "license_plate_detection":
             # Import here to avoid circular import
@@ -1575,11 +1657,14 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(LicensePlateConfig, kwargs)
+            
             config = LicensePlateConfig(
                 category=category or "vehicle",
                 usecase=usecase,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
         elif usecase == "parking_space_detection":
             # Import here to avoid circular import
@@ -1590,11 +1675,14 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(ParkingSpaceConfig, kwargs)
+            
             config = ParkingSpaceConfig(
                 category=category or "parking_space",
                 usecase=usecase,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
         elif usecase == "field_mapping":
             # Import here to avoid circular import
@@ -1605,11 +1693,14 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(FieldMappingConfig, kwargs)
+            
             config = FieldMappingConfig(
                 category=category or "infrastructure",
                 usecase=usecase,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
 
         elif usecase == "leaf_disease_detection":
@@ -1621,6 +1712,9 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(LeafDiseaseDetectionConfig, kwargs)
+
             config = LeafDiseaseDetectionConfig(
                 category=category or "agriculture",
                 usecase=usecase,
@@ -1964,11 +2058,14 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(ColorDetectionConfig, kwargs)
+
             config = ColorDetectionConfig(
                 category=category or "visual_appearance",
                 usecase=usecase,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
         elif usecase == "video_color_classification":
             # Alias for color_detection - Import here to avoid circular import
@@ -1979,11 +2076,14 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(ColorDetectionConfig, kwargs)
+
             config = ColorDetectionConfig(
                 category=category or "visual_appearance",
                 usecase="color_detection",  # Use canonical name internally
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
         elif usecase == "ppe_compliance_detection":
             # Import here to avoid circular import
@@ -2478,11 +2578,14 @@ class ConfigManager:
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(LicensePlateMonitorConfig, kwargs)
+            
             config = LicensePlateMonitorConfig(
                 category=category or "license_plate_monitor",
                 usecase=usecase,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
 
         elif usecase == "dwell":

matrice_analytics/post_processing/face_reg/compare_similarity.py

@@ -62,11 +62,11 @@ class FaceTracker:
         self.tracks: Dict[str, Dict[str, object]] = {}
         self.track_counter: int = 1
 
-    def _find_matching_track(self, new_embedding: List[float]) -> str | None:
+    def _find_matching_track(self, new_embedding: List[float]) -> Optional[str]:
         if not new_embedding:
             return None
         best_similarity: float = 0.0
-        best_track_id: str | None = None
+        best_track_id: Optional[str] = None
         for track_id, data in self.tracks.items():
             stored_embedding = data.get("embedding")
             if stored_embedding:
@@ -76,7 +76,7 @@ class FaceTracker:
                     best_track_id = track_id
         return best_track_id
 
-    def assign_track_id(self, embedding: List[float], frame_id: int | None = None) -> str:
+    def assign_track_id(self, embedding: List[float], frame_id: Optional[int] = None) -> str:
         match_id = self._find_matching_track(embedding)
         if match_id is not None and match_id in self.tracks:
             # Update last seen frame for the matched track
@@ -139,7 +139,7 @@ def compute_pairwise_similarities(embeddings: List[List[float]]) -> Dict[Tuple[i
     return similarity_dict
 
 
-def get_embeddings_from_folder(folder_path: str, max_images: int | None = None) -> Tuple[List[List[float]], List[str]]:
+def get_embeddings_from_folder(folder_path: str, max_images: Optional[int] = None) -> Tuple[List[List[float]], List[str]]:
     image_paths = sorted([p for p in Path(folder_path).iterdir() if p.suffix.lower() in {'.jpg', '.jpeg', '.png'}])
     if max_images is not None:
         image_paths = image_paths[:max_images]
@@ -155,7 +155,7 @@ def get_embeddings_from_folder(folder_path: str, max_images: int | None = None)
     return embeddings, img_names
 
 
-def get_embeddings_per_person(identity_root: str, max_images_per_person: int | None = None) -> Dict[str, List[List[float]]]:
+def get_embeddings_per_person(identity_root: str, max_images_per_person: Optional[int] = None) -> Dict[str, List[List[float]]]:
     """Build a mapping: person (subdirectory name) -> list of embeddings from all images inside it."""
     root = Path(identity_root)
     if not root.exists():

matrice_analytics/post_processing/face_reg/embedding_manager.py

@@ -46,6 +46,10 @@ class EmbeddingConfig:
     # Search settings
     search_limit: int = 5
     search_collection: str = "staff_enrollment"
+    
+    # Background embedding refresh settings
+    enable_background_refresh: bool = True
+    background_refresh_interval: int = 600  # Refresh embeddings every 10 minutes (600 seconds)
 
 
 class EmbeddingManager:
@@ -76,10 +80,93 @@ class EmbeddingManager:
         self._cache_lock = threading.Lock()
         self._embeddings_lock = threading.Lock()
         
+        # Background refresh thread
+        self._refresh_thread = None
+        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")
+        
     def set_face_client(self, face_client: FacialRecognitionClient):
         """Set the face recognition client."""
         self.face_client = face_client
         
+        # Start background refresh if it wasn't started yet
+        if self.config.enable_background_refresh and not self._is_running:
+            self.start_background_refresh()
+            self.logger.info("Background embedding refresh started after setting face client")
+    
+    def start_background_refresh(self):
+        """Start the background embedding refresh thread"""
+        if not self._is_running and self.face_client:
+            self._is_running = True
+            self._stop_event.clear()
+            self._refresh_thread = threading.Thread(
+                target=self._run_refresh_loop, daemon=True, name="EmbeddingRefreshThread"
+            )
+            self._refresh_thread.start()
+            self.logger.info("Started background embedding refresh thread")
+    
+    def stop_background_refresh(self):
+        """Stop the background embedding refresh thread"""
+        if self._is_running:
+            self.logger.info("Stopping background embedding refresh thread...")
+            self._is_running = False
+            self._stop_event.set()
+            if self._refresh_thread:
+                self._refresh_thread.join(timeout=10.0)
+                self.logger.info("Background embedding refresh thread stopped")
+    
+    def _run_refresh_loop(self):
+        """Run the embedding refresh loop in background thread"""
+        import asyncio
+        
+        try:
+            # Create new event loop for this thread
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            
+            # Run initial load
+            self.logger.info("Loading initial staff embeddings in background thread...")
+            loop.run_until_complete(self._load_staff_embeddings())
+            
+            # Periodic refresh loop
+            while self._is_running and not self._stop_event.is_set():
+                try:
+                    # Wait for refresh interval with ability to stop
+                    if self._stop_event.wait(timeout=self.config.background_refresh_interval):
+                        # Stop event was set
+                        break
+                    
+                    if not self._is_running:
+                        break
+                    
+                    # Refresh embeddings
+                    self.logger.info("Refreshing staff embeddings from server...")
+                    success = loop.run_until_complete(self._load_staff_embeddings())
+                    
+                    if success:
+                        self.logger.info("Successfully refreshed staff embeddings in background")
+                    else:
+                        self.logger.warning("Failed to refresh staff embeddings in background")
+                        
+                except Exception as e:
+                    self.logger.error(f"Error in background embedding refresh loop: {e}", exc_info=True)
+                    # Continue loop even on error
+                    time.sleep(60)  # Wait 1 minute before retry on error
+                    
+        except Exception as e:
+            self.logger.error(f"Fatal error in background refresh thread: {e}", exc_info=True)
+        finally:
+            try:
+                loop.close()
+            except:
+                pass
+            self.logger.info("Background embedding refresh loop ended")
+        
     async def _load_staff_embeddings(self) -> bool:
         """Load all staff embeddings from API and cache them."""
         if not self.face_client:
@@ -87,10 +174,11 @@ class EmbeddingManager:
             return False
             
         try:
+            self.logger.info("Loading staff embeddings from API...")
             response = await self.face_client.get_all_staff_embeddings()
             
             if not response.get("success", False):
-                self.logger.error(f"Failed to get staff embeddings: {response.get('error', 'Unknown error')}")
+                self.logger.error(f"Failed to get staff embeddings from API: {response.get('error', 'Unknown error')}")
                 return False
                 
             # The API response has the format: {"success": True, "data": [embedding_items]}
@@ -128,10 +216,11 @@ class EmbeddingManager:
                     
                     self.embedding_metadata = self.staff_embeddings.copy()
                     self.staff_embeddings_last_update = time.time()
-                    self.logger.info(f"Loaded {len(self.staff_embeddings)} staff embeddings")
+                    self.logger.info(f"Successfully loaded and cached {len(self.staff_embeddings)} staff embeddings")
+                    self.logger.debug(f"Embeddings matrix shape: {self.embeddings_matrix.shape}")
                     return True
                 else:
-                    self.logger.warning("No active staff embeddings found")
+                    self.logger.warning("No active staff embeddings found in API response")
                     return False
                 
         except Exception as e:
@@ -440,6 +529,7 @@ class EmbeddingManager:
             
         # Refresh staff embeddings if needed
         if self._should_refresh_embeddings() or self.embeddings_matrix is None:
+            self.logger.debug("Staff embeddings cache expired or empty, refreshing...")
             await self._load_staff_embeddings()
         
         # Always perform similarity search first
@@ -448,7 +538,8 @@ class EmbeddingManager:
         
         if local_match:
             staff_embedding, similarity_score = local_match
-            self.logger.debug(f"Found local match for staff {staff_embedding.staff_id} with similarity {similarity_score:.3f}")
+            self.logger.info(f"Local embedding match found - staff_id={staff_embedding.staff_id}, similarity={similarity_score:.3f}, employee_id={staff_embedding.employee_id}")
+            self.logger.debug(f"Match details: staff_details={staff_embedding.staff_details}")
             
             current_search_result = SearchResult(
                 employee_id=staff_embedding.employee_id,
@@ -466,6 +557,8 @@ class EmbeddingManager:
             employee_id = f"unknown_{int(time.time())}_{counter_value}"
             staff_id = track_id if track_id else f"unknown_{counter_value}"
             
+            self.logger.info(f"No local match found - creating unknown face entry: employee_id={employee_id}, track_id={track_id}")
+            
             current_search_result = SearchResult(
                 employee_id=employee_id,
                 staff_id=staff_id,
@@ -482,13 +575,14 @@ class EmbeddingManager:
             
             # If current result is unknown, always continue checking even if cached
             if current_search_result.detection_type == "unknown":
-                self.logger.debug(f"Unknown face with track_id: {track_id} - continuing to re-check for potential identification")
+                self.logger.debug(f"Unknown face with track_id={track_id} - not caching, will re-check for potential identification")
                 # Still update cache if new result is better, but don't return cached result for unknowns
                 if cached_result and current_search_result.similarity_score > cached_result.similarity_score:
-                    self._update_track_id_cache(track_id, current_search_result)
+                    self._update_track_id_cache(track_id, current_search_result) # TODO: check if this is correct
+                    self.logger.debug(f"Not updating cache for unknown face (track_id={track_id})")
                 elif not cached_result:
                     # Don't cache unknown results - let them be rechecked every time
-                    self.logger.debug(f"Not caching unknown face result for track_id: {track_id}")
+                    self.logger.debug(f"Not caching unknown face result for track_id={track_id}")
                 return current_search_result
             
             if cached_result:
@@ -678,4 +772,11 @@ class EmbeddingManager:
             self.logger.warning(f"Unknown detection type: {search_result.detection_type}")
             return None
             
-        return detection
+        return detection
+    
+    def __del__(self):
+        """Cleanup when object is destroyed"""
+        try:
+            self.stop_background_refresh()
+        except:
+            pass