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

unrealon_driver/managers/cache.py

@@ -0,0 +1,116 @@
+"""
+Clean cache manager.
+"""
+
+import asyncio
+from typing import Any, Optional, Dict
+from datetime import datetime, timedelta
+from pydantic import Field
+
+from ..utils.time import utc_now
+from .base import BaseManager, ManagerConfig
+
+
+class CacheManagerConfig(ManagerConfig):
+    """Cache manager configuration."""
+    default_ttl: int = Field(default=3600, description="Default TTL seconds")
+    max_size: int = Field(default=1000, description="Max cache entries")
+
+
+class CacheEntry:
+    """Cache entry with TTL."""
+    
+    def __init__(self, value: Any, ttl: int):
+        self.value = value
+        self.expires_at = utc_now() + timedelta(seconds=ttl)
+    
+    def is_expired(self) -> bool:
+        """Check if entry is expired."""
+        return utc_now() > self.expires_at
+
+
+class CacheManager(BaseManager):
+    """Simple in-memory cache manager."""
+    
+    def __init__(self, config: CacheManagerConfig):
+        super().__init__(config, "cache")
+        self.config: CacheManagerConfig = config
+        self._cache: Dict[str, CacheEntry] = {}
+        self._cleanup_task: Optional[asyncio.Task] = None
+    
+    async def _initialize(self) -> bool:
+        """Initialize cache."""
+        # Start cleanup task
+        self._cleanup_task = asyncio.create_task(self._cleanup_expired())
+        return True
+    
+    async def _shutdown(self):
+        """Shutdown cache."""
+        if self._cleanup_task:
+            self._cleanup_task.cancel()
+            try:
+                await self._cleanup_task
+            except asyncio.CancelledError:
+                pass
+        
+        self._cache.clear()
+    
+    async def _cleanup_expired(self):
+        """Background task to clean expired entries."""
+        while True:
+            try:
+                await asyncio.sleep(60)  # Cleanup every minute
+                
+                expired_keys = []
+                for key, entry in self._cache.items():
+                    if entry.is_expired():
+                        expired_keys.append(key)
+                
+                for key in expired_keys:
+                    del self._cache[key]
+                
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                self.logger.error(f"Cache cleanup error: {e}")
+    
+    def get(self, key: str) -> Optional[Any]:
+        """Get value from cache."""
+        entry = self._cache.get(key)
+        if not entry:
+            return None
+        
+        if entry.is_expired():
+            del self._cache[key]
+            return None
+        
+        return entry.value
+    
+    def set(self, key: str, value: Any, ttl: Optional[int] = None) -> None:
+        """Set value in cache."""
+        if len(self._cache) >= self.config.max_size:
+            # Remove oldest entry
+            oldest_key = next(iter(self._cache))
+            del self._cache[oldest_key]
+        
+        ttl = ttl or self.config.default_ttl
+        self._cache[key] = CacheEntry(value, ttl)
+    
+    def delete(self, key: str) -> bool:
+        """Delete key from cache."""
+        if key in self._cache:
+            del self._cache[key]
+            return True
+        return False
+    
+    def clear(self) -> None:
+        """Clear all cache entries."""
+        self._cache.clear()
+    
+    async def _health_check(self) -> Dict[str, Any]:
+        """Cache health check."""
+        return {
+            "status": "ok",
+            "entries": len(self._cache),
+            "max_size": self.config.max_size
+        }

unrealon_driver/managers/http.py

@@ -0,0 +1,107 @@
+"""
+Clean HTTP manager for requests.
+"""
+
+import asyncio
+import aiohttp
+from typing import Dict, Any, Optional
+from pydantic import Field
+
+from .base import BaseManager, ManagerConfig
+
+
+class HttpManagerConfig(ManagerConfig):
+    """HTTP manager configuration."""
+    user_agent: str = Field(default="UnrealOn-Driver/1.0", description="User agent string")
+    max_connections: int = Field(default=100, description="Max concurrent connections")
+    connector_limit: int = Field(default=30, description="Connector limit per host")
+
+
+class HttpManager(BaseManager):
+    """Clean HTTP manager with aiohttp."""
+    
+    def __init__(self, config: HttpManagerConfig):
+        super().__init__(config, "http")
+        self.config: HttpManagerConfig = config
+        self.session: Optional[aiohttp.ClientSession] = None
+    
+    async def _initialize(self) -> bool:
+        """Initialize HTTP session."""
+        try:
+            # Create connector
+            connector = aiohttp.TCPConnector(
+                limit=self.config.max_connections,
+                limit_per_host=self.config.connector_limit,
+                ttl_dns_cache=300,
+                use_dns_cache=True
+            )
+            
+            # Create session
+            timeout = aiohttp.ClientTimeout(total=self.config.timeout)
+            headers = {"User-Agent": self.config.user_agent}
+            
+            self.session = aiohttp.ClientSession(
+                connector=connector,
+                timeout=timeout,
+                headers=headers
+            )
+            
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"HTTP manager initialization failed: {e}")
+            return False
+    
+    async def _shutdown(self):
+        """Shutdown HTTP session."""
+        if self.session:
+            await self.session.close()
+            self.session = None
+    
+    async def get(self, url: str, **kwargs) -> aiohttp.ClientResponse:
+        """Make GET request."""
+        if not self.session:
+            raise RuntimeError("HTTP manager not initialized")
+        
+        start_time = asyncio.get_event_loop().time()
+        success = False
+        
+        try:
+            response = await self.session.get(url, **kwargs)
+            success = True
+            return response
+        finally:
+            duration = asyncio.get_event_loop().time() - start_time
+            self.stats.record_operation(success, duration)
+    
+    async def post(self, url: str, **kwargs) -> aiohttp.ClientResponse:
+        """Make POST request."""
+        if not self.session:
+            raise RuntimeError("HTTP manager not initialized")
+        
+        start_time = asyncio.get_event_loop().time()
+        success = False
+        
+        try:
+            response = await self.session.post(url, **kwargs)
+            success = True
+            return response
+        finally:
+            duration = asyncio.get_event_loop().time() - start_time
+            self.stats.record_operation(success, duration)
+    
+    async def request(self, method: str, url: str, **kwargs) -> aiohttp.ClientResponse:
+        """Make generic request."""
+        if not self.session:
+            raise RuntimeError("HTTP manager not initialized")
+        
+        start_time = asyncio.get_event_loop().time()
+        success = False
+        
+        try:
+            response = await self.session.request(method, url, **kwargs)
+            success = True
+            return response
+        finally:
+            duration = asyncio.get_event_loop().time() - start_time
+            self.stats.record_operation(success, duration)

unrealon_driver/managers/logger.py

@@ -0,0 +1,286 @@
+"""
+Clean logger manager with RPC batching and local fallback.
+"""
+
+import asyncio
+import logging
+import logging.handlers
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+from pathlib import Path
+from collections import deque
+
+from pydantic import BaseModel, Field
+
+from unrealon_core.models.logging import LogEntryData, LogContext
+from unrealon_core.models.websocket.logging import LogBatchMessage, LogBatchData
+from unrealon_driver.utils.time import utc_now
+from .base import BaseManager, ManagerConfig
+
+logger = logging.getLogger(__name__)
+
+
+class LoggerManagerConfig(ManagerConfig):
+    """Logger manager configuration."""
+    
+    # Local logging
+    log_file: Optional[str] = Field(default=None, description="Local log file path")
+    max_file_size: int = Field(default=10485760, description="Max log file size (10MB)")
+    backup_count: int = Field(default=5, description="Number of backup files")
+    
+    # RPC batching
+    batch_size: int = Field(default=10, description="Logs per batch")
+    batch_timeout: float = Field(default=5.0, description="Max batch wait time")
+    
+    # Driver info
+    driver_id: str = Field(..., description="Driver ID for logs")
+
+
+class LoggerManager(BaseManager):
+    """
+    Clean logger manager.
+    
+    Features:
+    - Local file logging (always works)
+    - RPC batching to server (when available)
+    - Automatic fallback on RPC failure
+    - Clean batch processing
+    """
+    
+    def __init__(self, config: LoggerManagerConfig, websocket_client=None):
+        super().__init__(config, "logger")
+        self.config: LoggerManagerConfig = config
+        self.websocket_client = websocket_client
+        
+        # Local logger setup
+        self.local_logger = logging.getLogger(f"driver.{config.driver_id}")
+        self._setup_local_logging()
+        
+        # RPC batching
+        self._log_batch: deque = deque()
+        self._batch_lock = asyncio.Lock()
+        self._batch_task: Optional[asyncio.Task] = None
+        self._running = False
+    
+    def _setup_local_logging(self):
+        """Setup local file logging."""
+        if not self.config.log_file:
+            return
+        
+        try:
+            # Create log directory if needed
+            log_path = Path(self.config.log_file)
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Setup rotating file handler
+            handler = logging.handlers.RotatingFileHandler(
+                self.config.log_file,
+                maxBytes=self.config.max_file_size,
+                backupCount=self.config.backup_count
+            )
+            
+            # Set format
+            formatter = logging.Formatter(
+                '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+            )
+            handler.setFormatter(formatter)
+            
+            # Add to logger
+            self.local_logger.addHandler(handler)
+            self.local_logger.setLevel(getattr(logging, self.config.log_level))
+            
+        except Exception as e:
+            logger.error(f"Failed to setup local logging: {e}")
+    
+    async def _initialize(self) -> bool:
+        """Initialize logger manager."""
+        try:
+            # Start batch processor
+            self._running = True
+            self._batch_task = asyncio.create_task(self._batch_processor())
+            
+            logger.info("Logger manager initialized")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Logger manager initialization failed: {e}")
+            return False
+    
+    async def _shutdown(self):
+        """Shutdown logger manager."""
+        try:
+            # Stop batch processor
+            self._running = False
+            
+            if self._batch_task and not self._batch_task.done():
+                self._batch_task.cancel()
+                try:
+                    await self._batch_task
+                except asyncio.CancelledError:
+                    pass
+            
+            # Send remaining logs
+            if self._log_batch:
+                await self._send_batch()
+            
+            logger.info("Logger manager shutdown complete")
+            
+        except Exception as e:
+            logger.error(f"Logger manager shutdown error: {e}")
+    
+    async def _batch_processor(self):
+        """Background task to process log batches."""
+        while self._running:
+            try:
+                # Wait for batch timeout or until we have enough logs
+                await asyncio.sleep(self.config.batch_timeout)
+                
+                async with self._batch_lock:
+                    if len(self._log_batch) >= self.config.batch_size:
+                        await self._send_batch()
+                
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Batch processor error: {e}")
+                await asyncio.sleep(1.0)
+    
+    async def _send_batch(self):
+        """Send current batch via RPC."""
+        if not self._log_batch or not self.websocket_client:
+            return
+        
+        try:
+            # Get logs from batch
+            logs_to_send = []
+            while self._log_batch and len(logs_to_send) < self.config.batch_size:
+                logs_to_send.append(self._log_batch.popleft())
+            
+            if not logs_to_send:
+                return
+            
+            # Create batch message
+            batch_data = LogBatchData(
+                driver_id=self.config.driver_id,
+                logs=logs_to_send,
+                batch_timestamp=utc_now().isoformat()
+            )
+            batch_message = LogBatchMessage(data=batch_data)
+            
+            # Send via WebSocket
+            self.websocket_client.send(batch_message)
+            
+            # Update stats
+            self.stats.record_operation(True, 0.0)
+            
+        except Exception as e:
+            logger.error(f"Failed to send log batch: {e}")
+            # Put logs back in batch for retry
+            for log_entry in reversed(logs_to_send):
+                self._log_batch.appendleft(log_entry)
+            
+            self.stats.record_operation(False, 0.0)
+    
+    def log(self, level: str, message: str, context: Optional[Dict[str, Any]] = None):
+        """
+        Log message with both local and RPC.
+        
+        Args:
+            level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+            message: Log message
+            context: Additional context data
+        """
+        try:
+            # Always log locally first
+            self._log_local(level, message, context)
+            
+            # Add to RPC batch if WebSocket available
+            if self.websocket_client:
+                self._add_to_batch(level, message, context)
+                
+        except Exception as e:
+            logger.error(f"Logging failed: {e}")
+    
+    def _log_local(self, level: str, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log to local file."""
+        try:
+            # Format message with context
+            if context:
+                formatted_message = f"{message} | Context: {context}"
+            else:
+                formatted_message = message
+            
+            # Log at appropriate level
+            log_level = getattr(logging, level.upper(), logging.INFO)
+            self.local_logger.log(log_level, formatted_message)
+            
+        except Exception as e:
+            logger.error(f"Local logging failed: {e}")
+    
+    def _add_to_batch(self, level: str, message: str, context: Optional[Dict[str, Any]] = None):
+        """Add log to RPC batch."""
+        try:
+            # Create log entry
+            log_context = LogContext()  # Use default empty context
+            
+            log_entry = LogEntryData(
+                timestamp=utc_now().isoformat(),
+                level=level.upper(),
+                message=message,
+                driver_id=self.config.driver_id,
+                context=log_context
+            )
+            
+            # Add to batch (thread-safe) - only if event loop is running
+            try:
+                loop = asyncio.get_running_loop()
+                loop.create_task(self._add_to_batch_async(log_entry))
+            except RuntimeError:
+                # No running event loop - add directly to batch
+                self._log_batch.append(log_entry)
+            
+        except Exception as e:
+            logger.error(f"Failed to add log to batch: {e}")
+    
+    async def _add_to_batch_async(self, log_entry: LogEntryData):
+        """Add log entry to batch asynchronously."""
+        try:
+            async with self._batch_lock:
+                self._log_batch.append(log_entry)
+                
+                # Send immediately if batch is full
+                if len(self._log_batch) >= self.config.batch_size:
+                    await self._send_batch()
+                    
+        except Exception as e:
+            logger.error(f"Failed to add log to batch async: {e}")
+    
+    # Convenience methods
+    def debug(self, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log debug message."""
+        self.log("DEBUG", message, context)
+    
+    def info(self, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log info message."""
+        self.log("INFO", message, context)
+    
+    def warning(self, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log warning message."""
+        self.log("WARNING", message, context)
+    
+    def error(self, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log error message."""
+        self.log("ERROR", message, context)
+    
+    def critical(self, message: str, context: Optional[Dict[str, Any]] = None):
+        """Log critical message."""
+        self.log("CRITICAL", message, context)
+    
+    async def _health_check(self) -> Dict[str, Any]:
+        """Health check for logger."""
+        return {
+            "status": "ok",
+            "batch_size": len(self._log_batch),
+            "local_logging": self.config.log_file is not None,
+            "rpc_logging": self.websocket_client is not None
+        }

unrealon_driver/managers/proxy.py

@@ -0,0 +1,99 @@
+"""
+Clean proxy manager.
+"""
+
+import asyncio
+import random
+from typing import List, Optional, Dict, Any
+from pydantic import Field
+
+from .base import BaseManager, ManagerConfig
+
+
+class ProxyManagerConfig(ManagerConfig):
+    """Proxy manager configuration."""
+    proxies: List[str] = Field(default_factory=list, description="List of proxy URLs")
+    rotation_interval: int = Field(default=300, description="Rotation interval seconds")
+    health_check_interval: int = Field(default=60, description="Health check interval")
+
+
+class ProxyManager(BaseManager):
+    """Simple proxy rotation manager."""
+    
+    def __init__(self, config: ProxyManagerConfig):
+        super().__init__(config, "proxy")
+        self.config: ProxyManagerConfig = config
+        self.active_proxies: List[str] = []
+        self.current_proxy: Optional[str] = None
+        self._rotation_task: Optional[asyncio.Task] = None
+    
+    async def _initialize(self) -> bool:
+        """Initialize proxy manager."""
+        self.active_proxies = self.config.proxies.copy()
+        
+        if self.active_proxies:
+            self.current_proxy = random.choice(self.active_proxies)
+            # Start rotation task
+            self._rotation_task = asyncio.create_task(self._rotation_loop())
+        
+        return True
+    
+    async def _shutdown(self):
+        """Shutdown proxy manager."""
+        if self._rotation_task:
+            self._rotation_task.cancel()
+            try:
+                await self._rotation_task
+            except asyncio.CancelledError:
+                pass
+    
+    async def _rotation_loop(self):
+        """Background proxy rotation."""
+        while True:
+            try:
+                await asyncio.sleep(self.config.rotation_interval)
+                
+                if self.active_proxies:
+                    old_proxy = self.current_proxy
+                    self.current_proxy = random.choice(self.active_proxies)
+                    
+                    if old_proxy != self.current_proxy:
+                        self.logger.info(f"Rotated proxy: {old_proxy} -> {self.current_proxy}")
+                
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                self.logger.error(f"Proxy rotation error: {e}")
+    
+    def get_proxy(self) -> Optional[str]:
+        """Get current proxy."""
+        return self.current_proxy
+    
+    def get_proxy_dict(self) -> Optional[Dict[str, str]]:
+        """Get proxy as dict for requests."""
+        if not self.current_proxy:
+            return None
+        
+        return {
+            "http": self.current_proxy,
+            "https": self.current_proxy
+        }
+    
+    def mark_proxy_bad(self, proxy: str):
+        """Mark proxy as bad and remove from rotation."""
+        if proxy in self.active_proxies:
+            self.active_proxies.remove(proxy)
+            self.logger.warning(f"Removed bad proxy: {proxy}")
+            
+            # Switch to new proxy if current is bad
+            if proxy == self.current_proxy and self.active_proxies:
+                self.current_proxy = random.choice(self.active_proxies)
+    
+    async def _health_check(self) -> Dict[str, Any]:
+        """Proxy health check."""
+        return {
+            "status": "ok",
+            "current_proxy": self.current_proxy,
+            "active_proxies": len(self.active_proxies),
+            "total_proxies": len(self.config.proxies)
+        }

unrealon_driver/managers/registry.py

@@ -0,0 +1,87 @@
+"""
+Clean manager registry.
+"""
+
+import asyncio
+from typing import Dict, List, Any, Optional
+from .base import BaseManager
+
+
+class ManagerRegistry:
+    """
+    Clean registry for managing all driver managers.
+    
+    Provides centralized lifecycle management and health monitoring.
+    """
+    
+    def __init__(self):
+        self.managers: Dict[str, BaseManager] = {}
+        self._initialized = False
+    
+    def register(self, manager: BaseManager):
+        """Register a manager."""
+        self.managers[manager.name] = manager
+    
+    def get(self, name: str) -> Optional[BaseManager]:
+        """Get manager by name."""
+        return self.managers.get(name)
+    
+    async def initialize_all(self) -> bool:
+        """Initialize all registered managers."""
+        if self._initialized:
+            return True
+        
+        success_count = 0
+        
+        for name, manager in self.managers.items():
+            try:
+                if await manager.initialize():
+                    success_count += 1
+                else:
+                    print(f"Manager {name} initialization failed")
+            except Exception as e:
+                print(f"Manager {name} initialization error: {e}")
+        
+        self._initialized = success_count == len(self.managers)
+        return self._initialized
+    
+    async def shutdown_all(self):
+        """Shutdown all managers."""
+        for name, manager in self.managers.items():
+            try:
+                await manager.shutdown()
+            except Exception as e:
+                print(f"Manager {name} shutdown error: {e}")
+        
+        self._initialized = False
+    
+    async def health_check_all(self) -> Dict[str, Any]:
+        """Get health status of all managers."""
+        health_data = {}
+        
+        for name, manager in self.managers.items():
+            try:
+                health_data[name] = await manager.health_check()
+            except Exception as e:
+                health_data[name] = {
+                    "name": name,
+                    "status": "error",
+                    "error": str(e)
+                }
+        
+        return {
+            "managers": health_data,
+            "total": len(self.managers),
+            "initialized": self._initialized
+        }
+    
+    def get_ready_managers(self) -> List[str]:
+        """Get list of ready manager names."""
+        return [
+            name for name, manager in self.managers.items()
+            if manager.is_ready()
+        ]
+    
+    def is_all_ready(self) -> bool:
+        """Check if all managers are ready."""
+        return all(manager.is_ready() for manager in self.managers.values())