matrice 1.0.99273__py3-none-any.whl → 1.0.99275__py3-none-any.whl

matrice/deploy/aggregator/analytics.py

@@ -0,0 +1,435 @@
+import logging
+import threading
+import time
+import base64
+import json
+from typing import Dict, Any, Optional, List, Tuple
+
+from matrice.session import Session
+from confluent_kafka import Producer
+
+class AnalyticsSummarizer:
+    """
+    Buffers aggregated camera_results and emits 5-minute rollups per camera
+    focusing on tracking_stats per application.
+
+    Output structure example per camera:
+        {
+          "camera_name": "camera_1",
+          "inferencePipelineId": "pipeline-xyz",
+          "camera_group": "group_a",
+          "location": "Lobby",
+          "agg_apps": [
+            {
+              "application_name": "People Counting",
+              "application_key_name": "People_Counting",
+              "application_version": "1.3",
+              "tracking_stats": {
+                "input_timestamp": "00:00:09.9",          # last seen
+                "reset_timestamp": "00:00:00",             # earliest seen in window
+                "current_counts": [{"category": "person", "count": 4}],  # last seen
+                "total_counts": [{"category": "person", "count": 37}]   # max seen in window
+              }
+            }
+          ],
+          "summary_metadata": {
+            "window_seconds": 300,
+            "messages_aggregated": 123,
+            "start_time": 1710000000.0,
+            "end_time": 1710000300.0
+          }
+        }
+    """
+
+    def __init__(
+        self,
+        session: Session,
+        inference_pipeline_id: str,
+        flush_interval_seconds: int = 300,
+    ) -> None:
+        self.session = session
+        self.inference_pipeline_id = inference_pipeline_id
+        self.flush_interval_seconds = flush_interval_seconds
+
+        self.kafka_producer = self._setup_kafka_producer()
+
+        # Threading
+        self._stop = threading.Event()
+        self._thread: Optional[threading.Thread] = None
+        self._is_running = False
+        self._lock = threading.RLock()
+
+        # Ingestion queue
+        self._ingest_queue: List[Dict[str, Any]] = []
+
+        # Aggregation buffers keyed by (camera_group, camera_name)
+        # Each value holds:
+        #   {
+        #       "window_start": float,
+        #       "last_seen": float,
+        #       "camera_info": dict,
+        #       "messages": int,
+        #       "apps": {
+        #           application_key_name: {
+        #               "meta": {name, key_name, version},
+        #               "last_input_timestamp": str,
+        #               "earliest_reset_timestamp": str | None,
+        #               "current_counts": {category: last_value},
+        #               "total_counts": {category: max_value}
+        #           }
+        #       }
+        #   }
+        #
+        self._buffers: Dict[Tuple[str, str], Dict[str, Any]] = {}
+
+        # Stats
+        self.stats = {
+            "start_time": None,
+            "summaries_published": 0,
+            "messages_ingested": 0,
+            "errors": 0,
+            "last_error": None,
+            "last_error_time": None,
+            "last_flush_time": None,
+        }
+
+    def _setup_kafka_producer(self):
+        path = "/v1/actions/get_kafka_info"
+
+        response = self.session.get(path=path, raise_exception=True)
+
+        if not response or not response.get("success"):
+            raise ValueError(f"Failed to fetch Kafka config: {response.get('message', 'No response')}")
+
+        # Decode base64 fields
+        encoded_ip = response["data"]["ip"]
+        encoded_port = response["data"]["port"]
+        ip = base64.b64decode(encoded_ip).decode("utf-8")
+        port = base64.b64decode(encoded_port).decode("utf-8")
+        bootstrap_servers = f"{ip}:{port}"
+        
+        
+        # Kafka handler for summaries (reuse pipeline server topic)
+        kafka_producer = Producer({
+            "bootstrap.servers": bootstrap_servers,
+            "acks": "all",
+            "retries": 3,
+            "retry.backoff.ms": 1000,
+            "request.timeout.ms": 30000,
+            "max.in.flight.requests.per.connection": 1,
+            "linger.ms": 10,
+            "batch.size": 4096,
+            "queue.buffering.max.ms": 50,
+            "log_level": 0,
+        })
+        return kafka_producer
+    
+    def start(self) -> bool:
+        if self._is_running:
+            logging.warning("Analytics summarizer already running")
+            return True
+        try:
+            self._stop.clear()
+            self._is_running = True
+            self.stats["start_time"] = time.time()
+            self.stats["last_flush_time"] = time.time()
+            self._thread = threading.Thread(
+                target=self._run, name=f"AnalyticsSummarizer-{self.inference_pipeline_id}", daemon=True
+            )
+            self._thread.start()
+            logging.info("Analytics summarizer started")
+            return True
+        except Exception as exc:
+            self._record_error(f"Failed to start analytics summarizer: {exc}")
+            self.stop()
+            return False
+
+    def stop(self) -> None:
+        if not self._is_running:
+            logging.info("Analytics summarizer not running")
+            return
+        logging.info("Stopping analytics summarizer...")
+        self._is_running = False
+        self._stop.set()
+        try:
+            if self._thread and self._thread.is_alive():
+                self._thread.join(timeout=5.0)
+        except Exception as exc:
+            logging.error(f"Error joining analytics summarizer thread: {exc}")
+        self._thread = None
+        logging.info("Analytics summarizer stopped")
+
+    def ingest_result(self, aggregated_result: Dict[str, Any]) -> None:
+        """
+        Receive a single aggregated camera_results payload for buffering.
+        This is intended to be called by the publisher after successful publish.
+        """
+        try:
+            with self._lock:
+                self._ingest_queue.append(aggregated_result)
+                self.stats["messages_ingested"] += 1
+        except Exception as exc:
+            self._record_error(f"Failed to ingest result: {exc}")
+
+    def _run(self) -> None:
+        logging.info("Analytics summarizer worker started")
+        while not self._stop.is_set():
+            try:
+                # Drain ingestion queue
+                self._drain_ingest_queue()
+
+                # Time-based flush
+                current_time = time.time()
+                last_flush = self.stats.get("last_flush_time") or current_time
+                if current_time - last_flush >= self.flush_interval_seconds:
+                    self._flush_all(current_time)
+                    self.stats["last_flush_time"] = current_time
+
+                # Prevent busy loop
+                time.sleep(0.5)
+
+            except Exception as exc:
+                if not self._stop.is_set():
+                    self._record_error(f"Error in summarizer loop: {exc}")
+                    time.sleep(0.2)
+        # Final flush on stop
+        try:
+            self._flush_all(time.time())
+        except Exception as exc:
+            logging.error(f"Error during final analytics flush: {exc}")
+        logging.info("Analytics summarizer worker stopped")
+
+    def _drain_ingest_queue(self) -> None:
+        local_batch: List[Dict[str, Any]] = []
+        with self._lock:
+            if self._ingest_queue:
+                local_batch = self._ingest_queue
+                self._ingest_queue = []
+
+        for result in local_batch:
+            try:
+                self._add_to_buffers(result)
+            except Exception as exc:
+                self._record_error(f"Failed buffering result: {exc}")
+
+    def _add_to_buffers(self, result: Dict[str, Any]) -> None:
+        camera_info = result.get("camera_info", {}) or {}
+        camera_name = camera_info.get("camera_name") or "unknown"
+        camera_group = camera_info.get("camera_group") or "default_group"
+        location = camera_info.get("location")
+
+        key = (camera_group, camera_name)
+        now = time.time()
+        buffer = self._buffers.get(key)
+        if not buffer:
+            buffer = {
+                "window_start": now,
+                "last_seen": now,
+                "camera_info": {
+                    "camera_name": camera_name,
+                    "camera_group": camera_group,
+                    "location": location,
+                },
+                "messages": 0,
+                "apps": {},
+            }
+            self._buffers[key] = buffer
+        else:
+            buffer["last_seen"] = now
+            # Update location if provided
+            if location:
+                buffer["camera_info"]["location"] = location
+
+        buffer["messages"] += 1
+
+        # Process each app
+        agg_apps = result.get("agg_apps", []) or []
+        for app in agg_apps:
+            app_name = app.get("application_name") or app.get("app_name") or "unknown"
+            app_key = app.get("application_key_name") or app.get("application_key") or app_name
+            app_ver = app.get("application_version") or app.get("version") or ""
+
+            app_buf = buffer["apps"].get(app_key)
+            if not app_buf:
+                app_buf = {
+                    "meta": {
+                        "application_name": app_name,
+                        "application_key_name": app_key,
+                        "application_version": app_ver,
+                    },
+                    "last_input_timestamp": None,
+                    "reset_timestamp": None,
+                    "current_counts": {},
+                    "total_counts": {},
+                }
+                buffer["apps"][app_key] = app_buf
+
+            # Extract tracking_stats from app
+            tracking_stats = self._extract_tracking_stats_from_app(app)
+            if not tracking_stats:
+                continue
+
+            input_ts = tracking_stats.get("input_timestamp")
+            reset_ts = tracking_stats.get("reset_timestamp")
+            current_counts = tracking_stats.get("current_counts") or []
+            total_counts = tracking_stats.get("total_counts") or []
+
+            if input_ts:
+                app_buf["last_input_timestamp"] = input_ts
+            if reset_ts is not None:
+                # Simplify: keep last seen reset timestamp only
+                app_buf["reset_timestamp"] = reset_ts
+
+            # Update current counts (take last observed)
+            for item in current_counts:
+                cat = item.get("category")
+                cnt = item.get("count")
+                if cat is not None and cnt is not None:
+                    app_buf["current_counts"][cat] = cnt
+
+            # Update total counts (take max observed to avoid double-counting cumulative totals)
+            for item in total_counts:
+                cat = item.get("category")
+                cnt = item.get("count")
+                if cat is None or cnt is None:
+                    continue
+                existing = app_buf["total_counts"].get(cat)
+                if existing is None or cnt > existing:
+                    app_buf["total_counts"][cat] = cnt
+
+    def _extract_tracking_stats_from_app(self, app: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        # Prefer direct 'tracking_stats' if present
+        if isinstance(app.get("tracking_stats"), dict):
+            return app["tracking_stats"]
+
+        # Otherwise, try agg_summary structure: pick latest by key order
+        agg_summary = app.get("agg_summary")
+        if isinstance(agg_summary, dict) and agg_summary:
+            # Keys might be frame numbers as strings -> choose max numerically
+            try:
+                latest_key = max(agg_summary.keys(), key=lambda k: int(str(k)))
+            except Exception:
+                latest_key = sorted(agg_summary.keys())[-1]
+            entry = agg_summary.get(latest_key) or {}
+            ts = entry.get("tracking_stats")
+            if isinstance(ts, dict):
+                return ts
+        return None
+
+    def _flush_all(self, end_time: float) -> None:
+        # Build and publish summaries per camera
+        with self._lock:
+            items = list(self._buffers.items())
+            # Reset buffers after copying references
+            self._buffers = {}
+
+        for (camera_group, camera_name), buf in items:
+            try:
+                camera_info = buf.get("camera_info", {})
+                start_time = buf.get("window_start", end_time)
+                messages = buf.get("messages", 0)
+
+                agg_apps_output: List[Dict[str, Any]] = []
+                for app_key, app_buf in buf.get("apps", {}).items():
+                    # Convert counts dicts to lists
+                    current_list = [
+                        {"category": cat, "count": cnt}
+                        for cat, cnt in app_buf.get("current_counts", {}).items()
+                    ]
+                    total_list = [
+                        {"category": cat, "count": cnt}
+                        for cat, cnt in app_buf.get("total_counts", {}).items()
+                    ]
+
+                    agg_apps_output.append(
+                        {
+                            **app_buf["meta"],
+                            "tracking_stats": {
+                                "input_timestamp": app_buf.get("last_input_timestamp"),
+                                "reset_timestamp": app_buf.get("reset_timestamp"),
+                                "current_counts": current_list,
+                                "total_counts": total_list,
+                            },
+                        }
+                    )
+
+                summary_payload = {
+                    "camera_name": camera_info.get("camera_name", camera_name),
+                    "inferencePipelineId": self.inference_pipeline_id,
+                    "camera_group": camera_info.get("camera_group", camera_group),
+                    "location": camera_info.get("location"),
+                    "agg_apps": agg_apps_output,
+                    "summary_metadata": {
+                        "window_seconds": self.flush_interval_seconds,
+                        "messages_aggregated": messages,
+                    },
+                }
+
+                # Publish via Kafka (JSON bytes)
+                self.kafka_producer.produce(
+                    topic="Analytics-Inference-Pipeline",
+                    key=str(camera_name).encode("utf-8"),
+                    value=json.dumps(summary_payload, separators=(",", ":")).encode("utf-8"),
+                )
+                self.stats["summaries_published"] += 1
+                logging.debug(
+                    f"Published 5-min summary for camera {camera_group}/{camera_name} with {len(agg_apps_output)} apps"
+                )
+            except Exception as exc:
+                self._record_error(f"Failed to publish summary for {camera_group}/{camera_name}: {exc}")
+        # Brief flush for delivery
+        try:
+            self.kafka_producer.poll(0)
+            self.kafka_producer.flush(5)
+        except Exception:
+            pass
+
+    def _record_error(self, error_message: str) -> None:
+        with self._lock:
+            self.stats["errors"] += 1
+            self.stats["last_error"] = error_message
+            self.stats["last_error_time"] = time.time()
+        logging.error(f"Analytics summarizer error: {error_message}")
+
+    def get_stats(self) -> Dict[str, Any]:
+        with self._lock:
+            stats = dict(self.stats)
+        if stats.get("start_time"):
+            stats["uptime_seconds"] = time.time() - stats["start_time"]
+        return stats
+
+    def get_health_status(self) -> Dict[str, Any]:
+        health = {
+            "status": "healthy",
+            "is_running": self._is_running,
+            "errors": self.stats["errors"],
+            "summaries_published": self.stats["summaries_published"],
+            "messages_ingested": self.stats["messages_ingested"],
+        }
+        if (
+            self.stats.get("last_error_time")
+            and (time.time() - self.stats["last_error_time"]) < 60
+        ):
+            health["status"] = "degraded"
+            health["reason"] = f"Recent error: {self.stats.get('last_error')}"
+        if not self._is_running:
+            health["status"] = "unhealthy"
+            health["reason"] = "Summarizer is not running"
+        return health
+
+    def cleanup(self) -> None:
+        try:
+            self.stop()
+        except Exception:
+            pass
+        with self._lock:
+            self._ingest_queue = []
+            self._buffers = {}
+        try:
+            if hasattr(self, "kafka_producer") and self.kafka_producer is not None:
+                self.kafka_producer.flush(5)
+        except Exception as exc:
+            logging.error(f"Error flushing analytics kafka producer: {exc}")
+        logging.info("Analytics summarizer cleanup completed")
+
+

matrice/deploy/aggregator/pipeline.py

@@ -7,6 +7,7 @@ from matrice.deploy.aggregator.ingestor import ResultsIngestor
 from matrice.deploy.aggregator.synchronizer import ResultsSynchronizer
 from matrice.deploy.aggregator.aggregator import ResultsAggregator
 from matrice.deploy.aggregator.publisher import ResultsPublisher
+from matrice.deploy.aggregator.analytics import AnalyticsSummarizer
 from matrice.deployment.inference_pipeline import InferencePipeline
 
 
@@ -71,6 +72,7 @@ class ResultsAggregationPipeline:
         self.results_synchronizer = None
         self.results_aggregator = None
         self.results_publisher = None
+        self.analytics_summarizer = None
 
         # Initialize the final results queue
         self.final_results_queue = Queue()
@@ -178,12 +180,22 @@ class ResultsAggregationPipeline:
             )
             self.stats["component_status"]["aggregator"] = "initialized"
             
+            # Initialize analytics summarizer (5-minute window)
+            # logging.info("Initializing analytics summarizer...")
+            # self.analytics_summarizer = AnalyticsSummarizer(
+            #     session=self.session,
+            #     inference_pipeline_id=self.inference_pipeline_id,
+            #     flush_interval_seconds=300,
+            # )
+            # self.stats["component_status"]["analytics_summarizer"] = "initialized"
+
             # Initialize the results publisher
             logging.info("Initializing results publisher...")
             self.results_publisher = ResultsPublisher(
                 inference_pipeline_id=self.inference_pipeline_id,
                 session=self.session,
-                final_results_queue=self.results_aggregator.aggregated_results_queue
+                final_results_queue=self.results_aggregator.aggregated_results_queue,
+                analytics_summarizer=self.analytics_summarizer,
             )
             self.stats["component_status"]["publisher"] = "initialized"
             
@@ -238,6 +250,13 @@ class ResultsAggregationPipeline:
                 return False
             self.stats["component_status"]["aggregator"] = "running"
             
+            # Start analytics summarizer
+            logging.info("Starting analytics summarizer...")
+            # if not self.analytics_summarizer.start(): # TODO: Uncomment this when analytics summarizer is ready
+            #     self._record_error("Failed to start analytics summarizer")
+            #     return False
+            self.stats["component_status"]["analytics_summarizer"] = "running"
+
             # Start results publishing
             logging.info("Starting results publishing...")
             if not self.results_publisher.start_streaming():
@@ -387,6 +406,12 @@ class ResultsAggregationPipeline:
                 if agg_stats.get("errors", 0) > 0:
                     logging.warning(f"      └─ Aggregator Errors: {agg_stats['errors']} (last: {agg_stats.get('last_error', 'N/A')})")
             
+            if "analytics_summarizer" in components:
+                sum_stats = components["analytics_summarizer"]
+                logging.info(f"   🧮 Summaries Published: {sum_stats.get('summaries_published', 0)}")
+                if sum_stats.get("errors", 0) > 0:
+                    logging.warning(f"      └─ Summarizer Errors: {sum_stats['errors']} (last: {sum_stats.get('last_error', 'N/A')})")
+            
             if "results_publisher" in components:
                 pub_stats = components["results_publisher"]
                 logging.info(f"   📤 Messages Published: {pub_stats.get('messages_produced', 0)}")
@@ -440,6 +465,14 @@ class ResultsAggregationPipeline:
             except Exception as exc:
                 logging.error(f"Error stopping results publisher: {exc}")
 
+        if self.analytics_summarizer:
+            try:
+                logging.info("Stopping analytics summarizer...")
+                self.analytics_summarizer.stop()
+                self.stats["component_status"]["analytics_summarizer"] = "stopped"
+            except Exception as exc:
+                logging.error(f"Error stopping analytics summarizer: {exc}")
+
         if self.results_aggregator:
             try:
                 logging.info("Stopping results aggregator...")
@@ -484,6 +517,9 @@ class ResultsAggregationPipeline:
         if self.results_aggregator:
             stats["components"]["results_aggregator"] = self.results_aggregator.get_stats()
         
+        if self.analytics_summarizer:
+            stats["components"]["analytics_summarizer"] = self.analytics_summarizer.get_stats()
+        
         if self.results_publisher:
             stats["components"]["results_publisher"] = self.results_publisher.get_stats()
         
@@ -598,6 +634,21 @@ class ResultsAggregationPipeline:
                 health["issues"].append("Results aggregator not initialized")
                 logging.error("Results aggregator not initialized")
             
+            if self.analytics_summarizer:
+                sum_health = self.analytics_summarizer.get_health_status()
+                health["components"]["analytics_summarizer"] = sum_health
+                if sum_health.get("status") != "healthy":
+                    issue_detail = f"Analytics summarizer is {sum_health.get('status', 'unknown')}"
+                    if "reason" in sum_health:
+                        issue_detail += f": {sum_health['reason']}"
+                    if sum_health.get("errors", 0) > 0:
+                        issue_detail += f" ({sum_health['errors']} errors)"
+                    health["issues"].append(issue_detail)
+                    logging.warning(f"Summarizer health issue: {issue_detail}")
+            else:
+                health["issues"].append("Analytics summarizer not initialized")
+                logging.error("Analytics summarizer not initialized")
+            
             if self.results_publisher:
                 pub_health = self.results_publisher.get_health_status()
                 health["components"]["results_publisher"] = pub_health
@@ -738,6 +789,12 @@ class ResultsAggregationPipeline:
                 self.results_aggregator.cleanup()
             except Exception as exc:
                 logging.error(f"Error cleaning up aggregator: {exc}")
+
+        if self.analytics_summarizer:
+            try:
+                self.analytics_summarizer.cleanup()
+            except Exception as exc:
+                logging.error(f"Error cleaning up analytics summarizer: {exc}")
         
         if self.results_synchronizer:
             try:

matrice/deploy/aggregator/publisher.py

@@ -15,7 +15,7 @@ class ResultsPublisher:
     """
 
     def __init__(
-        self, inference_pipeline_id: str, session: Session, final_results_queue: Queue
+        self, inference_pipeline_id: str, session: Session, final_results_queue: Queue, analytics_summarizer: Optional[Any] = None
     ):
         """
         Initialize the final results streamer.
@@ -31,6 +31,8 @@ class ResultsPublisher:
         self.kafka_handler = MatriceKafkaDeployment(
             session, inference_pipeline_id, type="server"
         )
+        # Optional analytics summarizer hook
+        self.analytics_summarizer = analytics_summarizer
         
         # Threading and state management
         self._stop_streaming = threading.Event()
@@ -109,6 +111,12 @@ class ResultsPublisher:
                     camera_info = aggregated_result.get('camera_info', {})
                     stream_key = camera_info.get('camera_name', 'unknown')
                     logging.debug(f"Successfully published camera_results for stream: {stream_key}")
+                    # Forward to analytics summarizer after successful publish
+                    try:
+                        if self.analytics_summarizer is not None and hasattr(self.analytics_summarizer, 'ingest_result'):
+                            self.analytics_summarizer.ingest_result(aggregated_result)
+                    except Exception as exc_inner:
+                        logging.warning(f"Failed to forward to analytics summarizer: {exc_inner}")
                 except Exception as exc:
                     self.stats["kafka_errors"] += 1
                     self._record_error(f"Failed to produce aggregated result to Kafka: {str(exc)}")

matrice/deploy/client/streaming_gateway/streaming_gateway_utils.py

@@ -319,7 +319,7 @@ class OutputConfig:
 class _RealTimeJsonEventPicker:
     """Stateful helper that replicates the original logic but works one frame at a time."""
 
-    def __init__(self, consecutive_threshold: int = 7, end_threshold: int = 120):
+    def __init__(self, consecutive_threshold: int = 7, end_threshold: int = 130):
         # Required sequence of severities
         self._base_sequence: List[str] = ["low", "medium", "significant", "critical", "low"]
         self._sequence: deque[str] = deque(self._base_sequence)

matrice/deploy/server/stream_worker.py

@@ -52,8 +52,15 @@ class StreamWorker:
         if consumer_group_suffix:
             consumer_group_id += f"-{consumer_group_suffix}"
 
-        custom_request_service_id = self.inference_pipeline_id if (self.inference_pipeline_id and self.inference_pipeline_id != "000000000000000000000000") else deployment_id 
-        
+        custom_request_service_id = (
+            self.inference_pipeline_id
+            if (
+                self.inference_pipeline_id
+                and self.inference_pipeline_id != "000000000000000000000000"
+            )
+            else deployment_id
+        )
+
         self.kafka_deployment = MatriceKafkaDeployment(
             session,
             deployment_id,
@@ -231,7 +238,7 @@ class StreamWorker:
                     "original_fps": input_stream.get("original_fps",31),
                 }
             }
-            
+
             model_result, post_processing_result = await self.inference_interface.inference(
                 input_content,
                 apply_post_processing=True,
@@ -240,7 +247,7 @@ class StreamWorker:
                 camera_info=camera_info,
                 input_hash=input_hash
             )
-            
+
             # Extract agg_summary from post-processing result
             agg_summary = {}
             if post_processing_result and isinstance(post_processing_result, dict):
@@ -255,7 +262,7 @@ class StreamWorker:
                     "stream_time": self._get_high_precision_timestamp(),
                 },
             }
-            
+
             app_result = {
                 "application_name": self.app_name,
                 "application_key_name": self.app_name.replace(" ", "_").replace("-", "_"), 

matrice/deploy/utils/post_processing/usecases/fire_detection.py

@@ -313,6 +313,8 @@ class FireSmokeUseCase(BaseProcessor):
             # Safely fetch the last recorded severity level as a **string** (empty if no history yet)
             last_level = self._ascending_alert_list[-1] if self._ascending_alert_list else "low"
             alert_id = self._get_alert_incident_ids(last_level)
+            if alert_id not in [1,2,3,4,5]:
+                alert_id = 4
 
             count_thresholds = {}
             if config.alert_config and hasattr(config.alert_config, "count_thresholds"):
@@ -443,6 +445,7 @@ class FireSmokeUseCase(BaseProcessor):
                             elif intensity_pct >= 13:
                                 level = "significant"
                                 self._ascending_alert_list.append(level)
+                                self.current_incident_end_timestamp='Incident still active'
                             elif intensity_pct >= 3:
                                 level = "medium"
                                 self._ascending_alert_list.append(level)
@@ -457,6 +460,7 @@ class FireSmokeUseCase(BaseProcessor):
                             elif intensity_pct > 12:
                                 level = "significant"
                                 intensity = 9.0
+                                self.current_incident_end_timestamp='Incident still active'
                                 self._ascending_alert_list.append(level)
                             elif intensity_pct > 2:
                                 level = "medium"
@@ -475,6 +479,8 @@ class FireSmokeUseCase(BaseProcessor):
                     # Pass the last severity level **value** instead of a single-element list
                     last_level = level if level else self._ascending_alert_list[-1]
                     incident_id = self._get_alert_incident_ids(last_level)
+                    if incident_id not in [1,2,3,4,5]:
+                        incident_id = 4
 
                     alert_settings=[]
                     if config.alert_config and hasattr(config.alert_config, 'alert_type'):
@@ -632,16 +638,17 @@ class FireSmokeUseCase(BaseProcessor):
             last_ending_id = self._get_alert_incident_ids("")
             print('last_ending_id',last_ending_id)
             if last_ending_id==5:
-                tracking_stats.append({
+                alerts={
                             "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
-                            "alert_id": "alert_"+category+'_'+str(last_ending_id),
+                            "alert_id": "alert_"+'Event_Ended'+'_'+str(last_ending_id),
                             "incident_category": self.CASE_TYPE,
                             "threshold_level": 0,
                             "ascending": False,
                             "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'])
                                     }       
-                        })
+                        }
+                tracking_stats.append(alerts)
                 tracking_stats.append(self.create_incident(incident_id=self.CASE_TYPE+'_'+str(last_ending_id), incident_type=self.CASE_TYPE,
                             severity_level='info', human_text='Event Over', camera_info=camera_info, alerts=alerts, alert_settings=alert_settings,
                             start_time=start_timestamp, end_time='Incident still active',
@@ -1016,7 +1023,7 @@ class FireSmokeUseCase(BaseProcessor):
         else:
             if len(self.id_hit_list)==1:
                 self.id_hit_counter+=1
-                if self.id_hit_counter>120:
+                if self.id_hit_counter>130:
                     self.id_hit_list = ["low","medium","significant","critical","low"]
                     self.id_hit_counter = 0
                     self.latest_stack = None

{matrice-1.0.99273.dist-info → matrice-1.0.99275.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice
-Version: 1.0.99273
+Version: 1.0.99275
 Summary: SDK for connecting to matrice.ai services
 Home-page: https://github.com/matrice-ai/python-sdk
 Author: Matrice.ai

{matrice-1.0.99273.dist-info → matrice-1.0.99275.dist-info}/RECORD

@@ -94,9 +94,10 @@ matrice/data_processing/data_formats/yolo_detection.py,sha256=qUeZA7_8Of_QWGZlHh
 matrice/deploy/__init__.py,sha256=1IEknWS1AxZL4aGzCyASusGH_vMEPk1L6u8RnnZjI9w,1256
 matrice/deploy/aggregator/__init__.py,sha256=HFz-ufUMeSpSyRINcrx6NdmrcuVZtPfyIXxYu5UNLTc,508
 matrice/deploy/aggregator/aggregator.py,sha256=ob-I9ZaGmhXqdzbIHZL8DDtYCaT944ipmlhFzIz6peQ,11450
+matrice/deploy/aggregator/analytics.py,sha256=kNfME7CEySJNOhsVH25DXKryj8bTdKnkroordJVauQM,16764
 matrice/deploy/aggregator/ingestor.py,sha256=-ySEg1UD2ahPXw7Ifr_4QC5xRGb6co8jGD6PgtvCK3w,17141
-matrice/deploy/aggregator/pipeline.py,sha256=xOKDqb4Qre5Ek3Fr-03C-jxpZNXdQ2_Dk5EaOn4ssYE,33948
-matrice/deploy/aggregator/publisher.py,sha256=SRPnyindD_R_QNK5MJ_WZAeAaGtj79CZ1VNoltsQtXM,15587
+matrice/deploy/aggregator/pipeline.py,sha256=nqHoc-lGIpiJ4UWq6KfRqykE4QNfu-XxNUPvlmnVDIs,37049
+matrice/deploy/aggregator/publisher.py,sha256=XeZG5XcnSn0Z----yH4vFKd_gohTd4g8Kx9TYwAaPOA,16196
 matrice/deploy/aggregator/synchronizer.py,sha256=nSoFxlt4Ol6zbg4yCHufcNsif_Spq3jjKTvB5WY73Gk,20455
 matrice/deploy/client/__init__.py,sha256=d7yxlWNHYKOoAM9T_AlrSQw1_9cfLEop4zBE0QqrTVw,1330
 matrice/deploy/client/client.py,sha256=5itmvupufK48lPNb2__ZbZ9q3Q5ycfCDTW6ClDC7cM4,28531
@@ -108,11 +109,11 @@ matrice/deploy/client/auto_streaming/auto_streaming.py,sha256=VRfy_EBFvhspN-hoN3
 matrice/deploy/client/auto_streaming/auto_streaming_utils.py,sha256=BuRUokLp3t43yzRF8YSX9p_RHQD94RoBwNEoldXFDQo,14995
 matrice/deploy/client/streaming_gateway/__init__.py,sha256=hkYC0qszaXZThquMuuI20Qkt_AHCB3pdy7jlJVeqPN4,1203
 matrice/deploy/client/streaming_gateway/streaming_gateway.py,sha256=r8Z5AXBom89n-8W5RTlB-nOeUaprxK-QBDsAb-E9gl8,19605
-matrice/deploy/client/streaming_gateway/streaming_gateway_utils.py,sha256=znNZkzG9W7VeZPKUxzgxHiW1GqvD-oA-McZSnMiBm1E,42144
+matrice/deploy/client/streaming_gateway/streaming_gateway_utils.py,sha256=_fJl0ry2O8UkEwHpufNdJ68EAkWAAN7moGbBLJtPQeE,42144
 matrice/deploy/client/streaming_gateway/streaming_results_handler.py,sha256=OpHkdbnuqVN28tQm9CYwrfgAth3Qz40Uaq5Tg4bbxyo,15813
 matrice/deploy/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 matrice/deploy/server/server.py,sha256=duki4KUU1tvW3Y7wkrlMRVvt7bAP2QqSIsrSogLxC4o,36799
-matrice/deploy/server/stream_worker.py,sha256=KDNlYep4Bg1xhHwDrwY9kfxsJfFtATydiYbzVDt58vs,20481
+matrice/deploy/server/stream_worker.py,sha256=reRkWGBl7a1f7EduZs25Uzecs6mc5wr2adNhlXxSgK0,20530
 matrice/deploy/server/inference/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 matrice/deploy/server/inference/batch_manager.py,sha256=7fCHJfSeBqfYgKGZH9_sgUDAllymkGkFm0Oin_-SAYI,8322
 matrice/deploy/server/inference/cache_manager.py,sha256=ebQ1Y3vGNW3--TCPnWijDK3ix5HuZ_zH7wjs8iHKkbU,1610
@@ -182,7 +183,7 @@ matrice/deploy/utils/post_processing/usecases/face_emotion.py,sha256=eRfqBdryB0u
 matrice/deploy/utils/post_processing/usecases/face_recognition.py,sha256=T5xAuv6b9OrkmTmoXgZs4LZ5XUsbvp9xCpeLBwdu7eI,40231
 matrice/deploy/utils/post_processing/usecases/fashion_detection.py,sha256=f9gpzMDhIW-gyn46k9jgf8nY7YeoqAnTxGOzksabFbE,40457
 matrice/deploy/utils/post_processing/usecases/field_mapping.py,sha256=JDwYX8pd2W-waDvBh98Y_o_uchJu7wEYbFxOliA4Iq4,39822
-matrice/deploy/utils/post_processing/usecases/fire_detection.py,sha256=iGsTciE54AnuGf8tDmgIIAXpuCyFTcU_qOTRPsxo2gA,48549
+matrice/deploy/utils/post_processing/usecases/fire_detection.py,sha256=8GMabLpVFWCSHULdjO8V_fCPqz9hf9pyAu2n-vuLg7A,48936
 matrice/deploy/utils/post_processing/usecases/flare_analysis.py,sha256=-egmS3Hs_iGOLeCMfapbkfQ04EWtZx97QRuUcDa-jMU,45340
 matrice/deploy/utils/post_processing/usecases/flower_segmentation.py,sha256=4I7qMx9Ztxg_hy9KTVX-3qBhAN-QwDt_Yigf9fFjLus,52017
 matrice/deploy/utils/post_processing/usecases/gas_leak_detection.py,sha256=KL2ft7fXvjTas-65-QgcJm3W8KBsrwF44qibSXjfaLc,40557
@@ -243,8 +244,8 @@ matrice/deployment/camera_manager.py,sha256=e1Lc81RJP5wUWRdTgHO6tMWF9BkBdHOSVyx3
 matrice/deployment/deployment.py,sha256=HFt151eWq6iqIAMsQvurpV2WNxW6Cx_gIUVfnVy5SWE,48093
 matrice/deployment/inference_pipeline.py,sha256=6b4Mm3-qt-Zy0BeiJfFQdImOn3FzdNCY-7ET7Rp8PMk,37911
 matrice/deployment/streaming_gateway_manager.py,sha256=ifYGl3g25wyU39HwhPQyI2OgF3M6oIqKMWt8RXtMxY8,21401
-matrice-1.0.99273.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-matrice-1.0.99273.dist-info/METADATA,sha256=Zu1ooyc7gmPiF9mrhwDdcRn2wewobwm1aXdxTN9ZKnk,14624
-matrice-1.0.99273.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice-1.0.99273.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
-matrice-1.0.99273.dist-info/RECORD,,
+matrice-1.0.99275.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+matrice-1.0.99275.dist-info/METADATA,sha256=F8K1g936l74lHwzQ9iLCeOwcTHnSzcFxchP3cbU6qbI,14624
+matrice-1.0.99275.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice-1.0.99275.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
+matrice-1.0.99275.dist-info/RECORD,,