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

nedo_vision_worker/worker/PPEDetectionManager.py

@@ -0,0 +1,86 @@
+import logging
+import threading
+import time
+from ..services.PPEDetectionClient import PPEDetectionClient
+from ..repositories.PPEDetectionRepository import PPEDetectionRepository
+from ..util.Networking import Networking
+
+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 PPEDetectionManager:
+    def __init__(self, server_host: str, worker_id: str, worker_source_id: str, token: str):
+        """
+        Handles PPE detection monitoring and reporting.
+
+        Args:
+            server_host (str): The gRPC server host.
+            worker_id (str): Unique worker ID (passed externally).
+            worker_source_id (str): Unique worker source ID (passed externally).
+            token (str): Authentication token for the worker.
+        """
+        if not worker_id or not worker_source_id:
+            raise ValueError("⚠️ [APP] 'worker_id' and 'worker_source_id' cannot be empty.")
+        if not token:
+            raise ValueError("⚠️ [APP] 'token' cannot be empty.")
+
+        self.ppe_detection_client = PPEDetectionClient(server_host)
+        self.server_host = server_host
+        self.worker_id = worker_id
+        self.worker_source_id = worker_source_id
+        self.token = token
+        self.ppe_detection_data = []
+        self.stop_event = threading.Event()
+        self.ppe_detection_thread = None
+        self.ppe_detection_repo = PPEDetectionRepository()
+
+        self._start_ppe_detection_monitoring()
+
+    def _start_ppe_detection_monitoring(self):
+        """Starts a background thread to monitor and collect PPE detection data."""
+        if self.ppe_detection_thread and self.ppe_detection_thread.is_alive():
+            logger.warning("⚠️ [APP] PPE detection monitoring thread is already running.")
+            return
+
+        logger.info("📡 [APP] PPE detection monitoring started.")
+
+
+    def send_ppe_detection_batch(self):
+        """Sends a batch of collected PPE detection data to the server."""
+        try:
+            self.ppe_detection_data = self.ppe_detection_repo.get_latest_5_detections()
+            if not self.ppe_detection_data:
+                return
+
+            response = self.ppe_detection_client.send_upsert_batch(
+                worker_id=self.worker_id,
+                worker_source_id=self.worker_source_id,
+                detection_data=self.ppe_detection_data,
+                token=self.token
+            )
+
+            if response.get("success"):
+                logger.info("✅ [APP] Successfully sent PPE detection batch.")
+                self.ppe_detection_data.clear() 
+            else:
+                logger.error(f"❌ [APP] Failed to send PPE detection batch: {response.get('message')}")
+
+        except Exception as e:
+            logger.error("🚨 [APP] Error sending PPE detection batch.", exc_info=True)
+
+    def close(self):
+        """Closes the PPE detection client and stops the monitoring thread."""
+        self.stop_event.set()
+
+        if self.ppe_detection_thread and self.ppe_detection_thread.is_alive():
+            safe_join_thread(self.ppe_detection_thread)
+            logger.info("🔌 [APP] PPE detection monitoring thread stopped.")
+
+        if self.ppe_detection_client:
+            logger.info("✅ [APP] PPE Detection Client closed.")

nedo_vision_worker/worker/PipelineActionWorker.py

@@ -0,0 +1,129 @@
+import threading
+import logging
+import json
+from ..repositories.WorkerSourcePipelineDebugRepository import WorkerSourcePipelineDebugRepository
+from ..repositories.WorkerSourcePipelineRepository import WorkerSourcePipelineRepository
+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 PipelineActionWorker:
+    def __init__(self, config: dict):
+        """
+        Initialize Pipeline Action Worker.
+
+        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()
+
+        self.repo = WorkerSourcePipelineRepository()
+        self.debug_repo = WorkerSourcePipelineDebugRepository()
+
+        # Initialize RabbitMQ listener
+        self.listener = RabbitMQListener(
+            self.config, self.worker_id, self.stop_event, self._process_pipeline_action_message
+        )
+
+    def start(self):
+        """Start the Pipeline Action Worker."""
+        with self.lock:
+            if self.thread and self.thread.is_alive():
+                logger.warning("⚠️ [APP] Pipeline Action 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 Action Worker started (Device: {self.worker_id}).")
+
+    def stop(self):
+        """Stop the Pipeline Action Worker."""
+        with self.lock:
+            if not self.thread or not self.thread.is_alive():
+                logger.warning("⚠️ [APP] Pipeline Action 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 Action 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] Waiting for Pipeline action messages...")
+                self.listener.start_listening(
+                    exchange_name="nedo.worker.pipeline.action", 
+                    queue_name=f"nedo.worker.pipeline.{self.worker_id}"
+                )
+                safe_join_thread(self.listener.listener_thread)
+        except Exception as e:
+            logger.error("🚨 [APP] Unexpected error in Pipeline Action Worker loop.", exc_info=True)
+
+    def _process_pipeline_action_message(self, message):
+        """
+        Process received Pipeline action messages.
+        
+        Args:
+            message (str): JSON message containing action and timestamp
+        """
+        try:
+            data = json.loads(message)
+            uuid = data.get('uuid')
+            pipeline_id = data.get('workerSourcePipelineId')
+            action = data.get('action')
+            timestamp = data.get('timestamp')
+
+            logger.info(f"📥 [APP] Received Pipeline action: {pipeline_id}:{action} at {timestamp}")
+
+            pipeline = self.repo.get_worker_source_pipeline(pipeline_id)
+
+            if not pipeline:
+                logger.warning(f"⚠️ [APP] Pipeline not found: {pipeline_id}")
+                return
+
+            if action == "start":
+                pipeline.pipeline_status_code = "run"
+                
+            elif action == "stop":
+                pipeline.pipeline_status_code = "stop"
+                
+            elif action == "restart":
+                pipeline.pipeline_status_code = "restart"
+                
+            elif action == "debug":
+                self.debug_repo.create_debug_entry(uuid, pipeline_id)
+                
+            else:
+                logger.warning(f"⚠️ [APP] Unknown Pipeline action received: {action}")
+
+            self.repo.session.commit()
+            logger.info(f"✅ [APP] Pipeline action processed: {pipeline_id}:{action}")
+
+        except json.JSONDecodeError:
+            logger.error("🚨 [APP] Failed to parse Pipeline action message JSON")
+        except Exception as e:
+            logger.error(f"🚨 [APP] Error processing Pipeline action: {str(e)}")
+

nedo_vision_worker/worker/PipelineImageWorker.py

@@ -0,0 +1,116 @@
+import threading
+import logging
+import json
+from ..repositories.WorkerSourceRepository import WorkerSourceRepository
+from ..services.WorkerSourcePipelineClient import WorkerSourcePipelineClient
+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 PipelineImageWorker:
+    def __init__(self, config: dict):
+        """
+        Initialize Pipeline Image Worker.
+
+        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")
+        self.server_host = self.config.get("server_host")
+        self.token = self.config.get("token")
+
+        if not self.worker_id:
+            raise ValueError("⚠️ [APP] Configuration is missing 'worker_id'.")
+        if not self.token:
+            raise ValueError("⚠️ [APP] Configuration is missing 'token'.")
+        
+        self.worker_source_pipeline_client = WorkerSourcePipelineClient(self.server_host)
+
+        self.thread = None
+        self.stop_event = threading.Event()
+        self.lock = threading.Lock()
+        
+        self.worker_source_repo = WorkerSourceRepository()
+
+        # Initialize RabbitMQ listener
+        self.listener = RabbitMQListener(
+            self.config, self.worker_id, self.stop_event, self._process_image_request_message
+        )
+
+    def start(self):
+        """Start the Pipeline Image Worker."""
+        with self.lock:
+            if self.thread and self.thread.is_alive():
+                logger.warning("⚠️ [APP] Pipeline Image Worker is already running.")
+                return
+
+            self.stop_event.clear()
+            self.thread = threading.Thread(target=self._run, daemon=True)  # ✅ Run as daemon
+            self.thread.start()
+            logger.info(f"🚀 [APP] Pipeline Image Worker started (Device: {self.worker_id}).")
+
+    def stop(self):
+        """Stop the Pipeline Image Worker."""
+        with self.lock:
+            if not self.thread or not self.thread.is_alive():
+                logger.warning("⚠️ [APP] Pipeline Image Worker is not running.")
+                return
+
+            self.stop_event.set()
+            self.listener.stop_listening()
+
+            safe_join_thread(self.thread)  # Ensures the thread stops gracefully
+            self.thread = None
+            logger.info(f"🛑 [APP] Pipeline Image 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] Waiting for image request messages...")
+                self.listener.start_listening(exchange_name="nedo.pipeline.image.request", queue_name=f"nedo.pipeline.request.{self.worker_id}")
+                safe_join_thread(self.listener.listener_thread)
+        except Exception as e:
+            logger.error("🚨 [APP] Unexpected error in Pipeline Image Worker loop.", exc_info=True)
+
+    def _process_image_request_message(self, message):
+        """Process messages related to video preview streaming."""
+        try:
+            data = json.loads(message)
+            worker_source_pipeline_id = data.get("workerSourcePipelineId")
+            worker_source_id = data.get("workerSourceId")
+            uuid = data.get("uuid")
+
+            worker_source = self.worker_source_repo.get_worker_source_by_id(worker_source_id)
+            if not worker_source:
+                return
+            
+            logger.info(f"📡 [APP] Sending Pipeline Image Preview to Worker Source Pipeline: {worker_source_pipeline_id}")
+            
+            response = self.worker_source_pipeline_client.send_pipeline_image(
+                worker_source_pipeline_id=worker_source_pipeline_id,
+                uuid=uuid,
+                url=worker_source.url if worker_source.type_code == "live" else worker_source.file_path,
+                token=self.token
+            )
+
+            if response.get("success"):
+                logger.info("✅ [APP] Successfully sent Pipeline Image Preview.")
+            else:
+                logger.error(f"❌ [APP] Failed to send Pipeline Image Preview: {response.get('message')}")
+
+        except json.JSONDecodeError:
+            logger.error("⚠️ [APP] Invalid JSON message format.")
+        except Exception as e:
+            logger.error("🚨 [APP] Error processing video preview message.", exc_info=True)

nedo_vision_worker/worker/RabbitMQListener.py

@@ -0,0 +1,170 @@
+import threading
+import logging
+import time
+import pika
+import pika.exceptions
+
+logger = logging.getLogger(__name__)
+
+class RabbitMQListener:
+    def __init__(self, config, device_id, stop_event, message_callback):
+        self.config = config
+        self.device_id = device_id.lower()
+        self.stop_event = stop_event
+        self.message_callback = message_callback
+        self.connection = None
+        self.channel = None
+        self.exchange_name = None
+        self.queue_name = None
+        self.listener_thread = None
+        self.reconnect_delay = 5  # Exponential backoff (max 60s)
+
+    def _connect(self):
+        """Establish a new RabbitMQ connection."""
+        rabbitmq_host = self.config.get("rabbitmq_host")
+        rabbitmq_port = int(self.config.get("rabbitmq_port", 5672))
+        rabbitmq_username = self.config.get("rabbitmq_username")
+        rabbitmq_password = self.config.get("rabbitmq_password")
+
+        credentials = pika.PlainCredentials(rabbitmq_username, rabbitmq_password)
+        parameters = pika.ConnectionParameters(
+            host=rabbitmq_host,
+            port=rabbitmq_port,
+            virtual_host='/',
+            credentials=credentials,
+            heartbeat=30,
+            blocked_connection_timeout=10
+        )
+
+        try:
+            self.connection = pika.SelectConnection(
+                parameters,
+                on_open_callback=self._on_connected,
+                on_close_callback=self._on_closed
+            )
+        except pika.exceptions.AMQPConnectionError as e:
+            logger.error(f"⚠️ [APP] Connection failed: {e}")
+            return False
+
+        return True
+
+    def _on_connected(self, connection):
+        """Callback for successful RabbitMQ connection."""
+        logger.info("🔌 [APP] Connected to RabbitMQ")
+        self.connection = connection
+        self.connection.channel(on_open_callback=self._on_channel_open)
+
+    def _on_channel_open(self, channel):
+        """Callback for successfully opened channel."""
+        self.channel = channel
+        routing_key = self.device_id
+
+        self.channel.exchange_declare(exchange=self.exchange_name, exchange_type='direct', durable=True)
+        self.channel.queue_declare(queue=self.queue_name, durable=False, auto_delete=True, exclusive=True)
+        self.channel.queue_bind(exchange=self.exchange_name, queue=self.queue_name, routing_key=routing_key)
+        self.channel.basic_qos(prefetch_count=1)
+
+        self.channel.basic_consume(queue=self.queue_name, on_message_callback=self._on_message_received, auto_ack=True)
+
+        logger.info(f"📡 [APP] Listening for RabbitMQ messages on '{self.exchange_name}' with routing key '{routing_key}'.")
+
+    def _on_closed(self, connection, reason):
+        """Handle unexpected connection closure."""
+        logger.error(f"🚨 [APP] RabbitMQ connection closed unexpectedly: {reason}")
+        self._cleanup_connection()
+        time.sleep(self.reconnect_delay)
+        self.reconnect_delay = min(self.reconnect_delay * 2, 60)
+        self.start_listening(self.exchange_name, self.queue_name)  # Restart listener
+
+    def start_listening(self, exchange_name, queue_name):
+        """
+        Establish a RabbitMQ connection and listen for messages.
+        Automatically reconnects if the connection is lost.
+        """
+        if not self.stop_event:
+            logger.error("🚨 [APP] Stop event is not initialized")
+            return
+
+        self.exchange_name = exchange_name
+        self.queue_name = queue_name
+
+        if self.listener_thread and self.listener_thread.is_alive():
+            logger.warning("⚠️ [APP] RabbitMQ listener is already running.")
+            return
+
+        def run():
+            while not self.stop_event.is_set():
+                if self._connect():
+                    try:
+                        self.connection.ioloop.start()  # Start pika's event loop
+                    except KeyboardInterrupt:
+                        self.stop_listening()
+                        break
+                    except Exception as e:
+                        logger.error(f"🚨 [APP] Unexpected RabbitMQ error: {e}")
+                        time.sleep(self.reconnect_delay)
+                        self.reconnect_delay = min(self.reconnect_delay * 2, 60)
+                else:
+                    logger.error(f"⚠️ [APP] Connection failed. Retrying in {self.reconnect_delay}s...")
+                    time.sleep(self.reconnect_delay)
+
+        # Start RabbitMQ listener in a new thread
+        self.listener_thread = threading.Thread(target=run, daemon=True)
+        self.listener_thread.start()
+
+    def stop_listening(self):
+        """
+        Stop RabbitMQ listening and close the connection.
+        """
+        logger.info("🛑 [APP] Stopping RabbitMQ listener...")
+        if not self.stop_event:
+            logger.error("🚨 [APP] Stop event is not initialized")
+            return
+
+        self.stop_event.set()
+
+        try:
+            if self.channel and self.channel.is_open:
+                self.channel.close()
+
+            if self.connection and self.connection.is_open:
+                self.connection.close()
+
+            if self.connection:
+                self.connection.ioloop.stop()  # Stop pika event loop
+
+        except Exception as e:
+            logger.error(f"🚨 [APP] Error during RabbitMQ shutdown: {e}")
+
+        self._cleanup_connection()
+        logger.info("🔌 [APP] RabbitMQ listener stopped.")
+
+    def _cleanup_connection(self):
+        """Safely close RabbitMQ connection and channel."""
+        if self.channel:
+            try:
+                if self.channel.is_open:
+                    self.channel.close()
+            except Exception:
+                pass
+            self.channel = None
+
+        if self.connection:
+            try:
+                if self.connection.is_open:
+                    self.connection.close()
+                    self.connection.ioloop.stop()
+            except Exception:
+                pass
+            self.connection = None
+
+    def _on_message_received(self, ch, method, properties, body):
+        """
+        Callback function triggered when a message is received.
+        """
+        try:
+            message = body.decode("utf-8")
+            logger.info(f"📩 [APP] Received RabbitMQ message: {message}")
+            self.message_callback(message)
+        except Exception as e:
+            logger.error(f"🚨 [APP] Error processing RabbitMQ message: {e}")

nedo_vision_worker/worker/RestrictedAreaManager.py

@@ -0,0 +1,85 @@
+import logging
+import threading
+import time
+
+from ..repositories.RestrictedAreaRepository import RestrictedAreaRepository
+from ..services.RestrictedAreaClient import RestrictedAreaClient
+
+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 RestrictedAreaManager:
+    def __init__(self, server_host: str, worker_id: str, worker_source_id: str, token: str):
+        """
+        Handles restricted area violation monitoring and reporting.
+
+        Args:
+            server_host (str): The gRPC server host.
+            worker_id (str): Unique worker ID (passed externally).
+            worker_source_id (str): Unique worker source ID (passed externally).
+            token (str): Authentication token for the worker.
+        """
+        if not worker_id or not worker_source_id:
+            raise ValueError("⚠️ [APP] 'worker_id' and 'worker_source_id' cannot be empty.")
+        if not token:
+            raise ValueError("⚠️ [APP] 'token' cannot be empty.")
+
+        self.client = RestrictedAreaClient(server_host)
+        self.server_host = server_host
+        self.worker_id = worker_id
+        self.worker_source_id = worker_source_id
+        self.token = token
+        self.violations_data = []
+        self.stop_event = threading.Event()
+        self.violation_thread = None
+        self.repo = RestrictedAreaRepository()
+
+        self._start_violation_monitoring()
+
+    def _start_violation_monitoring(self):
+        """Starts a background thread to monitor and collect restricted area violations."""
+        if self.violation_thread and self.violation_thread.is_alive():
+            logger.warning("⚠️ [APP] Restricted area violation thread already running.")
+            return
+
+        logger.info("📡 [APP] Restricted area violation monitoring started.")
+
+    def send_violation_batch(self):
+        """Sends a batch of collected violation data to the server."""
+        try:
+            self.violations_data = self.repo.get_latest_5_violations()
+            if not self.violations_data:
+                return
+
+            response = self.client.send_upsert_batch(
+                worker_id=self.worker_id,
+                worker_source_id=self.worker_source_id,
+                violation_data=self.violations_data,
+                token=self.token
+            )
+
+            if response.get("success"):
+                logger.info("✅ [APP] Successfully sent restricted area violation batch.")
+                self.violations_data.clear()
+            else:
+                logger.error(f"❌ [APP] Failed to send restricted area violation batch: {response.get('message')}")
+
+        except Exception as e:
+            logger.error("🚨 [APP] Error sending restricted area violation batch.", exc_info=True)
+
+    def close(self):
+        """Closes the violation client and stops the monitoring thread."""
+        self.stop_event.set()
+
+        if self.violation_thread and self.violation_thread.is_alive():
+            safe_join_thread(self.violation_thread)
+            logger.info("🔌 [APP] Restricted area violation monitoring thread stopped.")
+
+        if self.client:
+            logger.info("✅ [APP] Restricted Area Violation Client closed.")