unrealon 1.0.9__py3-none-any.whl → 1.1.1__py3-none-any.whl

unrealon_browser/__init__.py

@@ -1,26 +1,69 @@
 """
-🌐 UnrealOn Browser v1.0 - Enterprise Browser Automation
-
+UnrealOn Browser - Independent Browser Automation Module
 Enterprise-grade browser automation with stealth capabilities and proxy integration.
-Service-based architecture following KISS principles.
+
+Based on proven patterns from unrealparser with modular architecture.
 """
 
-# Import everything from src
-from .src import *
+from importlib.metadata import version
+
+try:
+    __version__ = version("unrealon")
+except Exception:
+    __version__ = "0.1.0"
+
+# Core browser management
+from .core import BrowserManager
 
-# Description
-__description__ = "Enterprise browser automation with stealth capabilities"
+# Specialized managers
+from .managers import (
+    StealthManager,
+    ProfileManager,
+    CookieManager,
+    CaptchaDetector,
+)
+
+# Note: CLI interfaces are available as standalone modules
+# Import them directly: from unrealon_browser.cli import BrowserCLI, CookiesCLI
 
+# API client
+try:
+    from .api import BrowserApiClient
+except ImportError:
+    BrowserApiClient = None
 
-# Import from centralized config
-from unrealon.sdk_config import (
-    VERSION as __version__,
-    AUTHOR as __author__,
-    AUTHOR_EMAIL as __email__,
-    LICENSE as __license__,
-    PROJECT_URL as __url__,
-    VERSION_INFO,
-    PROJECT_INFO,
-    get_version,
-    is_debug_mode,
+
+# Data models
+from .dto import (
+    BrowserConfig,
+    BrowserType,
+    BrowserMode,
+    BrowserSessionStatus,
+    BrowserSession,
+    ProxyInfo,
+    CaptchaType,
+    CaptchaStatus,
+    CaptchaDetectionResult,
 )
+
+__all__ = [
+    # Core
+    "BrowserManager",
+    # Managers
+    "StealthManager",
+    "ProfileManager",
+    "CookieManager",
+    "CaptchaDetector",
+    # API
+    "BrowserApiClient",
+    # DTOs (CLI available as: from unrealon_browser.cli import BrowserCLI, CookiesCLI)
+    "BrowserConfig",
+    "BrowserType",
+    "BrowserMode",
+    "BrowserSessionStatus",
+    "BrowserSession",
+    "ProxyInfo",
+    "CaptchaType",
+    "CaptchaStatus",
+    "CaptchaDetectionResult",
+]

unrealon_browser/{src/cli → cli}/browser_cli.py

@@ -13,7 +13,7 @@ from rich.panel import Panel
 from rich.table import Table
 
 # Use existing unrealon_browser API
-from unrealon_browser import BrowserManager, BrowserConfig, BrowserType, BrowserMode, StealthLevel
+from unrealon_browser import BrowserManager, BrowserConfig, BrowserType, BrowserMode
 
 console = Console()
 
@@ -106,9 +106,7 @@ def interactive():
 def _interactive_launch():
     """Interactive browser launch."""
     parser = questionary.text("Parser name:", default="default_parser").ask()
-    browser_type = questionary.select(
-        "Browser type:", choices=["chromium", "firefox", "webkit"]
-    ).ask()
+    browser_type = questionary.select("Browser type:", choices=["chromium", "firefox", "webkit"]).ask()
     headless = questionary.confirm("Headless mode?", default=False).ask()
     stealth = questionary.select("Stealth level:", choices=["disabled", "basic", "advanced"]).ask()
     url = questionary.text("URL to navigate:", default="https://bot.sannysoft.com").ask()
@@ -151,9 +149,7 @@ def _show_browser_statistics():
     console.print(table)
 
 
-async def _run_browser_session(
-    parser: str, browser_type: str, headless: bool, stealth: str, url: str
-):
+async def _run_browser_session(parser: str, browser_type: str, headless: bool, stealth: str, url: str):
     """Simple wrapper using existing BrowserManager API."""
     try:
         # Use existing BrowserConfig
@@ -161,7 +157,7 @@ async def _run_browser_session(
             parser_name=parser,
             browser_type=BrowserType(browser_type.lower()),
             mode=BrowserMode.HEADLESS if headless else BrowserMode.HEADED,
-            stealth_level=StealthLevel(stealth.lower()),
+            # stealth_level removed - STEALTH ALWAYS ON!
         )
 
         # Use existing BrowserManager - no duplication!
@@ -170,9 +166,7 @@ async def _run_browser_session(
         console.print("[cyan]Using existing BrowserManager API...[/cyan]")
 
         await browser_manager.initialize_async()
-        console.print(
-            f"[green]✅ Browser ready (Session: {browser_manager.session_metadata.session_id})[/green]"
-        )
+        console.print(f"[green]✅ Browser ready (Session: {browser_manager.session_metadata.session_id})[/green]")
 
         result = await browser_manager.navigate_async(url)
 
@@ -200,7 +194,7 @@ async def _run_stealth_test(parser: str, url: str):
             parser_name=parser,
             browser_type=BrowserType.CHROMIUM,
             mode=BrowserMode.HEADLESS,
-            stealth_level=StealthLevel.ADVANCED,
+            # stealth_level removed - STEALTH ALWAYS ON!
         )
 
         browser_manager = BrowserManager(config)
@@ -222,7 +216,6 @@ async def _run_automation_workflow(parser: str, url: str):
         config = BrowserConfig(
             parser_name=parser,
             browser_type=BrowserType.CHROMIUM,
-            stealth_level=StealthLevel.ADVANCED,
         )
 
         browser_manager = BrowserManager(config)

unrealon_browser/{src/cli → cli}/cookies_cli.py

@@ -393,5 +393,9 @@ def _clear_proxy_cookies(cookies_file: Path, proxy_key: str):
         console.print(f"[red]❌ Error clearing cookies: {e}[/red]")
 
 
-if __name__ == "__main__":
+def main():
+    """Main entry point for cookies CLI."""
     cookies()
+
+if __name__ == "__main__":
+    main()

unrealon_browser/{src/core → core}/browser_manager.py

@@ -11,7 +11,7 @@ from datetime import datetime, timezone
 from typing import Optional, Dict, Any, Union
 from pathlib import Path
 
-from unrealon_browser.src.dto import (
+from unrealon_browser.dto import (
     BrowserConfig,
     BrowserSession,
     BrowserSessionStatus,
@@ -22,7 +22,7 @@ from unrealon_browser.src.dto import (
     PageResult,
     ProxyInfo,
 )
-from unrealon_browser.src.managers import (
+from unrealon_browser.managers import (
     StealthManager,
     ProfileManager,
     CookieManager,

unrealon_browser/{src/managers → managers}/captcha.py

@@ -8,7 +8,7 @@ from typing import Optional, Dict, Any, List
 from datetime import datetime, timezone
 
 # Browser DTOs
-from unrealon_browser.src.dto import (
+from unrealon_browser.dto import (
     CaptchaType,
     CaptchaStatus,
     CaptchaDetection,

unrealon_browser/{src/managers → managers}/cookies.py

@@ -10,7 +10,7 @@ from typing import Dict, List, Optional, Any, Union
 from datetime import datetime, timezone
 
 # Browser DTOs
-from unrealon_browser.src.dto import ProxyInfo, CookieMetadata
+from unrealon_browser.dto import ProxyInfo, CookieMetadata
 
 # Playwright imports
 from playwright.async_api import Page, BrowserContext

unrealon_browser/managers/logger_bridge.py

@@ -0,0 +1,231 @@
+"""
+Logger Bridge - Integration bridge between unrealon_browser and unrealon_driver loggers
+Layer 2.5: Logging Integration - Connects independent browser module with driver enterprise loggers
+"""
+
+from typing import Optional, Any, Dict
+from datetime import datetime, timezone
+import uuid
+
+# Browser DTOs
+from unrealon_browser.dto import (
+    BrowserSessionStatus,
+    BrowserSession,
+    CaptchaDetectionResult,
+)
+
+# Import from unrealon_driver
+from unrealon_driver.parser.managers.logging import LoggingManager, LoggingConfig, LogLevel, get_logging_manager
+
+
+class BrowserLoggerBridge:
+    """
+    Bridge between unrealon_browser and unrealon_driver loggers
+
+    Provides unified logging interface for browser operations using
+    the driver's LoggingManager for consistent logging across the ecosystem.
+    """
+
+    def __init__(
+        self,
+        session_id: Optional[str] = None,
+        bridge_client: Optional[Any] = None,
+        enable_console: bool = True,
+    ):
+        """Initialize logger bridge"""
+        self.session_id = session_id or str(uuid.uuid4())
+
+        # Create logging manager from driver
+        self.logger = get_logging_manager(parser_name="unrealon_browser", bridge_client=bridge_client, console_enabled=enable_console, file_enabled=True, bridge_enabled=bridge_client is not None)
+
+        # Set session context
+        self.logger.set_session(self.session_id)
+
+        # Statistics
+        self._events_logged = 0
+        self._browser_events = {
+            "browser_initialized": 0,
+            "navigation_success": 0,
+            "navigation_failed": 0,
+            "stealth_applied": 0,
+            "captcha_detected": 0,
+            "captcha_solved": 0,
+            "profile_created": 0,
+            "cookies_saved": 0,
+        }
+
+        self._log_debug(f"BrowserLoggerBridge initialized for session {self.session_id}")
+
+    def _log_debug(self, message: str, **context: Any) -> None:
+        """Debug level logging using driver logger"""
+        self._events_logged += 1
+        self.logger.debug(message, **context)
+
+    def _log_info(self, message: str, **context: Any) -> None:
+        """Info level logging using driver logger"""
+        self._events_logged += 1
+        self.logger.info(message, **context)
+
+    def _log_warning(self, message: str, **context: Any) -> None:
+        """Warning level logging using driver logger"""
+        self._events_logged += 1
+        self.logger.warning(message, **context)
+
+    def _log_error(self, message: str, **context: Any) -> None:
+        """Error level logging using driver logger"""
+        self._events_logged += 1
+        self.logger.error(message, **context)
+
+    # Browser-specific logging methods
+    def log_browser_initialized(self, metadata: BrowserSession) -> None:
+        """Log browser initialization"""
+        self._browser_events["browser_initialized"] += 1
+        self._log_info(
+            f"Browser session initialized: {metadata.session_id}",
+            session_id=metadata.session_id,
+            parser_name=metadata.parser_name,
+            browser_type=metadata.browser_type or "unknown",
+            stealth_level="unknown",
+            proxy_host=getattr(metadata.proxy, "host", None) if metadata.proxy else None,
+            proxy_port=getattr(metadata.proxy, "port", None) if metadata.proxy else None,
+        )
+
+    def log_navigation_success(self, url: str, title: str, duration_ms: float) -> None:
+        """Log successful navigation"""
+        self._browser_events["navigation_success"] += 1
+        self._log_info(
+            f"Navigation successful: {title}",
+            url=url,
+            title=title,
+            duration_ms=duration_ms,
+            navigation_type="browser_navigation",
+        )
+
+    def log_navigation_failed(self, url: str, error: str, duration_ms: float) -> None:
+        """Log failed navigation"""
+        self._browser_events["navigation_failed"] += 1
+        self._log_error(
+            f"Navigation failed: {url}",
+            url=url,
+            error_message=error,
+            duration_ms=duration_ms,
+            navigation_type="browser_navigation",
+        )
+
+    def log_stealth_applied(self, stealth_level: str, success: bool) -> None:
+        """Log stealth application - 🔥 STEALTH ALWAYS ON!"""
+        self._browser_events["stealth_applied"] += 1
+
+        if success:
+            self._log_info(
+                f"Stealth measures applied: {stealth_level}",
+                stealth_level=stealth_level,
+                stealth_success=True,
+            )
+        else:
+            self._log_warning(
+                f"Stealth application failed: {stealth_level}",
+                stealth_level=stealth_level,
+                stealth_success=False,
+            )
+
+    def log_captcha_detected(self, result: CaptchaDetectionResult) -> None:
+        """Log captcha detection"""
+        self._browser_events["captcha_detected"] += 1
+        self._log_warning(
+            f"Captcha detected: {result.captcha_type.value}",
+            captcha_type=result.captcha_type.value,
+            page_url=result.page_url,
+            proxy_host=result.proxy_host,
+            proxy_port=result.proxy_port,
+            detected_at=result.detected_at.isoformat(),
+        )
+
+    def log_captcha_solved(self, proxy_host: str, proxy_port: int, manual: bool = True) -> None:
+        """Log captcha resolution"""
+        self._browser_events["captcha_solved"] += 1
+        self._log_info(
+            f"Captcha solved for proxy {proxy_host}:{proxy_port}",
+            proxy_host=proxy_host,
+            proxy_port=proxy_port,
+            resolution_method="manual" if manual else "automatic",
+            cookies_will_be_saved=True,
+        )
+
+    def log_profile_created(self, profile_name: str, proxy_info: Optional[Dict[str, Any]] = None) -> None:
+        """Log profile creation"""
+        self._browser_events["profile_created"] += 1
+        context = {"profile_name": profile_name}
+        if proxy_info:
+            context.update(proxy_info)
+
+        self._log_info(f"Browser profile created: {profile_name}", **context)
+
+    def log_cookies_saved(self, proxy_host: str, proxy_port: int, cookies_count: int, parser_name: str) -> None:
+        """Log cookie saving"""
+        self._browser_events["cookies_saved"] += 1
+        self._log_info(
+            f"Cookies saved for {proxy_host}:{proxy_port}",
+            proxy_host=proxy_host,
+            proxy_port=proxy_port,
+            cookies_count=cookies_count,
+            parser_name=parser_name,
+            storage_type="proxy_bound",
+        )
+
+    def log_performance_metric(self, metric_name: str, value: float, unit: str, threshold: Optional[float] = None) -> None:
+        """Log performance metrics"""
+        exceeded = threshold is not None and value > threshold
+        level = "WARNING" if exceeded else "DEBUG"
+        message = f"Performance: {metric_name} = {value} {unit}"
+        if threshold:
+            message += f" (threshold: {threshold})"
+
+        if exceeded:
+            self._log_warning(message, metric=metric_name, value=value, unit=unit, threshold=threshold)
+        else:
+            self._log_debug(message, metric=metric_name, value=value, unit=unit, threshold=threshold)
+
+    def get_statistics(self) -> Dict[str, Any]:
+        """Get logging statistics"""
+        return {
+            "total_events_logged": self._events_logged,
+            "browser_events": self._browser_events.copy(),
+            "session_id": self.session_id,
+            "logger_stats": self.logger.get_log_stats(),
+        }
+
+    def print_statistics(self) -> None:
+        """Print logging statistics"""
+        stats = self.get_statistics()
+
+        print("\n📊 Browser Logger Bridge Statistics:")
+        print(f"   Total events logged: {stats['total_events_logged']}")
+        print(f"   Session ID: {stats['session_id']}")
+
+        print("   Browser events:")
+        for event, count in stats["browser_events"].items():
+            print(f"     {event}: {count}")
+
+        print("   Logger stats:")
+        for key, value in stats["logger_stats"].items():
+            print(f"     {key}: {value}")
+
+
+# Factory function for easy integration
+def create_browser_logger_bridge(
+    session_id: Optional[str] = None,
+    bridge_client: Optional[Any] = None,
+    enable_console: bool = True,
+) -> BrowserLoggerBridge:
+    """
+    Create browser logger bridge with driver integration
+
+    This function creates a logger bridge that uses the driver's LoggingManager
+    for consistent logging across the ecosystem.
+    """
+    return BrowserLoggerBridge(
+        session_id=session_id,
+        bridge_client=bridge_client,
+        enable_console=enable_console,
+    )

unrealon_browser/{src/managers → managers}/profile.py

@@ -10,7 +10,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Dict, Any, Optional, List, Union
 
-from unrealon_browser.src.dto import ProfileType, ProxyInfo
+from unrealon_browser.dto import ProfileType, ProxyInfo
 
 
 class ProfileManager:

unrealon_driver/__init__.py

@@ -1,26 +1,80 @@
 """
-🚀 UnrealOn Driver - Simple Parser Development Tools
+🚀 UnrealOn Driver v4.0 - Modern Parser Framework
 
-Clean, modular, powerful tools for building web scrapers and parsers.
-Service-based architecture following KISS principles.
-"""
+Revolutionary parser framework with specialized managers and zero configuration.
+Built on unrealon-rpc bridge with full Pydantic v2 compliance.
 
-# Import everything from src
-from .src import *
+Key Features:
+- 🎯 Zero Configuration: Everything works out of the box
+- 🏗️ Manager Architecture: Specialized managers for different concerns
+- 🌐 Smart Browser: Intelligent automation with stealth
+- 🧹 HTML Cleaning: Optimized for LLM analysis
+- 🔌 Bridge Integration: Built on unrealon-rpc bridge
+- 📊 Built-in Monitoring: Enterprise observability
+- 🛡️ Type Safety: Full Pydantic v2 compliance
+"""
 
-# Description
-__description__ = "Simple, modular parser development tools for UnrealOn SDK"
+from importlib.metadata import version
 
+try:
+    __version__ = version("unrealon")
+except Exception:
+    __version__ = "1.1.1"
 
-# Import from centralized config
-from unrealon.sdk_config import (
-    VERSION as __version__,
-    AUTHOR as __author__,
-    AUTHOR_EMAIL as __email__,
-    LICENSE as __license__,
-    PROJECT_URL as __url__,
-    VERSION_INFO,
-    PROJECT_INFO,
-    get_version,
-    is_debug_mode,
+from .parser import (
+    ParserManager,
+    ParserManagerConfig,
+    ParserStats,
+    get_parser_manager,
+    quick_parse,
+    ConfigManager,
+    ParserConfig,
+    ResultManager,
+    ParseResult,
+    ParseMetrics,
+    ErrorManager,
+    RetryConfig,
+    ErrorInfo,
+    LoggingManager,
+    LoggingConfig,
+    LogLevel,
+    HTMLManager,
+    HTMLCleaningConfig,
+    BrowserManager,
+    BrowserConfig,
 )
+from .exceptions import ParserError, BrowserError
+
+__all__ = [
+    # Main Parser Manager
+    "ParserManager",
+    "ParserManagerConfig",
+    "ParserStats",
+    "get_parser_manager",
+    "quick_parse",
+    # Individual Managers
+    "ConfigManager",
+    "ParserConfig",
+    "ResultManager",
+    "ParseResult",
+    "ParseMetrics",
+    "ErrorManager",
+    "RetryConfig",
+    "ErrorInfo",
+    "LoggingManager",
+    "LoggingConfig",
+    "LogLevel",
+    "HTMLManager",
+    "HTMLCleaningConfig",
+    "BrowserManager",
+    "BrowserConfig",
+    # Exceptions
+    "ParserError",
+    "BrowserError",
+    # Version
+    "__version__",
+]
+# Convenience aliases for backward compatibility
+Parser = ParserManager
+DriverLogger = LoggingManager
+get_driver_logger = LoggingManager

unrealon_driver/browser/__init__.py

@@ -0,0 +1,8 @@
+"""
+Browser automation module
+"""
+
+from .manager import BrowserManager
+from .config import BrowserConfig
+
+__all__ = ["BrowserManager", "BrowserConfig"]

unrealon_driver/browser/config.py

@@ -0,0 +1,74 @@
+"""
+Browser configuration with Pydantic v2
+"""
+
+from typing import Optional, Dict, Any, List
+from pathlib import Path
+from pydantic import BaseModel, Field
+
+
+class BrowserConfig(BaseModel):
+    """
+    Browser configuration with smart defaults
+    """
+    
+    # Browser type and mode
+    browser_type: str = Field("chromium", description="Browser type (chromium, firefox, webkit)")
+    headless: bool = Field(True, description="Run browser in headless mode")
+    
+    # Stealth and detection
+    stealth_mode: bool = Field(True, description="Enable stealth mode")
+    user_agent: Optional[str] = Field(None, description="Custom user agent")
+    viewport_width: int = Field(1920, description="Viewport width")
+    viewport_height: int = Field(1080, description="Viewport height")
+    
+    # Timeouts
+    page_timeout: int = Field(30000, description="Page load timeout in milliseconds")
+    navigation_timeout: int = Field(30000, description="Navigation timeout in milliseconds")
+    element_timeout: int = Field(10000, description="Element wait timeout in milliseconds")
+    
+    # Proxy settings
+    proxy_url: Optional[str] = Field(None, description="Proxy URL")
+    proxy_username: Optional[str] = Field(None, description="Proxy username")
+    proxy_password: Optional[str] = Field(None, description="Proxy password")
+    
+    # Cookie and session management
+    persist_cookies: bool = Field(True, description="Persist cookies between sessions")
+    cookies_file: Optional[Path] = Field(None, description="Path to cookies file")
+    
+    # Screenshots and debugging
+    screenshots_dir: Optional[Path] = Field(None, description="Screenshots directory")
+    save_screenshots: bool = Field(False, description="Save screenshots for debugging")
+    debug: bool = Field(False, description="Enable debug mode")
+    
+    # Performance settings
+    disable_images: bool = Field(False, description="Disable image loading")
+    disable_javascript: bool = Field(False, description="Disable JavaScript execution")
+    disable_css: bool = Field(False, description="Disable CSS loading")
+    
+    # Browser arguments
+    extra_args: List[str] = Field(default_factory=list, description="Additional browser arguments")
+    
+    # Additional settings
+    extra_config: Dict[str, Any] = Field(default_factory=dict, description="Additional configuration")
+    
+    class Config:
+        """Pydantic configuration"""
+        validate_assignment = True
+        extra = "forbid"
+        
+    def model_post_init(self, __context: Any) -> None:
+        """Post-initialization setup"""
+        # Setup directories
+        if not self.screenshots_dir:
+            self.screenshots_dir = Path.cwd() / "system" / "screenshots"
+            
+        if not self.cookies_file:
+            self.cookies_file = Path.cwd() / "system" / "cookies.json"
+            
+        # Create directories
+        if self.screenshots_dir:
+            self.screenshots_dir.mkdir(parents=True, exist_ok=True)
+            
+        if self.cookies_file:
+            self.cookies_file.parent.mkdir(parents=True, exist_ok=True)