nedo-vision-worker 1.2.6__py3-none-any.whl → 1.2.8__py3-none-any.whl

nedo_vision_worker/__init__.py

@@ -6,5 +6,5 @@ A library for running worker agents in the Nedo Vision platform.
 
 from .worker_service import WorkerService
 
-__version__ = "1.2.6"
+__version__ = "1.2.8"
 __all__ = ["WorkerService"] 

nedo_vision_worker/database/DatabaseManager.py

@@ -104,7 +104,23 @@ class DatabaseManager:
         # Initialize engines and session factories for each database
         for name, path in DB_PATHS.items():
             path.parent.mkdir(parents=True, exist_ok=True)  # Ensure directory exists
-            engine = create_engine(f"sqlite:///{path.as_posix()}")
+            
+            # Configure connection pool for multi-threaded usage
+            # pool_size: Max connections to keep open
+            # max_overflow: Additional connections that can be created temporarily
+            # pool_pre_ping: Test connections before using (prevents stale connections)
+            # pool_recycle: Recycle connections after N seconds (prevents long-lived stale connections)
+            engine = create_engine(
+                f"sqlite:///{path.as_posix()}",
+                pool_size=20,          # Base pool size for persistent connections
+                max_overflow=30,       # Allow up to 30 additional temporary connections
+                pool_pre_ping=True,    # Verify connection health before use
+                pool_recycle=3600,     # Recycle connections after 1 hour
+                connect_args={
+                    "check_same_thread": False,  # Required for SQLite with multiple threads
+                    "timeout": 30.0              # Connection timeout
+                }
+            )
             ENGINES[name] = engine
             SESSION_FACTORIES[name] = scoped_session(sessionmaker(bind=engine))  # Use scoped sessions
             DatabaseManager.synchronize(name)

nedo_vision_worker/initializer/AppInitializer.py

@@ -76,3 +76,63 @@ class AppInitializer:
             logging.error(f"Grpc Error: {ge}")
         except Exception as e:
             logging.error(f"Unexpected error during initialization: {e}")
+
+    @staticmethod
+    def update_connection_info(server_host: str, server_port: int, token: str):
+        """
+        Fetch and update connection information (RabbitMQ credentials) from the server.
+        This should be called on startup to ensure credentials are up-to-date.
+        
+        Args:
+            server_host: The server hostname or IP address
+            server_port: The gRPC server port
+            token: Authentication token for the worker
+            
+        Returns:
+            bool: True if update was successful, False otherwise
+        """
+        try:
+            # Validate server host
+            AppInitializer.validate_server_host(server_host)
+
+            # Get connection info using the ConnectionInfoClient
+            connection_client = ConnectionInfoClient(server_host, server_port, token)
+            connection_result = connection_client.get_connection_info()
+
+            if not connection_result["success"]:
+                logging.error(f"Failed to fetch connection info: {connection_result['message']}")
+                return False
+
+            # Check if any RabbitMQ credentials have changed
+            current_config = ConfigurationManager.get_all_configs()
+            config_updated = False
+            
+            rabbitmq_fields = {
+                'rabbitmq_host': connection_result['rabbitmq_host'],
+                'rabbitmq_port': str(connection_result['rabbitmq_port']),
+                'rabbitmq_username': connection_result['rabbitmq_username'],
+                'rabbitmq_password': connection_result['rabbitmq_password']
+            }
+            
+            for field, new_value in rabbitmq_fields.items():
+                if current_config.get(field) != new_value:
+                    ConfigurationManager.set_config(field, new_value)
+                    config_updated = True
+                    logging.info(f"✅ [APP] Updated {field}")
+            
+            if config_updated:
+                logging.info("✅ [APP] RabbitMQ connection info updated successfully")
+            else:
+                logging.info("✅ [APP] RabbitMQ connection info is up-to-date")
+            
+            return True
+        
+        except ValueError as ve:
+            logging.error(f"Validation error: {ve}")
+            return False
+        except grpc.RpcError as ge:
+            logging.error(f"gRPC Error: {ge}")
+            return False
+        except Exception as e:
+            logging.error(f"Unexpected error updating connection info: {e}")
+            return False

nedo_vision_worker/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/services/DirectDeviceToRTMPStreamer.py

@@ -8,6 +8,7 @@ import cv2
 import os
 from .VideoSharingDaemon import VideoSharingClient
 from ..database.DatabaseManager import get_storage_path
+from ..util.EncoderSelector import EncoderSelector
 
 
 class DirectDeviceToRTMPStreamer:
@@ -68,6 +69,10 @@ class DirectDeviceToRTMPStreamer:
 
     def _start_ffmpeg_stream(self):
         """Starts an FFmpeg process to stream frames to the RTMP server silently."""
+        # Get optimal encoder for hardware
+        encoder_args, encoder_name = EncoderSelector.get_encoder_args()
+        logging.info(f"🎬 [APP] Using encoder: {encoder_name}")
+        
         ffmpeg_command = [
             "ffmpeg",
             "-y",
@@ -79,16 +84,17 @@ class DirectDeviceToRTMPStreamer:
             "-video_size", f"{self.width}x{self.height}",
             "-framerate", str(self.fps),
             "-i", "-",
-            "-c:v", "libx264",
-            "-preset", "ultrafast",
-            "-tune", "zerolatency",
+            
+            # Video encoding with optimal encoder
+            *encoder_args,
             "-b:v", self.bitrate,
-            # Disable Audio (Avoid unnecessary encoding overhead)
-            "-an",
             "-maxrate", "2500k",
             "-bufsize", "5000k",
+            
+            # Disable Audio
+            "-an",
+            
             "-f", "flv",
-            # Remove duration limit - let application control duration
             self.rtmp_url,
         ]
 

nedo_vision_worker/services/FileToRTMPServer.py

@@ -1,6 +1,7 @@
 import subprocess
 import logging
 import os
+from ..util.EncoderSelector import EncoderSelector
 
 class FileToRTMPStreamer:
     def __init__(self, video_path, rtmp_url, stream_key, fps=30, resolution="1280x720", loop=False):
@@ -31,6 +32,10 @@ class FileToRTMPStreamer:
 
         logging.info(f"📼 [APP] Starting file stream: {self.video_path} → {self.rtmp_url}")
 
+        # Get optimal encoder for hardware
+        encoder_args, encoder_name = EncoderSelector.get_encoder_args()
+        logging.info(f"🎬 [APP] Using encoder: {encoder_name}")
+
         # FFmpeg command
         ffmpeg_command = [
             "ffmpeg",
@@ -38,9 +43,8 @@ class FileToRTMPStreamer:
             "-stream_loop", "-1" if self.loop else "0",  # Loop if needed
             "-i", self.video_path,
 
-            "-c:v", "libx264",
-            "-preset", "ultrafast",
-            "-tune", "zerolatency",
+            # Video encoding with optimal encoder
+            *encoder_args,
             "-r", str(self.fps),
             "-b:v", "1500k",
             "-maxrate", "2000k",

nedo_vision_worker/services/GrpcClientBase.py

@@ -3,6 +3,7 @@ import logging
 import time
 from grpc import StatusCode
 from typing import Callable, Optional, Any, Dict
+from .GrpcConnection import GrpcConnection
 
 logger = logging.getLogger(__name__)
 
@@ -42,42 +43,21 @@ class GrpcClientBase:
     def __init__(self, server_host: str, server_port: int = 50051, max_retries: int = 3):
         self.server_address = f"{server_host}:{server_port}"
         self.channel: Optional[grpc.Channel] = None
-        self.stub: Optional[Any] = None
         self.connected = False
         self.max_retries = max_retries
 
+        self.connection = GrpcConnection(server_host, server_port)
+
     def connect(self, stub_class, retry_interval: int = 2) -> bool:
-        attempts = 0
-        while attempts < self.max_retries and not self.connected:
-            try:
-                if self.channel:
-                    self._close_channel()
-                
-                self.channel = grpc.insecure_channel(self.server_address)
-                
-                future = grpc.channel_ready_future(self.channel)
-                future.result(timeout=30)
-
-                self.stub = stub_class(self.channel)
-                self.connected = True
-                logger.info(f"🚀 Connected to gRPC server at {self.server_address}")
-                return True
-
-            except (grpc.RpcError, grpc.FutureTimeoutError, Exception) as e:
-                attempts += 1
-                self.connected = False
-                error_msg = str(e)
-                
-                logger.error(f"⚠️ Connection failed ({attempts}/{self.max_retries}): {error_msg}", exc_info=True)
-
-                if attempts < self.max_retries:
-                    sleep_time = retry_interval * (2 ** (attempts - 1))
-                    logger.info(f"⏳ Retrying in {sleep_time}s...")
-                    time.sleep(sleep_time)
-                else:
-                    logger.critical("❌ Max retries reached. Connection failed.")
-
-        return False
+        conn = self.connection.get_connection()
+        if conn is None:
+            return False
+        requested_stub = stub_class(conn)
+        
+        self.stub = requested_stub
+        self.connected = True
+
+        return True
 
     def _close_channel(self) -> None:
         try:
@@ -89,6 +69,7 @@ class GrpcClientBase:
             self.channel = None
             self.stub = None
 
+    # MARK:
     def close(self) -> None:
         self._close_channel()
         self.connected = False
@@ -104,6 +85,11 @@ class GrpcClientBase:
         except grpc.RpcError as e:
             return self._handle_grpc_error(e, rpc_call, *args, **kwargs)
         except Exception as e:
+            print(e)
+            print(str(e) == "Cannot invoke RPC on closed channel!")
+            if str(e) == "Cannot invoke RPC on closed channel!":
+                self.connect(type(self.stub))
+
             logger.error(f"💥 Unexpected RPC error: {e}")
             return None
 
@@ -127,8 +113,11 @@ class GrpcClientBase:
 
         return None
 
+    # MARK:
+    # Should request for reconnection two times. Notify grpc connection to do reconnect
     def _handle_unavailable(self, rpc_call: Callable, *args, **kwargs) -> Optional[Any]:
-        self.connected = False
+        # self.connected = False
+        self.connection.try_reconnect()
         
         if self.stub:
             stub_class = type(self.stub)
@@ -154,7 +143,7 @@ class GrpcClientBase:
         return error_message.split("debug_error_string")[0].strip()
 
     def is_connected(self) -> bool:
-        return self.connected and self.channel and self.stub
+        return self.connected and self.connection.get_connection() is not None and self.stub is not None
 
     def get_connection_info(self) -> Dict[str, Any]:
         return {

nedo_vision_worker/services/GrpcConnection.py

@@ -0,0 +1,147 @@
+import grpc
+import logging
+import time
+import threading
+from grpc import StatusCode
+from typing import Optional, Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+class GrpcConnection:
+    """
+    Grpc connection management. Responsible for initiating connection with gRPC server that
+    will be used across gRPC clients in the project.
+    Expected to be initiated as a singleton.
+    """
+    
+    _instance = None
+    _init_done = False
+    _lock = threading.Lock()
+    _reconnectLock = threading.Lock()
+    _reconnecting = False
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self, server_host: str, server_port: int = 50051, max_retries: int = 3):
+        if self.__class__._init_done:
+            return  # prevent re-initialization
+        self.__class__._init_done = True
+
+        self.server_address = f"{server_host}:{server_port}"
+        self.channel: Optional[grpc.Channel] = None
+        self.connected = False
+        self.max_retries = max_retries
+        self.connect()
+
+    def connect(self, retry_interval: int = 2) -> bool:
+        attempts = 0
+        while attempts < self.max_retries and not self.connected:
+            try:
+                if self.channel:
+                    self._close_channel()
+                
+                self.channel = grpc.insecure_channel(self.server_address)
+                
+                future = grpc.channel_ready_future(self.channel)
+                future.result(timeout=30)
+
+                self.connected = True
+                logger.info(f"🚀 Connected to gRPC server at {self.server_address}")
+                return True
+
+            except (grpc.RpcError, grpc.FutureTimeoutError, Exception) as e:
+                attempts += 1
+                self.connected = False
+                error_msg = str(e)
+                
+                logger.error(f"⚠️ Connection failed ({attempts}/{self.max_retries}): {error_msg}")
+
+                if attempts < self.max_retries:
+                    sleep_time = retry_interval * (2 ** (attempts - 1))
+                    logger.info(f"⏳ Retrying in {sleep_time}s...")
+                    time.sleep(sleep_time)
+                else:
+                    logger.critical("❌ Max retries reached. Connection failed.")
+
+        return False
+    
+    def get_connection(self):
+        if self._reconnecting or not self.connected:
+            return None
+        
+        return self.channel
+    
+    def _reconnect(self):
+        logger.info(f"⏳ Reconnecting...")
+        attempts = 0
+
+        while not self.connected:
+            try:
+                if self.channel:
+                    self._close_channel()
+                
+                self.channel = grpc.insecure_channel(self.server_address)
+                
+                future = grpc.channel_ready_future(self.channel)
+                future.result(timeout=30)
+
+                self.connected = True
+                self._reconnecting = False
+                logger.info(f"🚀 Connected to gRPC server at {self.server_address}")
+                self._reconnectLock.release_lock()
+            except (grpc.RpcError, grpc.FutureTimeoutError, Exception) as e:
+                attempts += 1
+                self.connected = False
+                error_msg = str(e)
+                
+                logger.error(f"⚠️ Connection failed ({attempts}/{self.max_retries}): {error_msg}")
+
+                sleep_time = 2 * (2 ** (attempts - 1))
+                logger.info(f"⏳ Retrying in {sleep_time}s...")
+                time.sleep(sleep_time)
+    
+    def try_reconnect(self):
+        if self._reconnecting:
+            return
+        
+        if self._reconnectLock.acquire_lock(blocking=False):
+            self._reconnecting = True
+            self.connected = False
+            self._reconnect()
+
+    def _close_channel(self) -> None:
+        try:
+            if self.channel:
+                self.channel.close()
+            logger.info("🔌 gRPC connection closed")
+        except Exception as e:
+            logger.warning(f"⚠️ Error closing channel: {e}")
+        finally:
+            self.channel = None
+            self.connected = False
+
+    def close(self) -> None:
+        if self.channel:
+            self.channel.close()
+        self.connected = False
+        logger.info("🔌 gRPC connection closed")
+
+    def is_connected(self) -> bool:
+        return self.connected and self.channel is not None
+
+    def get_connection_info(self) -> Dict[str, Any]:
+        return {
+            "server_address": self.server_address,
+            "connected": self.connected,
+            "max_retries": self.max_retries,
+            "has_channel": self.channel is not None,
+        }
+
+    def __enter__(self):
+        return self

nedo_vision_worker/services/RTSPtoRTMPStreamer.py

@@ -3,6 +3,7 @@ import logging
 import time
 import os
 from urllib.parse import urlparse
+from ..util.EncoderSelector import EncoderSelector
 
 class RTSPtoRTMPStreamer:
     def __init__(self, rtsp_url, rtmp_url, stream_key, fps=30, resolution="1280x720", duration=120):
@@ -38,6 +39,10 @@ class RTSPtoRTMPStreamer:
 
         logging.info(f"📡 [APP] Starting RTSP to RTMP stream: {self.rtsp_url} → {self.rtmp_url} for {self.duration} seconds")
 
+        # Get optimal encoder for hardware
+        encoder_args, encoder_name = EncoderSelector.get_encoder_args()
+        logging.info(f"🎬 [APP] Using encoder: {encoder_name}")
+
         # FFmpeg command
         ffmpeg_command = [
             "ffmpeg",
@@ -47,17 +52,14 @@ class RTSPtoRTMPStreamer:
             "-strict", "experimental",
             "-i", self.rtsp_url,
 
-            # ✅ Video Encoding (Fastest possible)
-            "-c:v", "libx264",
-            "-preset", "ultrafast",  # 🚀 Reduce CPU usage
-            "-tune", "zerolatency",  # 🚀 Optimize for real-time streaming
-            "-x264-params", "keyint=40:min-keyint=40",  # 🚀 Keyframe optimization
-            "-r", "25",  # ⏳ Limit FPS to 20 (prevents excessive encoding load)
-            "-b:v", "1500k",  # ✅ Lower bitrate to improve performance
+            # Video encoding with optimal encoder
+            *encoder_args,
+            "-r", "25",  # ⏳ Limit FPS to 25
+            "-b:v", "1500k",  # ✅ Bitrate
             "-maxrate", "2000k",  # ✅ Set max bitrate
             "-bufsize", "4000k",  # ✅ Reduce buffer latency
             "-g", "25",  # ✅ Reduce GOP size for faster keyframes
-            "-vf", "scale='min(1024,iw)':-2",  # ✅ Resize width to max 800px
+            "-vf", "scale='min(1024,iw)':-2",  # ✅ Resize width to max 1024px
 
             # ❌ Disable Audio (Avoid unnecessary encoding overhead)
             "-an",

nedo_vision_worker/services/SystemUsageClient.py

@@ -21,7 +21,7 @@ class SystemUsageClient(GrpcClientBase):
             logging.error(f"Failed to connect to gRPC server: {e}")
             self.stub = None
 
-    def send_system_usage(self, device_id: str, cpu_usage: float, ram_usage: dict, gpu_usage: list, latency: float, token: str) -> dict:
+    def send_system_usage(self, device_id: str, cpu_usage: float, ram_usage: dict, gpu_usage: list, latency: float, cpu_temperature: float, token: str) -> dict:
         """
         Send system usage data to the server using token authentication.
 
@@ -44,6 +44,7 @@ class SystemUsageClient(GrpcClientBase):
             request = SystemUsageRequest(
                 device_id=device_id,
                 cpu_usage=cpu_usage,
+                cpu_temperature=cpu_temperature,
                 ram_usage_percent=ram_usage.get("percent", 0.0),
                 ram_total=ram_usage.get("total", 0),
                 ram_used=ram_usage.get("used", 0),

nedo_vision_worker/services/WorkerSourcePipelineClient.py

@@ -377,7 +377,15 @@ class WorkerSourcePipelineClient(GrpcClientBase):
             debug_entries = self.debug_repo.get_debug_entries_with_data()
 
             for debug_entry in debug_entries:
-                image_binary = self.read_image_as_binary(debug_entry.image_path)
+                try:
+                    image_binary = self.read_image_as_binary(debug_entry.image_path)
+                except FileNotFoundError:
+                    logging.warning(f"Image file not found: {debug_entry.image_path}, deleting entry {debug_entry.id}")
+                    self.debug_repo.delete_entry_by_id(debug_entry.id)
+                    continue
+                except Exception as e:
+                    logging.error(f"Error reading image {debug_entry.image_path}: {e}")
+                    continue
 
                 request = SendPipelineDebugRequest(
                     worker_source_pipeline_id=debug_entry.worker_source_pipeline_id,
@@ -391,12 +399,13 @@ class WorkerSourcePipelineClient(GrpcClientBase):
                 if response and response.success:
                     self.debug_repo.delete_entry_by_id(debug_entry.id)
                 else:
-                    return {"success": False, "message": response.message if response else "Unknown error"}
+                    logging.warning(f"Failed to sync debug entry {debug_entry.id}: {response.message if response else 'Unknown error'}")
 
             return {"success": True, "message": "Successfully synced debug entries"}
 
         except Exception as e:
-            logging.error(f"Error syncing pipeline debug: {e}")
+            logging.error(f"Error syncing pipeline debug: {e}", exc_info=True)
+            return {"success": False, "message": f"Exception: {str(e)}"}
 
     def sync_pipeline_detection(self, token: str):
         if not self.stub:
@@ -406,7 +415,15 @@ class WorkerSourcePipelineClient(GrpcClientBase):
             entries = self.detection_repo.get_entries()
 
             for entry in entries:
-                image_binary = self.read_image_as_binary(entry.image_path)
+                try:
+                    image_binary = self.read_image_as_binary(entry.image_path)
+                except FileNotFoundError:
+                    logging.warning(f"Image file not found: {entry.image_path}, deleting entry {entry.id}")
+                    self.detection_repo.delete_entry_by_id(entry.id)
+                    continue
+                except Exception as e:
+                    logging.error(f"Error reading image {entry.image_path}: {e}")
+                    continue
 
                 request = SendPipelineDetectionDataRequest(
                     worker_source_pipeline_id=entry.worker_source_pipeline_id,
@@ -420,9 +437,10 @@ class WorkerSourcePipelineClient(GrpcClientBase):
                 if response and response.success:
                     self.detection_repo.delete_entry_by_id(entry.id)
                 else:
-                    return {"success": False, "message": response.message if response else "Unknown error"}
+                    logging.warning(f"Failed to sync detection entry {entry.id}: {response.message if response else 'Unknown error'}")
 
-            return {"success": True, "message": "Successfully synced debug entries"}
+            return {"success": True, "message": "Successfully synced detection entries"}
 
         except Exception as e:
-            logging.error(f"Error syncing pipeline debug: {e}")
+            logging.error(f"Error syncing pipeline detection: {e}", exc_info=True)
+            return {"success": False, "message": f"Exception: {str(e)}"}

nedo_vision_worker/util/EncoderSelector.py

@@ -0,0 +1,109 @@
+"""
+Utility for selecting the best available video encoder (GPU or CPU fallback).
+"""
+import os
+import sys
+import logging
+from typing import List, Tuple
+from .PlatformDetector import PlatformDetector
+
+logger = logging.getLogger(__name__)
+
+
+class EncoderSelector:
+    """Selects optimal video encoder based on available hardware."""
+    
+    _platform = PlatformDetector()
+    
+    @classmethod
+    def get_encoder_args(cls, force_cpu: bool = False) -> Tuple[List[str], str]:
+        """
+        Get FFmpeg encoder arguments.
+        
+        Args:
+            force_cpu: Force CPU encoding even if GPU is available
+            
+        Returns:
+            Tuple of (encoder_args_list, encoder_name)
+        """
+        if force_cpu:
+            return cls._get_cpu_encoder()
+        
+        # Check environment variable override
+        force_encoder = os.environ.get("RTMP_ENCODER", "").lower()
+        
+        if force_encoder == "cpu" or force_encoder == "libx264":
+            return cls._get_cpu_encoder()
+        elif force_encoder == "nvenc":
+            return cls._get_nvenc_encoder()
+        
+        # Jetson platform
+        if cls._platform.is_jetson():
+            return cls._get_jetson_encoder()
+        
+        # macOS
+        if sys.platform == "darwin":
+            return cls._get_videotoolbox_encoder()
+        
+        # NVIDIA GPU
+        if cls._has_nvidia_gpu():
+            return cls._get_nvenc_encoder()
+        
+        # Fallback to CPU
+        return cls._get_cpu_encoder()
+    
+    @staticmethod
+    def _has_nvidia_gpu() -> bool:
+        """Check if NVIDIA GPU is available."""
+        return (
+            os.environ.get("NVIDIA_VISIBLE_DEVICES") is not None or
+            os.path.exists("/proc/driver/nvidia/version")
+        )
+    
+    @staticmethod
+    def _get_cpu_encoder() -> Tuple[List[str], str]:
+        """Get CPU encoder (libx264) with optimized settings."""
+        return [
+            "-c:v", "libx264",
+            "-preset", "ultrafast",
+            "-tune", "zerolatency",
+            "-profile:v", "main",
+        ], "libx264"
+    
+    @staticmethod
+    def _get_nvenc_encoder() -> Tuple[List[str], str]:
+        """Get NVIDIA NVENC encoder with GPU-optimized settings."""
+        return [
+            "-c:v", "h264_nvenc",
+            "-preset", "p1",  # p1 = fastest preset
+            "-tune", "ull",  # ultra-low latency
+            "-rc:v", "cbr",  # constant bitrate
+            "-rc-lookahead", "0",  # disable lookahead for lower latency
+            "-delay", "0",  # zero delay
+            "-zerolatency", "1",  # zero latency mode
+            "-profile:v", "main",
+            "-gpu", "0",  # Use first GPU
+        ], "h264_nvenc"
+    
+    @staticmethod
+    def _get_jetson_encoder() -> Tuple[List[str], str]:
+        """Get Jetson-optimized NVENC encoder."""
+        return [
+            "-c:v", "h264_nvenc",
+            "-preset", "p1",
+            "-tune", "ull",
+            "-rc:v", "cbr",
+            "-rc-lookahead", "0",
+            "-delay", "0",
+            "-zerolatency", "1",
+            "-profile:v", "main",
+        ], "h264_nvenc"
+    
+    @staticmethod
+    def _get_videotoolbox_encoder() -> Tuple[List[str], str]:
+        """Get macOS VideoToolbox encoder."""
+        return [
+            "-c:v", "h264_videotoolbox",
+            "-profile:v", "main",
+            "-realtime", "1",
+        ], "h264_videotoolbox"

nedo_vision_worker/util/SystemMonitor.py

@@ -78,6 +78,9 @@ class SystemMonitor:
                     return [temp.current for temp in core_temps if hasattr(temp, "current")]
                 elif "cpu-thermal" in sensors:
                     return [sensors["cpu-thermal"][0].current]
+                elif "k10temp" in sensors and len(sensors["k10temp"]) > 0:
+                    temp = sensors["k10temp"][0]
+                    return float(temp.current)
                 else:
                     return {"error": "CPU temperature sensor not found"}
         except Exception as e:

nedo_vision_worker/worker/DataSyncWorker.py

@@ -138,7 +138,7 @@ class DataSyncWorker:
 
             if not response or not response.get("success"):
                 error_message = GrpcClientBase.get_error_message(response)
-                logger.error(f"❌ [APP] Failed to sync dataset sources: {error_message}")
+                logger.error(f"❌ [APP] Failed to sync worker source pipelines detection: {error_message}")
 
         except Exception as e:
-            logger.error("🚨 [APP] Error syncing worker source pipelines detection.", exc_info=True)
+            logger.error(f"🚨 [APP] Error syncing worker source pipelines detection: {e}", exc_info=True)

nedo_vision_worker/worker/DatasetFrameWorker.py

@@ -284,7 +284,7 @@ class DatasetFrameWorker:
                 self.last_sync_time = time.time()
             else:
                 error_message = response.get("message", "Unknown error") if response else "Unknown error"
-                logger.error(f"❌ [APP] Failed to sync dataset sources: {error_message}")
+                logger.error(f"❌ [APP] Failed to sync dataset sources: {error_message}", exc_info=True)
 
         except Exception as e:
             logger.error("🚨 [APP] Error syncing dataset sources.", exc_info=True)

nedo_vision_worker/worker/PipelinePreviewWorker.py

@@ -0,0 +1,160 @@
+import threading
+import logging
+import json
+from datetime import datetime
+from ..database.DatabaseManager import DatabaseManager
+from ..models.worker_source_pipeline import WorkerSourcePipelineEntity
+from .RabbitMQListener import RabbitMQListener
+
+logger = logging.getLogger(__name__)
+
+def safe_join_thread(thread, timeout=5):
+    """Safely join a thread, avoiding RuntimeError when joining current thread."""
+    if thread and thread != threading.current_thread():
+        thread.join(timeout=timeout)
+    elif thread == threading.current_thread():
+        logging.info("🛑 [APP] Thread stopping from within itself, skipping join.")
+
+class PipelinePreviewWorker:
+    def __init__(self, config: dict):
+        """
+        Initialize Pipeline Preview Worker.
+        
+        This worker listens for pipeline preview requests and updates the
+        last_preview_request_at timestamp in the database. The worker core
+        will check this timestamp to decide whether to publish RTMP streams.
+
+        Args:
+            config (dict): Configuration object containing settings.
+        """
+        if not isinstance(config, dict):
+            raise ValueError("⚠️ [APP] config must be a dictionary.")
+
+        self.config = config
+        self.worker_id = self.config.get("worker_id")
+
+        if not self.worker_id:
+            raise ValueError("⚠️ [APP] Configuration is missing 'worker_id'.")
+
+        self.thread = None
+        self.stop_event = threading.Event()
+        self.lock = threading.Lock()
+
+        # Initialize RabbitMQ listener
+        self.listener = RabbitMQListener(
+            self.config, self.worker_id, self.stop_event, self._process_pipeline_preview_message
+        )
+
+    def start(self):
+        """Start the Pipeline Preview Worker."""
+        with self.lock:
+            if self.thread and self.thread.is_alive():
+                logger.warning("⚠️ [APP] Pipeline Preview Worker is already running.")
+                return
+
+            self.stop_event.clear()
+            self.thread = threading.Thread(target=self._run, daemon=True)
+            self.thread.start()
+            logger.info(f"🚀 [APP] Pipeline Preview Worker started (Device: {self.worker_id}).")
+
+    def stop(self):
+        """Stop the Pipeline Preview Worker."""
+        with self.lock:
+            if not self.thread or not self.thread.is_alive():
+                logger.warning("⚠️ [APP] Pipeline Preview Worker is not running.")
+                return
+
+            self.stop_event.set()
+            self.listener.stop_listening()
+
+            safe_join_thread(self.thread)
+            self.thread = None
+            logger.info(f"🛑 [APP] Pipeline Preview Worker stopped (Device: {self.worker_id}).")
+
+    def _run(self):
+        """Main loop to manage RabbitMQ listener."""
+        try:
+            while not self.stop_event.is_set():
+                logger.info("📡 [APP] Starting pipeline preview message listener...")
+                self.listener.start_listening(
+                    exchange_name="nedo.worker.pipeline.preview", 
+                    queue_name=f"nedo.worker.pipeline.preview.{self.worker_id}"
+                )
+                
+                # Wait for the listener thread to finish (connection lost or stop requested)
+                while not self.stop_event.is_set() and self.listener.listener_thread and self.listener.listener_thread.is_alive():
+                    self.listener.listener_thread.join(timeout=5)
+                
+                if not self.stop_event.is_set():
+                    logger.warning("⚠️ [APP] Pipeline preview listener disconnected. Attempting to reconnect in 10 seconds...")
+                    self.stop_event.wait(10)
+                else:
+                    logger.info("📡 [APP] Pipeline preview listener stopped.")
+                    break
+                    
+        except Exception as e:
+            logger.error("🚨 [APP] Unexpected error in Pipeline Preview Worker loop.", exc_info=True)
+
+    def _process_pipeline_preview_message(self, message):
+        """
+        Process messages related to pipeline preview streaming.
+        Updates the last_preview_request_at timestamp for the specified pipeline.
+        """
+        try:
+            data = json.loads(message)
+            worker_id = data.get("workerId")
+            pipeline_id = data.get("pipelineId")
+
+            logger.info(f"📡 [APP] Received pipeline preview message ({data})")
+
+            # Validate required fields
+            if not pipeline_id:
+                logger.error(f"⚠️ [APP] Missing pipelineId in message")
+                return
+
+            if worker_id != self.worker_id:
+                logger.warning(f"⚠️ [APP] Worker ID mismatch: expected {self.worker_id}, got {worker_id}")
+                return
+
+            # Update the last_preview_request_at timestamp in database
+            self._update_pipeline_preview_timestamp(pipeline_id)
+
+        except json.JSONDecodeError:
+            logger.error("⚠️ [APP] Invalid JSON message format.")
+        except Exception as e:
+            logger.error("🚨 [APP] Error processing pipeline preview message.", exc_info=True)
+
+    def _update_pipeline_preview_timestamp(self, pipeline_id: str):
+        """
+        Update the last_preview_request_at timestamp for the specified pipeline.
+        
+        Args:
+            pipeline_id (str): The ID of the pipeline to update.
+        """
+        session = None
+        try:
+            session = DatabaseManager.get_session("config")
+            
+            # Find the pipeline
+            pipeline = session.query(WorkerSourcePipelineEntity).filter_by(
+                id=pipeline_id,
+                worker_id=self.worker_id
+            ).first()
+
+            if not pipeline:
+                logger.error(f"⚠️ [APP] Pipeline not found: {pipeline_id}")
+                return
+
+            # Update timestamp
+            pipeline.last_preview_request_at = datetime.utcnow()
+            session.commit()
+            
+            logger.info(f"✅ [APP] Updated preview timestamp for pipeline {pipeline_id} ({pipeline.name})")
+
+        except Exception as e:
+            if session:
+                session.rollback()
+            logger.error(f"🚨 [APP] Error updating pipeline preview timestamp: {e}", exc_info=True)
+        finally:
+            if session:
+                session.close()

nedo_vision_worker/worker/SystemUsageManager.py

@@ -74,8 +74,28 @@ class SystemUsageManager:
         try:
             usage = self.system_monitor.get_system_usage()
             cpu_usage = usage["cpu"]["usage_percent"]
+            cpu_temperature_raw = usage["cpu"]["temperature_celsius"]
             ram_usage = usage["ram"]
-            gpu_usage = usage.get("gpu", [])
+            gpu_usage_raw = usage.get("gpu", [])
+            
+            if isinstance(cpu_temperature_raw, (int, float)):
+                cpu_temperature = float(cpu_temperature_raw)
+            elif isinstance(cpu_temperature_raw, list):
+                if cpu_temperature_raw:
+                    cpu_temperature = float(sum(cpu_temperature_raw) / len(cpu_temperature_raw))
+                else:
+                    cpu_temperature = 0.0
+            elif isinstance(cpu_temperature_raw, dict):
+                cpu_temperature = 0.0
+            else:
+                cpu_temperature = 0.0
+            
+            if isinstance(gpu_usage_raw, dict):
+                gpu_usage = []
+            elif isinstance(gpu_usage_raw, list):
+                gpu_usage = gpu_usage_raw
+            else:
+                gpu_usage = []
 
             with self.latency_lock:
                 latency = self.latency if self.latency is not None else -1
@@ -85,6 +105,7 @@ class SystemUsageManager:
                 cpu_usage=cpu_usage,
                 ram_usage=ram_usage,
                 gpu_usage=gpu_usage,
+                cpu_temperature=cpu_temperature,
                 latency=latency,
                 token=self.token,
             )
@@ -92,8 +113,6 @@ class SystemUsageManager:
             if not response or not response.get("success"):
                 error_message = GrpcClientBase.get_error_message(response)
                 logger.error(f"❌ [APP] Failed to send system usage: {error_message}")
-            #else:
-            #    logger.info("✅ [APP] System usage sent successfully.")
 
         except Exception as e:
             logger.error("🚨 [APP] Error sending system usage.", exc_info=True)

nedo_vision_worker/worker/WorkerManager.py

@@ -7,6 +7,7 @@ from .DataSyncWorker import DataSyncWorker
 from .DataSenderWorker import DataSenderWorker
 from .PipelineImageWorker import PipelineImageWorker
 from .VideoStreamWorker import VideoStreamWorker
+from .PipelinePreviewWorker import PipelinePreviewWorker
 from .CoreActionWorker import CoreActionWorker
 from .DatasetFrameWorker import DatasetFrameWorker
 
@@ -38,6 +39,7 @@ class WorkerManager:
         self.data_sync_worker = DataSyncWorker(config, sync_interval=10)
         self.data_sender_worker = DataSenderWorker(config, send_interval=10)
         self.video_stream_worker = VideoStreamWorker(config)
+        self.pipeline_preview_worker = PipelinePreviewWorker(config)
         self.pipeline_image_worker = PipelineImageWorker(config)
         self.pipeline_action_worker = PipelineActionWorker(config)
         self.core_action_worker = CoreActionWorker(config, self._start_workers, self._stop_workers)
@@ -47,6 +49,7 @@ class WorkerManager:
         """Start processing workers while keeping monitoring workers running."""
         try:
             self.video_stream_worker.start()
+            self.pipeline_preview_worker.start()
             self.pipeline_image_worker.start()
             self.data_sender_worker.start_updating()
             self.dataset_frame_worker.start()
@@ -60,6 +63,7 @@ class WorkerManager:
         """Stop processing workers while keeping monitoring workers running."""
         try:
             self.video_stream_worker.stop()
+            self.pipeline_preview_worker.stop()
             self.pipeline_image_worker.stop()
             self.data_sender_worker.stop_updating()
             self.dataset_frame_worker.stop()

nedo_vision_worker/worker_service.py

@@ -151,6 +151,16 @@ class WorkerService:
                 self.logger.info("✅ [APP] Configuration updated successfully")
             else:
                 self.logger.info("✅ [APP] Configuration found. No changes needed.")
+            
+            # Always fetch connection info on startup to check for updates
+            self.logger.info("🔄 [APP] Checking for connection info updates...")
+            token_to_use = self.token if self.token else config.get('token')
+            if token_to_use:
+                AppInitializer.update_connection_info(server_host, self.server_port, token_to_use)
+                # Reload config after potential updates
+                config = ConfigurationManager.get_all_configs()
+            else:
+                self.logger.warning("⚠️ [APP] No token available to fetch connection info updates")
         
         # Add runtime parameters to config
         config['rtmp_server'] = self.rtmp_server

{nedo_vision_worker-1.2.6.dist-info → nedo_vision_worker-1.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedo-vision-worker
-Version: 1.2.6
+Version: 1.2.8
 Summary: Nedo Vision Worker Service Library for AI Vision Processing
 Author-email: Willy Achmat Fauzi <willy.achmat@gmail.com>
 Maintainer-email: Willy Achmat Fauzi <willy.achmat@gmail.com>
@@ -40,9 +40,10 @@ Requires-Dist: protobuf>=3.20.0
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: requests>=2.28.0
 Requires-Dist: SQLAlchemy>=1.4.0
-Requires-Dist: opencv-python>=4.6.0; platform_machine not in "aarch64 armv7l"
-Requires-Dist: opencv-python-headless>=4.6.0; platform_machine in "aarch64 armv7l"
 Requires-Dist: pynvml>=11.4.1; platform_system != "Darwin" or platform_machine != "arm64"
+Provides-Extra: opencv
+Requires-Dist: opencv-python>=4.6.0; platform_machine not in "aarch64 armv7l" and extra == "opencv"
+Requires-Dist: opencv-python-headless>=4.6.0; platform_machine in "aarch64 armv7l" and extra == "opencv"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: black>=22.0.0; extra == "dev"

{nedo_vision_worker-1.2.6.dist-info → nedo_vision_worker-1.2.8.dist-info}/RECORD

@@ -1,12 +1,12 @@
-nedo_vision_worker/__init__.py,sha256=3uSTVntcW747CFtMZ_qyKrptoNgHDvLNjg0pdgb4otM,203
+nedo_vision_worker/__init__.py,sha256=RU8uEjcEodK2R_F4Fg2qBYmhhJpvf-vQBA-Cjo9Dvf8,203
 nedo_vision_worker/cli.py,sha256=ddWspJmSgVkcUYvRdkvTtMNuMTDvNCqLLuMVU9KE3Ik,7457
 nedo_vision_worker/doctor.py,sha256=wNkpe8gLVd76Y_ViyK2h1ZFdqeSl37MnzZN5frWKu30,48410
-nedo_vision_worker/worker_service.py,sha256=rXUVmyxcJPGhQEZ4UQvjQS5UqlnLBYudHQZCj0dQDxo,10421
+nedo_vision_worker/worker_service.py,sha256=9zz8hKwDwqwpfS0KPQfftGJtRci0uj_wiwcr_TGf-E0,11039
 nedo_vision_worker/config/ConfigurationManager.py,sha256=QrQaQ9Cdjpkcr2JE_miyrWJIZmMgZwJYBz-wE45Zzes,8011
 nedo_vision_worker/config/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-nedo_vision_worker/database/DatabaseManager.py,sha256=BZAK3VzbAo_xWUNCni4O8rCLzCjY7mE02PI2HlEpqg4,8505
+nedo_vision_worker/database/DatabaseManager.py,sha256=j2koXo1fnMmAyQnY4sv4txfZR8qIzrPyev-sQ4HBaOQ,9478
 nedo_vision_worker/database/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-nedo_vision_worker/initializer/AppInitializer.py,sha256=iGw8-7Eg2aNT-nFaxiRIhWHU8iwecLuwuvjWlt1-V0Y,3163
+nedo_vision_worker/initializer/AppInitializer.py,sha256=6UVdjiuayziPYZ7JkQ436z7-9sHj7J3jtp6lfQsu-DU,5698
 nedo_vision_worker/initializer/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker/models/__init__.py,sha256=6ZH2W1Jcy4o6xBPqFPcyxRU2UJ5Zvw_kfO38yLLGtHA,796
 nedo_vision_worker/models/ai_model.py,sha256=9muyZL9AxtX417-tYUiw8bgvFPtqdXgEAq-hm_mLxGY,2277
@@ -19,7 +19,7 @@ nedo_vision_worker/models/ppe_detection_label.py,sha256=qON7a0fuDv5cK8phGH0gGTzq
 nedo_vision_worker/models/restricted_area_violation.py,sha256=0enCi3tv15YMy3NaI6FwqhmLYHbbVX4nWTh46qKxrWc,829
 nedo_vision_worker/models/user.py,sha256=SnLUz2nS7j17bIP-gElMEaR-jWdnNQ0fTpRminVKY60,294
 nedo_vision_worker/models/worker_source.py,sha256=FB8irZ26LhCKNHBcpIIb5Mi3SoSNm9-q25VIkO5jQWg,793
-nedo_vision_worker/models/worker_source_pipeline.py,sha256=xCD4i9pHr8Qy5B_h1dH0Q7V7faS2lAou2UNEzx24oIw,752
+nedo_vision_worker/models/worker_source_pipeline.py,sha256=CGA_nz5wywsJcBPm-5kd0v_-h59f8Iu7uEeX3C91eT4,824
 nedo_vision_worker/models/worker_source_pipeline_config.py,sha256=dGYTpcTFFu6pmGBufuWBHjv3Xs4RGAQwZn6jp6Ondvs,876
 nedo_vision_worker/models/worker_source_pipeline_debug.py,sha256=6S7TkN37FrAT4VwsEB38DWSad7QfvNhsOGtSEK8D1Qs,594
 nedo_vision_worker/models/worker_source_pipeline_detection.py,sha256=p6CJsiVCKprTYrNxJsiTB8njXdHkjZKVEyBceRVE6fY,560
@@ -50,49 +50,52 @@ nedo_vision_worker/repositories/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKr
 nedo_vision_worker/services/AIModelClient.py,sha256=lxRNax6FR-pV0G1NpJnlaqjbQeu3kRolIUNSw1RkoZA,15406
 nedo_vision_worker/services/ConnectionInfoClient.py,sha256=toC9zuY2Hrx1Cwq8Gycy_iFlaG1DvFT4qewlLlitpEQ,2214
 nedo_vision_worker/services/DatasetSourceClient.py,sha256=O5a7onxFl0z47zXaMXWxHAMPuuc-i_vzkd2w5fwrukc,3319
-nedo_vision_worker/services/DirectDeviceToRTMPStreamer.py,sha256=M5ei0cd3_KDhHZp6EkrOowhAY-hAHfAQh9YDVjQtbQI,22278
-nedo_vision_worker/services/FileToRTMPServer.py,sha256=yUJxrouoTLSq9XZ88dhDYhP-px10jLoHopkPoy4lQxk,2663
-nedo_vision_worker/services/GrpcClientBase.py,sha256=bRNeajiPGcJZtNofD_HU7JhLHVPbnuGacqv5Dp62GC0,7400
+nedo_vision_worker/services/DirectDeviceToRTMPStreamer.py,sha256=K0n7iyR7jdce8IWdNuqa1Im-R00QnxBcb7u2KM2Wjbc,22423
+nedo_vision_worker/services/FileToRTMPServer.py,sha256=0hY5pmeAzLw_d3uPR2Qp6gSAYb4rJHiAunuNe08OvkM,2870
+nedo_vision_worker/services/GrpcClientBase.py,sha256=hPyxOGw3aGSW1FhmY3wp3Iq8U1MArXBmvEMdmd63NZ4,6827
 nedo_vision_worker/services/GrpcClientManager.py,sha256=DLXekmxlQogLo8V9-TNDXtyHT_UG-BaggqwsIups55k,5568
+nedo_vision_worker/services/GrpcConnection.py,sha256=UNjaUC4ZcXuteHQx8AAAL5ymYkT1OpoIvyCYPUc3tCI,4915
 nedo_vision_worker/services/ImageUploadClient.py,sha256=T353YsRfm74G7Mh-eWr5nvdQHXTfpKwHJFmNW8HyjT8,3019
 nedo_vision_worker/services/PPEDetectionClient.py,sha256=CC-b0LRAgrftfIKp6TFKpeBkTYefe-C6Z1oz_X3HArQ,4345
-nedo_vision_worker/services/RTSPtoRTMPStreamer.py,sha256=hkPRX6iGxUtivsOA36JWBopHEd1RlmgIP8SLqN4d2TU,3863
+nedo_vision_worker/services/RTSPtoRTMPStreamer.py,sha256=LtfrWDHNcm-Ky6nZLnFCF8xgqIm7VQmsWIenK2yKNfo,3804
 nedo_vision_worker/services/RestrictedAreaClient.py,sha256=AE9SOcVQca4zn5V96boho56EgN5BCIpV-8grvFBBnGo,3853
 nedo_vision_worker/services/SharedDirectDeviceClient.py,sha256=dylMhqpMsfK_UKLWIVL-ApJRP4g-NCP_55xvlGYBiwo,10760
 nedo_vision_worker/services/SharedVideoStreamServer.py,sha256=WMKVxkzMoyfbgYiJ0fQOT-Ujz9btz6FLlaDP738yfoY,11601
-nedo_vision_worker/services/SystemUsageClient.py,sha256=PbRuwDWKnMarcnkGtOKfYB5nA-3DeKv7V5_hZr8EDEo,3200
+nedo_vision_worker/services/SystemUsageClient.py,sha256=Yf77dooQeNh6CDL5FkWVrX9543OVz1wc3exCAg6GlWw,3273
 nedo_vision_worker/services/SystemWideDeviceCoordinator.py,sha256=9zBJMCbTMZS7gwN67rFpoUiTr82El2rpIO7DKFzeMjM,9417
 nedo_vision_worker/services/VideoSharingDaemon.py,sha256=hYMjUIKNUVT1qSxuUuHN-7Bd85MDkxfqslxDLe2PBYQ,29721
 nedo_vision_worker/services/VideoStreamClient.py,sha256=QSgUV3LijYrNdnBG1ylABOdUaSatQamfXaqJhAiol9M,7260
 nedo_vision_worker/services/WorkerSourceClient.py,sha256=vDZeCuHL5QQ2-knZ4TOSA59jzmbbThGIwFKKLEZ72Ws,9198
-nedo_vision_worker/services/WorkerSourcePipelineClient.py,sha256=qaBx9T2gWMzpqZaeQdbIeklsXNwzWD5kqgB41rrSkBI,17135
+nedo_vision_worker/services/WorkerSourcePipelineClient.py,sha256=cjev_NRGUZrC9tuMm8s5ov92fknQno4vLEt-yMFrUCY,18241
 nedo_vision_worker/services/WorkerSourceUpdater.py,sha256=4t_CEHBLGDRvvuQS6eEPMivTI11ZuzusKKto6t9tPIk,9115
 nedo_vision_worker/services/WorkerStatusClient.py,sha256=7kC5EZjEBwWtHOE6UQ29OPCpYnv_6HSuH7Tc0alK_2Q,2531
 nedo_vision_worker/services/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
+nedo_vision_worker/util/EncoderSelector.py,sha256=-9lZwVmiKzJr1cELeuCXi-jRonty2bpociZq4KDScmA,3399
 nedo_vision_worker/util/FFmpegUtil.py,sha256=QnQrzurmllzGb7SlAAYCrzKBUblweoFU-0h-X-32IYg,1829
 nedo_vision_worker/util/HardwareID.py,sha256=rSW8-6stm7rjXEdkYGqXMUn56gyw62YiWnSwZQVCCLM,4315
 nedo_vision_worker/util/ImageUploader.py,sha256=2xipN3fwpKgFmbvoGIdElpGn5ARJyrgR4dXtbRf73hw,3764
 nedo_vision_worker/util/Networking.py,sha256=uOtL8HkKZXJp02ZZIHWYMAvAsaYb7BsAPTncfdvJx2c,3241
 nedo_vision_worker/util/PlatformDetector.py,sha256=-iLPrKs7hp_oltkCI3hESJQkC2uRyu1-8mAbZrvgWx0,1501
-nedo_vision_worker/util/SystemMonitor.py,sha256=2MWYaEXoL91UANT_-SuDWrFMq1ajPorh8co6Py9PV_c,11300
+nedo_vision_worker/util/SystemMonitor.py,sha256=2kkqj9mOlywAS2fHdN1TaIXSXvCApcIHj0IO2T9k3Yw,11471
 nedo_vision_worker/util/VideoProbeUtil.py,sha256=cF-vJ7hIDlXfEJby2a0s9tqwkPGVz_6B3Vv4D5pMmIw,12876
 nedo_vision_worker/util/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker/worker/CoreActionWorker.py,sha256=lb7zPY3yui6I3F4rX4Ii7JwpWZahLEO72rh3iWOgFmg,5441
 nedo_vision_worker/worker/DataSenderWorker.py,sha256=9FudRRItiMOcQx5UfVyu4p0Enb9BbgwZZ5EgX6Ho2U4,7160
-nedo_vision_worker/worker/DataSyncWorker.py,sha256=WvYfi3bG4mOKHU09J_MavfjFPrVgmxrrZYtrlQ-bnio,6265
+nedo_vision_worker/worker/DataSyncWorker.py,sha256=LmDPt2J1frmXwuR46L6b0MjlFOHfgG-4_0MGQa78zF4,6288
 nedo_vision_worker/worker/DatasetFrameSender.py,sha256=1SFYj8LJFNi-anBTapsbq8U_NGMM7mnoMKg9NeFAHys,8087
-nedo_vision_worker/worker/DatasetFrameWorker.py,sha256=Ni5gPeDPk9Rz4_cbg63u7Y6LVw_-Bz24OvfeY-6Yp44,19320
+nedo_vision_worker/worker/DatasetFrameWorker.py,sha256=Hh_wZuMjwovxsEKFqXSuTRin9eYRBZCbcFKm3CKLMbE,19335
 nedo_vision_worker/worker/PPEDetectionManager.py,sha256=fAolWlrsY5SQAWygvjNBNU56IlC0HLlhPgpz7shL-gk,3588
 nedo_vision_worker/worker/PipelineActionWorker.py,sha256=xgvryjKtEsMj4BKqWzDIaK_lFny-DfMCj5Y2DxHnWww,5651
 nedo_vision_worker/worker/PipelineImageWorker.py,sha256=J8VBUG0cwcH3qOJp2zTl30B-XhmPFyvJLjxitKJYq0E,5642
+nedo_vision_worker/worker/PipelinePreviewWorker.py,sha256=owFiBbktcOZkdImQeykZSeBIR2-mpt6HNkmYIkLRKzE,6397
 nedo_vision_worker/worker/RabbitMQListener.py,sha256=9gR49MDplgpyb-D5HOH0K77-DJQFvhS2E7biL92SjSU,6950
 nedo_vision_worker/worker/RestrictedAreaManager.py,sha256=3yoXgQ459tV1bOa5choEzR9gE6LklrtHR_e0472U3L0,3521
-nedo_vision_worker/worker/SystemUsageManager.py,sha256=StutV4UyLUfduYfK20de4SbPd7wqkR7io0gsOajxWSU,4509
+nedo_vision_worker/worker/SystemUsageManager.py,sha256=mkh4sT-HkIEY1CJHMEG6LP9ATu39YXvLRLyf995OkoQ,5315
 nedo_vision_worker/worker/VideoStreamWorker.py,sha256=5n6v1PNO7IB-jj_McALLkUP-cBjJoIEw4UiSAs3vTb0,7606
-nedo_vision_worker/worker/WorkerManager.py,sha256=T0vMfhOd7YesgQ9o2w6soeJ6n9chUAcuwcGe7p31xr0,5298
+nedo_vision_worker/worker/WorkerManager.py,sha256=2bxXi19fp3p1qjYBStYRdVVgko8dnevXx1_M_sqH5og,5521
 nedo_vision_worker/worker/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-nedo_vision_worker-1.2.6.dist-info/METADATA,sha256=irbHs4_-uj182kff6PpW0YND59Q_UwhsPVLb5wI5NNQ,14661
-nedo_vision_worker-1.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nedo_vision_worker-1.2.6.dist-info/entry_points.txt,sha256=LrglS-8nCi8C_PL_pa6uxdgCe879hBETHDVXAckvs-8,60
-nedo_vision_worker-1.2.6.dist-info/top_level.txt,sha256=vgilhlkyD34YsEKkaBabmhIpcKSvF3XpzD2By68L-XI,19
-nedo_vision_worker-1.2.6.dist-info/RECORD,,
+nedo_vision_worker-1.2.8.dist-info/METADATA,sha256=7MmzgVArAQxzCvxpcCr-LzPrFa0prCfOkaYCPLkmH_0,14728
+nedo_vision_worker-1.2.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nedo_vision_worker-1.2.8.dist-info/entry_points.txt,sha256=LrglS-8nCi8C_PL_pa6uxdgCe879hBETHDVXAckvs-8,60
+nedo_vision_worker-1.2.8.dist-info/top_level.txt,sha256=vgilhlkyD34YsEKkaBabmhIpcKSvF3XpzD2By68L-XI,19
+nedo_vision_worker-1.2.8.dist-info/RECORD,,