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_node.py

@@ -1,176 +0,0 @@
-from absl.testing import absltest
-from accessibility_node import AccessibilityNode, NodeBounds
-
-
-class TestNodeBounds(absltest.TestCase):
-    def test_union(self):
-        bounds1 = NodeBounds(10, 20, 30, 40)
-        bounds2 = NodeBounds(20, 30, 40, 50)
-        union_bounds = bounds1.union(bounds2)
-        self.assertEqual(union_bounds.left, 10)
-        self.assertEqual(union_bounds.top, 20)
-        self.assertEqual(union_bounds.right, 60)
-        self.assertEqual(union_bounds.bottom, 80)
-
-    def test_union_with_empty_bound(self):
-        bounds = NodeBounds(10, 20, 30, 40)
-        empty_bounds = NodeBounds(0, 0, 0, 0)
-        union_bounds = bounds.union(empty_bounds)
-        self.assertEqual(union_bounds.left, 10)
-        self.assertEqual(union_bounds.top, 20)
-        self.assertEqual(union_bounds.right, 40)
-        self.assertEqual(union_bounds.bottom, 60)
-
-    def test_is_inside(self):
-        bounds = NodeBounds(10, 20, 30, 40)
-        self.assertTrue(bounds.is_inside(20, 30))
-        self.assertFalse(bounds.is_inside(5, 10))
-        self.assertFalse(bounds.is_inside(50, 70))
-
-    def test_overlaps(self):
-        bounds1 = NodeBounds(10, 20, 30, 40)
-        bounds2 = NodeBounds(20, 30, 40, 50)
-        self.assertTrue(bounds1.overlaps(bounds2))
-        bounds3 = NodeBounds(50, 60, 20, 30)
-        self.assertFalse(bounds1.overlaps(bounds3))
-
-
-class TestAccessibilityNode(absltest.TestCase):
-    def test_getitem(self):
-        node_data = {"name": {"value": "Test"}, "role": {"value": "button"}}
-        node = AccessibilityNode(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 = AccessibilityNode(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 = AccessibilityNode(node_data, bounds=NodeBounds(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 = AccessibilityNode(node_data, bounds=NodeBounds(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 = AccessibilityNode(node_data, bounds=NodeBounds(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 = AccessibilityNode(node_data)
-        self.assertIn('[*]  ""', str(node))
-
-    def test_link_children(self):
-        node_data = {"nodeId": "1", "childIds": [2, 3]}
-        node = AccessibilityNode(node_data)
-        child1 = AccessibilityNode({"nodeId": "2"})
-        child2 = AccessibilityNode({"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_union_bounds(self):
-        node_data = {"nodeId": "1", "childIds": [2, 3]}
-        node = AccessibilityNode(node_data, bounds=NodeBounds(10, 10, 20, 20))
-        child1 = AccessibilityNode({"nodeId": "2"}, bounds=NodeBounds(20, 20, 30, 30))
-        child2 = AccessibilityNode({"nodeId": "3"}, bounds=NodeBounds(5, 5, 10, 10))
-        node.link_children({2: child1, 3: child2})  # Manually link children
-
-        union_bounds = node.get_union_bounds()
-        self.assertEqual(union_bounds.left, 5)
-        self.assertEqual(union_bounds.top, 5)
-        self.assertEqual(union_bounds.right, 50)
-        self.assertEqual(union_bounds.bottom, 50)
-
-    def test_get_property(self):
-        node_data = {"name": {"value": "Test"}, "role": {"value": "button"}}
-        node = AccessibilityNode(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_to_string(self):
-        node_data = {
-            "nodeId": "1",
-            "ignored": False,
-            "childIds": [2],
-            "role": {"value": "button"},
-            "name": {"value": "Test Button"},
-        }
-        node = AccessibilityNode(node_data, bounds=NodeBounds(20, 20, 30, 30))
-        self.assertIn('[1] button "Test Button"', node.to_string())
-
-    def test_to_string_with_children(self):
-        node_data = {
-            "nodeId": "1",
-            "ignored": False,
-            "childIds": [2, 3],
-            "role": {"value": "button"},
-            "name": {"value": "Test Button"},
-        }
-        node = AccessibilityNode(node_data, bounds=NodeBounds(20, 20, 30, 30))
-        child_data = {
-            "nodeId": "2",
-            "ignored": False,
-            "role": {"value": "text"},
-            "name": {"value": "Child Text"},
-        }
-        child = AccessibilityNode(child_data, bounds=NodeBounds(20, 20, 30, 30))
-        ignored_child_data = {
-            "nodeId": "3",
-            "ignored": True,
-            "role": {"value": "text"},
-            "name": {"value": "Child Text"},
-        }
-        ignored_child = AccessibilityNode(
-            ignored_child_data, bounds=NodeBounds(20, 20, 30, 30)
-        )
-        node.link_children({2: child, 3: ignored_child})
-        self.assertIn('[2] text "Child Text"', node.to_string())
-        self.assertNotIn('[3] text "Child Text"', node.to_string())
-
-        # Test with include_children=False
-        self.assertNotIn(
-            '[2] text "Child Text"', node.to_string(include_children=False)
-        )
-
-    def test_property_string(self):
-        node_data = {"properties": [{"name": "checked", "value": {"value": True}}]}
-        node = AccessibilityNode(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 = AccessibilityNode(node_data)
-        # 'focusable' is in _IGNORED_ACTREE_PROPERTIES
-        self.assertEqual(node.property_string(), "")

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

@@ -1,135 +0,0 @@
-from concurrent import futures
-
-import dm_env_servicer
-import grpc
-import mock_environment
-from dm_env_rpc.v1 import (
-    compliance,
-    dm_env_rpc_pb2,
-    dm_env_rpc_pb2_grpc,
-    tensor_utils,
-)
-from dm_env_rpc.v1 import connection as dm_env_rpc_connection
-
-
-class ServerConnection:
-    def __init__(self):
-        self._server = grpc.server(futures.ThreadPoolExecutor(max_workers=1))
-        servicer = dm_env_servicer.EnvironmentService(mock_environment.MockEnvironment)
-        dm_env_rpc_pb2_grpc.add_EnvironmentServicer_to_server(servicer, self._server)
-        port = self._server.add_secure_port("[::]:0", grpc.local_server_credentials())
-        self._server.start()
-
-        self._channel = grpc.secure_channel(
-            f"[::]:{port}", grpc.local_channel_credentials()
-        )
-        grpc.channel_ready_future(self._channel).result()
-
-        self.connection = dm_env_rpc_connection.Connection(self._channel)
-
-    def close(self):
-        self.connection.close()
-        self._channel.close()
-        self._server.stop(grace=None)
-
-
-class JoinedServerConnection(ServerConnection):
-    def __init__(self):
-        super().__init__()
-        response = self.connection.send(dm_env_rpc_pb2.CreateWorldRequest())
-        self.world_name = response.world_name
-
-        response = self.connection.send(
-            dm_env_rpc_pb2.JoinWorldRequest(world_name=self.world_name)
-        )
-        self.specs = response.specs
-
-    def close(self):
-        try:
-            self.connection.send(dm_env_rpc_pb2.LeaveWorldRequest())
-            self.connection.send(
-                dm_env_rpc_pb2.DestroyWorldRequest(world_name=self.world_name)
-            )
-        finally:
-            super().close()
-
-
-class DmEnvRpcStepTest(compliance.Step):
-    @property
-    def connection(self):
-        return self._server_connection.connection
-
-    @property
-    def specs(self):
-        return self._server_connection.specs
-
-    def setUp(self):
-        super().setUp()
-        self._server_connection = JoinedServerConnection()
-
-    def tearDown(self):
-        self._server_connection.close()
-        super().tearDown()
-
-    # Overriding this test since this behaviour does not make sence
-    # for our use case.
-    def test_first_step_actions_are_ignored(self):
-        pass
-
-
-class DmEnvRpcCreateAndDestoryWorldTest(compliance.CreateDestroyWorld):
-    @property
-    def connection(self):
-        return self._server_connection.connection
-
-    @property
-    def required_world_settings(self):
-        """A string to Tensor mapping of the minimum set of required settings."""
-        return {}
-
-    @property
-    def invalid_world_settings(self):
-        """World creation settings which are invalid in some way."""
-        return {"invalid_setting": tensor_utils.pack_tensor(123)}
-
-    @property
-    def has_multiple_world_support(self):
-        """Does the server support creating more than one world?"""
-        return True
-
-    def setUp(self):
-        self._server_connection = ServerConnection()
-        super().setUp()
-
-    def tearDown(self):
-        super().tearDown()
-        self._server_connection.close()
-
-
-class DmEnvRpcJoinAndLeaveWorldTest(compliance.JoinLeaveWorld):
-    @property
-    def connection(self):
-        return self._server_connection.connection
-
-    @property
-    def world_name(self):
-        return self._world_name
-
-    @property
-    def invalid_join_settings(self):
-        return {"invalid_setting": tensor_utils.pack_tensor(123)}
-
-    def setUp(self):
-        self._server_connection = ServerConnection()
-        response = self.connection.send(dm_env_rpc_pb2.CreateWorldRequest())
-        self._world_name = response.world_name
-        super().setUp()
-
-    def tearDown(self):
-        super().tearDown()
-        try:
-            self.connection.send(
-                dm_env_rpc_pb2.DestroyWorldRequest(world_name=self.world_name)
-            )
-        finally:
-            self._server_connection.close()

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

@@ -1,71 +0,0 @@
-from unittest.mock import MagicMock, call, patch
-
-import web_environment
-from absl.testing import parameterized
-from playwright_crawler import CrawlerOutputFormat
-
-
-class TestWebEnvironment(parameterized.TestCase):
-    @patch("playwright_crawler.PlaywrightCrawler")
-    def setUp(self, MockCrawler):
-        self._mock_crawler = MagicMock()
-        MockCrawler.return_value = self._mock_crawler
-        self._mock_browser_context = MagicMock()
-        self._web_env = web_environment.WebEnvironment(self._mock_browser_context)
-
-    def test_step_go_to_command(self):
-        self._web_env.step("web_go https://en.wikipedia.org/wiki/Sun ignored_param")
-        self._mock_crawler.go_to_page.assert_called_once_with(
-            "https://en.wikipedia.org/wiki/Sun"
-        )
-
-    def test_step_click_command(self):
-        self._web_env.step("web_click 1111 ignored_param")
-        # click() might be also called later but we only check the first call
-        self.assertEqual(self._mock_crawler.mock_calls[0], call.click("1111"))
-
-    def test_step_scroll_command(self):
-        self._web_env.step("web_scroll up ignored_param")
-        self._mock_crawler.scroll.assert_called_once_with("up")
-
-    def test_step_forward_command(self):
-        self._web_env.step("web_forward ignored_param")
-        self._mock_crawler.forward.assert_called_once_with()
-
-    def test_step_back_command(self):
-        self._web_env.step("web_back ignored_param")
-        self._mock_crawler.back.assert_called_once_with()
-
-    def test_step_refresh_command(self):
-        self._web_env.step("web_refresh ignored_param")
-        self._mock_crawler.refresh.assert_called_once_with()
-
-    def test_step_type_command(self):
-        self._web_env.step("web_type some_element_id text to type into element")
-        self._mock_crawler.type.assert_called_once_with(
-            "some_element_id", "text to type into element"
-        )
-
-    def test_step_type_submit_command(self):
-        self._web_env.step("web_type_submit some_element_id text to type into element")
-        self._mock_crawler.clear.assert_called_once()
-        self._mock_crawler.type.assert_called_once_with(
-            "some_element_id", "text to type into element\n"
-        )
-
-    @parameterized.parameters(
-        ("web_go"),
-        ("web_click"),
-        ("web_scroll"),
-        ("web_type"),
-        ("web_type_submit"),
-        ("some_random_command"),
-    )
-    def test_step_invalid_command(self, command):
-        self._web_env.step(command)
-        self.assertEqual(self._web_env._last_error, f'\n\nInvalid command: "{command}"')
-
-    def test_get_observations_returns_only_required_observations(self):
-        obs = self._web_env.get_observations(["web_at"])
-        self.assertTrue(set(obs.keys()) == set(["web_at"]))
-        self._mock_crawler.render.assert_called_once_with(CrawlerOutputFormat.AT)

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

@@ -1,184 +0,0 @@
-"""A web dm_env (to be run in a docker container).
-
-This environment allows the agent to interact with a web browser via text
-commands.
-"""
-
-import functools
-import json
-import socket
-import traceback
-from typing import Any
-
-import dm_env
-import playwright_crawler
-from dm_env import specs
-
-
-class WebEnvironment(dm_env.Environment):
-    """A DM environment where an agent controls a web browser."""
-
-    DEFAULT_OBSERVATIONS = ["web_url", "web_at", "error", "info"]
-
-    def __init__(self, browser_context):
-        """Initializes the environment."""
-        super().__init__()
-        self._web: playwright_crawler.PlaywrightCrawler = (
-            playwright_crawler.PlaywrightCrawler(browser_context)
-        )
-        self._last_error = ""
-        self._hostname = socket.gethostname()
-        self._required_observations = self.DEFAULT_OBSERVATIONS
-        self._selected_node_id: str | None = None
-
-    def reset(self):
-        # We're not using reset at the moment
-        pass
-
-    def step(self, action: str) -> dm_env.TimeStep:
-        """Updates the environment according to the action and returns a `TimeStep`.
-
-        Args:
-          action: the command to execute in the web environment.
-
-        Returns:
-          A `TimeStep` namedtuple containing:
-            step_type: A `StepType` value.
-            reward: always 0.
-            discount: always 1.
-            observation: the current web browser state rendered as text.
-        """
-        # Process the incoming command.
-        # Commands are always in the form [COMMAND] [args]
-        command, *args = action.split(" ")
-
-        self._last_error = ""
-        self._selected_node_id = None
-        command_l = command.lower()
-
-        try:
-            if not command_l:  # Equivalent to case '':
-                # Treat an empty command as a NOOP.
-                pass
-            elif command_l == "web_go" and len(args) > 0:
-                self._web.go_to_page(args[0])
-            elif command_l == "web_click" and len(args) > 0:
-                self._web.click(args[0])
-            elif command_l == "web_scroll" and len(args) > 0:
-                self._web.scroll(args[0])
-            elif command_l == "web_forward":
-                self._web.forward()
-            elif command_l == "web_back":
-                self._web.back()
-            elif command_l == "web_refresh":
-                self._web.refresh()
-            elif command_l == "web_type" and len(args) > 0:
-                self._web.type(args[0], " ".join(args[1:]))
-            elif command_l == "web_type_submit" and len(args) > 0:
-                # Clear any existing text, type the new text, and then press enter.
-                self._web.clear(args[0])
-                self._web.type(args[0], " ".join(args[1:]) + "\n")
-            else:
-                self._last_error = f'\n\nInvalid command: "{action}"'
-
-        except Exception as e:
-            # Broard exception as we don't know what kind of error the crawler might
-            # generate. If an error does occur pass it back as part of the
-            # observation.
-            traceback_info = traceback.extract_tb(e.__traceback__)[-1]
-            self._last_error = f"\nERROR:{e}\n{traceback_info}"
-
-        try:
-            # The update might fail due to async issues.
-            # TODO: Instead of a catch-all, make  the webcrawler more
-            # robust dynamic or malformed elements.
-            self._web.update()
-
-            # If there's a cookies message click to sort it out.
-            self._auto_click_cookies()
-
-        except Exception as e:  # pylint: disable=broad-exception-caught
-            traceback_info = traceback.extract_tb(e.__traceback__)[-1]
-            self._last_error = f"\nUPDATE ERROR:{e}\n{traceback_info}"
-
-        return dm_env.transition(
-            reward=0.0,
-            observation=self.get_observations(),
-        )
-
-    def observation_spec(self) -> dict[str, specs.Array]:
-        """Defines the observations provided by the environment.
-
-        Returns:
-          The observation specification.
-        """
-        obs_shapes = {
-            "web_url": specs.Array(shape=(), dtype=str, name="web_url"),
-            "web_at": specs.Array(shape=(), dtype=str, name="web_at"),
-            "error": specs.Array(shape=(), dtype=str, name="error"),
-            "info": specs.Array(shape=(), dtype=str, name="info"),
-        }
-        return {key: obs_shapes[key] for key in self._required_observations}
-
-    def action_spec(self) -> specs.Array:
-        """Defines the actions that should be provided to `step`.
-
-        Returns:
-          The action specification.
-        """
-        return specs.Array(shape=(), dtype=str, name="command")
-
-    def close(self) -> None:
-        """Closes the environment."""
-        self._web.close()
-
-    @property
-    def info(self) -> dict[str, str]:
-        """Returns a dictionary of information about this environment."""
-        out = {
-            "hostname": self._hostname,
-        }
-        if self._selected_node_id is not None:
-            out["node_id"] = self._selected_node_id
-        return out
-
-    def get_observations(
-        self, required_observations: list[str] | None = None
-    ) -> dict[str, Any]:
-        """Returns dictionary containing each requested observations.
-
-        Args:
-          required_observations: List of observations to include in the output. If
-            non-none overrides the default `self._requested_observations`.
-        """
-
-        def render(mode):
-            return functools.partial(self._web.render, mode)
-
-        obs_map = {
-            "web_url": lambda: self._web.url.split("?")[0],
-            "web_at": render(playwright_crawler.CrawlerOutputFormat.AT),
-            "error": lambda: self._last_error,
-            "info": lambda: json.dumps(self.info),
-        }
-
-        result = {}
-        required_observations = (
-            self._required_observations
-            if required_observations is None
-            else required_observations
-        )
-        for obs_name in required_observations:
-            result[obs_name] = obs_map[obs_name]()
-
-        return result
-
-    def _auto_click_cookies(self):
-        """Autoclick any cookies popup."""
-        try:
-            accept_node = self._web.lookup_node("<Accept all>")
-            self._web.click(accept_node.node_id)
-            self._web.update()
-        except ValueError:
-            # Node not found.
-            pass