nedo-vision-worker-core 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

nedo_vision_worker_core/streams/VideoStreamManager.py

@@ -1,7 +1,6 @@
 import logging
 import time
 import threading
-import cv2
 from typing import Any, Dict, Optional
 
 from .VideoStream import VideoStream
@@ -18,6 +17,11 @@ class VideoStreamManager:
         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] = {}
+        
+        # Reference counting for lazy loading: {worker_source_id: set of pipeline_ids}
+        self.stream_references: Dict[Any, set] = {}
+        # Store URLs for streams that aren't started yet: {worker_source_id: url}
+        self.pending_streams: Dict[Any, str] = {}
 
         self.shared_device_manager = SharedVideoDeviceManager()
 
@@ -38,16 +42,71 @@ class VideoStreamManager:
     # -----------------------
     # Public API
     # -----------------------
-    def add_stream(self, worker_source_id, url):
-        """Adds and starts a stream (regular file/RTSP or a shared direct device) if not already present."""
+    def register_stream(self, worker_source_id, url):
+        """Register a stream URL without starting it (lazy loading)."""
         with self._lock:
+            if worker_source_id not in self.pending_streams:
+                self.pending_streams[worker_source_id] = url
+                logging.debug(f"📝 Registered stream {worker_source_id} for lazy loading")
+    
+    def unregister_stream(self, worker_source_id):
+        """Unregister a stream that's no longer available in the database."""
+        with self._lock:
+            # If it's pending, remove it
+            if worker_source_id in self.pending_streams:
+                del self.pending_streams[worker_source_id]
+                logging.debug(f"🗑️ Unregistered pending stream {worker_source_id}")
+            
+            # If it's active and has no references, remove it
+            if worker_source_id in self.stream_references:
+                if len(self.stream_references[worker_source_id]) == 0:
+                    self._stop_stream(worker_source_id)
+    
+    def acquire_stream(self, worker_source_id, pipeline_id):
+        """Request access to a stream for a pipeline. Starts the stream if not already running."""
+        with self._lock:
+            # Initialize reference set if needed
+            if worker_source_id not in self.stream_references:
+                self.stream_references[worker_source_id] = set()
+            
+            # Add pipeline reference
+            self.stream_references[worker_source_id].add(pipeline_id)
+            logging.info(f"🔗 Pipeline {pipeline_id} acquired stream {worker_source_id} (refs: {len(self.stream_references[worker_source_id])})")
+            
+            # If stream is already running, we're done
             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 True
+            
+            # Get URL from pending streams
+            url = self.pending_streams.get(worker_source_id)
+            if not url:
+                logging.error(f"❌ Cannot acquire stream {worker_source_id}: URL not registered")
+                return False
+        
+        # Start the stream (outside lock to avoid blocking)
+        return self._start_stream(worker_source_id, url)
+    
+    def release_stream(self, worker_source_id, pipeline_id):
+        """Release a stream reference from a pipeline. Stops the stream if no more references."""
+        with self._lock:
+            if worker_source_id not in self.stream_references:
                 return
-
+            
+            # Remove pipeline reference
+            self.stream_references[worker_source_id].discard(pipeline_id)
+            ref_count = len(self.stream_references[worker_source_id])
+            logging.info(f"🔓 Pipeline {pipeline_id} released stream {worker_source_id} (refs: {ref_count})")
+            
+            # If no more references, stop the stream
+            if ref_count == 0:
+                logging.info(f"💤 Stream {worker_source_id} has no more references, stopping...")
+                self._stop_stream(worker_source_id)
+    
+    def _start_stream(self, worker_source_id, url):
+        """Internal method to actually start a stream."""
         if self._is_direct_device(url):
             self._add_direct_device_stream(worker_source_id, url)
-            return
+            return True
 
         # Regular stream
         stream = VideoStream(url)
@@ -55,18 +114,19 @@ class VideoStreamManager:
             stream.start()  # start thread
             with self._lock:
                 self.streams[worker_source_id] = stream
-            logging.info("✅ Added and started video stream: %s", worker_source_id)
+            logging.info("✅ Started video stream: %s", worker_source_id)
+            return True
         except Exception as e:
             logging.error("❌ Failed to start regular stream %s: %s", worker_source_id, e)
-
-    def remove_stream(self, worker_source_id):
-        """Stops and removes a stream (regular or direct device)."""
-        if not worker_source_id:
-            return
-
+            return False
+    
+    def _stop_stream(self, worker_source_id):
+        """Internal method to stop a stream."""
         # Direct device?
         with self._lock:
             is_direct = worker_source_id in self.direct_device_streams
+            # Clean up references
+            self.stream_references.pop(worker_source_id, None)
 
         if is_direct:
             self._remove_direct_device_stream(worker_source_id)
@@ -77,20 +137,16 @@ class VideoStreamManager:
             stream = self.streams.pop(worker_source_id, None)
 
         if stream is None:
-            logging.warning("⚠️ Stream %s not found in manager.", worker_source_id)
             return
 
-        logging.info("🛑 Removing video stream: %s", worker_source_id)
+        logging.info("🛑 Stopping video stream: %s", worker_source_id)
         try:
-            # Expectation: VideoStream.stop() should signal and join internally.
             stream.stop()
         except Exception as 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 regular streams that are not alive. (Direct devices are publisher-driven.)"""
         logging.info("🔄 Starting all video streams...")
@@ -114,51 +170,47 @@ class VideoStreamManager:
 
         for wid in regular_ids:
             try:
-                self.remove_stream(wid)
+                self._stop_stream(wid)
             except Exception as e:
                 logging.error("Error stopping regular stream %s: %s", wid, e)
 
         for wid in direct_ids:
             try:
-                self.remove_stream(wid)
+                self._stop_stream(wid)
             except Exception as e:
                 logging.error("Error stopping direct device stream %s: %s", wid, e)
 
         self._running_evt.clear()
 
+    def wait_for_stream_ready(self, worker_source_id, timeout: float = 10.0) -> bool:
+        """Waits for a specific stream to signal that it has received its first frame."""
+        with self._lock:
+            stream = self.streams.get(worker_source_id)
+
+        if stream and hasattr(stream, 'wait_first_frame'):
+            return stream.wait_first_frame(timeout)
+
+        return False
+
     def get_frame(self, worker_source_id):
-        """Returns the latest frame for the stream, or None if not available.
-        Non-blocking. No sleeps. Short lock scopes.
-        """
-        # Direct device path
+        """Returns the latest frame for the stream, or None if not available."""
         with self._lock:
             if worker_source_id in self.direct_device_streams:
-                # fall through to direct getter outside the manager lock
-                pass
+                stream = None
             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)
 
-        # Regular stream
-        if stream is None or not getattr(stream, "running", False):
+        if stream is None or not hasattr(stream, 'running') or not stream.running:
             return None
 
         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
-
-            # 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():
+            if hasattr(stream, 'is_file') and stream.is_file and hasattr(stream, 'is_video_ended') and stream.is_video_ended():
                 logging.debug("Video file %s ended; waiting for producer to restart.", worker_source_id)
                 return None
 
-            # Must return a copy (VideoStream.get_frame() expected to handle copying)
             return stream.get_frame()
         except Exception as e:
             logging.error("Error getting frame from stream %s: %s", worker_source_id, e)

nedo_vision_worker_core/util/PlatformDetector.py

@@ -0,0 +1,100 @@
+import os
+import platform
+import sys
+import torch
+
+
+class PlatformDetector:
+    """
+    Detects platform and multimedia stack capabilities.
+    """
+
+    @staticmethod
+    def is_linux() -> bool:
+        return sys.platform.startswith("linux")
+
+    @staticmethod
+    def is_windows() -> bool:
+        return sys.platform.startswith("win")
+
+    @staticmethod
+    def is_macos() -> bool:
+        return sys.platform == "darwin"
+
+    @staticmethod
+    def is_jetson() -> bool:
+        """
+        Determines if the platform is an NVIDIA Jetson device.
+        """
+        try:
+            # Device-tree model (most reliable)
+            if os.path.exists("/proc/device-tree/model"):
+                with open("/proc/device-tree/model", "r") as f:
+                    model = f.read().strip()
+                    if "NVIDIA Jetson" in model:
+                        return True
+
+            # Jetson-specific libs/paths
+            jetson_libraries = ["/usr/lib/aarch64-linux-gnu/tegra", "/etc/nv_tegra_release", "/etc/tegra-release"]
+            if any(os.path.exists(p) for p in jetson_libraries):
+                return True
+
+            # Arch alone is not definitive, but is a signal
+            if platform.machine() == "aarch64" and os.path.exists("/dev/nvhost-ctrl"):
+                return True
+
+        except Exception:
+            pass
+
+        return False
+
+    @staticmethod
+    def get_platform_type() -> str:
+        """
+        Returns a coarse platform type: 'jetson' | 'mac' | 'windows' | 'linux'
+        """
+        if PlatformDetector.is_jetson():
+            return "jetson"
+        if PlatformDetector.is_macos():
+            return "mac"
+        if PlatformDetector.is_windows():
+            return "windows"
+        return "linux"
+
+    @staticmethod
+    def has_gstreamer() -> bool:
+        """
+        Check if OpenCV was built with GStreamer support.
+        """
+        try:
+            import cv2
+            info = cv2.getBuildInformation()
+            return ("GStreamer:                   YES" in info) or ("GStreamer: YES" in info)
+        except Exception:
+            return False
+
+    @staticmethod
+    def has_nvidia_gpu() -> bool:
+        """
+        Heuristic for NVIDIA dGPU presence (desktop/server).
+        """
+        if PlatformDetector.is_windows():
+            return bool(os.environ.get("NVIDIA_VISIBLE_DEVICES", ""))  # WSL/Docker hint
+        if PlatformDetector.is_linux():
+            if os.path.exists("/proc/driver/nvidia/version"):
+                return True
+            if os.environ.get("NVIDIA_VISIBLE_DEVICES", "") not in ("", "none"):
+                return True
+        return False
+    
+    @staticmethod
+    def get_device() -> str:
+        """
+        Check for GPU availability and return the appropriate device.
+        """
+        if torch.cuda.is_available():
+            return "cuda"
+        # Add checks for other devices like MPS if needed
+        # elif torch.backends.mps.is_available():
+        #     return "mps"
+        return "cpu"

{nedo_vision_worker_core-0.3.3.dist-info → nedo_vision_worker_core-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedo-vision-worker-core
-Version: 0.3.3
+Version: 0.3.5
 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>

{nedo_vision_worker_core-0.3.3.dist-info → nedo_vision_worker_core-0.3.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-nedo_vision_worker_core/__init__.py,sha256=Uo_DTA0SZ1s_ah7fUFuHTMVx3PUl-8GOYkkczvdl2VI,1924
+nedo_vision_worker_core/__init__.py,sha256=GmU149mopLuJKQ3rEY_-OetVB1aD4BIryIFVa7thDAw,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=K_-hVV2-mdEefZ4Cfu5hMCiOxBiI1aXY8VtkkpK80Lc,10651
@@ -14,8 +14,7 @@ nedo_vision_worker_core/config/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrF
 nedo_vision_worker_core/database/DatabaseManager.py,sha256=o2e9jcqBbtf0Zd9TYuyQhXyKj9rjnNYbSShr7CxuAPk,9341
 nedo_vision_worker_core/database/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker_core/detection/BaseDetector.py,sha256=bReQCTy4tEA1itvw3kkjBMQnx3Jn4MjnDkzdtPwmNPQ,757
-nedo_vision_worker_core/detection/DetectionManager.py,sha256=GSxdXbG6sQXgKEzxsFhi_CQCdy8JK3nytiJPYZUE-xo,3142
-nedo_vision_worker_core/detection/RFDETRDetector.py,sha256=FYZX0wh_y9R3wRYz5vratHcx-pCDnZUkeL2YI__UCPI,2908
+nedo_vision_worker_core/detection/RFDETRDetector.py,sha256=3T3zTFZW0pBv9E-pSpY4JP7wI0LOTM4hxzanvrEXMcE,3093
 nedo_vision_worker_core/detection/YOLODetector.py,sha256=oMCW4KanQCDbtz-ttMiCY5lP1rIgVH_LpfvZvi270j0,2290
 nedo_vision_worker_core/detection/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker_core/detection/detection_processing/DetectionProcessor.py,sha256=wqf4hliR_CPkeoeRbBB3PEpQsmasC4mASJ4WyYjNyPE,948
@@ -58,17 +57,18 @@ nedo_vision_worker_core/models/worker_source_pipeline.py,sha256=xCD4i9pHr8Qy5B_h
 nedo_vision_worker_core/models/worker_source_pipeline_config.py,sha256=dGYTpcTFFu6pmGBufuWBHjv3Xs4RGAQwZn6jp6Ondvs,876
 nedo_vision_worker_core/models/worker_source_pipeline_debug.py,sha256=6S7TkN37FrAT4VwsEB38DWSad7QfvNhsOGtSEK8D1Qs,594
 nedo_vision_worker_core/models/worker_source_pipeline_detection.py,sha256=p6CJsiVCKprTYrNxJsiTB8njXdHkjZKVEyBceRVE6fY,560
+nedo_vision_worker_core/pipeline/ModelManager.py,sha256=K7lmVOo-KL7bnWtyafilZs23bzd6loCgfUz7xuAmlVw,6195
 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/PipelineManager.py,sha256=GGW3fBmDQwNcPJn5yU_BNz7hsR_H7rKoGMImCtC4T9s,6154
 nedo_vision_worker_core/pipeline/PipelinePrepocessor.py,sha256=cCiVSHHqsKCtKYURdYoEjHJX2GnT6zd8kQ6ZukjQ3V0,1271
-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/PipelineProcessor.py,sha256=4pAcyVpiPM8KClm6hjENQgjDbPH9_na93-ehBDGw_5U,26446
+nedo_vision_worker_core/pipeline/PipelineSyncThread.py,sha256=CAn-4F95J_VAv_7_ClrT-z9226U8ATrOGg5jOYqNuyM,8601
 nedo_vision_worker_core/pipeline/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker_core/preprocessing/ImageResizer.py,sha256=RvOazxe6dJQuiy0ZH4lIGbdFfiu0FLUVCHoMvxkDNT4,1324
 nedo_vision_worker_core/preprocessing/ImageRoi.py,sha256=iO7oQ-SdUSA_kTIVBuq_mdycXsiJNfiFD3J7-VTxiQ4,2141
 nedo_vision_worker_core/preprocessing/Preprocessor.py,sha256=uYIh0Ld4T1zEEHtKVLbUVBcF0kUwj5zCfPXn__bKwwU,477
 nedo_vision_worker_core/preprocessing/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-nedo_vision_worker_core/repositories/AIModelRepository.py,sha256=8DaTcKQK89Nf_xTbAUtJUFuMJV9qiQ0VcInHdVFEjts,952
+nedo_vision_worker_core/repositories/AIModelRepository.py,sha256=SzBLwUrjDnc4QayZOA2zL0Jl8YQ-x6S1rde_zCBu6LQ,1591
 nedo_vision_worker_core/repositories/PPEDetectionRepository.py,sha256=C_0QL2sHiSlM9rPmhLmfs6hdZk9FDazy-aVLcznN5w0,6623
 nedo_vision_worker_core/repositories/RestrictedAreaRepository.py,sha256=umZ7IrgoEFqAa9ZZlH7KPUIbmp5yhBc0FSDUOY6UFag,4283
 nedo_vision_worker_core/repositories/WorkerSourcePipelineDebugRepository.py,sha256=_z-UyaYtg1Q5nqSbs_16ngYesyM3aji4VrP1ZBHm6Jk,2987
@@ -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=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=mJiivZjfId1g_GGiwoz68lVyN8n41oGfUL9BNxDLUYk,16024
-nedo_vision_worker_core/streams/VideoStreamManager.py,sha256=FpTNRS8F1LvLLYBMwwTeaiOPTz5yyX_HDYtcYJ97utU,12269
+nedo_vision_worker_core/streams/RTMPStreamer.py,sha256=Dblfutc1UVHj159KUHFYZ8xFEVhHVknZn_nAqKR6uCs,8695
+nedo_vision_worker_core/streams/SharedVideoDeviceManager.py,sha256=vSslwxbhKH6FPndR1HcSFIVWtF-iiOQMlSa4VvFa6M4,16265
+nedo_vision_worker_core/streams/StreamSyncThread.py,sha256=ETT0N_P90ksn6Q5pb7NvMadqCuoicz_g52lcDkHIp88,5382
+nedo_vision_worker_core/streams/VideoStream.py,sha256=nGtJ4FAZ1Ek-8hVRopEt0bLWLpa10OtyUwdDEuXLObQ,13343
+nedo_vision_worker_core/streams/VideoStreamManager.py,sha256=g5cz-YXPewSubBXxCg4mfzsuGKoOHXu-SrMxaGjYPHw,14956
 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
@@ -93,10 +93,11 @@ nedo_vision_worker_core/util/DrawingUtils.py,sha256=sLptmzVaJakP_ZgbZsLL03RMH_9N
 nedo_vision_worker_core/util/ModelReadinessChecker.py,sha256=ywHvt_d7UlY3DyFEJrO4Iyl0zx3SaLKb-Qab5l5Q8n4,6548
 nedo_vision_worker_core/util/PersonAttributeMatcher.py,sha256=PhYTPYSF62Nfuc7dage03K6icw_bBBdpvXvnlzCbS30,2773
 nedo_vision_worker_core/util/PersonRestrictedAreaMatcher.py,sha256=iuzCU32BQKaZ3dIy0QHNg2yoWJA-XhTRwwYqCvFdDgg,1711
+nedo_vision_worker_core/util/PlatformDetector.py,sha256=GGL8UfeMQITR22EMYIRWnuOEnSqo7Dr5mb0PaFrl8AM,3006
 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.3.dist-info/METADATA,sha256=ZA9hjlEGTNBZKkw8lBDMFHOUIgyYolafdUy-UMNeyns,14370
-nedo_vision_worker_core-0.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nedo_vision_worker_core-0.3.3.dist-info/entry_points.txt,sha256=pIPafsvPnBw-fpBKBmc1NQCQ6PQY3ad8mZ6mn8_p5FI,70
-nedo_vision_worker_core-0.3.3.dist-info/top_level.txt,sha256=y8kusXjVYqtG8MSHYWTrk8bRrvjOrphKXYyzu943TTQ,24
-nedo_vision_worker_core-0.3.3.dist-info/RECORD,,
+nedo_vision_worker_core-0.3.5.dist-info/METADATA,sha256=IkDINswFijRo2j9RTaziXJdaivHiTXDe5M6X5fBAh3o,14370
+nedo_vision_worker_core-0.3.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nedo_vision_worker_core-0.3.5.dist-info/entry_points.txt,sha256=pIPafsvPnBw-fpBKBmc1NQCQ6PQY3ad8mZ6mn8_p5FI,70
+nedo_vision_worker_core-0.3.5.dist-info/top_level.txt,sha256=y8kusXjVYqtG8MSHYWTrk8bRrvjOrphKXYyzu943TTQ,24
+nedo_vision_worker_core-0.3.5.dist-info/RECORD,,

nedo_vision_worker_core/detection/DetectionManager.py

@@ -1,83 +0,0 @@
-import logging
-try:
-    import torch
-    TORCH_AVAILABLE = True
-except ImportError:
-    TORCH_AVAILABLE = False
-from .BaseDetector import BaseDetector
-from .RFDETRDetector import RFDETRDetector
-from .YOLODetector import YOLODetector
-
-
-class DetectionManager:
-    def __init__(self, model=None):
-        self.detector: BaseDetector | None = None
-        self.model_metadata = None
-
-        if model:
-            self.load_model(model)
-
-    def load_model(self, model):
-        """
-        Loads a new model at runtime and replaces current detector if successful.
-        Checks download status before attempting to load the model.
-        """
-        if not model:
-            if self.detector:
-                logging.info("🧹 Model unloaded")
-            self.detector = None
-            self.model_metadata = None
-            return
-
-        # Check download status before loading
-        if not model.is_ready_for_use():
-            if model.is_downloading():
-                logging.warning(f"⏳ Model {model.name} is still downloading. Skipping load.")
-                self.detector = None
-                self.model_metadata = None
-                return
-            elif model.has_download_failed():
-                logging.error(f"❌ Model {model.name} download failed: {model.download_error}")
-                self.detector = None
-                self.model_metadata = None
-                return
-            else:
-                logging.warning(f"⚠️ Model {model.name} is not ready for use (status: {model.download_status})")
-                self.detector = None
-                self.model_metadata = None
-                return
-
-        detector_type = model.type.lower()
-
-        try:
-            if detector_type == "yolo":
-                detector = YOLODetector(model)
-            elif detector_type == "rf_detr":
-                detector = RFDETRDetector(model)
-            else:
-                raise ValueError(f"Unsupported model type: {detector_type}")
-
-            if detector.model is not None:
-                self.detector = detector
-                self.model_metadata = model
-                # Log device info
-                if TORCH_AVAILABLE:
-                    device = "GPU" if torch.cuda.is_available() else "CPU"
-                else:
-                    device = "CPU (torch not installed)"
-                logging.info(f"🚀 Model {model.name} loaded on {device}")
-                logging.info(f"📥 Model {model.name} with {detector_type} detector loaded")
-            else:
-                logging.error(f"❌ Error loading model: {model.name} with {detector_type} detector")
-                self.detector = None
-                self.model_metadata = None
-
-        except Exception as e:
-            logging.error(f"❌ Error loading model: {model.name} with {detector_type} detector: {e}")
-            self.detector = None
-            self.model_metadata = None
-
-    def detect_objects(self, frame, confidence_threshold=0.7, class_thresholds=None):
-        if not self.detector:
-            return []
-        return self.detector.detect_objects(frame, confidence_threshold, class_thresholds)