inspect-ai 0.3.92__py3-none-any.whl → 0.3.94__py3-none-any.whl

inspect_ai/tool/_tools/_computer/_resources/tool/_args.py

@@ -1,78 +0,0 @@
-from argparse import Action, ArgumentParser, Namespace
-from typing import Sequence
-
-
-def parse_arguments(args: Sequence[str] | None = None) -> Namespace:
-    return _create_parser().parse_args(args)
-
-
-def _create_parser() -> ArgumentParser:
-    parser = ArgumentParser(prog="computer_tool")
-    subparsers = parser.add_subparsers(dest="action", required=True)
-
-    # these take no additional arguments
-    subparsers.add_parser(
-        "screenshot",
-        aliases=["cursor_position", "left_mouse_down", "left_mouse_up"],
-    )
-
-    key_and_type = subparsers.add_parser("type", aliases=["key"])
-    _add_text(key_and_type)
-
-    hold_key = subparsers.add_parser("hold_key")
-    _add_text(hold_key)
-    _add_duration(hold_key)
-
-    mouse_move = subparsers.add_parser("mouse_move")
-    _add_coordinate(mouse_move)
-
-    click = subparsers.add_parser(
-        "left_click",
-        aliases=["right_click", "middle_click", "double_click", "triple_click"],
-    )
-    _add_coordinate(click, False)
-    _add_text(click, False)
-
-    left_click_drag = subparsers.add_parser("left_click_drag")
-    _add_start_coordinate(left_click_drag)
-    _add_coordinate(left_click_drag)
-    _add_text(left_click_drag, False)
-
-    scroll = subparsers.add_parser("scroll")
-    _add_scroll_direction(scroll)
-    _add_scroll_amount(scroll)
-    # despite what the doc says, the model doesn't always provide a coordinate
-    _add_coordinate(scroll, False)
-
-    wait = subparsers.add_parser("wait")
-    _add_duration(wait)
-
-    return parser
-
-
-def _add_scroll_direction(subparser: ArgumentParser) -> Action:
-    return subparser.add_argument(
-        "--scroll_direction", choices=["up", "down", "left", "right"], required=True
-    )
-
-
-def _add_scroll_amount(subparser: ArgumentParser) -> Action:
-    return subparser.add_argument("--scroll_amount", type=int, required=True)
-
-
-def _add_coordinate(subparser: ArgumentParser, required: bool = True) -> Action:
-    return subparser.add_argument("--coordinate", type=int, nargs=2, required=required)
-
-
-def _add_start_coordinate(subparser: ArgumentParser) -> Action:
-    return subparser.add_argument(
-        "--start_coordinate", type=int, nargs=2, required=True
-    )
-
-
-def _add_duration(subparser: ArgumentParser) -> Action:
-    return subparser.add_argument("--duration", type=int, required=True)
-
-
-def _add_text(subparser: ArgumentParser, required: bool = True) -> Action:
-    return subparser.add_argument("--text", type=str, required=required)

inspect_ai/tool/_tools/_computer/_resources/tool/_constants.py

@@ -1,22 +0,0 @@
-from typing import Literal
-
-Action = Literal[
-    "key",
-    "hold_key",
-    "type",
-    "cursor_position",
-    "mouse_move",
-    "left_mouse_down",
-    "left_mouse_up",
-    "left_click",
-    "left_click_drag",
-    "right_click",
-    "middle_click",
-    "back_click",
-    "forward_click",
-    "double_click",
-    "triple_click",
-    "scroll",
-    "wait",
-    "screenshot",
-]

inspect_ai/tool/_tools/_computer/_resources/tool/_logger.py

@@ -1,22 +0,0 @@
-import logging
-
-
-def setup_logger(level=logging.INFO):
-    """
-    This logger emits all of its output to PID 1's stdout.
-
-    This makes it so that logging from invocations of the computer_tool cli show up in `docker logs` output.
-    """
-    new_logger = logging.getLogger("computer_tool")
-    new_logger.setLevel(level)
-
-    stdout_handler = logging.FileHandler("/proc/1/fd/1", mode="w")
-    stdout_handler.setLevel(level)
-    stdout_handler.setFormatter(
-        logging.Formatter("%(name)s(pid=%(process)d) - %(levelname)s - %(message)s")
-    )
-
-    if not new_logger.handlers:
-        new_logger.addHandler(stdout_handler)
-
-    return new_logger

inspect_ai/tool/_tools/_computer/_resources/tool/_run.py

@@ -1,42 +0,0 @@
-"""Utility to run shell commands asynchronously with a timeout."""
-
-import asyncio
-
-TRUNCATED_MESSAGE: str = "<response clipped><NOTE>To save on context only part of this file has been shown to you. You should retry this tool after you have searched inside the file with `grep -n` in order to find the line numbers of what you are looking for.</NOTE>"
-MAX_RESPONSE_LEN: int = 16000
-
-
-def maybe_truncate(content: str, truncate_after: int | None = MAX_RESPONSE_LEN):
-    """Truncate content and append a notice if content exceeds the specified length."""
-    return (
-        content
-        if not truncate_after or len(content) <= truncate_after
-        else content[:truncate_after] + TRUNCATED_MESSAGE
-    )
-
-
-async def run(
-    cmd: str,
-    timeout: float | None = 120.0,  # seconds
-    truncate_after: int | None = MAX_RESPONSE_LEN,
-):
-    """Run a shell command asynchronously with a timeout."""
-    process = await asyncio.create_subprocess_shell(
-        cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
-    )
-
-    try:
-        stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout)
-        return (
-            process.returncode or 0,
-            maybe_truncate(stdout.decode(), truncate_after=truncate_after),
-            maybe_truncate(stderr.decode(), truncate_after=truncate_after),
-        )
-    except (TimeoutError, asyncio.TimeoutError) as exc:
-        try:
-            process.kill()
-        except ProcessLookupError:
-            pass
-        raise TimeoutError(
-            f"Command '{cmd}' timed out after {timeout} seconds"
-        ) from exc

inspect_ai/tool/_tools/_computer/_resources/tool/_tool_result.py

@@ -1,33 +0,0 @@
-from dataclasses import dataclass, fields, replace
-
-
-@dataclass(kw_only=True, frozen=True)
-class ToolResult:
-    """Represents the result of a tool execution."""
-
-    output: str | None = None
-    error: str | None = None
-    base64_image: str | None = None
-
-    def __bool__(self):
-        return any(getattr(self, field.name) for field in fields(self))
-
-    def __add__(self, other: "ToolResult"):
-        def combine_fields(
-            field: str | None, other_field: str | None, concatenate: bool = True
-        ):
-            if field and other_field:
-                if concatenate:
-                    return field + other_field
-                raise ValueError("Cannot combine tool results")
-            return field or other_field
-
-        return ToolResult(
-            output=combine_fields(self.output, other.output),
-            error=combine_fields(self.error, other.error),
-            base64_image=combine_fields(self.base64_image, other.base64_image, False),
-        )
-
-    def replace(self, **kwargs):
-        """Returns a new ToolResult with the given fields replaced."""
-        return replace(self, **kwargs)

inspect_ai/tool/_tools/_computer/_resources/tool/_x11_client.py

@@ -1,341 +0,0 @@
-"""Inspired by https://github.com/anthropics/anthropic-quickstarts/blob/main/computer-use-demo/computer_use_demo/tools/computer.py"""
-
-import asyncio
-import base64
-import logging
-import os
-import shlex
-from pathlib import Path
-from typing import Literal, TypedDict
-from uuid import uuid4
-
-from _run import run
-from _tool_result import ToolResult
-
-OUTPUT_DIR = "/tmp/outputs"
-
-TYPING_DELAY_MS = 12
-TYPING_GROUP_SIZE = 50
-
-ColorCount = Literal[4096, 2048, 1024, 512, 256, 128, 64, 32, 16, 8, 4]
-
-
-class X11ClientError(Exception):
-    def __init__(self, message):
-        self.message = message
-
-
-class Resolution(TypedDict):
-    width: int
-    height: int
-
-
-# sizes above XGA/WXGA are not recommended (see README.md)
-# scale down to one of these targets if ComputerTool._scaling_enabled is set
-MAX_SCALING_TARGETS: dict[str, Resolution] = {
-    "XGA": Resolution(width=1024, height=768),  # 4:3
-    "WXGA": Resolution(width=1280, height=800),  # 16:10
-    "FWXGA": Resolution(width=1366, height=768),  # ~16:9
-}
-
-
-ScalingSource = Literal["computer", "api"]
-
-
-class ComputerToolOptions(TypedDict):
-    display_height_px: int
-    display_width_px: int
-    display_number: int | None
-
-
-def chunks(s: str, chunk_size: int) -> list[str]:
-    return [s[i : i + chunk_size] for i in range(0, len(s), chunk_size)]
-
-
-class X11Client:
-    """
-    A tool that allows the agent to interact with the screen, keyboard, and mouse of the current computer.
-
-    The tool parameters are defined by Anthropic and are not editable.
-    """
-
-    width: int
-    height: int
-    display_num: int | None
-    # TODO: Complete plumbing this or remove it
-    color_count: ColorCount | None = 256
-
-    _screenshot_delay = 2.0
-    _scaling_enabled = True
-
-    @property
-    def options(self) -> ComputerToolOptions:
-        width, height = self._scale_coordinates("computer", self.width, self.height)
-        return {
-            "display_width_px": width,
-            "display_height_px": height,
-            "display_number": self.display_num,
-        }
-
-    def __init__(self):
-        super().__init__()
-
-        self.width = int(os.getenv("WIDTH") or 0)
-        self.height = int(os.getenv("HEIGHT") or 0)
-        assert self.width and self.height, "WIDTH, HEIGHT must be set"
-        if (display_num := os.getenv("DISPLAY_NUM")) is not None:
-            self.display_num = int(display_num)
-            self._display_prefix = f"DISPLAY=:{self.display_num} "
-        else:
-            self.display_num = None
-            self._display_prefix = ""
-
-        self.xdotool = f"{self._display_prefix}xdotool"
-
-    async def key(self, text: str) -> ToolResult:
-        return await self._shell(f"{self.xdotool} key -- {_key_arg_for_text(text)}")
-
-    async def hold_key(self, text: str, duration: int) -> ToolResult:
-        key_arg = _key_arg_for_text(text)
-        await self._shell(f"{self.xdotool} keydown -- {key_arg}", False)
-        await asyncio.sleep(duration)
-        return await self._shell(f"{self.xdotool} keyup -- {key_arg}")
-
-    async def type(self, text: str) -> ToolResult:
-        results: list[ToolResult] = []
-        for chunk in chunks(text, TYPING_GROUP_SIZE):
-            cmd = (
-                f"{self.xdotool} type --delay {TYPING_DELAY_MS} -- {shlex.quote(chunk)}"
-            )
-            results.append(await self._shell(cmd, take_screenshot=False))
-
-        screenshot_base64 = await self._take_screenshot_after_delay()
-        return ToolResult(
-            output="".join(result.output or "" for result in results),
-            error="".join(result.error or "" for result in results),
-            base64_image=screenshot_base64,
-        )
-
-    async def cursor_position(self) -> ToolResult:
-        result = await self._shell(
-            f"{self.xdotool} getmouselocation --shell",
-            take_screenshot=False,
-        )
-        output = result.output or ""
-        x, y = self._scale_coordinates(
-            "computer",
-            int(output.split("X=")[1].split("\n")[0]),
-            int(output.split("Y=")[1].split("\n")[0]),
-        )
-        return result.replace(output=f"X={x},Y={y}")
-
-    async def left_mouse_down(self) -> ToolResult:
-        return await self._shell(f"{self.xdotool} mousedown 1")
-
-    async def left_mouse_up(self) -> ToolResult:
-        return await self._shell(f"{self.xdotool} mouseup 1")
-
-    async def mouse_move(self, coordinate: tuple[int, int]) -> ToolResult:
-        return await self._mouse_move_and("mouse_move", coordinate, None)
-
-    async def left_click(
-        self, coordinate: tuple[int, int] | None, text: str | None
-    ) -> ToolResult:
-        return await self._mouse_move_and("left_click", coordinate, text)
-
-    async def right_click(
-        self, coordinate: tuple[int, int] | None, text: str | None
-    ) -> ToolResult:
-        return await self._mouse_move_and("right_click", coordinate, text)
-
-    async def middle_click(
-        self, coordinate: tuple[int, int] | None, text: str | None
-    ) -> ToolResult:
-        return await self._mouse_move_and("middle_click", coordinate, text)
-
-    # https://wiki.archlinux.org/title/Mouse_buttons#Thumb_buttons_-_forward_and_back
-    # suggests that, although not in any spec, the de facto standard is 8 for
-    # back and 9 for forward.
-    async def back_click(
-        self, coordinate: tuple[int, int] | None, text: str | None
-    ) -> ToolResult:
-        return await self._mouse_move_and("back_click", coordinate, text)
-
-    async def forward_click(
-        self, coordinate: tuple[int, int] | None, text: str | None
-    ) -> ToolResult:
-        return await self._mouse_move_and("forward_click", coordinate, text)
-
-    async def double_click(
-        self, coordinate: tuple[int, int] | None, text: str | None
-    ) -> ToolResult:
-        return await self._mouse_move_and("double_click", coordinate, text)
-
-    async def triple_click(
-        self, coordinate: tuple[int, int] | None, text: str | None
-    ) -> ToolResult:
-        return await self._mouse_move_and("triple_click", coordinate, text)
-
-    async def left_click_drag(
-        self, start_coordinate: tuple[int, int], coordinate: tuple[int, int]
-    ) -> ToolResult:
-        await self._move_mouse_to_coordinate(start_coordinate, False)
-        x, y = self._scale_coordinates("api", *coordinate)
-        return await self._shell(
-            f"{self.xdotool} mousedown 1 mousemove --sync {x} {y} mouseup 1"
-        )
-
-    async def scroll(
-        self,
-        scroll_direction: Literal["up", "down", "left", "right"],
-        scroll_amount: int,
-        coordinate: tuple[int, int] | None,
-        text: str | None,
-    ) -> ToolResult:
-        if coordinate:
-            await self._move_mouse_to_coordinate(coordinate, False)
-        scroll_button = {
-            "up": 4,
-            "down": 5,
-            "left": 6,
-            "right": 7,
-        }[scroll_direction]
-
-        if text:
-            key_arg = _key_arg_for_text(text)
-            await self._shell(f"{self.xdotool} keydown -- {key_arg}", False)
-            await self._shell(
-                f"{self.xdotool} click --repeat {scroll_amount} {scroll_button}",
-                False,
-            )
-            return await self._shell(f"{self.xdotool} keyup -- {key_arg}")
-        else:
-            return await self._shell(
-                f"{self.xdotool} click --repeat {scroll_amount} {scroll_button}"
-            )
-
-    async def wait(self, duration: int) -> ToolResult:
-        await asyncio.sleep(duration)
-        return await self.screenshot()
-
-    async def screenshot(self) -> ToolResult:
-        return await self._screenshot()
-
-    async def _mouse_move_and(
-        self,
-        action: Literal[
-            "mouse_move",
-            "left_click",
-            "right_click",
-            "middle_click",
-            "back_click",
-            "forward_click",
-            "double_click",
-            "triple_click",
-        ],
-        coordinate: tuple[int, int] | None,
-        text: str | None,
-    ):
-        should_move = action == "mouse_move" or coordinate
-        if should_move:
-            assert coordinate  # coding/type safety error
-            move_result = await self._move_mouse_to_coordinate(
-                coordinate, action == "mouse_move"
-            )
-            if action == "mouse_move":
-                return move_result
-        click_arg = {
-            "left_click": "1",
-            "right_click": "3",
-            "middle_click": "2",
-            "back_click": "8",
-            "forward_click": "9",
-            "double_click": "--repeat 2 --delay 300 1",
-            "triple_click": "--repeat 3 --delay 300 1",
-        }[action]
-
-        if text:
-            key_arg = _key_arg_for_text(text)
-            await self._shell(f"{self.xdotool} keydown -- {key_arg}", False)
-            await self._shell(f"{self.xdotool} click {click_arg}", False)
-            return await self._shell(f"{self.xdotool} keyup -- {key_arg}")
-        else:
-            return await self._shell(f"{self.xdotool} click {click_arg}")
-
-    async def _move_mouse_to_coordinate(
-        self, coordinate: tuple[int, int], take_screenshot: bool
-    ):
-        x, y = self._scale_coordinates("api", *coordinate)
-        return await self._shell(
-            f"{self.xdotool} mousemove --sync {x} {y}", take_screenshot=take_screenshot
-        )
-
-    async def _screenshot(self):
-        """Take a screenshot of the current screen and return the base64 encoded image."""
-        output_dir = Path(OUTPUT_DIR)
-        output_dir.mkdir(parents=True, exist_ok=True)
-        path = output_dir / f"screenshot_{uuid4().hex}.png"
-
-        result = await self._shell(
-            f"{self._display_prefix}scrot --silent -p {path}", take_screenshot=False
-        )
-        if self._scaling_enabled:
-            x, y = self._scale_coordinates("computer", self.width, self.height)
-            convert_cmd = f"convert {path} -resize {x}x{y}!"
-            if self.color_count is not None:
-                convert_cmd += f" -colors {self.color_count}"
-            convert_cmd += f" {path}"
-            await self._shell(convert_cmd, take_screenshot=False)
-
-        if path.exists():
-            return result.replace(
-                base64_image=base64.b64encode(path.read_bytes()).decode()
-            )
-        raise X11ClientError(f"Failed to take screenshot: {result.error}")
-
-    async def _shell(self, command: str, take_screenshot=True) -> ToolResult:
-        """Run a shell command and return the output, error, and optionally a screenshot."""
-        logging.debug(f"running shell command {command}")
-        _, stdout, stderr = await run(command)
-        logging.debug(f"shell command returned stdout: {stdout}, stderr: {stderr}")
-        return ToolResult(
-            output=stdout,
-            error=stderr,
-            base64_image=(await self._take_screenshot_after_delay())
-            if take_screenshot
-            else None,
-        )
-
-    async def _take_screenshot_after_delay(self) -> str:
-        # delay to let things settle before taking a screenshot
-        await asyncio.sleep(self._screenshot_delay)
-        return (await self._screenshot()).base64_image
-
-    def _scale_coordinates(self, source: ScalingSource, x: int, y: int):
-        """Scale coordinates to a target maximum resolution."""
-        if not self._scaling_enabled:
-            return x, y
-        ratio = self.width / self.height
-        target_dimension = None
-        for dimension in MAX_SCALING_TARGETS.values():
-            # allow some error in the aspect ratio - not ratios are exactly 16:9
-            if abs(dimension["width"] / dimension["height"] - ratio) < 0.02:
-                if dimension["width"] < self.width:
-                    target_dimension = dimension
-                break
-        if target_dimension is None:
-            return x, y
-        # should be less than 1
-        x_scaling_factor = target_dimension["width"] / self.width
-        y_scaling_factor = target_dimension["height"] / self.height
-        if source == "api":
-            if x > self.width or y > self.height:
-                raise X11ClientError(f"Coordinates {x}, {y} are out of bounds")
-            # scale up
-            return round(x / x_scaling_factor), round(y / y_scaling_factor)
-        # scale down
-        return round(x * x_scaling_factor), round(y * y_scaling_factor)
-
-
-def _key_arg_for_text(text: str) -> str:
-    return " ".join(shlex.quote(part) for part in text.split())

inspect_ai/tool/_tools/_computer/_resources/tool/computer_tool.py

@@ -1,141 +0,0 @@
-import asyncio
-import json
-import logging
-import os
-import sys
-import time
-from argparse import Namespace
-from typing import TypeVar
-
-from _args import parse_arguments
-from _constants import Action
-from _logger import setup_logger
-from _tool_result import ToolResult
-from _x11_client import X11Client
-
-
-class ComputerToolError(Exception):
-    def __init__(self, message):
-        self.message = message
-
-
-# This is a bit sketchy. We really want to use relative imports here. Using absolute imports
-# works at runtime, but it prevents intellisense from working. However, when this folder is
-# copied to the container, by default relative imports won't work if this file is launched
-# normally. To overcome this, two things need to happen:
-# 1. PYTHONPATH must be set to the parent of the container folder. `PYTHONPATH=/opt`
-# 2. The program must be launched with the -m flag. `python3 -m computer_tool.computer_tool`
-#
-# TODO: There's got to be a cleaner way.
-
-my_logger = setup_logger(logging.INFO)
-
-
-def main():
-    try:
-        args = parse_arguments()
-        my_logger.info(f"({args})")
-        result = asyncio.run(execute_action(args))
-
-        print(
-            json.dumps(
-                {
-                    "output": result.output,
-                    "error": result.error,
-                    "base64_image": result.base64_image,
-                }
-            )
-        )
-        my_logger.debug("SUCCESS")
-    except Exception as e:
-        my_logger.warning(f"An error occurred: {e}")
-        print(f"An error occurred: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-async def execute_action(args: Namespace) -> ToolResult:
-    # we can't do anything until X11 is ready to go.
-    await wait_for_file("/tmp/xfce_started")
-
-    computer = X11Client()
-    action: Action = args.action
-    match action:
-        case "key":
-            return await computer.key(not_none(args.text, "text"))
-        case "hold_key":
-            return await computer.hold_key(
-                not_none(args.text, "text"), not_none(args.duration, "duration")
-            )
-        case "type":
-            return await computer.type(not_none(args.text, "text"))
-        case "cursor_position":
-            return await computer.cursor_position()
-        case "left_mouse_down":
-            return await computer.left_mouse_down()
-        case "left_mouse_up":
-            return await computer.left_mouse_up()
-        case "mouse_move":
-            return await computer.mouse_move(not_none(args.coordinate, "coordinate"))
-        case "left_click":
-            return await computer.left_click(
-                getattr(args, "coordinate", None), getattr(args, "text", None)
-            )
-        case "right_click":
-            return await computer.right_click(
-                getattr(args, "coordinate", None), getattr(args, "text", None)
-            )
-        case "middle_click":
-            return await computer.middle_click(
-                getattr(args, "coordinate", None), getattr(args, "text", None)
-            )
-        case "double_click":
-            return await computer.double_click(
-                getattr(args, "coordinate", None), getattr(args, "text", None)
-            )
-        case "triple_click":
-            return await computer.triple_click(
-                getattr(args, "coordinate", None), getattr(args, "text", None)
-            )
-        case "left_click_drag":
-            return await computer.left_click_drag(
-                not_none(args.start_coordinate, "start_coordinate"),
-                not_none(args.coordinate, "coordinate"),
-            )
-        case "scroll":
-            return await computer.scroll(
-                not_none(args.scroll_direction, "scroll_direction"),
-                not_none(args.scroll_amount, "scroll_amount"),
-                getattr(args, "coordinate", None),
-                getattr(args, "text", None),
-            )
-        case "wait":
-            return await computer.wait(not_none(args.duration, "duration"))
-        case "screenshot":
-            return await computer.screenshot()
-
-    raise ComputerToolError(f"Invalid action: {action}")
-
-
-async def wait_for_file(file_path, check_interval=1):
-    if os.path.exists(file_path):
-        return
-    my_logger.info(f"Waiting for {file_path}")
-    start_time = time.time()
-    while not os.path.exists(file_path):
-        await asyncio.sleep(check_interval)
-    my_logger.info(
-        f"Done waiting for {file_path} after {time.time() - start_time:.1f} seconds"
-    )
-
-
-T = TypeVar("T")
-
-
-def not_none(value: T | None, name: str) -> T:
-    if value is None:
-        raise ComputerToolError(f"{name} must be provided")
-    return value
-
-
-if __name__ == "__main__":
-    main()