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

matrice_analytics/post_processing/usecases/license_plate_detection.py

@@ -1,10 +1,15 @@
-from typing import Any, Dict, List, Optional
 from dataclasses import asdict
 import time
 from datetime import datetime, timezone
 import copy  # Added for deep copying detections to preserve original masks
-
-from ..core.base import BaseProcessor, ProcessingContext, ProcessingResult, ConfigProtocol, ResultFormat
+from typing import Any, Dict, List, Optional
+from ..core.base import (
+    BaseProcessor,
+    ProcessingContext,
+    ProcessingResult,
+    ConfigProtocol,
+    ResultFormat,
+)
 from ..utils import (
     filter_by_confidence,
     filter_by_categories,
@@ -15,7 +20,7 @@ from ..utils import (
     match_results_structure,
     bbox_smoothing,
     BBoxSmoothingConfig,
-    BBoxSmoothingTracker
+    BBoxSmoothingTracker,
 )
 from dataclasses import dataclass, field
 from ..core.config import BaseConfig, AlertConfig, ZoneConfig
@@ -24,6 +29,7 @@ from ..core.config import BaseConfig, AlertConfig, ZoneConfig
 @dataclass
 class LicensePlateConfig(BaseConfig):
     """Configuration for License plate detection use case in License plate monitoring."""
+
     # Smoothing configuration
     enable_smoothing: bool = True
     smoothing_algorithm: str = "observability"  # "window" or "observability"
@@ -31,16 +37,12 @@ class LicensePlateConfig(BaseConfig):
     smoothing_cooldown_frames: int = 5
     smoothing_confidence_range_factor: float = 0.5
 
-    #confidence thresholds
+    # confidence thresholds
     confidence_threshold: float = 0.6
 
-    usecase_categories: List[str] = field(
-        default_factory=lambda: ['license_plate']
-    )
+    usecase_categories: List[str] = field(default_factory=lambda: ["license_plate"])
 
-    target_categories: List[str] = field(
-        default_factory=lambda: ['license_plate']
-    )
+    target_categories: List[str] = field(default_factory=lambda: ["license_plate"])
 
     alert_config: Optional[AlertConfig] = None
 
@@ -57,16 +59,16 @@ class LicensePlateUseCase(BaseProcessor):
     CATEGORY_DISPLAY = {
         "license_plate": "license_plate",
     }
-    
+
     def __init__(self):
         super().__init__("license_plate_detection")
         self.category = "license_plate"
 
         # List of  categories to track
-        self.target_categories = ['license_plate']
+        self.target_categories = ["license_plate"]
 
-        self.CASE_TYPE: Optional[str] = 'license_plate_detection'
-        self.CASE_VERSION: Optional[str] = '1.3'
+        self.CASE_TYPE: Optional[str] = "license_plate_detection"
+        self.CASE_VERSION: Optional[str] = "1.3"
 
         # Initialize smoothing tracker
         self.smoothing_tracker = None
@@ -97,8 +99,13 @@ class LicensePlateUseCase(BaseProcessor):
         self._ascending_alert_list: List[int] = []
         self.current_incident_end_timestamp: str = "N/A"
 
-    def process(self, data: Any, config: ConfigProtocol, context: Optional[ProcessingContext] = None,
-                stream_info: Optional[Dict[str, Any]] = None) -> ProcessingResult:
+    def process(
+        self,
+        data: Any,
+        config: ConfigProtocol,
+        context: Optional[ProcessingContext] = None,
+        stream_info: Optional[Dict[str, Any]] = None,
+    ) -> ProcessingResult:
         """
         Main entry point for post-processing.
         Applies category mapping, smoothing, counting, alerting, and summary generation.
@@ -107,8 +114,12 @@ class LicensePlateUseCase(BaseProcessor):
         start_time = time.time()
         # Ensure config is correct type
         if not isinstance(config, LicensePlateConfig):
-            return self.create_error_result("Invalid config type", usecase=self.name, category=self.category,
-                                            context=context)
+            return self.create_error_result(
+                "Invalid config type",
+                usecase=self.name,
+                category=self.category,
+                context=context,
+            )
         if context is None:
             context = ProcessingContext()
 
@@ -116,21 +127,27 @@ class LicensePlateUseCase(BaseProcessor):
         input_format = match_results_structure(data)
         context.input_format = input_format
         context.confidence_threshold = config.confidence_threshold
-        
+
         # Step 1: Confidence filtering
         if config.confidence_threshold is not None:
             processed_data = filter_by_confidence(data, config.confidence_threshold)
         else:
             processed_data = data
-            self.logger.debug(f"Did not apply confidence filtering with threshold since nothing was provided")
+            self.logger.debug(
+                f"Did not apply confidence filtering with threshold since nothing was provided"
+            )
 
         # Step 2: Apply category mapping if provided
         if config.index_to_category:
-            processed_data = apply_category_mapping(processed_data, config.index_to_category)
+            processed_data = apply_category_mapping(
+                processed_data, config.index_to_category
+            )
 
         # Step 3: Category filtering
         if config.target_categories:
-            processed_data = [d for d in processed_data if d.get('category') in self.target_categories]
+            processed_data = [
+                d for d in processed_data if d.get("category") in self.target_categories
+            ]
 
         # Step 4: Apply bbox smoothing if enabled
         # Deep-copy detections so that we preserve the original masks before any
@@ -144,18 +161,20 @@ class LicensePlateUseCase(BaseProcessor):
                     cooldown_frames=config.smoothing_cooldown_frames,
                     confidence_threshold=config.confidence_threshold,
                     confidence_range_factor=config.smoothing_confidence_range_factor,
-                    enable_smoothing=True
+                    enable_smoothing=True,
                 )
                 self.smoothing_tracker = BBoxSmoothingTracker(smoothing_config)
-           
-            processed_data = bbox_smoothing(processed_data, self.smoothing_tracker.config, self.smoothing_tracker)
+
+            processed_data = bbox_smoothing(
+                processed_data, self.smoothing_tracker.config, self.smoothing_tracker
+            )
             # Restore masks after smoothing
 
         # Step 5: Advanced tracking (BYTETracker-like)
         try:
             from ..advanced_tracker import AdvancedTracker
             from ..advanced_tracker.config import TrackerConfig
-            
+
             if self.tracker is None:
                 # Configure tracker thresholds based on the use-case confidence threshold so that
                 # low-confidence detections (e.g. < 0.7) can still be initialised as tracks when
@@ -164,8 +183,10 @@ class LicensePlateUseCase(BaseProcessor):
                     tracker_config = TrackerConfig(
                         track_high_thresh=float(config.confidence_threshold),
                         # Allow even lower detections to participate in secondary association
-                        track_low_thresh=max(0.05, float(config.confidence_threshold) / 2),
-                        new_track_thresh=float(config.confidence_threshold)
+                        track_low_thresh=max(
+                            0.05, float(config.confidence_threshold) / 2
+                        ),
+                        new_track_thresh=float(config.confidence_threshold),
                     )
                 else:
                     tracker_config = TrackerConfig()
@@ -193,7 +214,9 @@ class LicensePlateUseCase(BaseProcessor):
         # processed detection back to the raw detection with the highest IoU
         # and copy over its "masks" field (if available).
         # ------------------------------------------------------------------ #
-        processed_data = self._attach_masks_to_detections(processed_data, raw_processed_data)
+        processed_data = self._attach_masks_to_detections(
+            processed_data, raw_processed_data
+        )
 
         # Update frame counter
         self._total_frame_counter += 1
@@ -205,7 +228,11 @@ class LicensePlateUseCase(BaseProcessor):
             start_frame = input_settings.get("start_frame")
             end_frame = input_settings.get("end_frame")
             # If start and end frame are the same, it's a single frame
-            if start_frame is not None and end_frame is not None and start_frame == end_frame:
+            if (
+                start_frame is not None
+                and end_frame is not None
+                and start_frame == end_frame
+            ):
                 frame_number = start_frame
 
         # Compute summaries and alerts
@@ -213,31 +240,45 @@ class LicensePlateUseCase(BaseProcessor):
         counting_summary = self._count_categories(processed_data, config)
         # Add total unique counts after tracking using only local state
         total_counts = self.get_total_counts()
-        counting_summary['total_counts'] = total_counts
+        counting_summary["total_counts"] = total_counts
 
         alerts = self._check_alerts(counting_summary, frame_number, config)
         predictions = self._extract_predictions(processed_data)
-        
+
         # Step: Generate structured events and tracking stats with frame-based keys
-        incidents_list = self._generate_incidents(counting_summary, alerts, config, frame_number, stream_info)
-        tracking_stats_list = self._generate_tracking_stats(counting_summary, alerts, config, frame_number,stream_info)
+        incidents_list = self._generate_incidents(
+            counting_summary, alerts, config, frame_number, stream_info
+        )
+        tracking_stats_list = self._generate_tracking_stats(
+            counting_summary, alerts, config, frame_number, stream_info
+        )
         # business_analytics_list = self._generate_business_analytics(counting_summary, alerts, config, frame_number, stream_info, is_empty=False)
         business_analytics_list = []
-        summary_list = self._generate_summary(counting_summary, incidents_list, tracking_stats_list, business_analytics_list, alerts)
+        summary_list = self._generate_summary(
+            counting_summary,
+            incidents_list,
+            tracking_stats_list,
+            business_analytics_list,
+            alerts,
+        )
 
         # Extract frame-based dictionaries from the lists
         incidents = incidents_list[0] if incidents_list else {}
         tracking_stats = tracking_stats_list[0] if tracking_stats_list else {}
-        business_analytics = business_analytics_list[0] if business_analytics_list else {}
+        business_analytics = (
+            business_analytics_list[0] if business_analytics_list else {}
+        )
         summary = summary_list[0] if summary_list else {}
-        agg_summary = {str(frame_number): {
-                        "incidents": incidents,
-                        "tracking_stats": tracking_stats,
-                        "business_analytics": business_analytics,
-                        "alerts": alerts,
-                        "human_text": summary}
-                    }
-       
+        agg_summary = {
+            str(frame_number): {
+                "incidents": incidents,
+                "tracking_stats": tracking_stats,
+                "business_analytics": business_analytics,
+                "alerts": alerts,
+                "human_text": summary,
+            }
+        }
+
         context.mark_completed()
 
         # Build result object following the new pattern
@@ -246,20 +287,23 @@ class LicensePlateUseCase(BaseProcessor):
             data={"agg_summary": agg_summary},
             usecase=self.name,
             category=self.category,
-            context=context
+            context=context,
         )
-        
+
         return result
 
-    def _check_alerts(self, summary: dict, frame_number:Any, config: LicensePlateConfig) -> List[Dict]:
+    def _check_alerts(
+        self, summary: dict, frame_number: Any, config: LicensePlateConfig
+    ) -> List[Dict]:
         """
         Check if any alert thresholds are exceeded and return alert dicts.
         """
+
         def get_trend(data, lookback=900, threshold=0.6):
-            '''
+            """
             Determine if the trend is ascending or descending based on actual value progression.
             Now works with values 0,1,2,3 (not just binary).
-            '''
+            """
             window = data[-lookback:] if len(data) >= lookback else data
             if len(window) < 2:
                 return True  # not enough data to determine trend
@@ -277,75 +321,166 @@ class LicensePlateUseCase(BaseProcessor):
 
         frame_key = str(frame_number) if frame_number is not None else "current_frame"
         alerts = []
-        total_detections = summary.get("total_count", 0) #CURRENT combined total count of all classes
-        total_counts_dict = summary.get("total_counts", {}) #TOTAL cumulative counts per class
-        cumulative_total = sum(total_counts_dict.values()) if total_counts_dict else 0 #TOTAL combined cumulative count
-        per_category_count = summary.get("per_category_count", {}) #CURRENT count per class
+        total_detections = summary.get(
+            "total_count", 0
+        )  # CURRENT combined total count of all classes
+        total_counts_dict = summary.get(
+            "total_counts", {}
+        )  # TOTAL cumulative counts per class
+        cumulative_total = (
+            sum(total_counts_dict.values()) if total_counts_dict else 0
+        )  # TOTAL combined cumulative count
+        per_category_count = summary.get(
+            "per_category_count", {}
+        )  # CURRENT count per class
 
         if not config.alert_config:
             return alerts
 
         total = summary.get("total_count", 0)
-        #self._ascending_alert_list
-        if hasattr(config.alert_config, 'count_thresholds') and config.alert_config.count_thresholds:
+        # self._ascending_alert_list
+        if (
+            hasattr(config.alert_config, "count_thresholds")
+            and config.alert_config.count_thresholds
+        ):
 
             for category, threshold in config.alert_config.count_thresholds.items():
-                if category == "all" and total > threshold:  
-
-                    alerts.append({
-                        "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
-                        "alert_id": "alert_"+category+'_'+frame_key,
-                        "incident_category": self.CASE_TYPE,
-                        "threshold_level": threshold,
-                        "ascending": get_trend(self._ascending_alert_list, lookback=900, threshold=0.8),
-                        "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
-                                     getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])
-                                    }                    
-                    })
+                if category == "all" and total > threshold:
+
+                    alerts.append(
+                        {
+                            "alert_type": (
+                                getattr(config.alert_config, "alert_type", ["Default"])
+                                if hasattr(config.alert_config, "alert_type")
+                                else ["Default"]
+                            ),
+                            "alert_id": "alert_" + category + "_" + frame_key,
+                            "incident_category": self.CASE_TYPE,
+                            "threshold_level": threshold,
+                            "ascending": get_trend(
+                                self._ascending_alert_list, lookback=900, threshold=0.8
+                            ),
+                            "settings": {
+                                t: v
+                                for t, v in zip(
+                                    (
+                                        getattr(
+                                            config.alert_config,
+                                            "alert_type",
+                                            ["Default"],
+                                        )
+                                        if hasattr(config.alert_config, "alert_type")
+                                        else ["Default"]
+                                    ),
+                                    (
+                                        getattr(
+                                            config.alert_config, "alert_value", ["JSON"]
+                                        )
+                                        if hasattr(config.alert_config, "alert_value")
+                                        else ["JSON"]
+                                    ),
+                                )
+                            },
+                        }
+                    )
                 elif category in summary.get("per_category_count", {}):
                     count = summary.get("per_category_count", {})[category]
                     if count > threshold:  # Fixed logic: alert when EXCEEDING threshold
-                        alerts.append({
-                            "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
-                            "alert_id": "alert_"+category+'_'+frame_key,
-                            "incident_category": self.CASE_TYPE,
-                            "threshold_level": threshold,
-                            "ascending": get_trend(self._ascending_alert_list, lookback=900, threshold=0.8),
-                            "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
-                                     getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])
-                                    }       
-                        })
+                        alerts.append(
+                            {
+                                "alert_type": (
+                                    getattr(
+                                        config.alert_config, "alert_type", ["Default"]
+                                    )
+                                    if hasattr(config.alert_config, "alert_type")
+                                    else ["Default"]
+                                ),
+                                "alert_id": "alert_" + category + "_" + frame_key,
+                                "incident_category": self.CASE_TYPE,
+                                "threshold_level": threshold,
+                                "ascending": get_trend(
+                                    self._ascending_alert_list,
+                                    lookback=900,
+                                    threshold=0.8,
+                                ),
+                                "settings": {
+                                    t: v
+                                    for t, v in zip(
+                                        (
+                                            getattr(
+                                                config.alert_config,
+                                                "alert_type",
+                                                ["Default"],
+                                            )
+                                            if hasattr(
+                                                config.alert_config, "alert_type"
+                                            )
+                                            else ["Default"]
+                                        ),
+                                        (
+                                            getattr(
+                                                config.alert_config,
+                                                "alert_value",
+                                                ["JSON"],
+                                            )
+                                            if hasattr(
+                                                config.alert_config, "alert_value"
+                                            )
+                                            else ["JSON"]
+                                        ),
+                                    )
+                                },
+                            }
+                        )
         else:
             pass
         return alerts
 
-    def _generate_incidents(self, counting_summary: Dict, alerts: List, config: LicensePlateConfig,
-                         frame_number: Optional[int] = None, stream_info: Optional[Dict[str, Any]] = None) -> List[
-        Dict]:
+    def _generate_incidents(
+        self,
+        counting_summary: Dict,
+        alerts: List,
+        config: LicensePlateConfig,
+        frame_number: Optional[int] = None,
+        stream_info: Optional[Dict[str, Any]] = None,
+    ) -> List[Dict]:
         """Generate structured events for the output format with frame-based keys."""
 
         # Use frame number as key, fallback to 'current_frame' if not available
         frame_key = str(frame_number) if frame_number is not None else "current_frame"
-        incidents=[]
+        incidents = []
         total_detections = counting_summary.get("total_count", 0)
         current_timestamp = self._get_current_timestamp_str(stream_info)
         camera_info = self.get_camera_info_from_stream(stream_info)
-        
-        self._ascending_alert_list = self._ascending_alert_list[-900:] if len(self._ascending_alert_list) > 900 else self._ascending_alert_list
+
+        self._ascending_alert_list = (
+            self._ascending_alert_list[-900:]
+            if len(self._ascending_alert_list) > 900
+            else self._ascending_alert_list
+        )
 
         if total_detections > 0:
             # Determine event level based on thresholds
             level = "low"
             intensity = 5.0
             start_timestamp = self._get_start_timestamp_str(stream_info)
-            if start_timestamp and self.current_incident_end_timestamp=='N/A':
-                self.current_incident_end_timestamp = 'Incident still active'
-            elif start_timestamp and self.current_incident_end_timestamp=='Incident still active':
-                if len(self._ascending_alert_list) >= 15 and sum(self._ascending_alert_list[-15:]) / 15 < 1.5: 
+            if start_timestamp and self.current_incident_end_timestamp == "N/A":
+                self.current_incident_end_timestamp = "Incident still active"
+            elif (
+                start_timestamp
+                and self.current_incident_end_timestamp == "Incident still active"
+            ):
+                if (
+                    len(self._ascending_alert_list) >= 15
+                    and sum(self._ascending_alert_list[-15:]) / 15 < 1.5
+                ):
                     self.current_incident_end_timestamp = current_timestamp
-            elif self.current_incident_end_timestamp!='Incident still active' and self.current_incident_end_timestamp!='N/A':
-                self.current_incident_end_timestamp = 'N/A'
-                
+            elif (
+                self.current_incident_end_timestamp != "Incident still active"
+                and self.current_incident_end_timestamp != "N/A"
+            ):
+                self.current_incident_end_timestamp = "N/A"
+
             if config.alert_config and config.alert_config.count_thresholds:
                 threshold = config.alert_config.count_thresholds.get("all", 15)
                 intensity = min(10.0, (total_detections / threshold) * 10)
@@ -380,27 +515,61 @@ class LicensePlateUseCase(BaseProcessor):
                     intensity = min(10.0, total_detections / 3.0)
                     self._ascending_alert_list.append(0)
 
-             # Generate human text in new format
+            # Generate human text in new format
             human_text_lines = [f"INCIDENTS DETECTED @ {current_timestamp}:"]
             human_text_lines.append(f"\tSeverity Level: {(self.CASE_TYPE,level)}")
             human_text = "\n".join(human_text_lines)
 
-            alert_settings=[]
-            if config.alert_config and hasattr(config.alert_config, 'alert_type'):
-                alert_settings.append({
-                    "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
-                    "incident_category": self.CASE_TYPE,
-                    "threshold_level": config.alert_config.count_thresholds if hasattr(config.alert_config, 'count_thresholds') else {},
-                    "ascending": True,
-                    "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
-                                        getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])
-                                }
-                })
-        
-            event= self.create_incident(incident_id=self.CASE_TYPE+'_'+str(frame_number), incident_type=self.CASE_TYPE,
-                        severity_level=level, human_text=human_text, camera_info=camera_info, alerts=alerts, alert_settings=alert_settings,
-                        start_time=start_timestamp, end_time=self.current_incident_end_timestamp,
-                        level_settings= {"low": 1, "medium": 3, "significant":4, "critical": 7})
+            alert_settings = []
+            if config.alert_config and hasattr(config.alert_config, "alert_type"):
+                alert_settings.append(
+                    {
+                        "alert_type": (
+                            getattr(config.alert_config, "alert_type", ["Default"])
+                            if hasattr(config.alert_config, "alert_type")
+                            else ["Default"]
+                        ),
+                        "incident_category": self.CASE_TYPE,
+                        "threshold_level": (
+                            config.alert_config.count_thresholds
+                            if hasattr(config.alert_config, "count_thresholds")
+                            else {}
+                        ),
+                        "ascending": True,
+                        "settings": {
+                            t: v
+                            for t, v in zip(
+                                (
+                                    getattr(
+                                        config.alert_config, "alert_type", ["Default"]
+                                    )
+                                    if hasattr(config.alert_config, "alert_type")
+                                    else ["Default"]
+                                ),
+                                (
+                                    getattr(
+                                        config.alert_config, "alert_value", ["JSON"]
+                                    )
+                                    if hasattr(config.alert_config, "alert_value")
+                                    else ["JSON"]
+                                ),
+                            )
+                        },
+                    }
+                )
+
+            event = self.create_incident(
+                incident_id=self.CASE_TYPE + "_" + str(frame_number),
+                incident_type=self.CASE_TYPE,
+                severity_level=level,
+                human_text=human_text,
+                camera_info=camera_info,
+                alerts=alerts,
+                alert_settings=alert_settings,
+                start_time=start_timestamp,
+                end_time=self.current_incident_end_timestamp,
+                level_settings={"low": 1, "medium": 3, "significant": 4, "critical": 7},
+            )
             incidents.append(event)
 
         else:
@@ -410,12 +579,12 @@ class LicensePlateUseCase(BaseProcessor):
         return incidents
 
     def _generate_tracking_stats(
-            self,
-            counting_summary: Dict,
-            alerts: Any,
-            config: LicensePlateConfig,
-            frame_number: Optional[int] = None,
-            stream_info: Optional[Dict[str, Any]] = None
+        self,
+        counting_summary: Dict,
+        alerts: Any,
+        config: LicensePlateConfig,
+        frame_number: Optional[int] = None,
+        stream_info: Optional[Dict[str, Any]] = None,
     ) -> List[Dict]:
         """Generate structured tracking stats for the output format with frame-based keys, including track_ids_info and detections with masks."""
         # frame_key = str(frame_number) if frame_number is not None else "current_frame"
@@ -428,14 +597,22 @@ class LicensePlateUseCase(BaseProcessor):
         cumulative_total = sum(total_counts.values()) if total_counts else 0
         per_category_count = counting_summary.get("per_category_count", {})
 
-        track_ids_info = self._get_track_ids_info(counting_summary.get("detections", []))
+        track_ids_info = self._get_track_ids_info(
+            counting_summary.get("detections", [])
+        )
 
-        current_timestamp = self._get_current_timestamp_str(stream_info, precision=False)
+        current_timestamp = self._get_current_timestamp_str(
+            stream_info, precision=False
+        )
         start_timestamp = self._get_start_timestamp_str(stream_info, precision=False)
-        
+
         # Create high precision timestamps for input_timestamp and reset_timestamp
-        high_precision_start_timestamp = self._get_current_timestamp_str(stream_info, precision=True)
-        high_precision_reset_timestamp = self._get_start_timestamp_str(stream_info, precision=True)
+        high_precision_start_timestamp = self._get_current_timestamp_str(
+            stream_info, precision=True
+        )
+        high_precision_reset_timestamp = self._get_start_timestamp_str(
+            stream_info, precision=True
+        )
 
         camera_info = self.get_camera_info_from_stream(stream_info)
         human_text_lines = []
@@ -443,11 +620,15 @@ class LicensePlateUseCase(BaseProcessor):
         # CURRENT FRAME section
         human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}:")
         if total_detections > 0:
-            category_counts = [f"{count} {cat}" for cat, count in per_category_count.items()]
+            category_counts = [
+                f"{count} {cat}" for cat, count in per_category_count.items()
+            ]
             if len(category_counts) == 1:
                 detection_text = category_counts[0] + " detected"
             elif len(category_counts) == 2:
-                detection_text = f"{category_counts[0]} and {category_counts[1]} detected"
+                detection_text = (
+                    f"{category_counts[0]} and {category_counts[1]} detected"
+                )
             else:
                 detection_text = f"{', '.join(category_counts[:-1])}, and {category_counts[-1]} detected"
             human_text_lines.append(f"\t- {detection_text}")
@@ -464,14 +645,13 @@ class LicensePlateUseCase(BaseProcessor):
             for cat, count in total_counts.items():
                 if count > 0:  # Only include categories with non-zero counts
                     human_text_lines.append(f"\t- {cat}: {count}")
-        # Build current_counts array in expected format  
+        # Build current_counts array in expected format
         current_counts = []
         for cat, count in per_category_count.items():
-            if count > 0 or total_detections > 0:  # Include even if 0 when there are detections
-                current_counts.append({
-                    "category": cat,
-                    "count": count
-                })
+            if (
+                count > 0 or total_detections > 0
+            ):  # Include even if 0 when there are detections
+                current_counts.append({"category": cat, "count": count})
 
         human_text = "\n".join(human_text_lines)
 
@@ -483,69 +663,115 @@ class LicensePlateUseCase(BaseProcessor):
             category = detection.get("category", "person")
             # Include segmentation if available (like in eg.json)
             if detection.get("masks"):
-                segmentation= detection.get("masks", [])
-                detection_obj = self.create_detection_object(category, bbox, segmentation=segmentation)
+                segmentation = detection.get("masks", [])
+                detection_obj = self.create_detection_object(
+                    category, bbox, segmentation=segmentation
+                )
             elif detection.get("segmentation"):
-                segmentation= detection.get("segmentation")
-                detection_obj = self.create_detection_object(category, bbox, segmentation=segmentation)
+                segmentation = detection.get("segmentation")
+                detection_obj = self.create_detection_object(
+                    category, bbox, segmentation=segmentation
+                )
             elif detection.get("mask"):
-                segmentation= detection.get("mask")
-                detection_obj = self.create_detection_object(category, bbox, segmentation=segmentation)
+                segmentation = detection.get("mask")
+                detection_obj = self.create_detection_object(
+                    category, bbox, segmentation=segmentation
+                )
             else:
                 detection_obj = self.create_detection_object(category, bbox)
             detections.append(detection_obj)
 
         # Build alert_settings array in expected format
         alert_settings = []
-        if config.alert_config and hasattr(config.alert_config, 'alert_type'):
-            alert_settings.append({
-                "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
-                "incident_category": self.CASE_TYPE,
-                "threshold_level": config.alert_config.count_thresholds if hasattr(config.alert_config, 'count_thresholds') else {},
-                "ascending": True,
-                "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
-                                    getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])
-                            }
-            })
+        if config.alert_config and hasattr(config.alert_config, "alert_type"):
+            alert_settings.append(
+                {
+                    "alert_type": (
+                        getattr(config.alert_config, "alert_type", ["Default"])
+                        if hasattr(config.alert_config, "alert_type")
+                        else ["Default"]
+                    ),
+                    "incident_category": self.CASE_TYPE,
+                    "threshold_level": (
+                        config.alert_config.count_thresholds
+                        if hasattr(config.alert_config, "count_thresholds")
+                        else {}
+                    ),
+                    "ascending": True,
+                    "settings": {
+                        t: v
+                        for t, v in zip(
+                            (
+                                getattr(config.alert_config, "alert_type", ["Default"])
+                                if hasattr(config.alert_config, "alert_type")
+                                else ["Default"]
+                            ),
+                            (
+                                getattr(config.alert_config, "alert_value", ["JSON"])
+                                if hasattr(config.alert_config, "alert_value")
+                                else ["JSON"]
+                            ),
+                        )
+                    },
+                }
+            )
 
         if alerts:
             for alert in alerts:
-                human_text_lines.append(f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}")
+                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"
-                    }
-                }
-            ]
+            {"interval_type": "daily", "reset_time": {"value": 9, "time_unit": "hour"}}
+        ]
 
-        tracking_stat=self.create_tracking_stats(total_counts=total_counts, current_counts=current_counts,
-                            detections=detections, human_text=human_text, camera_info=camera_info, alerts=alerts, alert_settings=alert_settings,
-                            reset_settings=reset_settings, start_time=high_precision_start_timestamp ,
-                            reset_time=high_precision_reset_timestamp)
+        tracking_stat = self.create_tracking_stats(
+            total_counts=total_counts,
+            current_counts=current_counts,
+            detections=detections,
+            human_text=human_text,
+            camera_info=camera_info,
+            alerts=alerts,
+            alert_settings=alert_settings,
+            reset_settings=reset_settings,
+            start_time=high_precision_start_timestamp,
+            reset_time=high_precision_reset_timestamp,
+        )
 
         tracking_stats.append(tracking_stat)
         return tracking_stats
 
-    def _generate_business_analytics(self, counting_summary: Dict, zone_analysis: Dict, config: LicensePlateConfig, stream_info: Optional[Dict[str, Any]] = None, is_empty=False) -> List[Dict]:
+    def _generate_business_analytics(
+        self,
+        counting_summary: Dict,
+        zone_analysis: Dict,
+        config: LicensePlateConfig,
+        stream_info: Optional[Dict[str, Any]] = None,
+        is_empty=False,
+    ) -> List[Dict]:
         """Generate standardized business analytics for the agg_summary structure."""
         if is_empty:
             return []
 
-        #-----IF YOUR USECASE NEEDS BUSINESS ANALYTICS, YOU CAN USE THIS FUNCTION------#
-        #camera_info = self.get_camera_info_from_stream(stream_info)
+        # -----IF YOUR USECASE NEEDS BUSINESS ANALYTICS, YOU CAN USE THIS FUNCTION------#
+        # camera_info = self.get_camera_info_from_stream(stream_info)
         # business_analytics = self.create_business_analytics(nalysis_name, statistics,
         #                          human_text, camera_info=camera_info, alerts=alerts, alert_settings=alert_settings,
         #                          reset_settings)
         # return business_analytics
 
-    def _generate_summary(self, summary: dict, incidents: List, tracking_stats: List, business_analytics: List, alerts: List) -> List[str]:
+    def _generate_summary(
+        self,
+        summary: dict,
+        incidents: List,
+        tracking_stats: List,
+        business_analytics: List,
+        alerts: List,
+    ) -> List[str]:
         """
         Generate a human_text string for the tracking_stat, incident, business analytics and alerts.
         """
@@ -553,18 +779,27 @@ class LicensePlateUseCase(BaseProcessor):
         lines["Application Name"] = self.CASE_TYPE
         lines["Application Version"] = self.CASE_VERSION
         if len(incidents) > 0:
-            lines["Incidents:"]=f"\n\t{incidents[0].get('human_text', 'No incidents detected')}\n"
+            lines["Incidents:"] = (
+                f"\n\t{incidents[0].get('human_text', 'No incidents detected')}\n"
+            )
         if len(tracking_stats) > 0:
-            lines["Tracking Statistics:"]=f"\t{tracking_stats[0].get('human_text', 'No tracking statistics detected')}\n"
+            lines["Tracking Statistics:"] = (
+                f"\t{tracking_stats[0].get('human_text', 'No tracking statistics detected')}\n"
+            )
         if len(business_analytics) > 0:
-            lines["Business Analytics:"]=f"\t{business_analytics[0].get('human_text', 'No business analytics detected')}\n"
-
-        if len(incidents) == 0 and len(tracking_stats) == 0 and len(business_analytics) == 0:
+            lines["Business Analytics:"] = (
+                f"\t{business_analytics[0].get('human_text', 'No business analytics detected')}\n"
+            )
+
+        if (
+            len(incidents) == 0
+            and len(tracking_stats) == 0
+            and len(business_analytics) == 0
+        ):
             lines["Summary"] = "No Summary Data"
 
         return [lines]
 
-
     def _count_categories(self, detections: list, config: LicensePlateConfig) -> dict:
         """
         Count the number of detections per category and return a summary dict.
@@ -574,24 +809,30 @@ class LicensePlateUseCase(BaseProcessor):
         counts = {}
         valid_detections = []
         for det in detections:
-            cat = det.get('category', 'unknown')
-            if not all(k in det for k in ['category', 'confidence', 'bounding_box']):  # Validate required fields
+            cat = det.get("category", "unknown")
+            if not all(
+                k in det for k in ["category", "confidence", "bounding_box"]
+            ):  # Validate required fields
                 self.logger.warning(f"Skipping invalid detection: {det}")
                 continue
             counts[cat] = counts.get(cat, 0) + 1
-            valid_detections.append({
-                "bounding_box": det.get("bounding_box"),
-                "category": det.get("category"),
-                "confidence": det.get("confidence"),
-                "track_id": det.get("track_id"),
-                "frame_id": det.get("frame_id"),
-                "masks": det.get("masks", det.get("mask", []))  # Include masks, fallback to empty list
-            })
+            valid_detections.append(
+                {
+                    "bounding_box": det.get("bounding_box"),
+                    "category": det.get("category"),
+                    "confidence": det.get("confidence"),
+                    "track_id": det.get("track_id"),
+                    "frame_id": det.get("frame_id"),
+                    "masks": det.get(
+                        "masks", det.get("mask", [])
+                    ),  # Include masks, fallback to empty list
+                }
+            )
         self.logger.debug(f"Valid detections after filtering: {len(valid_detections)}")
         return {
             "total_count": sum(counts.values()),
             "per_category_count": counts,
-            "detections": valid_detections
+            "detections": valid_detections,
         }
 
     def _get_track_ids_info(self, detections: list) -> Dict[str, Any]:
@@ -601,12 +842,12 @@ class LicensePlateUseCase(BaseProcessor):
         # Collect all track_ids in this frame
         frame_track_ids = set()
         for det in detections:
-            tid = det.get('track_id')
+            tid = det.get("track_id")
             if tid is not None:
                 frame_track_ids.add(tid)
         # Use persistent total set for unique counting
         total_track_ids = set()
-        for s in getattr(self, '_per_category_total_track_ids', {}).values():
+        for s in getattr(self, "_per_category_total_track_ids", {}).values():
             total_track_ids.update(s)
         return {
             "total_count": len(total_track_ids),
@@ -614,7 +855,7 @@ class LicensePlateUseCase(BaseProcessor):
             "total_unique_track_ids": len(total_track_ids),
             "current_frame_track_ids": list(frame_track_ids),
             "last_update_time": time.time(),
-            "total_frames_processed": getattr(self, '_total_frame_counter', 0)
+            "total_frames_processed": getattr(self, "_total_frame_counter", 0),
         }
 
     def _update_tracking_state(self, detections: list):
@@ -625,7 +866,9 @@ class LicensePlateUseCase(BaseProcessor):
         """
         # Lazily initialise storage dicts
         if not hasattr(self, "_per_category_total_track_ids"):
-            self._per_category_total_track_ids = {cat: set() for cat in self.target_categories}
+            self._per_category_total_track_ids = {
+                cat: set() for cat in self.target_categories
+            }
         self._current_frame_track_ids = {cat: set() for cat in self.target_categories}
 
         for det in detections:
@@ -645,21 +888,29 @@ class LicensePlateUseCase(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()}
+        return {
+            cat: len(ids)
+            for cat, ids in getattr(self, "_per_category_total_track_ids", {}).items()
+        }
 
     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)
+        seconds = round(float(timestamp % 60), 2)
         return f"{hours:02d}:{minutes:02d}:{seconds:.1f}"
 
     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')
+        return dt.strftime("%Y:%m:%d %H:%M:%S")
 
-    def _get_current_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False, frame_id: Optional[str]=None) -> str:
+    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"
@@ -667,24 +918,36 @@ class LicensePlateUseCase(BaseProcessor):
         if precision:
             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)
+                    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)
+                    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 stream_time_str
             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 stream_time_str
+            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 stream_time_str
         else:
             # For streams, use stream_time from stream_info
-            stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
+            stream_time_str = (
+                stream_info.get("input_settings", {})
+                .get("stream_info", {})
+                .get("stream_time", "")
+            )
             if stream_time_str:
                 # Parse the high precision timestamp string to get timestamp
                 try:
@@ -699,7 +962,9 @@ class LicensePlateUseCase(BaseProcessor):
             else:
                 return self._format_timestamp_for_stream(time.time())
 
-    def _get_start_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False) -> str:
+    def _get_start_timestamp_str(
+        self, stream_info: Optional[Dict[str, Any]], precision=False
+    ) -> str:
         """Get formatted start timestamp for 'TOTAL SINCE' based on stream type."""
         if not stream_info:
             return "00:00:00"
@@ -716,13 +981,19 @@ class LicensePlateUseCase(BaseProcessor):
             # For streams, use tracking start time or current time with minutes/seconds reset
             if self._tracking_start_time is None:
                 # Try to extract timestamp from stream_time string
-                stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
+                stream_time_str = (
+                    stream_info.get("input_settings", {})
+                    .get("stream_info", {})
+                    .get("stream_time", "")
+                )
                 if stream_time_str:
                     try:
                         # Remove " UTC" suffix and parse
                         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()
+                        self._tracking_start_time = dt.replace(
+                            tzinfo=timezone.utc
+                        ).timestamp()
                     except:
                         # Fallback to current time if parsing fails
                         self._tracking_start_time = time.time()
@@ -732,7 +1003,7 @@ class LicensePlateUseCase(BaseProcessor):
             dt = datetime.fromtimestamp(self._tracking_start_time, tz=timezone.utc)
             # Reset minutes and seconds to 00:00 for "TOTAL SINCE" format
             dt = dt.replace(minute=0, second=0, microsecond=0)
-            return dt.strftime('%Y:%m:%d %H:%M:%S')
+            return dt.strftime("%Y:%m:%d %H:%M:%S")
 
     # ------------------------------------------------------------------ #
     # Helper to merge masks back into detections                        #
@@ -772,7 +1043,9 @@ class LicensePlateUseCase(BaseProcessor):
                 if idx in used_raw_indices:
                     continue
 
-                iou = self._compute_iou(det.get("bounding_box"), raw_det.get("bounding_box"))
+                iou = self._compute_iou(
+                    det.get("bounding_box"), raw_det.get("bounding_box")
+                )
                 if iou > best_iou:
                     best_iou = iou
                     best_idx = idx
@@ -798,12 +1071,11 @@ class LicensePlateUseCase(BaseProcessor):
                 "category": det.get("category", "unknown"),
                 "confidence": det.get("confidence", 0.0),
                 "bounding_box": det.get("bounding_box", {}),
-                "mask": det.get("mask", det.get("masks", None))  # Accept either key
+                "mask": det.get("mask", det.get("masks", None)),  # Accept either key
             }
             for det in detections
         ]
 
-
     # ------------------------------------------------------------------ #
     # Canonical ID helpers                                               #
     # ------------------------------------------------------------------ #
@@ -901,7 +1173,9 @@ class LicensePlateUseCase(BaseProcessor):
 
     def _format_timestamp(self, timestamp: float) -> str:
         """Format a timestamp for human-readable output."""
-        return datetime.fromtimestamp(timestamp, timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')
+        return datetime.fromtimestamp(timestamp, timezone.utc).strftime(
+            "%Y-%m-%d %H:%M:%S UTC"
+        )
 
     def _get_tracking_start_time(self) -> str:
         """Get the tracking start time, formatted as a string."""