inspect-ai 0.3.55__py3-none-any.whl → 0.3.56__py3-none-any.whl

inspect_ai/tool/_tools/_web_browser/_web_browser.py

@@ -1,6 +1,8 @@
 import re
 from textwrap import dedent
 
+from pydantic import Field
+
 from inspect_ai._util.error import PrerequisiteError
 from inspect_ai.tool._tool import Tool, ToolError, tool
 from inspect_ai.tool._tool_call import ToolCall, ToolCallContent, ToolCallView
@@ -8,7 +10,7 @@ from inspect_ai.tool._tool_info import parse_tool_info
 from inspect_ai.tool._tool_with import tool_with
 from inspect_ai.util._sandbox import SandboxEnvironment, sandbox_with
 from inspect_ai.util._sandbox.docker.internal import INSPECT_WEB_BROWSER_IMAGE_DOCKERHUB
-from inspect_ai.util._store import store
+from inspect_ai.util._store_model import StoreModel, store_as
 
 
 def web_browser(interactive: bool = True) -> list[Tool]:
@@ -97,12 +99,15 @@ def go_without_interactive_docs(tool: Tool) -> Tool:
 # custom viewer for interactive tool calls that shows a truncated
 # version of current the web accessiblity tree if available
 
-WEB_BROWSER_AT = "web_browser:at"
+
+class WebBrowserStore(StoreModel):
+    web_at: str = Field(default_factory=str)
+    session_id: str = Field(default_factory=str)
 
 
 def web_at_viewer(call: ToolCall) -> ToolCallView:
     # get the web accessiblity tree, if we have it create a view from it
-    web_at = store().get(WEB_BROWSER_AT, "")
+    web_at = store_as(WebBrowserStore).web_at
     element_id = call.arguments.get("element_id", 0)
     if web_at and element_id:
         lines = web_at.splitlines()
@@ -332,15 +337,14 @@ def web_browser_refresh() -> Tool:
 
 WEB_CLIENT_REQUEST = "/app/web_browser/web_client.py"
 WEB_CLIENT_NEW_SESSION = "/app/web_browser/web_client_new_session.py"
-BROWSER_SESSION_ID = "BROWSER_SESSION_ID"
 
 
 async def web_browser_cmd(cmd: str, *args: str) -> str:
     sandbox_env = await sandbox_with(WEB_CLIENT_NEW_SESSION)
     session_flag = ""
     if sandbox_env:
-        browser_session = store().get(BROWSER_SESSION_ID, "")
-        if not browser_session:
+        store = store_as(WebBrowserStore)
+        if not store.session_id:
             result = await sandbox_env.exec(["python3", WEB_CLIENT_NEW_SESSION])
 
             if not result.success:
@@ -348,10 +352,9 @@ async def web_browser_cmd(cmd: str, *args: str) -> str:
                     f"Error creating new web browser session: {result.stderr}"
                 )
 
-            browser_session = result.stdout.strip("\n")
-            store().set(BROWSER_SESSION_ID, browser_session)
+            store.session_id = result.stdout.strip("\n")
 
-        session_flag = f"--session_name={browser_session}"
+        session_flag = f"--session_name={store.session_id}"
 
     else:
         sandbox_env = await web_browser_sandbox()
@@ -379,7 +382,7 @@ async def web_browser_cmd(cmd: str, *args: str) -> str:
                 line.partition("data:image/png;base64")[0] for line in web_at_lines
             ]
             web_at = "\n".join(web_at_lines)
-            store().set(WEB_BROWSER_AT, web_at)
+            store_as(WebBrowserStore).web_at = web_at
             return web_at
         elif "error" in response:
             raise ToolError(str(response.get("error")) or "(unknown error)")

inspect_ai/util/__init__.py

@@ -1,5 +1,6 @@
 from ._concurrency import concurrency
 from ._console import input_screen
+from ._display import DisplayType, display_type
 from ._panel import InputPanel, input_panel
 from ._resource import resource
 from ._sandbox import (
@@ -11,23 +12,25 @@ from ._sandbox import (
     SandboxEnvironments,
     SandboxEnvironmentSpec,
     SandboxEnvironmentType,
-    SandboxService,
     sandbox,
-    sandbox_service,
     sandbox_with,
     sandboxenv,
 )
 from ._store import Store, store
+from ._store_model import StoreModel, store_as
 from ._subprocess import (
     ExecResult,
     subprocess,
 )
 from ._subtask import Subtask, subtask
+from ._throttle import throttle
 from ._trace import trace_enabled, trace_panel
 
 __all__ = [
     "ExecResult",
     "concurrency",
+    "DisplayType",
+    "display_type",
     "InputPanel",
     "input_panel",
     "input_screen",
@@ -44,12 +47,13 @@ __all__ = [
     "sandboxenv",
     "sandbox",
     "sandbox_with",
-    "SandboxService",
-    "sandbox_service",
     "Store",
     "store",
+    "StoreModel",
+    "store_as",
     "Subtask",
     "subtask",
+    "throttle",
     "trace_enabled",
     "trace_panel",
 ]

inspect_ai/{_util/display.py → util/_display.py}

@@ -7,6 +7,7 @@ from inspect_ai._util.constants import DEFAULT_DISPLAY
 logger = getLogger(__name__)
 
 DisplayType = Literal["full", "rich", "plain", "none"]
+"""Console display type."""
 
 
 _display_type: DisplayType | None = None
@@ -28,6 +29,11 @@ def init_display_type(display: str | None = None) -> DisplayType:
 
 
 def display_type() -> DisplayType:
+    """Get the current console display type.
+
+    Returns:
+       DisplayType: Display type.
+    """
     global _display_type
     if _display_type:
         return _display_type

inspect_ai/util/_panel.py

@@ -1,23 +1,46 @@
 from typing import Any, Protocol, TypeVar
 
 from textual.containers import Container
+from typing_extensions import Self
 
 
 class InputPanel(Container):
+    DEFAULT_TITLE = "Panel"
+
     DEFAULT_CLASSES = "task-input-panel"
 
+    DEFAULT_CSS = """
+    InputPanel {
+        padding: 0 1 1 1;
+    }
+    """
+
     class Host(Protocol):
         def set_title(self, title: str) -> None: ...
         def activate(self) -> None: ...
         def deactivate(self) -> None: ...
         def close(self) -> None: ...
 
-    def __init__(self, title: str, host: Host) -> None:
+    def __init__(self, host: Host) -> None:
+        """Initialise the panel.
+
+        Panels are created as required by the input_panel() function so
+        you should NOT override __init__ with your own initisation (rather,
+        you should define reactive props and/or methods that perform
+        initialisation).
+
+        You should also override the `DEFAULT_TITLE` variable for your panel to
+        provide a default tab title (you can change the table dynamically as
+        required using the `title` property).
+
+        Args:
+           host (InputPanel.Host): Interface to UI host of input panel.
+        """
         super().__init__()
-        self._title = title
+        self._title = self.DEFAULT_TITLE
         self._host = host
 
-    async def __aenter__(self) -> "InputPanel":
+    async def __aenter__(self) -> Self:
         self.activate()
         return self
 
@@ -50,10 +73,10 @@ class InputPanel(Container):
         pass
 
 
-TP = TypeVar("TP", bound=InputPanel)
+TP = TypeVar("TP", bound=InputPanel, covariant=True)
 
 
-async def input_panel(title: str, panel: type[TP]) -> TP:
+async def input_panel(panel: type[TP]) -> TP:
     """Create an input panel in the task display.
 
     There can only be a single instance of an InputPanel with a given
@@ -65,19 +88,18 @@ async def input_panel(title: str, panel: type[TP]) -> TP:
         the scope exits -- see below for open/close semantics)
 
         ```python
-        panel = await input_panel("Custom", CustomPanel)
+        panel = await input_panel(CustomPanel)
         panel.activate()
         ```
 
         Activate and close an input panel using a context manager:
 
         ```python
-        async with await input_panel("Custom", CustomPanel) as panel:
+        async with await input_panel(CustomPanel) as panel:
             ...
         ```
 
     Args:
-       title (str): Input panel title.
        panel (type[TP]): Type of panel widget (must derive from `InputPanel`)
 
     Returns:
@@ -88,4 +110,4 @@ async def input_panel(title: str, panel: type[TP]) -> TP:
     """
     from inspect_ai._display.core.active import task_screen
 
-    return await task_screen().input_panel(title, panel)
+    return await task_screen().input_panel(panel)

inspect_ai/util/_sandbox/__init__.py

@@ -13,7 +13,6 @@ from .environment import (
 from .limits import OutputLimitExceededError, SandboxEnvironmentLimits
 from .local import LocalSandboxEnvironment  # noqa: F401
 from .registry import sandboxenv
-from .service import SandboxService, sandbox_service
 
 __all__ = [
     "OutputLimitExceededError",
@@ -27,6 +26,4 @@ __all__ = [
     "sandboxenv",
     "sandbox",
     "sandbox_with",
-    "SandboxService",
-    "sandbox_service",
 ]

inspect_ai/util/_sandbox/context.py

@@ -24,6 +24,10 @@ def sandbox(name: str | None = None) -> SandboxEnvironment:
 
     Return:
       SandboxEnvironment instance.
+
+    Raises:
+      ProcessLookupError: If there are no sandboxes available.
+      ValueError: If an invalid sandbox name is specified.
     """
     # verify we have a context
     environments = sandbox_environments_context_var.get(None)
@@ -102,7 +106,7 @@ async def sandbox_connections() -> dict[str, SandboxConnection]:
 
 
 def raise_no_sandbox() -> NoReturn:
-    raise RuntimeError(
+    raise ProcessLookupError(
         "No sandbox environment has been provided for the current sample or task. "
         + "Please specify a sandbox for the sample or a global default sandbox for the task"
     )

inspect_ai/util/_sandbox/docker/compose.py

@@ -8,8 +8,8 @@ from typing import Any, Literal, TypedDict, cast
 import yaml
 from pydantic import BaseModel
 
-from inspect_ai._util.display import display_type
 from inspect_ai._util.error import PrerequisiteError
+from inspect_ai.util._display import display_type
 from inspect_ai.util._subprocess import ExecResult, subprocess
 
 from .prereqs import (
@@ -29,6 +29,8 @@ async def compose_up(project: ComposeProject) -> None:
     result = 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,
     )
     if not result.success:
         msg = (
@@ -80,7 +82,11 @@ async def compose_cp(
     output_limit: int | None = None,
 ) -> None:
     result = await compose_command(
-        ["cp", "--", src, dest], project=project, cwd=cwd, output_limit=output_limit
+        ["cp", "--", src, dest],
+        project=project,
+        timeout=120,  # 2-minute timeout for file copies
+        cwd=cwd,
+        output_limit=output_limit,
     )
     if not result.success:
         msg = f"Failed to copy file from '{src}' to '{dest}': {result.stderr}"
@@ -118,7 +124,7 @@ async def compose_ps(
         command.append("--all")
     if status:
         command = command + ["--status", status]
-    result = await compose_command(command, project=project)
+    result = await compose_command(command, project=project, timeout=60)
     if not result.success:
         msg = f"Error querying for running services: {result.stderr}"
         raise RuntimeError(msg)
@@ -136,6 +142,7 @@ async def compose_build(project: ComposeProject, capture_output: bool = False) -
     result = await compose_command(
         ["build"],
         project=project,
+        timeout=None,  # no timeout for build
         capture_output=capture_output,
     )
     if not result.success:
@@ -151,6 +158,7 @@ async def compose_pull(
     return await compose_command(
         ["pull", "--ignore-buildable", "--policy", "missing", service],
         project=project,
+        timeout=None,  # no timeout for pull
         capture_output=capture_output,
     )
 
@@ -185,7 +193,7 @@ ComposeService = TypedDict(
 
 
 async def compose_services(project: ComposeProject) -> dict[str, ComposeService]:
-    result = await compose_command(["config"], project=project)
+    result = await compose_command(["config"], project=project, timeout=60)
     if not result.success:
         raise RuntimeError(f"Error reading docker config: {result.stderr}")
     return cast(dict[str, ComposeService], yaml.safe_load(result.stdout)["services"])
@@ -209,12 +217,13 @@ async def compose_ls() -> list[Project]:
 
 async def compose_cleanup_images(
     project: ComposeProject,
+    *,
     cwd: str | None = None,
-    timeout: int | None = None,
+    timeout: int | None,
 ) -> None:
     # List the images that would be created for this compose
     images_result = await compose_command(
-        ["config", "--images"], project=project, cwd=cwd
+        ["config", "--images"], project=project, timeout=timeout, cwd=cwd
     )
 
     # Remove those images explicitly
@@ -246,14 +255,11 @@ async def compose_cleanup_images(
                         logger.warning(msg)
 
 
-DEFAULT_COMPOSE_TIMEOUT = 60
-
-
 async def compose_command(
     command: list[str],
     *,
     project: ComposeProject,
-    timeout: int | None = DEFAULT_COMPOSE_TIMEOUT,
+    timeout: int | None,
     input: str | bytes | None = None,
     cwd: str | Path | None = None,
     forward_env: bool = True,

inspect_ai/util/_sandbox/docker/docker.py

@@ -78,7 +78,7 @@ class DockerSandboxEnvironment(SandboxEnvironment):
             await compose_build(project)
 
             # cleanup images created during build
-            await compose_cleanup_images(project)
+            await compose_cleanup_images(project, timeout=60)
 
             services = await compose_services(project)
             for name, service in services.items():
@@ -326,6 +326,7 @@ class DockerSandboxEnvironment(SandboxEnvironment):
                 container_tmpfile,
             ],
             project=self._project,
+            timeout=60,
         )
 
         parent = PurePosixPath(file).parent
@@ -405,7 +406,7 @@ class DockerSandboxEnvironment(SandboxEnvironment):
 
             # read and return w/ appropriate encoding
             if text:
-                with open(dest_file, "r", encoding="utf-8") as f:
+                with open(dest_file, "r", newline="", encoding="utf-8") as f:
                     return f.read()
             else:
                 with open(dest_file, "rb") as f:
@@ -424,13 +425,15 @@ class DockerSandboxEnvironment(SandboxEnvironment):
             None,
         )
 
-        # return container login
+        # return container connection
         if container:
             return SandboxConnection(
-                command=f"docker exec -it {container} /bin/bash --login",
-                container=container,
+                command=f"docker exec -it {container} bash -l",
+                vscode_command=[
+                    "remote-containers.attachToRunningContainer",
+                    container,
+                ],
             )
-
         # error (not currently running)
         else:
             raise ConnectionError(

inspect_ai/util/_sandbox/docker/internal.py

@@ -1,6 +1,6 @@
 from inspect_ai._util.constants import PKG_PATH
-from inspect_ai._util.display import display_type
 from inspect_ai._util.error import PrerequisiteError
+from inspect_ai.util._display import display_type
 from inspect_ai.util._subprocess import subprocess
 
 INSPECT_WEB_BROWSER_IMAGE_DOCKERHUB = "aisiuk/inspect-web-browser-tool"

inspect_ai/util/_sandbox/docker/util.py

@@ -84,10 +84,10 @@ def task_project_name(task: str) -> str:
     if len(task) == 0:
         task = "task"
 
-    return f"inspect-{task}-i{uuid().lower()}"
+    return f"inspect-{task[:12]}-i{uuid().lower()[:6]}"
 
 
-inspect_project_pattern = r"^inspect-[a-z\d\-_]*-i[a-z\d]{22}$"
+inspect_project_pattern = r"^inspect-[a-z\d\-_]*-i[a-z\d]{6,}$"
 
 
 def is_inspect_project(name: str) -> bool:

inspect_ai/util/_sandbox/environment.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import abc
 from dataclasses import dataclass, field
-from typing import Awaitable, Callable, Literal, NamedTuple, Union, overload
+from typing import Any, Awaitable, Callable, Literal, NamedTuple, Union, overload
 
 from pydantic import BaseModel, Field
 
@@ -34,12 +34,9 @@ class SandboxConnection(BaseModel):
     command: str
     """Shell command to connect to sandbox."""
 
-    vscode_command: list[str] | None = Field(default=None)
+    vscode_command: list[Any] | None = Field(default=None)
     """Optional vscode command (+args) to connect to sandbox."""
 
-    container: str | None = Field(default=None)
-    """Optional container name (will not apply to all sandboxes)."""
-
 
 class SandboxEnvironment(abc.ABC):
     """Environment for executing arbitrary code from tools.
@@ -205,6 +202,10 @@ class SandboxEnvironment(abc.ABC):
 
         File size is limited to 100 MiB.
 
+        When reading text files, implementations should preserve newline constructs
+        (e.g. crlf should be preserved not converted to lf). This is equivalent
+        to specifying `newline=""` in a call to the Python `open()` function.
+
         Args:
           file (str): Path to file (relative file paths will resolve to the
             per-sample working directory).

inspect_ai/util/_sandbox/local.py

@@ -101,7 +101,7 @@ class LocalSandboxEnvironment(SandboxEnvironment):
         file = self._resolve_file(file)
         verify_read_file_size(file)
         if text:
-            with open(file, "r", encoding="utf-8") as f:
+            with open(file, "r", newline="", encoding="utf-8") as f:
                 return f.read()
         else:
             with open(file, "rb") as f:

inspect_ai/util/_sandbox/service.py

@@ -1,5 +1,6 @@
 import asyncio
 import json
+from logging import getLogger
 from pathlib import PurePosixPath
 from textwrap import dedent
 from typing import (
@@ -14,9 +15,12 @@ from inspect_ai.util._subprocess import ExecResult
 
 from .environment import SandboxEnvironment
 
+logger = getLogger(__name__)
+
+
 REQUESTS_DIR = "requests"
 RESPONSES_DIR = "responses"
-SERVICES_DIR = "/tmp/inspect-sandbox-services"
+SERVICES_DIR = "/var/tmp/sandbox-services"
 
 ID = "id"
 METHOD = "method"
@@ -70,7 +74,7 @@ class SandboxService:
 
     ```python
     import sys
-    sys.path.append("/tmp/inspect-sandbox-services/foo")
+    sys.path.append("/var/tmp/sandbox-services/foo")
     import foo
     ```
 
@@ -79,7 +83,7 @@ class SandboxService:
     ```python
     import importlib.util
     spec = importlib.util.spec_from_file_location(
-        "foo", "/tmp/inspect-sandbox-services/foo/foo.py"
+        "foo", "/var/tmp/sandbox-services/foo/foo.py"
     )
     foo = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(foo)
@@ -150,8 +154,14 @@ class SandboxService:
                 f"Error reading request for service {self._name}: '{read_request}' ({result.stderr})"
             )
 
-        # parse request
-        request_data = json.loads(result.stdout)
+        # parse request (decode error could occur if its incomplete so bypass this)
+        try:
+            request_data = json.loads(result.stdout)
+        except json.JSONDecodeError:
+            logger.warning(
+                f"JSON decoding error reading service request: {result.stdout}"
+            )
+            return None
         if not isinstance(request_data, dict):
             raise TypeError(f"Service request is not a dict (type={request_data})")
 
@@ -275,7 +285,7 @@ class SandboxService:
             return request_id
 
         def _read_{self._name}_response(request_id: str) -> tuple[bool, Any]:
-            from json import load
+            from json import JSONDecodeError, load
             from pathlib import Path
 
             responses_dir = Path("{SERVICES_DIR}", "{self._name}", "{RESPONSES_DIR}")
@@ -283,7 +293,12 @@ class SandboxService:
             if response_path.exists():
                 # read and remove the file
                 with open(response_path, "r") as f:
-                    response = load(f)
+                    # it's possible the file is still being written so
+                    # just catch and wait for another retry if this occurs
+                    try:
+                        response = load(f)
+                    except JSONDecodeError:
+                        return False, None
                 response_path.unlink()
 
                 # raise error if we have one

inspect_ai/util/_store.py

@@ -38,14 +38,10 @@ class Store:
         self._data: dict[str, Any] = {}
 
     @overload
-    def get(self, key: str, default: None = None) -> Any:
-        return self._data.get(key, default)
+    def get(self, key: str, default: None = None) -> Any: ...
 
     @overload
-    def get(self, key: str, default: VT) -> VT:
-        if key not in self._data.keys():
-            self._data[key] = default
-        return cast(VT, self._data.get(key, default))
+    def get(self, key: str, default: VT) -> VT: ...
 
     def get(self, key: str, default: VT | None = None) -> VT | Any:
         """Get a value from the store.
@@ -60,6 +56,9 @@ class Store:
         Returns:
            Value if is exists, otherwise default.
         """
+        if default is not None:
+            if key not in self._data.keys():
+                self._data[key] = default
         return cast(VT, self._data.get(key, default))
 
     def set(self, key: str, value: Any) -> None: