nedo-vision-worker 1.3.7__py3-none-any.whl → 1.3.9__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.7"
+__version__ = "1.3.9"
 __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
+from nedo_vision_worker import __version__
 
 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=f"nedo-vision-worker {__version__}")
+
+        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/services/ConnectionInfoClient.py

@@ -31,7 +31,7 @@ class ConnectionInfoClient(GrpcClientBase):
         try:
             if not self.stub:
                 raise Exception("Not connected to manager")
-
+            
             # Prepare the request
             request = GetWorkerConnectionInfoRequest(token=self.token)
 

nedo_vision_worker/services/GrpcClientBase.py

@@ -41,6 +41,7 @@ class GrpcClientBase:
     }
 
     def __init__(self, server_host: str, server_port: int = 50051, max_retries: int = 3):
+        self.stub = None
         self.server_address = f"{server_host}:{server_port}"
         self.channel: Optional[grpc.Channel] = None
         self.connected = False

nedo_vision_worker/util/CorruptedImageValidator.py

@@ -0,0 +1,55 @@
+from PIL import Image
+import io
+import numpy as np
+
+# Tunables (adjust once, then forget)
+MIN_IMAGE_KB = 10
+GRAY_RATIO_THRESHOLD = 0.55
+GRAY_MIN = 90
+GRAY_MAX = 210
+GRAY_DELTA = 4
+
+def validate_image_gray_area(image_bytes: bytes) -> bool:
+    print(len(image_bytes))
+    # ---- Stage 1: size check (O(1)) ----
+    if len(image_bytes) < (MIN_IMAGE_KB * 1024):
+        return False
+
+    # ---- Stage 2: structural integrity (cheap) ----
+    try:
+        with Image.open(io.BytesIO(image_bytes)) as img:
+            img.verify()
+    except Exception:
+        return False
+
+    # ---- Stage 3: partial pixel decode (cropped, fast) ----
+    try:
+        with Image.open(io.BytesIO(image_bytes)) as img:
+            img = img.convert("RGB")
+
+            w, h = img.size
+            if w == 0 or h == 0:
+                return False
+
+            # Sample bottom 35% where corruption usually appears
+            crop_y = int(h * 0.65)
+            img_crop = img.crop((0, crop_y, w, h))
+
+            # Downscale aggressively (huge speedup)
+            img_small = img_crop.resize((w // 8, h // 8))
+
+            arr = np.asarray(img_small, dtype=np.uint8)
+
+            r, g, b = arr[..., 0], arr[..., 1], arr[..., 2]
+
+            gray_mask = (
+                (np.abs(r - g) < GRAY_DELTA) &
+                (np.abs(r - b) < GRAY_DELTA) &
+                (r > GRAY_MIN) & (r < GRAY_MAX)
+            )
+
+            gray_ratio = gray_mask.mean()
+            return gray_ratio < GRAY_RATIO_THRESHOLD
+
+    except Exception:
+        return False

nedo_vision_worker/worker/DatasetFrameWorker.py

@@ -7,6 +7,7 @@ from typing import Dict
 from ..services.WorkerSourcePipelineClient import WorkerSourcePipelineClient
 from ..services.GrpcClientManager import GrpcClientManager
 from ..repositories.DatasetSourceRepository import DatasetSourceRepository
+from ..util.CorruptedImageValidator import validate_image_gray_area
 
 logger = logging.getLogger(__name__)
 
@@ -96,6 +97,9 @@ class DatasetSourceThread:
         try:
             # Get frame from source
             frame_bytes = self._get_frame_from_source(self.dataset_source.worker_source_url)
+            if not validate_image_gray_area(frame_bytes):
+                logger.warning(f"⚠️ [APP] Detected gray area corruption in image while processing {self.dataset_source.dataset_name} (ID: {self.dataset_source.id})")
+                return True
             
             if frame_bytes:
                 # Generate unique filename

nedo_vision_worker/worker/RabbitMQListener.py

@@ -88,10 +88,6 @@ class RabbitMQListener:
         self.exchange_name = exchange_name
         self.queue_name = queue_name
 
-        if self.listener_thread and self.listener_thread.is_alive():
-            logger.warning("⚠️ [APP] RabbitMQ listener is already running.")
-            return
-            
         # Clean up any dead thread reference
         if self.listener_thread and not self.listener_thread.is_alive():
             self.listener_thread = None

nedo_vision_worker/worker_service.py

@@ -9,14 +9,9 @@ try:
 except RuntimeError:
     pass
 
-from .initializer.AppInitializer import AppInitializer
 from .worker.WorkerManager import WorkerManager
-from .config.ConfigurationManager import ConfigurationManager
-from .util.HardwareID import HardwareID
+from .config.ConfigurationManagerInterface import ConfigurationManagerInterface
 from .services.GrpcClientBase import set_auth_failure_callback
-from .database.DatabaseManager import set_storage_path
-from . import models
-
 
 class WorkerService:
     """
@@ -26,8 +21,9 @@ class WorkerService:
     
     def __init__(
         self,
+        configuration_manager: ConfigurationManagerInterface,
         server_host: str = "be.vision.sindika.co.id",
-        token: str = None,
+        token: str = "",
         system_usage_interval: int = 30,
         rtmp_server: str = "rtmp://live.vision.sindika.co.id:1935/live",
         storage_path: str = "data",
@@ -44,9 +40,8 @@ class WorkerService:
             storage_path: Storage path for databases and files (default: 'data')
             server_port: gRPC server port (default: 50051)
         """
-        # Set the global storage path before any database operations
-        set_storage_path(storage_path)
         
+        self._configuration_manager = configuration_manager
         self.logger = self._setup_logging()
         self.worker_manager = None
         self.running = False
@@ -89,84 +84,6 @@ class WorkerService:
         
         return logging.getLogger(__name__)
 
-    def _initialize_configuration(self):
-        """Initialize the application configuration."""
-        self.logger.info("🚀 [APP] Initializing application...")
-
-        # Initialize database
-        ConfigurationManager.init_database()
-
-        # Load all configurations at once
-        config = ConfigurationManager.get_all_configs()
-        
-        # Use the server_host parameter directly
-        server_host = self.server_host
-        self.logger.info(f"🌐 [APP] Using server host: {server_host}")
-
-        # Check if configuration exists
-        if not config:
-            self.logger.info("⚙️ [APP] Configuration not found. Performing first-time setup...")
-
-            # 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: {server_host}")
-
-            # Check if token is provided
-            if not self.token:
-                raise ValueError("Token is required for worker initialization. Please provide a token obtained from the frontend.")
-
-            # Initialize with token
-            AppInitializer.initialize_configuration(hardware_id, server_host, self.token)
-
-            # Set server_port in config for first-time setup
-            ConfigurationManager.set_config("server_port", str(self.server_port))
-
-            # Get configuration
-            config = ConfigurationManager.get_all_configs()
-        else:
-            # Check if server_host, server_port, or token has changed and update if needed
-            config_updated = False
-            
-            if config['server_host'] != server_host:
-                ConfigurationManager.set_config("server_host", server_host)
-                config_updated = True
-                self.logger.info(f"✅ [APP] Updated server host to: {server_host}")
-            
-            # Check if server_port has changed and update if needed
-            if str(config.get('server_port')) != str(self.server_port):
-                ConfigurationManager.set_config("server_port", str(self.server_port))
-                config_updated = True
-                self.logger.info(f"✅ [APP] Updated server port to: {self.server_port}")
-            
-            # Check if token has changed and update if needed
-            if self.token and config.get('token') != self.token:
-                ConfigurationManager.set_config("token", self.token)
-                config_updated = True
-                self.logger.info("✅ [APP] Updated authentication token")
-            
-            if config_updated:
-                config = ConfigurationManager.get_all_configs()
-                self.logger.info("✅ [APP] Configuration updated successfully")
-            else:
-                self.logger.info("✅ [APP] Configuration found. No changes needed.")
-            
-            # Always fetch connection info on startup to check for updates
-            self.logger.info("🔄 [APP] Checking for connection info updates...")
-            token_to_use = self.token if self.token else config.get('token')
-            if token_to_use:
-                AppInitializer.update_connection_info(server_host, self.server_port, token_to_use)
-                # Reload config after potential updates
-                config = ConfigurationManager.get_all_configs()
-            else:
-                self.logger.warning("⚠️ [APP] No token available to fetch connection info updates")
-        
-        # Add runtime parameters to config
-        config['rtmp_server'] = self.rtmp_server
-        
-        return config
-
     def initialize(self) -> bool:
         """
         Initialize the worker service components.
@@ -178,9 +95,9 @@ class WorkerService:
             self.logger.info("Worker service initialization started")
             
             # Initialize configuration
-            self.config = self._initialize_configuration()
-            
-            if not self.config:
+            self.config = self._configuration_manager.get_all_configs()
+            print(self.config)
+            if self.config is None:
                 raise RuntimeError("Failed to initialize configuration")
 
             # Initialize WorkerManager
@@ -275,12 +192,12 @@ def main():
     args = parser.parse_args()
     
     # Create and run worker service
-    service = WorkerService(
-        server_host=args.server_host,
-        server_port=args.server_port,
-        system_usage_interval=args.system_usage_interval
-    )
-    service.run()
+    # service = WorkerService(
+    #     server_host=args.server_host,
+    #     server_port=args.server_port,
+    #     system_usage_interval=args.system_usage_interval
+    # )
+    # service.run()
 
 
 if __name__ == "__main__":

{nedo_vision_worker-1.3.7.dist-info → nedo_vision_worker-1.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedo-vision-worker
-Version: 1.3.7
+Version: 1.3.9
 Summary: Nedo Vision Worker Service Library for AI Vision Processing
 Author-email: Willy Achmat Fauzi <willy.achmat@gmail.com>
 Maintainer-email: Willy Achmat Fauzi <willy.achmat@gmail.com>
@@ -40,6 +40,7 @@ Requires-Dist: protobuf>=3.20.0
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: requests>=2.28.0
 Requires-Dist: SQLAlchemy>=1.4.0
+Requires-Dist: Pillow>=12.1.0
 Requires-Dist: pynvml>=11.4.1; platform_system != "Darwin" or platform_machine != "arm64"
 Provides-Extra: opencv
 Requires-Dist: opencv-python>=4.6.0; platform_machine not in "aarch64 armv7l" and extra == "opencv"

{nedo_vision_worker-1.3.7.dist-info → nedo_vision_worker-1.3.9.dist-info}/RECORD

@@ -1,13 +1,14 @@
-nedo_vision_worker/__init__.py,sha256=SoFfn_lr0mgpPFESSvD3Wg3PDoyi4bwdY5gGVadDJPg,203
-nedo_vision_worker/cli.py,sha256=ddWspJmSgVkcUYvRdkvTtMNuMTDvNCqLLuMVU9KE3Ik,7457
+nedo_vision_worker/__init__.py,sha256=vQPFkMA2dVYlXMWnsaaP0bx0guzxL0prnYAA2hObGUE,203
+nedo_vision_worker/bootstrap.py,sha256=CUwNtb_mf1VGwO1-ujai7ZNN0ojiO3XQzV50JEwmS3U,1430
+nedo_vision_worker/cli.py,sha256=L0hrjSdU4yfoC-KuxkYJ3orpwH_dWzdmGMTHzjOj5MM,2539
 nedo_vision_worker/doctor.py,sha256=wNkpe8gLVd76Y_ViyK2h1ZFdqeSl37MnzZN5frWKu30,48410
-nedo_vision_worker/worker_service.py,sha256=9zz8hKwDwqwpfS0KPQfftGJtRci0uj_wiwcr_TGf-E0,11039
-nedo_vision_worker/config/ConfigurationManager.py,sha256=QrQaQ9Cdjpkcr2JE_miyrWJIZmMgZwJYBz-wE45Zzes,8011
+nedo_vision_worker/worker_service.py,sha256=4SoWqjuz7lQKByU48-yBLV0CeTmX9LIJ5uIc-vmn6ck,7318
+nedo_vision_worker/config/ConfigurationManager.py,sha256=NQD6kXmBrahuMIEhvUr1zrcB60HlQxTmWvBY1dD28PI,8392
+nedo_vision_worker/config/ConfigurationManagerInterface.py,sha256=doV1Qv6e2edL5Llu-JOF_vhmB87iG-yTXL_GYmlvv9M,270
+nedo_vision_worker/config/DummyConfigurationManager.py,sha256=J1Ur5AD4YKl6CmdJ78SufSw5gdTQURUQtww61FxIoks,1685
 nedo_vision_worker/config/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker/database/DatabaseManager.py,sha256=j2koXo1fnMmAyQnY4sv4txfZR8qIzrPyev-sQ4HBaOQ,9478
 nedo_vision_worker/database/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-nedo_vision_worker/initializer/AppInitializer.py,sha256=6UVdjiuayziPYZ7JkQ436z7-9sHj7J3jtp6lfQsu-DU,5698
-nedo_vision_worker/initializer/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker/models/__init__.py,sha256=6ZH2W1Jcy4o6xBPqFPcyxRU2UJ5Zvw_kfO38yLLGtHA,796
 nedo_vision_worker/models/ai_model.py,sha256=9muyZL9AxtX417-tYUiw8bgvFPtqdXgEAq-hm_mLxGY,2277
 nedo_vision_worker/models/auth.py,sha256=hBMchk6ATy8Wc3fUWLpYRbeNiteb43t2hIub0cCFap8,456
@@ -48,11 +49,11 @@ nedo_vision_worker/repositories/WorkerSourcePipelineRepository.py,sha256=xfmEvgn
 nedo_vision_worker/repositories/WorkerSourceRepository.py,sha256=AhAJLAacMFdsOgtQNiu7Pahl1DAGI0T1THHeUlKwQJc,2385
 nedo_vision_worker/repositories/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker/services/AIModelClient.py,sha256=lxRNax6FR-pV0G1NpJnlaqjbQeu3kRolIUNSw1RkoZA,15406
-nedo_vision_worker/services/ConnectionInfoClient.py,sha256=toC9zuY2Hrx1Cwq8Gycy_iFlaG1DvFT4qewlLlitpEQ,2214
+nedo_vision_worker/services/ConnectionInfoClient.py,sha256=udvcKVjZaWfmMbC3HM1cybU5fz9ZidnJGnHj6OSr0uQ,2226
 nedo_vision_worker/services/DatasetSourceClient.py,sha256=O5a7onxFl0z47zXaMXWxHAMPuuc-i_vzkd2w5fwrukc,3319
 nedo_vision_worker/services/DirectDeviceToRTMPStreamer.py,sha256=Ypcc0fh1WiUMkICN_KRRAvGmeGkgF8jQ06gfiRYReW4,24747
 nedo_vision_worker/services/FileToRTMPServer.py,sha256=0hY5pmeAzLw_d3uPR2Qp6gSAYb4rJHiAunuNe08OvkM,2870
-nedo_vision_worker/services/GrpcClientBase.py,sha256=hPyxOGw3aGSW1FhmY3wp3Iq8U1MArXBmvEMdmd63NZ4,6827
+nedo_vision_worker/services/GrpcClientBase.py,sha256=RkJDGRsXu5HalMDR8cOsIaoFf5tA_cLTkh5euBPyo2M,6852
 nedo_vision_worker/services/GrpcClientManager.py,sha256=DLXekmxlQogLo8V9-TNDXtyHT_UG-BaggqwsIups55k,5568
 nedo_vision_worker/services/GrpcConnection.py,sha256=UNjaUC4ZcXuteHQx8AAAL5ymYkT1OpoIvyCYPUc3tCI,4915
 nedo_vision_worker/services/ImageUploadClient.py,sha256=T353YsRfm74G7Mh-eWr5nvdQHXTfpKwHJFmNW8HyjT8,3019
@@ -70,6 +71,7 @@ nedo_vision_worker/services/WorkerSourcePipelineClient.py,sha256=9qj65uBujCVoUE3
 nedo_vision_worker/services/WorkerSourceUpdater.py,sha256=RUNkiL1FRrKkW4UDm4i4i8ShgJy__MhTTrNlfouDAZc,8892
 nedo_vision_worker/services/WorkerStatusClient.py,sha256=7kC5EZjEBwWtHOE6UQ29OPCpYnv_6HSuH7Tc0alK_2Q,2531
 nedo_vision_worker/services/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
+nedo_vision_worker/util/CorruptedImageValidator.py,sha256=F58L-thVFiz_sfi84L6xc9y2njrEuiO2d9AwzSe03hk,1529
 nedo_vision_worker/util/EncoderSelector.py,sha256=-9lZwVmiKzJr1cELeuCXi-jRonty2bpociZq4KDScmA,3399
 nedo_vision_worker/util/FFmpegUtil.py,sha256=QnQrzurmllzGb7SlAAYCrzKBUblweoFU-0h-X-32IYg,1829
 nedo_vision_worker/util/HardwareID.py,sha256=rSW8-6stm7rjXEdkYGqXMUn56gyw62YiWnSwZQVCCLM,4315
@@ -83,19 +85,19 @@ nedo_vision_worker/worker/CoreActionWorker.py,sha256=lb7zPY3yui6I3F4rX4Ii7JwpWZa
 nedo_vision_worker/worker/DataSenderWorker.py,sha256=TpMLhjpuuW-70TP6BzKpR9irPqVr9dDyFsBAA5s2N3U,8784
 nedo_vision_worker/worker/DataSyncWorker.py,sha256=LmDPt2J1frmXwuR46L6b0MjlFOHfgG-4_0MGQa78zF4,6288
 nedo_vision_worker/worker/DatasetFrameSender.py,sha256=1SFYj8LJFNi-anBTapsbq8U_NGMM7mnoMKg9NeFAHys,8087
-nedo_vision_worker/worker/DatasetFrameWorker.py,sha256=vzl6bab58a8MyXm6lfDom-kuGKwRj70moFIizePAnU0,18931
+nedo_vision_worker/worker/DatasetFrameWorker.py,sha256=gVgMEnwZsLUsnOIml4XJGTBk5YkB0cjDYEp0X14OMHQ,19255
 nedo_vision_worker/worker/PPEDetectionManager.py,sha256=sXeOjvhCzi4oUhDZwH5-8DSxI9b__Jp0de8QksgaYGw,6063
 nedo_vision_worker/worker/PipelineActionWorker.py,sha256=xgvryjKtEsMj4BKqWzDIaK_lFny-DfMCj5Y2DxHnWww,5651
 nedo_vision_worker/worker/PipelineImageWorker.py,sha256=J8VBUG0cwcH3qOJp2zTl30B-XhmPFyvJLjxitKJYq0E,5642
 nedo_vision_worker/worker/PipelinePreviewWorker.py,sha256=owFiBbktcOZkdImQeykZSeBIR2-mpt6HNkmYIkLRKzE,6397
-nedo_vision_worker/worker/RabbitMQListener.py,sha256=9gR49MDplgpyb-D5HOH0K77-DJQFvhS2E7biL92SjSU,6950
+nedo_vision_worker/worker/RabbitMQListener.py,sha256=Gwn7VpRg0fMZ0fva98eOnTzZ4HPFf2i_ZCUgwfTdyYQ,6768
 nedo_vision_worker/worker/RestrictedAreaManager.py,sha256=Pz2M9KPSMa1QPXZeYhyN9ih4eX6wmkNS_ZPu5KrvNxY,5927
 nedo_vision_worker/worker/SystemUsageManager.py,sha256=mkh4sT-HkIEY1CJHMEG6LP9ATu39YXvLRLyf995OkoQ,5315
 nedo_vision_worker/worker/VideoStreamWorker.py,sha256=5n6v1PNO7IB-jj_McALLkUP-cBjJoIEw4UiSAs3vTb0,7606
 nedo_vision_worker/worker/WorkerManager.py,sha256=2bxXi19fp3p1qjYBStYRdVVgko8dnevXx1_M_sqH5og,5521
 nedo_vision_worker/worker/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-nedo_vision_worker-1.3.7.dist-info/METADATA,sha256=PFsTaJvY-oOl6159V_lzBNIcFG7lKODrjYWNsYqzPAU,14728
-nedo_vision_worker-1.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nedo_vision_worker-1.3.7.dist-info/entry_points.txt,sha256=LrglS-8nCi8C_PL_pa6uxdgCe879hBETHDVXAckvs-8,60
-nedo_vision_worker-1.3.7.dist-info/top_level.txt,sha256=vgilhlkyD34YsEKkaBabmhIpcKSvF3XpzD2By68L-XI,19
-nedo_vision_worker-1.3.7.dist-info/RECORD,,
+nedo_vision_worker-1.3.9.dist-info/METADATA,sha256=nTYIlYmWee5VO9kjFPGbcsrNaYcamNkKc89ZzwKzF-o,14758
+nedo_vision_worker-1.3.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nedo_vision_worker-1.3.9.dist-info/entry_points.txt,sha256=LrglS-8nCi8C_PL_pa6uxdgCe879hBETHDVXAckvs-8,60
+nedo_vision_worker-1.3.9.dist-info/top_level.txt,sha256=vgilhlkyD34YsEKkaBabmhIpcKSvF3XpzD2By68L-XI,19
+nedo_vision_worker-1.3.9.dist-info/RECORD,,

nedo_vision_worker/initializer/AppInitializer.py

@@ -1,138 +0,0 @@
-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}")
-
-    @staticmethod
-    def update_connection_info(server_host: str, server_port: int, token: str):
-        """
-        Fetch and update connection information (RabbitMQ credentials) from the server.
-        This should be called on startup to ensure credentials are up-to-date.
-        
-        Args:
-            server_host: The server hostname or IP address
-            server_port: The gRPC server port
-            token: Authentication token for the worker
-            
-        Returns:
-            bool: True if update was successful, False otherwise
-        """
-        try:
-            # Validate server host
-            AppInitializer.validate_server_host(server_host)
-
-            # Get connection info using the ConnectionInfoClient
-            connection_client = ConnectionInfoClient(server_host, server_port, token)
-            connection_result = connection_client.get_connection_info()
-
-            if not connection_result["success"]:
-                logging.error(f"Failed to fetch connection info: {connection_result['message']}")
-                return False
-
-            # Check if any RabbitMQ credentials have changed
-            current_config = ConfigurationManager.get_all_configs()
-            config_updated = False
-            
-            rabbitmq_fields = {
-                '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']
-            }
-            
-            for field, new_value in rabbitmq_fields.items():
-                if current_config.get(field) != new_value:
-                    ConfigurationManager.set_config(field, new_value)
-                    config_updated = True
-                    logging.info(f"✅ [APP] Updated {field}")
-            
-            if config_updated:
-                logging.info("✅ [APP] RabbitMQ connection info updated successfully")
-            else:
-                logging.info("✅ [APP] RabbitMQ connection info is up-to-date")
-            
-            return True
-        
-        except ValueError as ve:
-            logging.error(f"Validation error: {ve}")
-            return False
-        except grpc.RpcError as ge:
-            logging.error(f"gRPC Error: {ge}")
-            return False
-        except Exception as e:
-            logging.error(f"Unexpected error updating connection info: {e}")
-            return False

nedo_vision_worker/initializer/__init__.py

@@ -1 +0,0 @@
-