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

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

@@ -1,275 +0,0 @@
-"""Environment service that allows clients to run shell commands in steps."""
-
-import threading
-from typing import Any, Iterable, Type
-
-import dm_env
-import grpc
-import playwright_crawler
-from dm_env import specs
-from dm_env_rpc.v1 import (
-    dm_env_rpc_pb2,
-    dm_env_rpc_pb2_grpc,
-    dm_env_utils,
-    spec_manager,
-)
-from google.rpc import code_pb2, status_pb2
-
-_DEFAULT_WORLD_NAME = "WebBrowser"
-
-
-class EnvironmentSpec:
-    """Specifications for a dm_environment.
-
-    This class holds action and observation specs, as well as the required
-    managers to pack actions and observations.
-    """
-
-    def __init__(self, env: dm_env.Environment):
-        convert = dm_env_utils.dm_env_spec_to_tensor_spec
-
-        # We support either a single spec, of flat dictionary of specs.
-        # In the dictionary case we need to map names to unique IDs.
-        env_obs_spec: dict[str, Any] = env.observation_spec()
-        if isinstance(env_obs_spec, specs.Array):
-            self.observation_spec = {1: convert(env_obs_spec)}
-        else:
-            self.observation_spec = {}
-            for i, obs_spec in enumerate(env_obs_spec.values()):
-                self.observation_spec[i + 1] = convert(obs_spec)
-
-        assert isinstance(env.action_spec(), specs.Array), (
-            "Only a single action type is supported."
-        )
-        self.action_spec = {1: convert(env.action_spec())}
-
-        self.observation_manager = spec_manager.SpecManager(self.observation_spec)
-        self.action_manager = spec_manager.SpecManager(self.action_spec)
-
-
-class EnvironmentService(dm_env_rpc_pb2_grpc.EnvironmentServicer):
-    """Runs the environment as a gRPC EnvironmentServicer."""
-
-    def __init__(self, env_type: Type[dm_env.Environment]) -> None:
-        """Initializes the environment.
-
-        Args:
-          env_type: A dm_env class to serve.
-        """
-        self._env_type = env_type
-        self._envs: dict[str, dm_env.Environment] = {}
-        self._specs: dict[str, EnvironmentSpec] = {}
-        self._joined_worlds: set[str] = set()
-        self._browser: playwright_crawler.PlaywrightBrowser = None
-        self._lock = threading.Lock()
-        self._num_worlds = 0
-
-    def Process(
-        self,
-        request_iterator: Iterable[dm_env_rpc_pb2.EnvironmentRequest],
-        context: grpc.ServicerContext,
-    ):
-        """Processes incoming EnvironmentRequests.
-
-        For each EnvironmentRequest the internal message is extracted and handled.
-        The response for that message is then placed in a EnvironmentResponse which
-        is returned to the client.
-
-        An error status will be returned if an unknown message type is received or
-        if the message is invalid for the current world state.
-
-
-        Args:
-          request_iterator: Message iterator provided by gRPC.
-          context: Context provided by gRPC.
-
-        Yields:
-          EnvironmentResponse: Response for each incoming EnvironmentRequest.
-        """
-        cur_world = None
-        for request in request_iterator:
-            environment_response = dm_env_rpc_pb2.EnvironmentResponse()
-            try:
-                message_type = request.WhichOneof("payload")
-                internal_request = getattr(request, message_type)
-                match type(internal_request):
-                    case dm_env_rpc_pb2.CreateWorldRequest:
-                        response = self._handle_create_world_request(internal_request)
-                    case dm_env_rpc_pb2.JoinWorldRequest:
-                        response, cur_world = self._handle_join_world_request(
-                            internal_request
-                        )
-                    case dm_env_rpc_pb2.LeaveWorldRequest:
-                        response = self._handle_leave_world_request(
-                            internal_request, cur_world
-                        )
-                    case dm_env_rpc_pb2.DestroyWorldRequest:
-                        response = self._handle_destroy_world_request(internal_request)
-                    case dm_env_rpc_pb2.StepRequest:
-                        response = self._handle_step_request(
-                            internal_request, cur_world
-                        )
-                    case _:
-                        raise ValueError(
-                            f"Unsupported request type: {type(internal_request)}"
-                        )
-                getattr(environment_response, message_type).CopyFrom(response)
-            except Exception as e:  # pylint: disable=broad-except
-                environment_response.error.CopyFrom(
-                    status_pb2.Status(code=code_pb2.INTERNAL, message=str(e))
-                )
-            yield environment_response
-
-    def _validate_settings(self, settings, valid_settings):
-        """Validate the provided settings with list of valid setting keys."""
-        unrecognized_settings = [
-            setting for setting in settings if setting not in valid_settings
-        ]
-
-        if unrecognized_settings:
-            raise ValueError(
-                "Unrecognized settings provided! Invalid settings:"
-                f" {unrecognized_settings}"
-            )
-
-    def _add_spec_to_response(
-        self, world_name: str, response: dm_env_rpc_pb2.EnvironmentResponse
-    ):
-        """Modifies given respose to include action/observation specifications."""
-        if not self._specs.get(world_name):
-            raise ValueError(f"Not found a spec for {world_name} world")
-
-        spec = self._specs[world_name]
-        for uid, action in spec.action_spec.items():
-            response.specs.actions[uid].CopyFrom(action)
-        for uid, observation in spec.observation_spec.items():
-            response.specs.observations[uid].CopyFrom(observation)
-
-    def _handle_create_world_request(
-        self, request: dm_env_rpc_pb2.CreateWorldRequest
-    ) -> dm_env_rpc_pb2.CreateWorldResponse:
-        """Handles create_world requests."""
-        self._validate_settings(request.settings, [])
-        del request
-        world_name = _DEFAULT_WORLD_NAME
-        with self._lock:
-            if self._browser is None:
-                self._browser = playwright_crawler.PlaywrightBrowser()
-            else:
-                world_name += f"_{self._num_worlds}"
-            self._num_worlds += 1
-
-            new_context = self._browser.get_new_context()
-            env = self._env_type(new_context)
-            spec = EnvironmentSpec(env)
-            self._envs[world_name] = env
-            self._specs[world_name] = spec
-
-        return dm_env_rpc_pb2.CreateWorldResponse(world_name=world_name)
-
-    def _handle_join_world_request(
-        self, request: dm_env_rpc_pb2.JoinWorldRequest
-    ) -> tuple[dm_env_rpc_pb2.JoinWorldResponse, str]:
-        """Handles join_world requests."""
-        self._validate_settings(request.settings, [])
-        response = dm_env_rpc_pb2.JoinWorldResponse()
-        world_name = request.world_name
-        with self._lock:
-            if not self._envs.get(world_name):
-                raise ValueError(f"Joining with the wrong world_name {world_name}")
-            if world_name in self._joined_worlds:
-                raise ValueError(f"Only one client can joint the world {world_name}")
-            self._joined_worlds.add(world_name)
-            self._add_spec_to_response(world_name, response)
-
-        del request
-        return (response, world_name)
-
-    def _handle_leave_world_request(
-        self, request: dm_env_rpc_pb2.LeaveWorldRequest, world_name: str
-    ) -> dm_env_rpc_pb2.LeaveWorldResponse:
-        """Handles leave_world requests."""
-        del request
-        if world_name in self._joined_worlds:
-            self._joined_worlds.remove(world_name)
-        response = dm_env_rpc_pb2.LeaveWorldResponse()
-        return response
-
-    def _handle_destroy_world_request(
-        self, request: dm_env_rpc_pb2.DestroyWorldRequest
-    ) -> dm_env_rpc_pb2.DestroyWorldResponse:
-        """Handles destroy_world requests."""
-        world_name = request.world_name
-        del request
-        with self._lock:
-            if not self._envs.get(world_name):
-                raise ValueError("Can not destroy uncreated environment.")
-            if world_name in self._joined_worlds:
-                raise ValueError("Can not destroy environment with a joined agent.")
-            env = self._envs.pop(world_name)
-            env.close()
-            env = None
-            self._specs.pop(world_name, None)
-
-            if not self._envs:
-                self._browser.close()
-                self._browser = None
-        response = dm_env_rpc_pb2.DestroyWorldResponse()
-        return response
-
-    def _handle_step_request(
-        self, request: dm_env_rpc_pb2.StepRequest, cur_world: str
-    ) -> dm_env_rpc_pb2.StepResponse:
-        """Handles step requests.
-
-        Args:
-          request: The request, which should contain a 'command' entry.
-          cur_world: The name of the world in which we're making a step.
-
-        Returns:
-          Response including requested observations.
-
-        Raises:
-          KeyError: If the requested observation is not in the list of available
-            observations.
-        """
-        with self._lock:
-            assert cur_world in self._envs, (
-                "Current world does not have an assosiated environment"
-            )
-            assert cur_world in self._joined_worlds, (
-                "Please join world before calling step."
-            )
-            env = self._envs[cur_world]
-            spec = self._specs[cur_world]
-
-            action = spec.action_manager.unpack(request.actions)
-
-            if "command" in action:
-                command = action["command"]
-            else:
-                # For some reason dm_env calls step without actions after a reset.
-                command = ""
-
-            timestep: dm_env.TimeStep = env.step(command)
-
-            packed_observations = spec.observation_manager.pack(timestep.observation)
-
-            match timestep.step_type:
-                case dm_env.StepType.MID:
-                    step_state = dm_env_rpc_pb2.RUNNING
-                case dm_env.StepType.LAST:
-                    step_state = dm_env_rpc_pb2.TERMINATED
-                case _:
-                    raise ValueError(f"Unsupported step type {timestep.step_type}.")
-
-            response = dm_env_rpc_pb2.StepResponse(state=step_state)
-            for requested_observation in request.requested_observations:
-                if requested_observation not in packed_observations:
-                    name = spec.observation_manager.uid_to_name(requested_observation)
-                    raise KeyError(f"Requested observation not found: {name}")
-                response.observations[requested_observation].CopyFrom(
-                    packed_observations[requested_observation]
-                )
-
-        return response

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)