matrice 1.0.99241__tar.gz → 1.0.99243__tar.gz

{matrice-1.0.99241/src/matrice.egg-info → matrice-1.0.99243}/PKG-INFO

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

{matrice-1.0.99241 → matrice-1.0.99243}/setup.py

@@ -14,7 +14,7 @@ long_description = (here / "README.md").read_text(encoding="utf-8")
 setup(
     name="matrice",
 
-    version = "1.0.99241",
+    version = "1.0.99243",
     
     description="SDK for connecting to matrice.ai services",
     long_description=long_description,

{matrice-1.0.99241 → matrice-1.0.99243}/src/matrice/deploy/aggregator/aggregator.py

@@ -257,7 +257,7 @@ class ResultsAggregator:
 
         # Check if output queue is getting full
         queue_size = self.aggregated_results_queue.qsize()
-        if queue_size > 0:
+        if queue_size > 1000:
             health["status"] = "degraded"
             health["reason"] = f"Output queue too large ({queue_size} items)"
             logging.warning(f"Aggregator degraded: output queue has {queue_size} items (threshold: 100)")

{matrice-1.0.99241 → matrice-1.0.99243}/src/matrice/deploy/aggregator/ingestor.py

@@ -2,7 +2,7 @@ import logging
 import time
 import threading
 from typing import Dict, Optional, List, Tuple
-from queue import Empty, PriorityQueue
+from queue import Empty, PriorityQueue, Full
 from matrice.session import Session
 from matrice.deploy.utils.kafka_utils import MatriceKafkaDeployment
 import itertools
@@ -198,7 +198,7 @@ class ResultsIngestor:
                     input_streams = result_value.get("input_streams", [])
                     input_stream = input_streams[0]["input_stream"] if input_streams else {}
                     # input_order = input_stream.get("input_order")
-                    camera_info = input_stream.get("camera_info")
+                    camera_info = input_stream.get("camera_info") or {}
                     stream_key = camera_info.get("camera_name")
                     stream_group_key = camera_info.get("camera_group") or "default_group"
 
@@ -229,15 +229,24 @@ class ResultsIngestor:
                                 deployment_id
                             ] = results_queue.qsize()
 
-                    except Exception as exc:
+                    except Full:
                         # Queue is full, log warning and continue
                         logging.warning(
-                            f"Result queue full for deployment {deployment_id}, dropping result: {exc}"
+                            f"Result queue full for deployment {deployment_id}, dropping result"
                         )
                         with self._lock:
                             self.stats["errors"] += 1
                             self.stats["last_error"] = "Queue full"
                             self.stats["last_error_time"] = time.time()
+                    except Exception as exc:
+                        # Other enqueue errors
+                        logging.error(
+                            f"Failed to enqueue result for deployment {deployment_id}: {exc}"
+                        )
+                        with self._lock:
+                            self.stats["errors"] += 1
+                            self.stats["last_error"] = str(exc)
+                            self.stats["last_error_time"] = time.time()
 
             except Exception as exc:
                 if not self._stop_streaming.is_set():

{matrice-1.0.99241 → matrice-1.0.99243}/src/matrice/deploy/aggregator/synchronizer.py

@@ -36,12 +36,12 @@ class ResultsSynchronizer:
         self._synchronization_thread = None
 
         # Synchronization state
-        # Structure: {(stream_key, session_id, input_order): {deployment_id: result, ...}}
-        self._pending_results: Dict[Tuple[str, int, int], Dict[str, Dict]] = defaultdict(
+        # Structure: {(stream_group_key, stream_key, input_order): {deployment_id: result, ...}}
+        self._pending_results: Dict[Tuple[str, str, int], Dict[str, Dict]] = defaultdict(
             dict
         )
         # Track when each key combination was first seen
-        self._result_timestamps: Dict[Tuple[str, int, int], float] = {}
+        self._result_timestamps: Dict[Tuple[str, str, int], float] = {}
 
         # Statistics
         self.stats = {
@@ -113,7 +113,7 @@ class ResultsSynchronizer:
 
     def _create_synchronized_result(
         self,
-        key: Tuple[str, int, int],
+        key: Tuple[str, str, int],
         deployment_results: Dict[str, Dict],
         is_complete: bool,
         is_timeout: bool,
@@ -204,11 +204,17 @@ class ResultsSynchronizer:
                     # Update statistics
                     if is_complete:
                         self.stats["complete_syncs"] += 1
-                        logging.debug(f"Complete sync for stream {key[0]}, session {key[1]}, order {key[2]} with {len(deployment_results)} deployments")
+                        stream_group_key, stream_key, input_order = key
+                        logging.debug(
+                            f"Complete sync for group {stream_group_key}, stream {stream_key}, "
+                            f"order {input_order} with {len(deployment_results)} deployments"
+                        )
                     else:
                         self.stats["partial_syncs"] += 1
+                        stream_group_key, stream_key, input_order = key
                         logging.warning(
-                            f"Partial sync for stream {key[0]}, session {key[1]}, order {key[2]}: {len(deployment_results)}/{len(self.deployment_ids)} deployments "
+                            f"Partial sync for group {stream_group_key}, stream {stream_key}, "
+                            f"order {input_order}: {len(deployment_results)}/{len(self.deployment_ids)} deployments "
                             f"(timeout after {result_age:.2f}s)"
                         )
 
@@ -230,8 +236,9 @@ class ResultsSynchronizer:
                 self.stats["results_synchronized"] += 1
 
             logging.debug(
-                f"Sent synchronized result for stream {synchronized_result['stream_key']}, "
-                f"session {synchronized_result['session_id']}, order {synchronized_result['input_order']}"
+                f"Sent synchronized result for group {synchronized_result.get('stream_group_key')}, "
+                f"stream {synchronized_result['stream_key']}, "
+                f"order {synchronized_result['input_order']}"
             )
 
         except Exception as exc:

{matrice-1.0.99241 → matrice-1.0.99243}/src/matrice/deploy/utils/post_processing/usecases/intrusion_detection.py

@@ -422,13 +422,10 @@ class IntrusionUseCase(BaseProcessor):
                         self._ascending_alert_list.append(0)
 
                     human_text_lines.append(f"\t\t- Zone name: {zone_name}")
-                    if zone_name == "Boarding Entrance":
-                        human_text_lines.append(f"\t\t\t- Total count in Prohibited Boarding Gate: {zone_total}")
-                    elif zone_name == "Boarding Booth":
-                        human_text_lines.append(f"\t\t\t- Total count in Prohibited Boarding Booth: {zone_total}")
+                    human_text_lines.append(f"\t\t\t- Total count in Prohibited Boarding Gate: {zone_total}")
                     # Main people counting incident
                     human_text = "\n".join(human_text_lines)
-                    event= self.create_incident(incident_id=self.CASE_TYPE+'_'+'zone_'+zone_name+str(frame_id), incident_type=self.CASE_TYPE,
+                    event = self.create_incident(incident_id=self.CASE_TYPE+'_'+'zone_'+zone_name+str(frame_id), incident_type=self.CASE_TYPE,
                             severity_level=zone_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})
@@ -557,17 +554,14 @@ class IntrusionUseCase(BaseProcessor):
                     return zone_count
                 else:
                     return 0
-            human_text_lines.append(f"\t- Total count in Prohibited Boarding Area: {total_people}")
+            human_text_lines.append(f"\t- Total count in Prohibited Boarding Gate: {total_people}")
             human_text_lines.append("")
             human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}:")
                 
             for zone_name, zone_count in zone_analysis.items():
                 zone_total = robust_zone_total(zone_count)
                 human_text_lines.append(f"\t- Zone name: {zone_name}")
-                if zone_name == "Boarding Entrance":
-                    human_text_lines.append(f"\t\t\t- Total count in Prohibited Boarding Gate: {zone_total}")
-                elif zone_name == "Boarding Booth":
-                    human_text_lines.append(f"\t\t\t- Total count in Prohibited Boarding Booth: {zone_total}")
+                human_text_lines.append(f"\t\t\t- Total count in Prohibited Boarding Gate: {zone_total}")
                         # human_text_lines.append(f"\t\t- Total count in Prohibited Boarding Gate: {zone_total-1}")
 
                 

{matrice-1.0.99241 → matrice-1.0.99243/src/matrice.egg-info}/PKG-INFO

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