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

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

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

@@ -1,63 +1,213 @@
-"""A client to interract with the web server."""
-
+import argparse
 import sys
+from typing import Literal
 
-import grpc
-from dm_env_rpc.v1 import connection as dm_env_connection
-from dm_env_rpc.v1 import dm_env_adaptor, dm_env_rpc_pb2
+from constants import DEFAULT_SESSION_NAME, SERVER_PORT
+from rpc_client_helpers import RPCError, rpc_call
+from web_browser_rpc_types import (
+    ClickArgs,
+    CrawlerBaseArgs,
+    CrawlerResponse,
+    GoArgs,
+    NewSessionArgs,
+    NewSessionResponse,
+    ScrollArgs,
+    TypeOrSubmitArgs,
+)
 
-_DM_ENV_BASE_PORT = 9443
-_WORLD_NAME = "WebBrowser"
-_SESSION_FLAG = "--session_name="
+_SERVER_URL = f"http://localhost:{SERVER_PORT}/"
 
 
-def parse_args(cli_args: list[str]) -> tuple[str, str]:
-    if not cli_args:
-        return _WORLD_NAME, ""
+def main() -> None:
+    if len(sys.argv) > 1:
+        command, params = _parse_args()
+        _execute_command(command, params)
+    else:
+        _interactive_mode()
 
-    if cli_args[0].startswith(_SESSION_FLAG):
-        world_name = cli_args[0][len(_SESSION_FLAG) :]
 
-        if len(cli_args) == 1:
-            return world_name, ""
+def _execute_command(
+    command: str,
+    params: NewSessionArgs
+    | GoArgs
+    | ClickArgs
+    | TypeOrSubmitArgs
+    | ScrollArgs
+    | CrawlerBaseArgs,
+) -> None:
+    try:
+        if command == "new_session":
+            print(
+                rpc_call(
+                    _SERVER_URL, command, dict(params), NewSessionResponse
+                ).session_name
+            )
         else:
-            return world_name, " ".join(cli_args[1:])
+            response = rpc_call(
+                _SERVER_URL,
+                command,
+                dict(params),
+                CrawlerResponse,
+            )
+            for key, value in vars(response).items():
+                if value is not None:
+                    print(key, ": ", value)
 
-    else:
-        return _WORLD_NAME, " ".join(cli_args)
+    except RPCError as rpc_error:
+        _return_error(f"error: {rpc_error}")
 
 
-def main() -> None:
-    world_name, command = parse_args(sys.argv[1:])
-
-    # Keep connection open even when empty data pings are received. This is
-    # required to avoid a "too many pings" error.
-    options = [
-        ("grpc.keepalive_permit_without_calls", 0),
-        ("grpc.keepalive_timeout_ms", 20000),
-        ("grpc.http2.max_pings_without_data", 0),
-        ("grpc.http2.max_pings_without_data", 0),
-        ("grpc.http2.max_ping_strikes", 0),
-        ("grpc.http2.min_recv_ping_interval_without_data_ms", 0),
-    ]
-    channel = grpc.secure_channel(
-        f"localhost:{_DM_ENV_BASE_PORT}",
-        grpc.local_channel_credentials(),
-        options=options,
+def _interactive_mode() -> None:
+    print(
+        "Welcome to the Playwright Crawler interactive mode!\n"
+        "commands:\n"
+        "  web_go <URL> - goes to the specified url.\n"
+        "  web_click <ELEMENT_ID> - clicks on a given element.\n"
+        "  web_scroll <up/down> - scrolls up or down one page.\n"
+        "  web_forward - navigates forward a page.\n"
+        "  web_back - navigates back a page.\n"
+        "  web_refresh - reloads current page (F5).\n"
+        "  web_type <ELEMENT_ID> <TEXT> - types the specified text into the input with the specified id.\n"
+        "  web_type_submit <ELEMENT_ID> <TEXT> - types the specified text into the input with the specified id and presses ENTER to submit the form."
+    )
+
+    session_created = False
+    while True:
+        try:
+            user_input = input("Enter command: ").strip()
+            if user_input.lower() in {"exit", "quit"}:
+                break
+            args = user_input.split()
+            sys.argv = ["cli"] + args
+            command, params = _parse_args()
+            print(f"command: {command}, params: {params}")
+            if not session_created:
+                _execute_command("new_session", NewSessionArgs(headful=True))
+                session_created = True
+            _execute_command(command, params)
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            print(f"Error: {e}")
+
+
+def _return_error(error: str) -> None:
+    print(error, file=sys.stderr)
+    sys.exit(1)
+
+
+def _create_main_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="web_client")
+    parser.add_argument(
+        "--session_name",
+        type=str,
+        required=False,
+        default=DEFAULT_SESSION_NAME,
+        help="Session name",
     )
-    connection = dm_env_connection.Connection(channel)
-
-    specs = connection.send(
-        dm_env_rpc_pb2.JoinWorldRequest(world_name=world_name)
-    ).specs
-
-    with dm_env_adaptor.DmEnvAdaptor(
-        connection=connection, specs=specs, nested_tensors=False
-    ) as env:
-        time_step = env.step({"command": command})
-        for key, value in time_step.observation.items():
-            print(key, ": ", value)
-        env.close()
+    return parser
+
+
+def _create_command_parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(prog="web_client")
+
+    subparsers = result.add_subparsers(dest="command", required=True)
+
+    go_parser = subparsers.add_parser("web_go")
+    go_parser.add_argument("url", type=str, help="URL to navigate to")
+
+    click_parser = subparsers.add_parser("web_click")
+    click_parser.add_argument("element_id", type=str, help="ID of the element to click")
+
+    scroll_parser = subparsers.add_parser("web_scroll")
+    scroll_parser.add_argument(
+        "direction",
+        type=str,
+        choices=["up", "down"],
+        help="Direction to scroll (up or down)",
+    )
+    subparsers.add_parser("web_forward")
+    subparsers.add_parser("web_back")
+    subparsers.add_parser("web_refresh")
+
+    type_parser = subparsers.add_parser("web_type")
+    type_parser.add_argument(
+        "element_id", type=str, help="ID of the element to type into"
+    )
+    type_parser.add_argument("text", type=str, help="The text to type")
+
+    submit_parser = subparsers.add_parser("web_type_submit")
+    submit_parser.add_argument(
+        "element_id",
+        type=str,
+        help="ID of the element to type into and submit",
+    )
+    submit_parser.add_argument("text", type=str, help="The text to type")
+
+    # Add common argument to all subparsers
+    for name, subparser in subparsers.choices.items():
+        if name != "new_session":
+            subparser.add_argument(
+                "--session_name",
+                type=str,
+                nargs="?",
+                required=False,
+                default=DEFAULT_SESSION_NAME,
+                help="Session name",
+            )
+
+    return result
+
+
+main_parser = _create_main_parser()
+command_parser = _create_command_parser()
+
+
+def _parse_args() -> (
+    tuple[Literal["web_go"], GoArgs]
+    | tuple[Literal["web_click"], ClickArgs]
+    | tuple[Literal["web_type", "web_type_submit"], TypeOrSubmitArgs]
+    | tuple[Literal["web_scroll"], ScrollArgs]
+    | tuple[Literal["web_forward", "web_back", "web_refresh"], CrawlerBaseArgs]
+):
+    # web_client.py supports a very non-standard command line. It has a required named
+    # parameter, --session_name, before the command.
+    # Unfortunately, because we can't break backwards compatibility, we're stuck
+    # with that. To properly parse it, we'll be forced to have a separate parser
+    # for --session_name and merge the results with the normal command parser.
+
+    main_args, remaining_args = main_parser.parse_known_args()
+    session_name = main_args.session_name or DEFAULT_SESSION_NAME
+
+    command_args = command_parser.parse_args(remaining_args)
+    command_args_dict = vars(command_args)
+
+    match command_args.command:
+        case "web_go":
+            return command_args_dict["command"], GoArgs(
+                url=command_args_dict["url"],
+                session_name=session_name,
+            )
+        case "web_click":
+            return command_args_dict["command"], ClickArgs(
+                element_id=command_args_dict["element_id"],
+                session_name=session_name,
+            )
+        case "web_type" | "web_type_submit":
+            return command_args_dict["command"], TypeOrSubmitArgs(
+                element_id=command_args_dict["element_id"],
+                text=command_args_dict["text"],
+                session_name=session_name,
+            )
+        case "web_scroll":
+            return command_args_dict["command"], ScrollArgs(
+                direction=command_args_dict["direction"],
+                session_name=session_name,
+            )
+        case "web_forward" | "web_back" | "web_refresh":
+            return command_args_dict["command"], CrawlerBaseArgs(
+                session_name=session_name,
+            )
+        case _:
+            raise ValueError("Unexpected command")
 
 
 if __name__ == "__main__":

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

@@ -1,33 +1,34 @@
-"""Simple script to run and test the RPC server."""
+import argparse
+import sys
 
-import grpc
-from dm_env_rpc.v1 import connection as dm_env_connection
-from dm_env_rpc.v1 import dm_env_rpc_pb2
+from constants import SERVER_PORT
+from rpc_client_helpers import RPCError, rpc_call
+from web_browser_rpc_types import NewSessionArgs, NewSessionResponse
 
-_DM_ENV_BASE_PORT = 9443
 
-
-def main():
-    # Keep connection open even when empty data pings are received. This is
-    # required to avoid a "too many pings" error.
-    options = [
-        ("grpc.keepalive_permit_without_calls", 0),
-        ("grpc.keepalive_timeout_ms", 20000),
-        ("grpc.http2.max_pings_without_data", 0),
-        ("grpc.http2.max_ping_strikes", 0),
-        ("grpc.http2.min_recv_ping_interval_without_data_ms", 0),
-    ]
-    # Creating a world with the headless browser.
-    channel = grpc.secure_channel(
-        f"localhost:{_DM_ENV_BASE_PORT}",
-        grpc.local_channel_credentials(),
-        options=options,
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="web_client_new_session")
+    parser.add_argument(
+        "--headful", action="store_true", help="Run in headful mode for testing"
     )
-    connection = dm_env_connection.Connection(channel)
-    world_name = connection.send(dm_env_rpc_pb2.CreateWorldRequest()).world_name
-    print(world_name)
+    args_class = parser.parse_args()
+    args_dict = vars(args_class)
+    # TODO: Frick. this does no validation
+    params_typed_dict = NewSessionArgs(headful=args_dict["headful"])
+    params = dict(params_typed_dict)
 
-    connection.close()
+    try:
+        print(
+            rpc_call(
+                f"http://localhost:{SERVER_PORT}/",
+                "new_session",
+                params,
+                NewSessionResponse,
+            ).session_name
+        )
+    except RPCError as rpc_error:
+        print(rpc_error, file=sys.stderr)
+        sys.exit(1)
 
 
 if __name__ == "__main__":