unrealon 1.1.6__py3-none-any.whl → 2.0.5__py3-none-any.whl

unrealon_driver/driver/lifecycle/initialization.py

@@ -0,0 +1,97 @@
+"""
+Driver initialization logic.
+
+Handles the setup and initialization of all driver components.
+"""
+
+import logging
+from typing import List, TYPE_CHECKING
+
+from ..core.config import DriverMode
+from ..communication.websocket_client import WebSocketClient
+from ..communication.session import DriverSession
+
+if TYPE_CHECKING:
+    from ..core.driver import UniversalDriver
+
+logger = logging.getLogger(__name__)
+
+
+class DriverInitializer:
+    """Handles driver initialization process."""
+    
+    @staticmethod
+    async def initialize_driver(driver: 'UniversalDriver', capabilities: List[str] = []) -> bool:
+        """
+        Initialize driver with all components.
+        
+        Args:
+            driver: UniversalDriver instance
+            capabilities: List of driver capabilities
+            
+        Returns:
+            True if initialization successful
+        """
+        # Store capabilities
+        driver.capabilities = capabilities
+        
+        try:
+            logger.info(f"Initializing UniversalDriver: {driver.driver_id}")
+            
+            # Initialize manager system
+            if not await driver.manager_registry.initialize_all():
+                logger.error("Manager initialization failed")
+                return False
+            
+            # Initialize module system
+            await driver.module_registry.initialize_all()
+            
+            # Setup WebSocket and session
+            await DriverInitializer._setup_communication(driver, capabilities)
+            
+            logger.info(f"UniversalDriver {driver.driver_id} initialized successfully")
+            driver.is_initialized = True
+            return True
+            
+        except Exception as e:
+            logger.error(f"Driver initialization failed: {e}")
+            return False
+    
+    @staticmethod
+    async def _setup_communication(driver: 'UniversalDriver', capabilities: List[str]):
+        """Setup WebSocket client and session based on driver mode."""
+        # Get WebSocket URL from config (auto-detected)
+        websocket_url = driver.config.effective_websocket_url
+        
+        # Setup WebSocket client if URL available
+        if websocket_url:
+            driver.websocket_client = WebSocketClient(
+                websocket_url,
+                driver.driver_id
+            )
+            
+            # Set WebSocket client for logger (always for logging)
+            if driver.logger_manager:
+                driver.logger_manager.websocket_client = driver.websocket_client
+            
+            # Only create RPC session in DAEMON mode
+            if driver.config.mode == DriverMode.DAEMON:
+                # Create session
+                driver.session = DriverSession(
+                    driver.driver_id,
+                    driver.websocket_client
+                )
+                
+                # Start session with capabilities
+                if capabilities is not None:
+                    if not await driver.session.start_session(capabilities):
+                        logger.error("Session start failed")
+                        raise RuntimeError("Session start failed")
+            else:
+                # In STANDALONE mode - try to connect WebSocket for logging (optional)
+                try:
+                    await driver.websocket_client.connect()
+                    logger.info("WebSocket connected for logging only (standalone mode)")
+                except Exception as e:
+                    logger.warning(f"WebSocket connection failed in standalone mode (will use local logging): {e}")
+                    # Continue without WebSocket - not critical in standalone mode

unrealon_driver/driver/lifecycle/shutdown.py

@@ -0,0 +1,48 @@
+"""
+Driver shutdown logic.
+
+Handles clean shutdown of all driver components.
+"""
+
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..core.driver import UniversalDriver
+
+logger = logging.getLogger(__name__)
+
+
+class DriverShutdown:
+    """Handles driver shutdown process."""
+    
+    @staticmethod
+    async def shutdown_driver(driver: 'UniversalDriver'):
+        """Shutdown driver cleanly."""
+        try:
+            logger.info(f"Shutting down UniversalDriver: {driver.driver_id}")
+            
+            # Stop session
+            if driver.session:
+                await driver.session.stop_session()
+            
+            # Disconnect WebSocket client
+            if driver.websocket_client:
+                await driver.websocket_client.disconnect()
+            
+            # Stop event manager
+            await driver.event_manager.stop()
+            
+            # Stop module system
+            await driver.module_registry.stop_all()
+            
+            # Shutdown managers
+            await driver.manager_registry.shutdown_all()
+            
+            logger.info(f"UniversalDriver {driver.driver_id} shutdown complete")
+            driver.is_initialized = False
+            
+        except Exception as e:
+            logger.error(f"Driver shutdown error: {e}")
+            # Still mark as not initialized even if shutdown failed
+            driver.is_initialized = False

unrealon_driver/driver/monitoring/__init__.py

@@ -0,0 +1,9 @@
+"""
+Driver monitoring and health checks.
+
+Provides health status and monitoring capabilities.
+"""
+
+from .health import HealthMonitor
+
+__all__ = ["HealthMonitor"]

unrealon_driver/driver/monitoring/health.py

@@ -0,0 +1,63 @@
+"""
+Health monitoring for driver components.
+
+Provides health checks and status monitoring for the driver.
+"""
+
+import logging
+from typing import Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..core.driver import UniversalDriver
+
+logger = logging.getLogger(__name__)
+
+
+class HealthMonitor:
+    """Monitors driver health and provides status information."""
+    
+    @staticmethod
+    async def get_health_status(driver: 'UniversalDriver') -> Dict[str, Any]:
+        """Get comprehensive health status."""
+        try:
+            # Get manager health
+            manager_health = await driver.manager_registry.health_check_all()
+            
+            # Get module health
+            module_health = await driver.module_registry.health_check_all()
+            
+            # Get session status
+            session_status = None
+            if driver.session:
+                session_status = driver.session.get_status()
+            
+            return {
+                "driver_id": driver.driver_id,
+                "config": {
+                    "mode": driver.config.mode.value,
+                    "websocket_enabled": driver.config.websocket_url is not None
+                },
+                "managers": manager_health,
+                "modules": module_health,
+                "session": session_status
+            }
+            
+        except Exception as e:
+            logger.error(f"Health check failed: {e}")
+            return {
+                "driver_id": driver.driver_id,
+                "status": "error",
+                "error": str(e)
+            }
+    
+    @staticmethod
+    def get_basic_status(driver: 'UniversalDriver') -> Dict[str, Any]:
+        """Get basic driver status (synchronous)."""
+        return {
+            "driver_id": driver.driver_id,
+            "is_initialized": driver.is_initialized,
+            "is_daemon_mode": driver.session is not None,
+            "is_connected": driver.websocket_client is not None and driver.websocket_client.is_connected,
+            "manager_count": len(driver.manager_registry.managers) if driver.manager_registry else 0,
+            "capabilities": driver.capabilities
+        }

unrealon_driver/driver/utilities/__init__.py

@@ -0,0 +1,10 @@
+"""
+Driver utilities.
+
+Common utilities for logging, serialization, and result handling.
+"""
+
+from .logging import LoggingUtility
+from .serialization import SerializationUtility
+
+__all__ = ["LoggingUtility", "SerializationUtility"]

unrealon_driver/driver/utilities/logging.py

@@ -0,0 +1,51 @@
+"""
+Logging utilities for driver components.
+
+Provides convenient logging methods and utilities.
+"""
+
+import logging
+from typing import Dict, Any, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from unrealon_driver.managers.logger import LoggerManager
+
+logger = logging.getLogger(__name__)
+
+
+class LoggingUtility:
+    """Utility class for driver logging operations."""
+    
+    def __init__(self, driver_id: str):
+        """Initialize logging utility."""
+        self.driver_id = driver_id
+        self.logger_manager: Optional['LoggerManager'] = None
+    
+    def log(self, level: str, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log message through logger manager."""
+        if self.logger_manager:
+            self.logger_manager.log(level, message, context)
+        else:
+            # Fallback to standard logging
+            log_func = getattr(logger, level.lower(), logger.info)
+            log_func(f"{message} | Context: {context}" if context else message)
+    
+    def debug(self, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log debug message."""
+        self.log("DEBUG", message, context)
+    
+    def info(self, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log info message."""
+        self.log("INFO", message, context)
+    
+    def warning(self, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log warning message."""
+        self.log("WARNING", message, context)
+    
+    def error(self, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log error message."""
+        self.log("ERROR", message, context)
+    
+    def critical(self, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log critical message."""
+        self.log("CRITICAL", message, context)

unrealon_driver/driver/utilities/serialization.py

@@ -0,0 +1,61 @@
+"""
+Serialization utilities for driver components.
+
+Handles result saving and JSON serialization with Pydantic support.
+"""
+
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class SerializationUtility:
+    """Utility class for serialization and result saving."""
+    
+    @staticmethod
+    def save_results_to_file(data: dict, filename: str, results_dir: Optional[str] = None) -> Path:
+        """
+        Save parsing results to JSON file with automatic serialization.
+        
+        Args:
+            data: Data to save (can contain Pydantic models)
+            filename: Base filename (without extension)
+            results_dir: Directory to save to (default: ./data/results)
+            
+        Returns:
+            Path to saved file
+        """
+        if results_dir is None:
+            results_dir = "./data/results"
+        
+        results_path = Path(results_dir)
+        results_path.mkdir(parents=True, exist_ok=True)
+        
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filepath = results_path / f"{filename}_{timestamp}.json"
+        
+        # Convert Pydantic models to dict for JSON serialization
+        serializable_data = SerializationUtility._serialize_for_json(data)
+        
+        with open(filepath, 'w', encoding='utf-8') as f:
+            json.dump(serializable_data, f, indent=2, ensure_ascii=False, default=str)
+        
+        logger.info(f"Results saved to: {filepath}")
+        return filepath
+    
+    @staticmethod
+    def _serialize_for_json(data: Any) -> Any:
+        """Recursively serialize data for JSON, handling Pydantic models."""
+        if hasattr(data, "model_dump"):
+            # Pydantic v2 model
+            return data.model_dump()
+        elif isinstance(data, dict):
+            return {key: SerializationUtility._serialize_for_json(value) for key, value in data.items()}
+        elif isinstance(data, list):
+            return [SerializationUtility._serialize_for_json(item) for item in data]
+        else:
+            return data

unrealon_driver/managers/__init__.py

@@ -0,0 +1,32 @@
+"""
+Clean manager system for UnrealOn Driver.
+"""
+
+from .base import BaseManager, ManagerConfig, ManagerStatus
+from .logger import LoggerManager, LoggerManagerConfig
+from .http import HttpManager, HttpManagerConfig
+from .browser import BrowserManager, BrowserManagerConfig
+from .cache import CacheManager, CacheManagerConfig
+from .proxy import ProxyManager, ProxyManagerConfig
+from .threading import ThreadManager, ThreadManagerConfig
+from .update import UpdateManager, UpdateManagerConfig
+from .registry import ManagerRegistry
+
+__all__ = [
+    # Base
+    "BaseManager",
+    "ManagerConfig", 
+    "ManagerStatus",
+    
+    # Managers
+    "LoggerManager", "LoggerManagerConfig",
+    "HttpManager", "HttpManagerConfig",
+    "BrowserManager", "BrowserManagerConfig",
+    "CacheManager", "CacheManagerConfig",
+    "ProxyManager", "ProxyManagerConfig",
+    "ThreadManager", "ThreadManagerConfig",
+    "UpdateManager", "UpdateManagerConfig",
+    
+    # Registry
+    "ManagerRegistry",
+]

unrealon_driver/managers/base.py

@@ -0,0 +1,174 @@
+"""
+Clean base manager system.
+"""
+
+import asyncio
+import logging
+from abc import ABC, abstractmethod
+from datetime import datetime
+from typing import Optional, Dict, Any
+from enum import Enum
+
+from pydantic import BaseModel, Field
+
+from ..utils.time import utc_now
+
+logger = logging.getLogger(__name__)
+
+
+class ManagerStatus(str, Enum):
+    """Manager lifecycle status."""
+    UNINITIALIZED = "uninitialized"
+    INITIALIZING = "initializing"
+    READY = "ready"
+    ERROR = "error"
+    SHUTTING_DOWN = "shutting_down"
+    SHUTDOWN = "shutdown"
+
+
+class ManagerConfig(BaseModel):
+    """Base configuration for all managers."""
+    enabled: bool = Field(default=True, description="Whether manager is enabled")
+    timeout: int = Field(default=30, description="Operation timeout seconds")
+    max_retries: int = Field(default=3, description="Max retry attempts")
+    log_level: str = Field(default="INFO", description="Logging level")
+    
+    model_config = {"extra": "forbid"}
+
+
+class ManagerStats(BaseModel):
+    """Manager operation statistics."""
+    operations_total: int = 0
+    operations_successful: int = 0
+    operations_failed: int = 0
+    last_operation: Optional[datetime] = None
+    average_duration: float = 0.0
+    
+    def record_operation(self, success: bool, duration: float):
+        """Record operation result."""
+        self.operations_total += 1
+        if success:
+            self.operations_successful += 1
+        else:
+            self.operations_failed += 1
+        
+        self.last_operation = utc_now()
+        
+        # Simple moving average
+        if self.operations_total == 1:
+            self.average_duration = duration
+        else:
+            self.average_duration = (
+                (self.average_duration * (self.operations_total - 1) + duration) 
+                / self.operations_total
+            )
+    
+    def get_success_rate(self) -> float:
+        """Get success rate percentage."""
+        if self.operations_total == 0:
+            return 0.0
+        return (self.operations_successful / self.operations_total) * 100.0
+
+
+class BaseManager(ABC):
+    """
+    Clean base manager class.
+    
+    Provides common functionality for all managers:
+    - Lifecycle management
+    - Statistics tracking
+    - Error handling
+    - Health checks
+    """
+    
+    def __init__(self, config: ManagerConfig, name: str):
+        self.config = config
+        self.name = name
+        self.status = ManagerStatus.UNINITIALIZED
+        self.stats = ManagerStats()
+        self.logger = logging.getLogger(f"{__name__}.{name}")
+        
+        # Set log level
+        if hasattr(logging, config.log_level):
+            self.logger.setLevel(getattr(logging, config.log_level))
+    
+    async def initialize(self) -> bool:
+        """Initialize manager."""
+        if not self.config.enabled:
+            self.logger.info(f"Manager {self.name} is disabled")
+            self.status = ManagerStatus.SHUTDOWN
+            return True
+        
+        try:
+            self.status = ManagerStatus.INITIALIZING
+            self.logger.info(f"Initializing manager: {self.name}")
+            
+            success = await self._initialize()
+            
+            if success:
+                self.status = ManagerStatus.READY
+                self.logger.info(f"Manager {self.name} initialized successfully")
+            else:
+                self.status = ManagerStatus.ERROR
+                self.logger.error(f"Manager {self.name} initialization failed")
+            
+            return success
+            
+        except Exception as e:
+            self.status = ManagerStatus.ERROR
+            self.logger.error(f"Manager {self.name} initialization error: {e}")
+            return False
+    
+    async def shutdown(self):
+        """Shutdown manager."""
+        try:
+            self.status = ManagerStatus.SHUTTING_DOWN
+            self.logger.info(f"Shutting down manager: {self.name}")
+            
+            await self._shutdown()
+            
+            self.status = ManagerStatus.SHUTDOWN
+            self.logger.info(f"Manager {self.name} shutdown complete")
+            
+        except Exception as e:
+            self.logger.error(f"Manager {self.name} shutdown error: {e}")
+            self.status = ManagerStatus.ERROR
+    
+    @abstractmethod
+    async def _initialize(self) -> bool:
+        """Manager-specific initialization."""
+        pass
+    
+    @abstractmethod
+    async def _shutdown(self):
+        """Manager-specific shutdown."""
+        pass
+    
+    async def health_check(self) -> Dict[str, Any]:
+        """Perform health check."""
+        try:
+            health_data = await self._health_check()
+            
+            return {
+                "name": self.name,
+                "status": self.status.value,
+                "enabled": self.config.enabled,
+                "stats": self.stats.model_dump(),
+                "health": health_data
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Health check failed for {self.name}: {e}")
+            return {
+                "name": self.name,
+                "status": "error",
+                "error": str(e)
+            }
+    
+    async def _health_check(self) -> Dict[str, Any]:
+        """Manager-specific health check."""
+        return {"status": "ok"}
+    
+    def is_ready(self) -> bool:
+        """Check if manager is ready."""
+        return self.status == ManagerStatus.READY

unrealon_driver/managers/browser.py

@@ -0,0 +1,98 @@
+"""
+Clean browser manager using unrealon_browser.
+"""
+
+from typing import Optional
+from pydantic import Field
+
+from unrealon_browser import BrowserManager as CoreBrowserManager, BrowserConfig
+from .base import BaseManager, ManagerConfig
+
+
+class BrowserManagerConfig(ManagerConfig):
+    """Browser manager configuration."""
+
+    headless: bool = Field(default=True, description="Run headless")
+    parser_name: str = Field(..., description="Parser name for browser")
+
+
+class BrowserManager(BaseManager):
+    """Clean browser manager wrapper."""
+
+    def __init__(self, config: BrowserManagerConfig):
+        super().__init__(config, "browser")
+        self.config: BrowserManagerConfig = config
+        self.browser: Optional[CoreBrowserManager] = None
+
+    async def _initialize(self) -> bool:
+        """Initialize browser manager (but not the actual browser yet)."""
+        try:
+            # Don't initialize the actual browser here - do it lazily on first use
+            # This prevents browser from starting in daemon mode until needed
+            self.logger.info("Browser manager ready (browser will start on first use)")
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Browser manager initialization failed: {e}")
+            return False
+
+    async def _shutdown(self):
+        """Shutdown browser."""
+        if self.browser:
+            await self.browser.close_async()
+            self.browser = None
+
+    async def _ensure_browser_initialized(self) -> bool:
+        """Ensure browser is initialized (lazy initialization)."""
+        if self.browser is not None:
+            return True
+            
+        try:
+            self.logger.info("🚀 Starting browser (lazy initialization)...")
+            
+            # Create browser config
+            browser_config = BrowserConfig(parser_name=self.config.parser_name)
+
+            # Create browser manager
+            self.browser = CoreBrowserManager(browser_config)
+
+            # Initialize browser
+            await self.browser.initialize_async()
+            
+            self.logger.info("✅ Browser started successfully")
+            return True
+
+        except Exception as e:
+            self.logger.error(f"❌ Browser initialization failed: {e}")
+            self.browser = None
+            return False
+
+    async def navigate(self, url: str) -> bool:
+        """Navigate to URL (with lazy browser initialization)."""
+        # Ensure browser is initialized
+        if not await self._ensure_browser_initialized():
+            raise RuntimeError("Failed to initialize browser")
+
+        try:
+            await self.browser.navigate_async(url)
+            self.stats.record_operation(True, 0.0)
+            return True
+        except Exception as e:
+            self.logger.error(f"Navigation failed: {e}")
+            self.stats.record_operation(False, 0.0)
+            return False
+
+    async def get_html(self) -> Optional[str]:
+        """Get page HTML (with lazy browser initialization)."""
+        # Ensure browser is initialized
+        if not await self._ensure_browser_initialized():
+            raise RuntimeError("Failed to initialize browser")
+
+        try:
+            html = await self.browser.get_page_content_async()
+            self.stats.record_operation(True, 0.0)
+            return html
+        except Exception as e:
+            self.logger.error(f"Get HTML failed: {e}")
+            self.stats.record_operation(False, 0.0)
+            return None