pydoll-python 2.9.0__tar.gz → 2.9.2__tar.gz

{pydoll_python-2.9.0 → pydoll_python-2.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydoll-python
-Version: 2.9.0
+Version: 2.9.2
 Summary: Pydoll is a library for automating chromium-based browsers without a WebDriver, offering realistic interactions.
 License-File: LICENSE
 Author: Thalison Fernandes
@@ -73,6 +73,19 @@ pip install pydoll-python
 
 And that's it! Just install and start automating.
 
+
+## ⭐ Sponsors
+The support from sponsors is essential to keep the project alive, evolving, and accessible to the entire community. Each partnership helps cover costs, drive new features, and ensure ongoing development.
+We are truly grateful to everyone who believes in and supports the project!
+
+<br>
+<p style="font-size:21px; color:black;">Browser testing via 
+    <a href="https://www.lambdatest.com/?utm_source=pydoll&utm_medium=sponsor" target="_blank">
+        <img src="https://www.lambdatest.com/blue-logo.png" style="vertical-align: middle;" width="250" height="45" />
+    </a>
+</p>
+<br>
+
 ## 🚀 Getting Started
 
 ### Your first automation

{pydoll_python-2.9.0 → pydoll_python-2.9.2}/README.md

@@ -53,6 +53,19 @@ pip install pydoll-python
 
 And that's it! Just install and start automating.
 
+
+## ⭐ Sponsors
+The support from sponsors is essential to keep the project alive, evolving, and accessible to the entire community. Each partnership helps cover costs, drive new features, and ensure ongoing development.
+We are truly grateful to everyone who believes in and supports the project!
+
+<br>
+<p style="font-size:21px; color:black;">Browser testing via 
+    <a href="https://www.lambdatest.com/?utm_source=pydoll&utm_medium=sponsor" target="_blank">
+        <img src="https://www.lambdatest.com/blue-logo.png" style="vertical-align: middle;" width="250" height="45" />
+    </a>
+</p>
+<br>
+
 ## 🚀 Getting Started
 
 ### Your first automation

{pydoll_python-2.9.0 → pydoll_python-2.9.2}/pydoll/browser/chromium/base.py

@@ -1,5 +1,6 @@
 import asyncio
 import json
+import logging
 import os
 import shutil
 import warnings
@@ -59,6 +60,8 @@ from pydoll.protocol.target.methods import (
 )
 from pydoll.protocol.target.types import TargetInfo
 
+logger = logging.getLogger(__name__)
+
 
 class Browser(ABC):  # noqa: PLR0904
     """
@@ -95,14 +98,21 @@ class Browser(ABC):  # noqa: PLR0904
         self._backup_preferences_dir = ''
         self._tabs_opened: dict[str, Tab] = {}
         self._context_proxy_auth: dict[str, tuple[str, str]] = {}
+        logger.debug(
+            f'Browser initialized: port={self._connection_port}, '
+            f'headless={getattr(self.options, "headless", None)}'
+        )
 
     async def __aenter__(self) -> 'Browser':
         """Async context manager entry."""
+        logger.debug('Entering browser async context')
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Async context manager exit with cleanup."""
+        logger.debug(f'Exiting browser async context: exc_type={exc_type}')
         if self._backup_preferences_dir:
+            logger.debug(f'Restoring backup preferences directory: {self._backup_preferences_dir}')
             user_data_dir = self._get_user_data_dir()
             shutil.copy2(
                 self._backup_preferences_dir,
@@ -129,8 +139,10 @@ class Browser(ABC):  # noqa: PLR0904
             You are supposed to use this method only if you want to connect to a browser
             that is already running.
         """
+        logger.info(f'Connecting to browser via WebSocket: {ws_address}')
         await self._setup_ws_address(ws_address)
         tabs = await self.get_opened_tabs()
+        logger.info(f'Connected. Tabs available: {len(tabs)}')
         return tabs[0]
 
     async def start(self, headless: bool = False) -> Tab:
@@ -156,19 +168,24 @@ class Browser(ABC):  # noqa: PLR0904
             self.options.headless = headless
 
         binary_location = self.options.binary_location or self._get_default_binary_location()
+        logger.debug('Resolved binary location: %s', binary_location)
 
         self._setup_user_dir()
+        logger.debug('User data directory configured')
         proxy_config = self._proxy_manager.get_proxy_credentials()
 
+        logger.info(f'Starting browser process on port {self._connection_port}')
         self._browser_process_manager.start_browser_process(
             binary_location, self._connection_port, self.options.arguments
         )
         await self._verify_browser_running()
+        logger.info('Browser process started and responsive')
         await self._configure_proxy(proxy_config[0], proxy_config[1])
 
         valid_tab_id = await self._get_valid_tab_id(await self.get_targets())
         tab = Tab(self, target_id=valid_tab_id, connection_port=self._connection_port)
         self._tabs_opened[valid_tab_id] = tab
+        logger.info(f'Initial tab attached: {valid_tab_id}')
         return tab
 
     async def stop(self):
@@ -182,12 +199,15 @@ class Browser(ABC):  # noqa: PLR0904
             BrowserNotRunning: If the browser is not currently running.
         """
         if not await self._is_browser_running():
+            logger.error('Stop called but browser is not running')
             raise BrowserNotRunning()
 
+        logger.info('Stopping browser process')
         await self._execute_command(BrowserCommands.close())
         self._browser_process_manager.stop_process()
         self._temp_directory_manager.cleanup()
         await self._connection_handler.close()
+        logger.info('Browser process stopped and resources cleaned up')
 
     async def create_browser_context(
         self, proxy_server: Optional[str] = None, proxy_bypass_list: Optional[str] = None
@@ -210,6 +230,10 @@ class Browser(ABC):  # noqa: PLR0904
         extracted_auth: Optional[tuple[str, str]] = None
         if proxy_server:
             sanitized_proxy, extracted_auth = self._sanitize_proxy_and_extract_auth(proxy_server)
+            logger.debug(
+                f'Creating browser context with proxy: {sanitized_proxy}'
+                f'(credentials provided={bool(extracted_auth)})'
+            )
 
         response: CreateBrowserContextResponse = await self._execute_command(
             TargetCommands.create_browser_context(
@@ -220,6 +244,7 @@ class Browser(ABC):  # noqa: PLR0904
         context_id = response['result']['browserContextId']
         if extracted_auth:
             self._context_proxy_auth[context_id] = extracted_auth
+        logger.info(f'Created browser context: {context_id}')
         return context_id
 
     async def delete_browser_context(self, browser_context_id: str):
@@ -232,6 +257,7 @@ class Browser(ABC):  # noqa: PLR0904
         Note:
             Closes all associated tabs immediately.
         """
+        logger.info(f'Deleting browser context: {browser_context_id}')
         return await self._execute_command(
             TargetCommands.dispose_browser_context(browser_context_id)
         )
@@ -241,6 +267,7 @@ class Browser(ABC):  # noqa: PLR0904
         response: GetBrowserContextsResponse = await self._execute_command(
             TargetCommands.get_browser_contexts()
         )
+        logger.debug(f'Fetched {len(response["result"]["browserContextIds"])} browser contexts')
         return response['result']['browserContextIds']
 
     async def new_tab(self, url: str = '', browser_context_id: Optional[str] = None) -> Tab:
@@ -254,6 +281,7 @@ class Browser(ABC):  # noqa: PLR0904
         Returns:
             Tab instance for page navigation and element interaction.
         """
+        logger.info(f'Creating new tab (context={browser_context_id})')
         response: CreateTargetResponse = await self._execute_command(
             TargetCommands.create_target(
                 browser_context_id=browser_context_id,
@@ -263,7 +291,9 @@ class Browser(ABC):  # noqa: PLR0904
         tab = Tab(self, **self._get_tab_kwargs(target_id, browser_context_id))
         self._tabs_opened[target_id] = tab
         await self._setup_context_proxy_auth_for_tab(tab, browser_context_id)
-        if url: await tab.go_to(url)
+        if url:
+            await tab.go_to(url)
+        logger.info(f'New tab created: {target_id}')
         return tab
 
     async def get_targets(self) -> list[TargetInfo]:
@@ -277,6 +307,7 @@ class Browser(ABC):  # noqa: PLR0904
             List of TargetInfo objects.
         """
         response: GetTargetsResponse = await self._execute_command(TargetCommands.get_targets())
+        logger.debug(f'Fetched {len(response["result"]["targetInfos"])} targets')
         return response['result']['targetInfos']
 
     async def get_opened_tabs(self) -> list[Tab]:
@@ -305,10 +336,14 @@ class Browser(ABC):  # noqa: PLR0904
             for target_id in reversed(remaining_target_ids)
         ]
         self._tabs_opened.update(dict(zip(remaining_target_ids, new_tabs)))
+        logger.debug(
+            f'Opened tabs resolved: existing={len(existing_tabs)}, new={len(new_tabs)}',
+        )
         return existing_tabs + new_tabs
 
     async def set_download_path(self, path: str, browser_context_id: Optional[str] = None):
         """Set download directory path (convenience method for set_download_behavior)."""
+        logger.info(f'Setting download path: {path} (context={browser_context_id})')
         return await self._execute_command(
             BrowserCommands.set_download_behavior(
                 behavior=DownloadBehavior.ALLOW,
@@ -333,6 +368,11 @@ class Browser(ABC):  # noqa: PLR0904
             browser_context_id: Context to apply to (default if None).
             events_enabled: Generate download events for progress tracking.
         """
+        logger.info(
+            f'Setting download behavior: behavior={behavior},'
+            f'path={download_path}, context={browser_context_id},'
+            f'events={events_enabled}'
+        )
         return await self._execute_command(
             BrowserCommands.set_download_behavior(
                 behavior=behavior,
@@ -344,12 +384,14 @@ class Browser(ABC):  # noqa: PLR0904
 
     async def delete_all_cookies(self, browser_context_id: Optional[str] = None):
         """Delete all cookies (session, persistent, third-party) from browser or context."""
+        logger.info(f'Clearing all cookies (context={browser_context_id})')
         return await self._execute_command(StorageCommands.clear_cookies(browser_context_id))
 
     async def set_cookies(
         self, cookies: list[CookieParam], browser_context_id: Optional[str] = None
     ):
         """Set multiple cookies in browser or context."""
+        logger.debug(f'Setting {len(cookies)} cookies (context={browser_context_id})')
         return await self._execute_command(StorageCommands.set_cookies(cookies, browser_context_id))
 
     async def get_cookies(self, browser_context_id: Optional[str] = None) -> list[Cookie]:
@@ -357,11 +399,15 @@ class Browser(ABC):  # noqa: PLR0904
         response: GetCookiesResponse = await self._execute_command(
             StorageCommands.get_cookies(browser_context_id)
         )
+        logger.debug(
+            f'Retrieved {len(response["result"]["cookies"])} cookies (context={browser_context_id})'
+        )
         return response['result']['cookies']
 
     async def get_version(self) -> GetVersionResult:
         """Get browser version and CDP protocol information."""
         response: GetVersionResponse = await self._execute_command(BrowserCommands.get_version())
+        logger.debug(f'Browser version: {response["result"]}')
         return response['result']
 
     async def get_window_id_for_target(self, target_id: str) -> int:
@@ -369,12 +415,14 @@ class Browser(ABC):  # noqa: PLR0904
         response: GetWindowForTargetResponse = await self._execute_command(
             BrowserCommands.get_window_for_target(target_id)
         )
+        logger.debug(f'Window id for target {target_id}: {response["result"]["windowId"]}')
         return response['result']['windowId']
 
     async def get_window_id_for_tab(self, tab: Tab) -> int:
         """Get window ID for tab (convenience method)."""
         target_id = tab._target_id or (tab._ws_address.split('/')[-1] if tab._ws_address else None)
         if not target_id:
+            logger.error('Missing target id or ws address for tab when getting window id')
             raise MissingTargetOrWebSocket()
         return await self.get_window_id_for_target(target_id)
 
@@ -392,11 +440,13 @@ class Browser(ABC):  # noqa: PLR0904
     async def set_window_maximized(self):
         """Maximize browser window (affects all tabs in window)."""
         window_id = await self.get_window_id()
+        logger.info(f'Maximizing window: id={window_id}')
         return await self._execute_command(BrowserCommands.set_window_maximized(window_id))
 
     async def set_window_minimized(self):
         """Minimize browser window to taskbar/dock."""
         window_id = await self.get_window_id()
+        logger.info(f'Minimizing window: id={window_id}')
         return await self._execute_command(BrowserCommands.set_window_minimized(window_id))
 
     async def set_window_bounds(self, bounds: Bounds):
@@ -408,6 +458,7 @@ class Browser(ABC):  # noqa: PLR0904
                 Only specified properties are changed.
         """
         window_id = await self.get_window_id()
+        logger.info(f'Setting window bounds: id={window_id}, bounds={bounds}')
         return await self._execute_command(BrowserCommands.set_window_bounds(window_id, bounds))
 
     async def grant_permissions(
@@ -426,12 +477,16 @@ class Browser(ABC):  # noqa: PLR0904
             origin: Origin to grant to (all origins if None).
             browser_context_id: Context to apply to (default if None).
         """
+        logger.info(
+            f'Granting permissions: {permissions} (origin={origin}, context={browser_context_id})',
+        )
         return await self._execute_command(
             BrowserCommands.grant_permissions(permissions, origin, browser_context_id)
         )
 
     async def reset_permissions(self, browser_context_id: Optional[str] = None):
         """Reset all permissions to defaults and restore prompting behavior."""
+        logger.info(f'Resetting permissions (context={browser_context_id})')
         return await self._execute_command(BrowserCommands.reset_permissions(browser_context_id))
 
     @overload
@@ -467,12 +522,17 @@ class Browser(ABC):  # noqa: PLR0904
             function_to_register = callback_wrapper
         else:
             function_to_register = callback
+        logger.debug(
+            f'Registering callback: event={event_name}, temporary={temporary}, '
+            f'async={asyncio.iscoroutinefunction(callback)}'
+        )
         return await self._connection_handler.register_callback(
             event_name, function_to_register, temporary
         )
 
     async def remove_callback(self, callback_id: int):
         """Remove callback from browser."""
+        logger.debug(f'Removing callback: id={callback_id}')
         return await self._connection_handler.remove_callback(callback_id)
 
     async def enable_fetch_events(
@@ -493,6 +553,10 @@ class Browser(ABC):  # noqa: PLR0904
         Note:
             Paused requests must be continued or they will timeout.
         """
+        logger.debug(
+            f'Enabling Fetch events: handle_auth={handle_auth_requests}, '
+            f'resource_type={resource_type}'
+        )
         return await self._connection_handler.execute_command(
             FetchCommands.enable(
                 handle_auth_requests=handle_auth_requests,
@@ -502,14 +566,17 @@ class Browser(ABC):  # noqa: PLR0904
 
     async def disable_fetch_events(self):
         """Disable request interception and release any paused requests."""
+        logger.debug('Disabling Fetch events')
         return await self._connection_handler.execute_command(FetchCommands.disable())
 
     async def enable_runtime_events(self):
         """Enable runtime events."""
+        logger.debug('Enabling Runtime events')
         return await self._connection_handler.execute_command(RuntimeCommands.enable())
 
     async def disable_runtime_events(self):
         """Disable runtime events."""
+        logger.debug('Disabling Runtime events')
         return await self._connection_handler.execute_command(RuntimeCommands.disable())
 
     async def continue_request(
@@ -524,6 +591,7 @@ class Browser(ABC):  # noqa: PLR0904
         """
         Continue paused request without modifications.
         """
+        logger.debug(f'Continuing request: id={request_id}')
         return await self._execute_command(
             FetchCommands.continue_request(
                 request_id=request_id,
@@ -537,6 +605,7 @@ class Browser(ABC):  # noqa: PLR0904
 
     async def fail_request(self, request_id: str, error_reason: ErrorReason):
         """Fail request with error code."""
+        logger.debug(f'Failing request: id={request_id}, reason={error_reason}')
         return await self._execute_command(FetchCommands.fail_request(request_id, error_reason))
 
     async def fulfill_request(
@@ -548,6 +617,10 @@ class Browser(ABC):  # noqa: PLR0904
         response_phrase: Optional[str] = None,
     ):
         """Fulfill request with response data."""
+        logger.debug(
+            f'Fulfilling request: id={request_id}, code={response_code}, '
+            f'headers={bool(response_headers)}, body={bool(body)}'
+        )
         return await self._execute_command(
             FetchCommands.fulfill_request(
                 request_id=request_id,
@@ -562,11 +635,13 @@ class Browser(ABC):  # noqa: PLR0904
     def _validate_connection_port(connection_port: Optional[int]):
         """Validate connection port."""
         if connection_port and connection_port < 0:
+            logger.error(f'Invalid connection port: {connection_port}')
             raise InvalidConnectionPort()
 
     async def _continue_request_callback(self, event: RequestPausedEvent):
         """Internal callback to continue paused requests."""
         request_id = event['params']['requestId']
+        logger.debug(f'[Fetch] REQUEST_PAUSED -> continue: id={request_id}')
         return await self.continue_request(request_id)
 
     async def _continue_request_with_auth_callback(
@@ -577,6 +652,10 @@ class Browser(ABC):  # noqa: PLR0904
     ):
         """Internal callback for proxy authentication."""
         request_id = event['params']['requestId']
+        logger.debug(
+            f'[Fetch] AUTH_REQUIRED -> provide credentials: id={request_id}, '
+            f'user_set={bool(proxy_username)}'
+        )
         response: Response = await self._execute_command(
             FetchCommands.continue_request_with_auth(
                 request_id,
@@ -592,6 +671,7 @@ class Browser(ABC):  # noqa: PLR0904
     async def _tab_continue_request_callback(event: RequestPausedEvent, tab: Tab):
         """Internal callback to continue paused requests at Tab level."""
         request_id = event['params']['requestId']
+        logger.debug(f'[Tab Fetch] REQUEST_PAUSED -> continue: id={request_id}')
         return await tab.continue_request(request_id)
 
     @staticmethod
@@ -603,6 +683,10 @@ class Browser(ABC):  # noqa: PLR0904
     ):
         """Internal callback for proxy/server authentication at Tab level."""
         request_id = event['params']['requestId']
+        logger.debug(
+            f'[Tab Fetch] AUTH_REQUIRED -> provide credentials: id={request_id}, '
+            f'user_set={bool(proxy_username)}'
+        )
         response: Response = await tab.continue_with_auth(
             request_id=request_id,
             auth_challenge_response=AuthChallengeResponseType.PROVIDE_CREDENTIALS,
@@ -622,6 +706,10 @@ class Browser(ABC):  # noqa: PLR0904
         if not creds:
             return
         username, password = creds
+        logger.debug(
+            f'Enabling context-level proxy auth for tab (context={browser_context_id}, '
+            f'user_set={bool(username)}'
+        )
         await tab.enable_fetch_events(handle_auth=True)
         await tab.on(
             FetchEvent.REQUEST_PAUSED,
@@ -649,29 +737,37 @@ class Browser(ABC):  # noqa: PLR0904
         Raises:
             FailedToStartBrowser: If the browser failed to start.
         """
+        logger.debug(f'Verifying browser is running (timeout={self.options.start_timeout})')
         if not await self._is_browser_running(self.options.start_timeout):
+            logger.error('Browser failed to start within timeout')
             raise FailedToStartBrowser()
 
     async def _configure_proxy(
         self, private_proxy: bool, proxy_credentials: tuple[Optional[str], Optional[str]]
     ):
         """Setup proxy authentication handling if needed."""
-        if private_proxy:
-            await self.enable_fetch_events(handle_auth_requests=True)
-            await self.on(
-                FetchEvent.REQUEST_PAUSED,
-                self._continue_request_callback,
-                temporary=True,
-            )
-            await self.on(
-                FetchEvent.AUTH_REQUIRED,
-                partial(
-                    self._continue_request_with_auth_callback,
-                    proxy_username=proxy_credentials[0],
-                    proxy_password=proxy_credentials[1],
-                ),
-                temporary=True,
-            )
+        if not private_proxy:
+            return
+
+        logger.debug(
+            'Configuring proxy authentication: '
+            f'credentials provided={bool(proxy_credentials[0] or proxy_credentials[1])}'
+        )
+        await self.enable_fetch_events(handle_auth_requests=True)
+        await self.on(
+            FetchEvent.REQUEST_PAUSED,
+            self._continue_request_callback,
+            temporary=True,
+        )
+        await self.on(
+            FetchEvent.AUTH_REQUIRED,
+            partial(
+                self._continue_request_with_auth_callback,
+                proxy_username=proxy_credentials[0],
+                proxy_password=proxy_credentials[1],
+            ),
+            temporary=True,
+        )
 
     @staticmethod
     def _is_valid_tab(target: TargetInfo) -> bool:
@@ -696,10 +792,12 @@ class Browser(ABC):  # noqa: PLR0904
         )
 
         if not valid_tab:
+            logger.error(f'No valid tab found among {len(targets)} targets')
             raise NoValidTabFound()
 
         tab_id = valid_tab.get('targetId')
         if not tab_id:
+            logger.error('Valid tab missing targetId')
             raise NoValidTabFound('Tab missing targetId')
 
         return tab_id
@@ -717,6 +815,7 @@ class Browser(ABC):  # noqa: PLR0904
         self, command: Command[T_CommandParams, T_CommandResponse], timeout: int = 10
     ) -> T_CommandResponse:
         """Execute CDP command and return result (core method for browser communication)."""
+        logger.debug(f'Executing command: {command.get("method")} (timeout={timeout})')
         return await self._connection_handler.execute_command(command, timeout=timeout)
 
     def _setup_user_dir(self):
@@ -730,6 +829,7 @@ class Browser(ABC):  # noqa: PLR0904
             self.options.arguments.append(f'--user-data-dir={temp_dir.name}')
             if self.options.browser_preferences:
                 self._set_browser_preferences_in_temp_dir(temp_dir)
+        logger.debug(f'User dir setup complete: {self._get_user_data_dir()}')
 
     def _set_browser_preferences_in_temp_dir(self, temp_dir: TemporaryDirectory):
         os.mkdir(os.path.join(temp_dir.name, 'Default'))
@@ -738,6 +838,7 @@ class Browser(ABC):  # noqa: PLR0904
             os.path.join(temp_dir.name, 'Default', 'Preferences'), 'w', encoding='utf-8'
         ) as json_file:
             json.dump(preferences, json_file)
+        logger.debug('Wrote browser preferences to temp user dir')
 
     def _set_browser_preferences_in_user_data_dir(self, user_data_dir: str):
         """
@@ -769,6 +870,7 @@ class Browser(ABC):  # noqa: PLR0904
         preferences.update(self.options.browser_preferences)
         with open(preferences_path, 'w', encoding='utf-8') as json_file:
             json.dump(preferences, json_file, indent=2)
+        logger.debug(f'Updated browser preferences in user data dir: {preferences_path}')
 
     def _get_user_data_dir(self) -> Optional[str]:
         for arg in self.options.arguments:
@@ -781,8 +883,10 @@ class Browser(ABC):  # noqa: PLR0904
         """Validate WebSocket address."""
         min_slashes = 4
         if not ws_address.startswith('ws://'):
+            logger.error('Invalid WebSocket address: missing ws:// prefix')
             raise InvalidWebSocketAddress('WebSocket address must start with ws://')
         if len(ws_address.split('/')) < min_slashes:
+            logger.error('Invalid WebSocket address: not enough slashes')
             raise InvalidWebSocketAddress(
                 f'WebSocket address must contain at least {min_slashes} slashes'
             )
@@ -793,6 +897,7 @@ class Browser(ABC):  # noqa: PLR0904
         self._ws_address = ws_address
         self._connection_handler._ws_address = self._ws_address
         await self._connection_handler._ensure_active_connection()
+        logger.info('WebSocket address set for browser-level connection')
 
     def _get_tab_kwargs(self, target_id: str, browser_context_id: Optional[str] = None) -> dict:
         """
@@ -815,18 +920,28 @@ class Browser(ABC):  # noqa: PLR0904
             kwargs['ws_address'] = self._get_tab_ws_address(target_id)
         else:
             kwargs['connection_port'] = self._connection_port
+        logger.debug(f'Tab kwargs resolved for {target_id}: using_ws={bool(self._ws_address)}')
         return kwargs
 
     def _get_tab_ws_address(self, tab_id: str) -> str:
         """
-        Get WebSocket address for tab. If tab_id is not provided,
-        it will be derived from the targets.
+        Get WebSocket address for a specific tab, preserving any query or fragment
+        components present in the original browser-level WebSocket URL.
+
+        This ensures authentication tokens passed via query string (e.g.,
+        ws://host/devtools/browser/abc?token=XYZ) are retained when switching
+        to the page-level endpoint (devtools/page/<tab_id>), which is critical
+        for providers like Browserless or authenticated CDP proxies.
         """
         if not self._ws_address:
             raise InvalidWebSocketAddress('WebSocket address is not set')
 
-        ws_domain = '/'.join(self._ws_address.split('/')[:3])
-        return f'{ws_domain}/devtools/page/{tab_id}'
+        parts = urlsplit(self._ws_address)
+        # Preserve scheme and netloc; build the page path and keep query/fragment
+        page_path = f'/devtools/page/{tab_id}'
+        ws = urlunsplit((parts.scheme, parts.netloc, page_path, parts.query, parts.fragment))
+        logger.debug(f'Resolved tab WebSocket address: {ws}')
+        return ws
 
     @staticmethod
     def _sanitize_proxy_and_extract_auth(

{pydoll_python-2.9.0 → pydoll_python-2.9.2}/pydoll/browser/chromium/chrome.py

@@ -1,3 +1,4 @@
+import logging
 import platform
 from typing import Optional
 
@@ -7,6 +8,8 @@ from pydoll.browser.options import ChromiumOptions
 from pydoll.exceptions import UnsupportedOS
 from pydoll.utils import validate_browser_paths
 
+logger = logging.getLogger(__name__)
+
 
 class Chrome(Browser):
     """Chrome browser implementation for CDP automation."""
@@ -39,6 +42,7 @@ class Chrome(Browser):
             ValueError: If executable not found at default location.
         """
         os_name = platform.system()
+        logger.debug(f'Resolving default Chrome binary for OS: {os_name}')
 
         browser_paths = {
             'Windows': [
@@ -57,6 +61,9 @@ class Chrome(Browser):
         browser_path = browser_paths.get(os_name)
 
         if not browser_path:
+            logger.error(f'Unsupported OS: {os_name}')
             raise UnsupportedOS(f'Unsupported OS: {os_name}')
 
-        return validate_browser_paths(browser_path)
+        path = validate_browser_paths(browser_path)
+        logger.debug(f'Using Chrome binary: {path}')
+        return path

{pydoll_python-2.9.0 → pydoll_python-2.9.2}/pydoll/browser/chromium/edge.py

@@ -1,3 +1,4 @@
+import logging
 import platform
 from typing import Optional
 
@@ -7,6 +8,8 @@ from pydoll.browser.options import Options
 from pydoll.exceptions import UnsupportedOS
 from pydoll.utils import validate_browser_paths
 
+logger = logging.getLogger(__name__)
+
 
 class Edge(Browser):
     """Edge browser implementation for CDP automation."""
@@ -39,6 +42,7 @@ class Edge(Browser):
             ValueError: If executable not found at default location.
         """
         os_name = platform.system()
+        logger.debug(f'Resolving default Edge binary for OS: {os_name}')
 
         browser_paths = {
             'Windows': [
@@ -62,6 +66,9 @@ class Edge(Browser):
         browser_path = browser_paths.get(os_name)
 
         if not browser_path:
+            logger.error(f'Unsupported OS: {os_name}')
             raise UnsupportedOS()
 
-        return validate_browser_paths(browser_path)
+        path = validate_browser_paths(browser_path)
+        logger.debug(f'Using Edge binary: {path}')
+        return path