Eval updates

Makefile

@@ -1,4 +1,4 @@
-.PHONY: help docker-build docker-run local-install local-run local-test local-test-integration eval-photo-v1 eval-dance-v1 eval-photo-matrix eval-dance-matrix data-photos data-dance
+.PHONY: help docker-build docker-run local-install local-run local-test local-test-integration eval-photo eval-dance eval-photo-matrix eval-dance-matrix data-photos data-dance
 
 help:
 	@echo "---------------------------------------------------"
@@ -35,33 +35,35 @@ local-test-integration:
 	uv run pytest -q -m integration
 
 eval-photo:
-	uv run python scripts/classify_dataset.py \
+	uv run photo-eval single \
 		--label-set label-dataset/personal-photos-lite-v1.json \
 		--images data_eval/photos/normalized \
-		--csv data_results/personal-photos-lite-v1.csv
+		--out-dir data_results \
+		--summary
 
 eval-dance:
-	uv run python scripts/classify_dataset.py \
+	uv run photo-eval single \
 		--label-set label-dataset/scene-dance-formation-group-v1.json \
 		--images data_eval/dance/normalized \
-		--csv data_results/scene-dance-formation-group-v1.csv
+		--out-dir data_results \
+		--summary
 
 eval-photo-matrix:
-	uv run python scripts/eval_matrix.py \
+	uv run photo-eval matrix \
 		--label-sets "label-dataset/personal-photos-*.json" \
 		--images data_eval/photos/normalized \
 		--out-dir data_results \
-		--summary-csv data_results/personal-photos-summary.csv
+		--summary
 
 eval-dance-matrix:
-	uv run python scripts/eval_matrix.py \
+	uv run photo-eval matrix \
 		--label-sets "label-dataset/scene-dance-*.json" \
 		--images data_eval/dance/normalized \
 		--out-dir data_results \
-		--summary-csv data_results/dance-summary.csv
+		--summary
 
 data-photos:
-	uv run python scripts/dataset_prep.py --out data_eval --target photos --n 50 --normalize
+	uv run photo-eval prep --out data_eval --target photos --n 50 --normalize
 
 data-dance:
-	uv run python scripts/dataset_prep.py --out data_eval --target dance --n 50 --normalize
+	uv run photo-eval prep --out data_eval --target dance --n 50 --normalize

README.md

@@ -154,36 +154,41 @@ Error handling and HTTP boundaries:
 
 ## Eval scripts
 
-Use the lightweight evaluator in `scripts/classify_dataset.py` to run a label set against
+Use the lightweight evaluator via `photo-eval` to run a label set against
 local images and capture timings:
 
 ```bash
-uv run python scripts/classify_dataset.py \
+uv run photo-eval single \
   --label-set label-dataset/personal-photos-lite-v1.json \
   --images /path/to/images \
-  --csv data_results/summary.csv
+  --out-dir data_results \
+  --summary
 ```
 
+Output CSV files are timestamped (UTC) in `data_results/`.
+
 Makefile shortcuts:
 
-- `make eval-photo-v1`
-- `make eval-dance-v1`
+- `make eval-photo`
+- `make eval-dance`
 - `make eval-photo-matrix`
 - `make eval-dance-matrix`
 
+See `src/eval/README.md` for the eval CLI reference and API endpoints.
+
 Matrix eval (multiple label sets against the same images):
 
 ```bash
-uv run python scripts/eval_matrix.py \
+uv run photo-eval matrix \
   --label-sets "label-dataset/personal-photos-*.json" \
   --images data_eval/photos/normalized \
   --out-dir data_results \
-  --summary-csv data_results/personal-photos-summary.csv
+  --summary
 ```
 
 ## Eval datasets (download schema)
 
-We use a simple, reproducible layout for evaluation datasets created by `scripts/dataset_prep.py`:
+We use a simple, reproducible layout for evaluation datasets created by `photo-eval prep`:
 
 ```
 data_eval/
@@ -198,20 +203,20 @@ data_eval/
 Download and normalize (recommended):
 
 ```bash
-uv run python scripts/dataset_prep.py --out data_eval --target photos --n 50 --normalize
-uv run python scripts/dataset_prep.py --out data_eval --target dance --n 50 --normalize
+uv run photo-eval prep --out data_eval --target photos --n 50 --normalize
+uv run photo-eval prep --out data_eval --target dance --n 50 --normalize
 ```
 
 Reset existing files and start fresh:
 
 ```bash
-uv run python scripts/dataset_prep.py --out data_eval --target photos --n 50 --normalize --reset
+uv run photo-eval prep --out data_eval --target photos --n 50 --normalize --reset
 ```
 
 Normalize your own folder into the same schema:
 
 ```bash
-uv run python scripts/dataset_prep.py --normalize-only --in-dir /path/to/images --out data_eval/photos
+uv run photo-eval prep --normalize-only --in-dir /path/to/images --out data_eval/photos
 ```
 
 ## Project layout

pyproject.toml

@@ -27,6 +27,9 @@ dev = [
   "tqdm==4.66.5",
 ]
 
+[project.scripts]
+photo-eval = "eval.cli:main"
+
 [tool.setuptools]
 package-dir = {"" = "src"}
 

src/eval/README.md

@@ -0,0 +1,41 @@
+# Eval CLI
+
+Quick reference for the standalone evaluation tools in `src/eval`.
+
+## Commands
+
+- `photo-eval prep`  
+  Download a small evaluation dataset (photos or dance) and optionally normalize.
+
+- `photo-eval single`  
+  Upload one label set, classify a set of images, and write timestamped CSV + optional summary.
+
+- `photo-eval matrix`  
+  Upload multiple label sets and run the same images against each; outputs a matrix CSV + optional summary.
+
+## API endpoints used
+
+All eval commands call the running API (default `http://localhost:7860`):
+
+- `POST /api/v1/label-sets` (upload a label set)
+- `POST /api/v1/label-sets/{label_set_hash}/activate` (optional for `single` via `--activate`)
+- `POST /api/v1/classify` (classify image with optional `label_set_hash`)
+
+## Examples
+
+```bash
+photo-eval prep --out data_eval --target photos --n 50 --normalize
+photo-eval prep --out data_eval --target dance --n 50 --normalize
+
+photo-eval single \
+  --label-set label-dataset/personal-photos-lite-v1.json \
+  --images data_eval/photos/normalized \
+  --out-dir data_results \
+  --summary
+
+photo-eval matrix \
+  --label-sets "label-dataset/personal-photos-*.json" \
+  --images data_eval/photos/normalized \
+  --out-dir data_results \
+  --summary
+```

src/eval/__init__.py

@@ -0,0 +1 @@
+"""Eval CLI package (autonomous from app)."""

{scripts → src/eval}/classify_dataset.py

@@ -1,17 +1,15 @@
 #!/usr/bin/env python3
 from __future__ import annotations
 
-import base64
-import csv
 import json
 from dataclasses import dataclass
-from datetime import datetime, timezone
 from pathlib import Path
-from typing import Iterable
 
 import click
 import httpx
 
+from eval import common
+
 
 @dataclass(frozen=True)
 class Config:
@@ -27,44 +25,11 @@ class Config:
     summary: bool
 
 
-def iter_images(paths: list[Path]) -> Iterable[Path]:
-    exts = {".jpg", ".jpeg", ".png", ".webp"}
-    for path in paths:
-        if path.is_dir():
-            for p in sorted(path.rglob("*")):
-                if p.suffix.lower() in exts and p.is_file():
-                    yield p
-        elif path.is_file() and path.suffix.lower() in exts:
-            yield path
-
-
-def b64_image(path: Path) -> str:
-    return base64.b64encode(path.read_bytes()).decode("utf-8")
-
-
-def upload_label_set(client: httpx.Client, label_set: Path) -> str:
-    payload = json.loads(label_set.read_text())
-    r = client.post("/api/v1/label-sets", json=payload)
-    r.raise_for_status()
-    return r.json()["label_set_hash"]
-
-
 def activate_label_set(client: httpx.Client, label_set_hash: str) -> None:
     r = client.post(f"/api/v1/label-sets/{label_set_hash}/activate")
     r.raise_for_status()
 
 
-def classify_one(client: httpx.Client, label_set_hash: str, image: Path, domain_top_n: int, top_k: int) -> dict:
-    payload = {
-        "image_base64": b64_image(image),
-        "domain_top_n": domain_top_n,
-        "top_k": top_k,
-    }
-    r = client.post(f"/api/v1/classify?label_set_hash={label_set_hash}", json=payload)
-    r.raise_for_status()
-    return r.json()
-
-
 def to_row(image: Path, data: dict) -> dict[str, str]:
     domain_hits = data.get("domain_hits", [])
     label_hits = data.get("label_hits", [])
@@ -73,71 +38,16 @@ def to_row(image: Path, data: dict) -> dict[str, str]:
         "label_set_hash": data.get("label_set_hash", ""),
         "model_id": data.get("model_id", ""),
         "chosen_domains": "|".join(data.get("chosen_domains", [])),
-        "domain_hits": "|".join(f"{d.get('id')}:{d.get('score'):.4f}" for d in domain_hits),
-        "label_hits": "|".join(f"{l.get('id')}:{l.get('score'):.4f}" for l in label_hits),
+        "domain_hits": "|".join(common.fmt_hit(d) for d in domain_hits),
+        "label_hits": "|".join(common.fmt_hit(l) for l in label_hits),
         "elapsed_ms": str(data.get("elapsed_ms", "")),
         "elapsed_domain_ms": str(data.get("elapsed_domain_ms", "")),
         "elapsed_labels_ms": str(data.get("elapsed_labels_ms", "")),
     }
 
 
-def write_csv(path: Path, rows: list[dict[str, str]]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with path.open("w", newline="", encoding="utf-8") as f:
-        writer = csv.DictWriter(
-            f,
-                fieldnames=[
-                    "image",
-                    "label_set_hash",
-                    "model_id",
-                    "chosen_domains",
-                    "domain_hits",
-                    "label_hits",
-                    "elapsed_ms",
-                    "elapsed_domain_ms",
-                    "elapsed_labels_ms",
-                ],
-            )
-            writer.writeheader()
-            writer.writerows(rows)
-
-
-def _percentile(values: list[int], q: float) -> int:
-    if not values:
-        return 0
-    values = sorted(values)
-    idx = int(round((len(values) - 1) * q))
-    return values[idx]
-
-
-def write_summary(path: Path, rows: list[dict[str, str]]) -> None:
-    times: list[int] = []
-    for row in rows:
-        try:
-            times.append(int(row["elapsed_ms"]))
-        except Exception:
-            continue
-    summary = {
-        "count": str(len(times)),
-        "avg_elapsed_ms": str(int(sum(times) / max(1, len(times)))),
-        "p50_elapsed_ms": str(_percentile(times, 0.50)),
-        "p90_elapsed_ms": str(_percentile(times, 0.90)),
-        "p95_elapsed_ms": str(_percentile(times, 0.95)),
-        "p99_elapsed_ms": str(_percentile(times, 0.99)),
-    }
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with path.open("w", newline="", encoding="utf-8") as f:
-        writer = csv.DictWriter(f, fieldnames=list(summary.keys()))
-        writer.writeheader()
-        writer.writerow(summary)
-
-
-def _timestamp() -> str:
-    return datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
-
-
 def run(cfg: Config) -> int:
-    images = list(iter_images(cfg.images))
+    images = list(common.iter_images(cfg.images))
     if cfg.limit > 0:
         images = images[: cfg.limit]
     if not images:
@@ -145,26 +55,43 @@ def run(cfg: Config) -> int:
 
     rows: list[dict[str, str]] = []
     with httpx.Client(base_url=cfg.api, timeout=30) as client:
-        label_set_hash = upload_label_set(client, cfg.label_set)
+        label_set_hash = common.upload_label_set(client, cfg.label_set)
         if cfg.activate:
             activate_label_set(client, label_set_hash)
 
         for image in images:
-            data = classify_one(client, label_set_hash, image, cfg.domain_top_n, cfg.top_k)
+            data = common.classify_one(
+                client,
+                label_set_hash,
+                image_b64=common.encode_image_b64(image),
+                domain_top_n=cfg.domain_top_n,
+                top_k=cfg.top_k,
+            )
             print(json.dumps({"image": str(image), "result": data}, ensure_ascii=True))
             rows.append(to_row(image, data))
 
+    fieldnames = [
+        "image",
+        "label_set_hash",
+        "model_id",
+        "chosen_domains",
+        "domain_hits",
+        "label_hits",
+        "elapsed_ms",
+        "elapsed_domain_ms",
+        "elapsed_labels_ms",
+    ]
+
     if cfg.csv_path and rows:
-        write_csv(cfg.csv_path, rows)
+        common.write_csv(cfg.csv_path, rows, fieldnames)
     elif rows:
-        ts = _timestamp()
-        out_path = cfg.out_dir / f"{cfg.label_set.stem}_{ts}.csv"
-        write_csv(out_path, rows)
+        out_path = cfg.out_dir / f"{cfg.label_set.stem}_{common.timestamp()}.csv"
+        common.write_csv(out_path, rows, fieldnames)
 
     if cfg.summary:
-        ts = _timestamp()
-        summary_path = cfg.out_dir / f"{cfg.label_set.stem}_summary_{ts}.csv"
-        write_summary(summary_path, rows)
+        summary = common.summarize_latency(rows)
+        summary_path = cfg.out_dir / f"{cfg.label_set.stem}_summary_{common.timestamp()}.csv"
+        common.write_csv(summary_path, [summary], list(summary.keys()))
 
     return 0
 

src/eval/cli.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import click
+
+from eval.classify_dataset import cli as classify_cli
+from eval.dataset_prep import cli as prep_cli
+from eval.eval_matrix import cli as matrix_cli
+
+
+@click.group()
+def main() -> None:
+    """Evaluation CLI (standalone from the API)."""
+
+
+main.add_command(prep_cli, name="prep")
+main.add_command(classify_cli, name="single")
+main.add_command(matrix_cli, name="matrix")
+
+
+if __name__ == "__main__":
+    main()

src/eval/common.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import base64
+import csv
+import json
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Iterable
+
+import httpx
+
+
+@dataclass(frozen=True)
+class EvalConfig:
+    api: str
+    images: list[Path]
+    domain_top_n: int
+    top_k: int
+    out_dir: Path
+    summary: bool
+
+
+def iter_images(paths: Iterable[Path]) -> Iterable[Path]:
+    exts = {".jpg", ".jpeg", ".png", ".webp"}
+    for path in paths:
+        if path.is_dir():
+            for p in sorted(path.rglob("*")):
+                if p.is_file() and p.suffix.lower() in exts:
+                    yield p
+        elif path.is_file() and path.suffix.lower() in exts:
+            yield path
+
+
+def upload_label_set(client: httpx.Client, label_set: Path) -> str:
+    payload = json.loads(label_set.read_text())
+    r = client.post("/api/v1/label-sets", json=payload)
+    r.raise_for_status()
+    return r.json()["label_set_hash"]
+
+
+def classify_one(
+    client: httpx.Client,
+    label_set_hash: str,
+    image_b64: str,
+    domain_top_n: int,
+    top_k: int,
+) -> dict:
+    payload = {
+        "image_base64": image_b64,
+        "domain_top_n": domain_top_n,
+        "top_k": top_k,
+    }
+    r = client.post(f"/api/v1/classify?label_set_hash={label_set_hash}", json=payload)
+    r.raise_for_status()
+    return r.json()
+
+
+def encode_image_b64(path: Path) -> str:
+    return base64.b64encode(path.read_bytes()).decode("utf-8")
+
+
+def fmt_hit(hit: dict) -> str:
+    score = hit.get("score")
+    try:
+        score_str = f"{float(score):.4f}"
+    except Exception:
+        score_str = ""
+    return f"{hit.get('id')}:{score_str}"
+
+
+def percentile(values: list[int], q: float) -> int:
+    if not values:
+        return 0
+    values = sorted(values)
+    idx = int(round((len(values) - 1) * q))
+    return values[idx]
+
+
+def timestamp() -> str:
+    return datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+
+
+def write_csv(path: Path, rows: list[dict[str, str]], fieldnames: list[str]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def summarize_latency(rows: list[dict[str, str]]) -> dict[str, str]:
+    times: list[int] = []
+    for row in rows:
+        try:
+            times.append(int(row["elapsed_ms"]))
+        except Exception:
+            continue
+    return {
+        "count": str(len(times)),
+        "avg_elapsed_ms": str(int(sum(times) / max(1, len(times)))),
+        "p50_elapsed_ms": str(percentile(times, 0.50)),
+        "p90_elapsed_ms": str(percentile(times, 0.90)),
+        "p95_elapsed_ms": str(percentile(times, 0.95)),
+        "p99_elapsed_ms": str(percentile(times, 0.99)),
+    }

{scripts → src/eval}/eval_matrix.py

@@ -1,16 +1,16 @@
 #!/usr/bin/env python3
 from __future__ import annotations
 
-import csv
 import json
 from dataclasses import dataclass
-import base64
 from pathlib import Path
 from typing import Iterable
 
 import click
 import httpx
 
+from eval import common
+
 
 @dataclass(frozen=True)
 class Config:
@@ -20,18 +20,7 @@ class Config:
     domain_top_n: int
     top_k: int
     out_dir: Path
-    summary_csv: Path | None
-
-
-def iter_images(paths: Iterable[Path]) -> Iterable[Path]:
-    exts = {".jpg", ".jpeg", ".png", ".webp"}
-    for path in paths:
-        if path.is_dir():
-            for p in sorted(path.rglob("*")):
-                if p.is_file() and p.suffix.lower() in exts:
-                    yield p
-        elif path.is_file() and path.suffix.lower() in exts:
-            yield path
+    summary: bool
 
 
 def expand_label_sets(paths: Iterable[str]) -> list[Path]:
@@ -45,64 +34,24 @@ def expand_label_sets(paths: Iterable[str]) -> list[Path]:
     return [p for p in out if p.is_file()]
 
 
-def upload_label_set(client: httpx.Client, label_set: Path) -> str:
-    payload = json.loads(label_set.read_text())
-    r = client.post("/api/v1/label-sets", json=payload)
-    r.raise_for_status()
-    return r.json()["label_set_hash"]
-
-
-def classify_one(
-    client: httpx.Client,
-    label_set_hash: str,
-    image_b64: str,
-    domain_top_n: int,
-    top_k: int,
-) -> dict:
-    payload = {
-        "image_base64": image_b64,
-        "domain_top_n": domain_top_n,
-        "top_k": top_k,
-    }
-    r = client.post(f"/api/v1/classify?label_set_hash={label_set_hash}", json=payload)
-    r.raise_for_status()
-    return r.json()
-
-
 def to_row(label_set: Path, image: Path, data: dict) -> dict[str, str]:
+    domain_hits = data.get("domain_hits", [])
+    label_hits = data.get("label_hits", [])
     return {
         "label_set": label_set.name,
         "image": str(image),
         "label_set_hash": data.get("label_set_hash", ""),
         "model_id": data.get("model_id", ""),
         "chosen_domains": "|".join(data.get("chosen_domains", [])),
+        "domain_hits": "|".join(common.fmt_hit(d) for d in domain_hits),
+        "label_hits": "|".join(common.fmt_hit(l) for l in label_hits),
         "elapsed_ms": str(data.get("elapsed_ms", "")),
         "elapsed_domain_ms": str(data.get("elapsed_domain_ms", "")),
         "elapsed_labels_ms": str(data.get("elapsed_labels_ms", "")),
     }
 
 
-def write_csv(path: Path, rows: list[dict[str, str]]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with path.open("w", newline="", encoding="utf-8") as f:
-        writer = csv.DictWriter(
-            f,
-            fieldnames=[
-                "label_set",
-                "image",
-                "label_set_hash",
-                "model_id",
-                "chosen_domains",
-                "elapsed_ms",
-                "elapsed_domain_ms",
-                "elapsed_labels_ms",
-            ],
-        )
-        writer.writeheader()
-        writer.writerows(rows)
-
-
-def write_summary(path: Path, rows: list[dict[str, str]]) -> None:
+def summarize_by_label_set(rows: list[dict[str, str]]) -> list[dict[str, str]]:
     summary: dict[str, list[int]] = {}
     for row in rows:
         label = row["label_set"]
@@ -115,17 +64,20 @@ def write_summary(path: Path, rows: list[dict[str, str]]) -> None:
     out_rows: list[dict[str, str]] = []
     for label, times in summary.items():
         avg = int(sum(times) / max(1, len(times)))
-        out_rows.append({"label_set": label, "count": str(len(times)), "avg_elapsed_ms": str(avg)})
-
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with path.open("w", newline="", encoding="utf-8") as f:
-        writer = csv.DictWriter(f, fieldnames=["label_set", "count", "avg_elapsed_ms"])
-        writer.writeheader()
-        writer.writerows(out_rows)
+        out_rows.append(
+            {
+                "label_set": label,
+                "count": str(len(times)),
+                "avg_elapsed_ms": str(avg),
+                "p50_elapsed_ms": str(common.percentile(times, 0.50)),
+                "p95_elapsed_ms": str(common.percentile(times, 0.95)),
+            }
+        )
+    return out_rows
 
 
 def run(cfg: Config) -> None:
-    images = list(iter_images(cfg.images))
+    images = list(common.iter_images(cfg.images))
     if not images:
         raise SystemExit("No images found.")
     if not cfg.label_sets:
@@ -134,23 +86,38 @@ def run(cfg: Config) -> None:
     rows: list[dict[str, str]] = []
     with httpx.Client(base_url=cfg.api, timeout=30) as client:
         for label_set in cfg.label_sets:
-            label_set_hash = upload_label_set(client, label_set)
+            label_set_hash = common.upload_label_set(client, label_set)
             for image in images:
-                image_b64 = image.read_bytes()
-                data = classify_one(
+                data = common.classify_one(
                     client,
                     label_set_hash,
-                    image_b64=base64.b64encode(image_b64).decode("utf-8"),
+                    image_b64=common.encode_image_b64(image),
                     domain_top_n=cfg.domain_top_n,
                     top_k=cfg.top_k,
                 )
                 print(json.dumps({"label_set": label_set.name, "image": str(image), "result": data}))
                 rows.append(to_row(label_set, image, data))
 
-    out_path = cfg.out_dir / "eval_matrix.csv"
-    write_csv(out_path, rows)
-    if cfg.summary_csv:
-        write_summary(cfg.summary_csv, rows)
+    fieldnames = [
+        "label_set",
+        "image",
+        "label_set_hash",
+        "model_id",
+        "chosen_domains",
+        "domain_hits",
+        "label_hits",
+        "elapsed_ms",
+        "elapsed_domain_ms",
+        "elapsed_labels_ms",
+    ]
+
+    out_path = cfg.out_dir / f"eval_matrix_{common.timestamp()}.csv"
+    common.write_csv(out_path, rows, fieldnames)
+
+    if cfg.summary:
+        summary_rows = summarize_by_label_set(rows)
+        summary_path = cfg.out_dir / f"eval_matrix_summary_{common.timestamp()}.csv"
+        common.write_csv(summary_path, summary_rows, ["label_set", "count", "avg_elapsed_ms", "p50_elapsed_ms", "p95_elapsed_ms"])
 
 
 @click.command()
@@ -160,7 +127,7 @@ def run(cfg: Config) -> None:
 @click.option("--domain-top-n", default=2, show_default=True, type=int)
 @click.option("--top-k", default=5, show_default=True, type=int)
 @click.option("--out-dir", default="data_results", show_default=True, type=click.Path(path_type=Path))
-@click.option("--summary-csv", type=click.Path(path_type=Path))
+@click.option("--summary", is_flag=True, default=False)
 def cli(
     api: str,
     label_sets_raw: tuple[str, ...],
@@ -168,7 +135,7 @@ def cli(
     domain_top_n: int,
     top_k: int,
     out_dir: Path,
-    summary_csv: Path | None,
+    summary: bool,
 ) -> None:
     label_sets = expand_label_sets(label_sets_raw)
     cfg = Config(
@@ -178,7 +145,7 @@ def cli(
         domain_top_n=domain_top_n,
         top_k=top_k,
         out_dir=out_dir,
-        summary_csv=summary_csv,
+        summary=summary,
     )
     run(cfg)
 

tests/test_eval_common.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from eval import common
+
+
+def test_percentile_basic():
+    values = [10, 20, 30, 40, 50]
+    assert common.percentile(values, 0.0) == 10
+    assert common.percentile(values, 0.5) == 30
+    assert common.percentile(values, 1.0) == 50
+
+
+def test_summarize_latency_empty():
+    summary = common.summarize_latency([])
+    assert summary["count"] == "0"
+    assert summary["avg_elapsed_ms"] == "0"