nedo-vision-worker-core 0.4.0__tar.gz → 0.4.9__tar.gz

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.9}/PKG-INFO

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

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.9}/nedo_vision_worker_core/__init__.py

@@ -7,10 +7,10 @@ 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.4.0"
+__version__ = "0.4.9"
 __all__ = [
     "CoreService", 
-    "DetectionType", 
+    "DetectionType",
     "CallbackTrigger", 
     "DetectionData",
     "IntervalMetadata",

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.9}/nedo_vision_worker_core/pipeline/ModelManager.py

@@ -12,19 +12,15 @@ class ModelManager:
     """Manages loading and caching of AI models to avoid redundant loads."""
 
     def __init__(self):
-        self._detector_cache: Dict[str, BaseDetector] = {}
+        # Cache disabled to prevent shared state issues
+        # self._detector_cache: Dict[str, BaseDetector] = {}
         self._model_repo = AIModelRepository()
-        logging.info("🤖 ModelManager initialized.")
+        logging.info("🤖 ModelManager initialized (Cache Disabled).")
 
     def get_detector(self, model_id: str) -> Optional[BaseDetector]:
         """
         Retrieves a detector by its model ID.
-
-        This method implements a lazy-loading and cache-validation strategy:
-        1. It fetches the latest model metadata from the database.
-        2. If a detector is already cached, it validates its metadata against the DB version.
-        3. If the cached version is stale (e.g., version or classes changed), it's evicted.
-        4. If no detector is cached or the cache was stale, it loads the detector on-demand.
+        ALWAYS loads a new instance (Cache Disabled).
         """
         if not model_id:
             return None
@@ -32,32 +28,14 @@ class ModelManager:
         # 1. Fetch the current model state from the database
         db_model: AIModelEntity = self._model_repo.get_model(model_id)
         if not db_model:
-            # If the model doesn't exist in DB, ensure it's not in cache either
-            if model_id in self._detector_cache:
-                logging.info(f"🧹 Removing detector for deleted model {model_id} from cache.")
-                del self._detector_cache[model_id]
             return None
 
-        # 2. Check if a detector is cached
-        if model_id in self._detector_cache:
-            cached_detector = self._detector_cache[model_id]
-            
-            # 3. Check if the cached version is stale
-            if self._has_metadata_changed(cached_detector.metadata, db_model):
-                logging.info(f"Reloading detector for model {model_id} due to metadata changes.")
-                del self._detector_cache[model_id]
-                # Fall through to load the new version
-            else:
-                # Cache is fresh, return it
-                logging.debug(f"🧠 Detector for model {model_id} found in cache and is fresh.")
-                return cached_detector
-
-        # 4. If not cached or was stale, load it now
-        return self._load_and_cache_detector(model_id, db_model)
+        # Always load new detector
+        return self._load_detector(model_id, db_model)
 
-    def _load_and_cache_detector(self, model_id: str, db_model: AIModelEntity) -> Optional[BaseDetector]:
-        """Creates a detector from a DB model entity and caches it."""
-        logging.info(f"🔄 Loading model {model_id} (version: {db_model.version}) from database to create detector...")
+    def _load_detector(self, model_id: str, db_model: AIModelEntity) -> Optional[BaseDetector]:
+        """Creates a detector from a DB model entity."""
+        logging.info(f"🔄 Loading model {model_id} (version: {db_model.version}) from database...")
 
         # Check model readiness before attempting to load
         if not db_model.is_ready_for_use():
@@ -80,8 +58,7 @@ class ModelManager:
                 raise ValueError(f"Unsupported model type: {detector_type}")
 
             if detector and detector.model is not None:
-                self._detector_cache[model_id] = detector
-                logging.info(f"✅ Detector for model {model_id} loaded and cached successfully.")
+                logging.info(f"✅ Detector for model {model_id} loaded successfully.")
                 return detector
             else:
                 logging.error(f"❌ Failed to load detector for model: {db_model.name}")
@@ -91,7 +68,11 @@ class ModelManager:
             logging.error(f"❌ Error creating detector for model {db_model.name}: {e}")
             return None
 
-    def _has_metadata_changed(self, cached_model: AIModelEntity, db_model: AIModelEntity) -> bool:
+    def get_model_metadata(self, model_id: str) -> Optional[AIModelEntity]:
+        """Retrieves model metadata without loading the detector."""
+        return self._model_repo.get_model(model_id)
+
+    def has_metadata_changed(self, cached_model: AIModelEntity, db_model: AIModelEntity) -> bool:
         """Check if critical model metadata has changed."""
         if cached_model.version != db_model.version:
             logging.info(
@@ -123,14 +104,8 @@ class ModelManager:
 
     def sync_cache(self, active_model_ids: Set[str]):
         """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:
-            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.")
+        # Cache is disabled, so no sync needed.
+        pass
     
     def _cleanup_detector(self, detector: BaseDetector):
         """Free detector resources and GPU memory."""
@@ -170,5 +145,5 @@ class ModelManager:
 
     def clear_cache(self):
         """Clears the detector cache."""
-        logging.info("🧹 Clearing all detectors from cache.")
-        self._detector_cache.clear()
+        logging.info("🧹 Clearing all detectors from cache (No-op as cache is disabled).")
+        # self._detector_cache.clear()

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.9}/nedo_vision_worker_core/pipeline/PipelineManager.py

@@ -31,6 +31,11 @@ class PipelineManager:
         self._stop_lock = threading.Lock()
         self.on_pipeline_stopped = on_pipeline_stopped
         
+        # Stagger pipeline startup to reduce CPU spikes
+        self._last_pipeline_start = 0
+        self._pipeline_start_delay = 1.0  # 1 second between pipeline starts
+        self._start_lock = threading.Lock()
+        
         logging.info(f"🚀 PipelineManager initialized with {max_workers} worker threads")
 
     def start_pipeline(self, pipeline, detector):
@@ -46,6 +51,15 @@ class PipelineManager:
             logging.warning(f"⚠️ Pipeline {pipeline_id} is already running.")
             return
 
+        # Stagger pipeline starts to reduce CPU spikes
+        with self._start_lock:
+            time_since_last_start = time.time() - self._last_pipeline_start
+            if time_since_last_start < self._pipeline_start_delay:
+                delay = self._pipeline_start_delay - time_since_last_start
+                logging.info(f"⏳ Staggering pipeline {pipeline_id} start by {delay:.2f}s to reduce CPU spike")
+                time.sleep(delay)
+            self._last_pipeline_start = time.time()
+
         logging.info(f"🚀 Starting Pipeline processing for pipeline: {pipeline_id} | Source: {worker_source_id} ({pipeline.name})")
 
         # Acquire video stream

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.9}/nedo_vision_worker_core/pipeline/PipelinePrepocessor.py

@@ -37,4 +37,9 @@ class PipelinePrepocessor:
         for det, bbox in zip(detections, bboxes):
             det["bbox"] = bbox
 
+        return detections
+
+    def filter_detections(self, detections: list, dimension: Tuple[int, int]) -> list:
+        for preprocessor in reversed(self.preprocessors):
+            detections = preprocessor.filter_detections(detections, dimension)
         return detections

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.9}/nedo_vision_worker_core/pipeline/PipelineProcessor.py

@@ -47,6 +47,10 @@ class PipelineProcessor:
         self.last_preview_check_time = 0
         self.preview_check_interval = 10.0  # Check every 10 seconds (reduced from 5s to save CPU)
         self.pipeline_repo = WorkerSourcePipelineRepository()
+        
+        # RTMP frame rate limiting to reduce CPU
+        self.last_rtmp_frame_time = 0
+        self.rtmp_frame_interval = 1.0 / 25.0  # 25 FPS for RTMP (matching render FPS)
 
         self.detection_processor_codes = [
             PPEDetectionProcessor.code,
@@ -71,6 +75,7 @@ class PipelineProcessor:
         self.base_detection_interval = 1.0 / 3.0
         self.detection_interval = self.base_detection_interval
         self.is_fps_user_configured = False
+        self.fps_resolution_modifier = 1.0
 
     def update_config(self, pipeline):
         """Updates the pipeline configuration."""
@@ -127,7 +132,13 @@ class PipelineProcessor:
         self.config_manager.update(self.pipeline_id)
         self.preprocessor.update(self.config_manager)
         self.base_detection_interval, self.is_fps_user_configured = self._get_detection_interval()
-        self.detection_interval = self.base_detection_interval
+        
+        if self.is_fps_user_configured:
+            self.detection_interval = self.base_detection_interval
+            self.fps_resolution_modifier = 1.0
+        else:
+            self.detection_interval = self.base_detection_interval * self.fps_resolution_modifier
+
         self._update_detection_processor()
         
         # Reset failure counters on config update
@@ -198,10 +209,15 @@ class PipelineProcessor:
                 if loop_start - last_preview_check >= self.preview_check_interval:
                     self._check_and_update_rtmp_streaming()
                     last_preview_check = loop_start
-
-                should_draw = self.rtmp_streaming_active or self.debug_flag
                 
-                if should_draw:
+                # For RTMP, also check if it's time to send a frame (rate limiting)
+                should_draw_for_rtmp = (
+                    self.rtmp_streaming_active and 
+                    self.rtmp_streamer is not None and
+                    (loop_start - self.last_rtmp_frame_time >= self.rtmp_frame_interval)
+                )
+                
+                if should_draw_for_rtmp or self.debug_flag:
                     try:
                         frame_to_draw = frame.copy()
                         self.frame_drawer.draw_polygons(frame_to_draw)
@@ -215,7 +231,7 @@ class PipelineProcessor:
                         logging.error(f"❌ Draw failed, using raw frame: {e}")
                         drawn_frame = frame
                 else:
-                    drawn_frame = frame
+                    drawn_frame = None  # Don't waste CPU drawing if not needed
 
                 if self.debug_flag:
                     tracked_objects_render = self._process_frame(frame)
@@ -235,13 +251,16 @@ class PipelineProcessor:
                         try:
                             self.rtmp_streamer = RTMPStreamer(self.pipeline_id)
                             logging.info(f"🎬 RTMP streamer initialized for pipeline {pipeline_id} (preview requested)")
+                            self.last_rtmp_frame_time = 0  # Reset frame time on new stream
                         except Exception as e:
                             logging.error(f"❌ Failed to initialize RTMP streamer for pipeline {pipeline_id}: {e}")
                             self.rtmp_streamer = None
 
-                    if self.rtmp_streamer:
+                    if self.rtmp_streamer and drawn_frame is not None:
+                        # Frame already rate-limited by drawing logic above
                         try:
                             self.rtmp_streamer.push_frame(drawn_frame)
+                            self.last_rtmp_frame_time = loop_start
                         except Exception as e:
                             logging.error(f"❌ RTMP push error for pipeline {pipeline_id}: {e}")
                             if "initialization_failed" in str(e).lower():
@@ -259,9 +278,10 @@ class PipelineProcessor:
                     finally:
                         self.rtmp_streamer = None
 
-                # Simplified queue feeding - avoid expensive try-except
-                if not self.frame_queue.full():
-                    self.frame_queue.put_nowait(frame)
+                # Only feed frames to detection queue if detection processor is active
+                if self.detection_processor is not None:
+                    if not self.frame_queue.full():
+                        self.frame_queue.put_nowait(frame)
                 
                 loop_elapsed = time.time() - loop_start
                 sleep_time = max(0.001, target_frame_time - loop_elapsed)
@@ -290,6 +310,7 @@ class PipelineProcessor:
             detections = self.detector.detect_objects(processed_frame, self.threshold, class_thresholds)
         
         detections = self.preprocessor.revert_detections_bboxes(detections, dimension)
+        detections = self.preprocessor.filter_detections(detections, dimension)
         
         if self.detection_processor:
             matched_results = self.detection_processor.process(detections, dimension)
@@ -307,7 +328,13 @@ class PipelineProcessor:
 
         while self.running:
             try:
-                frame = self.frame_queue.get(block=True, timeout=1)
+                # Calculate how long to wait for next detection
+                current_time = time.time()
+                time_since_last_detection = current_time - last_detection_time
+                time_until_next_detection = max(0.1, self.detection_interval - time_since_last_detection)
+                
+                # Wait for frame with timeout aligned to detection interval
+                frame = self.frame_queue.get(block=True, timeout=time_until_next_detection)
                 
                 # Check for poison pill (None = stop signal)
                 if frame is None:
@@ -332,9 +359,14 @@ class PipelineProcessor:
                 except queue.Empty:
                     pass
 
-                # Respect detection interval
+                # Respect detection interval - skip if too soon
                 if (current_time - last_detection_time) < self.detection_interval:
+                    # Sleep the remaining time instead of busy-waiting
+                    remaining_time = self.detection_interval - (current_time - last_detection_time)
+                    if remaining_time > 0.01:
+                        time.sleep(remaining_time)
                     continue
+                
                 last_detection_time = current_time
 
                 if self.detection_processor is None or frame is None or frame.size == 0:
@@ -363,6 +395,7 @@ class PipelineProcessor:
                     )
 
             except queue.Empty:
+                # Timeout occurred - this is normal, just continue to next iteration
                 pass
             except Exception as e:
                 logging.error(f"❌ Error in detection thread for pipeline {pipeline_id}: {e}", exc_info=True)
@@ -602,7 +635,7 @@ class PipelineProcessor:
         
     def _get_detection_interval(self):
         """Returns (interval, is_user_configured) tuple."""
-        config = self.config_manager.get_feature_config("processing_speed")
+        config = self.config_manager.get_feature_config("processing_sped")
         fps = config.get("decimal", None)
         
         # Check if user explicitly configured FPS
@@ -616,7 +649,7 @@ class PipelineProcessor:
     def _auto_adjust_detection_interval_for_resolution(self, frame):
         """
         Auto-adjust detection interval based on frame resolution.
-        Automatically applies when user hasn't configured processing_speed FPS.
+        Automatically applies when user hasn't configured processing_sped FPS.
         User-configured FPS always takes precedence.
         """
         if frame is None:
@@ -629,22 +662,20 @@ class PipelineProcessor:
         PIXELS_4K = 3840 * 2160  # ~8.3M pixels
         PIXELS_2K = 2560 * 1440  # ~3.7M pixels
         
-        base_interval = self.base_detection_interval
-        
         # Adjust based on resolution
         if total_pixels >= PIXELS_4K:
             # 4K: Reduce FPS by 50% (double the interval)
-            adjusted_interval = base_interval * 2.0
-            logging.debug(f"📊 4K stream detected ({width}x{height}): FPS reduced to {1.0/adjusted_interval:.1f}")
+            self.fps_resolution_modifier = 2.0
+            logging.debug(f"📊 4K stream detected ({width}x{height}): FPS reduced to {1.0/(self.base_detection_interval * 2.0):.1f}")
         elif total_pixels >= PIXELS_2K:
             # 2K: Reduce FPS by 25% (increase interval by 1.33x)
-            adjusted_interval = base_interval * 1.33
-            logging.debug(f"📊 2K stream detected ({width}x{height}): FPS reduced to {1.0/adjusted_interval:.1f}")
+            self.fps_resolution_modifier = 1.33
+            logging.debug(f"📊 2K stream detected ({width}x{height}): FPS reduced to {1.0/(self.base_detection_interval * 1.33):.1f}")
         else:
             # 1080p and below: Use full configured FPS
-            adjusted_interval = base_interval
+            self.fps_resolution_modifier = 1.0
         
-        return adjusted_interval
+        return self.base_detection_interval * self.fps_resolution_modifier
 
     def enable_debug(self):
         self.debug_flag = True

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.9}/nedo_vision_worker_core/pipeline/PipelineSyncThread.py

@@ -5,6 +5,7 @@ import threading
 from typing import Dict, Set, Optional
 from ..repositories.WorkerSourcePipelineDebugRepository import WorkerSourcePipelineDebugRepository
 from ..repositories.WorkerSourcePipelineRepository import WorkerSourcePipelineRepository
+from ..repositories.WorkerSourceRepository import WorkerSourceRepository
 from .PipelineManager import PipelineManager
 from .ModelManager import ModelManager
 from ..streams.VideoStreamManager import VideoStreamManager
@@ -19,6 +20,7 @@ class PipelineSyncThread(threading.Thread):
         self.polling_interval = polling_interval
         self.pipeline_repo = WorkerSourcePipelineRepository()
         self.debug_repo = WorkerSourcePipelineDebugRepository()
+        self.source_repo = WorkerSourceRepository()
         self.model_manager = ModelManager()
         self.running = True
         self.pipeline_manager = PipelineManager(video_manager, self.on_pipeline_stopped, max_workers)
@@ -82,6 +84,11 @@ class PipelineSyncThread(threading.Thread):
                 pipeline.pipeline_status_code = 'run'
 
             if pipeline.pipeline_status_code == 'run':
+                # Check if source is connected before starting pipeline
+                if not self.source_repo.is_source_connected(pipeline.worker_source_id):
+                    logging.warning(f"⚠️ Skipping pipeline {pid} ({pipeline.name}): Source {pipeline.worker_source_id} is disconnected")
+                    continue
+                
                 detector = self.model_manager.get_detector(pipeline.ai_model_id)
                 
                 if not detector and pipeline.ai_model_id:
@@ -135,17 +142,33 @@ class PipelineSyncThread(threading.Thread):
 
         # At this point, we know db_pipeline.pipeline_status_code == 'run' (checked in caller)
         # Check for significant changes that require a restart
-        db_detector = self.model_manager.get_detector(db_pipeline.ai_model_id)
-
-        requires_restart = any([
-            db_pipeline.ai_model_id != processor._pipeline.ai_model_id,
-            db_pipeline.worker_source_id != processor._pipeline.worker_source_id,
-            local_detector != db_detector
-        ])
+        
+        requires_restart = False
+        
+        if db_pipeline.ai_model_id != processor._pipeline.ai_model_id:
+            requires_restart = True
+        elif db_pipeline.worker_source_id != processor._pipeline.worker_source_id:
+            requires_restart = True
+        else:
+            # Check metadata changes without loading detector
+            db_model_metadata = self.model_manager.get_model_metadata(db_pipeline.ai_model_id)
+            if local_detector and db_model_metadata:
+                if self.model_manager.has_metadata_changed(local_detector.metadata, db_model_metadata):
+                    requires_restart = True
+            elif (local_detector is None) != (db_model_metadata is None):
+                requires_restart = True
 
         if requires_restart:
+            # Check if source is connected before restarting
+            if not self.source_repo.is_source_connected(db_pipeline.worker_source_id):
+                logging.warning(f"⚠️ Cannot restart pipeline {pid}: Source {db_pipeline.worker_source_id} is disconnected")
+                return
+            
             logging.info(f"🔄 Restarting pipeline due to significant changes: {pid}")
             self.pipeline_manager.stop_pipeline(pid)
+            
+            # Load detector ONLY when restarting
+            db_detector = self.model_manager.get_detector(db_pipeline.ai_model_id)
             self.pipeline_manager.start_pipeline(db_pipeline, db_detector)
         else:
             # Update config for minor changes that don't require restart

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.9}/nedo_vision_worker_core/preprocessing/ImageRoi.py

@@ -11,7 +11,7 @@ class ImageRoi(Preprocessor):
         self.is_enabled = False
         self.normalized_points = []
 
-    def _get_roi_points(self, config: PipelineConfigManager) -> float:
+    def _get_roi_points(self, config: PipelineConfigManager) -> list:
         if not self.is_enabled:
             return []
         
@@ -21,12 +21,22 @@ class ImageRoi(Preprocessor):
         self.is_enabled = config.is_feature_enabled(self.code)
         self.normalized_points = self._get_roi_points(config)
 
+    def _get_scaled_points(self, width: int, height: int) -> list:
+        points = []
+        for p in self.normalized_points:
+            x = int(p["x"] * width)
+            y = int(p["y"] * height)
+            x = max(0, min(x, width))
+            y = max(0, min(y, height))
+            points.append((x, y))
+        return points
+
     def apply(self, image: np.ndarray) -> np.ndarray:
         if not self.is_enabled or len(self.normalized_points) < 4:
             return image
         
         height, width = image.shape[:2]
-        points = [(int(p["x"] * width), int(p["y"] * height)) for p in self.normalized_points]
+        points = self._get_scaled_points(width, height)
         x_coords = [p[0] for p in points]
         y_coords = [p[1] for p in points]
 
@@ -35,15 +45,15 @@ class ImageRoi(Preprocessor):
         roi_width = max(x_coords) - roi_x + 1 
         roi_height = max(y_coords) - roi_y + 1 
 
-        cropped = image[roi_y:roi_y+roi_height, roi_x:roi_x+roi_width].copy()
-        mask = np.zeros(cropped.shape[:2], dtype=np.uint8)
-
-        offset_points = [(x - roi_x, y - roi_y) for x, y in points]
-        points_np = np.array(offset_points, dtype=np.int32).reshape((-1, 1, 2))
+        if roi_width <= 0 or roi_height <= 0:
+            return image
 
-        cv2.fillPoly(mask, [points_np], 255)
+        cropped = image[roi_y:roi_y+roi_height, roi_x:roi_x+roi_width].copy()
+        
+        if cropped.size == 0:
+            return image
 
-        return cv2.bitwise_and(cropped, cropped, mask=mask)
+        return cropped
     
 
     def revert_bboxes(self, bboxes: np.ndarray, dimension: Tuple[int, int]) -> np.ndarray:
@@ -51,11 +61,33 @@ class ImageRoi(Preprocessor):
             return bboxes
 
         height, width = dimension
-        points = [(int(p["x"] * width), int(p["y"] * height)) for p in self.normalized_points]
+        points = self._get_scaled_points(width, height)
         x_coords = [p[0] for p in points]
         y_coords = [p[1] for p in points]
 
         roi_x = min(x_coords)
         roi_y = min(y_coords)
 
-        return bboxes + np.array([roi_x, roi_y, roi_x, roi_y])
+        return bboxes + np.array([roi_x, roi_y, roi_x, roi_y])
+    
+    def filter_detections(self, detections: list, dimension: Tuple[int, int]) -> list:
+        if not self.is_enabled or len(self.normalized_points) < 4:
+            return detections
+
+        height, width = dimension
+        points = self._get_scaled_points(width, height)
+        points_np = np.array(points, dtype=np.int32).reshape((-1, 1, 2))
+
+        filtered_detections = []
+        for det in detections:
+            bbox = det["bbox"]
+            # bbox is [x1, y1, x2, y2]
+            center_x = (bbox[0] + bbox[2]) / 2
+            center_y = (bbox[1] + bbox[3]) / 2
+            
+            # Measure distance. If >= 0, it's inside or on edge.
+            result = cv2.pointPolygonTest(points_np, (center_x, center_y), False)
+            if result >= 0:
+                filtered_detections.append(det)
+        
+        return filtered_detections

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.9}/nedo_vision_worker_core/preprocessing/Preprocessor.py

@@ -13,4 +13,7 @@ class Preprocessor(ABC):
         pass
     @abstractmethod
     def revert_bboxes(self, bboxes: np.ndarray, dimension: Tuple[int, int]) -> np.ndarray:
-        pass
+        pass
+
+    def filter_detections(self, detections: list, dimension: Tuple[int, int]) -> list:
+        return detections

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.9}/nedo_vision_worker_core/repositories/WorkerSourcePipelineDetectionRepository.py

@@ -18,12 +18,14 @@ class WorkerSourcePipelineDetectionRepository(BaseRepository):
     def save_detection(self, pipeline_id: int, frame, tracked_objects, frame_drawer: FrameDrawer):
         """
         Save detection data that need to be sent to database.
+        Only saves if there are violations detected.
         """
         now = datetime.now(timezone.utc)
         current_datetime = now.strftime("%Y%m%d_%H%M%S")
 
         frame_drawer.draw_polygons(frame)
         filtered_objects = []
+        has_violations = False
 
         for tracked_obj in tracked_objects:
             attributes = tracked_obj["attributes"]
@@ -34,9 +36,17 @@ class WorkerSourcePipelineDetectionRepository(BaseRepository):
             obj = tracked_obj.copy()
             obj["attributes"] = [attr for attr in attributes if attr.get("count", 0) >= 5]
 
+            # Check if any attribute is a violation
+            for attr in obj["attributes"]:
+                attr_label = attr.get("label", "")
+                if attr_label in frame_drawer.violation_labels:
+                    has_violations = True
+                    break
+
             filtered_objects.append(obj)
 
-        if not filtered_objects:
+        # Only save and trigger webhook/MQTT if there are actual violations
+        if not filtered_objects or not has_violations:
             return
 
         drawn_frame = frame_drawer.draw_frame(frame.copy(), filtered_objects)
@@ -64,7 +74,5 @@ class WorkerSourcePipelineDetectionRepository(BaseRepository):
                 )
                 session.add(new_detection)
                 session.flush()
-                # Commit happens automatically via context manager
-                print(f"✅ Inserted detection data for pipeline {pipeline_id}")
         except Exception as e:
             print(f"❌ Database error while saving detection: {e}")

nedo_vision_worker_core-0.4.9/nedo_vision_worker_core/repositories/WorkerSourceRepository.py

@@ -0,0 +1,56 @@
+from .BaseRepository import BaseRepository
+from ..models.worker_source import WorkerSourceEntity
+
+
+class WorkerSourceRepository(BaseRepository):
+    def __init__(self):
+        super().__init__(db_name="config")
+
+    def get_worker_sources(self):
+        """
+        Fetch all worker sources from the local database in a single query.
+
+        Returns:
+            list: A list of WorkerSourceEntity records.
+        """
+        with self._get_session() as session:
+            session.expire_all()
+            sources = session.query(WorkerSourceEntity).all()
+            for source in sources:
+                session.expunge(source)
+            return sources
+    
+    def get_worker_source(self, source_id: str):
+        """
+        Fetch a single worker source by ID.
+        
+        Args:
+            source_id (str): The worker source ID
+            
+        Returns:
+            WorkerSourceEntity: The worker source entity or None if not found
+        """
+        with self._get_session() as session:
+            session.expire_all()
+            source = session.query(WorkerSourceEntity).filter(
+                WorkerSourceEntity.id == source_id
+            ).first()
+            if source:
+                session.expunge(source)
+            return source
+    
+    def is_source_connected(self, source_id: str) -> bool:
+        """
+        Check if a worker source is connected.
+        
+        Args:
+            source_id (str): The worker source ID
+            
+        Returns:
+            bool: True if source is connected, False otherwise
+        """
+        source = self.get_worker_source(source_id)
+        if not source:
+            return False
+        
+        return source.status_code == "connected" if source.status_code else False