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

unrealon_browser/managers/cookies.py

@@ -8,13 +8,27 @@ import asyncio
 from pathlib import Path
 from typing import Dict, List, Optional, Any, Union
 from datetime import datetime, timezone
+import logging
 
 # Browser DTOs
 from unrealon_browser.dto import ProxyInfo, CookieMetadata
+from pydantic import BaseModel
 
 # Playwright imports
 from playwright.async_api import Page, BrowserContext
 
+logger = logging.getLogger(__name__)
+
+
+class CookieSet(BaseModel):
+    proxy_info: ProxyInfo
+    cookies: Dict[str, str]
+    metadata: CookieMetadata
+
+
+class CookieStorage(BaseModel):
+    cookies_array: List[CookieSet]
+
 
 class CookieManager:
     """
@@ -28,11 +42,12 @@ class CookieManager:
     - Support for multiple parsers
     """
 
-    def __init__(self, cookies_dir: str = "cookies", parser_name: str = "default_parser"):
+    def __init__(self, cookies_dir: str = "cookies", parser_name: str = "default_parser", logger_bridge=None):
         """Initialize cookie manager"""
         self.cookies_dir = Path(cookies_dir)
         self.parser_name = parser_name
         self.cookies_file = self.cookies_dir / f"{parser_name}_cookies.json"
+        self.logger_bridge = logger_bridge
 
         # Create cookies directory if it doesn't exist
         self.cookies_dir.mkdir(parents=True, exist_ok=True)
@@ -48,6 +63,26 @@ class CookieManager:
         # Load existing cookies
         self._load_cookies_from_file()
 
+    def _logger(self, message: str, level: str = "info") -> None:
+        if self.logger_bridge:
+            if level == "info":
+                self.logger_bridge.log_info(message)
+            elif level == "error":
+                self.logger_bridge.log_error(message)
+            elif level == "warning":
+                self.logger_bridge.log_warning(message)
+            else:
+                self.logger_bridge.log_info(message)
+        else:
+            if level == "info":
+                logger.info(message)
+            elif level == "error":
+                logger.error(message)
+            elif level == "warning":
+                logger.warning(message)
+            else:
+                logger.info(message)
+
     def _generate_proxy_key(self, proxy_info: ProxyInfo) -> str:
         """Generate unique key for proxy configuration"""
         return f"{proxy_info.host}:{proxy_info.port}"
@@ -68,12 +103,12 @@ class CookieManager:
                     self._current_cookies[proxy_key] = cookie_set
 
                 self._proxies_with_cookies = len(self._current_cookies)
-                print(f"🍪 Loaded cookies for {self._proxies_with_cookies} proxies")
+                self._logger(f"🍪 Loaded cookies for {self._proxies_with_cookies} proxies", "info")
             else:
-                print(f"🍪 No existing cookies file found, starting fresh")
+                self._logger(f"🍪 No existing cookies file found, starting fresh", "info")
 
         except Exception as e:
-            print(f"❌ Error loading cookies: {e}")
+            self._logger(f"❌ Error loading cookies: {e}", "error")
             self._current_cookies = {}
 
     def _save_cookies_to_file(self) -> None:
@@ -87,10 +122,10 @@ class CookieManager:
             with open(self.cookies_file, "w", encoding="utf-8") as f:
                 json.dump(storage.model_dump(), f, indent=2, ensure_ascii=False, default=str)
 
-            print(f"💾 Saved cookies for {len(cookies_array)} proxies to {self.cookies_file}")
+            self._logger(f"💾 Saved cookies for {len(cookies_array)} proxies to {self.cookies_file}", "info")
 
         except Exception as e:
-            print(f"❌ Error saving cookies: {e}")
+            self._logger(f"❌ Error saving cookies: {e}", "error")
 
     async def load_cookies_for_proxy(self, page: Page, proxy_info: ProxyInfo) -> bool:
         """
@@ -108,7 +143,7 @@ class CookieManager:
             proxy_key = self._generate_proxy_key(proxy_info)
 
             if proxy_key not in self._current_cookies:
-                print(f"🍪 No cookies found for proxy {proxy_key}")
+                self._logger(f"🍪 No cookies found for proxy {proxy_key}", "info")
                 return False
 
             cookie_set = self._current_cookies[proxy_key]
@@ -130,12 +165,12 @@ class CookieManager:
             await context.add_cookies(playwright_cookies)
 
             self._cookies_loaded += 1
-            print(f"✅ Loaded {len(playwright_cookies)} cookies for proxy {proxy_key}")
+            self._logger(f"✅ Loaded {len(playwright_cookies)} cookies for proxy {proxy_key}", "info")
 
             return True
 
         except Exception as e:
-            print(f"❌ Error loading cookies for proxy {proxy_info.host}:{proxy_info.port}: {e}")
+            self._logger(f"❌ Error loading cookies for proxy {proxy_info.host}:{proxy_info.port}: {e}", "error")
             return False
 
     async def save_cookies_with_proxy(self, page: Page, proxy_info: ProxyInfo) -> bool:
@@ -156,7 +191,7 @@ class CookieManager:
             playwright_cookies = await context.cookies()
 
             if not playwright_cookies:
-                print(f"🍪 No cookies to save for proxy {proxy_info.host}:{proxy_info.port}")
+                self._logger(f"🍪 No cookies to save for proxy {proxy_info.host}:{proxy_info.port}", "info")
                 return False
 
             # Convert to our format
@@ -188,12 +223,12 @@ class CookieManager:
             self._cookies_saved += 1
             self._proxies_with_cookies = len(self._current_cookies)
 
-            print(f"💾 Saved {len(cookies_dict)} cookies for proxy {proxy_key}")
+            self._logger(f"💾 Saved {len(cookies_dict)} cookies for proxy {proxy_key}", "info")
 
             return True
 
         except Exception as e:
-            print(f"❌ Error saving cookies for proxy {proxy_info.host}:{proxy_info.port}: {e}")
+            self._logger(f"❌ Error saving cookies for proxy {proxy_info.host}:{proxy_info.port}: {e}", "error")
             return False
 
     def get_proxies_with_cookies(self) -> List[ProxyInfo]:
@@ -222,7 +257,7 @@ class CookieManager:
             del self._current_cookies[proxy_key]
             self._save_cookies_to_file()
             self._proxies_with_cookies = len(self._current_cookies)
-            print(f"🗑️ Cleared cookies for proxy {proxy_key}")
+            self._logger(f"🗑️ Cleared cookies for proxy {proxy_key}", "info")
             return True
 
         return False
@@ -232,7 +267,7 @@ class CookieManager:
         self._current_cookies.clear()
         self._save_cookies_to_file()
         self._proxies_with_cookies = 0
-        print("🗑️ Cleared all cookies")
+        self._logger("🗑️ Cleared all cookies", "info")
 
     def cleanup_old_cookies(self, max_age_days: int = 30) -> int:
         """
@@ -262,13 +297,11 @@ class CookieManager:
         if removed_count > 0:
             self._save_cookies_to_file()
             self._proxies_with_cookies = len(self._current_cookies)
-            print(f"🧹 Cleaned up {removed_count} old cookie sets (>{max_age_days} days)")
+            self._logger(f"🧹 Cleaned up {removed_count} old cookie sets (>{max_age_days} days)", "info")
 
         return removed_count
 
-    async def test_cookies_with_proxy(
-        self, page: Page, proxy_info: ProxyInfo, test_url: str = "https://httpbin.org/cookies"
-    ) -> Dict[str, Any]:
+    async def test_cookies_with_proxy(self, page: Page, proxy_info: ProxyInfo, test_url: str = "https://httpbin.org/cookies") -> Dict[str, Any]:
         """
         Test cookie functionality with specific proxy
 
@@ -322,9 +355,7 @@ class CookieManager:
             "cookies_loaded": self._cookies_loaded,
             "total_cookie_sets": len(self._current_cookies),
             "storage_file_exists": self.cookies_file.exists(),
-            "storage_file_size_bytes": (
-                self.cookies_file.stat().st_size if self.cookies_file.exists() else 0
-            ),
+            "storage_file_size_bytes": (self.cookies_file.stat().st_size if self.cookies_file.exists() else 0),
         }
 
     def print_statistics(self) -> None:
@@ -341,14 +372,12 @@ class CookieManager:
 
         # Show proxy details
         if self._current_cookies:
-            print("   Cookie details:")
+            self._logger("   Cookie details:", "info")
             for proxy_key, cookie_set in self._current_cookies.items():
                 metadata = cookie_set.metadata
-                print(
-                    f"     {proxy_key}: {metadata.cookies_count} cookies (saved {metadata.saved_at.strftime('%Y-%m-%d %H:%M')})"
-                )
+                self._logger(f"     {proxy_key}: {metadata.cookies_count} cookies (saved {metadata.saved_at.strftime('%Y-%m-%d %H:%M')})", "info")
         else:
-            print("   No cookies stored")
+            self._logger("   No cookies stored", "info")
 
     def export_cookies_for_proxy(self, proxy_info: ProxyInfo) -> Optional[Dict[str, Any]]:
         """
@@ -387,9 +416,9 @@ class CookieManager:
             self._save_cookies_to_file()
             self._proxies_with_cookies = len(self._current_cookies)
 
-            print(f"📥 Imported cookies for proxy {proxy_key}")
+            self._logger(f"📥 Imported cookies for proxy {proxy_key}", "info")
             return True
 
         except Exception as e:
-            print(f"❌ Error importing cookies: {e}")
+            self._logger(f"❌ Error importing cookies: {e}", "error")
             return False

unrealon_browser/managers/logger_bridge.py

@@ -14,8 +14,16 @@ from unrealon_browser.dto import (
     CaptchaDetectionResult,
 )
 
-# Import from unrealon_driver
-from unrealon_driver.parser.managers.logging import LoggingManager, LoggingConfig, LogLevel, get_logging_manager
+# Smart logging with fallback to avoid circular imports
+import logging
+
+# Try to import smart logging, fallback to standard logging
+try:
+    from unrealon_driver.smart_logging import create_unified_logger
+    from unrealon_driver.smart_logging.unified_logger import UnifiedLoggerConfig
+    SMART_LOGGING_AVAILABLE = True
+except ImportError:
+    SMART_LOGGING_AVAILABLE = False
 
 
 class BrowserLoggerBridge:
@@ -29,17 +37,41 @@ class BrowserLoggerBridge:
     def __init__(
         self,
         session_id: Optional[str] = None,
-        bridge_client: Optional[Any] = None,
+        parser_id: Optional[str] = None,
+        bridge_logs_url: Optional[str] = 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)
+        self.parser_id = parser_id or f"browser_{uuid.uuid4().hex[:8]}"
+
+        # Initialize logger based on availability
+        if SMART_LOGGING_AVAILABLE:
+            # Use smart logging if available
+            self.logger = create_unified_logger(
+                parser_id=self.parser_id,
+                parser_name="unrealon_browser",
+                bridge_logs_url=bridge_logs_url,
+                console_enabled=enable_console,
+            )
+            # Set session context
+            self.logger.set_session(self.session_id)
+            self._use_smart_logging = True
+        else:
+            # Fallback to standard Python logging
+            self.logger = logging.getLogger(f"unrealon_browser.{self.parser_id}")
+            self.logger.setLevel(logging.DEBUG)
+            
+            # Add console handler if needed
+            if enable_console and not self.logger.handlers:
+                handler = logging.StreamHandler()
+                formatter = logging.Formatter(
+                    '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+                )
+                handler.setFormatter(formatter)
+                self.logger.addHandler(handler)
+            
+            self._use_smart_logging = False
 
         # Statistics
         self._events_logged = 0
@@ -56,25 +88,49 @@ class BrowserLoggerBridge:
 
         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"""
+    def _log(self, level: str, message: str, **context: Any) -> None:
+        """Universal logging method"""
         self._events_logged += 1
-        self.logger.debug(message, **context)
+        
+        if self._use_smart_logging:
+            # Use smart logging with context
+            getattr(self.logger, level)(message, **context)
+        else:
+            # Use standard logging with formatted context
+            context_str = f" {context}" if context else ""
+            getattr(self.logger, level)(f"{message}{context_str}")
+
+    def _log_debug(self, message: str, **context: Any) -> None:
+        """Debug level logging"""
+        self._log("debug", message, **context)
+        
+    def log_debug(self, message: str, **context: Any) -> None:
+        """Public debug level logging"""
+        self._log_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)
+        """Info level logging"""
+        self._log("info", message, **context)
+        
+    def log_info(self, message: str, **context: Any) -> None:
+        """Public info level logging"""
+        self._log_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)
+        """Warning level logging"""
+        self._log("warning", message, **context)
+        
+    def log_warning(self, message: str, **context: Any) -> None:
+        """Public warning level logging"""
+        self._log_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)
+        """Error level logging"""
+        self._log("error", message, **context)
+        
+    def log_error(self, message: str, **context: Any) -> None:
+        """Public error level logging"""
+        self._log_error(message, **context)
 
     # Browser-specific logging methods
     def log_browser_initialized(self, metadata: BrowserSession) -> None:
@@ -192,40 +248,44 @@ class BrowserLoggerBridge:
             "total_events_logged": self._events_logged,
             "browser_events": self._browser_events.copy(),
             "session_id": self.session_id,
-            "logger_stats": self.logger.get_log_stats(),
+            "parser_id": self.parser_id,
+            "logger_stats": {"events_logged": self._events_logged},
         }
 
     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']}")
+        self._log_info("\n📊 Browser Logger Bridge Statistics:")
+        self._log_info(f"   Total events logged: {stats['total_events_logged']}")
+        self._log_info(f"   Session ID: {stats['session_id']}")
 
-        print("   Browser events:")
+        self._log_info("   Browser events:")
         for event, count in stats["browser_events"].items():
-            print(f"     {event}: {count}")
+            self._log_info(f"     {event}: {count}")
 
-        print("   Logger stats:")
+        self._log_info("   Logger stats:")
         for key, value in stats["logger_stats"].items():
-            print(f"     {key}: {value}")
+            self._log_info(f"     {key}: {value}")
 
 
 # Factory function for easy integration
 def create_browser_logger_bridge(
     session_id: Optional[str] = None,
-    bridge_client: Optional[Any] = None,
+    parser_id: Optional[str] = None,
+    bridge_logs_url: Optional[str] = None,
     enable_console: bool = True,
 ) -> BrowserLoggerBridge:
     """
-    Create browser logger bridge with driver integration
+    Create browser logger bridge with smart logging integration
 
-    This function creates a logger bridge that uses the driver's LoggingManager
-    for consistent logging across the ecosystem.
+    This function creates a logger bridge that uses the driver's UnifiedLogger
+    for consistent logging across the ecosystem with Rich console, WebSocket batching,
+    and structured logging.
     """
     return BrowserLoggerBridge(
         session_id=session_id,
-        bridge_client=bridge_client,
+        parser_id=parser_id,
+        bridge_logs_url=bridge_logs_url,
         enable_console=enable_console,
     )