matrice 1.0.99128__py3-none-any.whl → 1.0.99130__py3-none-any.whl

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

@@ -31,7 +31,7 @@ class ConcreteCrackConfig(BaseConfig):
     smoothing_confidence_range_factor: float = 0.5
 
     #confidence thresholds
-    confidence_threshold: float = 0.1
+    confidence_threshold: float = 0.6
 
     usecase_categories: List[str] = field(
         default_factory=lambda: ['Cracks']
@@ -45,159 +45,26 @@ class ConcreteCrackConfig(BaseConfig):
 
     index_to_category: Optional[Dict[int, str]] = field(
         default_factory=lambda: {
-            0: "Cracks"
+            0: "Cracks",
         }
     )
 
 
 class ConcreteCrackUseCase(BaseProcessor):
-    def _get_track_ids_info(self, detections: list) -> Dict[str, Any]:
-        """
-        Get detailed information about track IDs (per frame).
-        """
-        # Collect all track_ids in this frame
-        frame_track_ids = set()
-        for det in detections:
-            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():
-            total_track_ids.update(s)
-        return {
-            "total_count": len(total_track_ids),
-            "current_frame_count": len(frame_track_ids),
-            "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)
-        }
-
-
-
-
-
-    def _update_tracking_state(self, detections: list):
-        """
-        Track unique categories track_ids per category for total count after tracking.
-        Applies canonical ID merging to avoid duplicate counting when the underlying
-        tracker loses an object temporarily and assigns a new ID.
-        """
-        # 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._current_frame_track_ids = {cat: set() for cat in self.target_categories}
-
-        for det in detections:
-            cat = det.get("category")
-            raw_track_id = det.get("track_id")
-            if cat not in self.target_categories or raw_track_id is None:
-                continue
-            bbox = det.get("bounding_box", det.get("bbox"))
-            canonical_id = self._merge_or_register_track(raw_track_id, bbox)
-            # Propagate canonical ID back to detection so downstream logic uses it
-            det["track_id"] = canonical_id
-
-            self._per_category_total_track_ids.setdefault(cat, set()).add(canonical_id)
-            self._current_frame_track_ids[cat].add(canonical_id)
-
-    def get_total_counts(self):
-        """
-        Return total unique track_id count for each category.
-        """
-        return {cat: len(ids) for cat, ids in getattr(self, '_per_category_total_track_ids', {}).items()}
-
-    def _format_timestamp_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 = timestamp % 60
-        return f"{hours:02d}:{minutes:02d}:{seconds:06.2f}"
-
-    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')
-
-    def _get_current_timestamp_str(self, stream_info: Optional[Dict[str, Any]]) -> str:
-        """Get formatted current timestamp based on stream type."""
-        if not stream_info:
-            return "00:00:00.00"
-
-        is_video_chunk = stream_info.get("input_settings", {}).get("is_video_chunk", False)
-
-        # if is_video_chunk:
-        #     # For video chunks, use video_timestamp from stream_info
-        #     video_timestamp = stream_info.get("video_timestamp", 0.0)
-        #     return self._format_timestamp_for_video(video_timestamp)
-        if stream_info.get("input_settings", {}).get("stream_type", "video_file") == "video_file":
-            # If video format, return video timestamp
-            stream_time_str = stream_info.get("video_timestamp", "")
-            return stream_time_str[:8]
-        else:
-            # For streams, use stream_time from stream_info
-            stream_time_str = stream_info.get("stream_time", "")
-            if stream_time_str:
-                # Parse the high precision timestamp string to get timestamp
-                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")
-                    timestamp = dt.replace(tzinfo=timezone.utc).timestamp()
-                    return self._format_timestamp_for_stream(timestamp)
-                except:
-                    # Fallback to current time if parsing fails
-                    return self._format_timestamp_for_stream(time.time())
-            else:
-                return self._format_timestamp_for_stream(time.time())
-
-    def _get_start_timestamp_str(self, stream_info: Optional[Dict[str, Any]]) -> str:
-        """Get formatted start timestamp for 'TOTAL SINCE' based on stream type."""
-        if not stream_info:
-            return "00:00:00"
-
-        is_video_chunk = stream_info.get("input_settings", {}).get("is_video_chunk", False)
-
-        if is_video_chunk:
-            # For video chunks, start from 00:00:00
-            return "00:00:00"
-        elif stream_info.get("input_settings", {}).get("stream_type", "video_file") == "video_file":
-            # If video format, start from 00:00:00
-            return "00:00:00"
-        else:
-            # 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("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()
-                    except:
-                        # Fallback to current time if parsing fails
-                        self._tracking_start_time = time.time()
-                else:
-                    self._tracking_start_time = time.time()
-
-            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')
-
-    """ Monitoring use case with smoothing and alerting."""
-
+    # Human-friendly display names for categories
+    CATEGORY_DISPLAY = {
+        "Cracks": "Cracks",
+    }
     def __init__(self):
         super().__init__("concrete_crack_detection")
         self.category = "general"
 
+        self.CASE_TYPE: Optional[str] = 'concrete_crack_detection'
+        self.CASE_VERSION: Optional[str] = '1.3'
+
         # List of  categories to track
         self.target_categories = ["Cracks"]
 
-
-
         # Initialize smoothing tracker
         self.smoothing_tracker = None
 
@@ -211,19 +78,15 @@ class ConcreteCrackUseCase(BaseProcessor):
         # Track start time for "TOTAL SINCE" calculation
         self._tracking_start_time = None
 
-        # ------------------------------------------------------------------ #
-        # Canonical tracking aliasing to avoid duplicate counts              #
-        # ------------------------------------------------------------------ #
-        # Maps raw tracker-generated IDs to stable canonical IDs that persist
-        # even if the underlying tracker re-assigns a new ID after a short
-        # interruption. This mirrors the logic used in people_counting to
-        # provide accurate unique counting.
         self._track_aliases: Dict[Any, Any] = {}
         self._canonical_tracks: Dict[Any, Dict[str, Any]] = {}
         # Tunable parameters – adjust if necessary for specific scenarios
         self._track_merge_iou_threshold: float = 0.05  # IoU ≥ 0.05 →
         self._track_merge_time_window: float = 7.0  # seconds within which to merge
 
+        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:
         """
@@ -249,6 +112,7 @@ class ConcreteCrackUseCase(BaseProcessor):
             self.logger.debug(f"Applied confidence filtering with threshold {config.confidence_threshold}")
         else:
             processed_data = data
+            
             self.logger.debug(f"Did not apply confidence filtering with threshold since nothing was provided")
 
         # Step 2: Apply category mapping if provided
@@ -274,7 +138,6 @@ class ConcreteCrackUseCase(BaseProcessor):
                 self.smoothing_tracker = BBoxSmoothingTracker(smoothing_config)
             processed_data = bbox_smoothing(processed_data, self.smoothing_tracker.config, self.smoothing_tracker)
 
-
         # Advanced tracking (BYTETracker-like)
         try:
             from ..advanced_tracker import AdvancedTracker
@@ -294,9 +157,6 @@ class ConcreteCrackUseCase(BaseProcessor):
             # If advanced tracker fails, fallback to unsmoothed detections
             self.logger.warning(f"AdvancedTracker failed: {e}")
 
-
-
-
         # Update  tracking state for total count per label
         self._update_tracking_state(processed_data)
 
@@ -314,218 +174,490 @@ class ConcreteCrackUseCase(BaseProcessor):
                 frame_number = start_frame
 
         # Compute summaries and alerts
-        general_counting_summary = calculate_counting_summary(data) #done
-        counting_summary = self._count_categories(processed_data, config) #done
+        general_counting_summary = calculate_counting_summary(data) 
+        counting_summary = self._count_categories(processed_data, config) 
         # Add total unique  counts after tracking using only local state
-        total_counts = self.get_total_counts() #done
-        counting_summary['total_counts'] = total_counts #done
-        insights = self._generate_insights(counting_summary, config)#done
-        alerts = self._check_alerts(counting_summary, config)#done
-        predictions = self._extract_predictions(processed_data)#done
-        summary = self._generate_summary(counting_summary, alerts)#done
-
-        # Step: Generate structured events and tracking stats with frame-based keys
-        events_list = self._generate_events(counting_summary, alerts, config, frame_number, stream_info)#done
-        tracking_stats_list = self._generate_tracking_stats(counting_summary, insights, summary, config, frame_number,
-                                                            stream_info)
+        total_counts = self.get_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 incidents, tracking stats and business analytics 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)
+        # business_analytics_list = self._generate_business_analytics(counting_summary, alerts, config, frame_number, stream_info, is_empty=True)
+        business_analytics_list = []
+        summary_list = self._generate_summary(counting_summary, incidents_list, tracking_stats_list, business_analytics_list, alerts)
 
         # Extract frame-based dictionaries from the lists
-        events = events_list[0] if events_list else {}
+        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 {}
+        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}
+                    }
+    
         context.mark_completed()
 
-        # Build result object
+        # Build result object following the new pattern
+
         result = self.create_result(
-            data={
-                "counting_summary": counting_summary,
-                "general_counting_summary": general_counting_summary,
-                "alerts": alerts,
-                "total_detections": counting_summary.get("total_count", 0),
-                "events": events,
-                "tracking_stats": tracking_stats,
-            },
+            data={"agg_summary": agg_summary},
             usecase=self.name,
             category=self.category,
             context=context
         )
-        result.summary = summary
-        result.insights = insights
-        result.predictions = predictions
+        
         return result
 
+    def _check_alerts(self, summary: dict, frame_number:Any, config: ConcreteCrackConfig) -> 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
+            increasing = 0
+            total = 0
+            for i in range(1, len(window)):
+                if window[i] >= window[i - 1]:
+                    increasing += 1
+                total += 1
+            ratio = increasing / total
+            if ratio >= threshold:
+                return True
+            elif ratio <= (1 - threshold):
+                return False
+
+        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
 
+        if not config.alert_config:
+            return alerts
 
-    def _generate_events(self, counting_summary: Dict, alerts: List, config: ConcreteCrackConfig,
-                         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."""
-        from datetime import datetime, timezone
+        total = summary.get("total_count", 0)
+        #self._ascending_alert_list
+        if hasattr(config.alert_config, 'count_thresholds') and config.alert_config.count_thresholds:
 
-        # 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"
-        events = [{frame_key: []}]
-        frame_events = events[0][frame_key]
-        total_detections = counting_summary.get("total_count", 0)
+            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'])
+                                }                    
+                    })
+                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'])
+                                }       
+                        })
+        else:
+            pass
+        return alerts
+
+    def _generate_incidents(self, counting_summary: Dict, alerts: List, config: ConcreteCrackConfig,
+                        frame_number: Optional[int] = None, stream_info: Optional[Dict[str, Any]] = None) -> List[
+        Dict]:
+        """Generate structured incidents for the output format with frame-based keys."""
+        
+        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
+        
         if total_detections > 0:
             # Determine event level based on thresholds
-            level = "info"
+            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: 
+                    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'
+                
             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)
 
-                if intensity >= 7:
+                if intensity >= 9:
                     level = "critical"
+                    self._ascending_alert_list.append(3)
+                elif intensity >= 7:
+                    level = "significant"
+                    self._ascending_alert_list.append(2)
                 elif intensity >= 5:
-                    level = "warning"
+                    level = "medium"
+                    self._ascending_alert_list.append(1)
                 else:
-                    level = "info"
+                    level = "low"
+                    self._ascending_alert_list.append(0)
             else:
-                if total_detections > 25:
+                if total_detections > 30:
                     level = "critical"
+                    intensity = 10.0
+                    self._ascending_alert_list.append(3)
+                elif total_detections > 25:
+                    level = "significant"
                     intensity = 9.0
+                    self._ascending_alert_list.append(2)
                 elif total_detections > 15:
-                    level = "warning"
+                    level = "medium"
                     intensity = 7.0
+                    self._ascending_alert_list.append(1)
                 else:
-                    level = "info"
+                    level = "low"
                     intensity = min(10.0, total_detections / 3.0)
+                    self._ascending_alert_list.append(0)
 
             # Generate human text in new format
-            human_text_lines = ["EVENTS DETECTED:"]
-            human_text_lines.append(f"    - {total_detections}  detected [INFO]")
+            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)
 
-            event = {
-                "type": "concrete_crack_detection",
-                "stream_time": datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S UTC"),
-                "level": level,
-                "intensity": round(intensity, 1),
-                "config": {
-                    "min_value": 0,
-                    "max_value": 10,
-                    "level_settings": {"info": 2, "warning": 5, "critical": 7}
-                },
-                "application_name": "concrete crack detection System",
-                "application_version": "1.2",
-                "location_info": None,
-                "human_text": human_text
-            }
-            frame_events.append(event)
-
-        # Add alert events
-        for alert in alerts:
-            total_detections = counting_summary.get("total_count", 0)
-            intensity_message = "ALERT: Low congestion in the scene"
-            if config.alert_config and config.alert_config.count_thresholds:
-                threshold = config.alert_config.count_thresholds.get("all", 15)
-                percentage = (total_detections / threshold) * 100 if threshold > 0 else 0
-                if percentage < 20:
-                    intensity_message = "ALERT: Low congestion in the scene"
-                elif percentage <= 50:
-                    intensity_message = "ALERT: Moderate congestion in the scene"
-                elif percentage <= 70:
-                    intensity_message = "ALERT: Heavy congestion in the scene"
-                else:
-                    intensity_message = "ALERT: Severe congestion in the scene"
-            else:
-                if total_detections > 15:
-                    intensity_message = "ALERT: Heavy congestion in the scene"
-                elif total_detections == 1:
-                    intensity_message = "ALERT: Low congestion in the scene"
-                else:
-                    intensity_message = "ALERT: Moderate congestion in the scene"
-
-            alert_event = {
-                "type": alert.get("type", "congestion_alert"),
-                "stream_time": datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S UTC"),
-                "level": alert.get("severity", "warning"),
-                "intensity": 8.0,
-                "config": {
-                    "min_value": 0,
-                    "max_value": 10,
-                    "level_settings": {"info": 2, "warning": 5, "critical": 7}
-                },
-                "application_name": "Congestion Alert System",
-                "application_version": "1.2",
-                "location_info": alert.get("zone"),
-                "human_text": f"{datetime.now(timezone.utc).strftime('%Y-%m-%d-%H:%M:%S UTC')} : {intensity_message}"
-            }
-            frame_events.append(alert_event)
+            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)
 
-        return events
+        else:
+            self._ascending_alert_list.append(0)
+            incidents.append({})
+           
+        return incidents
 
     def _generate_tracking_stats(
             self,
             counting_summary: Dict,
-            insights: List[str],
-            summary: str,
+            alerts: List,
             config: ConcreteCrackConfig,
             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."""
-        frame_key = str(frame_number) if frame_number is not None else "current_frame"
-        tracking_stats = [{frame_key: []}]
-        frame_tracking_stats = tracking_stats[0][frame_key]
+        """Generate structured tracking stats matching eg.json format."""
+        camera_info = self.get_camera_info_from_stream(stream_info)
+        
+        # frame_key = str(frame_number) if frame_number is not None else "current_frame"
+        # tracking_stats = [{frame_key: []}]
+        # frame_tracking_stats = tracking_stats[0][frame_key]
+        tracking_stats = []
+        
+        total_detections = counting_summary.get("total_count", 0) #CURRENT total count of all classes
+        total_counts_dict = counting_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 = counting_summary.get("per_category_count", {}) #CURRENT count per class
+
+        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)
+
+    
+        # Build total_counts array in expected format
+        total_counts = []
+        for cat, count in total_counts_dict.items():
+            if count > 0:
+                total_counts.append({
+                    "category": cat,
+                    "count": count
+                })
+
+        # 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
+                })
+
+        # Prepare detections without confidence scores (as per eg.json)
+        detections = []
+        for detection in counting_summary.get("detections", []):
+            bbox = detection.get("bounding_box", {})
+            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)
+            elif detection.get("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)
+            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'])
+                            }
+            })
+
+        # Generate human_text in expected format
+        human_text_lines = [f"Tracking Statistics:"]
+        human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}")
+        
+        for cat, count in per_category_count.items():
+            human_text_lines.append(f"\t{cat}: {count}")
+            
+        human_text_lines.append(f"TOTAL SINCE {start_timestamp}")
+        for cat, count in total_counts_dict.items():
+            if count > 0:
+                human_text_lines.append(f"\t{cat}: {count}")
+            
+        if alerts:
+            for alert in alerts:
+                human_text_lines.append(f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}")
+        else:
+            human_text_lines.append("Alerts: None")
 
-        total_detections = counting_summary.get("total_count", 0)
-        total_counts = counting_summary.get("total_counts", {})
-        cumulative_total = sum(total_counts.values()) if total_counts else 0
-        per_category_count = counting_summary.get("per_category_count", {})
+        human_text = "\n".join(human_text_lines)
+        reset_settings=[
+                {
+                    "interval_type": "daily",
+                    "reset_time": {
+                        "value": 9,
+                        "time_unit": "hour"
+                    }
+                }
+            ]
 
-        track_ids_info = self._get_track_ids_info(counting_summary.get("detections", []))
+        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)
 
-        current_timestamp = self._get_current_timestamp_str(stream_info)
-        start_timestamp = self._get_start_timestamp_str(stream_info)
+        tracking_stats.append(tracking_stat)
+        return tracking_stats
 
-        human_text_lines = []
+    def _generate_business_analytics(self, counting_summary: Dict, zone_analysis: Dict, config: ConcreteCrackConfig, 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 []
 
-        # 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()]
-            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"
-            else:
-                detection_text = f"{', '.join(category_counts[:-1])}, and {category_counts[-1]} detected"
-            human_text_lines.append(f"\t- {detection_text}")
-        else:
-            human_text_lines.append(f"\t- No detections")
+        #-----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
 
-        human_text_lines.append("")  # spacing
+    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.
+        """
+        lines = {}
+        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"
+        if len(tracking_stats) > 0:
+            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"
 
-        # TOTAL SINCE section
-        human_text_lines.append(f"TOTAL SINCE {start_timestamp}:")
-        human_text_lines.append(f"\t- Total  Detected: {cumulative_total}")
-        # Add category-wise counts
-        if total_counts:
-            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}")
+        if len(incidents) == 0 and len(tracking_stats) == 0 and len(business_analytics) == 0:
+            lines["Summary"] = "No Summary Data"
 
-        human_text = "\n".join(human_text_lines)
+        return [lines]
 
-        tracking_stat = {
-            "type": "concrete_crack_detection",
-            "category": "general",
-            "count": total_detections,
-            "insights": insights,
-            "summary": summary,
-            "timestamp": datetime.now(timezone.utc).strftime('%Y-%m-%d-%H:%M:%S UTC'),
-            "human_text": human_text,
-            "track_ids_info": track_ids_info,
-            "global_frame_offset": getattr(self, '_global_frame_offset', 0),
-            "local_frame_id": frame_key,
-            "detections": counting_summary.get("detections", [])  # Added line to include detections
+    def _get_track_ids_info(self, detections: list) -> Dict[str, Any]:
+        """
+        Get detailed information about track IDs (per frame).
+        """
+        # Collect all track_ids in this frame
+        frame_track_ids = set()
+        for det in detections:
+            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():
+            total_track_ids.update(s)
+        return {
+            "total_count": len(total_track_ids),
+            "current_frame_count": len(frame_track_ids),
+            "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)
         }
 
-        frame_tracking_stats.append(tracking_stat)
-        return tracking_stats
+    def _update_tracking_state(self, detections: list):
+        """
+        Track unique categories track_ids per category for total count after tracking.
+        Applies canonical ID merging to avoid duplicate counting when the underlying
+        tracker loses an object temporarily and assigns a new ID.
+        """
+        # 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._current_frame_track_ids = {cat: set() for cat in self.target_categories}
+
+        for det in detections:
+            cat = det.get("category")
+            raw_track_id = det.get("track_id")
+            if cat not in self.target_categories or raw_track_id is None:
+                continue
+            bbox = det.get("bounding_box", det.get("bbox"))
+            canonical_id = self._merge_or_register_track(raw_track_id, bbox)
+            # Propagate canonical ID back to detection so downstream logic uses it
+            det["track_id"] = canonical_id
+
+            self._per_category_total_track_ids.setdefault(cat, set()).add(canonical_id)
+            self._current_frame_track_ids[cat].add(canonical_id)
+
+    def get_total_counts(self):
+        """
+        Return total unique track_id count for each category.
+        """
+        return {cat: len(ids) for cat, ids in getattr(self, '_per_category_total_track_ids', {}).items()}
+
+    def _format_timestamp_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)
+        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')
+
+    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"
+        # is_video_chunk = stream_info.get("input_settings", {}).get("is_video_chunk", False)
+        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)
+                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:
+                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
+        else:
+            # For streams, use stream_time from stream_info
+            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:
+                    # Remove " UTC" suffix and parse
+                    timestamp_str = stream_time_str.replace(" UTC", "")
+                    dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
+                    timestamp = dt.replace(tzinfo=timezone.utc).timestamp()
+                    return self._format_timestamp_for_stream(timestamp)
+                except:
+                    # Fallback to current time if parsing fails
+                    return self._format_timestamp_for_stream(time.time())
+            else:
+                return self._format_timestamp_for_stream(time.time())
+
+    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"
+        if precision:
+            if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
+                return "00:00:00"
+            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 video format, start from 00:00:00
+            return "00:00:00"
+        else:
+            # 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", "")
+                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()
+                    except:
+                        # Fallback to current time if parsing fails
+                        self._tracking_start_time = time.time()
+                else:
+                    self._tracking_start_time = time.time()
+
+            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')
 
     def _count_categories(self, detections: list, config: ConcreteCrackConfig) -> dict:
         """
@@ -553,83 +685,6 @@ class ConcreteCrackUseCase(BaseProcessor):
             ]
         }
 
-    # Human-friendly display names for  categories
-    CATEGORY_DISPLAY = {
-        "Cracks": "Cracks"
-    }
-
-    def _generate_insights(self, summary: dict, config: ConcreteCrackConfig) -> List[str]:
-        """
-        Generate human-readable insights for each category.
-        """
-        insights = []
-        per_cat = summary.get("per_category_count", {})
-        total_detections = summary.get("total_count", 0)
-
-        if total_detections == 0:
-            insights.append("No detections in the scene")
-            return insights
-        insights.append(f"EVENT: Detected {total_detections}  in the scene")
-        # Intensity calculation based on threshold percentage
-        intensity_threshold = None
-        if (config.alert_config and
-                config.alert_config.count_thresholds and
-                "all" in config.alert_config.count_thresholds):
-            intensity_threshold = config.alert_config.count_thresholds["all"]
-
-        if intensity_threshold is not None:
-            # Calculate percentage relative to threshold
-            percentage = (total_detections / intensity_threshold) * 100
-
-            if percentage < 20:
-                insights.append(f"INTENSITY: Low congestion in the scene ({percentage:.1f}% of capacity)")
-            elif percentage <= 50:
-                insights.append(f"INTENSITY: Moderate congestion in the scene ({percentage:.1f}% of capacity)")
-            elif percentage <= 70:
-                insights.append(f"INTENSITY:  Heavy congestion in the scene ({percentage:.1f}% of capacity)")
-            else:
-                insights.append(f"INTENSITY: Severe congestion in the scene ({percentage:.1f}% of capacity)")
-
-
-        for cat, count in per_cat.items():
-            display = self.CATEGORY_DISPLAY.get(cat, cat)
-            insights.append(f"{display}:{count}")
-        return insights
-
-    def _check_alerts(self, summary: dict, config: ConcreteCrackConfig) -> List[Dict]:
-        """
-        Check if any alert thresholds are exceeded and return alert dicts.
-        """
-        alerts = []
-        if not config.alert_config:
-            return alerts
-        total = summary.get("total_count", 0)
-        if config.alert_config.count_thresholds:
-            for category, threshold in config.alert_config.count_thresholds.items():
-                if category == "all" and total >= threshold:
-                    timestamp = datetime.now(timezone.utc).strftime('%Y-%m-%d-%H:%M:%S UTC')
-                    alert_description = f"detections count ({total}) exceeds threshold ({threshold})"
-                    alerts.append({
-                        "type": "count_threshold",
-                        "severity": "warning",
-                        "message": f"Total detections count ({total}) exceeds threshold ({threshold})",
-                        "category": category,
-                        "current_count": total,
-                        "threshold": threshold
-                    })
-                elif category in summary.get("per_category_count", {}):
-                    count = summary.get("per_category_count", {})[category]
-                    if count >= threshold:
-                        alerts.append({
-                            "type": "count_threshold",
-                            "severity": "warning",
-                            "message": f"{category} count ({count}) exceeds threshold ({threshold})",
-                            "category": category,
-                            "current_count": count,
-                            "threshold": threshold
-                        })
-        return alerts
-
     def _extract_predictions(self, detections: list) -> List[Dict[str, Any]]:
         """
         Extract prediction details for output (category, confidence, bounding box).
@@ -643,30 +698,6 @@ class ConcreteCrackUseCase(BaseProcessor):
             for det in detections
         ]
 
-    def _generate_summary(self, summary: dict, alerts: List) -> str:
-        """
-        Generate a human_text string for the result, including per-category insights if available.
-        Adds a tab before each  label for better formatting.
-        Also always includes the cumulative count so far.
-        """
-        total = summary.get("total_count", 0)
-        per_cat = summary.get("per_category_count", {})
-        cumulative = summary.get("total_counts", {})
-        cumulative_total = sum(cumulative.values()) if cumulative else 0
-        lines = []
-        if total > 0:
-            lines.append(f"{total} detections")
-            if per_cat:
-                lines.append("detections:")
-                for cat, count in per_cat.items():
-                    lines.append(f"\t{cat}:{count}")
-        else:
-            lines.append("No  detections")
-        lines.append(f"Total detections: {cumulative_total}")
-        if alerts:
-            lines.append(f"{len(alerts)} alert(s)")
-        return "\n".join(lines)
-
     # ------------------------------------------------------------------ #
     # Canonical ID helpers                                               #
     # ------------------------------------------------------------------ #

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

@@ -28,7 +28,7 @@ class WeldDefectConfig(BaseConfig):
     smoothing_window_size: int = 20
     smoothing_cooldown_frames: int = 5
     smoothing_confidence_range_factor: float = 0.5
-    confidence_threshold: float = 0.6
+    confidence_threshold: float = 0.45
     defect_categories: List[str] = field(
         default_factory=lambda: ['Bad Welding', 'Crack', 'Porosity', 'Spatters', 'Good Welding', 'Reinforcement']
     )

{matrice-1.0.99128.dist-info → matrice-1.0.99130.dist-info}/METADATA

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

{matrice-1.0.99128.dist-info → matrice-1.0.99130.dist-info}/RECORD

@@ -166,7 +166,7 @@ matrice/deploy/utils/post_processing/usecases/chicken_pose_detection.py,sha256=-
 matrice/deploy/utils/post_processing/usecases/child_monitoring.py,sha256=cWYDTXca0hci8k7rHNYfwzoByeGIeJ-d4tESwTnRXa0,38807
 matrice/deploy/utils/post_processing/usecases/color_detection.py,sha256=Z8-akjy8a7f8YyiOzXu_Zi1Km30v-TRrymDqQOPpJ_8,43277
 matrice/deploy/utils/post_processing/usecases/color_map_utils.py,sha256=SP-AEVcjLmL8rxblu-ixqUJC2fqlcr7ab4hWo4Fcr_k,2677
-matrice/deploy/utils/post_processing/usecases/concrete_crack_detection.py,sha256=jl3INFXNjEGS5qha1NP9xrDYPMXNlacKI1Z98zFjo0Q,34358
+matrice/deploy/utils/post_processing/usecases/concrete_crack_detection.py,sha256=whjhRfiFa1dZq-rytaA6QhtZLbaeUmz9fomTW0okDCQ,39264
 matrice/deploy/utils/post_processing/usecases/crop_weed_detection.py,sha256=i7BWhC-D7liOg9fzFHFg_upd1fdvXlVHYzDRyHL-AdM,40322
 matrice/deploy/utils/post_processing/usecases/customer_service.py,sha256=UWS83qxguyAyhh8a0JF5QH9DtKxO8I-gI2BPOjLPxBw,44642
 matrice/deploy/utils/post_processing/usecases/defect_detection_products.py,sha256=flvTWv6vxa3q4zXD8_e8TW0pqNE5z3LIuvU9ceVKuXg,34481
@@ -204,7 +204,7 @@ matrice/deploy/utils/post_processing/usecases/underwater_pollution_detection.py,
 matrice/deploy/utils/post_processing/usecases/vehicle_monitoring.py,sha256=-Q4x0jRYrmbDPAooWbTeYr1TowtvpU5oJ-sVeqRPaM4,31193
 matrice/deploy/utils/post_processing/usecases/warehouse_object_segmentation.py,sha256=5uZXTJL_A3tUEN08T-_ZQpUoJ9gqbuuMc4z2mT4sMnQ,43753
 matrice/deploy/utils/post_processing/usecases/weapon_detection.py,sha256=ait-RCgmu3BH6tNAl9nZgVXO0pSu4ETjtJzN7x6ZFRY,29365
-matrice/deploy/utils/post_processing/usecases/weld_defect_detection.py,sha256=0V3JUKcv2hPtAT1f3Ps-B1BrBUuPnM49qF15zyF9sh0,30208
+matrice/deploy/utils/post_processing/usecases/weld_defect_detection.py,sha256=b0dAJGKUofbGrwHDJfIYb4pqmvp4Y23JK09Qb-34mxg,30209
 matrice/deploy/utils/post_processing/usecases/windmill_maintenance.py,sha256=G1eqo3Z-HYmGJ6oeZYrpZwhpvqQ9Lc_T-6S7BLBXHeA,40498
 matrice/deploy/utils/post_processing/usecases/wound_segmentation.py,sha256=7Nbc7zUQUKdXTSv8XpPuAZLIU3Mr1RU1KyO_D3thoGk,38289
 matrice/deploy/utils/post_processing/utils/__init__.py,sha256=A49ksdXL7gRwBbIUwnU2ueFDGA67qVnEW_9lItOibtk,3626
@@ -225,8 +225,8 @@ matrice/deployment/camera_manager.py,sha256=ReBZqm1CNXRImKcbcZ4uWAT3TUWkof1D28oB
 matrice/deployment/deployment.py,sha256=PLIUD-PxTaC2Zxb3Y12wUddsryV-OJetjCjLoSUh7S4,48103
 matrice/deployment/inference_pipeline.py,sha256=bXLgd29ViA7o0c7YWLFJl1otBUQfTPb61jS6VawQB0Y,37918
 matrice/deployment/streaming_gateway_manager.py,sha256=w5swGsuFVfZIdOm2ZuBHRHlRdYYJMLopLsf2gb91lQ8,20946
-matrice-1.0.99128.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-matrice-1.0.99128.dist-info/METADATA,sha256=gXAqcRNMLWJ3W-9UIIn1jK-Fmj9OydTdwUCGVbqxjAo,14624
-matrice-1.0.99128.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice-1.0.99128.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
-matrice-1.0.99128.dist-info/RECORD,,
+matrice-1.0.99130.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+matrice-1.0.99130.dist-info/METADATA,sha256=xrPDt8ng3IcxPsSmYp4Wa2Co-URJP3qGjc1MDQDhm10,14624
+matrice-1.0.99130.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice-1.0.99130.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
+matrice-1.0.99130.dist-info/RECORD,,