tuieval 0.2.0.dev65__tar.gz → 0.2.0.dev68__tar.gz

{tuieval-0.2.0.dev65 → tuieval-0.2.0.dev68}/CHANGELOG.md

@@ -2,12 +2,13 @@
 
 ## Unreleased
 
+- Results tables sort by a click on a column name; a second click reverses. Numbers, times and levels sort by value; empty cells stay last.
 - Nvidia and AMD GPUs on Linux: VRAM from `nvidia-smi`, `amd-smi` or `rocm-smi` sizes models (`gpu_memory_gb` overrides it), runs record peak VRAM, and `tuieval doctor` shows the GPU.
 - Results has four tabs: PTA index, Production readiness, Per question and Failures. The PTA table adds tok/s, TTFT and memory; Per question can show only where models disagree; the settings warning is one line. Scorecard, pairwise, history and test quality stay in `tuieval compare`, `history` and `items`.
 - The run's ETA adds up each pack's answers left × that model's time per answer there (its history, then its own times once it has 5 answers), instead of extrapolating from the first few answers.
 - Faster start on Macs: the GPU core count comes from `ioreg` instead of `system_profiler`, which took seconds on some Macs.
 - A model a server won't serve (HTTP 401-404, e.g. OpenRouter's "No endpoints found") is never judged on it: those answers don't count, and the model stops at once instead of failing every question.
-- PTA index: parsimony (tokens), time and accuracy per model as bars, with tokens and time shown as multiples of the best (2.4×): the first Results tab (where `r` lands), `tuieval pta` and the report. Server errors aren't answers, and models with few answers are left out unless picked.
+- PTA index: parsimony (tokens), time and accuracy per model as bars (tokens and time as long as they took, shorter is better; accuracy longer is better), with tokens and time also shown as multiples of the best (2.4×): the first Results tab (where `r` lands), `tuieval pta` and the report. Server errors aren't answers, and models with few answers are left out unless picked.
 - Run several models at a time: `parallel_models` per machine, **Models at a time** in the TUI, or `tuieval run --parallel N` (default 1). Models wait for memory to fit, and answers note what ran alongside them.
 - More evals during a run: `n` opens Setup, and Start adds them to the run going (same tier) or queues them after it.
 - A new workspace's `models.toml` is 23 lines: the llama, local and OpenRouter servers and the defaults are built in (docs/models.md lists them in full; a server defined in `models.toml` replaces the built-in one with that name). Existing workspaces keep their settings; built-in servers they don't define become available, and adding a model still prefers the workspace's own servers.

{tuieval-0.2.0.dev65 → tuieval-0.2.0.dev68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tuieval
-Version: 0.2.0.dev65
+Version: 0.2.0.dev68
 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
@@ -144,7 +144,7 @@ See **[docs/models.md](docs/models.md)** for servers, OpenRouter endpoint pinnin
 1. **Pick packs and models** (space ticks; type to filter models by label or tag). Each model shows a short code per use case, e.g. `C✓ S?` (✓ pass, ✗ fail, ? inconclusive; grey = from earlier results). To run only some tests of a pack, highlight it and press `e`. Runs of different tests add up, and the pack can PASS once all its tests have run.
 2. **Pick a tier** (Smoke to check setup, Screen, Certify) and **press `s`**. The line above the buttons shows how many answers that is and roughly how long it will take. For each model, tuieval starts its server (or uses a running one), checks the right model is loaded, runs every selected pack, then stops it.
 3. **Watch the run:** progress with ETA, live score, tok/s, TTFT and memory, the current test with reasoning and answer side by side, recent results with the grader's reason. `k` skips a model, `c` cancels (finished work is kept and resumes next time). `n` sets up more evals while it runs: add them to this run (same tier) or queue them as the next run.
-4. **Press `r` for results:** the PTA index (parsimony (tokens), time and accuracy as bars), production readiness, per question, and failures. `tuieval compare`, `tuieval history` and `tuieval items` have the rest: whether a difference is real, verdict history and test quality.
+4. **Press `r` for results:** the PTA index (parsimony (tokens), time and accuracy as bars), production readiness, per question, and failures; click a column name to sort. `tuieval compare`, `tuieval history` and `tuieval items` have the rest: whether a difference is real, verdict history and test quality.
 
 Other keys: `t` tunes the ticked models' speed flags, `a` adds a model, `m` scans for GGUFs, `p` saves or loads a preset, `x` hides a model. `?` explains any screen.
 

{tuieval-0.2.0.dev65 → tuieval-0.2.0.dev68}/README.md

@@ -118,7 +118,7 @@ See **[docs/models.md](docs/models.md)** for servers, OpenRouter endpoint pinnin
 1. **Pick packs and models** (space ticks; type to filter models by label or tag). Each model shows a short code per use case, e.g. `C✓ S?` (✓ pass, ✗ fail, ? inconclusive; grey = from earlier results). To run only some tests of a pack, highlight it and press `e`. Runs of different tests add up, and the pack can PASS once all its tests have run.
 2. **Pick a tier** (Smoke to check setup, Screen, Certify) and **press `s`**. The line above the buttons shows how many answers that is and roughly how long it will take. For each model, tuieval starts its server (or uses a running one), checks the right model is loaded, runs every selected pack, then stops it.
 3. **Watch the run:** progress with ETA, live score, tok/s, TTFT and memory, the current test with reasoning and answer side by side, recent results with the grader's reason. `k` skips a model, `c` cancels (finished work is kept and resumes next time). `n` sets up more evals while it runs: add them to this run (same tier) or queue them as the next run.
-4. **Press `r` for results:** the PTA index (parsimony (tokens), time and accuracy as bars), production readiness, per question, and failures. `tuieval compare`, `tuieval history` and `tuieval items` have the rest: whether a difference is real, verdict history and test quality.
+4. **Press `r` for results:** the PTA index (parsimony (tokens), time and accuracy as bars), production readiness, per question, and failures; click a column name to sort. `tuieval compare`, `tuieval history` and `tuieval items` have the rest: whether a difference is real, verdict history and test quality.
 
 Other keys: `t` tunes the ticked models' speed flags, `a` adds a model, `m` scans for GGUFs, `p` saves or loads a preset, `x` hides a model. `?` explains any screen.
 

{tuieval-0.2.0.dev65 → tuieval-0.2.0.dev68}/docs/models.md

@@ -98,13 +98,13 @@ By default a run serves one model at a time. On a machine with room for more, se
 
 ## PTA index
 
-The **PTA index** puts parsimony (tokens), time and accuracy side by side, as a bar for each per model (longer is better), with a table underneath. It's the first tab in Results, where `r` opens, and it's also `tuieval pta` and a section in `tuieval report`. There's no combined number; verdicts and critical failures stay in Production readiness.
+The **PTA index** puts parsimony (tokens), time and accuracy side by side, as a bar for each per model, with a table underneath. It's the first tab in Results, where `r` opens, and it's also `tuieval pta` and a section in `tuieval report`. There's no combined number; verdicts and critical failures stay in Production readiness.
 
 - **P parsimony (tokens)**: the tokens used, reasoning and answer, on every question compared (each question at its median over repeats). Beside the bar: how many times the leanest model's, e.g. `2.4×` (`1.0×` is the leanest, ★ in the table's **tokens/answer**). Unlike time it doesn't depend on your machine: it's how much a model says to get to an answer, which is what you pay for on an API and what fills its context.
 - **T time**: the total time to answer those questions, as how many times the fastest model's, e.g. `28×` (★ in **time/answer**).
 - **A accuracy**: the share of answers to those questions that passed.
 
-The P and T bars use a log scale: full for the best, 15 points (of 100) shorter for every doubling, empty at about 100 times the best. So a model at 28× still shows a bar, and adding a better model shortens the others'.
+The P and T bars are as long as the tokens and time used: the model that used the most fills its bar, the others in proportion (at least one block), so **shorter is better**. The A bar is the share of answers right, so **longer is better**; it's full only when every answer passed. Each heading says which way is better.
 
 Models are compared on the questions all of them answered, so one that skipped some never looks faster. Server and connection errors aren't answers: a model with only those is listed as having none. A model with fewer than half as many answers as the most-answered one is left out (and listed), or it would shrink the shared questions for everyone. Pick the models and pack to compare in the TUI, or use `--only` and `--packs`: models you pick are always compared.
 

{tuieval-0.2.0.dev65 → tuieval-0.2.0.dev68}/src/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.dev65'
-__version_tuple__ = version_tuple = (0, 2, 0, 'dev65')
+__version__ = version = '0.2.0.dev68'
+__version_tuple__ = version_tuple = (0, 2, 0, 'dev68')
 
 __commit_id__ = commit_id = None

{tuieval-0.2.0.dev65 → tuieval-0.2.0.dev68}/src/tuieval/pta.py

@@ -1,4 +1,4 @@
-"""PTA index: parsimony (tokens), time and accuracy per model, a bar each (longer = better).
+"""PTA index: parsimony (tokens), time and accuracy per model, a bar each.
 
     P  parsimony (tokens)  the tokens (reasoning and answer) used on every question compared (each
                            question at its median over repeats), shown as how many times the leanest
@@ -7,8 +7,10 @@
                            model's ("28×").
     A  accuracy            the share of answers to those questions that passed (%).
 
-Behind the P and T bars is a 0-100 score: 100 for the best, POINTS_PER_DOUBLING points less for every
-doubling (0 at about 100 times more), so models far behind the best still get a visible bar.
+The P and T bars are as long as the tokens and time used (the model that used the most fills its bar,
+the others in proportion, at least one block), so shorter is better; the A bar: longer is better.
+P and T also carry a 0-100 score (100 for the best, POINTS_PER_DOUBLING points less for every
+doubling), used to order models with the same accuracy.
 
 Models are compared on the questions all of them answered, so one that skipped some never looks
 faster. Server and connection errors aren't answers. By default a model with fewer than half as many
@@ -93,9 +95,11 @@ def index(rows, models=None, memory=None):
             "most": most}
 
 
-# (letter, name, what the number beside the bar shows, colour); the bar itself is the 0-100 score
-LETTERS = (("P", "parsimony (tokens)", "tokens_x", "cyan"), ("T", "time", "time_x", "magenta"),
-           ("A", "accuracy", "A", "green"))
+# (letter, name, which way is better, what the bar measures, the number beside it, colour). P and T bars
+# are the amount itself (tokens, time: shorter is better); the A bar is the share right (longer is better).
+LETTERS = (("P", "parsimony (tokens)", "▼ shorter is better", "tokens", "tokens_x", "cyan"),
+           ("T", "time", "▼ shorter is better", "total_s", "time_x", "magenta"),
+           ("A", "accuracy", "▲ longer is better", "A", "A", "green"))
 
 
 def times(v):
@@ -103,26 +107,41 @@ def times(v):
     return "-" if v is None else f"{v:.1f}×" if v < 9.95 else f"{v:.0f}×"
 
 
+def _blocks(width, v, most):
+    """How many of width blocks a bar fills: v as a share of most, at least one block when v > 0."""
+    if not v or not most:
+        return 0
+    return max(1, min(width, round(width * v / most)))
+
+
 def bars(result, width=20, markup=True):
-    """Lines with a row per model and a bar per score (P, T, A), longer = better: the at-a-glance view.
-    Beside P and T, how many times the leanest / fastest model's tokens / time; beside A, the percentage.
-    markup=False gives plain text (the report)."""
+    """Lines with a row per model and a bar each for P, T and A: the at-a-glance view. The P and T bars
+    are proportional to tokens and time (the longest is the model that used most; shorter is better),
+    with how many times the leanest / fastest model's beside them; the A bar is the share of answers
+    right (longer is better, full only when every answer passed). markup=False gives plain text."""
     if not result["models"]:
         return []
     name_w = max(len(x["model"]) for x in result["models"])
-    # each column: the bar, a space, "100%" or "9.8×" (5), then a gap; at least as wide as its heading
-    cell_w = max(width + 9, *(len(f"{k} {name}") + 2 for k, name, _, _ in LETTERS))
-    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()]
+    # each column: the bar, a space, "100%" or "9.8×" (6), then a gap; at least as wide as its heading
+    cell_w = max(width + 9, *(len(t) + 2 for k, name, better, *_ in LETTERS for t in (f"{k} {name}", better)))
+    pad = " " * (name_w + 2)
+    head = pad + "".join(f"{f'{k} {name}':<{cell_w}}" for k, name, *_ in LETTERS)
+    sub = pad + "".join(f"{better:<{cell_w}}" for _, _, better, *_ in LETTERS)
+    lines = [f"[b]{head.rstrip()}[/b]" if markup else head.rstrip(), f"[dim]{sub.rstrip()}[/dim]" if markup else sub.rstrip()]
+    most = {m: max((x.get(m) or 0 for x in result["models"]), default=0) for _, _, _, m, _, _ in LETTERS}
     for x in result["models"]:
         cells = []
-        for k, _, shown, color in LETTERS:
-            v = x[k]
-            full = 0 if v is None else round(width * max(0, min(100, v)) / 100)
-            if v is not None and v < 100:   # full only when perfect (accuracy) or the best (P, T)
-                full = min(full, width - 1)
+        for k, _, _, measure, shown, color in LETTERS:
+            if k == "A":
+                v = x["A"]
+                full = 0 if v is None else round(width * max(0, min(100, v)) / 100)
+                if v is not None and v < 100:   # full only when every answer passed
+                    full = min(full, width - 1)
+                num = "-" if v is None else compare.pct(v / 100)
+            else:
+                full = _blocks(width, x.get(measure), most[measure])
+                num = times(x.get(shown))
             bar, rest = "█" * full, "░" * (width - full)
-            num = (("-" if v is None else compare.pct(v / 100)) if shown == "A" else times(x.get(shown)))
             bar = f"[{color}]{bar}[/][grey37]{rest}[/]" if markup else bar + rest
             cells.append(f"{bar} {num:>6}" + " " * (cell_w - width - 7))
         name = f"{x['model']:<{name_w}}"
@@ -183,8 +202,9 @@ def scope_note(result, models):
     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(result['models'])} model(s) answered. "
-            "Longer bars are better. P parsimony (tokens) and T time: how many times the leanest / fastest "
-            "model's (1.0×, ★ in the table). A accuracy: answers right.")
+            "P parsimony (tokens) and T time: bars as long as the tokens / time used (shorter is better), "
+            "and how many times the leanest / fastest model's (1.0×, ★ in the table). A accuracy: answers right "
+            "(longer is better).")
 
 
 def for_engine(e, labels=None, packs=None, results_dir=None):

{tuieval-0.2.0.dev65 → tuieval-0.2.0.dev68}/src/tuieval/tui.py

@@ -39,6 +39,8 @@ from textual.widgets.option_list import Option
 from textual.widgets.selection_list import Selection
 
 import yaml
+from rich.cells import cell_len
+from rich.text import Text
 
 from . import compare
 from . import engine
@@ -181,6 +183,79 @@ def fmt_secs(secs):
     return f"{secs // 60}m{secs % 60:02d}s" if secs >= 60 else f"{secs}s"
 
 
+# -- sorting Results tables by a click on a column name
+SORT_ARROWS = (" ▲", " ▼")
+SORT_RANKS = {"EASY": 1, "MEDIUM": 2, "HARD": 3, "FAIL": 1, "INCONCLUSIVE": 2, "PASS": 3,
+              "DOESN'T FIT": float("inf")}
+
+
+class SortCell(Text):
+    """A table cell that sorts by its `sort_value` instead of what it shows."""
+
+
+def sort_cell(markup, value):
+    t = Text.from_markup(markup)
+    cell = SortCell(t.plain, spans=t.spans)
+    cell.sort_value = value
+    return cell
+
+
+def _sort_number(tok):
+    """1,234 · 3.1k · 2.4× · 12/20 · 4m10s · 1h02m · 12.5s as a number, else None."""
+    tok = tok.rstrip("★×%").replace(",", "")
+    if m := re.fullmatch(r"(\d+)/(\d+)", tok):    # answers right: the share, then the count
+        a, b = int(m[1]), int(m[2])
+        return (a / b if b else 0) + a * 1e-9
+    if (m := re.fullmatch(r"(?:(\d+)h)?(?:(\d+)m)?(?:(\d+(?:\.\d+)?)s)?", tok)) and any(m.groups()):
+        h, mi, s = m.groups()
+        return int(h or 0) * 3600 + int(mi or 0) * 60 + float(s or 0)
+    if m := re.fullmatch(r"(-?\d+(?:\.\d+)?)(k?)", tok):
+        return float(m[1]) * (1000 if m[2] else 1)
+    return None
+
+
+def sort_value(cell):
+    """What a Results cell sorts by: the number it shows, a rank for levels and verdicts, else its
+    text; None (always last) for an empty cell."""
+    if isinstance(cell, SortCell):
+        return cell.sort_value
+    plain = (cell.plain if isinstance(cell, Text) else Text.from_markup(str(cell)).plain).strip()
+    if plain.lower() in ("", "-", "no data", "unrated"):
+        return None
+    if plain.upper() in SORT_RANKS:
+        return SORT_RANKS[plain.upper()]
+    first = re.sub(r"^(OK|TOO SLOW) ", "", plain).split()[0]   # latency: by its p90 seconds
+    n = _sort_number(first)
+    return plain.casefold() if n is None else n
+
+
+class _Desc:
+    """Reverses the order of what it wraps (so empty cells stay last when sorting descending)."""
+    __slots__ = ("v",)
+
+    def __init__(self, v):
+        self.v = v
+
+    def __eq__(self, other):
+        return self.v == other.v
+
+    def __lt__(self, other):
+        return other.v < self.v
+
+
+def sort_key(cell, reverse=False):
+    v = sort_value(cell)
+    if v is None:
+        return (1,)
+    return (0, isinstance(v, str), _Desc(v) if reverse else v)
+
+
+def column_name(label):
+    """A column's label without the sort arrow."""
+    text = label.plain if isinstance(label, Text) else str(label)
+    return next((text[:-len(a)] for a in SORT_ARROWS if text.endswith(a)), text)
+
+
 class StreamView(TextArea):
     """Read-only, word-wrapped text that grows as tokens stream in. Scroll it with the mouse; it follows
     new text only while scrolled to the bottom."""
@@ -332,13 +407,16 @@ 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]
 
-  PTA index              parsimony (tokens), time and accuracy per model, a bar each (longer = better;
-                         2.4× = 2.4 times the best), with per-answer numbers, tok/s, TTFT and memory in
-                         the table. Results open here.
+  PTA index              parsimony (tokens), time and accuracy per model, a bar each: tokens and time
+                         as long as they took (shorter is better; 2.4× = 2.4 times the best), accuracy
+                         longer is better. Per-answer numbers, tok/s, TTFT and memory in the table.
+                         Results open here.
   Production readiness   one verdict per model and use case; the table says why and what to run next
   Per question           every question, model by model (filters: pack, level, Models disagree)
   Failures               every wrong answer with the grader's reason; enter opens it in full
 
+Click a column name to sort a table by it; click it again to reverse. Empty cells stay last.
+
 More in the terminal: tuieval compare (--pairwise: is a difference real), tuieval history,
 tuieval items (test quality).
 
@@ -2407,7 +2485,7 @@ class ResultsScreen(Screen):
                 yield DataTable(id="pq-summary", zebra_stripes=True, cursor_type="none")
                 yield Static(id="pq-legend")
                 yield DataTable(id="per-question", zebra_stripes=True, cursor_type="cell")
-            with TabPane("Failures"):
+            with TabPane("Failures", id="tab-failures"):
                 yield Static("[dim]Enter on a row shows the whole answer, its reasoning and what was checked.[/dim]")
                 yield DataTable(id="failures", zebra_stripes=True, cursor_type="row")
         yield Footer()
@@ -2416,6 +2494,8 @@ class ResultsScreen(Screen):
         self.rows, self.infos, self.partial_rows, self.superseded = [], [], [], set()
         if not hasattr(self.app, "pq_models"):
             self.app.pq_models = set()
+        if not hasattr(self.app, "result_sorts"):
+            self.app.result_sorts = {}   # table id -> (column name, descending), kept for this session
         self.fill()
 
     def on_screen_resume(self):
@@ -2487,15 +2567,17 @@ class ResultsScreen(Screen):
         f.add_columns("Model", "Level", "Test", "Reason")
         # compare.failures lists the failed rows in order, so they line up with fail_rows
         self.fail_rows = [r for r in rows if not r["ok"]]
-        for model, test, reason, level in compare.failures(rows):
-            f.add_row(model, diff_badge(level), test, rich_escape(reason[:130]))
+        for i, (model, test, reason, level) in enumerate(compare.failures(rows)):
+            f.add_row(model, diff_badge(level), test, rich_escape(reason[:130]), key=str(i))
         self.fill_per_question()
         self.fill_pta()
         self.fill_readiness(results_dir)
+        self.sort_tables()
 
     @on(DataTable.RowSelected, "#failures")
     def failure_selected(self, event):
-        entries = [answer_entry(r) for r in self.fail_rows]
+        # in the order shown, so [ and ] step through them as sorted
+        entries = [answer_entry(self.fail_rows[int(r.key.value)]) for r in event.data_table.ordered_rows]
         i = event.cursor_row
         if not entries[i]:
             self.notify("This result is in the old format and has no stored answer.", severity="warning")
@@ -2506,7 +2588,6 @@ class ResultsScreen(Screen):
     # -- per question: tokens and time for every model on the same question
     @on(Select.Changed, "#pq-pack")
     @on(Select.Changed, "#pq-level")
-    @on(Select.Changed, "#pq-sort")
     @on(Checkbox.Changed, "#pq-partial")
     @on(Checkbox.Changed, "#pq-shared")
     @on(Checkbox.Changed, "#pq-disagree")
@@ -2514,6 +2595,45 @@ class ResultsScreen(Screen):
         if getattr(self, "rows", None) is not None:
             self.fill_per_question()
 
+    @on(Select.Changed, "#pq-sort")
+    def pq_sort_changed(self):
+        """The Sort dropdown takes over from a column sorted by a click."""
+        self.app.result_sorts.pop("per-question", None)
+        self.per_question_changed()
+
+    @on(DataTable.HeaderSelected)
+    def header_selected(self, event):
+        """A click on a column name sorts by it; another click on it reverses the order."""
+        t, name = event.data_table, column_name(event.label)
+        prev = self.app.result_sorts.get(t.id)
+        self.app.result_sorts[t.id] = (name, not prev[1] if prev and prev[0] == name else False)
+        self.sort_table(t)
+
+    def sort_tables(self):
+        """After a table is rebuilt: sort it again by the column picked (if that column is still there)."""
+        for t in self.query(DataTable):
+            self.sort_table(t)
+
+    def sort_table(self, t):
+        name, desc = self.app.result_sorts.get(t.id, (None, False))
+        found = None
+        for col in t.ordered_columns:
+            base = column_name(col.label)
+            label = base + SORT_ARROWS[desc] if base == name else base
+            if col.label.plain != label:
+                col.label = Text(label)
+                w = cell_len(label)   # room for the arrow (a column keeps the width it was added with)
+                col.content_width = max(col.content_width, w)
+                if not col.auto_width:
+                    col.width = max(col.width, w)
+                t._require_update_dimensions = True
+            if base == name:
+                found = col
+        if found is not None:
+            t.sort(found.key, key=lambda cell: sort_key(cell, desc))
+        else:
+            t.refresh()
+
     @on(Button.Pressed, "#pq-models")
     @on(Button.Pressed, "#pta-models")
     def pick_models(self):
@@ -2578,6 +2698,7 @@ class ResultsScreen(Screen):
         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)
+        self.sort_table(t)
 
     def fill_per_question(self):
         # a pack being rerun under new questions or settings: its old result file is on its way out,
@@ -2640,18 +2761,21 @@ class ResultsScreen(Screen):
             best = min((c["tokens"] for c in t["cells"].values() if c["tokens"] and c["passed"]), default=None)
             for m in models:
                 c = t["cells"].get(m)
-                cells.append(self.pq_cell(c, best, here) if c else "[dim]-[/dim]")
+                # a model's column sorts by its tokens
+                cells.append(sort_cell(self.pq_cell(c, best, here), c["tokens"] or None) if c else "[dim]-[/dim]")
             spread = t["spread"]["tokens"]
             sp = f"[yellow]{spread:.1f}×[/yellow]" if spread >= 3 else (f"{spread:.1f}×" if len(t["cells"]) > 1 else "")
             desc = t["cells"][next(iter(t["cells"]))]["rows"][0].get("raw", {}).get("description") or t["name"]
             table.add_row(rich_escape(desc[:48]), t["suite"], diff_badge(t["difficulty"]), sp, *cells, key=t["test"])
             self.pq_tests[t["test"]] = t
+        self.sort_table(table)
+        self.sort_table(self.query_one("#pq-summary", DataTable))
         self.query_one("#pq-legend", Static).update(
             f"[dim]{len(tests)} questions. Each cell: result (passes/answers if repeated), median tokens, median seconds. "
             "[green]bold[/green] = fewest tokens among passing answers · [red]cut[/red] = hit max_tokens · "
             "◐ = pack unfinished (not in scores) · dim seconds = hosted, or measured on another machine; tokens compare "
             "across machines, seconds don't. ×tokens = most / fewest tokens across models. Enter on a cell opens the "
-            "answers.[/dim]" + ("\n[yellow]Left out, being rerun with other questions or settings: " + ", ".join(
+            "answers. Click a column name to sort by it (a model's column: by its tokens).[/dim]" + ("\n[yellow]Left out, being rerun with other questions or settings: " + ", ".join(
                 f"{os.path.basename(os.path.dirname(p))} · {os.path.basename(p)[:-5]}" for p in sorted(self.superseded))
                 + ". Only the new run's answers (◐) are shown for these.[/yellow]" if self.superseded else ""))
 

{tuieval-0.2.0.dev65 → tuieval-0.2.0.dev68}/tests/test_tuieval.py

@@ -761,10 +761,14 @@ class PTAIndex(unittest.TestCase):
         self.assertEqual((cells["slow"][1], cells["fast"][1:3]), ("10 ★", ["40", "2.0s ★"]))   # per answer
         bars = pta.bars(res, 10, markup=False)
         self.assertEqual(bars[0].split(), ["P", "parsimony", "(tokens)", "T", "time", "A", "accuracy"])
+        self.assertEqual(bars[1].split(), ["▼", "shorter", "is", "better"] * 2 + ["▲", "longer", "is", "better"])
+        slow, fast = bars[2], bars[3]
         self.assertEqual((bars[0].index("P parsimony"), bars[0].index("T time")),   # each bar starts under
-                         (bars[2].index("███████░░░"), bars[2].index("██████████")))  # its heading
-        # the bar is the score (4x the tokens: 70); beside it, how many times the best
-        self.assertEqual(bars[2].split(), ["fast", "███████░░░", "4.0×", "██████████", "1.0×", "█████░░░░░", "50.0%"])
+                         (fast.index("██████████"), fast.index("███░░░░░░░")))       # its heading
+        # P and T bars as long as tokens and time (shorter is better): fast used 4x the tokens of slow but
+        # took 4 s against 13 s, so it has the longest token bar and the shortest time bar
+        self.assertEqual(fast.split(), ["fast", "██████████", "4.0×", "███░░░░░░░", "1.0×", "█████░░░░░", "50.0%"])
+        self.assertEqual(slow.split()[1:5], ["██░░░░░░░░", "1.0×", "██████████", "3.2×"])
         self.assertEqual((pta.times(1), pta.times(9.84), pta.times(27.9)), ("1.0×", "9.8×", "28×"))
         self.assertEqual((by["fast"]["A"], by["slow"]["A"]), (50, 100))
         self.assertEqual([x["model"] for x in res["models"]], ["slow", "fast"])   # best accuracy first
@@ -774,7 +778,7 @@ class PTAIndex(unittest.TestCase):
         self.assertEqual([compare.pct(f) for f in (467 / 469, 1, 0, 0.5)], ["99.6%", "100%", "0%", "50.0%"])
         row = lambda model, a: {"model": model, "P": 100, "T": 100, "A": a, "tokens_x": 1, "time_x": 1}
         bars = pta.bars({"models": [row("two-wrong", 100 * 467 / 469), row("perfect", 100.0)]}, 10, markup=False)
-        two_wrong, perfect = bars[1].split(), bars[2].split()
+        two_wrong, perfect = bars[2].split(), bars[3].split()
         self.assertEqual((two_wrong[-2], two_wrong[-1]), ("█████████░", "99.6%"))   # not a full bar
         self.assertEqual((perfect[-2], perfect[-1]), ("██████████", "100%"))
 
@@ -799,6 +803,18 @@ class PTAIndex(unittest.TestCase):
         picked = pta.index(rows, ["a", "few"])      # picked by hand: compared anyway
         self.assertEqual((picked["questions"], picked["left_out"]), (1, []))
 
+    def test_results_sort_values(self):
+        from tuieval.tui import diff_badge, sort_cell, sort_key, sort_value
+        got = [sort_value(c) for c in ("1,234 ★", "3.1k", "2.4×", "4m10s", "1h02m", "12.5s", diff_badge("hard"),
+                                        "[bold green]PASS[/]", "[green]OK 12s[/] [dim]measured[/dim]",
+                                        "[bold red]doesn't fit[/]", "Top 10 holdings")]
+        self.assertEqual(got, [1234, 3100, 2.4, 250, 3720, 12.5, 3, 3, 12, float("inf"), "top 10 holdings"])
+        self.assertEqual([sort_value(c) for c in ("-", "[dim]-[/dim]", "[dim]no data[/]", "")], [None] * 4)
+        self.assertEqual(sort_value(sort_cell("[green]✓[/green] 3.1k 12s", 3100)), 3100)
+        cells = ["3/4", "-", "10/20", "4/4", "abc"]       # numbers, then text; empty cells last both ways
+        self.assertEqual(sorted(cells, key=sort_key), ["10/20", "3/4", "4/4", "abc", "-"])
+        self.assertEqual(sorted(cells, key=lambda c: sort_key(c, True)), ["4/4", "3/4", "10/20", "abc", "-"])
+
     def test_cli_report_and_tui(self):
         with tempfile.TemporaryDirectory() as tmp:
             ws = os.path.join(tmp, "ws")
@@ -853,8 +869,37 @@ class PTAIndex(unittest.TestCase):
                         app.screen.fill_per_question()
                         await pilot.pause(0.3)
                         alone = pq.row_count
+                        tab = app.screen.query_one(TabbedContent).active
+
+                        async def click_header(t, name):   # a real click on the column name
+                            i = next(i for i, c in enumerate(t.ordered_columns) if c.label.plain.startswith(name))
+                            x = sum(c.get_render_width(t) for c in t.ordered_columns[:i]) + 1
+                            await pilot.click(t, offset=(x, 0))
+                            await pilot.pause(0.2)
+                            return [str(t.get_row_at(r)[0]) for r in range(t.row_count)], \
+                                   [c.label.plain for c in t.ordered_columns]
+                        sorts = {}
+                        pta_t = app.screen.query_one("#pta", DataTable)
+                        sorts["up"], _ = await click_header(pta_t, "answers right")
+                        sorts["down"], sorts["labels"] = await click_header(pta_t, "answers right")
+                        app.pq_models = set()
+                        app.screen.fill_pta()                                   # rebuilt: still sorted
+                        await pilot.pause(0.2)
+                        sorts["kept"] = [str(pta_t.get_row_at(r)[0]) for r in range(pta_t.row_count)]
+                        app.screen.query_one(TabbedContent).active = "tab-failures"
+                        await pilot.pause(0.3)
+                        f = app.screen.query_one("#failures", DataTable)
+                        await click_header(f, "Test")
+                        sorts["tests"], _ = await click_header(f, "Test")
+                        sorts["tests"] = [str(f.get_row_at(r)[2]) for r in range(f.row_count)]
+                        f.focus()
+                        f.move_cursor(row=0)
+                        await pilot.press("enter")                              # opens the row shown, not the first failure
+                        await pilot.pause(0.3)
+                        s = app.screen
+                        sorts["opened"] = s.entries[s.index]["record"]["test"]
                         print(json.dumps({"rows": rows, "bars": "P parsimony" in tri, "disagree": [both, alone],
-                                          "tab": app.screen.query_one(TabbedContent).active}))
+                                          "tab": tab, "sorts": sorts}))
                 asyncio.run(go())
             """)
             p = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True, timeout=300,
@@ -865,6 +910,10 @@ class PTAIndex(unittest.TestCase):
             self.assertEqual(got["disagree"], [4, 0])
             self.assertEqual(got["tab"], "tab-pta")                  # Results opens on the PTA index
             self.assertEqual([(r[0], r[3]) for r in got["rows"]][0], ("good", "4/4"))
+            s = got["sorts"]   # a click on a column name sorts by it, a second click reverses
+            self.assertEqual((s["up"], s["down"], s["kept"]), (["hosted", "good"], ["good", "hosted"], ["good", "hosted"]))
+            self.assertIn("answers right ▼", s["labels"])
+            self.assertEqual((s["tests"][0], s["opened"]), ("apps: d", "d"))
 
 
 class Unavailable(unittest.TestCase):