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

matrice_analytics/post_processing/test_cases/test_usecases.py

@@ -0,0 +1,165 @@
+import os
+import sys
+import cv2
+import json
+import importlib
+import argparse
+from ultralytics import YOLO
+from src.matrice_analytics.post_processing.core.base import ProcessingContext
+
+
+class UseCaseTestProcessor:
+    """
+    A flexible YOLO-based video processor for testing different post-processing use cases.
+    """
+
+    def __init__(self, file_name, config_name, usecase_name, model_path, video_path, post_process=None, max_frames=None):
+        self.file_name = file_name
+        self.config_name = config_name
+        self.usecase_name = usecase_name
+        self.model_path = model_path
+        self.video_path = video_path
+        self.post_process = post_process
+        self.max_frames = max_frames
+        self.json_dir = "jsons"
+
+        self._setup_environment()
+        self.ConfigClass, self.UsecaseClass = self._load_usecase()
+        self.config = self._initialize_config()
+        self.processor = self.UsecaseClass()
+        self.model = YOLO(self.model_path)
+        os.makedirs(self.json_dir, exist_ok=True)
+
+    def _setup_environment(self):
+        """Ensure project root is added to sys.path."""
+        project_root = os.path.abspath("/content/py_analytics")
+        if project_root not in sys.path:
+            sys.path.append(project_root)
+
+    def _load_usecase(self):
+        """Dynamically import config and usecase classes."""
+        module_path = f"src.matrice_analytics.post_processing.usecases.{self.file_name}"
+        module = importlib.import_module(module_path)
+        return getattr(module, self.config_name), getattr(module, self.usecase_name)
+
+    def _initialize_config(self):
+        """Initialize config object, applying overrides if provided."""
+        if self.post_process:
+            return self.ConfigClass(**self.post_process)
+        return self.ConfigClass()
+
+    def _serialize_result(self, result):
+        """Convert result object into JSON-serializable dict."""
+        def to_serializable(obj):
+            if hasattr(obj, "to_dict"):
+                return obj.to_dict()
+            if hasattr(obj, "__dict__"):
+                return obj.__dict__
+            return str(obj)
+        return json.loads(json.dumps(result, default=to_serializable))
+
+
+    def process_video(self):
+        """Run YOLO inference on video and post-process frame by frame."""
+        cap = cv2.VideoCapture(self.video_path)
+        if not cap.isOpened():
+            raise ValueError(f"Failed to open video at {self.video_path}")
+
+        frame_idx = 0
+        stream_info = {
+            'input_settings': {
+                'start_frame': 0,
+                'original_fps': cap.get(cv2.CAP_PROP_FPS),
+                'camera_info': {'id': 'cam1', 'name': 'Test Camera'}
+            }
+        }
+
+        print(f"\nStarting video processing: {self.video_path}")
+        print(f"Model: {self.model_path}")
+        print(f"Output directory: {self.json_dir}\n")
+
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            results = self.model(frame_rgb)
+
+            detections = []
+            for xyxy, conf, cls in zip(results[0].boxes.xyxy, results[0].boxes.conf, results[0].boxes.cls):
+                x1, y1, x2, y2 = xyxy.tolist()
+                detections.append({
+                    'category_id': int(cls),
+                    'confidence': conf.item(),
+                    'bounding_box': {
+                        'xmin': int(x1),
+                        'ymin': int(y1),
+                        'xmax': int(x2),
+                        'ymax': int(y2)
+                    }
+                })
+
+            success, encoded_image = cv2.imencode(".jpg", frame)
+            input_bytes = encoded_image.tobytes() if success else None
+
+            try:
+                result = self.processor.process(
+                    detections, self.config, input_bytes, ProcessingContext(), stream_info
+                )
+            except TypeError:
+                result = self.processor.process(
+                    detections, self.config, ProcessingContext(), stream_info
+                )
+
+            json_path = os.path.join(self.json_dir, f"frame_{frame_idx:04d}.json")
+            with open(json_path, "w") as f:
+                json.dump(self._serialize_result(result), f, indent=2)
+
+            print(f"Frame {frame_idx} processed — detections: {len(detections)} — saved: {json_path}")
+
+            frame_idx += 1
+            stream_info['input_settings']['start_frame'] += 1
+
+            if self.max_frames and frame_idx >= self.max_frames:
+                print(f"\nMax frame limit ({self.max_frames}) reached.")
+                break
+
+        cap.release()
+        print(f"\nProcessing complete. JSON outputs saved in: {self.json_dir}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="YOLO Use Case Test Processor")
+
+    parser.add_argument("--file_name", type=str, required=True,
+                        help="Usecase file name under src/matrice_analytics/post_processing/usecases/")
+    parser.add_argument("--config_name", type=str, required=True,
+                        help="Config class name (e.g., PeopleCountingConfig)")
+    parser.add_argument("--usecase_name", type=str, required=True,
+                        help="Use case class name (e.g., PeopleCountingUseCase)")
+    parser.add_argument("--model_path", type=str, required=True,
+                        help="Path to YOLO model file (.pt)")
+    parser.add_argument("--video_path", type=str, required=True,
+                        help="Path to input video")
+    parser.add_argument("--post_process", type=json.loads, default=None,
+                        help="JSON string for config overrides, e.g. '{\"min_confidence\": 0.5}'")
+    parser.add_argument("--max_frames", type=int, default=None,
+                        help="Limit number of frames processed")
+
+    args = parser.parse_args()
+
+    processor = UseCaseTestProcessor(
+        file_name=args.file_name,
+        config_name=args.config_name,
+        usecase_name=args.usecase_name,
+        model_path=args.model_path,
+        video_path=args.video_path,
+        post_process=args.post_process,
+        max_frames=args.max_frames
+    )
+    processor.process_video()
+
+
+if __name__ == "__main__":
+    main()

matrice_analytics/post_processing/usecases/color/clip.py

@@ -11,20 +11,21 @@ subprocess.run(
         cmd,
         stdout=log_file,
         stderr=subprocess.STDOUT,
-        preexec_fn=os.setpgrp   
+        # preexec_fn=os.setpgrp
     )
 cmd = ["pip", "install", "httpx", "aiohttp", "filterpy"]
 subprocess.run(
         cmd,
         stdout=log_file,
         stderr=subprocess.STDOUT,
-        preexec_fn=os.setpgrp   
+        # preexec_fn=os.setpgrp
     )
 log_file.close()
 
 import numpy as np
 from typing import List, Dict, Tuple, Optional
 from dataclasses import dataclass, field
+from pathlib import Path
 import cv2
 import io
 import threading
@@ -371,7 +372,7 @@ class ClipProcessor:
                 cmd,
                 stdout=log_file,
                 stderr=subprocess.STDOUT,
-                preexec_fn=os.setpgrp
+                # preexec_fn=os.setpgrp
             )
 
         # Determine and enforce providers (prefer CUDA only)

matrice_analytics/post_processing/usecases/color/color_mapper.py

@@ -465,4 +465,4 @@ def process_video_with_color_detection(
     classifier = VideoColorClassifier(top_k_colors, min_confidence)
     return classifier.process_video_with_predictions(
         video_bytes, yolo_predictions, output_dir, fps
-    )
+    )

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"""
@@ -1109,4 +1144,3 @@ class FireSmokeUseCase(BaseProcessor):
         return (1,1)
 
 
-