nedo-vision-worker-core 0.3.7__tar.gz → 0.3.9__tar.gz

{nedo_vision_worker_core-0.3.7 → nedo_vision_worker_core-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedo-vision-worker-core
-Version: 0.3.7
+Version: 0.3.9
 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>
@@ -30,7 +30,7 @@ Classifier: Environment :: No Input/Output (Daemon)
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: alembic>=1.8.0
-Requires-Dist: numpy>=1.21.0
+Requires-Dist: numpy<2.0.0,>=1.21.0
 Requires-Dist: pillow>=8.0.0
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: scipy>=1.9.0
@@ -40,8 +40,6 @@ Requires-Dist: torch>=1.9.0
 Requires-Dist: torchvision>=0.10.0
 Requires-Dist: ultralytics>=8.0.0
 Requires-Dist: rfdetr<2.0.0,>=1.2.0
-Provides-Extra: opencv
-Requires-Dist: opencv-python>=4.6.0; extra == "opencv"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: black>=22.0.0; extra == "dev"
@@ -49,6 +47,8 @@ Requires-Dist: isort>=5.10.0; extra == "dev"
 Requires-Dist: mypy>=0.950; extra == "dev"
 Requires-Dist: flake8>=4.0.0; extra == "dev"
 Requires-Dist: pre-commit>=2.17.0; extra == "dev"
+Provides-Extra: opencv
+Requires-Dist: opencv-python<5.0.0,>=4.6.0; extra == "opencv"
 
 # Nedo Vision Worker Core
 

{nedo_vision_worker_core-0.3.7 → nedo_vision_worker_core-0.3.9}/nedo_vision_worker_core/__init__.py

@@ -7,7 +7,7 @@ A library for running AI vision processing and detection in the Nedo Vision plat
 from .core_service import CoreService
 from .callbacks import DetectionType, CallbackTrigger, DetectionData, IntervalMetadata
 
-__version__ = "0.3.7"
+__version__ = "0.3.9"
 __all__ = [
     "CoreService", 
     "DetectionType", 

nedo_vision_worker_core-0.3.9/nedo_vision_worker_core/ai/VideoDebugger.py

@@ -0,0 +1,89 @@
+import cv2
+import threading
+import time
+from collections import defaultdict
+import logging
+
+class VideoDebugger:
+    """Real-time visualization of video streams with detections."""
+
+    def __init__(self, enable_visualization=True):
+        self.enable_visualization = enable_visualization
+        self.windows = {}
+        self.lock = threading.Lock()
+        self.fps_tracker = defaultdict(lambda: {"start_time": time.time(), "frame_count": 0})
+        self._cv_lock = threading.Lock()  # Prevent OpenCV segfaults
+
+    def show_frame(self, pipeline_id, worker_source_id, frame):
+        """Display frame with FPS overlay."""
+        if not self.enable_visualization or frame is None:
+            return
+
+        window_name = f"Pipeline {pipeline_id} - {worker_source_id}"
+        
+        try:
+            with self.lock:
+                if window_name not in self.fps_tracker:
+                    self.fps_tracker[window_name] = {"start_time": time.time(), "frame_count": 0}
+
+                self.fps_tracker[window_name]["frame_count"] += 1
+                elapsed_time = time.time() - self.fps_tracker[window_name]["start_time"]
+                fps = self.fps_tracker[window_name]["frame_count"] / max(elapsed_time, 1e-5)
+
+                cv2.putText(frame, f"FPS: {fps:.2f}", (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 1)
+
+                if window_name not in self.windows:
+                    self.windows[window_name] = True
+
+            # Serialize cv2 calls to prevent segfaults
+            with self._cv_lock:
+                try:
+                    cv2.imshow(window_name, frame)
+                    key = cv2.waitKey(1) & 0xFF
+                    
+                    if key == ord('q'):
+                        self.close_window(window_name)
+                except Exception as e:
+                    logging.error(f"Error displaying frame for {window_name}: {e}")
+                    
+        except Exception as e:
+            logging.error(f"Error in show_frame for {window_name}: {e}")
+
+    def close_window(self, window_name):
+        """Close specific window."""
+        with self.lock:
+            if window_name in self.windows:
+                with self._cv_lock:
+                    try:
+                        cv2.destroyWindow(window_name)
+                    except Exception as e:
+                        logging.error(f"Error closing window {window_name}: {e}")
+                del self.windows[window_name]
+    
+    def is_window_open(self, pipeline_id):
+        """Check if a window is open for a given pipeline."""
+        with self.lock:
+            # Check if any window exists for this pipeline
+            for window_name in self.windows.keys():
+                if f"Pipeline {pipeline_id}" in window_name:
+                    return True
+            return False
+
+    def close_all(self):
+        """Close all windows."""
+        with self.lock:
+            window_list = list(self.windows.keys())
+        
+        with self._cv_lock:
+            try:
+                for window in window_list:
+                    try:
+                        cv2.destroyWindow(window)
+                    except Exception as e:
+                        logging.debug(f"Error destroying window {window}: {e}")
+                cv2.waitKey(1)
+            except Exception as e:
+                logging.error(f"Error in close_all: {e}")
+        
+        with self.lock:
+            self.windows.clear()

{nedo_vision_worker_core-0.3.7 → nedo_vision_worker_core-0.3.9}/nedo_vision_worker_core/core_service.py

@@ -32,7 +32,8 @@ class CoreService:
                  log_level: str = "INFO",
                  storage_path: str = "data",
                  rtmp_server: str = "rtmp://live.vision.sindika.co.id:1935/live",
-                 enable_video_sharing_daemon: bool = True):
+                 enable_video_sharing_daemon: bool = True,
+                 max_pipeline_workers: int = None):
         """
         Initialize the Core Service.
         
@@ -42,12 +43,14 @@ class CoreService:
             storage_path: Storage path for databases and files (default: data)
             rtmp_server: RTMP server URL for video streaming (default: rtmp://localhost:1935/live)
             enable_video_sharing_daemon: Enable automatic video sharing daemon management (default: True)
+            max_pipeline_workers: Maximum concurrent pipeline workers (default: auto-detect based on CPU cores)
         """
         self.running = True
         self.video_manager = None
         self.stream_sync_thread = None
         self.pipeline_sync_thread = None
         self.enable_video_sharing_daemon = enable_video_sharing_daemon
+        self.max_pipeline_workers = max_pipeline_workers
         
         # Initialize callback manager if not already done
         if CoreService._callback_manager is None:
@@ -230,7 +233,10 @@ class CoreService:
             self.stream_sync_thread.start()
 
             # Start pipeline synchronization thread (AI processing)
-            self.pipeline_sync_thread = PipelineSyncThread(self.video_manager)
+            self.pipeline_sync_thread = PipelineSyncThread(
+                self.video_manager,
+                max_workers=self.max_pipeline_workers
+            )
             self.pipeline_sync_thread.start()
 
             logging.info("✅ Nedo Vision Core initialized and running.")

{nedo_vision_worker_core-0.3.7 → nedo_vision_worker_core-0.3.9}/nedo_vision_worker_core/detection/RFDETRDetector.py

@@ -1,11 +1,11 @@
 import cv2
 import logging
 try:
-    from rfdetr import RFDETRBase
+    from rfdetr import RFDETRNano, RFDETRSmall, RFDETRMedium, RFDETRBase, RFDETRLarge
     RFDETR_AVAILABLE = True
 except ImportError:
     RFDETR_AVAILABLE = False
-    RFDETRBase = None
+    RFDETRNano = RFDETRSmall = RFDETRMedium = RFDETRBase = RFDETRLarge = None
 
 from ..database.DatabaseManager import DatabaseManager
 from ..models.ai_model import AIModelEntity
@@ -32,6 +32,32 @@ class RFDETRDetector(BaseDetector):
         if model:
             self.load_model(model)
 
+    def _detect_model_variant(self, model_path: str):
+        """
+        Automatically detect the correct RF-DETR variant by trying to load the weights.
+        Returns the appropriate RF-DETR class or None if all attempts fail.
+        """
+        variants = [
+            ("Nano", RFDETRNano),
+            ("Small", RFDETRSmall),
+            ("Medium", RFDETRMedium),
+            ("Base", RFDETRBase),
+            ("Large", RFDETRLarge)
+        ]
+        
+        for variant_name, variant_class in variants:
+            try:
+                logging.info(f"🔍 Trying RF-DETR {variant_name} variant...")
+                temp_model = variant_class(pretrain_weights=model_path)
+                logging.info(f"✅ Successfully loaded RF-DETR {variant_name} variant")
+                return temp_model, variant_name
+            except Exception as e:
+                # Only log at debug level to avoid cluttering logs
+                logging.debug(f"RF-DETR {variant_name} variant failed: {e}")
+                continue
+        
+        return None, None
+
     def load_model(self, model: AIModelEntity):
         if not isinstance(model, AIModelEntity):
             raise TypeError("model must be an instance of AIModelEntity")
@@ -44,8 +70,16 @@ class RFDETRDetector(BaseDetector):
             return False
             
         try:
-            self.model = RFDETRBase(pretrain_weights=path.as_posix())
+            loaded_model, variant_name = self._detect_model_variant(path.as_posix())
+            
+            if loaded_model is None:
+                logging.error(f"❌ Could not load model with any RF-DETR variant")
+                self.model = None
+                return False
+            
+            self.model = loaded_model
             self.model.optimize_for_inference()
+            logging.info(f"✅ Loaded {model.name} using RF-DETR {variant_name}")
             return True
         except Exception as e:
             logging.error(f"❌ Error loading RFDETR model {model.name}: {e}")

{nedo_vision_worker_core-0.3.7 → nedo_vision_worker_core-0.3.9}/nedo_vision_worker_core/pipeline/ModelManager.py

@@ -122,16 +122,51 @@ class ModelManager:
         return False
 
     def sync_cache(self, active_model_ids: Set[str]):
-        """
-        Removes detectors from the cache if their corresponding models are no longer in the database
-        or are not being used by any active pipeline.
-        """
+        """Remove unused detectors from cache."""
         cached_ids = set(self._detector_cache.keys())
         stale_ids = cached_ids - active_model_ids
         
         for model_id in stale_ids:
-            del self._detector_cache[model_id]
+            detector = self._detector_cache.pop(model_id, None)
+            if detector:
+                self._cleanup_detector(detector)
             logging.info(f"🧹 Removed unused detector for model {model_id} from cache.")
+    
+    def _cleanup_detector(self, detector: BaseDetector):
+        """Free detector resources and GPU memory."""
+        try:
+            if hasattr(detector, 'model') and detector.model is not None:
+                # Move model to CPU if possible
+                if hasattr(detector.model, 'cpu'):
+                    try:
+                        detector.model.cpu()
+                    except Exception as e:
+                        logging.debug(f"Error moving model to CPU: {e}")
+                
+                if hasattr(detector.model, 'eval'):
+                    try:
+                        detector.model.eval()
+                    except Exception:
+                        pass
+                
+                detector.model = None
+            
+            detector.metadata = None
+            
+            # Force garbage collection and clear GPU cache
+            import gc
+            gc.collect()
+            
+            try:
+                import torch
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                    logging.debug("🧹 GPU cache cleared")
+            except ImportError:
+                pass
+                
+        except Exception as e:
+            logging.error(f"Error cleaning up detector: {e}")
 
     def clear_cache(self):
         """Clears the detector cache."""

nedo_vision_worker_core-0.3.9/nedo_vision_worker_core/pipeline/PipelineManager.py

@@ -0,0 +1,184 @@
+import logging
+import time
+import threading
+from typing import Dict
+from concurrent.futures import ThreadPoolExecutor
+from .PipelineProcessor import PipelineProcessor
+from ..streams.VideoStreamManager import VideoStreamManager
+
+class PipelineManager:
+    """Manages AI pipeline execution with thread pooling for scalability."""
+
+    def __init__(self, video_manager: VideoStreamManager, on_pipeline_stopped, max_workers=None):
+        # Auto-detect optimal worker count if not specified
+        if max_workers is None:
+            import os
+            cpu_count = os.cpu_count() or 4
+            # Reserve 2 cores for system/video streams, use rest for pipelines
+            max_workers = max(4, cpu_count - 2)
+        
+        self.max_workers = max_workers
+        self.executor = ThreadPoolExecutor(
+            max_workers=max_workers,
+            thread_name_prefix="pipeline-worker"
+        )
+        self.pipeline_futures = {}  # {pipeline_id: Future}
+        self.pipeline_metadata = {}  # {pipeline_id: metadata}
+        self.video_manager = video_manager
+        self.processors: Dict[str, PipelineProcessor] = {}  # {pipeline_id: PipelineProcessor}
+        self.running = True
+        self._stopping_pipelines = set()
+        self._stop_lock = threading.Lock()
+        self.on_pipeline_stopped = on_pipeline_stopped
+        
+        logging.info(f"🚀 PipelineManager initialized with {max_workers} worker threads")
+
+    def start_pipeline(self, pipeline, detector):
+        """Start a pipeline processing."""
+        pipeline_id = pipeline.id
+        worker_source_id = pipeline.worker_source_id
+
+        if not self.running:
+            logging.warning(f"⚠️ Attempt to start pipeline {pipeline_id} after shutdown.")
+            return
+
+        if self.is_running(pipeline_id):
+            logging.warning(f"⚠️ Pipeline {pipeline_id} is already running.")
+            return
+
+        logging.info(f"🚀 Starting Pipeline processing for pipeline: {pipeline_id} | Source: {worker_source_id} ({pipeline.name})")
+
+        # Acquire video stream
+        if not self.video_manager.acquire_stream(worker_source_id, pipeline_id):
+            logging.error(f"❌ Failed to acquire stream {worker_source_id} for pipeline {pipeline_id}")
+            return
+
+        processor = PipelineProcessor(pipeline, detector, False)
+        processor.frame_drawer.location_name = pipeline.location_name
+        self.processors[pipeline_id] = processor
+
+        active_count = len([f for f in self.pipeline_futures.values() if not f.done()])
+        logging.info(f"📋 Submitting pipeline {pipeline_id} to thread pool (active: {active_count}/{self.max_workers})")
+        
+        try:
+            # Submit to thread pool instead of creating dedicated thread
+            future = self.executor.submit(
+                self._pipeline_worker,
+                pipeline_id,
+                processor
+            )
+            
+            # Add completion callback
+            future.add_done_callback(lambda f: self._handle_pipeline_completion(pipeline_id, f))
+            
+            self.pipeline_futures[pipeline_id] = future
+            self.pipeline_metadata[pipeline_id] = pipeline
+            
+            logging.info(f"✅ Pipeline {pipeline_id} submitted to thread pool")
+
+        except Exception as e:
+            logging.error(f"❌ Failed to submit pipeline {pipeline_id} to thread pool: {e}", exc_info=True)
+            self.processors.pop(pipeline_id, None)
+            self.video_manager.release_stream(worker_source_id, pipeline_id)
+            raise
+    
+    def _pipeline_worker(self, pipeline_id: str, processor: PipelineProcessor):
+        """Worker function executed in thread pool."""
+        try:
+            logging.info(f"🏁 Pipeline {pipeline_id} worker starting...")
+            processor.process_pipeline(self.video_manager)
+        except Exception as e:
+            logging.error(f"❌ Unhandled error in pipeline {pipeline_id} worker: {e}", exc_info=True)
+        finally:
+            logging.info(f"🏁 Pipeline {pipeline_id} worker finished")
+
+    def _handle_pipeline_completion(self, pipeline_id: str, future=None):
+        """Handle cleanup when pipeline finishes."""
+        with self._stop_lock:
+            if pipeline_id in self._stopping_pipelines:
+                return
+
+        try:
+            logging.info(f"🏁 Pipeline {pipeline_id} completed execution")
+            
+            # Log any exception from the future
+            if future and not future.cancelled():
+                try:
+                    future.result(timeout=0)
+                except Exception as e:
+                    logging.error(f"Pipeline {pipeline_id} ended with exception: {e}")
+        except Exception as e:
+            logging.error(f"⚠️ Error in handling pipeline {pipeline_id} completion: {e}")
+        finally:
+            self.on_pipeline_stopped(pipeline_id)
+
+    def stop_pipeline(self, pipeline_id: str):
+        """Stop an AI processing pipeline."""
+        with self._stop_lock:
+            if pipeline_id in self._stopping_pipelines:
+                logging.debug(f"Pipeline {pipeline_id} already being stopped, skipping")
+                return
+            self._stopping_pipelines.add(pipeline_id)
+
+        try:
+            pipeline = self.pipeline_metadata.get(pipeline_id)
+            worker_source_id = pipeline.worker_source_id if pipeline else None
+
+            # Stop processor first to signal threads
+            processor = self.processors.pop(pipeline_id, None)
+            if processor:
+                processor.stop()
+
+            # Cancel future if still pending/running
+            future = self.pipeline_futures.pop(pipeline_id, None)
+            if future and not future.done():
+                logging.debug(f"Cancelling future for pipeline {pipeline_id}")
+                future.cancel()
+                
+                # Wait briefly for graceful shutdown
+                try:
+                    future.result(timeout=1.0)
+                except Exception as e:
+                    logging.debug(f"Pipeline {pipeline_id} future ended: {e}")
+
+            self.pipeline_metadata.pop(pipeline_id, None)
+
+            # Release video stream
+            if worker_source_id:
+                self.video_manager.release_stream(worker_source_id, pipeline_id)
+
+            logging.info(f"✅ Pipeline {pipeline_id} stopped successfully.")
+
+        except Exception as e:
+            logging.error(f"❌ Error during pipeline shutdown: {e}")
+        
+        finally:
+            self._stopping_pipelines.discard(pipeline_id)
+            self.on_pipeline_stopped(pipeline_id)
+
+    def get_active_pipelines(self):
+        """Returns a list of active pipeline IDs."""
+        return list(self.pipeline_metadata.keys())
+
+    def get_pipeline(self, pipeline_id):
+        """Returns the pipeline metadata."""
+        return self.pipeline_metadata.get(pipeline_id, None)
+
+    def is_running(self, pipeline_id):
+        """Check if pipeline is currently running."""
+        future = self.pipeline_futures.get(pipeline_id)
+        return future is not None and not future.done()
+
+    def shutdown(self):
+        """Shuts down the pipeline manager gracefully."""
+        logging.info("🛑 Shutting down PipelineManager...")
+        self.running = False
+
+        # Stop all pipelines
+        for pipeline_id in list(self.pipeline_futures.keys()):
+            self.stop_pipeline(pipeline_id)
+
+        # Shutdown thread pool
+        logging.info("🛑 Shutting down thread pool executor...")
+        self.executor.shutdown(wait=True)
+        logging.info("✅ PipelineManager stopped.")