unrealon 1.0.9__py3-none-any.whl → 1.1.1__py3-none-any.whl

unrealon_driver/src/services/websocket_service.py

@@ -1,362 +0,0 @@
-"""
-WebSocket Service for UnrealOn Driver v3.0
-
-Full WebSocket service using unrealon_sdk AdapterClient.
-Provides Socket.IO WebSocket connectivity for daemon mode.
-
-CRITICAL REQUIREMENTS COMPLIANCE:
-- ✅ Absolute imports only 
-- ✅ Pydantic v2 models everywhere
-- ✅ Complete type annotations
-- ✅ Full unrealon_sdk integration
-"""
-
-import asyncio
-from typing import Any, Dict, Optional, Callable
-from datetime import datetime
-
-from pydantic import BaseModel, Field, ConfigDict
-
-from unrealon_sdk.src.provider import Core, Utils, Models
-from unrealon_sdk.src.enterprise.logging.development import get_development_logger
-from unrealon_sdk.src.dto.logging import SDKContext, SDKEventType
-
-from unrealon_driver.src.core.exceptions import WebSocketError, create_websocket_error
-from unrealon_driver.src.dto.services import (
-    WebSocketConfig,
-    ServiceHealthStatus,
-    ServiceOperationResult,
-)
-from unrealon_driver.src.dto.events import DriverEventType
-
-
-class SDKAdapterConfig(BaseModel):
-    """Configuration for SDK Adapter service."""
-
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-
-    parser_id: str = Field(..., description="Parser identifier")
-    parser_name: str = Field(..., description="Human-readable parser name")
-    api_key: str = Field(..., description="UnrealOn API key")
-    server_url: str = Field(default="ws://localhost:8000", description="WebSocket server URL")
-    auto_reconnect: bool = Field(default=True, description="Auto-reconnect on connection loss")
-    heartbeat_interval: int = Field(default=30, ge=5, le=300, description="Heartbeat interval")
-    connection_timeout: int = Field(default=10, ge=1, le=60, description="Connection timeout")
-
-
-class WebSocketService:
-    """
-    🔌 WebSocket Service - Production Daemon Communication
-
-    Full implementation using unrealon_sdk AdapterClient:
-    - Socket.IO WebSocket communication (not raw websockets)
-    - Command handler registration
-    - Automatic reconnection
-    - Parser registration with server
-    - Type-safe message handling
-    """
-
-    def __init__(
-        self,
-        config: WebSocketConfig,
-        logger: Optional[Any] = None,
-        metrics: Optional[Any] = None,
-        parser_id: str = "unknown",
-    ):
-        """Initialize WebSocket service with full SDK integration."""
-        self.config = config
-        self.logger = logger
-        self.metrics = metrics
-        self.parser_id = parser_id
-
-        # ✅ DEVELOPMENT LOGGER INTEGRATION (CRITICAL REQUIREMENT)
-        self.dev_logger = get_development_logger()
-
-        # SDK components
-        self._adapter_client: Optional[Core.AdapterClient] = None
-        self._command_handlers: Dict[str, Callable] = {}
-        self._is_connected = False
-        self._shutdown_event = asyncio.Event()
-
-        # WebSocket connection events are automatically logged by unrealon_sdk AdapterClient
-        # Driver logs only its specific initialization
-        if self.dev_logger:
-            self.dev_logger.log_info(
-                SDKEventType.COMPONENT_CREATED,
-                "WebSocket service initialized (connection events handled by SDK)",
-                context=SDKContext(
-                    parser_id=self.parser_id,
-                    component_name="WebSocket",
-                    layer_name="UnrealOn_Driver",
-                    metadata={
-                        "server_url": self.config.server_url or "auto-detect",
-                        "auto_reconnect": self.config.auto_reconnect,
-                    },
-                ),
-            )
-
-    @property
-    def is_connected(self) -> bool:
-        """Check if WebSocket is connected."""
-        return self._is_connected and self._adapter_client is not None
-
-    def register_handler(self, command_type: str, handler: Callable) -> None:
-        """
-        Register a command handler.
-
-        Args:
-            command_type: Command type to handle
-            handler: Async function to handle the command
-        """
-        self._command_handlers[command_type] = handler
-        
-        # Log driver-specific handler registration
-        if self.dev_logger:
-            self.dev_logger.log_info(
-                DriverEventType.WEBSOCKET_COMMAND_HANDLER_REGISTERED.value,
-                f"Command handler registered: {command_type}",
-                context=SDKContext(
-                    parser_id=self.parser_id,
-                    component_name="WebSocket",
-                    layer_name="UnrealOn_Driver",
-                    metadata={
-                        "command_type": command_type,
-                        "handler_name": handler.__name__ if hasattr(handler, '__name__') else str(handler),
-                        "total_handlers": len(self._command_handlers),
-                    },
-                ),
-            )
-        
-        if self.logger:
-            self.logger.info(f"Registered handler for command type: {command_type}")
-
-    async def connect(
-        self, server_url: Optional[str] = None, api_key: Optional[str] = None, **kwargs
-    ) -> bool:
-        """Connect to UnrealOn Server via SDK AdapterClient."""
-        if self._is_connected:
-            if self.logger:
-                self.logger.warning("Already connected to server")
-            return True
-
-        try:
-            # Get connection parameters
-            actual_server_url = server_url or self.config.server_url or "ws://localhost:8000"
-            actual_api_key = api_key or self.config.api_key or ""
-
-            if not actual_api_key:
-                raise create_websocket_error(
-                    "API key is required for WebSocket connection", server_url=actual_server_url
-                )
-
-            if self.logger:
-                self.logger.info(f"Connecting to UnrealOn Server: {actual_server_url}")
-
-            # Create SDK configuration
-            sdk_config = Utils.create_parser_config(
-                parser_id=self.parser_id,
-                parser_name=self.config.parser_name or self.parser_id,
-                api_key=actual_api_key,
-                server_url=actual_server_url,
-            )
-
-            # Create AdapterClient
-            self._adapter_client = Core.AdapterClient(sdk_config)
-
-            # Register command handlers with the adapter
-            for command_type, handler in self._command_handlers.items():
-                self._register_sdk_handler(command_type, handler)
-
-            # Connect to server
-            await self._adapter_client.connect()
-
-            self._is_connected = True
-
-            if self.logger:
-                self.logger.info("WebSocket service connected successfully")
-
-            return True
-
-        except Exception as e:
-            self._is_connected = False
-            if self.logger:
-                self.logger.error(f"WebSocket connection failed: {e}")
-
-            raise create_websocket_error(
-                f"Failed to connect to WebSocket server: {e}",
-                server_url=actual_server_url,
-                connection_status="failed",
-            )
-
-    def _register_sdk_handler(self, command_type: str, handler: Callable) -> None:
-        """Register handler with SDK AdapterClient."""
-        if not self._adapter_client:
-            return
-
-        @self._adapter_client.on_command(command_type)
-        async def sdk_handler(command: Models.ParserCommandEvent) -> Models.SuccessResponse:
-            try:
-                # Call the user's handler
-                result = await handler(command)
-
-                # Convert result to proper SDK response
-                if isinstance(result, (Models.SuccessResponse, Models.ErrorResponse)):
-                    return result
-                elif isinstance(result, dict):
-                    return Utils.create_success_response(
-                        command_id=command.command_id,
-                        message=f"Command {command_type} handled successfully",
-                        data=result,
-                    )
-                else:
-                    return Utils.create_success_response(
-                        command_id=command.command_id,
-                        message=f"Command {command_type} handled successfully",
-                        data={"result": str(result)},
-                    )
-
-            except Exception as e:
-                if self.logger:
-                    self.logger.error(f"Handler for {command_type} failed: {e}")
-                return Utils.create_error_response(
-                    message=f"Command {command_type} failed: {str(e)}", error_code="HANDLER_ERROR"
-                )
-
-    async def listen(self, shutdown_event: Optional[asyncio.Event] = None) -> None:
-        """Start listening for commands (blocks until stopped or shutdown_event is set)."""
-        if not self._is_connected or not self._adapter_client:
-            raise WebSocketError("WebSocket not connected. Call connect() first.")
-
-        try:
-            if self.logger:
-                self.logger.info("WebSocket service listening for commands...")
-                self.logger.info(f"   Registered handlers: {list(self._command_handlers.keys())}")
-
-            # Start the adapter
-            await self._adapter_client.start()
-
-            # Use provided shutdown event or our internal one
-            event_to_wait = shutdown_event or self._shutdown_event
-
-            # Wait for shutdown signal
-            await event_to_wait.wait()
-
-            if self.logger:
-                self.logger.info("WebSocket service received shutdown signal")
-
-        except asyncio.CancelledError:
-            if self.logger:
-                self.logger.info("WebSocket service stopped (cancelled)")
-            raise
-        except Exception as e:
-            if self.logger:
-                self.logger.error(f"WebSocket listening error: {e}")
-            raise
-
-    async def send(self, data: dict):
-        """Send data through WebSocket."""
-        if not self._is_connected or not self._adapter_client:
-            if self.logger:
-                self.logger.warning("Cannot send data - not connected")
-            return
-
-        try:
-            # Send status update or other data
-            if self.logger:
-                self.logger.debug(f"Sending data: {data}")
-            # Note: Specific send methods depend on SDK implementation
-
-        except Exception as e:
-            if self.logger:
-                self.logger.error(f"Failed to send data: {e}")
-
-    async def send_status_update(self, status: str, metadata: Optional[dict] = None) -> None:
-        """Send status update to server."""
-        if not self._is_connected:
-            if self.logger:
-                self.logger.warning("Cannot send status - not connected")
-            return
-
-        try:
-            status_data = {
-                "status": status,
-                "parser_id": self.parser_id,
-                "timestamp": datetime.utcnow().isoformat(),
-            }
-            if metadata:
-                status_data["metadata"] = metadata
-
-            await self.send(status_data)
-
-        except Exception as e:
-            if self.logger:
-                self.logger.error(f"Failed to send status update: {e}")
-
-    async def disconnect(self):
-        """Disconnect from WebSocket server."""
-        if not self._is_connected:
-            return
-
-        try:
-            if self._adapter_client:
-                await self._adapter_client.stop()
-
-            self._is_connected = False
-
-            if self.logger:
-                self.logger.info("WebSocket service disconnected")
-
-        except Exception as e:
-            if self.logger:
-                self.logger.error(f"Error during WebSocket disconnect: {e}")
-
-    def stop(self):
-        """Signal shutdown for graceful stop."""
-        self._shutdown_event.set()
-
-    async def health_check(self) -> dict:
-        """Check WebSocket service health."""
-        try:
-            health_status = {
-                "status": "healthy" if self._is_connected else "disconnected",
-                "connected": self._is_connected,
-                "server_url": self.config.server_url or "unknown",
-                "handlers_count": len(self._command_handlers),
-                "parser_id": self.parser_id,
-            }
-
-            if self._adapter_client:
-                # Add adapter-specific health info if available
-                health_status["adapter_status"] = "active"
-
-            return health_status
-
-        except Exception as e:
-            return {"status": "unhealthy", "error": str(e), "connected": False}
-
-    async def cleanup(self):
-        """Clean up WebSocket resources."""
-        try:
-            await self.disconnect()
-            self._command_handlers.clear()
-
-            if self.logger:
-                self.logger.info("WebSocket service cleanup completed")
-
-        except Exception as e:
-            if self.logger:
-                self.logger.error(f"Error during WebSocket cleanup: {e}")
-
-    @property
-    def connection_info(self) -> dict:
-        """Get connection information."""
-        return {
-            "connected": self._is_connected,
-            "parser_id": self.parser_id,
-            "server_url": self.config.server_url or "unknown",
-            "handlers": list(self._command_handlers.keys()),
-            "timestamp": datetime.utcnow().isoformat(),
-        }
-
-    def __repr__(self) -> str:
-        return f"<WebSocketService(connected={self._is_connected}, handlers={len(self._command_handlers)})>"

unrealon_driver/src/utils/__init__.py

@@ -1,16 +0,0 @@
-"""
-UnrealOn Driver v3.0 - Utilities
-
-Modern utilities and helper classes for driver operations.
-COMPLIANCE: 100% Pydantic v2 compliant, no Dict[str, Any] usage.
-"""
-
-from .service_factory import ServiceFactory
-from .time_formatter import TimeFormatter, ScheduleTimer, DaemonTimer
-
-__all__ = [
-    "ServiceFactory",
-    "TimeFormatter", 
-    "ScheduleTimer",
-    "DaemonTimer",
-]

unrealon_driver/src/utils/service_factory.py

@@ -1,317 +0,0 @@
-"""
-Modern Service Factory - UnrealOn Driver v3.0
-
-Revolutionary service factory with Pydantic v2 integration and AutoConfig support.
-Provides type-safe, zero-configuration service creation with enterprise defaults.
-
-COMPLIANCE: 100% Pydantic v2 compliant, no Dict[str, Any] usage.
-"""
-
-from typing import Optional, TypeVar, Type
-from pathlib import Path
-
-from unrealon_driver.src.config.auto_config import AutoConfig
-from unrealon_driver.src.core.parser import Parser
-from unrealon_driver.src.services.browser_service import BrowserService
-from unrealon_driver.src.services.llm import LLMService
-from unrealon_driver.src.services.websocket_service import WebSocketService
-from unrealon_driver.src.logging import DriverLogger, ensure_driver_logger
-from unrealon_driver.src.services.metrics_service import MetricsService
-from unrealon_driver.src.services.scheduler_service import SchedulerService
-from unrealon_driver.src.dto.services import (
-    DriverBrowserConfig,
-    LLMConfig,
-    WebSocketConfig,
-    LoggerConfig,
-    MetricsConfig,
-    SchedulerConfig,
-)
-
-# Type variable for generic service creation
-ServiceType = TypeVar("ServiceType")
-
-
-class ServiceFactory:
-    """
-    🎯 Modern Service Factory - UnrealOn Driver v3.0
-
-    Revolutionary Simplicity meets Enterprise Power:
-    - 🔧 Zero-configuration defaults via AutoConfig
-    - 🎯 100% Pydantic v2 type safety
-    - ⚡ Fluent API for service creation
-    - 🚀 Enterprise-grade configurations
-    - 🔄 Environment-aware settings
-
-    Examples:
-        # Quick development setup
-        factory = ServiceFactory.for_development("my_parser")
-        parser = factory.create_parser()
-        browser = factory.create_browser_service()
-
-        # Production setup with custom config
-        factory = ServiceFactory.for_production("prod_parser")
-        parser = factory.create_parser()
-        llm = factory.create_llm_service()
-
-        # Custom configuration
-        factory = ServiceFactory(config=my_config)
-        all_services = factory.create_all_services()
-    """
-
-    def __init__(self, config: Optional[AutoConfig] = None):
-        """
-        Initialize service factory with optional configuration.
-
-        Args:
-            config: AutoConfig instance. If None, creates default development config.
-        """
-        self.config = config or AutoConfig.create_development("factory_default")
-
-    # ===========================================
-    # FLUENT FACTORY CREATION METHODS
-    # ===========================================
-
-    @classmethod
-    def for_development(cls, parser_id: str) -> "ServiceFactory":
-        """Create factory for development environment with debug features."""
-        config = AutoConfig.create_development(parser_id)
-        return cls(config)
-
-    @classmethod
-    def for_production(cls, parser_id: str) -> "ServiceFactory":
-        """Create factory for production environment with optimal settings."""
-        config = AutoConfig.create_production(parser_id)
-        return cls(config)
-
-    @classmethod
-    def for_testing(cls, parser_id: str) -> "ServiceFactory":
-        """Create factory for testing environment with minimal settings."""
-        config = AutoConfig.create_minimal(parser_id)
-        return cls(config)
-
-    @classmethod
-    def with_custom_config(cls, config: AutoConfig) -> "ServiceFactory":
-        """Create factory with custom AutoConfig."""
-        return cls(config)
-    
-    @classmethod
-    def from_config(cls, config: AutoConfig) -> "ServiceFactory":
-        """Create factory from AutoConfig (alias for with_custom_config)."""
-        return cls(config)
-
-    # ===========================================
-    # CORE SERVICE CREATION METHODS
-    # ===========================================
-
-    def create_parser(self, **overrides) -> Parser:
-        """
-        Create fully configured Parser instance.
-
-        Args:
-            **overrides: Override specific parser configuration options.
-
-        Returns:
-            Parser with all services auto-configured based on environment.
-        """
-        parser_id = overrides.get("parser_id", self.config.parser_id)
-        parser_name = overrides.get("parser_name", self.config.parser_id.replace("_", " ").title())
-        
-        config = self.config.model_dump()
-        if overrides:
-            config.update(overrides)
-            
-        return Parser(
-            parser_id=parser_id,
-            parser_name=parser_name,
-            config=config,
-        )
-
-    def create_browser_service(self, **overrides) -> BrowserService:
-        """
-        Create BrowserService with intelligent defaults.
-
-        Args:
-            **overrides: Override specific browser configuration options.
-
-        Returns:
-            Configured BrowserService instance.
-        """
-        browser_config = self.config.browser_config
-        if overrides:
-            browser_config = browser_config.model_copy(update=overrides)
-
-        return BrowserService(
-            config=browser_config,
-            logger=self._create_service_logger("browser"),
-            metrics=self._create_service_metrics("browser"),
-        )
-
-    def create_llm_service(self, **overrides) -> LLMService:
-        """
-        Create LLMService with AI-optimized defaults.
-
-        Args:
-            **overrides: Override specific LLM configuration options.
-
-        Returns:
-            Configured LLMService instance.
-        """
-        llm_config = self.config.llm_config
-        if overrides:
-            llm_config = llm_config.model_copy(update=overrides)
-
-        return LLMService(
-            config=llm_config,
-            logger=self._create_service_logger("llm"),
-        )
-
-    def create_websocket_service(self, **overrides) -> WebSocketService:
-        """
-        Create WebSocketService for real-time communication.
-
-        Args:
-            **overrides: Override specific WebSocket configuration options.
-
-        Returns:
-            Configured WebSocketService instance.
-        """
-        websocket_config = self.config.websocket_config
-        if overrides:
-            websocket_config = websocket_config.model_copy(update=overrides)
-
-        return WebSocketService(
-            parser_id=self.config.parser_id,
-            config=websocket_config,
-            logger=self._create_service_logger("websocket"),
-        )
-
-    def create_driver_logger(self, **overrides) -> DriverLogger:
-        """
-        Create DriverLogger with enterprise SDK integration.
-
-        Args:
-            **overrides: Override specific logger configuration options.
-
-        Returns:
-            Configured DriverLogger instance with SDK integration.
-        """
-        # Extract relevant config from overrides
-        log_level = overrides.get("log_level", self.config.logger_config.log_level.value)
-        enable_console = overrides.get("enable_console", self.config.logger_config.console_output)
-        enable_websocket = overrides.get("enable_websocket", False)  # Default off for performance
-        
-        return ensure_driver_logger(
-            parser_id=self.config.parser_id,
-            parser_name=self.config.parser_id.replace("_", " ").title(),
-        )
-
-    def create_metrics_service(self, **overrides) -> MetricsService:
-        """
-        Create MetricsService for performance monitoring.
-
-        Args:
-            **overrides: Override specific metrics configuration options.
-
-        Returns:
-            Configured MetricsService instance.
-        """
-        metrics_config = self.config.metrics_config
-        if overrides:
-            metrics_config = metrics_config.model_copy(update=overrides)
-
-        return MetricsService(
-            parser_id=self.config.parser_id,
-            config=metrics_config,
-        )
-
-    def create_scheduler_service(self, **overrides) -> SchedulerService:
-        """
-        Create SchedulerService for task automation.
-
-        Args:
-            **overrides: Override specific scheduler configuration options.
-
-        Returns:
-            Configured SchedulerService instance.
-        """
-        scheduler_config = self.config.scheduler_config
-        if overrides:
-            scheduler_config = scheduler_config.model_copy(update=overrides)
-
-        return SchedulerService(
-            config=scheduler_config,
-            logger=self._create_service_logger("scheduler"),
-        )
-
-    # ===========================================
-    # CONVENIENCE METHODS
-    # ===========================================
-
-    def create_all_services(self) -> dict:
-        """
-        Create all services with consistent configuration.
-
-        Returns:
-            Dictionary with all configured services.
-        """
-        return {
-            "parser": self.create_parser(),
-            "browser": self.create_browser_service(),
-            "llm": self.create_llm_service(),
-            "websocket": self.create_websocket_service(),
-            "logger": self.create_driver_logger(),
-            "metrics": self.create_metrics_service(),
-            "scheduler": self.create_scheduler_service(),
-        }
-
-    def create_core_services(self) -> dict:
-        """
-        Create essential services for basic parsing operations.
-
-        Returns:
-            Dictionary with core services (browser, llm, logger).
-        """
-        return {
-            "parser": self.create_parser(),
-            "browser": self.create_browser_service(),
-            "llm": self.create_llm_service(),
-            "logger": self.create_driver_logger(),
-        }
-
-    # ===========================================
-    # INTERNAL HELPER METHODS
-    # ===========================================
-
-    def _create_service_logger(self, service_name: str) -> Optional[DriverLogger]:
-        """Create a DriverLogger for a specific service (shared global instance)."""
-        # Services now share the global DriverLogger instance for consistency
-        return ensure_driver_logger(
-            parser_id=self.config.parser_id,
-            parser_name=self.config.parser_id.replace("_", " ").title(),
-        )
-
-    def _create_service_metrics(self, service_name: str) -> Optional[MetricsService]:
-        """Create metrics collector for a specific service."""
-        if not self.config.metrics_config:
-            return None
-
-        return MetricsService(
-            config=self.config.metrics_config,
-            parser_id=f"{self.config.parser_id}_{service_name}",
-        )
-
-    def update_config(self, **updates) -> "ServiceFactory":
-        """
-        Create new factory with updated configuration.
-
-        Args:
-            **updates: Configuration updates to apply.
-
-        Returns:
-            New ServiceFactory instance with updated config.
-        """
-        new_config = self.config.model_copy(update=updates)
-        return ServiceFactory(new_config)
-
-    def __repr__(self) -> str:
-        return f"<ServiceFactory(parser_id={self.config.parser_id}, env={self.config.environment})>"