parsek-cdp 0.1.0__py3-none-any.whl

parsek_cdp/__init__.py

@@ -0,0 +1,55 @@
+"""parsek_cdp -- a Chrome DevTools Protocol client.
+
+``cdp`` is the generated protocol layer (one module per domain); ``core`` is the
+hand-written runtime (connection, browser, page, request tracking).
+
+Quickstart::
+
+    import asyncio
+    from parsek_cdp import Browser, Page, RequestListener
+
+    async def main():
+        browser = await Browser.connect_http(
+            "http://127.0.0.1:9222", page_class=Page[RequestListener]
+        )
+        page = await browser.new_page("https://example.com")
+        await page.navigate("https://example.com", wait_load=True)
+        print(len(page.request_listener.requests), "requests captured")
+
+    asyncio.run(main())
+"""
+
+import logging
+
+from ._logging import TRACE, get_logger
+from .core import (
+    Browser,
+    BrowserContext,
+    Element,
+    Feature,
+    Page,
+    ProtocolError,
+    Target,
+)
+from .core.frame import ElementState, Frame, LoadState
+from .core.page import NavigationError
+from .features import RequestListener
+
+# Library best practice: stay silent unless the application configures logging.
+get_logger(__name__).addHandler(logging.NullHandler())
+
+__all__ = [
+    "TRACE",
+    "Browser",
+    "BrowserContext",
+    "Element",
+    "ElementState",
+    "Feature",
+    "Frame",
+    "LoadState",
+    "NavigationError",
+    "Page",
+    "ProtocolError",
+    "RequestListener",
+    "Target",
+]

parsek_cdp/_logging.py

@@ -0,0 +1,49 @@
+"""Logging helpers for parsek_cdp.
+
+Adds a ``TRACE`` level (below ``DEBUG``) for the very verbose wire-level dumps
+(every CDP frame sent/received) so they can be enabled independently of normal
+debug logging.  Use :func:`get_logger` per module::
+
+    from .._logging import get_logger
+
+    logger = get_logger(__name__)
+    logger.trace("send %s", payload)   # only emitted when TRACE is enabled
+
+The library never configures handlers itself (a ``NullHandler`` is attached to
+the package logger in ``__init__``); the application decides where logs go, e.g.
+``logging.basicConfig(level=parsek_cdp.TRACE)``.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+#: Numeric level for wire-level tracing, below ``logging.DEBUG`` (10).
+TRACE = 5
+logging.addLevelName(TRACE, "TRACE")
+
+
+class TraceLogger(logging.Logger):
+    """A :class:`logging.Logger` with an extra :meth:`trace` method."""
+
+    def trace(self, msg: object, *args: Any, **kwargs: Any) -> None:
+        """Log at :data:`TRACE` level (cheap no-op when not enabled)."""
+        if self.isEnabledFor(TRACE):
+            self._log(TRACE, msg, args, **kwargs)
+
+
+# Loggers obtained from now on are TraceLogger instances.
+logging.setLoggerClass(TraceLogger)
+
+
+def get_logger(name: str) -> TraceLogger:
+    """Return the module logger, typed so ``logger.trace`` is visible."""
+    return logging.getLogger(name)  # type: ignore[return-value]
+
+
+# The websockets library logs every frame at DEBUG, which drowns out our own
+# logs once the app sets a DEBUG/TRACE root level.  Cap it at WARNING by
+# default; re-enable explicitly with
+# ``logging.getLogger("websockets").setLevel(logging.DEBUG)``.
+logging.getLogger("websockets").setLevel(logging.WARNING)

parsek_cdp/cdp/__init__.py

@@ -0,0 +1,247 @@
+"""Generated CDP package: every protocol domain.
+
+Each domain is importable as a namespace::
+
+    from parsek_cdp.cdp import Network
+    Network.RequestWillBeSent        # an event class
+    Network.ResourceType             # a type / enum
+    await page.cdp.Network.enable()  # a command (target-bound)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from . import accessibility as Accessibility
+from . import animation as Animation
+from . import audits as Audits
+from . import autofill as Autofill
+from . import backgroundservice as BackgroundService
+from . import bluetoothemulation as BluetoothEmulation
+from . import browser as Browser
+from . import cachestorage as CacheStorage
+from . import cast as Cast
+
+# Domain namespaces (events + types + command class).
+from . import console as Console
+from . import css as CSS
+from . import debugger as Debugger
+from . import deviceaccess as DeviceAccess
+from . import deviceorientation as DeviceOrientation
+from . import dom as DOM
+from . import domdebugger as DOMDebugger
+from . import domsnapshot as DOMSnapshot
+from . import domstorage as DOMStorage
+from . import emulation as Emulation
+from . import eventbreakpoints as EventBreakpoints
+from . import extensions as Extensions
+from . import fedcm as FedCm
+from . import fetch as Fetch
+from . import filesystem as FileSystem
+from . import headlessexperimental as HeadlessExperimental
+from . import heapprofiler as HeapProfiler
+from . import indexeddb as IndexedDB
+from . import input as Input
+from . import inspector as Inspector
+from . import io as IO
+from . import layertree as LayerTree
+from . import log as Log
+from . import media as Media
+from . import memory as Memory
+from . import network as Network
+from . import overlay as Overlay
+from . import page as Page
+from . import performance as Performance
+from . import performancetimeline as PerformanceTimeline
+from . import preload as Preload
+from . import profiler as Profiler
+from . import pwa as PWA
+from . import runtime as Runtime
+from . import schema as Schema
+from . import security as Security
+from . import serviceworker as ServiceWorker
+from . import storage as Storage
+from . import systeminfo as SystemInfo
+from . import target as Target
+from . import tethering as Tethering
+from . import tracing as Tracing
+from . import webaudio as WebAudio
+from . import webauthn as WebAuthn
+from .accessibility.functions import Accessibility as _Accessibility
+from .animation.functions import Animation as _Animation
+from .audits.functions import Audits as _Audits
+from .autofill.functions import Autofill as _Autofill
+from .backgroundservice.functions import BackgroundService as _BackgroundService
+from .bluetoothemulation.functions import BluetoothEmulation as _BluetoothEmulation
+from .browser.functions import Browser as _Browser
+from .cachestorage.functions import CacheStorage as _CacheStorage
+from .cast.functions import Cast as _Cast
+
+# Command classes for the per-target aggregator below.
+from .console.functions import Console as _Console
+from .css.functions import CSS as _CSS
+from .debugger.functions import Debugger as _Debugger
+from .deviceaccess.functions import DeviceAccess as _DeviceAccess
+from .deviceorientation.functions import DeviceOrientation as _DeviceOrientation
+from .dom.functions import DOM as _DOM
+from .domdebugger.functions import DOMDebugger as _DOMDebugger
+from .domsnapshot.functions import DOMSnapshot as _DOMSnapshot
+from .domstorage.functions import DOMStorage as _DOMStorage
+from .emulation.functions import Emulation as _Emulation
+from .eventbreakpoints.functions import EventBreakpoints as _EventBreakpoints
+from .extensions.functions import Extensions as _Extensions
+from .fedcm.functions import FedCm as _FedCm
+from .fetch.functions import Fetch as _Fetch
+from .filesystem.functions import FileSystem as _FileSystem
+from .headlessexperimental.functions import (
+    HeadlessExperimental as _HeadlessExperimental,
+)
+from .heapprofiler.functions import HeapProfiler as _HeapProfiler
+from .indexeddb.functions import IndexedDB as _IndexedDB
+from .input.functions import Input as _Input
+from .inspector.functions import Inspector as _Inspector
+from .io.functions import IO as _IO
+from .layertree.functions import LayerTree as _LayerTree
+from .log.functions import Log as _Log
+from .media.functions import Media as _Media
+from .memory.functions import Memory as _Memory
+from .network.functions import Network as _Network
+from .overlay.functions import Overlay as _Overlay
+from .page.functions import Page as _Page
+from .performance.functions import Performance as _Performance
+from .performancetimeline.functions import PerformanceTimeline as _PerformanceTimeline
+from .preload.functions import Preload as _Preload
+from .profiler.functions import Profiler as _Profiler
+from .pwa.functions import PWA as _PWA
+from .runtime.functions import Runtime as _Runtime
+from .schema.functions import Schema as _Schema
+from .security.functions import Security as _Security
+from .serviceworker.functions import ServiceWorker as _ServiceWorker
+from .storage.functions import Storage as _Storage
+from .systeminfo.functions import SystemInfo as _SystemInfo
+from .target.functions import Target as _Target
+from .tethering.functions import Tethering as _Tethering
+from .tracing.functions import Tracing as _Tracing
+from .webaudio.functions import WebAudio as _WebAudio
+from .webauthn.functions import WebAuthn as _WebAuthn
+
+if TYPE_CHECKING:
+    from ..core.target import CDPConnection
+
+
+class CDP:
+    """Access every CDP domain through a single target (commands)."""
+
+    def __init__(self, target: "CDPConnection") -> None:
+        self.connection = target
+        self.Console = _Console(target)
+        self.Debugger = _Debugger(target)
+        self.HeapProfiler = _HeapProfiler(target)
+        self.Profiler = _Profiler(target)
+        self.Runtime = _Runtime(target)
+        self.Schema = _Schema(target)
+        self.Accessibility = _Accessibility(target)
+        self.Animation = _Animation(target)
+        self.Audits = _Audits(target)
+        self.Autofill = _Autofill(target)
+        self.BackgroundService = _BackgroundService(target)
+        self.BluetoothEmulation = _BluetoothEmulation(target)
+        self.Browser = _Browser(target)
+        self.CSS = _CSS(target)
+        self.CacheStorage = _CacheStorage(target)
+        self.Cast = _Cast(target)
+        self.DOM = _DOM(target)
+        self.DOMDebugger = _DOMDebugger(target)
+        self.DOMSnapshot = _DOMSnapshot(target)
+        self.DOMStorage = _DOMStorage(target)
+        self.DeviceAccess = _DeviceAccess(target)
+        self.DeviceOrientation = _DeviceOrientation(target)
+        self.Emulation = _Emulation(target)
+        self.EventBreakpoints = _EventBreakpoints(target)
+        self.Extensions = _Extensions(target)
+        self.FedCm = _FedCm(target)
+        self.Fetch = _Fetch(target)
+        self.FileSystem = _FileSystem(target)
+        self.HeadlessExperimental = _HeadlessExperimental(target)
+        self.IO = _IO(target)
+        self.IndexedDB = _IndexedDB(target)
+        self.Input = _Input(target)
+        self.Inspector = _Inspector(target)
+        self.LayerTree = _LayerTree(target)
+        self.Log = _Log(target)
+        self.Media = _Media(target)
+        self.Memory = _Memory(target)
+        self.Network = _Network(target)
+        self.Overlay = _Overlay(target)
+        self.PWA = _PWA(target)
+        self.Page = _Page(target)
+        self.Performance = _Performance(target)
+        self.PerformanceTimeline = _PerformanceTimeline(target)
+        self.Preload = _Preload(target)
+        self.Security = _Security(target)
+        self.ServiceWorker = _ServiceWorker(target)
+        self.Storage = _Storage(target)
+        self.SystemInfo = _SystemInfo(target)
+        self.Target = _Target(target)
+        self.Tethering = _Tethering(target)
+        self.Tracing = _Tracing(target)
+        self.WebAudio = _WebAudio(target)
+        self.WebAuthn = _WebAuthn(target)
+
+
+__all__ = [
+    "CDP",
+    "Console",
+    "Debugger",
+    "HeapProfiler",
+    "Profiler",
+    "Runtime",
+    "Schema",
+    "Accessibility",
+    "Animation",
+    "Audits",
+    "Autofill",
+    "BackgroundService",
+    "BluetoothEmulation",
+    "Browser",
+    "CSS",
+    "CacheStorage",
+    "Cast",
+    "DOM",
+    "DOMDebugger",
+    "DOMSnapshot",
+    "DOMStorage",
+    "DeviceAccess",
+    "DeviceOrientation",
+    "Emulation",
+    "EventBreakpoints",
+    "Extensions",
+    "FedCm",
+    "Fetch",
+    "FileSystem",
+    "HeadlessExperimental",
+    "IO",
+    "IndexedDB",
+    "Input",
+    "Inspector",
+    "LayerTree",
+    "Log",
+    "Media",
+    "Memory",
+    "Network",
+    "Overlay",
+    "PWA",
+    "Page",
+    "Performance",
+    "PerformanceTimeline",
+    "Preload",
+    "Security",
+    "ServiceWorker",
+    "Storage",
+    "SystemInfo",
+    "Target",
+    "Tethering",
+    "Tracing",
+    "WebAudio",
+    "WebAuthn",
+]

parsek_cdp/cdp/accessibility/__init__.py

@@ -0,0 +1,15 @@
+"""The Accessibility CDP domain (generated).
+
+Importing ``Accessibility`` from ``parsek_cdp.cdp`` gives a namespace with this
+domain's events and types as attributes (``Accessibility.SomeEvent`` /
+``Accessibility.SomeType``); commands run on a target via ``page.cdp.Accessibility``.
+"""
+from . import events, functions, types
+from .functions import Accessibility
+from .events import *  # noqa: F401,F403 -- expose events on the namespace
+from .types import *  # noqa: F401,F403 -- expose types on the namespace
+
+#: Protocol domain name (used by features that declare ``domains=(Accessibility,)``).
+DOMAIN = "Accessibility"
+
+__all__ = ["events", "functions", "types", "Accessibility", "DOMAIN"]

parsek_cdp/cdp/accessibility/events.py

@@ -0,0 +1,35 @@
+"""Events for the Accessibility domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import FieldMeta
+from ..mixins.event import Event, register_event
+
+if TYPE_CHECKING:
+    from .types import AXNode
+
+@register_event("Accessibility.loadComplete")
+@dataclass
+class LoadComplete(Event):
+    """
+    The loadComplete event mirrors the load complete event sent by the browser to assistive
+    technology when the web page has finished loading.
+    """
+    root: AXNode
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('root', 'root', False, 'object', ref='Accessibility.AXNode'),
+    )
+
+
+@register_event("Accessibility.nodesUpdated")
+@dataclass
+class NodesUpdated(Event):
+    """The nodesUpdated event is sent every time a previously requested node has changed the in tree."""
+    nodes: List[AXNode]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('nodes', 'nodes', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Accessibility.AXNode')),
+    )
+
+__all__ = ["LoadComplete", "NodesUpdated"]

parsek_cdp/cdp/accessibility/functions.py

@@ -0,0 +1,202 @@
+"""Commands for the Accessibility domain (generated)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Literal, Optional
+
+from ..mixins.datatype import DataType, FieldMeta, encode
+
+if TYPE_CHECKING:
+    from .types import (
+        AXNode,
+        AXNodeId,
+    )
+    from ..dom.types import BackendNodeId as DOM_BackendNodeId
+    from ..dom.types import NodeId as DOM_NodeId
+    from ..page.types import FrameId as Page_FrameId
+    from ..runtime.types import RemoteObjectId as Runtime_RemoteObjectId
+
+@dataclass
+class GetPartialAXTreeReturn(DataType):
+    """Return value of :meth:`Accessibility.get_partial_ax_tree`."""
+    nodes: List[AXNode]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('nodes', 'nodes', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Accessibility.AXNode')),
+    )
+
+
+@dataclass
+class GetFullAXTreeReturn(DataType):
+    """Return value of :meth:`Accessibility.get_full_ax_tree`."""
+    nodes: List[AXNode]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('nodes', 'nodes', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Accessibility.AXNode')),
+    )
+
+
+@dataclass
+class GetRootAXNodeReturn(DataType):
+    """Return value of :meth:`Accessibility.get_root_ax_node`."""
+    node: AXNode
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('node', 'node', False, 'object', ref='Accessibility.AXNode'),
+    )
+
+
+@dataclass
+class GetAXNodeAndAncestorsReturn(DataType):
+    """Return value of :meth:`Accessibility.get_ax_node_and_ancestors`."""
+    nodes: List[AXNode]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('nodes', 'nodes', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Accessibility.AXNode')),
+    )
+
+
+@dataclass
+class GetChildAXNodesReturn(DataType):
+    """Return value of :meth:`Accessibility.get_child_ax_nodes`."""
+    nodes: List[AXNode]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('nodes', 'nodes', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Accessibility.AXNode')),
+    )
+
+
+@dataclass
+class QueryAXTreeReturn(DataType):
+    """Return value of :meth:`Accessibility.query_ax_tree`."""
+    nodes: List[AXNode]
+    __FIELDS__: ClassVar[tuple] = (
+        FieldMeta('nodes', 'nodes', False, 'array', inner=FieldMeta('', '', False, 'object', ref='Accessibility.AXNode')),
+    )
+
+
+class Accessibility:
+    """Commands of the Accessibility domain, bound to a target."""
+
+    def __init__(self, target: Any) -> None:
+        self._target = target
+
+
+    async def disable(self) -> None:
+        """Disables the accessibility domain."""
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Accessibility.disable', _params)
+        return None
+
+    async def enable(self) -> None:
+        """
+        Enables the accessibility domain which causes `AXNodeId`s to remain consistent between method calls.
+        This turns on accessibility for the page, which can impact performance until accessibility is disabled.
+        """
+        _params: Dict[str, Any] = {}
+        _result = await self._target.send('Accessibility.enable', _params)
+        return None
+
+    async def get_partial_ax_tree(self, *, node_id: Optional[DOM_NodeId] = None, backend_node_id: Optional[DOM_BackendNodeId] = None, object_id: Optional[Runtime_RemoteObjectId] = None, fetch_relatives: Optional[bool] = None) -> GetPartialAXTreeReturn:
+        """
+        Fetches the accessibility node and partial accessibility tree for this DOM node, if it exists.
+        :param node_id: Identifier of the node to get the partial accessibility tree for.
+        :param backend_node_id: Identifier of the backend node to get the partial accessibility tree for.
+        :param object_id: JavaScript object id of the node wrapper to get the partial accessibility tree for.
+        :param fetch_relatives: Whether to fetch this node's ancestors, siblings and children. Defaults to true.
+        """
+        _params: Dict[str, Any] = {}
+        if node_id is not None:
+            _params['nodeId'] = encode(FieldMeta('', '', False, 'primitive'), node_id)
+        if backend_node_id is not None:
+            _params['backendNodeId'] = encode(FieldMeta('', '', False, 'primitive'), backend_node_id)
+        if object_id is not None:
+            _params['objectId'] = encode(FieldMeta('', '', False, 'primitive'), object_id)
+        if fetch_relatives is not None:
+            _params['fetchRelatives'] = encode(FieldMeta('', '', False, 'primitive'), fetch_relatives)
+        _result = await self._target.send('Accessibility.getPartialAXTree', _params)
+        return GetPartialAXTreeReturn.from_json(_result)
+
+    async def get_full_ax_tree(self, *, depth: Optional[int] = None, frame_id: Optional[Page_FrameId] = None) -> GetFullAXTreeReturn:
+        """
+        Fetches the entire accessibility tree for the root Document
+        :param depth: The maximum depth at which descendants of the root node should be retrieved.
+        If omitted, the full tree is returned.
+        :param frame_id: The frame for whose document the AX tree should be retrieved.
+        If omitted, the root frame is used.
+        """
+        _params: Dict[str, Any] = {}
+        if depth is not None:
+            _params['depth'] = encode(FieldMeta('', '', False, 'primitive'), depth)
+        if frame_id is not None:
+            _params['frameId'] = encode(FieldMeta('', '', False, 'primitive'), frame_id)
+        _result = await self._target.send('Accessibility.getFullAXTree', _params)
+        return GetFullAXTreeReturn.from_json(_result)
+
+    async def get_root_ax_node(self, *, frame_id: Optional[Page_FrameId] = None) -> GetRootAXNodeReturn:
+        """
+        Fetches the root node.
+        Requires `enable()` to have been called previously.
+        :param frame_id: The frame in whose document the node resides.
+        If omitted, the root frame is used.
+        """
+        _params: Dict[str, Any] = {}
+        if frame_id is not None:
+            _params['frameId'] = encode(FieldMeta('', '', False, 'primitive'), frame_id)
+        _result = await self._target.send('Accessibility.getRootAXNode', _params)
+        return GetRootAXNodeReturn.from_json(_result)
+
+    async def get_ax_node_and_ancestors(self, *, node_id: Optional[DOM_NodeId] = None, backend_node_id: Optional[DOM_BackendNodeId] = None, object_id: Optional[Runtime_RemoteObjectId] = None) -> GetAXNodeAndAncestorsReturn:
+        """
+        Fetches a node and all ancestors up to and including the root.
+        Requires `enable()` to have been called previously.
+        :param node_id: Identifier of the node to get.
+        :param backend_node_id: Identifier of the backend node to get.
+        :param object_id: JavaScript object id of the node wrapper to get.
+        """
+        _params: Dict[str, Any] = {}
+        if node_id is not None:
+            _params['nodeId'] = encode(FieldMeta('', '', False, 'primitive'), node_id)
+        if backend_node_id is not None:
+            _params['backendNodeId'] = encode(FieldMeta('', '', False, 'primitive'), backend_node_id)
+        if object_id is not None:
+            _params['objectId'] = encode(FieldMeta('', '', False, 'primitive'), object_id)
+        _result = await self._target.send('Accessibility.getAXNodeAndAncestors', _params)
+        return GetAXNodeAndAncestorsReturn.from_json(_result)
+
+    async def get_child_ax_nodes(self, *, id: AXNodeId, frame_id: Optional[Page_FrameId] = None) -> GetChildAXNodesReturn:
+        """
+        Fetches a particular accessibility node by AXNodeId.
+        Requires `enable()` to have been called previously.
+        :param id:
+        :param frame_id: The frame in whose document the node resides.
+        If omitted, the root frame is used.
+        """
+        _params: Dict[str, Any] = {}
+        _params['id'] = encode(FieldMeta('', '', False, 'primitive'), id)
+        if frame_id is not None:
+            _params['frameId'] = encode(FieldMeta('', '', False, 'primitive'), frame_id)
+        _result = await self._target.send('Accessibility.getChildAXNodes', _params)
+        return GetChildAXNodesReturn.from_json(_result)
+
+    async def query_ax_tree(self, *, node_id: Optional[DOM_NodeId] = None, backend_node_id: Optional[DOM_BackendNodeId] = None, object_id: Optional[Runtime_RemoteObjectId] = None, accessible_name: Optional[str] = None, role: Optional[str] = None) -> QueryAXTreeReturn:
+        """
+        Query a DOM node's accessibility subtree for accessible name and role.
+        This command computes the name and role for all nodes in the subtree, including those that are
+        ignored for accessibility, and returns those that match the specified name and role. If no DOM
+        node is specified, or the DOM node does not exist, the command returns an error. If neither
+        `accessibleName` or `role` is specified, it returns all the accessibility nodes in the subtree.
+        :param node_id: Identifier of the node for the root to query.
+        :param backend_node_id: Identifier of the backend node for the root to query.
+        :param object_id: JavaScript object id of the node wrapper for the root to query.
+        :param accessible_name: Find nodes with this computed name.
+        :param role: Find nodes with this computed role.
+        """
+        _params: Dict[str, Any] = {}
+        if node_id is not None:
+            _params['nodeId'] = encode(FieldMeta('', '', False, 'primitive'), node_id)
+        if backend_node_id is not None:
+            _params['backendNodeId'] = encode(FieldMeta('', '', False, 'primitive'), backend_node_id)
+        if object_id is not None:
+            _params['objectId'] = encode(FieldMeta('', '', False, 'primitive'), object_id)
+        if accessible_name is not None:
+            _params['accessibleName'] = encode(FieldMeta('', '', False, 'primitive'), accessible_name)
+        if role is not None:
+            _params['role'] = encode(FieldMeta('', '', False, 'primitive'), role)
+        _result = await self._target.send('Accessibility.queryAXTree', _params)
+        return QueryAXTreeReturn.from_json(_result)