matrice 1.0.99267__py3-none-any.whl → 1.0.99268__py3-none-any.whl

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

@@ -6,9 +6,9 @@ with zone-based analysis, tracking, and alerting capabilities.
 """
 
 from typing import Any, Dict, List, Optional, Set
-from dataclasses import asdict
 import time
 from datetime import datetime, timezone
+import math
 
 from ..core.base import BaseProcessor, ProcessingContext, ProcessingResult, ConfigProtocol, ResultFormat
 from ..core.config import ProximityConfig, ZoneConfig, AlertConfig
@@ -65,6 +65,7 @@ class ProximityUseCase(BaseProcessor):
         
         # Proximity counting
         self._total_proximity_count = 0  # Total proximity events across all calls
+        self._observed_proximity_pairs: Set[frozenset] = set()  # Unique canonical ID pairs seen across frames
         
 
         # --------------------------------------------------------------------- #
@@ -108,7 +109,7 @@ class ProximityUseCase(BaseProcessor):
         Returns:
             ProcessingResult: Processing result with standardized agg_summary structure
         """
-        start_time = time.time()
+        # start_time = time.time()
         
         try:
             # Ensure we have the right config type
@@ -144,8 +145,8 @@ class ProximityUseCase(BaseProcessor):
             else:
                 return self._process_single_frame(data, config, context, stream_info)
                 
-        except Exception as e:
-            self.logger.error(f"Proximity detection failed: {str(e)}", exc_info=True)
+        except Exception as e:  # noqa: BLE001
+            self.logger.error("Proximity detection failed: %s", str(e), exc_info=True)
             
             if context:
                 context.mark_completed()
@@ -283,9 +284,13 @@ class ProximityUseCase(BaseProcessor):
             current_count = counting_summary["categories"].get(category, 0)
             counting_summary["categories"][category] = current_count + 1
 
-        proximity_count = self._count_proximity_events(frame_detections)
+        # Update tracking state BEFORE proximity calculation so we have canonical IDs
+        self._update_tracking_state(counting_summary)
+
+        # Calculate unique proximity events for this frame
+        proximity_count = self._count_proximity_events(counting_summary["detections"])
         counting_summary["proximity_events"] = proximity_count
-        counting_summary["total_proximity_count"] = self._total_proximity_count + proximity_count
+        counting_summary["total_proximity_count"] = self._total_proximity_count
         
         # Step 5: Zone analysis for this frame
         zone_analysis = {}
@@ -301,9 +306,6 @@ class ProximityUseCase(BaseProcessor):
                 for zone_name, enhanced_data in enhanced_zone_analysis.items():
                     zone_analysis[zone_name] = enhanced_data
         
-        # Step 4.5: Always update tracking state (regardless of enable_unique_counting setting)
-        self._update_tracking_state(counting_summary)
-        
         # Step 5: Generate insights and alerts for this frame
         alerts = self._check_alerts(counting_summary, zone_analysis, config, frame_id)
         
@@ -402,11 +404,10 @@ class ProximityUseCase(BaseProcessor):
         
         # Add zone-specific events if applicable
         if zone_analysis:
-            human_text_lines.append(f"\t- ZONE EVENTS:")
+            human_text_lines.append("\t- ZONE EVENTS:")
             for zone_name, zone_count in zone_analysis.items():
                 zone_total = self._robust_zone_total(zone_count)
                 if zone_total > 0:
-                    zone_intensity = min(10.0, zone_total / 5.0)
                     zone_level = "info"
                     if intensity >= 9:
                         level = "critical"
@@ -432,14 +433,14 @@ class ProximityUseCase(BaseProcessor):
                     incidents.append(event)
         return incidents
 
-    def _generate_tracking_stats(self, counting_summary: Dict, zone_analysis: Dict, config: ProximityConfig, frame_id: str, alerts: Any=[], stream_info: Optional[Dict[str, Any]] = None) -> List[Dict]:
+    def _generate_tracking_stats(self, counting_summary: Dict, zone_analysis: Dict, config: ProximityConfig, frame_id: str, alerts: Any=None, stream_info: Optional[Dict[str, Any]] = None) -> List[Dict]:
         """Generate tracking stats using standardized methods."""
         
         total_people = counting_summary.get("total_objects", 0)
         
         # Get total count from cached tracking state
         total_unique_count = self.get_total_count()
-        current_frame_count = self.get_current_frame_count()
+        # current_frame_count = self.get_current_frame_count()
         
         # Get camera info using standardized method
         camera_info = self.get_camera_info_from_stream(stream_info)
@@ -520,7 +521,7 @@ class ProximityUseCase(BaseProcessor):
                 detection_obj = self.create_detection_object(category, bbox)
             detections.append(detection_obj)
         
-        print(detections)
+        # detections prepared above are used only for output formatting
         # Build alerts and alert_settings arrays
         alert_settings = []
         if config.alert_config and hasattr(config.alert_config, 'alert_type'):
@@ -534,42 +535,44 @@ class ProximityUseCase(BaseProcessor):
                             }
             })
         if zone_analysis:
-                human_text_lines=[]
-                current_timestamp = self._get_current_timestamp_str(stream_info, frame_id=frame_id)
-                start_timestamp = self._get_start_timestamp_str(stream_info)
-                human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}:")
-                def robust_zone_total(zone_count):
-                    if isinstance(zone_count, dict):
-                        total = 0
-                        for v in zone_count.values():
-                            if isinstance(v, int):
-                                total += v
-                            elif isinstance(v, list) and total==0:
-                                total += len(v)
-                        return total
-                    elif isinstance(zone_count, list):
-                        return len(zone_count)
-                    elif isinstance(zone_count, int):
-                        return zone_count
-                    else:
-                        return 0
-                human_text_lines.append(f"\t- People Detected: {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}")
-                        human_text_lines.append(f"\t\t- Total count in zone: {zone_total-1}")
-
-                if total_unique_count > 0:
-                    human_text_lines.append(f"\t- Total unique people in the scene: {total_unique_count}")
-                if alerts:
-                    for alert in alerts:
-                        human_text_lines.append(f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}")
+            human_text_lines = []
+            current_timestamp = self._get_current_timestamp_str(stream_info, frame_id=frame_id)
+            start_timestamp = self._get_start_timestamp_str(stream_info)
+            human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}:")
+
+            def robust_zone_total(zone_count):
+                if isinstance(zone_count, dict):
+                    total = 0
+                    for v in zone_count.values():
+                        if isinstance(v, int):
+                            total += v
+                        elif isinstance(v, list) and total == 0:
+                            total += len(v)
+                    return total
+                elif isinstance(zone_count, list):
+                    return len(zone_count)
+                elif isinstance(zone_count, int):
+                    return zone_count
                 else:
-                    human_text_lines.append("Alerts: None")
-                human_text = "\n".join(human_text_lines)  
+                    return 0
+
+            human_text_lines.append(f"\t- People Detected: {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}")
+                human_text_lines.append(f"\t\t- Total count in zone: {zone_total}")
+
+            if total_unique_count > 0:
+                human_text_lines.append(f"\t- Total unique people in the scene: {total_unique_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")
+            human_text = "\n".join(human_text_lines)
         else:      
             human_text = self._generate_human_text_for_tracking(total_people, detections, total_unique_count, config, frame_id, alerts, stream_info)
         
@@ -580,43 +583,97 @@ class ProximityUseCase(BaseProcessor):
         tracking_stat = self.create_tracking_stats(
             total_counts, current_counts, detections, human_text, camera_info, alerts, alert_settings, start_time=high_precision_start_timestamp, reset_time=high_precision_reset_timestamp
         )
-        print(tracking_stat)
         return [tracking_stat]
     
-    def _count_proximity_events(self, detections):
-        """Count proximity events between detections."""
-        proximity_threshold = 400  # pixels
-        proximity_count = 0
-            
-        for i, detection1 in enumerate(detections):
-            for j, detection2 in enumerate(detections[i+1:], i+1):
-                bbox1 = detection1.get("bounding_box", {})
-                bbox2 = detection2.get("bounding_box", {})
-                    
-                if not bbox1 or not bbox2:
+    def _count_proximity_events(self, detections: List[Dict[str, Any]]) -> int:
+        """Count UNIQUE proximity events between detections in a frame.
+
+        Rules:
+        - If canonical track IDs are present, deduplicate by track_id first.
+        - Otherwise, deduplicate overlapping boxes using IoU to avoid duplicate detections of the same person.
+        - Count each pair once (i < j) using Euclidean distance between bottom-center points.
+        - Maintain a running set of unique canonical-ID pairs across frames to compute total unique proximity events.
+        """
+        if not detections:
+            return 0
+
+        proximity_threshold = 400.0  # pixels, screen space
+        iou_duplicate_threshold = getattr(self, "_proximity_iou_duplicate_threshold", 0.5)
+
+        # Step 1: Deduplicate detections
+        unique_detections: List[Dict[str, Any]] = []
+        seen_track_ids: Set[Any] = set()
+
+        for det in detections:
+            track_id = det.get("track_id")
+            bbox = det.get("bounding_box", det.get("bbox", {}))
+            if not bbox:
+                continue
+
+            # Prefer canonical track IDs if present (set earlier in _update_tracking_state)
+            if track_id is not None:
+                if track_id in seen_track_ids:
                     continue
-                    
-                center1 = get_bbox_center(bbox1)
-                center2 = get_bbox_center(bbox2)
-                    
-                if center1 and center2:
-                    distance = abs((center1[0] - center2[0]) + (center1[1] - center2[1]))
-                    if distance < proximity_threshold:
-                        proximity_count += 1
-            
-        return proximity_count
+                seen_track_ids.add(track_id)
+                unique_detections.append(det)
+                continue
+
+            # Fallback: IoU-based dedup for pure detection outputs without track IDs
+            is_duplicate = False
+            for kept in unique_detections:
+                kept_bbox = kept.get("bounding_box", kept.get("bbox", {}))
+                if self._compute_iou(bbox, kept_bbox) >= iou_duplicate_threshold:
+                    is_duplicate = True
+                    break
+            if not is_duplicate:
+                unique_detections.append(det)
+
+        # Step 2: Compute proximity pairs uniquely (i < j)
+        frame_unique_count = 0
+
+        for i in range(len(unique_detections)):
+            det_i = unique_detections[i]
+            bbox_i = det_i.get("bounding_box", det_i.get("bbox", {}))
+            p_i = get_bbox_bottom25_center(bbox_i) or get_bbox_center(bbox_i)
+            if not p_i:
+                continue
+
+            for j in range(i + 1, len(unique_detections)):
+                det_j = unique_detections[j]
+                bbox_j = det_j.get("bounding_box", det_j.get("bbox", {}))
+                p_j = get_bbox_bottom25_center(bbox_j) or get_bbox_center(bbox_j)
+                if not p_j:
+                    continue
+
+                dx = float(p_i[0]) - float(p_j[0])
+                dy = float(p_i[1]) - float(p_j[1])
+                distance = math.hypot(dx, dy)
+                if distance >= proximity_threshold:
+                    continue
+
+                frame_unique_count += 1
+
+                # Update global unique proximity pairs only when both have canonical IDs
+                id_i = det_i.get("track_id")
+                id_j = det_j.get("track_id")
+                if id_i is not None and id_j is not None:
+                    pair_key = frozenset({id_i, id_j})
+                    if pair_key not in self._observed_proximity_pairs:
+                        self._observed_proximity_pairs.add(pair_key)
+                        self._total_proximity_count += 1
+
+        return frame_unique_count
     
     def _generate_human_text_for_tracking(
-        self, 
-        total_people: int, 
-        detections, 
-        total_unique_count: int, 
-        config: ProximityConfig, 
-        frame_id: str, 
-        alerts:Any=[], 
+        self,
+        _total_people: int,
+        detections,
+        _total_unique_count: int,
+        _config: ProximityConfig,
+        frame_id: str,
+        alerts: Any = None,
         stream_info: Optional[Dict[str, Any]] = None) -> str:
         """Generate human-readable text for tracking stats in old format."""
-        from datetime import datetime, timezone
         
         human_text_lines=[]
         current_timestamp = self._get_current_timestamp_str(stream_info, precision=True, frame_id=frame_id)
@@ -625,7 +682,6 @@ class ProximityUseCase(BaseProcessor):
         human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}:")
         
         # Add proximity count to human text
-                # Add proximity count to human text
         proximity_count = self._count_proximity_events(detections)
         if proximity_count > 0:
             human_text_lines.append(f"\t- Current Frame Proximity: {proximity_count}")
@@ -635,7 +691,10 @@ class ProximityUseCase(BaseProcessor):
         human_text_lines.append("")
         if proximity_count > 0:
             human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}:")
-            human_text_lines.append(f"\t- Total Proximity Count: {self._total_proximity_count + proximity_count}")
+            # If tracking IDs are available, _total_proximity_count already includes this frame's new pairs
+            # Otherwise, fall back to showing the current frame's count
+            total_unique = self._total_proximity_count if self._total_proximity_count > 0 else proximity_count
+            human_text_lines.append(f"\t- Total Proximity Count: {total_unique}")
 
         if alerts:
             for alert in alerts:
@@ -712,7 +771,6 @@ class ProximityUseCase(BaseProcessor):
             for zone_name, threshold in config.alert_config.occupancy_thresholds.items():
                 if zone_name in zone_analysis:
                     # Calculate zone_count robustly (supports int, list, dict values)
-                    print('ZONEEE',zone_name, zone_analysis[zone_name])
                     zone_count = self._robust_zone_total(zone_analysis[zone_name])
                     if zone_count >= threshold:
                         alerts.append({
@@ -771,7 +829,7 @@ class ProximityUseCase(BaseProcessor):
         
         return business_analytics
 
-    def _generate_summary(self, summary: dict, incidents: List, tracking_stats: List, business_analytics: List, alerts: List) -> List[str]:
+    def _generate_summary(self, _summary: dict, incidents: List, tracking_stats: List, business_analytics: List, _alerts: List) -> List[str]:
         """
         Generate a human_text string for the tracking_stat, incident, business analytics and alerts.
         """
@@ -880,8 +938,8 @@ class ProximityUseCase(BaseProcessor):
                                 prediction["frame_id"] = frame_id
                                 predictions.append(prediction)
         
-        except Exception as e:
-            self.logger.warning(f"Failed to extract predictions: {str(e)}")
+        except Exception as e:  # noqa: BLE001
+            self.logger.warning("Failed to extract predictions: %s", str(e))
         
         return predictions
     
@@ -939,7 +997,9 @@ class ProximityUseCase(BaseProcessor):
             current_frame_tracks.add(canonical_id)
 
         # Update total track IDs with new canonical IDs from current frame
-        old_total_count = len(self._total_track_ids)
+        # old_total_count can be used for debugging or analytics if needed
+        # Keeping it for potential future use but suppressing linter warning
+        old_total_count = len(self._total_track_ids)  # noqa: F841
         self._total_track_ids.update(current_frame_tracks)
         self._current_frame_track_ids = current_frame_tracks
 
@@ -952,10 +1012,12 @@ class ProximityUseCase(BaseProcessor):
             new_tracks = current_frame_tracks - (self._total_track_ids - current_frame_tracks)
             if new_tracks:
                 self.logger.debug(
-                    f"Tracking state updated: {len(new_tracks)} new canonical track IDs added, total unique tracks: {self._total_count}")
+                    "Tracking state updated: %s new canonical track IDs added, total unique tracks: %s",
+                    len(new_tracks), self._total_count)
             else:
                 self.logger.debug(
-                    f"Tracking state updated: {len(current_frame_tracks)} current frame canonical tracks, total unique tracks: {self._total_count}")
+                    "Tracking state updated: %s current frame canonical tracks, total unique tracks: %s",
+                    len(current_frame_tracks), self._total_count)
     
     def get_total_count(self) -> int:
         """Get the total count of unique people tracked across all calls."""
@@ -972,7 +1034,7 @@ class ProximityUseCase(BaseProcessor):
     def set_global_frame_offset(self, offset: int) -> None:
         """Set the global frame offset for video chunk processing."""
         self._global_frame_offset = offset
-        self.logger.info(f"Global frame offset set to: {offset}")
+        self.logger.info("Global frame offset set to: %s", offset)
     
     def get_global_frame_offset(self) -> int:
         """Get the current global frame offset."""
@@ -982,7 +1044,7 @@ class ProximityUseCase(BaseProcessor):
         """Update global frame offset after processing a chunk."""
         old_offset = self._global_frame_offset
         self._global_frame_offset += frames_in_chunk
-        self.logger.info(f"Global frame offset updated: {old_offset} -> {self._global_frame_offset} (added {frames_in_chunk} frames)")
+        self.logger.info("Global frame offset updated: %s -> %s (added %s frames)", old_offset, self._global_frame_offset, frames_in_chunk)
     
     def get_global_frame_id(self, local_frame_id: str) -> str:
         """Convert local frame ID to global frame ID."""
@@ -1093,14 +1155,14 @@ class ProximityUseCase(BaseProcessor):
         # Update timestamp
         self._last_update_time = time.time()
         
-        self.logger.info(f"Cleared {old_current_count} current frame tracks and {cleared_zone_tracks} zone current tracks. Cumulative total preserved: {self._total_count}")
+        self.logger.info("Cleared %s current frame tracks and %s zone current tracks. Cumulative total preserved: %s", old_current_count, cleared_zone_tracks, self._total_count)
         return old_current_count
     
     def reset_frame_counter(self) -> None:
         """Reset only the frame counter."""
         old_count = self._total_frame_counter
         self._total_frame_counter = 0
-        self.logger.info(f"Frame counter reset from {old_count} to 0")
+        self.logger.info("Frame counter reset from %s to 0", old_count)
     
     def clear_expired_tracks(self, max_age_seconds: float = 300.0) -> int:
         """
@@ -1125,7 +1187,7 @@ class ProximityUseCase(BaseProcessor):
         if current_time - self._last_update_time > max_age_seconds:
             # Use the safe method that preserves cumulative totals
             cleared_count = self.clear_current_frame_tracking()
-            self.logger.info(f"Manual cleanup: cleared {cleared_count} expired current frame tracks (age > {max_age_seconds}s)")
+            self.logger.info("Manual cleanup: cleared %s expired current frame tracks (age > %ss)", cleared_count, max_age_seconds)
             return cleared_count
         return 0
     
@@ -1267,12 +1329,12 @@ class ProximityUseCase(BaseProcessor):
                 return datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
 
         if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
-                if frame_id:
-                    start_time = int(frame_id)/stream_info.get("input_settings", {}).get("original_fps", 30)
-                else:
-                    start_time = stream_info.get("input_settings", {}).get("start_frame", 30)/stream_info.get("input_settings", {}).get("original_fps", 30)
-                stream_time_str = self._format_timestamp_for_video(start_time)
-                return stream_time_str
+            if frame_id:
+                start_time = int(frame_id)/stream_info.get("input_settings", {}).get("original_fps", 30)
+            else:
+                start_time = stream_info.get("input_settings", {}).get("start_frame", 30)/stream_info.get("input_settings", {}).get("original_fps", 30)
+            stream_time_str = self._format_timestamp_for_video(start_time)
+            return stream_time_str
         else:
             # For streams, use stream_time from stream_info
             stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
@@ -1284,7 +1346,7 @@ class ProximityUseCase(BaseProcessor):
                     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:
+                except Exception:  # noqa: BLE001
                     # Fallback to current time if parsing fails
                     return self._format_timestamp_for_stream(time.time())
             else:
@@ -1316,7 +1378,7 @@ class ProximityUseCase(BaseProcessor):
                         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:
+                    except Exception:  # noqa: BLE001
                         # Fallback to current time if parsing fails
                         self._tracking_start_time = time.time()
                 else:
@@ -1450,7 +1512,7 @@ class ProximityUseCase(BaseProcessor):
                 info["last_update"] = now
                 info["raw_ids"].add(raw_id)
                 self.logger.debug(
-                    f"Merged raw track {raw_id} into canonical track {canonical_id} (IoU={iou:.2f})")
+                    "Merged raw track %s into canonical track %s (IoU=%.2f)", raw_id, canonical_id, iou)
                 return canonical_id
 
         # No match found – create a new canonical track
@@ -1461,7 +1523,7 @@ class ProximityUseCase(BaseProcessor):
             "last_update": now,
             "raw_ids": {raw_id},
         }
-        self.logger.debug(f"Registered new canonical track {canonical_id}")
+        self.logger.debug("Registered new canonical track %s", canonical_id)
         return canonical_id 
 
     def _format_timestamp(self, timestamp: float) -> str:
@@ -1603,5 +1665,5 @@ class ProximityUseCase(BaseProcessor):
             self.smoothing_tracker = BBoxSmoothingTracker(smoothing_config)
         
         smoothed_data = bbox_smoothing(data, self.smoothing_tracker.config, self.smoothing_tracker)
-        self.logger.debug(f"Applied bbox smoothing to tracking results")
+        self.logger.debug("Applied bbox smoothing to tracking results")
         return smoothed_data

{matrice-1.0.99267.dist-info → matrice-1.0.99268.dist-info}/METADATA

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

{matrice-1.0.99267.dist-info → matrice-1.0.99268.dist-info}/RECORD

@@ -204,7 +204,7 @@ matrice/deploy/utils/post_processing/usecases/plaque_segmentation_img.py,sha256=
 matrice/deploy/utils/post_processing/usecases/pothole_segmentation.py,sha256=jXTb8ZqInp5xJ-O3Zp3zQBiryFVD0-WBbhW6Kux_NDo,44905
 matrice/deploy/utils/post_processing/usecases/ppe_compliance.py,sha256=G9P9j9E9nfNJInHJxmK1Lb4daFBlG5hq0aqotTLvFFE,30146
 matrice/deploy/utils/post_processing/usecases/price_tag_detection.py,sha256=09Tp6MGAHh95s-NSAp-4WC9iCc20sajWApuUBAvgXiQ,39880
-matrice/deploy/utils/post_processing/usecases/proximity_detection.py,sha256=vgQCVep4yJnZZlOh33M2x2p4N980dYwDifam8_2-Gwc,78406
+matrice/deploy/utils/post_processing/usecases/proximity_detection.py,sha256=HjUZMKZHAgpD_YiyTXFAoaO4awF_QkY9oflCIVFlsiM,81157
 matrice/deploy/utils/post_processing/usecases/road_lane_detection.py,sha256=V_KxwBtAHSNkyoH8sXw-U-P3J8ToXtX3ncc69gn6Tds,31591
 matrice/deploy/utils/post_processing/usecases/road_traffic_density.py,sha256=YiHQ0kKhXglagHPvygywxMqZAw8s0WharrBQqLQj2q4,40311
 matrice/deploy/utils/post_processing/usecases/road_view_segmentation.py,sha256=BcBbOOg5622KuvzKrzs9cJW1wkRoIIcOab0N7BONQKQ,44986
@@ -243,8 +243,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.99267.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-matrice-1.0.99267.dist-info/METADATA,sha256=AKbp9IcGh4knRNdZ5uVslhXEEu4Xl92xoXvJRBt9jPw,14624
-matrice-1.0.99267.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice-1.0.99267.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
-matrice-1.0.99267.dist-info/RECORD,,
+matrice-1.0.99268.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+matrice-1.0.99268.dist-info/METADATA,sha256=aU45pkw_HtMNp9C-mI1pSRKXVAI9djwHr1UCaRvpbCA,14624
+matrice-1.0.99268.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice-1.0.99268.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
+matrice-1.0.99268.dist-info/RECORD,,