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

unrealon_driver/src/execution/interactive_mode.py

@@ -1,88 +0,0 @@
-"""
-Interactive Mode implementation for UnrealOn Driver v3.0 (Stub Implementation)
-
-Live development and debugging shell.
-TODO: Full implementation to be completed.
-"""
-
-import asyncio
-from typing import Any, Dict
-
-from unrealon_driver.src.dto.execution import InteractiveModeConfig
-
-
-class InteractiveMode:
-    """
-    🎮 Interactive Mode - Live Development Shell
-
-    TODO: Full implementation with interactive shell
-    """
-
-    def __init__(self, parser: Any, config: InteractiveModeConfig):
-        """Initialize interactive mode."""
-        self.parser = parser
-        self.config = config
-        self.logger = parser.logger
-        self._is_running = False
-
-    async def start(self, **kwargs):
-        """Start interactive mode."""
-        if self.logger:
-            self.logger.warning("Interactive mode not yet implemented")
-            self.logger.info(f"Parser: {self.parser.parser_name}")
-
-        print("\n" + "=" * 60)
-        print("🎮 UnrealOn Driver v3.0 - Interactive Mode")
-        print("📝 Parser:", self.parser.parser_name)
-        print("🆔 ID:", self.parser.parser_id)
-        print("\n⚠️  Interactive mode is not yet implemented")
-        print("Available commands will include:")
-        print("  - run       : Execute parser")
-        print("  - config    : Show configuration")
-        print("  - browser   : Browser debugging tools")
-        print("  - llm       : AI extraction tools")
-        print("  - metrics   : Performance metrics")
-        print("  - help      : Show help")
-        print("  - exit      : Exit interactive mode")
-        print("=" * 60)
-
-        # Simple simulation
-        self._is_running = True
-
-        try:
-            while self._is_running:
-                try:
-                    command = input("\nunrealon> ").strip().lower()
-
-                    if command in ["exit", "quit"]:
-                        break
-                    elif command == "run":
-                        print("🚀 Running parser...")
-                        result = await self.parser.test()
-                        print(f"✅ Result: {result.get('success', False)}")
-                    elif command == "config":
-                        print("� Configuration:")
-                        print(f"   Environment: {self.parser._config.environment}")
-                        print(f"   Debug mode: {self.parser._config.debug_mode}")
-                    elif command == "help":
-                        print("� Interactive mode commands (planned):")
-                        print("   run, config, browser, llm, metrics, help, exit")
-                    else:
-                        print(
-                            f"❓ Unknown command: {command}. Type 'help' for available commands."
-                        )
-
-                except KeyboardInterrupt:
-                    print("\n👋 Use 'exit' to quit interactive mode")
-                except EOFError:
-                    break
-        finally:
-            await self.stop()
-
-    async def stop(self):
-        """Stop interactive mode."""
-        self._is_running = False
-        print("\n👋 Interactive mode stopped")
-
-    def __repr__(self) -> str:
-        return f"<InteractiveMode(running={self._is_running}, stub=True)>"

unrealon_driver/src/execution/modes.py

@@ -1,45 +0,0 @@
-"""
-Execution mode enumeration and utilities for UnrealOn Driver v3.0
-"""
-
-from enum import Enum, auto
-from typing import Any, Dict
-
-
-class ExecutionMode(Enum):
-    """Enumeration of available execution modes."""
-
-    TEST = auto()  # Development testing
-    DAEMON = auto()  # Production WebSocket service
-    SCHEDULED = auto()  # Automated recurring execution
-    INTERACTIVE = auto()  # Live development shell
-
-    @classmethod
-    def from_string(cls, mode_str: str) -> "ExecutionMode":
-        """Convert string to ExecutionMode."""
-        mode_map = {
-            "test": cls.TEST,
-            "daemon": cls.DAEMON,
-            "scheduled": cls.SCHEDULED,
-            "interactive": cls.INTERACTIVE,
-        }
-
-        mode_str = mode_str.lower().strip()
-        if mode_str not in mode_map:
-            raise ValueError(f"Unknown execution mode: {mode_str}")
-
-        return mode_map[mode_str]
-
-    def to_string(self) -> str:
-        """Convert ExecutionMode to string."""
-        return self.name.lower()
-
-    def get_description(self) -> str:
-        """Get human-readable description."""
-        descriptions = {
-            self.TEST: "Development testing and debugging",
-            self.DAEMON: "Production WebSocket service",
-            self.SCHEDULED: "Automated recurring execution",
-            self.INTERACTIVE: "Live development shell",
-        }
-        return descriptions[self]

unrealon_driver/src/execution/scheduled_mode.py

@@ -1,209 +0,0 @@
-"""
-Scheduled Mode implementation for UnrealOn Driver v3.0
-
-Automated recurring execution with human-readable intervals.
-Full implementation using enterprise SchedulerService.
-"""
-
-import asyncio
-import signal
-from typing import Any, Optional
-
-from unrealon_driver.src.dto.execution import ScheduledModeConfig, ScheduledModeStatus
-from unrealon_driver.src.dto.services import SchedulerConfig
-
-from unrealon_driver.src.services.scheduler_service import SchedulerService
-
-
-class ScheduledMode:
-    """
-    ⏰ Scheduled Mode - Automated Recurring Execution
-
-    Full implementation with enterprise features:
-    - Human-readable intervals ("30m", "1h", "daily")
-    - Smart load balancing with jitter
-    - Error recovery and retries
-    - Health monitoring and alerting
-    - Production-ready reliability
-    """
-
-    def __init__(self, parser: Any, config: ScheduledModeConfig):
-        """Initialize scheduled mode."""
-        self.parser = parser
-        self.config = config
-        self.logger = parser.logger
-        self._is_running = False
-        self._scheduler_service = None
-        self._shutdown_event = asyncio.Event()
-
-    async def start(self, every: str, at: Optional[str] = None, **kwargs):
-        """Start scheduled execution with full enterprise features."""
-        if self.logger:
-            self.logger.info(
-                f"⏰ Starting scheduled mode for: {self.parser.parser_name}"
-            )
-            self.logger.info(f"📅 Schedule: every {every}")
-            if at:
-                self.logger.info(f"🕘 At time: {at}")
-
-        # Setup scheduler service with type safety
-        scheduler_config = SchedulerConfig(
-            parser_id=self.parser.parser_id,
-            max_concurrent_tasks=kwargs.get(
-                "max_concurrent", self.config.max_concurrent
-            ),
-            enable_jitter=kwargs.get("jitter", self.config.jitter),
-            jitter_range=kwargs.get("jitter_range", self.config.jitter_range),
-            default_timeout=kwargs.get("timeout", self.config.timeout),
-            default_retries=kwargs.get("retry_attempts", self.config.retry_attempts),
-            enable_task_monitoring=True,
-            health_check_interval=60,
-        )
-
-        self._scheduler_service = SchedulerService(
-            config=scheduler_config,
-            logger=self.logger,
-            metrics=self.parser.metrics if hasattr(self.parser, "metrics") else None,
-        )
-
-        # Create scheduled parse task with type safety
-        self._scheduler_service.add_task(
-            task_id=f"{self.parser.parser_id}_scheduled",
-            name=f"Scheduled {self.parser.parser_name}",
-            func=self._scheduled_parse_task,
-            every=every,
-            enabled=True,
-            timeout=kwargs.get("timeout", 300),
-            retry_attempts=kwargs.get("retry_attempts", 3),
-            max_runs=kwargs.get("max_runs"),
-        )
-
-        # Setup signal handlers for graceful shutdown
-        self._setup_signal_handlers()
-
-        self._is_running = True
-
-        try:
-            if self.logger:
-                self.logger.info("✅ Scheduler configured successfully")
-                self.logger.info("👂 Starting scheduled execution...")
-                self.logger.info("   Press Ctrl+C to stop")
-
-            # Start scheduler service
-            await self._scheduler_service.start()
-
-        except KeyboardInterrupt:
-            if self.logger:
-                self.logger.info("⏹️  Scheduled mode interrupted")
-        except Exception as e:
-            if self.logger:
-                self.logger.error(f"❌ Scheduled 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()
-
-            # Stop scheduler
-            if self._scheduler_service:
-                asyncio.create_task(self._scheduler_service.stop())
-
-        # 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 _scheduled_parse_task(self):
-        """Scheduled parse task handler with full monitoring."""
-        start_time = asyncio.get_event_loop().time()
-
-        try:
-            if self.logger:
-                self.logger.info("🚀 Executing scheduled parse task")
-
-            # 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 = asyncio.get_event_loop().time() - start_time
-            items_count = len(result) if isinstance(result, (list, dict)) else 1
-
-            if self.logger:
-                self.logger.info(
-                    f"✅ Scheduled task completed in {duration:.2f}s - {items_count} items"
-                )
-
-            return result
-
-        except Exception as e:
-            duration = asyncio.get_event_loop().time() - start_time
-
-            if self.logger:
-                self.logger.error(
-                    f"❌ Scheduled task failed after {duration:.2f}s: {e}"
-                )
-
-            # Re-raise for scheduler error handling
-            raise
-
-    async def get_status(self) -> ScheduledModeStatus:
-        """Get current scheduling status with type safety."""
-
-        if not self._scheduler_service:
-            return ScheduledModeStatus(
-                status="not_started",
-                is_running=False,
-                parser_id=self.parser.parser_id,
-                parser_name=self.parser.parser_name,
-                scheduler_health=None,
-            )
-
-        health = await self._scheduler_service.health_check()
-        return ScheduledModeStatus(
-            status="running" if self._is_running else "stopped",
-            is_running=self._is_running,
-            parser_id=self.parser.parser_id,
-            parser_name=self.parser.parser_name,
-            scheduler_health=health,
-        )
-
-    async def stop(self):
-        """Stop scheduled mode gracefully."""
-        if self.logger:
-            self.logger.info("🛑 Stopping scheduled mode...")
-
-        self._is_running = False
-        self._shutdown_event.set()
-
-        # Stop scheduler service
-        if self._scheduler_service:
-            try:
-                await self._scheduler_service.stop()
-            except Exception as e:
-                if self.logger:
-                    self.logger.error(f"Error stopping scheduler: {e}")
-
-        if self.logger:
-            self.logger.info("✅ Scheduled mode stopped")
-
-    def __repr__(self) -> str:
-        task_count = (
-            len(self._scheduler_service._tasks) if self._scheduler_service else 0
-        )
-        return f"<ScheduledMode(running={self._is_running}, tasks={task_count})>"

unrealon_driver/src/execution/test_mode.py

@@ -1,250 +0,0 @@
-"""
-Test Mode implementation for UnrealOn Driver v3.0
-
-Development and debugging execution mode with detailed output and error reporting.
-COMPLIANCE: 100% Pydantic v2 compliant, no Dict[str, Any] usage.
-"""
-
-import asyncio
-import time
-from datetime import datetime
-from typing import Any, Optional
-
-from unrealon_driver.src.core.exceptions import ParserError
-from unrealon_driver.src.dto.execution import (
-    ParserTestConfig,
-    ExecutionResult,
-    ErrorInfo,
-    PerformanceMetrics,
-    ExecutionEnvironment,
-)
-
-
-class TestMode:
-    """
-    🧪 Test Mode - Development and debugging
-
-    Single execution for development and testing with:
-    - Detailed logging and debugging
-    - Error reporting with suggestions
-    - Performance metrics
-    - Results visualization
-    """
-
-    def __init__(self, parser: Any, config: ParserTestConfig):
-        """Initialize test mode with type-safe configuration."""
-        self.parser = parser
-        self.config = config
-        self.logger = parser.logger
-        self.metrics = parser.metrics
-
-    async def execute(self, **kwargs) -> ExecutionResult:
-        """Execute parser in test mode with type-safe results."""
-        start_time = time.time()
-        start_datetime = datetime.now()
-        execution_id = f"test_{int(start_time)}"
-
-        if self.config.verbose:
-            self._print_test_header()
-
-        try:
-            # Initialize parser if needed
-            await self._initialize_test_environment()
-
-            # Execute the parse method
-            if self.config.verbose:
-                print("🚀 Starting parse execution...")
-
-            parse_start = time.time()
-            result = await self.parser.parse()
-            parse_duration = time.time() - parse_start
-
-            # Process results
-            processed_result = await self._process_test_result(
-                result, parse_duration, execution_id, start_datetime
-            )
-
-            if self.config.verbose:
-                self._print_test_success(processed_result, time.time() - start_time)
-
-            return processed_result
-
-        except Exception as e:
-            # In test mode, let critical exceptions propagate for debugging
-            if isinstance(e, (RuntimeError, NotImplementedError)):
-                raise
-                
-            error_result = await self._handle_test_error(
-                e, execution_id, start_datetime, time.time() - start_time
-            )
-
-            if self.config.verbose:
-                self._print_test_error(error_result)
-
-            return error_result
-
-        finally:
-            await self._cleanup_test_environment()
-
-    def _print_test_header(self):
-        """Print test mode header."""
-        print("\n" + "=" * 60)
-        print(f"🧪 UnrealOn Driver v3.0 - Test Mode")
-        print(f"📝 Parser: {self.parser.parser_name}")
-        print(f"🆔 ID: {self.parser.parser_id}")
-        print(f"⏰ Started: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-        print("=" * 60)
-
-    async def _initialize_test_environment(self):
-        """Initialize test environment."""
-        if self.config.show_browser:
-            # Override browser config to show browser
-            if hasattr(self.parser, "_browser") and self.parser._browser:
-                self.parser._browser.config["headless"] = False
-            else:
-                self.parser._config.browser_config["headless"] = False
-
-        # Ensure system directories exist
-        system_dir = self.parser._config._get_system_dir()
-        system_dir.mkdir(parents=True, exist_ok=True)
-
-        if self.logger:
-            self.logger.info(f"Starting test execution for {self.parser.parser_name}")
-
-    async def _process_test_result(
-        self, result: Any, duration: float, execution_id: str, start_time: datetime
-    ) -> ExecutionResult:
-        """Process and enrich test results with type safety."""
-        end_time = datetime.now()
-
-        # Count items processed
-        items_count = 0
-        if isinstance(result, list):
-            items_count = len(result)
-        elif isinstance(result, dict) and "data" in result:
-            data = result["data"]
-            if isinstance(data, list):
-                items_count = len(data)
-            else:
-                items_count = 1
-        elif result is not None:
-            items_count = 1
-
-        # Create performance metrics
-        performance_metrics = PerformanceMetrics(
-            execution_time_seconds=duration,
-            memory_usage_mb=0.0,  # TODO: Add real memory tracking
-            cpu_usage_percent=0.0,  # TODO: Add real CPU tracking
-            operations_count=items_count,
-            operations_per_second=items_count / duration if duration > 0 else 0.0,
-        )
-
-        return ExecutionResult(
-            success=True,
-            execution_id=execution_id,
-            start_time=start_time.isoformat(),
-            end_time=end_time.isoformat(),
-            duration_seconds=duration,
-            data=result if isinstance(result, dict) else {"result": result},
-            items_processed=items_count,
-            error=None,
-            parser_id=self.parser.parser_id,
-            execution_mode="test",
-            environment=self.config.environment,
-            performance_metrics=performance_metrics,
-        )
-
-    async def _handle_test_error(
-        self,
-        error: Exception,
-        execution_id: str,
-        start_time: datetime,
-        total_duration: float,
-    ) -> ExecutionResult:
-        """Handle test execution errors with type safety."""
-        end_time = datetime.now()
-
-        # Create error info
-        error_info = ErrorInfo(
-            message=str(error),
-            error_type=type(error).__name__,
-            error_code=getattr(
-                error, "error_code", None
-            ),  # OK for exception attributes
-            traceback=None,  # We can add traceback if needed
-            context={
-                "parser_id": self.parser.parser_id,
-                "execution_id": execution_id,
-                "test_config": self.config.model_dump(),
-            },
-        )
-
-        # Log error
-        if self.logger:
-            self.logger.error(f"Test execution failed: {error}")
-
-        # Create performance metrics for error case
-        performance_metrics = PerformanceMetrics(
-            execution_time_seconds=total_duration,
-            memory_usage_mb=0.0,
-            cpu_usage_percent=0.0,
-            operations_count=0,
-            operations_per_second=0.0,
-        )
-
-        return ExecutionResult(
-            success=False,
-            execution_id=execution_id,
-            start_time=start_time.isoformat(),
-            end_time=end_time.isoformat(),
-            duration_seconds=total_duration,
-            data=None,
-            items_processed=0,
-            error=error_info,
-            parser_id=self.parser.parser_id,
-            execution_mode="test",
-            environment=self.config.environment,
-            performance_metrics=performance_metrics,
-        )
-
-    async def _cleanup_test_environment(self):
-        """Clean up test environment."""
-        try:
-            # Capture final screenshots if enabled
-            if self.config.save_screenshots:
-                # Implementation for screenshot capture
-                pass
-
-            if self.logger:
-                self.logger.info("Test environment cleanup completed")
-
-        except Exception as e:
-            # Don't fail on screenshot errors, but log for debugging
-            if self.logger:
-                self.logger.debug(f"Screenshot capture failed (non-critical): {e}")
-
-    def _print_test_success(self, result: ExecutionResult, total_duration: float):
-        """Print successful test results."""
-        print("\n✅ Test completed successfully!")
-        print(f"⏱️  Total duration: {total_duration:.2f}s")
-        print(f"📊 Parse duration: {result.duration_seconds:.2f}s")
-        print(f"📈 Items processed: {result.items_processed}")
-        print(f"🆔 Execution ID: {result.execution_id}")
-
-        if result.data and self.config.verbose:
-            print(f"📄 Result preview: {str(result.data)[:100]}...")
-
-    def _print_test_error(self, result: ExecutionResult):
-        """Print test error information."""
-        print("\n❌ Test failed!")
-        print(f"⏱️  Duration: {result.duration_seconds:.2f}s")
-        print(f"🆔 Execution ID: {result.execution_id}")
-
-        if result.error:
-            print(f"🚫 Error: {result.error.message}")
-            print(f"📝 Type: {result.error.error_type}")
-            if result.error.error_code:
-                print(f"🔢 Code: {result.error.error_code}")
-
-    def __repr__(self) -> str:
-        return f"<TestMode(parser={self.parser.parser_id}, config={self.config.environment})>"

unrealon_driver/src/logging/__init__.py

@@ -1,24 +0,0 @@
-"""
-UnrealOn Driver v3.0 Logging Module
-
-Zero-configuration logging with enterprise features:
-- Integration with UnrealOn SDK DevelopmentLogger
-- Specialized Driver operations logging
-- Real-time WebSocket streaming (optional)
-- Structured logging with Pydantic v2
-- Performance metrics and operation tracking
-"""
-
-from .driver_logger import (
-    DriverLogger,
-    initialize_driver_logger,
-    get_driver_logger,
-    ensure_driver_logger,
-)
-
-__all__ = [
-    "DriverLogger",
-    "initialize_driver_logger", 
-    "get_driver_logger",
-    "ensure_driver_logger",
-]