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

nedo_vision_worker/util/HardwareID.py

@@ -0,0 +1,104 @@
+import os
+import platform
+import subprocess
+import uuid
+
+class HardwareID:
+    @staticmethod
+    def get_unique_id():
+        """Returns a unique hardware identifier based on the OS."""
+        system = platform.system().lower()
+        try:
+            if system == "windows":
+                return HardwareID._get_windows_uuid()
+            elif system == "darwin":
+                return HardwareID._get_mac_uuid()
+            elif system == "linux":
+                return HardwareID._get_linux_uuid()
+            else:
+                return HardwareID._get_fallback_uuid()
+        except Exception as e:
+            return f"Error: {str(e)}"
+
+    @staticmethod
+    def _get_windows_uuid():
+        """Fetches the hardware UUID from Windows using WMIC."""
+        try:
+            # First attempt: Use wmic
+            output = subprocess.check_output("wmic csproduct get UUID", shell=True)
+            uuid_str = output.decode().split("\n")[1].strip()
+            if uuid_str:
+                return uuid_str
+            else:
+                # Fallback: Machine GUID from Registry
+                output = subprocess.check_output("reg query HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid", shell=True)
+                return HardwareID.convert_to_uuid(output.decode().split()[-1])
+        except subprocess.CalledProcessError:
+            try:
+                # Fallback attempt: Use PowerShell if wmic fails
+                output = subprocess.check_output(['powershell', 'Get-WmiObject -Class Win32_ComputerSystemProduct | Select-Object -ExpandProperty UUID'], shell=True, text=True)
+                return output.strip()  # Clean up the result
+            except subprocess.CalledProcessError:
+                # Both methods failed, return fallback UUID
+                return HardwareID._get_fallback_uuid()
+
+    @staticmethod
+    def _get_mac_uuid():
+        """Fetches the hardware UUID from macOS using ioreg."""
+        try:
+            output = subprocess.check_output("ioreg -rd1 -c IOPlatformExpertDevice | awk '/IOPlatformUUID/ { print $3; }'", shell=True)
+            return output.decode().strip().replace('"', '')
+        except:
+            return HardwareID._get_fallback_uuid()
+
+    @staticmethod
+    def _get_linux_uuid():
+        """Fetches the hardware UUID from Linux or NVIDIA Jetson."""
+        try:
+            # Check for Jetson Serial Number
+            if os.path.exists("/sys/devices/soc0/serial_number"):
+                with open("/sys/devices/soc0/serial_number", "r") as f:
+                    return HardwareID.convert_to_uuid(f.read().strip())
+            elif os.path.exists("/proc/device-tree/serial-number"):
+                with open("/proc/device-tree/serial-number", "r") as f:
+                    return HardwareID.convert_to_uuid(f.read().strip())
+
+            # Standard Linux machine-id
+            if os.path.exists("/etc/machine-id"):
+                with open("/etc/machine-id", "r") as f:
+                    return HardwareID.convert_to_uuid(f.read().strip())
+            elif os.path.exists("/var/lib/dbus/machine-id"):
+                with open("/var/lib/dbus/machine-id", "r") as f:
+                    return HardwareID.convert_to_uuid(f.read().strip())
+            
+            # Fallback to DMI Product UUID
+            output = subprocess.check_output("cat /sys/class/dmi/id/product_uuid", shell=True)
+            return HardwareID.convert_to_uuid(output.decode().strip())
+        except:
+            return HardwareID._get_fallback_uuid()
+
+    @staticmethod
+    def _get_fallback_uuid():
+        """Fallback method using MAC address hash."""
+        return str(uuid.getnode())
+    
+    @staticmethod
+    def convert_to_uuid(hardware_id: str) -> str:
+        """
+        Converts a hardware ID to a valid UUID format.
+        
+        Args:
+            hardware_id (str): The raw hardware ID string.
+        
+        Returns:
+            str: A valid UUID string.
+        """
+        # Remove null characters and non-printable characters
+        cleaned_id = hardware_id.strip().replace("\x00", "")
+        
+        # Ensure the length is 32 characters (UUID hex format)
+        hex_id = cleaned_id.ljust(32, "0")[:32]  # Pad with zeros if needed
+        
+        # Convert to UUID format
+        return str(uuid.UUID(hex_id))
+

nedo_vision_worker/util/ImageUploader.py

@@ -0,0 +1,92 @@
+import os
+import time
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ImageUploader:
+    def __init__(self, image_client, device_id, image_dir="images"):
+        """
+        Initialize the ImageUploader.
+
+        Args:
+            image_client: The ImageUploadClient instance.
+            device_id (str): The unique device ID.
+            image_dir (str): Directory containing images to upload.
+        """
+        self.image_client = image_client
+        self.device_id = device_id
+        self.image_dir = image_dir
+
+    def check_and_upload_images(self):
+        """
+        Check the last uploaded image date and upload new images.
+        """
+        try:
+            response = self.image_client.get_last_uploaded_date(device_id=self.device_id)
+
+            # Ensure response is a dictionary
+            if not response or not isinstance(response, dict):
+                logger.error("🚨 [APP] Invalid response from server.")
+                return {"success": False, "message": "Invalid response from server."}
+
+            if not response.get("success"):
+                error_message = response.get("message", "Unknown error")
+                logger.error(f"⚠️ [APP] Failed to get last uploaded image date: {error_message}")
+                return {"success": False, "message": error_message}
+
+            last_uploaded_date = response.get("last_uploaded_date", "1970-01-01T00:00:00")
+            # logger.info(f"📸 [APP] Last uploaded date: {last_uploaded_date}")
+
+            self._upload_new_images(last_uploaded_date)
+            return response
+
+        except Exception as e:
+            logger.error("🚨 [APP] Unexpected error while checking/uploading images.", exc_info=True)
+            return {"success": False, "message": str(e)}
+
+    def _upload_new_images(self, last_uploaded_date):
+        """
+        Upload images newer than the last uploaded date and delete them after successful upload.
+
+        Args:
+            last_uploaded_date (str): The last uploaded image date.
+        """
+        try:
+            images_uploaded = 0
+            for root, _, files in os.walk(self.image_dir):
+                for file in sorted(files):
+                    file_path = os.path.join(root, file)
+                    file_mod_time = time.strftime('%Y-%m-%dT%H:%M:%S', time.gmtime(os.path.getmtime(file_path)))
+
+                    if file_mod_time > last_uploaded_date:
+                        metadata = json.dumps({"file_name": file})
+                        response = self.image_client.upload_image(self.device_id, metadata, file_path)
+
+                        if response and response.get("success"):
+                            logger.info(f"✅ [APP] Image '{file}' uploaded successfully: {response.get('message')}")
+                            self._delete_file(file_path)
+                            images_uploaded += 1
+                        else:
+                            error_message = response.get("message", "Unknown error")
+                            logger.error(f"❌ [APP] Failed to upload image '{file}': {error_message}")
+            
+            if images_uploaded > 0:
+                logger.info(f"📊 [APP] Total images uploaded: {images_uploaded}")
+
+        except Exception as e:
+            logger.error("🚨 [APP] Unexpected error during image upload process.", exc_info=True)
+
+    def _delete_file(self, file_path):
+        """
+        Delete the specified file.
+
+        Args:
+            file_path (str): Path to the file to delete.
+        """
+        try:
+            os.remove(file_path)
+            logger.info(f"🗑️ [APP] File deleted: {file_path}")
+        except Exception as e:
+            logger.error(f"⚠️ [APP] Failed to delete file '{file_path}': {e}")

nedo_vision_worker/util/Networking.py

@@ -0,0 +1,94 @@
+import requests
+import socket
+import logging
+import time
+import grpc
+from ..protos.VisionWorkerService_pb2_grpc import HealthCheckServiceStub
+from ..protos.VisionWorkerService_pb2 import HealthCheckRequest
+
+
+
+class Networking:
+
+    @staticmethod
+    def check_grpc_latency(server_host: str, server_port: int = 50051) -> float:
+        try:
+            channel = grpc.insecure_channel(f"{server_host}:{server_port}")
+            stub = HealthCheckServiceStub(channel)
+            request = HealthCheckRequest()
+
+            start_time = time.time()
+            response = stub.HealthCheck(request)
+            end_time = time.time()
+
+            latency = (end_time - start_time) * 1000
+            return latency
+
+        except grpc.RpcError as e:
+            print(f"gRPC error: {e}")
+            return -1
+
+    @staticmethod
+    def check_latency(server_url: str) -> float:
+        """
+        Measures the latency to the specified server URL.
+
+        Args:
+            server_url (str): The URL of the server to check latency for.
+
+        Returns:
+            float: The latency in milliseconds.
+        """
+        import time
+
+        try:
+            start_time = time.time()  # Record the start time
+            response = requests.get(server_url)  # Send the GET request
+            end_time = time.time()  # Record the end time
+
+            if response.status_code == 200:
+                latency = (end_time - start_time) * 1000  # Convert to milliseconds
+                return latency
+            else:
+                raise Exception(f"Server responded with status code: {response.status_code}")
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Error occurred while checking latency: {e}")
+
+    @staticmethod
+    def get_public_ip() -> str:
+        """
+        Gets the current public IP address.
+
+        Returns:
+            str: The public IP address as a string.
+        """
+        try:
+            response = requests.get("https://api.ipify.org?format=json")
+            if response.status_code == 200:
+                return response.json().get("ip", "Unable to retrieve IP address")
+            else:
+                raise Exception(f"Failed to get public IP. Status code: {response.status_code}")
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Error occurred while retrieving public IP: {e}")
+
+    @staticmethod
+    def get_local_ip() -> str:
+        """
+        Gets the local IP address assigned to the system's network interface.
+
+        Returns:
+            str: The local IP address (not loopback), or a fallback message if not connected.
+        """
+        try:
+            # Create a temporary socket to determine the local IP
+            with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+                # Connect to a public IP (Google's DNS server) on port 80
+                s.connect(("8.8.8.8", 80))
+                local_ip = s.getsockname()[0]  # Retrieve the local IP address
+            return local_ip
+        except OSError as e:
+            # Handle network unreachable or other OS-related errors
+            logging.warning(f"Could not determine local IP address: {e}")
+            return "127.0.0.1"
+
+

nedo_vision_worker/util/PlatformDetector.py

@@ -0,0 +1,50 @@
+import os
+import platform
+
+class PlatformDetector:
+    """
+    A class to detect whether the application is running on a Jetson device or a PC.
+    """
+
+    @staticmethod
+    def is_jetson():
+        """
+        Determines if the platform is an NVIDIA Jetson device.
+
+        Returns:
+            bool: True if running on a Jetson device, False otherwise.
+        """
+        try:
+            # Check for Jetson-specific device tree file
+            if os.path.exists("/proc/device-tree/model"):
+                with open("/proc/device-tree/model", "r") as f:
+                    model = f.read().strip()
+                    if "NVIDIA Jetson" in model:
+                        return True
+
+            # Check for Jetson-specific libraries
+            jetson_libraries = ["/usr/lib/aarch64-linux-gnu/tegra"]
+            if any(os.path.exists(lib) for lib in jetson_libraries):
+                return True
+
+            # Check architecture
+            arch = platform.machine()
+            if arch == "aarch64":  # Jetson typically runs on ARM64 (aarch64)
+                return True
+
+        except Exception as e:
+            print(f"Error detecting Jetson platform: {e}")
+
+        return False
+
+    @staticmethod
+    def get_platform_type():
+        """
+        Gets the platform type as a string.
+
+        Returns:
+            str: "Jetson" if running on an NVIDIA Jetson device, "PC" otherwise.
+        """
+        if PlatformDetector.is_jetson():
+            return "jetson"
+        return "pc"

nedo_vision_worker/util/SystemMonitor.py

@@ -0,0 +1,299 @@
+import platform
+import psutil
+import os
+import re
+import subprocess
+from pynvml import (
+    nvmlInit,
+    nvmlDeviceGetHandleByIndex,
+    nvmlDeviceGetUtilizationRates,
+    nvmlDeviceGetCount,
+    nvmlDeviceGetMemoryInfo,
+    nvmlDeviceGetTemperature,
+    nvmlShutdown,
+    NVML_TEMPERATURE_GPU,
+)
+
+
+class SystemMonitor:
+    def __init__(self):
+        """
+        Initialize the System Monitor.
+        """
+        try:
+            nvmlInit()  # Initialize NVIDIA Management Library
+            self.gpu_available = True
+            self.gpu_count = nvmlDeviceGetCount()  # Get the number of GPUs
+        except Exception:
+            self.gpu_available = False
+            self.gpu_count = 0
+
+        # Detect platform (Windows, Linux, macOS, Jetson, etc.)
+        self.system = platform.system().lower()
+        self.is_jetson = self._detect_jetson()
+
+        # Jetson always have gpu
+        if self.is_jetson:
+            self.gpu_available = True
+            self.gpu_count = 1 
+
+
+    def get_cpu_usage(self):
+        """
+        Get CPU usage percentage.
+        """
+        return psutil.cpu_percent(interval=1)
+
+    def get_cpu_temperature(self):
+        """
+        Get CPU temperature (if supported).
+        """
+        try:
+            if self.system == "windows":
+                try:
+                    import wmi
+                    w = wmi.WMI(namespace="root\\OpenHardwareMonitor")  # Use OpenHardwareMonitor
+                    sensors = w.Sensor()
+                    cpu_temps = [s.Value for s in sensors if s.SensorType == "Temperature" and "CPU" in s.Name]
+                    return cpu_temps[0]
+                except Exception:
+                    return 0
+
+            elif self.is_jetson:
+                # For NVIDIA Jetson, read CPU temperature from thermal zones
+                with open("/sys/class/thermal/thermal_zone1/temp", "r") as f:
+                    return float(f.read().strip()) / 1000  # Convert millidegree to Celsius
+            elif self.system == "darwin":  # macOS
+                try:
+                    temp = subprocess.check_output(["osx-cpu-temp"], text=True).strip()
+                    return float(temp.replace("°C", ""))
+                except FileNotFoundError:
+                    return {"error": "Install 'osx-cpu-temp' for macOS temperature monitoring"}
+                except ValueError:
+                    return {"error": "Invalid temperature value retrieved from osx-cpu-temp"}
+            else:  # Linux
+                sensors = psutil.sensors_temperatures()
+                if "coretemp" in sensors:
+                    core_temps = sensors["coretemp"]
+                    return [temp.current for temp in core_temps if hasattr(temp, "current")]
+                elif "cpu-thermal" in sensors:
+                    return [sensors["cpu-thermal"][0].current]
+                else:
+                    return {"error": "CPU temperature sensor not found"}
+        except Exception as e:
+            return {"error": str(e)}
+
+    def get_ram_usage(self):
+        """
+        Get refined RAM usage details for macOS.
+        """
+        memory = psutil.virtual_memory()
+        cached_memory = memory.cached if hasattr(memory, "cached") else 0  # Check if cached memory is available
+
+        # Adjust "used" to exclude cached memory on macOS
+        adjusted_used = memory.used - cached_memory if self.system == "darwin" else memory.used
+        adjusted_free = memory.total - adjusted_used if self.system == "darwin" else memory.available
+
+        return {
+            "total": memory.total,
+            "used": adjusted_used,
+            "free": adjusted_free,
+            "percent": round((adjusted_used / memory.total) * 100, 2),
+        }
+
+    def get_gpu_usage(self):
+        """
+        Get usage details for all available GPUs.
+        """
+        if self.is_jetson:
+            return self.get_jetson_gpu_usage()  # Use Jetson-specific method
+
+        if not self.gpu_available:
+            return {"error": "GPU monitoring is not supported on this system."}
+
+        gpu_data = []
+        try:
+            for i in range(self.gpu_count):
+                handle = nvmlDeviceGetHandleByIndex(i)
+                utilization = nvmlDeviceGetUtilizationRates(handle)
+                memory = nvmlDeviceGetMemoryInfo(handle)
+                temperature = nvmlDeviceGetTemperature(handle, NVML_TEMPERATURE_GPU)
+
+                gpu_data.append({
+                    "gpu_index": i,
+                    "gpu_usage_percent": utilization.gpu,
+                    "memory_usage_percent": (memory.used / memory.total) * 100 if memory.total > 0 else 0,
+                    "temperature_celsius": temperature,
+                    "total_memory": memory.total,
+                    "used_memory": memory.used,
+                    "free_memory": memory.free,
+                })
+        except Exception as e:
+            return {"error": str(e)}
+
+        return gpu_data
+
+    def get_system_usage(self):
+        """
+        Get combined system usage (CPU, RAM, GPU, and temperatures).
+        """
+        system_usage = {
+            "cpu": {
+                "usage_percent": self.get_cpu_usage(),
+                "temperature_celsius": self.get_cpu_temperature(),
+            },
+            "ram": self.get_ram_usage(),
+        }
+
+        if self.gpu_available:
+            system_usage["gpu"] = self.get_gpu_usage()
+        else:
+            system_usage["gpu"] = []
+
+        return system_usage
+
+    def print_usage(self):
+        """
+        Print the system usage details (CPU, RAM, GPU).
+        """
+        usage = self.get_system_usage()
+
+        # CPU Usage
+        print("CPU Usage:")
+        print(f"  Usage Percent: {usage['cpu']['usage_percent']}%")
+        cpu_temp = usage['cpu']['temperature_celsius']
+        if isinstance(cpu_temp, dict) and "error" in cpu_temp:
+            print(f"  Temperature: {cpu_temp['error']}")
+        else:
+            print(f"  Temperature: {cpu_temp}°C")
+
+        # RAM Usage
+        print("RAM Usage:")
+        ram = usage['ram']
+        print(f"  Total: {ram['total'] / (1024**3):.2f} GB")
+        print(f"  Used: {ram['used'] / (1024**3):.2f} GB")
+        print(f"  Free: {ram['free'] / (1024**3):.2f} GB")
+        print(f"  Usage Percent: {ram['percent']}%")
+
+        # GPU Usage
+        gpu = usage.get("gpu", {})
+        if isinstance(gpu, list):
+            for gpu_info in gpu:
+                print(f"GPU {gpu_info['gpu_index']} Usage:")
+                print(f"  GPU Utilization: {gpu_info['gpu_usage_percent']}%")
+                print(f"  Memory Usage Percent: {gpu_info['memory_usage_percent']:.2f}%")
+                print(f"  Temperature: {gpu_info['temperature_celsius']}°C")
+                print(f"  Total Memory: {gpu_info['total_memory'] / (1024**2):.2f} MB")
+                print(f"  Used Memory: {gpu_info['used_memory'] / (1024**2):.2f} MB")
+                print(f"  Free Memory: {gpu_info['free_memory'] / (1024**2):.2f} MB")
+        else:
+            print("GPU Usage:")
+            print(f"  {gpu}")
+
+    def shutdown(self):
+        """
+        Shutdown the NVIDIA Management Library (for cleanup).
+        """
+        if self.gpu_available:
+            try:
+                nvmlShutdown()
+            except Exception:
+                pass  # Ignore shutdown errors
+
+    def _detect_jetson(self):
+        """
+        Check if the system is an NVIDIA Jetson by reading /proc/device-tree/compatible.
+        """
+        try:
+            if os.path.exists("/proc/device-tree/compatible"):
+                with open("/proc/device-tree/compatible", "r") as f:
+                    compatible = f.read().lower()
+                    return "nvidia,jetson" in compatible or "tegra" in compatible
+        except Exception:
+            pass
+        return False
+
+    def _get_jetson_gpu_stats(self):
+        """
+        Get Jetson GPU utilization, memory usage, and temperature using 'tegrastats'.
+        """
+        try:
+            process = subprocess.Popen("tegrastats", shell=True, stdout=subprocess.PIPE, text=True)
+            output = process.stdout.readline().strip()  # Read only the first line
+            process.terminate()  # Stop the process
+
+            # Extract GPU Utilization from "GR3D_FREQ X%"
+            gpu_match = re.search(r"GR3D_FREQ\s+(\d+)%", output)
+            gpu_usage_percent = float(gpu_match.group(1)) if gpu_match else 0.0
+
+            # Extract GPU Memory Usage from "RAM X/YMB"
+            mem_match = re.search(r"RAM\s+(\d+)/(\d+)MB", output)
+            if mem_match:
+                used_memory = int(mem_match.group(1)) * 1024 * 1024  # Convert MB to Bytes
+                total_memory = int(mem_match.group(2)) * 1024 * 1024  # Convert MB to Bytes
+                free_memory = total_memory - used_memory
+                memory_usage_percent = (used_memory / total_memory) * 100 if total_memory > 0 else 0
+            else:
+                total_memory = used_memory = free_memory = memory_usage_percent = 0
+
+            # Extract GPU Temperature from "GPU@XXC"
+            temp_match = re.search(r"GPU@(\d+\.?\d*)C", output)
+            temperature_celsius = float(temp_match.group(1)) if temp_match else 0.0
+
+            return {
+                "gpu_index": 0,  # Jetson has only 1 integrated GPU
+                "gpu_usage_percent": gpu_usage_percent,
+                "memory_usage_percent": memory_usage_percent,
+                "temperature_celsius": temperature_celsius,
+                "total_memory": total_memory,
+                "used_memory": used_memory,
+                "free_memory": free_memory,
+            }
+        except Exception as e:
+            return {"error": str(e)}
+
+    def get_jetson_gpu_usage(self):
+        """
+        Get Jetson GPU usage percentage, memory usage, and temperature using 'tegrastats'.
+        """
+        try:
+            gpu_stats = self._get_jetson_gpu_stats()
+            return [gpu_stats]  # Return as a list
+        except Exception as e:
+            return [{"error": str(e)}]
+
+
+    def _get_jetson_memory_usage(self):
+        """
+        Get Jetson GPU memory usage using 'jtop' (if installed).
+        """
+        try:
+            from jtop import jtop
+            with jtop() as jetson:
+                ram_info = jetson.memory["RAM"]
+                return {
+                    "total": ram_info["tot"],  # Total RAM in KB
+                    "used": ram_info["used"],  # Used RAM in KB
+                    "free": ram_info["free"],  # Free RAM in KB
+                }
+        except ImportError:
+            return {"error": "Install 'jtop' using: pip install jtop"}
+        except Exception as e:
+            return {"error": str(e)}
+
+    def _get_jetson_gpu_temperature(self):
+        """
+        Get GPU temperature from 'tegrastats'.
+        """
+        try:
+            process = subprocess.Popen("tegrastats", shell=True, stdout=subprocess.PIPE, text=True)
+            output = process.stdout.readline().strip()  # Read only one line
+            process.terminate()
+
+            # Extract GPU temperature
+            match = re.search(r"GPU@(\d+\.?\d*)C", output)
+            if match:
+                return float(match.group(1))
+            return 0.0  # Default if temperature not found
+        except Exception as e:
+            return {"error": str(e)}