nedo-vision-worker 1.0.0__py3-none-any.whl

nedo_vision_worker/services/GrpcClientBase.py

@@ -0,0 +1,155 @@
+import grpc
+import logging
+import time
+from grpc import StatusCode
+
+logger = logging.getLogger(__name__)
+
+# Global callback for authentication failures
+_auth_failure_callback = None
+
+def set_auth_failure_callback(callback):
+    """Set a global callback to be called when authentication failures occur."""
+    global _auth_failure_callback
+    _auth_failure_callback = callback
+
+def _notify_auth_failure():
+    """Notify the registered callback about authentication failure."""
+    global _auth_failure_callback
+    if _auth_failure_callback:
+        _auth_failure_callback()
+
+class GrpcClientBase:
+    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.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.
+        """
+        attempts = 0
+        while attempts < self.max_retries and not self.connected:
+            try:
+                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.")
+
+                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
+
+            except grpc.RpcError 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)
+
+                if attempts < self.max_retries:
+                    sleep_time = retry_interval * (2 ** (attempts - 1))  # Exponential backoff
+                    logger.info("⏳ [APP] Retrying in %d seconds...", sleep_time)
+                    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.
+
+        Args:
+            rpc_call: The RPC method to call.
+            *args: Positional arguments for the RPC call.
+            **kwargs: Keyword arguments for the RPC call.
+
+        Returns:
+            The RPC response or None if an error occurs.
+        """
+        try:
+            response = rpc_call(*args, **kwargs)
+            return response
+
+        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
+
+    @staticmethod
+    def get_error_message(response):
+        """
+        Extract only the meaningful part of the error message.
+
+        Args:
+            response: The RPC response.
+
+        Returns:
+            str: The error message.
+        """
+        if response and response.get("success"):
+            return None
+        
+        message = response.get("message", "Unknown error") if response else "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)
+            _notify_auth_failure()
+        
+        return message

nedo_vision_worker/services/GrpcClientManager.py

@@ -0,0 +1,141 @@
+import logging
+import threading
+from typing import Dict, Type, Optional
+from .GrpcClientBase import GrpcClientBase
+
+logger = logging.getLogger(__name__)
+
+class GrpcClientManager:
+    """
+    Centralized gRPC client manager that reuses connections and provides singleton access to clients.
+    This optimizes resource usage by sharing connections among multiple workers.
+    """
+    
+    _instance = None
+    _lock = threading.Lock()
+    
+    def __new__(cls):
+        """Singleton pattern implementation."""
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(GrpcClientManager, cls).__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        """Initialize the client manager."""
+        if not hasattr(self, '_initialized'):
+            self._clients: Dict[str, GrpcClientBase] = {}
+            self._clients_lock = threading.RLock()
+            self._server_host = None
+            self._server_port = 50051
+            self._initialized = True
+    
+    def configure(self, server_host: str, server_port: int = 50051):
+        """
+        Configure the manager with server connection details.
+        
+        Args:
+            server_host (str): The gRPC server host
+            server_port (int): The gRPC server port
+        """
+        with self._clients_lock:
+            self._server_host = server_host
+            self._server_port = server_port
+            logger.info(f"🔧 [GrpcClientManager] Configured for server: {server_host}:{server_port}")
+    
+    def get_client(self, client_class: Type[GrpcClientBase], client_key: Optional[str] = None) -> GrpcClientBase:
+        """
+        Get a shared client instance, creating it if it doesn't exist.
+        
+        Args:
+            client_class: The client class to instantiate
+            client_key: Optional unique key for the client (defaults to class name)
+            
+        Returns:
+            GrpcClientBase: The shared client instance
+        """
+        if not self._server_host:
+            raise ValueError("GrpcClientManager not configured. Call configure() first.")
+        
+        key = client_key or client_class.__name__
+        
+        with self._clients_lock:
+            if key not in self._clients:
+                logger.info(f"🚀 [GrpcClientManager] Creating new shared client: {key}")
+                client = client_class(self._server_host, self._server_port)
+                self._clients[key] = client
+            else:
+                logger.debug(f"♻️ [GrpcClientManager] Reusing existing client: {key}")
+            
+            return self._clients[key]
+    
+    def close_client(self, client_key: str):
+        """
+        Close and remove a specific client.
+        
+        Args:
+            client_key (str): The key of the client to close
+        """
+        with self._clients_lock:
+            if client_key in self._clients:
+                try:
+                    self._clients[client_key].close()
+                    logger.info(f"🔌 [GrpcClientManager] Closed client: {client_key}")
+                except Exception as e:
+                    logger.warning(f"⚠️ [GrpcClientManager] Error closing client {client_key}: {e}")
+                finally:
+                    del self._clients[client_key]
+    
+    def close_all_clients(self):
+        """Close all managed clients."""
+        with self._clients_lock:
+            for key in list(self._clients.keys()):
+                self.close_client(key)
+            logger.info("🔌 [GrpcClientManager] All clients closed")
+    
+    def get_active_clients(self) -> Dict[str, str]:
+        """
+        Get information about active clients.
+        
+        Returns:
+            Dict[str, str]: Dictionary mapping client keys to their class names
+        """
+        with self._clients_lock:
+            return {key: client.__class__.__name__ for key, client in self._clients.items()}
+    
+    def reconnect_all_clients(self):
+        """Reconnect all managed clients (useful after network issues)."""
+        with self._clients_lock:
+            reconnected = 0
+            for key, client in self._clients.items():
+                try:
+                    if hasattr(client, 'connect') and hasattr(client, 'stub'):
+                        # Get the stub class from the existing client
+                        stub_class = type(client.stub)
+                        client.connect(stub_class)
+                        reconnected += 1
+                        logger.info(f"🔄 [GrpcClientManager] Reconnected client: {key}")
+                except Exception as e:
+                    logger.warning(f"⚠️ [GrpcClientManager] Failed to reconnect client {key}: {e}")
+            
+            logger.info(f"🔄 [GrpcClientManager] Reconnected {reconnected}/{len(self._clients)} clients")
+    
+    @classmethod
+    def get_instance(cls) -> 'GrpcClientManager':
+        """Get the singleton instance."""
+        return cls()
+    
+    @classmethod
+    def get_shared_client(cls, client_class: Type[GrpcClientBase], client_key: Optional[str] = None) -> GrpcClientBase:
+        """
+        Convenience method to get a shared client without explicitly getting the manager instance.
+        
+        Args:
+            client_class: The client class to instantiate
+            client_key: Optional unique key for the client
+            
+        Returns:
+            GrpcClientBase: The shared client instance
+        """
+        return cls.get_instance().get_client(client_class, client_key)

nedo_vision_worker/services/ImageUploadClient.py

@@ -0,0 +1,82 @@
+from .GrpcClientBase import GrpcClientBase
+from ..protos.VisionWorkerService_pb2_grpc import ImageServiceStub
+from ..protos.VisionWorkerService_pb2 import LastImageDateRequest, UploadImageRequest
+
+
+class ImageUploadClient(GrpcClientBase):
+    def __init__(self, server_host: str, server_port: int = 50051):
+        """
+        Initialize the image upload client.
+
+        Args:
+            server_host (str): The server hostname or IP address.
+            server_port (int): The server port. Default is 50051.
+        """
+        super().__init__(server_host, server_port)
+
+    def get_last_uploaded_date(self, device_id: str):
+        """
+        Retrieve the last uploaded image date from the server.
+
+        Args:
+            device_id (str): The unique device ID.
+
+        Returns:
+            dict: A dictionary containing the last upload date and additional information.
+        """
+        self.connect(ImageServiceStub)  # Ensure connection and stub are established
+
+        try:
+            # Prepare the request with the device_id
+            request = LastImageDateRequest(device_id=device_id)
+            response = self.handle_rpc(self.stub.GetLastImageDate, request)
+
+            if response and response.success:
+                return {
+                    "success": True,
+                    "last_uploaded_date": response.last_uploaded_date,
+                    "message": response.message,
+                }
+            return {
+                "success": False,
+                "message": response.message if response else "Unknown error",
+            }
+        except Exception as e:
+            return {"success": False, "message": str(e)}
+
+    def upload_image(self, device_id: str, metadata: str, image_path: str):
+        """
+        Upload an image to the server.
+
+        Args:
+            device_id (str): The unique device ID.
+            metadata (str): Metadata as a JSON string.
+            image_path (str): Path to the image file.
+
+        Returns:
+            dict: A dictionary containing the result of the upload operation.
+        """
+        self.connect(ImageServiceStub)  # Ensure connection and stub are established
+
+        try:
+            # Read the image file
+            with open(image_path, "rb") as file:
+                image_data = file.read()
+
+            # Create the request
+            request = UploadImageRequest(
+                device_id=device_id,
+                metadata=metadata,
+                image_data=image_data,
+            )
+
+            # Call the RPC
+            response = self.handle_rpc(self.stub.UploadImage, request)
+
+            if response and response.success:
+                return {"success": True, "message": response.message}
+            return {"success": False, "message": response.message if response else "Unknown error"}
+        except FileNotFoundError:
+            return {"success": False, "message": f"File not found: {image_path}"}
+        except Exception as e:
+            return {"success": False, "message": str(e)}

nedo_vision_worker/services/PPEDetectionClient.py

@@ -0,0 +1,108 @@
+import logging
+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__)
+
+class PPEDetectionClient(GrpcClientBase):
+    def __init__(self, server_host: str, server_port: int = 50051):
+        """
+        Initialize the PPE Detection Batch Client.
+
+        Args:
+            server_host (str): The server hostname or IP address.
+            server_port (int): The server port. Default is 50051.
+        """
+        super().__init__(server_host, server_port)
+
+        try:
+            self.connect(PPEDetectionGRPCServiceStub)
+        except Exception as e:
+            logger.error(f"Failed to connect to gRPC server: {e}")
+            self.stub = None
+        
+        self.repository = PPEDetectionRepository()
+
+    @staticmethod
+    def read_image_as_binary(image_path: str) -> bytes:
+        """
+        Reads an image file and returns its binary content.
+
+        Args:
+            image_path (str): Path to the image file.
+
+        Returns:
+            bytes: Binary content of the image.
+        """
+        with open(image_path, 'rb') as image_file:
+            return image_file.read()
+
+    def send_upsert_batch(self, worker_id: str, worker_source_id: str, detection_data: list, token: str) -> dict:
+        """
+        Sends a batch of PPE detection requests to the server using token authentication.
+
+        Args:
+            worker_id (str): The worker ID for the detection.
+            worker_source_id (str): The worker source ID for the detection.
+            detection_data (list): A list of dictionaries containing PPE detection data.
+            token (str): Authentication token for the worker.
+
+        Returns:
+            dict: A dictionary containing the result of sending the batch request.
+        """
+        if not self.stub:
+            return {"success": False, "message": "gRPC connection is not established."}
+
+        try:
+            # Prepare the list of UpsertPPEDetectionRequest messages
+            ppe_detection_requests = []
+            for data in detection_data:
+                image_binary = self.read_image_as_binary(data['image'])
+                image_tile_binary = self.read_image_as_binary(data['image_tile'])
+
+                ppe_detection_labels = [
+                    PPEDetectionLabelRequest(
+                        code=label['code'],
+                        confidence_score=label['confidence_score'],
+                        b_box_x1=label['b_box_x1'],
+                        b_box_y1=label['b_box_y1'],
+                        b_box_x2=label['b_box_x2'],
+                        b_box_y2=label['b_box_y2'],
+                    )
+                    for label in data['ppe_detection_labels']
+                ]
+                source = data['worker_source_id']
+                request = UpsertPPEDetectionRequest(
+                    person_id=data['person_id'],
+                    worker_id=worker_id,
+                    worker_source_id=source,
+                    image=image_binary,
+                    image_tile=image_tile_binary,
+                    worker_timestamp=data['worker_timestamp'],
+                    ppe_detection_labels=ppe_detection_labels,
+                    token=token
+                )
+                ppe_detection_requests.append(request)
+
+            # Create the UpsertPPEDetectionBatchRequest
+            batch_request = UpsertPPEDetectionBatchRequest(
+                ppe_detection_requests=ppe_detection_requests,
+                token=token
+            )
+
+            # Call the UpsertBatch RPC
+            response = self.handle_rpc(self.stub.UpsertBatch, batch_request)
+            
+            if response and response.success:
+                self.repository.delete_records_from_db(detection_data)
+                return {"success": True, "message": response.message}
+
+            return {"success": False, "message": response.message if response else "Unknown error"}
+
+        except Exception as e:
+            logger.error(f"Error sending batch PPE detection: {e}")
+            return {"success": False, "message": f"Error occurred: {e}"}

nedo_vision_worker/services/RTSPtoRTMPStreamer.py

@@ -0,0 +1,98 @@
+import subprocess
+import logging
+import time
+import os
+from urllib.parse import urlparse
+
+class RTSPtoRTMPStreamer:
+    def __init__(self, rtsp_url, rtmp_url, stream_key, fps=30, resolution="1280x720", duration=120):
+        """
+        Initialize the streamer.
+
+        Args:
+            rtsp_url (str): The RTSP stream URL (e.g., from an IP camera).
+            rtmp_url (str): The RTMP server URL (without stream key).
+            stream_key (str): The unique stream key for RTMP.
+            fps (int): Frames per second for output stream.
+            resolution (str): Resolution of the output stream.
+            duration (int): Duration in seconds to stream.
+        """
+        self.rtsp_url = rtsp_url
+        self.rtmp_url = f"{rtmp_url}/{stream_key}"
+        self.fps = fps
+        self.resolution = resolution
+        self.duration = duration
+        self.stream_key = stream_key
+        self.process = None
+
+    def _detect_stream_type(self, url):
+        """Detect the type of input stream."""
+        parsed_url = urlparse(url)
+        return "rtsp" if parsed_url.scheme == "rtsp" else "unknown"
+    
+    def start_stream(self):
+        """Start streaming RTSP to RTMP using FFmpeg without logs."""
+        if self._detect_stream_type(self.rtsp_url) == "unknown":
+            logging.error(f"❌ [APP] Invalid RTSP URL: {self.rtsp_url}")
+            return
+
+        logging.info(f"📡 [APP] Starting RTSP to RTMP stream: {self.rtsp_url} → {self.rtmp_url} for {self.duration} seconds")
+
+        # FFmpeg command
+        ffmpeg_command = [
+            "ffmpeg",
+            "-rtsp_transport", "tcp",  # 🚀 Use TCP
+            "-fflags", "nobuffer",  # 🚀 Reduce internal buffering
+            "-flags", "low_delay",  # 🚀 Enable low-latency mode
+            "-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
+            "-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
+
+            # ❌ Disable Audio (Avoid unnecessary encoding overhead)
+            "-an",
+
+            # ✅ Output RTMP Stream
+            "-f", "flv",
+            self.rtmp_url
+        ]
+
+        try:
+            with open(os.devnull, "w") as devnull:
+                self.process = subprocess.Popen(
+                    ffmpeg_command,
+                    stdout=devnull,  # Redirect stdout to null
+                    stderr=devnull,  # Redirect stderr to null
+                    text=True
+                )
+
+            logging.info("✅ [APP] FFmpeg process started successfully.")
+
+            start_time = time.time()
+            while self.process.poll() is None:
+                if time.time() - start_time > self.duration:
+                    logging.info(f"⏳ [APP] Streaming duration {self.duration}s reached. Stopping stream...")
+                    self.stop_stream()
+                    break
+                time.sleep(1)
+
+        except Exception as e:
+            logging.error(f"🚨 [APP] Failed to start FFmpeg: {e}")
+            self.stop_stream()
+    
+    def stop_stream(self):
+        """Stop the streaming process."""
+        if self.process:
+            self.process.terminate()
+            self.process.wait()
+            logging.info("FFmpeg process terminated.")

nedo_vision_worker/services/RestrictedAreaClient.py

@@ -0,0 +1,100 @@
+import logging
+from ..repositories.RestrictedAreaRepository import RestrictedAreaRepository
+from .GrpcClientBase import GrpcClientBase
+from ..protos.HumanDetectionService_pb2_grpc import HumanDetectionGRPCServiceStub
+from ..protos.HumanDetectionService_pb2 import (
+    UpsertHumanDetectionBatchRequest,
+    UpsertHumanDetectionRequest,
+)
+
+logger = logging.getLogger(__name__)
+
+class RestrictedAreaClient(GrpcClientBase):
+    def __init__(self, server_host: str, server_port: int = 50051):
+        """
+        Initialize the Restricted Area Violation Client.
+
+        Args:
+            server_host (str): The server hostname or IP address.
+            server_port (int): The server port. Default is 50051.
+        """
+        super().__init__(server_host, server_port)
+
+        try:
+            self.connect(HumanDetectionGRPCServiceStub)
+        except Exception as e:
+            logger.error(f"Failed to connect to gRPC server: {e}")
+            self.stub = None
+
+        self.repository = RestrictedAreaRepository()
+
+    @staticmethod
+    def read_image_as_binary(image_path: str) -> bytes:
+        """
+        Reads an image file and returns its binary content.
+
+        Args:
+            image_path (str): Path to the image file.
+
+        Returns:
+            bytes: Binary content of the image.
+        """
+        with open(image_path, 'rb') as image_file:
+            return image_file.read()
+
+    def send_upsert_batch(self, worker_id: str, worker_source_id: str, violation_data: list, token: str) -> dict:
+        """
+        Sends a batch of restricted area violation records to the server using token authentication.
+
+        Args:
+            worker_id (str): The worker ID for the violation.
+            worker_source_id (str): The worker source ID for the violation.
+            violation_data (list): A list of dictionaries representing the violations.
+            token (str): Authentication token for the worker.
+
+        Returns:
+            dict: A dictionary containing the result of the batch request.
+        """
+        if not self.stub:
+            return {"success": False, "message": "gRPC connection is not established."}
+
+        try:
+            human_detection_requests = []
+
+            for data in violation_data:
+                image_binary = self.read_image_as_binary(data['image'])
+                image_tile_binary = self.read_image_as_binary(data['image_tile'])
+
+                request = UpsertHumanDetectionRequest(
+                    person_id=data['person_id'],
+                    worker_id=worker_id,
+                    worker_source_id=data['worker_source_id'],
+                    image=image_binary,
+                    image_tile=image_tile_binary,
+                    worker_timestamp=data['worker_timestamp'],
+                    confidence_score=data['confidence_score'],
+                    b_box_x1=data['b_box_x1'],
+                    b_box_y1=data['b_box_y1'],
+                    b_box_x2=data['b_box_x2'],
+                    b_box_y2=data['b_box_y2'],
+                    token=token,
+                )
+
+                human_detection_requests.append(request)
+
+            batch_request = UpsertHumanDetectionBatchRequest(
+                human_detection_requests=human_detection_requests,
+                token=token
+            )
+
+            response = self.handle_rpc(self.stub.UpsertBatch, batch_request)
+
+            if response and response.success:
+                self.repository.delete_records_from_db(violation_data)
+                return {"success": True, "message": response.message}
+
+            return {"success": False, "message": response.message if response else "Unknown error"}
+
+        except Exception as e:
+            logger.error(f"Error sending batch restricted area violation data: {e}")
+            return {"success": False, "message": f"Error occurred: {e}"}