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

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

@@ -1,280 +0,0 @@
-"""A crawler implementation using Playwright.
-
-Portions based on  https://github.com/web-arena-x/webarena
-"""
-
-from __future__ import annotations
-
-import asyncio
-import re
-from typing import Literal
-
-from playwright.async_api import CDPSession, Page
-
-from accessibility_tree import AccessibilityTree, create_accessibility_tree
-from accessibility_tree_node import AccessibilityTreeNode
-from cdp.a11y import AXNodeId, AXTree
-from cdp.dom_snapshot import DOMSnapshot
-from rectangle import Rectangle
-
-# Number of seconds to wait for possible click induced navigation before proceeding
-_WAIT_FOR_NAVIGATION_TIME = 2.0
-
-# The waiting strategy to use between browser commands.
-# see https://playwright.dev/docs/api/class-page.
-_WAIT_STRATEGY: Literal["domcontentloaded"] = "domcontentloaded"
-
-
-class PageCrawler:
-    @classmethod
-    async def create(
-        cls, page: Page, device_scale_factor: float | None = None
-    ) -> PageCrawler:
-        # Enable chrome development tools, and accessibility tree output.
-        cdp_session = await page.context.new_cdp_session(page)
-        await cdp_session.send("Accessibility.enable")
-        return PageCrawler(
-            page,
-            cdp_session,
-            device_scale_factor or await page.evaluate("window.devicePixelRatio"),
-        )
-
-    def __init__(
-        self, page: Page, cdp_session: CDPSession, device_scale_factor: float
-    ) -> None:
-        self._page = page
-        self._cdp_session = cdp_session
-
-        # Start with an empty accessibility tree
-        self._rendered_main_content: str | None = None
-        self._rendered_accessibility_tree: str = ""
-        self._accessibility_tree: AccessibilityTree | None = None
-        self._device_scale_factor = device_scale_factor
-
-    @property
-    def page(self) -> Page:
-        return self._page
-
-    @property
-    def url(self) -> str:
-        return self._page.url
-
-    def lookup_node(self, node_id_or_tag: int | str) -> AccessibilityTreeNode:
-        """Looks up the node by id or tag.
-
-        Args:
-          node_id_or_tag: Either the id number (as int or str), or <tag_name>
-
-        Returns:
-          AccessibilityNode.
-
-        Raise:
-          LookupError if node is not matched.
-        """
-        node: AccessibilityTreeNode | None = None
-        node_id_or_tag = str(node_id_or_tag)
-        nodes = self._accessibility_tree["nodes"] if self._accessibility_tree else {}
-        if re.match("^<.*>", node_id_or_tag):
-            tag = node_id_or_tag[1:-1].lower()
-            # This is a smart tag, try to resolve it.
-            if node := next(
-                # We match on anything that starts with the code, this is potentially
-                # a little brittle, can be replaced with an RE if there are issues.
-                (
-                    n
-                    for n in nodes.values()
-                    if n.name.lower().startswith(tag) and not n.is_ignored
-                ),
-                None,
-            ):
-                return node
-            else:
-                raise LookupError(
-                    f"Could not find tag {node_id_or_tag} from {[node.name for node in nodes.values() if node.name]}"
-                )
-        else:
-            if (
-                node := nodes.get(AXNodeId(node_id_or_tag), None)
-            ) and not node.is_ignored:
-                return node
-            else:
-                raise LookupError(f"Could not find element with id {node_id_or_tag}")
-
-    async def update(self) -> None:
-        """Updates the accessibility tree and DOM from current page."""
-        await self._page.wait_for_load_state(_WAIT_STRATEGY)
-
-        available_retries = 2
-        retry_delay = 0.25
-        while available_retries:
-            self._accessibility_tree = create_accessibility_tree(
-                ax_nodes=AXTree(
-                    **await self._cdp_session.send("Accessibility.getFullAXTree", {})
-                ).nodes,
-                dom_snapshot=DOMSnapshot(
-                    **await self._cdp_session.send(
-                        "DOMSnapshot.captureSnapshot",
-                        {
-                            "computedStyles": [],
-                            "includeDOMRects": True,
-                        },
-                    )
-                ),
-                device_scale_factor=self._device_scale_factor,
-                window_bounds=Rectangle(
-                    await self._page.evaluate("window.pageXOffset"),
-                    await self._page.evaluate("window.pageYOffset"),
-                    await self._page.evaluate("window.screen.width"),
-                    await self._page.evaluate("window.screen.height"),
-                ),
-            )
-
-            self._rendered_main_content, self._rendered_accessibility_tree = (
-                (
-                    self._accessibility_tree["root"].render_main_content(),
-                    self._accessibility_tree["root"].render_accessibility_tree(),
-                )
-                if self._accessibility_tree
-                else (None, "")
-            )
-
-            if self._rendered_accessibility_tree:
-                return
-            # sometimes, the entire tree is initially ignored. in such cases, it's typically
-            # because we're sampling too soon. Waiting a small amount of time and trying again
-            # resolves the issue.
-            available_retries = available_retries - 1
-            await asyncio.sleep(retry_delay)
-
-    def render_at(self) -> str:
-        """Returns the current webpage accessibility tree.
-
-        Only elements visible on the screen will be rendered.
-        """
-        return self._rendered_accessibility_tree
-
-    def render_main_content(self) -> str | None:
-        return self._rendered_main_content
-
-    async def go_to_url(self, url: str) -> None:
-        """Goes to the given url.
-
-        Args:
-          url: The url to redirect crawler to.
-        """
-        if "://" not in url:
-            url = f"https://{url}"
-        try:
-            await self._page.goto(url, wait_until=_WAIT_STRATEGY)
-        except Exception as e:
-            print(f"caught {e}")
-            raise
-
-    async def click(self, element_id: int | str) -> None:
-        """Clicks the element with the given id.
-
-        Args:
-          element_id: The id for the element we want to click on.
-        """
-        element = self.lookup_node(element_id)
-        if element.bounds is None:
-            raise LookupError(f"Element with id {element_id} has no layout info.")
-
-        # Mouse.click() requires coordinates relative to the viewport:
-        # https://playwright.dev/python/docs/api/class-mouse#mouse-click,
-        # thus adjusting the Y coordinate since we only scroll up/down.
-        scroll_y = await self._page.evaluate("window.scrollY")
-        await self._click_and_await_navigation(
-            element.bounds.center_x, element.bounds.center_y - scroll_y
-        )
-
-    async def clear(self, element_id: int | str) -> None:
-        """Clears text within a field."""
-        await self.click(element_id)
-        await self._page.keyboard.press("Control+A")
-        await self._page.keyboard.press("Backspace")
-
-    async def type(self, element_id: int | str, text: str) -> None:
-        """Types into the element with the given id."""
-        await self.click(element_id)
-        await self._page.keyboard.type(text)
-
-    async def scroll(self, direction: Literal["up", "down"]) -> None:
-        """Scrolls the page to the given direction.
-
-        Args:
-          direction: The direction to scroll in ('up' or 'down')
-        """
-        match direction.lower():
-            case "up":
-                await self._page.evaluate(
-                    "(document.scrollingElement || document.body).scrollTop ="
-                    " (document.scrollingElement || document.body).scrollTop -"
-                    " window.innerHeight;"
-                )
-            case "down":
-                await self._page.evaluate(
-                    "(document.scrollingElement || document.body).scrollTop ="
-                    " (document.scrollingElement || document.body).scrollTop +"
-                    " window.innerHeight;"
-                )
-
-            case _:
-                raise ValueError(f"Invalid scroll direction {direction}")
-
-    async def forward(self) -> None:
-        """Move browser forward one history step."""
-        await self._page.go_forward(wait_until=_WAIT_STRATEGY)
-
-    async def back(self) -> None:
-        """Move browser backward one history step."""
-        await self._page.go_back(wait_until=_WAIT_STRATEGY)
-
-    async def refresh(self) -> None:
-        """Refresh (reload) the page."""
-        await self._page.reload(wait_until=_WAIT_STRATEGY)
-
-    async def _click_and_await_navigation(self, x: float, y: float) -> None:
-        """
-        Clicks on the specified coordinates and waits for navigation (if any) to occur.
-
-        This function sets up event listeners to detect in-page navigation or new page
-        navigation, performs a mouse click at the given coordinates, and waits for the
-        navigation to complete within the specified timeout period.
-
-        The point of this is to allow enough time to switch our page in the event of a new
-        page being opened. The problem is that it takes some amount of time, and the challenge
-        is determining how long to wait.
-
-        A naïve approach would simply sleep for some amount of time. However, this time may
-        not be long enough AND it would delay the common case by that delay waiting for a new
-        page navigation that never comes.
-
-        This approach accomplishes waiting the minimal amount of time in the common cases of
-        a click inducing an in page or new page navigation. The downside is that clicks that
-        do not induce navigation are delayed by the timeout. Since navigating clicks are much
-        more common, this is a reasonable approach.
-        """
-        future = asyncio.Future[None]()
-
-        async def on_in_page_navigation(_frame):
-            if not future.done():
-                await self._page.wait_for_load_state(_WAIT_STRATEGY)
-                future.set_result()
-
-        async def on_new_page(new_page):
-            if not future.done():
-                await new_page.wait_for_load_state(_WAIT_STRATEGY)
-                future.set_result(None)
-
-        self._page.once("framenavigated", on_in_page_navigation)
-        self._page.context.once("page", on_new_page)
-
-        await self._page.mouse.click(x, y)
-
-        try:
-            await asyncio.wait_for(future, timeout=_WAIT_FOR_NAVIGATION_TIME)
-            # a navigation of some sort has occurred and gotten to domcontentloaded
-        except (asyncio.TimeoutError, TimeoutError):
-            # No navigation occurred within the timeout period
-            pass

inspect_ai/tool/_tools/_web_browser/_resources/pyproject.toml

@@ -1,65 +0,0 @@
-[build-system]
-requires = ["setuptools>=64", "setuptools_scm[toml]>=8"]
-build-backend = "setuptools.build_meta"
-
-[tool.setuptools_scm]
-
-[tool.setuptools.packages.find]
-where = ["."]
-include = ["inspect_ai*"]
-
-[tool.ruff]
-src = ["."]
-
-[tool.ruff.lint]
-select = [
-    "E",      # pycodestyle errors
-    "W",      # pycodestyle warnings
-    "F",      # flake8
-    "D",      # pydocstyle
-    "I",      # isort
-    "SIM101", # duplicate isinstance
-    "UP038",  # non-pep604-isinstance
-    # "RET", # flake8-return
-    # "RUF", # ruff rules
-]
-ignore = ["E203", "E501", "D10", "D212", "D415"]
-
-[tool.ruff.lint.pydocstyle]
-convention = "google"
-
-[tool.pytest.ini_options]
-minversion = "7.0"
-addopts = "-rA --doctest-modules --color=yes"
-doctest_optionflags = ["NORMALIZE_WHITESPACE", "IGNORE_EXCEPTION_DETAIL"]
-asyncio_mode = "auto"
-asyncio_default_fixture_loop_scope = "function"
-log_level = "warning"
-
-[tool.mypy]
-warn_unused_ignores = true
-no_implicit_reexport = true
-strict_equality = true
-warn_redundant_casts = true
-warn_unused_configs = true
-disallow_any_explicit = true
-disallow_any_generics = true
-disallow_subclassing_any = true
-plugins=["pydantic.mypy"]
-
-
-[tool.pydantic-mypy]
-init_forbid_extra = true
-init_typed = true
-
-[tool.check-wheel-contents]
-ignore = ["W002", "W009"]
-
-[project]
-name = "web_browser_tool_container"
-requires-python = ">=3.10"
-dynamic = ["version", "dependencies"]
-
-
-[project.optional-dependencies]
-dev = ["pytest"]

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

@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-
-class Rectangle:
-    def __init__(self, left: float, top: float, width: float, height: float):
-        self._left = int(left)
-        self._width = int(width)
-        self._top = int(top)
-        self._height = int(height)
-
-    @classmethod
-    def _from_left_right_top_bottom(
-        cls, left: float, right: float, top: float, bottom: float
-    ) -> Rectangle:
-        return cls(left, top, right - left, bottom - top)
-
-    @property
-    def _right(self) -> int:
-        return self._left + self._width
-
-    @property
-    def _bottom(self) -> int:
-        return self._top + self._height
-
-    @property
-    def center_x(self) -> int:
-        return self._left + self._width // 2
-
-    @property
-    def center_y(self) -> int:
-        return self._top + self._height // 2
-
-    @property
-    def has_area(self) -> bool:
-        return self._width > 0 and self._height > 0
-
-    def __str__(self) -> str:
-        return f"({self._left}, {self._top}, {self._width}, {self._height})"
-
-    def scale(self, scale: float) -> Rectangle:
-        return self._from_left_right_top_bottom(
-            self._left * scale,
-            self._right * scale,
-            self._top * scale,
-            self._bottom * scale,
-        )
-
-    def overlaps(self, other: Rectangle) -> bool:
-        """Returns if the two rectangles intersect."""
-        return (
-            other._left < self._right  # pylint: disable=protected-access
-            and other._right > self._left  # pylint: disable=protected-access
-            and other._top < self._bottom  # pylint: disable=protected-access
-            and other._bottom > self._top  # pylint: disable=protected-access
-        )
-
-    def within(self, other: Rectangle) -> bool:
-        """Returns if this rectangle is within the other rectangle."""
-        return (
-            other._left <= self._left  # pylint: disable=protected-access
-            and other._right >= self._left  # pylint: disable=protected-access
-            and other._top <= self._bottom  # pylint: disable=protected-access
-            and other._bottom >= self._top  # pylint: disable=protected-access
-        )

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

@@ -1,146 +0,0 @@
-"""
-This module provides helper functions and classes for making strongly typed RPC calls.
-
-The module is designed to be generic and should not contain any use case specific logic.
-It uses the `httpx` library for making HTTP requests, `jsonrpcclient` for handling JSON-RPC responses,
-and `pydantic` for validating and parsing response data into Python objects.
-
-Classes:
-  RPCError: Custom exception for handling RPC errors.
-
-Functions:
-  typed_rpc_call: Makes a typed RPC call and returns the response as a Pydantic model.
-"""
-
-from typing import Generic, Mapping, Type, TypedDict, TypeVar
-
-from httpx import (
-    URL,
-    Client,
-    ConnectError,
-    ConnectTimeout,
-    HTTPStatusError,
-    ReadTimeout,
-    Response,
-)
-from jsonrpcclient import Error, Ok, parse, request
-from pydantic import BaseModel
-from tenacity import (
-    retry,
-    retry_if_exception,
-    stop_after_attempt,
-    stop_after_delay,
-    wait_exponential_jitter,
-)
-
-
-class RPCError(RuntimeError):
-    def __init__(self, *, code: int, message: str, data: object):
-        self.code = code
-        self.message = message
-        self.data = data
-        super().__init__(f"RPCError {code}: {message}")
-
-    def __str__(self):
-        return f"RPCError {self.code}: {self.message} (data: {self.data})"
-
-
-TBaseModel = TypeVar("TBaseModel", bound=BaseModel)
-
-
-def rpc_call(
-    url: URL | str,
-    method: str,
-    params: dict[str, object] | None,
-    response_class: Type[TBaseModel],
-) -> TBaseModel:
-    """
-    Makes an RPC call to the specified URL with the given method and parameters, and returns the response as a parsed and validated instance of the specified response class.
-
-    Args:
-      url (URL | str): The URL to which the RPC call is made.
-      method (str): The RPC method to be called.
-      response_class (Type[TBaseModel]): The class to which the response should be deserialized.
-      params (dict[str, object] | None, optional): The parameters to be sent with the RPC call. Defaults to None.
-
-    Returns:
-      TBaseModel: An instance of the response class containing the result of the RPC call.
-
-    Raises:
-      RPCError: If the RPC call returns an error response.
-      RuntimeError: If an unexpected response is received.
-    """
-    match parse(_retrying_post(url, request(method, params)).json()):
-        case Ok(ok_result):
-            return response_class(**ok_result)
-        case Error(code, message, data):
-            raise RPCError(code=code, message=message, data=data)
-        case _:
-            raise RuntimeError("how did we get here")
-
-
-def _retrying_post(url: URL | str, json: object | None = None) -> Response:
-    max_retries = 3
-    total_timeout = 180
-
-    @retry(
-        wait=wait_exponential_jitter(),
-        stop=(stop_after_attempt(max_retries) | stop_after_delay(total_timeout)),
-        retry=retry_if_exception(httpx_should_retry),
-    )
-    def do_post() -> Response:
-        with Client() as client:
-            return client.post(url, json=json, timeout=30)
-
-    return do_post()
-
-
-RPCArgsType = Type[Mapping[str, object]]
-
-
-class RPCCallTypes(TypedDict, Generic[TBaseModel]):
-    args_type: RPCArgsType
-    response_class: Type[TBaseModel]
-
-
-# TODO: cloned from inspect_ai repo code that is unavailable in the container
-# fix this by copying that source file into the container
-def httpx_should_retry(ex: BaseException) -> bool:
-    """Check whether an exception raised from httpx should be retried.
-
-    Implements the strategy described here: https://cloud.google.com/storage/docs/retry-strategy
-
-    Args:
-      ex (BaseException): Exception to examine for retry behavior
-
-    Returns:
-      True if a retry should occur
-    """
-    # httpx status exception
-    if isinstance(ex, HTTPStatusError):
-        # request timeout
-        if ex.response.status_code == 408:
-            return True
-        # lock timeout
-        elif ex.response.status_code == 409:
-            return True
-        # rate limit
-        elif ex.response.status_code == 429:
-            return True
-        # internal errors
-        elif ex.response.status_code >= 500:
-            return True
-        else:
-            return False
-
-    # connection error
-    elif is_httpx_connection_error(ex):
-        return True
-
-    # don't retry
-    else:
-        return False
-
-
-def is_httpx_connection_error(ex: BaseException) -> bool:
-    return isinstance(ex, ConnectTimeout | ConnectError | ConnectionError | ReadTimeout)

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

@@ -1,64 +0,0 @@
-import subprocess
-import sys
-
-# Playwright launches Chromium with --force-device-scale-factor=1 by default, which
-# ensures consistent rendering and measurement behavior using CSS pixels instead of
-# native device pixels, regardless of the actual display's DPI. On HiDPI displays,
-# like Apple Retina, the ratio of native pixels to CSS pixels is typically 2x or even 3x.
-#
-# However, the Chrome DevTools Protocol (CDP) has an inconsistency when running on
-# HiDPI devices with --force-device-scale-factor=1. Although window.devicePixelRatio
-# correctly reports as 1 (honoring the forced scale factor), CDP's LayoutTreeSnapshot.bounds
-# still returns coordinates in native device pixels without applying the forced scale factor,
-# resulting in a mismatch between CSS and native pixels.
-#
-# To work around this inconsistency, we determine the native scale factor independently
-# of browser-reported values, using system-level data via the get_screen_scale_factor helper
-# function. We then apply this actual scale factor to adjust the window bounds, ensuring
-# they are in the same coordinate space as LayoutTreeSnapshot.bounds. This alignment
-# allows the code to accurately calculate node visibility.
-
-
-def get_screen_scale_factor() -> float:
-    if sys.platform == "darwin":
-        from AppKit import NSScreen
-
-        return NSScreen.mainScreen().backingScaleFactor()
-    elif sys.platform == "win32":
-        try:
-            # Using GetDpiForSystem from Windows API
-            import ctypes
-
-            user32 = ctypes.windll.user32
-            user32.SetProcessDPIAware()
-            return user32.GetDpiForSystem() / 96.0
-        except Exception:
-            return 1.0
-    elif sys.platform.startswith("linux"):
-        try:
-            # Try to get scaling from gsettings (GNOME)
-            result = subprocess.run(
-                ["gsettings", "get", "org.gnome.desktop.interface", "scaling-factor"],
-                capture_output=True,
-                text=True,
-            )
-            if result.returncode == 0:
-                return float(result.stdout.strip())
-
-            # Try to get scaling from xrandr (X11)
-            result = subprocess.run(
-                ["xrandr", "--current"], capture_output=True, text=True
-            )
-            if result.returncode == 0:
-                # Parse xrandr output to find scaling
-                # This is a simplified check - might need adjustment
-                for line in result.stdout.splitlines():
-                    if "connected primary" in line and "x" in line:
-                        # Look for something like "3840x2160+0+0"
-                        resolution = line.split()[3].split("+")[0]
-                        if "3840x2160" in resolution:  # 4K
-                            return 2.0
-            return 1.0
-        except Exception:
-            return 1.0
-    return 1.0  # Default fallback