nedo-vision-worker 1.2.6__tar.gz → 1.2.7__tar.gz

{nedo_vision_worker-1.2.6 → nedo_vision_worker-1.2.7}/PKG-INFO

@@ -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 → nedo_vision_worker-1.2.7}/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-1.2.6 → nedo_vision_worker-1.2.7}/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-1.2.6 → nedo_vision_worker-1.2.7}/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-1.2.6 → nedo_vision_worker-1.2.7}/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-1.2.7/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-1.2.6 → nedo_vision_worker-1.2.7}/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-1.2.6 → nedo_vision_worker-1.2.7}/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-1.2.7/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-1.2.6 → nedo_vision_worker-1.2.7}/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-1.2.6 → nedo_vision_worker-1.2.7}/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 → nedo_vision_worker-1.2.7}/nedo_vision_worker.egg-info/PKG-INFO

@@ -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 → nedo_vision_worker-1.2.7}/nedo_vision_worker.egg-info/SOURCES.txt

@@ -63,6 +63,7 @@ nedo_vision_worker/services/DirectDeviceToRTMPStreamer.py
 nedo_vision_worker/services/FileToRTMPServer.py
 nedo_vision_worker/services/GrpcClientBase.py
 nedo_vision_worker/services/GrpcClientManager.py
+nedo_vision_worker/services/GrpcConnection.py
 nedo_vision_worker/services/ImageUploadClient.py
 nedo_vision_worker/services/PPEDetectionClient.py
 nedo_vision_worker/services/RTSPtoRTMPStreamer.py
@@ -94,6 +95,7 @@ nedo_vision_worker/worker/DatasetFrameWorker.py
 nedo_vision_worker/worker/PPEDetectionManager.py
 nedo_vision_worker/worker/PipelineActionWorker.py
 nedo_vision_worker/worker/PipelineImageWorker.py
+nedo_vision_worker/worker/PipelinePreviewWorker.py
 nedo_vision_worker/worker/RabbitMQListener.py
 nedo_vision_worker/worker/RestrictedAreaManager.py
 nedo_vision_worker/worker/SystemUsageManager.py

{nedo_vision_worker-1.2.6 → nedo_vision_worker-1.2.7}/nedo_vision_worker.egg-info/requires.txt

@@ -7,12 +7,6 @@ psutil>=5.9.0
 requests>=2.28.0
 SQLAlchemy>=1.4.0
 
-[:platform_machine in "aarch64 armv7l"]
-opencv-python-headless>=4.6.0
-
-[:platform_machine not in "aarch64 armv7l"]
-opencv-python>=4.6.0
-
 [:platform_system != "Darwin" or platform_machine != "arm64"]
 pynvml>=11.4.1
 
@@ -23,3 +17,11 @@ isort>=5.10.0
 mypy>=0.950
 flake8>=4.0.0
 pre-commit>=2.17.0
+
+[opencv]
+
+[opencv:platform_machine in "aarch64 armv7l"]
+opencv-python-headless>=4.6.0
+
+[opencv:platform_machine not in "aarch64 armv7l"]
+opencv-python>=4.6.0

{nedo_vision_worker-1.2.6 → nedo_vision_worker-1.2.7}/pyproject.toml

@@ -56,14 +56,17 @@ dependencies = [
     "psutil>=5.9.0",
     "requests>=2.28.0",
     "SQLAlchemy>=1.4.0",
-    # Computer vision - will use appropriate variant based on platform
-    "opencv-python>=4.6.0; platform_machine not in 'aarch64 armv7l'",
-    "opencv-python-headless>=4.6.0; platform_machine in 'aarch64 armv7l'",
     # NVIDIA GPU support - optional, not available on Apple Silicon
     "pynvml>=11.4.1; platform_system != 'Darwin' or platform_machine != 'arm64'",
 ]
 
 [project.optional-dependencies]
+# OpenCV dependencies - use this if not using system packages or custom build
+opencv = [
+    # Computer vision - will use appropriate variant based on platform
+    "opencv-python>=4.6.0; platform_machine not in 'aarch64 armv7l'",
+    "opencv-python-headless>=4.6.0; platform_machine in 'aarch64 armv7l'",
+]
 dev = [
     "pytest>=7.0.0",
     "black>=22.0.0",