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

{inspect_ai-0.3.70.dist-info → inspect_ai-0.3.72.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (75.8.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

inspect_ai/_view/www/src/components/VirtualList.module.css

@@ -1,19 +0,0 @@
-.container {
-  position: relative;
-  width: 100%;
-  min-height: 100%;
-  overflow: visible;
-}
-
-.container.hidden {
-  overflow: hidden;
-}
-
-.content {
-  position: absolute;
-  top: 0;
-  left: 0;
-  height: 100%;
-  width: 100%;
-  overflow: visible;
-}

inspect_ai/_view/www/src/components/VirtualList.tsx

@@ -1,292 +0,0 @@
-import clsx from "clsx";
-import React, {
-  forwardRef,
-  useEffect,
-  useImperativeHandle,
-  useMemo,
-  useRef,
-  useState,
-} from "react";
-import styles from "./VirtualList.module.css";
-
-export interface VirtualListRef {
-  focus: () => void;
-  scrollToIndex: (index: number, direction?: "up" | "down") => void;
-}
-
-interface VirtualListProps<T> {
-  data: T[];
-  renderRow: (item: T, index: number) => React.ReactNode;
-  overscanCount?: number;
-  initialEstimatedRowHeight?: number;
-  sync?: boolean;
-  scrollRef?: React.RefObject<HTMLElement | null>;
-  className?: string;
-  style?: React.CSSProperties;
-  tabIndex?: number;
-  onKeyDown?: (event: React.KeyboardEvent<HTMLDivElement>) => void;
-}
-
-interface ListMetrics {
-  rowHeights: Map<number, number>;
-  totalHeight: number;
-  estimatedRowHeight: number;
-}
-
-export const VirtualList = forwardRef(function VirtualList<T>(
-  {
-    data,
-    renderRow,
-    overscanCount = 15,
-    initialEstimatedRowHeight = 50,
-    sync = false,
-    scrollRef,
-    onKeyDown,
-    ...props
-  }: VirtualListProps<T>,
-  ref: React.Ref<VirtualListRef>,
-) {
-  const [height, setHeight] = useState(0);
-  const [offset, setOffset] = useState(0);
-  const [listMetrics, setListMetrics] = useState<ListMetrics>({
-    rowHeights: new Map(),
-    totalHeight: data.length * initialEstimatedRowHeight,
-    estimatedRowHeight: initialEstimatedRowHeight,
-  });
-
-  const baseRef = useRef<HTMLDivElement>(null);
-  const containerRef = useRef<HTMLDivElement>(null);
-  const rowRefs = useRef<Map<number, HTMLElement>>(new Map());
-
-  const getRowHeight = (index: number): number => {
-    return listMetrics.rowHeights.get(index) || listMetrics.estimatedRowHeight;
-  };
-
-  // Calculate new estimated height based on measured rows
-  const calculateEstimatedHeight = (heights: Map<number, number>): number => {
-    if (heights.size === 0) return listMetrics.estimatedRowHeight;
-
-    // Calculate average of measured heights
-    let sum = 0;
-    heights.forEach((height) => {
-      sum += height;
-    });
-
-    // Use exponential moving average to smooth transitions
-    const alpha = 0.2; // Smoothing factor
-    const newEstimate = sum / heights.size;
-    return Math.round(
-      alpha * newEstimate + (1 - alpha) * listMetrics.estimatedRowHeight,
-    );
-  };
-
-  const rowPositions = useMemo(() => {
-    let currentPosition = 0;
-    const positions = new Map<number, number>();
-
-    for (let i = 0; i < data.length; i++) {
-      positions.set(i, currentPosition);
-      currentPosition += getRowHeight(i);
-    }
-
-    return positions;
-  }, [listMetrics.rowHeights, listMetrics.estimatedRowHeight, data.length]);
-
-  // Measure rendered rows and update heights if needed
-  const measureRows = () => {
-    let updates: [number, number][] = [];
-
-    rowRefs.current.forEach((element, index) => {
-      if (element) {
-        const measuredHeight = element.offsetHeight;
-        if (
-          measuredHeight &&
-          measuredHeight !== listMetrics.rowHeights.get(index)
-        ) {
-          updates.push([index, measuredHeight]);
-        }
-      }
-    });
-
-    if (updates.length === 0) return;
-
-    const newHeights = new Map(listMetrics.rowHeights);
-    updates.forEach(([index, height]) => {
-      newHeights.set(index, height);
-    });
-
-    // Calculate new estimated height
-    const newEstimatedHeight = calculateEstimatedHeight(newHeights);
-
-    let newTotalHeight = 0;
-    for (let i = 0; i < data.length; i++) {
-      newTotalHeight += newHeights.get(i) || newEstimatedHeight;
-    }
-
-    setListMetrics({
-      rowHeights: newHeights,
-      totalHeight: newTotalHeight,
-      estimatedRowHeight: newEstimatedHeight,
-    });
-  };
-
-  useImperativeHandle(
-    ref,
-    () => ({
-      focus: () => {
-        baseRef.current?.focus();
-      },
-      scrollToIndex: (index: number, direction?: "up" | "down") => {
-        const scrollElement = scrollRef?.current || baseRef.current;
-        if (!scrollElement || index < 0 || index >= data.length) return;
-
-        const currentScrollTop = scrollElement.scrollTop;
-        const viewportHeight = scrollElement.offsetHeight;
-
-        const rowTop = rowPositions.get(index) || 0;
-        const rowHeight = getRowHeight(index);
-        const rowBottom = rowTop + rowHeight;
-
-        const isVisible =
-          rowTop >= currentScrollTop &&
-          rowBottom <= currentScrollTop + viewportHeight;
-        if (isVisible) return;
-
-        let newScrollTop: number;
-        if (direction === "up") {
-          newScrollTop = rowTop;
-        } else {
-          newScrollTop = rowBottom - viewportHeight;
-        }
-
-        newScrollTop = Math.max(
-          0,
-          Math.min(newScrollTop, listMetrics.totalHeight - viewportHeight),
-        );
-        scrollElement.scrollTop = newScrollTop;
-      },
-    }),
-    [rowPositions, data.length],
-  );
-
-  const resize = () => {
-    const scrollElement = scrollRef?.current || baseRef.current;
-    if (scrollElement && height !== scrollElement.offsetHeight) {
-      setHeight(scrollElement.offsetHeight);
-    }
-  };
-
-  const handleScroll = throttle(() => {
-    const scrollElement = scrollRef?.current || baseRef.current;
-    if (scrollElement) {
-      setOffset(scrollElement.scrollTop);
-    }
-    if (sync) {
-      setOffset((prev) => prev);
-    }
-  }, 100);
-
-  useEffect(() => {
-    resize();
-    const scrollElement = scrollRef?.current || baseRef.current;
-
-    if (scrollElement) {
-      scrollElement.addEventListener("scroll", handleScroll);
-      window.addEventListener("resize", resize);
-
-      return () => {
-        scrollElement.removeEventListener("scroll", handleScroll);
-        window.removeEventListener("resize", resize);
-      };
-    }
-  }, [scrollRef?.current]);
-
-  useEffect(() => {
-    measureRows();
-  });
-
-  const findRowAtOffset = (targetOffset: number): number => {
-    if (targetOffset <= 0) return 0;
-    if (targetOffset >= listMetrics.totalHeight) return data.length - 1;
-
-    let low = 0;
-    let high = data.length - 1;
-    let lastValid = 0;
-
-    while (low <= high) {
-      const mid = Math.floor((low + high) / 2);
-      const rowStart = rowPositions.get(mid) || 0;
-
-      if (rowStart <= targetOffset) {
-        lastValid = mid;
-        low = mid + 1;
-      } else {
-        high = mid - 1;
-      }
-    }
-    return lastValid;
-  };
-
-  const firstVisibleIdx = findRowAtOffset(offset);
-  const lastVisibleIdx = findRowAtOffset(offset + height);
-
-  const start = Math.max(0, firstVisibleIdx - overscanCount);
-  const end = Math.min(data.length, lastVisibleIdx + overscanCount);
-
-  const renderedRows = useMemo(() => {
-    const selection = data.slice(start, end);
-    return selection.map((item, index) => {
-      const actualIndex = start + index;
-      return (
-        <div
-          key={`list-item-${actualIndex}`}
-          ref={(el) => {
-            if (el) {
-              rowRefs.current.set(actualIndex, el);
-            } else {
-              rowRefs.current.delete(actualIndex);
-            }
-          }}
-        >
-          {renderRow(item, actualIndex)}
-        </div>
-      );
-    });
-  }, [data, start, end, renderRow]);
-
-  const top = rowPositions.get(start) || 0;
-  const scrollProps = scrollRef ? {} : { onScroll: handleScroll };
-
-  return (
-    <div ref={baseRef} {...props} {...scrollProps} onKeyDown={onKeyDown}>
-      <div
-        className={clsx(
-          styles.container,
-          !scrollRef?.current ? styles.hidden : undefined,
-        )}
-        style={{ height: `${listMetrics.totalHeight}px` }}
-      >
-        <div
-          className={styles.content}
-          style={{ transform: `translateY(${top}px)` }}
-          ref={containerRef}
-        >
-          {renderedRows}
-        </div>
-      </div>
-    </div>
-  );
-}) as <T>(
-  props: VirtualListProps<T> & { ref?: React.Ref<VirtualListRef> },
-) => React.ReactElement;
-
-const throttle = (func: (...args: any[]) => void, limit: number) => {
-  let inThrottle: boolean;
-  return function (this: any, ...args: any[]) {
-    if (!inThrottle) {
-      func.apply(this, args);
-      inThrottle = true;
-      setTimeout(() => (inThrottle = false), limit);
-    }
-  };
-};

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