matrice-analytics 0.1.43__py3-none-any.whl → 0.1.44__py3-none-any.whl

matrice_analytics/post_processing/face_reg/face_recognition.py

@@ -1743,56 +1743,57 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         return f"{hours:02d}:{minutes:02d}:{seconds:.1f}"
 
     def _format_timestamp(self, timestamp: Any) -> str:
-        """Format a timestamp so that exactly two digits follow the decimal point (milliseconds).
+        """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 first be converted to a
-           string in the format ``YYYY-MM-DD-HH:MM:SS.ffffff UTC``.
-        2. A string already following the same layout.
+        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 preserves the overall format of the input but truncates or pads
-        the fractional seconds portion to **exactly two digits**.
+        The returned value will be in the format: YYYY:MM:DD HH:MM:SS (no milliseconds, no UTC suffix).
 
         Example
         -------
-        >>> self._format_timestamp("2025-08-19-04:22:47.187574 UTC")
-        '2025-08-19-04:22:47.18 UTC'
+        >>> self._format_timestamp("2025-10-27-19:31:20.187574 UTC")
+        '2025:10:27 19:31:20'
         """
 
-        # Convert numeric timestamps to the expected string representation first
+        # Convert numeric timestamps to datetime first
         if isinstance(timestamp, (int, float)):
-            timestamp = datetime.fromtimestamp(timestamp, timezone.utc).strftime(
-                '%Y-%m-%d-%H:%M:%S.%f UTC'
-            )
+            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)
 
-        # If there is no fractional component, simply return the original string
-        if '.' not in timestamp:
-            return timestamp
+        # Remove ' UTC' suffix if present
+        timestamp_clean = timestamp.replace(' UTC', '').strip()
 
-        # Split out the main portion (up to the decimal point)
-        main_part, fractional_and_suffix = timestamp.split('.', 1)
-
-        # Separate fractional digits from the suffix (typically ' UTC')
-        if ' ' in fractional_and_suffix:
-            fractional_part, suffix = fractional_and_suffix.split(' ', 1)
-            suffix = ' ' + suffix  # Re-attach the space removed by split
-        else:
-            fractional_part, suffix = fractional_and_suffix, ''
+        # Remove milliseconds if present (everything after the last dot)
+        if '.' in timestamp_clean:
+            timestamp_clean = timestamp_clean.split('.')[0]
 
-        # Guarantee exactly two digits for the fractional part
-        fractional_part = (fractional_part + '00')[:2]
+        # 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
 
-        return f"{main_part}.{fractional_part}{suffix}"
+        # 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:
             if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
                 if frame_id:
@@ -1801,7 +1802,6 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                     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")
@@ -1813,7 +1813,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 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", "")
@@ -1835,23 +1836,57 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         
         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:

matrice_analytics/post_processing/usecases/color_detection.py

@@ -1617,6 +1617,53 @@ class ColorDetectionUseCase(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."""
         
@@ -1630,7 +1677,6 @@ class ColorDetectionUseCase(BaseProcessor):
                     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")
@@ -1642,7 +1688,8 @@ class ColorDetectionUseCase(BaseProcessor):
                 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", "")
@@ -1661,26 +1708,60 @@ class ColorDetectionUseCase(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", datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC"))
+                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", datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC"))
+                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", datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC"))
+            # 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", datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC"))
+            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:
@@ -1699,52 +1780,6 @@ class ColorDetectionUseCase(BaseProcessor):
             dt = dt.replace(minute=0, second=0, microsecond=0)
             return dt.strftime('%Y:%m:%d %H:%M:%S')
 
-    def _format_timestamp(self, timestamp: Any) -> str:
-        """Format a timestamp so that exactly two digits follow the decimal point (milliseconds).
-
-        The input can be either:
-        1. A numeric Unix timestamp (``float`` / ``int``) – it will first be converted to a
-           string in the format ``YYYY-MM-DD-HH:MM:SS.ffffff UTC``.
-        2. A string already following the same layout.
-
-        The returned value preserves the overall format of the input but truncates or pads
-        the fractional seconds portion to **exactly two digits**.
-
-        Example
-        -------
-        >>> self._format_timestamp("2025-08-19-04:22:47.187574 UTC")
-        '2025-08-19-04:22:47.18 UTC'
-        """
-
-        # Convert numeric timestamps to the expected string representation first
-        if isinstance(timestamp, (int, float)):
-            timestamp = datetime.fromtimestamp(timestamp, timezone.utc).strftime(
-                '%Y-%m-%d-%H:%M:%S.%f UTC'
-            )
-
-        # Ensure we are working with a string from here on
-        if not isinstance(timestamp, str):
-            return str(timestamp)
-
-        # If there is no fractional component, simply return the original string
-        if '.' not in timestamp:
-            return timestamp
-
-        # Split out the main portion (up to the decimal point)
-        main_part, fractional_and_suffix = timestamp.split('.', 1)
-
-        # Separate fractional digits from the suffix (typically ' UTC')
-        if ' ' in fractional_and_suffix:
-            fractional_part, suffix = fractional_and_suffix.split(' ', 1)
-            suffix = ' ' + suffix  # Re-attach the space removed by split
-        else:
-            fractional_part, suffix = fractional_and_suffix, ''
-
-        # Guarantee exactly two digits for the fractional part
-        fractional_part = (fractional_part + '00')[:2]
-
-        return f"{main_part}.{fractional_part}{suffix}"
-
     def _get_tracking_start_time(self) -> str:
         """Get the tracking start time, formatted as a string."""
         if self._tracking_start_time is None:

matrice_analytics/post_processing/usecases/fire_detection.py

@@ -892,11 +892,58 @@ class FireSmokeUseCase(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:
             if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
                 if frame_id:
@@ -905,7 +952,6 @@ class FireSmokeUseCase(BaseProcessor):
                     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")
@@ -917,7 +963,8 @@ class FireSmokeUseCase(BaseProcessor):
                 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", "")
@@ -939,23 +986,57 @@ class FireSmokeUseCase(BaseProcessor):
         
         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:
@@ -974,52 +1055,6 @@ class FireSmokeUseCase(BaseProcessor):
             dt = dt.replace(minute=0, second=0, microsecond=0)
             return dt.strftime('%Y:%m:%d %H:%M:%S')
 
-    def _format_timestamp(self, timestamp: Any) -> str:
-        """Format a timestamp so that exactly two digits follow the decimal point (milliseconds).
-
-        The input can be either:
-        1. A numeric Unix timestamp (``float`` / ``int``) – it will first be converted to a
-           string in the format ``YYYY-MM-DD-HH:MM:SS.ffffff UTC``.
-        2. A string already following the same layout.
-
-        The returned value preserves the overall format of the input but truncates or pads
-        the fractional seconds portion to **exactly two digits**.
-
-        Example
-        -------
-        >>> self._format_timestamp("2025-08-19-04:22:47.187574 UTC")
-        '2025-08-19-04:22:47.18 UTC'
-        """
-
-        # Convert numeric timestamps to the expected string representation first
-        if isinstance(timestamp, (int, float)):
-            timestamp = datetime.fromtimestamp(timestamp, timezone.utc).strftime(
-                '%Y-%m-%d-%H:%M:%S.%f UTC'
-            )
-
-        # Ensure we are working with a string from here on
-        if not isinstance(timestamp, str):
-            return str(timestamp)
-
-        # If there is no fractional component, simply return the original string
-        if '.' not in timestamp:
-            return timestamp
-
-        # Split out the main portion (up to the decimal point)
-        main_part, fractional_and_suffix = timestamp.split('.', 1)
-
-        # Separate fractional digits from the suffix (typically ' UTC')
-        if ' ' in fractional_and_suffix:
-            fractional_part, suffix = fractional_and_suffix.split(' ', 1)
-            suffix = ' ' + suffix  # Re-attach the space removed by split
-        else:
-            fractional_part, suffix = fractional_and_suffix, ''
-
-        # Guarantee exactly two digits for the fractional part
-        fractional_part = (fractional_part + '00')[:2]
-
-        return f"{main_part}.{fractional_part}{suffix}"
-
     def get_duration_seconds(self, start_time, end_time):
         def parse_relative_time(t):
             """Parse HH:MM:SS(.f) manually into timedelta"""

matrice_analytics/post_processing/usecases/license_plate_monitoring.py

@@ -1566,63 +1566,64 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         }
         return canonical_id
 
+    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)
+        return dt.strftime('%Y:%m:%d %H:%M:%S')
+
+    def _format_timestamp_for_video(self, timestamp: float) -> str:
+        """Format timestamp for video chunks (HH:MM:SS.ms format)."""
+        hours = int(timestamp // 3600)
+        minutes = int((timestamp % 3600) // 60)
+        seconds = round(float(timestamp % 60), 2)
+        return f"{hours:02d}:{minutes:02d}:{seconds:.1f}"
+
     def _format_timestamp(self, timestamp: Any) -> str:
-        """Format a timestamp so that exactly two digits follow the decimal point (milliseconds).
+        """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 first be converted to a
-           string in the format ``YYYY-MM-DD-HH:MM:SS.ffffff UTC``.
-        2. A string already following the same layout.
+        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 preserves the overall format of the input but truncates or pads
-        the fractional seconds portion to **exactly two digits**.
+        The returned value will be in the format: YYYY:MM:DD HH:MM:SS (no milliseconds, no UTC suffix).
 
         Example
         -------
-        >>> self._format_timestamp("2025-08-19-04:22:47.187574 UTC")
-        '2025-08-19-04:22:47.18 UTC'
+        >>> self._format_timestamp("2025-10-27-19:31:20.187574 UTC")
+        '2025:10:27 19:31:20'
         """
 
-        # Convert numeric timestamps to the expected string representation first
+        # Convert numeric timestamps to datetime first
         if isinstance(timestamp, (int, float)):
-            timestamp = datetime.fromtimestamp(timestamp, timezone.utc).strftime(
-                '%Y-%m-%d-%H:%M:%S.%f UTC'
-            )
+            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)
 
-        # If there is no fractional component, simply return the original string
-        if '.' not in timestamp:
-            return timestamp
-
-        # Split out the main portion (up to the decimal point)
-        main_part, fractional_and_suffix = timestamp.split('.', 1)
-
-        # Separate fractional digits from the suffix (typically ' UTC')
-        if ' ' in fractional_and_suffix:
-            fractional_part, suffix = fractional_and_suffix.split(' ', 1)
-            suffix = ' ' + suffix  # Re-attach the space removed by split
-        else:
-            fractional_part, suffix = fractional_and_suffix, ''
-
-        # Guarantee exactly two digits for the fractional part
-        fractional_part = (fractional_part + '00')[:2]
+        # Remove ' UTC' suffix if present
+        timestamp_clean = timestamp.replace(' UTC', '').strip()
 
-        return f"{main_part}.{fractional_part}{suffix}"
+        # Remove milliseconds if present (everything after the last dot)
+        if '.' in timestamp_clean:
+            timestamp_clean = timestamp_clean.split('.')[0]
 
-    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)
-        return dt.strftime('%Y:%m:%d %H:%M:%S')
-
-    def _format_timestamp_for_video(self, timestamp: float) -> str:
-        """Format timestamp for video chunks (HH:MM:SS.ms format)."""
-        hours = int(timestamp // 3600)
-        minutes = int((timestamp % 3600) // 60)
-        seconds = round(float(timestamp % 60), 2)
-        return f"{hours:02d}:{minutes:02d}:{seconds:.1f}"
+        # 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."""
@@ -1671,23 +1672,57 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         
         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:
@@ -1705,7 +1740,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             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 _get_tracking_start_time(self) -> str:
         """Get the tracking start time, formatted as a string."""
         if self._tracking_start_time is None:

matrice_analytics/post_processing/usecases/people_counting.py

@@ -437,50 +437,51 @@ class PeopleCountingUseCase(BaseProcessor):
         return f"{hours:02d}:{minutes:02d}:{seconds:.1f}"
 
     def _format_timestamp(self, timestamp: Any) -> str:
-        """Format a timestamp so that exactly two digits follow the decimal point (milliseconds).
+        """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 first be converted to a
-           string in the format ``YYYY-MM-DD-HH:MM:SS.ffffff UTC``.
-        2. A string already following the same layout.
+        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 preserves the overall format of the input but truncates or pads
-        the fractional seconds portion to **exactly two digits**.
+        The returned value will be in the format: YYYY:MM:DD HH:MM:SS (no milliseconds, no UTC suffix).
 
         Example
         -------
-        >>> self._format_timestamp("2025-08-19-04:22:47.187574 UTC")
-        '2025-08-19-04:22:47.18 UTC'
+        >>> self._format_timestamp("2025-10-27-19:31:20.187574 UTC")
+        '2025:10:27 19:31:20'
         """
 
-        # Convert numeric timestamps to the expected string representation first
+        # Convert numeric timestamps to datetime first
         if isinstance(timestamp, (int, float)):
-            timestamp = datetime.fromtimestamp(timestamp, timezone.utc).strftime(
-                '%Y-%m-%d-%H:%M:%S.%f UTC'
-            )
+            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)
 
-        # If there is no fractional component, simply return the original string
-        if '.' not in timestamp:
-            return timestamp
-
-        # Split out the main portion (up to the decimal point)
-        main_part, fractional_and_suffix = timestamp.split('.', 1)
+        # Remove ' UTC' suffix if present
+        timestamp_clean = timestamp.replace(' UTC', '').strip()
 
-        # Separate fractional digits from the suffix (typically ' UTC')
-        if ' ' in fractional_and_suffix:
-            fractional_part, suffix = fractional_and_suffix.split(' ', 1)
-            suffix = ' ' + suffix  # Re-attach the space removed by split
-        else:
-            fractional_part, suffix = fractional_and_suffix, ''
-
-        # Guarantee exactly two digits for the fractional part
-        fractional_part = (fractional_part + '00')[:2]
+        # Remove milliseconds if present (everything after the last dot)
+        if '.' in timestamp_clean:
+            timestamp_clean = timestamp_clean.split('.')[0]
 
-        return f"{main_part}.{fractional_part}{suffix}"
+        # 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."""

matrice_analytics/post_processing/usecases/vehicle_monitoring.py

@@ -759,11 +759,58 @@ class VehicleMonitoringUseCase(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:
             if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
                 if frame_id:
@@ -772,7 +819,6 @@ class VehicleMonitoringUseCase(BaseProcessor):
                     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")
@@ -784,7 +830,8 @@ class VehicleMonitoringUseCase(BaseProcessor):
                 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", "")
@@ -806,23 +853,57 @@ class VehicleMonitoringUseCase(BaseProcessor):
         
         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:
@@ -841,52 +922,6 @@ class VehicleMonitoringUseCase(BaseProcessor):
             dt = dt.replace(minute=0, second=0, microsecond=0)
             return dt.strftime('%Y:%m:%d %H:%M:%S')
 
-    def _format_timestamp(self, timestamp: Any) -> str:
-        """Format a timestamp so that exactly two digits follow the decimal point (milliseconds).
-
-        The input can be either:
-        1. A numeric Unix timestamp (``float`` / ``int``) – it will first be converted to a
-           string in the format ``YYYY-MM-DD-HH:MM:SS.ffffff UTC``.
-        2. A string already following the same layout.
-
-        The returned value preserves the overall format of the input but truncates or pads
-        the fractional seconds portion to **exactly two digits**.
-
-        Example
-        -------
-        >>> self._format_timestamp("2025-08-19-04:22:47.187574 UTC")
-        '2025-08-19-04:22:47.18 UTC'
-        """
-
-        # Convert numeric timestamps to the expected string representation first
-        if isinstance(timestamp, (int, float)):
-            timestamp = datetime.fromtimestamp(timestamp, timezone.utc).strftime(
-                '%Y-%m-%d-%H:%M:%S.%f UTC'
-            )
-
-        # Ensure we are working with a string from here on
-        if not isinstance(timestamp, str):
-            return str(timestamp)
-
-        # If there is no fractional component, simply return the original string
-        if '.' not in timestamp:
-            return timestamp
-
-        # Split out the main portion (up to the decimal point)
-        main_part, fractional_and_suffix = timestamp.split('.', 1)
-
-        # Separate fractional digits from the suffix (typically ' UTC')
-        if ' ' in fractional_and_suffix:
-            fractional_part, suffix = fractional_and_suffix.split(' ', 1)
-            suffix = ' ' + suffix  # Re-attach the space removed by split
-        else:
-            fractional_part, suffix = fractional_and_suffix, ''
-
-        # Guarantee exactly two digits for the fractional part
-        fractional_part = (fractional_part + '00')[:2]
-
-        return f"{main_part}.{fractional_part}{suffix}"
-
     def _count_categories(self, detections: list, config: VehicleMonitoringConfig) -> dict:
         counts = {}
         for det in detections:

{matrice_analytics-0.1.43.dist-info → matrice_analytics-0.1.44.dist-info}/METADATA

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

{matrice_analytics-0.1.43.dist-info → matrice_analytics-0.1.44.dist-info}/RECORD

@@ -29,7 +29,7 @@ matrice_analytics/post_processing/core/config_utils.py,sha256=QuAS-_JKSoNOtfUWgr
 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=qbh0df3-YbE0qvFDQvjpCg-JrsCZRJ5capjQ2LPOj1k,35619
-matrice_analytics/post_processing/face_reg/face_recognition.py,sha256=17RVs_5BtGw2ruksL2JLbpXljbs4-96tP-yKGX3hrOI,90232
+matrice_analytics/post_processing/face_reg/face_recognition.py,sha256=eXzd2hc3qYtYLOxc32l5KAvqS1pIZQTKUhG4wPRMwOc,92552
 matrice_analytics/post_processing/face_reg/face_recognition_client.py,sha256=YaC73mN0yrHZYkjJ7nZIZen5YCVOwEX2gn6I1XpHTW0,27575
 matrice_analytics/post_processing/face_reg/people_activity_logging.py,sha256=NhJXy9jCy_mlZiDXv8IeGyrRN_TL0kKCe3ZOlaNbZUw,13676
 matrice_analytics/post_processing/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -100,7 +100,7 @@ matrice_analytics/post_processing/usecases/cardiomegaly_classification.py,sha256
 matrice_analytics/post_processing/usecases/cell_microscopy_segmentation.py,sha256=eQ_s5u3Vnvja6-FmI6ZPxlNkaZtG-pVjTu8NuLjZJ5M,43714
 matrice_analytics/post_processing/usecases/chicken_pose_detection.py,sha256=-e8di7Am-E-FCQFrSY8qJTO1aWtdRAVJoE-VKBgcyyI,29291
 matrice_analytics/post_processing/usecases/child_monitoring.py,sha256=z3oymoqq4hDGwA8MkdEONZW_Vx5CAZmvzZaNLsqmCfw,39380
-matrice_analytics/post_processing/usecases/color_detection.py,sha256=gucKGrIexZ8fgARzehrXXPBHxNVw1u5-OqF2HysH-eo,90293
+matrice_analytics/post_processing/usecases/color_detection.py,sha256=56oLhecGN8jaPcRLNpZ-AJYjhYqvcRq_BX7rjkPHW0s,92361
 matrice_analytics/post_processing/usecases/color_map_utils.py,sha256=SP-AEVcjLmL8rxblu-ixqUJC2fqlcr7ab4hWo4Fcr_k,2677
 matrice_analytics/post_processing/usecases/concrete_crack_detection.py,sha256=pxhOH_hG4hq9yytNepbGMdk2W_lTG8D1_2RAagaPBkg,40252
 matrice_analytics/post_processing/usecases/crop_weed_detection.py,sha256=Ao1k5fJDYU_f6yZ8VO-jW8-esECV0-zY5Q570c_fako,35674
@@ -115,7 +115,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=6ZwIWSweFZoeRk1CoOtOdlEV-CtYj3gWnhSQw6ONZxg,52294
+matrice_analytics/post_processing/usecases/fire_detection.py,sha256=3ZZZrIXtZ_Ui3d3nQxvj12pqFTgguRN4OiE0cQYNXhg,54614
 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
@@ -126,7 +126,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=Mu8Hu1EqTwYQ1lqDyz3mioDiTDJddIT2F2HbLWeZSfc,89059
+matrice_analytics/post_processing/usecases/license_plate_monitoring.py,sha256=hjc9tQkUzVwvWuNohw28P2SJNHb25P5ERZbNlRkSKOk,91379
 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
@@ -134,7 +134,7 @@ matrice_analytics/post_processing/usecases/parking.py,sha256=lqTGqcjUZZPFw3tu11H
 matrice_analytics/post_processing/usecases/parking_space_detection.py,sha256=xwhkJjGGKcT827URbasi3olYqhd95Sh0zsEIphwzcgY,39561
 matrice_analytics/post_processing/usecases/pcb_defect_detection.py,sha256=xH3q-WoR3TwMUeUvWw1W7vPLdCUfu_Kl_gQ9dZFf1SE,43006
 matrice_analytics/post_processing/usecases/pedestrian_detection.py,sha256=hPFtvpWXXEsbDavmuiXIhrosMNlOhGya--jukT-ZOHA,39288
-matrice_analytics/post_processing/usecases/people_counting.py,sha256=IeNu33nWhzRlbOPf8DPbzQp1QRdPSAIr4nO3A1wUr_k,35272
+matrice_analytics/post_processing/usecases/people_counting.py,sha256=mlzezqESW2qifW2PmsygWMjHLw6v8I34p9L2RwbxZMo,35267
 matrice_analytics/post_processing/usecases/people_counting_bckp.py,sha256=WM9te7oYyhu5f_bIMye_D5BpEn6CwA-6Kz95IMLmSbs,82209
 matrice_analytics/post_processing/usecases/people_tracking.py,sha256=iXzGJgqKgWxvIVLqa1cFKkiF0DrHolwghSiJ2P8mDhc,90484
 matrice_analytics/post_processing/usecases/pipeline_detection.py,sha256=VsLTXMAqx0tRw7Olrxqx7SBLolZR7p2aFOrdSXLS-kE,30796
@@ -158,7 +158,7 @@ matrice_analytics/post_processing/usecases/theft_detection.py,sha256=Rs_zKn2z9YM
 matrice_analytics/post_processing/usecases/traffic_sign_monitoring.py,sha256=nDlEzHgMlUjy_VtJ7usnEzMcdSs-jouqaoJpJ8DYUMw,34351
 matrice_analytics/post_processing/usecases/underground_pipeline_defect_detection.py,sha256=W_2joZStsP0jl2zn89-jtdtqqGv3vJ0amsalbE5WKwo,37647
 matrice_analytics/post_processing/usecases/underwater_pollution_detection.py,sha256=jqP1ZKfDZe2-56Lyvgb2DxnbqRfvxm6pPL0Ck3esfBk,40356
-matrice_analytics/post_processing/usecases/vehicle_monitoring.py,sha256=iH0kqx8VwWldVLnWbDIMyjKBgOMLakbqMMHypXsxGdo,50529
+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
@@ -188,8 +188,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.43.dist-info/licenses/LICENSE.txt,sha256=_uQUZpgO0mRYL5-fPoEvLSbNnLPv6OmbeEDCHXhK6Qc,1066
-matrice_analytics-0.1.43.dist-info/METADATA,sha256=XEb8jt0ezecP_Phg22fCGsMBFToMhI2iSHb5FAahQhE,14378
-matrice_analytics-0.1.43.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice_analytics-0.1.43.dist-info/top_level.txt,sha256=STAPEU-e-rWTerXaspdi76T_eVRSrEfFpURSP7_Dt8E,18
-matrice_analytics-0.1.43.dist-info/RECORD,,
+matrice_analytics-0.1.44.dist-info/licenses/LICENSE.txt,sha256=_uQUZpgO0mRYL5-fPoEvLSbNnLPv6OmbeEDCHXhK6Qc,1066
+matrice_analytics-0.1.44.dist-info/METADATA,sha256=fdA7eR44gue1uKeUrOE0fDpgx2bIsqXH2-h4uOuNiDY,14378
+matrice_analytics-0.1.44.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice_analytics-0.1.44.dist-info/top_level.txt,sha256=STAPEU-e-rWTerXaspdi76T_eVRSrEfFpURSP7_Dt8E,18
+matrice_analytics-0.1.44.dist-info/RECORD,,