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

inspect_ai/_util/timeouts.py

@@ -1,160 +0,0 @@
-# based on: https://github.com/python/cpython/commits/main/Lib/asyncio/timeouts.py
-# (vendored for compatibility with Python 3.1)
-
-import enum
-from asyncio import events, exceptions, tasks
-from contextlib import _AsyncGeneratorContextManager
-from types import TracebackType
-from typing import Any, Optional, Type, final
-
-__all__ = (
-    "Timeout",
-    "timeout",
-    "timeout_at",
-)
-
-
-class _State(enum.Enum):
-    CREATED = "created"
-    ENTERED = "active"
-    EXPIRING = "expiring"
-    EXPIRED = "expired"
-    EXITED = "finished"
-
-
-@final
-class Timeout(_AsyncGeneratorContextManager["Timeout"]):
-    """Asynchronous context manager for cancelling overdue coroutines.
-
-    Use `timeout()` or `timeout_at()` rather than instantiating this class directly.
-    """
-
-    def __init__(self, when: Optional[float]) -> None:
-        """Schedule a timeout that will trigger at a given loop time.
-
-        - If `when` is `None`, the timeout will never trigger.
-        - If `when < loop.time()`, the timeout will trigger on the next
-          iteration of the event loop.
-        """
-        self._state = _State.CREATED
-
-        self._timeout_handler: Optional[events.Handle] = None
-        self._task: Optional[tasks.Task[Any]] = None
-        self._when = when
-
-    def when(self) -> Optional[float]:
-        """Return the current deadline."""
-        return self._when
-
-    def reschedule(self, when: Optional[float]) -> None:
-        """Reschedule the timeout."""
-        assert self._state is not _State.CREATED
-        if self._state is not _State.ENTERED:
-            raise RuntimeError(
-                f"Cannot change state of {self._state.value} Timeout",
-            )
-
-        self._when = when
-
-        if self._timeout_handler is not None:
-            self._timeout_handler.cancel()
-
-        if when is None:
-            self._timeout_handler = None
-        else:
-            loop = events.get_running_loop()
-            if when <= loop.time():
-                self._timeout_handler = loop.call_soon(self._on_timeout)
-            else:
-                self._timeout_handler = loop.call_at(when, self._on_timeout)
-
-    def expired(self) -> bool:
-        """Is timeout expired during execution?"""
-        return self._state in (_State.EXPIRING, _State.EXPIRED)
-
-    def __repr__(self) -> str:
-        info = [""]
-        if self._state is _State.ENTERED:
-            when = round(self._when, 3) if self._when is not None else None
-            info.append(f"when={when}")
-        info_str = " ".join(info)
-        return f"<Timeout [{self._state.value}]{info_str}>"
-
-    async def __aenter__(self) -> "Timeout":
-        self._state = _State.ENTERED
-        self._task = tasks.current_task()
-        if self._task is None:
-            raise RuntimeError("Timeout should be used inside a task")
-        self.reschedule(self._when)
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
-        assert self._state in (_State.ENTERED, _State.EXPIRING)
-
-        if self._timeout_handler is not None:
-            self._timeout_handler.cancel()
-            self._timeout_handler = None
-
-        if self._state is _State.EXPIRING:
-            self._state = _State.EXPIRED
-            if exc_type and issubclass(exc_type, exceptions.CancelledError):
-                raise TimeoutError from exc_val
-        elif self._state is _State.ENTERED:
-            self._state = _State.EXITED
-
-        return None
-
-    def _on_timeout(self) -> None:
-        assert self._state is _State.ENTERED
-        if self._task:
-            self._task.cancel()
-        self._state = _State.EXPIRING
-        # drop the reference early
-        self._timeout_handler = None
-
-
-def timeout(delay: Optional[float]) -> Timeout:
-    """Timeout async context manager.
-
-    Useful in cases when you want to apply timeout logic around block
-    of code or in cases when asyncio.wait_for is not suitable. For example:
-
-    >>> async with asyncio.timeout(10):  # 10 seconds timeout
-    ...     await long_running_task()
-
-
-    delay - value in seconds or None to disable timeout logic
-
-    long_running_task() is interrupted by raising asyncio.CancelledError,
-    the top-most affected timeout() context manager converts CancelledError
-    into TimeoutError.
-    """
-    loop = events.get_running_loop()
-    return Timeout(loop.time() + delay if delay is not None else None)
-
-
-def timeout_at(when: Optional[float]) -> Timeout:
-    """Schedule the timeout at absolute time.
-
-    Like timeout() but argument gives absolute time in the same clock system
-    as loop.time().
-
-    Please note: it is not POSIX time but a time with
-    undefined starting base, e.g. the time of the system power on.
-
-    >>> async with asyncio.timeout_at(loop.time() + 10):
-    ...     await long_running_task()
-
-
-    when - a deadline when timeout occurs or None to disable timeout logic
-
-    long_running_task() is interrupted by raising asyncio.CancelledError,
-    the top-most affected timeout() context manager converts CancelledError
-    into TimeoutError.
-    """
-    return Timeout(when)

inspect_ai/model/_providers/util/tracker.py

@@ -1,92 +0,0 @@
-import re
-import time
-from typing import Any, cast
-
-import httpx
-from shortuuid import uuid
-
-
-class HttpTimeTracker:
-    def __init__(self) -> None:
-        # track request start times
-        self._requests: dict[str, float] = {}
-
-    def start_request(self) -> str:
-        request_id = uuid()
-        self._requests[request_id] = time.monotonic()
-        return request_id
-
-    def end_request(self, request_id: str) -> float:
-        # read the request time if (if available) and purge from dict
-        request_time = self._requests.pop(request_id, None)
-        if request_time is None:
-            raise RuntimeError(f"request_id not registered: {request_id}")
-
-        # return elapsed time
-        return time.monotonic() - request_time
-
-    def update_request_time(self, request_id: str) -> None:
-        request_time = self._requests.get(request_id, None)
-        if not request_time:
-            raise RuntimeError(f"No request registered for request_id: {request_id}")
-
-        # update the request time
-        self._requests[request_id] = time.monotonic()
-
-
-class BotoTimeTracker(HttpTimeTracker):
-    def __init__(self, session: Any) -> None:
-        from aiobotocore.session import AioSession
-
-        super().__init__()
-
-        # register hook
-        session = cast(AioSession, session._session)
-        session.register(
-            "before-send.bedrock-runtime.Converse", self.converse_before_send
-        )
-
-    def converse_before_send(self, **kwargs: Any) -> None:
-        user_agent = kwargs["request"].headers["User-Agent"].decode()
-        match = re.search(rf"{self.USER_AGENT_PREFIX}(\w+)", user_agent)
-        if match:
-            request_id = match.group(1)
-            self.update_request_time(request_id)
-
-    def user_agent_extra(self, request_id: str) -> str:
-        return f"{self.USER_AGENT_PREFIX}{request_id}"
-
-    USER_AGENT_PREFIX = "ins/rid#"
-
-
-class HttpxTimeTracker(HttpTimeTracker):
-    """Class which tracks the duration of successful (200 status) http requests.
-
-    A special header is injected into requests which is then read from
-    an httpx 'request' event hook -- this creates a record of when the request
-    started. Note that with retries a single request id could be started
-    several times; our request hook makes sure we always track the time of
-    the last request.
-
-    To determine the total time, we also install an httpx response hook. In
-    this hook we look for 200 responses which have a registered request id.
-    When we find one, we update the end time of the request.
-
-    There is an 'end_request()' method which gets the total requeset time
-    for a request_id and then purges the request_id from our tracking (so
-    the dict doesn't grow unbounded)
-    """
-
-    REQUEST_ID_HEADER = "x-irid"
-
-    def __init__(self, client: httpx.AsyncClient):
-        super().__init__()
-
-        # install httpx request hook
-        client.event_hooks["request"].append(self.request_hook)
-
-    async def request_hook(self, request: httpx.Request) -> None:
-        # update the last request time for this request id (as there could be retries)
-        request_id = request.headers.get(self.REQUEST_ID_HEADER, None)
-        if request_id:
-            self.update_request_time(request_id)

inspect_ai/tool/_tools/_computer/_computer_split.py

@@ -1,198 +0,0 @@
-"""
-This module provides the same functionality as the computer tool but via a list of per-action tools . e.g. computer_mouse_move(100, 100).
-
-The split version is not publicly exported, but is retained until we decide if it performs better than the monolithic computer tool.
-"""
-
-from typing import Awaitable, Callable
-
-from inspect_ai.tool import Tool, ToolResult, tool
-
-from . import _common as common
-
-ActionFunction = Callable[[str], ToolResult | Awaitable[ToolResult]]
-
-
-def computer_split(timeout: int | None = None) -> list[Tool]:
-    """
-    Computer interaction tools.
-
-    Args:
-      timeout (int | None): Timeout (in seconds) for command.
-
-    Returns:
-       List of computer interaction tools.
-    """
-    return [
-        computer_cursor_position(),
-        computer_screenshot(),
-        computer_mouse_move(),
-        computer_left_click(),
-        computer_double_click(),
-        computer_left_click_drag(),
-        computer_right_click(),
-        computer_key(),
-        computer_type(),
-    ]
-
-
-@tool()
-def computer_cursor_position(timeout: int | None = None) -> Tool:
-    async def execute() -> ToolResult:
-        """
-        Get the current (x, y) pixel coordinate of the cursor on the screen.
-
-        Args:
-          None
-
-        Returns:
-          A `str` of the form "x y" where x and y are the current mouse coordinates.
-        """
-        return await common.cursor_position(timeout=timeout)
-
-    return execute
-
-
-@tool()
-def computer_screenshot(timeout: int | None = None) -> Tool:
-    async def execute() -> ToolResult:
-        """
-        Take a screenshot.
-
-        Args:
-          None
-
-        Returns:
-          A `list` with a single `ContentImage` of the screen.
-        """
-        return await common.screenshot(timeout=timeout)
-
-    return execute
-
-
-@tool()
-def computer_mouse_move(timeout: int | None = None) -> Tool:
-    async def execute(x: int, y: int) -> ToolResult:
-        """
-        Move the cursor to a specified (x, y) pixel coordinate on the screen.
-
-        Args:
-          x: X coordinate of the mouse destination.
-          y: Y coordinate of the mouse destination.
-
-        Returns:
-          A `list` with a single `ContentImage` of the screen.
-        """
-        return await common.mouse_move(x, y, timeout=timeout)
-
-    return execute
-
-
-@tool()
-def computer_left_click(timeout: int | None = None) -> Tool:
-    async def execute() -> ToolResult:
-        """
-        Click the left mouse button.
-
-        Args:
-          None
-
-        Returns:
-          A `list` with a single `ContentImage` of the screen.
-        """
-        return await common.left_click(timeout=timeout)
-
-    return execute
-
-
-@tool()
-def computer_double_click(timeout: int | None = None) -> Tool:
-    async def execute() -> ToolResult:
-        """
-        Double-click the left mouse button.
-
-        Args:
-          None
-
-        Returns:
-          A `list` with a single `ContentImage` of the screen.
-        """
-        return await common.double_click(timeout=timeout)
-
-    return execute
-
-
-@tool()
-def computer_left_click_drag(timeout: int | None = None) -> Tool:
-    async def execute(x: int, y: int) -> ToolResult:
-        """
-        Click and drag the cursor to a specified (x, y) pixel coordinate on the screen.
-
-        Args:
-          x: X coordinate of the mouse destination.
-          y: Y coordinate of the mouse destination.
-
-        Returns:
-          A `list` with a single `ContentImage` of the screen.
-        """
-        return await common.left_click_drag(x, y, timeout=timeout)
-
-    return execute
-
-
-@tool()
-def computer_right_click(timeout: int | None = None) -> Tool:
-    async def execute() -> ToolResult:
-        """
-        Click the right mouse button.
-
-        Args:
-          None
-
-        Returns:
-          A `list` with a single `ContentImage` of the screen.
-        """
-        return await common.right_click(timeout=timeout)
-
-    return execute
-
-
-# keysm list is from https://gist.github.com/rvaiya/be31f42049a4b5ad46666a8e120d9843
-@tool()
-def computer_key(timeout: int | None = None) -> Tool:
-    async def execute(key: str) -> ToolResult:
-        """
-        Press a key or key-combination on the keyboard.
-
-        Args:
-          key: The key or key-combination to press. Can be any key name supported by xdotool's `key` such as:
-            "Return", "Escape", "alt+Tab", "BackSpace", "Tab", "alt+Tab", "ctrl+s", "Up", "KP_0" (for the numpad 0 key),
-            "Insert", "Delete", "Home", "End", "Prior", "Next", "Left", "Up", "Right", "Down",
-            "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12",
-            "Shift_L", "Shift_R", "Control_L", "Control_R", "Alt_L", "Alt_R", "Scroll_Lock", "Num_Lock", "Caps_Lock", "Pause",
-            "KP_Multiply", "KP_Home", "KP_Up", "KP_Prior", "KP_Subtract", "KP_Left", "KP_Begin", "KP_Right", "KP_Add", "KP_End","KP_Down",
-            "KP_Next", "KP_Insert", "KP_Delete", "KP_Enter", "KP_Divide", "KP_Equal", "KP_Decimal"
-
-        Returns:
-          A `list` with a single `ContentImage` of the screen.
-        """
-        return await common.press_key(key, timeout=timeout)
-
-    return execute
-
-
-@tool()
-def computer_type(timeout: int | None = None) -> Tool:
-    async def execute(text: str) -> ToolResult:
-        """
-        Type a string of text on the keyboard.
-
-        Args:
-          text: The text to type. If the text contains spaces, enclose it in quotes.
-
-        Returns:
-          A `list` with a single `ContentImage` of the screen.
-        """
-        return await common.type(text, timeout=timeout)
-
-    return execute