nedo-vision-worker-core 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

nedo_vision_worker_core/streams/VideoStreamManager.py

@@ -1,273 +1,302 @@
 import logging
 import time
+import threading
+import cv2
+from typing import Any, Dict, Optional
+
 from .VideoStream import VideoStream
 from .SharedVideoDeviceManager import SharedVideoDeviceManager
-import threading
+
 
 class VideoStreamManager:
-    """Manages multiple video streams dynamically using VideoStream threads."""
+    """Manages multiple video streams (files/RTSP) and direct devices (/dev/videoN or index) safely."""
 
     def __init__(self):
-        self.streams = {}  # Store streams as {worker_source_id: VideoStream}
-        self.running = False
-        self.lock = threading.Lock()  # Add thread lock
+        # Regular streams: {worker_source_id: VideoStream}
+        self.streams: Dict[Any, VideoStream] = {}
+        # Direct device streams: {worker_source_id: {'url':..., 'latest_frame':..., 'last_update':..., 'alive': bool}}
+        self.direct_device_streams: Dict[Any, Dict[str, Any]] = {}
+        # Per-direct-device locks: {worker_source_id: threading.Lock}
+        self.direct_device_locks: Dict[Any, threading.Lock] = {}
+
         self.shared_device_manager = SharedVideoDeviceManager()
-        self.direct_device_streams = {}  # Store direct device streams {worker_source_id: latest_frame}
-        self.direct_device_locks = {}  # Store locks for direct device frame access
 
+        self._lock = threading.RLock()
+        self._running_evt = threading.Event()  # safer than a bare bool
+
+    # -----------------------
+    # Helpers / classification
+    # -----------------------
     def _is_direct_device(self, url) -> bool:
         """Check if URL represents a direct video device."""
+        if isinstance(url, int):
+            return True
         if isinstance(url, str):
-            return url.isdigit() or url.startswith('/dev/video')
-        return isinstance(url, int)
+            return url.isdigit() or url.startswith("/dev/video")
+        return False
 
+    # -----------------------
+    # Public API
+    # -----------------------
     def add_stream(self, worker_source_id, url):
-        """Adds a new video stream if it's not already active."""
-        if worker_source_id not in self.streams and worker_source_id not in self.direct_device_streams:
-            # Check if this is a direct video device
-            if self._is_direct_device(url):
-                self._add_direct_device_stream(worker_source_id, url)
-            else:
-                # Regular stream (file, RTSP, etc.)
-                stream = VideoStream(url)
-                stream.start()  # Start the thread
-                self.streams[worker_source_id] = stream
-                logging.info(f"✅ Added and started video stream: {worker_source_id}")
-        else:
-            logging.warning(f"⚠️ Stream {worker_source_id} is already active.")
+        """Adds and starts a stream (regular file/RTSP or a shared direct device) if not already present."""
+        with self._lock:
+            if worker_source_id in self.streams or worker_source_id in self.direct_device_streams:
+                logging.warning("⚠️ Stream %s is already active.", worker_source_id)
+                return
 
-    def _add_direct_device_stream(self, worker_source_id, url):
-        """Add a direct device stream using the shared device manager."""
+        if self._is_direct_device(url):
+            self._add_direct_device_stream(worker_source_id, url)
+            return
+
+        # Regular stream
+        stream = VideoStream(url)
         try:
-            # Initialize frame storage for this stream
-            self.direct_device_streams[worker_source_id] = {
-                'url': url,
-                'latest_frame': None,
-                'last_update': time.time()
-            }
-            self.direct_device_locks[worker_source_id] = threading.Lock()
-            
-            # Create callback for receiving frames
-            def frame_callback(frame):
-                with self.direct_device_locks[worker_source_id]:
-                    self.direct_device_streams[worker_source_id]['latest_frame'] = frame
-                    self.direct_device_streams[worker_source_id]['last_update'] = time.time()
-            
-            # Subscribe to the shared device
-            success = self.shared_device_manager.subscribe_to_device(
-                source=url,
-                subscriber_id=f"stream_{worker_source_id}",
-                callback=frame_callback
-            )
-            
-            if success:
-                logging.info(f"✅ Added direct device stream: {worker_source_id} -> {url}")
-            else:
-                # Clean up on failure
-                if worker_source_id in self.direct_device_streams:
-                    del self.direct_device_streams[worker_source_id]
-                if worker_source_id in self.direct_device_locks:
-                    del self.direct_device_locks[worker_source_id]
-                logging.error(f"❌ Failed to add direct device stream: {worker_source_id}")
-                
+            stream.start()  # start thread
+            with self._lock:
+                self.streams[worker_source_id] = stream
+            logging.info("✅ Added and started video stream: %s", worker_source_id)
         except Exception as e:
-            logging.error(f"❌ Error adding direct device stream {worker_source_id}: {e}")
-            # Clean up on error
-            if worker_source_id in self.direct_device_streams:
-                del self.direct_device_streams[worker_source_id]
-            if worker_source_id in self.direct_device_locks:
-                del self.direct_device_locks[worker_source_id]
+            logging.error("❌ Failed to start regular stream %s: %s", worker_source_id, e)
 
     def remove_stream(self, worker_source_id):
-        """Removes and stops a video stream."""
+        """Stops and removes a stream (regular or direct device)."""
         if not worker_source_id:
             return
 
-        with self.lock:
-            # Check if it's a direct device stream
-            if worker_source_id in self.direct_device_streams:
-                self._remove_direct_device_stream(worker_source_id)
-                return
-            
-            # Check if it's a regular stream
-            if worker_source_id not in self.streams:
-                logging.warning(f"⚠️ Stream {worker_source_id} not found in manager.")
-                return
+        # Direct device?
+        with self._lock:
+            is_direct = worker_source_id in self.direct_device_streams
 
-            logging.info(f"🛑 Removing video stream: {worker_source_id}")
+        if is_direct:
+            self._remove_direct_device_stream(worker_source_id)
+            return
 
-            # Get reference before removing from dict
+        # Regular stream
+        with self._lock:
             stream = self.streams.pop(worker_source_id, None)
 
-        if stream:
-            try:
-                stream.stop()
-
-            except Exception as e:
-                logging.error(f"❌ Error stopping stream {worker_source_id}: {e}")
-            finally:
-                stream = None  # Ensure cleanup
-
-        logging.info(f"✅ Stream {worker_source_id} removed successfully.")
+        if stream is None:
+            logging.warning("⚠️ Stream %s not found in manager.", worker_source_id)
+            return
 
-    def _remove_direct_device_stream(self, worker_source_id):
-        """Remove a direct device stream from the shared device manager."""
+        logging.info("🛑 Removing video stream: %s", worker_source_id)
         try:
-            device_info = self.direct_device_streams.get(worker_source_id)
-            if device_info:
-                url = device_info['url']
-                
-                # Unsubscribe from the shared device
-                success = self.shared_device_manager.unsubscribe_from_device(
-                    source=url,
-                    subscriber_id=f"stream_{worker_source_id}"
-                )
-                
-                if success:
-                    logging.info(f"✅ Removed direct device stream: {worker_source_id}")
-                else:
-                    logging.warning(f"⚠️ Failed to unsubscribe direct device stream: {worker_source_id}")
-            
-            # Clean up local storage
-            if worker_source_id in self.direct_device_streams:
-                del self.direct_device_streams[worker_source_id]
-            if worker_source_id in self.direct_device_locks:
-                del self.direct_device_locks[worker_source_id]
-                
+            # Expectation: VideoStream.stop() should signal and join internally.
+            stream.stop()
         except Exception as e:
-            logging.error(f"❌ Error removing direct device stream {worker_source_id}: {e}")
+            logging.error("❌ Error stopping stream %s: %s", worker_source_id, e)
+        finally:
+            stream = None
+
+        logging.info("✅ Stream %s removed successfully.", worker_source_id)
 
     def start_all(self):
-        """Starts all video streams."""
+        """Starts all regular streams that are not alive. (Direct devices are publisher-driven.)"""
         logging.info("🔄 Starting all video streams...")
-        for stream in self.streams.values():
-            if not stream.is_alive():
-                stream.start()  # Start thread if not already running
-        self.running = True
+        with self._lock:
+            for stream in self.streams.values():
+                if not stream.is_alive():
+                    try:
+                        stream.start()
+                    except Exception as e:
+                        logging.error("❌ Failed to start a stream: %s", e)
+        self._running_evt.set()
+
     def stop_all(self):
-        """Stops all video streams."""
+        """Stops all streams (regular + direct devices)."""
         logging.info("🛑 Stopping all video streams...")
-        
-        with self.lock:
-            # Get a list of IDs to avoid modification during iteration
-            stream_ids = list(self.streams.keys())
-            direct_stream_ids = list(self.direct_device_streams.keys())
-            
-        # Stop each regular stream
-        for worker_source_id in stream_ids:
+
+        # Snapshot IDs to avoid dict-size-change races
+        with self._lock:
+            regular_ids = list(self.streams.keys())
+            direct_ids = list(self.direct_device_streams.keys())
+
+        for wid in regular_ids:
             try:
-                self.remove_stream(worker_source_id)
+                self.remove_stream(wid)
             except Exception as e:
-                logging.error(f"Error stopping stream {worker_source_id}: {e}")
-        
-        # Stop each direct device stream
-        for worker_source_id in direct_stream_ids:
+                logging.error("Error stopping regular stream %s: %s", wid, e)
+
+        for wid in direct_ids:
             try:
-                self.remove_stream(worker_source_id)
+                self.remove_stream(wid)
             except Exception as e:
-                logging.error(f"Error stopping direct device stream {worker_source_id}: {e}")
-        
-        self.running = False
+                logging.error("Error stopping direct device stream %s: %s", wid, e)
+
+        self._running_evt.clear()
 
     def get_frame(self, worker_source_id):
-        """Retrieves the latest frame for a specific stream."""
-        # Check if it's a direct device stream first
+        """Returns the latest frame for the stream, or None if not available.
+        Non-blocking. No sleeps. Short lock scopes.
+        """
+        # Direct device path
+        with self._lock:
+            if worker_source_id in self.direct_device_streams:
+                # fall through to direct getter outside the manager lock
+                pass
+            else:
+                # Regular stream path
+                stream = self.streams.get(worker_source_id)
+
+        # Direct device?
         if worker_source_id in self.direct_device_streams:
             return self._get_direct_device_frame(worker_source_id)
-        
-        # Handle regular streams
-        with self.lock:  # Add lock protection for stream access
-            stream = self.streams.get(worker_source_id)
-            if stream is None:
-                return None
 
-            # Check if stream is still running
-            if not stream.running:
-                return None
-
-            try:
-                # **Ignore warnings for the first 5 seconds**
-                elapsed_time = time.time() - stream.start_time
-                if elapsed_time < 5:
-                    return None
-
-                # Check if video file has ended
-                if stream.is_file and stream.is_video_ended():
-                    logging.debug(f"Video file {worker_source_id} has ended, waiting for restart...")
-                    # Small delay to allow the video to restart
-                    time.sleep(0.1)
-                    return None
+        # Regular stream
+        if stream is None or not getattr(stream, "running", False):
+            return None
 
-                return stream.get_frame()  # Already returns a copy
-            except Exception as e:
-                logging.error(f"Error getting frame from stream {worker_source_id}: {e}")
+        try:
+            # Soft warm-up: your original code suppressed frames for the first 5s
+            start_time = getattr(stream, "start_time", None)
+            if start_time is not None and (time.time() - start_time) < 5.0:
                 return None
 
-    def _get_direct_device_frame(self, worker_source_id):
-        """Get the latest frame from a direct device stream."""
-        try:
-            if worker_source_id not in self.direct_device_locks:
+            # If it's a file and ended, do not sleep here; let the producer handle restarts.
+            if getattr(stream, "is_file", False) and stream.is_video_ended():
+                logging.debug("Video file %s ended; waiting for producer to restart.", worker_source_id)
                 return None
-            
-            with self.direct_device_locks[worker_source_id]:
-                device_info = self.direct_device_streams.get(worker_source_id)
-                if not device_info:
-                    return None
-                
-                frame = device_info.get('latest_frame')
-                last_update = device_info.get('last_update', 0)
-                
-                # Check if frame is too old (5 seconds threshold)
-                if time.time() - last_update > 5.0:
-                    return None
-                
-                return frame.copy() if frame is not None else None
-                
+
+            # Must return a copy (VideoStream.get_frame() expected to handle copying)
+            return stream.get_frame()
         except Exception as e:
-            logging.error(f"Error getting frame from direct device stream {worker_source_id}: {e}")
+            logging.error("Error getting frame from stream %s: %s", worker_source_id, e)
             return None
 
     def get_active_stream_ids(self):
-        """Returns a list of active stream IDs."""
-        regular_streams = list(self.streams.keys())
-        direct_streams = list(self.direct_device_streams.keys())
-        return regular_streams + direct_streams
-
-    def get_stream_url(self, worker_source_id):
-        """Returns the URL of a specific stream."""
-        # Check direct device streams first
-        if worker_source_id in self.direct_device_streams:
-            return self.direct_device_streams[worker_source_id]['url']
-        
-        # Check regular streams
-        stream = self.streams.get(worker_source_id)
-        return stream.source if stream else None
-    
-    def has_stream(self, worker_source_id):
+        """Returns a snapshot of active stream IDs (regular + direct)."""
+        with self._lock:
+            return list(self.streams.keys()) + list(self.direct_device_streams.keys())
+
+    def get_stream_url(self, worker_source_id) -> Optional[str]:
+        """Returns the URL/source of a specific stream."""
+        with self._lock:
+            if worker_source_id in self.direct_device_streams:
+                return self.direct_device_streams[worker_source_id]["url"]
+            s = self.streams.get(worker_source_id)
+            return s.source if s else None
+
+    def has_stream(self, worker_source_id) -> bool:
         """Checks if a stream is active."""
-        return (worker_source_id in self.streams or 
-                worker_source_id in self.direct_device_streams)
+        with self._lock:
+            return (worker_source_id in self.streams) or (worker_source_id in self.direct_device_streams)
 
-    def is_running(self):
-        """Checks if the manager is running."""
-        return self.running
+    def is_running(self) -> bool:
+        """Checks if manager is 'running'."""
+        return self._running_evt.is_set()
 
-    def is_video_file(self, worker_source_id):
-        """Check if a stream is a video file."""
-        # Direct device streams are never video files
-        if worker_source_id in self.direct_device_streams:
-            return False
-        
-        # Check regular streams
-        stream = self.streams.get(worker_source_id)
-        return stream.is_file if stream else False
+    def is_video_file(self, worker_source_id) -> bool:
+        """True if a stream is a file. Direct devices are never files."""
+        with self._lock:
+            if worker_source_id in self.direct_device_streams:
+                return False
+            s = self.streams.get(worker_source_id)
+            return bool(getattr(s, "is_file", False)) if s else False
 
     def get_device_sharing_info(self):
-        """Get information about device sharing."""
+        """Returns info from the shared device manager."""
         return self.shared_device_manager.get_all_devices_info()
 
     def shutdown(self):
-        """Shutdown the manager and clean up all resources."""
+        """Cleanly stop all and leave the shared manager to auto-clean."""
         logging.info("Shutting down VideoStreamManager")
         self.stop_all()
-        # The SharedVideoDeviceManager is a singleton and will clean up automatically
+
+    # -----------------------
+    # Direct device management
+    # -----------------------
+    def _add_direct_device_stream(self, worker_source_id, url):
+        """Subscribe to a shared device and store frames safely, handling removal races."""
+        lock = threading.Lock()
+
+        with self._lock:
+            # Initialize storage
+            self.direct_device_locks[worker_source_id] = lock
+            self.direct_device_streams[worker_source_id] = {
+                "url": url,
+                "latest_frame": None,
+                "last_update": 0.0,
+                "alive": True,  # tombstone flag
+            }
+
+        # Callback uses captured lock and checks the alive flag to avoid races
+        def frame_callback(frame):
+            # Use the per-worker lock we captured (not via dict lookup)
+            with lock:
+                with self._lock:
+                    info = self.direct_device_streams.get(worker_source_id)
+                    if not info or not info.get("alive", False):
+                        return  # dropped subscriber; ignore late frames
+                    info["latest_frame"] = frame
+                    info["last_update"] = time.time()
+
+        try:
+            success = self.shared_device_manager.subscribe_to_device(
+                source=url,
+                subscriber_id=f"stream_{worker_source_id}",
+                callback=frame_callback,
+            )
+            if success:
+                logging.info("✅ Added direct device stream: %s -> %s", worker_source_id, url)
+            else:
+                logging.error("❌ Failed to add direct device stream: %s", worker_source_id)
+                # rollback
+                with self._lock:
+                    self.direct_device_streams.pop(worker_source_id, None)
+                    self.direct_device_locks.pop(worker_source_id, None)
+        except Exception as e:
+            logging.error("❌ Error adding direct device stream %s: %s", worker_source_id, e)
+            with self._lock:
+                self.direct_device_streams.pop(worker_source_id, None)
+                self.direct_device_locks.pop(worker_source_id, None)
+
+    def _remove_direct_device_stream(self, worker_source_id):
+        """Unsubscribe and safely tear down direct device stream, tolerating late callbacks."""
+        # Mark as dead first so any in-flight callbacks become no-ops
+        with self._lock:
+            info = self.direct_device_streams.get(worker_source_id)
+            if not info:
+                logging.warning("⚠️ Direct device stream %s not found.", worker_source_id)
+                return
+            info["alive"] = False
+            url = info["url"]
+
+        try:
+            success = self.shared_device_manager.unsubscribe_from_device(
+                source=url,
+                subscriber_id=f"stream_{worker_source_id}",
+            )
+            if success:
+                logging.info("✅ Removed direct device stream: %s", worker_source_id)
+            else:
+                logging.warning("⚠️ Unsubscribe reported failure for direct device stream: %s", worker_source_id)
+        except Exception as e:
+            logging.error("❌ Error unsubscribing direct device stream %s: %s", worker_source_id, e)
+
+        # Now it is safe to drop references
+        with self._lock:
+            self.direct_device_streams.pop(worker_source_id, None)
+            self.direct_device_locks.pop(worker_source_id, None)
+
+    def _get_direct_device_frame(self, worker_source_id):
+        """Return last frame from a direct device if fresh, else None."""
+        with self._lock:
+            lock = self.direct_device_locks.get(worker_source_id)
+
+        if lock is None:
+            return None
+
+        # Serialize per-stream frame access
+        with lock:
+            with self._lock:
+                info = self.direct_device_streams.get(worker_source_id)
+                if not info:
+                    return None
+                frame = info.get("latest_frame")
+                last_update = info.get("last_update", 0.0)
+
+            # Outside manager lock: only local refs used now
+            if (time.time() - last_update) > 5.0:
+                return None
+            return frame.copy() if frame is not None else None

{nedo_vision_worker_core-0.3.1.dist-info → nedo_vision_worker_core-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedo-vision-worker-core
-Version: 0.3.1
+Version: 0.3.2
 Summary: Nedo Vision Worker Core Library for AI Vision Processing
 Author-email: Willy Achmat Fauzi <willy.achmat@gmail.com>
 Maintainer-email: Willy Achmat Fauzi <willy.achmat@gmail.com>
@@ -391,40 +391,7 @@ def cleanup_monitoring():
     CoreService.unregister_callback("area_security")
 ```
 
-### Dependencies
-
-The service relies on several key technologies:
-
-- **PyTorch**: Deep learning framework with CUDA support
-- **OpenCV**: Computer vision and video processing
-- **SQLAlchemy**: Database ORM and management
-- **FFmpeg**: Video streaming and processing
-- **Ultralytics**: YOLO model implementations
-
-## Development Setup
-
-For development and testing:
-
-```bash
-# Clone and setup development environment
-git clone <repository-url>
-cd nedo-vision-worker-core-v2
-
-# Create virtual environment
-python -m venv .venv
-source .venv/bin/activate  # Linux/Mac
-# or
-.venv\Scripts\activate     # Windows
-
-# Install in development mode
-pip install -e .
-
-# Run tests
-python test.py
-
-# Check system health
-nedo-worker-core doctor
-```
+See [INSTALL.md](INSTALL.md) for detailed installation instructions.
 
 ## Troubleshooting
 

{nedo_vision_worker_core-0.3.1.dist-info → nedo_vision_worker_core-0.3.2.dist-info}/RECORD

@@ -1,7 +1,7 @@
-nedo_vision_worker_core/__init__.py,sha256=kvKFO3vOryC1VT3Up4pR7XxNk_wqhDs4uTk7HH7rX6Q,1924
+nedo_vision_worker_core/__init__.py,sha256=gOVK9WXdcVvRyelxasgOBdnkqE2wbdbRZ3VnuSXgobc,1924
 nedo_vision_worker_core/cli.py,sha256=8YuKWsIgICUYXE_QtwyU3WzGhVjTWiAo5uzpFOmjNc8,5766
 nedo_vision_worker_core/core_service.py,sha256=dnHNjbslOeyeWqHDFnk_yKdfTICYzLyRIcuZNwF0Zf4,11323
-nedo_vision_worker_core/doctor.py,sha256=JQ14WDxxA-ABrx7XQ7vc8QpcZztMvCwqf0UGLlQRxaQ,10650
+nedo_vision_worker_core/doctor.py,sha256=K_-hVV2-mdEefZ4Cfu5hMCiOxBiI1aXY8VtkkpK80Lc,10651
 nedo_vision_worker_core/ai/FrameDrawer.py,sha256=lj83WFaE70BQfkEc6AHcMBXaiEm8l3s_zJZG9C0NkAs,5286
 nedo_vision_worker_core/ai/ImageDebugger.py,sha256=5FwgNGZrxO2eT7hxdxp7N2gQ0oyyYDZChJ3PJapKu-w,4612
 nedo_vision_worker_core/ai/VideoDebugger.py,sha256=M6XVuK2Lq2ceE5UdYj2GLaMbEU6THmGzgQlVkqs-lAc,2578
@@ -61,7 +61,7 @@ nedo_vision_worker_core/models/worker_source_pipeline_detection.py,sha256=p6CJsi
 nedo_vision_worker_core/pipeline/PipelineConfigManager.py,sha256=X55i9GyXcW9ylO6cj2UMAZFSxxPViacL4H4DZl60CAY,1157
 nedo_vision_worker_core/pipeline/PipelineManager.py,sha256=kJslTS1QD7sgmvZ4ZShxW2HI2u_xzmNM5yD0KlpPx_4,5485
 nedo_vision_worker_core/pipeline/PipelinePrepocessor.py,sha256=cCiVSHHqsKCtKYURdYoEjHJX2GnT6zd8kQ6ZukjQ3V0,1271
-nedo_vision_worker_core/pipeline/PipelineProcessor.py,sha256=GG6SLj2OZWUzj_ahs31bNp-njbgXJIsBcNhutu3LQs8,29457
+nedo_vision_worker_core/pipeline/PipelineProcessor.py,sha256=Qw8gRk7cOuVBAvS2h12CF0VLkqLrCrIOIGqGQHnzrKk,26262
 nedo_vision_worker_core/pipeline/PipelineSyncThread.py,sha256=9eVGsm4rUfr5tpDHRYOshpiaZ5I484AjJdilhffHzls,11692
 nedo_vision_worker_core/pipeline/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker_core/preprocessing/ImageResizer.py,sha256=RvOazxe6dJQuiy0ZH4lIGbdFfiu0FLUVCHoMvxkDNT4,1324
@@ -79,11 +79,11 @@ nedo_vision_worker_core/repositories/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8
 nedo_vision_worker_core/services/SharedVideoStreamServer.py,sha256=rhCineMKPG3GQbrMHlSHP4xhXaGZ6Rn1oqIajW5xpaY,9827
 nedo_vision_worker_core/services/VideoSharingDaemon.py,sha256=iY6afEKTOsphfHvmZTL0grezka2DS9DDq-1EIpVMy0Y,28524
 nedo_vision_worker_core/services/VideoSharingDaemonManager.py,sha256=sc8VZo5iwoOdR8uTiel5BKz6-eZ7wwLy3IwV_3tsAu0,10340
-nedo_vision_worker_core/streams/RTMPStreamer.py,sha256=GuvSaY8Siuswrwww0L1yRrOg8N1yITjRPJWy2Vf_Vzs,5821
+nedo_vision_worker_core/streams/RTMPStreamer.py,sha256=GNooWE4V--GiqetqpWSj0TTmOns12DaIpLGy1qHFulc,10167
 nedo_vision_worker_core/streams/SharedVideoDeviceManager.py,sha256=N2cvlKfemD3OG4zEW5mnyup4JgqbzS_JvP2rbbHEBE0,16183
 nedo_vision_worker_core/streams/StreamSyncThread.py,sha256=WmYAY9wFiFhLlxGdnvKGIjAqLwCBayNKdmAWzkbU0jM,3763
-nedo_vision_worker_core/streams/VideoStream.py,sha256=7rmn6nCF7PU1b1HEpKzaVZ5K4HaaiLa90_OkfSTCL_Q,13051
-nedo_vision_worker_core/streams/VideoStreamManager.py,sha256=JsZsyDTaCQCifUXYZAPj_tQlLfN28EzUZDbf8AMvNOk,11636
+nedo_vision_worker_core/streams/VideoStream.py,sha256=Mtj5FI4vEy-dhJN2hQZaD9D_OWBbsntVqWMSDfKn4wk,16024
+nedo_vision_worker_core/streams/VideoStreamManager.py,sha256=FpTNRS8F1LvLLYBMwwTeaiOPTz5yyX_HDYtcYJ97utU,12269
 nedo_vision_worker_core/streams/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker_core/tracker/SFSORT.py,sha256=0kggw0l4yPZ55AKHdqVX6mu9ehHmJed7jcJ3JQoC4sk,14061
 nedo_vision_worker_core/tracker/TrackerManager.py,sha256=xtDMI657W2s7HM2lMGtwU0x5Hq74BZpLHd-5xk-278I,6152
@@ -95,8 +95,8 @@ nedo_vision_worker_core/util/PersonAttributeMatcher.py,sha256=PhYTPYSF62Nfuc7dag
 nedo_vision_worker_core/util/PersonRestrictedAreaMatcher.py,sha256=iuzCU32BQKaZ3dIy0QHNg2yoWJA-XhTRwwYqCvFdDgg,1711
 nedo_vision_worker_core/util/TablePrinter.py,sha256=wzLGgb1GFMeIbAP6HmKcZD33j4D-IlyqlyeR7C5yD7w,1137
 nedo_vision_worker_core/util/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-nedo_vision_worker_core-0.3.1.dist-info/METADATA,sha256=oEphVks7DPx7YeI3SoR-5iDkE6z3pxwnZuYa37mbqKc,15032
-nedo_vision_worker_core-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nedo_vision_worker_core-0.3.1.dist-info/entry_points.txt,sha256=pIPafsvPnBw-fpBKBmc1NQCQ6PQY3ad8mZ6mn8_p5FI,70
-nedo_vision_worker_core-0.3.1.dist-info/top_level.txt,sha256=y8kusXjVYqtG8MSHYWTrk8bRrvjOrphKXYyzu943TTQ,24
-nedo_vision_worker_core-0.3.1.dist-info/RECORD,,
+nedo_vision_worker_core-0.3.2.dist-info/METADATA,sha256=ql_lATGf7e9bMoC80qbVUEqTq6IbqUAt7fk62kfcZEI,14370
+nedo_vision_worker_core-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nedo_vision_worker_core-0.3.2.dist-info/entry_points.txt,sha256=pIPafsvPnBw-fpBKBmc1NQCQ6PQY3ad8mZ6mn8_p5FI,70
+nedo_vision_worker_core-0.3.2.dist-info/top_level.txt,sha256=y8kusXjVYqtG8MSHYWTrk8bRrvjOrphKXYyzu943TTQ,24
+nedo_vision_worker_core-0.3.2.dist-info/RECORD,,