tuieval 0.2.0.dev99__py3-none-any.whl → 0.2.0.dev103__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.dev99'
-__version_tuple__ = version_tuple = (0, 2, 0, 'dev99')
+__version__ = version = '0.2.0.dev103'
+__version_tuple__ = version_tuple = (0, 2, 0, 'dev103')
 
 __commit_id__ = commit_id = None

tuieval/compare.py

@@ -41,6 +41,7 @@ def _load_native(data):
             "pack": pack["name"], "pack_fp": pack["fingerprint"],
             # hosted (OpenRouter) models: the provider endpoint and its declared quantization
             "endpoint": run.get("endpoint"), "quantization": run.get("quantization"),
+            "hosted": bool(run.get("hosted") or run.get("endpoint")),
             "loaded_alongside": run.get("loaded_alongside") or []}
     rows = []
     for r in data["results"]:
@@ -78,9 +79,37 @@ def load(paths):
             row.update(raw=rec, path=path, pack_fp=data["pack"]["fingerprint"])
         rows += r
         infos.append(i)
+    # older results also noted hosted models alongside, which share nothing of this machine: a hosted
+    # model's rows note no one, and no one notes it
+    labels, prefixes = configured_hosted(paths)
+    labels |= {i["label"] for i in infos if i["hosted"]}
+
+    def local(along):
+        return [l for l in along if l not in labels and not l.startswith(tuple(prefixes))]
+    for row in rows:
+        row["alongside"] = [] if row["model"] in labels else local(row["alongside"])
+    for i in infos:
+        i["loaded_alongside"] = [] if i["label"] in labels else local(i["loaded_alongside"])
     return rows, infos
 
 
+def configured_hosted(paths):
+    """(labels, label prefixes) models.toml says are hosted, in the workspaces these results/<label>/
+    <pack>.json are from: its hosted models, and the prefix of models named at run time on a hosted
+    server (e.g. "or-"). Covers hosted models whose results aren't loaded."""
+    from . import engine
+    labels, prefixes = set(), set()
+    for root in {os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(p)))) for p in paths}:
+        try:
+            cfg = engine.load_config(os.path.join(root, "models.toml"))
+        except Exception:
+            continue    # no readable models.toml there: the results' own marks still apply
+        labels |= {m["label"] for m in cfg["models"] if engine.hosted(cfg, m)}
+        prefixes |= {engine.remote_label(n, s, "") for n, s in cfg["servers"].items()
+                     if s.get("any_model") and engine.hosted(cfg, {"server": n})}
+    return labels, prefixes
+
+
 def default_paths(results_dir=None):
     """results/<label>/<pack>.json, excluding smoke runs and the archive."""
     results_dir = results_dir or workspace.path("results")

tuieval/engine.py

@@ -83,6 +83,21 @@ def builtin_config():
         return tomllib.load(f)
 
 
+def hosted(cfg, m):
+    """A model served by an API elsewhere: tuieval doesn't start its server and its url isn't this
+    machine (or its server sets hosted = true). A server you started yourself on localhost still
+    counts as local (it uses the GPU)."""
+    if m.get("remote"):
+        return True
+    server = cfg["servers"][m["server"]]
+    if "hosted" in server:   # say so for a server the url doesn't give away (e.g. a local proxy to an API)
+        return bool(server["hosted"])
+    if server.get("cmd"):
+        return False
+    host = urllib.parse.urlparse(server.get("url") or "").hostname or ""
+    return bool(host) and host not in ("localhost", "127.0.0.1", "::1", "0.0.0.0")
+
+
 def load_config(path):
     """Read models.toml, fill in the built-ins it leaves out (builtin.toml) and each model's defaults.
     [defaults] are filled key by key; [sampling] only when models.toml has none (sampling is part of
@@ -442,6 +457,7 @@ class Job:
     earlier: list = dataclasses.field(default_factory=list)  # earlier sittings (see Engine._sittings)
     stop_early: bool = False  # stop once the pack's FAIL is certain (verdict.fail_certain)
     first: list = dataclasses.field(default_factory=list)   # test ids round 1 asks first (most failed)
+    claimed: bool = False   # its model's server took it on: it can no longer be removed from the run
 
     @property
     def label(self):
@@ -675,8 +691,9 @@ class Lane:
     """One model being run: its own request stream, stall reason and skip switch, so models run
     side by side (parallel_models) stop independently. Runs and tunes in one lane use the engine's
     main lane."""
-    def __init__(self, label=None):
+    def __init__(self, label=None, hosted=False):
         self.label = label
+        self.hosted = hosted      # a hosted model shares nothing of this machine, so it's never noted alongside
         self.stream = None
         self.stall = None         # set by the stall watcher: why this model's server stalled
         self.skip = threading.Event()
@@ -1282,18 +1299,7 @@ class Engine:
                 + min(parallel_hosted or self.parallel_hosted(), hosted))
 
     def hosted(self, m):
-        """A model served by an API elsewhere: tuieval doesn't start its server and its url isn't this
-        machine (or its server sets hosted = true). A server you started yourself on localhost still
-        counts as local (it uses the GPU)."""
-        if m.get("remote"):
-            return True
-        server = self.cfg["servers"][m["server"]]
-        if "hosted" in server:   # say so for a server the url doesn't give away (e.g. a local proxy to an API)
-            return bool(server["hosted"])
-        if server.get("cmd"):
-            return False
-        host = urllib.parse.urlparse(server.get("url") or "").hostname or ""
-        return bool(host) and host not in ("localhost", "127.0.0.1", "::1", "0.0.0.0")
+        return hosted(self.cfg, m)
 
     def memory_need_gb(self, m):
         """GPU memory a model takes while served here: 0 for one we don't start (a hosted API or a
@@ -1723,6 +1729,33 @@ class Engine:
             r["cond"].notify_all()
         return added, None if added else "everything picked is already in the run"
 
+    def removable(self, job):
+        """Why a job of the run going can't be removed (None: it can): only a pack not yet started."""
+        if job.status in ("done", "failed", "skipped"):
+            return "it has finished"
+        if job.claimed or job.status == "running":
+            return "it's running (k skips the model)"
+        return None
+
+    def remove_jobs(self, keys):
+        """Take jobs not yet started (removable) out of the run going, the reverse of add_jobs: they never
+        run, and a model left with none isn't started. Returns the jobs removed."""
+        removed = []
+        with self._run_lock:
+            r = self._run
+            if not r or not r["open"]:
+                return removed
+            for j in [j for j in r["jobs"] if j.key in keys and self.removable(j) is None]:
+                j.status, j.note = "removed", "removed from the run"
+                r["jobs"].remove(j)
+                for _, group in r["pending"]:
+                    if j in group:
+                        group.remove(j)
+                removed.append(j)
+            r["pending"][:] = [g for g in r["pending"] if g[1]]   # the lanes hold this very list
+            r["cond"].notify_all()
+        return removed
+
     def _run_lanes(self, parallel, parallel_hosted=4):
         """Run each model's jobs in its own lane: up to `parallel` local models at a time, in order (the
         next one starts once a lane is free, nothing running stops it (runs_alone), and its memory fits
@@ -1817,15 +1850,23 @@ class Engine:
         for t in threads:
             t.join()
 
+    def _local_lanes(self, lane, exclude=None):
+        """Labels of the local models served now (call with _lanes_lock held); none for a hosted lane."""
+        if lane.hosted:
+            return set()
+        return {l for l, o in self._lanes.items() if not o.hosted} - {exclude}
+
     def _run_lane(self, label, mine):
         """One model's jobs, in this thread's own lane. Other models served meanwhile are noted on
-        each answer (ran_alongside), since they share the machine's GPU and memory bandwidth."""
-        lane = Lane(label)
+        each answer (ran_alongside), since they share the machine's GPU and memory bandwidth. Hosted
+        models share neither, so they note nothing and nobody notes them."""
         m = mine[0].model
+        lane = Lane(label, self.hosted(m))
         with self._lanes_lock:
-            for other in self._lanes.values():
-                other.seen.add(label)
-            lane.seen = set(self._lanes)
+            if not lane.hosted:
+                for other in self._lanes.values():
+                    other.seen.add(label)
+            lane.seen = self._local_lanes(lane)
             if self.cfg["servers"][m["server"]].get("cmd"):
                 lane.port = self._lane_port(m)
             self._lanes[label] = lane
@@ -1987,6 +2028,8 @@ class Engine:
                         "kv_type": sv.kv_type, "perf_args": sv.perf_args if local else None,
                         "perf_source": sv.perf_source, "server_version": self.server_version(m) if local else None}
         ep = self.endpoint(m)
+        if self.hosted(m):
+            serving_info["hosted"] = True
         if ep:
             serving_info.update(endpoint=ep["tag"], provider=ep.get("provider"), quantization=ep.get("quantization"))
         for j in jobs:
@@ -2006,6 +2049,10 @@ class Engine:
             failed_in_row = 0
             for j in jobs:
                 self._check()
+                with self._run_lock:
+                    if j.status == "removed":   # taken out of the run while its model ran another pack
+                        continue
+                    j.claimed = True
                 try:
                     self._run_job(j, base_url, run_info, alive=info["alive"])
                 except BaseException as ex:
@@ -2244,7 +2291,7 @@ class Engine:
                 self._check()
                 lane = self._lane()
                 with self._lanes_lock:
-                    lane.seen = set(self._lanes) - {job.label}
+                    lane.seen = self._local_lanes(lane, job.label)
                 self.emit("request_started", job=job, test=test["description"], test_id=test["id"],
                           has_image=bool(test.get("image")), repeat=rep, difficulty=test.get("difficulty", "unrated"))
                 waits = list(self.SERVER_RETRY_WAITS_S)

tuieval/tui.py

@@ -1828,16 +1828,33 @@ class RetestScreen(ModalScreen):
 
 
 class ConfirmScreen(ModalScreen):
-    def __init__(self, question):
+    """Yes or no; No has the focus, so Enter by reflex changes nothing. y: yes; n or Esc: no
+    (and no_keys, e.g. the key that opened it, pressed again)."""
+    BINDINGS = [Binding("y", "answer(True)", "Yes", show=False), Binding("n", "answer(False)", "No", show=False),
+                Binding("escape", "answer(False)", "No", show=False)]
+
+    def __init__(self, question, no_keys=()):
         super().__init__()
         self.question = question
+        self.no_keys = no_keys
 
     def compose(self) -> ComposeResult:
         with Vertical(id="dialog"):
             yield Label(self.question)
             with Horizontal(classes="dialog-buttons"):
-                yield Button("Yes", id="yes", variant="error")
-                yield Button("No", id="no")
+                yield Button("Yes (y)", id="yes", variant="error")
+                yield Button("No (n)", id="no")
+
+    def on_mount(self):
+        self.query_one("#no", Button).focus()
+
+    def on_key(self, event):
+        if event.key in self.no_keys:
+            event.stop()
+            self.dismiss(False)
+
+    def action_answer(self, yes):
+        self.dismiss(yes)
 
     @on(Button.Pressed)
     def answer(self, event):
@@ -2114,6 +2131,7 @@ class RunScreen(Screen):
     # priority: these work whichever pane has focus (the text panes would otherwise swallow keys)
     BINDINGS = [
         Binding("k", "skip_model", "Skip model", priority=True),
+        Binding("x", "remove_job", "Remove from run", priority=True),
         Binding("c", "cancel_all", "Cancel all", priority=True),
         Binding("f", "toggle_follow", "Pause scroll", priority=True),
         Binding("v", "watch_next", "Next model", priority=True),
@@ -2124,7 +2142,7 @@ class RunScreen(Screen):
         Binding("q", "back", "Back", show=False, priority=True),
     ]
     kind = "Run"
-    LIVE_ONLY = {"skip_model", "cancel_all", "toggle_follow"}
+    LIVE_ONLY = {"skip_model", "remove_job", "cancel_all", "toggle_follow"}
     DONE_ONLY = set()
 
     def __init__(self, jobs, parallel=None):
@@ -2180,6 +2198,8 @@ class RunScreen(Screen):
     def check_action(self, action, parameters):
         if action == "watch_next":
             return self.running and self.side_by_side
+        if action == "remove_job":   # only while something is left to remove
+            return self.running and any(self.app.engine.removable(j) is None for j in self.jobs)
         if action in self.LIVE_ONLY:
             return self.running
         if action in self.DONE_ONLY:
@@ -2219,7 +2239,7 @@ class RunScreen(Screen):
         with Vertical(id="top"):
             yield Static(id="overall")
             yield ProgressBar(id="bar", show_eta=False)
-            yield DataTable(id="queue", cursor_type="none", zebra_stripes=True)
+            yield DataTable(id="queue", cursor_type="row", zebra_stripes=True)
         yield Static(id="current")
         with Horizontal(id="done-bar"):
             yield Button("New run  [n]", id="done-new", variant="success")
@@ -2365,10 +2385,12 @@ class RunScreen(Screen):
                 self.total += j.total
             self.query_one("#bar", ProgressBar).update(total=max(self.total, 1))
             self.event(f"added to this run: {', '.join(j.key for j in d['jobs'])}")
+            self.refresh_bindings()
             self.update_overall()
         elif kind in ("job_started", "job_update", "job_done"):
             job = d["job"]
             self.update_job(job)
+            self.refresh_bindings()   # x shows while a pack can still be removed
             if kind == "job_started" and d.get("resumed"):
                 earlier = (f" ({fmt_secs(d['earlier_s'])} over {d['sittings']} earlier sitting(s))"
                            if d.get("sittings") else "")
@@ -2611,13 +2633,63 @@ class RunScreen(Screen):
 
     # -- actions
     def action_skip_model(self):
-        if self.running:
-            if self.side_by_side and self.watch:
-                self.app.engine.skip_model(self.watch)
-                self.notify(f"Skipping {self.watch}; the others keep going…")
+        if not self.running:
+            return
+        one = self.watch if self.side_by_side and self.watch else None
+        names = [one] if one else self.active()
+        if not names:
+            return
+
+        def skip(yes):
+            if not yes or not self.running:
+                return
+            if one:
+                self.app.engine.skip_model(one)
+                self.notify(f"Skipping {one}; the others keep going…")
             else:
                 self.app.engine.skip_model()
                 self.notify("Skipping the current model…")
+        self.app.push_screen(ConfirmScreen(
+            f"Skip {', '.join(names)}? Answers so far are kept (a later run picks up from them); the rest "
+            f"of {'its' if len(names) == 1 else 'their'} questions in this run are skipped.", no_keys=("k",)), skip)
+
+    def action_remove_job(self):
+        """Take the highlighted pack out of the run if it hasn't started (the reverse of adding it)."""
+        if not self.running:
+            return
+        q = self.query_one("#queue", DataTable)
+        try:
+            key = q.coordinate_to_cell_key(q.cursor_coordinate).row_key.value
+        except Exception:
+            key = None
+        job = next((j for j in self.jobs if j.key == key), None)
+        if job is None:
+            self.notify("Highlight a pack in the queue (click it or use ↑/↓ there), then press x.")
+            return
+        why = self.app.engine.removable(job)
+        if why:
+            self.notify(f"{job.label} · {job.pack.label} can't be removed: {why}.")
+            return
+
+        def remove(yes):
+            if not yes:
+                return
+            removed = self.app.engine.remove_jobs({job.key})
+            if not removed:
+                self.notify(f"{job.label} · {job.pack.label} started meanwhile, so it stays (k skips the model).")
+                return
+            for j in removed:
+                q.remove_row(j.key)
+                self.total -= j.total
+            self.query_one("#bar", ProgressBar).update(total=max(self.total, 1))
+            self.event(f"removed from this run: {', '.join(j.key for j in removed)}")
+            self.update_overall()
+            self.refresh_bindings()
+            self.app.refresh_live()
+            self.notify(f"Removed from the run: {job.label} · {job.pack.label}.")
+        self.app.push_screen(ConfirmScreen(
+            f"Remove {job.label} · {job.pack.label} from this run? It hasn't started, so nothing is lost; "
+            "Start can add it again later.", no_keys=("x",)), remove)
 
     def action_watch_next(self):
         """Stream the next model running alongside (from its next answer)."""
@@ -3489,7 +3561,7 @@ class EvalsApp(App):
             return
         run.handle("jobs_added", {"jobs": added})
         models = sorted({j.label for j in added})
-        self.notify(f"Added {len(added)} pack run(s) to the run going: {', '.join(models)}. w shows it.", timeout=10)
+        self.notify(f"Added {len(added)} pack run(s) to the run going: {', '.join(models)}. x removes a pack not started yet.", timeout=10)
         self.refresh_live()
 
     def enqueue(self, item):

{tuieval-0.2.0.dev99.dist-info → tuieval-0.2.0.dev103.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tuieval
-Version: 0.2.0.dev99
+Version: 0.2.0.dev103
 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
@@ -143,7 +143,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.
+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 (after a yes), `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. `x` takes a pack that hasn't started out of the run; `w` lists queued runs (`del` removes one).
 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.dev99.dist-info → tuieval-0.2.0.dev103.dist-info}/RECORD

@@ -1,12 +1,12 @@
 tuieval/__init__.py,sha256=myVXVX7htbwezW6k3x_FuKgn1RSZ2WcTaDEMByGn6Wg,312
 tuieval/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
-tuieval/_version.py,sha256=EnjLNHE3-O1-hviWXp7HEQ3pbBMWrRtAx08ValpcMyA,535
+tuieval/_version.py,sha256=OqCp46F86BGn3PQMHx7-p_Mh-DxYSRy-JY729z5yOWM,537
 tuieval/builtin.toml,sha256=Nwu7O0qFzcrDAxXO_VZtDPvjVwxZ29OtYOW0BPihZGs,4410
 tuieval/cli.py,sha256=mr0o_ud6NctZeU4WIrh17x_uzEK0vTeCynGP0wrCeBY,4812
 tuieval/client.py,sha256=wtACBVsngtWopWWhIc4bB6mEUEi31dvvDePN-PjmXbM,11122
-tuieval/compare.py,sha256=uXU_Yzf4zDSHoupHQrTmBhsfc8wCyI1nMaZQN81ybiA,30522
+tuieval/compare.py,sha256=UjZcWsbPep7EG4XRKWaEthUT0l0iN8rKIs1135dbt6c,32139
 tuieval/doctor.py,sha256=j2MdDORstsAGPnRmpsnxau1_fR6sTc_oEFGM5zugTJU,7246
-tuieval/engine.py,sha256=96GWzKzMQ_KaG6wXrIuBiKWFCcblXWL9cQs89QYgj7Y,125256
+tuieval/engine.py,sha256=J_r60eRHkJYWFXkK5C0soYzeDkJqep0SS14GixC7NOE,127431
 tuieval/export.py,sha256=dbHQgL_ubWtIPM1sLzAew_gETnrDJyd0zgqVA5vkpXM,9657
 tuieval/insights.py,sha256=m6HZk1VbX-avHr3xyT8eVJ5OLjKa_EKTVBxsu04X_HQ,28947
 tuieval/logs.py,sha256=01gZK6tf53dIThaIrs1bEsz9eqKYVlcxpyaLnSPTVxo,8127
@@ -19,7 +19,7 @@ tuieval/remove.py,sha256=Vwh43nm9lVb9U9aN-h6CMYbkTwdR3UWfZObwweF72n0,5157
 tuieval/run_evals.py,sha256=DN6FhC8Zj08N5pwlrCmlkbkTxA2vmT-G5sWJnp-S-AI,50114
 tuieval/scaffold.py,sha256=YBOqniJpf_GtKKAFF3_OHxxMGbmTWdFjcClGcOnrrKE,12130
 tuieval/selftest.py,sha256=nExkrOidgymlmvkxImEBfrQG5iTUN5WuRMIKtqusCCs,9835
-tuieval/tui.py,sha256=yO69K_LfK5pfUZkQgxA7UqFbXK7BtDr6Y6A8JZCBA9E,184628
+tuieval/tui.py,sha256=o9FpDJZH3cWBAjbEVnNzS3B6-tl6ke928zVIb6M7uhI,187913
 tuieval/tune.py,sha256=azxxthgJeag8JyoQUgaRxq6oI1XvEgzb9vkszjJZH7w,39645
 tuieval/verdict.py,sha256=3SM8qrVdWNIFDENagaR5ZPBYEnjsBtkYB9WS5TDVssU,20517
 tuieval/watch_proxy.py,sha256=bnDO1i6n6yUs1hODoUWcMppJMGPavoQqs6aNYrIxpT8,11416
@@ -48,8 +48,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.dev99.dist-info/METADATA,sha256=ulrRF0F1nVj2zmY3ds6cF6VpvOBOG3rOOjbZeyNxIT0,14580
-tuieval-0.2.0.dev99.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-tuieval-0.2.0.dev99.dist-info/entry_points.txt,sha256=7eIhi1GpFxBP2OLJV02Nn8LwsNuO512eKOGt1IBbj04,45
-tuieval-0.2.0.dev99.dist-info/licenses/LICENSE,sha256=7wfRgGtBGH1aXhZkIn47oUznqKC18kEPMvUVgol7Ffc,1077
-tuieval-0.2.0.dev99.dist-info/RECORD,,
+tuieval-0.2.0.dev103.dist-info/METADATA,sha256=fTjLV29L3PEdrDViPhlaqlfJF7h1n2Bw1ruGyKniKPk,14691
+tuieval-0.2.0.dev103.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+tuieval-0.2.0.dev103.dist-info/entry_points.txt,sha256=7eIhi1GpFxBP2OLJV02Nn8LwsNuO512eKOGt1IBbj04,45
+tuieval-0.2.0.dev103.dist-info/licenses/LICENSE,sha256=7wfRgGtBGH1aXhZkIn47oUznqKC18kEPMvUVgol7Ffc,1077
+tuieval-0.2.0.dev103.dist-info/RECORD,,