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

matrice_analytics/post_processing/face_reg/face_recognition.py

@@ -14,6 +14,19 @@ 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 logging
+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 +61,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)
@@ -79,6 +94,7 @@ class TemporalIdentityManager:
         switch_patience: int = 5,
         fallback_margin: float = 0.05,
     ) -> None:
+        self.logger = logging.getLogger(__name__)
         self.face_client = face_client
         self.threshold = float(recognition_threshold)
         self.history_size = int(history_size)
@@ -118,14 +134,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 +152,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 +176,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 +189,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 +356,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 +376,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 +433,83 @@ 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
+        
+        # Don't call asyncio.run() in __init__ - it will fail if called from async context
+        # Initialization must be done by calling await initialize(config) after instantiation
+        # This is handled in PostProcessor._get_use_case_instance()
+
+    async def initialize(self, config: Optional[FaceRecognitionEmbeddingConfig] = None) -> None:
+        """
+        Async initialization method to set up face client and all components.
+        Must be called after __init__ before process() can be called.
+        
+        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:
+            raise ValueError("No config provided for initialization - config is required")
+            
+        # Validate config type
+        if not isinstance(init_config, FaceRecognitionEmbeddingConfig):
+            raise TypeError(f"Invalid config type for initialization: {type(init_config)}, expected FaceRecognitionEmbeddingConfig")
+            
+        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)
+            
+            # Initialize People activity logging if enabled
+            if init_config.enable_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 init_config.embedding_config:
+                init_config.embedding_config = EmbeddingConfig(
+                    similarity_threshold=init_config.similarity_threshold,
+                    confidence_threshold=init_config.confidence_threshold,
+                    enable_track_id_cache=init_config.enable_track_id_cache,
+                    cache_max_size=init_config.cache_max_size,
+                    cache_ttl=3600
+                )
+            self.embedding_manager = EmbeddingManager(init_config.embedding_config, self.face_client)
+            self.logger.info("Embedding manager initialized")
+            
+            # Initialize TemporalIdentityManager
+            self.temporal_identity_manager = TemporalIdentityManager(
+                face_client=self.face_client,
+                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._initialized = True
+            self.logger.info("Face recognition use case fully initialized")
+            
+        except Exception as e:
+            self.logger.error(f"Error during use case initialization: {e}", exc_info=True)
+            raise RuntimeError(f"Failed to initialize face recognition use case: {e}") from e
 
-    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 +519,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,44 +560,28 @@ 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()
 
-        if not self.face_client:
-            self.face_client = self._get_facial_recognition_client(config)
+        # Ensure use case is initialized (should be done in _get_use_case_instance, not lazy loaded)
+        if not self._initialized:
+            raise RuntimeError(
+                "Face recognition use case not initialized. "
+                "This should be initialized eagerly in PostProcessor._get_use_case_instance()"
+            )
 
+        # Ensure confidence threshold is set
         if not config.confidence_threshold:
             config.confidence_threshold = 0.35
-        
-        # Initialize People activity logging 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
-        if not self.embedding_manager:
-            # Create default embedding config if not provided
-            if not config.embedding_config:
-                config.embedding_config = EmbeddingConfig(
-                    similarity_threshold=config.similarity_threshold,
-                    confidence_threshold=config.confidence_threshold,
-                    enable_track_id_cache=config.enable_track_id_cache,
-                    cache_max_size=config.cache_max_size,
-                    cache_ttl=3600
-                )
-            self.embedding_manager = EmbeddingManager(config.embedding_config, self.face_client)
-
-        # Initialize TemporalIdentityManager (top-1 via API with smoothing)
-        if not self.temporal_identity_manager:
-            self.temporal_identity_manager = TemporalIdentityManager(
-                face_client=self.face_client,
-                recognition_threshold=float(config.similarity_threshold),
-                history_size=20,
-                unknown_patience=7,
-                switch_patience=5,
-                fallback_margin=0.05,
-            )
 
         
         # Detect input format and store in context
@@ -1285,23 +1375,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
@@ -1866,5 +1956,11 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         try:
             if hasattr(self, "people_activity_logging") and self.people_activity_logging:
                 self.people_activity_logging.stop_background_processing()
+        except:
+            pass
+        
+        try:
+            if hasattr(self, "embedding_manager") and self.embedding_manager:
+                self.embedding_manager.stop_background_refresh()
         except:
             pass