unrealon 2.0.11__tar.gz → 2.0.12__tar.gz

{unrealon-2.0.11/unrealon.egg-info → unrealon-2.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unrealon
-Version: 2.0.11
+Version: 2.0.12
 Summary: Enterprise-grade web scraping platform with AI-powered automation and real-time orchestration capabilities
 Author-email: UnrealOn Team <team@unrealon.com>
 License: MIT

{unrealon-2.0.11 → unrealon-2.0.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "unrealon"
-version = "2.0.11"
+version = "2.0.12"
 description = "Enterprise-grade web scraping platform with AI-powered automation and real-time orchestration capabilities"
 authors = [
     {name = "UnrealOn Team", email = "team@unrealon.com"}

{unrealon-2.0.11 → unrealon-2.0.12}/unrealon-browser/src/unrealon_browser/core/browser_manager.py

@@ -55,6 +55,9 @@ class BrowserManager:
         self._page = None
         self._initialized = False
         self._statistics = BrowserManagerStatistics()
+        
+        # Proxy settings (can be set externally)
+        self._proxy_url: Optional[str] = None
 
         # Initialize logger bridge first
         self.logger_bridge = create_browser_logger_bridge(session_id=self._generate_session_id(), parser_id=self.parser_id, enable_console=True)  # Use resolved parser_id
@@ -197,6 +200,12 @@ class BrowserManager:
                     "ignore_default_args": ["--enable-automation"],
                     **context_options,  # viewport, user_agent, etc.
                 }
+                
+                # Add proxy configuration for persistent context
+                if self._proxy_url:
+                    proxy_config = self._get_playwright_proxy_config()
+                    if proxy_config:
+                        persistent_args["proxy"] = proxy_config
 
                 # Use persistent context with user_data_dir for profiles
                 if self.config.browser_type == BrowserType.CHROMIUM:
@@ -223,6 +232,12 @@ class BrowserManager:
                     raise ValueError(f"Unsupported browser type: {self.config.browser_type}")
 
                 # Create context without profile
+                # Add proxy configuration for context
+                if self._proxy_url:
+                    proxy_config = self._get_playwright_proxy_config()
+                    if proxy_config:
+                        context_options["proxy"] = proxy_config
+                
                 self._context = await self._browser.new_context(**context_options)
 
             # 🔥 STEALTH ALWAYS ON - NO CONFIG NEEDED!
@@ -276,6 +291,9 @@ class BrowserManager:
         # 🔥 STEALTH ALWAYS ON - ALWAYS ADD STEALTH ARGS!
         browser_args.extend(self.stealth_manager.get_stealth_args())
 
+        # Note: Proxy configuration is now handled via Playwright API in context options
+        # instead of command line arguments for better compatibility
+
         if self.config.disable_images:
             browser_args.extend(
                 [
@@ -286,6 +304,46 @@ class BrowserManager:
 
         args["args"] = browser_args
         return args
+    
+    def _get_playwright_proxy_config(self) -> Optional[Dict[str, Any]]:
+        """
+        Get Playwright-compatible proxy configuration.
+        
+        Returns:
+            Proxy configuration dict for Playwright or None if not supported
+        """
+        if not self._proxy_url:
+            return None
+            
+        try:
+            from urllib.parse import urlparse
+            
+            parsed = urlparse(self._proxy_url)
+            
+            # Playwright proxy configuration
+            proxy_config = {
+                "server": f"{parsed.scheme}://{parsed.hostname}:{parsed.port}"
+            }
+            
+            # Add authentication if present
+            if parsed.username and parsed.password:
+                # WARNING: Playwright does NOT support SOCKS5 authentication!
+                if parsed.scheme == 'socks5':
+                    self.logger_bridge.log_warning("⚠️ Playwright does not support SOCKS5 authentication!")
+                    self.logger_bridge.log_warning("⚠️ Falling back to SOCKS5 without auth - may fail!")
+                    # Return configuration without authentication for SOCKS5
+                    return proxy_config
+                else:
+                    # HTTP/HTTPS proxies support authentication
+                    proxy_config["username"] = parsed.username
+                    proxy_config["password"] = parsed.password
+            
+            self.logger_bridge.log_info(f"🔒 Playwright proxy config: {proxy_config['server']}")
+            return proxy_config
+            
+        except Exception as e:
+            self.logger_bridge.log_error(f"❌ Failed to parse proxy URL: {e}")
+            return None
 
     def _get_context_options(self) -> Dict[str, Any]:
         """Get browser context options"""

{unrealon-2.0.11 → unrealon-2.0.12}/unrealon-driver/src/unrealon_driver/__init__.py

@@ -60,15 +60,20 @@ from .decorators import (
     timing
 )
 
+# Utilities - Cross-platform compatibility
+from .utils import (
+    PlatformCompatibility,
+    ensure_platform_compatibility,
+    get_platform_info
+)
+
 __version__ = get_driver_version()
 __author__ = "UnrealOn Team"
-__phase__ = "Phase 3.8: Clean Refactor"
 
 __all__ = [
     # Version
     "__version__",
     "__author__", 
-    "__phase__",
     
     # Core API
     "UniversalDriver",
@@ -102,4 +107,9 @@ __all__ = [
     "retry",
     "schedule", 
     "timing",
+    
+    # Utilities
+    "PlatformCompatibility",
+    "ensure_platform_compatibility",
+    "get_platform_info",
 ]

{unrealon-2.0.11 → unrealon-2.0.12}/unrealon-driver/src/unrealon_driver/driver/factory/manager_factory.py

@@ -81,11 +81,18 @@ class ManagerFactory:
     @staticmethod
     def _setup_browser_manager(driver: 'UniversalDriver', registry: ManagerRegistry):
         """Setup browser manager."""
+        # Get proxy URL from proxy manager if enabled
+        proxy_url = None
+        if driver.config.proxy_enabled and hasattr(driver, 'proxy') and driver.proxy:
+            proxy_url = driver.proxy.get_proxy()
+        
         browser_config = BrowserManagerConfig(
             enabled=True,
             headless=driver.config.browser_headless,
             timeout=driver.config.browser_timeout,
-            parser_name=driver.driver_id
+            parser_name=driver.driver_id,
+            proxy_enabled=driver.config.proxy_enabled,
+            proxy_url=proxy_url
         )
         driver.browser = BrowserManager(browser_config)
         registry.register(driver.browser)

{unrealon-2.0.11 → unrealon-2.0.12}/unrealon-driver/src/unrealon_driver/managers/browser.py

@@ -17,6 +17,11 @@ class BrowserManagerConfig(ManagerConfig):
     headless: bool = Field(default=True, description="Run headless")
     parser_name: str = Field(..., description="Parser name for browser")
     stealth_warmup_enabled: bool = Field(default=False, description="Enable stealth warmup")
+    
+    # Proxy settings
+    proxy_enabled: bool = Field(default=False, description="Enable proxy usage")
+    proxy_url: Optional[str] = Field(default=None, description="Proxy URL (http://user:pass@host:port)")
+    proxy_timeout: int = Field(default=30, description="Proxy timeout in seconds")
 
 
 class BrowserManager(BaseManager):
@@ -53,6 +58,12 @@ class BrowserManager(BaseManager):
         try:
             self.logger.info("🚀 Starting browser (lazy initialization)...")
             
+            # Log proxy status
+            if self.config.proxy_enabled and self.config.proxy_url:
+                self.logger.info(f"🔒 Proxy enabled: {self.config.proxy_url}")
+            else:
+                self.logger.info("🌐 No proxy configured")
+            
             # Create browser config with proper headless mode
             browser_mode = BrowserMode.HEADLESS if self.config.headless else BrowserMode.HEADED
             
@@ -62,8 +73,12 @@ class BrowserManager(BaseManager):
                 stealth_warmup_enabled=self.config.stealth_warmup_enabled
             )
 
-            # Create browser manager
+            # Create browser manager with proxy support
             self.browser = CoreBrowserManager(browser_config)
+            
+            # Set proxy if enabled (we'll need to modify CoreBrowserManager to support this)
+            if self.config.proxy_enabled and self.config.proxy_url:
+                self.browser._proxy_url = self.config.proxy_url
 
             # Initialize browser
             await self.browser.initialize_async()

{unrealon-2.0.11 → unrealon-2.0.12}/unrealon-driver/src/unrealon_driver/managers/proxy.py

@@ -13,6 +13,7 @@ from .base import BaseManager, ManagerConfig
 class ProxyManagerConfig(ManagerConfig):
     """Proxy manager configuration."""
     proxies: List[str] = Field(default_factory=list, description="List of proxy URLs")
+    single_proxy: Optional[str] = Field(default=None, description="Single proxy URL to use")
     rotation_interval: int = Field(default=300, description="Rotation interval seconds")
     health_check_interval: int = Field(default=60, description="Health check interval")
 
@@ -29,11 +30,17 @@ class ProxyManager(BaseManager):
     
     async def _initialize(self) -> bool:
         """Initialize proxy manager."""
-        self.active_proxies = self.config.proxies.copy()
+        # Use single proxy if specified, otherwise use proxy list
+        if self.config.single_proxy:
+            self.active_proxies = [self.config.single_proxy]
+            self.current_proxy = self.config.single_proxy
+        else:
+            self.active_proxies = self.config.proxies.copy()
+            if self.active_proxies:
+                self.current_proxy = random.choice(self.active_proxies)
         
-        if self.active_proxies:
-            self.current_proxy = random.choice(self.active_proxies)
-            # Start rotation task
+        # Only start rotation if we have multiple proxies
+        if len(self.active_proxies) > 1:
             self._rotation_task = asyncio.create_task(self._rotation_loop())
         
         return True

unrealon-2.0.12/unrealon-driver/src/unrealon_driver/utils/__init__.py

@@ -0,0 +1,18 @@
+"""
+Utility modules for UnrealOn Driver.
+
+Contains cross-platform compatibility and other utility functions.
+"""
+from .time import utc_now
+from .platform_compatibility import (
+    PlatformCompatibility,
+    ensure_platform_compatibility,
+    get_platform_info
+)
+
+__all__ = [
+    'utc_now',
+    'PlatformCompatibility',
+    'ensure_platform_compatibility', 
+    'get_platform_info'
+]

unrealon-2.0.12/unrealon-driver/src/unrealon_driver/utils/platform_compatibility.py

@@ -0,0 +1,205 @@
+"""
+Cross-platform compatibility utilities for UnrealOn Driver.
+
+Handles platform-specific configurations and fixes for Windows, macOS, and Linux.
+"""
+
+import asyncio
+import sys
+import platform
+import warnings
+from typing import Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class PlatformCompatibility:
+    """
+    Handles cross-platform compatibility for UnrealOn Driver.
+    
+    Automatically applies platform-specific fixes and configurations
+    to ensure consistent behavior across Windows, macOS, and Linux.
+    """
+    
+    def __init__(self):
+        """Initialize platform compatibility."""
+        self.platform = platform.system()
+        self.python_version = sys.version_info
+        self._applied_fixes = []
+    
+    def apply_all_fixes(self) -> None:
+        """
+        Apply all platform-specific fixes automatically.
+        
+        This method should be called once at the start of the application
+        to ensure optimal cross-platform compatibility.
+        """
+        logger.info(f"🔧 Applying platform fixes for {self.platform}")
+        
+        if self.platform == "Windows":
+            self._apply_windows_fixes()
+        elif self.platform == "Darwin":  # macOS
+            self._apply_macos_fixes()
+        elif self.platform == "Linux":
+            self._apply_linux_fixes()
+        
+        logger.info(f"✅ Applied {len(self._applied_fixes)} platform fixes: {', '.join(self._applied_fixes)}")
+    
+    def _apply_windows_fixes(self) -> None:
+        """Apply Windows-specific fixes."""
+        
+        # Fix 1: Set ProactorEventLoopPolicy for better asyncio performance
+        if self.python_version >= (3, 8):
+            try:
+                asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
+                self._applied_fixes.append("WindowsProactorEventLoopPolicy")
+                logger.debug("✅ Set WindowsProactorEventLoopPolicy for better asyncio performance")
+            except Exception as e:
+                logger.warning(f"⚠️ Failed to set WindowsProactorEventLoopPolicy: {e}")
+        
+        # Fix 2: Suppress ResourceWarning on Windows
+        try:
+            warnings.filterwarnings("ignore", category=ResourceWarning)
+            self._applied_fixes.append("ResourceWarning suppression")
+            logger.debug("✅ Suppressed ResourceWarning for cleaner output")
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to suppress ResourceWarning: {e}")
+        
+        # Fix 3: Set console encoding to UTF-8 if possible
+        try:
+            if hasattr(sys.stdout, 'reconfigure'):
+                sys.stdout.reconfigure(encoding='utf-8')
+                sys.stderr.reconfigure(encoding='utf-8')
+                self._applied_fixes.append("UTF-8 console encoding")
+                logger.debug("✅ Set console encoding to UTF-8")
+        except Exception as e:
+            logger.debug(f"Console encoding fix not needed or failed: {e}")
+        
+        # Fix 4: Increase default socket timeout for Windows
+        try:
+            import socket
+            socket.setdefaulttimeout(30.0)
+            self._applied_fixes.append("Socket timeout increase")
+            logger.debug("✅ Increased default socket timeout to 30s")
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to set socket timeout: {e}")
+    
+    def _apply_macos_fixes(self) -> None:
+        """Apply macOS-specific fixes."""
+        
+        # Fix 1: Handle macOS SSL context issues
+        try:
+            import ssl
+            # Create unverified SSL context for development
+            ssl._create_default_https_context = ssl._create_unverified_context
+            self._applied_fixes.append("SSL context fix")
+            logger.debug("✅ Applied macOS SSL context fix")
+        except Exception as e:
+            logger.debug(f"SSL context fix not needed: {e}")
+        
+        # Fix 2: Set optimal file descriptor limits
+        try:
+            import resource
+            soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
+            if soft < 1024:
+                resource.setrlimit(resource.RLIMIT_NOFILE, (min(1024, hard), hard))
+                self._applied_fixes.append("File descriptor limit increase")
+                logger.debug("✅ Increased file descriptor limit")
+        except Exception as e:
+            logger.debug(f"File descriptor limit fix not needed: {e}")
+    
+    def _apply_linux_fixes(self) -> None:
+        """Apply Linux-specific fixes."""
+        
+        # Fix 1: Set optimal file descriptor limits
+        try:
+            import resource
+            soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
+            if soft < 2048:
+                resource.setrlimit(resource.RLIMIT_NOFILE, (min(2048, hard), hard))
+                self._applied_fixes.append("File descriptor limit increase")
+                logger.debug("✅ Increased file descriptor limit")
+        except Exception as e:
+            logger.debug(f"File descriptor limit fix not needed: {e}")
+        
+        # Fix 2: Handle display issues for headless environments
+        try:
+            import os
+            if not os.environ.get('DISPLAY'):
+                os.environ['DISPLAY'] = ':99'
+                self._applied_fixes.append("Headless display fix")
+                logger.debug("✅ Set display for headless environment")
+        except Exception as e:
+            logger.debug(f"Display fix not needed: {e}")
+    
+    def get_platform_info(self) -> dict:
+        """
+        Get detailed platform information.
+        
+        Returns:
+            Dictionary with platform details
+        """
+        return {
+            'platform': self.platform,
+            'platform_release': platform.release(),
+            'platform_version': platform.version(),
+            'architecture': platform.architecture(),
+            'machine': platform.machine(),
+            'processor': platform.processor(),
+            'python_version': f"{self.python_version.major}.{self.python_version.minor}.{self.python_version.micro}",
+            'python_implementation': platform.python_implementation(),
+            'applied_fixes': self._applied_fixes
+        }
+    
+    @classmethod
+    def auto_configure(cls) -> 'PlatformCompatibility':
+        """
+        Automatically configure platform compatibility.
+        
+        This is the recommended way to use this class - it will
+        automatically detect the platform and apply all necessary fixes.
+        
+        Returns:
+            Configured PlatformCompatibility instance
+        """
+        compatibility = cls()
+        compatibility.apply_all_fixes()
+        return compatibility
+
+
+# Global instance for easy access
+_platform_compatibility: Optional[PlatformCompatibility] = None
+
+
+def ensure_platform_compatibility() -> PlatformCompatibility:
+    """
+    Ensure platform compatibility is configured.
+    
+    This function can be called multiple times safely - it will only
+    configure compatibility once per application run.
+    
+    Returns:
+        PlatformCompatibility instance
+    """
+    global _platform_compatibility
+    
+    if _platform_compatibility is None:
+        _platform_compatibility = PlatformCompatibility.auto_configure()
+    
+    return _platform_compatibility
+
+
+def get_platform_info() -> dict:
+    """
+    Get platform information.
+    
+    Returns:
+        Dictionary with platform details
+    """
+    compatibility = ensure_platform_compatibility()
+    return compatibility.get_platform_info()
+
+
+# Auto-configure on import for convenience
+ensure_platform_compatibility()

{unrealon-2.0.11 → unrealon-2.0.12/unrealon.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unrealon
-Version: 2.0.11
+Version: 2.0.12
 Summary: Enterprise-grade web scraping platform with AI-powered automation and real-time orchestration capabilities
 Author-email: UnrealOn Team <team@unrealon.com>
 License: MIT

{unrealon-2.0.11 → unrealon-2.0.12}/unrealon.egg-info/SOURCES.txt

@@ -128,6 +128,7 @@ unrealon-driver/src/unrealon_driver/managers/registry.py
 unrealon-driver/src/unrealon_driver/managers/threading.py
 unrealon-driver/src/unrealon_driver/managers/update.py
 unrealon-driver/src/unrealon_driver/utils/__init__.py
+unrealon-driver/src/unrealon_driver/utils/platform_compatibility.py
 unrealon-driver/src/unrealon_driver/utils/time.py
 unrealon.egg-info/PKG-INFO
 unrealon.egg-info/SOURCES.txt

unrealon-2.0.11/unrealon-driver/src/unrealon_driver/utils/__init__.py

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