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

nedo_vision_worker/__init__.py

@@ -0,0 +1,10 @@
+"""
+Nedo Vision Worker Service Library
+
+A library for running worker agents in the Nedo Vision platform.
+"""
+
+from .worker_service import WorkerService
+
+__version__ = "1.0.0"
+__all__ = ["WorkerService"] 

nedo_vision_worker/cli.py

@@ -0,0 +1,195 @@
+import argparse
+import signal
+import sys
+import traceback
+import logging
+
+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="""
+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.0.0"
+    )
+    
+    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)
+
+
+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__)
+    
+    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
+        )
+        
+        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")
+        
+        # Start the service
+        service.run()
+        
+        # Keep the service running
+        try:
+            while getattr(service, 'running', False):
+                import time
+                time.sleep(1)
+        except KeyboardInterrupt:
+            logger.info("\n🛑 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 __name__ == "__main__":
+    main() 

nedo_vision_worker/config/ConfigurationManager.py

@@ -0,0 +1,196 @@
+import logging
+from ..models.config import ConfigEntity  # ORM model for server_config
+from ..database.DatabaseManager import DatabaseManager  # DatabaseManager for managing sessions
+
+
+class ConfigurationManager:
+    """
+    A class to manage server configuration stored in the 'config' database using SQLAlchemy.
+    """
+
+    @staticmethod
+    def init_database():
+        """
+        Initialize the 'config' database and create the `server_config` table if it doesn't exist.
+        """
+        try:
+            DatabaseManager.init_databases()
+            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:
+        """
+        Check if the configuration is already initialized.
+
+        Returns:
+            bool: True if configuration exists, False otherwise.
+        """
+        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
+        except Exception as e:
+            logging.exception("❌ [APP] Failed to check if configuration is initialized.")
+            return False
+        finally:
+            if session:
+                session.close()
+
+    @staticmethod
+    def set_config(key: str, value: str):
+        """
+        Set or update a configuration key-value pair in the 'config' database.
+
+        Args:
+            key (str): The configuration key.
+            value (str): The configuration value.
+        """
+        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
+            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.")
+        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
+        finally:
+            if session:
+                session.close()
+
+    @staticmethod
+    def set_config_batch(configs: dict):
+        """
+        Set or update multiple configuration key-value pairs in the 'config' database in a batch operation.
+
+        Args:
+            configs (dict): A dictionary containing configuration key-value pairs.
+        """
+        if not isinstance(configs, dict) or not configs:
+            raise ValueError("⚠️ [APP] The 'configs' parameter must be a non-empty dictionary.")
+
+        session = None
+        try:
+            session = DatabaseManager.get_session("config")
+            logging.info(f"🔄 [APP] Attempting to set {len(configs)} configuration keys in batch.")
+
+            existing_configs = session.query(ConfigEntity).filter(ConfigEntity.key.in_(configs.keys())).all()
+            existing_keys = {config.key: config for config in existing_configs}
+
+            for key, value in configs.items():
+                if key in existing_keys:
+                    logging.info(f"🔄 [APP] Updating configuration key: {key}")
+                    existing_keys[key].value = value
+                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("✅ [APP] All configuration keys set successfully.")
+        except Exception as e:
+            if session:
+                session.rollback()
+            logging.exception(f"❌ [APP] Failed to set batch configuration keys: {e}")
+            raise RuntimeError("Failed to set batch configuration keys.") from e
+        finally:
+            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():
+        """
+        Print all configuration key-value pairs to the console.
+        """
+        try:
+            configs = ConfigurationManager.get_all_configs()
+            if configs:
+                print("📄 Current Configuration:")
+                for key, value in configs.items():
+                    # Mask sensitive information completely
+                    if key.lower() in ['token', 'password']:
+                        print(f"  🔹 {key}: ***")
+                    else:
+                        print(f"  🔹 {key}: {value}")
+            else:
+                print("⚠️ No configuration found. Please initialize the configuration.")
+        except Exception as e:
+            logging.exception("❌ Failed to print configuration keys.")
+            raise RuntimeError("Failed to print configuration keys.") from e

nedo_vision_worker/config/__init__.py

@@ -0,0 +1 @@
+ 

nedo_vision_worker/database/DatabaseManager.py

@@ -0,0 +1,219 @@
+import os
+from alembic.migration import MigrationContext
+from alembic.operations import Operations
+from alembic.operations.ops import AlterColumnOp
+from alembic.autogenerate import produce_migrations
+from sqlalchemy import Column, Connection, Table, create_engine, inspect, MetaData, select, text
+from sqlalchemy.orm import sessionmaker, declarative_base, scoped_session
+from pathlib import Path
+import logging
+
+# Base class for ORM models
+Base = declarative_base()
+
+# Dictionary to hold engines and session factories
+ENGINES = {}
+SESSION_FACTORIES = {}
+_initialized = False  # To track whether databases have been initialized
+_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)
+
+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
+    
+    return {
+        "db": _storage_path / "sqlite",
+        "files": _storage_path / "files",
+        "models": _storage_path / "model",
+    }
+
+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
+    
+    if subdir:
+        return _storage_path / subdir
+    return _storage_path
+
+def alter_drop_not_null_sqlite(conn: Connection, table_name: str, column_name: str):
+    # Load existing metadata
+    metadata = MetaData()
+    metadata.reflect(conn)
+
+    table = metadata.tables[table_name]
+
+    # Create new table with updated schema (column without NOT NULL)
+    new_columns = []
+    for col in table.columns:
+        new_col = Column(
+            col.name,
+            col.type,
+            nullable=(True if col.name == column_name else col.nullable),
+            primary_key=col.primary_key,
+            default=col.default,
+            server_default=col.server_default
+        )
+        new_columns.append(new_col)
+    
+    new_table = Table(f"{table_name}_new", MetaData(), *new_columns)
+    new_table.create(conn)
+
+    # Copy data
+    data = conn.execute(select(table)).mappings().all()
+    if data:
+        conn.execute(new_table.insert(), data)
+
+    # Drop old table, rename new table
+    table.drop(conn)
+    conn.execute(text(f"ALTER TABLE {table_name}_new RENAME TO {table_name}"))
+
+class DatabaseManager:
+    """
+    Manages multiple database connections, engines, and session factories.
+    """
+
+    @staticmethod
+    def init_databases():
+        """
+        Initialize databases and create tables for all models based on their `__bind_key__`.
+        """
+        global _initialized
+        if _initialized:
+            logging.info("✅ Databases already initialized.")
+            return
+
+        # Get storage paths with lazy loading
+        storage_paths = _get_storage_paths()
+        
+        # Define database paths
+        DB_PATHS = {
+            "default": storage_paths["db"] / "default.db",
+            "config": storage_paths["db"] / "config.db",
+            "logging": storage_paths["db"] / "logging.db",
+        }
+
+        # Initialize engines and session factories for each database
+        for name, path in DB_PATHS.items():
+            path.parent.mkdir(parents=True, exist_ok=True)  # Ensure directory exists
+            engine = create_engine(f"sqlite:///{path.as_posix()}")
+            ENGINES[name] = engine
+            SESSION_FACTORIES[name] = scoped_session(sessionmaker(bind=engine))  # Use scoped sessions
+            DatabaseManager.synchronize(name)
+
+        _initialized = True
+        logging.info("✅ [APP] Databases initialized successfully.")
+
+    @staticmethod
+    def synchronize(db_name):
+        engine = ENGINES[db_name]
+
+        models = []
+        for mapper_object in Base.registry.mappers:
+            model_class = mapper_object.class_
+            if hasattr(model_class, "__bind_key__") and model_class.__bind_key__ == db_name:
+                models.append(model_class)
+
+        inspector = inspect(engine)
+        dialect = inspector.dialect.name
+        existing_tables = inspector.get_table_names()
+
+        if not existing_tables:
+            if not models:
+                return
+
+            for model in models:
+                model.metadata.create_all(bind=engine)
+
+            logging.info(f"✅ [APP] Created initial tables for '{db_name}' database")
+            return
+        
+        connection: Connection = engine.connect()
+        try:
+           with connection.begin():
+                context = MigrationContext.configure(connection)
+
+                target_metadata = MetaData()
+                for model in models:
+                    for table in model.metadata.tables.values():
+                        if table.name not in target_metadata.tables:
+                            table.tometadata(target_metadata)
+
+                ops_list = produce_migrations(context, target_metadata).upgrade_ops_list
+
+                if ops_list[0].ops:
+                    logging.info(f"⚡ [APP] Detected schema changes in '{db_name}' database. Applying migrations...")
+                
+                    op = Operations(context)
+                    for upgrade_ops in ops_list:
+                        for schema_element in upgrade_ops.ops:
+                            if hasattr(schema_element, 'ops'):
+                                for table_op in schema_element.ops:
+                                    if dialect == 'sqlite' and isinstance(table_op, AlterColumnOp):
+                                        alter_drop_not_null_sqlite(connection, table_op.table_name, table_op.column_name)
+                                    else:
+                                        op.invoke(table_op)
+                            else:
+                                if dialect == 'sqlite' and isinstance(schema_element, AlterColumnOp):
+                                    alter_drop_not_null_sqlite(connection, schema_element.table_name, schema_element.column_name)
+                                else:
+                                    op.invoke(schema_element)
+                            
+                        for diff in upgrade_ops.as_diffs():
+                            if diff[0] == 'add_table':
+                                table = diff[1]
+                                logging.info(f"🆕 [APP] Creating new table: {table.name}")
+                            
+                            elif diff[0] == 'remove_table':
+                                table_name = diff[1].name
+                                logging.info(f"🗑️ [APP] Removing table: {table_name}")
+                            
+                            elif diff[0] == 'add_column':
+                                table_name, column = diff[2], diff[3]
+                                logging.info(f"➕ [APP] Adding column: {column.name} to table {table_name}")
+                            
+                            elif diff[0] == 'remove_column':
+                                table_name, column = diff[2], diff[3]
+                                logging.info(f"➖ [APP] Removing column: {column.name} from table {table_name}")
+
+                    logging.info(f"✅ [APP] Schema migrations for '{db_name}' database completed successfully")
+                else:
+                    logging.info(f"✅ [APP] No schema changes detected for '{db_name}' database")
+
+        finally:
+            connection.close()
+
+    @staticmethod
+    def get_session(db_name: str = "default"):
+        """
+        Provide a session object for the specified database.
+
+        Args:
+            db_name (str): The name of the database connection.
+
+        Returns:
+            sqlalchemy.orm.Session: A session for the specified database.
+
+        Raises:
+            ValueError: If the database name is invalid.
+        """
+        if db_name not in SESSION_FACTORIES:
+            raise ValueError(f"❌ Invalid database name: {db_name}")
+        return SESSION_FACTORIES[db_name]
+
+    @staticmethod
+    def shutdown():
+        """
+        Cleanly dispose of all database connections.
+        """
+        for name, engine in ENGINES.items():
+            engine.dispose()
+        logging.info("🛑 All database connections have been closed.")

nedo_vision_worker/database/__init__.py

@@ -0,0 +1 @@
+