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

nedo_vision_worker/doctor.py

@@ -0,0 +1,453 @@
+#!/usr/bin/env python3
+"""
+Nedo Vision Worker Service Doctor
+
+This module provides diagnostic capabilities to check system requirements
+and dependencies for the Nedo Vision Worker Service.
+"""
+
+import subprocess
+import sys
+import platform
+import shutil
+import os
+from pathlib import Path
+
+
+def check_python_version():
+    """Check if Python version meets requirements."""
+    print("🐍 Checking Python version...")
+    
+    version = sys.version_info
+    min_version = (3, 8)
+    
+    if version >= min_version:
+        print(f"   ✅ Python {version.major}.{version.minor}.{version.micro} (meets requirement >= {min_version[0]}.{min_version[1]})")
+        return True
+    else:
+        print(f"   ❌ Python {version.major}.{version.minor}.{version.micro} (requires >= {min_version[0]}.{min_version[1]})")
+        return False
+
+
+def check_ffmpeg():
+    """Check if FFmpeg is installed and accessible."""
+    print("🎬 Checking FFmpeg...")
+    
+    try:
+        # Check if ffmpeg is in PATH
+        ffmpeg_path = shutil.which("ffmpeg")
+        if not ffmpeg_path:
+            print("   ❌ FFmpeg not found in PATH")
+            return False
+        
+        # Check ffmpeg version
+        result = subprocess.run(
+            ["ffmpeg", "-version"],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode == 0:
+            # Extract version from output
+            version_line = result.stdout.split('\n')[0]
+            print(f"   ✅ {version_line}")
+            print(f"   📍 Location: {ffmpeg_path}")
+            return True
+        else:
+            print("   ❌ FFmpeg found but failed to get version")
+            return False
+            
+    except subprocess.TimeoutExpired:
+        print("   ❌ FFmpeg check timed out")
+        return False
+    except Exception as e:
+        print(f"   ❌ Error checking FFmpeg: {e}")
+        return False
+
+
+def check_opencv():
+    """Check if OpenCV is properly installed."""
+    print("👁️ Checking OpenCV...")
+    
+    try:
+        import cv2
+        version = cv2.__version__
+        build_info = cv2.getBuildInformation()
+        
+        print(f"   ✅ OpenCV {version} installed")
+        
+        # Check OpenCV build configuration
+        if "CUDA" in build_info:
+            print("   🚀 OpenCV built with CUDA support")
+        if "OpenMP" in build_info:
+            print("   ⚡ OpenCV built with OpenMP support")
+        
+        # Check for platform-specific optimizations
+        machine = platform.machine()
+        if machine in ["aarch64", "armv7l", "arm64"]:
+            if "NEON" in build_info:
+                print("   🎯 OpenCV built with ARM NEON optimizations")
+            else:
+                print("   ⚠️ OpenCV may not have ARM optimizations")
+        
+        # Test basic functionality
+        import numpy as np
+        test_img = np.zeros((100, 100, 3), dtype=np.uint8)
+        
+        # Test encoding/decoding
+        _, encoded = cv2.imencode('.jpg', test_img)
+        decoded = cv2.imdecode(encoded, cv2.IMREAD_COLOR)
+        
+        if decoded is not None:
+            print("   ✅ OpenCV basic functionality working")
+            return True
+        else:
+            print("   ❌ OpenCV encoding/decoding test failed")
+            return False
+            
+    except ImportError:
+        print("   ❌ OpenCV not installed")
+        return False
+    except Exception as e:
+        print(f"   ❌ OpenCV test failed: {e}")
+        return False
+
+
+def check_grpc():
+    """Check if gRPC is properly installed."""
+    print("🌐 Checking gRPC...")
+    
+    try:
+        import grpc
+        print(f"   ✅ gRPC installed")
+        
+        # Test basic gRPC functionality
+        from grpc import StatusCode
+        print("   ✅ gRPC basic imports working")
+        return True
+        
+    except ImportError:
+        print("   ❌ gRPC not installed")
+        return False
+    except Exception as e:
+        print(f"   ❌ gRPC test failed: {e}")
+        return False
+
+
+def check_pynvml():
+    """Check if pynvml (NVIDIA management) is available."""
+    print("🎮 Checking NVIDIA GPU support...")
+    
+    try:
+        import pynvml
+        pynvml.nvmlInit()
+        
+        device_count = pynvml.nvmlDeviceGetCount()
+        if device_count > 0:
+            for i in range(device_count):
+                handle = pynvml.nvmlDeviceGetHandleByIndex(i)
+                name = pynvml.nvmlDeviceGetName(handle)
+                # Handle both string and bytes return types for compatibility
+                if isinstance(name, bytes):
+                    name = name.decode('utf-8')
+                
+                # Get additional GPU information
+                try:
+                    memory_info = pynvml.nvmlDeviceGetMemoryInfo(handle)
+                    memory_total_gb = memory_info.total / (1024**3)
+                    print(f"   ✅ GPU {i}: {name}")
+                    print(f"      💾 Memory: {memory_total_gb:.1f} GB")
+                    
+                    # Check for Jetson-specific GPUs
+                    if "tegra" in name.lower() or "jetson" in name.lower():
+                        print("      🚀 Jetson GPU detected")
+                    
+                    # Check compute capability for deep learning
+                    try:
+                        major, minor = pynvml.nvmlDeviceGetCudaComputeCapability(handle)
+                        print(f"      🔢 Compute Capability: {major}.{minor}")
+                        if major >= 6:  # Pascal architecture or newer
+                            print("      ✅ GPU supports modern deep learning frameworks")
+                        else:
+                            print("      ⚠️ GPU may have limited deep learning support")
+                    except:
+                        pass
+                        
+                except Exception as e:
+                    print(f"   ✅ GPU {i}: {name} (limited info: {e})")
+            
+            return True
+        else:
+            print("   ⚠️ pynvml installed but no NVIDIA GPUs detected")
+            # Check if we're on ARM and might have integrated GPU
+            if platform.machine() in ["aarch64", "armv7l", "arm64"]:
+                print("   💡 ARM device may use integrated GPU (Mali, Adreno, etc.)")
+            return True  # Not an error, just no NVIDIA GPU
+            
+    except ImportError:
+        print("   ❌ pynvml not installed")
+        print("   💡 Install with: pip install pynvml")
+        return False
+    except Exception as e:
+        print(f"   ⚠️ GPU check failed: {e}")
+        # More helpful error messages for common issues
+        if "driver" in str(e).lower():
+            print("   💡 NVIDIA drivers may not be installed")
+        elif "nvml" in str(e).lower():
+            print("   💡 NVIDIA Management Library not available")
+        return True  # Not critical for service operation
+
+
+def check_storage_permissions():
+    """Check if we can create storage directories."""
+    print("💾 Checking storage permissions...")
+    
+    try:
+        # Test default storage path
+        test_path = Path("data") / "test_permissions"
+        test_path.mkdir(parents=True, exist_ok=True)
+        
+        # Test file creation
+        test_file = test_path / "test.txt"
+        test_file.write_text("test")
+        
+        # Test file reading
+        content = test_file.read_text()
+        
+        # Cleanup
+        test_file.unlink()
+        test_path.rmdir()
+        
+        if content == "test":
+            print("   ✅ Storage read/write permissions OK")
+            return True
+        else:
+            print("   ❌ Storage read/write test failed")
+            return False
+            
+    except Exception as e:
+        print(f"   ❌ Storage permission check failed: {e}")
+        return False
+
+
+def check_network_connectivity():
+    """Check basic network connectivity."""
+    print("🌐 Checking network connectivity...")
+    
+    try:
+        import socket
+        
+        # Test DNS resolution
+        socket.gethostbyname("be.vision.sindika.co.id")
+        print("   ✅ DNS resolution working (be.vision.sindika.co.id)")
+        
+        # Test basic socket connectivity
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(5)
+        result = sock.connect_ex(("be.vision.sindika.co.id", 50051))
+        sock.close()
+        
+        if result == 0:
+            print("   ✅ Network connectivity to be.vision.sindika.co.id:50051 OK")
+            return True
+        else:
+            print("   ⚠️ Cannot connect to be.vision.sindika.co.id:50051 (may be normal if service is down)")
+            return True  # Not critical for initial setup
+            
+    except Exception as e:
+        print(f"   ⚠️ Network check failed: {e}")
+        return True  # Not critical for service installation
+
+
+def check_platform_compatibility():
+    """Check platform-specific compatibility."""
+    print("🔧 Checking platform compatibility...")
+    
+    system = platform.system()
+    machine = platform.machine()
+    
+    # Check for known compatible platforms
+    compatible_platforms = {
+        "Linux": ["x86_64", "aarch64", "armv7l", "arm64"],
+        "Windows": ["AMD64", "x86_64"],
+        "Darwin": ["x86_64", "arm64"]  # macOS Intel and Apple Silicon
+    }
+    
+    if system in compatible_platforms:
+        if machine in compatible_platforms[system]:
+            print(f"   ✅ Platform {system}/{machine} is supported")
+            
+            # Special handling for ARM devices
+            if machine in ["aarch64", "armv7l", "arm64"]:
+                print("   📱 ARM-based device detected")
+                if "tegra" in platform.platform().lower():
+                    print("   🚀 NVIDIA Jetson device detected")
+                elif "raspberry" in platform.platform().lower():
+                    print("   🍓 Raspberry Pi device detected")
+            
+            return True
+        else:
+            print(f"   ⚠️ Architecture {machine} may have limited support on {system}")
+            return True  # Still allow execution
+    else:
+        print(f"   ⚠️ Platform {system} may have limited support")
+        return True  # Still allow execution
+
+
+def print_system_info():
+    """Print basic system information."""
+    print("💻 System Information:")
+    print(f"   🖥️ OS: {platform.system()} {platform.release()}")
+    print(f"   🏗️ Architecture: {platform.machine()}")
+    print(f"   🐍 Python: {platform.python_version()}")
+    print(f"   📍 Python executable: {sys.executable}")
+    
+    # Additional platform details
+    try:
+        import os
+        if hasattr(os, 'uname'):
+            uname = os.uname()
+            print(f"   🔧 Kernel: {uname.sysname} {uname.release}")
+    except:
+        pass
+    
+    # Check for containerized environment
+    if Path("/.dockerenv").exists():
+        print("   🐳 Running in Docker container")
+    elif os.environ.get("KUBERNETES_SERVICE_HOST"):
+        print("   ☸️ Running in Kubernetes pod")
+
+
+def print_installation_help():
+    """Print installation help for missing dependencies."""
+    print("\n📋 Installation Help:")
+    print("=" * 50)
+    
+    system = platform.system()
+    machine = platform.machine()
+    
+    print("\n🎬 FFmpeg Installation:")
+    if system == "Windows":
+        print("   • Using Chocolatey: choco install ffmpeg")
+        print("   • Using winget: winget install FFmpeg")
+        print("   • Manual: Download from https://ffmpeg.org/download.html")
+    elif system == "Darwin":  # macOS
+        print("   • Using Homebrew: brew install ffmpeg")
+        print("   • Using MacPorts: sudo port install ffmpeg")
+    else:  # Linux
+        print("   • Ubuntu/Debian: sudo apt update && sudo apt install ffmpeg")
+        print("   • CentOS/RHEL: sudo yum install ffmpeg")
+        print("   • Fedora: sudo dnf install ffmpeg")
+        print("   • Alpine: apk add ffmpeg")
+        
+        # ARM-specific guidance
+        if machine in ["aarch64", "armv7l", "arm64"]:
+            print("   • For ARM devices:")
+            print("     - Jetson: Usually pre-installed with JetPack")
+            print("     - Raspberry Pi: sudo apt install ffmpeg")
+            print("     - Build from source for optimal performance")
+    
+    print("\n🐍 Python Dependencies:")
+    print("   • Install all: pip install -r requirements.txt")
+    print("   • Or install individually:")
+    print("     - pip install opencv-python")
+    print("     - pip install grpcio")
+    print("     - pip install pynvml")
+    
+    # Platform-specific OpenCV guidance
+    if machine in ["aarch64", "armv7l", "arm64"]:
+        print("\n🔧 ARM-Specific Notes:")
+        print("   • OpenCV: Consider opencv-python-headless for servers")
+        print("   • Jetson: Use opencv built with JetPack for GPU acceleration")
+        print("   • Build from source for optimal ARM performance")
+        print("   • For Jetson: Install with 'sudo apt install python3-opencv'")
+    
+    print("\n🎮 GPU Support:")
+    if system == "Linux" and machine in ["aarch64", "armv7l"]:
+        print("   • Jetson devices:")
+        print("     - Install JetPack SDK from NVIDIA")
+        print("     - Verify with: sudo /usr/bin/tegrastats")
+        print("     - Check CUDA: nvcc --version")
+    else:
+        print("   • NVIDIA GPU (Optional):")
+        print("     - Install NVIDIA drivers from https://www.nvidia.com/drivers/")
+        print("     - Install CUDA toolkit if needed")
+        print("     - pynvml should work automatically if drivers are installed")
+    
+    print("\n☁️ Cloud/Container Deployment:")
+    print("   • Docker: Use nvidia/cuda base images for GPU support")
+    print("   • Cloud: Ensure GPU instances have proper drivers")
+    print("   • Kubernetes: Use nvidia.com/gpu resource limits")
+    print("   • AWS: Use Deep Learning AMI or ECS GPU instances")
+    print("   • GCP: Use AI Platform or GPU-enabled Compute instances")
+    
+    print("\n📦 Package Installation Tips:")
+    print("   • Use virtual environments: python -m venv venv")
+    print("   • Update pip: pip install --upgrade pip")
+    print("   • For ARM: pip install --extra-index-url https://www.piwheels.org/simple/")
+    print("   • Build tools: sudo apt install build-essential python3-dev")
+
+
+def main():
+    """Run all diagnostic checks."""
+    print("🏥 Nedo Vision Worker Service Doctor")
+    print("=" * 50)
+    
+    # Print system info
+    print_system_info()
+    print()
+    
+    # Run all checks
+    checks = [
+        ("Platform Compatibility", check_platform_compatibility),
+        ("Python Version", check_python_version),
+        ("FFmpeg", check_ffmpeg),
+        ("OpenCV", check_opencv),
+        ("gRPC", check_grpc),
+        ("NVIDIA GPU Support", check_pynvml),
+        ("Storage Permissions", check_storage_permissions),
+        ("Network Connectivity", check_network_connectivity),
+    ]
+    
+    results = []
+    print("🔍 Running Diagnostic Checks:")
+    print("-" * 30)
+    
+    for name, check_func in checks:
+        try:
+            result = check_func()
+            results.append((name, result))
+        except Exception as e:
+            print(f"   ❌ {name} check failed with exception: {e}")
+            results.append((name, False))
+        print()
+    
+    # Summary
+    print("📊 Summary:")
+    print("-" * 20)
+    
+    passed = 0
+    failed = 0
+    
+    for name, result in results:
+        if result:
+            print(f"   ✅ {name}")
+            passed += 1
+        else:
+            print(f"   ❌ {name}")
+            failed += 1
+    
+    print(f"\n🎯 Results: {passed} passed, {failed} failed")
+    
+    if failed > 0:
+        print("\n⚠️ Some checks failed. See installation help below:")
+        print_installation_help()
+        return 1
+    else:
+        print("\n🎉 All checks passed! Your system is ready for Nedo Vision Worker Service.")
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

nedo_vision_worker/initializer/AppInitializer.py

@@ -0,0 +1,78 @@
+import logging
+import re
+import uuid
+import grpc
+from ..config.ConfigurationManager import ConfigurationManager
+from ..util.PlatformDetector import PlatformDetector
+from ..util.Networking import Networking
+from ..services.ConnectionInfoClient import ConnectionInfoClient
+from ..database.DatabaseManager import DatabaseManager
+
+
+class AppInitializer:
+    @staticmethod
+    def validate_uuid(value):
+        """Validate if the provided value is a valid UUID."""
+        try:
+            uuid.UUID(value)
+            return value
+        except ValueError:
+            raise ValueError(f"Invalid device ID format: {value}. Must be a valid UUID.")
+
+    @staticmethod
+    def validate_server_host(value):
+        """Validate if the server host is a valid domain name or IP address."""
+        domain_regex = (
+            r"^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*"
+            r"([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$"
+        )
+        ip_regex = (
+            r"^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\."
+            r"(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\."
+            r"(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\."
+            r"(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
+        )
+        if re.match(domain_regex, value) or re.match(ip_regex, value):
+            return value
+        raise ValueError(f"Invalid server host: {value}. Must be a valid domain or IP address.")
+
+    @staticmethod
+    def initialize_configuration(device_id: str, server_host: str, token: str):
+        """
+        Initialize the application configuration using the provided token
+        and saving configuration data locally.
+        """
+        try:
+            # Validate inputs
+            AppInitializer.validate_uuid(device_id)
+            AppInitializer.validate_server_host(server_host)
+
+            # Get connection info using the ConnectionInfoClient
+            connection_client = ConnectionInfoClient(server_host, 50051, token)
+            connection_result = connection_client.get_connection_info()
+
+            if not connection_result["success"]:
+                logging.error(f"Device connection info failed: {connection_result['message']}")
+                return
+
+            worker_id = connection_result.get('id')
+            if not worker_id:
+                raise ValueError("No worker_id returned from connection info!")
+
+            ConfigurationManager.set_config_batch({
+                "worker_id": worker_id,
+                "server_host": server_host,
+                "token": token,
+                "rabbitmq_host": connection_result['rabbitmq_host'],
+                "rabbitmq_port": str(connection_result['rabbitmq_port']),
+                "rabbitmq_username": connection_result['rabbitmq_username'],
+                "rabbitmq_password": connection_result['rabbitmq_password']
+            })
+            ConfigurationManager.print_config()
+        
+        except ValueError as ve:
+            logging.error(f"Validation error: {ve}")
+        except grpc.RpcError as ge:
+            logging.error(f"Grpc Error: {ge}")
+        except Exception as e:
+            logging.error(f"Unexpected error during initialization: {e}")

nedo_vision_worker/initializer/__init__.py

@@ -0,0 +1 @@
+ 

nedo_vision_worker/models/__init__.py

@@ -0,0 +1,15 @@
+# Import all models to ensure they are registered with SQLAlchemy Base registry
+from .ai_model import AIModelEntity
+from .auth import AuthEntity
+from .config import ConfigEntity
+from .dataset_source import DatasetSourceEntity
+from .logs import LogEntity
+from .ppe_detection import PPEDetectionEntity
+from .ppe_detection_label import PPEDetectionLabelEntity
+from .restricted_area_violation import RestrictedAreaViolationEntity
+from .user import UserEntity
+from .worker_source import WorkerSourceEntity
+from .worker_source_pipeline import WorkerSourcePipelineEntity
+from .worker_source_pipeline_config import WorkerSourcePipelineConfigEntity
+from .worker_source_pipeline_debug import WorkerSourcePipelineDebugEntity
+from .worker_source_pipeline_detection import WorkerSourcePipelineDetectionEntity 

nedo_vision_worker/models/ai_model.py

@@ -0,0 +1,29 @@
+import uuid
+from sqlalchemy import Column, String, DateTime
+from datetime import datetime
+from ..database.DatabaseManager import Base
+
+class AIModelEntity(Base):
+    __tablename__ = "ai_model"
+    __bind_key__ = "default"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    file = Column(String, nullable=False)
+    type = Column(String, nullable=False)
+    name = Column(String, nullable=False)
+    version = Column(String, nullable=False)
+    download_status = Column(String, nullable=True, default="completed")  # pending, downloading, completed, failed
+    last_download_attempt = Column(DateTime, nullable=True)
+    download_error = Column(String, nullable=True)
+
+    def __repr__(self):
+        return (
+            f"<AIModelEntity(id={self.id}, name={self.name}, type={self.type}, "
+            f"file={self.file}, version={self.version})>"
+        )
+
+    def __str__(self):
+        return (
+            f"AIModelEntity(id={self.id}, name={self.name}, type={self.type}, "
+            f"file={self.file}, version={self.version}, status={self.download_status})"
+        )

nedo_vision_worker/models/auth.py

@@ -0,0 +1,14 @@
+from sqlalchemy import Column, String, Integer
+from ..database.DatabaseManager import Base
+
+class AuthEntity(Base):
+    __tablename__ = "auth"
+    id = Column(Integer, primary_key=True)
+    username = Column(String, nullable=False)
+    password = Column(String, nullable=False)
+
+    def __repr__(self):
+        return f"<AuthEntity(id={self.id}, username={self.username})>"
+
+    def to_dict(self):
+        return {"id": self.id, "username": self.username}

nedo_vision_worker/models/config.py

@@ -0,0 +1,9 @@
+from sqlalchemy import Column, String
+from ..database.DatabaseManager import Base
+
+class ConfigEntity(Base):
+    __tablename__ = "server_config"
+    __bind_key__ = "config"
+
+    key = Column(String, primary_key=True)
+    value = Column(String, nullable=False)

nedo_vision_worker/models/dataset_source.py

@@ -0,0 +1,30 @@
+from sqlalchemy import Column, String, Integer
+from ..database.DatabaseManager import Base
+
+class DatasetSourceEntity(Base):
+    __tablename__ = "dataset_sources"
+    __bind_key__ = "default"
+
+    id = Column(String, primary_key=True)
+    dataset_id = Column(String, nullable=False)
+    worker_source_id = Column(String, nullable=False)
+    sampling_interval = Column(Integer, nullable=False)
+    dataset_name = Column(String, nullable=False)
+    worker_source_name = Column(String, nullable=False)
+    worker_source_url = Column(String, nullable=False)
+
+    def __repr__(self):
+        return (
+            f"<DatasetSourceEntity(id={self.id}, dataset_id={self.dataset_id}, "
+            f"worker_source_id={self.worker_source_id}, sampling_interval={self.sampling_interval}, "
+            f"dataset_name={self.dataset_name}, worker_source_name={self.worker_source_name}, "
+            f"worker_source_url={self.worker_source_url})>"
+        )
+
+    def __str__(self):
+        return (
+            f"DatasetSourceEntity(id={self.id}, dataset_id={self.dataset_id}, "
+            f"worker_source_id={self.worker_source_id}, sampling_interval={self.sampling_interval}, "
+            f"dataset_name={self.dataset_name}, worker_source_name={self.worker_source_name}, "
+            f"worker_source_url={self.worker_source_url})"
+        ) 

nedo_vision_worker/models/logs.py

@@ -0,0 +1,9 @@
+from sqlalchemy import Column, String, Integer
+from ..database.DatabaseManager import Base
+
+class LogEntity(Base):
+    __tablename__ = "logs"
+    __bind_key__ = "logging"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    message = Column(String, nullable=False)

nedo_vision_worker/models/ppe_detection.py

@@ -0,0 +1,39 @@
+import uuid
+import datetime
+from sqlalchemy import Column, String, ForeignKey, DateTime, Float, Integer
+from sqlalchemy.orm import relationship
+from ..database.DatabaseManager import Base
+
+class PPEDetectionEntity(Base):
+    __tablename__ = "ppe_detections"
+    __bind_key__ = "default"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    worker_id = Column(String, nullable=False)
+    worker_source_id = Column(String, nullable=False)
+    person_id = Column(String, nullable=False)
+    image_path = Column(String, nullable=False)
+    image_tile_path = Column(String, nullable=False)
+    detection_count = Column(Integer, nullable=False, default=0)  # Tracks total detections before saving
+    created_at = Column(DateTime, default=datetime.datetime.utcnow)
+    b_box_x1 = Column(Float, nullable=False)
+    b_box_y1 = Column(Float, nullable=False)
+    b_box_x2 = Column(Float, nullable=False)
+    b_box_y2 = Column(Float, nullable=False)
+
+    ppe_labels = relationship("PPEDetectionLabelEntity", back_populates="detection")
+
+    def __repr__(self):
+        return (
+            f"<PPEDetectionEntity(id={self.id}, worker_id={self.worker_id}, "
+            f"worker_source_id={self.worker_source_id}, person_id={self.person_id}, "
+            f"image_path={self.image_path}, detection_count={self.detection_count}, "
+            f"created_at={self.created_at})>"
+        )
+
+    def __str__(self):
+        return (
+            f"PPEDetectionEntity(id={self.id}, worker_id={self.worker_id}, "
+            f"worker_source_id={self.worker_source_id}, person_id={self.person_id}, "
+            f"detection_count={self.detection_count}, created_at={self.created_at})"
+        )