unrealon 2.0.11__py3-none-any.whl → 2.0.13__py3-none-any.whl

{unrealon-2.0.11.dist-info → unrealon-2.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unrealon
-Version: 2.0.11
+Version: 2.0.13
 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.dist-info → unrealon-2.0.13.dist-info}/RECORD

@@ -6,7 +6,7 @@ unrealon_browser/cli/cookies_cli.py,sha256=yhZvGrg8bknlH4zlySdi8ue-25Ue-1rI_u1G0
 unrealon_browser/cli/interactive_mode.py,sha256=gLn9bMH0h0tPX3dP4i4QQxQK4Htkyg5r4KcqdMBaP6Q,12125
 unrealon_browser/cli/main.py,sha256=XCYcTxJUqaz320KCU_JPKizYMk6bdljb8Boyok3uO-4,1353
 unrealon_browser/core/__init__.py,sha256=uVL_t4sZelUzflWPdgrwoXGnAkSV1WNQ98-eu0QB2eM,151
-unrealon_browser/core/browser_manager.py,sha256=G7jZ9490j4yAsfW-VM1QXyRJGCsESX4dgaSO4-5EHko,29864
+unrealon_browser/core/browser_manager.py,sha256=vPWQjoh_QAoKWFlKVQCPIuehNsWIY9HIN7z3QeGoxAc,32398
 unrealon_browser/dto/__init__.py,sha256=bApqcLz-KanEi0_MCiFPrQmGBoX3VBijP7XtBUyIfjo,1636
 unrealon_browser/dto/bot_detection.py,sha256=qXfC0HghV7m4L6qA87t3STi-166jM-QgoP6OYbCb4o4,6884
 unrealon_browser/dto/models/config.py,sha256=Why5H3rtFclmwbdczuDfhlgf-LDz72Aa8LhDX4_ayfw,1752
@@ -83,7 +83,7 @@ unrealon_core/monitoring/health_check.py,sha256=UAdZ1Of0LCWFVfVXQP0BF-4HDOe4rxyh
 unrealon_core/monitoring/metrics.py,sha256=UPCRoridgGVxQ1kh--NuXzH-2dY0WyKljfXDH96OroU,11705
 unrealon_core/utils/__init__.py,sha256=L4nJum_ekqh3Rn324pcIASfr6QQtnT_PwWKCtl2L0mU,179
 unrealon_core/utils/time.py,sha256=27iWhOEl4wHgBOag7gqFlI0hl5cTHPnKHoe8GxmnKHA,1356
-unrealon_driver/__init__.py,sha256=HC6QTY6ufzQdBZ5-GrrNFH-VWoIKKqS0nyzZ2ZPhEak,1924
+unrealon_driver/__init__.py,sha256=0uwrmIEaAwpOSSTd6nv8fJinhpW2whBQHvqN430Cbz0,2130
 unrealon_driver/core_module/__init__.py,sha256=v4bHF0eqSQBAUBBEl8RnQWrvb3LjAeIAQCeIXrRTy3w,620
 unrealon_driver/core_module/base.py,sha256=RbC6MVQSA-1145gnDMdsMJ_QnMpQT52pIg86UfRSSMc,6135
 unrealon_driver/core_module/config.py,sha256=N0XGWsoYmv2ruKZOZKOyfaHOZ_jstUDqH7aTqURG2TI,1023
@@ -103,7 +103,7 @@ unrealon_driver/driver/core/__init__.py,sha256=ZvJQp1zO7pj6tBNYTJk2fj-0ZMiQTQEk-
 unrealon_driver/driver/core/config.py,sha256=jWJjRll19VlL4iM5Q-J3o9qwYeH89Iuj1_3KayM6fCk,5914
 unrealon_driver/driver/core/driver.py,sha256=NI-pdhnduRyHLsfFr8HmP2gp7pR1pWB4vBIJkMJ2cls,7886
 unrealon_driver/driver/factory/__init__.py,sha256=XrjBhOaLvC3MIG5PAFIYS_xYXFDz5JizpFvmQcwA7mU,189
-unrealon_driver/driver/factory/manager_factory.py,sha256=zJt63N8oWNJS0aNbLy7WjY4GCeUwLjvtWGdqdpucufU,4792
+unrealon_driver/driver/factory/manager_factory.py,sha256=b-3tWKsnicTNygZ3zIDhBlSbGySPRPT1GYrFY32QQgo,5103
 unrealon_driver/driver/lifecycle/__init__.py,sha256=KnkXklezAOIbXcCzEU_XSOt32z7tz1zIGclXYXTkO8k,286
 unrealon_driver/driver/lifecycle/daemon.py,sha256=KHAzpiWFu3HRElRtzSEStmI74bMivFjfCAFlXha87KU,2609
 unrealon_driver/driver/lifecycle/initialization.py,sha256=R4MgfkSNnfAdMO0Kp1Cx42cfNqq8VIxj_mGX7ECXad4,4406
@@ -115,19 +115,20 @@ unrealon_driver/driver/utilities/logging.py,sha256=2my2QnkAa6Hdw-TfO4oOQ94yGc-Cj
 unrealon_driver/driver/utilities/serialization.py,sha256=wTCSVrEloykiGN4K1JXbk2aqNKm7W90aWXmzhcLyAZc,2123
 unrealon_driver/managers/__init__.py,sha256=zJJsOb6Oodg7l00v4ncKUytnyeaZM887pHY8-eSuWdU,981
 unrealon_driver/managers/base.py,sha256=GkuXillg9uqqnx6RL682fmKgK-7JyqYlH6DFUgyN4F8,5445
-unrealon_driver/managers/browser.py,sha256=v2FjgtgzTM94Qobll9_7TGRVbxsMlVvirP_sj3u152Q,4608
+unrealon_driver/managers/browser.py,sha256=bc6O2NyC4FV82mb9sat48_k8s1c3IGY4i90ddMVWRIo,5432
 unrealon_driver/managers/cache.py,sha256=c0tPKQ5KFd_Un1U8mw3j1WPuycxg863MMWNMveVF_2I,3506
 unrealon_driver/managers/http.py,sha256=EjlpoTRuhpsgzzrEARxRlbGczzua7hnKFVq06bvCgTM,3624
 unrealon_driver/managers/logger.py,sha256=PL3rA9ZQl12jJU0EiPAkLwJ6eDHQfIzr8-nc8bVivKQ,10526
-unrealon_driver/managers/proxy.py,sha256=Y_3ok2iGefeYHcTtBQIEK3Rnr8qRnPsP90hOOYPUMz0,3449
+unrealon_driver/managers/proxy.py,sha256=b2w6DteMJWnwxZmL3NfwBMdE_mscchoMwPs-XFKNwnU,3855
 unrealon_driver/managers/registry.py,sha256=--oNPU-65e8J21ubJufyEOc1TirnzJIvpvuY_j7rH7Q,2666
 unrealon_driver/managers/threading.py,sha256=djw5cSC99dfBKmep3IJ_8IgxQceMXtNvCp5fIxHM0TY,1702
 unrealon_driver/managers/update.py,sha256=-hohVxGXpj5bZ6ZTQN6NH1RK9Pd6GVzCMtu3GS2SdcQ,3582
-unrealon_driver/utils/__init__.py,sha256=qxXVoQJVdLJhaLBXk_LZV_062AhrvBrMPXWAKfEc3C4,104
+unrealon_driver/utils/__init__.py,sha256=qMEFiXU7R8hMZ9yAgUYMZ_TF-Yqo3w9Xm7ToPO9Pew0,383
+unrealon_driver/utils/platform_compatibility.py,sha256=kydNJhxswBq-z249YQBBVxP0QKEP3vQHuvGuYcBVH-w,7617
 unrealon_driver/utils/time.py,sha256=Oxk1eicKeZl8ZWbf7gu1Ll716k6CpXmVj67FHSnPIsA,184
-unrealon-2.0.11.dist-info/LICENSE,sha256=eEH8mWZW49YMpl4Sh5MtKqkZ8aVTzKQXiNPEnvL14ns,1070
-unrealon-2.0.11.dist-info/METADATA,sha256=ROMoMLZznLuLhKF9pDVigTdkiaGuoJRTbIbxel3sahY,15689
-unrealon-2.0.11.dist-info/WHEEL,sha256=pL8R0wFFS65tNSRnaOVrsw9EOkOqxLrlUPenUYnJKNo,91
-unrealon-2.0.11.dist-info/entry_points.txt,sha256=k0qM-eotpajkKUq-almJmxj9afhXprZ6IkvQkSdcKhI,104
-unrealon-2.0.11.dist-info/top_level.txt,sha256=Gu8IeIfIVfUxdi-h-F0nKMQxo15pjhHZ0aTadXTpRE8,47
-unrealon-2.0.11.dist-info/RECORD,,
+unrealon-2.0.13.dist-info/LICENSE,sha256=eEH8mWZW49YMpl4Sh5MtKqkZ8aVTzKQXiNPEnvL14ns,1070
+unrealon-2.0.13.dist-info/METADATA,sha256=A051dpkf4-8dQevRVKFvOwHfvBQy3UPytnQ9k0w5cbQ,15689
+unrealon-2.0.13.dist-info/WHEEL,sha256=pL8R0wFFS65tNSRnaOVrsw9EOkOqxLrlUPenUYnJKNo,91
+unrealon-2.0.13.dist-info/entry_points.txt,sha256=k0qM-eotpajkKUq-almJmxj9afhXprZ6IkvQkSdcKhI,104
+unrealon-2.0.13.dist-info/top_level.txt,sha256=Gu8IeIfIVfUxdi-h-F0nKMQxo15pjhHZ0aTadXTpRE8,47
+unrealon-2.0.13.dist-info/RECORD,,

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_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_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_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_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_driver/utils/__init__.py

@@ -1,9 +1,18 @@
 """
-Utility functions for UnrealOn Driver.
-"""
+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",
-]
+    'utc_now',
+    'PlatformCompatibility',
+    'ensure_platform_compatibility', 
+    'get_platform_info'
+]

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()