unrealon 2.0.34__py3-none-any.whl → 2.0.35__py3-none-any.whl

{unrealon-2.0.34.dist-info → unrealon-2.0.35.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unrealon
-Version: 2.0.34
+Version: 2.0.35
 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.34.dist-info → unrealon-2.0.35.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=vPWQjoh_QAoKWFlKVQCPIuehNsWIY9HIN7z3QeGoxAc,32398
+unrealon_browser/core/browser_manager.py,sha256=gKx7M5eQQU7B8FYhQsrvJaB11An2ZH1Yc1PnED1HV1Y,31977
 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
@@ -14,11 +14,12 @@ unrealon_browser/dto/models/core.py,sha256=HvbwYG27rmmWtp401uws7lfalN_9QPad0M6ce
 unrealon_browser/dto/models/dataclasses.py,sha256=zqhJVyzp4CvtuTBsZwm6n6TodVWrZf9gkdDG-0_tgeA,2571
 unrealon_browser/dto/models/detection.py,sha256=ma9ZNIjPR7HnjqZaAj6ZoskiewPFiSn_FgFXSkgiQc8,2715
 unrealon_browser/dto/models/enums.py,sha256=Q4WzHdfSKf7dhKyX00i_Pvl2U8w3lBsxOYfSIoaQY3Q,1219
-unrealon_browser/dto/models/statistics.py,sha256=aIzJNV5r23VBxjhEoja4tXwI1Z7_UCw5zOaxuPya2E8,2728
-unrealon_browser/managers/__init__.py,sha256=lpa93ggEN93ucoi4FqnCG_sn-_aRlP1As7DBRogDSsQ,591
-unrealon_browser/managers/captcha.py,sha256=KGBO7sfq9XusAlcPByUFdIg-v6rlruzS2oHx-Zx28wo,21453
+unrealon_browser/dto/models/statistics.py,sha256=RbiMChC6EumFvzIoxfWp2eIqjkW4yOpWZTKsOHNtok8,2685
+unrealon_browser/managers/__init__.py,sha256=YDNpfdA-cRqn1xnX9xurgHC1x1zw0nLiPo7rPjikuzQ,679
+unrealon_browser/managers/captcha.py,sha256=JsAG1gjfwrOrNZd1N1HALtzOuJ6loEhCYZVKTylKubU,21488
 unrealon_browser/managers/cookies.py,sha256=r4VVnKLXH82vhU7qgtY-dF7KPf0Ie3QxGD3FEi6geFA,15085
-unrealon_browser/managers/logger_bridge.py,sha256=b6H9aq6AGv0s_g5bTH6ZFYoFINClsUejevlef3s1srw,10864
+unrealon_browser/managers/data_extraction_manager.py,sha256=dbbNgrqGvtMCgSxpliLxkD0PrAN0NrRrVpbN7iqcQKQ,10575
+unrealon_browser/managers/logger_bridge.py,sha256=aCaDVRS7ZksXYtIKCCQIBqsmD5n0cPpc__0o4c3Iah0,10366
 unrealon_browser/managers/page_wait_manager.py,sha256=UyZqiSfkjzahrxp9x1odXFIT_sFhZGvdECxWuIMCVBY,7876
 unrealon_browser/managers/profile.py,sha256=HjddlSeUry_65WPtF8CMkT7cfJ6X3Jap9kJaaZpwtAA,18956
 unrealon_browser/managers/script_manager.py,sha256=hVnEWDb2LM1rfnptFo1MtE0SGcYCoFA66udykmb5e1g,11581
@@ -101,9 +102,9 @@ unrealon_driver/driver/communication/session.py,sha256=DYN_Q3Qm3XuOi-dM8aNihJfQJ
 unrealon_driver/driver/communication/websocket_client.py,sha256=VPsICBvGHunuCGZvorvPCF01Qdvp7QWyTDX0hkYXRwo,7910
 unrealon_driver/driver/core/__init__.py,sha256=ZvJQp1zO7pj6tBNYTJk2fj-0ZMiQTQEk-I9hXalNsfg,235
 unrealon_driver/driver/core/config.py,sha256=jWJjRll19VlL4iM5Q-J3o9qwYeH89Iuj1_3KayM6fCk,5914
-unrealon_driver/driver/core/driver.py,sha256=NI-pdhnduRyHLsfFr8HmP2gp7pR1pWB4vBIJkMJ2cls,7886
+unrealon_driver/driver/core/driver.py,sha256=8rufKfvE7M1axB7ZyK28OINqsrBJcUyL0HVdqjK47ps,7950
 unrealon_driver/driver/factory/__init__.py,sha256=XrjBhOaLvC3MIG5PAFIYS_xYXFDz5JizpFvmQcwA7mU,189
-unrealon_driver/driver/factory/manager_factory.py,sha256=b-3tWKsnicTNygZ3zIDhBlSbGySPRPT1GYrFY32QQgo,5103
+unrealon_driver/driver/factory/manager_factory.py,sha256=BII7cH6-X8i_DMoHvcE72AakD3wuD44gWEK5K8WJJOg,5644
 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,21 +116,21 @@ unrealon_driver/driver/utilities/logging.py,sha256=2my2QnkAa6Hdw-TfO4oOQ94yGc-Cj
 unrealon_driver/driver/utilities/serialization.py,sha256=wTCSVrEloykiGN4K1JXbk2aqNKm7W90aWXmzhcLyAZc,2123
 unrealon_driver/installer/__init__.py,sha256=PraOjOg-cN1zOtuhPSTE5vCGPSMzWtEBYU8A05GWEf8,227
 unrealon_driver/installer/platform.py,sha256=U_8FJZk0C8M0ujpfzcpOPWEoUrT6asTNEIhsN0n2bCg,5081
-unrealon_driver/managers/__init__.py,sha256=zJJsOb6Oodg7l00v4ncKUytnyeaZM887pHY8-eSuWdU,981
+unrealon_driver/managers/__init__.py,sha256=LZUQXwpgqjStC5B4fIdwBJTwlB-4om_eQPhdGs7SJeo,1057
 unrealon_driver/managers/base.py,sha256=GkuXillg9uqqnx6RL682fmKgK-7JyqYlH6DFUgyN4F8,5445
-unrealon_driver/managers/browser.py,sha256=bc6O2NyC4FV82mb9sat48_k8s1c3IGY4i90ddMVWRIo,5432
+unrealon_driver/managers/browser.py,sha256=_b6YEOLqrgcD83eiVJOYvYqC5OJw_Nr4b4FmOa0uHaE,6906
 unrealon_driver/managers/cache.py,sha256=c0tPKQ5KFd_Un1U8mw3j1WPuycxg863MMWNMveVF_2I,3506
-unrealon_driver/managers/http.py,sha256=EjlpoTRuhpsgzzrEARxRlbGczzua7hnKFVq06bvCgTM,3624
+unrealon_driver/managers/http.py,sha256=NZ8VRRpVX2EsE_LMV0AYqb3HriOQCY8Qfkojg3pV7sE,7387
 unrealon_driver/managers/logger.py,sha256=PL3rA9ZQl12jJU0EiPAkLwJ6eDHQfIzr8-nc8bVivKQ,10526
 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/threading.py,sha256=yw2RlWxc2MBn0ZbPJ9h3eLIC5OFCvVkr8DQM7DhWO8M,3498
 unrealon_driver/managers/update.py,sha256=-hohVxGXpj5bZ6ZTQN6NH1RK9Pd6GVzCMtu3GS2SdcQ,3582
 unrealon_driver/utils/__init__.py,sha256=2Sz3eats5q4O2fDmefDuJt8M_zkN6xrS-9xXntWZWFc,168
 unrealon_driver/utils/time.py,sha256=Oxk1eicKeZl8ZWbf7gu1Ll716k6CpXmVj67FHSnPIsA,184
-unrealon-2.0.34.dist-info/LICENSE,sha256=eEH8mWZW49YMpl4Sh5MtKqkZ8aVTzKQXiNPEnvL14ns,1070
-unrealon-2.0.34.dist-info/METADATA,sha256=xZkorKxeW0f0dLynonoXpTlvHYvhbuPCiWzoHFep2Y4,15689
-unrealon-2.0.34.dist-info/WHEEL,sha256=pL8R0wFFS65tNSRnaOVrsw9EOkOqxLrlUPenUYnJKNo,91
-unrealon-2.0.34.dist-info/entry_points.txt,sha256=k0qM-eotpajkKUq-almJmxj9afhXprZ6IkvQkSdcKhI,104
-unrealon-2.0.34.dist-info/top_level.txt,sha256=Gu8IeIfIVfUxdi-h-F0nKMQxo15pjhHZ0aTadXTpRE8,47
-unrealon-2.0.34.dist-info/RECORD,,
+unrealon-2.0.35.dist-info/LICENSE,sha256=eEH8mWZW49YMpl4Sh5MtKqkZ8aVTzKQXiNPEnvL14ns,1070
+unrealon-2.0.35.dist-info/METADATA,sha256=5oIiWxcda_6_DCik53Vt5Xd4CsuyGA1yARkZXSvkOIY,15689
+unrealon-2.0.35.dist-info/WHEEL,sha256=pL8R0wFFS65tNSRnaOVrsw9EOkOqxLrlUPenUYnJKNo,91
+unrealon-2.0.35.dist-info/entry_points.txt,sha256=k0qM-eotpajkKUq-almJmxj9afhXprZ6IkvQkSdcKhI,104
+unrealon-2.0.35.dist-info/top_level.txt,sha256=Gu8IeIfIVfUxdi-h-F0nKMQxo15pjhHZ0aTadXTpRE8,47
+unrealon-2.0.35.dist-info/RECORD,,

unrealon_browser/core/browser_manager.py

@@ -31,6 +31,7 @@ from unrealon_browser.managers import (
     create_browser_logger_bridge,
     PageWaitManager,
     ScriptManager,
+    DataExtractionManager,
 )
 
 
@@ -71,6 +72,7 @@ class BrowserManager:
         self.captcha_manager = CaptchaDetector()
         self.page_wait = PageWaitManager(None, self.logger_bridge)
         self.script_manager = ScriptManager(None, self.logger_bridge)
+        self.data_extraction = DataExtractionManager(None, self.logger_bridge)
 
         # Signal handlers for graceful shutdown
         self._setup_signal_handlers()
@@ -251,6 +253,9 @@ class BrowserManager:
             
             # Update script manager with new page
             self.script_manager.update_page(self._page)
+            
+            # Update data extraction manager with new page
+            self.data_extraction.update_page(self._page)
 
             # 🔥 STEALTH ALWAYS APPLIED TO EVERY PAGE!
             stealth_success = await self.stealth_manager.apply_stealth(self._page)
@@ -476,17 +481,6 @@ class BrowserManager:
                 "error": str(e),
             }
 
-    async def get_page_content_async(self) -> Optional[str]:
-        """Get current page content"""
-        if not self._page:
-            return None
-
-        try:
-            return await self._page.content()
-        except Exception as e:
-            self.logger_bridge.log_error(f"❌ Failed to get page content: {e}")
-            return None
-
     async def execute_script_async(self, script: str) -> Any:
         """Execute JavaScript on current page"""
         if not self._page:
@@ -603,11 +597,6 @@ class BrowserManager:
             resolution_result = await self.captcha_manager.handle_captcha_interactive(self, detection_result, timeout_seconds)
 
             if resolution_result["success"]:
-                # Log successful captcha resolution
-                if hasattr(self, "_current_proxy") and self._current_proxy:
-                    proxy_host = self._current_proxy.get("host", "unknown")
-                    proxy_port = self._current_proxy.get("port", 0)
-                    self.logger_bridge.log_captcha_solved(proxy_host, proxy_port, manual=True)
 
                 # Update session status back to active
                 self.session_metadata.current_status = BrowserSessionStatus.ACTIVE
@@ -708,6 +697,7 @@ class BrowserManager:
                     self._page = None
                     self.page_wait.update_page(None)
                     self.script_manager.update_page(None)
+                    self.data_extraction.update_page(None)
 
             # Close context with safety checks
             if self._context:

unrealon_browser/dto/models/statistics.py

@@ -62,7 +62,6 @@ class BrowserStatistics(BaseModel):
     
     # Captcha metrics
     captcha_encounters: int = Field(default=0)
-    captcha_solved: int = Field(default=0)
     captcha_timeouts: int = Field(default=0)
     
     # Performance

unrealon_browser/managers/__init__.py

@@ -9,6 +9,7 @@ from .cookies import CookieManager
 from .captcha import CaptchaDetector
 from .page_wait_manager import PageWaitManager
 from .script_manager import ScriptManager
+from .data_extraction_manager import DataExtractionManager
 
 
 __all__ = [
@@ -20,4 +21,5 @@ __all__ = [
     "CaptchaDetector",
     "PageWaitManager",
     "ScriptManager",
+    "DataExtractionManager",
 ]

unrealon_browser/managers/captcha.py

@@ -310,7 +310,7 @@ class CaptchaDetector:
 
                 if cookies_saved:
                     self._logger("💾 Cookies saved after captcha resolution", "info")
-                    self._captchas_solved += 1
+                    # self._captchas_solved += 1  # Solving disabled
                 else:
                     self._logger("⚠️ Failed to save cookies after captcha resolution", "warning")
 
@@ -499,8 +499,8 @@ class CaptchaDetector:
 
         print(f"\n🤖 Captcha Detection Statistics:")
         print(f"   Captchas detected: {stats['captchas_detected']}")
-        print(f"   Captchas solved: {stats['captchas_solved']}")
-        print(f"   Success rate: {stats['success_rate']:.1f}%")
+        print(f"   Captchas solved: {stats['captchas_solved']} (solving disabled)")
+        print(f"   Success rate: N/A (solving disabled)")
         print(f"   Detection history: {stats['detection_history_count']} events")
         print(f"   Supported types: {', '.join(stats['supported_types'])}")
 

unrealon_browser/managers/data_extraction_manager.py

@@ -0,0 +1,266 @@
+"""
+Data Extraction Manager - Extract different types of data from pages
+"""
+import json
+from typing import Optional, Dict, Any, Union
+from playwright.async_api import Page
+
+from .logger_bridge import BrowserLoggerBridge as LoggingBridge
+
+
+class DataExtractionManager:
+    """Manager for extracting different types of data from web pages"""
+    
+    def __init__(self, page: Optional[Page], logger_bridge: LoggingBridge):
+        self._page = page
+        self.logger_bridge = logger_bridge
+    
+    def update_page(self, page: Optional[Page]):
+        """Update the page reference"""
+        self._page = page
+    
+    async def get_json_content(self) -> Optional[Dict[str, Any]]:
+        """Extract JSON content from current page (for API endpoints)."""
+        if not self._page:
+            self.logger_bridge.log_error("No page available for JSON extraction")
+            return None
+        
+        try:
+            self.logger_bridge.log_info("🔍 Extracting JSON content from page...")
+            
+            # JavaScript to extract JSON from different page formats
+            script = """
+            (() => {
+                try {
+                    // Method 1: Try to get from document.body.textContent (for API responses)
+                    const bodyText = document.body.textContent || document.body.innerText || '';
+                    const cleanBodyText = bodyText.trim();
+                    
+                    if (cleanBodyText && (cleanBodyText.startsWith('{') || cleanBodyText.startsWith('['))) {
+                        return {
+                            success: true,
+                            data: JSON.parse(cleanBodyText),
+                            method: 'body_text'
+                        };
+                    }
+                    
+                    // Method 2: Try to get from <pre> tag (common for JSON APIs)
+                    const preElement = document.querySelector('pre');
+                    if (preElement) {
+                        const preText = (preElement.textContent || preElement.innerText || '').trim();
+                        if (preText && (preText.startsWith('{') || preText.startsWith('['))) {
+                            return {
+                                success: true,
+                                data: JSON.parse(preText),
+                                method: 'pre_element'
+                            };
+                        }
+                    }
+                    
+                    // Method 3: Check if entire document is JSON
+                    const docText = (document.documentElement.textContent || document.documentElement.innerText || '').trim();
+                    if (docText && (docText.startsWith('{') || docText.startsWith('['))) {
+                        return {
+                            success: true,
+                            data: JSON.parse(docText),
+                            method: 'document_text'
+                        };
+                    }
+                    
+                    // Method 4: Look for JSON in script tags
+                    const scriptTags = document.querySelectorAll('script[type="application/json"]');
+                    for (const script of scriptTags) {
+                        const scriptText = (script.textContent || script.innerText || '').trim();
+                        if (scriptText && (scriptText.startsWith('{') || scriptText.startsWith('['))) {
+                            return {
+                                success: true,
+                                data: JSON.parse(scriptText),
+                                method: 'script_tag'
+                            };
+                        }
+                    }
+                    
+                    return {
+                        success: false,
+                        error: 'No JSON content found',
+                        page_text_preview: cleanBodyText.substring(0, 200)
+                    };
+                    
+                } catch (e) {
+                    return {
+                        success: false,
+                        error: 'JSON parse failed: ' + e.message,
+                        page_text_preview: (document.body.textContent || '').substring(0, 200)
+                    };
+                }
+            })();
+            """
+            
+            result = await self._page.evaluate(script)
+            
+            if result.get('success'):
+                method = result.get('method', 'unknown')
+                self.logger_bridge.log_info(f"✅ JSON extracted successfully using method: {method}")
+                return result.get('data')
+            else:
+                error = result.get('error', 'Unknown error')
+                preview = result.get('page_text_preview', '')
+                self.logger_bridge.log_warning(f"❌ JSON extraction failed: {error}")
+                if preview:
+                    self.logger_bridge.log_info(f"📄 Page preview: {preview}...")
+                return None
+                
+        except Exception as e:
+            self.logger_bridge.log_error(f"JSON extraction error: {e}")
+            return None
+    
+    async def get_page_text(self) -> Optional[str]:
+        """Get plain text content from current page."""
+        if not self._page:
+            return None
+        
+        try:
+            self.logger_bridge.log_info("📄 Extracting plain text content...")
+            
+            script = """
+            (() => {
+                return {
+                    body_text: document.body.textContent || document.body.innerText || '',
+                    title: document.title || '',
+                    url: window.location.href
+                };
+            })();
+            """
+            
+            result = await self._page.evaluate(script)
+            text = result.get('body_text', '').strip()
+            
+            if text:
+                self.logger_bridge.log_info(f"✅ Text extracted: {len(text)} characters")
+                return text
+            else:
+                self.logger_bridge.log_warning("❌ No text content found")
+                return None
+                
+        except Exception as e:
+            self.logger_bridge.log_error(f"Text extraction error: {e}")
+            return None
+    
+    async def get_structured_data(self) -> Optional[Dict[str, Any]]:
+        """Get structured data including JSON, text, and metadata."""
+        if not self._page:
+            return None
+        
+        try:
+            self.logger_bridge.log_info("🔍 Extracting structured data...")
+            
+            # Try JSON first
+            json_data = await self.get_json_content()
+            
+            # Get page metadata
+            script = """
+            (() => {
+                return {
+                    url: window.location.href,
+                    title: document.title || '',
+                    content_type: document.contentType || '',
+                    charset: document.characterSet || '',
+                    ready_state: document.readyState,
+                    has_pre_element: !!document.querySelector('pre'),
+                    body_text_length: (document.body.textContent || '').length
+                };
+            })();
+            """
+            
+            metadata = await self._page.evaluate(script)
+            
+            result = {
+                "extraction_success": json_data is not None,
+                "json_data": json_data,
+                "metadata": metadata,
+                "extracted_at": self._get_timestamp()
+            }
+            
+            if json_data:
+                self.logger_bridge.log_info("✅ Structured data extraction successful")
+            else:
+                self.logger_bridge.log_warning("⚠️ No JSON data found, but metadata extracted")
+            
+            return result
+            
+        except Exception as e:
+            self.logger_bridge.log_error(f"Structured data extraction error: {e}")
+            return None
+    
+    async def detect_content_type(self) -> str:
+        """Detect the type of content on the current page."""
+        if not self._page:
+            return "unknown"
+        
+        try:
+            script = """
+            (() => {
+                const bodyText = (document.body.textContent || '').trim();
+                const contentType = document.contentType || '';
+                const hasPreElement = !!document.querySelector('pre');
+                
+                // Check for JSON
+                if (bodyText.startsWith('{') || bodyText.startsWith('[')) {
+                    return 'json';
+                }
+                
+                // Check for XML
+                if (bodyText.startsWith('<') && contentType.includes('xml')) {
+                    return 'xml';
+                }
+                
+                // Check for HTML
+                if (document.querySelector('html') && document.querySelector('body') && !hasPreElement) {
+                    return 'html';
+                }
+                
+                // Check for plain text
+                if (hasPreElement || contentType.includes('text/plain')) {
+                    return 'text';
+                }
+                
+                return 'unknown';
+            })();
+            """
+            
+            content_type = await self._page.evaluate(script)
+            self.logger_bridge.log_info(f"🔍 Detected content type: {content_type}")
+            return content_type
+            
+        except Exception as e:
+            self.logger_bridge.log_error(f"Content type detection error: {e}")
+            return "unknown"
+    
+    async def get_page_html(self) -> Optional[str]:
+        """Get full HTML content from current page."""
+        if not self._page:
+            return None
+        
+        try:
+            self.logger_bridge.log_info("📄 Extracting HTML content...")
+            html = await self._page.content()
+            
+            if html:
+                self.logger_bridge.log_info(f"✅ HTML extracted: {len(html)} characters")
+                return html
+            else:
+                self.logger_bridge.log_warning("❌ No HTML content found")
+                return None
+                
+        except Exception as e:
+            self.logger_bridge.log_error(f"HTML extraction error: {e}")
+            return None
+    
+    def _get_timestamp(self) -> str:
+        """Get current timestamp in ISO format."""
+        from datetime import datetime
+        return datetime.now().isoformat()
+
+
+# Export
+__all__ = ["DataExtractionManager"]

unrealon_browser/managers/logger_bridge.py

@@ -81,7 +81,6 @@ class BrowserLoggerBridge:
             "navigation_failed": 0,
             "stealth_applied": 0,
             "captcha_detected": 0,
-            "captcha_solved": 0,
             "profile_created": 0,
             "cookies_saved": 0,
         }
@@ -194,17 +193,6 @@ class BrowserLoggerBridge:
             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

unrealon_driver/driver/core/driver.py

@@ -21,7 +21,7 @@ from ..utilities.logging import LoggingUtility
 from ..utilities.serialization import SerializationUtility
 
 from ...managers import (
-    LoggerManager, HttpManager, BrowserManager, CacheManager,
+    LoggerManager, HttpManager, HttpxManager, BrowserManager, CacheManager,
     ProxyManager, ThreadManager, UpdateManager, ManagerRegistry
 )
 
@@ -77,6 +77,7 @@ class UniversalDriver:
         self.manager_registry: Optional[ManagerRegistry] = None
         self.logger_manager: Optional[LoggerManager] = None
         self.http: Optional[HttpManager] = None
+        self.httpx: Optional[HttpxManager] = None
         self.browser: Optional[BrowserManager] = None
         self.cache: Optional[CacheManager] = None
         self.proxy: Optional[ProxyManager] = None

unrealon_driver/driver/factory/manager_factory.py

@@ -8,11 +8,12 @@ import logging
 from typing import TYPE_CHECKING
 
 from ...managers import (
-    LoggerManager, HttpManager, BrowserManager, CacheManager,
+    LoggerManager, HttpManager, HttpxManager, BrowserManager, CacheManager,
     ProxyManager, ThreadManager, UpdateManager, ManagerRegistry
 )
 from ...managers.logger import LoggerManagerConfig
 from ...managers.http import HttpManagerConfig
+from ...managers.http import HttpxManagerConfig
 from ...managers.browser import BrowserManagerConfig
 from ...managers.cache import CacheManagerConfig
 from ...managers.proxy import ProxyManagerConfig
@@ -45,6 +46,7 @@ class ManagerFactory:
         # Setup each manager
         ManagerFactory._setup_logger_manager(driver, manager_registry)
         ManagerFactory._setup_http_manager(driver, manager_registry)
+        ManagerFactory._setup_httpx_manager(driver, manager_registry)
         ManagerFactory._setup_browser_manager(driver, manager_registry)
         ManagerFactory._setup_cache_manager(driver, manager_registry)
         ManagerFactory._setup_proxy_manager(driver, manager_registry)
@@ -78,6 +80,17 @@ class ManagerFactory:
         driver.http = HttpManager(http_config)
         registry.register(driver.http)
     
+    @staticmethod
+    def _setup_httpx_manager(driver: 'UniversalDriver', registry: ManagerRegistry):
+        """Setup HTTPx manager."""
+        httpx_config = HttpxManagerConfig(
+            enabled=True,
+            timeout=driver.config.http_timeout,
+            max_retries=driver.config.max_retries
+        )
+        driver.httpx = HttpxManager(httpx_config)
+        registry.register(driver.httpx)
+    
     @staticmethod
     def _setup_browser_manager(driver: 'UniversalDriver', registry: ManagerRegistry):
         """Setup browser manager."""

unrealon_driver/managers/__init__.py

@@ -4,7 +4,7 @@ Clean manager system for UnrealOn Driver.
 
 from .base import BaseManager, ManagerConfig, ManagerStatus
 from .logger import LoggerManager, LoggerManagerConfig
-from .http import HttpManager, HttpManagerConfig
+from .http import HttpManager, HttpManagerConfig, HttpxManager, HttpxManagerConfig
 from .browser import BrowserManager, BrowserManagerConfig
 from .cache import CacheManager, CacheManagerConfig
 from .proxy import ProxyManager, ProxyManagerConfig
@@ -21,6 +21,7 @@ __all__ = [
     # Managers
     "LoggerManager", "LoggerManagerConfig",
     "HttpManager", "HttpManagerConfig",
+    "HttpxManager", "HttpxManagerConfig",
     "BrowserManager", "BrowserManagerConfig",
     "CacheManager", "CacheManagerConfig",
     "ProxyManager", "ProxyManagerConfig",

unrealon_driver/managers/browser.py

@@ -113,7 +113,7 @@ class BrowserManager(BaseManager):
             raise RuntimeError("Failed to initialize browser")
 
         try:
-            html = await self.browser.get_page_content_async()
+            html = await self.browser.data_extraction.get_page_html()
             self.stats.record_operation(True, 0.0)
             return html
         except Exception as e:
@@ -121,6 +121,36 @@ class BrowserManager(BaseManager):
             self.stats.record_operation(False, 0.0)
             return None
     
+    async def get_json_content(self) -> Optional[dict]:
+        """Extract JSON content from current page via DataExtractionManager."""
+        # Ensure browser is initialized
+        if not await self._ensure_browser_initialized():
+            raise RuntimeError("Failed to initialize browser")
+        
+        try:
+            result = await self.browser.data_extraction.get_json_content()
+            self.stats.record_operation(True, 0.0)
+            return result
+        except Exception as e:
+            self.logger.error(f"JSON extraction failed: {e}")
+            self.stats.record_operation(False, 0.0)
+            return None
+    
+    async def get_page_text(self) -> Optional[str]:
+        """Get plain text content from current page via DataExtractionManager."""
+        # Ensure browser is initialized
+        if not await self._ensure_browser_initialized():
+            raise RuntimeError("Failed to initialize browser")
+        
+        try:
+            result = await self.browser.data_extraction.get_page_text()
+            self.stats.record_operation(True, 0.0)
+            return result
+        except Exception as e:
+            self.logger.error(f"Text extraction failed: {e}")
+            self.stats.record_operation(False, 0.0)
+            return None
+    
     async def execute_script_async(self, script: str) -> any:
         """Execute JavaScript on current page via ScriptManager."""
         # Ensure browser is initialized
@@ -136,3 +166,9 @@ class BrowserManager(BaseManager):
             self.logger.error(f"Script execution failed: {e}")
             self.stats.record_operation(False, 0.0)
             raise
+    
+    async def cleanup(self) -> None:
+        """Cleanup browser resources."""
+        if self.browser:
+            await self.browser.close_async()
+            self.browser = None

unrealon_driver/managers/http.py

@@ -1,9 +1,10 @@
 """
-Clean HTTP manager for requests.
+Clean HTTP managers for requests - both aiohttp and httpx with HTTP/2 support.
 """
 
 import asyncio
 import aiohttp
+import httpx
 from typing import Dict, Any, Optional
 from pydantic import Field
 
@@ -17,8 +18,16 @@ class HttpManagerConfig(ManagerConfig):
     connector_limit: int = Field(default=30, description="Connector limit per host")
 
 
+class HttpxManagerConfig(ManagerConfig):
+    """HTTPx manager configuration with HTTP/2 support."""
+    user_agent: str = Field(default="UnrealOn-Driver/1.0", description="User agent string")
+    max_connections: int = Field(default=100, description="Max concurrent connections")
+    connector_limit: int = Field(default=30, description="Connector limit per host")
+    http2: bool = Field(default=True, description="Enable HTTP/2 support")
+
+
 class HttpManager(BaseManager):
-    """Clean HTTP manager with aiohttp."""
+    """Clean HTTP manager with aiohttp (original)."""
     
     def __init__(self, config: HttpManagerConfig):
         super().__init__(config, "http")
@@ -105,3 +114,98 @@ class HttpManager(BaseManager):
         finally:
             duration = asyncio.get_event_loop().time() - start_time
             self.stats.record_operation(success, duration)
+
+
+class HttpxManager(BaseManager):
+    """Modern HTTP manager with httpx and HTTP/2 support."""
+    
+    def __init__(self, config: HttpxManagerConfig):
+        super().__init__(config, "httpx")
+        self.config: HttpxManagerConfig = config
+        self.client: Optional[httpx.AsyncClient] = None
+    
+    async def _initialize(self) -> bool:
+        """Initialize HTTP client with HTTP/2 support."""
+        try:
+            # Create limits
+            limits = httpx.Limits(
+                max_keepalive_connections=self.config.max_connections,
+                max_connections=self.config.max_connections,
+                keepalive_expiry=300
+            )
+            
+            # Create timeout
+            timeout = httpx.Timeout(self.config.timeout)
+            
+            # Default headers
+            headers = {"User-Agent": self.config.user_agent}
+            
+            # Create client with HTTP/2 support
+            self.client = httpx.AsyncClient(
+                limits=limits,
+                timeout=timeout,
+                headers=headers,
+                http2=self.config.http2,
+                verify=True,
+                follow_redirects=True
+            )
+            
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"HTTPx manager initialization failed: {e}")
+            return False
+    
+    async def _shutdown(self):
+        """Shutdown HTTP client."""
+        if self.client:
+            await self.client.aclose()
+            self.client = None
+    
+    async def get(self, url: str, **kwargs) -> httpx.Response:
+        """Make GET request."""
+        if not self.client:
+            raise RuntimeError("HTTPx manager not initialized")
+        
+        start_time = asyncio.get_event_loop().time()
+        success = False
+        
+        try:
+            response = await self.client.get(url, **kwargs)
+            success = True
+            return response
+        finally:
+            duration = asyncio.get_event_loop().time() - start_time
+            self.stats.record_operation(success, duration)
+    
+    async def post(self, url: str, **kwargs) -> httpx.Response:
+        """Make POST request."""
+        if not self.client:
+            raise RuntimeError("HTTPx manager not initialized")
+        
+        start_time = asyncio.get_event_loop().time()
+        success = False
+        
+        try:
+            response = await self.client.post(url, **kwargs)
+            success = True
+            return response
+        finally:
+            duration = asyncio.get_event_loop().time() - start_time
+            self.stats.record_operation(success, duration)
+    
+    async def request(self, method: str, url: str, **kwargs) -> httpx.Response:
+        """Make generic request."""
+        if not self.client:
+            raise RuntimeError("HTTPx manager not initialized")
+        
+        start_time = asyncio.get_event_loop().time()
+        success = False
+        
+        try:
+            response = await self.client.request(method, url, **kwargs)
+            success = True
+            return response
+        finally:
+            duration = asyncio.get_event_loop().time() - start_time
+            self.stats.record_operation(success, duration)

unrealon_driver/managers/threading.py

@@ -3,8 +3,9 @@ Clean threading manager.
 """
 
 import asyncio
+import inspect
 from concurrent.futures import ThreadPoolExecutor
-from typing import Any, Callable, Optional, Dict
+from typing import Any, Callable, Optional, Dict, Coroutine, Union
 from pydantic import Field
 
 from .base import BaseManager, ManagerConfig
@@ -38,12 +39,52 @@ class ThreadManager(BaseManager):
             self.executor = None
     
     async def run_in_thread(self, func: Callable, *args, **kwargs) -> Any:
-        """Run function in thread pool."""
+        """Run function in thread pool (supports both sync and async functions)."""
         if not self.executor:
             raise RuntimeError("Thread manager not initialized")
         
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(self.executor, func, *args, **kwargs)
+        # Check if function is async
+        if inspect.iscoroutinefunction(func):
+            # For async functions, we need to run them in a new event loop in the thread
+            def run_async_in_thread():
+                # Create new event loop for this thread
+                new_loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(new_loop)
+                try:
+                    return new_loop.run_until_complete(func(*args, **kwargs))
+                finally:
+                    new_loop.close()
+            
+            loop = asyncio.get_event_loop()
+            return await loop.run_in_executor(self.executor, run_async_in_thread)
+        else:
+            # For sync functions, use normal executor
+            loop = asyncio.get_event_loop()
+            return await loop.run_in_executor(self.executor, func, *args, **kwargs)
+    
+    async def run_concurrent_async(self, async_funcs: list[Callable], max_concurrent: int = None) -> list[Any]:
+        """
+        Run multiple async functions concurrently using semaphore for control.
+        
+        This is more efficient than ThreadManager for pure async operations,
+        but provides controlled concurrency.
+        """
+        if not async_funcs:
+            return []
+        
+        # Use max_workers as default concurrency limit
+        max_concurrent = max_concurrent or self.config.max_workers
+        
+        # Create semaphore to limit concurrency
+        semaphore = asyncio.Semaphore(max_concurrent)
+        
+        async def run_with_semaphore(func):
+            async with semaphore:
+                return await func()
+        
+        # Execute all functions concurrently with semaphore control
+        tasks = [run_with_semaphore(func) for func in async_funcs]
+        return await asyncio.gather(*tasks, return_exceptions=True)
     
     async def _health_check(self) -> Dict[str, Any]:
         """Thread manager health check."""