matrice-analytics 0.1.60__py3-none-any.whl → 0.1.70__py3-none-any.whl

matrice_analytics/post_processing/face_reg/embedding_manager.py

@@ -234,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]] = []
@@ -330,13 +330,13 @@ class EmbeddingManager:
                     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
@@ -395,13 +395,13 @@ class EmbeddingManager:
         """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})")
+            #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)}, _embeddings_loaded={self._embeddings_loaded}")
+                #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
                 

matrice_analytics/post_processing/face_reg/face_recognition.py

@@ -427,9 +427,9 @@ class FaceRecognitionEmbeddingConfig(BaseConfig):
     smoothing_confidence_range_factor: float = 0.5
 
     # Base confidence threshold (separate from embedding similarity threshold)
-    similarity_threshold: float = 0.45 #-- KEEP IT AT 0.45 ALWAYS
+    similarity_threshold: float = 0.2  # Lowered to match local code - 0.45 was too conservative
     # Base confidence threshold (separate from embedding similarity threshold)
-    confidence_threshold: float = 0.1 #-- KEEP IT AT 0.1 ALWAYS
+    confidence_threshold: float = 0.1  # Detection confidence threshold
     
     # Face recognition optional features
     enable_face_tracking: bool = True  # Enable BYTE TRACKER advanced face tracking -- KEEP IT TRUE ALWAYS
@@ -528,7 +528,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         # Removed lightweight face tracker fallback; we always use AdvancedTracker
         # Optional gating similar to compare_similarity
         self._track_first_seen: Dict[int, int] = {}
-        self._probation_frames: int = 260  # default gate ~4 seconds at 60 fps; tune per stream
+        self._probation_frames: int = 30  # Reduced from 260 - only for "Unknown" label suppression, not recognition
         self._min_face_w: int = 30
         self._min_face_h: int = 30
 
@@ -584,12 +584,12 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             raise TypeError(f"Invalid config type for initialization: {type(init_config)}, expected FaceRecognitionEmbeddingConfig")
             
         self.logger.info("Initializing face recognition use case with provided config")
-        # print("=============== STEP 1: INITIALIZING FACE CLIENT ===============")
+        
         
         # Initialize face client (includes deployment update)
         try:
             self.face_client = await self._get_facial_recognition_client(init_config)
-            # print(f"=============== FACE CLIENT INITIALIZED: {self.face_client is not None} ===============")
+            
             
             # Initialize People activity logging if enabled
             if init_config.enable_people_activity_logging:
@@ -598,9 +598,9 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 self.logger.info("People activity logging enabled and started")
             
             # Initialize EmbeddingManager
-            # print("=============== STEP 2: INITIALIZING EMBEDDING MANAGER ===============")
+            
             if not init_config.embedding_config:
-                # print("=============== CREATING EMBEDDING CONFIG ===============")
+                
                 init_config.embedding_config = EmbeddingConfig(
                     similarity_threshold=init_config.similarity_threshold,
                     confidence_threshold=init_config.confidence_threshold,
@@ -611,14 +611,11 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                     staff_embeddings_cache_ttl=43200,
                 )
             self.embedding_manager = EmbeddingManager(init_config.embedding_config, self.face_client)
-            # print(f"=============== EMBEDDING MANAGER CREATED: {self.embedding_manager is not None} ===============")
+            
             self.logger.info("Embedding manager initialized")
             
-            # Load staff embeddings immediately for fast startup (avoid race conditions)
-            # This MUST succeed before we can proceed - fail fast if it doesn't
-            # print("=============== STEP 3: CALLING _load_staff_embeddings() ===============")
             embeddings_loaded = await self.embedding_manager._load_staff_embeddings()
-            # print(f"=============== EMBEDDINGS LOADED: {embeddings_loaded} ===============")
+            
             
             if not embeddings_loaded:
                 error_msg = "CRITICAL: Failed to load staff embeddings at initialization - cannot proceed without embeddings"
@@ -659,7 +656,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             self.logger.info("Temporal identity manager initialized with embedding manager for local similarity search")
             
             # Final verification before marking as initialized
-            # print("=============== STEP 6: FINAL VERIFICATION ===============")
+
             if not self.embedding_manager.is_ready():
                 status = self.embedding_manager.get_status()
                 error_msg = f"CRITICAL: Final verification failed - embeddings not ready. Status: {status}"
@@ -669,16 +666,10 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             
             # Log detailed status for debugging
             status = self.embedding_manager.get_status()
-            # print(f"=============== FINAL CHECKS PASSED ===============")
-            # print(f"  - Face client: {self.face_client is not None}")
-            # print(f"  - Embedding manager: {self.embedding_manager is not None}")
-            # print(f"  - Embedding manager status: {status}")
-            # print(f"  - Temporal identity manager: {self.temporal_identity_manager is not None}")
             
             self._initialized = True
             self.logger.info("Face recognition use case fully initialized and verified")
-            # print("=============== INITIALIZATION COMPLETE ===============")
-            
+                        
         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
@@ -700,9 +691,16 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             # Call update_deployment if deployment_id is provided
             if config.deployment_id:
                 try:
+                    self.logger.info(f"Updating deployment action with ID: {config.deployment_id}")
+                    response = await self.face_client.update_deployment_action(config.deployment_id)
+                    if response:
+                        self.logger.info(f"Successfully updated deployment action {config.deployment_id}")
+                    else:
+                        self.logger.warning(f"Failed to update deployment: {response.get('error', 'Unknown error')}")
+                    
                     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):
+                    if response:
                         self.logger.info(f"Successfully updated deployment {config.deployment_id}")
                     else:
                         self.logger.warning(f"Failed to update deployment: {response.get('error', 'Unknown error')}")
@@ -835,8 +833,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                                 track_low_thresh=0.05,
                                 new_track_thresh=0.5,
                                 match_thresh=0.8,
-                                track_buffer=int(300),  # allow short occlusions
-                                max_time_lost=int(150),
+                                track_buffer=int(600),  # Increased to match local code - allows longer occlusions
+                                max_time_lost=int(300),  # Increased to match local code
                                 fuse_score=True,
                                 enable_gmc=False,
                                 frame_rate=int(20)
@@ -1197,11 +1195,12 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         else:
             age_frames = 1
 
+        # Eligible for recognition if face is large enough (lowered threshold to match local code behavior)
         eligible_for_recognition = (w_box >= self._min_face_w and h_box >= self._min_face_h)
 
         # Primary: API-based identity smoothing via TemporalIdentityManager
         staff_id = None
-        person_name = "Unknown"
+        person_name = ""
         similarity_score = 0.0
         employee_id = None
         staff_details: Dict[str, Any] = {}
@@ -1273,16 +1272,21 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         # Update detection object directly (avoid relying on SearchResult type)
         detection = detection.copy()
         detection["person_id"] = staff_id
-        detection["person_name"] = person_name or "Unknown"
+        detection["person_name"] = person_name or ""
         detection["recognition_status"] = "known" if staff_id else "unknown"
         detection["employee_id"] = employee_id
         detection["staff_details"] = staff_details if isinstance(staff_details, dict) else {}
         detection["similarity_score"] = float(similarity_score)
         detection["enrolled"] = bool(staff_id)
-        # Display label policy: show only if identified OR probation exceeded, else empty label
+        # Display label policy: ALWAYS show identified faces immediately, only suppress "Unknown" during probation
         is_identified = (staff_id is not None and detection_type == "known")
-        show_label = is_identified or (age_frames >= self._probation_frames and not is_identified)
-        detection["display_name"] = (person_name if is_identified else ("Unknown" if show_label else ""))
+        if is_identified:
+            # Identified faces: show name immediately (no probation delay)
+            detection["display_name"] = person_name
+        else:
+            # Unknown faces: only show "Unknown" label after probation period to avoid flicker
+            show_unknown_label = (age_frames >= self._probation_frames)
+            detection["display_name"] = "" if show_unknown_label else "" #TODO: Maybe replace this with "Unknown" bec probationif fail we show unknown.
         # Preserve original category (e.g., 'face') for tracking/counting
 
         # Update global tracking per unique internal track id to avoid double-counting within a frame
@@ -1335,7 +1339,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         except Exception as e:
             self.logger.error(f"Error enqueueing detection for activity logging: {e}")
         # print("------------------PROCESS FACE LATENCY TOTAL----------------------------")
-        print("LATENCY:",(time.time() - st2)*1000,"| Throughput fps:",(1.0 / (time.time() - st2)) if (time.time() - st2) > 0 else None)
+        #print("LATENCY:",(time.time() - st2)*1000,"| Throughput fps:",(1.0 / (time.time() - st2)) if (time.time() - st2) > 0 else None)
         # print("------------------PROCESS FACE LATENCY TOTAL----------------------------")
 
         return detection

matrice_analytics/post_processing/face_reg/face_recognition_client.py

@@ -510,6 +510,42 @@ class FacialRecognitionClient:
         except Exception as e:
             self.logger.error(f"API ERROR: Update deployment request failed - deployment_id={deployment_id} - {e}", exc_info=True)
             return {"success": False, "error": str(e)}
+
+    async def update_deployment_action(self, deployment_id: str) -> Dict[str, Any]:
+        """Update deployment action in backend
+        
+        API: PUT /internal/v1/actions/update_facial_recognition_deployment/:server_id?app_deployment_id=:deployment_id
+        
+        Args:
+            deployment_id: The deployment ID to update
+            
+        Returns:
+            Dict containing response data
+        """
+        if not deployment_id:
+            self.logger.warning("No deployment_id provided for update_deployment_action")
+            return {"success": False, "error": "deployment_id is required"}
+
+        self.logger.info(f"API REQUEST: Updating deployment action - deployment_id={deployment_id}")
+
+        # Use Matrice session for async RPC call to backend (not facial recognition server)
+        try:
+            response = await self.session.rpc.async_send_request(
+                method="PUT",
+                path=f"/internal/v1/actions/update_facial_recognition_deployment/{self.server_id}?app_deployment_id={deployment_id}",
+                payload={},
+                base_url="https://prod.backend.app.matrice.ai"
+            )
+            
+            if response.get('success', False):
+                self.logger.info(f"API RESPONSE: Deployment action updated successfully - deployment_id={deployment_id}")
+            else:
+                self.logger.warning(f"Failed to update deployment action for deployment_id={deployment_id}: {response.get('error', 'Unknown error')}")
+            
+            return self._handle_response(response)
+        except Exception as e:
+            self.logger.error(f"API ERROR: Update deployment action request failed - deployment_id={deployment_id} - {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
     
     async def enroll_unknown_person(self, embedding: List[float], image_source: str = None, timestamp: str = None, location: str = None, employee_id: str = None) -> Dict[str, Any]:
         """Enroll an unknown person

matrice_analytics/post_processing/usecases/fire_detection.py

@@ -245,8 +245,8 @@ class FireSmokeUseCase(BaseProcessor):
             business_analytics = business_analytics_list[0] if business_analytics_list else []
             summary = summary_list[0] if summary_list else {}
             agg_summary = {str(frame_number): {
-                            "incidents": [incidents],
-                            "tracking_stats": [tracking_stats],
+                            "incidents": incidents,
+                            "tracking_stats": tracking_stats,
                             "business_analytics": business_analytics,
                             "alerts": alerts,
                             "human_text": summary}

matrice_analytics/post_processing/usecases/license_plate_monitoring.py

@@ -575,7 +575,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         print(f"[LP_LOGGING] Starting plate logging check - detections count: {len(detections)}")
         self.logger.info(f"[LP_LOGGING] Starting plate logging check - detections count: {len(detections)}")
         self.logger.info(f"[LP_LOGGING] Logging enabled: {self._logging_enabled}, Plate logger exists: {self.plate_logger is not None}, Stream info exists: {stream_info is not None}")
-        
+        #self._logging_enabled=False  
         if not self._logging_enabled:
             print("[LP_LOGGING] Plate logging is DISABLED")
             self.logger.warning("[LP_LOGGING] Plate logging is DISABLED - logging_enabled flag is False")

matrice_analytics/post_processing/usecases/weapon_detection.py

@@ -585,23 +585,6 @@ class WeaponDetectionUseCase(BaseProcessor):
         """Return total unique track_id count for each category."""
         return {cat: len(ids) for cat, ids in getattr(self, '_per_category_total_track_ids', {}).items()}
 
-    def _format_timestamp(self, timestamp: Any) -> str:
-        """Format a timestamp so that exactly two digits follow the decimal point (milliseconds)."""
-        if isinstance(timestamp, (int, float)):
-            timestamp = datetime.fromtimestamp(timestamp, timezone.utc).strftime('%Y-%m-%d-%H:%M:%S.%f UTC')
-        if not isinstance(timestamp, str):
-            return str(timestamp)
-        if '.' not in timestamp:
-            return timestamp
-        main_part, fractional_and_suffix = timestamp.split('.', 1)
-        if ' ' in fractional_and_suffix:
-            fractional_part, suffix = fractional_and_suffix.split(' ', 1)
-            suffix = ' ' + suffix
-        else:
-            fractional_part, suffix = fractional_and_suffix, ''
-        fractional_part = (fractional_part + '00')[:2]
-        return f"{main_part}.{fractional_part}{suffix}"
-
     def _format_timestamp_for_stream(self, timestamp: float) -> str:
         """Format timestamp for streams (YYYY:MM:DD HH:MM:SS format)."""
         dt = datetime.fromtimestamp(timestamp, tz=timezone.utc)
@@ -614,8 +597,56 @@ class WeaponDetectionUseCase(BaseProcessor):
         seconds = round(float(timestamp % 60), 2)
         return f"{hours:02d}:{minutes:02d}:{seconds:.1f}"
 
+    def _format_timestamp(self, timestamp: Any) -> str:
+        """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 be converted to datetime.
+        2. A string in the format ``YYYY-MM-DD-HH:MM:SS.ffffff UTC``.
+
+        The returned value will be in the format: YYYY:MM:DD HH:MM:SS (no milliseconds, no UTC suffix).
+
+        Example
+        -------
+        >>> self._format_timestamp("2025-10-27-19:31:20.187574 UTC")
+        '2025:10:27 19:31:20'
+        """
+
+        # Convert numeric timestamps to datetime first
+        if isinstance(timestamp, (int, float)):
+            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)
+
+        # Remove ' UTC' suffix if present
+        timestamp_clean = timestamp.replace(' UTC', '').strip()
+
+        # Remove milliseconds if present (everything after the last dot)
+        if '.' in timestamp_clean:
+            timestamp_clean = timestamp_clean.split('.')[0]
+
+        # 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
+
+        # 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:
@@ -625,15 +656,20 @@ class WeaponDetectionUseCase(BaseProcessor):
                 else:
                     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")
+
         if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
             if frame_id:
                 start_time = int(frame_id)/stream_info.get("input_settings", {}).get("original_fps", 30)
             else:
                 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", "")
@@ -652,24 +688,62 @@ class WeaponDetectionUseCase(BaseProcessor):
         """Get formatted start timestamp for 'TOTAL SINCE' based on stream type."""
         if not stream_info:
             return "00:00:00"
+        
         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:
                 stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
                 if stream_time_str:
@@ -681,10 +755,12 @@ class WeaponDetectionUseCase(BaseProcessor):
                         self._tracking_start_time = time.time()
                 else:
                     self._tracking_start_time = time.time()
+
             dt = datetime.fromtimestamp(self._tracking_start_time, tz=timezone.utc)
             dt = dt.replace(minute=0, second=0, microsecond=0)
             return dt.strftime('%Y:%m:%d %H:%M:%S')
 
+
     def _compute_iou(self, box1: Any, box2: Any) -> float:
         """Compute IoU between two bounding boxes."""
         def _bbox_to_list(bbox):

{matrice_analytics-0.1.60.dist-info → matrice_analytics-0.1.70.dist-info}/METADATA

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

{matrice_analytics-0.1.60.dist-info → matrice_analytics-0.1.70.dist-info}/RECORD

@@ -28,9 +28,9 @@ matrice_analytics/post_processing/core/config.py,sha256=uyxWndO-DE9PeGD_h5K3TeB0
 matrice_analytics/post_processing/core/config_utils.py,sha256=QuAS-_JKSoNOtfUWgr7Alf_wsqODzN2rHlQu-cHRK0s,34311
 matrice_analytics/post_processing/face_reg/__init__.py,sha256=yntaiGlW9vdjBpPZQXNuovALihJPzRlFyUE88l3MhBA,1364
 matrice_analytics/post_processing/face_reg/compare_similarity.py,sha256=NlFc8b2a74k0PqSFAbuM_fUbA1BT3pr3VUgvSqRpJzQ,23396
-matrice_analytics/post_processing/face_reg/embedding_manager.py,sha256=zd4KIqZijRssPzA7QJsg9-DCJ983aIyUPoo8WuRW2rs,44956
-matrice_analytics/post_processing/face_reg/face_recognition.py,sha256=NuTf_fYbP6MvR5pmCmk0b04wm-tiakAzXcU_ZnMcQWQ,109385
-matrice_analytics/post_processing/face_reg/face_recognition_client.py,sha256=jAwJ74i4euQWidT7rKdWicHLSzS9RHx0JJEerTRw_KM,28544
+matrice_analytics/post_processing/face_reg/embedding_manager.py,sha256=3Rba94EcYWFK0D4el9JZ7fwqQ9kOyadrwK30lFmTP-k,44964
+matrice_analytics/post_processing/face_reg/face_recognition.py,sha256=QpiIB0POkVknNr80o5_S3cCHUzGSvbEzO563vVxc0uo,109071
+matrice_analytics/post_processing/face_reg/face_recognition_client.py,sha256=4RhneX-P1IEXsvMllNW3tA8XAAKnvlsZLwNvO8ehdYY,30344
 matrice_analytics/post_processing/face_reg/people_activity_logging.py,sha256=vZbIvkK1h3h58ROeF0_ygF3lqr19O2h5222bN8XyIis,13675
 matrice_analytics/post_processing/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 matrice_analytics/post_processing/ocr/easyocr_extractor.py,sha256=RMrRoGb2gMcJEGouQn8U9cCgCLXPT7qRa8liI4LNxFM,11555
@@ -116,7 +116,7 @@ matrice_analytics/post_processing/usecases/face_emotion.py,sha256=eRfqBdryB0uNoO
 matrice_analytics/post_processing/usecases/face_recognition.py,sha256=T5xAuv6b9OrkmTmoXgZs4LZ5XUsbvp9xCpeLBwdu7eI,40231
 matrice_analytics/post_processing/usecases/fashion_detection.py,sha256=f9gpzMDhIW-gyn46k9jgf8nY7YeoqAnTxGOzksabFbE,40457
 matrice_analytics/post_processing/usecases/field_mapping.py,sha256=JDwYX8pd2W-waDvBh98Y_o_uchJu7wEYbFxOliA4Iq4,39822
-matrice_analytics/post_processing/usecases/fire_detection.py,sha256=o57jhIrsVBRkpD4nzaUHyuBRA4YZb3yNvQz0Ri_xiVg,54613
+matrice_analytics/post_processing/usecases/fire_detection.py,sha256=-xB9K-2PSqsRWMeZ961aT5dhPzHlw0h8m3wuJotjOG0,54609
 matrice_analytics/post_processing/usecases/flare_analysis.py,sha256=3nf4fUeUwlP_UII0h5fQkUGPXbr32ZnJjaM-dukNSP8,42680
 matrice_analytics/post_processing/usecases/flower_segmentation.py,sha256=4I7qMx9Ztxg_hy9KTVX-3qBhAN-QwDt_Yigf9fFjLus,52017
 matrice_analytics/post_processing/usecases/gas_leak_detection.py,sha256=KL2ft7fXvjTas-65-QgcJm3W8KBsrwF44qibSXjfaLc,40557
@@ -127,7 +127,7 @@ matrice_analytics/post_processing/usecases/leaf.py,sha256=cwgB1ZNxkQFtkk-thSJrkX
 matrice_analytics/post_processing/usecases/leaf_disease.py,sha256=bkiLccTdf4KUq3he4eCpBlKXb5exr-WBhQ_oWQ7os68,36225
 matrice_analytics/post_processing/usecases/leak_detection.py,sha256=oOCLLVMuXVeXPHyN8FUrD3U9JYJJwIz-5fcEMgvLdls,40531
 matrice_analytics/post_processing/usecases/license_plate_detection.py,sha256=dsavd92-wnyXCNrCzaRj24zH7BVvLSa09HkYsrOXYDM,50806
-matrice_analytics/post_processing/usecases/license_plate_monitoring.py,sha256=hjc9tQkUzVwvWuNohw28P2SJNHb25P5ERZbNlRkSKOk,91379
+matrice_analytics/post_processing/usecases/license_plate_monitoring.py,sha256=2fOfjqhpjw2Ql9pNaZ8phXXDvLcVjiXDuPo74dAXlI8,91409
 matrice_analytics/post_processing/usecases/litter_monitoring.py,sha256=XaHAUGRBDJg_iVbu8hRMjTR-5TqrLj6ZNCRkInbzZTY,33255
 matrice_analytics/post_processing/usecases/mask_detection.py,sha256=L_s6ZiT5zeXG-BsFcskb3HEG98DhLgqeMSDmCuwOteU,41501
 matrice_analytics/post_processing/usecases/natural_disaster.py,sha256=ehxdPBoYcZWGVDOVn_mHFoz4lIE8LrveAkuXQj0n9XE,44253
@@ -162,7 +162,7 @@ matrice_analytics/post_processing/usecases/underwater_pollution_detection.py,sha
 matrice_analytics/post_processing/usecases/vehicle_monitoring.py,sha256=QsO-coozfy29rY6NszwA6A7nFBOGysfMz5S5VVY7Beg,52849
 matrice_analytics/post_processing/usecases/warehouse_object_segmentation.py,sha256=5uZXTJL_A3tUEN08T-_ZQpUoJ9gqbuuMc4z2mT4sMnQ,43753
 matrice_analytics/post_processing/usecases/waterbody_segmentation.py,sha256=JsCxDEMB8s4WDcezfJDr2zrjM-TCjB9hxOztzSvWmpY,45268
-matrice_analytics/post_processing/usecases/weapon_detection.py,sha256=AhbVpJaa2I3aRCEAdIxovY5xd9370dUY4JllCQ8tdT4,37185
+matrice_analytics/post_processing/usecases/weapon_detection.py,sha256=12fwL3IT26fxdq5aZWbZcrei6JGmhMWxal4q8brUv8E,40614
 matrice_analytics/post_processing/usecases/weld_defect_detection.py,sha256=b0dAJGKUofbGrwHDJfIYb4pqmvp4Y23JK09Qb-34mxg,30209
 matrice_analytics/post_processing/usecases/wildlife_monitoring.py,sha256=TMVHJ5GLezmqG7DywmqbLggqNXgpsb63MD7IR6kvDkk,43446
 matrice_analytics/post_processing/usecases/windmill_maintenance.py,sha256=G1eqo3Z-HYmGJ6oeZYrpZwhpvqQ9Lc_T-6S7BLBXHeA,40498
@@ -189,8 +189,8 @@ matrice_analytics/post_processing/utils/format_utils.py,sha256=UTF7A5h9j0_S12xH9
 matrice_analytics/post_processing/utils/geometry_utils.py,sha256=BWfdM6RsdJTTLR1GqkWfdwpjMEjTCJyuBxA4zVGKdfk,9623
 matrice_analytics/post_processing/utils/smoothing_utils.py,sha256=78U-yucAcjUiZ0NIAc9NOUSIT0PWP1cqyIPA_Fdrjp0,14699
 matrice_analytics/post_processing/utils/tracking_utils.py,sha256=rWxuotnJ3VLMHIBOud2KLcu4yZfDp7hVPWUtNAq_2xw,8288
-matrice_analytics-0.1.60.dist-info/licenses/LICENSE.txt,sha256=_uQUZpgO0mRYL5-fPoEvLSbNnLPv6OmbeEDCHXhK6Qc,1066
-matrice_analytics-0.1.60.dist-info/METADATA,sha256=Nc2fVe_HdrRGNjWz2SWcdG4JlgSZ6FXdduSPaBkSw60,14378
-matrice_analytics-0.1.60.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice_analytics-0.1.60.dist-info/top_level.txt,sha256=STAPEU-e-rWTerXaspdi76T_eVRSrEfFpURSP7_Dt8E,18
-matrice_analytics-0.1.60.dist-info/RECORD,,
+matrice_analytics-0.1.70.dist-info/licenses/LICENSE.txt,sha256=_uQUZpgO0mRYL5-fPoEvLSbNnLPv6OmbeEDCHXhK6Qc,1066
+matrice_analytics-0.1.70.dist-info/METADATA,sha256=Kx834enthybusq864ukKPcMmcuCE9b6laG_8N3ESJbA,14378
+matrice_analytics-0.1.70.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice_analytics-0.1.70.dist-info/top_level.txt,sha256=STAPEU-e-rWTerXaspdi76T_eVRSrEfFpURSP7_Dt8E,18
+matrice_analytics-0.1.70.dist-info/RECORD,,