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

nedo_vision_worker/__init__.py

@@ -6,5 +6,5 @@ A library for running worker agents in the Nedo Vision platform.
 
 from .worker_service import WorkerService
 
-__version__ = "1.1.2"
+__version__ = "1.2.0"
 __all__ = ["WorkerService"] 

nedo_vision_worker/cli.py

@@ -3,193 +3,222 @@ import signal
 import sys
 import traceback
 import logging
+from typing import NoReturn
 
 from .worker_service import WorkerService
 
 
-def signal_handler(signum, frame):
-    """Handle system signals for graceful shutdown"""
-    logging.info(f"Received signal {signum}, shutting down...")
-    sys.exit(0)
-
-
-def main():
-    """Main CLI entry point."""
-    parser = argparse.ArgumentParser(
-        description="Nedo Vision Worker Service Library CLI",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
+class NedoWorkerCLI:
+    """Main CLI application for Nedo Vision Worker Service."""
+    
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        self._setup_signal_handlers()
+    
+    def _setup_signal_handlers(self) -> None:
+        """Set up signal handlers for graceful shutdown."""
+        signal.signal(signal.SIGINT, self._signal_handler)
+        signal.signal(signal.SIGTERM, self._signal_handler)
+    
+    def _signal_handler(self, signum: int, frame) -> NoReturn:
+        """Handle system signals for graceful shutdown."""
+        self.logger.info(f"Received signal {signum}, shutting down...")
+        sys.exit(0)
+    
+    def create_parser(self) -> argparse.ArgumentParser:
+        """Create and configure the argument parser."""
+        parser = argparse.ArgumentParser(
+            description="Nedo Vision Worker Service",
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            epilog="""
 Examples:
   # Check system dependencies and requirements
   nedo-worker doctor
 
-  # Start worker service with required parameters
-  nedo-worker run --token your-token-here --rtmp-server rtmp://server.com:1935/live
-
-  # Start with custom server host
-  nedo-worker run --token your-token-here --rtmp-server rtmp://server.com:1935/live --server-host custom.server.com
-
-  # Start with custom storage path
-  nedo-worker run --token your-token-here --rtmp-server rtmp://server.com:1935/live --storage-path /path/to/storage
-        """
-    )
-    
-    # Add subcommands
-    subparsers = parser.add_subparsers(dest='command', help='Available commands')
-    
-    # Doctor command
-    doctor_parser = subparsers.add_parser(
-        'doctor', 
-        help='Check system dependencies and requirements',
-        description='Run diagnostic checks for FFmpeg, OpenCV, gRPC and other dependencies'
-    )
-    
-    # Run command
-    run_parser = subparsers.add_parser(
-        'run',
-        help='Start the worker service',
-        description='Start the Nedo Vision Worker Service'
-    )
-    
-    run_parser.add_argument(
-        "--server-host",
-        default="be.vision.sindika.co.id",
-        help="Server hostname for communication (default: be.vision.sindika.co.id)"
-    )
-    
-    run_parser.add_argument(
-        "--token",
-        required=True,
-        help="Authentication token for the worker (obtained from frontend)"
-    )
-    
-    run_parser.add_argument(
-        "--system-usage-interval",
-        type=int,
-        default=30,
-        help="System usage reporting interval in seconds (default: 30)"
-    )
-    
-    run_parser.add_argument(
-        "--rtmp-server",
-        required=True,
-        help="RTMP server URL for video streaming (e.g., rtmp://server.com:1935/live)"
-    )
-    
-    run_parser.add_argument(
-        "--storage-path",
-        default="data",
-        help="Storage path for databases and files (default: data)"
-    )
-    
-    # Add legacy arguments for backward compatibility (when no subcommand is used)
-    parser.add_argument(
-        "--token",
-        help="(Legacy) Authentication token for the worker (obtained from frontend)"
-    )
-    
-    parser.add_argument(
-        "--server-host",
-        default="be.vision.sindika.co.id",
-        help="(Legacy) Server hostname for communication (default: be.vision.sindika.co.id)"
-    )
-    
-    parser.add_argument(
-        "--system-usage-interval",
-        type=int,
-        default=30,
-        help="(Legacy) System usage reporting interval in seconds (default: 30)"
-    )
-    
-    parser.add_argument(
-        "--rtmp-server",
-        help="(Legacy) RTMP server URL for video streaming (e.g., rtmp://server.com:1935/live)"
-    )
-    
-    parser.add_argument(
-        "--storage-path",
-        default="data",
-        help="(Legacy) Storage path for databases and files (default: data)"
-    )
-    
-    parser.add_argument(
-        "--version",
-        action="version",
-        version="nedo-vision-worker 1.1.2"
-    )
-    
-    parser.add_argument(
-        "--doctor",
-        action="store_true",
-        help="(Deprecated) Run system diagnostics - use 'nedo-worker doctor' instead"
-    )
-    
-    args = parser.parse_args()
-    
-    # Handle subcommands
-    if args.command == 'doctor':
-        from .doctor import main as doctor_main
-        sys.exit(doctor_main())
-    elif args.command == 'run':
-        run_worker_service(args)
-    elif args.doctor:  # Legacy mode - deprecated --doctor flag
-        print("⚠️  Warning: Using deprecated --doctor flag. Use 'nedo-worker doctor' instead.")
-        from .doctor import main as doctor_main
-        sys.exit(doctor_main())
-    elif args.token and args.rtmp_server:  # Legacy mode - if token and rtmp_server are provided without subcommand
-        print("⚠️  Warning: Using legacy command format. Consider using 'nedo-worker run --token ... --rtmp-server ...' instead.")
-        run_worker_service(args)
-    else:
-        # If no subcommand provided and no token, show help
-        parser.print_help()
-        sys.exit(1)
-
+  # Start worker service
+  nedo-worker run --token your-token-here
 
-def run_worker_service(args):
-    """Run the worker service with the provided arguments."""
-    # Set up signal handlers for graceful shutdown
-    signal.signal(signal.SIGINT, signal_handler)
-    signal.signal(signal.SIGTERM, signal_handler)
-    
-    logger = logging.getLogger(__name__)
+  # Start with custom configuration
+  nedo-worker run --token your-token-here \\
+    --rtmp-server rtmp://custom.server.com:1935/live \\
+    --server-host custom.server.com \\
+    --storage-path /custom/storage/path
+            """
+        )
+        
+        parser.add_argument(
+            "--version",
+            action="version",
+            version="nedo-vision-worker 1.2.0"
+        )
+        
+        subparsers = parser.add_subparsers(
+            dest='command', 
+            help='Available commands',
+            required=True
+        )
+        
+        self._add_doctor_command(subparsers)
+        self._add_run_command(subparsers)
+        
+        return parser
+    
+    def _add_doctor_command(self, subparsers) -> None:
+        """Add the doctor command."""
+        subparsers.add_parser(
+            'doctor',
+            help='Check system dependencies and requirements',
+            description='Run diagnostic checks for FFmpeg, OpenCV, gRPC and other dependencies'
+        )
     
-    try:
-        # Create and start the worker service
-        service = WorkerService(
-            server_host=args.server_host,
-            token=args.token,
-            system_usage_interval=args.system_usage_interval,
-            rtmp_server=args.rtmp_server,
-            storage_path=args.storage_path
+    def _add_run_command(self, subparsers) -> None:
+        """Add the run command with its arguments."""
+        run_parser = subparsers.add_parser(
+            'run',
+            help='Start the worker service',
+            description='Start the Nedo Vision Worker Service'
+        )
+        
+        run_parser.add_argument(
+            "--token",
+            required=True,
+            help="Authentication token for the worker (obtained from frontend)"
+        )
+        
+        run_parser.add_argument(
+            "--server-host",
+            default="be.vision.sindika.co.id",
+            help="Server hostname for communication (default: %(default)s)"
+        )
+        
+        run_parser.add_argument(
+            "--server-port",
+            type=int,
+            default=50051,
+            help="Server port for gRPC communication (default: %(default)s)"
         )
         
-        logger.info("🚀 Starting Nedo Vision Worker Service...")
-        logger.info(f"🌐 Server: {args.server_host}")
-        logger.info(f"🔑 Token: {args.token[:8]}...")
-        logger.info(f"⏱️ System Usage Interval: {args.system_usage_interval}s")
-        logger.info(f"📡 RTMP Server: {args.rtmp_server}")
-        logger.info(f"💾 Storage Path: {args.storage_path}")
-        logger.info("Press Ctrl+C to stop the service")
+        run_parser.add_argument(
+            "--rtmp-server",
+            default="rtmp://live.vision.sindika.co.id:1935/live",
+            help="RTMP server URL for video streaming (default: %(default)s)"
+        )
+        
+        run_parser.add_argument(
+            "--storage-path",
+            default="data",
+            help="Storage path for databases and files (default: %(default)s)"
+        )
+        
+        run_parser.add_argument(
+            "--system-usage-interval",
+            type=int,
+            default=30,
+            metavar="SECONDS",
+            help="System usage reporting interval in seconds (default: %(default)s)"
+        )
+        
+        run_parser.add_argument(
+            "--log-level",
+            choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+            default="INFO",
+            help="Set the logging level (default: %(default)s)"
+        )
+    
+    def run_doctor_command(self) -> int:
+        """Execute the doctor command."""
+        try:
+            from .doctor import main as doctor_main
+            return doctor_main()
+        except ImportError as e:
+            self.logger.error(f"Failed to import doctor module: {e}")
+            return 1
+        except Exception as e:
+            self.logger.error(f"Doctor command failed: {e}")
+            return 1
+    
+    def run_worker_service(self, args: argparse.Namespace) -> int:
+        """Start and run the worker service."""
+        # Configure logging
+        logging.basicConfig(
+            level=getattr(logging, args.log_level),
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
         
-        # Start the service
-        service.run()
+        try:
+            # Create the worker service
+            service = WorkerService(
+                server_host=args.server_host,
+                token=args.token,
+                system_usage_interval=args.system_usage_interval,
+                rtmp_server=args.rtmp_server,
+                storage_path=args.storage_path,
+                server_port=args.server_port
+            )
+            
+            # Log startup information
+            self._log_startup_info(args)
+            
+            # Start the service
+            service.run()
+            
+            # Keep the service running
+            self._wait_for_service(service)
+            
+            return 0
+            
+        except KeyboardInterrupt:
+            self.logger.info("Shutdown requested by user")
+            return 0
+        except Exception as e:
+            self.logger.error(f"Service failed: {e}")
+            if args.log_level == "DEBUG":
+                traceback.print_exc()
+            return 1
+    
+    def _log_startup_info(self, args: argparse.Namespace) -> None:
+        """Log service startup information."""
+        self.logger.info("🚀 Starting Nedo Vision Worker Service...")
+        self.logger.info(f"🌐 Server: {args.server_host}")
+        self.logger.info(f"🔑 Token: {args.token[:8]}{'*' * (len(args.token) - 8)}")
+        self.logger.info(f"⏱️  System Usage Interval: {args.system_usage_interval}s")
+        self.logger.info(f"📡 RTMP Server: {args.rtmp_server}")
+        self.logger.info(f"💾 Storage Path: {args.storage_path}")
+        self.logger.info("Press Ctrl+C to stop the service")
+    
+    def _wait_for_service(self, service: WorkerService) -> None:
+        """Wait for the service to run and handle shutdown."""
+        import time
         
-        # Keep the service running
         try:
             while getattr(service, 'running', False):
-                import time
                 time.sleep(1)
         except KeyboardInterrupt:
-            logger.info("\n🛑 Shutdown requested...")
+            self.logger.info("🛑 Shutdown requested...")
         finally:
-            service.stop()
-            logger.info("✅ Service stopped successfully")
-            
-    except Exception as e:
-        logger.error(f"❌ Error: {e}")
-        traceback.print_exc()
-        sys.exit(1)
+            if hasattr(service, 'stop'):
+                service.stop()
+            self.logger.info("✅ Service stopped successfully")
+    
+    def run(self) -> int:
+        """Main entry point for the CLI application."""
+        parser = self.create_parser()
+        args = parser.parse_args()
+        
+        if args.command == 'doctor':
+            return self.run_doctor_command()
+        elif args.command == 'run':
+            return self.run_worker_service(args)
+        else:
+            parser.print_help()
+            return 1
+
+
+def main() -> int:
+    """Main CLI entry point."""
+    cli = NedoWorkerCLI()
+    return cli.run()
 
 
 if __name__ == "__main__":
-    main() 
+    sys.exit(main())

nedo_vision_worker/database/DatabaseManager.py

@@ -20,13 +20,13 @@ _storage_path = None  # Global storage path
 def set_storage_path(storage_path: str):
     """Set the global storage path for the application."""
     global _storage_path
-    _storage_path = Path(storage_path)
+    _storage_path = Path(storage_path).resolve()  # Convert to absolute path
 
 def _get_storage_paths():
     """Get storage paths using the configured storage path."""
     global _storage_path
     if _storage_path is None:
-        _storage_path = Path("data")  # Default fallback
+        _storage_path = Path("data").resolve()  # Default fallback as absolute path
     
     return {
         "db": _storage_path / "sqlite",
@@ -38,7 +38,7 @@ def get_storage_path(subdir: str = None) -> Path:
     """Get a storage path for a specific subdirectory."""
     global _storage_path
     if _storage_path is None:
-        _storage_path = Path("data")  # Default fallback
+        _storage_path = Path("data").resolve()  # Default fallback as absolute path
     
     if subdir:
         return _storage_path / subdir