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

unrealon_browser/managers/page_wait_manager.py

@@ -0,0 +1,198 @@
+"""
+Page Wait Manager - Convenient methods for different page loading scenarios
+"""
+import asyncio
+from typing import Optional
+from playwright.async_api import Page
+
+from .logger_bridge import BrowserLoggerBridge as LoggingBridge
+
+
+class PageWaitManager:
+    """Manager for different page waiting strategies"""
+    
+    def __init__(self, page: Optional[Page], logger_bridge: LoggingBridge):
+        self._page = page
+        self.logger_bridge = logger_bridge
+    
+    def update_page(self, page: Optional[Page]):
+        """Update the page reference"""
+        self._page = page
+    
+    # Quick wait methods with fallback
+    async def wait_fast_with_fallback(self) -> bool:
+        """Fast wait - networkidle 5s, fallback to domcontentloaded 3s"""
+        if not self._page:
+            return False
+            
+        self.logger_bridge.log_info("🚀 Fast wait with fallback (networkidle 5s → domcontentloaded 3s)")
+        
+        # Try networkidle first
+        if await self._wait_for_state("networkidle", 5000):
+            return True
+            
+        # Fallback to domcontentloaded
+        self.logger_bridge.log_info("⏳ Networkidle timeout, trying domcontentloaded...")
+        return await self._wait_for_state("domcontentloaded", 3000)
+    
+    async def wait_safe_with_fallback(self) -> bool:
+        """Safe wait - networkidle 10s, fallback to domcontentloaded 5s"""
+        if not self._page:
+            return False
+            
+        self.logger_bridge.log_info("🛡️ Safe wait with fallback (networkidle 10s → domcontentloaded 5s)")
+        
+        # Try networkidle first
+        if await self._wait_for_state("networkidle", 10000):
+            return True
+            
+        # Fallback to domcontentloaded
+        self.logger_bridge.log_info("⏳ Networkidle timeout, trying domcontentloaded...")
+        return await self._wait_for_state("domcontentloaded", 5000)
+    
+    # Generic methods
+    async def wait_fast(self) -> bool:
+        """Fast wait - domcontentloaded 3s"""
+        if not self._page:
+            return False
+            
+        self.logger_bridge.log_info("⚡ Fast wait (domcontentloaded 3s)")
+        return await self._wait_for_state("domcontentloaded", 3000)
+    
+    async def wait_standard(self) -> bool:
+        """Standard wait - networkidle 10s"""
+        if not self._page:
+            return False
+            
+        self.logger_bridge.log_info("⏳ Standard wait (networkidle 10s)")
+        return await self._wait_for_state("networkidle", 10000)
+    
+    async def wait_full_load(self) -> bool:
+        """Full page load including images - load 30s"""
+        if not self._page:
+            return False
+            
+        self.logger_bridge.log_info("🖼️ Full load wait (load 30s)")
+        return await self._wait_for_state("load", 30000)
+    
+    async def wait_minimal(self) -> bool:
+        """Minimal wait - domcontentloaded 1s"""
+        if not self._page:
+            return False
+            
+        self.logger_bridge.log_info("⚡ Minimal wait (domcontentloaded 1s)")
+        return await self._wait_for_state("domcontentloaded", 1000)
+    
+    # Specialized methods
+    async def wait_spa(self) -> bool:
+        """Single Page Application wait - networkidle 15s"""
+        if not self._page:
+            return False
+            
+        self.logger_bridge.log_info("⚛️ SPA wait (networkidle 15s)")
+        return await self._wait_for_state("networkidle", 15000)
+    
+    # Custom methods
+    async def wait_custom(self, wait_type: str = "networkidle", timeout: int = 10000) -> bool:
+        """Custom wait with specified parameters"""
+        if not self._page:
+            return False
+            
+        self.logger_bridge.log_info(f"🔧 Custom wait ({wait_type} {timeout}ms)")
+        return await self._wait_for_state(wait_type, timeout)
+    
+    async def wait_with_fallback(self, 
+                                primary_type: str = "networkidle", 
+                                primary_timeout: int = 10000,
+                                fallback_type: str = "domcontentloaded", 
+                                fallback_timeout: int = 5000) -> bool:
+        """Wait with custom fallback strategy"""
+        if not self._page:
+            return False
+            
+        self.logger_bridge.log_info(f"🔄 Fallback wait ({primary_type} {primary_timeout}ms → {fallback_type} {fallback_timeout}ms)")
+        
+        # Try primary first
+        if await self._wait_for_state(primary_type, primary_timeout):
+            return True
+            
+        # Fallback
+        self.logger_bridge.log_info(f"⏳ {primary_type} timeout, trying {fallback_type}...")
+        return await self._wait_for_state(fallback_type, fallback_timeout)
+    
+    # Helper methods
+    async def _wait_for_state(self, wait_type: str, timeout: int) -> bool:
+        """Internal method to wait for specific state"""
+        if not self._page:
+            return False
+            
+        try:
+            if wait_type == "networkidle":
+                await self._page.wait_for_load_state("networkidle", timeout=timeout)
+            elif wait_type == "domcontentloaded":
+                await self._page.wait_for_load_state("domcontentloaded", timeout=timeout)
+            elif wait_type == "load":
+                await self._page.wait_for_load_state("load", timeout=timeout)
+            else:
+                # Default to networkidle
+                await self._page.wait_for_load_state("networkidle", timeout=timeout)
+            
+            self.logger_bridge.log_info(f"✅ Page ready ({wait_type})")
+            return True
+            
+        except Exception as e:
+            self.logger_bridge.log_warning(f"⚠️ Page ready timeout ({wait_type}): {e}")
+            return False
+    
+    # Utility methods
+    async def wait_for_selector(self, selector: str, timeout: int = 10000) -> bool:
+        """Wait for specific selector to appear"""
+        if not self._page:
+            return False
+            
+        try:
+            self.logger_bridge.log_info(f"🎯 Waiting for selector: {selector}")
+            await self._page.wait_for_selector(selector, timeout=timeout)
+            self.logger_bridge.log_info(f"✅ Selector found: {selector}")
+            return True
+        except Exception as e:
+            self.logger_bridge.log_warning(f"⚠️ Selector timeout: {selector} - {e}")
+            return False
+    
+    async def wait_for_text(self, text: str, timeout: int = 10000) -> bool:
+        """Wait for specific text to appear on page"""
+        if not self._page:
+            return False
+            
+        try:
+            self.logger_bridge.log_info(f"📝 Waiting for text: {text}")
+            await self._page.wait_for_function(
+                f"document.body.innerText.includes('{text}')",
+                timeout=timeout
+            )
+            self.logger_bridge.log_info(f"✅ Text found: {text}")
+            return True
+        except Exception as e:
+            self.logger_bridge.log_warning(f"⚠️ Text timeout: {text} - {e}")
+            return False
+    
+    async def wait_for_url_change(self, timeout: int = 10000) -> bool:
+        """Wait for URL to change"""
+        if not self._page:
+            return False
+            
+        try:
+            current_url = self._page.url
+            self.logger_bridge.log_info(f"🔗 Waiting for URL change from: {current_url}")
+            
+            await self._page.wait_for_function(
+                f"window.location.href !== '{current_url}'",
+                timeout=timeout
+            )
+            
+            new_url = self._page.url
+            self.logger_bridge.log_info(f"✅ URL changed to: {new_url}")
+            return True
+        except Exception as e:
+            self.logger_bridge.log_warning(f"⚠️ URL change timeout: {e}")
+            return False

unrealon_browser/stealth/__init__.py

@@ -0,0 +1,27 @@
+"""
+UnrealOn Stealth Package - Advanced anti-detection system
+
+Modular bot detection bypass system:
+- PlaywrightStealth: playwright-stealth integration
+- UndetectedChrome: undetected-chromedriver support  
+- NoDriverStealth: NoDriver integration
+- BypassTechniques: advanced BotD bypass techniques
+- StealthManager: main coordinator for all techniques
+- ScannerTester: real-world testing through UnrealOn scanner
+"""
+
+from .manager import StealthManager
+from .playwright_stealth import PlaywrightStealth
+from .undetected_chrome import UndetectedChrome
+from .nodriver_stealth import NoDriverStealth
+from .bypass_techniques import BypassTechniques
+from .scanner_tester import ScannerTester
+
+__all__ = [
+    "StealthManager",
+    "PlaywrightStealth", 
+    "UndetectedChrome",
+    "NoDriverStealth",
+    "BypassTechniques",
+    "ScannerTester"
+]

unrealon_core/__init__.py

@@ -0,0 +1,160 @@
+"""
+UnrealOn Core Package
+
+Core models, enums, and exceptions for the UnrealOn RPC system.
+This package provides the foundational data structures and utilities
+used across all UnrealOn components.
+
+Phase 1: Bedrock Foundation
+- Base Pydantic models with strict validation
+- Core enums and constants
+- Custom exceptions hierarchy
+- 100% test coverage required
+"""
+
+# Import unified version system
+from unrealon_core.version import get_rpc_version, get_version_info
+
+__version__ = get_rpc_version()
+__author__ = "UnrealOn Team"
+
+# Import main components for easy access
+from .models.base import UnrealOnBaseModel, TimestampedModel, IdentifiedModel, StatusModel
+from .models.arq_context import (
+    ARQWorkerContext, ARQWorkerStats, TaskAssignmentParams, TaskResultParams,
+    LogEntryParams, DriverRegistrationParams, HeartbeatParams
+)
+from .models.arq_responses import (
+    TaskAssignmentResponse, TaskResultResponse, LogEntryResponse,
+    DriverRegistrationResponse, HeartbeatResponse, PingResponse
+)
+from .models.typed_responses import (
+    HealthCheckResult, StatusInfo, SessionInfo, ProxyStats,
+    ThreadStats, CacheStats, BatchStats
+)
+from .models.communication import (
+    MessageType as WebSocketMessageType, WebSocketMessage, 
+    DriverRegistrationMessage, RegistrationResponseMessage,
+    TaskAssignmentMessage, TaskResultMessage,
+    LogEntryMessage, LogBatchMessage,
+    HeartbeatMessage, ConfigurationUpdateMessage,
+    ErrorMessage, AckMessage,
+    create_error_message, create_ack_message,
+    # Data models for strict typing
+    TaskAssignmentData, TaskResultData,
+    DriverRegistrationData, HeartbeatData, LogEntryData, LogContext
+)
+from .enums.status import DriverStatus, TaskStatus, ProxyStatus, LogLevel
+from .enums.types import MessageType, ProxyType, TaskPriority
+from .exceptions.base import UnrealOnError
+from .exceptions.validation import ValidationError as UnrealOnValidationError
+from .exceptions.communication import CommunicationError
+
+# Error handling system
+from .error_handling import (
+    RetryConfig, RetryStrategy, RetryResult,
+    ExponentialBackoff, LinearBackoff, FixedBackoff,
+    retry_async, retry_sync,
+    CircuitBreakerConfig, CircuitBreakerState,
+    CircuitBreaker, circuit_breaker,
+    ErrorContext, ErrorSeverity,
+    create_error_context, format_error_context,
+    RecoveryStrategy, RecoveryAction,
+    AutoRecovery, recovery_handler
+)
+
+# Monitoring system
+from .monitoring import (
+    HealthStatus, HealthCheckResult, ComponentHealth,
+    HealthChecker, health_check_decorator,
+    MetricType, MetricValue, Metric,
+    MetricsCollector, counter, gauge, histogram, timer,
+    AlertSeverity, AlertRule, Alert,
+    AlertManager, alert_on_condition,
+    DashboardData, SystemStatus,
+    MonitoringDashboard, get_system_overview
+)
+
+# Configuration system
+from .config import (
+    EnvironmentConfig, URLConfig,
+    get_environment_config, get_url_config
+)
+
+__all__ = [
+    # Version info
+    "__version__",
+    "__author__", 
+    "__phase__",
+    
+    # Base models
+    "UnrealOnBaseModel",
+    "TimestampedModel", 
+    "IdentifiedModel",
+    "StatusModel",
+    
+    # WebSocket Communication models
+    "WebSocketMessageType",
+    "WebSocketMessage",
+    "DriverRegistrationMessage",
+    "RegistrationResponseMessage", 
+    "TaskAssignmentMessage",
+    "TaskResultMessage",
+    "LogEntryMessage",
+    "LogBatchMessage",
+    "HeartbeatMessage",
+    "ConfigurationUpdateMessage",
+    "ErrorMessage",
+    "AckMessage",
+    "create_error_message",
+    "create_ack_message",
+    
+    # Data models for strict typing
+    "TaskAssignmentData",
+    "TaskResultData", 
+    "DriverRegistrationData",
+    "HeartbeatData",
+    "LogEntryData",
+    "LogContext",
+    
+    # Status enums
+    "DriverStatus",
+    "TaskStatus",
+    "ProxyStatus", 
+    "LogLevel",
+    
+    # Type enums
+    "MessageType",
+    "ProxyType",
+    "TaskPriority",
+    
+    # Exceptions
+    "UnrealOnError",
+    "UnrealOnValidationError",
+    "CommunicationError",
+    
+    # Error handling system
+    "RetryConfig", "RetryStrategy", "RetryResult",
+    "ExponentialBackoff", "LinearBackoff", "FixedBackoff",
+    "retry_async", "retry_sync",
+    "CircuitBreakerConfig", "CircuitBreakerState",
+    "CircuitBreaker", "circuit_breaker",
+    "ErrorContext", "ErrorSeverity",
+    "create_error_context", "format_error_context",
+    "RecoveryStrategy", "RecoveryAction",
+    "AutoRecovery", "recovery_handler",
+    
+    # Monitoring system
+    "HealthStatus", "HealthCheckResult", "ComponentHealth",
+    "HealthChecker", "health_check_decorator",
+    "MetricType", "MetricValue", "Metric",
+    "MetricsCollector", "counter", "gauge", "histogram", "timer",
+    "AlertSeverity", "AlertRule", "Alert",
+    "AlertManager", "alert_on_condition",
+    "DashboardData", "SystemStatus",
+    "MonitoringDashboard", "get_system_overview",
+    
+    # Configuration system
+    "EnvironmentConfig", "URLConfig",
+    "get_environment_config", "get_url_config",
+]

unrealon_core/config/__init__.py

@@ -0,0 +1,16 @@
+"""
+Configuration management for UnrealOn platform.
+
+This module provides centralized configuration management with support for
+development and production environments.
+"""
+
+from .environment import EnvironmentConfig, get_environment_config
+from .urls import URLConfig, get_url_config
+
+__all__ = [
+    "EnvironmentConfig",
+    "URLConfig", 
+    "get_environment_config",
+    "get_url_config",
+]

unrealon_core/config/environment.py

@@ -0,0 +1,98 @@
+"""
+Environment configuration management.
+
+Handles switching between development and production environments.
+"""
+
+import os
+from enum import Enum
+from typing import Optional
+from pydantic import BaseModel, Field, ConfigDict
+
+
+class Environment(str, Enum):
+    """Environment types."""
+    DEVELOPMENT = "development"
+    PRODUCTION = "production"
+    TESTING = "testing"
+
+
+class EnvironmentConfig(BaseModel):
+    """Environment configuration settings."""
+    
+    model_config = ConfigDict(
+        # Add any specific config here if needed
+    )
+    
+    environment: Environment = Field(
+        default=Environment.DEVELOPMENT,
+        description="Current environment"
+    )
+    
+    debug: bool = Field(
+        default=True,
+        description="Enable debug mode"
+    )
+    
+    log_level: str = Field(
+        default="INFO",
+        description="Logging level"
+    )
+    
+    @classmethod
+    def from_env(cls) -> "EnvironmentConfig":
+        """Create config from environment variables."""
+        env_name = os.getenv("UNREALON_ENV", "development").lower()
+        
+        # Map environment names
+        env_mapping = {
+            "dev": Environment.DEVELOPMENT,
+            "development": Environment.DEVELOPMENT,
+            "prod": Environment.PRODUCTION,
+            "production": Environment.PRODUCTION,
+            "test": Environment.TESTING,
+            "testing": Environment.TESTING,
+        }
+        
+        environment = env_mapping.get(env_name, Environment.DEVELOPMENT)
+        
+        return cls(
+            environment=environment,
+            debug=environment != Environment.PRODUCTION,
+            log_level=os.getenv("UNREALON_LOG_LEVEL", "DEBUG" if environment != Environment.PRODUCTION else "INFO")
+        )
+    
+    @property
+    def is_development(self) -> bool:
+        """Check if running in development mode."""
+        return self.environment == Environment.DEVELOPMENT
+    
+    @property
+    def is_production(self) -> bool:
+        """Check if running in production mode."""
+        return self.environment == Environment.PRODUCTION
+    
+    @property
+    def is_testing(self) -> bool:
+        """Check if running in testing mode."""
+        return self.environment == Environment.TESTING
+
+
+# Global config instance
+_environment_config: Optional[EnvironmentConfig] = None
+
+
+def get_environment_config() -> EnvironmentConfig:
+    """Get the global environment configuration."""
+    global _environment_config
+    
+    if _environment_config is None:
+        _environment_config = EnvironmentConfig.from_env()
+    
+    return _environment_config
+
+
+def set_environment_config(config: EnvironmentConfig) -> None:
+    """Set the global environment configuration."""
+    global _environment_config
+    _environment_config = config

unrealon_core/config/urls.py

@@ -0,0 +1,93 @@
+"""
+URL configuration management.
+
+Provides centralized URL management with environment-specific endpoints.
+"""
+
+from typing import Optional
+from pydantic import BaseModel, Field, HttpUrl, ConfigDict
+from .environment import get_environment_config, Environment
+
+
+class URLConfig(BaseModel):
+    """URL configuration for different services."""
+    
+    model_config = ConfigDict(
+        # Add any specific config here if needed
+    )
+    
+    # Scanner/Detection URLs
+    scanner_url: str = Field(
+        description="URL for browser detection and stealth testing"
+    )
+    
+    # Cloud platform URLs  
+    cloud_base_url: str = Field(
+        description="Base URL for UnrealOn Cloud platform"
+    )
+    
+    # API endpoints
+    api_base_url: str = Field(
+        description="Base URL for API endpoints"
+    )
+    
+    @classmethod
+    def for_environment(cls, environment: Optional[Environment] = None) -> "URLConfig":
+        """Create URL config for specific environment."""
+        if environment is None:
+            environment = get_environment_config().environment
+        
+        if environment == Environment.PRODUCTION:
+            return cls(
+                scanner_url="https://cloud.unrealon.com/scanner",
+                cloud_base_url="https://cloud.unrealon.com",
+                api_base_url="https://api.unrealon.com"
+            )
+        elif environment == Environment.TESTING:
+            return cls(
+                scanner_url="https://staging.unrealon.com/scanner", 
+                cloud_base_url="https://staging.unrealon.com",
+                api_base_url="https://api-staging.unrealon.com"
+            )
+        else:  # Development
+            return cls(
+                scanner_url="http://localhost:3000/scanner",
+                cloud_base_url="http://localhost:3000", 
+                api_base_url="http://localhost:8000"
+            )
+    
+    @property
+    def stealth_test_url(self) -> str:
+        """Get the URL for stealth testing (replaces bot.sannysoft.com)."""
+        return self.scanner_url
+    
+    @property
+    def detection_test_url(self) -> str:
+        """Get the URL for browser detection testing."""
+        return self.scanner_url
+
+
+# Global config instance
+_url_config: Optional[URLConfig] = None
+
+
+def get_url_config() -> URLConfig:
+    """Get the global URL configuration."""
+    global _url_config
+    
+    if _url_config is None:
+        _url_config = URLConfig.for_environment()
+    
+    return _url_config
+
+
+def set_url_config(config: URLConfig) -> None:
+    """Set the global URL configuration."""
+    global _url_config
+    _url_config = config
+
+
+def reset_url_config() -> None:
+    """Reset URL config to reload from environment."""
+    global _url_config
+    _url_config = None

unrealon_core/enums/__init__.py

@@ -0,0 +1,24 @@
+"""
+UnrealOn Core Enums
+
+All enums and constants used across the UnrealOn system.
+These provide type safety and consistent values throughout the codebase.
+
+Phase 1: Foundation enums with strict validation
+"""
+
+from .status import DriverStatus, TaskStatus, ProxyStatus, LogLevel
+from .types import MessageType, ProxyType, TaskPriority
+
+__all__ = [
+    # Status enums
+    "DriverStatus",
+    "TaskStatus", 
+    "ProxyStatus",
+    "LogLevel",
+    
+    # Type enums
+    "MessageType",
+    "ProxyType",
+    "TaskPriority",
+]