tuieval 0.2.0.dev43__py3-none-any.whl → 0.2.0.dev50__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.dev43'
-__version_tuple__ = version_tuple = (0, 2, 0, 'dev43')
+__version__ = version = '0.2.0.dev50'
+__version_tuple__ = version_tuple = (0, 2, 0, 'dev50')
 
 __commit_id__ = commit_id = None

tuieval/cli.py

@@ -14,7 +14,7 @@ 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 pta                 the PTA index: parsimony, speed and accuracy per model, as bars
   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/pta.py

@@ -1,145 +1,133 @@
-"""PTA index: privacy, time and accuracy per model, 0-100 each, drawn as a radar triangle.
+"""PTA index: parsimony, speed (time) and accuracy per model, 0-100 each and higher is better, shown
+as a bar per score for each model.
 
-    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.
+    P  parsimony  a score out of 100, from the tokens (reasoning and answer) used on every question
+                  compared (each question at its median over repeats): 100 for the model that used the
+                  fewest, POINTS_PER_DOUBLING points less for every doubling (0 at about 100 times more).
+                  Unlike T it doesn't depend on the machine: it's how much a model says to get there.
+    T  speed      a score out of 100, the same from the total time to answer those questions: 100 for
+                  the fastest model. Log scales, so models that are all far behind the best still differ.
+    A  accuracy   a percentage: 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).
+faster. Server and connection errors aren't answers. By default a model with fewer than half as many
+answers as the most-answered model is left out (listed, so it can be picked), or it would shrink the
+shared questions for everyone. 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
+import math
+
+from rich.markup import escape as rich_escape
 
 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"]
+MIN_SHARE = 0.5   # fewer answers than this share of the most-answered model's: left out by default
+POINTS_PER_DOUBLING = 15
 
 
-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:
+def score(total, best):
+    """P and T: 100 for the best (lowest) total, POINTS_PER_DOUBLING less for every doubling, never below 0."""
+    if not total or not best:
         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
+    return max(0.0, 100 - POINTS_PER_DOUBLING * math.log2(total / best))
 
 
-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)."""
+def index(rows, models=None):
+    """{"questions": n shared, "models": [{model, P, T, A, tokens, total_s, passed, answers, alongside,
+    fewest, fastest}],
+    "left_out": [(model, questions answered)], "no_answers": [model], "most": questions answered by the
+    most-answered model}, best accuracy first. models: the ones to compare (default: every model in rows
+    with enough answers; models named here are compared whatever their count)."""
+    no_answers = sorted({r["model"] for r in rows} - {r["model"] for r in rows if not r.get("error")})
+    rows = [r for r in rows if not r.get("error")]     # a server or connection error isn't an answer
     tests = compare.per_question(rows)
-    models = sorted(models or {m for t in tests for m in t["cells"]})
+    counts = {}
+    for t in tests:
+        for m in t["cells"]:
+            counts[m] = counts.get(m, 0) + 1
+    most = max(counts.values(), default=0)
+    if models:
+        no_answers = [m for m in no_answers if m in models]
+        models, left_out = sorted(m for m in models if m in counts), []
+    else:
+        models = sorted(m for m in counts if counts[m] >= MIN_SHARE * most)
+        left_out = sorted(((m, n) for m, n in counts.items() if m not in models), key=lambda x: (-x[1], x[0]))
     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),
+        out.append({"model": m, "tokens": sum(c["tokens"] or 0 for c in cells),
+                    "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)
+    fewest = min((x["tokens"] for x in out if x["tokens"] > 0), default=None)
     for x in out:
-        x["T"] = 100 * fastest / x["total_s"] if fastest and x["total_s"] > 0 else None
+        x["P"], x["T"] = score(x["tokens"], fewest), score(x["total_s"], fastest)
+        x["fewest"] = bool(fewest) and x["tokens"] == fewest
+        x["fastest"] = bool(fastest) and x["total_s"] == fastest
     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
+    return {"questions": len(shared), "models": out, "left_out": left_out, "no_answers": no_answers,
+            "most": most}
+
+
+LETTERS = (("P", "parsimony", "/100", "cyan"), ("T", "speed", "/100", "magenta"), ("A", "accuracy", "%", "green"))
+
+
+def bars(result, width=20, markup=True):
+    """Lines with a row per model and a bar per score (P, T, A), longer = better, each with its number:
+    the at-a-glance view. markup=False gives plain text (the report)."""
+    if not result["models"]:
+        return []
+    name_w = max(len(x["model"]) for x in result["models"])
+    cell_w = width + 6                          # the bar, a space and "100%" or " 100"
+    head = " " * (name_w + 2) + "".join(f"{f'{k} {name}':<{cell_w}}" for k, name, _, _ in LETTERS)
+    lines = [f"[b]{head.rstrip()}[/b]" if markup else head.rstrip()]
+    for x in result["models"]:
+        cells = []
+        for k, _, unit, color in LETTERS:
+            v = x[k]
+            full = 0 if v is None else round(width * max(0, min(100, v)) / 100)
+            bar, rest = "█" * full, "░" * (width - full)
+            num = "-" if v is None else f"{v:.0f}{'%' if unit == '%' else ''}"
+            bar = f"[{color}]{bar}[/][grey37]{rest}[/]" if markup else bar + rest
+            cells.append(f"{bar} {num:>4}")
+        name = f"{x['model']:<{name_w}}"
+        lines.append(f"{rich_escape(name) if markup else name}  " + "  ".join(cells))
+    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."""
+def left_out_lines(result):
+    """Plain sentences on the models not compared (too few answers, or only server errors) and on
+    answers that shared the machine with other models."""
     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 ""))
+    if result["left_out"]:
+        out.append("Left out (fewer than half as many answers as the most-answered model; pick them under "
+                   "Models or --only to include them): "
+                   + ", ".join(f"{m} ({n} of {result['most']})" for m, n in result["left_out"]))
+    if result["no_answers"]:
+        out.append("No answers, only server errors: " + ", ".join(result["no_answers"]))
+    shared = [x["model"] for x in result["models"] if x["alongside"]]
+    if shared:
+        out.append("Some answers ran alongside other models, which shared the machine's speed: " + ", ".join(shared))
     return out
 
 
-def _score(v):
-    return "-" if v is None else f"{v:.0f}"
+def _score(v, unit=""):
+    """A is a percentage (%), P and T scores out of 100 (/100: on a log scale, not percentages)."""
+    return "-" if v is None else f"{v:.0f}{unit}"
 
 
 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"]),
+    header = ["model", "P parsimony /100", "T speed /100", "A accuracy %", "tokens", "total time",
+              "answers right"]
+    rows = [[x["model"], _score(x["P"]), _score(x["T"]), _score(x["A"], "%"),
+             f"{round(x['tokens']):,}" + (" ★" if x.get("fewest") else ""),
+             fmt_total(x["total_s"]) + (" ★" if x.get("fastest") else ""),
              f"{x['passed']}/{x['answers']}"] for x in result["models"]]
     return header, rows
 
@@ -158,8 +146,10 @@ 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.")
+    return (f"Compared on the {result['questions']} questions all {len(result['models'])} model(s) answered. "
+            f"A is a percentage. P parsimony and T speed are scores out of 100, not percentages: 100 = the fewest "
+            f"tokens / the fastest total time (★), {POINTS_PER_DOUBLING} points less for each doubling; a better "
+            "model added lowers the others.")
 
 
 def for_engine(e, labels=None, packs=None, results_dir=None):
@@ -169,7 +159,7 @@ def for_engine(e, labels=None, packs=None, results_dir=None):
     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
+    return index(rows, models if labels else None), models
 
 
 def markdown(result, models):
@@ -177,9 +167,10 @@ def markdown(result, models):
     lines = ["## PTA index", "", scope_note(result, models), ""]
     if not result["questions"]:
         return lines
+    lines += ["```"] + bars(result, markup=False) + ["```", ""]
     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."]
+    for line in left_out_lines(result):
+        lines += ["", line]
     return lines

tuieval/run_evals.py

@@ -389,11 +389,11 @@ def report_markdown(e, labels=None):
 
 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.")
+                                description="The PTA index: parsimony (tokens), speed and accuracy per model (0-100, higher is better), as a "
+                                            "bar per score for each model 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("--width", type=int, default=20, help="bar width in characters (default 20)")
     p.add_argument("--models")
     p.add_argument("--results-dir")
     a = p.parse_args(argv)
@@ -408,15 +408,20 @@ def cmd_pta(argv):
         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"]:
+        for line in pta.left_out_lines(result):
+            out.print(line, markup=False)
         return
     out.print()
-    for line in pta.triangle(result, a.width) + [""] + pta.legend(result):
+    for line in pta.bars(result, a.width):
         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)
+    for line in pta.left_out_lines(result):
+        out.print()
+        out.print(line, markup=False)
 
 
 def cmd_report(argv):

tuieval/tui.py

@@ -10,10 +10,10 @@ Run screen:    live reasoning and answer, per-test ✓/✗, TTFT and tokens/s, p
                k skips the current model, c cancels everything, f pauses auto-scroll.
                r shows results at any time (also mid-run); n starts a new run when it ends.
                Enter on a Recent results row shows that answer in full.
-Results:       opens on Per question, which compares each model's tokens and seconds on the same
-               question. ctrl+r reloads (it also reloads when a run's pack finishes). Enter on a
-               Failures row or a Per question cell shows the answer: grading and checks, reasoning,
-               answer, question.
+Results:       opens on the PTA index (parsimony, speed and accuracy per model, as bars). Per
+               question compares each model's tokens and seconds on the same question. ctrl+r
+               reloads (it also reloads when a run's pack finishes). Enter on a Failures row or a
+               Per question cell shows the answer: grading and checks, reasoning, answer, question.
 Answer detail: [ and ] step to the previous/next answer; esc/q close.
 Anywhere:      esc/q go back (q quits only on Setup), ctrl+q quits, w lists this session's runs and
                tunes. Leaving a live run or tune keeps it going; the header shows its progress.
@@ -331,11 +331,11 @@ with the model's reasoning and answer as they stream, then recent results with t
   v  with several models at a time: stream the next one (k skips the one streaming)""",
     "ResultsScreen": """[b]Results[/b]
 
-Opens on [b]Per question[/b]. [b]Production readiness[/b] gives one verdict per model and use case,
-and what's missing when it's INCONCLUSIVE. The other tabs are the evidence:
+Opens on the [b]PTA index[/b]: parsimony (tokens), speed and accuracy per model, a bar each (0-100,
+longer = better). [b]Production readiness[/b] gives one verdict per model and use case, 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
@@ -2341,7 +2341,18 @@ class ResultsScreen(Screen):
             yield Static(id="results-info")
             if self.smoke_dir:
                 yield Button("Show this Smoke run's results", id="toggle-smoke")
-        with TabbedContent(initial="tab-per-question"):
+        with TabbedContent(initial="tab-pta"):
+            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 parsimony: tokens used (reasoning and answer). T speed: total time. A accuracy: "
+                             "answers right. Longer bars are better for all three. Verdicts and critical failures "
+                             "are in Production readiness.[/dim]")
+                yield Static(id="pta-note")
+                yield Static(id="pta-bars")
+                yield DataTable(id="pta", zebra_stripes=True, cursor_type="none")
+                yield Static(id="pta-left-out")
             with TabPane("Production readiness"):
                 yield Static(id="readiness-short")
                 yield Static(self.READINESS_HELP, id="readiness-help")
@@ -2366,19 +2377,6 @@ 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="")
@@ -2586,21 +2584,22 @@ class ResultsScreen(Screen):
         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:
+        if not present:
             self.query_one("#pta-note", Static).update("No finished results to compare yet.")
-            self.query_one("#pta-triangle", Static).update("")
+            self.query_one("#pta-bars", Static).update("")
+            self.query_one("#pta-left-out", 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 "")
+        # none picked: every model with enough answers (pta.index leaves out the rest, and says so)
+        result = pta.index(rows, sorted(chosen) or None)
+        self.query_one("#pta-note", Static).update(pta.scope_note(result, sorted(present)))
+        self.query_one("#pta-bars", Static).update("\n".join(pta.bars(result)) if result["questions"] else "")
+        self.query_one("#pta-left-out", Static).update(
+            "\n".join(f"[dim]{rich_escape(line)}[/dim]" for line in pta.left_out_lines(result)))
         header, table = pta.table(result)
-        t.add_columns(*header)
+        for i, h in enumerate(header):   # sized to the contents: added before the rows, a column keeps its header's width
+            t.add_column(h, width=max(len(h), *(len(r[i]) for r in table)) if table else None)
         t.add_rows(table)
 
     def fill_per_question(self):
@@ -2908,9 +2907,9 @@ class EvalsApp(App):
     #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-bars { height: auto; padding: 1 0 0 0; }
     #pta { width: 1fr; height: auto; margin-top: 1; }
+    #pta-left-out { height: auto; padding: 1 0 0 0; }
     #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.dev43.dist-info → tuieval-0.2.0.dev50.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tuieval
-Version: 0.2.0.dev43
+Version: 0.2.0.dev50
 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

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

@@ -1,8 +1,8 @@
 tuieval/__init__.py,sha256=myVXVX7htbwezW6k3x_FuKgn1RSZ2WcTaDEMByGn6Wg,312
 tuieval/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
-tuieval/_version.py,sha256=5PoXfeeUc_RJHZEcbrdVeWQpyK7qC0e8oom2QPT307Y,535
+tuieval/_version.py,sha256=cUlv5rRBNcBZ7a8L_s4uRBMTmFx7dza4nVKsHqXS0Pg,535
 tuieval/builtin.toml,sha256=Kxw22RZCJhURUyu5Wz8tj5Y1nM85A8hFVRbA4ocoPUg,4293
-tuieval/cli.py,sha256=kI1P0a7TMS-daHjZjLDBdBDPOwBCmPw1qjw6VDlY258,4505
+tuieval/cli.py,sha256=gzGBzhqvR0WKJQQNHB8CudpgViIeIyawrNWa54whmoI,4502
 tuieval/client.py,sha256=kpsyLEZKfxCsvIGBHBbBy83TpI97CvnGCDq-4AbJS4Y,9986
 tuieval/compare.py,sha256=SHN_o_nlppFcHMBqBZRITIkeQDPaR_JxhUZItQLMBwo,26270
 tuieval/doctor.py,sha256=y1C_ggjd8oikXTrovgTBf26wjThP8EoVkfTVeO_n5dQ,6070
@@ -12,12 +12,12 @@ 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/pta.py,sha256=KkrOxE1hTDwu1435IrzMzIysrgVUvFuKVo786VlRyK4,9056
 tuieval/remove.py,sha256=Vwh43nm9lVb9U9aN-h6CMYbkTwdR3UWfZObwweF72n0,5157
-tuieval/run_evals.py,sha256=1iht7XHc4-PNdppXC2PbPEkIaRZAem7u_M6Xfe588ik,46250
+tuieval/run_evals.py,sha256=5bQEqU533XYiLze9dYcl72c5GSIpohMj1eqJrePRwnc,46450
 tuieval/scaffold.py,sha256=YBOqniJpf_GtKKAFF3_OHxxMGbmTWdFjcClGcOnrrKE,12130
 tuieval/selftest.py,sha256=nExkrOidgymlmvkxImEBfrQG5iTUN5WuRMIKtqusCCs,9835
-tuieval/tui.py,sha256=ZuDOJQ65D8UH-JpEvaQ3eIzdGYJTstQb1ElmJki31Ko,164195
+tuieval/tui.py,sha256=21Re8fM5rf3zbHIKvK9laMV-mL2HjcGfMReoRg0DRLw,164268
 tuieval/tune.py,sha256=jXwYuSjfdqbLCE3WonP2xaUHwk_FnhI67twB1BaHggI,38992
 tuieval/verdict.py,sha256=Muo1a05mCv781MlEJsXwDsGaKbRi0JS4Lv8HdvK_Aco,19054
 tuieval/watch_proxy.py,sha256=z916NRhEur04a9RnLm6ZpIEY1SnnUGPiHYbmlD9ktQ0,11035
@@ -46,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.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,,
+tuieval-0.2.0.dev50.dist-info/METADATA,sha256=VW1tuB9QtgVUt9irfVVzrDhkF907wql1_WpM7PasfPU,13881
+tuieval-0.2.0.dev50.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+tuieval-0.2.0.dev50.dist-info/entry_points.txt,sha256=7eIhi1GpFxBP2OLJV02Nn8LwsNuO512eKOGt1IBbj04,45
+tuieval-0.2.0.dev50.dist-info/licenses/LICENSE,sha256=7wfRgGtBGH1aXhZkIn47oUznqKC18kEPMvUVgol7Ffc,1077
+tuieval-0.2.0.dev50.dist-info/RECORD,,