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

{inspect_ai-0.3.70.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/node_modules/flatted/python/flatted.py

@@ -1,149 +0,0 @@
-# ISC License
-#
-# Copyright (c) 2018-2021, Andrea Giammarchi, @WebReflection
-#
-# Permission to use, copy, modify, and/or distribute this software for any
-# purpose with or without fee is hereby granted, provided that the above
-# copyright notice and this permission notice appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-# AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-# LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
-# OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-# PERFORMANCE OF THIS SOFTWARE.
-
-import json as _json
-
-class _Known:
-    def __init__(self):
-        self.key = []
-        self.value = []
-
-class _String:
-    def __init__(self, value):
-        self.value = value
-
-
-def _array_keys(value):
-    keys = []
-    i = 0
-    for _ in value:
-        keys.append(i)
-        i += 1
-    return keys
-
-def _object_keys(value):
-    keys = []
-    for key in value:
-        keys.append(key)
-    return keys
-
-def _is_array(value):
-    return isinstance(value, list) or isinstance(value, tuple)
-
-def _is_object(value):
-    return isinstance(value, dict)
-
-def _is_string(value):
-    return isinstance(value, str)
-
-def _index(known, input, value):
-    input.append(value)
-    index = str(len(input) - 1)
-    known.key.append(value)
-    known.value.append(index)
-    return index
-
-def _loop(keys, input, known, output):
-    for key in keys:
-        value = output[key]
-        if isinstance(value, _String):
-            _ref(key, input[int(value.value)], input, known, output)
-
-    return output
-
-def _ref(key, value, input, known, output):
-    if _is_array(value) and not value in known:
-        known.append(value)
-        value = _loop(_array_keys(value), input, known, value)
-    elif _is_object(value) and not value in known:
-        known.append(value)
-        value = _loop(_object_keys(value), input, known, value)
-
-    output[key] = value
-
-def _relate(known, input, value):
-    if _is_string(value) or _is_array(value) or _is_object(value):
-        try:
-            return known.value[known.key.index(value)]
-        except:
-            return _index(known, input, value)
-
-    return value
-
-def _transform(known, input, value):
-    if _is_array(value):
-        output = []
-        for val in value:
-            output.append(_relate(known, input, val))
-        return output
-
-    if _is_object(value):
-        obj = {}
-        for key in value:
-            obj[key] = _relate(known, input, value[key])
-        return obj
-
-    return value
-
-def _wrap(value):
-    if _is_string(value):
-        return _String(value)
-
-    if _is_array(value):
-        i = 0
-        for val in value:
-            value[i] = _wrap(val)
-            i += 1
-
-    elif _is_object(value):
-        for key in value:
-            value[key] = _wrap(value[key])
-
-    return value
-
-def parse(value, *args, **kwargs):
-    json = _json.loads(value, *args, **kwargs)
-    wrapped = []
-    for value in json:
-        wrapped.append(_wrap(value))
-
-    input = []
-    for value in wrapped:
-        if isinstance(value, _String):
-            input.append(value.value)
-        else:
-            input.append(value)
-
-    value = input[0]
-
-    if _is_array(value):
-        return _loop(_array_keys(value), input, [value], value)
-
-    if _is_object(value):
-        return _loop(_object_keys(value), input, [value], value)
-
-    return value
-
-
-def stringify(value, *args, **kwargs):
-    known = _Known()
-    input = []
-    output = []
-    i = int(_index(known, input, value))
-    while i < len(input):
-        output.append(_transform(known, input, input[i]))
-        i += 1
-    return _json.dumps(output, *args, **kwargs)

inspect_ai/_view/www/node_modules/flatted/python/test.py

@@ -1,63 +0,0 @@
-from flatted import stringify as _stringify, parse
-
-def stringify(value):
-    return _stringify(value, separators=(',', ':'))
-
-assert stringify([None, None]) == '[[null,null]]'
-
-a = []
-o = {}
-
-assert stringify(a) == '[[]]'
-assert stringify(o) == '[{}]'
-
-a.append(a)
-o['o'] = o
-
-assert stringify(a) == '[["0"]]'
-assert stringify(o) == '[{"o":"0"}]'
-
-b = parse(stringify(a))
-assert isinstance(b, list) and b[0] == b
-
-a.append(1)
-a.append('two')
-a.append(True)
-o['one'] = 1
-o['two'] = 'two'
-o['three'] = True
-
-assert stringify(a) == '[["0",1,"1",true],"two"]'
-assert stringify(o) == '[{"o":"0","one":1,"two":"1","three":true},"two"]'
-
-a.append(o)
-o['a'] = a
-
-assert stringify(a) == '[["0",1,"1",true,"2"],"two",{"o":"2","one":1,"two":"1","three":true,"a":"0"}]'
-assert stringify(o) == '[{"o":"0","one":1,"two":"1","three":true,"a":"2"},"two",["2",1,"1",true,"0"]]'
-
-a.append({'test': 'OK'})
-a.append([1, 2, 3])
-
-o['test'] = {'test': 'OK'}
-o['array'] = [1, 2, 3]
-
-assert stringify(a) == '[["0",1,"1",true,"2","3","4"],"two",{"o":"2","one":1,"two":"1","three":true,"a":"0","test":"3","array":"4"},{"test":"5"},[1,2,3],"OK"]'
-assert stringify(o) == '[{"o":"0","one":1,"two":"1","three":true,"a":"2","test":"3","array":"4"},"two",["2",1,"1",true,"0","3","4"],{"test":"5"},[1,2,3],"OK"]'
-
-a2 = parse(stringify(a));
-o2 = parse(stringify(o));
-
-assert a2[0] == a2
-assert o2['o'] == o2
-
-assert a2[1] == 1 and a2[2] == 'two' and a2[3] == True and isinstance(a2[4], dict)
-assert a2[4] == a2[4]['o'] and a2 == a2[4]['o']['a']
-
-str = parse('[{"prop":"1","a":"2","b":"3"},{"value":123},["4","5"],{"e":"6","t":"7","p":4},{},{"b":"8"},"f",{"a":"9"},["10"],"sup",{"a":1,"d":2,"c":"7","z":"11","h":1},{"g":2,"a":"7","b":"12","f":6},{"r":4,"u":"7","c":5}]')
-assert str['b']['t']['a'] == 'sup' and str['a'][1]['b'][0]['c'] == str['b']['t']
-
-oo = parse('[{"a":"1","b":"0","c":"2"},{"aa":"3"},{"ca":"4","cb":"5","cc":"6","cd":"7","ce":"8","cf":"9"},{"aaa":"10"},{"caa":"4"},{"cba":"5"},{"cca":"2"},{"cda":"4"},"value2","value3","value1"]');
-assert oo['a']['aa']['aaa'] == 'value1' and oo == oo['b'] and oo['c']['ca']['caa'] == oo['c']['ca']
-
-print('OK')

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);
-    }
-  };
-};