matrice-analytics 0.1.3__py3-none-any.whl → 0.1.31__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/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

@@ -87,10 +87,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 +129,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 +442,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 +451,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 +470,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 +488,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:

matrice_analytics/post_processing/face_reg/face_recognition.py

@@ -14,6 +14,18 @@ Configuration options:
 - cache_max_size: Maximum number of cached track IDs (default: 1000)
 - cache_ttl: Cache time-to-live in seconds (default: 3600)
 """
+import subprocess
+import asyncio
+import os
+log_file = open("pip_jetson_btii.log", "w")
+cmd = ["pip", "install", "httpx"]
+subprocess.run(
+        cmd,
+        stdout=log_file,
+        stderr=subprocess.STDOUT,
+        preexec_fn=os.setpgrp   
+    )
+log_file.close()
 
 from typing import Any, Dict, List, Optional, Tuple
 import time
@@ -48,6 +60,8 @@ from .embedding_manager import EmbeddingManager, EmbeddingConfig
 from collections import deque, defaultdict
 
 
+
+
 def _normalize_embedding(vec: List[float]) -> List[float]:
     """Normalize an embedding vector to unit length (L2). Returns float32 list."""
     arr = np.asarray(vec, dtype=np.float32)
@@ -118,14 +132,13 @@ class TemporalIdentityManager:
                 location=location,
                 timestamp=timestamp,
             )
-        except Exception:
+        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] = []
-            print('----------------TOP@1 FROM API----------------------------')
-            print(resp)
-            print('----------------------------------------------------------')
+            self.logger.debug('API Response received for identity search')
             if isinstance(resp, dict):
                 if isinstance(resp.get("data"), list):
                     results = resp.get("data", [])
@@ -137,12 +150,11 @@ class TemporalIdentityManager:
                 results = resp
 
             if not results:
+                self.logger.debug("No identity match found from API")
                 return None, "Unknown", 0.0, None, {}, "unknown"
 
             item = results[0] if isinstance(results, list) else results
-            print('----------------TOP@1 LISTT FROM API----------------------------')
-            print(item)
-            print('----------------------------------------------------------')
+            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
@@ -162,9 +174,12 @@ class TemporalIdentityManager:
                         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"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:
+        except Exception as e:
+            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]:
@@ -172,9 +187,11 @@ class TemporalIdentityManager:
         if not hist:
             return None, "Unknown", 0.0, None, {}, "unknown"
         try:
+            self.logger.debug(f"Computing identity from embedding history - history_size={len(hist)}")
             proto = np.mean(np.asarray(list(hist), dtype=np.float32), axis=0)
             proto_list = proto.tolist() if isinstance(proto, np.ndarray) else list(proto)
-        except Exception:
+        except Exception as e:
+            self.logger.error(f"Error computing prototype from history: {e}", exc_info=True)
             proto_list = []
         return await self._compute_best_identity(proto_list, location=location, timestamp=timestamp)
 
@@ -337,6 +354,7 @@ class FaceRecognitionEmbeddingConfig(BaseConfig):
 
     facial_recognition_server_id: str = ""
     session: Any = None  # Matrice session for face recognition client
+    deployment_id: Optional[str] = None  # deployment ID for update_deployment call
     
     # Embedding configuration
     embedding_config: Optional[Any] = None  # Will be set to EmbeddingConfig instance
@@ -356,7 +374,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
     # Human-friendly display names for categories
     CATEGORY_DISPLAY = {"face": "face"}
 
-    def __init__(self):
+    def __init__(self, config: Optional[FaceRecognitionEmbeddingConfig] = None):
         super().__init__("face_recognition")
         self.category = "security"
 
@@ -413,11 +431,53 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         self._min_face_h: int = 30
 
         self.start_timer = None
+        
+        # Store config for async initialization
+        self._default_config = config
+        self._initialized = False
+        
+        asyncio.run(self.initialize(config))
+
+    async def initialize(self, config: Optional[FaceRecognitionEmbeddingConfig] = None) -> None:
+        """
+        Async initialization method to set up face client and deployment update.
+        Should be called after __init__ to perform async setup operations.
+        
+        Args:
+            config: Optional config to use. If not provided, uses config from __init__.
+        """
+        if self._initialized:
+            self.logger.debug("Use case already initialized, skipping")
+            return
+            
+        # Use provided config or fall back to default config from __init__
+        init_config = config or self._default_config
+        
+        if not init_config:
+            self.logger.warning("No config provided for initialization, will initialize on first process() call")
+            return
+            
+        # Validate config type
+        if not isinstance(init_config, FaceRecognitionEmbeddingConfig):
+            self.logger.warning(f"Invalid config type for initialization: {type(init_config)}, skipping early initialization")
+            return
+            
+        self.logger.info("Initializing face recognition use case with provided config")
+        
+        # Initialize face client (includes deployment update)
+        try:
+            self.face_client = await self._get_facial_recognition_client(init_config)
+            self._initialized = True
+            self.logger.info("Face recognition use case initialized successfully")
+            
+        except Exception as e:
+            self.logger.error(f"Error during use case initialization: {e}", exc_info=True)
+            # Don't mark as initialized so it can retry during process()
 
-    def _get_facial_recognition_client(
+    async def _get_facial_recognition_client(
         self, config: FaceRecognitionEmbeddingConfig
     ) -> FacialRecognitionClient:
-        """Get facial recognition client"""
+        """Get facial recognition client and update deployment"""
         # Initialize face recognition client if not already done
         if self.face_client is None:
             self.logger.info(
@@ -427,6 +487,20 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 server_id=config.facial_recognition_server_id, session=config.session
             )
             self.logger.info("Face recognition client initialized")
+            
+            # Call update_deployment if deployment_id is provided
+            if config.deployment_id:
+                try:
+                    self.logger.info(f"Updating deployment with ID: {config.deployment_id}")
+                    response = await self.face_client.update_deployment(config.deployment_id)
+                    if response.get('success', False):
+                        self.logger.info(f"Successfully updated deployment {config.deployment_id}")
+                    else:
+                        self.logger.warning(f"Failed to update deployment: {response.get('error', 'Unknown error')}")
+                except Exception as e:
+                    self.logger.error(f"Exception while updating deployment: {e}", exc_info=True)
+            else:
+                self.logger.debug("No deployment_id provided, skipping deployment update")
 
         return self.face_client
 
@@ -454,22 +528,37 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 category=self.category,
                 context=context,
             )
-        #if context is None:
-        context = ProcessingContext()
+        if context is None:
+            context = ProcessingContext()
+        
+        # Defensive check: Ensure context is ProcessingContext object (production safety)
+        # This handles edge cases where parameter mismatch might pass a dict as context
+        if not isinstance(context, ProcessingContext):
+            self.logger.warning(
+                f"Context parameter is not ProcessingContext (got {type(context).__name__}, {context}). "
+                "Creating new ProcessingContext. This may indicate a parameter mismatch in the caller."
+            )
+            context = ProcessingContext()
 
+        # Ensure initialization is complete (handles lazy initialization if not done earlier)
+        if not self._initialized:
+            await self.initialize(config)
+        
+        # Fallback: If initialization failed but we still need face_client, try to initialize it
         if not self.face_client:
-            self.face_client = self._get_facial_recognition_client(config)
+            self.face_client = await self._get_facial_recognition_client(config)
 
+        # Ensure confidence threshold is set
         if not config.confidence_threshold:
             config.confidence_threshold = 0.35
         
-        # Initialize People activity logging if enabled
+        # Ensure People activity logging is initialized if enabled
         if config.enable_people_activity_logging and not self.people_activity_logging:
             self.people_activity_logging = PeopleActivityLogging(self.face_client)
             self.people_activity_logging.start_background_processing()
             self.logger.info("People activity logging enabled and started")
 
-        # Initialize EmbeddingManager if not already done
+        # Ensure EmbeddingManager is initialized
         if not self.embedding_manager:
             # Create default embedding config if not provided
             if not config.embedding_config:
@@ -482,7 +571,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 )
             self.embedding_manager = EmbeddingManager(config.embedding_config, self.face_client)
 
-        # Initialize TemporalIdentityManager (top-1 via API with smoothing)
+        # Ensure TemporalIdentityManager is initialized (top-1 via API with smoothing)
         if not self.temporal_identity_manager:
             self.temporal_identity_manager = TemporalIdentityManager(
                 face_client=self.face_client,
@@ -1285,23 +1374,23 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         detections = []
         for detection in counting_summary.get("detections", []):
             bbox = detection.get("bounding_box", {})
-            category = detection.get("display_name", "") #detection.get("category", "face")
-            print(f"CATegory: {category}")
+            category = detection.get("display_name", "")
+
             detection_obj = self.create_detection_object(category, bbox)
             # Add face recognition specific fields
-            # detection_obj.update(
-            #     {
-            #         "person_id": detection.get("person_id"),
-            #         # Use display_name for front-end label suppression policy
-            #         "person_name": detection.get("display_name", ""),
-            #         # Explicit label field for UI overlays
-            #         "label": detection.get("display_name", ""),
-            #         "recognition_status": detection.get(
-            #             "recognition_status", "unknown"
-            #         ),
-            #         "enrolled": detection.get("enrolled", False),
-            #     }
-            # )
+            detection_obj.update(
+                {
+                    "person_id": detection.get("person_id"),
+                    # Use display_name for front-end label suppression policy
+                    "person_name": detection.get("display_name", ""),
+                    # Explicit label field for UI overlays
+                    "label": detection.get("display_name", ""),
+                    "recognition_status": detection.get(
+                        "recognition_status", "unknown"
+                    ),
+                    "enrolled": detection.get("enrolled", False),
+                }
+            )
             detections.append(detection_obj)
 
         # Build alert_settings array in expected format
@@ -1867,4 +1956,4 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             if hasattr(self, "people_activity_logging") and self.people_activity_logging:
                 self.people_activity_logging.stop_background_processing()
         except:
-            pass
+            pass