unrealon 2.0.12__py3-none-any.whl → 2.0.14__py3-none-any.whl

{unrealon-2.0.12.dist-info → unrealon-2.0.14.dist-info}/METADATA

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

@@ -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=0uwrmIEaAwpOSSTd6nv8fJinhpW2whBQHvqN430Cbz0,2130
+unrealon_driver/__init__.py,sha256=un_W-fmvFJ8TIIEKpEOK0Fi62InXTUL8cRCiKgKUtwY,1975
 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
@@ -123,12 +123,16 @@ unrealon_driver/managers/proxy.py,sha256=b2w6DteMJWnwxZmL3NfwBMdE_mscchoMwPs-XFK
 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=qMEFiXU7R8hMZ9yAgUYMZ_TF-Yqo3w9Xm7ToPO9Pew0,383
-unrealon_driver/utils/platform_compatibility.py,sha256=kydNJhxswBq-z249YQBBVxP0QKEP3vQHuvGuYcBVH-w,7617
+unrealon_driver/utils/__init__.py,sha256=2Sz3eats5q4O2fDmefDuJt8M_zkN6xrS-9xXntWZWFc,168
 unrealon_driver/utils/time.py,sha256=Oxk1eicKeZl8ZWbf7gu1Ll716k6CpXmVj67FHSnPIsA,184
-unrealon-2.0.12.dist-info/LICENSE,sha256=eEH8mWZW49YMpl4Sh5MtKqkZ8aVTzKQXiNPEnvL14ns,1070
-unrealon-2.0.12.dist-info/METADATA,sha256=UDN8rMi-1DqFObmEJiMboDUzCmh_j1jQJwv6KhRsntw,15689
-unrealon-2.0.12.dist-info/WHEEL,sha256=pL8R0wFFS65tNSRnaOVrsw9EOkOqxLrlUPenUYnJKNo,91
-unrealon-2.0.12.dist-info/entry_points.txt,sha256=k0qM-eotpajkKUq-almJmxj9afhXprZ6IkvQkSdcKhI,104
-unrealon-2.0.12.dist-info/top_level.txt,sha256=Gu8IeIfIVfUxdi-h-F0nKMQxo15pjhHZ0aTadXTpRE8,47
-unrealon-2.0.12.dist-info/RECORD,,
+unrealon_installer/__init__.py,sha256=JxA2hKat5E6R6nt-batuAc-2Cr0nO2M0XW0vOFU_xy0,333
+unrealon_installer/browser_fixes.py,sha256=I09aEMWwvN8-SbGJqJQHcnvsR4_JmjoiRKoyIqft4Rc,7754
+unrealon_installer/core.py,sha256=Ib_10WwXBixHw_jozY_JsAG2eq6dmDCxT0Ucoy_WKVU,5259
+unrealon_installer/platform.py,sha256=NI6-j6674jLWjF0RFRDwXW01D0OueEhhijjevgmbAVs,3122
+unrealon_installer/templates.py,sha256=jU3Fznp_VfZedfWNutVzepGUv2QYI2Q4LM_j8H38CrU,1896
+unrealon-2.0.14.dist-info/LICENSE,sha256=eEH8mWZW49YMpl4Sh5MtKqkZ8aVTzKQXiNPEnvL14ns,1070
+unrealon-2.0.14.dist-info/METADATA,sha256=HIr3X3TBCqGy3nZ0-VVvAZSqHrAFVIngrg4x0RcYGJI,15689
+unrealon-2.0.14.dist-info/WHEEL,sha256=pL8R0wFFS65tNSRnaOVrsw9EOkOqxLrlUPenUYnJKNo,91
+unrealon-2.0.14.dist-info/entry_points.txt,sha256=k0qM-eotpajkKUq-almJmxj9afhXprZ6IkvQkSdcKhI,104
+unrealon-2.0.14.dist-info/top_level.txt,sha256=qN6Q72fe4_i8mTOhYcO3fhGa3g4dmBgvZOsqmK4j8D8,66
+unrealon-2.0.14.dist-info/RECORD,,

{unrealon-2.0.12.dist-info → unrealon-2.0.14.dist-info}/top_level.txt

@@ -1,3 +1,4 @@
 unrealon_browser
 unrealon_core
 unrealon_driver
+unrealon_installer

unrealon_driver/__init__.py

@@ -60,12 +60,8 @@ from .decorators import (
     timing
 )
 
-# Utilities - Cross-platform compatibility
-from .utils import (
-    PlatformCompatibility,
-    ensure_platform_compatibility,
-    get_platform_info
-)
+# Utilities - Time utilities only (platform compatibility moved to installer)
+from .utils import time
 
 __version__ = get_driver_version()
 __author__ = "UnrealOn Team"
@@ -108,8 +104,4 @@ __all__ = [
     "schedule", 
     "timing",
     
-    # Utilities
-    "PlatformCompatibility",
-    "ensure_platform_compatibility",
-    "get_platform_info",
 ]

unrealon_driver/utils/__init__.py

@@ -4,15 +4,7 @@ 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_installer/__init__.py

@@ -0,0 +1,11 @@
+"""
+UnrealOn Universal Installer - Clean Edition
+
+One function installs everything. Simple and reliable.
+"""
+
+from .core import install_parser
+from .browser_fixes import fix_browsers, diagnose_browsers, get_browser_status
+
+__version__ = "2.0.0"
+__all__ = ["install_parser", "fix_browsers", "diagnose_browsers", "get_browser_status"]

unrealon_installer/browser_fixes.py

@@ -0,0 +1,227 @@
+"""
+Browser troubleshooting and fixes for Windows.
+"""
+
+import os
+import sys
+import subprocess
+import platform
+from pathlib import Path
+from typing import Dict, List, Optional
+import shutil
+
+
+class BrowserFixer:
+    """Windows browser troubleshooting and fixes."""
+    
+    def __init__(self):
+        self.is_windows = platform.system() == "Windows"
+        self.playwright_cache = self._get_playwright_cache_path()
+    
+    def _get_playwright_cache_path(self) -> Optional[Path]:
+        """Get Playwright cache directory path."""
+        if self.is_windows:
+            return Path(os.environ.get("USERPROFILE", "")) / "AppData" / "Local" / "ms-playwright"
+        elif platform.system() == "Darwin":  # macOS
+            return Path.home() / "Library" / "Caches" / "ms-playwright"
+        else:  # Linux
+            return Path.home() / ".cache" / "ms-playwright"
+    
+    def diagnose_browser_issues(self) -> Dict[str, bool]:
+        """Diagnose common browser issues."""
+        issues = {}
+        
+        # Check if Playwright is installed
+        issues['playwright_installed'] = self._check_playwright_installed()
+        
+        # Check if browsers are installed
+        issues['browsers_installed'] = self._check_browsers_installed()
+        
+        # Check cache directory
+        issues['cache_exists'] = self._check_cache_directory()
+        
+        # Check if browsers can launch
+        issues['browser_launch_test'] = self._test_browser_launch()
+        
+        return issues
+    
+    def _check_playwright_installed(self) -> bool:
+        """Check if Playwright is installed."""
+        try:
+            subprocess.run([sys.executable, "-c", "import playwright"], 
+                         check=True, capture_output=True)
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+    
+    def _check_browsers_installed(self) -> bool:
+        """Check if Playwright browsers are installed."""
+        try:
+            result = subprocess.run([sys.executable, "-m", "playwright", "--version"], 
+                                  check=True, capture_output=True, text=True)
+            return "version" in result.stdout.lower()
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+    
+    def _check_cache_directory(self) -> bool:
+        """Check if Playwright cache directory exists."""
+        if not self.playwright_cache:
+            return False
+        return self.playwright_cache.exists()
+    
+    def _test_browser_launch(self) -> bool:
+        """Test if browser can launch (quick test)."""
+        try:
+            test_code = """
+from playwright.sync_api import sync_playwright
+try:
+    with sync_playwright() as p:
+        browser = p.chromium.launch(headless=True)
+        browser.close()
+    print("OK")
+except Exception as e:
+    print(f"ERROR: {e}")
+"""
+            result = subprocess.run([sys.executable, "-c", test_code], 
+                                  capture_output=True, text=True, timeout=30)
+            return "OK" in result.stdout
+        except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
+            return False
+    
+    def fix_browser_issues(self, force_reinstall: bool = False) -> bool:
+        """Fix common browser issues."""
+        print("🔧 Fixing browser issues...")
+        
+        success = True
+        
+        # Step 1: Clear cache if it exists
+        if self._clear_browser_cache():
+            print("✅ Browser cache cleared")
+        else:
+            print("⚠️  Could not clear browser cache")
+        
+        # Step 2: Reinstall Playwright if needed or forced
+        if force_reinstall or not self._check_playwright_installed():
+            if self._reinstall_playwright():
+                print("✅ Playwright reinstalled")
+            else:
+                print("❌ Failed to reinstall Playwright")
+                success = False
+        
+        # Step 3: Install browsers
+        if self._install_browsers():
+            print("✅ Browsers installed")
+        else:
+            print("❌ Failed to install browsers")
+            success = False
+        
+        # Step 4: Test installation
+        if self._test_browser_launch():
+            print("✅ Browser test passed")
+        else:
+            print("❌ Browser test failed")
+            success = False
+        
+        return success
+    
+    def _clear_browser_cache(self) -> bool:
+        """Clear Playwright browser cache."""
+        try:
+            if self.playwright_cache and self.playwright_cache.exists():
+                shutil.rmtree(self.playwright_cache, ignore_errors=True)
+                print(f"Cleared cache: {self.playwright_cache}")
+            return True
+        except Exception as e:
+            print(f"Cache clear error: {e}")
+            return False
+    
+    def _reinstall_playwright(self) -> bool:
+        """Reinstall Playwright completely."""
+        try:
+            # Uninstall
+            subprocess.run([sys.executable, "-m", "pip", "uninstall", "-y", "playwright"], 
+                         check=False, capture_output=True)
+            
+            # Clear pip cache
+            subprocess.run([sys.executable, "-m", "pip", "cache", "purge"], 
+                         check=False, capture_output=True)
+            
+            # Reinstall
+            subprocess.run([sys.executable, "-m", "pip", "install", "playwright"], 
+                         check=True, capture_output=True)
+            
+            return True
+        except subprocess.CalledProcessError:
+            return False
+    
+    def _install_browsers(self) -> bool:
+        """Install Playwright browsers."""
+        try:
+            # Install chromium (most stable)
+            subprocess.run([sys.executable, "-m", "playwright", "install", "chromium"], 
+                         check=True, capture_output=True)
+            
+            # Try to install firefox too (optional)
+            subprocess.run([sys.executable, "-m", "playwright", "install", "firefox"], 
+                         check=False, capture_output=True)
+            
+            return True
+        except subprocess.CalledProcessError:
+            return False
+    
+    def get_browser_info(self) -> Dict[str, str]:
+        """Get browser installation information."""
+        info = {}
+        
+        # Playwright version
+        try:
+            result = subprocess.run([sys.executable, "-m", "playwright", "--version"], 
+                                  capture_output=True, text=True)
+            info['playwright_version'] = result.stdout.strip()
+        except:
+            info['playwright_version'] = "Not installed"
+        
+        # Cache directory
+        info['cache_path'] = str(self.playwright_cache) if self.playwright_cache else "Unknown"
+        info['cache_exists'] = str(self._check_cache_directory())
+        
+        # Browser test
+        info['browser_test'] = "PASS" if self._test_browser_launch() else "FAIL"
+        
+        return info
+
+
+def fix_browsers(force_reinstall: bool = False) -> bool:
+    """
+    Quick browser fix function.
+    
+    Args:
+        force_reinstall: Force complete reinstall
+    
+    Returns:
+        True if successful
+    """
+    fixer = BrowserFixer()
+    return fixer.fix_browser_issues(force_reinstall)
+
+
+def diagnose_browsers() -> Dict[str, bool]:
+    """
+    Quick browser diagnosis.
+    
+    Returns:
+        Dictionary with diagnosis results
+    """
+    fixer = BrowserFixer()
+    return fixer.diagnose_browser_issues()
+
+
+def get_browser_status() -> Dict[str, str]:
+    """
+    Get browser status information.
+    
+    Returns:
+        Dictionary with browser info
+    """
+    fixer = BrowserFixer()
+    return fixer.get_browser_info()

unrealon_installer/core.py

@@ -0,0 +1,166 @@
+"""
+Core installer logic. Clean and simple.
+"""
+
+import os
+import sys
+import subprocess
+import platform
+from pathlib import Path
+from typing import Dict, Any
+
+from .platform import apply_platform_fixes, check_system_requirements
+from .templates import TemplateEngine
+from .browser_fixes import fix_browsers, diagnose_browsers
+
+
+def install_parser(parser_name: str, parser_path: str = ".") -> bool:
+    """
+    Install everything for a UnrealOn parser.
+    
+    Args:
+        parser_name: Name like "upbit_concurrent"
+        parser_path: Path to parser directory
+    
+    Returns:
+        True if success, False if failed
+    """
+    print(f"🚀 Installing {parser_name}")
+    print("=" * 40)
+    
+    parser_dir = Path(parser_path).resolve()
+    os.chdir(parser_dir)
+    
+    # 1. Apply platform fixes
+    print("🔧 Applying platform fixes...")
+    apply_platform_fixes()
+    print("✅ Platform fixes applied")
+    
+    # 2. Check system
+    print("🔍 Checking system...")
+    requirements = check_system_requirements()
+    failed = [k for k, v in requirements.items() if not v]
+    if failed:
+        print(f"❌ Missing: {', '.join(failed)}")
+        return False
+    
+    print(f"✅ Python {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}")
+    
+    # 3. Install dependencies
+    if not _install_dependencies():
+        return False
+    
+    # 4. Install browsers
+    if not _install_browsers():
+        return False
+    
+    # 5. Create batch files (Windows only)
+    if platform.system() == "Windows":
+        _create_batch_files(parser_name)
+    
+    print(f"\n✅ {parser_name} installed successfully!")
+    print("Run: python main.py 5 2")
+    if platform.system() == "Windows":
+        print("Or:  START.bat")
+    
+    return True
+
+
+def _install_dependencies() -> bool:
+    """Install Python dependencies."""
+    print("📦 Installing dependencies...")
+    
+    try:
+        # Check if requirements.txt exists
+        if Path("requirements.txt").exists():
+            subprocess.run([sys.executable, "-m", "pip", "install", "-r", "requirements.txt"], 
+                         check=True, capture_output=True)
+        else:
+            # Fallback to basic packages
+            subprocess.run([sys.executable, "-m", "pip", "install", "unrealon", "playwright"], 
+                         check=True, capture_output=True)
+        
+        print("✅ Dependencies installed")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Failed to install dependencies: {e}")
+        return False
+
+
+def _install_browsers() -> bool:
+    """Install Playwright browsers with smart fixing."""
+    print("🌐 Installing browsers...")
+    
+    # First, diagnose any issues
+    issues = diagnose_browsers()
+    
+    # If there are issues, try to fix them
+    if not all(issues.values()):
+        print("🔧 Detected browser issues, applying fixes...")
+        if fix_browsers(force_reinstall=False):
+            print("✅ Browser issues fixed")
+            return True
+        else:
+            print("❌ Could not fix browser issues")
+            return False
+    
+    # If no issues, just install normally
+    try:
+        subprocess.run([sys.executable, "-m", "playwright", "install", "chromium"], 
+                     check=True, capture_output=True)
+        print("✅ Browsers installed")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"⚠️  Normal install failed, trying fix: {e}")
+        # Try fixing as fallback
+        return fix_browsers(force_reinstall=True)
+
+
+def _create_batch_files(parser_name: str):
+    """Create Windows batch files using Jinja2 templates."""
+    print("🪟 Creating Windows batch files...")
+    
+    # Detect parser config
+    config = _detect_parser_config()
+    
+    # Create template engine
+    engine = TemplateEngine()
+    
+    # Generate batch files
+    start_content = engine.render_start_bat(parser_name, config)
+    Path("START.bat").write_text(start_content, encoding="utf-8")
+    
+    quick_content = engine.render_quick_run_bat(parser_name, config)
+    Path("QUICK_RUN.bat").write_text(quick_content, encoding="utf-8")
+    
+    test_content = engine.render_test_bat(parser_name, config)
+    Path("TEST.bat").write_text(test_content, encoding="utf-8")
+    
+    print("✅ Created START.bat, QUICK_RUN.bat, TEST.bat")
+
+
+def _detect_parser_config() -> Dict[str, Any]:
+    """Detect parser configuration from files."""
+    config = {
+        'browsers_needed': ['chromium'],
+        'proxy_support': False,
+        'supports_persistent': False
+    }
+    
+    # Check main.py for persistent mode support
+    if Path("main.py").exists():
+        main_content = Path("main.py").read_text()
+        if "--persistent" in main_content:
+            config['supports_persistent'] = True
+    
+    # Check for proxy config
+    if Path("src/proxy_config.py").exists() or Path("proxy_config.py").exists():
+        config['proxy_support'] = True
+    
+    # Check pyproject.toml for browser requirements
+    if Path("pyproject.toml").exists():
+        toml_content = Path("pyproject.toml").read_text()
+        if "firefox" in toml_content.lower():
+            config['browsers_needed'].append('firefox')
+    
+    return config

unrealon_installer/platform.py

@@ -0,0 +1,122 @@
+"""
+Platform compatibility fixes. Clean and simple.
+"""
+
+import asyncio
+import sys
+import platform
+import warnings
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def apply_platform_fixes():
+    """Apply all necessary platform fixes automatically."""
+    system = platform.system()
+    fixes = []
+    
+    if system == "Windows":
+        fixes.extend(_apply_windows_fixes())
+    elif system == "Darwin":  # macOS
+        fixes.extend(_apply_macos_fixes())
+    elif system == "Linux":
+        fixes.extend(_apply_linux_fixes())
+    
+    if fixes:
+        logger.info(f"✅ Applied platform fixes: {', '.join(fixes)}")
+    
+    return fixes
+
+
+def _apply_windows_fixes():
+    """Windows-specific fixes."""
+    fixes = []
+    
+    # Asyncio event loop policy
+    if sys.version_info >= (3, 8):
+        try:
+            asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
+            fixes.append("ProactorEventLoop")
+        except Exception:
+            pass
+    
+    # Console encoding
+    try:
+        if hasattr(sys.stdout, 'reconfigure'):
+            sys.stdout.reconfigure(encoding='utf-8')
+            sys.stderr.reconfigure(encoding='utf-8')
+            fixes.append("UTF-8 encoding")
+    except Exception:
+        pass
+    
+    # Suppress warnings
+    warnings.filterwarnings("ignore", category=ResourceWarning)
+    fixes.append("ResourceWarning suppression")
+    
+    return fixes
+
+
+def _apply_macos_fixes():
+    """macOS-specific fixes."""
+    fixes = []
+    
+    # SSL context fix
+    try:
+        import ssl
+        ssl._create_default_https_context = ssl._create_unverified_context
+        fixes.append("SSL context")
+    except Exception:
+        pass
+    
+    # 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))
+            fixes.append("File descriptor limit")
+    except Exception:
+        pass
+    
+    return fixes
+
+
+def _apply_linux_fixes():
+    """Linux-specific fixes."""
+    fixes = []
+    
+    # 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))
+            fixes.append("File descriptor limit")
+    except Exception:
+        pass
+    
+    # Headless display
+    import os
+    if not os.environ.get('DISPLAY'):
+        os.environ['DISPLAY'] = ':99'
+        fixes.append("Headless display")
+    
+    return fixes
+
+
+def get_platform_info():
+    """Get platform information."""
+    return {
+        'platform': platform.system(),
+        'architecture': platform.architecture()[0],
+        'python_version': f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+    }
+
+
+def check_system_requirements():
+    """Check if system meets requirements."""
+    return {
+        'python_version': sys.version_info >= (3, 9),
+        'platform_supported': platform.system() in ['Windows', 'Darwin', 'Linux']
+    }

unrealon_installer/templates.py

@@ -0,0 +1,60 @@
+"""
+Jinja2 template engine for batch files.
+"""
+
+from pathlib import Path
+from typing import Dict, Any
+import json
+from jinja2 import Environment, FileSystemLoader
+
+
+class TemplateEngine:
+    """Jinja2-based template engine for Windows batch files."""
+    
+    def __init__(self):
+        # Get batch templates directory
+        templates_dir = Path(__file__).parent / "batch_templates"
+        
+        # Create Jinja2 environment
+        self.env = Environment(
+            loader=FileSystemLoader(str(templates_dir)),
+            trim_blocks=True,
+            lstrip_blocks=True
+        )
+    
+    def render_start_bat(self, parser_name: str, config: Dict[str, Any]) -> str:
+        """Render START.bat file."""
+        template = self.env.get_template('start.bat.j2')
+        
+        context = {
+            'parser_name': parser_name,
+            'config': config,
+            'config_json': json.dumps(config, indent=None),
+            'browsers_list': ', '.join(config.get('browsers_needed', ['chromium'])),
+            'has_proxy': config.get('proxy_support', False),
+            'has_persistent': config.get('supports_persistent', False)
+        }
+        
+        return template.render(**context)
+    
+    def render_quick_run_bat(self, parser_name: str, config: Dict[str, Any]) -> str:
+        """Render QUICK_RUN.bat file."""
+        template = self.env.get_template('quick_run.bat.j2')
+        
+        context = {
+            'parser_name': parser_name,
+            'config': config
+        }
+        
+        return template.render(**context)
+    
+    def render_test_bat(self, parser_name: str, config: Dict[str, Any]) -> str:
+        """Render TEST.bat file."""
+        template = self.env.get_template('test.bat.j2')
+        
+        context = {
+            'parser_name': parser_name,
+            'config': config
+        }
+        
+        return template.render(**context)

unrealon_driver/utils/platform_compatibility.py

@@ -1,205 +0,0 @@
-"""
-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()