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

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

@@ -0,0 +1,292 @@
+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/_view/www/src/{index.js → index.tsx}

@@ -1,33 +1,59 @@
-import { render } from "preact";
-import { html } from "htm/preact";
-
-import { App } from "./App.mjs";
+import { createRoot } from "react-dom/client";
+import { App } from "./App";
 import api from "./api/index";
+import { ApplicationState, Capabilities } from "./types";
+import { throttle } from "./utils/sync";
 import { getVscodeApi } from "./utils/vscode";
-import { throttle } from "./utils/sync.mjs";
 
 // Read any state from the page itself
 const vscode = getVscodeApi();
 let initialState = undefined;
+let capabilities: Capabilities = {
+  downloadFiles: true,
+  webWorkers: true,
+};
 if (vscode) {
-  initialState = filterState(vscode.getState());
+  initialState = filterState(vscode.getState() as ApplicationState);
+
+  // Determine the capabilities
+  const extensionVersionEl = document.querySelector(
+    'meta[name="inspect-extension:version"]',
+  );
+  const extensionVersion = extensionVersionEl
+    ? extensionVersionEl.getAttribute("content")
+    : undefined;
+
+  if (!extensionVersion) {
+    capabilities = { downloadFiles: false, webWorkers: false };
+  }
+}
+
+const containerId = "app";
+const container = document.getElementById(containerId);
+if (!container) {
+  console.error("Root container not found");
+  throw new Error(
+    `Expected a container element with Id '${containerId}' but no such container element was present.`,
+  );
 }
 
-render(
-  html`<${App}
-    api=${api}
-    initialState=${initialState}
-    saveInitialState=${throttle((state) => {
+const root = createRoot(container as HTMLElement);
+root.render(
+  <App
+    api={api}
+    applicationState={initialState}
+    saveApplicationState={throttle((state) => {
       const vscode = getVscodeApi();
       if (vscode) {
         vscode.setState(filterState(state));
       }
     }, 1000)}
-  />`,
-  document.getElementById("app"),
+    capabilities={capabilities}
+    pollForLogs={false}
+  />,
 );
 
-function filterState(state) {
+function filterState(state: ApplicationState) {
   if (!state) {
     return state;
   }
@@ -41,7 +67,7 @@ function filterState(state) {
 }
 
 // Filters the selected Sample if it is large
-function filterLargeSample(state) {
+function filterLargeSample(state: ApplicationState) {
   if (!state || !state.selectedSample) {
     return state;
   }
@@ -56,7 +82,7 @@ function filterLargeSample(state) {
 }
 
 // Filters the selectedlog if it is too large
-function filterLargeSelectedLog(state) {
+function filterLargeSelectedLog(state: ApplicationState) {
   if (!state || !state.selectedLog?.contents) {
     return state;
   }
@@ -72,8 +98,8 @@ function filterLargeSelectedLog(state) {
   }
 }
 
-function estimateSize(list, frequency = 0.2) {
-  if (!list || list.len === 0) {
+function estimateSize(list: unknown[], frequency = 0.2) {
+  if (!list || list.length === 0) {
     return 0;
   }
 
@@ -81,7 +107,7 @@ function estimateSize(list, frequency = 0.2) {
   const sampleSize = Math.ceil(list.length * frequency);
 
   // Get a proper random sample without duplicates
-  const messageIndices = new Set();
+  const messageIndices = new Set<number>();
   while (
     messageIndices.size < sampleSize &&
     messageIndices.size < list.length

inspect_ai/_view/www/src/{log → logfile}/remoteLogFile.ts

@@ -1,17 +1,13 @@
-//@ts-check
 import {
   EvalHeader,
   EvalSummary,
   LogViewAPI,
   SampleSummary,
-} from "../api/Types";
+} from "../api/types";
 import { EvalLog, EvalPlan, EvalSample, EvalSpec } from "../types/log";
 import { asyncJsonParse } from "../utils/json-worker";
-import { AsyncQueue } from "../utils/queue.mjs";
-import {
-  FileSizeLimitError,
-  openRemoteZipFile,
-} from "../utils/remoteZipFile.mjs";
+import { AsyncQueue } from "../utils/queue";
+import { FileSizeLimitError, openRemoteZipFile } from "./remoteZipFile";
 
 // don't try to load samples greater than 50mb
 const MAX_BYTES = 50 * 1024 * 1024;
@@ -105,7 +101,6 @@ export const openRemoteLogFile = async (
     if (remoteZipFile.centralDirectory.has(sampleFile)) {
       return (await readJSONFile(sampleFile, MAX_BYTES)) as EvalSample;
     } else {
-      console.log({ dir: remoteZipFile.centralDirectory });
       throw new Error(
         `Unable to read sample file ${sampleFile} - it is not present in the manifest.`,
       );

inspect_ai/_view/www/src/{utils/remoteZipFile.mjs → logfile/remoteZipFile.ts}

@@ -1,72 +1,60 @@
-//@ts-check
-import { decompress } from "fflate";
+import { AsyncInflateOptions, decompress } from "fflate";
 
-/**
- * @typedef {Object} ZipFileEntry
- * @property {number} versionNeeded - The minimum version needed to extract the ZIP entry.
- * @property {number} bitFlag - The general purpose bit flag of the ZIP entry.
- * @property {number} compressionMethod - The compression method used for the ZIP entry.
- * @property {number} crc32 - The CRC-32 checksum of the uncompressed data.
- * @property {number} compressedSize - The size of the compressed data in bytes.
- * @property {number} uncompressedSize - The size of the uncompressed data in bytes.
- * @property {number} filenameLength - The length of the filename in bytes.
- * @property {number} extraFieldLength - The length of the extra field in bytes.
- * @property {Uint8Array} data - The compressed data for the ZIP entry.
- */
+export interface ZipFileEntry {
+  versionNeeded: number;
+  bitFlag: number;
+  compressionMethod: number;
+  crc32: number;
+  compressedSize: number;
+  uncompressedSize: number;
+  filenameLength: number;
+  extraFieldLength: number;
+  data: Uint8Array;
+}
 
-/**
- * @typedef {Object} CentralDirectoryEntry
- * @property {string} filename - The name of the file in the ZIP archive.
- * @property {number} compressionMethod - The compression method used for the file.
- * @property {number} compressedSize - The size of the compressed file in bytes.
- * @property {number} uncompressedSize - The size of the uncompressed file in bytes.
- * @property {number} fileOffset - The offset of the file's data in the ZIP archive.
- */
+export interface CentralDirectoryEntry {
+  filename: string;
+  compressionMethod: number;
+  compressedSize: number;
+  uncompressedSize: number;
+  fileOffset: number;
+}
 
 /**
  * Represents an error thrown when a file exceeds the maximum allowed size.
- *
- * @class
- * @extends {Error}
  */
 export class FileSizeLimitError extends Error {
-  /**
-   * Creates a new FileSizeLimitError.
-   *
-   * @param {string} file - The name of the file that caused the error.
-   * @param {number} maxBytes - The maximum allowed size for the file, in bytes.
-   */
-  constructor(file, maxBytes) {
+  public readonly file: string;
+  public readonly maxBytes: number;
+
+  constructor(file: string, maxBytes: number) {
     super(
       `File "${file}" exceeds the maximum size (${maxBytes} bytes) and cannot be loaded.`,
     );
     this.name = "FileSizeLimitError";
     this.file = file;
     this.maxBytes = maxBytes;
+
+    Object.setPrototypeOf(this, FileSizeLimitError.prototype);
   }
 }
 
 /**
  * Opens a remote ZIP file from the specified URL, fetches and parses the central directory,
  * and provides a method to read files within the ZIP.
- *
- * @param {string} url - The URL of the remote ZIP file.
- * @param {(url: string) => Promise<number>} [fetchContentLength] - Optional function to compute the content length of the remote file.
- * @param {(url: string, start: number, end: number) => Promise<Uint8Array>} [fetchBytes] - Optional function to fetch a range of bytes from the remote file.
- * @returns {Promise<{
- *   centralDirectory: Map<string, CentralDirectoryEntry>,
- *   readFile: (file: string, maxBytes?: number) => Promise<Uint8Array>
- * }>} A promise that resolves with an object containing:
- *   - `centralDirectory`: A map where keys are filenames and values are their corresponding central directory entries.
- *   - `readFile`: A function to read a specific file from the ZIP archive by name.
- *                  Takes the filename and an optional maximum byte length to read.
- * @throws {Error} If the file is not found or if an unsupported compression method is encountered.
  */
 export const openRemoteZipFile = async (
-  url,
-  fetchContentLength = fetchSize,
-  fetchBytes = fetchRange,
-) => {
+  url: string,
+  fetchContentLength: (url: string) => Promise<number> = fetchSize,
+  fetchBytes: (
+    url: string,
+    start: number,
+    end: number,
+  ) => Promise<Uint8Array> = fetchRange,
+): Promise<{
+  centralDirectory: Map<string, CentralDirectoryEntry>;
+  readFile: (file: string, maxBytes?: number) => Promise<Uint8Array>;
+}> => {
   const contentLength = await fetchContentLength(url);
 
   // Read the end of central directory record
@@ -89,7 +77,7 @@ export const openRemoteZipFile = async (
   const centralDirectory = parseCentralDirectory(centralDirBuffer);
   return {
     centralDirectory: centralDirectory,
-    readFile: async (file, maxBytes) => {
+    readFile: async (file, maxBytes): Promise<Uint8Array> => {
       const entry = centralDirectory.get(file);
       if (!entry) {
         throw new Error(`File not found: ${file}`);
@@ -142,7 +130,7 @@ export const openRemoteZipFile = async (
   };
 };
 
-export const fetchSize = async (url) => {
+export const fetchSize = async (url: string): Promise<number> => {
   const response = await fetch(`${url}`, { method: "HEAD" });
   const contentLength = Number(response.headers.get("Content-Length"));
   return contentLength;
@@ -150,14 +138,12 @@ export const fetchSize = async (url) => {
 
 /**
  * Fetches a range of bytes from a remote resource and returns it as a `Uint8Array`.
- *
- * @param {string} url - The URL of the remote resource to fetch.
- * @param {number} start - The starting byte position of the range to fetch.
- * @param {number} end - The ending byte position of the range to fetch.
- * @returns {Promise<Uint8Array>} A promise that resolves to a `Uint8Array` containing the fetched byte range.
- * @throws {Error} If there is an issue with the network request.
  */
-export const fetchRange = async (url, start, end) => {
+export const fetchRange = async (
+  url: string,
+  start: number,
+  end: number,
+): Promise<Uint8Array> => {
   const response = await fetch(`${url}`, {
     headers: { Range: `bytes=${start}-${end}` },
   });
@@ -167,13 +153,11 @@ export const fetchRange = async (url, start, end) => {
 
 /**
  * Asynchronously decompresses the provided data using the specified options.
- *
- * @param {Uint8Array} data - The compressed data to be decompressed.
- * @param {Object} opts - Options to configure the decompression process.
- * @returns {Promise<Uint8Array>} A promise that resolves with the decompressed data.
- * @throws {Error} If an error occurs during decompression, the promise is rejected with the error.
  */
-const decompressAsync = async (data, opts) => {
+const decompressAsync = async (
+  data: Uint8Array,
+  opts: AsyncInflateOptions,
+): Promise<Uint8Array> => {
   return new Promise((resolve, reject) => {
     decompress(data, opts, (err, result) => {
       if (err) {
@@ -187,13 +171,11 @@ const decompressAsync = async (data, opts) => {
 
 /**
  * Extracts and parses the header and data of a compressed ZIP entry from raw binary data.
- *
- * @param {string} file - The name of the file stream to be parsed
- * @param {Uint8Array} rawData - The raw binary data containing the ZIP entry.
- * @returns {Promise<ZipFileEntry>} A promise that resolves to an object containing the ZIP entry's header information and compressed data.
- * @throws {Error} If the ZIP entry signature is invalid.
  */
-const parseZipFileEntry = async (file, rawData) => {
+const parseZipFileEntry = async (
+  file: string,
+  rawData: Uint8Array,
+): Promise<ZipFileEntry> => {
   // Parse ZIP entry header
   const view = new DataView(rawData.buffer);
   let offset = 0;
@@ -237,20 +219,17 @@ const parseZipFileEntry = async (file, rawData) => {
   };
 };
 
+const kFileHeaderSize = 46;
 /**
  * Parses the central directory of a ZIP file from the provided buffer and returns a map of entries.
- *
- * @param {Uint8Array} buffer - The raw binary data containing the central directory of the ZIP archive.
- * @returns {Map<string, CentralDirectoryEntry>} A map where the key is the filename and the value is the corresponding central directory entry.
- * @throws {Error} If the buffer does not contain a valid central directory signature.
  */
-const parseCentralDirectory = (buffer) => {
+const parseCentralDirectory = (buffer: Uint8Array<ArrayBufferLike>) => {
   let offset = 0;
   const view = new DataView(buffer.buffer);
-
   const entries = new Map();
+
   while (offset < buffer.length) {
-    // Make sure there is a central directory signature
+    // Central Directory signature
     if (view.getUint32(offset, true) !== 0x02014b50) break;
 
     const filenameLength = view.getUint16(offset + 28, true);
@@ -258,20 +237,47 @@ const parseCentralDirectory = (buffer) => {
     const fileCommentLength = view.getUint16(offset + 32, true);
 
     const filename = new TextDecoder().decode(
-      buffer.subarray(offset + 46, offset + 46 + filenameLength),
+      buffer.subarray(
+        offset + kFileHeaderSize,
+        offset + kFileHeaderSize + filenameLength,
+      ),
     );
 
+    // Read 32-bit file offset
+    let fileOffset = view.getUint32(offset + 42, true);
+
+    // If fileOffset is 0xFFFFFFFF, use the ZIP64 extended offset instead
+    if (fileOffset === 0xffffffff) {
+      // Move to extra field
+      let extraOffset = offset + kFileHeaderSize + filenameLength;
+      // Look through extra fields until we find zip64 extra field
+      while (
+        extraOffset <
+        offset + kFileHeaderSize + filenameLength + extraFieldLength
+      ) {
+        const tag = view.getUint16(extraOffset, true);
+        const size = view.getUint16(extraOffset + 2, true);
+        if (tag === 0x0001) {
+          // ZIP64 Extra Field - Read 64-bit offset
+          fileOffset = Number(view.getBigUint64(extraOffset + 4, true));
+          break;
+        }
+        extraOffset += 4 + size; // Move to next extra field
+      }
+    }
+
     const entry = {
       filename,
       compressionMethod: view.getUint16(offset + 10, true),
       compressedSize: view.getUint32(offset + 20, true),
       uncompressedSize: view.getUint32(offset + 24, true),
-      fileOffset: view.getUint32(offset + 42, true),
+      fileOffset,
     };
 
     entries.set(filename, entry);
-
-    offset += 46 + filenameLength + extraFieldLength + fileCommentLength;
+    offset +=
+      kFileHeaderSize + filenameLength + extraFieldLength + fileCommentLength;
   }
+
   return entries;
 };