inspect-ai 0.3.62__py3-none-any.whl → 0.3.64__py3-none-any.whl

inspect_ai/tool/{beta → _tools}/_computer/_common.py

@@ -123,11 +123,11 @@ async def computer_sandbox() -> SandboxEnvironment:
     else:
         raise PrerequisiteError(
             dedent("""
-                The computer tool service was not found in any of the sandboxes for this sample. Please add the computer tool service to your configuration. For example, the following Docker compose file uses the aisiuk/inspect-computer-tool:latest-beta image as its default sandbox:
+                The computer tool service was not found in any of the sandboxes for this sample. Please add the computer tool service to your configuration. For example, the following Docker compose file uses the aisiuk/inspect-computer-tool:latest image as its default sandbox:
 
                 services:
                   default:
-                    image: "aisiuk/inspect-computer-tool:latest-beta"
+                    image: "aisiuk/inspect-computer-tool:latest"
                     init: true
                 """).strip()
         )

inspect_ai/tool/{beta → _tools}/_computer/_computer.py

@@ -2,10 +2,7 @@ from typing import Awaitable, Callable
 
 from inspect_ai._util.content import Content, ContentImage, ContentText
 from inspect_ai.tool import Tool, ToolResult, tool
-from inspect_ai.tool._tool import (
-    TOOL_INIT_MODEL_INPUT,
-    ToolParsingError,
-)
+from inspect_ai.tool._tool import TOOL_INIT_MODEL_INPUT, ToolParsingError
 from inspect_ai.tool._tool_call import ToolCallModelInput
 
 from . import _common as common
@@ -16,6 +13,17 @@ ActionFunction = Callable[[str], ToolResult | Awaitable[ToolResult]]
 
 @tool
 def computer(max_screenshots: int | None = 1, timeout: int | None = 180) -> Tool:
+    """Desktop computer tool.
+
+    See documentation at <https://inspect.ai-safety-institute.org.uk/tools.html#sec-computer>.
+
+    Args:
+      max_screenshots: The maximum number of screenshots to play
+        back to the model as input. Defaults to 1 (set to `None` to have no limit).
+      timeout: Timeout in seconds for computer tool actions.
+        Defaults to 180 (set to `None` for no timeout).
+    """
+
     async def execute(
         action: Action,
         text: str | None = None,
@@ -84,7 +92,7 @@ def computer(max_screenshots: int | None = 1, timeout: int | None = 180) -> Tool
             if coordinate is not None:
                 raise ToolParsingError(f"coordinate is not accepted for {action}")
             if not isinstance(text, str):
-                raise ToolParsingError(output=f"{text} must be a string")
+                raise ToolParsingError(f"{text} must be a string")
 
             if action == "key":
                 return await common.press_key(text, timeout=timeout)

inspect_ai/tool/{beta → _tools}/_computer/_resources/tool/_x11_client.py

@@ -138,7 +138,7 @@ class X11Client:
             if coordinate is not None:
                 raise ToolError(f"coordinate is not accepted for {action}")
             if not isinstance(text, str):
-                raise ToolError(output=f"{text} must be a string")
+                raise ToolError(f"{text} must be a string")
 
             if action == "key":
                 return await self.shell(

inspect_ai/tool/_tools/_execute.py

@@ -1,4 +1,4 @@
-from inspect_ai.util import sandbox
+from inspect_ai.util import sandbox as sandbox_env
 
 from .._tool import Tool, tool
 from .._tool_call import ToolCall, ToolCallContent, ToolCallView, ToolCallViewer
@@ -20,14 +20,17 @@ def code_viewer(language: str, code_param: str) -> ToolCallViewer:
 
 
 @tool(viewer=code_viewer("bash", "cmd"))
-def bash(timeout: int | None = None, user: str | None = None) -> Tool:
+def bash(
+    timeout: int | None = None, user: str | None = None, sandbox: str | None = None
+) -> Tool:
     """Bash shell command execution tool.
 
     Execute bash shell commands using a sandbox environment (e.g. "docker").
 
     Args:
-      timeout (int | None): Timeout (in seconds) for command.
-      user (str | None): User to execute commands as.
+      timeout: Timeout (in seconds) for command.
+      user: User to execute commands as.
+      sandbox: Optional sandbox environmnent name.
 
     Returns:
       String with command output (stdout) or command error (stderr).
@@ -44,7 +47,7 @@ def bash(timeout: int | None = None, user: str | None = None) -> Tool:
           The output of the command.
         """
         # execute the command
-        result = await sandbox().exec(
+        result = await sandbox_env(sandbox).exec(
             cmd=["bash", "--login", "-c", cmd], timeout=timeout, user=user
         )
         # return output (including stderr if any)
@@ -57,14 +60,17 @@ def bash(timeout: int | None = None, user: str | None = None) -> Tool:
 
 
 @tool(viewer=code_viewer("python", "code"))
-def python(timeout: int | None = None, user: str | None = None) -> Tool:
+def python(
+    timeout: int | None = None, user: str | None = None, sandbox: str | None = None
+) -> Tool:
     """Python code execution tool.
 
     Execute Python code using a sandbox environment (e.g. "docker").
 
     Args:
-      timeout (int | None): Timeout (in seconds) for command.
-      user (str | None): User to execute commands as.
+      timeout: Timeout (in seconds) for command.
+      user: User to execute commands as.
+      sandbox: Optional sandbox environmnent name.
 
     Returns:
       String with command output (stdout) or command error (stderr).
@@ -74,8 +80,14 @@ def python(timeout: int | None = None, user: str | None = None) -> Tool:
         """
         Use the python function to execute Python code.
 
-        The python function will only return you the stdout of the script,
-        so make sure to use print to see the output.
+        The Python tool executes single-run Python scripts. Important notes:
+        1. Each execution is independent - no state is preserved between runs
+        2. You must explicitly use print() statements to see any output
+        3. Simply writing expressions (like in notebooks) will not display results
+        4. The script cannot accept interactive input during execution
+        5. Return statements alone won't produce visible output
+        6. All variables and imports are cleared between executions
+        7. Standard output (via print()) is the only way to see results
 
         Args:
           code (str): The python code to execute.
@@ -83,7 +95,7 @@ def python(timeout: int | None = None, user: str | None = None) -> Tool:
         Returns:
           The output of the Python code.
         """
-        result = await sandbox().exec(
+        result = await sandbox_env(sandbox).exec(
             cmd=["python3"], input=code, timeout=timeout, user=user
         )
         # return output (including stderr if any)

inspect_ai/tool/_tools/_web_browser/_resources/README.md

@@ -40,7 +40,7 @@ The result will be printed out in _stdout_ in the following format:
 error: <an ERROR message if one occured>
 info: <general info about the container>
 web_url: <the URL of the page the browser is currently at>
-wen_at: <accessibility tree of the visible elements of the page>
+web_at: <accessibility tree of the visible elements of the page>
 ```   
 
 
@@ -57,7 +57,7 @@ The tool consists of the following components:
   * _web_environment.py_ - an environment which gets instantiated by the servicer and which launches the browser, stores its state and maps client commands to Playwright API. 
   * _playwright_crawler.py_ - a wrapper over the sync Playwright API. 
 
-* [WebClient](web_client.py) - a simple stateless client to interract with the server. When launched, the client:
+* [WebClient](web_client.py) - a simple stateless client to interact with the server. When launched, the client:
   1. creates a connection with the server;
   2. sends user command to the server;
   3. receives the response in the form of observations and prints them to stdout;

inspect_ai/tool/_tools/_web_browser/_web_browser.py

@@ -16,10 +16,12 @@ from inspect_ai.util._store_model import StoreModel, store_as
 def web_browser(interactive: bool = True) -> list[Tool]:
     """Tools used for web browser navigation.
 
+     See documentation at <https://inspect.ai-safety-institute.org.uk/tools.html#sec-web-browser>.
+
     Args:
-       interactive (bool): Provide interactive tools (enable
-         clicking, typing, and submitting forms). Defaults
-         to True.
+       interactive: Provide interactive tools (enable
+          clicking, typing, and submitting forms). Defaults
+          to True.
 
     Returns:
        List of tools used for web browser navigation.

inspect_ai/tool/_tools/_web_search.py

@@ -41,14 +41,16 @@ def web_search(
     A web search is conducted using the specified provider, the results are parsed for relevance
     using the specified model, and the top 'num_results' relevant pages are returned.
 
+    See further documentation at <https://inspect.ai-safety-institute.org.uk/tools.html#sec-web-search>.
+
     Args:
-      provider (Literal["google"]): Search provider (defaults to "google", currently
+      provider: Search provider (defaults to "google", currently
         the only provider). Possible future providers include "brave" and "bing".
-      num_results (int): Number of web search result pages to return to the model.
-      max_provider_calls (int): Maximum number of search calls to make to the search provider.
-      max_connections (int): Maximum number of concurrent connections to API
+      num_results: Number of web search result pages to return to the model.
+      max_provider_calls: Maximum number of search calls to make to the search provider.
+      max_connections: Maximum number of concurrent connections to API
         endpoint of search provider.
-      model (str | Model): Model used to parse web pages for relevance.
+      model: Model used to parse web pages for relevance.
 
     Returns:
        A tool that can be registered for use by models to search the web.

inspect_ai/tool/beta.py

@@ -0,0 +1,3 @@
+from inspect_ai._util.deprecation import relocated_module_attribute
+
+relocated_module_attribute("computer", "inspect_ai.tool.computer", "0.3.62", "0.4")

inspect_ai/util/_concurrency.py

@@ -23,12 +23,12 @@ def concurrency(
     for launching subprocesses is handled via the `subprocess` function.
 
     Args:
-      name (str): Name for concurrency context. This serves as the
+      name: Name for concurrency context. This serves as the
          display name for the context, and also the unique context
          key (if the `key` parameter is omitted)
-      concurrency (int): Maximum number of coroutines that can
+      concurrency: Maximum number of coroutines that can
          enter the context.
-      key (str | None): Unique context key for this context. Optional.
+      key: Unique context key for this context. Optional.
          Used if the unique key isn't human readable -- e.g. includes
          api tokens or account ids so that the more readable `name`
          can be presented to users e.g in console UI>

inspect_ai/util/_panel.py

@@ -5,6 +5,8 @@ from typing_extensions import Self
 
 
 class InputPanel(Container):
+    """Base class for for Inspect input panels."""
+
     DEFAULT_TITLE = "Panel"
 
     DEFAULT_CLASSES = "task-input-panel"

inspect_ai/util/_resource.py

@@ -33,18 +33,18 @@ def resource(
     `resource("templates/prompt.txt", type="file")`
 
     Args:
-        resource (str): Path to local or remote (e.g. s3://)
-          resource, or for `type="auto"` (the default),
-          a string containing the literal resource value.
-        type (Literal["auto", "file"]): For "auto" (the default),
-          interpret the resource as a literal string if its not
-          a valid path. For "file", always interpret it as
-          a file path.
-        fs_options (dict[str, Any]): Optional. Additional
-          arguments to pass through to the `fsspec` filesystem
-          provider (e.g. `S3FileSystem`). Use `{"anon": True }`
-          if you are accessing a public S3 bucket with no
-          credentials.
+        resource: Path to local or remote (e.g. s3://)
+            resource, or for `type="auto"` (the default),
+            a string containing the literal resource value.
+        type: For "auto" (the default),
+            interpret the resource as a literal string if its not
+            a valid path. For "file", always interpret it as
+            a file path.
+        fs_options: Optional. Additional
+            arguments to pass through to the `fsspec` filesystem
+            provider (e.g. `S3FileSystem`). Use `{"anon": True }`
+            if you are accessing a public S3 bucket with no
+            credentials.
 
     Returns:
        Text content of resource.

inspect_ai/util/_sandbox/docker/compose.py

@@ -3,12 +3,13 @@ import os
 import shlex
 from logging import getLogger
 from pathlib import Path
-from typing import Any, Literal, TypedDict, cast
+from typing import Any, Literal, cast
 
 import yaml
 from pydantic import BaseModel
 
 from inspect_ai._util.error import PrerequisiteError
+from inspect_ai._util.trace import trace_message
 from inspect_ai.util._display import display_type
 from inspect_ai.util._subprocess import ExecResult, subprocess
 
@@ -16,26 +17,39 @@ from .prereqs import (
     DOCKER_COMPOSE_REQUIRED_VERSION_PULL_POLICY,
     validate_docker_compose,
 )
+from .service import ComposeService, services_healthcheck_time
 from .util import ComposeProject, is_inspect_project
 
 logger = getLogger(__name__)
 
 # How long to wait for compose environment to pass a health check
-COMPOSE_WAIT = "120"
+COMPOSE_WAIT = 120
 
 
-async def compose_up(project: ComposeProject) -> None:
+async def compose_up(
+    project: ComposeProject, services: dict[str, ComposeService]
+) -> None:
+    # compute the maximum amount of time we will
+    up_command = ["up", "--detach", "--wait"]
+
+    # are there healthchecks in the service definitions? if so then peg our timeout
+    # at the maximum total wait time. otherwise, pick a reasonable default
+    healthcheck_time = services_healthcheck_time(services)
+    if healthcheck_time > 0:
+        timeout: int = healthcheck_time
+        trace_message(logger, "Docker", "Docker services heathcheck timeout: {timeout}")
+    else:
+        timeout = COMPOSE_WAIT
+
+    # align global wait timeout to maximum healthcheck timeout
+    up_command.extend(["--wait-timeout", str(timeout + 1)])
+
     # Start the environment. Note that we don't check the result because docker will
     # return a non-zero exit code for services that exit (even successfully) when
     # passing the --wait flag (see https://github.com/docker/compose/issues/10596).
     # In practice, we will catch any errors when calling compose_check_running()
     # immediately after we call compose_up().
-    await compose_command(
-        ["up", "--detach", "--wait", "--wait-timeout", COMPOSE_WAIT],
-        project=project,
-        # wait up to 5 minutes for container to go up (compose wait + 3 minutes)
-        timeout=300,
-    )
+    await compose_command(up_command, project=project, timeout=timeout)
 
 
 async def compose_down(project: ComposeProject, quiet: bool = True) -> None:
@@ -191,17 +205,6 @@ async def compose_exec(
     )
 
 
-ComposeService = TypedDict(
-    "ComposeService",
-    {
-        "image": str | None,
-        "build": str | None,
-        "x-default": bool | None,
-        "x-local": bool | None,
-    },
-)
-
-
 async def compose_services(project: ComposeProject) -> dict[str, ComposeService]:
     result = await compose_command(["config"], project=project, timeout=60)
     if not result.success:

inspect_ai/util/_sandbox/docker/config.py

@@ -42,7 +42,8 @@ def find_compose_file(parent: str = "") -> str | None:
 
 
 def is_dockerfile(file: str) -> bool:
-    return os.path.basename(file) == DOCKERFILE
+    path = Path(file)
+    return path.name == DOCKERFILE or path.suffix == f".{DOCKERFILE}"
 
 
 def has_dockerfile(parent: str = "") -> bool:

inspect_ai/util/_sandbox/docker/docker.py

@@ -1,3 +1,4 @@
+import base64
 import errno
 import json
 import os
@@ -8,6 +9,7 @@ from typing import Literal, Union, cast, overload
 
 from typing_extensions import override
 
+from inspect_ai._util.error import PrerequisiteError
 from inspect_ai.util._subprocess import ExecResult, subprocess
 
 from ..environment import (
@@ -34,7 +36,6 @@ from .compose import (
     compose_build,
     compose_check_running,
     compose_cleanup_images,
-    compose_command,
     compose_cp,
     compose_exec,
     compose_ps,
@@ -85,6 +86,14 @@ class DockerSandboxEnvironment(SandboxEnvironment):
 
             services = await compose_services(project)
             for name, service in services.items():
+                # if the service has an explicit container_name then
+                # error (as this won't work w/ epochs > 1)
+                container_name = service.get("container_name", None)
+                if container_name:
+                    raise PrerequisiteError(
+                        f"ERROR: Docker service '{name}' includes an explicitly configured container_name ('{container_name}'). This is not permitted, as container names should be provisioned by Docker compose and an explicit container_name will not work with epochs > 1."
+                    )
+
                 # build internal images
                 image = service.get("image", None)
                 if image and is_internal_image(image):
@@ -139,7 +148,7 @@ class DockerSandboxEnvironment(SandboxEnvironment):
             services = await compose_services(project)
 
             # start the services
-            await compose_up(project)
+            await compose_up(project, services)
 
             # check to ensure that the services are running
             running_services = await compose_check_running(
@@ -270,103 +279,50 @@ class DockerSandboxEnvironment(SandboxEnvironment):
 
     @override
     async def write_file(self, file: str, contents: str | bytes) -> None:
-        # exec function w/ timeout
-        async def exec(cmd: list[str]) -> ExecResult[str]:
-            return await self.exec(cmd, timeout=60)
-
         # resolve relative file paths
         file = self.container_file(file)
 
-        # We want to be able to write a file in the container,
-        # but only if the container's user would be allowed to do that.
-        # We need to avoid implicitly trusting the provided "file" string.
-        # For example, it shouldn't be passed as part of a shell command,
-        # because of the risk of shell injection.
-
-        local_tmpfile = tempfile.NamedTemporaryFile()
+        # ensure that the directory exists
+        parent = Path(file).parent.as_posix()
+        if parent != ".":
+            result = await self.exec(["mkdir", "-p", parent])
+            if not result.success:
+                msg = f"Failed to create container directory {parent}: {result.stderr}"
+                raise RuntimeError(msg)
 
-        # write contents into a local tmp file (not in the container)
+        # write the file
         if isinstance(contents, str):
-            local_tmpfile.write(contents.encode("utf-8"))
+            result = await self.exec(
+                ["sh", "-e", "-c", 'tee -- "$1"', "write_file_script", file],
+                input=contents,
+            )
         else:
-            local_tmpfile.write(contents)
-
-        local_tmpfile.flush()
-
-        # Copy the local tmp file into a tmp file on the container.
-        # Both tmp files have safe names as we created them ourselves
-
-        # We write the tmp file in the default directory,
-        # because of strangeness with /tmp on GitHub action runners.
-
-        # We are reusing the generated local tmp file name within
-        # the sandbox to save on a container roundtrip. There is a very slight
-        # risk of collision if another write_file call happens
-        # to get the same local tmp file name. But we assume tmp file
-        # names have enough randomness for us to ignore that.
-
-        container_tmpfile = (
-            f".tmp_inspect_sandbox_{os.path.basename(local_tmpfile.name)}"
-        )
-
-        # compose cp will leave the file owned by root
-        await compose_cp(
-            src=local_tmpfile.name,
-            dest=f"{self._service}:{self.container_file(container_tmpfile)}",
-            project=self._project,
-        )
-
-        local_tmpfile.close()  # this will also delete the file
-
-        if not hasattr(self, "_docker_user"):
-            uid = (await exec(["id", "-u"])).stdout.strip()
-            gid = (await exec(["id", "-g"])).stdout.strip()
-            self._docker_user = (uid, gid)
-
-        await compose_command(
-            [
-                "exec",
-                "--user",
-                "root",
-                self._service,
-                "chown",
-                f"{self._docker_user[0]}:{self._docker_user[1]}",
-                container_tmpfile,
-            ],
-            project=self._project,
-            timeout=60,
-        )
-
-        parent = PurePosixPath(file).parent
-
-        # We do these steps in a shell script for efficiency to avoid round-trips to docker.
-        res_cp = await exec(
-            [
-                "sh",
-                "-e",
-                "-c",
-                'mkdir -p -- "$1"; cp -T -- "$2" "$3"; rm -- "$2"',
-                "copy_script",
-                str(parent),
-                container_tmpfile,
-                file,
-            ]
-        )
-
-        if res_cp.returncode != 0:
-            if "Permission denied" in res_cp.stderr:
-                ls_result = await exec(["ls", "-la", "."])
-                error_string = f"Permission was denied. Error details: {res_cp.stderr}; ls -la: {ls_result.stdout}; {self._docker_user=}"
+            base64_contents = base64.b64encode(contents).decode("US-ASCII")
+            result = await self.exec(
+                [
+                    "sh",
+                    "-e",
+                    "-c",
+                    'base64 -d | tee -- "$1" > /dev/null',
+                    "write_file_script",
+                    file,
+                ],
+                input=base64_contents,
+            )
+        if result.returncode != 0:
+            if "permission denied" in result.stderr.casefold():
+                ls_result = await self.exec(["ls", "-la", "."])
+                error_string = f"Permission was denied. Error details: {result.stderr}; ls -la: {ls_result.stdout}"
                 raise PermissionError(error_string)
             elif (
-                "cannot overwrite directory" in res_cp.stderr
-                or "is a directory" in res_cp.stderr
+                "cannot overwrite directory" in result.stderr.casefold()
+                or "is a directory" in result.stderr.casefold()
             ):
                 raise IsADirectoryError(
                     f"Failed to write file: {file} because it is a directory already"
                 )
             else:
-                raise RuntimeError(f"failed to copy during write_file: {res_cp}")
+                raise RuntimeError(f"failed to copy during write_file: {result}")
 
     @overload
     async def read_file(self, file: str, text: Literal[True] = True) -> str: ...

inspect_ai/util/_sandbox/docker/service.py

@@ -0,0 +1,100 @@
+import re
+from dataclasses import dataclass
+from typing import TypedDict
+
+
+class ComposeServiceHealthcheck(TypedDict, total=False):
+    start_period: str
+    interval: str
+    retries: int
+    timeout: str
+
+
+ComposeService = TypedDict(
+    "ComposeService",
+    {
+        "image": str,
+        "build": str,
+        "container_name": str,
+        "x-default": bool,
+        "x-local": bool,
+        "healthcheck": ComposeServiceHealthcheck,
+    },
+    total=False,
+)
+
+
+def services_healthcheck_time(services: dict[str, ComposeService]) -> int:
+    max_time = 0
+
+    for _, service in services.items():
+        service_time = service_healthcheck_time(service)
+        max_time = max(max_time, service_time)
+
+    return max_time
+
+
+def service_healthcheck_time(service: ComposeService) -> int:
+    """
+    Calculate the maximum time a single service's healthcheck could take.
+
+    The total time is:
+    (retries * (interval + timeout))
+
+    Default values (from Docker documentation):
+    - retries: 3
+    - interval: 30s
+    - timeout: 30s
+    """
+    healthcheck = service.get("healthcheck", None)
+    if healthcheck is None:
+        return 0
+
+    # Parse duration strings with defaults
+    retries = healthcheck.get("retries", 3)
+    interval = parse_duration(healthcheck.get("interval", "30s"))
+    timeout = parse_duration(healthcheck.get("timeout", "30s"))
+
+    # Calculate total time in seconds
+    total_time = retries * (interval.seconds + timeout.seconds)
+
+    return int(total_time)
+
+
+@dataclass
+class Duration:
+    nanoseconds: int
+
+    @property
+    def seconds(self) -> float:
+        return self.nanoseconds / 1_000_000_000
+
+
+def parse_duration(duration_str: str) -> Duration:
+    """Parse a Docker compose style duration string."""
+    if not duration_str:
+        return Duration(0)
+
+    units = {
+        "ns": 1,
+        "us": 1_000,
+        "ms": 1_000_000,
+        "s": 1_000_000_000,
+        "m": 60_000_000_000,
+        "h": 3_600_000_000_000,
+    }
+
+    duration_str = "".join(duration_str.split())
+    pattern = re.compile(r"(\d+)([a-z]+)")
+    matches = pattern.findall(duration_str)
+
+    if not matches:
+        raise ValueError(f"Invalid duration format: {duration_str}")
+
+    total_nanoseconds = 0
+    for number, unit in matches:
+        if unit not in units:
+            raise ValueError(f"Invalid unit: {unit}")
+        total_nanoseconds += int(number) * units[unit]
+
+    return Duration(total_nanoseconds)