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

matrice_analytics/post_processing/usecases/people_counting.py

@@ -333,20 +333,20 @@ class PeopleCountingUseCase(BaseProcessor):
             })
 
         human_text_lines = []
-        human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}")
+        human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}:")
         for cat, count in per_category_count.items():
             human_text_lines.append(f"\t- People Detected: {count}")
         human_text_lines.append("")
-        human_text_lines.append(f"TOTAL SINCE {start_timestamp}")
-        for cat, count in total_counts_dict.items():
-            if count > 0:
-                human_text_lines.append("")
-                human_text_lines.append(f"\t- Total unique people count: {count}")
-        if alerts:
-            for alert in alerts:
-                human_text_lines.append(f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}")
-        else:
-            human_text_lines.append("Alerts: None")
+        # human_text_lines.append(f"TOTAL SINCE {start_timestamp}")
+        # for cat, count in total_counts_dict.items():
+        #     if count > 0:
+        #         human_text_lines.append("")
+        #         human_text_lines.append(f"\t- Total unique people count: {count}")
+        # if alerts:
+        #     for alert in alerts:
+        #         human_text_lines.append(f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}")
+        # else:
+        #     human_text_lines.append("Alerts: None")
         human_text = "\n".join(human_text_lines)
 
         reset_settings = [{"interval_type": "daily", "reset_time": {"value": 9, "time_unit": "hour"}}]

matrice_analytics/post_processing/usecases/vehicle_monitoring.py

@@ -633,40 +633,40 @@ class VehicleMonitoringUseCase(BaseProcessor):
                         human_text_lines.append(f"\t\t- {cat}: {count}")
 
         human_text_lines.append("")
-        human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}:")
-
-        # Display total counts - zone-wise or category-wise
-        if zone_analysis:
-            human_text_lines.append("\t- Total Vehicles by Zone:")
-            for zone_name, zone_data in zone_analysis.items():
-                total_count = 0
-                if isinstance(zone_data, dict):
-                    # Prefer the numeric cumulative total if available
-                    if "total_count" in zone_data and isinstance(zone_data.get("total_count"), (int, float)):
-                        total_count = zone_data.get("total_count", 0)
-                    # Fallback: compute from list of total_track_ids if present
-                    elif "total_track_ids" in zone_data and isinstance(zone_data.get("total_track_ids"), list):
-                        total_count = len(zone_data.get("total_track_ids", []))
-                    else:
-                        # Last resort: try to sum numeric values present
-                        counts_dict = zone_data if isinstance(zone_data, dict) else {}
-                        total_count = sum(v for v in counts_dict.values() if isinstance(v, (int, float)))
-                human_text_lines.append(f"\t\t- {zone_name}: {int(total_count)}")
-        else:
-            if total_counts_dict:
-                human_text_lines.append("\t- Total Unique Vehicles:")
-                for cat, count in total_counts_dict.items():
-                    if count > 0:
-                        human_text_lines.append(f"\t\t- {cat}: {count}")
-
-        # Display alerts
-        if alerts:
-            human_text_lines.append("")
-            for alert in alerts:
-                human_text_lines.append(f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}")
-        else:
-            human_text_lines.append("")
-            human_text_lines.append("Alerts: None")
+        # human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}:")
+
+        # # Display total counts - zone-wise or category-wise
+        # if zone_analysis:
+        #     human_text_lines.append("\t- Total Vehicles by Zone:")
+        #     for zone_name, zone_data in zone_analysis.items():
+        #         total_count = 0
+        #         if isinstance(zone_data, dict):
+        #             # Prefer the numeric cumulative total if available
+        #             if "total_count" in zone_data and isinstance(zone_data.get("total_count"), (int, float)):
+        #                 total_count = zone_data.get("total_count", 0)
+        #             # Fallback: compute from list of total_track_ids if present
+        #             elif "total_track_ids" in zone_data and isinstance(zone_data.get("total_track_ids"), list):
+        #                 total_count = len(zone_data.get("total_track_ids", []))
+        #             else:
+        #                 # Last resort: try to sum numeric values present
+        #                 counts_dict = zone_data if isinstance(zone_data, dict) else {}
+        #                 total_count = sum(v for v in counts_dict.values() if isinstance(v, (int, float)))
+        #         human_text_lines.append(f"\t\t- {zone_name}: {int(total_count)}")
+        # else:
+        #     if total_counts_dict:
+        #         human_text_lines.append("\t- Total Unique Vehicles:")
+        #         for cat, count in total_counts_dict.items():
+        #             if count > 0:
+        #                 human_text_lines.append(f"\t\t- {cat}: {count}")
+
+        # # Display alerts
+        # if alerts:
+        #     human_text_lines.append("")
+        #     for alert in alerts:
+        #         human_text_lines.append(f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}")
+        # else:
+        #     human_text_lines.append("")
+        #     human_text_lines.append("Alerts: None")
 
         human_text = "\n".join(human_text_lines)
 

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):