nedo-vision-worker 1.2.6__py3-none-any.whl → 1.2.7__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.7"
 __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/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/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/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/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/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-1.2.6.dist-info → nedo_vision_worker-1.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedo-vision-worker
-Version: 1.2.6
+Version: 1.2.7
 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.7.dist-info}/RECORD

@@ -1,10 +1,10 @@
-nedo_vision_worker/__init__.py,sha256=3uSTVntcW747CFtMZ_qyKrptoNgHDvLNjg0pdgb4otM,203
+nedo_vision_worker/__init__.py,sha256=1QtTEMaMlbF3PH-GmXuZzF1PvxRe_CUCme72WXqFci0,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/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/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
@@ -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
@@ -52,15 +52,16 @@ nedo_vision_worker/services/ConnectionInfoClient.py,sha256=toC9zuY2Hrx1Cwq8Gycy_
 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/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/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
@@ -74,7 +75,7 @@ nedo_vision_worker/util/HardwareID.py,sha256=rSW8-6stm7rjXEdkYGqXMUn56gyw62YiWnS
 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
@@ -85,14 +86,15 @@ nedo_vision_worker/worker/DatasetFrameWorker.py,sha256=Ni5gPeDPk9Rz4_cbg63u7Y6LV
 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.7.dist-info/METADATA,sha256=xcM1OD1cAy83Rz4OaFYnHsHO8-DgNBrP0zEX9-_uX3I,14728
+nedo_vision_worker-1.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nedo_vision_worker-1.2.7.dist-info/entry_points.txt,sha256=LrglS-8nCi8C_PL_pa6uxdgCe879hBETHDVXAckvs-8,60
+nedo_vision_worker-1.2.7.dist-info/top_level.txt,sha256=vgilhlkyD34YsEKkaBabmhIpcKSvF3XpzD2By68L-XI,19
+nedo_vision_worker-1.2.7.dist-info/RECORD,,