nedo-vision-worker-core 0.3.6__py3-none-any.whl → 0.3.8__py3-none-any.whl

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.6"
+__version__ = "0.3.8"
 __all__ = [
     "CoreService", 
     "DetectionType", 

nedo_vision_worker_core/ai/VideoDebugger.py

@@ -2,68 +2,79 @@ import cv2
 import threading
 import time
 from collections import defaultdict
+import logging
 
-# TODO: fix timer error (because of threading)
 class VideoDebugger:
-    """Handles real-time visualization of video streams with object detections."""
+    """Real-time visualization of video streams with detections."""
 
     def __init__(self, enable_visualization=True):
-        """
-        Initializes the VideoDebugger with frame drawing and visualization capabilities.
-
-        Args:
-            enable_visualization (bool): Whether to display frames.
-        """
         self.enable_visualization = enable_visualization
-        self.windows = {}  # Tracks OpenCV windows
-        self.lock = threading.Lock()  # Thread-safe updates
+        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):
-        """
-        Displays a frame with FPS overlay.
-
-        Args:
-            pipeline_id (str/int): Identifier for the pipeline.
-            worker_source_id (str): Identifier for the worker/source.
-            frame: The frame to display.
-        """
+        """Display frame with FPS overlay."""
         if not self.enable_visualization or frame is None:
             return
 
         window_name = f"Pipeline {pipeline_id} - {worker_source_id}"
-        with self.lock:
-            if window_name not in self.fps_tracker:
-                self.fps_tracker[window_name] = {"start_time": time.time(), "frame_count": 0}
+        
+        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)
+                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)
 
-            # Display FPS on the frame
-            cv2.putText(frame, f"FPS: {fps:.2f}", (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 1)
+                cv2.putText(frame, f"FPS: {fps:.2f}", (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 1)
 
-            # Show the window
-            if window_name not in self.windows:
-                self.windows[window_name] = True  # Register window
+                if window_name not in self.windows:
+                    self.windows[window_name] = True
 
-            cv2.imshow(window_name, frame)
-
-            # Close on 'q' press
-            if cv2.waitKey(1) & 0xFF == ord('q'):
-                self.close_window(window_name)
+            # 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):
-        """Closes a specific OpenCV window."""
+        """Close specific window."""
         with self.lock:
             if window_name in self.windows:
-                cv2.destroyWindow(window_name)
+                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 close_all(self):
-        """Closes all OpenCV windows."""
+        """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:
-            for window in list(self.windows.keys()):
-                cv2.destroyWindow(window)
             self.windows.clear()
-        cv2.waitKey(1)

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/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/models/worker_source_pipeline.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Column, String
+from sqlalchemy import Column, String, DateTime
 from sqlalchemy.orm import relationship
 from ..database.DatabaseManager import Base
 
@@ -13,6 +13,7 @@ class WorkerSourcePipelineEntity(Base):
     ai_model_id = Column(String, nullable=True)
     pipeline_status_code = Column(String, nullable=False)
     location_name = Column(String, nullable=True)
+    last_preview_request_at = Column(DateTime, nullable=True)
 
     worker_source_pipeline_configs = relationship(
         "WorkerSourcePipelineConfigEntity",

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/pipeline/PipelineManager.py

@@ -1,30 +1,40 @@
 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 and video stream processing."""
-
-    def __init__(self, video_manager: VideoStreamManager, on_pipeline_stopped, max_workers=50):
+    """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.pipeline_threads = {}  # Stores Thread objects {pipeline_id: Thread}
-        self.pipeline_metadata = {}  # Stores actual pipeline data {pipeline_id: metadata}
-        self.video_manager = video_manager  # Manages video streams
-        self.processors: Dict[str, PipelineProcessor] = {}  # Stores PipelineProcessor instances per pipeline
+        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()  # Track pipelines being stopped
-        self._stop_lock = threading.Lock()  # Lock for thread-safe pipeline stopping
+        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.
-        Args:
-            pipeline: The pipeline object (contains id, worker_source_id, name, etc.)
-            detector: The detector instance to use for processing.
-        """
+        """Start a pipeline processing."""
         pipeline_id = pipeline.id
         worker_source_id = pipeline.worker_source_id
 
@@ -38,64 +48,67 @@ class PipelineManager:
 
         logging.info(f"🚀 Starting Pipeline processing for pipeline: {pipeline_id} | Source: {worker_source_id} ({pipeline.name})")
 
-        # Acquire the video stream (starts it if not already running)
+        # 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  # Store processor instance
+        self.processors[pipeline_id] = processor
 
-        active_count = len([t for t in self.pipeline_threads.values() if t.is_alive()])
-        logging.info(f"📋 Starting pipeline {pipeline_id} thread (active threads: {active_count})")
+        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:
-            # Wrap the execution to catch any early errors
-            def _safe_process_pipeline():
-                try:
-                    logging.info(f"🏁 Pipeline {pipeline_id} thread execution beginning...")
-                    processor.process_pipeline(self.video_manager)
-                except Exception as e:
-                    logging.error(f"❌ Unhandled error in pipeline {pipeline_id} thread: {e}", exc_info=True)
-                finally:
-                    # Ensure cleanup callback is called
-                    self._handle_pipeline_completion(pipeline_id)
-            
-            # Create and start thread directly
-            thread = threading.Thread(
-                target=_safe_process_pipeline,
-                name=f"pipeline-{pipeline_id[:8]}",
-                daemon=True
+            # Submit to thread pool instead of creating dedicated thread
+            future = self.executor.submit(
+                self._pipeline_worker,
+                pipeline_id,
+                processor
             )
             
-            self.pipeline_threads[pipeline_id] = thread
+            # 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"⚙️ Starting thread for pipeline {pipeline_id}")
-            thread.start()
-            logging.info(f"✅ Pipeline {pipeline_id} thread started successfully")
+            logging.info(f"✅ Pipeline {pipeline_id} submitted to thread pool")
 
         except Exception as e:
-            logging.error(f"❌ Failed to start pipeline {pipeline_id} thread: {e}", exc_info=True)
-            # Clean up on failure
+            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):
-        """
-        Handles cleanup when a pipeline finishes processing.
-        """
+    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  # If it's already being stopped manually, don't trigger again
+                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)
 
@@ -108,28 +121,29 @@ class PipelineManager:
             self._stopping_pipelines.add(pipeline_id)
 
         try:
-            # Get worker_source_id before removing metadata
             pipeline = self.pipeline_metadata.get(pipeline_id)
             worker_source_id = pipeline.worker_source_id if pipeline else None
 
-            # Stop AI processing
+            # Stop processor first to signal threads
             processor = self.processors.pop(pipeline_id, None)
             if processor:
                 processor.stop()
 
-            # Stop execution thread (thread will terminate naturally)
-            thread = self.pipeline_threads.pop(pipeline_id, None)
-            if thread and thread.is_alive():
-                # Thread is daemon, will stop when processor.running becomes False
-                logging.debug(f"Waiting for pipeline {pipeline_id} thread to terminate...")
-                thread.join(timeout=5.0)
-                if thread.is_alive():
-                    logging.warning(f"Pipeline {pipeline_id} thread did not terminate cleanly")
+            # 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}")
 
-            # Remove metadata
             self.pipeline_metadata.pop(pipeline_id, None)
 
-            # Release the video stream (stops it if no more pipelines use it)
+            # Release video stream
             if worker_source_id:
                 self.video_manager.release_stream(worker_source_id, pipeline_id)
 
@@ -147,31 +161,24 @@ class PipelineManager:
         return list(self.pipeline_metadata.keys())
 
     def get_pipeline(self, pipeline_id):
-        """Returns the actual pipeline metadata (not the Future object)."""
+        """Returns the pipeline metadata."""
         return self.pipeline_metadata.get(pipeline_id, None)
 
     def is_running(self, pipeline_id):
-        """
-        Checks if a pipeline is currently running.
-        
-        Args:
-            pipeline_id (str): The ID of the pipeline to check.
-            
-        Returns:
-            bool: True if the pipeline is running, False otherwise.
-        """
-        thread = self.pipeline_threads.get(pipeline_id)
-        return thread is not None and thread.is_alive()
+        """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
 
-        for pipeline_id in list(self.pipeline_threads.keys()):
+        # Stop all pipelines
+        for pipeline_id in list(self.pipeline_futures.keys()):
             self.stop_pipeline(pipeline_id)
 
-        logging.info("✅ PipelineManager stopped.")
-
-        self.executor.shutdown(wait=True)  # Wait for all threads to finish
+        # Shutdown thread pool
+        logging.info("🛑 Shutting down thread pool executor...")
+        self.executor.shutdown(wait=True)
         logging.info("✅ PipelineManager stopped.")

nedo_vision_worker_core/pipeline/PipelineProcessor.py

@@ -8,12 +8,14 @@ from .PipelineConfigManager import PipelineConfigManager
 from .PipelinePrepocessor import PipelinePrepocessor
 from ..repositories.WorkerSourcePipelineDebugRepository import WorkerSourcePipelineDebugRepository
 from ..repositories.WorkerSourcePipelineDetectionRepository import WorkerSourcePipelineDetectionRepository
+from ..repositories.WorkerSourcePipelineRepository import WorkerSourcePipelineRepository
 from ..streams.VideoStreamManager import VideoStreamManager
 from ..ai.VideoDebugger import VideoDebugger
 from ..ai.FrameDrawer import FrameDrawer
 from ..tracker.TrackerManager import TrackerManager
 from ..detection.BaseDetector import BaseDetector
 from ..streams.RTMPStreamer import RTMPStreamer
+from ..util.PipelinePreviewChecker import PipelinePreviewChecker
 
 
 class PipelineProcessor:
@@ -41,6 +43,10 @@ class PipelineProcessor:
         self.worker_source_id = pipeline.worker_source_id
 
         self.rtmp_streamer = None
+        self.rtmp_streaming_active = False
+        self.last_preview_check_time = 0
+        self.preview_check_interval = 5.0  # Check every 5 seconds
+        self.pipeline_repo = WorkerSourcePipelineRepository()
 
         self.detection_processor_codes = [
             PPEDetectionProcessor.code,
@@ -61,6 +67,10 @@ class PipelineProcessor:
         self.hevc_error_count = 0
         self.last_hevc_recovery = 0
         self.hevc_recovery_cooldown = 30.0  # 30 seconds between HEVC recovery attempts
+        
+        self.base_detection_interval = 1.0 / 3.0
+        self.detection_interval = self.base_detection_interval
+        self.is_fps_user_configured = False
 
     def update_config(self, pipeline):
         """Updates the pipeline configuration."""
@@ -116,7 +126,8 @@ class PipelineProcessor:
     def _update_config_internal(self):
         self.config_manager.update(self.pipeline_id)
         self.preprocessor.update(self.config_manager)
-        self.detection_interval = self._get_detection_interval()
+        self.base_detection_interval, self.is_fps_user_configured = self._get_detection_interval()
+        self.detection_interval = self.base_detection_interval
         self._update_detection_processor()
         
         # Reset failure counters on config update
@@ -148,8 +159,14 @@ class PipelineProcessor:
         if initial_frame is None:
             logging.error(f"❌ Pipeline {pipeline_id} | Source {worker_source_id}: No initial frame available. Exiting...")
             return
+        
+        # Auto-adjust FPS based on resolution when user hasn't configured FPS
+        if not self.is_fps_user_configured:
+            self.detection_interval = self._auto_adjust_detection_interval_for_resolution(initial_frame)
+            logging.info(f"📊 Pipeline {pipeline_id}: Auto-adjusted FPS to {1.0/self.detection_interval:.1f} based on {initial_frame.shape[1]}x{initial_frame.shape[0]} resolution (no user config)")
+        else:
+            logging.info(f"📊 Pipeline {pipeline_id}: Using user-configured FPS {1.0/self.detection_interval:.1f} for {initial_frame.shape[1]}x{initial_frame.shape[0]} stream")
 
-        # Start detection thread
         self.detection_thread = threading.Thread(
             target=self._detection_worker,
             name=f"detection-{pipeline_id}",
@@ -167,10 +184,6 @@ class PipelineProcessor:
                     # no frame this tick—just continue (the streamer will repeat last good frame)
                     continue
                     
-                # cv2.imshow("AA", frame)
-                # cv2.waitKey(1)
-                # continue
-                
                 # successful frame
                 self.consecutive_frame_failures = 0
                 self.last_successful_frame_time = time.time()
@@ -179,8 +192,9 @@ class PipelineProcessor:
                 # draw annotations
                 try:
                     self.frame_drawer.draw_polygons(frame)
+                    frame_to_draw = frame.copy() if self.debug_flag else frame
                     drawn_frame = self.frame_drawer.draw_frame(
-                        frame.copy(),
+                        frame_to_draw,
                         self.tracked_objects_render,
                         with_trails=True,
                         trail_length=int(max(1, 2 / self.detection_interval))
@@ -195,33 +209,49 @@ class PipelineProcessor:
                     try:
                         self.debug_repo.update_debug_entries_by_pipeline_id(
                             self.pipeline_id,
-                            self.frame_drawer.draw_frame(frame.copy(), tracked_objects_render),
+                            self.frame_drawer.draw_frame(frame, tracked_objects_render),
                             tracked_objects_render
                         )
                     except Exception as e:
                         logging.warning(f"Debug save failed: {e}")
                     self.debug_flag = False
 
-                # Push frame to RTMP stream
-                # RTMPStreamer handles its own restarts internally
-                if self.rtmp_streamer is None:
-                    try:
-                        self.rtmp_streamer = RTMPStreamer(self.pipeline_id)
-                        logging.info(f"🎬 RTMP streamer initialized for pipeline {pipeline_id}")
-                    except Exception as e:
-                        logging.error(f"❌ Failed to initialize RTMP streamer for pipeline {pipeline_id}: {e}")
-                        self.rtmp_streamer = None
+                # Check if RTMP streaming should be active based on preview requests
+                current_time = time.time()
+                if current_time - self.last_preview_check_time >= self.preview_check_interval:
+                    self._check_and_update_rtmp_streaming()
+                    self.last_preview_check_time = current_time
 
-                if self.rtmp_streamer:
-                    try:
-                        self.rtmp_streamer.push_frame(drawn_frame)
-                    except Exception as e:
-                        logging.error(f"❌ RTMP push error for pipeline {pipeline_id}: {e}")
-                        if "initialization_failed" in str(e).lower():
-                            try:
-                                self.rtmp_streamer.stop_stream()
-                            except Exception:
-                                pass
+                # Push frame to RTMP stream if preview is active
+                if self.rtmp_streaming_active:
+                    if self.rtmp_streamer is None:
+                        try:
+                            self.rtmp_streamer = RTMPStreamer(self.pipeline_id)
+                            logging.info(f"🎬 RTMP streamer initialized for pipeline {pipeline_id} (preview requested)")
+                        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:
+                        try:
+                            self.rtmp_streamer.push_frame(drawn_frame)
+                        except Exception as e:
+                            logging.error(f"❌ RTMP push error for pipeline {pipeline_id}: {e}")
+                            if "initialization_failed" in str(e).lower():
+                                try:
+                                    self.rtmp_streamer.stop_stream()
+                                except Exception:
+                                    pass
+                                self.rtmp_streamer = None
+                else:
+                    # Stop RTMP streaming if preview is no longer active
+                    if self.rtmp_streamer is not None:
+                        try:
+                            logging.info(f"🛑 Stopping RTMP streamer for pipeline {pipeline_id} (preview expired)")
+                            self.rtmp_streamer.stop_stream()
+                        except Exception as e:
+                            logging.error(f"❌ Error stopping RTMP streamer: {e}")
+                        finally:
                             self.rtmp_streamer = None
 
                 # feed detection worker with latest-only behavior
@@ -244,7 +274,9 @@ class PipelineProcessor:
                 except Exception as e:
                     logging.error(f"⚠️ Failed to render frame for pipeline {pipeline_id}: {e}")
                 
-                time.sleep(0.1)
+                # Dynamic sleep based on detection interval to reduce CPU
+                sleep_time = min(0.01, self.detection_interval / 10)
+                time.sleep(sleep_time)
 
         except Exception as e:
             logging.error(f"❌ Error in pipeline {pipeline_id}: {e}", exc_info=True)
@@ -287,6 +319,12 @@ class PipelineProcessor:
         while self.running:
             try:
                 frame = self.frame_queue.get(block=True, timeout=1)
+                
+                # Check for poison pill (None = stop signal)
+                if frame is None:
+                    logging.debug(f"Detection worker for {pipeline_id} received stop signal")
+                    break
+                
                 current_time = time.time()
 
                 # Update config periodically
@@ -298,6 +336,9 @@ class PipelineProcessor:
                 try:
                     while True:
                         newer = self.frame_queue.get_nowait()
+                        if newer is None:  # Stop signal
+                            logging.debug(f"Detection worker for {pipeline_id} received stop signal")
+                            return
                         frame = newer
                 except queue.Empty:
                     pass
@@ -483,12 +524,23 @@ class PipelineProcessor:
             return False
 
     def stop(self):
-        """Stops the Pipeline processor and cleans up resources."""
+        """Stop processor and cleanup resources."""
         if not self.running:
             return
         logging.info("🛑 Stopping PipelineProcessor...")
         self.running = False
 
+        # Wake up detection thread immediately with poison pill
+        try:
+            self.frame_queue.put_nowait(None)
+        except queue.Full:
+            try:
+                self.frame_queue.get_nowait()
+                self.frame_queue.put_nowait(None)
+            except:
+                pass
+
+        # Stop RTMP streamer
         if hasattr(self, 'rtmp_streamer') and self.rtmp_streamer:
             try:
                 self.rtmp_streamer.stop_stream()
@@ -497,6 +549,7 @@ class PipelineProcessor:
             finally:
                 self.rtmp_streamer = None
 
+        # Clear frame queue
         try:
             while True:
                 try:
@@ -506,38 +559,136 @@ class PipelineProcessor:
         except Exception as e:
             logging.error(f"Error clearing frame queue: {e}")
 
+        # Wait for detection thread (should exit quickly with poison pill)
         if self.detection_thread and self.detection_thread.is_alive():
             try:
-                self.detection_thread.join(timeout=5.0)
+                self.detection_thread.join(timeout=1.0)
                 if self.detection_thread.is_alive():
-                    logging.warning("Detection thread did not terminate cleanly")
+                    logging.warning("Detection thread did not terminate cleanly within 1s")
             except Exception as e:
                 logging.error(f"Error joining detection thread: {e}")
             finally:
                 self.detection_thread = None
 
-        self.tracked_objects_render.clear()
+        # Unload detector immediately to free GPU memory
+        if hasattr(self, 'detector') and self.detector:
+            try:
+                if hasattr(self.detector, 'model') and self.detector.model:
+                    if hasattr(self.detector.model, 'cpu'):
+                        self.detector.model.cpu()
+                    self.detector.model = None
+            except Exception as e:
+                logging.debug(f"Error clearing detector: {e}")
 
+        # Clear tracking data
+        if hasattr(self, 'tracked_objects_render'):
+            self.tracked_objects_render.clear()
+        
+        # Clear tracker state
+        if hasattr(self, 'tracker_manager') and self.tracker_manager:
+            try:
+                if hasattr(self.tracker_manager, 'track_uuid_map'):
+                    self.tracker_manager.track_uuid_map.clear()
+                if hasattr(self.tracker_manager, 'track_count_map'):
+                    self.tracker_manager.track_count_map.clear()
+                if hasattr(self.tracker_manager, 'track_attributes_presence'):
+                    self.tracker_manager.track_attributes_presence.clear()
+                if hasattr(self.tracker_manager, 'track_last_seen'):
+                    self.tracker_manager.track_last_seen.clear()
+            except Exception as e:
+                logging.error(f"Error clearing tracker state: {e}")
+
+        # Close debugger
         try:
             if hasattr(self, 'video_debugger'):
                 self.video_debugger.close_all()
         except Exception as e:
             logging.error(f"Error closing video debugger: {e}")
+        
+        # Force garbage collection
+        import gc
+        gc.collect()
 
         logging.info("✅ PipelineProcessor stopped successfully")
         
     def _get_detection_interval(self):
+        """Returns (interval, is_user_configured) tuple."""
         config = self.config_manager.get_feature_config("processing_speed")
-        fps = config.get("decimal", 1.0)
-        if fps <= 0:
-            return 1.0 / 10.0  # default 10 fps
-        return 1.0 / fps
+        fps = config.get("decimal", None)
+        
+        # Check if user explicitly configured FPS
+        is_user_configured = fps is not None
+        
+        if fps is None or fps <= 0:
+            fps = 3.0  # default 3 fps when not configured
+        
+        return 1.0 / fps, is_user_configured
+    
+    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.
+        User-configured FPS always takes precedence.
+        """
+        if frame is None:
+            return self.base_detection_interval
+        
+        height, width = frame.shape[:2]
+        total_pixels = height * width
+        
+        # Define resolution tiers
+        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}")
+        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}")
+        else:
+            # 1080p and below: Use full configured FPS
+            adjusted_interval = base_interval
+        
+        return adjusted_interval
 
     def enable_debug(self):
         self.debug_flag = True
         self.consecutive_frame_failures = 0
         self.last_successful_frame_time = time.time()
     
+    def _check_and_update_rtmp_streaming(self):
+        """
+        Check if RTMP streaming should be active based on preview requests.
+        Updates the rtmp_streaming_active flag.
+        """
+        try:
+            # Get fresh pipeline data from database
+            pipeline = self.pipeline_repo.get_worker_source_pipeline(self.pipeline_id)
+            
+            if not pipeline:
+                logging.warning(f"⚠️ Pipeline {self.pipeline_id} not found in database")
+                self.rtmp_streaming_active = False
+                return
+            
+            # Check if preview is active using the utility
+            should_stream = PipelinePreviewChecker.should_stream_rtmp(
+                pipeline.last_preview_request_at,
+                preview_window_seconds=300  # 5 minutes
+            )
+            
+            self.rtmp_streaming_active = should_stream
+            
+        except Exception as e:
+            logging.error(f"❌ Error checking preview status for pipeline {self.pipeline_id}: {e}")
+            # On error, disable streaming to be safe
+            self.rtmp_streaming_active = False
+    
     def reset_frame_failure_counters(self):
         logging.info(f"🔄 Resetting frame failure counters for pipeline {self.pipeline_id}")
         self.consecutive_frame_failures = 0

nedo_vision_worker_core/pipeline/PipelineSyncThread.py

@@ -13,7 +13,7 @@ from ..streams.VideoStreamManager import VideoStreamManager
 class PipelineSyncThread(threading.Thread):
     """Thread responsible for synchronizing worker source pipelines from the database in real-time."""
 
-    def __init__(self, video_manager: VideoStreamManager, polling_interval=5, max_workers=4):
+    def __init__(self, video_manager: VideoStreamManager, polling_interval=5, max_workers=None):
         super().__init__(daemon=True)  # Runs as a daemon
         self.video_manager = video_manager
         self.polling_interval = polling_interval

nedo_vision_worker_core/util/PipelinePreviewChecker.py

@@ -0,0 +1,50 @@
+from datetime import datetime
+
+class PipelinePreviewChecker:
+    """
+    Utility class to check if RTMP streaming should be enabled for a pipeline
+    based on the last preview request timestamp.
+    """
+    
+    @staticmethod
+    def should_stream_rtmp(last_preview_request_at, preview_window_seconds=300):
+        """
+        Check if RTMP streaming should be enabled based on the last preview request.
+        
+        Args:
+            last_preview_request_at: DateTime object or None representing the last preview request
+            preview_window_seconds: Time window in seconds to keep streaming after a request (default: 300 = 5 minutes)
+            
+        Returns:
+            bool: True if streaming should be enabled, False otherwise
+        """
+        if last_preview_request_at is None:
+            return False
+        
+        # Calculate the time difference
+        current_time = datetime.utcnow()
+        time_since_request = current_time - last_preview_request_at
+        
+        # Check if we're within the preview window
+        return time_since_request.total_seconds() <= preview_window_seconds
+    
+    @staticmethod
+    def get_remaining_preview_time(last_preview_request_at, preview_window_seconds=300):
+        """
+        Get the remaining time (in seconds) for the preview window.
+        
+        Args:
+            last_preview_request_at: DateTime object or None representing the last preview request
+            preview_window_seconds: Time window in seconds (default: 300 = 5 minutes)
+            
+        Returns:
+            int: Remaining seconds in the preview window, or 0 if expired/not requested
+        """
+        if last_preview_request_at is None:
+            return 0
+        
+        current_time = datetime.utcnow()
+        time_since_request = current_time - last_preview_request_at
+        remaining = preview_window_seconds - time_since_request.total_seconds()
+        
+        return max(0, int(remaining))

{nedo_vision_worker_core-0.3.6.dist-info → nedo_vision_worker_core-0.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedo-vision-worker-core
-Version: 0.3.6
+Version: 0.3.8
 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.6.dist-info → nedo_vision_worker_core-0.3.8.dist-info}/RECORD

@@ -1,10 +1,10 @@
-nedo_vision_worker_core/__init__.py,sha256=E4gmykhnzrU8ANXRIGP9LQG8TNbk6eAyuWqtAsFdj7Y,1924
+nedo_vision_worker_core/__init__.py,sha256=HAUgt6tA__5tRxc5EtEDSooC_CQI0Uyjp0RFJtSK754,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/core_service.py,sha256=q8-GuGW_l5l6wTWQDqc7BDdhM7zKC-mMLZ5wIHu9xV0,11628
 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
+nedo_vision_worker_core/ai/VideoDebugger.py,sha256=4BqOB_vszS4Prux1VFnZ3nGwQ3dyQOljtp5ud0XZBCU,3074
 nedo_vision_worker_core/ai/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker_core/callbacks/DetectionCallbackManager.py,sha256=Ogoco3JD_o5IMccruau1ly69bDWnsckJyVtzCw259JQ,13379
 nedo_vision_worker_core/callbacks/DetectionCallbackTypes.py,sha256=U7Qb0dCMtOHuZi_HNjapKjPqsCNM9ucHQosjHk9vPJ8,5057
@@ -14,7 +14,7 @@ nedo_vision_worker_core/config/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrF
 nedo_vision_worker_core/database/DatabaseManager.py,sha256=EDSz6auDx3i-DofHJBZdcEWyDHXqCwFB54WTBu9ExME,10314
 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/RFDETRDetector.py,sha256=3T3zTFZW0pBv9E-pSpY4JP7wI0LOTM4hxzanvrEXMcE,3093
+nedo_vision_worker_core/detection/RFDETRDetector.py,sha256=nimnCELy3FLi-6VRinw_id1pAk2jMDKrTfKINSM200k,4602
 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
@@ -53,16 +53,16 @@ nedo_vision_worker_core/models/ppe_detection_label.py,sha256=qON7a0fuDv5cK8phGH0
 nedo_vision_worker_core/models/restricted_area_violation.py,sha256=0enCi3tv15YMy3NaI6FwqhmLYHbbVX4nWTh46qKxrWc,829
 nedo_vision_worker_core/models/user.py,sha256=SnLUz2nS7j17bIP-gElMEaR-jWdnNQ0fTpRminVKY60,294
 nedo_vision_worker_core/models/worker_source.py,sha256=FB8irZ26LhCKNHBcpIIb5Mi3SoSNm9-q25VIkO5jQWg,793
-nedo_vision_worker_core/models/worker_source_pipeline.py,sha256=xCD4i9pHr8Qy5B_h1dH0Q7V7faS2lAou2UNEzx24oIw,752
+nedo_vision_worker_core/models/worker_source_pipeline.py,sha256=CGA_nz5wywsJcBPm-5kd0v_-h59f8Iu7uEeX3C91eT4,824
 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/ModelManager.py,sha256=2DoQiIdF-PAqU7nT_u6bj-DY0aT2FHb8kt24okGGCRc,7449
 nedo_vision_worker_core/pipeline/PipelineConfigManager.py,sha256=X55i9GyXcW9ylO6cj2UMAZFSxxPViacL4H4DZl60CAY,1157
-nedo_vision_worker_core/pipeline/PipelineManager.py,sha256=S3QxTcJjDhOY2O8x9c62kYXotgjV4enlCJLcziZEIh8,7589
+nedo_vision_worker_core/pipeline/PipelineManager.py,sha256=3I9UBJu_rRfTEctwj8i4hO4MHjpBtYpfh-rIi64qgEw,7638
 nedo_vision_worker_core/pipeline/PipelinePrepocessor.py,sha256=cCiVSHHqsKCtKYURdYoEjHJX2GnT6zd8kQ6ZukjQ3V0,1271
-nedo_vision_worker_core/pipeline/PipelineProcessor.py,sha256=KMdFDvQO2yI9NxjNDwRQU07St1Y01QgM97tgNuyelw0,26766
-nedo_vision_worker_core/pipeline/PipelineSyncThread.py,sha256=2tIqheE2BG-DAEqUgq9i4blz0vQWmnYu8MgHPLJkg3g,8704
+nedo_vision_worker_core/pipeline/PipelineProcessor.py,sha256=9gQ6AVOD_cC-c9VLqJ8WwaDb8HZNkAOT35Op0nHDROs,34194
+nedo_vision_worker_core/pipeline/PipelineSyncThread.py,sha256=HkW6wj0eDr6M1K3Y25IlB2V6tpIZsKA34AM49AXvcQk,8707
 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
@@ -94,11 +94,12 @@ 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/PipelinePreviewChecker.py,sha256=XxlSMlrDlRrzfV8_Y--40Xfk5N7FjGgkKHth3KKCZzU,1963
 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.6.dist-info/METADATA,sha256=bGu8iMZGYWUU3zPPN23EwAZenJNJlayPcGzE-AT6sl0,14412
-nedo_vision_worker_core-0.3.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nedo_vision_worker_core-0.3.6.dist-info/entry_points.txt,sha256=pIPafsvPnBw-fpBKBmc1NQCQ6PQY3ad8mZ6mn8_p5FI,70
-nedo_vision_worker_core-0.3.6.dist-info/top_level.txt,sha256=y8kusXjVYqtG8MSHYWTrk8bRrvjOrphKXYyzu943TTQ,24
-nedo_vision_worker_core-0.3.6.dist-info/RECORD,,
+nedo_vision_worker_core-0.3.8.dist-info/METADATA,sha256=uClzBEF9GttUKm4thh8BpzA7VEhVBeZ8M6Yf1bGFl10,14412
+nedo_vision_worker_core-0.3.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nedo_vision_worker_core-0.3.8.dist-info/entry_points.txt,sha256=pIPafsvPnBw-fpBKBmc1NQCQ6PQY3ad8mZ6mn8_p5FI,70
+nedo_vision_worker_core-0.3.8.dist-info/top_level.txt,sha256=y8kusXjVYqtG8MSHYWTrk8bRrvjOrphKXYyzu943TTQ,24
+nedo_vision_worker_core-0.3.8.dist-info/RECORD,,