kalfa 3.0.0.dev0__py3-none-any.whl

kalfa/board/static/views/record.js

@@ -0,0 +1,179 @@
+import { computed, defineAsyncComponent, onBeforeUnmount, onErrorCaptured, onMounted, ref, watch }
+  from "https://cdn.jsdelivr.net/npm/vue@3.4.38/dist/vue.esm-browser.prod.js";
+
+import { client as api } from "../api.js";
+import { Badge } from "../components/badge.js";
+import { ErrorBox } from "../components/error.js";
+import { Loading } from "../components/loading.js";
+import { Progress } from "../components/progress.js";
+import { bestText, liveNote, nonfiniteText, seconds, when } from "../format.js";
+import { TABS, entryOf, isSweepEntry, onLive, recordLink, sweepLink, touches } from "../store.js";
+
+
+function lazy(loader) {
+  return defineAsyncComponent({ loader, errorComponent: ErrorBox, loadingComponent: Loading, delay: 150 });
+}
+
+export const TAB_VIEWS = {
+  overview: lazy(() => import("./record/overview.js")),
+  curves: lazy(() => import("./record/curves.js")),
+  model: lazy(() => import("./record/model.js")),
+  data: lazy(() => import("./record/data.js")),
+  predictions: lazy(() => import("./record/predictions.js")),
+  plots: lazy(() => import("./record/plots.js")),
+  config: lazy(() => import("./record/config.js")),
+  files: lazy(() => import("./record/files.js")),
+  log: lazy(() => import("./record/log.js")),
+};
+const STOPPABLE = ["running", "stale"];
+
+export function parentOf(path) {
+  const parts = String(path || "").split("/").filter(Boolean);
+  return parts.slice(0, -1).join("/");
+}
+
+export const Record = {
+  name: "RecordView",
+  components: { KBadge: Badge, KError: ErrorBox, KProgress: Progress },
+  props: {
+    path: { type: String, default: "" },
+    tab: { type: String, default: "overview" },
+  },
+  setup(props) {
+    const record = ref(null);
+    const error = ref("");
+    const loading = ref(false);
+    const version = ref(0);
+    const tabError = ref("");
+    const stopping = ref(false);
+    const stopNote = ref("");
+    let ticket = 0;
+    let off = null;
+
+    const isRecord = async (path) => {
+      try {
+        await api.getJson(api.recordUrl(path));
+        return true;
+      } catch (failure) {
+        return false;
+      }
+    };
+    const load = async () => {
+      const mine = ++ticket;
+      loading.value = true;
+      try {
+        const found = await api.getJson(api.recordUrl(props.path));
+        if (mine !== ticket) return;
+        record.value = found;
+        version.value += 1;
+        error.value = "";
+      } catch (failure) {
+        if (mine !== ticket) return;
+        const longer = props.path + "/" + props.tab;
+        if (failure.status === 404 && await isRecord(longer)) {
+          window.location.hash = recordLink(longer, "overview");
+          return;
+        }
+        error.value = failure.message;
+      } finally {
+        if (mine === ticket) loading.value = false;
+      }
+    };
+
+    const summary = computed(() => (record.value && record.value.summary) || {});
+    const progress = computed(() => (record.value && record.value.progress) || {});
+    const best = computed(() => (record.value && record.value.best) || summary.value.best || null);
+    const status = computed(() => summary.value.status || progress.value.status || "unknown");
+    const current = computed(() => (TABS.includes(props.tab) ? props.tab : "overview"));
+    const view = computed(() => TAB_VIEWS[current.value] || TAB_VIEWS.overview);
+    const canStop = computed(() => STOPPABLE.includes(status.value));
+    const asSweep = computed(() => isSweepEntry(entryOf(props.path)));
+    const sweepParent = computed(() => (summary.value.sweep ? parentOf(props.path) : ""));
+    const tabLink = (tab) => recordLink(props.path, tab);
+    const note = computed(() => liveNote(progress.value));
+    const warning = computed(() => nonfiniteText(summary.value.nonfinite));
+
+    const stop = async () => {
+      if (stopping.value) return;
+      stopping.value = true;
+      stopNote.value = "";
+      try {
+        const written = await api.postJson(api.recordUrl(props.path, "stop"), {});
+        const paths = (written && written.paths) || [];
+        stopNote.value = paths.length ? "asked to stop: " + paths.join(", ") : "nothing to stop";
+        load();
+      } catch (failure) {
+        stopNote.value = "";
+        error.value = failure.message;
+      } finally {
+        stopping.value = false;
+      }
+    };
+
+    watch(() => props.tab, () => {
+      tabError.value = "";
+    });
+    onErrorCaptured((failure) => {
+      tabError.value = "the " + current.value + " tab failed: " + (failure && failure.message ? failure.message
+        : String(failure));
+      return false;
+    });
+    onMounted(() => {
+      load();
+      off = onLive((changed) => {
+        if (touches(changed, [props.path])) load();
+      });
+    });
+    onBeforeUnmount(() => {
+      ticket += 1;
+      if (off) off();
+    });
+    return {
+      api, record, error, loading, version, tabError, stopping, stopNote, summary, progress, best, status, current,
+      view, canStop, asSweep, sweepParent, tabLink, note, warning, stop, TABS, bestText, seconds, when, sweepLink,
+    };
+  },
+  template: `
+    <section class="page record">
+      <k-error :error="error"></k-error>
+      <div v-if="asSweep" class="notice">
+        <span class="mono">{{ path }}</span> is a sweep: <a class="link" :href="sweepLink(path)">open the sweep page</a>
+      </div>
+      <div v-if="loading && !record && !error" class="loading">reading the record</div>
+      <template v-if="record">
+        <header class="record-head card">
+          <div class="record-title">
+            <h2>{{ summary.name || path }}</h2>
+            <k-badge :status="status"></k-badge>
+            <span class="spacer"></span>
+            <button v-if="canStop" type="button" class="button danger" :disabled="stopping" @click="stop"
+              title="write stop.json; the run stops after its current turn">{{ stopping ? "stopping" : "stop" }}</button>
+          </div>
+          <div class="record-meta">
+            <span class="mono muted">{{ path }}</span>
+            <span v-if="sweepParent">point of <a class="link" :href="sweepLink(sweepParent)">{{ sweepParent }}</a></span>
+            <k-progress :value="progress.turn || summary.turn || 0" :total="progress.total || summary.total || null"
+              :part="progress.fraction"
+              :label="(progress.turn || summary.turn || 0) + ' / ' + (progress.total || summary.total || '?') + ' ' + (progress.unit || summary.unit || 'turns')">
+            </k-progress>
+            <span v-if="note" class="muted">{{ note }}</span>
+            <span v-if="best && best.series">best <b>{{ bestText(best) }}</b><span v-if="best.turn" class="muted"> at turn {{ best.turn }}</span></span>
+            <span class="muted">{{ seconds(progress.seconds || summary.seconds) }}</span>
+            <span class="muted">started {{ when(summary.started) }}</span>
+          </div>
+          <div v-if="summary.failure" class="error-box">{{ summary.failure }}</div>
+          <div v-if="warning" class="error-box">{{ warning }}</div>
+          <div v-if="stopNote" class="notice small">{{ stopNote }}</div>
+        </header>
+        <nav class="tabs">
+          <a v-for="name in TABS" :key="name" class="tab" :class="{ active: name === current }" :href="tabLink(name)">{{ name }}</a>
+        </nav>
+        <k-error :error="tabError"></k-error>
+        <div class="tab-body">
+          <component :is="view" :key="current" :record="record" :path="path" :api="api" :version="version"></component>
+        </div>
+      </template>
+    </section>`,
+};
+
+export default Record;

kalfa/board/static/views/runs.js

@@ -0,0 +1,124 @@
+import { computed } from "https://cdn.jsdelivr.net/npm/vue@3.4.38/dist/vue.esm-browser.prod.js";
+
+import { ErrorBox } from "../components/error.js";
+import { Table } from "../components/table.js";
+import { EMPTY, seconds, text, when } from "../format.js";
+import {
+  compareLink,
+  isSweepEntry,
+  nameOf,
+  progressOf,
+  recordLink,
+  setSelected,
+  statusOf,
+  store,
+  sweepLink,
+} from "../store.js";
+
+
+const summaryOf = (entry) => entry.summary || {};
+const bestOf = (entry) => summaryOf(entry).best || {};
+const paramsOf = (entry) => summaryOf(entry).params || {};
+
+export function paramKeys(entries) {
+  const keys = [];
+  for (const entry of entries) {
+    for (const key of Object.keys(paramsOf(entry))) {
+      if (!keys.includes(key)) keys.push(key);
+    }
+  }
+  return keys;
+}
+
+export function recordColumns(entries) {
+  const columns = [
+    { key: "name", label: "name", value: nameOf, href: (entry) => recordLink(entry.path, "overview"),
+      title: (entry) => entry.path },
+    { key: "status", label: "status", value: statusOf, badge: true },
+    { key: "progress", label: "turn/total", value: (entry) => summaryOf(entry).turn,
+      progress: (entry) => progressOf(entry), numeric: true },
+    { key: "seconds", label: "seconds", value: (entry) => summaryOf(entry).seconds,
+      text: (entry) => seconds(summaryOf(entry).seconds), numeric: true },
+    { key: "best_series", label: "best of", value: (entry) => bestOf(entry).series },
+    { key: "best", label: "best", value: (entry) => bestOf(entry).value, numeric: true,
+      title: (entry) => (bestOf(entry).turn ? "at turn " + bestOf(entry).turn : "") },
+    { key: "started", label: "started", value: (entry) => summaryOf(entry).started,
+      text: (entry) => when(summaryOf(entry).started), descending: true },
+  ];
+  for (const key of paramKeys(entries)) {
+    columns.push({ key: "param:" + key, label: key, value: (entry) => paramsOf(entry)[key],
+      text: (entry) => text(paramsOf(entry)[key]), numeric: true, hint: "param " + key });
+  }
+  return columns;
+}
+
+export function failedText(sweep) {
+  const parts = [];
+  if (sweep.failed) parts.push(sweep.failed + " failed");
+  if (sweep.stale) parts.push(sweep.stale + " stale");
+  return parts.join(", ") || EMPTY;
+}
+
+export function sweepColumns() {
+  const sweepOf = (entry) => entry.sweep || {};
+  const objectiveOf = (entry) => sweepOf(entry).objective || {};
+  return [
+    { key: "name", label: "sweep", value: (entry) => entry.path, href: (entry) => sweepLink(entry.path) },
+    { key: "status", label: "status", value: statusOf, badge: true },
+    { key: "points", label: "points done", value: (entry) => sweepOf(entry).done,
+      progress: (entry) => progressOf(entry), numeric: true },
+    { key: "running", label: "running", value: (entry) => sweepOf(entry).running, numeric: true },
+    { key: "failed", label: "failed", value: (entry) => sweepOf(entry).failed, numeric: true,
+      hint: "points that failed or went stale", text: (entry) => failedText(sweepOf(entry)) },
+    { key: "strategy", label: "strategy", value: (entry) => (sweepOf(entry).strategy || {}).use },
+    { key: "objective", label: "objective", value: (entry) => objectiveOf(entry).watch,
+      text: (entry) => (objectiveOf(entry).watch ? objectiveOf(entry).watch + " (" + (objectiveOf(entry).mode || "min")
+        + ")" : EMPTY) },
+    { key: "started", label: "started", value: (entry) => sweepOf(entry).started,
+      text: (entry) => when(sweepOf(entry).started), descending: true },
+  ];
+}
+
+export const Runs = {
+  name: "RunsView",
+  components: { KError: ErrorBox, KTable: Table },
+  setup() {
+    const records = computed(() => store.records.filter((entry) => !isSweepEntry(entry)));
+    const sweeps = computed(() => store.records.filter(isSweepEntry));
+    const columns = computed(() => recordColumns(records.value));
+    const sweepTable = sweepColumns();
+    const chosen = computed(() => store.selected.filter((path) => records.value.some((entry) => entry.path === path)));
+    const compareHref = computed(() => compareLink(chosen.value));
+    const select = (paths) => setSelected(paths);
+    const clear = () => setSelected([]);
+    return { store, records, sweeps, columns, sweepTable, chosen, compareHref, select, clear };
+  },
+  template: `
+    <section class="page runs">
+      <k-error :error="store.error"></k-error>
+      <div v-if="!store.loaded" class="loading">reading the records</div>
+      <template v-else>
+        <div class="page-head">
+          <h2 class="section-title">records</h2>
+          <span class="muted small mono">{{ store.root }}</span>
+        </div>
+        <k-table :columns="columns" :rows="records" row-key="path" selectable :selected="store.selected"
+          @update:selected="select" sort-key="started" :sort-desc="true" placeholder="filter by name, status or param"
+          empty="no records under this root">
+          <template #tools>
+            <span class="spacer"></span>
+            <span class="muted small" v-if="chosen.length">{{ chosen.length }} selected</span>
+            <a class="button" :class="{ disabled: !chosen.length }" :href="chosen.length ? compareHref : null">compare</a>
+            <button type="button" class="button ghost" v-if="chosen.length" @click="clear">clear</button>
+          </template>
+        </k-table>
+        <template v-if="sweeps.length">
+          <h2 class="section-title">sweeps</h2>
+          <k-table :columns="sweepTable" :rows="sweeps" row-key="path" :filterable="false" sort-key="started"
+            :sort-desc="true"></k-table>
+        </template>
+      </template>
+    </section>`,
+};
+
+export default Runs;

kalfa/board/static/views/sweep.js

@@ -0,0 +1,282 @@
+import { computed, onBeforeUnmount, onMounted, ref }
+  from "https://cdn.jsdelivr.net/npm/vue@3.4.38/dist/vue.esm-browser.prod.js";
+
+import { fileUrl, getJson, getText, postJson, sweepUrl } from "../api.js";
+import { Chart } from "../components/chart.js";
+import { ErrorBox } from "../components/error.js";
+import { Table } from "../components/table.js";
+import { EMPTY, number, text, when } from "../format.js";
+import { compareLink, onLive, recordLink, setSelected, store, touches } from "../store.js";
+
+
+const POLL = 1000;
+const BEST = [5, 10, 20];
+
+export function pointPath(root, point) {
+  return root && root !== "." ? root + "/" + point.path : point.path;
+}
+
+export function baseName(path) {
+  const parts = String(path || "").split(/[\\/]/).filter(Boolean);
+  return parts.length ? parts[parts.length - 1] : "";
+}
+
+export function isLogSpace(spec) {
+  return Boolean(spec) && typeof spec === "object" && !Array.isArray(spec) && Array.isArray(spec.log);
+}
+
+export function pointColumns(root, answer) {
+  const ranked = (answer && answer.ranked) || [];
+  const keys = Object.keys((answer && answer.params) || {});
+  const objective = ((answer && answer.sweep) || {}).objective || {};
+  const columns = [
+    { key: "id", label: "point", value: (point) => point.id, href: (point) => recordLink(pointPath(root, point)),
+      numeric: true, title: (point) => point.path },
+    { key: "rank", label: "rank", value: (point) => (ranked.indexOf(point.id) >= 0 ? ranked.indexOf(point.id) + 1 : null),
+      numeric: true },
+    { key: "status", label: "status", value: (point) => point.status, badge: true },
+    { key: "progress", label: "turn/total", value: (point) => point.turn,
+      progress: (point) => ({ value: point.turn || 0, total: point.total || null }), numeric: true },
+    { key: "objective", label: objective.watch || "objective", value: (point) => point.objective, numeric: true,
+      descending: objective.mode === "max", hint: "objective (" + (objective.mode || "min") + ")" },
+  ];
+  for (const key of keys) {
+    columns.push({ key: "param:" + key, label: key, value: (point) => (point.values || {})[key],
+      text: (point) => text((point.values || {})[key]), numeric: true });
+  }
+  return columns;
+}
+
+export function orderLines(answer) {
+  const order = (answer && answer.order) || {};
+  const ids = Array.isArray(order.ids) ? order.ids : [];
+  if (!ids.length) return [];
+  return [
+    { name: "objective", x: ids, y: order.objective || [], mode: "markers" },
+    { name: "best so far", x: ids, y: order.best || [], mode: "lines" },
+  ];
+}
+
+export function scatters(answer) {
+  if (!answer) return [];
+  const params = answer.params || {};
+  const ids = answer.ids || [];
+  const objectives = answer.objectives || [];
+  const space = ((answer.sweep || {}).space) || {};
+  const objective = ((answer.sweep || {}).objective) || {};
+  const best = answer.best;
+  return Object.keys(params).map((key) => {
+    const groups = [{ name: "points", x: params[key], y: objectives, text: ids.map((id) => "point " + id) }];
+    if (best && best.values && best.values[key] !== undefined) {
+      groups.push({ name: "best", x: [best.values[key]], y: [best.objective], text: ["best: point " + best.id],
+        size: 12 });
+    }
+    return { key, groups, options: { xlabel: key, ylabel: objective.watch || "objective", logx: isLogSpace(space[key]) } };
+  });
+}
+
+export const Sweep = {
+  name: "SweepView",
+  components: { KChart: Chart, KError: ErrorBox, KTable: Table },
+  props: { path: { type: String, default: "" } },
+  setup(props) {
+    const answer = ref(null);
+    const error = ref("");
+    const loading = ref(false);
+    const job = ref(null);
+    const report = ref({ status: "", path: "", error: "", url: "", name: "" });
+    let ticket = 0;
+    let timer = null;
+    let off = null;
+    let alive = true;
+
+    const load = async () => {
+      const mine = ++ticket;
+      loading.value = true;
+      try {
+        const found = await getJson(sweepUrl(props.path));
+        if (mine !== ticket) return;
+        answer.value = found;
+        error.value = "";
+      } catch (failure) {
+        if (mine === ticket) error.value = failure.message;
+      } finally {
+        if (mine === ticket) loading.value = false;
+      }
+    };
+
+    const forget = () => {
+      if (report.value.url) URL.revokeObjectURL(report.value.url);
+    };
+    const fetchReport = async (path) => {
+      const name = baseName(path) || "report.html";
+      try {
+        const body = await getText(fileUrl(props.path, name));
+        if (!alive) return;
+        forget();
+        const url = URL.createObjectURL(new Blob([body], { type: "text/html" }));
+        report.value = { status: "done", path, error: "", url, name };
+      } catch (failure) {
+        report.value = { status: "done", path, error: "written, but the board cannot read it back: " + failure.message,
+          url: "", name };
+      }
+    };
+    const poll = async () => {
+      timer = null;
+      if (!alive || job.value === null) return;
+      try {
+        const state = await getJson("/api/report/" + encodeURIComponent(job.value));
+        if (!alive) return;
+        if (state.status === "running") {
+          timer = setTimeout(poll, POLL);
+          return;
+        }
+        job.value = null;
+        if (state.status === "done") await fetchReport(state.path || "");
+        else report.value = { status: "failed", path: "", error: state.error || "the report failed", url: "", name: "" };
+      } catch (failure) {
+        job.value = null;
+        report.value = { status: "failed", path: "", error: failure.message, url: "", name: "" };
+      }
+    };
+    const writeReport = async () => {
+      if (job.value !== null) return;
+      report.value = { status: "running", path: "", error: "", url: "", name: "" };
+      try {
+        const started = await postJson("/api/report", { records: [props.path], out: null });
+        job.value = started && started.job !== undefined ? started.job : null;
+        if (job.value === null) throw new Error("the server did not start a report job");
+        timer = setTimeout(poll, POLL);
+      } catch (failure) {
+        report.value = { status: "failed", path: "", error: failure.message, url: "", name: "" };
+      }
+    };
+
+    const info = computed(() => (answer.value && answer.value.sweep) || {});
+    const objective = computed(() => info.value.objective || {});
+    const points = computed(() => ((answer.value && answer.value.points) || [])
+      .map((point) => ({ ...point, full: pointPath(props.path, point) })));
+    const paths = computed(() => points.value.map((point) => point.full));
+    const chosen = computed(() => store.selected.filter((path) => paths.value.includes(path)));
+    const compareHref = computed(() => compareLink(chosen.value));
+    const select = (found) => setSelected(found);
+    const clear = () => setSelected(store.selected.filter((path) => !paths.value.includes(path)));
+    const pickBest = (count) => {
+      const ranked = (answer.value && answer.value.ranked) || [];
+      const best = ranked.slice(0, count).map((id) => points.value.find((point) => point.id === id))
+        .filter((point) => point && point.objective !== null && point.objective !== undefined);
+      setSelected(best.map((point) => point.full));
+    };
+    const order = computed(() => orderLines(answer.value));
+    const orderOptions = computed(() => ({ xlabel: "point", ylabel: objective.value.watch || "objective" }));
+    const space = computed(() => (answer.value && answer.value.space) || { axes: [], left_out: 0 });
+    const spaceNote = computed(() => (space.value.left_out
+      ? space.value.left_out + " points without an objective are not drawn; the color is the objective, the best bright"
+      : "a line per point; the color is the objective, the best bright; drag along an axis to keep a range"));
+    const best = computed(() => (answer.value && answer.value.best) || null);
+    const columns = computed(() => pointColumns(props.path, answer.value));
+    const charts = computed(() => scatters(answer.value));
+    const counts = computed(() => {
+      const found = {};
+      for (const point of points.value) found[point.status || "unknown"] = (found[point.status || "unknown"] || 0) + 1;
+      return Object.entries(found);
+    });
+    const bestLink = computed(() => (best.value ? recordLink(pointPath(props.path, best.value)) : ""));
+    const valuesOf = (point) => Object.entries((point && point.values) || {});
+    const strategy = computed(() => (info.value.strategy && info.value.strategy.use) || EMPTY);
+
+    onMounted(() => {
+      load();
+      off = onLive((changed) => {
+        if (touches(changed, [props.path])) load();
+      });
+    });
+    onBeforeUnmount(() => {
+      alive = false;
+      ticket += 1;
+      if (timer) clearTimeout(timer);
+      if (off) off();
+      forget();
+    });
+    return {
+      answer, error, loading, job, report, info, objective, points, best, columns, charts, counts, bestLink, valuesOf,
+      strategy, writeReport, number, text, when, store, chosen, compareHref, select, clear, pickBest, order,
+      orderOptions, space, spaceNote, BEST,
+    };
+  },
+  template: `
+    <section class="page sweep">
+      <div class="page-head">
+        <h2 class="section-title">sweep <span class="mono">{{ path }}</span></h2>
+        <span class="spacer"></span>
+        <button type="button" class="button" :disabled="report.status === 'running'" @click="writeReport">
+          {{ report.status === "running" ? "writing report.html" : "write report.html" }}
+        </button>
+      </div>
+      <div v-if="report.status === 'done'" class="notice">
+        <span>report written to <span class="mono">{{ report.path }}</span></span>
+        <a v-if="report.url" class="link" :href="report.url" target="_blank" rel="noopener">open</a>
+        <a v-if="report.url" class="link" :href="report.url" :download="report.name">download</a>
+      </div>
+      <k-error :error="report.error"></k-error>
+      <k-error :error="error"></k-error>
+      <div v-if="loading && !answer" class="loading">reading the sweep</div>
+      <template v-if="answer">
+        <div class="cards">
+          <div class="card stat">
+            <div class="stat-label">strategy</div>
+            <div class="stat-value">{{ strategy }}</div>
+            <div class="muted small">started {{ when(info.started) }}</div>
+          </div>
+          <div class="card stat">
+            <div class="stat-label">points</div>
+            <div class="stat-value">{{ points.length }} / {{ info.points || points.length }}</div>
+            <div class="muted small"><span v-for="pair in counts" :key="pair[0]" class="chip">{{ pair[1] }} {{ pair[0] }}</span></div>
+          </div>
+          <div class="card stat">
+            <div class="stat-label">objective</div>
+            <div class="stat-value mono">{{ objective.watch || "none" }}</div>
+            <div class="muted small">{{ objective.mode || "min" }} at {{ objective.at || "best" }}</div>
+          </div>
+          <div class="card stat best-card">
+            <div class="stat-label">best</div>
+            <template v-if="best">
+              <div class="stat-value"><a class="link" :href="bestLink">point {{ best.id }}</a> {{ number(best.objective) }}</div>
+              <div class="small"><span v-for="pair in valuesOf(best)" :key="pair[0]" class="chip">{{ pair[0] }} = {{ text(pair[1]) }}</span></div>
+            </template>
+            <div v-else class="muted">no point has an objective yet</div>
+          </div>
+        </div>
+        <h3 class="section-title">points</h3>
+        <k-table :columns="columns" :rows="points" row-key="full" sort-key="rank" placeholder="filter points"
+          selectable :selected="store.selected" @update:selected="select" empty="the sweep has no points yet">
+          <template #tools>
+            <span class="spacer"></span>
+            <button v-for="count in BEST" :key="count" type="button" class="tool" @click="pickBest(count)"
+              title="select the best points by the objective">best {{ count }}</button>
+            <span class="muted small" v-if="chosen.length">{{ chosen.length }} selected</span>
+            <a class="button" :class="{ disabled: !chosen.length }" :href="chosen.length ? compareHref : null">compare</a>
+            <button type="button" class="button ghost" v-if="chosen.length" @click="clear">clear</button>
+          </template>
+        </k-table>
+        <h3 class="section-title">the search over its order</h3>
+        <div v-if="!order.length" class="empty">no point has an objective yet</div>
+        <div class="grid" v-else>
+          <k-chart title="objective by point" kind="lines" :data="order" :options="orderOptions"
+            note="the objective of every point in the order the sweep made them, and the best value so far"></k-chart>
+        </div>
+        <h3 class="section-title">every point across the space</h3>
+        <div v-if="space.axes.length < 2" class="empty">no point has an objective yet</div>
+        <k-chart v-else title="params and objective" kind="parallel" :data="space" :height="340" :log-toggle="false"
+          :note="spaceNote"></k-chart>
+        <h3 class="section-title">objective against each param</h3>
+        <div v-if="!charts.length" class="empty">the sweep has no params</div>
+        <div class="grid">
+          <k-chart v-for="chart in charts" :key="chart.key" kind="scatter" :title="chart.key" :data="chart.groups"
+            :options="chart.options"></k-chart>
+        </div>
+      </template>
+    </section>`,
+};
+
+export default Sweep;

kalfa/board/watch.py

@@ -0,0 +1,87 @@
+import logging
+import threading
+from collections import deque
+
+
+KEPT = 256
+LOGGER = logging.getLogger("kalfa.board")
+
+
+class Watcher:
+    def __init__(self, board, every=2.0):
+        self.board = board
+        self.every = float(every)
+        self.condition = threading.Condition()
+        self.version = 0
+        self.changed = []
+        self.stamps = {}
+        self.thread = None
+        self.stopping = False
+        self.log = deque(maxlen=KEPT)
+        self.failure = None
+
+    def start(self):
+        with self.condition:
+            if self.thread is not None and self.thread.is_alive():
+                return self
+            self.stopping = False
+            found = self.read()
+            if found is not None:
+                self.stamps = found
+            self.thread = threading.Thread(target=self.run, name="kalfa-watch", daemon=True)
+            self.thread.start()
+        return self
+
+    def stop(self):
+        with self.condition:
+            self.stopping = True
+            self.condition.notify_all()
+            thread, self.thread = self.thread, None
+        if thread is not None and thread is not threading.current_thread():
+            thread.join()
+
+    def wait(self, version, timeout):
+        with self.condition:
+            self.condition.wait_for(lambda: self.version > version or self.stopping, timeout)
+            return self.version if self.version > version else None
+
+    def since(self, version):
+        with self.condition:
+            changed = {path for number, paths in self.log if number > version for path in paths}
+            missed = self.version > version and (not self.log or self.log[0][0] > version + 1)
+            if missed:
+                changed.update(self.stamps)
+            return self.version, sorted(changed)
+
+    def run(self):
+        while True:
+            with self.condition:
+                if self.condition.wait_for(lambda: self.stopping, self.every):
+                    return
+            self.poll()
+
+    def poll(self):
+        found = self.read()
+        if found is None or found == self.stamps:
+            return False
+        with self.condition:
+            changed = sorted(path for path in found.keys() | self.stamps.keys()
+                             if found.get(path) != self.stamps.get(path))
+            self.stamps = found
+            self.changed = changed
+            self.version += 1
+            self.log.append((self.version, changed))
+            self.condition.notify_all()
+        return True
+
+    def read(self):
+        try:
+            found = dict(self.board.stamps())
+        except Exception as error:
+            text = f"{type(error).__name__}: {error}"
+            if text != self.failure:
+                LOGGER.warning("the board could not read its stamps: %s", text)
+            self.failure = text
+            return None
+        self.failure = None
+        return found