nedo-vision-worker 1.3.6__py3-none-any.whl → 1.3.8__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.3.6"
+__version__ = "1.3.8"
 __all__ = ["WorkerService"] 

nedo_vision_worker/bootstrap.py

@@ -0,0 +1,51 @@
+import logging
+from nedo_vision_worker.config.ConfigurationManager import ConfigurationManager
+from nedo_vision_worker.database.DatabaseManager import set_storage_path, DatabaseManager
+from nedo_vision_worker.worker_service import WorkerService
+
+
+def start_worker(
+    *,
+    server_host: str,
+    server_port: int,
+    token: str,
+    system_usage_interval: int,
+    rtmp_server: str,
+    storage_path: str,
+    log_level: str = "INFO",
+) -> WorkerService:
+    # Logging (only once, force allowed)
+    logging.basicConfig(
+        level=getattr(logging, log_level),
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        force=True,
+    )
+
+    logger = logging.getLogger("nedo-worker")
+
+    # Storage & DB
+    set_storage_path(storage_path)
+    DatabaseManager.init_databases()
+
+    # Configuration
+    configuration_manager = ConfigurationManager(
+        worker_token=token,
+        server_host=server_host,
+        server_port=server_port,
+        rtmp_server_url=rtmp_server,
+        logger=logging.getLogger("configuration_manager"),
+    )
+
+    service = WorkerService(
+        configuration_manager=configuration_manager,
+        server_host=server_host,
+        token=token,
+        system_usage_interval=system_usage_interval,
+        rtmp_server=rtmp_server,
+        storage_path=storage_path,
+    )
+
+    logger.info("🚀 Starting Nedo Vision Worker Service")
+    service.run()
+
+    return service

nedo_vision_worker/cli.py

@@ -1,224 +1,75 @@
 import argparse
 import signal
 import sys
-import traceback
 import logging
 from typing import NoReturn
 
-from .worker_service import WorkerService
+from nedo_vision_worker.bootstrap import start_worker
 
 
 class NedoWorkerCLI:
-    """Main CLI application for Nedo Vision Worker Service."""
-    
     def __init__(self):
         self.logger = logging.getLogger(__name__)
         self._setup_signal_handlers()
-    
+        self._service = None
+
     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...")
+        self.logger.info("🛑 Shutdown signal received")
+        if self._service and hasattr(self._service, "stop"):
+            self._service.stop()
         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
-  nedo-worker run --token your-token-here
-
-  # 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.1"
-        )
-        
-        subparsers = parser.add_subparsers(
-            dest='command', 
-            help='Available commands',
-            required=True
-        )
-        
-        self._add_doctor_command(subparsers)
-        self._add_run_command(subparsers)
-        
+        parser = argparse.ArgumentParser(description="Nedo Vision Worker Service")
+
+        parser.add_argument("--version", action="version", version="nedo-vision-worker 1.2.1")
+
+        subparsers = parser.add_subparsers(dest="command", required=True)
+
+        subparsers.add_parser("doctor", help="Check system dependencies")
+
+        run = subparsers.add_parser("run", help="Start worker")
+
+        run.add_argument("--token", required=True)
+        run.add_argument("--server-host", default="be.vision.sindika.co.id")
+        run.add_argument("--server-port", type=int, default=50051)
+        run.add_argument("--rtmp-server", default="rtmp://live.vision.sindika.co.id:1935/live")
+        run.add_argument("--storage-path", default="data")
+        run.add_argument("--system-usage-interval", type=int, default=30)
+        run.add_argument("--log-level", default="INFO")
+
         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'
-        )
-    
-    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)"
-        )
-        
-        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
+
+    def run(self) -> int:
+        parser = self.create_parser()
+        args = parser.parse_args()
+
+        if args.command == "doctor":
+            from nedo_vision_worker.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'
-        )
-        
-        try:
-            # Create the worker service
-            service = WorkerService(
+
+        if args.command == "run":
+            self._service = start_worker(
                 server_host=args.server_host,
+                server_port=args.server_port,
                 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_level=args.log_level,
             )
-            
-            # 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
-        
-        try:
-            while getattr(service, 'running', False):
-                time.sleep(1)
-        except KeyboardInterrupt:
-            self.logger.info("🛑 Shutdown requested...")
-        finally:
-            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
+            signal.pause()  # wait for signal
+
+        return 0
 
 
 def main() -> int:
-    """Main CLI entry point."""
-    cli = NedoWorkerCLI()
-    return cli.run()
+    return NedoWorkerCLI().run()
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    sys.exit(main())

nedo_vision_worker/config/ConfigurationManager.py

@@ -1,84 +1,138 @@
 import logging
+import grpc
+from typing import Optional
 from ..models.config import ConfigEntity  # ORM model for server_config
 from ..database.DatabaseManager import DatabaseManager  # DatabaseManager for managing sessions
 
+from ..util.HardwareID import HardwareID
+from ..services.ConnectionInfoClient import ConnectionInfoClient
+from .ConfigurationManagerInterface import ConfigurationManagerInterface
 
-class ConfigurationManager:
+class ConfigurationManager(ConfigurationManagerInterface):
     """
-    A class to manage server configuration stored in the 'config' database using SQLAlchemy.
+    A class to manage local and remote configuration stored in the 'config' database.
     """
 
-    @staticmethod
-    def init_database():
-        """
-        Initialize the 'config' database and create the `server_config` table if it doesn't exist.
-        """
+    def __init__(self, worker_token: str, server_host: str, server_port: int, rtmp_server_url: str, logger: logging.Logger):
         try:
-            DatabaseManager.init_databases()
+            self._logger = logger
+            self._worker_token = worker_token
+            self._server_host = server_host
+            self._server_port = server_port
+            self._rtmp_server_url = rtmp_server_url
+
+            self._initialize_remote_configuration()
+
             logging.info("✅ [APP] Configuration database initialized successfully.")
         except Exception as e:
             logging.exception("❌ [APP] Failed to initialize the configuration database.")
             raise RuntimeError("Database initialization failed.") from e
-
-    @staticmethod
-    def is_config_initialized() -> bool:
+        
+    def get_config(self, key: str) -> str:
         """
-        Check if the configuration is already initialized.
+        Retrieve the value of a specific configuration key from the 'config' database.
+
+        Args:
+            key (str): The configuration key.
 
         Returns:
-            bool: True if configuration exists, False otherwise.
+            str: The configuration value, or None if the key does not exist.
         """
+        if not key or not isinstance(key, str):
+            raise ValueError("⚠️ The 'key' must be a non-empty string.")
+
         session = None
         try:
             session = DatabaseManager.get_session("config")
-            config_count = session.query(ConfigEntity).count()
-            return config_count > 0  # True if at least one config exists
+            logging.info(f"🔍 [APP] Retrieving configuration key: {key}")
+            config = session.query(ConfigEntity).filter_by(key=key).first()
+            if config:
+                logging.info(f"✅ [APP] Configuration key '{key}' retrieved successfully.")
+                return config.value
+            else:
+                logging.warning(f"⚠️ [APP] Configuration key '{key}' not found.")
+                return ""
         except Exception as e:
-            logging.exception("❌ [APP] Failed to check if configuration is initialized.")
-            return False
+            logging.exception(f"❌ [APP] Failed to retrieve configuration key '{key}': {e}")
+            raise RuntimeError(f"Failed to retrieve configuration key '{key}'") from e
         finally:
             if session:
                 session.close()
-
-    @staticmethod
-    def set_config(key: str, value: str):
+    
+    def get_all_configs(self) -> Optional[dict]:
         """
-        Set or update a configuration key-value pair in the 'config' database.
+        Retrieve all configuration key-value pairs from the 'config' database.
 
-        Args:
-            key (str): The configuration key.
-            value (str): The configuration value.
+        Returns:
+            dict: A dictionary of all configuration key-value pairs.
         """
-        if not key or not isinstance(key, str):
-            raise ValueError("⚠️ [APP] The 'key' must be a non-empty string.")
-        if not isinstance(value, str):
-            raise ValueError("⚠️ [APP] The 'value' must be a string.")
-
         session = None
         try:
             session = DatabaseManager.get_session("config")
-            logging.info(f"🔧 Attempting to set configuration: {key} = {value}")
-            existing_config = session.query(ConfigEntity).filter_by(key=key).first()
-            if existing_config:
-                logging.info(f"🔄 [APP] Updating configuration key: {key}")
-                existing_config.value = value
+            logging.info("🔍 [APP] Retrieving all configuration keys.")
+            configs = session.query(ConfigEntity).all()
+            if configs:
+                logging.info("✅ [APP] All configuration keys retrieved successfully.")
+                return {config.key: config.value for config in configs}
             else:
-                logging.info(f"➕ [APP] Adding new configuration key: {key}")
-                new_config = ConfigEntity(key=key, value=value)
-                session.add(new_config)
-            session.commit()
-            logging.info(f"✅ [APP] Configuration key '{key}' set successfully.")
+                logging.info("⚠️ [APP] No configuration keys found.")
+                return None
         except Exception as e:
-            if session:
-                session.rollback()
-            logging.exception(f"❌ [APP] Failed to set configuration key '{key}': {e}")
-            raise RuntimeError(f"Failed to set configuration key '{key}'") from e
+            logging.exception("❌ [APP] Failed to retrieve all configuration keys.")
+            raise RuntimeError("Failed to retrieve all configuration keys.") from e
         finally:
             if session:
                 session.close()
 
-    @staticmethod
-    def set_config_batch(configs: dict):
+    def _initialize_remote_configuration(self):
+        """
+        Initialize the application configuration using the provided token
+        and saving configuration data locally.
+        """
+        try:
+            # Get hardware ID
+            hardware_id = HardwareID.get_unique_id()
+
+            self._logger.info(f"🖥️ [APP] Detected Hardware ID: {hardware_id}")
+            self._logger.info(f"🌐 [APP] Using Server Host: {self._server_host}")
+
+            # Check if token is provided
+            if not self._worker_token:
+                raise ValueError("Token is required for worker initialization. Please provide a token obtained from the frontend.")
+
+            # Get connection info using the ConnectionInfoClient
+            connection_client = ConnectionInfoClient(self._server_host, self._server_port, self._worker_token)
+            connection_result = connection_client.get_connection_info()
+            
+            if not connection_result["success"]:
+                logging.error(f"Device connection info failed: {connection_result['message']}")
+                raise ValueError(f"Initializing remote config failed, reason: {connection_result['message']}")
+
+            worker_id = connection_result.get('id')
+            if not worker_id:
+                raise ValueError("No worker_id returned from connection info!")
+
+            self._set_config_batch({
+                "worker_id": worker_id,
+                "server_host": self._server_host,
+                "rtmp_server": self._rtmp_server_url,
+                "server_port": str(self._server_port),
+                "token": self._worker_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']
+            })
+            self._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}")
+
+    def _set_config_batch(self, configs: dict):
         """
         Set or update multiple configuration key-value pairs in the 'config' database in a batch operation.
 
@@ -116,71 +170,12 @@ class ConfigurationManager:
             if session:
                 session.close()
 
-    @staticmethod
-    def get_config(key: str) -> str:
-        """
-        Retrieve the value of a specific configuration key from the 'config' database.
-
-        Args:
-            key (str): The configuration key.
-
-        Returns:
-            str: The configuration value, or None if the key does not exist.
-        """
-        if not key or not isinstance(key, str):
-            raise ValueError("⚠️ The 'key' must be a non-empty string.")
-
-        session = None
-        try:
-            session = DatabaseManager.get_session("config")
-            logging.info(f"🔍 [APP] Retrieving configuration key: {key}")
-            config = session.query(ConfigEntity).filter_by(key=key).first()
-            if config:
-                logging.info(f"✅ [APP] Configuration key '{key}' retrieved successfully.")
-                return config.value
-            else:
-                logging.warning(f"⚠️ [APP] Configuration key '{key}' not found.")
-                return None
-        except Exception as e:
-            logging.exception(f"❌ [APP] Failed to retrieve configuration key '{key}': {e}")
-            raise RuntimeError(f"Failed to retrieve configuration key '{key}'") from e
-        finally:
-            if session:
-                session.close()
-
-    @staticmethod
-    def get_all_configs() -> dict:
-        """
-        Retrieve all configuration key-value pairs from the 'config' database.
-
-        Returns:
-            dict: A dictionary of all configuration key-value pairs.
-        """
-        session = None
-        try:
-            session = DatabaseManager.get_session("config")
-            logging.info("🔍 [APP] Retrieving all configuration keys.")
-            configs = session.query(ConfigEntity).all()
-            if configs:
-                logging.info("✅ [APP] All configuration keys retrieved successfully.")
-                return {config.key: config.value for config in configs}
-            else:
-                logging.info("⚠️ [APP] No configuration keys found.")
-                return {}
-        except Exception as e:
-            logging.exception("❌ [APP] Failed to retrieve all configuration keys.")
-            raise RuntimeError("Failed to retrieve all configuration keys.") from e
-        finally:
-            if session:
-                session.close()
-
-    @staticmethod
-    def print_config():
+    def _print_config(self):
         """
         Print all configuration key-value pairs to the console.
         """
         try:
-            configs = ConfigurationManager.get_all_configs()
+            configs = self.get_all_configs()
             if configs:
                 print("📄 Current Configuration:")
                 for key, value in configs.items():

nedo_vision_worker/config/ConfigurationManagerInterface.py

@@ -0,0 +1,12 @@
+from typing import Optional
+from abc import ABC, abstractmethod
+
+
+class ConfigurationManagerInterface(ABC):
+    @abstractmethod
+    def get_config(self, key: str) -> str:
+        pass
+    
+    @abstractmethod
+    def get_all_configs(self) -> Optional[dict]:
+        pass

nedo_vision_worker/config/DummyConfigurationManager.py

@@ -0,0 +1,52 @@
+import logging
+from typing import Optional
+
+from .ConfigurationManagerInterface import ConfigurationManagerInterface
+
+class DummyConfigurationManager(ConfigurationManagerInterface):
+    """
+    A class to manage local and remote configuration stored in the 'config' database.
+    """
+
+    def __init__(
+        self,
+        worker_id: str,
+        worker_token: str,
+        server_host: str,
+        server_port: str,
+        rtmp_server_url: str,
+        rabbitmq_host: str,
+        rabbitmq_port: str,
+        rabbitmq_username: str,
+        rabbitmq_password: str,
+        logger: logging.Logger
+    ):
+        self._logger = logger
+        self._worker_id = worker_id
+        self._worker_token = worker_token
+        self._server_host = server_host
+        self._server_port = server_port
+        self._rtmp_server_url = rtmp_server_url
+        self._rabbitmq_host = rabbitmq_host
+        self._rabbitmq_port = rabbitmq_port
+        self._rabbitmq_username = rabbitmq_username
+        self._rabbitmq_password = rabbitmq_password
+
+        self._config = {
+            "worker_id": self._worker_id,
+            "token": self._worker_token,
+            "server_host": self._server_host,
+            "server_port": str(self._server_port),
+            "rtmp_server": self._rtmp_server_url,
+            "rabbitmq_host": self._rabbitmq_host,
+            "rabbitmq_port": self._rabbitmq_port,
+            "rabbitmq_username": self._rabbitmq_username,
+            "rabbitmq_password": self._rabbitmq_password,
+        }
+
+        
+    def get_config(self, key: str) -> str:
+        return self._config[key]
+    
+    def get_all_configs(self) -> Optional[dict]:
+        return self._config

nedo_vision_worker/protos/AIModelService_pb2_grpc.py

@@ -5,7 +5,7 @@ import warnings
 
 from nedo_vision_worker.protos import AIModelService_pb2 as nedo__vision__worker_dot_protos_dot_AIModelService__pb2
 
-GRPC_GENERATED_VERSION = '1.74.0'
+GRPC_GENERATED_VERSION = '1.76.0'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False
 
@@ -18,7 +18,7 @@ except ImportError:
 if _version_not_supported:
     raise RuntimeError(
         f'The grpc package installed is at version {GRPC_VERSION},'
-        + f' but the generated code in nedo_vision_worker/protos/AIModelService_pb2_grpc.py depends on'
+        + ' but the generated code in nedo_vision_worker/protos/AIModelService_pb2_grpc.py depends on'
         + f' grpcio>={GRPC_GENERATED_VERSION}.'
         + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
         + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'