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

{inspect_ai-0.3.69.dist-info → inspect_ai-0.3.71.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/_web_browser/_resources/accessibility_node.py

@@ -1,312 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-# Properities to ignore when printing out the accessibility tree.
-_IGNORED_ACTREE_PROPERTIES = (
-    "focusable",
-    "readonly",
-    "level",
-    "settable",
-    "multiline",
-    "invalid",
-)
-
-_IGNORED_AT_ROLES = (
-    "generic",
-    "list",
-    "strong",
-    "paragraph",
-    "banner",
-    "navigation",
-    "Section",
-    "LabelText",
-    "Legend",
-    "listitem",
-)
-
-# Typically we use the bounding rect provided by the DOM in order to track
-# if an element is visible or not. However, sometimes it can be useful to
-# instead take the union of the elements bounds and all its children's bounds.
-# This process is a little slower, and is probably not needed, but can be
-# enabled using this flag.
-USE_UNION_BOUNDS = False
-
-# The maximum length of the description 'tag' for each element.
-# Tags longer than this will be truncated with an '...' appended.
-MAX_NODE_TEXT_LENGTH = 120
-
-# Used for debugging, include the elements bounding rect during output.
-_INCLUDE_BOUNDS_IN_OUTPUT = False
-
-
-class NodeBounds:
-    """Class to hold bounding rect for notes."""
-
-    def __init__(self, x: int, y: int, width: int, height: int):
-        self.x = int(x)
-        self.y = int(y)
-        self.width = int(width)
-        self.height = int(height)
-
-    @classmethod
-    def from_lrtb(cls, left: int, right: int, top: int, bottom: int) -> NodeBounds:
-        return cls(left, top, right - left, bottom - top)
-
-    @property
-    def left(self) -> int:
-        return self.x
-
-    @property
-    def top(self) -> int:
-        return self.y
-
-    @property
-    def right(self) -> int:
-        return self.x + self.width
-
-    @property
-    def bottom(self) -> int:
-        return self.y + self.height
-
-    @property
-    def center_x(self) -> int:
-        return self.x + self.width // 2
-
-    @property
-    def center_y(self) -> int:
-        return self.y + self.height // 2
-
-    @property
-    def area(self) -> int:
-        return self.width * self.height
-
-    def __str__(self):
-        return f"({self.left}, {self.top}, {self.width}, {self.height})"
-
-    def union(self, other: NodeBounds) -> NodeBounds:
-        """Return the (convex) union of two bounds."""
-        # Special cases when one or the other is an empty bound.
-        if self.area == 0:
-            return other
-        if other.area == 0:
-            return self
-
-        return self.from_lrtb(
-            min(self.left, other.left),
-            max(self.right, other.right),
-            min(self.top, other.top),
-            max(self.bottom, other.bottom),
-        )
-
-    def is_inside(self, x: int, y: int) -> bool:
-        """Returns if given point is inside the bounds or not."""
-        return x >= self.left and y >= self.top and x < self.right and y < self.bottom
-
-    def overlaps(self, other: NodeBounds) -> bool:
-        """Returns if the two bounds intersect."""
-        return (
-            other.left < self.right
-            and other.right > self.left
-            and other.top < self.bottom
-            and other.bottom > self.top
-        )
-
-
-class AccessibilityNode:
-    """A class for an accessibility node.
-
-    Accessibility properties are specified here:
-    https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#type-AXNode
-    """
-
-    def __init__(self, node: dict[str, Any], parent=None, bounds=None):
-        self._node = node
-        self._parent: AccessibilityNode | None = parent
-        self.bounds = bounds or NodeBounds(0, 0, 0, 0)
-
-    def __getitem__(self, key: str) -> Any:
-        """Access the underlying node fields."""
-        return self._node.get(key)
-
-    def __setitem__(self, key: str, value: Any):
-        """Set the underlying node fields."""
-        self._node[key] = value
-
-    def __str__(self):
-        if _INCLUDE_BOUNDS_IN_OUTPUT:
-            bounds_string = " " + str(
-                self.get_union_bounds() if USE_UNION_BOUNDS else self.bounds
-            )
-        else:
-            bounds_string = ""
-
-        node_input = self.current_input
-        if node_input:
-            input_string = f' Current input: "{node_input}"'
-        else:
-            input_string = ""
-
-        # Without bounds we can't click on the element, and therefore the ID
-        # can not be used. Still useful to show these elements though (e.g.)
-        # to let user know about options.
-        id_string = "*" if self.bounds.area == 0 else self.node_id
-
-        url_string = ""
-        if self.role == "image" and self._node.get("src", ""):
-            url_string = " " + self._node["src"]
-
-        return (
-            f'[{id_string}] {self.role} "{self.short_name}"'
-            + url_string
-            + input_string
-            + self.property_string()
-            + bounds_string
-        )
-
-    @property
-    def node_id(self) -> str:
-        return self._node["nodeId"]
-
-    @property
-    def value(self) -> str:
-        value_field = self._node.get("value", "{}")
-        if isinstance(value_field, dict):
-            return value_field.get("value", "")
-        else:
-            return ""
-
-    @property
-    def parent(self) -> Any | None:
-        """Returns the first visible parent."""
-        parent = self._parent
-        while parent and parent.is_ignored:
-            parent = parent._parent
-        return parent
-
-    @property
-    def role(self) -> str:
-        if "role" in self._node:
-            return self._node["role"].get("value", "")
-        else:
-            return ""
-
-    @property
-    def name(self) -> str:
-        if "name" in self._node:
-            return self._node["name"].get("value", "")
-        else:
-            return ""
-
-    @property
-    def short_name(self) -> str:
-        short_name = self.name[:MAX_NODE_TEXT_LENGTH]
-        if short_name != self.name:
-            short_name = short_name[: MAX_NODE_TEXT_LENGTH - 3] + "..."
-        return short_name
-
-    @property
-    def is_ignored(self) -> bool:
-        return (
-            self._node["ignored"]
-            or self.role in _IGNORED_AT_ROLES
-            or not self.is_visible
-            or (not self.name and self.role != "textbox")
-            or (self.parent and self.parent.name == self.name)
-        )
-
-    @property
-    def children(self) -> list[Any]:
-        return self._node.get("children", [])
-
-    @property
-    def is_visible(self) -> bool:
-        return self._node.get("is_visible", True)
-
-    def is_selected(self) -> bool:
-        return self._node.get("selected", False)
-
-    @property
-    def is_editable(self) -> bool:
-        for node_property in self.properties:
-            if node_property["name"] == "editable":
-                return True
-        return False
-
-    @property
-    def is_expanded(self) -> bool:
-        for node_property in self.properties:
-            if node_property["name"] == "expanded":
-                return bool(node_property["value"].get("value"))
-        return False
-
-    @property
-    def properties(self) -> list[Any]:
-        return self._node.get("properties", [])
-
-    @property
-    def dom_id(self) -> str:
-        """Returns the backend DOM id associated with this node."""
-        return self._node.get("backendDOMNodeId", -1)
-
-    @property
-    def current_input(self) -> str:
-        # For some reason text edit boxes get 'input' but comboboxs get 'values'
-        if self.role == "combobox":
-            value = self.value
-        else:
-            value = self.get_property("input")
-        return value
-
-    def get_union_bounds(self) -> list[int]:
-        """Returns the union of the bounds for this element all children."""
-        bounds = self.bounds
-        for child in self.children:
-            child_union_bounds = child.get_union_bounds()
-            bounds = bounds.union(child_union_bounds)
-        return bounds
-
-    def link_children(self, node_lookup: dict[str, Any]) -> None:
-        """Creates links to children nodes.
-
-        Nodes are referenced by id, but we want to add references to the
-        AccessibilityNode. We also want add a reference to the parent node.
-
-        To perform this task we need access to the complete list of nodes, and
-        therefore it must be done on a second pass after initializing the nodes.
-
-        Args:
-          node_lookup: A dictionary mapping from node_id to node instances.
-        """
-        self._node["children"] = []
-        for idx in self._node.get("childIds", []):
-            self._node["children"].append(node_lookup[idx])
-            node_lookup[idx]._parent = self
-
-    def get_property(self, property_name: str) -> Any:
-        """Query the property value of the underlying accessibility tree node."""
-        return self._node.get(property_name)
-
-    def to_string(self, indent: int = 0, include_children: bool = True) -> str:
-        """Returns the string representation of the node."""
-        result = ""
-        if not self.is_ignored:
-            result = "  " * indent + str(self) + "\n"
-            indent += 1
-        if include_children:
-            children_strings = [child.to_string(indent) for child in self.children]
-            result = result + "".join([s for s in children_strings if s])
-        return result
-
-    def property_string(self) -> str:
-        properties = []
-        for node_property in self.properties:
-            try:
-                if node_property["name"] in _IGNORED_ACTREE_PROPERTIES:
-                    continue
-                properties.append(
-                    f"{node_property['name']}: {node_property['value'].get('value')}"
-                )
-            except KeyError:
-                pass
-        return " [" + ", ".join(properties) + "]" if properties else ""