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

unrealon_driver/src/dto/services.py

@@ -1,311 +0,0 @@
-"""
-Service configuration models for UnrealOn Driver v3.0
-
-Type-safe configuration for all services.
-COMPLIANCE: 100% Pydantic v2 compliant, no Dict[str, Any] usage.
-"""
-
-from pydantic import BaseModel, Field, ConfigDict
-from typing import Optional, List, Union
-from pathlib import Path
-from enum import Enum
-
-from .config import LogLevel
-# 🔥 STEALTH ALWAYS ON - NO IMPORT NEEDED!
-
-
-class DriverBrowserConfig(BaseModel):
-    """Type-safe browser service configuration for UnrealOn Driver."""
-
-    model_config = ConfigDict(
-        validate_assignment=True,
-        extra="forbid",
-        str_strip_whitespace=True,
-    )
-
-    # Core browser settings
-    headless: bool = Field(default=True, description="Run browser in headless mode")
-    timeout: int = Field(
-        default=30, ge=1, le=300, description="Page timeout in seconds"
-    )
-    user_data_dir: Optional[str] = Field(
-        default=None, description="Browser user data directory"
-    )
-    parser_id: str = Field(..., description="Parser identifier")
-
-    # 🔥 STEALTH ALWAYS ON - NO CONFIG NEEDED!
-
-    # Performance settings
-    page_load_strategy: str = Field(default="normal", pattern=r"^(normal|eager|none)$")
-    wait_for_selector_timeout: int = Field(
-        default=10, ge=1, le=60, description="Selector wait timeout"
-    )
-    network_idle_timeout: int = Field(
-        default=3, ge=1, le=30, description="Network idle timeout"
-    )
-
-    # Features
-    enable_javascript: bool = Field(
-        default=True, description="Enable JavaScript execution"
-    )
-    enable_images: bool = Field(default=True, description="Load images")
-    enable_css: bool = Field(default=True, description="Load CSS")
-
-    # Debug settings
-    debug_mode: bool = Field(default=False, description="Enable debug mode")
-    save_screenshots: bool = Field(default=False, description="Save debug screenshots")
-    log_level: LogLevel = Field(default=LogLevel.INFO, description="Browser log level")
-
-
-class LLMConfig(BaseModel):
-    """Type-safe LLM service configuration."""
-
-    model_config = ConfigDict(
-        validate_assignment=True,
-        extra="forbid",
-        str_strip_whitespace=True,
-    )
-
-    # Provider settings
-    provider: str = Field(default="openrouter", description="LLM provider")
-    model: str = Field(
-        default="anthropic/claude-3.5-sonnet", description="Model identifier"
-    )
-    api_key: Optional[str] = Field(default=None, description="API key")
-
-    # Request settings
-    max_tokens: int = Field(default=2048, ge=1, le=8192, description="Maximum tokens")
-    temperature: float = Field(
-        default=0.1, ge=0.0, le=2.0, description="Sampling temperature"
-    )
-    timeout: int = Field(default=30, ge=1, le=300, description="Request timeout")
-
-    # Processing settings
-    max_retries: int = Field(
-        default=3, ge=0, le=10, description="Maximum retry attempts"
-    )
-    chunk_size: int = Field(
-        default=4000, ge=100, le=10000, description="Text chunk size"
-    )
-
-    # Features
-    enable_caching: bool = Field(default=True, description="Enable response caching")
-    enable_cost_tracking: bool = Field(default=True, description="Enable cost tracking")
-    log_level: LogLevel = Field(default=LogLevel.INFO, description="LLM log level")
-
-
-class WebSocketConfig(BaseModel):
-    """Type-safe WebSocket service configuration."""
-
-    model_config = ConfigDict(
-        validate_assignment=True,
-        extra="forbid",
-        str_strip_whitespace=True,
-    )
-
-    # Connection settings
-    server_url: Optional[str] = Field(default=None, description="WebSocket server URL")
-    api_key: Optional[str] = Field(default=None, description="Authentication API key")
-    parser_name: str = Field(..., description="Parser name for identification")
-
-    # Reliability settings
-    auto_reconnect: bool = Field(
-        default=True, description="Auto-reconnect on disconnect"
-    )
-    max_reconnect_attempts: int = Field(
-        default=10, ge=1, le=100, description="Max reconnection attempts"
-    )
-    reconnect_delay: float = Field(
-        default=1.0, ge=0.1, le=60.0, description="Reconnect delay seconds"
-    )
-
-    # Health monitoring
-    health_check_interval: int = Field(
-        default=30, ge=5, le=300, description="Health check interval"
-    )
-    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 LoggerConfig(BaseModel):
-    """Type-safe logger service configuration."""
-
-    model_config = ConfigDict(
-        validate_assignment=True,
-        extra="forbid",
-        str_strip_whitespace=True,
-    )
-
-    # Core settings
-    log_level: LogLevel = Field(default=LogLevel.INFO, description="Default log level")
-    console_output: bool = Field(default=True, description="Enable console output")
-    file_output: bool = Field(default=True, description="Enable file output")
-
-    # File settings
-    log_file: str = Field(default="parser.log", description="Log file name")
-    log_dir: Optional[str] = Field(default=None, description="Log directory")
-    max_file_size: str = Field(default="10MB", description="Max log file size")
-    backup_count: int = Field(
-        default=5, ge=1, le=50, description="Number of backup files"
-    )
-
-    # Format settings
-    log_format: str = Field(
-        default="%(asctime)s | %(name)s | %(levelname)s | %(message)s",
-        description="Log format string",
-    )
-    date_format: str = Field(default="%Y-%m-%d %H:%M:%S", description="Date format")
-
-    # Performance
-    buffer_size: int = Field(
-        default=1024, ge=256, le=8192, description="Log buffer size"
-    )
-    flush_interval: float = Field(
-        default=1.0, ge=0.1, le=10.0, description="Flush interval seconds"
-    )
-
-
-class MetricsConfig(BaseModel):
-    """Type-safe metrics service configuration."""
-
-    model_config = ConfigDict(
-        validate_assignment=True,
-        extra="forbid",
-        str_strip_whitespace=True,
-    )
-
-    # Core settings
-    parser_id: str = Field(..., description="Parser identifier")
-    enable_metrics: bool = Field(default=True, description="Enable metrics collection")
-
-    # Collection settings
-    collect_performance: bool = Field(
-        default=True, description="Collect performance metrics"
-    )
-    collect_errors: bool = Field(default=True, description="Collect error metrics")
-    collect_usage: bool = Field(default=True, description="Collect usage metrics")
-
-    # Storage settings
-    retention_days: int = Field(
-        default=30, ge=1, le=365, description="Metrics retention period"
-    )
-    export_format: str = Field(default="json", pattern=r"^(json|csv|prometheus)$")
-
-    # Performance
-    batch_size: int = Field(
-        default=100, ge=1, le=1000, description="Metrics batch size"
-    )
-    flush_interval: int = Field(
-        default=60, ge=1, le=3600, description="Flush interval seconds"
-    )
-
-
-class SchedulerConfig(BaseModel):
-    """Type-safe scheduler service configuration."""
-
-    model_config = ConfigDict(
-        validate_assignment=True,
-        extra="forbid",
-        str_strip_whitespace=True,
-    )
-
-    # Core settings
-    parser_id: str = Field(..., description="Parser identifier")
-    max_concurrent_tasks: int = Field(
-        default=10, ge=1, le=100, description="Max concurrent tasks"
-    )
-    enable_jitter: bool = Field(
-        default=True, description="Enable jitter for load balancing"
-    )
-    jitter_range: float = Field(default=0.1, ge=0.0, le=0.5, description="Jitter range")
-
-    # Task management
-    default_timeout: int = Field(
-        default=300, ge=30, le=3600, description="Default task timeout"
-    )
-    default_retries: int = Field(
-        default=3, ge=0, le=10, description="Default retry attempts"
-    )
-    cleanup_interval: int = Field(
-        default=3600, ge=60, le=86400, description="Cleanup interval"
-    )
-
-    # Monitoring
-    enable_task_monitoring: bool = Field(
-        default=True, description="Enable task monitoring"
-    )
-    health_check_interval: int = Field(
-        default=60, ge=10, le=3600, description="Health check interval"
-    )
-
-
-class ServiceHealthStatus(BaseModel):
-    """Type-safe service health status."""
-
-    model_config = ConfigDict(
-        validate_assignment=True,
-        extra="forbid",
-    )
-
-    status: str = Field(..., pattern=r"^(healthy|unhealthy|degraded|unknown)$")
-    service_name: str = Field(..., description="Service name")
-    last_check: str = Field(..., description="Last health check timestamp")
-
-    # Health details
-    response_time_ms: Optional[float] = Field(
-        default=None, ge=0.0, description="Response time"
-    )
-    error_rate: Optional[float] = Field(
-        default=None, ge=0.0, le=1.0, description="Error rate"
-    )
-    uptime_seconds: Optional[int] = Field(
-        default=None, ge=0, description="Service uptime"
-    )
-
-    # Error information
-    last_error: Optional[str] = Field(default=None, description="Last error message")
-    error_count: int = Field(default=0, ge=0, description="Total error count")
-
-
-class ServiceOperationResult(BaseModel):
-    """Type-safe service operation result."""
-
-    model_config = ConfigDict(
-        validate_assignment=True,
-        extra="forbid",
-    )
-
-    success: bool = Field(..., description="Operation success status")
-    service_name: str = Field(..., description="Service name")
-    operation: str = Field(..., description="Operation name")
-
-    # Timing
-    start_time: str = Field(..., description="Operation start time")
-    duration_seconds: float = Field(..., ge=0.0, description="Operation duration")
-
-    # Result data
-    result: Optional[dict] = Field(default=None, description="Operation result data")
-    items_processed: int = Field(default=0, ge=0, description="Items processed")
-
-    # Error information
-    error_message: Optional[str] = Field(
-        default=None, description="Error message if failed"
-    )
-    error_code: Optional[str] = Field(default=None, description="Error code if failed")
-
-
-# Export all models
-__all__ = [
-    "DriverBrowserConfig",
-    "LLMConfig",
-    "WebSocketConfig",
-    "LoggerConfig",
-    "MetricsConfig",
-    "SchedulerConfig",
-    "ServiceHealthStatus",
-    "ServiceOperationResult",
-]

unrealon_driver/src/execution/__init__.py

@@ -1,23 +0,0 @@
-"""
-Execution modes for UnrealOn Driver v3.0
-
-Multiple execution modes for different use cases:
-- Test Mode: Development and debugging
-- Daemon Mode: Production WebSocket service  
-- Scheduled Mode: Automated recurring execution
-- Interactive Mode: Live development shell
-"""
-
-from .modes import ExecutionMode
-from .test_mode import TestMode
-from .daemon_mode import DaemonMode
-from .scheduled_mode import ScheduledMode
-from .interactive_mode import InteractiveMode
-
-__all__ = [
-    "ExecutionMode",
-    "TestMode", 
-    "DaemonMode",
-    "ScheduledMode",
-    "InteractiveMode"
-]

unrealon_driver/src/execution/daemon_mode.py

@@ -1,317 +0,0 @@
-"""
-Daemon Mode implementation for UnrealOn Driver v3.0
-
-Production WebSocket service mode with full unrealon_sdk integration.
-Provides real-time parser execution via WebSocket commands.
-"""
-
-import asyncio
-import signal
-from typing import Any, Optional
-from datetime import datetime
-
-from unrealon_driver.src.dto.execution import (
-    DaemonModeConfig,
-    DaemonCommandResult,
-    DaemonStatusResult,
-    DaemonHealthResult,
-    ErrorInfo,
-)
-from unrealon_driver.src.dto.services import WebSocketConfig
-
-
-class DaemonMode:
-    """
-    🔌 Daemon Mode - Production WebSocket Service
-
-    Full implementation with unrealon_sdk integration:
-    - WebSocket connection via AdapterClient
-    - Command handling and response
-    - Graceful shutdown with signal handling
-    - Health monitoring and status reporting
-    - Automatic reconnection and error recovery
-    """
-
-    def __init__(self, parser: Any, config: DaemonModeConfig):
-        """Initialize daemon mode."""
-        self.parser = parser
-        self.config = config
-        self.logger = parser.logger
-        self._is_running = False
-        self._shutdown_event = asyncio.Event()
-
-    async def start(
-        self, server: Optional[str] = None, api_key: Optional[str] = None, **kwargs
-    ):
-        """Start daemon mode with full WebSocket integration."""
-        if self.logger:
-            self.logger.info(f"🔌 Starting daemon mode for: {self.parser.parser_name}")
-
-        # Get connection parameters
-        server_url = server or self.config.server_url or kwargs.get("server_url")
-        api_key = (
-            api_key or self.config.api_key or kwargs.get("api_key")
-        )
-
-        if not server_url:
-            if self.logger:
-                self.logger.error(
-                    "❌ WebSocket server URL not configured for daemon mode!"
-                )
-                self.logger.info("   Set server URL in config or pass as parameter")
-            return
-
-        if not api_key:
-            if self.logger:
-                self.logger.error(
-                    "❌ WebSocket API key not configured for daemon mode!"
-                )
-                self.logger.info("   Set API key in config or pass as parameter")
-            return
-
-        if self.logger:
-            self.logger.info(f"🔌 Starting WebSocket daemon mode")
-            self.logger.info(f"   Server: {server_url}")
-            self.logger.info(f"   Parser: {self.parser.parser_id}")
-            self.logger.info(
-                f"   API Key: {'***' + api_key[-4:] if len(api_key) > 4 else '***'}"
-            )
-
-        # Setup WebSocket service configuration with type safety
-        websocket_config = WebSocketConfig(
-            server_url=server_url,
-            api_key=api_key,
-            parser_name=self.parser.parser_name,
-            auto_reconnect=self.config.auto_reconnect,
-            health_check_interval=self.config.health_check_interval,
-            max_reconnect_attempts=self.config.max_reconnect_attempts,
-            connection_timeout=self.config.connection_timeout,
-        )
-
-        # Configure WebSocket service
-        self.parser.websocket.config = websocket_config
-
-        # Register command handlers
-        self.parser.websocket.register_handler(
-            "parse_command", self._handle_parse_command
-        )
-        self.parser.websocket.register_handler(
-            "status_request", self._handle_status_request
-        )
-        self.parser.websocket.register_handler(
-            "health_check", self._handle_health_check
-        )
-
-        # Setup signal handlers for graceful shutdown
-        self._setup_signal_handlers()
-
-        try:
-            await self.parser.setup() if hasattr(self.parser, "setup") else None
-
-            # Connect to WebSocket server
-            success = await self.parser.websocket.connect(
-                server_url=server_url, api_key=api_key
-            )
-
-            if not success:
-                if self.logger:
-                    self.logger.error("❌ Failed to connect to WebSocket server")
-                return
-
-            if self.logger:
-                self.logger.info("✅ Connected to WebSocket server")
-                self.logger.info("👂 Listening for parse commands...")
-                self.logger.info(
-                    "   Commands: 'parse_command', 'status_request', 'health_check'"
-                )
-                self.logger.info("   Press Ctrl+C to stop")
-
-            self._is_running = True
-
-            # Start listening for commands with graceful shutdown
-            await self.parser.websocket.listen(shutdown_event=self._shutdown_event)
-
-        except Exception as e:
-            if self.logger:
-                self.logger.error(f"❌ Daemon mode error: {e}")
-            raise
-        finally:
-            await self.stop()
-
-    def _setup_signal_handlers(self):
-        """Setup signal handlers for graceful shutdown."""
-
-        def signal_handler(signum, frame):
-            if self.logger:
-                self.logger.info(f"\n🛑 Shutdown signal received (signal {signum})...")
-            self._shutdown_event.set()
-
-        # Register signal handlers
-        try:
-            signal.signal(signal.SIGINT, signal_handler)
-            signal.signal(signal.SIGTERM, signal_handler)
-        except Exception as e:
-            if self.logger:
-                self.logger.warning(f"Could not register signal handlers: {e}")
-
-    async def _handle_parse_command(self, command: dict) -> DaemonCommandResult:
-        """Handle parse command from WebSocket with type safety."""
-
-        start_time = datetime.now()
-
-        try:
-            if self.logger:
-                self.logger.info("🚀 Received parse command via WebSocket")
-
-            # Setup parser if needed
-            if hasattr(self.parser, "setup"):
-                await self.parser.setup()
-
-            # Execute parse method
-            result = await self.parser.parse()
-
-            # Cleanup if needed
-            if hasattr(self.parser, "cleanup"):
-                await self.parser.cleanup()
-
-            duration = (datetime.now() - start_time).total_seconds()
-            items_count = len(result) if isinstance(result, (list, dict)) else 1
-
-            if self.logger:
-                self.logger.info(
-                    f"✅ Parse command completed in {duration:.2f}s - {items_count} items"
-                )
-
-            return DaemonCommandResult(
-                status="success",
-                data=result if isinstance(result, dict) else {"result": result},
-                items_processed=items_count,
-                duration_seconds=duration,
-                parser_id=self.parser.parser_id,
-                timestamp=datetime.now().isoformat(),
-                error=None,
-            )
-
-        except Exception as e:
-            duration = (datetime.now() - start_time).total_seconds()
-
-            if self.logger:
-                self.logger.error(f"❌ Parse command failed after {duration:.2f}s: {e}")
-
-            error_info = ErrorInfo(
-                message=str(e),
-                error_type=type(e).__name__,
-                error_code=getattr(e, "error_code", None),
-                traceback=None,
-                context={"command": "parse", "parser_id": self.parser.parser_id},
-            )
-
-            return DaemonCommandResult(
-                status="error",
-                data=None,
-                items_processed=0,
-                duration_seconds=duration,
-                parser_id=self.parser.parser_id,
-                timestamp=datetime.now().isoformat(),
-                error=error_info,
-            )
-
-    async def _handle_status_request(self, command: dict) -> DaemonStatusResult:
-        """Handle status request from WebSocket with type safety."""
-
-        try:
-            health = await self.parser.health_check()
-
-            return DaemonStatusResult(
-                status="success",
-                parser_id=self.parser.parser_id,
-                parser_name=self.parser.parser_name,
-                daemon_running=self._is_running,
-                health=health,
-                timestamp=datetime.now().isoformat(),
-                error=None,
-            )
-
-        except Exception as e:
-            error_info = ErrorInfo(
-                message=str(e),
-                error_type=type(e).__name__,
-                error_code=getattr(e, "error_code", None),
-                traceback=None,
-                context={"command": "status", "parser_id": self.parser.parser_id},
-            )
-
-            return DaemonStatusResult(
-                status="error",
-                parser_id=self.parser.parser_id,
-                parser_name=self.parser.parser_name,
-                daemon_running=self._is_running,
-                health=None,
-                timestamp=datetime.now().isoformat(),
-                error=error_info,
-            )
-
-    async def _handle_health_check(self, command: dict) -> DaemonHealthResult:
-        """Handle health check from WebSocket with type safety."""
-
-        try:
-            health = await self.parser.health_check()
-
-            # Type-safe health check - assume health is dict
-            status = "healthy" if health.get("status") == "healthy" else "unhealthy"
-
-            return DaemonHealthResult(
-                status=status,
-                data=health,
-                parser_id=self.parser.parser_id,
-                timestamp=datetime.now().isoformat(),
-                error=None,
-            )
-
-        except Exception as e:
-            error_info = ErrorInfo(
-                message=str(e),
-                error_type=type(e).__name__,
-                error_code=getattr(e, "error_code", None),
-                traceback=None,
-                context={"command": "health_check", "parser_id": self.parser.parser_id},
-            )
-
-            return DaemonHealthResult(
-                status="unhealthy",
-                data=None,
-                parser_id=self.parser.parser_id,
-                timestamp=datetime.now().isoformat(),
-                error=error_info,
-            )
-
-    async def stop(self):
-        """Stop daemon mode gracefully."""
-        if self.logger:
-            self.logger.info("🛑 Stopping daemon mode...")
-
-        self._is_running = False
-        self._shutdown_event.set()
-
-        # Disconnect WebSocket
-        try:
-            await self.parser.websocket.disconnect()
-        except Exception as e:
-            if self.logger:
-                self.logger.error(f"Error disconnecting WebSocket: {e}")
-
-        # Cleanup parser
-        try:
-            if hasattr(self.parser, "cleanup"):
-                await self.parser.cleanup()
-        except Exception as e:
-            if self.logger:
-                self.logger.error(f"Error during parser cleanup: {e}")
-
-        if self.logger:
-            self.logger.info("✅ Daemon mode stopped")
-
-    def __repr__(self) -> str:
-        return (
-            f"<DaemonMode(running={self._is_running}, parser={self.parser.parser_id})>"
-        )