PyPI - detectkit - Versions diffs - 0.36.2__tar.gz → 0.38.0__tar.gz - Mend

detectkit 0.36.2tar.gz → 0.38.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (139) hide show

{detectkit-0.36.2/detectkit.egg-info → detectkit-0.38.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: detectkit
-Version: 0.36.2
+Version: 0.38.0
 Summary: Metric monitoring with automatic anomaly detection
 Author: detectkit team
 License: MIT

{detectkit-0.36.2 → detectkit-0.38.0}/detectkit/__init__.py RENAMED Viewed

@@ -4,7 +4,7 @@ detectk - Anomaly Detection for Time-Series Metrics
 A Python library for data analysts and engineers to monitor metrics with automatic anomaly detection.
 """
-__version__ = "0.36.2"
+__version__ = "0.38.0"
 from detectkit.core.interval import Interval
 from detectkit.core.models import ColumnDefinition, TableModel

{detectkit-0.36.2 → detectkit-0.38.0}/detectkit/autotune/html_labeler.py RENAMED Viewed

@@ -10,9 +10,11 @@ It can be **seeded with existing incidents** (the ``incidents=`` argument) so a
 labels file can be opened and edited in place — the round-trip flow of filling
 incidents in over time. Beyond click-drag marking it supports **threshold
 capture** (grab every contiguous span above/below a horizontal line in one
-gesture), **on-chart deletion** (each band carries an ✕ handle; the selected
-band also responds to the Delete key), and an in-browser **Import** button that
-loads a labels file you pick (YAML/JSON).
+gesture), **lasso capture** (draw a freeform loop around a cloud of points and
+turn each grid-adjacent run — small gaps bridged — into one incident span),
+**on-chart deletion** (each band carries an ✕ handle; the selected band also
+responds to the Delete key), and an in-browser **Import** button that loads a
+labels file you pick (YAML/JSON).
 The page is offline-only — a browser cannot write to the project, so Export
 downloads a **versioned** file named after the metric, with the optional set name
@@ -186,6 +188,7 @@ _TEMPLATE = """<!doctype html>
     <input id="setname" class="setname" type="text" placeholder="name this set (optional)" />
     <button id="export" class="primary">Export labels</button>
     <button id="thbtn" class="ghost" title="capture every span above or below a horizontal line">Threshold capture</button>
+    <button id="lassobtn" class="ghost" title="draw a freeform loop around a cloud of points to grab them all at once">Lasso capture</button>
     <button id="clear" class="ghost">Clear all</button>
     <span id="summary" class="summary"></span>
   </div>
@@ -216,8 +219,9 @@ _TEMPLATE = """<!doctype html>
   adjust it, or its middle to move it · click its <b>✕</b> (or select it and press Delete) to remove it ·
   use <b>Threshold capture</b> to grab every span past a horizontal line at once (click sets the line; drag
   across the chart to limit it to a time window — handy when the metric behaves differently across periods) ·
-  <b>focus</b> a row to jump the chart to it · scroll to zoom, double-click to reset · drag the navigator
-  window below to pan.</div>
+  use <b>Lasso capture</b> to draw a freeform loop around a cloud of points and turn each consecutive run into
+  an incident · <b>focus</b> a row to jump the chart to it · scroll to zoom, double-click to reset · drag the
+  navigator window below to pan.</div>
   <div id="empty" class="empty">No incidents marked yet — drag across a span on the chart above.</div>
   <ul id="list"></ul>
   <footer>All times UTC · self-contained, nothing leaves your browser · re-label any time —
@@ -264,6 +268,10 @@ let selObj = null, hoverRow = -1, hoverDel = -1, thMode = false, thHover = null;
 // Threshold-capture window: thDown tracks a press, thDragWin a live drag, capWin
 // the committed custom window (null → capture within the current view).
 let thDown = null, thDragWin = null, capWin = null;
+// Lasso capture: draw a freeform loop around a cloud of points and turn each
+// grid-adjacent run (small gaps bridged) into one incident span. lassoDrag holds
+// the in-progress loop as DATA coords ({t, v}); off until the tool is toggled.
+let lassoMode = false, lassoDrag = null; const LASSO_BRIDGE = 2;
 // Restore a saved capture window so re-opening a labels file keeps the painted
 // regime scope (only shown once threshold capture is toggled on).
 if (CAPWINS && CAPWINS.length) { const w0 = CAPWINS[0];
@@ -426,9 +434,47 @@ function addCaptured(a,b) {
   if (host===null) incidents.push({a, b, label:''}); }
 function toggleTh(on) { thMode = (on===undefined) ? !thMode : !!on;
   thbtnEl.classList.toggle('active', thMode); thbarEl.style.display = thMode ? 'flex' : 'none';
-  if (thMode) { hover=null; } else { thHover=null; thDown=null; thDragWin=null; capWin=null; updateThWin(); }
+  if (thMode) { hover=null; if (lassoMode) toggleLasso(false); }
+  else { thHover=null; thDown=null; thDragWin=null; capWin=null; updateThWin(); }
   c.style.cursor = thMode ? 'crosshair' : 'crosshair'; if (thMode) { updateThWin(); thCount(); } draw(); }
+// ---- lasso capture --------------------------------------------------------
+// Ray-casting point-in-polygon in DATA space ({t, v}); the loop and the test
+// points map through the same per-axis affine, so screen-inside == data-inside.
+function pointInPoly(t, v, poly) { let inside=false;
+  for (let i=0,j=poly.length-1;i<poly.length;j=i++) {
+    const ti=poly[i].t, vi=poly[i].v, tj=poly[j].t, vj=poly[j].v;
+    if (((vi>v)!==(vj>v)) && t < (tj-ti)*(v-vi)/((vj-vi)||1e-9)+ti) inside=!inside; }
+  return inside; }
+// The raw point indices enclosed by the in-progress loop.
+function lassoCapturedIdx() { const out=[]; if (!lassoDrag || lassoDrag.length<3) return out;
+  for (let i=0;i<N;i++) { const p=pts[i]; if (p.v===null) continue;
+    if (pointInPoly(p.ts, p.v, lassoDrag)) out.push(i); } return out; }
+// Collapse the captured points into incident spans: a new span starts only when
+// the gap to the previous capture exceeds LASSO_BRIDGE grid steps; each span is
+// padded half a step each side so a lone point becomes one full-interval incident.
+function commitLasso() { const cap=lassoCapturedIdx(); if (!cap.length) return;
+  const maxGap=(LASSO_BRIDGE+1)*step, half=step/2; let runStart=cap[0], prev=cap[0], added=0;
+  const push=(s,e)=>{ addCaptured(pts[s].ts-half, pts[e].ts+half); added++; };
+  for (let k=1;k<cap.length;k++) { const idx=cap[k];
+    if (pts[idx].ts-pts[prev].ts > maxGap) { push(runStart, prev); runStart=idx; } prev=idx; }
+  push(runStart, prev);
+  setMsg('Added '+added+' incident'+(added===1?'':'s')+' from the lasso — review and tidy below.', 'ok');
+  render(); }
+// The lasso loop (dashed clay outline + faint fill) + a ring on every captured point.
+function drawLasso() { if (!lassoDrag || lassoDrag.length<2) return;
+  ctx.beginPath(); ctx.moveTo(px(lassoDrag[0].t), py(lassoDrag[0].v));
+  for (let i=1;i<lassoDrag.length;i++) ctx.lineTo(px(lassoDrag[i].t), py(lassoDrag[i].v));
+  ctx.closePath(); ctx.fillStyle='rgba(209,91,54,0.08)'; ctx.fill();
+  ctx.strokeStyle='rgba(209,91,54,0.9)'; ctx.lineWidth=1.5*dpr; ctx.setLineDash([5*dpr,4*dpr]);
+  ctx.stroke(); ctx.setLineDash([]);
+  lassoCapturedIdx().forEach(i => { const X=px(pts[i].ts), Y=py(pts[i].v);
+    ctx.strokeStyle='#d63232'; ctx.lineWidth=2*dpr; ctx.beginPath(); ctx.arc(X,Y,7*dpr,0,7); ctx.stroke(); }); }
+function toggleLasso(on) { lassoMode = (on===undefined) ? !lassoMode : !!on;
+  lassobtnEl.classList.toggle('active', lassoMode);
+  if (lassoMode) { hover=null; selObj=null; if (thMode) toggleTh(false); } else { lassoDrag=null; }
+  c.style.cursor='crosshair'; draw(); }
 function rr(g,x,y,w,h,r) { g.beginPath();
   g.moveTo(x+r,y); g.arcTo(x+w,y,x+w,y+h,r); g.arcTo(x+w,y+h,x,y+h,r);
   g.arcTo(x,y+h,x,y,r); g.arcTo(x,y,x+w,y,r); g.closePath(); }
@@ -496,6 +542,7 @@ function draw() {
     if (val!==null && val>=vmin && val<=vmax) { const yy=py(val);
       ctx.strokeStyle='#f0ad4e'; ctx.lineWidth=1.5*dpr; ctx.setLineDash([6*dpr,4*dpr]);
       ctx.beginPath(); ctx.moveTo(xlo, yy); ctx.lineTo(xhi, yy); ctx.stroke(); ctx.setLineDash([]); } }
+  if (lassoMode) drawLasso();
   ctx.restore();
   if (thMode) drawThLabel();
   else if (dragging && !ovAct) drawDragLabel();
@@ -612,7 +659,9 @@ const ovTsAtCss = clientX => { const r=ov.getBoundingClientRect();
 const ovEdgeCss = ts => { const r=ov.getBoundingClientRect();
   return r.left + OM.l + (ts-tmin)/fullSpan*(r.width-(OM.l+OM.r)); };
-c.addEventListener('wheel', e => { e.preventDefault(); const t=tsAt(e.clientX);
+c.addEventListener('wheel', e => { e.preventDefault();
+  if (lassoMode && lassoDrag) return;  // don't distort the loop mid-draw
+  const t=tsAt(e.clientX);
   let s=clamp(vspan()*Math.pow(1.0015, e.deltaY), minSpan, fullSpan);
   const f=(t-viewMin)/(vspan()||1); setView(t-f*s, t-f*s+s); }, {passive:false});
 // Hit-test an existing incident's ✕ handle / edge / body in CSS px.
@@ -634,6 +683,8 @@ function hitIncident(clientX, clientY) {
   return null;
 }
 c.addEventListener('mousedown', e => {
+  // Lasso mode: a press starts a freeform loop accumulated on mousemove.
+  if (lassoMode) { lassoDrag = [{t: tsAt(e.clientX), v: vAt(e.clientY)}]; draw(); return; }
   // In threshold mode a press either sets the line (a click) or paints a capture
   // window (a horizontal drag) — resolved on mouseup by how far it moved.
   if (thMode) { thDown = {x:e.clientX, ts:tsAt(e.clientX)}; thHover = vAt(e.clientY); thCount(); draw(); return; }
@@ -646,6 +697,8 @@ c.addEventListener('mousedown', e => {
   else { selObj=null; dragging={mode:'new', a:t, b:t, sx:e.clientX, cx:e.clientX}; draw(); }
 });
 c.addEventListener('mousemove', e => { if (ovAct) return;
+  if (lassoMode) { if (lassoDrag) { lassoDrag.push({t: tsAt(e.clientX), v: vAt(e.clientY)}); draw(); }
+    else { c.style.cursor='crosshair'; } return; }
   if (thMode && !dragging) {
     if (thDown && Math.abs(e.clientX - thDown.x) > 6) { thDragWin = {a: thDown.ts, b: tsAt(e.clientX)}; }
     else { if (thDown) thDragWin = null; thHover = vAt(e.clientY); }
@@ -689,6 +742,7 @@ window.addEventListener('mousemove', e => { if (!ovAct) return; const t=ovTsAtCs
   else { const d=t-ovAct.grab; setView(ovAct.vMin+d, ovAct.vMax+d); } });
 window.addEventListener('mouseup', e => {
   if (ovAct) { ovAct=null; return; }
+  if (lassoMode) { if (lassoDrag) { commitLasso(); lassoDrag=null; } draw(); return; }
   if (thMode && thDown) {
     if (Math.abs(e.clientX - thDown.x) > 6) {  // a drag → set the capture window
       const a=thDown.ts, b=tsAt(e.clientX); capWin = {a:Math.min(a,b), b:Math.max(a,b)};
@@ -713,12 +767,13 @@ function removeIncident(iv) { const k=incidents.indexOf(iv); if (k<0) return;
   incidents.splice(k,1); if (selObj===iv) selObj=null; hoverDel=-1; render(); }
 window.addEventListener('keydown', e => {
   const t=e.target, typing = t && (t.tagName==='INPUT' || t.tagName==='TEXTAREA' || t.isContentEditable);
-  if (e.key==='Escape') { if (thMode) toggleTh(false); else if (selObj) { selObj=null; draw(); } return; }
-  if ((e.key==='Delete' || e.key==='Backspace') && selObj && !typing) { e.preventDefault(); removeIncident(selObj); }
+  if (e.key==='Escape') { if (lassoMode) toggleLasso(false); else if (thMode) toggleTh(false);
+    else if (selObj) { selObj=null; draw(); } return; }
+  if ((e.key==='Delete' || e.key==='Backspace') && selObj && !typing && !lassoMode) { e.preventDefault(); removeIncident(selObj); }
 });
 document.getElementById('zreset').onclick = () => setView(tmin, tmax);
-c.addEventListener('dblclick', () => { if (!thMode) setView(tmin, tmax); });
+c.addEventListener('dblclick', () => { if (!thMode && !lassoMode) setView(tmin, tmax); });
 document.getElementById('clear').onclick = () => { incidents.length=0; selObj=null; render(); };
 window.setLabel = (i, val) => { if (incidents[i]) incidents[i].label = val; };
 window.rm = i => { const iv=incidents[i]; if (iv && selObj===iv) selObj=null; incidents.splice(i,1); render(); };
@@ -743,6 +798,8 @@ function updateThWin() {
 thwinEl.onclick = () => { capWin=null; updateThWin(); thCount(); draw(); };
 thbtnEl.onclick = () => toggleTh();
 thdoneEl.onclick = () => toggleTh(false);
+const lassobtnEl=document.getElementById('lassobtn');
+lassobtnEl.onclick = () => toggleLasso();
 thdirEl.onchange = () => { thCount(); draw(); };
 thgapEl.oninput = () => { thCount(); draw(); };
 thvalEl.oninput = () => { thCount(); draw(); };

{detectkit-0.36.2 → detectkit-0.38.0}/detectkit/autotune/labels.py RENAMED Viewed

@@ -67,6 +67,11 @@ class IncidentLabels:
     # metadata: it records the regime scope the user reasoned about (auditable in
     # the saved file, restored on reopen); it does NOT affect ground truth.
     capture_windows: list[tuple[datetime, datetime]] = field(default_factory=list)
+    # Optional per-alert review verdicts from `dtk tune` (streak span + 'valid' /
+    # 'false'). Pure metadata: it re-seeds the green/slate markers on reopen (a
+    # confirmed alert is also written as a normal incident, which IS ground truth).
+    # autotune ignores this block entirely.
+    alert_reviews: list[tuple[datetime, datetime, str]] = field(default_factory=list)
     def is_empty(self) -> bool:
         return not self.intervals and not self.points
@@ -158,6 +163,7 @@ def parse_incident_labels(
         return IncidentLabels([], [])
     raw_windows: list = []
+    raw_reviews: list = []
     if isinstance(raw, list):
         entries = raw
         tz: ZoneInfo | None = None
@@ -173,6 +179,9 @@ def parse_incident_labels(
         raw_windows = raw.get("capture_windows") or []
         if not isinstance(raw_windows, list):
             raise ValueError("'capture_windows' must be a list")
+        raw_reviews = raw.get("alert_reviews") or []
+        if not isinstance(raw_reviews, list):
+            raise ValueError("'alert_reviews' must be a list")
     else:
         raise ValueError("Labels must be a mapping with 'incidents' or a list of incidents")
@@ -205,7 +214,22 @@ def parse_incident_labels(
             raise ValueError(f"Capture window start {ws} is after end {we}")
         capture_windows.append((ws, we))
-    return IncidentLabels(intervals=intervals, points=points, capture_windows=capture_windows)
+    alert_reviews: list[tuple[datetime, datetime, str]] = []
+    for rv in raw_reviews:
+        if not isinstance(rv, dict) or "start" not in rv or "end" not in rv:
+            raise ValueError("Each alert_reviews entry needs 'start' and 'end'")
+        rs, re_ = _parse_dt(rv["start"], tz), _parse_dt(rv["end"], tz)
+        if rs > re_:
+            raise ValueError(f"Alert review start {rs} is after end {re_}")
+        verdict = "false" if str(rv.get("verdict", "valid")) == "false" else "valid"
+        alert_reviews.append((rs, re_, verdict))
+    return IncidentLabels(
+        intervals=intervals,
+        points=points,
+        capture_windows=capture_windows,
+        alert_reviews=alert_reviews,
+    )
 def parse_labels_file(
@@ -282,6 +306,29 @@ def load_capture_windows(
     return capture_windows_to_display(labels)
+def alert_reviews_to_display(labels: IncidentLabels) -> list[dict[str, str]]:
+    """Render parsed per-alert review verdicts as display dicts (naive-UTC strings)."""
+    return [
+        {
+            "start": start.strftime(_DISPLAY_FMT),
+            "end": end.strftime(_DISPLAY_FMT),
+            "verdict": verdict,
+        }
+        for start, end, verdict in labels.alert_reviews
+    ]
+def load_alert_reviews(
+    path: str | Path,
+    *,
+    interval_seconds: int,
+    metric_name: str | None = None,
+) -> list[dict[str, str]]:
+    """Load a labels file and render its per-alert review verdicts as display dicts."""
+    labels = parse_labels_file(path, interval_seconds=interval_seconds, metric_name=metric_name)
+    return alert_reviews_to_display(labels)
 # Versioned labels store helpers (shared by the autotune labeler server and the
 # `dtk tune` labeler so both name + discover files the same way).
 _LABELS_GLOBS = ("*.yml", "*.yaml", "*.json")

{detectkit-0.36.2 → detectkit-0.38.0}/detectkit/cli/assets/claude/rules/autotune.md RENAMED Viewed

@@ -80,9 +80,10 @@ dtk autotune --select <sel> [--incidents FILE] [--label] [--scoring METRIC] \
   **continues into tuning on it**. It **seeds from the metric's newest saved set**
   (or from `--incidents FILE|DIR` when given), so re-running `--label` continues
   editing in place. Beyond click-drag marking it offers **Threshold capture**
-  (grab every span above/below a horizontal line in one gesture), **on-chart
-  delete** (each band's ✕, or select + Delete key), and **Import file…** (load a
-  labels file you pick). `--no-serve` writes a static
+  (grab every span above/below a horizontal line in one gesture), **Lasso capture**
+  (loop around a cloud of points; each grid-adjacent run, gaps bridged, becomes one
+  incident span), **on-chart delete** (each band's ✕, or select + Delete key), and
+  **Import file…** (load a labels file you pick). `--no-serve` writes a static
   `metrics/<name>__labeler.html` (Export downloads the file) and exits; `--no-open`
   prints the URL instead of launching a browser.
 - `--scoring` — `mcc` (default), `f1`, `f_beta`, `balanced_accuracy`, `roc_auc`,
@@ -129,7 +130,9 @@ user to recall timestamps** — it is the easiest, most reliable path:
    at once (above/below, with an optional gap-bridge); it captures within the
    current view by default, and dragging across the chart limits it to a time
    window (different boundary per period) — the painted window is **saved with the
-   set and restored on reopen** (a `capture_windows:` block; metadata only). Each
+   set and restored on reopen** (a `capture_windows:` block; metadata only). For an
+   irregular cloud, **Lasso capture** loops around the points freehand and turns
+   each grid-adjacent run (small gaps bridged) into one incident span. Each
    band's ✕ (or select + Delete)
    removes one, and **focus** on a list row jumps the chart to it.
 3. That writes `incidents/<metric>/<metric>[-<set>]-<UTC>.yml` automatically

{detectkit-0.36.2 → detectkit-0.38.0}/detectkit/cli/assets/claude/rules/cli.md RENAMED Viewed

@@ -80,32 +80,45 @@ view of the metric's **real** persisted series and lets you turn the detector's
 knobs (type — including **Manual bounds** with lower/upper sliders — threshold,
 window, recency weighting + half-life, detrend, smoothing, **seasonality groups**,
 **direction** (both/up/down), alert `consecutive_anomalies`) while the confidence
-band and flagged anomalies **recompute live**. The chart is **zoomable** (scroll/drag +
-a navigator strip) and a **"Points shown"** slider trims the active sample to speed
-up recompute on a long metric. Clicking **Apply** writes the chosen
+band and flagged anomalies **recompute live**. The whole screen is a **chart-first
+cockpit**: ONE chart (the windshield) fills the view, every knob lives in a
+**collapsible dock under it**, the metrics ride beneath the chart, and the chart is
+**zoomable** (scroll/drag + navigator strip) with a **"Points shown"** trim slider.
+Clicking **Apply** writes the chosen
 config back into the metric YAML **in place** (autotune, by contrast, writes a new
 `__tuned_<id>.yml` and never edits the original). Reads the metric's loaded
 datapoints (run `dtk run --steps load` first if empty); the selector must resolve
 to a single metric.
-**Mark incidents + see alert quality live.** A second, **synced** chart beneath
-the detector view lets you **mark the real incidents** (drag to create a span,
-drag its edges/middle to adjust, ✕ or Delete to remove), or **Threshold capture**
-every contiguous span past a horizontal line in one shot (set the line by click or
-value, above/below, optional gap-bridging, optionally limited to a painted time
-window — the same tool as the autotune labeler; the window is saved as
-`capture_windows` and restored on reopen). As you tune, a metrics
-bar shows two operator numbers: **incident catch rate (recall)** — how many marked
-incidents your config catches — and **false-alert rate** — what share of alerts
-fall outside any real incident ("≈1 in N false"); only incidents within the loaded
+**Modes + alert review + live quality.** A **mode switch** picks which layers lead
+and which interactions are armed on the one chart: **Tune** (band leads; incidents
+recede to read-only context; hover a point for its window), **Review** (the fired
+alerts lead, band ghosts — click an alert marker to cycle its verdict un-reviewed →
+**valid** (green) → **false alarm** (slate); **Confirm all unreviewed valid** does
+the lot), and **Label** (band hides; **mark the real incidents** by drag, **Lasso
+anomalies** — loop a cloud of anomaly dots, each consecutive run, gaps bridged up to
+`consecutive_anomalies`, becomes one span — or **Threshold capture** every span past
+a horizontal line, each widened to a full interval so the alert lands inside; the
+painted window saves as `capture_windows`). A confirmed (valid) alert is the user
+asserting a real incident happened there — it folds in as a virtual incident (counts
+toward recall + correct) so a clean metric whose alerts are all good is validated in
+a few clicks **without hand-drawing spans**, and is written as an incident on Save.
+As you tune, a metrics bar shows **incident catch rate (recall)** — how many
+ground-truth incidents (marked + validated) your config catches (an incident is
+caught when an alert's anomaly **streak overlaps** it, not just the fire instant) —
+**false-alert rate** (what share of alerts fall outside any incident and aren't
+confirmed valid; "≈1 in N false", a decimal so a mostly-false rate doesn't round to
+a misleading "1 in 1") — and **reviewed N/M**; only incidents within the loaded
 window are scored. **Save incidents** writes a
 versioned `incidents/<metric>/*.yml` — the same store `dtk autotune` reads, so the
 same labels feed the next supervised tune (it seeds from the newest file on open,
 **anchoring the budget-sized loaded window on the seeded incidents** — ending just
 past the latest one rather than at the last datapoint — so they render/count
-without an old outlier pulling the whole history in). Saving incidents does not end
-the session; only **Apply** does. A
-**y = 0 line** toggle (shared with `dtk run --report`) shows the metric relative to zero.
+without an old outlier pulling the whole history in; per-alert verdicts persist as
+an `alert_reviews:` metadata block and re-seed on reopen, re-bound to the moved
+alerts by streak overlap). Saving incidents does not end the session; only **Apply**
+does. A **y = 0 line** toggle (shared with `dtk run --report`) shows the metric
+relative to zero.
 Safe write-back: the config is validated before anything is written, the previous
 YAML is archived under `metrics/.history/<metric>/`, and only then is the metric

{detectkit-0.36.2 → detectkit-0.38.0}/detectkit/cli/commands/tune.py RENAMED Viewed

@@ -16,6 +16,7 @@ from __future__ import annotations
 import click
 from detectkit.autotune.labels import (
+    load_alert_reviews,
     load_capture_windows,
     load_incidents_for_display,
     newest_labels_file,
@@ -70,6 +71,7 @@ def run_tune(
     incidents_dir = project_root / "incidents" / name
     preload_incidents: list[dict[str, str]] = []
     preload_capture: list[dict[str, str]] = []
+    preload_reviews: list[dict[str, str]] = []
     newest = newest_labels_file(incidents_dir)
     if newest is not None:
         try:
@@ -79,6 +81,9 @@ def run_tune(
             preload_capture = load_capture_windows(
                 newest, interval_seconds=interval_seconds, metric_name=name
             )
+            preload_reviews = load_alert_reviews(
+                newest, interval_seconds=interval_seconds, metric_name=name
+            )
             click.echo(
                 f"  Seeded {len(preload_incidents)} incident(s) from "
                 f"{newest.relative_to(project_root)}"
@@ -99,6 +104,7 @@ def run_tune(
         project_name=project_name,
         incidents=preload_incidents,
         capture_windows=preload_capture,
+        alert_reviews=preload_reviews,
     )
     n_points = len(payload["points"])
     if n_points == 0:

detectkit 0.36.2__tar.gz → 0.38.0__tar.gz

detectkit 0.36.2tar.gz → 0.38.0tar.gz