nedo-vision-worker-core 0.2.0__py3-none-any.whl

nedo_vision_worker_core/config/ConfigurationManager.py

@@ -0,0 +1,173 @@
+import logging
+from .models.config import ConfigEntity
+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("Configuration database initialized successfully.")
+        except Exception as e:
+            logging.exception("Failed to initialize the configuration database.")
+            raise RuntimeError("Database initialization failed.") from e
+
+    @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("The 'key' must be a non-empty string.")
+        if not isinstance(value, str):
+            raise ValueError("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"Updating configuration key: {key}")
+                existing_config.value = value
+            else:
+                logging.info(f"Adding new configuration key: {key}")
+                new_config = ConfigEntity(key=key, value=value)
+                session.add(new_config)
+            session.commit()
+            logging.info(f"Configuration key '{key}' set successfully.")
+        except Exception as e:
+            if session:
+                session.rollback()
+            logging.exception(f"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("The 'configs' parameter must be a non-empty dictionary.")
+
+        session = None
+        try:
+            session = DatabaseManager.get_session("config")
+            logging.info(f"Attempting to set {len(configs)} configuration keys in batch.")
+
+            # Retrieve existing configurations
+            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"Updating configuration key: {key}")
+                    existing_keys[key].value = value
+                else:
+                    logging.info(f"Adding new configuration key: {key}")
+                    new_config = ConfigEntity(key=key, value=value)
+                    session.add(new_config)
+
+            session.commit()
+            logging.info("All configuration keys set successfully.")
+        except Exception as e:
+            if session:
+                session.rollback()
+            logging.exception(f"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"Retrieving configuration key: {key}")
+            config = session.query(ConfigEntity).filter_by(key=key).first()
+            if config:
+                logging.info(f"Configuration key '{key}' retrieved successfully.")
+                return config.value
+            else:
+                logging.warning(f"Configuration key '{key}' not found.")
+                return None
+        except Exception as e:
+            logging.exception(f"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("Retrieving all configuration keys.")
+            configs = session.query(ConfigEntity).all()
+            if configs:
+                logging.info("All configuration keys retrieved successfully.")
+                return {config.key: config.value for config in configs}
+            else:
+                logging.info("No configuration keys found.")
+                return {}
+        except Exception as e:
+            logging.exception("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():
+                    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_core/config/__init__.py

@@ -0,0 +1 @@
+ 

nedo_vision_worker_core/core_service.py

@@ -0,0 +1,237 @@
+import logging
+import time
+import signal
+import os
+from pathlib import Path
+from typing import Callable, Dict, List, Any
+
+from .util.DrawingUtils import DrawingUtils
+from .streams.VideoStreamManager import VideoStreamManager
+from .streams.StreamSyncThread import StreamSyncThread
+from .pipeline.PipelineSyncThread import PipelineSyncThread
+from .database.DatabaseManager import DatabaseManager
+# Import models to ensure they are registered with SQLAlchemy Base registry
+from . import models
+import cv2
+
+
+class CoreService:
+    """Service class for running the Nedo Vision Core processing."""
+
+    # Class-level callback registry for detection events
+    _detection_callbacks: Dict[str, List[Callable]] = {
+        'ppe_detection': [],
+        'area_violation': [],
+        'general_detection': []
+    }
+
+    def __init__(self, 
+                 drawing_assets_path: str = None,
+                 log_level: str = "INFO",
+                 storage_path: str = "data",
+                 rtmp_server: str = "rtmp://live.vision.sindika.co.id:1935/live"):
+        """
+        Initialize the Core Service.
+        
+        Args:
+            drawing_assets_path: Path to drawing assets directory (optional, uses bundled assets by default)
+            log_level: Logging level (DEBUG, INFO, WARNING, ERROR)
+            storage_path: Storage path for databases and files (default: data)
+            rtmp_server: RTMP server URL for video streaming (default: rtmp://localhost:1935/live)
+        """
+        self.running = True
+        self.video_manager = None
+        self.stream_sync_thread = None
+        self.pipeline_sync_thread = None
+        
+        # Store configuration parameters
+        self.storage_path = storage_path
+        self.rtmp_server = rtmp_server
+        
+        # Use bundled drawing assets by default
+        if drawing_assets_path is None:
+            # Get the path to the bundled drawing assets
+            current_dir = Path(__file__).parent
+            self.drawing_assets_path = str(current_dir / "drawing_assets")
+        else:
+            self.drawing_assets_path = drawing_assets_path
+            
+        self.log_level = log_level
+        
+        # Set up logging
+        self._setup_logging()
+        
+        # Set up signal handlers
+        signal.signal(signal.SIGINT, self._signal_handler)
+        signal.signal(signal.SIGTERM, self._signal_handler)
+
+    @classmethod
+    def register_detection_callback(cls, detection_type: str, callback: Callable[[Dict[str, Any]], None]):
+        """
+        Register a callback for detection events.
+        
+        Args:
+            detection_type: Type of detection ('ppe_detection', 'area_violation', 'general_detection')
+            callback: Function to call when detection occurs. Should accept a dict with detection data.
+        """
+        if detection_type not in cls._detection_callbacks:
+            cls._detection_callbacks[detection_type] = []
+        
+        cls._detection_callbacks[detection_type].append(callback)
+        logging.info(f"📞 Registered {detection_type} callback: {callback.__name__}")
+
+    @classmethod
+    def unregister_detection_callback(cls, detection_type: str, callback: Callable[[Dict[str, Any]], None]):
+        """
+        Unregister a callback for detection events.
+        
+        Args:
+            detection_type: Type of detection ('ppe_detection', 'area_violation', 'general_detection')
+            callback: Function to unregister
+        """
+        if detection_type in cls._detection_callbacks and callback in cls._detection_callbacks[detection_type]:
+            cls._detection_callbacks[detection_type].remove(callback)
+            logging.info(f"📞 Unregistered {detection_type} callback: {callback.__name__}")
+
+    @classmethod
+    def trigger_detection_callback(cls, detection_type: str, detection_data: Dict[str, Any]):
+        """
+        Trigger all registered callbacks for a detection type.
+        
+        Args:
+            detection_type: Type of detection that occurred
+            detection_data: Dict containing detection information
+        """
+        callbacks = cls._detection_callbacks.get(detection_type, [])
+        general_callbacks = cls._detection_callbacks.get('general_detection', [])
+        
+        # Call specific callbacks
+        for callback in callbacks:
+            try:
+                callback(detection_data)
+            except Exception as e:
+                logging.error(f"❌ Error in {detection_type} callback {callback.__name__}: {e}")
+        
+        # Call general callbacks
+        for callback in general_callbacks:
+            try:
+                callback(detection_data)
+            except Exception as e:
+                logging.error(f"❌ Error in general detection callback {callback.__name__}: {e}")
+
+    @classmethod
+    def list_callbacks(cls) -> Dict[str, List[str]]:
+        """
+        List all registered callbacks.
+        
+        Returns:
+            Dict mapping detection types to callback function names
+        """
+        return {
+            detection_type: [callback.__name__ for callback in callbacks]
+            for detection_type, callbacks in cls._detection_callbacks.items()
+            if callbacks
+        }
+
+    def _setup_environment(self):
+        """Set up environment variables for components that still require them (like RTMPStreamer)."""
+        os.environ["STORAGE_PATH"] = self.storage_path
+        os.environ["RTMP_SERVER"] = self.rtmp_server
+
+    def _setup_logging(self):
+        """Configure logging settings."""
+        logging.basicConfig(
+            level=getattr(logging, self.log_level.upper()),
+            format="%(asctime)s [%(levelname)s] %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+        logging.getLogger("sqlalchemy").setLevel(logging.WARNING)
+        logging.getLogger("pika").setLevel(logging.WARNING)
+        logging.getLogger("grpc").setLevel(logging.FATAL)
+        logging.getLogger("ffmpeg").setLevel(logging.FATAL)
+        logging.getLogger("subprocess").setLevel(logging.FATAL)
+
+    def _signal_handler(self, signum, frame):
+        """Handle system signals for graceful shutdown."""
+        logging.info(f"Received signal {signum}, shutting down...")
+        self.stop()
+
+    def initialize(self):
+        """Initialize all application components."""
+        logging.info("🚀 Initializing Nedo Vision Core components...")
+
+        try:
+            # Set up environment variables for internal components that still need them
+            self._setup_environment()
+
+            # Initialize Database with storage path
+            DatabaseManager.init_databases(storage_path=self.storage_path)
+
+            # Initialize Drawing Utils
+            DrawingUtils.initialize(self.drawing_assets_path)
+
+            # Initialize Video Stream Manager
+            self.video_manager = VideoStreamManager()
+
+            # Start stream synchronization thread
+            self.stream_sync_thread = StreamSyncThread(self.video_manager)
+            self.stream_sync_thread.start()
+
+            # Start pipeline synchronization thread (AI processing)
+            self.pipeline_sync_thread = PipelineSyncThread(self.video_manager)
+            self.pipeline_sync_thread.start()
+
+            logging.info("✅ Nedo Vision Core initialized and running.")
+            return True
+            
+        except Exception as e:
+            logging.error(f"❌ Failed to initialize components: {e}", exc_info=True)
+            return False
+
+    def run(self):
+        """Run the main application loop."""
+        if not self.initialize():
+            logging.error("❌ Failed to initialize, exiting...")
+            return False
+            
+        try:
+            logging.info("🔄 Core service is running. Press Ctrl+C to stop.")
+            while self.running:
+                time.sleep(1)
+            return True
+        except KeyboardInterrupt:
+            logging.info("🛑 Interrupt received, shutting down...")
+            return True
+        except Exception as e:
+            logging.error(f"❌ Unexpected error: {e}", exc_info=True)
+            return False
+        finally:
+            self.stop()
+
+    def stop(self):
+        """Stop all application components gracefully."""
+        logging.info("🛑 Stopping Nedo Vision Core...")
+        
+        self.running = False
+        
+        try:    
+            if self.stream_sync_thread:
+                self.stream_sync_thread.running = False
+                self.stream_sync_thread.join(timeout=5)
+                
+            if self.pipeline_sync_thread:
+                self.pipeline_sync_thread.running = False
+                self.pipeline_sync_thread.join(timeout=5)
+
+            if self.video_manager:
+                self.video_manager.stop_all()
+                
+            # Final cleanup
+            cv2.destroyAllWindows()
+            for _ in range(5):  # Force windows to close
+                cv2.waitKey(1)
+                
+        except Exception as e:
+            logging.error(f"Error during shutdown: {e}")
+        finally:
+            logging.info("✅ Nedo Vision Core shutdown complete.") 

nedo_vision_worker_core/database/DatabaseManager.py

@@ -0,0 +1,236 @@
+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
+
+# Add dotenv for environment loading
+try:
+    from dotenv import load_dotenv
+except ImportError:
+    load_dotenv = None
+
+# 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
+
+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.
+    """
+
+    STORAGE_PATH = None
+    STORAGE_PATHS = None
+
+    @staticmethod
+    def _load_env_file():
+        """Load .env file from multiple possible locations (like worker_service.py)."""
+        if load_dotenv is None:
+            return
+        from os.path import join, dirname
+        import os
+        possible_paths = [
+            ".env",
+            join(dirname(__file__), '..', '..', '.env'),
+            join(dirname(__file__), '..', '.env'),
+            join(os.path.expanduser("~"), '.nedo_vision_worker.env'),
+        ]
+        for env_path in possible_paths:
+            if os.path.exists(env_path):
+                try:
+                    load_dotenv(env_path)
+                    logging.info(f"✅ [DB] Loaded environment from: {env_path}")
+                    break
+                except Exception as e:
+                    logging.warning(f"⚠️ [DB] Failed to load .env from {env_path}: {e}")
+
+    @staticmethod
+    def init_databases(storage_path: str = None):
+        """
+        Initialize databases and create tables for all models based on their `__bind_key__`.
+        
+        Args:
+            storage_path: Storage path for databases and files. If None, will try to load from environment.
+        """
+        global _initialized
+        if _initialized:
+            logging.info("✅ Databases already initialized.")
+            return
+
+        # Set storage paths - prioritize parameter over environment variables
+        if storage_path:
+            DatabaseManager.STORAGE_PATH = Path(storage_path)
+        else:
+            # Fallback to environment variables for backward compatibility
+            DatabaseManager._load_env_file()
+            DatabaseManager.STORAGE_PATH = Path(os.environ.get("STORAGE_PATH", "data"))
+            
+        DatabaseManager.STORAGE_PATHS = {
+            "db": DatabaseManager.STORAGE_PATH / "sqlite",
+            "files": DatabaseManager.STORAGE_PATH / "files",
+            "models": DatabaseManager.STORAGE_PATH / "model",
+        }
+
+        # Define database paths
+        DB_PATHS = {
+            "default": DatabaseManager.STORAGE_PATHS["db"] / "default.db",
+            "config": DatabaseManager.STORAGE_PATHS["db"] / "config.db",
+            "logging": DatabaseManager.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_core/database/__init__.py

@@ -0,0 +1 @@
+ 

nedo_vision_worker_core/detection/BaseDetector.py

@@ -0,0 +1,22 @@
+from abc import ABC, abstractmethod
+
+class BaseDetector(ABC):
+    """
+    Abstract base class for all object detectors.
+    """
+
+    @abstractmethod
+    def load_model(self, model_metadata):
+        pass
+
+    @abstractmethod
+    def detect_objects(self, frame, confidence_threshold=0.7):
+        """
+        Detect objects in the input frame.
+        Args:
+            frame: Image/frame (numpy array)
+            confidence_threshold: Minimum confidence threshold for detections (optional)
+        Returns:
+            List of detections: [{"label": str, "confidence": float, "bbox": [x1, y1, x2, y2]}, ...]
+        """
+        pass