inspect-ai 0.3.75__py3-none-any.whl → 0.3.77__py3-none-any.whl

inspect_ai/tool/_tools/_web_browser/_resources/accessibility_tree.py

@@ -1,71 +0,0 @@
-from functools import reduce
-from typing import Iterable, TypedDict
-
-from accessibility_tree_node import AccessibilityTreeNode
-from cdp.a11y import AXNode, AXNodeId
-from cdp.dom_snapshot import DOMSnapshot, create_snapshot_context
-from rectangle import Rectangle
-
-_AccType = tuple[
-    AXNode | None,
-    dict[AXNodeId, AXNode],
-]
-
-
-class AccessibilityTree(TypedDict):
-    root: AccessibilityTreeNode
-    nodes: dict[AXNodeId, AccessibilityTreeNode]
-
-
-def create_accessibility_tree(
-    *,
-    ax_nodes: Iterable[AXNode],
-    dom_snapshot: DOMSnapshot,
-    device_scale_factor: float,
-    window_bounds: Rectangle,
-) -> AccessibilityTree | None:
-    """
-    Creates an accessibility tree from the given Chrome DevTools Protocol AX nodes and DOM snapshot.
-
-    Args:
-      ax_nodes (Iterable[AXNode]): An iterable of AXNode objects representing the accessibility nodes.
-      dom_snapshot (DOMSnapshot): A snapshot of the DOM at the time of accessibility tree creation.
-      device_scale_factor (float): The scale factor of the device.
-      window_bounds (Bounds): The bounds of the window.
-
-    Returns:
-      AccessibilityTree: The accessibility tree.
-    """
-
-    # first make a dict of AXNodeId's to AXNode's and find the root on the way
-    def reducer(acc: _AccType, ax_node: AXNode) -> _AccType:
-        root_node, nodes = acc
-        nodes[ax_node.nodeId] = ax_node
-        return (
-            # TODO: What do we want for multiple roots?
-            root_node or (ax_node if ax_node.parentId is None else None),
-            nodes,
-        )
-
-    initial_acc: _AccType = (None, {})  # The inference engine is weak
-    root_node, nodes = reduce(reducer, ax_nodes, initial_acc)
-
-    if not root_node:
-        return None
-
-    # Now create the AccessibilityTreeNode hierarchy
-    snapshot_context = create_snapshot_context(dom_snapshot)
-    all_accessibility_tree_nodes: dict[AXNodeId, AccessibilityTreeNode] = {}
-
-    return AccessibilityTree(
-        root=AccessibilityTreeNode(
-            ax_node=root_node,
-            ax_nodes=nodes,
-            parent=None,
-            all_accessibility_tree_nodes=all_accessibility_tree_nodes,
-            snapshot_context=snapshot_context,
-            device_scale_factor=device_scale_factor,
-            window_bounds=window_bounds,
-        ),
-        nodes=all_accessibility_tree_nodes,
-    )

inspect_ai/tool/_tools/_web_browser/_resources/accessibility_tree_node.py

@@ -1,323 +0,0 @@
-from functools import reduce
-from typing import Optional
-
-from cdp.a11y import (
-    AXNode,
-    AXNodeId,
-    AXProperty,
-    AXPropertyName,
-    node_has_property,
-    string_from_ax_value,
-)
-from cdp.dom_snapshot import (
-    DOMSnapshotContext,
-    bounds_for_node_index,
-    current_url_src_for_node_index,
-    index_for_node_id,
-    text_value_for_node_index,
-)
-from rectangle import Rectangle
-
-# Properties to ignore when printing out the accessibility tree.
-_IGNORED_AT_PROPERTIES: set[AXPropertyName] = {
-    "focusable",
-    "readonly",
-    "level",
-    "settable",
-    "multiline",
-    "invalid",
-}
-
-# The AXRole enum is here (https://chromium.googlesource.com/chromium/chromium/+/HEAD/ui/accessibility/ax_enums.idl#62)
-_ROLES_IGNORED = {"horizontal_rule", "ignored"}
-
-# These are noisy and provide no real benefit unless there's a name associated with them
-_ROLES_REQUIRING_A_NAME = {"generic", "paragraph", "div"}
-
-# Used for debugging, include the elements bounding rect during output.
-_INCLUDE_BOUNDS_IN_OUTPUT = False
-
-
-class AccessibilityTreeNode:
-    def __init__(
-        self,
-        *,
-        ax_node: AXNode,
-        ax_nodes: dict[AXNodeId, AXNode],
-        parent: Optional["AccessibilityTreeNode"],
-        all_accessibility_tree_nodes: dict[AXNodeId, "AccessibilityTreeNode"],
-        snapshot_context: DOMSnapshotContext,
-        device_scale_factor: float,
-        window_bounds: Rectangle,
-    ):
-        all_accessibility_tree_nodes[ax_node.nodeId] = self
-
-        self._is_expanded = node_has_property(ax_node, "expanded")
-        self._ax_node = ax_node
-        self._parent = parent
-        self._is_ignored: bool | None = None
-        self._bounds: Rectangle | None = None
-        self._is_visible: bool | None = None
-        self._current_src_url: str | None = None
-        self._input: str | None = None
-        self.__closest_non_ignored_parent: AccessibilityTreeNode | None = None
-
-        dom_node_index = (
-            index_for_node_id(ax_node.backendDOMNodeId, snapshot_context)
-            if ax_node.backendDOMNodeId
-            else None
-        )
-
-        # The following three variables (_bounds, _is_visible, and _current_src_url) depend on
-        # info from the DOM element associated with this AXNode
-        if dom_node_index:
-            self._bounds = (
-                Rectangle(*layout_bounds).scale(1 / device_scale_factor)
-                if (
-                    layout_bounds := bounds_for_node_index(
-                        dom_node_index, snapshot_context
-                    )
-                )
-                is not None
-                else None
-            )
-            self._is_visible = (
-                (self._bounds.has_area and self._bounds.overlaps(window_bounds))
-                if self._bounds
-                else None
-            )
-            self._current_src_url = (
-                current_url_src_for_node_index(dom_node_index, snapshot_context)
-                if self.role == "image"
-                else None
-            )
-
-        if node_has_property(ax_node, "editable"):
-            # Sometimes a node will have it's input stored as 'value' other times we
-            # need to go looking through the DOM tree to find its matching string.
-            self._input = (
-                string_from_ax_value(ax_node.value)
-                if ax_node.value
-                else text_value_for_node_index(dom_node_index, snapshot_context)
-                if dom_node_index is not None
-                else None
-            )
-
-        # this is a little awkward, but the old code ensured that menuitems were visible in given the following condition
-        if self.role == "menuitem" and parent is not None and parent.is_expanded:
-            self._is_visible = True
-
-        # It's important to set all other properties before creating children in case
-        # the children sample parent.xxx
-        self.children = (
-            [
-                AccessibilityTreeNode(
-                    ax_node=ax_nodes[child_id],
-                    ax_nodes=ax_nodes,
-                    parent=self,
-                    all_accessibility_tree_nodes=all_accessibility_tree_nodes,
-                    snapshot_context=snapshot_context,
-                    device_scale_factor=device_scale_factor,
-                    window_bounds=window_bounds,
-                )
-                for child_id in ax_node.childIds
-            ]
-            if ax_node.childIds
-            else None
-        )
-
-    def __str__(self) -> str:
-        bounds_string = str(self.bounds) if _INCLUDE_BOUNDS_IN_OUTPUT else None
-
-        input_string = f'Current input: "{self._input}"' if self._input else None
-
-        name_string = f'"{self.name}"' if self.name else None
-        # Without bounds we can't click on the element, and therefore the ID
-        # can not be used. Still useful to show these elements though (e.g.)
-        # to let user know about options.
-        id_string = f"[{'*' if not self._bounds or not self._bounds.has_area else self._ax_node.nodeId}]"
-        url_string = self._current_src_url if self._current_src_url else None
-
-        url_string = _maybe_redact_base64_url(self._current_src_url)
-
-        return " ".join(
-            [
-                item
-                for item in [
-                    id_string,
-                    self.role,
-                    name_string,
-                    url_string,
-                    input_string,
-                    self._property_string(),
-                    bounds_string,
-                ]
-                if item is not None
-            ]
-        )
-
-    @property
-    def node_id(self) -> AXNodeId:
-        return self._ax_node.nodeId
-
-    @property
-    def name(self) -> str:
-        return string_from_ax_value(self._ax_node.name)
-
-    @property
-    def is_expanded(self) -> bool:
-        return self._is_expanded
-
-    @property
-    def is_visible(self) -> bool:
-        return self._is_visible or False
-
-    @property
-    def bounds(self) -> Rectangle | None:
-        return self._bounds
-
-    @property
-    def current_src_url(self) -> str | None:
-        return self._current_src_url
-
-    @property
-    def input(self) -> str | None:
-        return self._input
-
-    @property
-    def is_ignored(self) -> bool:
-        # computing _is_ignored is very expensive, do it on demand and remember the result
-        if self._is_ignored is None:
-            self._is_ignored = self._compute_is_ignored()
-        return self._is_ignored
-
-    @property
-    def role(self) -> str:
-        return string_from_ax_value(self._ax_node.role)
-
-    @property
-    def _closest_non_ignored_parent(self) -> Optional["AccessibilityTreeNode"]:
-        if self._parent and self.__closest_non_ignored_parent is None:
-            self.__closest_non_ignored_parent = (
-                None
-                if not self._parent
-                else self._parent
-                if not self._parent.is_ignored
-                else self._parent._closest_non_ignored_parent  # pylint: disable=protected-access
-            )
-        return self.__closest_non_ignored_parent
-
-    def render_accessibility_tree(self, indent: int = 0) -> str:
-        """Returns the string representation of the node and its children."""
-        result = ""
-        if not self.is_ignored:
-            result = "  " * indent + str(self) + "\n"
-            indent += 1
-        children_strings = [
-            child.render_accessibility_tree(indent) for child in self.children or []
-        ]
-        result = result + "".join([s for s in children_strings if s])
-        return result
-
-    def render_main_content(self) -> str | None:
-        return (
-            main_node._extract_text()  # pylint: disable=protected-access
-            if (main_node := self._get_main_content_node())
-            else None
-        )
-
-    def _compute_is_ignored(self) -> bool:
-        if self._ax_node.ignored or not self.is_visible or self.role in _ROLES_IGNORED:
-            return True
-
-        # if the parent is a link/button with a name, and this node is within the parent's bounds, we can ignore it.
-        if (
-            (closest_parent := self._closest_non_ignored_parent)
-            and closest_parent.bounds
-            and self.bounds
-            and (closest_parent.role == "link" or closest_parent.role == "button")
-            and closest_parent.name
-            and self.bounds.within(closest_parent.bounds)
-        ):
-            return True
-
-        if bool(self.name):  # excludes None or ""
-            # This simplifies things like links/buttons whose contents are sub-elements
-            # e.g.
-            #   [158] button "Menu"
-            #     [1166] StaticText "Menu"
-            # becomes
-            #   [158] button "Menu"
-            return self._parent is not None and self._parent.name == self.name
-
-        return self.role in _ROLES_REQUIRING_A_NAME
-
-    def _get_main_content_node(self) -> Optional["AccessibilityTreeNode"]:
-        if self.role == "main":
-            return self
-
-        return next(
-            (
-                result
-                for child in self.children or []
-                if (result := child._get_main_content_node())  # pylint: disable=protected-access
-            ),
-            None,
-        )
-
-    def _extract_text(self):
-        """
-        Recursively extracts and concatenates text from the accessibility tree nodes.
-
-        This method traverses the accessibility tree starting from the current node,
-        concatenating the text of each node.
-
-        Returns:
-          str: The concatenated text from the accessibility tree nodes, with
-             appropriate spacing based on node roles.
-        """
-        if not self.is_visible:
-            return ""
-
-        def reducer(acc, child):
-            child_text = child._extract_text()  # pylint: disable=protected-access
-            return (
-                acc
-                + (
-                    "\n\n"
-                    if child.role
-                    in {"paragraph", "note", "row", "div", "heading", "region"}
-                    else " "
-                )
-                + child_text
-            )
-
-        return reduce(reducer, self.children or [], self.name).strip()
-
-    def _property_string(self) -> str:
-        properties = [
-            _prop_name_value_str(node_property)
-            if node_property.value.value
-            else f"{node_property.name}"
-            for node_property in self._ax_node.properties or ()
-            if node_property.name not in _IGNORED_AT_PROPERTIES
-        ]
-        return " [" + ", ".join(properties) + "]" if properties else ""
-
-
-def _prop_name_value_str(node_property: AXProperty) -> str:
-    # pre-commit hook (debug-statements) crashes if value is inlined below
-    value = (
-        _maybe_redact_base64_url(node_property.value.value)
-        if node_property.name == "url" and isinstance(node_property.value.value, str)
-        else node_property.value.value
-    )
-    return f"{node_property.name}: {value}"
-
-
-def _maybe_redact_base64_url(url: str | None) -> str | None:
-    return (
-        "data:<base64-data-removed>"
-        if url and url.startswith("data:") and "base64" in url
-        else url
-    )

inspect_ai/tool/_tools/_web_browser/_resources/cdp/__init__.py

@@ -1,5 +0,0 @@
-"""
-Types and pure functional helpers associated with Chrome DevTools Protocol
-
-https://chromedevtools.github.io/devtools-protocol/
-"""

inspect_ai/tool/_tools/_web_browser/_resources/cdp/a11y.py

@@ -1,279 +0,0 @@
-"""
-Types and pure functional helpers associated with Chrome DevTools Protocol's 'Accessibility' Domain
-
-https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/
-"""
-
-from typing import Literal, NewType, Optional
-
-from pydantic import BaseModel
-
-from cdp.dom import DOMBackendNodeId
-
-# brand these str's so that we don't confuse them with other str's
-PageFrameId = NewType("PageFrameId", str)
-AXNodeId = NewType("AXNodeId", str)
-
-
-AXPropertyName = Literal[
-    "actions",
-    "busy",
-    "disabled",
-    "editable",
-    "focusable",
-    "focused",
-    "hidden",
-    "hiddenRoot",
-    "invalid",
-    "keyshortcuts",
-    "settable",
-    "roledescription",
-    "live",
-    "atomic",
-    "relevant",
-    "root",
-    "autocomplete",
-    "hasPopup",
-    "level",
-    "multiselectable",
-    "orientation",
-    "multiline",
-    "readonly",
-    "required",
-    "valuemin",
-    "valuemax",
-    "valuetext",
-    "checked",
-    "expanded",
-    "modal",
-    "pressed",
-    "selected",
-    "activedescendant",
-    "controls",
-    "describedby",
-    "details",
-    "errormessage",
-    "flowto",
-    "labelledby",
-    "owns",
-    "url",
-]
-
-
-AXValueType = Literal[
-    "boolean",
-    "tristate",
-    "booleanOrUndefined",
-    "idref",
-    "idrefList",
-    "integer",
-    "node",
-    "nodeList",
-    "number",
-    "string",
-    "computedString",
-    "token",
-    "tokenList",
-    "domRelation",
-    "role",
-    "internalRole",
-    "valueUndefined",
-]
-
-
-class AXRelatedNode(BaseModel, frozen=True):
-    backendDOMNodeId: DOMBackendNodeId
-    """The BackendNodeId of the related DOM node."""
-    idref: str | None = None
-    """The IDRef value provided, if any."""
-    text: str | None = None
-    """The text alternative of this node in the current context."""
-
-
-AXValueSourceType = Literal[
-    "attribute", "implicit", "stylet", "contents", "placeholder", "relatedElement"
-]
-
-AXValueNativeSourceType = Literal[
-    "description",
-    "figcaption",
-    "label",
-    "labelfor",
-    "labelwrapped",
-    "legend",
-    "rubyannotation",
-    "tablecaption",
-    "title",
-    "other",
-]
-
-
-class AXValueSource(BaseModel, frozen=True):
-    """A single source for a computed AX property."""
-
-    type: AXValueSourceType
-    """What type of source this is."""
-    value: Optional["AXValue"] = None
-    """The value of this property source."""
-    attribute: str | None = None
-    """The name of the relevant attribute, if any."""
-    attributeValue: Optional["AXValue"] = None
-    """The value of the relevant attribute, if any."""
-    superseded: bool | None = None
-    """Whether this source is superseded by a higher priority source."""
-    nativeSource: AXValueNativeSourceType | None = None
-    """The native markup source for this value, e.g. a `<label>` element."""
-    nativeSourceValue: Optional["AXValue"] = None
-    """The value, such as a node or node list, of the native source."""
-    invalid: bool | None = None
-    """Whether the value for this property is invalid."""
-    invalidReason: str | None = None
-    """Reason for the value being invalid, if it is."""
-
-
-class AXValue(BaseModel, frozen=True):
-    """A single computed AX property."""
-
-    type: AXValueType
-    """The type of this value."""
-    value: object | None = None
-    """The computed value of this property."""
-    relatedNodes: tuple[AXRelatedNode, ...] | None = None
-    """One or more related nodes, if applicable."""
-    sources: tuple[AXValueSource, ...] | None = None
-    """The sources which contributed to the computation of this property."""
-
-
-class AXProperty(BaseModel, frozen=True):
-    name: AXPropertyName
-    """The name of this property."""
-    value: AXValue
-    """The value of this property."""
-
-
-# AXNode's ignoredReasons is documented to be a list[AXProperty]. However, that seems to
-# be erroneous since the namespace for ignored reason names is completely separate from property names.
-class AXIgnoredReason(BaseModel, frozen=True):
-    # name: Literal[
-    #     "uninteresting",
-    #     "ariaHiddenSubtree",
-    #     "ariaHiddenElement",
-    #     "notRendered",
-    #     "notVisible",
-    #     "emptyAlt",
-    # ]
-    name: str  # since this is all undocumented, it's best to be loose
-    """The name of this ignored reason."""
-    value: AXValue
-    """The value of this ignored reason."""
-
-
-class AXNode(BaseModel, frozen=True):
-    """A node in the accessibility tree."""
-
-    nodeId: AXNodeId
-    """Unique identifier for this node."""
-    ignored: bool
-    """Wether this node is ignore3d for accessibility"""
-    ignoredReasons: tuple[AXIgnoredReason, ...] | None = None
-    """Collection of reasons why this node is hidden."""
-    role: AXValue | None = None
-    """This `Node`'s role, wether explicit or implicit."""
-    chromeRole: AXValue | None = None
-    """This `Node`'s Chrome raw role."""
-    name: AXValue | None = None
-    """The accessible name for this `Node`."""
-    description: AXValue | None = None
-    """The accessible description for this `Node`."""
-    value: AXValue | None = None
-    """The value for this `Node`."""
-    properties: tuple[AXProperty, ...] | None = None
-    """All other properties"""
-    parentId: AXNodeId | None = None
-    """ID for this node's parent."""
-    childIds: tuple[AXNodeId, ...] | None = None
-    """IDs for each of this node's child nodes."""
-    backendDOMNodeId: DOMBackendNodeId | None = None
-    """The backend ID for the associated DOM node, if any."""
-    frameId: PageFrameId | None = None
-    """The frame ID for the frame associated with this nodes document."""
-
-
-class AXTree(BaseModel, frozen=True):
-    nodes: tuple[AXNode, ...]
-
-
-# CDP defines `AXValue.value` as `Any`, so this is a coercion function
-def string_from_ax_value(value: AXValue | None) -> str:
-    """
-    Coerces an AXValue to a string.
-
-    Args:
-      value (AXValue | None): The AXValue to be coerced.
-
-    Returns:
-      str: The string representation of the AXValue, or an empty string if the value is None or not a string.
-    """
-    return value.value if value and isinstance(value.value, str) else ""
-
-
-def node_has_property(node: AXNode, property_name: AXPropertyName) -> bool:
-    """
-    Checks if an AXNode has a specific property.
-
-    Args:
-      node (AXNode): The AXNode to check.
-      property_name (AXPropertyName): The name of the property to look for.
-
-    Returns:
-      bool: True if the node has the property, False otherwise.
-    """
-    return node_property(node, property_name) is not None
-
-
-def node_property(node: AXNode, property_name: AXPropertyName) -> AXProperty | None:
-    """
-    Retrieves a specific property from an AXNode.
-
-    Args:
-      node (AXNode): The AXNode to retrieve the property from.
-      property_name (AXPropertyName): The name of the property to retrieve.
-
-    Returns:
-      AXProperty | None: The property if found, otherwise None.
-    """
-    return next(
-        (prop for prop in node.properties or () if prop.name == property_name), None
-    )
-
-
-def node_bool_property(node: AXNode, property_name: AXPropertyName) -> bool:
-    """
-    Retrieves a boolean property from an AXNode.
-
-    Args:
-      node (AXNode): The AXNode to retrieve the property from.
-      property_name (AXPropertyName): The name of the property to retrieve.
-
-    Returns:
-      bool: The boolean value of the property, or False if the property is not found or not a boolean.
-    """
-    return bool(prop.value) if (prop := node_property(node, property_name)) else False
-
-
-def node_str_property(node: AXNode, property_name: AXPropertyName) -> str | None:
-    """
-    Retrieves a str property from an AXNode.
-
-    Args:
-      node (AXNode): The AXNode to retrieve the property from.
-      property_name (AXPropertyName): The name of the property to retrieve.
-
-    Returns:
-      str: The str value of the property, or None if the property is not found or not a str.
-    """
-    prop = node_property(node, property_name)
-    if prop is None:
-        return None
-    v = prop.value
-    return v.value if isinstance(v.value, str) else None

inspect_ai/tool/_tools/_web_browser/_resources/cdp/dom.py

@@ -1,9 +0,0 @@
-"""
-Types associated with Chrome DevTools Protocol's 'DOM' Domain
-
-https://chromedevtools.github.io/devtools-protocol/tot/DOM/
-"""
-
-from typing import NewType
-
-DOMBackendNodeId = NewType("DOMBackendNodeId", int)