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

inspect_ai/_view/www/src/samples/transcript/state/StateEventRenderers.mjs

@@ -1,254 +0,0 @@
-// @ts-check
-import { html } from "htm/preact";
-import { ChatView } from "../../../components/ChatView.mjs";
-import { FontSize, TextStyle } from "../../../appearance/Fonts.mjs";
-import { HumanBaselineView } from "../../../components/HumanBaselineView.mjs";
-
-/**
- * @typedef {Object} Signature
- * @property {string[]} remove - Array of paths to be removed.
- * @property {string[]} replace - Array of paths to be replaced.
- * @property {string[]} add - Array of paths to be added.
- */
-
-/**
- * @typedef {Object} ChangeType
- * @property {string} type - Type of the system message.
- * @property {Signature} signature - Signature of the system message.
- * @property {function(import("../../../types/log").JsonChange[], Object): import("preact").JSX.Element} render - Function to render the resolved state.
- */
-
-/** @type {ChangeType} */
-const system_msg_added_sig = {
-  type: "system_message",
-  signature: {
-    remove: ["/messages/0/source"],
-    replace: ["/messages/0/role", "/messages/0/content"],
-    add: ["/messages/1"],
-  },
-  render: (_changes, resolvedState) => {
-    const message = resolvedState["messages"][0];
-    return html`<${ChatView}
-      id="system_msg_event_preview"
-      messages=${[message]}
-    />`;
-  },
-};
-
-const kToolPattern = "/tools/(\\d+)";
-
-/** @type {ChangeType} */
-const use_tools = {
-  type: "use_tools",
-  signature: {
-    add: ["/tools/0"],
-    replace: ["/tool_choice"],
-    remove: [],
-  },
-  render: (changes, resolvedState) => {
-    return renderTools(changes, resolvedState);
-  },
-};
-
-/** @type {ChangeType} */
-const add_tools = {
-  type: "add_tools",
-  signature: {
-    add: [kToolPattern],
-    replace: [],
-    remove: [],
-  },
-  render: (changes, resolvedState) => {
-    return renderTools(changes, resolvedState);
-  },
-};
-
-const humanAgentKey = (key) => {
-  return `HumanAgentState:${key}`;
-};
-const human_baseline_session = {
-  type: "human_baseline_session",
-  signature: {
-    add: ["HumanAgentState:logs"],
-    replace: [],
-    remove: [],
-  },
-  render: (changes, resolvedState) => {
-    // Read the session values
-    const started = resolvedState[humanAgentKey("started_running")];
-    const runtime = resolvedState[humanAgentKey("accumulated_time")];
-    const answer = resolvedState[humanAgentKey("answer")];
-    const completed = !!answer;
-    const running = resolvedState[humanAgentKey("running_state")];
-    const rawSessions = resolvedState[humanAgentKey("logs")];
-
-    // Tweak the date value
-    const startedDate = started ? new Date(started * 1000) : undefined;
-
-    // Convert raw sessions into session logs
-    const sessions = {};
-    if (rawSessions) {
-      for (const key of Object.keys(rawSessions)) {
-        const value = rawSessions[key];
-        // this pulls the key apart into
-        // <user>_<timestamp>.<type>
-        const match = key.match(/(.*)_(\d+_\d+)\.(.*)/);
-        if (match) {
-          const user = match[1];
-          const timestamp = match[2];
-          const type = match[3];
-          sessions[timestamp] = sessions[timestamp] || {};
-          sessions[timestamp][type] = value;
-          sessions[timestamp]["user"] = user;
-        }
-      }
-    }
-
-    return html`<${HumanBaselineView}
-      started=${startedDate}
-      running=${running}
-      completed=${completed}
-      answer=${answer}
-      runtime=${runtime}
-      sessionLogs=${Object.values(sessions)}
-    />`;
-  },
-};
-
-const renderTools = (changes, resolvedState) => {
-  // Find which tools were added in this change
-  const toolIndexes = [];
-  for (const change of changes) {
-    const match = change.path.match(kToolPattern);
-    if (match) {
-      toolIndexes.push(match[1]);
-    }
-  }
-
-  const toolName = (toolChoice) => {
-    if (typeof toolChoice === "object" && toolChoice) {
-      return toolChoice["name"];
-    } else {
-      return toolChoice;
-    }
-  };
-
-  const toolsInfo = {};
-
-  // Show tool choice if it was changed
-  const hasToolChoice = changes.find((change) => {
-    return change.path.startsWith("/tool_choice");
-  });
-  if (resolvedState.tool_choice && hasToolChoice) {
-    toolsInfo["Tool Choice"] = toolName(resolvedState.tool_choice);
-  }
-
-  // Show either all tools or just the specific tools
-  if (resolvedState.tools.length > 0) {
-    if (toolIndexes.length === 0) {
-      toolsInfo["Tools"] = html`<${Tools}
-        toolDefinitions=${resolvedState.tools}
-      />`;
-    } else {
-      const filtered = resolvedState.tools.filter((_, index) => {
-        return toolIndexes.includes(index.toString());
-      });
-      toolsInfo["Tools"] = html`<${Tools} toolDefinitions=${filtered} />`;
-    }
-  }
-
-  return html`
-    <div
-      style=${{
-        display: "grid",
-        gridTemplateColumns: "max-content max-content",
-        columnGap: "1rem",
-        margin: "0",
-      }}
-    >
-      ${Object.keys(toolsInfo).map((key) => {
-        return html` <div
-            style=${{
-              fontSize: FontSize.smaller,
-              ...TextStyle.label,
-              ...TextStyle.secondary,
-            }}
-          >
-            ${key}
-          </div>
-          <div style=${{ fontSize: FontSize.base }}>${toolsInfo[key]}</div>`;
-      })}
-    </div>
-  `;
-};
-
-/** @type {ChangeType[]} */
-export const RenderableChangeTypes = [
-  system_msg_added_sig,
-  use_tools,
-  add_tools,
-];
-
-/** @type {ChangeType[]} */
-export const StoreSpecificRenderableTypes = [human_baseline_session];
-
-/**
- * @typedef {Object} ToolParameters
- * @property {string} type - The type of the parameters object, typically "object".
- * @property {Object} properties - An object describing the properties of the parameters.
- * @property {ToolProperty} properties.code - The code property, which is a string.
- * @property {string[]} required - An array of required property names.
- */
-
-/**
- * @typedef {Object} ToolProperty
- * @property {string} type - The data type of the property (e.g., "string").
- * @property {string} description - A description of the property.
- */
-
-/**
- * @typedef {Object} ToolDefinition
- * @property {string} name - The name of the tool (e.g., "python").
- * @property {string} description - A brief description of what the tool does.
- * @property {ToolParameters} [parameters] - An object describing the parameters that the tool accepts.
- */
-
-/**
- * Renders a list of tool components based on the provided tool definitions.
- *
- * @param {Object} props - The component props.
- * @param {ToolDefinition[]} props.toolDefinitions - An array of tool definition objects, each containing the function name and arguments.
- *
- * @returns {import("preact").JSX.Element[]} An array of JSX elements representing the tools.
- */
-export const Tools = ({ toolDefinitions }) => {
-  return toolDefinitions.map((toolDefinition) => {
-    const toolName = toolDefinition.name;
-    const toolArgs = toolDefinition.parameters?.properties
-      ? Object.keys(toolDefinition.parameters.properties)
-      : [];
-    return html`<${Tool} toolName=${toolName} toolArgs=${toolArgs} />`;
-  });
-};
-
-/**
- * Renders a single tool component.
- *
- * @param {Object} props - The component props.
- * @param {string} props.toolName - The name of the tool to be displayed.
- * @param {string[]} [props.toolArgs] - An optional array of arguments for the tool (not used in the current implementation).
- * @param {string} [props.toolDesc] - An optional description of the tool (not used in the current implementation).
- *
- * @returns {import("preact").JSX.Element} A JSX element representing the tool.
- */
-export const Tool = ({ toolName, toolArgs }) => {
-  const functionCall =
-    toolArgs && toolArgs.length > 0
-      ? `${toolName}(${toolArgs.join(", ")})`
-      : toolName;
-  return html`<div>
-    <code style=${{ fontSize: FontSize.small, padding: "0" }}
-      >${functionCall}</code
-    >
-  </div>`;
-};

inspect_ai/_view/www/src/samples/transcript/state/StateEventView.mjs

@@ -1,313 +0,0 @@
-// @ts-check
-import { html } from "htm/preact";
-
-import { EventPanel } from "../EventPanel.mjs";
-import {
-  RenderableChangeTypes,
-  StoreSpecificRenderableTypes,
-} from "./StateEventRenderers.mjs";
-import { StateDiffView } from "./StateDiffView.mjs";
-import { formatDateTime } from "../../../utils/Format.mjs";
-
-/**
- * Renders the StateEventView component.
- *
- * @param {Object} props - The properties passed to the component.
- * @param { string  } props.id - The id of this event.
- * @param {import("../../../types/log").StateEvent } props.event - The event object to display.
- * @param {import("./../Types.mjs").TranscriptEventState} props.eventState - The state for this event
- * @param {(state: import("./../Types.mjs").TranscriptEventState) => void} props.setEventState - Update the state for this event
- * @param { boolean } props.isStore - Whether this event view is rendering a storage (rather than a state)
- * @param { Object } props.style - The style of this event.
- * @returns {import("preact").JSX.Element} The component.
- */
-export const StateEventView = ({
-  id,
-  event,
-  eventState,
-  setEventState,
-  isStore,
-  style,
-}) => {
-  const summary = summarizeChanges(event.changes);
-
-  // Synthesize objects for comparison
-  const [before, after] = synthesizeComparable(event.changes);
-
-  const tabs = [
-    html`<${StateDiffView}
-      before=${before}
-      after=${after}
-      name="Diff"
-      style=${{ margin: "1em 0em" }}
-    />`,
-  ];
-  // This clone is important since the state is used by preact as potential values that are rendered
-  // and as a result may be decorated with additional properties, etc..., resulting in DOM elements
-  // appearing attached to state.
-  const changePreview = generatePreview(
-    event.changes,
-    structuredClone(after),
-    isStore,
-  );
-  if (changePreview) {
-    tabs.unshift(
-      html`<div name="Summary" style=${{ margin: "1em 0em", width: "100%" }}>
-        ${changePreview}
-      </div>`,
-    );
-  }
-
-  // Compute the title
-  const title = event.event === "state" ? "State Updated" : "Store Updated";
-
-  return html`
-  <${EventPanel} 
-    id=${id} 
-    title="${title}" 
-    subTitle=${formatDateTime(new Date(event.timestamp))} 
-    text=${tabs.length === 1 ? summary : undefined} 
-    collapse=${changePreview === undefined ? true : undefined} 
-    style=${style}
-    selectedNav=${eventState.selectedNav || ""}
-    onSelectedNav=${(selectedNav) => {
-      setEventState({ ...eventState, selectedNav });
-    }}
-    collapsed=${eventState.collapsed}
-    onCollapsed=${(collapsed) => {
-      setEventState({ ...eventState, collapsed });
-    }}                  
-  >
-    ${tabs}
-  </${EventPanel}>`;
-};
-
-/**
- * Renders the value of a change based on its type.
- *
- * @param {import("../../../types/log").JsonChange[]} changes - The change object containing the value.
- * @param {Object} resolvedState - The change object containing the value.
- * @param {boolean} isStore - Is this rendering a store event
- * @returns {import("preact").JSX.Element|Object|string|undefined} - The rendered HTML template if the value is an object with content and source, otherwise the value itself.
- */
-const generatePreview = (changes, resolvedState, isStore) => {
-  const results = [];
-  for (const changeType of [
-    ...RenderableChangeTypes,
-    ...(isStore ? StoreSpecificRenderableTypes : []),
-  ]) {
-    // Note that we currently only have renderers that depend upon
-    // add, remove, replace, but we should likely add
-    // move, copy, test
-    const requiredMatchCount =
-      changeType.signature.remove.length +
-      changeType.signature.replace.length +
-      changeType.signature.add.length;
-    let matchingOps = 0;
-    for (const change of changes) {
-      if (
-        changeType.signature[change.op] &&
-        changeType.signature[change.op].length > 0
-      ) {
-        changeType.signature[change.op].forEach((signature) => {
-          if (change.path.match(signature)) {
-            matchingOps++;
-          }
-        });
-      }
-    }
-    if (matchingOps === requiredMatchCount) {
-      results.push(changeType.render(changes, resolvedState));
-      // Only one renderer can process a change
-      // TODO: consider changing this to allow many handlers to render (though then we sort of need
-      // to match the renderer to the key (e.g. a rendered for `tool_choice` a renderer for `tools` etc..))
-      break;
-    }
-  }
-  return results.length > 0 ? results : undefined;
-};
-
-/**
- * Renders the value of a change based on its type.
- *
- * @param {import("../../../types/log").JsonChange[]} changes - The change object containing the value.
- * @returns {string} - A string summarizing the changes
- */
-const summarizeChanges = (changes) => {
-  const changeMap = {
-    add: [],
-    copy: [],
-    move: [],
-    replace: [],
-    remove: [],
-    test: [],
-  };
-  for (const change of changes) {
-    changeMap[change.op].push(change.path);
-  }
-
-  const changeList = [];
-  const totalOpCount = Object.keys(changeMap).reduce((prev, current) => {
-    return prev + changeMap[current].length;
-  }, 0);
-
-  if (totalOpCount > 2) {
-    Object.keys(changeMap).forEach((key) => {
-      const opChanges = changeMap[key];
-      if (opChanges.length > 0) {
-        changeList.push(`${key} ${opChanges.length}`);
-      }
-    });
-  } else {
-    Object.keys(changeMap).forEach((key) => {
-      const opChanges = changeMap[key];
-      if (opChanges.length > 0) {
-        changeList.push(`${key} ${opChanges.join(", ")}`);
-      }
-    });
-  }
-  return changeList.join(", ");
-};
-
-/**
- * Renders a view displaying a list of state changes.
- *
- * @param {import("../../../types/log").Changes} changes - The list of changes to be displayed.
- * @returns {[Object, Object]} The before and after objects
- */
-const synthesizeComparable = (changes) => {
-  const before = {};
-  const after = {};
-
-  for (const change of changes) {
-    switch (change.op) {
-      case "add":
-        // 'Fill in' arrays with empty strings to ensure there is no unnecessary diff
-        initializeArrays(before, change.path);
-        initializeArrays(after, change.path);
-        setPath(after, change.path, change.value);
-        break;
-      case "copy":
-        setPath(before, change.path, change.value);
-        setPath(after, change.path, change.value);
-        break;
-      case "move":
-        setPath(before, change.from, change.value);
-        setPath(after, change.path, change.value);
-        break;
-      case "remove":
-        setPath(before, change.path, change.value);
-        break;
-      case "replace":
-        setPath(before, change.path, change.replaced);
-        setPath(after, change.path, change.value);
-        break;
-      case "test":
-        break;
-    }
-  }
-  return [before, after];
-};
-
-/**
- * Sets a value at a path in an object
- *
- * @param {Object} target - The object into which to set the path
- * @param {string} path - The path of the value to set
- * @param {unknown} value - The value to set
- * @returns {Object} The mutated object
- */
-function setPath(target, path, value) {
-  const keys = parsePath(path);
-  let current = target;
-
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    if (!(key in current)) {
-      // If the next key is a number, create an array, otherwise an object
-      current[key] = isArrayIndex(keys[i + 1]) ? [] : {};
-    }
-    current = current[key];
-  }
-
-  const lastKey = keys[keys.length - 1];
-  current[lastKey] = value;
-}
-
-/**
- * Places structure in an object (without placing values)
- *
- * @param {Object} target - The object into which to initialize the path
- * @param {string} path - The path of the value to set
- * @returns {Object} The mutated object
- */
-function initializeArrays(target, path) {
-  const keys = parsePath(path);
-  let current = target;
-
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    const nextKey = keys[i + 1];
-
-    if (isArrayIndex(nextKey)) {
-      current[key] = initializeArray(current[key], nextKey);
-    } else {
-      current[key] = initializeObject(current[key]);
-    }
-
-    current = current[key];
-  }
-
-  const lastKey = keys[keys.length - 1];
-  if (isArrayIndex(lastKey)) {
-    initializeArray(current, lastKey);
-  }
-}
-
-/**
- * Parses a path into an array of keys
- *
- * @param {string} path - The path to split
- * @returns {string[]} Array of keys
- */
-function parsePath(path) {
-  return path.split("/").filter(Boolean);
-}
-
-/**
- * Checks if a key represents an array index
- *
- * @param {string} key - The key to check
- * @returns {boolean} True if the key is a number
- */
-function isArrayIndex(key) {
-  return /^\d+$/.test(key);
-}
-
-/**
- * Initializes an array at a given key, ensuring it is large enough
- *
- * @param {Array|undefined} current - The current array or undefined
- * @param {string} nextKey - The key of the next array index
- * @returns {Array} Initialized array
- */
-function initializeArray(current, nextKey) {
-  if (!Array.isArray(current)) {
-    current = [];
-  }
-  const nextKeyIndex = parseInt(nextKey, 10);
-  while (current.length < nextKeyIndex) {
-    current.push("");
-  }
-  return current;
-}
-
-/**
- * Initializes an object at a given key if it doesn't exist
- *
- * @param {Object|undefined} current - The current object or undefined
- * @returns {Object} Initialized object
- */
-function initializeObject(current) {
-  return current ?? {};
-}