phantomwright 0.1.0__tar.gz → 0.1.2__tar.gz

{phantomwright-0.1.0 → phantomwright-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phantomwright
-Version: 0.1.0
+Version: 0.1.2
 Summary: Bridging playwright-core patch + extending playwright API for stealth injection & user simulation
 Project-URL: homepage, https://github.com/ai-microsoft/phantom-wright
 Project-URL: changelog, https://github.com/ai-microsoft/phantom-wright/blob/main/CHANGELOG.md
@@ -31,9 +31,7 @@ Description-Content-Type: text/markdown
 - **Full Playwright API** — All APIs exported from Playwright, no learning curve
 - **Fingerprints Evasion** — Override browser fingerprints to better evade detection
 - **User Simulation** — Humanized page interactions for realistic behavior
-
-> [!NOTE]
-> Coming Soon: Captcha Resolver
+- **Captcha Solver** — Automatic Cloudflare challenge solving with background monitoring
 
 ## Installation
 
@@ -136,6 +134,55 @@ with sync_playwright() as p:
     browser.close()
 ```
 
+### Cloudflare Captcha Solver
+
+```python
+import logging
+from phantomwright.async_api import async_playwright
+from phantomwright.captcha.cloudfare.solver import CloudflareAutoSolver
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+async def main():
+    async with async_playwright() as pw:
+        browser = await pw.chromium.launch(headless=False)
+        context = await browser.new_context()
+        solver = CloudflareAutoSolver(
+            context,
+            max_attempts=3,
+            attempt_delay=5,
+            log_callback=logger.info,
+        )
+
+        solver.start()
+        urls = [
+            "https://2captcha.com/demo/cloudflare-turnstile", 
+            "https://2captcha.com/demo/cloudflare-turnstile-challenge"
+            ]
+        for url in urls:
+            page = await context.new_page()
+            await page.goto(url)
+```
+
+**Key Features:**
+
+- **Seamless Background Solving** — Once `solve()` is called, the solver continuously monitors all pages in the context. No manual intervention required, even across navigations on the same page.
+- **Dual Challenge Support** — Handles both Cloudflare **Turnstile** and **Interstitial** challenge types automatically.
+- **Logging Callback** — Provides real-time visibility into captcha events via `log_callback`. Receives JSON strings containing:
+  ```json
+  {
+    "event": "cloudflare_captcha_solve",
+    "url": "https://example.com",
+    "challenge_type": "TURNSTILE",
+    "success": true,
+    "attempts": 1,
+    "duration_sec": 2.345,
+    "error": null,
+    "timestamp": 1736985600.123
+  }
+  ```
+
 ## Development
 
 ### Setup & Test

{phantomwright-0.1.0 → phantomwright-0.1.2}/README.md

@@ -11,9 +11,7 @@
 - **Full Playwright API** — All APIs exported from Playwright, no learning curve
 - **Fingerprints Evasion** — Override browser fingerprints to better evade detection
 - **User Simulation** — Humanized page interactions for realistic behavior
-
-> [!NOTE]
-> Coming Soon: Captcha Resolver
+- **Captcha Solver** — Automatic Cloudflare challenge solving with background monitoring
 
 ## Installation
 
@@ -116,6 +114,55 @@ with sync_playwright() as p:
     browser.close()
 ```
 
+### Cloudflare Captcha Solver
+
+```python
+import logging
+from phantomwright.async_api import async_playwright
+from phantomwright.captcha.cloudfare.solver import CloudflareAutoSolver
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+async def main():
+    async with async_playwright() as pw:
+        browser = await pw.chromium.launch(headless=False)
+        context = await browser.new_context()
+        solver = CloudflareAutoSolver(
+            context,
+            max_attempts=3,
+            attempt_delay=5,
+            log_callback=logger.info,
+        )
+
+        solver.start()
+        urls = [
+            "https://2captcha.com/demo/cloudflare-turnstile", 
+            "https://2captcha.com/demo/cloudflare-turnstile-challenge"
+            ]
+        for url in urls:
+            page = await context.new_page()
+            await page.goto(url)
+```
+
+**Key Features:**
+
+- **Seamless Background Solving** — Once `solve()` is called, the solver continuously monitors all pages in the context. No manual intervention required, even across navigations on the same page.
+- **Dual Challenge Support** — Handles both Cloudflare **Turnstile** and **Interstitial** challenge types automatically.
+- **Logging Callback** — Provides real-time visibility into captcha events via `log_callback`. Receives JSON strings containing:
+  ```json
+  {
+    "event": "cloudflare_captcha_solve",
+    "url": "https://example.com",
+    "challenge_type": "TURNSTILE",
+    "success": true,
+    "attempts": 1,
+    "duration_sec": 2.345,
+    "error": null,
+    "timestamp": 1736985600.123
+  }
+  ```
+
 ## Development
 
 ### Setup & Test

{phantomwright-0.1.0 → phantomwright-0.1.2}/phantomwright/__init__.py

@@ -1,5 +1,5 @@
 """
-Patchright + Stealth Plugin + User Behavior Simulation = PhantomWright
+Patchright + Stealth Plugin + User Behavior Simulation + Cloudflare Captcha Solver = PhantomWright
 """
 
 from ._impl import _core_debug_patch, _evaluate_patch, _inconsistency_patch

phantomwright-0.1.2/phantomwright/_repo_version.py

@@ -0,0 +1 @@
+version = 'v0.1.2'

phantomwright-0.1.2/phantomwright/captcha/__init__.py

@@ -0,0 +1,5 @@
+from .cloudfare.solver import CloudflareSolverAsync
+
+__all__ = [
+    "CloudflareSolverAsync",
+]

phantomwright-0.1.2/phantomwright/captcha/cloudfare/scripts/observer.js

@@ -0,0 +1,71 @@
+(function () {
+  const selectors = __CF_SELECTORS__;
+  const reportedNodes = new WeakSet();
+  let pendingRescan = false;
+
+  function isRealCallbackReady() {
+    return (
+      typeof window.onCloudflareDetected === "function" &&
+      window.onCloudflareDetected.toString().includes("__cf_callback")
+    );
+  }
+
+  function tryReport(node, sel) {
+    if (reportedNodes.has(node)) return;
+
+    if (!isRealCallbackReady()) {
+      pendingRescan = true;
+      return;
+    }
+
+    reportedNodes.add(node);
+    try {
+      window.onCloudflareDetected(sel, location.href);
+    } catch (e) {
+      console.error("onCloudflareDetected failed:", e);
+    }
+  }
+
+  function scan(root) {
+    for (const sel of selectors) {
+      let nodes;
+      try {
+        nodes = root.querySelectorAll(sel);
+      } catch (e) {
+        continue;
+      }
+      for (const node of nodes) {
+        console.log("Found Cloudflare element for selector:", sel, node);
+        tryReport(node, sel);
+      }
+    }
+  }
+
+  function startObserve() {
+    const root = document.body || document.documentElement;
+    if (!root) return;
+
+    const observer = new MutationObserver(() => {
+      scan(root);
+    });
+
+    observer.observe(root, { childList: true, subtree: true });
+    scan(root);
+  }
+
+  const readyTimer = setInterval(() => {
+    if (pendingRescan && isRealCallbackReady()) {
+      const root = document.body || document.documentElement;
+      if (root) {
+        scan(root);
+        pendingRescan = false;
+      }
+    }
+  }, 300);
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", startObserve);
+  } else {
+    startObserve();
+  }
+})();

phantomwright-0.1.2/phantomwright/captcha/cloudfare/scripts/shadow_root.js

@@ -0,0 +1,11 @@
+(() => {
+  const originalAttachShadow = Element.prototype.attachShadow;
+  Element.prototype.attachShadow = function (init) {
+    const shadowRoot = originalAttachShadow.call(this, init);
+
+    // expose shadowRoot for later use
+    this.shadowRootUnl = shadowRoot;
+
+    return shadowRoot;
+  };
+})();

phantomwright-0.1.2/phantomwright/captcha/cloudfare/solver.py

@@ -0,0 +1,284 @@
+import asyncio
+import json
+import time
+from typing import Callable, Optional, Union
+
+from phantomwright.async_api import Page, Browser, BrowserContext
+
+from .utils.consts import ChallengeType
+from .utils.detection import (
+    detect_cf_challenge_type,
+    detect_cloudflare_challenge,
+)
+from .utils.dom_helpers import get_ready_checkbox
+from .utils.shadow_root import (
+    search_shadow_root_elements,
+    search_shadow_root_iframes,
+)
+from .utils.build_js import observer_js, shadow_root_js
+
+
+class CloudflareSolverAsync:
+    """
+    Automatic Cloudflare challenge solver for Playwright async API.
+
+    This class automatically detects and solves Cloudflare Turnstile and Interstitial
+    challenges by monitoring page loads and clicking the verification checkbox.
+
+    Attributes:
+        context: Playwright BrowserContext to monitor for Cloudflare challenges.
+        max_attempts: Maximum number of solve attempts per challenge (default: 3).
+        attempt_delay: Delay in seconds between retry attempts (default: 5).
+        log: Optional callback function for logging solve events.
+
+    Example:
+        >>> from phantomwright.async_api import async_playwright
+        >>> from .solver import CloudflareSolverAsync
+        >>>
+        >>> async with async_playwright() as p:
+        ...     browser = await p.chromium.launch(headless=False)
+        ...     context = await browser.new_context()
+        ...     solver = CloudflareSolverAsync(context, log_callback=print)
+        ...     solver.solve()  # Start monitoring for Cloudflare challenges
+        ...     page = await context.new_page()
+        ...     await page.goto("https://example.com")  # Challenges will be auto-solved
+    """
+
+    def __init__(
+        self,
+        context_or_browser: Union[BrowserContext, Browser],
+        *,
+        max_attempts: int = 3,
+        attempt_delay: int = 5,
+        log_callback: Optional[Callable[[str], None]] = None,
+    ):
+        """
+        Initialize the Cloudflare solver.
+
+        Args:
+            context_or_browser: Playwright BrowserContext or Browser to monitor for challenges.
+                If a Browser is provided, all its contexts will be monitored.
+            max_attempts: Maximum number of solve attempts per challenge.
+            attempt_delay: Delay in seconds between retry attempts.
+            log_callback: Optional callback function that receives a JSON string
+                containing solve event details. The JSON includes:
+                - event: "cloudflare_captcha_solve"
+                - url: The page URL where the challenge was detected
+                - challenge_type: "TURNSTILE" or "INTERSTITIAL"
+                - success: Whether the solve was successful
+                - attempts: Number of attempts made
+                - duration_sec: Time taken to solve
+                - error: Error message if failed, None otherwise
+                - timestamp: Unix timestamp of the event
+        """
+        self._is_browser = hasattr(context_or_browser, 'new_context')
+        self._browser: Optional[Browser] = context_or_browser if self._is_browser else None
+        self._context: Optional[BrowserContext] = None if self._is_browser else context_or_browser
+        self.max_attempts = max_attempts
+        self.attempt_delay = attempt_delay
+        self.log = log_callback
+
+        self.solve_click_delay = 6
+        self.wait_checkbox_attempts = 3
+        self.wait_checkbox_delay = 6
+        self.checkbox_click_attempts = 3
+
+        self.page_solve_state = {}
+
+    # ---------------- state ----------------
+    def _get_page_state(self, page: Page):
+        return self.page_solve_state.setdefault(
+            page,
+            {
+                "status": "idle",  # idle | solving | done
+                "last_url": None,
+            },
+        )
+
+    # ---------------- js rebind ----------------
+    async def _rebind(self, page: Page):
+        await page.evaluate("""
+            window.onCloudflareDetected = function(sel, url) {
+                window.__cf_callback(sel, url);
+            };
+        """)
+
+    # ---------------- report helper ----------------
+    def _log_final_report(self, report: dict):
+        data = {
+            "event": "cloudflare_captcha_solve",
+            "url": report.get("url"),
+            "challenge_type": report.get("challenge_type"),
+            "success": report.get("success"),
+            "attempts": report.get("attempts"),
+            "duration_sec": round(report.get("duration", 0), 3),
+            "error": report.get("error"),
+            "timestamp": time.time(),
+        }
+
+        self.log(json.dumps(data, ensure_ascii=False))
+
+    # ---------------- core solve ----------------
+    async def _auto_solve_cf(self, page: Page):
+        state = self._get_page_state(page)
+
+        report = {
+            "url": page.url,
+            "challenge_type": None,
+            "success": False,
+            "attempts": 0,
+            "error": None,
+            "start_time": time.time(),
+            "duration": 0,
+        }
+
+        try:
+            for attempt in range(1, self.max_attempts + 1):
+                report["attempts"] = attempt
+                try:
+                    challenge_type = await detect_cf_challenge_type(page)
+                    if challenge_type is None:
+                        raise Exception("Unknown challenge type")
+
+                    report["challenge_type"] = challenge_type.name
+
+                    if challenge_type is ChallengeType.TURNSTILE:
+                        await page.locator("#cf-turnstile").wait_for()
+
+                    cf_iframes = await search_shadow_root_iframes(
+                        captcha_container=page,
+                        src_filter="https://challenges.cloudflare.com/cdn-cgi/challenge-platform/",
+                    )
+                    if not cf_iframes:
+                        raise Exception("Cloudflare iframe not found")
+
+                    checkbox_data = await get_ready_checkbox(
+                        iframes=cf_iframes,
+                        delay=self.wait_checkbox_delay,
+                        attempts=self.wait_checkbox_attempts,
+                    )
+                    if not checkbox_data:
+                        raise Exception("Checkbox not ready")
+
+                    iframe, checkbox = checkbox_data
+
+                    click_errors = []
+                    for i in range(self.checkbox_click_attempts):
+                        try:
+                            await checkbox.click()
+                            break
+                        except Exception as e:
+                            click_errors.append(e)
+                    else:
+                        raise Exception(f"Failed to click checkbox. Errors: {click_errors}")
+
+                    await asyncio.sleep(self.solve_click_delay)
+                    if challenge_type is ChallengeType.TURNSTILE:
+                        success_elements = await search_shadow_root_elements(
+                            iframe, 'div[id="success"]'
+                        )
+                        solved = bool(success_elements)
+                    else:
+                        solved = not await detect_cloudflare_challenge(page)
+
+                    if solved:
+                        state["status"] = "done"
+                        state["last_url"] = page.url
+
+                        report["success"] = True
+                        return
+                    else:
+                        raise Exception("Solve attempt did not pass verification")
+
+                except Exception as e:
+                    report["error"] = str(e)
+                    await asyncio.sleep(self.attempt_delay)
+
+            state["status"] = "idle"
+            raise Exception(f"Failed after {self.max_attempts} attempts")
+
+        except Exception as final_error:
+            report["error"] = str(final_error)
+            raise
+
+        finally:
+            report["duration"] = time.time() - report["start_time"]
+            self._log_final_report(report)
+
+    # ---------------- callback ----------------
+    def _make_on_cf_detected(self, page: Page):
+        async def on_cf_detected(selector, url):
+            if not selector:
+                return
+
+            state = self._get_page_state(page)
+
+            if state["last_url"] != page.url:
+                state["status"] = "idle"
+                state["last_url"] = page.url
+
+            if state["status"] in ("solving", "done"):
+                return
+
+            state["status"] = "solving"
+
+            asyncio.create_task(self._auto_solve_cf(page))
+
+        return on_cf_detected
+
+    # ---------------- page setup ----------------
+    async def _setup_page(self, page: Page):
+        await page.add_init_script("""
+            window.onCloudflareDetected = function(sel, url) {};
+        """)
+        await page.add_init_script(observer_js)
+        await page.add_init_script(shadow_root_js)
+
+        await page.expose_function("__cf_callback", self._make_on_cf_detected(page))
+        page.on("load", lambda: asyncio.create_task(self._rebind(page)))
+
+    def _setup_context(self, context: BrowserContext) -> None:
+        """Set up page monitoring for a single context."""
+        context.on(
+            "page",
+            lambda p: asyncio.create_task(self._setup_page(p)),
+        )
+
+    # ---------------- public api ----------------
+    def start(self) -> None:
+        """
+        Start monitoring the browser or context for Cloudflare challenges.
+
+        This method registers event listeners to automatically detect and solve
+        Cloudflare challenges on any new page. Call this once after creating
+        the solver instance.
+
+        If initialized with a Browser, monitors all existing and new contexts.
+        If initialized with a BrowserContext, monitors only that context.
+
+        Note:
+            This method is synchronous but sets up async handlers internally.
+            Challenges will be solved automatically in the background.
+        """
+        if self._is_browser:
+            # Track which contexts we've already set up
+            self._monitored_contexts: set = set()
+            
+            def _check_and_setup_contexts():
+                for context in self._browser.contexts:
+                    if context not in self._monitored_contexts:
+                        self._monitored_contexts.add(context)
+                        self._setup_context(context)
+            
+            # Monitor all existing contexts
+            _check_and_setup_contexts()
+            
+            # Start a background task to periodically check for new contexts
+            async def _monitor_contexts():
+                while self._browser.is_connected():
+                    _check_and_setup_contexts()
+                    await asyncio.sleep(0.1)  # Check every 100ms for new contexts
+            
+            self._monitor_task = asyncio.create_task(_monitor_contexts())
+        else:
+            self._setup_context(self._context)

phantomwright-0.1.2/phantomwright/captcha/cloudfare/utils/build_js.py

@@ -0,0 +1,7 @@
+import json
+from pathlib import Path
+
+from .consts import ALL_CF_SELECTORS
+
+observer_js = Path(__file__).parent.parent.joinpath("scripts", "observer.js").read_text(encoding="utf-8").replace("__CF_SELECTORS__", json.dumps(ALL_CF_SELECTORS))
+shadow_root_js = Path(__file__).parent.parent.joinpath("scripts", "shadow_root.js").read_text(encoding="utf-8")

phantomwright-0.1.2/phantomwright/captcha/cloudfare/utils/consts.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+CF_INTERSTITIAL_SELECTORS = [
+    'script[src*="/cdn-cgi/challenge-platform/"]',
+]
+
+CF_TURNSTILE_SELECTORS = [
+    'input[name="cf-turnstile-response"]',
+    'script[src*="challenges.cloudflare.com/turnstile/v0"]',
+]
+
+ALL_CF_SELECTORS = CF_INTERSTITIAL_SELECTORS + CF_TURNSTILE_SELECTORS
+
+class ChallengeType(Enum):
+    INTERSTITIAL = "interstitial"
+    TURNSTILE = "turnstile"

phantomwright-0.1.2/phantomwright/captcha/cloudfare/utils/detection.py

@@ -0,0 +1,52 @@
+from typing import Literal, Union
+
+from phantomwright.async_api import ElementHandle, Frame, Page
+from .consts import CF_INTERSTITIAL_SELECTORS, CF_TURNSTILE_SELECTORS, ChallengeType
+
+async def detect_cloudflare_challenge(
+        captcha_container: Union[Page, Frame, ElementHandle],
+        challenge_type: Literal['turnstile', 'interstitial'] = 'turnstile'
+) -> bool:
+    """
+    Detect if a Cloudflare challenge is present in the provided captcha container by checking for specific predefined selectors
+
+    :param captcha_container: Page, Frame, ElementHandle
+    :param challenge_type: Type of challenge to detect ('turnstile' or 'interstitial')
+
+    :return: True if Cloudflare challenge is detected, False otherwise
+    """
+
+    if challenge_type not in ('turnstile', 'interstitial'):
+        raise ValueError("Invalid challenge_type: it must be either 'turnstile' or 'interstitial'")
+
+    selectors = CF_TURNSTILE_SELECTORS if challenge_type == 'turnstile' else CF_INTERSTITIAL_SELECTORS
+    for selector in selectors:
+        try:
+            element = captcha_container.locator(selector)
+            if await element.count() == 0:
+                continue
+        except Exception as e:
+            if 'Execution context was destroyed, most likely because of a navigation' in str(e):
+                # logger.warning(
+                #     'Execution context was destroyed while detecting Cloudflare challenge - counting as not detected')
+                return False
+
+        return True
+
+    return False
+
+async def detect_cf_challenge_type(page: Page):
+    async def any_selector_hit(selectors):
+        for sel in selectors:
+            try:
+                if await page.locator(sel).count() > 0:
+                    return True
+            except:
+                continue
+        return False
+
+    if await any_selector_hit(CF_INTERSTITIAL_SELECTORS):
+        return ChallengeType.INTERSTITIAL
+    if await any_selector_hit(CF_TURNSTILE_SELECTORS):
+        return ChallengeType.TURNSTILE
+    return None

phantomwright-0.1.2/phantomwright/captcha/cloudfare/utils/dom_helpers.py

@@ -0,0 +1,59 @@
+import asyncio
+from typing import Optional, List, Tuple
+
+from phantomwright.async_api import Frame, ElementHandle
+from .shadow_root import search_shadow_root_elements
+
+async def get_ready_checkbox(
+        iframes: List[Frame],
+        delay: int,
+        attempts: int
+) -> Optional[Tuple[Frame, ElementHandle]]:
+    """
+    Accepts a list of Cloudflare iframes, sorts out detached ones, collects checkboxes from the remaining iframes,
+    and waits until at least one checkbox is found and ready to be clicked (visible)
+
+    :param iframes: Cloudflare iframes
+    :param delay: Delay in seconds between attempts to find the checkbox
+    :param attempts: Maximum number of attempts to find the checkbox
+
+    :return: Tuple (checkboxes Frame, checkboxes ElementHandle) if checkbox is found and ready, None otherwise
+    """
+
+    # ensure at least one attempt
+    if attempts <= 0:
+        attempts = 1
+
+    for attempt in range(attempts):
+        try:
+            checkboxes = []
+
+            # search for checkboxes in each iframe
+            for iframe in iframes:
+                try:
+                    if iframe.is_detached():  # skip detached iframes
+                        continue
+
+                    iframe_checkboxes = await search_shadow_root_elements(iframe, 'input[type="checkbox"]')
+
+                    # add found checkboxes to the list with their parent iframe
+                    checkboxes += [(iframe, iframe_checkbox) for iframe_checkbox in iframe_checkboxes]
+                except Exception as e:
+                    pass
+                    # logger.error(f'Error searching for checkboxes in iframe: {e}')
+
+            # filter checkboxes that are visible and ready to be clicked
+            visible_checkboxes = []
+            for iframe, checkbox in checkboxes:
+                if await checkbox.is_visible():
+                    visible_checkboxes.append((iframe, checkbox))
+
+            if visible_checkboxes:
+                return visible_checkboxes[0]  # return the first visible checkbox
+
+            await asyncio.sleep(delay)
+        except Exception as e:
+            pass
+            # logger.error(f'Error while waiting for checkbox: {e}')
+
+    return None

phantomwright-0.1.2/phantomwright/captcha/cloudfare/utils/shadow_root.py

@@ -0,0 +1,122 @@
+from typing import Union, List, Optional
+from phantomwright.async_api import ElementHandle, Page, Frame
+
+async def get_shadow_roots(
+        queryable: Union[Page, Frame, ElementHandle],
+) -> List[ElementHandle]:
+    """
+    Get all shadow roots on the page
+
+    :param queryable: Page, Frame, ElementHandle
+
+    :return: List of shadow roots ElementHandles
+    """
+
+    # script to collect all shadow roots
+    js_script = """
+    () => {
+        const roots = [];
+
+        function collectShadowRoots(node) {
+            console.log("captcha", "node", node);
+            if (!node) return;
+
+            if (node.shadowRootUnl) {
+                roots.push(node.shadowRootUnl);
+                node = node.shadowRootUnl;
+            }
+
+            for (const el of node.querySelectorAll("*")) {
+                if (el.shadowRootUnl) {
+                    collectShadowRoots(el);
+                }
+            }
+        }
+
+        collectShadowRoots(document);
+        console.log(roots);
+        return roots;
+    }
+    """
+
+    handle = await queryable.evaluate_handle(js_script)
+
+    # convert JSHandle array to python list of ElementHandle
+    properties = await handle.get_properties()
+
+    shadow_roots = []
+    for prop_handle in properties.values():
+        element = prop_handle.as_element()
+        if element:
+            shadow_roots.append(element)
+
+    return shadow_roots
+
+
+async def search_shadow_root_elements(
+        queryable: Union[Page, Frame, ElementHandle],
+        selector: str
+) -> List[ElementHandle]:
+    """
+    Search for elements by selector within the shadow DOM of the queryable object
+
+    :param queryable: Page, Frame, ElementHandle
+    :param selector: CSS selector to search for elements
+
+    :return: List of ElementHandles that match the selector
+    """
+
+    elements = []
+
+    try:
+        shadow_roots = await get_shadow_roots(queryable)  # get all shadow roots in the queryable object
+        for shadow_root in shadow_roots:
+            # find all elements by selector within the shadow root
+            js_script = f"shadow => shadow.querySelector('{selector}')"
+
+            element_handle = await shadow_root.evaluate_handle(js_script)
+            if not element_handle:
+                continue
+
+            element = element_handle.as_element()
+            if element:
+                elements.append(element)
+    except Exception as e:
+        pass
+        # logger.error(f'Error searching for elements: {e}')
+
+    return elements
+
+
+async def search_shadow_root_iframes(
+        captcha_container: Union[Page, Frame, ElementHandle],
+        src_filter: str
+) -> Optional[List[Frame]]:
+    """
+    Search for an iframe within the shadow DOM, src of which includes the src_filter
+
+    :param captcha_container: Page, Frame, ElementHandle
+    :param src_filter: String to filter the iframe's src attribute
+
+    :return: list of matched iframes or empty list if no iframes found
+    """
+
+    matched_iframes = []
+
+    try:
+        iframe_elements = await search_shadow_root_elements(captcha_container, 'iframe')
+        for iframe_element in iframe_elements:
+            src_prop = await iframe_element.get_property('src')
+            src = await src_prop.json_value()
+
+            if src_filter in src:
+                cf_iframe = await iframe_element.content_frame()
+                if cf_iframe and cf_iframe.is_detached():  # skip detached iframes
+                    continue
+
+                matched_iframes.append(cf_iframe)
+    except Exception as e:
+        pass
+        # logger.error(f'Error searching for iframes: {e}')
+
+    return matched_iframes

{phantomwright-0.1.0 → phantomwright-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "phantomwright"
-version = "0.1.0"
+version = "0.1.2"
 description = "Bridging playwright-core patch + extending playwright API for stealth injection & user simulation"
 authors = [
     {name="Hang Yin", email="hangyin@microsoft.com"},

phantomwright-0.1.0/phantomwright/_repo_version.py

@@ -1 +0,0 @@
-version = 'v0.1.0'