nedo-vision-worker 1.1.2__py3-none-any.whl → 1.2.0__py3-none-any.whl

nedo_vision_worker/services/GrpcClientBase.py

@@ -2,154 +2,188 @@ import grpc
 import logging
 import time
 from grpc import StatusCode
+from typing import Callable, Optional, Any, Dict
 
 logger = logging.getLogger(__name__)
 
-# Global callback for authentication failures
-_auth_failure_callback = None
+_auth_failure_callback: Optional[Callable[[], None]] = None
 
-def set_auth_failure_callback(callback):
-    """Set a global callback to be called when authentication failures occur."""
+def set_auth_failure_callback(callback: Callable[[], None]) -> None:
     global _auth_failure_callback
     _auth_failure_callback = callback
 
-def _notify_auth_failure():
-    """Notify the registered callback about authentication failure."""
-    global _auth_failure_callback
+def _notify_auth_failure() -> None:
     if _auth_failure_callback:
-        _auth_failure_callback()
+        try:
+            _auth_failure_callback()
+        except Exception as e:
+            logger.error(f"❌ Auth callback error: {e}")
+
 
 class GrpcClientBase:
+    ERROR_HANDLERS = {
+        StatusCode.UNAVAILABLE: ("⚠️", "warning", "Server unavailable"),
+        StatusCode.DEADLINE_EXCEEDED: ("⏳", "error", "Request timeout"),
+        StatusCode.PERMISSION_DENIED: ("🚫", "error", "Permission denied"),
+        StatusCode.UNAUTHENTICATED: ("🔑", "error", "Authentication failed"),
+        StatusCode.INVALID_ARGUMENT: ("⚠️", "error", "Invalid argument"),
+        StatusCode.NOT_FOUND: ("🔍", "error", "Resource not found"),
+        StatusCode.INTERNAL: ("💥", "error", "Internal server error"),
+        StatusCode.CANCELLED: ("🛑", "warning", "Request cancelled"),
+        StatusCode.ALREADY_EXISTS: ("📁", "warning", "Resource exists"),
+        StatusCode.RESOURCE_EXHAUSTED: ("🔋", "error", "Resources exhausted"),
+        StatusCode.FAILED_PRECONDITION: ("⚡", "error", "Precondition failed"),
+        StatusCode.ABORTED: ("🔄", "error", "Request aborted"),
+        StatusCode.OUT_OF_RANGE: ("📏", "error", "Value out of range"),
+        StatusCode.UNIMPLEMENTED: ("🚧", "error", "Method not implemented"),
+        StatusCode.DATA_LOSS: ("💿", "critical", "Data loss detected"),
+    }
+
     def __init__(self, server_host: str, server_port: int = 50051, max_retries: int = 3):
-        """
-        Initialize the gRPC client base.
-
-        Args:
-            server_host (str): The server hostname or IP address.
-            server_port (int): The server port. Default is 50051.
-            max_retries (int): Maximum number of reconnection attempts.
-        """
         self.server_address = f"{server_host}:{server_port}"
-        self.channel = None
-        self.stub = None
+        self.channel: Optional[grpc.Channel] = None
+        self.stub: Optional[Any] = None
         self.connected = False
         self.max_retries = max_retries
 
-    def connect(self, stub_class, retry_interval: int = 2):
-        """
-        Create a gRPC channel and stub, with retry logic if the server is unavailable.
-
-        Args:
-            stub_class: The gRPC stub class for the service.
-            retry_interval (int): Initial time in seconds between reconnection attempts.
-        """
+    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)
-                try:
-                    future.result(timeout=30)
-                except grpc.FutureTimeoutError:
-                    raise grpc.RpcError("gRPC connection timed out.")
+                future.result(timeout=30)
 
                 self.stub = stub_class(self.channel)
                 self.connected = True
-                logger.info("🚀 [APP] Successfully connected to gRPC server at %s", self.server_address)
-                return  # Exit if successful
+                logger.info(f"🚀 Connected to gRPC server at {self.server_address}")
+                return True
 
-            except grpc.RpcError as e:
+            except (grpc.RpcError, grpc.FutureTimeoutError, Exception) as e:
                 attempts += 1
                 self.connected = False
-
-                error_message = getattr(e, "details", lambda: str(e))()
-                logger.error("⚠️ [APP] Failed to connect (%d/%d): %s", attempts, self.max_retries, error_message)
+                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))  # Exponential backoff
-                    logger.info("⏳ [APP] Retrying in %d seconds...", sleep_time)
+                    sleep_time = retry_interval * (2 ** (attempts - 1))
+                    logger.info(f"⏳ Retrying in {sleep_time}s...")
                     time.sleep(sleep_time)
                 else:
-                    logger.critical("❌ [APP] Maximum retries reached. Could not connect to gRPC server.")
-
-            except Exception as e:
-                logger.critical("🚨 [APP] Unexpected error during gRPC initialization: %s", str(e))
-                break  # Stop retrying if an unexpected error occurs
-
-    def close(self):
-        """
-        Close the gRPC channel.
-        """
-        if self.channel:
-            self.channel.close()
-            self.connected = False
-            logger.info("🔌 [APP] gRPC channel closed.")
-
-    def handle_rpc(self, rpc_call, *args, **kwargs):
-        """
-        Handle an RPC call with error handling.
+                    logger.critical("❌ Max retries reached. Connection failed.")
 
-        Args:
-            rpc_call: The RPC method to call.
-            *args: Positional arguments for the RPC call.
-            **kwargs: Keyword arguments for the RPC call.
+        return False
 
-        Returns:
-            The RPC response or None if an error occurs.
-        """
+    def _close_channel(self) -> None:
         try:
-            response = rpc_call(*args, **kwargs)
-            return response
+            if self.channel:
+                self.channel.close()
+        except Exception as e:
+            logger.warning(f"⚠️ Error closing channel: {e}")
+        finally:
+            self.channel = None
+            self.stub = None
+
+    def close(self) -> None:
+        self._close_channel()
+        self.connected = False
+        logger.info("🔌 gRPC connection closed")
+
+    def handle_rpc(self, rpc_call: Callable, *args, **kwargs) -> Optional[Any]:
+        if not self.is_connected():
+            logger.error("❌ Not connected. Cannot make RPC call")
+            return None
 
+        try:
+            return rpc_call(*args, **kwargs)
         except grpc.RpcError as e:
-            status_code = e.code()
-
-            # ✅ Extract only the meaningful part of the error message
-            error_message = getattr(e, "details", lambda: str(e))()
-            error_clean = error_message.split("debug_error_string")[0].strip()
-
-            self.connected = False  # Mark as disconnected for reconnection
-
-            if status_code == StatusCode.UNAVAILABLE:
-                logger.warning("⚠️ [APP] Server unavailable. Attempting to reconnect... (Error: %s)", error_clean)
-                self.connect(type(self.stub))  # Attempt to reconnect
-            elif status_code == StatusCode.DEADLINE_EXCEEDED:
-                logger.error("⏳ [APP] RPC timeout error. (Error: %s)", error_clean)
-            elif status_code == StatusCode.PERMISSION_DENIED:
-                logger.error("🚫 [APP] RPC call failed: Permission denied. (Error: %s)", error_clean)
-            elif status_code == StatusCode.UNAUTHENTICATED:
-                logger.error("🔑 [APP] Authentication failed. (Error: %s)", error_clean)
-                _notify_auth_failure()  # Notify about authentication failure
-            elif status_code == StatusCode.INVALID_ARGUMENT:
-                logger.error("⚠️ [APP] Invalid argument in RPC call. (Error: %s)", error_clean)
-            elif status_code == StatusCode.NOT_FOUND:
-                logger.error("🔍 [APP] Requested resource not found. (Error: %s)", error_clean)
-            elif status_code == StatusCode.INTERNAL:
-                logger.error("💥 [APP] Internal server error encountered. (Error: %s)", error_clean)
-            else:
-                logger.error("❌ [APP] Unhandled gRPC error: %s (Code: %s)", error_clean, status_code)
-
-            return None  # Ensure the caller handles the failure
+            return self._handle_grpc_error(e, rpc_call, *args, **kwargs)
+        except Exception as e:
+            logger.error(f"💥 Unexpected RPC error: {e}")
+            return None
 
-    @staticmethod
-    def get_error_message(response):
-        """
-        Extract only the meaningful part of the error message.
+    def _handle_grpc_error(self, e: grpc.RpcError, rpc_call: Callable, *args, **kwargs) -> Optional[Any]:
+        status_code = e.code()
+        error_message = self._extract_error_message(e)
+        
+        emoji, log_level, description = self.ERROR_HANDLERS.get(
+            status_code, ("❌", "error", f"Unhandled error (Code: {status_code})")
+        )
 
-        Args:
-            response: The RPC response.
+        getattr(logger, log_level)(f"{emoji} {description}: {error_message}")
 
-        Returns:
-            str: The error message.
-        """
-        if response and response.get("success"):
+        if status_code == StatusCode.UNAVAILABLE:
+            return self._handle_unavailable(rpc_call, *args, **kwargs)
+        elif status_code in {StatusCode.UNAUTHENTICATED, StatusCode.PERMISSION_DENIED}:
+            self._handle_auth_error(error_message)
+        
+        if status_code in {StatusCode.UNAVAILABLE, StatusCode.DEADLINE_EXCEEDED}:
+            self.connected = False
+
+        return None
+
+    def _handle_unavailable(self, rpc_call: Callable, *args, **kwargs) -> Optional[Any]:
+        self.connected = False
+        
+        if self.stub:
+            stub_class = type(self.stub)
+            logger.info("🔄 Reconnecting...")
+            
+            if self.connect(stub_class):
+                logger.info("✅ Reconnected. Retrying...")
+                try:
+                    return rpc_call(*args, **kwargs)
+                except Exception as e:
+                    logger.error(f"❌ Retry failed: {e}")
+        
+        return None
+
+    def _handle_auth_error(self, error_message: str) -> None:
+        auth_keywords = ["authentication", "token", "unauthorized", "invalid token"]
+        if any(keyword in error_message.lower() for keyword in auth_keywords):
+            logger.error(f"🔑 Auth failure: {error_message}")
+            _notify_auth_failure()
+
+    def _extract_error_message(self, e: grpc.RpcError) -> str:
+        error_message = getattr(e, "details", lambda: str(e))()
+        return error_message.split("debug_error_string")[0].strip()
+
+    def is_connected(self) -> bool:
+        return self.connected and self.channel and self.stub
+
+    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,
+            "has_stub": self.stub is not None
+        }
+
+    @staticmethod
+    def get_error_message(response: Optional[Dict]) -> Optional[str]:
+        if not response:
+            return "Unknown error"
+            
+        if response.get("success"):
             return None
         
-        message = response.get("message", "Unknown error") if response else "Unknown error"
+        message = response.get("message", "Unknown error")
         
-        # Check for authentication failure in the message
-        if message and ("Invalid authentication token" in message or "authentication" in message.lower()):
-            logger.error("🔑 [APP] Authentication failure detected in response: %s", message)
+        auth_keywords = ["Invalid authentication token", "authentication", "unauthorized"]
+        if message and any(keyword in message for keyword in auth_keywords):
+            logger.error(f"🔑 Auth failure in response: {message}")
             _notify_auth_failure()
         
-        return message
+        return message
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()

nedo_vision_worker/services/PPEDetectionClient.py

@@ -3,8 +3,6 @@ from .GrpcClientBase import GrpcClientBase
 from ..protos.PPEDetectionService_pb2_grpc import PPEDetectionGRPCServiceStub
 from ..protos.PPEDetectionService_pb2 import UpsertPPEDetectionBatchRequest, UpsertPPEDetectionRequest, PPEDetectionLabelRequest
 from ..repositories.PPEDetectionRepository import PPEDetectionRepository 
-import json
-import os
 
 logger = logging.getLogger(__name__)
 
@@ -38,11 +36,6 @@ class PPEDetectionClient(GrpcClientBase):
         Returns:
             bytes: Binary content of the image.
         """
-        from ..database.DatabaseManager import get_storage_path
-        from pathlib import Path
-        import os
-        if not os.path.isabs(image_path):
-            image_path = str(get_storage_path("files") / Path(image_path).relative_to("data/files"))
         with open(image_path, 'rb') as image_file:
             return image_file.read()
 

nedo_vision_worker/services/RestrictedAreaClient.py

@@ -39,11 +39,6 @@ class RestrictedAreaClient(GrpcClientBase):
         Returns:
             bytes: Binary content of the image.
         """
-        from ..database.DatabaseManager import get_storage_path
-        from pathlib import Path
-        import os
-        if not os.path.isabs(image_path):
-            image_path = str(get_storage_path("restricted_violations") / Path(image_path).relative_to("data/restricted_violations"))
         with open(image_path, 'rb') as image_file:
             return image_file.read()
 

nedo_vision_worker/services/SharedDirectDeviceClient.py

@@ -0,0 +1,278 @@
+import logging
+import threading
+import time
+import cv2
+import platform
+import ffmpeg
+from typing import Dict
+from .SystemWideDeviceCoordinator import get_system_coordinator
+
+
+class SharedDirectDeviceClient:
+    """
+    Client for accessing shared direct video devices.
+    Coordinates with other services to prevent 'device busy' errors.
+    """
+    
+    _instance = None
+    _lock = threading.Lock()
+    
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        if hasattr(self, '_initialized'):
+            return
+            
+        self._initialized = True
+        self.active_devices: Dict[int, Dict] = {}  # device_index -> device_info
+        self.device_locks: Dict[int, threading.Lock] = {}
+        self.main_lock = threading.Lock()
+        
+        logging.info("SharedDirectDeviceClient initialized")
+    
+    def _is_direct_device(self, url) -> tuple:
+        """Check if source is a direct video device and return device index."""
+        if isinstance(url, int):
+            return True, url
+        elif isinstance(url, str) and url.isdigit():
+            return True, int(url)
+        elif isinstance(url, str) and url.startswith('/dev/video'):
+            try:
+                device_index = int(url.replace('/dev/video', ''))
+                return True, device_index
+            except ValueError:
+                pass
+        return False, None
+    
+    def _get_device_path(self, device_index: int) -> str:
+        """Get the appropriate device path based on the platform."""
+        system = platform.system().lower()
+        
+        if system == "linux":
+            return f"/dev/video{device_index}"
+        elif system == "windows":
+            return f"video={device_index}"
+        elif system == "darwin":
+            return f"{device_index}"
+        else:
+            logging.warning(f"Unsupported platform: {system}, using default")
+            return str(device_index)
+    
+    def get_video_properties(self, url) -> tuple:
+        """
+        Get video properties for a direct device using cv2 instead of ffmpeg probe.
+        This is safer for device access coordination.
+        """
+        is_device, device_index = self._is_direct_device(url)
+        
+        if not is_device:
+            logging.error(f"URL {url} is not a direct video device")
+            return None, None, None, "rgb24"
+        
+        with self.main_lock:
+            # Check if device is already being accessed locally
+            if device_index in self.active_devices:
+                device_info = self.active_devices[device_index]
+                return (
+                    device_info['width'],
+                    device_info['height'], 
+                    device_info['fps'],
+                    device_info['pixel_format']
+                )
+        
+        # Check if device is locked by another service
+        coordinator = get_system_coordinator()
+        if coordinator.is_device_locked(device_index):
+            lock_info = coordinator.get_device_lock_info(device_index)
+            service = lock_info.get('service', 'unknown') if lock_info else 'unknown'
+            logging.warning(f"⚠️ Device {device_index} is locked by {service}. Cannot probe properties.")
+            # Return default properties for locked devices
+            return 640, 480, 30.0, "rgb24"
+        
+        # Probe the device safely
+        try:
+            cap = cv2.VideoCapture(device_index)
+            
+            if not cap.isOpened():
+                logging.error(f"Failed to open direct video device: {device_index}")
+                return None, None, None, "rgb24"
+            
+            width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            fps = float(cap.get(cv2.CAP_PROP_FPS))
+            
+            if fps <= 0 or fps > 240:
+                fps = 30.0
+            
+            cap.release()
+            
+            # Store device info for future use
+            with self.main_lock:
+                self.active_devices[device_index] = {
+                    'width': width,
+                    'height': height,
+                    'fps': fps,
+                    'pixel_format': 'rgb24',
+                    'access_count': 0,
+                    'last_access': time.time()
+                }
+                self.device_locks[device_index] = threading.Lock()
+            
+            logging.info(f"Probed device {device_index}: {width}x{height} @ {fps}fps")
+            return width, height, fps, "rgb24"
+            
+        except Exception as e:
+            logging.error(f"Error probing direct video device {device_index}: {e}")
+            return None, None, None, "rgb24"
+    
+    def create_ffmpeg_input(self, url, width: int, height: int, fps: float):
+        """
+        Create an ffmpeg input for a direct device with proper coordination.
+        """
+        is_device, device_index = self._is_direct_device(url)
+        
+        if not is_device:
+            raise ValueError(f"URL {url} is not a direct video device")
+        
+        # Increment access count
+        with self.main_lock:
+            if device_index not in self.active_devices:
+                # This shouldn't happen if get_video_properties was called first
+                logging.warning(f"Device {device_index} not in active devices, initializing...")
+                self.get_video_properties(url)
+            
+            self.active_devices[device_index]['access_count'] += 1
+            self.active_devices[device_index]['last_access'] = time.time()
+            
+            logging.info(f"Creating ffmpeg input for device {device_index} "
+                        f"(access count: {self.active_devices[device_index]['access_count']})")
+        
+        system = platform.system().lower()
+        
+        try:
+            if system == "linux":
+                ffmpeg_input = (
+                    ffmpeg
+                    .input(f"/dev/video{device_index}", format="v4l2", 
+                           framerate=fps, video_size=f"{width}x{height}")
+                )
+            elif system == "windows":
+                ffmpeg_input = (
+                    ffmpeg
+                    .input(f"video={device_index}", format="dshow",
+                           framerate=fps, video_size=f"{width}x{height}")
+                )
+            elif system == "darwin":
+                ffmpeg_input = (
+                    ffmpeg
+                    .input(f"{device_index}", format="avfoundation",
+                           framerate=fps, video_size=f"{width}x{height}")
+                )
+            else:
+                raise ValueError(f"Unsupported platform for direct video streaming: {system}")
+            
+            return ffmpeg_input
+            
+        except Exception as e:
+            # Decrement access count on error
+            with self.main_lock:
+                if device_index in self.active_devices:
+                    self.active_devices[device_index]['access_count'] -= 1
+            raise e
+    
+    def release_device_access(self, url):
+        """
+        Release access to a direct device.
+        """
+        is_device, device_index = self._is_direct_device(url)
+        
+        if not is_device:
+            return
+        
+        with self.main_lock:
+            if device_index in self.active_devices:
+                self.active_devices[device_index]['access_count'] -= 1
+                
+                logging.info(f"Released device {device_index} access "
+                            f"(remaining count: {self.active_devices[device_index]['access_count']})")
+                
+                # Clean up if no more access
+                if self.active_devices[device_index]['access_count'] <= 0:
+                    del self.active_devices[device_index]
+                    if device_index in self.device_locks:
+                        del self.device_locks[device_index]
+                    logging.info(f"Cleaned up device {device_index} resources")
+    
+    def is_device_busy(self, url) -> bool:
+        """
+        Check if a device is currently being accessed.
+        """
+        is_device, device_index = self._is_direct_device(url)
+        
+        if not is_device:
+            return False
+        
+        with self.main_lock:
+            return (device_index in self.active_devices and 
+                    self.active_devices[device_index]['access_count'] > 0)
+    
+    def get_device_access_count(self, url) -> int:
+        """
+        Get the current access count for a device.
+        """
+        is_device, device_index = self._is_direct_device(url)
+        
+        if not is_device:
+            return 0
+        
+        with self.main_lock:
+            if device_index in self.active_devices:
+                return self.active_devices[device_index]['access_count']
+            return 0
+    
+    def get_all_devices_info(self) -> Dict[int, Dict]:
+        """Get information about all active devices."""
+        with self.main_lock:
+            return {
+                device_index: {
+                    'width': info['width'],
+                    'height': info['height'],
+                    'fps': info['fps'],
+                    'pixel_format': info['pixel_format'],
+                    'access_count': info['access_count'],
+                    'last_access': info['last_access'],
+                    'time_since_last_access': time.time() - info['last_access']
+                }
+                for device_index, info in self.active_devices.items()
+            }
+    
+    def cleanup_stale_devices(self, max_idle_time: float = 300.0):
+        """
+        Clean up devices that haven't been accessed for a while.
+        """
+        current_time = time.time()
+        stale_devices = []
+        
+        with self.main_lock:
+            for device_index, info in self.active_devices.items():
+                if (current_time - info['last_access']) > max_idle_time and info['access_count'] <= 0:
+                    stale_devices.append(device_index)
+            
+            for device_index in stale_devices:
+                del self.active_devices[device_index]
+                if device_index in self.device_locks:
+                    del self.device_locks[device_index]
+                logging.info(f"Cleaned up stale device {device_index}")
+    
+    def shutdown(self):
+        """Shutdown the client and clean up all resources."""
+        logging.info("Shutting down SharedDirectDeviceClient")
+        
+        with self.main_lock:
+            self.active_devices.clear()
+            self.device_locks.clear()