unrealon 1.1.5__py3-none-any.whl → 2.0.4__py3-none-any.whl

unrealon_driver/core_module/event_manager.py

@@ -0,0 +1,127 @@
+"""
+Clean event manager for module communication.
+"""
+
+import asyncio
+import logging
+from typing import Dict, List, Callable, Any, Optional
+from collections import defaultdict
+
+from .protocols import ModuleEvent, EventType
+
+logger = logging.getLogger(__name__)
+
+
+class EventManager:
+    """
+    Clean event manager for module communication.
+    
+    Provides pub/sub system for modules to communicate
+    without tight coupling.
+    """
+    
+    def __init__(self):
+        self.listeners: Dict[EventType, List[Callable]] = defaultdict(list)
+        self.event_queue: Optional[asyncio.Queue] = None
+        self._processor_task: Optional[asyncio.Task] = None
+        self._running = False
+    
+    async def start(self):
+        """Start event processing."""
+        if self._running:
+            return
+        
+        self._running = True
+        # Only create task if there's a running event loop
+        try:
+            loop = asyncio.get_running_loop()
+            self.event_queue = asyncio.Queue()
+            self._processor_task = loop.create_task(self._process_events())
+            logger.info("Event manager started")
+        except RuntimeError:
+            # No running event loop - don't start background processing
+            logger.debug("No running event loop - EventManager running in sync mode")
+    
+    async def stop(self):
+        """Stop event processing."""
+        self._running = False
+        
+        if self._processor_task and not self._processor_task.done():
+            self._processor_task.cancel()
+            try:
+                await self._processor_task
+            except asyncio.CancelledError:
+                pass
+        
+        # Clear queue
+        self.event_queue = None
+        self._processor_task = None
+        
+        logger.info("Event manager stopped")
+    
+    def subscribe(self, event_type: EventType, handler: Callable[[ModuleEvent], Any]):
+        """Subscribe to event type."""
+        self.listeners[event_type].append(handler)
+        logger.debug(f"Subscribed handler to {event_type}")
+    
+    def unsubscribe(self, event_type: EventType, handler: Callable):
+        """Unsubscribe from event type."""
+        if handler in self.listeners[event_type]:
+            self.listeners[event_type].remove(handler)
+            logger.debug(f"Unsubscribed handler from {event_type}")
+    
+    async def emit(self, event: ModuleEvent):
+        """Emit event to queue."""
+        if self._running and self.event_queue:
+            await self.event_queue.put(event)
+    
+    async def _process_events(self):
+        """Background event processing."""
+        while self._running:
+            try:
+                # Get event from queue
+                event = await asyncio.wait_for(self.event_queue.get(), timeout=1.0)
+                
+                # Process event
+                await self._handle_event(event)
+                
+            except asyncio.TimeoutError:
+                # No events to process, continue
+                continue
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Event processing error: {e}")
+    
+    async def _handle_event(self, event: ModuleEvent):
+        """Handle single event."""
+        try:
+            handlers = self.listeners.get(event.event_type, [])
+            
+            if not handlers:
+                logger.debug(f"No handlers for event type: {event.event_type}")
+                return
+            
+            # Execute all handlers
+            for handler in handlers:
+                try:
+                    if asyncio.iscoroutinefunction(handler):
+                        await handler(event)
+                    else:
+                        handler(event)
+                except Exception as e:
+                    logger.error(f"Event handler error: {e}")
+            
+        except Exception as e:
+            logger.error(f"Event handling error: {e}")
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get event manager statistics."""
+        return {
+            "running": self._running,
+            "listeners": {
+                event_type.value: len(handlers)
+                for event_type, handlers in self.listeners.items()
+            },
+            "queue_size": self.event_queue.qsize()
+        }

unrealon_driver/core_module/protocols.py

@@ -0,0 +1,98 @@
+"""
+Clean protocols for module system.
+"""
+
+from abc import abstractmethod
+from typing import Protocol, Dict, Any, Optional
+from datetime import datetime
+from enum import Enum
+
+from pydantic import BaseModel
+
+
+class ModuleStatus(str, Enum):
+    """Module lifecycle status."""
+    UNINITIALIZED = "uninitialized"
+    INITIALIZING = "initializing"
+    INITIALIZED = "initialized"
+    STARTING = "starting"
+    RUNNING = "running"
+    STOPPING = "stopping"
+    STOPPED = "stopped"
+    ERROR = "error"
+
+
+class EventType(str, Enum):
+    """Event types for module communication."""
+    MODULE_INITIALIZED = "module_initialized"
+    MODULE_STARTED = "module_started"
+    MODULE_STOPPED = "module_stopped"
+    MODULE_ERROR = "module_error"
+    TASK_STARTED = "task_started"
+    TASK_COMPLETED = "task_completed"
+    TASK_FAILED = "task_failed"
+    HEALTH_CHECK = "health_check"
+
+
+class HealthStatus(str, Enum):
+    """Health check status."""
+    HEALTHY = "healthy"
+    DEGRADED = "degraded"
+    UNHEALTHY = "unhealthy"
+    UNKNOWN = "unknown"
+
+
+class ModuleEvent(BaseModel):
+    """Event data structure."""
+    event_type: EventType
+    module_name: str
+    timestamp: datetime
+    data: Dict[str, Any] = {}
+    error: Optional[str] = None
+    
+    model_config = {"extra": "forbid"}
+
+
+class HealthCheckResult(BaseModel):
+    """Health check result."""
+    status: HealthStatus
+    timestamp: datetime
+    details: Dict[str, Any] = {}
+    error: Optional[str] = None
+    response_time_ms: Optional[float] = None
+    
+    model_config = {"extra": "forbid"}
+
+
+class BaseModule(Protocol):
+    """Base module protocol."""
+    
+    @property
+    def name(self) -> str:
+        """Module name."""
+        ...
+    
+    @property
+    def status(self) -> ModuleStatus:
+        """Current module status."""
+        ...
+    
+    @abstractmethod
+    async def initialize(self) -> bool:
+        """Initialize module."""
+        ...
+    
+    @abstractmethod
+    async def start(self) -> bool:
+        """Start module."""
+        ...
+    
+    @abstractmethod
+    async def stop(self) -> None:
+        """Stop module."""
+        ...
+    
+    @abstractmethod
+    async def health_check(self) -> HealthCheckResult:
+        """Perform health check."""
+        ...

unrealon_driver/core_module/registry.py

@@ -0,0 +1,146 @@
+"""
+Clean module registry for lifecycle management.
+"""
+
+import asyncio
+import logging
+from typing import Dict, List, Optional, Any
+
+from .protocols import BaseModule, ModuleStatus
+from .event_manager import EventManager
+
+logger = logging.getLogger(__name__)
+
+
+class ModuleRegistry:
+    """
+    Clean module registry.
+    
+    Manages module lifecycle and provides centralized
+    access to all registered modules.
+    """
+    
+    def __init__(self, event_manager: Optional[EventManager] = None):
+        self.modules: Dict[str, BaseModule] = {}
+        self.event_manager = event_manager or EventManager()
+        self._initialized = False
+    
+    def register(self, module: BaseModule):
+        """Register a module."""
+        self.modules[module.name] = module
+        
+        # Set event manager if module supports it
+        if hasattr(module, 'set_event_manager'):
+            module.set_event_manager(self.event_manager)
+        
+        logger.info(f"Registered module: {module.name}")
+    
+    def get(self, name: str) -> Optional[BaseModule]:
+        """Get module by name."""
+        return self.modules.get(name)
+    
+    def get_all(self) -> Dict[str, BaseModule]:
+        """Get all registered modules."""
+        return self.modules.copy()
+    
+    async def initialize_all(self) -> bool:
+        """Initialize all registered modules."""
+        if self._initialized:
+            return True
+        
+        # Start event manager
+        await self.event_manager.start()
+        
+        success_count = 0
+        
+        for name, module in self.modules.items():
+            try:
+                if await module.initialize():
+                    success_count += 1
+                    logger.info(f"Module {name} initialized successfully")
+                else:
+                    logger.error(f"Module {name} initialization failed")
+            except Exception as e:
+                logger.error(f"Module {name} initialization error: {e}")
+        
+        self._initialized = success_count == len(self.modules)
+        
+        if self._initialized:
+            logger.info(f"All {len(self.modules)} modules initialized successfully")
+        else:
+            logger.warning(f"Only {success_count}/{len(self.modules)} modules initialized")
+        
+        return self._initialized
+    
+    async def start_all(self) -> bool:
+        """Start all initialized modules."""
+        if not self._initialized:
+            logger.error("Cannot start modules - not all initialized")
+            return False
+        
+        success_count = 0
+        
+        for name, module in self.modules.items():
+            if module.status == ModuleStatus.INITIALIZED:
+                try:
+                    if await module.start():
+                        success_count += 1
+                        logger.info(f"Module {name} started successfully")
+                    else:
+                        logger.error(f"Module {name} start failed")
+                except Exception as e:
+                    logger.error(f"Module {name} start error: {e}")
+        
+        logger.info(f"Started {success_count}/{len(self.modules)} modules")
+        return success_count > 0
+    
+    async def stop_all(self):
+        """Stop all running modules."""
+        for name, module in self.modules.items():
+            if module.status == ModuleStatus.RUNNING:
+                try:
+                    await module.stop()
+                    logger.info(f"Module {name} stopped successfully")
+                except Exception as e:
+                    logger.error(f"Module {name} stop error: {e}")
+        
+        # Stop event manager
+        await self.event_manager.stop()
+        
+        self._initialized = False
+        logger.info("All modules stopped")
+    
+    async def health_check_all(self) -> Dict[str, Any]:
+        """Get health status of all modules."""
+        health_data = {}
+        
+        for name, module in self.modules.items():
+            try:
+                result = await module.health_check()
+                health_data[name] = result.model_dump()
+            except Exception as e:
+                health_data[name] = {
+                    "status": "error",
+                    "error": str(e)
+                }
+        
+        return {
+            "modules": health_data,
+            "total": len(self.modules),
+            "initialized": self._initialized,
+            "event_manager": self.event_manager.get_stats()
+        }
+    
+    def get_running_modules(self) -> List[str]:
+        """Get list of running module names."""
+        return [
+            name for name, module in self.modules.items()
+            if module.status == ModuleStatus.RUNNING
+        ]
+    
+    def is_all_running(self) -> bool:
+        """Check if all modules are running."""
+        return all(
+            module.status == ModuleStatus.RUNNING 
+            for module in self.modules.values()
+        )

unrealon_driver/decorators/__init__.py

@@ -0,0 +1,15 @@
+"""
+Clean decorator system for UnrealOn Driver.
+"""
+
+from .task import task
+from .retry import retry
+from .schedule import schedule
+from .timing import timing
+
+__all__ = [
+    "task",
+    "retry", 
+    "schedule",
+    "timing",
+]

unrealon_driver/decorators/retry.py

@@ -0,0 +1,117 @@
+"""
+Clean retry decorator with exponential backoff.
+"""
+
+import asyncio
+import logging
+from functools import wraps
+from typing import Callable, Type, Tuple, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def retry(
+    max_attempts: int = 3,
+    delay: float = 1.0,
+    backoff: float = 2.0,
+    exceptions: Tuple[Type[Exception], ...] = (Exception,),
+    on_retry: Optional[Callable] = None
+):
+    """
+    Clean retry decorator.
+    
+    Automatically retries function on specified exceptions
+    with exponential backoff.
+    
+    Args:
+        max_attempts: Maximum retry attempts
+        delay: Initial delay between retries
+        backoff: Backoff multiplier for delay
+        exceptions: Exception types to retry on
+        on_retry: Callback function called on each retry
+    """
+    
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            """Async retry wrapper."""
+            
+            last_exception = None
+            current_delay = delay
+            
+            for attempt in range(max_attempts):
+                try:
+                    return await func(*args, **kwargs)
+                    
+                except exceptions as e:
+                    last_exception = e
+                    
+                    if attempt == max_attempts - 1:
+                        # Last attempt failed
+                        logger.error(f"Function {func.__name__} failed after {max_attempts} attempts: {e}")
+                        raise
+                    
+                    # Log retry attempt
+                    logger.warning(f"Function {func.__name__} attempt {attempt + 1} failed: {e}. Retrying in {current_delay}s...")
+                    
+                    # Call retry callback if provided
+                    if on_retry:
+                        try:
+                            if asyncio.iscoroutinefunction(on_retry):
+                                await on_retry(attempt + 1, e)
+                            else:
+                                on_retry(attempt + 1, e)
+                        except Exception as callback_error:
+                            logger.error(f"Retry callback error: {callback_error}")
+                    
+                    # Wait before retry
+                    await asyncio.sleep(current_delay)
+                    current_delay *= backoff
+            
+            # Should never reach here, but just in case
+            raise last_exception
+        
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            """Sync retry wrapper."""
+            
+            last_exception = None
+            current_delay = delay
+            
+            for attempt in range(max_attempts):
+                try:
+                    return func(*args, **kwargs)
+                    
+                except exceptions as e:
+                    last_exception = e
+                    
+                    if attempt == max_attempts - 1:
+                        # Last attempt failed
+                        logger.error(f"Function {func.__name__} failed after {max_attempts} attempts: {e}")
+                        raise
+                    
+                    # Log retry attempt
+                    logger.warning(f"Function {func.__name__} attempt {attempt + 1} failed: {e}. Retrying in {current_delay}s...")
+                    
+                    # Call retry callback if provided
+                    if on_retry:
+                        try:
+                            on_retry(attempt + 1, e)
+                        except Exception as callback_error:
+                            logger.error(f"Retry callback error: {callback_error}")
+                    
+                    # Wait before retry (sync)
+                    import time
+                    time.sleep(current_delay)
+                    current_delay *= backoff
+            
+            # Should never reach here, but just in case
+            raise last_exception
+        
+        # Return appropriate wrapper based on function type
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        else:
+            return sync_wrapper
+    
+    return decorator

unrealon_driver/decorators/schedule.py

@@ -0,0 +1,137 @@
+"""
+Clean schedule decorator for cron-like scheduling.
+"""
+
+import asyncio
+import logging
+from functools import wraps
+from typing import Callable, Optional
+from datetime import datetime, timedelta
+
+logger = logging.getLogger(__name__)
+
+
+def schedule(
+    interval: Optional[int] = None,
+    cron: Optional[str] = None,
+    run_once: bool = False,
+    start_immediately: bool = False
+):
+    """
+    Clean schedule decorator.
+    
+    Schedules function execution at specified intervals or cron patterns.
+    
+    Args:
+        interval: Interval in seconds between executions
+        cron: Cron expression (simple format: "*/5 * * * *" for every 5 minutes)
+        run_once: Run only once then stop
+        start_immediately: Start immediately instead of waiting for first interval
+    """
+    
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            """Scheduled function wrapper."""
+            
+            if not interval and not cron:
+                raise ValueError("Either interval or cron must be specified")
+            
+            execution_count = 0
+            
+            # Start immediately if requested
+            if start_immediately:
+                try:
+                    logger.info(f"Executing scheduled function {func.__name__} (immediate start)")
+                    
+                    if asyncio.iscoroutinefunction(func):
+                        await func(*args, **kwargs)
+                    else:
+                        func(*args, **kwargs)
+                    
+                    execution_count += 1
+                    
+                    if run_once:
+                        logger.info(f"Scheduled function {func.__name__} completed (run_once=True)")
+                        return
+                        
+                except Exception as e:
+                    logger.error(f"Scheduled function {func.__name__} failed: {e}")
+            
+            # Main scheduling loop
+            while True:
+                try:
+                    # Calculate next execution time
+                    if interval:
+                        await asyncio.sleep(interval)
+                    elif cron:
+                        # Simple cron parsing (just for intervals like "*/5 * * * *")
+                        next_delay = _parse_simple_cron(cron)
+                        await asyncio.sleep(next_delay)
+                    
+                    # Execute function
+                    logger.debug(f"Executing scheduled function {func.__name__}")
+                    
+                    if asyncio.iscoroutinefunction(func):
+                        await func(*args, **kwargs)
+                    else:
+                        func(*args, **kwargs)
+                    
+                    execution_count += 1
+                    
+                    if run_once:
+                        logger.info(f"Scheduled function {func.__name__} completed after {execution_count} executions")
+                        break
+                        
+                except asyncio.CancelledError:
+                    logger.info(f"Scheduled function {func.__name__} cancelled after {execution_count} executions")
+                    break
+                except Exception as e:
+                    logger.error(f"Scheduled function {func.__name__} failed: {e}")
+                    # Continue scheduling even if execution fails
+        
+        # Store schedule metadata
+        wrapper._schedule_interval = interval
+        wrapper._schedule_cron = cron
+        wrapper._schedule_run_once = run_once
+        wrapper._is_scheduled = True
+        
+        return wrapper
+    
+    return decorator
+
+
+def _parse_simple_cron(cron_expr: str) -> int:
+    """
+    Parse simple cron expressions.
+    
+    Currently supports only basic interval patterns like:
+    - "*/5 * * * *" (every 5 minutes)
+    - "0 * * * *" (every hour)
+    - "0 0 * * *" (every day)
+    
+    Returns delay in seconds until next execution.
+    """
+    
+    parts = cron_expr.strip().split()
+    if len(parts) != 5:
+        raise ValueError(f"Invalid cron expression: {cron_expr}")
+    
+    minute, hour, day, month, weekday = parts
+    
+    # Simple parsing for common patterns
+    if minute.startswith("*/"):
+        # Every N minutes
+        interval_minutes = int(minute[2:])
+        return interval_minutes * 60
+    elif minute == "0" and hour.startswith("*/"):
+        # Every N hours
+        interval_hours = int(hour[2:])
+        return interval_hours * 3600
+    elif minute == "0" and hour == "0":
+        # Daily
+        return 24 * 3600
+    else:
+        # Default to 5 minutes for unsupported patterns
+        logger.warning(f"Unsupported cron pattern {cron_expr}, defaulting to 5 minutes")
+        return 300

unrealon_driver/decorators/task.py

@@ -0,0 +1,61 @@
+"""
+Clean task decorator for registering task handlers.
+"""
+
+import asyncio
+import logging
+from functools import wraps
+from typing import Callable, Any, Optional
+
+from unrealon_core.models.websocket import TaskAssignmentData, TaskResultData
+from unrealon_core.enums import TaskStatus
+
+logger = logging.getLogger(__name__)
+
+
+def task(task_type: str, description: Optional[str] = None):
+    """
+    Clean task decorator.
+    
+    Registers a function as a task handler and provides
+    automatic error handling and result formatting.
+    
+    Args:
+        task_type: Type of task this handler processes
+        description: Optional description of the task
+    """
+    
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(task_data: TaskAssignmentData, *args, **kwargs) -> Any:
+            """Task wrapper with error handling."""
+            
+            start_time = asyncio.get_event_loop().time()
+            
+            try:
+                logger.info(f"Starting task {task_type}: {task_data.task_id}")
+                
+                # Execute the task function
+                if asyncio.iscoroutinefunction(func):
+                    result = await func(task_data, *args, **kwargs)
+                else:
+                    result = func(task_data, *args, **kwargs)
+                
+                duration = asyncio.get_event_loop().time() - start_time
+                logger.info(f"Task {task_type} completed in {duration:.2f}s: {task_data.task_id}")
+                
+                return result
+                
+            except Exception as e:
+                duration = asyncio.get_event_loop().time() - start_time
+                logger.error(f"Task {task_type} failed after {duration:.2f}s: {task_data.task_id} - {e}")
+                raise
+        
+        # Store task metadata
+        wrapper._task_type = task_type
+        wrapper._task_description = description
+        wrapper._is_task_handler = True
+        
+        return wrapper
+    
+    return decorator