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

matrice_analytics/post_processing/usecases/weapon_detection.py

@@ -317,7 +317,7 @@ class WeaponDetectionUseCase(BaseProcessor):
         total_counts = [{"category": cat, "count": count} for cat, count in total_counts_dict.items() if count > 0]
 
         # Build current_counts
-        current_counts = [{"category": cat, "count": count} for cat, count in per_category_count.items() if count > 0]
+        current_counts = [{"category": 'Weapon', "count": count} for cat, count in per_category_count.items() if count > 0]
 
         # Prepare detections
         detections = []
@@ -377,6 +377,7 @@ class WeaponDetectionUseCase(BaseProcessor):
             start_time=high_precision_start_timestamp,
             reset_time=high_precision_reset_timestamp
         )
+        tracking_stat['target_categories'] = ['Weapon']
         tracking_stats.append(tracking_stat)
         return tracking_stats
 

matrice_analytics/post_processing/utils/alert_instance_utils.py

@@ -76,7 +76,8 @@ class ALERT_INSTANCE:
         config_topic: str = "alert_instant_config_request",
         trigger_topic: str = "alert_instant_triggered",
         polling_interval: int = 10,
-        logger: Optional[logging.Logger] = None
+        logger: Optional[logging.Logger] = None,
+        app_deployment_id: Optional[str] = None
     ):
         """
         Initialize ALERT_INSTANCE.
@@ -88,6 +89,7 @@ class ALERT_INSTANCE:
             trigger_topic: Topic/stream name for publishing triggers
             polling_interval: Seconds between config polling
             logger: Python logger instance
+            app_deployment_id: App deployment ID to filter incoming alerts (only process alerts matching this ID)
         """
         self.redis_client = redis_client
         self.kafka_client = kafka_client
@@ -95,6 +97,7 @@ class ALERT_INSTANCE:
         self.trigger_topic = trigger_topic
         self.polling_interval = polling_interval
         self.logger = logger or logging.getLogger(__name__)
+        self.app_deployment_id = app_deployment_id
 
         # In-memory alert storage: {instant_alert_id: AlertConfig}
         self._alerts: Dict[str, AlertConfig] = {}
@@ -114,7 +117,7 @@ class ALERT_INSTANCE:
         self.logger.info(
             f"Initialized ALERT_INSTANCE with config_topic={config_topic}, "
             f"trigger_topic={trigger_topic}, polling_interval={polling_interval}s, "
-            f"cooldown={self._cooldown_seconds}s"
+            f"cooldown={self._cooldown_seconds}s, app_deployment_id={app_deployment_id}"
         )
 
     def start(self):
@@ -394,6 +397,29 @@ class ALERT_INSTANCE:
                 self.logger.warning("[ALERT_DEBUG] Skipping malformed config with 'raw' key only")
                 return
             
+            # Log detection_service field (informational only, no filtering)
+            detection_service = config_data.get('detection_service', '')
+            self.logger.info(f"[ALERT_DEBUG] detection_service: '{detection_service}'")
+            
+            # Filter by app_deployment_id - only process alerts that match our app_deployment_id
+            incoming_app_deployment_id = config_data.get('app_deployment_id', '')
+            if self.app_deployment_id:
+                if incoming_app_deployment_id != self.app_deployment_id:
+                    self.logger.info(
+                        f"[ALERT_DEBUG] Skipping alert - app_deployment_id mismatch: "
+                        f"incoming='{incoming_app_deployment_id}', ours='{self.app_deployment_id}'"
+                    )
+                    return
+                else:
+                    self.logger.info(
+                        f"[ALERT_DEBUG] ✓ app_deployment_id match: '{incoming_app_deployment_id}'"
+                    )
+            else:
+                self.logger.warning(
+                    f"[ALERT_DEBUG] No app_deployment_id filter set, processing all alerts. "
+                    f"Incoming app_deployment_id: '{incoming_app_deployment_id}'"
+                )
+            
             # Log individual fields before creating AlertConfig
             self.logger.debug(f"[ALERT_DEBUG] Extracted fields from config_data:")
             self.logger.debug(f"[ALERT_DEBUG]   - instant_alert_id: '{config_data.get('instant_alert_id', 'MISSING')}'")
@@ -706,7 +732,13 @@ class ALERT_INSTANCE:
         detection: Dict[str, Any],
         config: Dict[str, Any]
     ) -> bool:
-        """Evaluate license plate detection against alert criteria."""
+        """
+        Evaluate license plate detection against alert criteria.
+        
+        Supports two alert conditions:
+        - "in_list" (BLACKLIST): Alert ONLY when detected plate IS in targetPlates list
+        - "not_in_list" (WHITELIST): Alert when detected plate is NOT in targetPlates list
+        """
         self.logger.debug(f"[ALERT_DEBUG] ========== EVALUATING LPR ALERT ==========")
         self.logger.debug(f"[ALERT_DEBUG] Alert ID: {alert.instant_alert_id}")
         self.logger.debug(f"[ALERT_DEBUG] Alert Name: {alert.alert_name}")
@@ -715,9 +747,12 @@ class ALERT_INSTANCE:
         
         target_plates = config.get("targetPlates", [])
         min_confidence = config.get("minConfidence", 0.0)
+        # Get alertCondition: "in_list" (blacklist) or "not_in_list" (whitelist)
+        alert_condition = config.get("alertCondition", "in_list")
         
         self.logger.debug(f"[ALERT_DEBUG] Target plates: {target_plates}")
         self.logger.debug(f"[ALERT_DEBUG] Min confidence: {min_confidence}")
+        self.logger.info(f"[ALERT_DEBUG] Alert condition: '{alert_condition}' (in_list=blacklist, not_in_list=whitelist)")
 
         plate_number = detection.get("plateNumber", "").upper().strip()
         confidence = detection.get("confidence", 0.0)
@@ -725,37 +760,68 @@ class ALERT_INSTANCE:
         self.logger.debug(f"[ALERT_DEBUG] Detected plate (normalized): '{plate_number}'")
         self.logger.debug(f"[ALERT_DEBUG] Detection confidence: {confidence}")
 
+        # Skip empty plate numbers
+        if not plate_number:
+            self.logger.debug(f"[ALERT_DEBUG] ✗ Empty plate number, skipping")
+            return False
+
         # Check if plate matches target list (case-insensitive)
-        plate_match = any(
-            plate_number == str(target).upper().strip()
-            for target in target_plates
-        )
+        normalized_targets = [str(t).upper().strip() for t in target_plates]
+        plate_in_list = plate_number in normalized_targets
         
-        self.logger.debug(f"[ALERT_DEBUG] Plate match result: {plate_match}")
-        if not plate_match and target_plates:
-            normalized_targets = [str(t).upper().strip() for t in target_plates]
-            self.logger.debug(f"[ALERT_DEBUG] Normalized target plates: {normalized_targets}")
-            self.logger.debug(f"[ALERT_DEBUG] Plate '{plate_number}' not in {normalized_targets}")
+        self.logger.debug(f"[ALERT_DEBUG] Normalized target plates: {normalized_targets}")
+        self.logger.debug(f"[ALERT_DEBUG] Plate '{plate_number}' in list: {plate_in_list}")
 
-        # Check confidence threshold
-        min_confidence=0.05
+        # Check confidence threshold (minimum 0.05)
+        min_confidence = max(0.05, min_confidence)
         confidence_match = confidence >= min_confidence
         
         self.logger.debug(f"[ALERT_DEBUG] Confidence match result: {confidence_match} ({confidence} >= {min_confidence})")
 
-        if plate_match:
-            self.logger.info(
-                f"[ALERT_DEBUG] ✓ LPR ALERT TRIGGERED: {alert.alert_name} - "
-                f"Plate: {plate_number}, Confidence: {confidence:.2f}"
-            )
-            return True
+        # Determine if alert should trigger based on alertCondition
+        should_trigger = False
+        
+        if alert_condition == "in_list":
+            # BLACKLIST: Alert only when plate IS in the target list
+            if plate_in_list and confidence_match:
+                should_trigger = True
+                self.logger.info(
+                    f"[ALERT_DEBUG] ✓ LPR BLACKLIST ALERT TRIGGERED: {alert.alert_name} - "
+                    f"Plate: {plate_number} IS in blacklist, Confidence: {confidence:.2f}"
+                )
+            else:
+                self.logger.debug(
+                    f"[ALERT_DEBUG] ✗ LPR blacklist alert NOT triggered: {alert.alert_name} - "
+                    f"Plate '{plate_number}' in_list={plate_in_list}, confidence_match={confidence_match}"
+                )
+        
+        elif alert_condition == "not_in_list":
+            # WHITELIST: Alert when plate is NOT in the target list
+            if not plate_in_list and confidence_match:
+                should_trigger = True
+                self.logger.info(
+                    f"[ALERT_DEBUG] ✓ LPR WHITELIST ALERT TRIGGERED: {alert.alert_name} - "
+                    f"Plate: {plate_number} is NOT in whitelist, Confidence: {confidence:.2f}"
+                )
+            else:
+                self.logger.debug(
+                    f"[ALERT_DEBUG] ✗ LPR whitelist alert NOT triggered: {alert.alert_name} - "
+                    f"Plate '{plate_number}' in_list={plate_in_list} (whitelisted), confidence_match={confidence_match}"
+                )
+        
         else:
-            self.logger.debug(
-                f"[ALERT_DEBUG] ✗ LPR alert NOT triggered: {alert.alert_name} - "
-                f"Plate match: {plate_match}"
+            # Unknown condition, default to blacklist behavior for backward compatibility
+            self.logger.warning(
+                f"[ALERT_DEBUG] Unknown alertCondition '{alert_condition}', defaulting to 'in_list' (blacklist) behavior"
             )
+            if plate_in_list and confidence_match:
+                should_trigger = True
+                self.logger.info(
+                    f"[ALERT_DEBUG] ✓ LPR ALERT TRIGGERED (default): {alert.alert_name} - "
+                    f"Plate: {plate_number}, Confidence: {confidence:.2f}"
+                )
 
-        return False
+        return should_trigger
 
     def _evaluate_count_alert(
         self,
@@ -868,10 +934,11 @@ class ALERT_INSTANCE:
             "detectionType": detection_type_raw,
             "confidence": detection.get("confidence", 0.0),
             "coordinates": detection.get("coordinates", {}),
-            "cameraName": detection.get("cameraName", "")
+            "cameraName": detection.get("cameraName", ""),
+            "locationName": detection.get("locationName", "")
         }
 
-        # Add type-specific fieldss
+        # Add type-specific fields
         if detection_type_raw == "license_plate":
             context_data.update({
                 "plateNumber": detection.get("plateNumber", ""),
@@ -900,6 +967,7 @@ class ALERT_INSTANCE:
         trigger_message = {
             "instant_alert_id": alert.instant_alert_id,
             "camera_id": alert.camera_id,
+            "frame_id": detection.get("frame_id", ""),
             "triggered_at": datetime.now(timezone.utc).isoformat(),
             "context_data": context_data
         }

matrice_analytics/post_processing/utils/business_metrics_manager_utils.py

@@ -28,6 +28,9 @@ DEFAULT_AGGREGATION_INTERVAL = 300
 # Supported aggregation types
 AGGREGATION_TYPES = ["mean", "min", "max", "sum"]
 
+# Cache for location names to avoid repeated API calls
+_location_name_cache: Dict[str, str] = {}
+
 # Default metrics configuration with aggregation type
 DEFAULT_METRICS_CONFIG = {
     "customer_to_staff_ratio": "mean",
@@ -85,6 +88,8 @@ class CameraMetricsState:
     camera_name: str = ""
     app_deployment_id: str = ""
     application_id: str = ""
+    location_id: str = ""
+    location_name: str = ""
     metrics: Dict[str, MetricAggregator] = field(default_factory=dict)
     last_push_time: float = field(default_factory=time.time)
     
@@ -311,13 +316,14 @@ class BUSINESS_METRICS_MANAGER:
             stream_info: Stream metadata from usecase
             
         Returns:
-            Dict with camera_id, camera_name, app_deployment_id, application_id
+            Dict with camera_id, camera_name, app_deployment_id, application_id, location_id
         """
         result = {
             "camera_id": "",
             "camera_name": "",
             "app_deployment_id": "",
-            "application_id": ""
+            "application_id": "",
+            "location_id": ""
         }
         
         if not stream_info:
@@ -393,6 +399,16 @@ class BUSINESS_METRICS_MANAGER:
                 ""
             )
             
+            # location_id - from camera_info.location
+            result["location_id"] = (
+                camera_info.get("location", "") or
+                camera_info.get("location_id", "") or
+                camera_info.get("locationId", "") or
+                input_camera_info.get("location", "") or
+                input_camera_info.get("location_id", "") or
+                ""
+            )
+            
             self.logger.debug(f"[BUSINESS_METRICS_MANAGER] Extracted camera info: {result}")
             
         except Exception as e:
@@ -400,6 +416,66 @@ class BUSINESS_METRICS_MANAGER:
         
         return result
     
+    def _fetch_location_name(self, location_id: str) -> str:
+        """
+        Fetch location name from API using location_id.
+        
+        Args:
+            location_id: The location ID to look up
+            
+        Returns:
+            Location name string, or 'Entry Reception' as default if API fails
+        """
+        global _location_name_cache
+        default_location = "Entry Reception"
+        
+        if not location_id:
+            self.logger.debug(f"[BUSINESS_METRICS_MANAGER] No location_id provided, using default: '{default_location}'")
+            return default_location
+        
+        # Check cache first
+        if location_id in _location_name_cache:
+            cached_name = _location_name_cache[location_id]
+            self.logger.debug(f"[BUSINESS_METRICS_MANAGER] Using cached location name for '{location_id}': '{cached_name}'")
+            return cached_name
+        
+        # Need factory reference with session to make API call
+        if not self._factory_ref or not self._factory_ref._session:
+            self.logger.warning(f"[BUSINESS_METRICS_MANAGER] No session available for location API, using default: '{default_location}'")
+            return default_location
+        
+        try:
+            endpoint = f"/v1/inference/get_location/{location_id}"
+            self.logger.info(f"[BUSINESS_METRICS_MANAGER] Fetching location name from API: {endpoint}")
+            
+            response = self._factory_ref._session.rpc.get(endpoint)
+            
+            if response and isinstance(response, dict):
+                success = response.get("success", False)
+                if success:
+                    data = response.get("data", {})
+                    location_name = data.get("locationName", default_location)
+                    self.logger.info(f"[BUSINESS_METRICS_MANAGER] ✓ Fetched location name: '{location_name}' for location_id: '{location_id}'")
+                    
+                    # Cache the result
+                    _location_name_cache[location_id] = location_name
+                    return location_name
+                else:
+                    self.logger.warning(
+                        f"[BUSINESS_METRICS_MANAGER] API returned success=false for location_id '{location_id}': "
+                        f"{response.get('message', 'Unknown error')}"
+                    )
+            else:
+                self.logger.warning(f"[BUSINESS_METRICS_MANAGER] Invalid response format from API: {response}")
+                
+        except Exception as e:
+            self.logger.error(f"[BUSINESS_METRICS_MANAGER] Error fetching location name for '{location_id}': {e}", exc_info=True)
+        
+        # Use default on any failure
+        self.logger.info(f"[BUSINESS_METRICS_MANAGER] Using default location name: '{default_location}'")
+        _location_name_cache[location_id] = default_location
+        return default_location
+    
     def process_metrics(
         self,
         camera_id: str,
@@ -452,11 +528,16 @@ class BUSINESS_METRICS_MANAGER:
             final_camera_name = camera_info.get("camera_name") or ""
             final_app_deployment_id = camera_info.get("app_deployment_id") or factory_app_deployment_id or ""
             final_application_id = camera_info.get("application_id") or factory_application_id or ""
+            final_location_id = camera_info.get("location_id") or ""
+            
+            # Fetch location_name from API using location_id
+            final_location_name = self._fetch_location_name(final_location_id)
             
             self.logger.info(
                 f"[BUSINESS_METRICS_MANAGER] Final values - camera_id={final_camera_id}, "
                 f"camera_name={final_camera_name}, app_deployment_id={final_app_deployment_id}, "
-                f"application_id={final_application_id}"
+                f"application_id={final_application_id}, location_id={final_location_id}, "
+                f"location_name={final_location_name}"
             )
             
             with self._states_lock:
@@ -466,7 +547,9 @@ class BUSINESS_METRICS_MANAGER:
                         camera_id=final_camera_id,
                         camera_name=final_camera_name,
                         app_deployment_id=final_app_deployment_id,
-                        application_id=final_application_id
+                        application_id=final_application_id,
+                        location_id=final_location_id,
+                        location_name=final_location_name
                     )
                     self.logger.info(
                         f"[BUSINESS_METRICS_MANAGER] ✓ Created new state for camera: {final_camera_id}"
@@ -483,6 +566,12 @@ class BUSINESS_METRICS_MANAGER:
                     self.logger.debug(f"[BUSINESS_METRICS_MANAGER] Updated app_deployment_id to: {final_app_deployment_id}")
                 if final_application_id and not state.application_id:
                     state.application_id = final_application_id
+                if final_location_id and not state.location_id:
+                    state.location_id = final_location_id
+                    self.logger.debug(f"[BUSINESS_METRICS_MANAGER] Updated location_id to: {final_location_id}")
+                if final_location_name and not state.location_name:
+                    state.location_name = final_location_name
+                    self.logger.debug(f"[BUSINESS_METRICS_MANAGER] Updated location_name to: {final_location_name}")
             
             # Add each metric value to aggregator
             metrics_added = 0
@@ -589,6 +678,7 @@ class BUSINESS_METRICS_MANAGER:
                     "camera_name": state.camera_name,
                     "app_deployment_id": state.app_deployment_id,
                     "application_id": state.application_id,
+                    "location_name": state.location_name,
                     "business_metrics": aggregated_metrics,
                     "timestamp": datetime.now(timezone.utc).isoformat(),
                     "aggregation_interval_seconds": self.aggregation_interval
@@ -695,6 +785,8 @@ class BUSINESS_METRICS_MANAGER:
                     "camera_name": state.camera_name,
                     "app_deployment_id": state.app_deployment_id,
                     "application_id": state.application_id,
+                    "location_id": state.location_id,
+                    "location_name": state.location_name,
                     "metrics_count": {
                         name: len(agg.values) 
                         for name, agg in state.metrics.items()
@@ -711,6 +803,7 @@ class BUSINESS_METRICS_MANAGER:
                 cam_id: {
                     "camera_id": state.camera_id,
                     "camera_name": state.camera_name,
+                    "location_name": state.location_name,
                     "metrics_count": {
                         name: len(agg.values) 
                         for name, agg in state.metrics.items()

matrice_analytics/post_processing/utils/incident_manager_utils.py

@@ -38,6 +38,9 @@ DEFAULT_THRESHOLDS = [
     {"level": "critical", "percentage": 30}
 ]
 
+# Cache for location names to avoid repeated API calls
+_location_name_cache: Dict[str, str] = {}
+
 
 @dataclass
 class IncidentState:
@@ -453,20 +456,22 @@ class INCIDENT_MANAGER:
                 'camera_group': 'staging-customer-1', 
                 'location': '6908756db129880c34f2e09a'
             }, 
-            'frame_id': '...'
+            'frame_id': '7b94e2f668fb456f95b73c3084e17f8a'
         }
         
         Args:
             stream_info: Stream metadata from usecase
             
         Returns:
-            Dict with camera_id, camera_name, app_deployment_id, application_id
+            Dict with camera_id, camera_name, app_deployment_id, application_id, frame_id, location_id
         """
         result = {
             "camera_id": "",
             "camera_name": "",
             "app_deployment_id": "",
-            "application_id": ""
+            "application_id": "",
+            "frame_id": "",
+            "location_id": ""
         }
         
         if not stream_info:
@@ -563,10 +568,30 @@ class INCIDENT_MANAGER:
                 ""
             )
             
+            # frame_id - at top level of stream_info
+            result["frame_id"] = (
+                stream_info.get("frame_id", "") or
+                stream_info.get("frameId", "") or
+                input_settings.get("frame_id", "") or
+                input_settings.get("frameId", "") or
+                ""
+            )
+            
+            # location_id - from camera_info.location
+            result["location_id"] = (
+                camera_info.get("location", "") or
+                camera_info.get("location_id", "") or
+                camera_info.get("locationId", "") or
+                input_camera_info.get("location", "") or
+                input_camera_info.get("location_id", "") or
+                ""
+            )
+            
             self.logger.debug(
                 f"[INCIDENT_MANAGER] Extracted from stream_info - "
                 f"camera_id={result['camera_id']}, camera_name={result['camera_name']}, "
-                f"app_deployment_id={result['app_deployment_id']}, application_id={result['application_id']}"
+                f"app_deployment_id={result['app_deployment_id']}, application_id={result['application_id']}, "
+                f"frame_id={result['frame_id']}, location_id={result['location_id']}"
             )
             
         except Exception as e:
@@ -592,6 +617,66 @@ class INCIDENT_MANAGER:
             return "high"
         return level
     
+    def _fetch_location_name(self, location_id: str) -> str:
+        """
+        Fetch location name from API using location_id.
+        
+        Args:
+            location_id: The location ID to look up
+            
+        Returns:
+            Location name string, or 'Entry Reception' as default if API fails
+        """
+        global _location_name_cache
+        default_location = "Entry Reception"
+        
+        if not location_id:
+            self.logger.debug(f"[INCIDENT_MANAGER] No location_id provided, using default: '{default_location}'")
+            return default_location
+        
+        # Check cache first
+        if location_id in _location_name_cache:
+            cached_name = _location_name_cache[location_id]
+            self.logger.debug(f"[INCIDENT_MANAGER] Using cached location name for '{location_id}': '{cached_name}'")
+            return cached_name
+        
+        # Need factory reference with session to make API call
+        if not self._factory_ref or not self._factory_ref._session:
+            self.logger.warning(f"[INCIDENT_MANAGER] No session available for location API, using default: '{default_location}'")
+            return default_location
+        
+        try:
+            endpoint = f"/v1/inference/get_location/{location_id}"
+            self.logger.info(f"[INCIDENT_MANAGER] Fetching location name from API: {endpoint}")
+            
+            response = self._factory_ref._session.rpc.get(endpoint)
+            
+            if response and isinstance(response, dict):
+                success = response.get("success", False)
+                if success:
+                    data = response.get("data", {})
+                    location_name = data.get("locationName", default_location)
+                    self.logger.info(f"[INCIDENT_MANAGER] ✓ Fetched location name: '{location_name}' for location_id: '{location_id}'")
+                    
+                    # Cache the result
+                    _location_name_cache[location_id] = location_name
+                    return location_name
+                else:
+                    self.logger.warning(
+                        f"[INCIDENT_MANAGER] API returned success=false for location_id '{location_id}': "
+                        f"{response.get('message', 'Unknown error')}"
+                    )
+            else:
+                self.logger.warning(f"[INCIDENT_MANAGER] Invalid response format from API: {response}")
+                
+        except Exception as e:
+            self.logger.error(f"[INCIDENT_MANAGER] Error fetching location name for '{location_id}': {e}", exc_info=True)
+        
+        # Use default on any failure
+        self.logger.info(f"[INCIDENT_MANAGER] Using default location name: '{default_location}'")
+        _location_name_cache[location_id] = default_location
+        return default_location
+    
     def _generate_incident_id(self, camera_id: str, cycle_id: int) -> str:
         """Generate a unique incident_id for a camera's cycle."""
         return f"incident_{camera_id}_{cycle_id}"
@@ -1005,6 +1090,8 @@ class INCIDENT_MANAGER:
             "app_deployment_id": "...",
             "application_id": "...",
             "camera_name": "...",
+            "frame_id": "...",
+            "location_name": "...",
             "incidents": [{
                 "incident_id": "...",
                 "incident_type": "...",
@@ -1061,10 +1148,18 @@ class INCIDENT_MANAGER:
             ""
         )
         
+        # Extract frame_id from stream_info
+        final_frame_id = stream_camera_info.get("frame_id", "")
+        
+        # Fetch location_name from API using location_id
+        location_id = stream_camera_info.get("location_id", "")
+        final_location_name = self._fetch_location_name(location_id)
+        
         self.logger.info(
             f"[INCIDENT_MANAGER] Building message with - "
             f"camera_id={final_camera_id}, camera_name={final_camera_name}, "
-            f"app_deployment_id={final_app_deployment_id}, application_id={final_application_id}"
+            f"app_deployment_id={final_app_deployment_id}, application_id={final_application_id}, "
+            f"frame_id={final_frame_id}, location_name={final_location_name}"
         )
         
         # Build incident - ONLY include required fields
@@ -1081,12 +1176,14 @@ class INCIDENT_MANAGER:
             "human_text": incident_data.get("human_text", "")
         }
         
-        # Build final message in STRICT format
+        # Build final message with all required fields
         message = {
             "camera_id": final_camera_id,
             "app_deployment_id": final_app_deployment_id,
             "application_id": final_application_id,
             "camera_name": final_camera_name,
+            "frame_id": final_frame_id,
+            "location_name": final_location_name,
             "incidents": [incident]
         }
         

{matrice_analytics-0.1.89.dist-info → matrice_analytics-0.1.97.dist-info}/METADATA

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