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

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

@@ -1,312 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-# Properities to ignore when printing out the accessibility tree.
-_IGNORED_ACTREE_PROPERTIES = (
-    "focusable",
-    "readonly",
-    "level",
-    "settable",
-    "multiline",
-    "invalid",
-)
-
-_IGNORED_AT_ROLES = (
-    "generic",
-    "list",
-    "strong",
-    "paragraph",
-    "banner",
-    "navigation",
-    "Section",
-    "LabelText",
-    "Legend",
-    "listitem",
-)
-
-# Typically we use the bounding rect provided by the DOM in order to track
-# if an element is visible or not. However, sometimes it can be useful to
-# instead take the union of the elements bounds and all its children's bounds.
-# This process is a little slower, and is probably not needed, but can be
-# enabled using this flag.
-USE_UNION_BOUNDS = False
-
-# The maximum length of the description 'tag' for each element.
-# Tags longer than this will be truncated with an '...' appended.
-MAX_NODE_TEXT_LENGTH = 120
-
-# Used for debugging, include the elements bounding rect during output.
-_INCLUDE_BOUNDS_IN_OUTPUT = False
-
-
-class NodeBounds:
-    """Class to hold bounding rect for notes."""
-
-    def __init__(self, x: int, y: int, width: int, height: int):
-        self.x = int(x)
-        self.y = int(y)
-        self.width = int(width)
-        self.height = int(height)
-
-    @classmethod
-    def from_lrtb(cls, left: int, right: int, top: int, bottom: int) -> NodeBounds:
-        return cls(left, top, right - left, bottom - top)
-
-    @property
-    def left(self) -> int:
-        return self.x
-
-    @property
-    def top(self) -> int:
-        return self.y
-
-    @property
-    def right(self) -> int:
-        return self.x + self.width
-
-    @property
-    def bottom(self) -> int:
-        return self.y + self.height
-
-    @property
-    def center_x(self) -> int:
-        return self.x + self.width // 2
-
-    @property
-    def center_y(self) -> int:
-        return self.y + self.height // 2
-
-    @property
-    def area(self) -> int:
-        return self.width * self.height
-
-    def __str__(self):
-        return f"({self.left}, {self.top}, {self.width}, {self.height})"
-
-    def union(self, other: NodeBounds) -> NodeBounds:
-        """Return the (convex) union of two bounds."""
-        # Special cases when one or the other is an empty bound.
-        if self.area == 0:
-            return other
-        if other.area == 0:
-            return self
-
-        return self.from_lrtb(
-            min(self.left, other.left),
-            max(self.right, other.right),
-            min(self.top, other.top),
-            max(self.bottom, other.bottom),
-        )
-
-    def is_inside(self, x: int, y: int) -> bool:
-        """Returns if given point is inside the bounds or not."""
-        return x >= self.left and y >= self.top and x < self.right and y < self.bottom
-
-    def overlaps(self, other: NodeBounds) -> bool:
-        """Returns if the two bounds intersect."""
-        return (
-            other.left < self.right
-            and other.right > self.left
-            and other.top < self.bottom
-            and other.bottom > self.top
-        )
-
-
-class AccessibilityNode:
-    """A class for an accessibility node.
-
-    Accessibility properties are specified here:
-    https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#type-AXNode
-    """
-
-    def __init__(self, node: dict[str, Any], parent=None, bounds=None):
-        self._node = node
-        self._parent: AccessibilityNode | None = parent
-        self.bounds = bounds or NodeBounds(0, 0, 0, 0)
-
-    def __getitem__(self, key: str) -> Any:
-        """Access the underlying node fields."""
-        return self._node.get(key)
-
-    def __setitem__(self, key: str, value: Any):
-        """Set the underlying node fields."""
-        self._node[key] = value
-
-    def __str__(self):
-        if _INCLUDE_BOUNDS_IN_OUTPUT:
-            bounds_string = " " + str(
-                self.get_union_bounds() if USE_UNION_BOUNDS else self.bounds
-            )
-        else:
-            bounds_string = ""
-
-        node_input = self.current_input
-        if node_input:
-            input_string = f' Current input: "{node_input}"'
-        else:
-            input_string = ""
-
-        # Without bounds we can't click on the element, and therefore the ID
-        # can not be used. Still useful to show these elements though (e.g.)
-        # to let user know about options.
-        id_string = "*" if self.bounds.area == 0 else self.node_id
-
-        url_string = ""
-        if self.role == "image" and self._node.get("src", ""):
-            url_string = " " + self._node["src"]
-
-        return (
-            f'[{id_string}] {self.role} "{self.short_name}"'
-            + url_string
-            + input_string
-            + self.property_string()
-            + bounds_string
-        )
-
-    @property
-    def node_id(self) -> str:
-        return self._node["nodeId"]
-
-    @property
-    def value(self) -> str:
-        value_field = self._node.get("value", "{}")
-        if isinstance(value_field, dict):
-            return value_field.get("value", "")
-        else:
-            return ""
-
-    @property
-    def parent(self) -> Any | None:
-        """Returns the first visible parent."""
-        parent = self._parent
-        while parent and parent.is_ignored:
-            parent = parent._parent
-        return parent
-
-    @property
-    def role(self) -> str:
-        if "role" in self._node:
-            return self._node["role"].get("value", "")
-        else:
-            return ""
-
-    @property
-    def name(self) -> str:
-        if "name" in self._node:
-            return self._node["name"].get("value", "")
-        else:
-            return ""
-
-    @property
-    def short_name(self) -> str:
-        short_name = self.name[:MAX_NODE_TEXT_LENGTH]
-        if short_name != self.name:
-            short_name = short_name[: MAX_NODE_TEXT_LENGTH - 3] + "..."
-        return short_name
-
-    @property
-    def is_ignored(self) -> bool:
-        return (
-            self._node["ignored"]
-            or self.role in _IGNORED_AT_ROLES
-            or not self.is_visible
-            or (not self.name and self.role != "textbox")
-            or (self.parent and self.parent.name == self.name)
-        )
-
-    @property
-    def children(self) -> list[Any]:
-        return self._node.get("children", [])
-
-    @property
-    def is_visible(self) -> bool:
-        return self._node.get("is_visible", True)
-
-    def is_selected(self) -> bool:
-        return self._node.get("selected", False)
-
-    @property
-    def is_editable(self) -> bool:
-        for node_property in self.properties:
-            if node_property["name"] == "editable":
-                return True
-        return False
-
-    @property
-    def is_expanded(self) -> bool:
-        for node_property in self.properties:
-            if node_property["name"] == "expanded":
-                return bool(node_property["value"].get("value"))
-        return False
-
-    @property
-    def properties(self) -> list[Any]:
-        return self._node.get("properties", [])
-
-    @property
-    def dom_id(self) -> str:
-        """Returns the backend DOM id associated with this node."""
-        return self._node.get("backendDOMNodeId", -1)
-
-    @property
-    def current_input(self) -> str:
-        # For some reason text edit boxes get 'input' but comboboxs get 'values'
-        if self.role == "combobox":
-            value = self.value
-        else:
-            value = self.get_property("input")
-        return value
-
-    def get_union_bounds(self) -> list[int]:
-        """Returns the union of the bounds for this element all children."""
-        bounds = self.bounds
-        for child in self.children:
-            child_union_bounds = child.get_union_bounds()
-            bounds = bounds.union(child_union_bounds)
-        return bounds
-
-    def link_children(self, node_lookup: dict[str, Any]) -> None:
-        """Creates links to children nodes.
-
-        Nodes are referenced by id, but we want to add references to the
-        AccessibilityNode. We also want add a reference to the parent node.
-
-        To perform this task we need access to the complete list of nodes, and
-        therefore it must be done on a second pass after initializing the nodes.
-
-        Args:
-          node_lookup: A dictionary mapping from node_id to node instances.
-        """
-        self._node["children"] = []
-        for idx in self._node.get("childIds", []):
-            self._node["children"].append(node_lookup[idx])
-            node_lookup[idx]._parent = self
-
-    def get_property(self, property_name: str) -> Any:
-        """Query the property value of the underlying accessibility tree node."""
-        return self._node.get(property_name)
-
-    def to_string(self, indent: int = 0, include_children: bool = True) -> str:
-        """Returns the string representation of the node."""
-        result = ""
-        if not self.is_ignored:
-            result = "  " * indent + str(self) + "\n"
-            indent += 1
-        if include_children:
-            children_strings = [child.to_string(indent) for child in self.children]
-            result = result + "".join([s for s in children_strings if s])
-        return result
-
-    def property_string(self) -> str:
-        properties = []
-        for node_property in self.properties:
-            try:
-                if node_property["name"] in _IGNORED_ACTREE_PROPERTIES:
-                    continue
-                properties.append(
-                    f"{node_property['name']}: {node_property['value'].get('value')}"
-                )
-            except KeyError:
-                pass
-        return " [" + ", ".join(properties) + "]" if properties else ""

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