laboard 1.0.0__py3-none-any.whl

laboard/newproject.py

@@ -0,0 +1,287 @@
+from pathlib import Path
+
+from PyQt6.QtCore import QPointF, Qt, QTimer
+from PyQt6.QtGui import QColor
+from PyQt6.QtWidgets import QGraphicsDropShadowEffect, QGraphicsOpacityEffect
+
+from . import store, tomledit
+from .theme import NEGATIVE
+from .widgets import (CROSS, Box, Button, Flow, HLine, Label, LineEdit, Overlay, Scroll, Segmented, Stroke, card,
+                      clear_layout, col, hbox, vbox, wrap)
+
+
+def _text(key, desc, ph="", req=False):
+    return dict(key=key, desc=desc, ph=ph, req=req, kind="text")
+
+
+def _enum(key, desc):
+    return dict(key=key, desc=desc, kind="enum", opts=("CSV", "DB"))
+
+
+SCHEMA = (
+    ("Project", "Raw data is shared by every task; each task has its own labels and predictions.", (
+        _text("Name", "Project name. Empty: the root folder’s name.", "cifar10-resnet"),
+        _text("Root", "Folder of the project’s git repository.", "~/projects/cifar10-resnet"),
+        dict(key="Task", desc="One task or several. Saved comma-separated.", kind="chips", opts=tomledit.TASKS),
+        dict(key="DB", desc='True when [Data], [Label] or [Prediction] uses Type = "DB".', kind="bool"))),
+    ("DB", "Database connection. Shown and used when [Project] DB = True.", (
+        _text("DB", "Database type, e.g. supabase.", "supabase"),
+        _text("DB_ip", "Database address.", "http://127.0.0.1:54323/  or  postgresql://user:password@host:5432/db"))),
+    ("Git", "Fallbacks when git can’t tell.", (
+        _text("Remote", "Remote URL.", "github.com:user/repo.git"),
+        _text("Branch", "Branch name.", "main"))),
+    ("Path", "Each may hold one folder per task, e.g. Results/classification/<model>/.", (
+        _text("Models", "Folder with model checkpoints.", "models/"),
+        _text("Hyperparameter", "Folder with one sub-folder per training run.", "runs/"),
+        _text("Results", "Folder with result files.", "results/"))),
+    ("Data", "The raw data files, one list for every task.", (
+        _enum("Type", "Where the file list comes from."),
+        _text("File_path", "CSV: the csv listing the files.", "data/files.csv"),
+        _text("Table", "DB: table with one row per file.", "raw_files"),
+        _text("Raw", "CSV / DB: column with each raw file’s path.", "file_path"))),
+    ("Label", "Ground truth, one column for every task.", (
+        _enum("Type", "Where the labels come from."),
+        _text("File_path", "CSV: the labels csv.", "data/labels.csv"),
+        _text("Table", "DB: table with the labels.", "labels"),
+        _text("Label", "Its column. A task column picks each task’s row.", "label"))),
+    ("Prediction", "Any key can be set for one task as <Task>_<Key>, e.g. Instance_segmentation_Predict.", (
+        _enum("Type", "Where the predictions come from."),
+        _text("File_path", "CSV: result file name / glob under Path.Results/<task>.", "predictions_*.csv"),
+        _text("Table", "DB: table with the predictions.", "predictions"),
+        _text("Predict", "Predicted-class column.", "pred"),
+        _text("Predict_score", "Score column.", "score"))),
+    ("gcloud", "gcloud compute ssh <instance_name> --zone <zone>", (
+        _text("instance_name", "The VM instance’s name.", "instance name", True),
+        _text("zone", "Instance zone.", "us-west1-b"))),
+    ("az", "az ssh vm --name <vm_name> --resource-group <resource-group>", (
+        _text("vm_name", "The Azure VM’s name.", "VM name"),
+        _text("resource-group", "Its resource group.", "resource group"))),
+    ("aws", "Sends the public key (EC2 Instance Connect), then ssh -i <private key> <user>@<public ip>.", (
+        _text("instance-id", "EC2 instance ID.", "i-0123456789abcdef0", True),
+        _text("instance-os-user", "The login user, e.g. ec2-user, ubuntu.", "ec2-user", True),
+        _text("ssh-public-key", "Public key. The private key is this file without .pub.", "file://~/.ssh/id_ed25519.pub",
+              True),
+        _text("availability-zone", "Its region finds the instance’s public ip.", "us-east-1a"))),
+    ("ssh", "ssh -i ~/.ssh/<key_name> <user_name>@<ip>", (
+        _text("key_name", "A key under ~/.ssh, or the key file’s own path when it has a \"/\".", "id_ed25519"),
+        _text("user_name", "Login user. Empty: ssh’s default.", "ubuntu"),
+        _text("ip", "Server address (ip or host name).", "192.168.0.10", True))),
+)
+CLOUD = ("gcloud", "az", "aws", "ssh")
+SHOWN = {"gcloud": "Google Cloud - gcloud", "az": "Azure - az", "aws": "AWS - aws", "ssh": "SSH - ssh"}
+REQUIRED = ("Project",)
+OFF = set(CLOUD)
+TITLE_BAR, TITLE_FG, TITLE_MUTE, CLOSE_BG = "#0e0f0c", "#e8ebe6", "#868685", "#2a2b28"
+
+
+def _group(section):
+    return "Cloud" if section in CLOUD else section
+
+
+def _free_path(folder):
+    f, n = folder / "laboard.toml", 2
+    while f.exists():
+        f, n = folder / f"laboard_{n}.toml", n + 1
+    return f
+
+
+class CreateProject(Overlay):
+    W, H = 1180, 900
+
+    def __init__(self, app):
+        super().__init__(app)
+        self.app, self.values, self.group = app, {}, "Project"
+        self.on = {name: name not in OFF for name, _, _ in SCHEMA}
+        loaded = store.PROJECT.get("toml")
+        self.folder = Path(loaded).parent if loaded else Path.home()
+
+        close = Box(bg=CLOSE_BG, radius=12, on_click=self.close,
+                    layout=hbox(Stroke(CROSS, 10, TITLE_FG, 1.5), align=Qt.AlignmentFlag.AlignCenter))
+        close.setFixedSize(24, 24)
+        bar = Box(bg=TITLE_BAR, radius=0, layout=hbox(
+            (Label("Laboard", 13, 600, TITLE_FG), 1),
+            (Label("Create project file — laboard.toml", 13, 400, TITLE_MUTE, align=Qt.AlignmentFlag.AlignCenter), 2),
+            (hbox("stretch", close), 1), spacing=12, margins=(16, 0, 10, 0), align=Qt.AlignmentFlag.AlignVCenter))
+        bar.setFixedHeight(38)
+        bar.setStyleSheet(f"QFrame#{bar.objectName()}{{background:{TITLE_BAR};border-top-left-radius:12px;"
+                          "border-top-right-radius:12px;}")
+
+        self.nav = vbox(spacing=2)
+        side = Box(bg="surf", radius=16, layout=vbox(Label("Sections", 16, 600, lh=24), 8, self.nav, "stretch",
+                                                     margins=(8, 16, 8, 16)))
+        side.layout().itemAt(0).widget().setContentsMargins(10, 0, 10, 0)
+        side.setFixedWidth(230)
+
+        self.cards = vbox(spacing=12)
+        self.scroll = Scroll(wrap(vbox(self.cards, "stretch")))
+        self.path = LineEdit("", size=13, pad=(8, 12), mono=True)
+        self.path.setText(str(_free_path(self.folder)))
+        self.path.setFixedHeight(40)
+        self.path.returnPressed.connect(self.create)
+        self.error = Label("", 12, 400, NEGATIVE, wrap=True)
+        self.error.hide()
+        foot = Box(bg="surf", radius=16, layout=hbox(
+            (vbox(Label("Save to", 13, 600, lh=18), 6, self.path, self.error, spacing=0), 1), 12,
+            vbox("stretch", hbox(Button("Cancel", "tertiary", on_click=self.close), 10,
+                                 Button("Create and load", "primary", on_click=self.create))),
+            margins=(20, 14, 20, 14)))
+        right = vbox((self.scroll, 1), 12, foot)
+
+        self.panel = Box(bg="bg", radius=12, layout=vbox(bar, hbox(side, 12, (right, 1), margins=(12, 12, 12, 12)), 1))
+        self.panel.setGraphicsEffect(QGraphicsDropShadowEffect(blurRadius=64, offset=QPointF(0, 24),
+                                                               color=QColor(14, 15, 12, 102)))
+        self.setLayout(vbox("stretch", hbox("stretch", self.panel, "stretch"), "stretch"))
+        self._fit()
+        self.show_group("Project")
+
+    def _fit(self):
+        super()._fit()
+        if getattr(self, "panel", None) is not None:
+            self.panel.setFixedSize(min(self.W, self.width() - 48), min(self.H, self.height() - 48))
+
+    def enabled(self, name):
+        if name in REQUIRED:
+            return True
+        return self.values.get("Project.DB") is True if name == "DB" else self.on[name]
+
+    def switch(self, name, on):
+        if name == "DB":
+            self.values["Project.DB"] = on
+        else:
+            self.on[name] = on
+        self.show_group(self.group, keep_scroll=True)
+
+    def show_group(self, group, keep_scroll=False):
+        at = self.scroll.verticalScrollBar().value() if keep_scroll else 0
+        groups = list(dict.fromkeys(_group(s[0]) for s in SCHEMA))
+        self.group = group if group in groups else "Project"
+        clear_layout(self.nav)
+        for g in groups:
+            secs = [s for s in SCHEMA if _group(s[0]) == g]
+            on, n = g == self.group, sum(len(s[2]) for s in secs)
+            used = any(self.enabled(s[0]) for s in secs)
+            self.nav.addWidget(Box(bg="sel" if on else None, radius=10, hover=None if on else "surf2",
+                                   on_click=lambda g=g: self.show_group(g), layout=hbox(
+                                       (Label(g, 14, 600 if on else 400, "selfg" if on else "ink" if used else "mute",
+                                              lh=20), 1), 8,
+                                       Label(str(n), 12, 400, "mute"), margins=(10, 7, 10, 7),
+                                       align=Qt.AlignmentFlag.AlignVCenter)))
+        clear_layout(self.cards)
+        for name, desc, fields in SCHEMA:
+            if _group(name) == self.group:
+                self.cards.addWidget(self._card(name, desc, fields))
+        QTimer.singleShot(0, lambda: self.scroll.verticalScrollBar().setValue(at))
+
+    def _card(self, name, desc, fields):
+        on = self.enabled(name)
+        head = hbox(Label(SHOWN.get(name, name), 18, 600, "ink" if on else "mute", mono=True, lh=24), spacing=12,
+                    align=Qt.AlignmentFlag.AlignVCenter)
+        if name in REQUIRED:
+            head.addWidget(Label("required", 11, 600, NEGATIVE, lh=14))
+        head.addStretch(1)
+        if name not in REQUIRED:
+            head.addWidget(Segmented([(False, "False"), (True, "True")], on, lambda v, n=name: self.switch(n, v),
+                                     size=12, pad=(4, 14), outer=3, gap=2))
+        rows = vbox()
+        for f in fields:
+            key = hbox(Label(f["key"], 13, 600, mono=True, lh=18), spacing=6, align=Qt.AlignmentFlag.AlignVCenter)
+            key.addStretch(1)
+            left = vbox("stretch", key, 2, Label(f["desc"], 12, 400, "mute", wrap=True), "stretch")
+            rows.addWidget(HLine())
+            rows.addLayout(hbox((left, 10), 20, (self._editor(name, f), 13), margins=(0, 10, 0, 10),
+                                align=Qt.AlignmentFlag.AlignVCenter))
+        body = wrap(vbox(Label(desc, 13, 400, "body", wrap=True), 8, rows))
+        if not on:
+            body.setEnabled(False)
+            fade = QGraphicsOpacityEffect(body)
+            fade.setOpacity(0.4)
+            body.setGraphicsEffect(fade)
+        return card(head, 4, body, pad=(24, 20, 24, 20))
+
+    def _editor(self, section, f):
+        fid = f"{section}.{f['key']}"
+        if f["kind"] == "text":
+            box = LineEdit(f.get("ph", ""), size=13, pad=(8, 12), mono=True)
+            box.setFixedHeight(40)
+            box.setText(self.values.get(fid, ""))
+            box.textChanged.connect(lambda t: self.values.__setitem__(fid, t))
+            return box
+        if f["kind"] in ("bool", "enum"):
+            opts = [(False, "False"), (True, "True")] if f["kind"] == "bool" else [(o, o) for o in f["opts"]]
+            cur = self.values.get(fid, False if f["kind"] == "bool" else None)
+
+            def pick(v):
+                self.values[fid] = v
+                seg.select(v)
+                if fid == "Project.DB":
+                    self.show_group(self.group, keep_scroll=True)
+            seg = Segmented(opts, cur, pick, size=13, pad=(6, 16))
+            return wrap(hbox(seg, "stretch"))
+        chips = Flow(spacing=6, fill=False)
+        for o in f["opts"]:
+            chips.add(self._chip(fid, o), stretch=0)
+        return wrap(chips)
+
+    def _chip(self, fid, option):
+        lbl = Label(option, 12, 600, lh=18)
+        chip = Box(bg=None, radius=999, layout=hbox(lbl, margins=(12, 5, 12, 5)))
+
+        def paint():
+            on = option in self.values.get(fid, ())
+            chip.restyle(bg="tab" if on else None, border=f"1px solid {col('tab' if on else 'ink')}")
+            lbl.setStyleSheet(f"color:{col('tabfg' if on else 'ink')};background:transparent;")
+
+        def flip():
+            picked = set(self.values.get(fid, ()))
+            picked ^= {option}
+            self.values[fid] = picked
+            paint()
+        chip.clicked.connect(flip)
+        chip.setCursor(Qt.CursorShape.PointingHandCursor)
+        paint()
+        return chip
+
+    def missing(self):
+        return [f"[{name}] {f['key']}" for name, _, fields in SCHEMA if self.enabled(name)
+                for f in fields if f.get("req") and not str(self.values.get(f"{name}.{f['key']}") or "").strip()]
+
+    def text(self):
+        lines = ["# Laboard project file, made with Setting → New. Empty values (\"\") count as not set."]
+        for name, _, fields in SCHEMA:
+            if not self.enabled(name):
+                continue
+            lines += ["", f"[{name}]"]
+            for f in fields:
+                v = self.values.get(f"{name}.{f['key']}")
+                if f["kind"] == "bool":
+                    value = tomledit.written(bool(v))
+                elif f["kind"] == "chips":
+                    value = tomledit.literal(", ".join(t for t in f["opts"] if t in (v or ())))
+                else:
+                    value = tomledit.literal((v or "").strip())
+                lines.append(f"{f['key']} = {value}")
+        return "\n".join(lines) + "\n"
+
+    def create(self):
+        raw = self.path.text().strip()
+        if not raw:
+            return self._fail("Type where to save the project file.")
+        if self.missing():
+            return self._fail("Fill in the required keys, or switch their section off: " + ", ".join(self.missing()))
+        f = Path(raw).expanduser()
+        f = f if f.is_absolute() else self.folder / f
+        f = f if f.suffix == ".toml" else f.with_name(f.name + ".toml")
+        if f.exists():
+            return self._fail(f"{f} already exists; it is never overwritten. Choose another name.")
+        try:
+            f.parent.mkdir(parents=True, exist_ok=True)
+            f.write_text(self.text())
+        except OSError as e:
+            return self._fail(f"Could not write {f}: {e}")
+        self.close()
+        self.app.s.pending_toml = None
+        self.app.load_project(str(f))
+
+    def _fail(self, message):
+        self.error.setText(message)
+        self.error.show()

laboard/pages/data.py

@@ -0,0 +1,352 @@
+import os
+from datetime import datetime
+
+from PyQt6 import sip
+from PyQt6.QtCore import QRect, QRectF, QSize, Qt
+from PyQt6.QtGui import QImageReader, QPainter, QPainterPath, QPixmap
+from PyQt6.QtWidgets import QScrollArea, QSizePolicy, QWidget
+
+from .. import labels as label_values, project, remote, store
+from ..charts import Stage, StackedBar, ZoomView
+from ..theme import T, font, qc
+from ..widgets import (Box, Button, Combo, Dot, HLine, Label, Scroll, Segmented, badge, card, col, elided, empty_state, hbox,
+                       kv_row, scrollbar_css, stat_tile, vbox, wrap)
+
+
+class _Slot(QWidget):
+    def __init__(self, child):
+        super().__init__()
+        self.setLayout(vbox())
+        self.child = child
+        self.layout().addWidget(child, 1)
+
+    def swap(self, child):
+        old, self.child = self.child, child
+        self.layout().replaceWidget(old, child)
+        old.hide()
+        old.deleteLater()
+
+
+class StageArea(QWidget):
+    def __init__(self, panes, mode, bg):
+        super().__init__()
+        self.panes, self.mode, self.bg = panes, mode, bg
+        for p in panes:
+            p.setParent(self)
+        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+        self.setMinimumSize(200, 200)
+
+    def paintEvent(self, e):
+        if self.bg and len(self.panes) == 2:
+            left, right = self.panes[0].geometry(), self.panes[1].geometry()
+            QPainter(self).fillRect(QRect(left.right() + 1, 0, right.left() - left.right() - 1, self.height()), qc(self.bg))
+
+    def resizeEvent(self, e):
+        w, h = self.width(), self.height()
+        if self.mode == "both":
+            half = (w - 2) // 2
+            self.panes[0].setGeometry(0, 0, half, h)
+            self.panes[1].setGeometry(w - half, 0, half, h)
+        else:
+            self.panes[0].setGeometry(0, 0, w, h)
+
+
+_thumbs = {}
+
+
+def _thumb(path):
+    if path.rsplit(".", 1)[-1].lower() not in project.IMAGE_EXT:
+        return None
+    if path not in _thumbs:
+        r = QImageReader(remote.local(path))
+        r.setScaledSize(QSize(76, 76))
+        _thumbs[path] = QPixmap.fromImage(r.read())
+    return _thumbs[path]
+
+
+class Thumb(QWidget):
+    WINDOW = 30
+
+    def __init__(self, short, dot, selected, on_click, path=None):
+        super().__init__()
+        self.short, self.dot, self.selected, self.on_click = short, dot, selected, on_click
+        self.pix = _thumb(path) if path else None
+        self.setFixedSize(80, 80)
+        self.setCursor(Qt.CursorShape.PointingHandCursor)
+
+    def mouseReleaseEvent(self, e):
+        self.on_click()
+
+    def paintEvent(self, e):
+        p = QPainter(self)
+        p.setRenderHint(QPainter.RenderHint.Antialiasing)
+        r = QRectF(2, 2, 76, 76)
+        if self.selected:
+            p.setPen(Qt.PenStyle.NoPen)
+            p.setBrush(qc(T.ink))
+            p.drawRoundedRect(r.adjusted(-2, -2, 2, 2), 10, 10)
+        path = QPainterPath()
+        path.addRoundedRect(r, 8, 8)
+        p.save()
+        p.setClipPath(path)
+        p.fillRect(r, qc(T.bg))
+        if self.pix and not self.pix.isNull():
+            p.drawPixmap(r.toRect(), self.pix)
+        else:
+            p.translate(r.center())
+            p.rotate(-45)
+            p.setPen(Qt.PenStyle.NoPen)
+            p.setBrush(qc(T.surf2))
+            k = -120
+            while k < 120:
+                p.drawRect(QRectF(k, -120, 8, 240))
+                k += 16
+        p.restore()
+        p.setFont(font(10, 600, mono=True))
+        tw = p.fontMetrics().horizontalAdvance(self.short)
+        chip = QRectF(r.x() + 4, r.bottom() - 4 - 16, tw + 10 + 10, 16)
+        p.setPen(Qt.PenStyle.NoPen)
+        p.setBrush(qc(T.surf))
+        p.drawRoundedRect(chip, 4, 4)
+        p.setBrush(qc(col(self.dot)))
+        p.drawEllipse(QRectF(chip.x() + 5, chip.center().y() - 3, 6, 6))
+        p.setPen(qc(T.body))
+        p.drawText(chip.adjusted(15, 0, 0, 0), Qt.AlignmentFlag.AlignVCenter, self.short)
+
+
+GOOD, BAD, PLAIN = "#2ead4b", "#d03238", None
+
+
+def _task(app):
+    return app.s.task if app.s.task in store.TASKS else (store.TASKS[0] if store.TASKS else None)
+
+
+def _sources(app):
+    task = _task(app)
+    return {k: v for k, v in store.INFERENCE.items() if v.get("task") in (None, task)}
+
+
+def _source(app):
+    srcs = _sources(app)
+    name = app.s.infer_source if app.s.infer_source in srcs else next(iter(srcs), None)
+    return name, srcs.get(name)
+
+
+def _label(app, row):
+    task = _task(app)
+    return row["labels"].get(task) if task and "labels" in row else row["label"]
+
+
+def _result(app, row):
+    src = _source(app)[1]
+    if not src:
+        return None
+    return src["by_path"].get(os.path.normpath(row["path"])) or src["by_name"].get(os.path.basename(row["path"]))
+
+
+def _label_and_prediction(app, row):
+    if store.INFERENCE:
+        name, src = _source(app)
+        if src is None:
+            return _label(app, row) or "n/a", [("", f"no predictions for {_task(app)}", PLAIN)]
+        rec = _result(app, row)
+        if rec is None:
+            return _label(app, row) or "n/a", [("", f"not in {src['rel']}", PLAIN)]
+        label, classes = _label(app, row), set(store.CLASSES)
+        chips = []
+        for key, v in rec["values"].items():
+            tone = PLAIN if v in (None, "") else GOOD if str(v) == str(label) else BAD if v in classes else PLAIN
+            chips.append((key, "—" if v in (None, "") else label_values.summary(v), tone))
+        return label or "n/a", chips
+    label = _label(app, row)
+    if row["predict"] in (None, ""):
+        return label or "n/a", [("pred", "none · predict column is empty", PLAIN)]
+    return label or "n/a", [("pred", str(row["predict"]), GOOD if str(row["predict"]) == str(label) else BAD)]
+
+
+def _overlays(app, row):
+    rec = _result(app, row) if store.INFERENCE else None
+    pred = next((v for v in rec["values"].values() if isinstance(label_values.parse(v), (list, dict))), None) if rec else None
+    return label_values.Overlay(_label(app, row)), label_values.Overlay(pred)
+
+
+def _dims(path):
+    if path.rsplit(".", 1)[-1].lower() not in project.IMAGE_EXT:
+        return "—"
+    size = QImageReader(remote.local(path)).size()
+    return f"{size.width()}×{size.height()}" if size.isValid() else "—"
+
+
+def _viewer(app, fd, files, di, sel):
+    s = app.s
+    row = fd["rows"][di]
+    sp = store.split_of(s.folder, di)
+    split_label, split_dot = store.SPLITS[sp]
+    mode = s.view_mode
+    names = [n for n, _ in files]
+    pos = names.index(sel) if sel in names else 0
+    lo = max(0, pos - Thumb.WINDOW)
+    remote.fetch([row["path"]] + [fd["rows"][i]["path"] for _, i in files[lo:pos + Thumb.WINDOW + 1]])
+    ext = row["path"].rsplit(".", 1)[-1].upper() if "." in row["path"] else "FILE"
+    path = remote.local(row["path"]) if ext.lower() in project.IMAGE_EXT else None
+    label, chips = _label_and_prediction(app, row)
+    meta, pred = f"{_dims(row['path'])} {ext}", dict(chips=chips, top=[])
+    label_shapes, pred_shapes = _overlays(app, row) if path else (None, None)
+    both = mode == "both"
+    if not s.zoom or s.zoom[0] != row["path"]:
+        s.zoom = (row["path"], dict(raw=ZoomView(), inference=ZoomView()))
+    views = s.zoom[1]
+    for v in views.values():
+        v.panes = []
+    panes = []
+    if mode != "inference":
+        panes.append(Stage(sel, meta, "raw", label=label_values.summary(label), path=path, radius=12, view=views["raw"],
+                           overlay=label_shapes))
+    if mode != "raw":
+        panes.append(Stage(sel, meta, "inference", pred=pred, path=path, radius=12, view=views["inference"],
+                           overlay=pred_shapes))
+    area = StageArea(panes, mode, "#868685" if both else None)
+    stage = Box(bg="stage", radius=12, border=f"1px solid {T.line}", layout=vbox(area, margins=(1, 1, 1, 1)))
+
+    split_pill = Box(bg="surf2", radius=12, layout=hbox(Dot(split_dot, 8), 6, Label(split_label, 12, 600),
+                                                        margins=(10, 4, 10, 4), align=Qt.AlignmentFlag.AlignVCenter))
+    modes = Segmented([("raw", "Raw"), ("inference", "Predict"), ("both", "Both")], mode,
+                      lambda k: restate(app, view_mode=k), size=13, pad=(6, 16))
+    srcs, task = _sources(app), _task(app)
+    if len(srcs) > 1:
+        shown = lambda k: k.removeprefix(f"{task} · ") if task else k
+        source = Combo([(k, shown(k)) for k in srcs], _source(app)[0], lambda k: restate(app, infer_source=k))
+        modes = hbox(Label("Results", 13, 400, "body"), 8, source, 12, modes, align=Qt.AlignmentFlag.AlignVCenter)
+    if len(store.TASKS) > 1:
+        pick = Combo([(t, t[:1].upper() + t[1:]) for t in store.TASKS], task, lambda k: restate(app, task=k, infer_source=None))
+        modes = hbox(Label("Task", 13, 400, "body"), 8, pick, 12, modes, align=Qt.AlignmentFlag.AlignVCenter)
+    head = hbox(elided(sel, 16, 600, lh=24), 10, split_pill, "stretch", 16, modes, margins=(20, 14, 20, 14), align=Qt.AlignmentFlag.AlignVCenter)
+
+    step = lambda d: names and app.pick("data", names[(pos + d) % len(names)])
+    hint = elided("Scroll to zoom · Shift+scroll or drag to pan · double-click to fit" if path else "", 12, 400, "mute")
+    reset = Button("Reset", on_click=lambda: [v.reset() for v in views.values()]) if path else None
+    nav = hbox(reset, 12 if reset else 0, hint, "stretch", 12, Label(f"{di + 1} of {fd['n']}", 13, 600, "body"), 12,
+               Button("Previous", on_click=lambda: step(-1)), 8, Button("Next", on_click=lambda: step(1)),
+               margins=(20, 12, 20, 0), align=Qt.AlignmentFlag.AlignVCenter)
+
+    thumbs = hbox(spacing=4, margins=(18, 12, 18, 12))
+    for n, i in files[lo:pos + Thumb.WINDOW + 1]:
+        thumbs.addWidget(Thumb(n.rsplit(".", 1)[0][-6:], store.SPLITS[store.split_of(s.folder, i)][1], n == sel,
+                               lambda n=n: app.pick("data", n), path=fd["rows"][i]["path"]))
+    thumbs.addStretch(1)
+    strip = QScrollArea()
+    strip.setWidget(wrap(thumbs))
+    strip.widget().setAutoFillBackground(False)
+    strip.viewport().setAutoFillBackground(False)
+    strip.setWidgetResizable(True)
+    strip.setFrameShape(QScrollArea.Shape.NoFrame)
+    strip.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+    strip.setStyleSheet(scrollbar_css())
+    strip.setFixedHeight(80 + 24 + 10)
+
+    return Box(bg="surf", radius=16, layout=vbox(head, (hbox(stage, margins=(20, 0, 20, 0)), 1), nav, strip))
+
+
+def _splits_card(app):
+    sf = app.s.split_filter
+    total = sum(n for _, n, _ in store.SPLIT_TOTALS)
+    src, desc = store.SPLIT_SOURCE
+    body = vbox(vbox(hbox(Label("Data splits", 16, 600, lh=24), "stretch", Label(src, 12, 400, "mute", mono=True)), 4,
+                     Label(desc, 12, 400, "body", wrap=True), 12,
+                     StackedBar([(n / total, store.SPLITS[k][1]) for k, n, _ in store.SPLIT_TOTALS]), 12, margins=(8, 0, 8, 0)))
+    for k, n, frm in store.SPLIT_TOTALS:
+        name, dot = store.SPLITS[k]
+        pct = n / total
+        row = hbox(Dot(dot, 10), 10, (vbox(Label(name, 13, 600), Label(frm, 11.5, 400, "mute", elide=True)), 1), 10,
+                   Label(f"{n:,}", 13, 600), 10,
+                   Label("<0.1%" if pct < 0.001 else f"{pct * 100:.1f}%", 12, 400, "body", align=Qt.AlignmentFlag.AlignRight),
+                   margins=(8, 7, 8, 7), align=Qt.AlignmentFlag.AlignVCenter)
+        row.itemAt(row.count() - 1).widget().setFixedWidth(44)
+        body.addWidget(Box(bg="surf2" if sf == k else None, radius=10, hover=None if sf == k else "surf2", layout=row,
+                           on_click=lambda k=k: app.set(split_filter="all" if sf == k else k)))
+    if store.SPLIT_OVERLAP:
+        check, result, tone = store.SPLIT_OVERLAP
+        body.addLayout(vbox(10, HLine(), hbox(Label(check, 13, 400, "body"), "stretch", badge(result, tone),
+                                              margins=(0, 12, 0, 0)), margins=(8, 0, 8, 0)))
+    return card(body, pad=(12, 20, 12, 20))
+
+
+def _info_card(app, fd, di, sel):
+    s = app.s
+    sp = store.split_of(s.folder, di)
+    r = fd["rows"][di]
+    ext = r["path"].rsplit(".", 1)[-1].upper() if "." in r["path"] else "—"
+    label, _ = _label_and_prediction(app, r)
+    if len(store.TASKS) > 1:
+        labels = [(f"Label · {t}", label_values.summary(r["labels"].get(t)) or "—") for t in store.TASKS]
+    else:
+        labels = [("Label", label_values.summary(label))]
+    rows = [("Path", r["path"]), ("Split", store.SPLITS[sp][0]), ("Dimensions", _dims(r["path"])), ("Format", ext),
+            *labels, ("Size", f"{r['bytes'] / 1024:.0f} KB" if r["bytes"] else "missing"),
+            ("Modified", datetime.fromtimestamp(r["mtime"]).strftime("%b %d, %H:%M") if r["mtime"] else "—")]
+    if r["created"]:
+        rows.append(("Created", r["created"].strftime("%b %d, %Y %H:%M")))
+    if r["trained"] is not None:
+        rows.append(("Trained", "yes" if r["trained"] else "no"))
+    if r["id"] is not None:
+        rows.append(("Row", f"{store.SPLIT_SOURCE[0]} · id {r['id']}"))
+    src = _source(app)[1]
+    if src:
+        rec = _result(app, r)
+        for key, column in src["shows"].items():
+            v = rec["values"].get(key) if rec else None
+            rows.append((f"{key} · {column}", "—" if v in (None, "") else label_values.summary(v)))
+        rows.append(("Result file", src["rel"] if rec else f"{src['rel']} · no row"))
+    body = vbox(Label("File info", 16, 600, lh=24), 10)
+    for k, v in rows:
+        body.addWidget(kv_row(k, v))
+    return card(body)
+
+
+def _folder_card(fd):
+    tiles = hbox(stat_tile("Files", f"{fd['n']:,}", value_size=22, lh=30), 12, stat_tile("Size", fd["size"], value_size=22, lh=30))
+    folders = {os.path.dirname(r["path"]) for r in fd["rows"]}
+    note = Label(f"From {store.SPLIT_SOURCE[0]} · {len(folders)} director{'y' if len(folders) == 1 else 'ies'} on disk",
+                 13, 400, "body", wrap=True)
+    return card(Label("Folder summary", 16, 600, lh=24), 12, tiles, 12, note)
+
+
+def build(app):
+    s = app.s
+    if s.folder not in store.DATA_FOLDERS:
+        return empty_state("No data", "Load a project file in Setting. Data comes from its [db] table or paths.data.")
+    fd = store.DATA_FOLDERS[s.folder]
+    sel = s.sel["data"] if s.sel["data"] in fd["files"] else fd["files"][0]
+    di = fd["files"].index(sel)
+    files = [(n, i) for i, n in enumerate(fd["files"]) if s.split_filter in ("all", store.split_of(s.folder, i))]
+    viewer, info = _Slot(_viewer(app, fd, files, di, sel)), _Slot(_info_card(app, fd, di, sel))
+    app.data_slots = (viewer, info)
+    side = Scroll(wrap(vbox(_splits_card(app), info, _folder_card(fd), "stretch", spacing=12)))
+    side.setFixedWidth(340)
+    return viewer, side
+
+
+def select(app, name):
+    fd = store.DATA_FOLDERS.get(app.s.folder)
+    slots = getattr(app, "data_slots", None)
+    if not fd or name not in fd["files"] or not slots or any(sip.isdeleted(x) for x in slots):
+        return False
+    _swap(app, fd, name)
+    return True
+
+
+def restate(app, **kw):
+    fd = store.DATA_FOLDERS.get(app.s.folder)
+    slots = getattr(app, "data_slots", None)
+    if not fd or not slots or any(sip.isdeleted(x) for x in slots):
+        return app.set(**kw)
+    vars(app.s).update(kw)
+    _swap(app, fd, app.s.sel["data"] if app.s.sel["data"] in fd["files"] else fd["files"][0])
+
+
+def _swap(app, fd, name):
+    s, di = app.s, fd["files"].index(name)
+    files = [(n, i) for i, n in enumerate(fd["files"]) if s.split_filter in ("all", store.split_of(s.folder, i))]
+    viewer, info = app.data_slots
+    viewer.swap(_viewer(app, fd, files, di, name))
+    info.swap(_info_card(app, fd, di, name))