I frame

[nzxcvz]

How do I click a button inside an i frame

[chronoAP]

Tab.query_select_all(target, include_frames=True). It is False by default.

[fqx]

@chronoAP It does not include iframe in a iframe, does it?

[chronoAP]

@fqx I think it does.

[fqx]

@chronoAP with help of claude, I tested this with a three-level page structure (outer.html → middle.html → inner.html) to verify the exact behavior.

Test setup:

outer.html ← main document
└─ middle.html ← first-level iframe
└─ inner.html ← nested iframe (iframe inside iframe)

Results with tab.find() / tab.find_all():

• outer page element (main document) — ✅ found
• middle frame element (1st-level iframe) — ✅ found
• inner frame element (nested iframe inside iframe) — ❌ timeout

Conclusion: find() does recurse into direct child iframes (one level), but does not recurse into iframes nested inside iframes.

Test files and full output: https://gist.github.com/fqx/b5f7f26dc302b25e8d0aef7267c61d0a

[chronoAP]

It looks like find_all uses a util filter_recurse_all to step through the iframes. select_all does not do this, and uses cdp's query_selector_all, and does the recursion itself. It does use filter_recurse as well, but I haven't investigated much past this. select_all has worked for what I needed but I may take your test and see what happens.

[chronoAP]

doc = await self.send(cdp.dom.get_document(-1, True))

This returned the full DOM tree, but cdp.dom.query_selector_all() would only query in a single document. So all the inner frames data was actually there, but wasn't being utilized / found. I modified it to walk the tree and grab each iframes content_document to be able to fully search the full depth.

I did not modify find() - just select_all() & query_selector_all()

Not fully tested, but this is where I'm at and it works for the test you linked above (modified to use select_all()).

async def select_all(
        self,
        selector: str,
        timeout: Union[int, float] = 10,
        include_frames: bool = False,
    ) -> List[Element]:
        """
        find multiple elements by css selector.
        can also be used to wait for such element to appear.


        :param selector: css selector, eg a[href], button[class*=close], a > img[src]
        :param timeout: raise timeout exception when after this many seconds nothing is found.
        :param include_frames: whether to include results in iframes.
        """

        loop = asyncio.get_running_loop()
        now = loop.time()
        selector = selector.strip()

        while True:
            items = []
            items.extend(await self.query_selector_all(selector, _include_frames=include_frames))

            if items:
                return items

            if loop.time() - now > timeout:
                raise asyncio.TimeoutError(
                    f"Timeout ({timeout}s) waiting for any element with selector: '{selector}'"
                )

            await self.sleep(0.5)


async def query_selector_all(
        self,
        selector: str,
        _node: cdp.dom.Node | Element | None = None,
        _include_frames: bool = False,
    ) -> List[Element]:
        """
        equivalent of javascripts document.querySelectorAll.
        this is considered one of the main methods to use in this package.

        it returns all matching :py:obj:`zendriver.Element` objects.

        :param selector: css selector. (first time? => https://www.w3schools.com/cssref/css_selectors.php )
        :param _node: internal use
        :return:
        :rtype:
        """
        doc: Any
        content_doc_nodes = []
        if not _node:
            # Returns all document node ids here
            doc = await self.send(cdp.dom.get_document(-1, True))
            if _include_frames:
                # Collect all iframe content_document node_ids
                stack = [doc]
                while stack:
                    # pop off items to grab the nodes
                    node = stack.pop()
                    if node.content_document:
                        # save the nodes
                        content_doc_nodes.append(node.content_document)
                        stack.append(node.content_document)
                    if node.children:
                        #  add back child nodes to pop later on
                        stack.extend(node.children)


        else:
            doc = _node
            if _node.node_name == "IFRAME":
                doc = _node.content_document
                if doc is None:
                    return [] # cross-origin iframes block access to content_document, skip gracefully
        node_ids = []

        try:
            node_ids = await self.send(
                cdp.dom.query_selector_all(doc.node_id, selector)
            )
            if _include_frames:
                for cd_node in content_doc_nodes:
                    try:
                        node_ids.extend(await self.send(
                            cdp.dom.query_selector_all(cd_node.node_id, selector)
                        ))
                    except Exception as e:
                        print(f"Exception in new content doc ids loop {e}")
                
        except ProtocolException as e:
            if _node is not None:
                if e.message is not None and "could not find node" in e.message.lower():
                    if getattr(_node, "__last", None):
                        delattr(_node, "__last")
                        return []
                    # if supplied node is not found, the dom has changed since acquiring the element
                    # therefore we need to update our passed node and try again
                    if isinstance(_node, element.Element):
                        await _node.update()
                    # make sure this isn't turned into infinite loop
                    setattr(_node, "__last", True)
                    return await self.query_selector_all(selector, _node, _include_frames=_include_frames)
            else:
                if e.message is not None and "could not find node" in e.message.lower():
                    # The document node is stale; refetch and retry once
                    doc = await self.send(cdp.dom.get_document(-1, True))
                    # Prevent double-retry by marking this node as 'last attempt'
                    setattr(doc, "__last", True)
                    return await self.query_selector_all(selector, doc, _include_frames=_include_frames)

                await self.disable_dom_agent()
                raise
        if not node_ids:
            return []
        items = []

        for nid in node_ids:
            node = util.filter_recurse(doc, lambda n: n.node_id == nid)
            if not node:
                for cd_node in content_doc_nodes:
                    node = util.filter_recurse(cd_node, lambda n: n.node_id == nid)
                    if node:
                        break
            # we pass along the retrieved document tree,
            # to improve performance
            if not node:
                continue
            elem = element.create(node, self, doc)
            items.append(elem)

        return items