Merge pull request #427 from KrAsH-CoD3/fix/resource-leaks-and-deprecations

Fix: resource leaks, incorrect behavior, and deprecation warnings

Author: thalissonvs

examples/cloudflare_bypass.py

@@ -11,7 +11,7 @@ async def example_with_context_manager():
     """
     browser = Chrome()
     await browser.start()
-    page = await browser.get_page()
+    page = await browser.new_tab()
 
     print('Using context manager approach...')
     async with page.expect_and_bypass_cloudflare_captcha():
@@ -32,7 +32,7 @@ async def example_with_enable_disable():
     """
     browser = Chrome()
     await browser.start()
-    page = await browser.get_page()
+    page = await browser.new_tab()
 
     print('Using enable/disable approach...')
 

pydoll/browser/chromium/base.py

@@ -136,10 +136,11 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
         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,
-                os.path.join(user_data_dir, 'Default', 'Preferences'),
-            )
+            if user_data_dir:
+                shutil.copy2(
+                    self._backup_preferences_dir,
+                    os.path.join(user_data_dir, 'Default', 'Preferences'),
+                )
         if await self._is_browser_running(timeout=2):
             await self.stop()
 
@@ -165,6 +166,8 @@ async def connect(self, ws_address: str) -> Tab:
         await self._setup_ws_address(ws_address)
         tabs = await self.get_opened_tabs()
         logger.info(f'Connected. Tabs available: {len(tabs)}')
+        if not tabs:
+            raise NoValidTabFound('No tabs available on remote browser')
         return tabs[0]
 
     async def start(self, headless: bool = False) -> Tab:
@@ -358,11 +361,12 @@ async def get_opened_tabs(self) -> list[Tab]:
             for target in targets
             if target['type'] == 'page' and 'extension' not in target['url']
         ]
-        all_target_ids = [target['targetId'] for target in valid_tab_targets]
+        all_target_ids = {target['targetId'] for target in valid_tab_targets}
+        # Prune stale entries: close tabs whose IDs no longer appear in targets.
+        for stale_id in set(self._tabs_opened.keys()) - all_target_ids:
+            del self._tabs_opened[stale_id]
         existing_target_ids = list(self._tabs_opened.keys())
-        remaining_target_ids = [
-            target_id for target_id in all_target_ids if target_id not in existing_target_ids
-        ]
+        remaining_target_ids = list(all_target_ids - set(existing_target_ids))
         existing_tabs = [self._tabs_opened[target_id] for target_id in existing_target_ids]
         new_tabs = []
         for target_id in reversed(remaining_target_ids):

pydoll/browser/tab.py

@@ -624,13 +624,13 @@ async def find_shadow_roots(self, deep: bool = False, timeout: float = 0) -> lis
         if not timeout:
             return await self._collect_all_shadow_roots(deep)
 
-        start_time = asyncio.get_event_loop().time()
+        start_time = asyncio.get_running_loop().time()
         while True:
             shadow_roots = await self._collect_all_shadow_roots(deep)
             if shadow_roots:
                 return shadow_roots
 
-            if asyncio.get_event_loop().time() - start_time > timeout:
+            if asyncio.get_running_loop().time() - start_time > timeout:
                 raise WaitElementTimeout(
                     f'Timed out after {timeout}s waiting for shadow roots in page'
                 )
@@ -701,24 +701,27 @@ async def _resolve_shadow_host(self, host_backend_id: int | None) -> WebElement
     async def _collect_oopif_shadow_roots(self) -> list[ShadowRoot]:
         """Discover shadow roots inside cross-origin iframes (OOPIFs)."""
         browser_handler = ConnectionHandler(connection_port=self._connection_port)
-        targets_response: GetTargetsResponse = await browser_handler.execute_command(
-            TargetCommands.get_targets()
-        )
+        try:
+            targets_response: GetTargetsResponse = await browser_handler.execute_command(
+                TargetCommands.get_targets()
+            )
 
-        target_infos = targets_response.get('result', {}).get('targetInfos', [])
-        iframe_targets = [t for t in target_infos if t.get('type') == 'iframe']
+            target_infos = targets_response.get('result', {}).get('targetInfos', [])
+            iframe_targets = [t for t in target_infos if t.get('type') == 'iframe']
 
-        if not iframe_targets:
-            logger.debug('No OOPIF targets found')
-            return []
+            if not iframe_targets:
+                logger.debug('No OOPIF targets found')
+                return []
 
-        shadow_roots: list[ShadowRoot] = []
-        for target in iframe_targets:
-            roots = await self._collect_shadow_roots_from_oopif_target(target, browser_handler)
-            shadow_roots.extend(roots)
+            shadow_roots: list[ShadowRoot] = []
+            for target in iframe_targets:
+                roots = await self._collect_shadow_roots_from_oopif_target(target, browser_handler)
+                shadow_roots.extend(roots)
 
-        logger.debug(f'Found {len(shadow_roots)} shadow roots in OOPIFs')
-        return shadow_roots
+            logger.debug(f'Found {len(shadow_roots)} shadow roots in OOPIFs')
+            return shadow_roots
+        finally:
+            await browser_handler.close()
 
     async def _collect_shadow_roots_from_oopif_target(
         self,
@@ -1681,7 +1684,7 @@ async def expect_download(
             _page_events_was_enabled = False
             await self.enable_page_events()
 
-        loop = asyncio.get_event_loop()
+        loop = asyncio.get_running_loop()
         will_begin: asyncio.Future[bool] = loop.create_future()
         done: asyncio.Future[bool] = loop.create_future()
         state: dict[str, Any] = {

pydoll/connection/connection_handler.py

@@ -117,10 +117,10 @@ async def execute_command(
                 f'Sending command: id={command.get("id")}, method={command.get("method")}, '
                 f'timeout={timeout}s'
             )
-            start = asyncio.get_event_loop().time()
+            start = asyncio.get_running_loop().time()
             await ws.send(command_str)
             response: str = await asyncio.wait_for(future, timeout)
-            elapsed = asyncio.get_event_loop().time() - start
+            elapsed = asyncio.get_running_loop().time() - start
             logger.debug(f'Command completed: id={command.get("id")} in {elapsed:.3f}s')
             return json.loads(response)
         except asyncio.TimeoutError:

pydoll/constants.py

@@ -408,12 +408,34 @@ class Scripts:
 
         // Standard input/textarea
         if (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA') {
-            const start = el.selectionStart || el.value.length;
-            const end = el.selectionEnd || el.value.length;
+            el.focus();
+            let start, end;
+            try {
+                start = el.selectionStart;
+                end = el.selectionEnd;
+            } catch (e) {
+                // Unsupported input type (number, email, range, etc.)
+                el.value = text ? el.value + text : '';
+                el.dispatchEvent(new Event('input', { bubbles: true }));
+                el.dispatchEvent(new Event('change', { bubbles: true }));
+                return true;
+            }
+            const hasSelection = start !== end;
+            // When inserting empty text with no selection, select all first
+            // so the field is cleared (matches user expectation for insertText('')).
+            if (!hasSelection && text === '') {
+                el.select();
+                start = 0;
+                end = el.value.length;
+            }
+            start = start ?? el.value.length;
+            end = end ?? el.value.length;
             const before = el.value.substring(0, start);
             const after = el.value.substring(end);
             el.value = before + text + after;
-            el.selectionStart = el.selectionEnd = start + text.length;
+            try {
+                el.selectionStart = el.selectionEnd = start + text.length;
+            } catch (e) {}
             el.dispatchEvent(new Event('input', { bubbles: true }));
             el.dispatchEvent(new Event('change', { bubbles: true }));
             return true;

pydoll/decorators.py

@@ -88,7 +88,7 @@ def retry(
         exponential_backoff (bool): If True, increase the delay exponentially
 
     Usage:
-        @retry_on_exception(
+        @retry(
             max_retries=3,
             exceptions=[ValueError, TypeError],
             delay=1

pydoll/elements/mixins/find_elements_mixin.py

@@ -334,7 +334,7 @@ async def find_or_wait_element(
             return await self._find_across_iframes(segments, timeout, find_all, raise_exc)
 
         find_method = self._find_element if not find_all else self._find_elements
-        start_time = asyncio.get_event_loop().time()
+        start_time = asyncio.get_running_loop().time()
 
         if not timeout:
             logger.debug('No timeout specified; performing single attempt')
@@ -349,7 +349,7 @@ async def find_or_wait_element(
                     logger.debug('Found 1 element within timeout window')
                 return element
 
-            if asyncio.get_event_loop().time() - start_time > timeout:
+            if asyncio.get_running_loop().time() - start_time > timeout:
                 if raise_exc:
                     logger.error('Timeout while waiting for elements')
                     raise WaitElementTimeout(
@@ -387,7 +387,7 @@ async def _find_across_iframes(
             ElementNotFound: If ``timeout=0``, nothing found, and ``raise_exc=True``.
             WaitElementTimeout: If timeout expires and ``raise_exc=True``.
         """
-        start_time = asyncio.get_event_loop().time()
+        start_time = asyncio.get_running_loop().time()
         selector_repr = ' -> '.join(seg for _, seg in segments)
 
         while True:
@@ -400,7 +400,7 @@ async def _find_across_iframes(
                     raise ElementNotFound(f'Element not found across iframes: {selector_repr}')
                 return [] if find_all else None
 
-            if asyncio.get_event_loop().time() - start_time > timeout:
+            if asyncio.get_running_loop().time() - start_time > timeout:
                 if raise_exc:
                     raise WaitElementTimeout(
                         f'Timed out after {timeout}s waiting for element '

pydoll/elements/web_element.py

@@ -23,6 +23,7 @@
 from pydoll.elements.mixins import FindElementsMixin
 from pydoll.elements.shadow_root import ShadowRoot
 from pydoll.exceptions import (
+    CommandExecutionTimeout,
     ElementNotAFileInput,
     ElementNotFound,
     ElementNotInteractable,
@@ -32,6 +33,7 @@
     MissingScreenshotPath,
     ShadowRootNotFound,
     WaitElementTimeout,
+    WebSocketConnectionClosed,
 )
 from pydoll.interactions.iframe import IFrameContext, IFrameContextResolver
 from pydoll.interactions.keyboard import Keyboard
@@ -238,7 +240,10 @@ async def iframe_context(self) -> Optional[IFrameContext]:
             return None
 
         resolver = self._get_iframe_resolver()
+        old_context = self._iframe_context
         self._iframe_context = await resolver.resolve()
+        if old_context is not None and old_context is not self._iframe_context:
+            await old_context.close()
         self._apply_routing_from_context()
         return self._iframe_context
 
@@ -299,14 +304,14 @@ async def get_shadow_root(self, timeout: float = 0) -> ShadowRoot:
         if not timeout:
             return await self._get_shadow_root()
 
-        start_time = asyncio.get_event_loop().time()
+        start_time = asyncio.get_running_loop().time()
         while True:
             try:
                 return await self._get_shadow_root()
             except ShadowRootNotFound:
                 pass
 
-            if asyncio.get_event_loop().time() - start_time > timeout:
+            if asyncio.get_running_loop().time() - start_time > timeout:
                 raise WaitElementTimeout(
                     f'Timed out after {timeout}s waiting for shadow root on element'
                 )
@@ -512,7 +517,7 @@ async def wait_until(
             f'Waiting for element: visible={is_visible}, '
             f'interactable={is_interactable}, timeout={timeout}s'
         )
-        loop = asyncio.get_event_loop()
+        loop = asyncio.get_running_loop()
         start_time = loop.time()
         while True:
             results = await asyncio.gather(*(check() for check in checks))
@@ -683,9 +688,22 @@ async def insert_text(self, text: str):
         # Keep cached attributes coherent for common cases (e.g., input value)
         # This avoids forcing a DOM round-trip for simple assertions.
         if self._attributes.get('tag_name', '').lower() in {'input', 'textarea'}:
-            # When inserting into an empty field, resulting value equals inserted text.
-            # For complex cases (non-empty with caret), tests usually check non-empty.
-            self._attributes['value'] = text
+            # Re-read the actual DOM value to keep cache consistent.
+            # insertText appends at cursor, so the result may differ from
+            # the inserted text when the field already had content.
+            try:
+                live_result = await self.execute_script('return this.value', return_by_value=True)
+                self._attributes['value'] = (
+                    live_result.get('result', {}).get('result', {}).get('value', text)
+                )
+            except (
+                KeyError,
+                TypeError,
+                AttributeError,
+                CommandExecutionTimeout,
+                WebSocketConnectionClosed,
+            ):
+                self._attributes['value'] = text
 
     async def set_input_files(self, files: str | Path | list[str | Path]):
         """

pydoll/interactions/iframe.py

@@ -31,6 +31,12 @@ class IFrameContext:
     session_handler: Optional[ConnectionHandler] = None
     session_id: Optional[str] = None
 
+    async def close(self) -> None:
+        """Close the session handler if one was created for this context."""
+        if self.session_handler is not None:
+            await self.session_handler.close()
+            self.session_handler = None
+
 
 class IFrameContextResolver:
     """Resolves iframe context for WebElement."""
@@ -244,6 +250,9 @@ async def _resolve_oopif_if_needed(
                 resolved_url or current_document_url,
             )
 
+        if session_handler:
+            await session_handler.close()
+
         return (
             None,
             None,
@@ -274,6 +283,27 @@ async def _resolve_oopif_by_parent(
         browser_handler = ConnectionHandler(
             connection_port=self._element._connection_handler._connection_port
         )
+        try:
+            return await self._try_resolve_oopif(
+                browser_handler,
+                content_frame_id,
+                backend_node_id,
+                base_handler,
+                base_session_id,
+            )
+        except Exception:
+            await browser_handler.close()
+            raise
+
+    async def _try_resolve_oopif(
+        self,
+        browser_handler: ConnectionHandler,
+        content_frame_id: str,
+        backend_node_id: Optional[int],
+        base_handler: Optional[ConnectionHandler],
+        base_session_id: Optional[str],
+    ) -> tuple[Optional[ConnectionHandler], Optional[str], Optional[str], Optional[str]]:
+        """Core logic for OOPIF resolution. Caller owns the handler lifecycle."""
         targets_response: GetTargetsResponse = await browser_handler.execute_command(
             TargetCommands.get_targets()
         )
@@ -370,6 +400,7 @@ async def _resolve_oopif_by_parent(
             if child_frame_id:
                 return browser_handler, attached_session_id, child_frame_id, None
 
+        await browser_handler.close()
         return None, None, None, None
 
     @staticmethod

pydoll/utils/bundle.py

@@ -166,13 +166,27 @@ def rewrite_html_urls(
     html: str,
     asset_map: dict[str, tuple[str, bytes, str, ResourceType]],
 ) -> str:
-    """Rewrite asset URLs in HTML to point to local assets/ directory."""
-    for url, (filename, data, mime, rtype) in asset_map.items():
+    """Rewrite asset URLs in HTML to point to local assets/ directory.
+
+    Handles both absolute URLs (https://...) and root-relative paths (/style.css)
+    by deriving the path component from each absolute URL and replacing it too.
+    """
+    replacements: dict[str, str] = {}
+    for url, (filename, data, mime, rtype) in list(asset_map.items()):
         if rtype == ResourceType.STYLESHEET:
             css_text = data.decode('utf-8', errors='replace')
             rewritten_css = rewrite_css_urls(css_text, url, asset_map)
             asset_map[url] = (filename, rewritten_css.encode('utf-8'), mime, rtype)
-        html = html.replace(url, f'assets/{filename}')
+
+        replacements[url] = f'assets/{filename}'
+        parsed = urlparse(url)
+        if parsed.path and parsed.path != '/':
+            replacements[parsed.path] = f'assets/{filename}'
+
+    # Apply longest-first to prevent shorter paths from corrupting longer ones.
+    for old_str in sorted(replacements, key=len, reverse=True):
+        html = html.replace(old_str, replacements[old_str])
+
     return html