tuieval 0.2.0.dev35__py3-none-any.whl → 0.2.0.dev43__py3-none-any.whl

tuieval/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.0.dev35'
-__version_tuple__ = version_tuple = (0, 2, 0, 'dev35')
+__version__ = version = '0.2.0.dev43'
+__version_tuple__ = version_tuple = (0, 2, 0, 'dev43')
 
 __commit_id__ = commit_id = None

tuieval/cli.py

@@ -14,11 +14,12 @@ Start here
 
 Day to day
   tuieval compare [...]       scorecards (--speed, --pairwise, --failures)
+  tuieval pta                 the PTA index: privacy, time and accuracy per model, as a triangle
   tuieval report              the verdicts with their evidence, as a markdown file
   tuieval history             every verdict change, newest first
   tuieval items               tests that don't separate models or look broken
   tuieval capture LOG --pack  turn a real failure (logs/live/*.txt) into a new test
-  tuieval regrade             re-score stored answers after changing a grader
+  tuieval regrade             re-score stored answers after changing a grader (--only, --packs)
   tuieval list                the models tuieval knows, hidden ones separately (--packs: the packs)
   tuieval remove MODEL        remove models, or every hidden one (--hidden); archived in removed/
 

tuieval/client.py

@@ -17,6 +17,10 @@ import time
 import urllib.parse
 
 SERVER_ERROR_PREFIXES = ("server returned HTTP 5", "server returned HTTP 429", "server error", "connection error")
+# the model can't be reached there at all (a bad key, no credits, or a hosted API with no provider serving it, e.g.
+# OpenRouter's 404 "No endpoints found"): not the model's answer either, and waiting won't fix it
+UNAVAILABLE_PREFIXES = ("server returned HTTP 401", "server returned HTTP 402", "server returned HTTP 403",
+                        "server returned HTTP 404")
 
 
 def is_server_error(error):
@@ -27,9 +31,15 @@ def is_server_error(error):
         and "timeout" not in error.lower()
 
 
+def is_unavailable(error):
+    """True for an error saying the model isn't available on that server at all: HTTP 401, 402, 403 or
+    404. Never the model's answer, and not worth retrying."""
+    return bool(error) and error.startswith(UNAVAILABLE_PREFIXES)
+
+
 def server_error_row(rec):
     """A stored answer that was really a server failure (never a judgement of the model)."""
-    return not rec.get("pass") and is_server_error(rec.get("reason"))
+    return not rec.get("pass") and (is_server_error(rec.get("reason")) or is_unavailable(rec.get("reason")))
 
 
 class Cancelled(Exception):

tuieval/engine.py

@@ -2105,6 +2105,9 @@ class Engine:
                     self._check()
                     if res["error"] and not alive():
                         raise ModelFailed(f"the server stopped: {res['error']}")
+                    if client.is_unavailable(res["error"]):   # never an answer; retrying won't help
+                        raise ModelFailed(f"the model isn't available there (not counted against it): "
+                                          f"{res['error'][:300]}")
                     if not client.is_server_error(res["error"]):
                         break
                     # the server failed, not the model: never recorded as an answer

tuieval/pta.py

@@ -0,0 +1,185 @@
+"""PTA index: privacy, time and accuracy per model, 0-100 each, drawn as a radar triangle.
+
+    P  privacy   100 when prompts stay on machines you control: tuieval starts the server, its URL
+                 is this machine, or the server is marked private = true in models.toml. 0 otherwise
+                 (a hosted API: there's no partial privacy once prompts leave).
+    T  time      the total time to answer every question compared (each question at its median over
+                 repeats), relative to the fastest model: 100 x fastest total / this model's total.
+    A  accuracy  the share of answers to those questions that passed.
+
+Models are compared on the questions all of them answered, so one that skipped some never looks
+faster. There's no combined number: the three stay side by side, and verdicts and critical
+failures stay where they are (verdict.py).
+"""
+import urllib.parse
+
+from . import compare
+
+LOCAL_HOSTS = {"localhost", "127.0.0.1", "::1", "0.0.0.0"}
+# one colour per model on the triangle; more models than colours are listed but not drawn
+COLORS = ["cyan", "magenta", "yellow", "green", "red", "blue", "bright_white", "bright_cyan"]
+
+
+def privacy(cfg, label):
+    """100 if a model's prompts stay on machines you control, else 0 (see the module docstring);
+    None for a model that's no longer in models.toml (where it ran isn't known)."""
+    m = next((m for m in cfg["models"] if m["label"] == label), None)
+    server = cfg["servers"].get(m["server"], {}) if m else {}
+    if not server:
+        return None
+    if server.get("cmd") or server.get("private"):
+        return 100
+    host = urllib.parse.urlparse(server.get("url", "")).hostname or ""
+    return 100 if host.lower() in LOCAL_HOSTS else 0
+
+
+def index(rows, privacy_of, models=None):
+    """{"questions": n shared, "models": [{model, P, T, A, total_s, passed, answers, alongside}]},
+    best accuracy first. models: the ones to compare (default: every model in rows)."""
+    tests = compare.per_question(rows)
+    models = sorted(models or {m for t in tests for m in t["cells"]})
+    shared = [t for t in tests if models and all(m in t["cells"] for m in models)]
+    out = []
+    for m in models:
+        cells = [t["cells"][m] for t in shared]
+        answers = sum(c["n"] for c in cells)
+        out.append({"model": m, "P": privacy_of(m), "total_s": sum(c["secs"] or 0 for c in cells),
+                    "passed": sum(c["passed"] for c in cells), "answers": answers,
+                    "A": 100 * sum(c["passed"] for c in cells) / answers if answers else None,
+                    # answers that ran while other models were served shared the machine's speed
+                    "alongside": any(r.get("alongside") for c in cells for r in c["rows"])})
+    fastest = min((x["total_s"] for x in out if x["total_s"] > 0), default=None)
+    for x in out:
+        x["T"] = 100 * fastest / x["total_s"] if fastest and x["total_s"] > 0 else None
+    out.sort(key=lambda x: (-(x["A"] or 0), -(x["T"] or 0), x["model"]))
+    return {"questions": len(shared), "models": out}
+
+
+# ---------------------------------------------------------------- the triangle (braille, no dependencies)
+_DOTS = ((0x01, 0x08), (0x02, 0x10), (0x04, 0x20), (0x40, 0x80))   # braille dot bits by (row, column)
+
+
+class _Canvas:
+    """Braille cells, 2 dots wide and 4 tall each; every cell takes the colour of the last line through it."""
+    def __init__(self, cols, rows):
+        self.cols, self.rows = cols, rows
+        self.bits = [[0] * cols for _ in range(rows)]
+        self.color = [[None] * cols for _ in range(rows)]
+
+    def dot(self, x, y, color):
+        cx, cy = int(x) // 2, int(y) // 4
+        if 0 <= cx < self.cols and 0 <= cy < self.rows:
+            self.bits[cy][cx] |= _DOTS[int(y) % 4][int(x) % 2]
+            self.color[cy][cx] = color
+
+    def line(self, a, b, color, dotted=False):
+        steps = int(max(abs(b[0] - a[0]), abs(b[1] - a[1]))) or 1
+        for i in range(steps + 1):
+            if dotted and i % 3:
+                continue
+            self.dot(a[0] + (b[0] - a[0]) * i / steps, a[1] + (b[1] - a[1]) * i / steps, color)
+
+    def text(self):
+        lines = []
+        for bits, colors in zip(self.bits, self.color):
+            out = []
+            for b, c in zip(bits, colors):
+                ch = chr(0x2800 + b) if b else " "
+                out.append(f"[{c}]{ch}[/]" if b and c else ch)
+            lines.append("".join(out).rstrip())
+        return lines
+
+
+def triangle(result, width=60):
+    """The radar triangle as Rich markup lines: P at the top, T bottom left, A bottom right; a
+    model's triangle reaches each corner as far as its score (bigger = better all round)."""
+    cols = max(20, width)
+    w = cols * 2 - 2                            # dots across
+    h = int(w * 0.866)                          # an equilateral triangle (braille dots are about square)
+    rows = h // 4 + 1
+    top, left, right = (w / 2, 0), (0, h), (w, h)
+    center = (w / 2, h * 2 / 3)
+    c = _Canvas(cols, rows)
+
+    def at(corner, score):
+        return (center[0] + (corner[0] - center[0]) * score / 100, center[1] + (corner[1] - center[1]) * score / 100)
+
+    for corner in (top, left, right):           # axes, the 50% ring, then the frame
+        c.line(center, corner, "grey37", dotted=True)
+    half = [at(k, 50) for k in (top, left, right)]
+    for a, b in zip(half, half[1:] + half[:1]):
+        c.line(a, b, "grey37", dotted=True)
+    for a, b in ((top, left), (left, right), (right, top)):
+        c.line(a, b, "grey70")
+    for i, x in enumerate(result["models"][:len(COLORS)][::-1]):   # the best ends on top
+        color = COLORS[len(result["models"][:len(COLORS)]) - 1 - i]
+        pts = [at(k, s or 0) for k, s in ((top, x["P"]), (left, x["T"]), (right, x["A"]))]
+        for a, b in zip(pts, pts[1:] + pts[:1]):
+            c.line(a, b, color)
+    lines = c.text()
+    pad = " " * max(0, cols // 2 - 5)
+    return ([f"{pad}[b]P[/b] privacy"] + lines
+            + [f"[b]T[/b] time{' ' * max(1, cols - 15)}[b]A[/b] accuracy"])
+
+
+def legend(result):
+    """One Rich markup line per model: its colour on the triangle and its three scores."""
+    out = []
+    for i, x in enumerate(result["models"]):
+        mark = f"[{COLORS[i]}]■[/]" if i < len(COLORS) else " "
+        out.append(f"{mark} {x['model']}  P {_score(x['P'])} · T {_score(x['T'])} · A {_score(x['A'])}"
+                   + ("  [yellow](some answers ran alongside other models)[/yellow]" if x["alongside"] else ""))
+    return out
+
+
+def _score(v):
+    return "-" if v is None else f"{v:.0f}"
+
+
+def table(result):
+    """(header, rows) for a plain table of the index."""
+    header = ["model", "P privacy", "T time", "A accuracy", "total time", "answers right"]
+    rows = [[x["model"], _score(x["P"]), _score(x["T"]), _score(x["A"]), fmt_total(x["total_s"]),
+             f"{x['passed']}/{x['answers']}"] for x in result["models"]]
+    return header, rows
+
+
+def fmt_total(secs):
+    if not secs:
+        return "-"
+    if secs < 60:
+        return f"{secs:.1f}s"
+    secs = round(secs)
+    h, rem = divmod(secs, 3600)
+    return f"{h}h{rem // 60:02d}m" if h else f"{rem // 60}m{rem % 60:02d}s" if rem >= 60 else f"{rem}s"
+
+
+def scope_note(result, models):
+    """What the scores compare, in a sentence."""
+    if not result["questions"]:
+        return "These models have no question in common yet, so there's nothing to compare."
+    return (f"Compared on the {result['questions']} questions all {len(models)} model(s) answered. "
+            "T is relative to the fastest total, so adding a faster model lowers the others.")
+
+
+def for_engine(e, labels=None, packs=None, results_dir=None):
+    """(result, models) from a workspace's finished results (results on their way out excluded)."""
+    paths = [p for p in compare.default_paths(results_dir or e.results_dir) if not e.superseded(p)]
+    rows, _ = compare.load(paths) if paths else ([], [])
+    if packs:
+        rows = [r for r in rows if r["suite"] in packs]
+    models = sorted({r["model"] for r in rows} & set(labels) if labels else {r["model"] for r in rows})
+    return index(rows, lambda m: privacy(e.cfg, m), models), models
+
+
+def markdown(result, models):
+    """The index as a markdown section (tuieval report)."""
+    lines = ["## PTA index", "", scope_note(result, models), ""]
+    if not result["questions"]:
+        return lines
+    header, rows = table(result)
+    lines += ["| " + " | ".join(header) + " |", "|" + "---|" * len(header)]
+    lines += ["| " + " | ".join(r) + " |" for r in rows]
+    if any(x["alongside"] for x in result["models"]):
+        lines += ["", "Some answers ran alongside other models, which shared the machine's speed."]
+    return lines

tuieval/run_evals.py

@@ -21,6 +21,7 @@
     tuieval list                                  # the models tuieval knows; hidden ones listed separately
     tuieval remove --hidden                       # clean up hidden models (archived in removed/)
     tuieval regrade                               # re-score stored answers with the current graders
+    tuieval regrade --only my-model --packs coding   # just one model's results (and packs)
     tuieval machines                              # this machine, known machines, fit and tuning per model
     tuieval tune my-model                         # find the fastest speed flags for a model on this machine
     tuieval tune --untuned                        # tune every model that has no profile here yet
@@ -270,9 +271,22 @@ def cmd_remove(argv):
 def cmd_regrade(argv):
     p = argparse.ArgumentParser(prog="tuieval regrade", description="Re-score stored answers with current graders.")
     p.add_argument("paths", nargs="*", help="result files (default: all in results/)")
+    p.add_argument("--only", help="comma-separated model labels")
+    p.add_argument("--packs", help="comma-separated packs")
     a = p.parse_args(argv)
     from . import compare
-    for path in a.paths or compare.default_paths():
+    paths = a.paths or compare.default_paths()
+    for flag, value, part in (("--only", a.only, lambda q: os.path.basename(os.path.dirname(q))),
+                              ("--packs", a.packs, lambda q: os.path.basename(q)[:-len(".json")])):
+        if not value:
+            continue
+        wanted = [v.strip() for v in value.split(",") if v.strip()]
+        known = sorted({part(q) for q in paths})
+        missing = [v for v in wanted if v not in known]
+        if missing:
+            sys.exit(f"{flag}: no results for {', '.join(missing)}. With results: {', '.join(known) or 'none'}")
+        paths = [q for q in paths if part(q) in wanted]
+    for path in paths:
         try:
             before, after = engine.regrade(path)
             print(f"{os.path.relpath(path)}: {before} -> {after} passed")
@@ -368,9 +382,43 @@ def report_markdown(e, labels=None):
                     lines.append("  - by difficulty: " + ", ".join(levels))
                 for ex in ev.get("critical_examples", []):
                     lines.append(f"  - critical: {ex}")
+    from . import pta
+    lines += [""] + pta.markdown(*pta.for_engine(e, labels))
     return "\n".join(lines) + "\n"
 
 
+def cmd_pta(argv):
+    p = argparse.ArgumentParser(prog="tuieval pta",
+                                description="The PTA index: privacy, time and accuracy per model (0-100 each), as a "
+                                            "triangle and a table, over the questions all the models answered.")
+    p.add_argument("--only", help="comma-separated model labels (default: every model with results)")
+    p.add_argument("--packs", help="comma-separated packs (default: all)")
+    p.add_argument("--width", type=int, default=48, help="triangle width in characters (default 48)")
+    p.add_argument("--models")
+    p.add_argument("--results-dir")
+    a = p.parse_args(argv)
+    from rich.console import Console
+    from . import pta
+    e = engine.Engine(models_path=a.models, results_dir=a.results_dir)
+    labels = [x.strip() for x in a.only.split(",")] if a.only else None
+    packs = [x.strip() for x in a.packs.split(",")] if a.packs else None
+    result, models = pta.for_engine(e, labels, packs)
+    out = Console(highlight=False)
+    if not models:
+        sys.exit("no finished results to compare" + (" for those models or packs" if labels or packs else ""))
+    out.print(pta.scope_note(result, models))
+    if not result["questions"]:
+        return
+    out.print()
+    for line in pta.triangle(result, a.width) + [""] + pta.legend(result):
+        out.print(line)
+    header, rows = pta.table(result)
+    widths = [max(len(h), *(len(r[i]) for r in rows)) for i, h in enumerate(header)]
+    out.print()
+    for line in [header] + rows:
+        out.print("  ".join(c.ljust(w) for c, w in zip(line, widths)).rstrip(), markup=False)
+
+
 def cmd_report(argv):
     p = argparse.ArgumentParser(prog="tuieval report", description="Write the readiness report as markdown.")
     p.add_argument("-o", "--output", help="default: reports/readiness-<date>.md")
@@ -652,7 +700,7 @@ def cmd_export(argv):
 COMMANDS = {"add": cmd_add, "list": cmd_list, "scan": cmd_scan, "regrade": cmd_regrade,
             "verdict": cmd_verdict, "report": cmd_report, "items": cmd_items, "selftest": cmd_selftest,
             "capture": cmd_capture, "history": cmd_history, "machines": cmd_machines, "tune": cmd_tune,
-            "export": cmd_export, "remove": cmd_remove}
+            "export": cmd_export, "remove": cmd_remove, "pta": cmd_pta}
 
 
 def parse_tests(text, pack_names, known):

tuieval/tui.py

@@ -335,6 +335,7 @@ Opens on [b]Per question[/b]. [b]Production readiness[/b] gives one verdict per
 and what's missing when it's INCONCLUSIVE. The other tabs are the evidence:
   Scorecard              accuracy, critical failures and truncation per model and pack
   Speed & tokens         time and tokens per answer (★ = nothing beats it on both accuracy and time)
+  PTA index              privacy, total time and accuracy per model (0-100 each), as a triangle
   Per question           every question, model by model
   Is the difference real? whether one model is really better than another, or it's noise
   Tests that separate    the questions that tell models apart
@@ -2365,6 +2366,19 @@ class ResultsScreen(Screen):
                              "On another machine, times are measured there if the model ran there, otherwise "
                              "projected from each answer's token counts and that machine's tuned speeds.[/dim]")
                 yield DataTable(id="speed", zebra_stripes=True)
+            with TabPane("PTA index", id="tab-pta"):
+                with Horizontal(id="pta-controls"):
+                    yield Select([("All packs", "")], id="pta-pack", allow_blank=False, value="")
+                    yield Button("Models: all", id="pta-models")
+                yield Static("[dim]P privacy: 100 when prompts stay on machines you control (local, or a server "
+                             "marked private = true), 0 for a hosted API. T time: total time for every question "
+                             "compared, relative to the fastest model (100). A accuracy: answers right. Bigger "
+                             "triangle = better all round; verdicts and critical failures are in Production "
+                             "readiness.[/dim]")
+                yield Static(id="pta-note")
+                with Horizontal(id="pta-body"):
+                    yield Static(id="pta-triangle")
+                    yield DataTable(id="pta", zebra_stripes=True, cursor_type="none")
             with TabPane("Per question", id="tab-per-question"):
                 with Horizontal(id="pq-controls"):
                     yield Select([("All packs", "")], id="pq-pack", allow_blank=False, value="")
@@ -2460,6 +2474,7 @@ class ResultsScreen(Screen):
             info.update("No results yet. Run an eval first." + banner)
             self.rows, self.infos = [], []
             self.fill_per_question()
+            self.fill_pta()
             return
         rows, infos = compare.load(paths)
         notes = compare.settings_notes(infos)
@@ -2501,6 +2516,7 @@ class ResultsScreen(Screen):
             for test, flags, rates in compare.items(rows):
                 qt.add_row(", ".join(flags), test, *[f"{100 * rates[m]:.0f}%" if m in rates else "-" for m in models])
         self.fill_per_question()
+        self.fill_pta()
         self.fill_readiness(results_dir)
 
     @on(DataTable.RowSelected, "#failures")
@@ -2524,6 +2540,7 @@ class ResultsScreen(Screen):
             self.fill_per_question()
 
     @on(Button.Pressed, "#pq-models")
+    @on(Button.Pressed, "#pta-models")
     def pick_models(self):
         counts = {}
         for t in getattr(self, "pq_all_tests", []):
@@ -2541,8 +2558,51 @@ class ResultsScreen(Screen):
                     self.query_one("#pq-shared", Checkbox).value = True
             # after the picker has closed: a table rebuilt under a modal keeps its header-only widths
             self.call_after_refresh(self.fill_per_question)
+            self.call_after_refresh(self.fill_pta)
         self.app.push_screen(ModelPickScreen(models, counts, self.app.pq_models), picked)
 
+    @on(Select.Changed, "#pta-pack")
+    def pta_changed(self):
+        if getattr(self, "rows", None) is not None:
+            self.fill_pta()
+
+    def fill_pta(self):
+        """The PTA index (pta.py) of the picked models (Models button, shared with Per question) on
+        the finished results, over the questions all of them answered."""
+        from . import pta
+        e = self.app.engine
+        rows = [r for r in self.rows if r.get("path") not in self.superseded]
+        packs = sorted({r["suite"] for r in rows})
+        sel = self.query_one("#pta-pack", Select)
+        options = [("All packs", "")] + [(e.packs[p].label if p in e.packs else p, p) for p in packs]
+        if [v for _, v in options] != getattr(self, "pta_pack_values", None):
+            self.pta_pack_values = [v for _, v in options]
+            current = sel.value
+            with sel.prevent(Select.Changed):
+                sel.set_options(options)
+                sel.value = current if current in self.pta_pack_values else ""
+        if sel.value:
+            rows = [r for r in rows if r["suite"] == sel.value]
+        present = {r["model"] for r in rows}
+        chosen = {m for m in self.app.pq_models if m in present}
+        self.query_one("#pta-models", Button).label = f"Models: {len(chosen)} picked" if chosen else "Models: all"
+        models = sorted(chosen or present)
+        t = self.query_one("#pta", DataTable)
+        t.clear(columns=True)
+        if not models:
+            self.query_one("#pta-note", Static).update("No finished results to compare yet.")
+            self.query_one("#pta-triangle", Static).update("")
+            return
+        result = pta.index(rows, lambda m: pta.privacy(e.cfg, m), models)
+        extra = (f"  [yellow]{len(pta.COLORS)} models are drawn at most; pick fewer with Models.[/yellow]"
+                 if len(models) > len(pta.COLORS) else "")
+        self.query_one("#pta-note", Static).update(pta.scope_note(result, models) + extra)
+        self.query_one("#pta-triangle", Static).update(
+            "\n".join(pta.triangle(result, 48) + [""] + pta.legend(result)) if result["questions"] else "")
+        header, table = pta.table(result)
+        t.add_columns(*header)
+        t.add_rows(table)
+
     def fill_per_question(self):
         # a pack being rerun under new questions or settings: its old result file is on its way out,
         # so it isn't compared (it moves to history/ when the new run of that pack finishes)
@@ -2846,6 +2906,11 @@ class EvalsApp(App):
     #results-info { width: 1fr; height: auto; }
     #toggle-smoke { width: auto; min-width: 32; }
     #pq-controls { height: 3; }
+    #pta-controls { height: 3; }
+    #pta-controls Select { width: 28; margin-right: 1; }
+    #pta-body { height: auto; }
+    #pta-triangle { width: auto; padding: 1 2 0 0; }
+    #pta { width: 1fr; height: auto; margin-top: 1; }
     #pq-controls Checkbox { width: auto; }
     #pq-controls Select { width: 28; margin-right: 1; }
     #pq-models { margin-right: 1; min-width: 20; }

{tuieval-0.2.0.dev35.dist-info → tuieval-0.2.0.dev43.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tuieval
-Version: 0.2.0.dev35
+Version: 0.2.0.dev43
 Summary: Evaluate local and frontier LLMs on your own questions: accuracy, speed, tokens and PASS/FAIL verdicts, in the terminal.
 Project-URL: Homepage, https://github.com/ashe-wb/tuieval
 Project-URL: Issues, https://github.com/ashe-wb/tuieval/issues
@@ -62,6 +62,14 @@ Once you've added your own packs and models, the setup screen looks like this (p
 
 ![tuieval's setup screen with five eval packs and three models with their verdicts](https://raw.githubusercontent.com/ashe-wb/tuieval/main/docs/images/tui-setup.png)
 
+While a run goes, you watch each question's reasoning and answer stream in:
+
+![tuieval's run screen with a model's reasoning streaming in for a coding question](https://raw.githubusercontent.com/ashe-wb/tuieval/main/docs/images/tui-run-reasoning.png)
+
+Afterwards, every answer keeps its reasoning. Enter on a result opens it with the grade and each check, the full reasoning and the answer; `[` and `]` step through the others:
+
+![one answer in full: the grade and its checks, the model's reasoning and its code](https://raw.githubusercontent.com/ashe-wb/tuieval/main/docs/images/tui-answer-reasoning.png)
+
 ## What you get
 
 - **A TUI** to pick packs and models, watch reasoning and answers stream live with TTFT, tokens/s, memory and a running score, and browse results.
@@ -156,6 +164,7 @@ tuieval selftest                              # check every test's reference and
 tuieval items                                 # tests that don't separate models or look broken
 tuieval capture logs/live/<file> --pack X     # turn a real failure into a new test
 tuieval regrade                               # re-score stored answers after changing a grader
+tuieval regrade --only <model> --packs X      # just one model's results (and packs)
 tuieval machines                              # this machine and others, fit and tuning per model
 tuieval tune <model>                          # fastest speed flags for a model on this machine
 tuieval export pi <model>                     # serve it in the pi coding agent with those flags

{tuieval-0.2.0.dev35.dist-info → tuieval-0.2.0.dev43.dist-info}/RECORD

@@ -1,22 +1,23 @@
 tuieval/__init__.py,sha256=myVXVX7htbwezW6k3x_FuKgn1RSZ2WcTaDEMByGn6Wg,312
 tuieval/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
-tuieval/_version.py,sha256=CbIICvzgRxETJn7V5B1XvQciGOT10G9JqjADauvBPbc,535
+tuieval/_version.py,sha256=5PoXfeeUc_RJHZEcbrdVeWQpyK7qC0e8oom2QPT307Y,535
 tuieval/builtin.toml,sha256=Kxw22RZCJhURUyu5Wz8tj5Y1nM85A8hFVRbA4ocoPUg,4293
-tuieval/cli.py,sha256=7joEA07W2we-kcg4VXxfCSXazj7dWBCKlQlSXpXQfTc,4390
-tuieval/client.py,sha256=Vui7ucVv_GiKObGoVS_EWSZFUKPou9PWmutqMTrahXk,9313
+tuieval/cli.py,sha256=kI1P0a7TMS-daHjZjLDBdBDPOwBCmPw1qjw6VDlY258,4505
+tuieval/client.py,sha256=kpsyLEZKfxCsvIGBHBbBy83TpI97CvnGCDq-4AbJS4Y,9986
 tuieval/compare.py,sha256=SHN_o_nlppFcHMBqBZRITIkeQDPaR_JxhUZItQLMBwo,26270
 tuieval/doctor.py,sha256=y1C_ggjd8oikXTrovgTBf26wjThP8EoVkfTVeO_n5dQ,6070
-tuieval/engine.py,sha256=xTDlcU2nPGcSvv6a45gLTsMU7p7ZvNxmzrkGPMe9vfQ,113950
+tuieval/engine.py,sha256=w3KsgxzFAMcRyVzFGQXhTgN3d9qYRtAZZxNLXZOgnrQ,114222
 tuieval/export.py,sha256=dbHQgL_ubWtIPM1sLzAew_gETnrDJyd0zgqVA5vkpXM,9657
 tuieval/machines.py,sha256=ImEihNj8QlBRdCHLED4QIdjJUvjVtZgo6DiVU5h6Zzs,13415
 tuieval/onboard.py,sha256=IYETVDWCCo9vF0Dtj4_rr9VanYeCky8PwP3-2g5A_l0,6215
 tuieval/packs.py,sha256=tiLmxsrX_M5EUMuR4Yvb7pLBLEI15wamHSjflD6wjoY,11299
 tuieval/profiles.py,sha256=soeLxjdB-l-OxSY8jZ4yjwfdSnsBV-QICcwKxRJS7nQ,3663
+tuieval/pta.py,sha256=IUVEy0AEmSfGu8y_HXBtnRxuz-6HJWvEklnp9s4YGcg,8733
 tuieval/remove.py,sha256=Vwh43nm9lVb9U9aN-h6CMYbkTwdR3UWfZObwweF72n0,5157
-tuieval/run_evals.py,sha256=ZGx4XcZ15qD3vIg15xCfdX4SxTDHXBp_GYoiGexchdw,43668
+tuieval/run_evals.py,sha256=1iht7XHc4-PNdppXC2PbPEkIaRZAem7u_M6Xfe588ik,46250
 tuieval/scaffold.py,sha256=YBOqniJpf_GtKKAFF3_OHxxMGbmTWdFjcClGcOnrrKE,12130
 tuieval/selftest.py,sha256=nExkrOidgymlmvkxImEBfrQG5iTUN5WuRMIKtqusCCs,9835
-tuieval/tui.py,sha256=OTkp7CkY6X1OjCLC-7N74BoVwRoawHDng5Nb_caWT1A,160493
+tuieval/tui.py,sha256=ZuDOJQ65D8UH-JpEvaQ3eIzdGYJTstQb1ElmJki31Ko,164195
 tuieval/tune.py,sha256=jXwYuSjfdqbLCE3WonP2xaUHwk_FnhI67twB1BaHggI,38992
 tuieval/verdict.py,sha256=Muo1a05mCv781MlEJsXwDsGaKbRi0JS4Lv8HdvK_Aco,19054
 tuieval/watch_proxy.py,sha256=z916NRhEur04a9RnLm6ZpIEY1SnnUGPiHYbmlD9ktQ0,11035
@@ -45,8 +46,8 @@ tuieval/templates/packs/tool_call/pack.toml,sha256=n4bx0lGJHSmW41uVqhfIXJ2BWZpmT
 tuieval/templates/packs/tool_call/system.txt,sha256=mKxu-lB-0YjLHXdgeFJa8x2C180OvcNz5cHv2N5Bg3U,254
 tuieval/templates/packs/tool_call/tests.yaml,sha256=Nv7c4syrzJ9cU8EBKSK_1ZSFx9V02aCjW4-2TBCPT7s,1859
 tuieval/templates/packs/tool_call/tools.yaml,sha256=HgxCkh0On2VwbHSsjAGM8tNCK7ZtKLGrs7lMCn3Fprs,1048
-tuieval-0.2.0.dev35.dist-info/METADATA,sha256=TmKW6Vv6y36IMxqxbI6_B0NRMM62t-9yXkUq-pI4z6Y,13189
-tuieval-0.2.0.dev35.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-tuieval-0.2.0.dev35.dist-info/entry_points.txt,sha256=7eIhi1GpFxBP2OLJV02Nn8LwsNuO512eKOGt1IBbj04,45
-tuieval-0.2.0.dev35.dist-info/licenses/LICENSE,sha256=7wfRgGtBGH1aXhZkIn47oUznqKC18kEPMvUVgol7Ffc,1077
-tuieval-0.2.0.dev35.dist-info/RECORD,,
+tuieval-0.2.0.dev43.dist-info/METADATA,sha256=P6oHoB_GI8wBLV-_DUqU4TggqZdTVGtz5glAfpIn2jU,13881
+tuieval-0.2.0.dev43.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+tuieval-0.2.0.dev43.dist-info/entry_points.txt,sha256=7eIhi1GpFxBP2OLJV02Nn8LwsNuO512eKOGt1IBbj04,45
+tuieval-0.2.0.dev43.dist-info/licenses/LICENSE,sha256=7wfRgGtBGH1aXhZkIn47oUznqKC18kEPMvUVgol7Ffc,1077
+tuieval-0.2.0.dev43.dist-info/RECORD,,