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

unrealon_driver/managers/threading.py

@@ -0,0 +1,54 @@
+"""
+Clean threading manager.
+"""
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Callable, Optional, Dict
+from pydantic import Field
+
+from .base import BaseManager, ManagerConfig
+
+
+class ThreadManagerConfig(ManagerConfig):
+    """Thread manager configuration."""
+    max_workers: int = Field(default=4, description="Max thread workers")
+
+
+class ThreadManager(BaseManager):
+    """Simple thread pool manager."""
+    
+    def __init__(self, config: ThreadManagerConfig):
+        super().__init__(config, "threading")
+        self.config: ThreadManagerConfig = config
+        self.executor: Optional[ThreadPoolExecutor] = None
+    
+    async def _initialize(self) -> bool:
+        """Initialize thread pool."""
+        self.executor = ThreadPoolExecutor(
+            max_workers=self.config.max_workers,
+            thread_name_prefix="unrealon-driver"
+        )
+        return True
+    
+    async def _shutdown(self):
+        """Shutdown thread pool."""
+        if self.executor:
+            self.executor.shutdown(wait=True)
+            self.executor = None
+    
+    async def run_in_thread(self, func: Callable, *args, **kwargs) -> Any:
+        """Run function in thread pool."""
+        if not self.executor:
+            raise RuntimeError("Thread manager not initialized")
+        
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(self.executor, func, *args, **kwargs)
+    
+    async def _health_check(self) -> Dict[str, Any]:
+        """Thread manager health check."""
+        return {
+            "status": "ok",
+            "max_workers": self.config.max_workers,
+            "active": self.executor is not None
+        }

unrealon_driver/managers/update.py

@@ -0,0 +1,107 @@
+"""
+Clean update manager for driver updates.
+"""
+
+import asyncio
+from typing import Dict, Any, Optional
+from pydantic import Field
+
+from .base import BaseManager, ManagerConfig
+
+
+class UpdateManagerConfig(ManagerConfig):
+    """Update manager configuration."""
+    check_interval: int = Field(default=3600, description="Update check interval seconds")
+    auto_update: bool = Field(default=False, description="Enable auto updates")
+    update_url: Optional[str] = Field(default=None, description="Update server URL")
+
+
+class UpdateManager(BaseManager):
+    """Simple update manager."""
+    
+    def __init__(self, config: UpdateManagerConfig):
+        super().__init__(config, "update")
+        self.config: UpdateManagerConfig = config
+        self._check_task: Optional[asyncio.Task] = None
+        self.last_check: Optional[str] = None
+        self.update_available: bool = False
+    
+    async def _initialize(self) -> bool:
+        """Initialize update manager."""
+        if self.config.update_url:
+            # Start update check task
+            self._check_task = asyncio.create_task(self._update_check_loop())
+        
+        return True
+    
+    async def _shutdown(self):
+        """Shutdown update manager."""
+        if self._check_task:
+            self._check_task.cancel()
+            try:
+                await self._check_task
+            except asyncio.CancelledError:
+                pass
+    
+    async def _update_check_loop(self):
+        """Background update checking."""
+        while True:
+            try:
+                await asyncio.sleep(self.config.check_interval)
+                await self.check_for_updates()
+                
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                self.logger.error(f"Update check error: {e}")
+    
+    async def check_for_updates(self) -> bool:
+        """Check for available updates."""
+        try:
+            # Placeholder for actual update checking logic
+            self.logger.info("Checking for updates...")
+            
+            # TODO: Implement actual update checking
+            # This would typically involve:
+            # 1. Fetching version info from update server
+            # 2. Comparing with current version
+            # 3. Setting update_available flag
+            
+            self.last_check = "checked"
+            return False
+            
+        except Exception as e:
+            self.logger.error(f"Update check failed: {e}")
+            return False
+    
+    async def perform_update(self) -> bool:
+        """Perform driver update."""
+        try:
+            if not self.update_available:
+                self.logger.info("No updates available")
+                return False
+            
+            # Placeholder for actual update logic
+            self.logger.info("Performing update...")
+            
+            # TODO: Implement actual update process
+            # This would typically involve:
+            # 1. Downloading new version
+            # 2. Validating download
+            # 3. Installing update
+            # 4. Restarting driver
+            
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Update failed: {e}")
+            return False
+    
+    async def _health_check(self) -> Dict[str, Any]:
+        """Update manager health check."""
+        return {
+            "status": "ok",
+            "last_check": self.last_check,
+            "update_available": self.update_available,
+            "auto_update": self.config.auto_update
+        }

unrealon_driver/utils/__init__.py

@@ -0,0 +1,9 @@
+"""
+Utility functions for UnrealOn Driver.
+"""
+
+from .time import utc_now
+
+__all__ = [
+    "utc_now",
+]

unrealon_driver/utils/time.py

@@ -0,0 +1,10 @@
+"""
+Time utilities for UnrealOn Driver.
+"""
+
+from datetime import datetime, timezone
+
+
+def utc_now() -> datetime:
+    """Get current UTC time."""
+    return datetime.now(timezone.utc)