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

unrealon_core/utils/__init__.py

@@ -0,0 +1,11 @@
+"""
+Utility functions for UnrealOn Core.
+"""
+
+from .time import utc_now, utc_timestamp, datetime_to_iso
+
+__all__ = [
+    "utc_now",
+    "utc_timestamp", 
+    "datetime_to_iso",
+]

unrealon_core/utils/time.py

@@ -0,0 +1,61 @@
+"""
+Time utilities for UnrealOn.
+
+Provides timezone-aware datetime functions to replace deprecated datetime.utc_now().
+"""
+
+from datetime import datetime, timezone
+from typing import Optional
+
+
+def utc_now() -> datetime:
+    """
+    Get current UTC time as timezone-aware datetime.
+    
+    Replacement for deprecated datetime.utc_now().
+    
+    Returns:
+        datetime: Current UTC time with timezone info
+    """
+    return datetime.now(timezone.utc)
+
+
+def utc_timestamp() -> str:
+    """
+    Get current UTC time as ISO format string.
+    
+    Returns:
+        str: Current UTC time in ISO format
+    """
+    return utc_now().isoformat()
+
+
+def datetime_to_iso(dt: Optional[datetime]) -> Optional[str]:
+    """
+    Convert datetime to ISO format string.
+    
+    Args:
+        dt: Datetime to convert (can be None)
+        
+    Returns:
+        str or None: ISO format string or None if input was None
+    """
+    if dt is None:
+        return None
+    return dt.isoformat()
+
+
+def ensure_utc(dt: datetime) -> datetime:
+    """
+    Ensure datetime is timezone-aware and in UTC.
+    
+    Args:
+        dt: Datetime to convert
+        
+    Returns:
+        datetime: UTC timezone-aware datetime
+    """
+    if dt.tzinfo is None:
+        # Assume naive datetime is UTC
+        return dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc)

unrealon_core/version.py

@@ -0,0 +1,219 @@
+"""
+🔄 UnrealOn Version Management
+
+Unified version system for all UnrealOn packages.
+This ensures version synchronization between driver, RPC server, and core components.
+"""
+
+import tomlkit
+from typing import Dict, Any
+from pathlib import Path
+from unrealon_core.utils.time import utc_timestamp
+
+
+def _get_version_from_pyproject() -> str:
+    """Get version from main pyproject.toml."""
+    try:
+        # Go up from unrealon-core/src/unrealon_core to project root
+        project_root = Path(__file__).parent.parent.parent.parent
+        pyproject_path = project_root / "pyproject.toml"
+        
+        if pyproject_path.exists():
+            with open(pyproject_path, "r") as f:
+                pyproject = tomlkit.parse(f.read())
+            
+            # Try PEP 621 format first
+            if "project" in pyproject and "version" in pyproject["project"]:
+                return str(pyproject["project"]["version"])
+            # Fallback to Poetry format
+            elif "tool" in pyproject and "poetry" in pyproject["tool"] and "version" in pyproject["tool"]["poetry"]:
+                return str(pyproject["tool"]["poetry"]["version"])
+    except Exception:
+        pass
+    
+    # Fallback version if can't read from pyproject.toml
+    return "2.0.0"
+
+
+# 🎯 UNIFIED VERSION - Automatically synced from main pyproject.toml
+__version__ = _get_version_from_pyproject()
+
+# 📅 Release Information
+__release_date__ = "2024-12-19"
+__build_number__ = "20241219001"
+
+# 🏷️ Version Components
+VERSION_MAJOR = 4
+VERSION_MINOR = 0
+VERSION_PATCH = 0
+VERSION_BUILD = "stable"
+
+# 🔧 Package Compatibility Matrix
+COMPATIBILITY_MATRIX = {
+    "unrealon_core": __version__,
+    "unrealon_rpc": __version__,
+    "unrealon_driver": __version__,
+    "unrealon_browser": __version__
+}
+
+# 📊 Version Metadata
+VERSION_INFO = {
+    "version": __version__,
+    "major": VERSION_MAJOR,
+    "minor": VERSION_MINOR,
+    "patch": VERSION_PATCH,
+    "build": VERSION_BUILD,
+    "release_date": __release_date__,
+    "build_number": __build_number__,
+    "compatibility": COMPATIBILITY_MATRIX
+}
+
+
+def get_version() -> str:
+    """
+    Get the current UnrealOn version.
+    
+    Returns:
+        str: Version string (e.g., "4.0.0")
+    """
+    return __version__
+
+
+def get_version_info() -> Dict[str, Any]:
+    """
+    Get detailed version information.
+    
+    Returns:
+        Dict[str, Any]: Complete version metadata
+    """
+    return VERSION_INFO.copy()
+
+
+def get_build_info() -> Dict[str, Any]:
+    """
+    Get build information.
+    
+    Returns:
+        Dict[str, Any]: Build metadata
+    """
+    return {
+        "version": __version__,
+        "build_number": __build_number__,
+        "release_date": __release_date__,
+        "build_type": VERSION_BUILD,
+        "timestamp": utc_timestamp()
+    }
+
+
+def is_compatible_version(other_version: str) -> bool:
+    """
+    Check if another version is compatible with current version.
+    
+    Args:
+        other_version: Version string to check
+        
+    Returns:
+        bool: True if versions are compatible
+    """
+    try:
+        # For now, require exact match for stability
+        return other_version == __version__
+    except Exception:
+        return False
+
+
+def get_compatibility_status(package_versions: Dict[str, str]) -> Dict[str, Any]:
+    """
+    Check compatibility status of multiple packages.
+    
+    Args:
+        package_versions: Dict of package names to versions
+        
+    Returns:
+        Dict[str, Any]: Compatibility report
+    """
+    compatible_packages = []
+    incompatible_packages = []
+    
+    for package, version in package_versions.items():
+        expected_version = COMPATIBILITY_MATRIX.get(package)
+        if expected_version and version == expected_version:
+            compatible_packages.append(package)
+        else:
+            incompatible_packages.append({
+                "package": package,
+                "current": version,
+                "expected": expected_version
+            })
+    
+    return {
+        "overall_compatible": len(incompatible_packages) == 0,
+        "compatible_packages": compatible_packages,
+        "incompatible_packages": incompatible_packages,
+        "total_packages": len(package_versions),
+        "compatibility_score": len(compatible_packages) / len(package_versions) if package_versions else 1.0
+    }
+
+
+# 🎯 Convenience functions for specific packages
+def get_core_version() -> str:
+    """Get unrealon_core version."""
+    return COMPATIBILITY_MATRIX["unrealon_core"]
+
+
+def get_rpc_version() -> str:
+    """Get unrealon_rpc version."""
+    return COMPATIBILITY_MATRIX["unrealon_rpc"]
+
+
+def get_driver_version() -> str:
+    """Get unrealon_driver version."""
+    return COMPATIBILITY_MATRIX["unrealon_driver"]
+
+
+def get_browser_version() -> str:
+    """Get unrealon_browser version."""
+    return COMPATIBILITY_MATRIX["unrealon_browser"]
+
+
+# 🔍 Version validation
+def validate_version_format(version: str) -> bool:
+    """
+    Validate version string format.
+    
+    Args:
+        version: Version string to validate
+        
+    Returns:
+        bool: True if format is valid
+    """
+    try:
+        parts = version.split(".")
+        if len(parts) != 3:
+            return False
+        
+        # Check if all parts are integers
+        for part in parts:
+            int(part)
+        
+        return True
+    except (ValueError, AttributeError):
+        return False
+
+
+# 📋 Export all version functions
+__all__ = [
+    "__version__",
+    "VERSION_INFO",
+    "COMPATIBILITY_MATRIX",
+    "get_version",
+    "get_version_info", 
+    "get_build_info",
+    "is_compatible_version",
+    "get_compatibility_status",
+    "get_core_version",
+    "get_rpc_version", 
+    "get_driver_version",
+    "get_browser_version",
+    "validate_version_format"
+]

unrealon_driver/__init__.py

@@ -1,66 +1,105 @@
 """
-🚀 UnrealOn Driver v4.0 - Modern Parser Framework
+UnrealOn Driver SDK - Refactored
 
-Revolutionary parser framework with specialized managers and zero configuration.
-Built on unrealon-rpc bridge with full Pydantic v2 compliance.
+Clean, simple, powerful API for parser development.
+Simplified architecture with all original functionality.
 
 Key Features:
-- 🎯 Zero Configuration: Everything works out of the box
-- 🏗️ Manager Architecture: Specialized managers for different concerns
-- 🌐 Smart Browser: Intelligent automation with stealth
-- 🧹 HTML Cleaning: Optimized for LLM analysis
-- 🔌 Bridge Integration: Built on unrealon-rpc bridge
-- 📊 Built-in Monitoring: Enterprise observability
-- 🛡️ Type Safety: Full Pydantic v2 compliance
+- UniversalDriver - Simple unified API
+- All managers integrated cleanly
+- WebSocket communication with RPC
+- Module system for extensibility
+- Clean decorator system
+- No complex inheritance chains
 """
 
-try:
-    from importlib.metadata import version
+# Version info
+from unrealon_core.version import get_driver_version
 
-    __version__ = version("unrealon-driver")
-except Exception:
-    __version__ = "1.0.0-dev"
+# Core API - Simple and clean
+from .driver import (
+    UniversalDriver,
+    DriverConfig,
+    DriverMode
+)
+
+from .driver.communication import (
+    DriverSession,
+    WebSocketClient
+)
+
+# Managers - Clean resource management
+from .managers import (
+    LoggerManager,
+    HttpManager,
+    BrowserManager,
+    CacheManager,
+    ProxyManager,
+    ThreadManager,
+    UpdateManager,
+    ManagerRegistry
+)
 
+# Module system - Extensible architecture
+from .core_module import (
+    BaseModule,
+    DriverModule,
+    ModuleConfig,
+    EventManager,
+    ModuleRegistry,
+    ModuleStatus,
+    EventType,
+    HealthStatus
+)
 
-from .parser import (
-    ParserManager,
-    ParserManagerConfig,
-    ParserStats,
-    get_parser_manager,
-    quick_parse,
-    ConfigManager,
-    ParserConfig,
-    ResultManager,
-    ParseResult,
-    ParseMetrics,
-    ErrorManager,
-    RetryConfig,
-    ErrorInfo,
+# Decorators - Clean task management
+from .decorators import (
+    task,
+    retry,
+    schedule,
+    timing
 )
-from .exceptions import ParserError, BrowserError
+
+__version__ = get_driver_version()
+__author__ = "UnrealOn Team"
+__phase__ = "Phase 3.8: Clean Refactor"
 
 __all__ = [
-    "__version__",
-    # Main Parser Manager
-    "ParserManager",
-    "ParserManagerConfig",
-    "ParserStats",
-    "get_parser_manager",
-    "quick_parse",
-    # Individual Managers
-    "ConfigManager",
-    "ParserConfig",
-    "ResultManager",
-    "ParseResult",
-    "ParseMetrics",
-    "ErrorManager",
-    "RetryConfig",
-    "ErrorInfo",
-    # Exceptions
-    "ParserError",
-    "BrowserError",
     # Version
     "__version__",
+    "__author__", 
+    "__phase__",
+    
+    # Core API
+    "UniversalDriver",
+    "DriverConfig",
+    "DriverMode", 
+    "DriverSession",
+    "WebSocketClient",
+    
+    # Managers
+    "LoggerManager",
+    "HttpManager",
+    "BrowserManager", 
+    "CacheManager",
+    "ProxyManager",
+    "ThreadManager",
+    "UpdateManager",
+    "ManagerRegistry",
+    
+    # Module system
+    "BaseModule",
+    "DriverModule",
+    "ModuleConfig",
+    "EventManager",
+    "ModuleRegistry",
+    "ModuleStatus",
+    "EventType",
+    "HealthStatus",
+    
+    # Decorators
+    "task",
+    "retry",
+    "schedule", 
+    "timing",
 ]
-# Convenience aliases for backward compatibility
-Parser = ParserManager

unrealon_driver/core_module/__init__.py

@@ -0,0 +1,34 @@
+"""
+Clean module system for UnrealOn Driver.
+"""
+
+from .protocols import (
+    BaseModule,
+    ModuleStatus,
+    EventType,
+    HealthStatus,
+    ModuleEvent,
+    HealthCheckResult
+)
+from .config import ModuleConfig
+from .base import DriverModule
+from .event_manager import EventManager
+from .registry import ModuleRegistry
+
+__all__ = [
+    # Protocols and enums
+    "BaseModule",
+    "ModuleStatus",
+    "EventType", 
+    "HealthStatus",
+    "ModuleEvent",
+    "HealthCheckResult",
+    
+    # Base classes
+    "ModuleConfig",
+    "DriverModule",
+    
+    # System components
+    "EventManager",
+    "ModuleRegistry",
+]

unrealon_driver/core_module/base.py

@@ -0,0 +1,184 @@
+"""
+Clean base module implementation.
+"""
+
+import asyncio
+import logging
+from abc import ABC, abstractmethod
+from typing import Optional, Dict, Any
+
+from .protocols import ModuleStatus, HealthStatus, HealthCheckResult, ModuleEvent, EventType
+from .config import ModuleConfig
+from ..utils.time import utc_now
+
+logger = logging.getLogger(__name__)
+
+
+class DriverModule(ABC):
+    """
+    Clean base module implementation.
+    
+    Provides common functionality for all driver modules.
+    """
+    
+    def __init__(self, config: ModuleConfig, driver_id: str):
+        self.config = config
+        self.driver_id = driver_id
+        self.name = config.module_name
+        self.status = ModuleStatus.UNINITIALIZED
+        self.logger = logging.getLogger(f"{__name__}.{self.name}")
+        
+        # Event system
+        self.event_manager: Optional[Any] = None
+    
+    async def initialize(self) -> bool:
+        """Initialize module."""
+        if not self.config.enabled:
+            self.logger.info(f"Module {self.name} is disabled")
+            self.status = ModuleStatus.STOPPED
+            return True
+        
+        try:
+            self.status = ModuleStatus.INITIALIZING
+            self.logger.info(f"Initializing module: {self.name}")
+            
+            success = await self._initialize()
+            
+            if success:
+                self.status = ModuleStatus.INITIALIZED
+                self.logger.info(f"Module {self.name} initialized successfully")
+                
+                # Emit event
+                await self._emit_event(EventType.MODULE_INITIALIZED)
+            else:
+                self.status = ModuleStatus.ERROR
+                self.logger.error(f"Module {self.name} initialization failed")
+            
+            return success
+            
+        except Exception as e:
+            self.status = ModuleStatus.ERROR
+            self.logger.error(f"Module {self.name} initialization error: {e}")
+            await self._emit_event(EventType.MODULE_ERROR, error=str(e))
+            return False
+    
+    async def start(self) -> bool:
+        """Start module."""
+        if self.status != ModuleStatus.INITIALIZED:
+            self.logger.error(f"Cannot start module {self.name} - not initialized")
+            return False
+        
+        try:
+            self.status = ModuleStatus.STARTING
+            self.logger.info(f"Starting module: {self.name}")
+            
+            success = await self._start()
+            
+            if success:
+                self.status = ModuleStatus.RUNNING
+                self.logger.info(f"Module {self.name} started successfully")
+                
+                # Emit event
+                await self._emit_event(EventType.MODULE_STARTED)
+            else:
+                self.status = ModuleStatus.ERROR
+                self.logger.error(f"Module {self.name} start failed")
+            
+            return success
+            
+        except Exception as e:
+            self.status = ModuleStatus.ERROR
+            self.logger.error(f"Module {self.name} start error: {e}")
+            await self._emit_event(EventType.MODULE_ERROR, error=str(e))
+            return False
+    
+    async def stop(self) -> None:
+        """Stop module."""
+        try:
+            self.status = ModuleStatus.STOPPING
+            self.logger.info(f"Stopping module: {self.name}")
+            
+            await self._stop()
+            
+            self.status = ModuleStatus.STOPPED
+            self.logger.info(f"Module {self.name} stopped successfully")
+            
+            # Emit event
+            await self._emit_event(EventType.MODULE_STOPPED)
+            
+        except Exception as e:
+            self.status = ModuleStatus.ERROR
+            self.logger.error(f"Module {self.name} stop error: {e}")
+            await self._emit_event(EventType.MODULE_ERROR, error=str(e))
+    
+    async def health_check(self) -> HealthCheckResult:
+        """Perform health check."""
+        start_time = asyncio.get_event_loop().time()
+        
+        try:
+            health_data = await self._health_check()
+            
+            response_time = (asyncio.get_event_loop().time() - start_time) * 1000
+            
+            return HealthCheckResult(
+                status=HealthStatus.HEALTHY,
+                timestamp=utc_now(),
+                details=health_data,
+                response_time_ms=response_time
+            )
+            
+        except Exception as e:
+            response_time = (asyncio.get_event_loop().time() - start_time) * 1000
+            
+            return HealthCheckResult(
+                status=HealthStatus.UNHEALTHY,
+                timestamp=utc_now(),
+                error=str(e),
+                response_time_ms=response_time
+            )
+    
+    def set_event_manager(self, event_manager):
+        """Set event manager for event emission."""
+        self.event_manager = event_manager
+    
+    async def _emit_event(self, event_type: EventType, data: Optional[Dict[str, Any]] = None, error: Optional[str] = None):
+        """Emit module event."""
+        if not self.event_manager:
+            return
+        
+        try:
+            event = ModuleEvent(
+                event_type=event_type,
+                module_name=self.name,
+                timestamp=utc_now(),
+                data=data or {},
+                error=error
+            )
+            
+            await self.event_manager.emit(event)
+            
+        except Exception as e:
+            self.logger.error(f"Failed to emit event: {e}")
+    
+    @abstractmethod
+    async def _initialize(self) -> bool:
+        """Module-specific initialization."""
+        pass
+    
+    @abstractmethod
+    async def _start(self) -> bool:
+        """Module-specific start logic."""
+        pass
+    
+    @abstractmethod
+    async def _stop(self) -> None:
+        """Module-specific stop logic."""
+        pass
+    
+    async def _health_check(self) -> Dict[str, Any]:
+        """Module-specific health check."""
+        return {
+            "status": "ok",
+            "module": self.name,
+            "version": self.config.version
+        }

unrealon_driver/core_module/config.py

@@ -0,0 +1,30 @@
+"""
+Clean module configuration.
+"""
+
+from typing import Optional, Dict, Any
+from pydantic import BaseModel, Field
+
+
+class ModuleConfig(BaseModel):
+    """Base configuration for all modules."""
+    
+    # Module identification
+    module_name: str = Field(..., description="Unique module name")
+    version: str = Field(default="1.0.0", description="Module version")
+    
+    # Module behavior
+    enabled: bool = Field(default=True, description="Whether module is enabled")
+    auto_start: bool = Field(default=True, description="Auto-start on driver init")
+    
+    # Performance
+    timeout_seconds: float = Field(default=30.0, description="Operation timeout")
+    retry_count: int = Field(default=3, description="Retry attempts")
+    
+    # Health checks
+    health_check_interval: int = Field(default=60, description="Health check interval")
+    
+    # Custom settings
+    custom_settings: Dict[str, Any] = Field(default_factory=dict, description="Module-specific settings")
+    
+    model_config = {"extra": "forbid"}