inspect-ai 0.3.70__py3-none-any.whl → 0.3.71__py3-none-any.whl

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

@@ -0,0 +1,65 @@
+[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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,146 @@
+"""
+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

@@ -0,0 +1,64 @@
+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

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

@@ -0,0 +1,180 @@
+from cdp.dom_snapshot import (
+    DocumentSnapshot,
+    DOMSnapshot,
+    LayoutTreeSnapshot,
+    NodeTreeSnapshot,
+    RareBooleanData,
+    StringIndex,
+    TextBoxSnapshot,
+)
+
+simple_node_tree = NodeTreeSnapshot()
+simple_layout_tree = LayoutTreeSnapshot(
+    nodeIndex=(),
+    styles=(),
+    bounds=(),
+    text=(),
+    stackingContexts=RareBooleanData(index=()),
+)
+simple_text_boxes = TextBoxSnapshot(layoutIndex=(), bounds=(), start=(), length=())
+simple_doc_snapshot = DocumentSnapshot(
+    documentURL=StringIndex(0),
+    title=StringIndex(1),
+    baseURL=StringIndex(0),
+    contentLanguage=StringIndex(2),
+    encodingName=StringIndex(3),
+    publicId=StringIndex(666),
+    systemId=StringIndex(666),
+    frameId=StringIndex(666),
+    nodes=simple_node_tree,
+    layout=simple_layout_tree,
+    textBoxes=simple_text_boxes,
+)
+simple_dom_snapshot = DOMSnapshot(
+    documents=(), strings=("documentUrl", "title", "contentLanguage", "encoding")
+)
+
+# THIS TEST MODULE IS DISABLED FOR NOW. IT WILL COME BACK
+
+# def test_foo():
+#     ax_node = cast(
+#         AXNode,
+#         {"nodeId": "666", "name": {"value": "Test"}, "role": {"value": "button"}},
+#     )
+#     ax_nodes = {ax_node.nodeId: ax_node}
+#     nodes: dict[AXNodeId, AccessibilityTreeNode] = {}
+#     snapshot_context = create_snapshot_context(simple_dom_snapshot)
+#     window_bounds = Rectangle(0, 0, 1024, 768)
+
+#     node = AccessibilityTreeNode(
+#         ax_node={"name": {"value": "Test"}, "role": {"value": "button"}},
+#         ax_nodes=ax_nodes,
+#         parent=None,
+#         all_accessibility_tree_nodes=nodes,
+#         snapshot_context=snapshot_context,
+#         device_scale_factor=1,
+#         window_bounds=window_bounds,
+#     )
+
+
+# class TestAccessibilityTreeNode(absltest.TestCase):
+#     def test_getitem(self):
+#         node_data = {"name": {"value": "Test"}, "role": {"value": "button"}}
+#         node = AccessibilityTreeNode(node_data)
+#         self.assertEqual(node["name"], {"value": "Test"})
+#         self.assertEqual(node["role"], {"value": "button"})
+#         self.assertIsNone(node["invalid_key"])
+
+#     def test_setitem(self):
+#         node_data = {"name": {"value": "Test"}}
+#         node = AccessibilityTreeNode(node_data)
+#         node["role"] = {"value": "button"}
+#         self.assertEqual(
+#             node._node, {"name": {"value": "Test"}, "role": {"value": "button"}}
+#         )
+
+#     def test_str_role_name(self):
+#         node_data = {
+#             "nodeId": "1",
+#             "role": {"value": "button"},
+#             "name": {"value": "Test Button"},
+#         }
+#         node = AccessibilityTreeNode(node_data, bounds=Rectangle(10, 10, 20, 20))
+#         self.assertIn('[1] button "Test Button"', str(node))
+
+#     def test_str_image_src(self):
+#         node_data = {
+#             "nodeId": "1",
+#             "role": {"value": "image"},
+#             "name": {"value": "Test Image"},
+#             "src": "image.png",
+#         }
+#         node = AccessibilityTreeNode(node_data, bounds=Rectangle(10, 10, 20, 20))
+#         self.assertIn('[1] image "Test Image" image.png', str(node))
+
+#     def test_str_property(self):
+#         node_data = {
+#             "nodeId": "1",
+#             "role": {"value": "link"},
+#             "name": {"value": "Test Link"},
+#             "properties": [{"name": "url", "value": {"value": "www.example.com"}}],
+#         }
+#         node = AccessibilityTreeNode(node_data, bounds=Rectangle(10, 10, 20, 20))
+#         self.assertIn('[1] link "Test Link" [url: www.example.com]', str(node))
+
+#     def test_str_empty(self):
+#         node_data = {"nodeId": "1"}
+#         node = AccessibilityTreeNode(node_data)
+#         self.assertIn('[*]  ""', str(node))
+
+#     def test_link_children(self):
+#         node_data = {"nodeId": "1", "childIds": [2, 3]}
+#         node = AccessibilityTreeNode(node_data)
+#         child1 = AccessibilityTreeNode({"nodeId": "2"})
+#         child2 = AccessibilityTreeNode({"nodeId": "3"})
+#         node_lookup = {2: child1, 3: child2}
+#         node.link_children(node_lookup)
+
+#         self.assertEqual(node.children, [child1, child2])
+#         self.assertEqual(child1._parent, node)
+#         self.assertEqual(child2._parent, node)
+
+#     def test_get_property(self):
+#         node_data = {"name": {"value": "Test"}, "role": {"value": "button"}}
+#         node = AccessibilityTreeNode(node_data)
+#         self.assertEqual(node.get_property("name"), {"value": "Test"})
+#         self.assertEqual(node.get_property("role"), {"value": "button"})
+#         self.assertIsNone(node.get_property("invalid_key"))
+
+#     def test_render(self):
+#         node_data = {
+#             "nodeId": "1",
+#             "ignored": False,
+#             "childIds": [2],
+#             "role": {"value": "button"},
+#             "name": {"value": "Test Button"},
+#         }
+#         node = AccessibilityTreeNode(node_data, bounds=Rectangle(20, 20, 30, 30))
+#         self.assertIn('[1] button "Test Button"', node.render())
+
+#     def test_to_render_with_children(self):
+#         node_data = {
+#             "nodeId": "1",
+#             "ignored": False,
+#             "childIds": [2, 3],
+#             "role": {"value": "button"},
+#             "name": {"value": "Test Button"},
+#         }
+#         node = AccessibilityTreeNode(node_data, bounds=Rectangle(20, 20, 30, 30))
+#         child_data = {
+#             "nodeId": "2",
+#             "ignored": False,
+#             "role": {"value": "text"},
+#             "name": {"value": "Child Text"},
+#         }
+#         child = AccessibilityTreeNode(child_data, bounds=Rectangle(20, 20, 30, 30))
+#         ignored_child_data = {
+#             "nodeId": "3",
+#             "ignored": True,
+#             "role": {"value": "text"},
+#             "name": {"value": "Child Text"},
+#         }
+#         ignored_child = AccessibilityTreeNode(
+#             ignored_child_data, bounds=Rectangle(20, 20, 30, 30)
+#         )
+#         node.link_children({2: child, 3: ignored_child})
+#         self.assertIn('[2] text "Child Text"', node.render())
+#         self.assertNotIn('[3] text "Child Text"', node.render())
+
+#     def test_property_string(self):
+#         node_data = {"properties": [{"name": "checked", "value": {"value": True}}]}
+#         node = AccessibilityTreeNode(node_data)
+#         self.assertEqual(node.property_string(), " [checked: True]")
+
+#     def test_property_string_with_ignored_property(self):
+#         node_data = {
+#             "properties": [{"name": "focusable", "value": {"value": "some_value"}}]
+#         }
+#         node = AccessibilityTreeNode(node_data)
+#         # 'focusable' is in _IGNORED_ACTREE_PROPERTIES
+#         self.assertEqual(node.property_string(), "")

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

@@ -1,10 +1,12 @@
-import playwright_crawler
 from absl.testing import parameterized
 
+import playwright_browser
+import playwright_crawler
+
 
 class TestPlaywrightCrawler(parameterized.TestCase):
     def setUp(self):
-        self._browser = playwright_crawler.PlaywrightBrowser()
+        self._browser = playwright_browser.PlaywrightBrowser()
         self._crawler = playwright_crawler.PlaywrightCrawler(
             self._browser.get_new_context()
         )
@@ -26,12 +28,14 @@ class TestPlaywrightCrawler(parameterized.TestCase):
 
     def test_render_accessibility_tree(self):
         self._crawler.go_to_page("https://www.example.com")
-        at_no_update = self._crawler.render(playwright_crawler.CrawlerOutputFormat.AT)
-        self.assertEqual(at_no_update, "<empty>")
+        at_no_update = self._crawler.render_at(
+            playwright_crawler.CrawlerOutputFormat.AT
+        )
+        self.assertEqual(at_no_update, "")
 
         self._crawler.update()
 
-        at_update = self._crawler.render(playwright_crawler.CrawlerOutputFormat.AT)
+        at_update = self._crawler.render_at(playwright_crawler.CrawlerOutputFormat.AT)
         nodes = at_update.splitlines()
         self.assertEqual(len(nodes), 3)
         self.assertTrue(
@@ -72,9 +76,9 @@ class TestPlaywrightCrawler(parameterized.TestCase):
             </body>
             </html>
             """
-        self._crawler._page.set_content(test_html)
+        self._crawler._page_future.set_content(test_html)
         self._crawler.update()
-        at_before_scroll = self._crawler.render(
+        at_before_scroll = self._crawler.render_at(
             playwright_crawler.CrawlerOutputFormat.AT
         )
         self.assertIn("Scrolling Test Page", at_before_scroll)
@@ -82,12 +86,14 @@ class TestPlaywrightCrawler(parameterized.TestCase):
 
         self._crawler.scroll("down")
         self._crawler.update()
-        at_after_scroll = self._crawler.render(
+        at_after_scroll = self._crawler.render_at(
             playwright_crawler.CrawlerOutputFormat.AT
         )
         self.assertIn("Click Me", at_after_scroll)
 
         self._crawler.click("17")
         self._crawler.update()
-        at_after_click = self._crawler.render(playwright_crawler.CrawlerOutputFormat.AT)
+        at_after_click = self._crawler.render_at(
+            playwright_crawler.CrawlerOutputFormat.AT
+        )
         self.assertIn("Text Changed!", at_after_click)

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

@@ -0,0 +1,15 @@
+from rectangle import Rectangle
+
+
+def test_overlaps():
+    bounds1 = Rectangle(10, 20, 30, 40)
+    bounds2 = Rectangle(20, 30, 40, 50)
+    assert bounds1.overlaps(bounds2)
+    bounds3 = Rectangle(50, 60, 20, 30)
+    assert not bounds1.overlaps(bounds3)
+
+
+def test_within():
+    bounds1 = Rectangle(231, 167, 2, 9)
+    bounds2 = Rectangle(231, 167, 26, 9)
+    assert bounds1.within(bounds2)

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

@@ -0,0 +1,44 @@
+import sys
+
+from web_browser_rpc_types import GoArgs
+from web_client import _parse_args
+
+
+def test_parse_args_session_name_handling() -> None:
+    test_cases: list[tuple[list[str], str, object]] = [
+        (
+            ["cli", "--session_name=my_session", "web_go", "boston.com"],
+            "web_go",
+            GoArgs(session_name="my_session", url="boston.com"),
+        ),
+        (
+            ["cli", "web_go", "boston.com", "--session_name=my_session"],
+            "web_go",
+            GoArgs(session_name="my_session", url="boston.com"),
+        ),
+        (
+            ["cli", "web_go", "--session_name=my_session", "boston.com"],
+            "web_go",
+            GoArgs(session_name="my_session", url="boston.com"),
+        ),
+        (
+            ["cli", "--session_name", "my_session", "web_go", "boston.com"],
+            "web_go",
+            GoArgs(session_name="my_session", url="boston.com"),
+        ),
+        (
+            ["cli", "web_go", "boston.com", "--session_name", "my_session"],
+            "web_go",
+            GoArgs(session_name="my_session", url="boston.com"),
+        ),
+        (
+            ["cli", "web_go", "--session_name", "my_session", "boston.com"],
+            "web_go",
+            GoArgs(session_name="my_session", url="boston.com"),
+        ),
+    ]
+    for argv, expected_cmd, expected_params in test_cases:
+        sys.argv = argv
+        cmd, params = _parse_args()
+        assert cmd == expected_cmd
+        assert params == expected_params

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

@@ -0,0 +1,39 @@
+from typing import Literal, TypedDict
+
+from pydantic import BaseModel
+
+
+class NewSessionArgs(TypedDict):
+    headful: bool
+
+
+class CrawlerBaseArgs(TypedDict):
+    session_name: str
+
+
+class GoArgs(CrawlerBaseArgs):
+    url: str
+
+
+class ClickArgs(CrawlerBaseArgs):
+    element_id: str
+
+
+class ScrollArgs(CrawlerBaseArgs):
+    direction: Literal["up", "down"]
+
+
+class TypeOrSubmitArgs(CrawlerBaseArgs):
+    element_id: str
+    text: str
+
+
+class NewSessionResponse(BaseModel):
+    session_name: str
+
+
+class CrawlerResponse(BaseModel):
+    web_url: str
+    main_content: str | None = None
+    web_at: str
+    error: str | None = None