trekr 0.1.0__py3-none-any.whl

trekr/__init__.py

@@ -0,0 +1,3 @@
+"""TREKR, early release: checks for a computer, its video files, and pose labels."""
+
+__version__ = "0.1.0"

trekr/__main__.py

@@ -0,0 +1,5 @@
+"""python -m trekr <command>: see cli.py."""
+
+from .cli import main
+
+raise SystemExit(main())

trekr/cli.py

@@ -0,0 +1,44 @@
+"""
+    trekr check                                is this computer ready for GPU video analysis?
+    trekr videocheck VIDEO [--save REF.json | --against REF.json]
+                                               a video file's fingerprint; is it still the same?
+    trekr labels DLC_PROJECT                   check and edit DeepLabCut labels (a window)
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from . import __version__
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="trekr", description="TREKR (early release): checks for a computer, its "
+                                                           "video files, and pose labels.")
+    ap.add_argument("--version", action="version", version=f"trekr {__version__}")
+    sub = ap.add_subparsers(dest="command", required=True, metavar="command")
+    sub.add_parser("check", help="the GPU against the PyTorch build, the driver, and whether OpenCV decodes camera "
+                                 "video with the right colours")
+    v = sub.add_parser("videocheck", help="a video file's fingerprint (size, SHA-256 of both ends, stream facts); "
+                                          "save it, or compare the file with a saved one")
+    v.add_argument("video")
+    g = v.add_mutually_exclusive_group()
+    g.add_argument("--save", metavar="REF.json", help="write the fingerprint to this file")
+    g.add_argument("--against", metavar="REF.json", help="compare with a saved fingerprint (exit 2 if changed)")
+    lab = sub.add_parser("labels", help="find and fix label errors in a DeepLabCut project: every labelled "
+                                        "animal by how well its points fit together, worst first (a window)")
+    lab.add_argument("project", help="a DeepLabCut project folder (with config.yaml and labeled-data/), or one "
+                                     "labeled-data folder")
+    args = ap.parse_args(argv)
+    if args.command == "labels":
+        from .labels.app import run
+        return run(args.project)
+    if args.command == "check":
+        from . import envcheck
+        return envcheck.run()
+    from . import videocheck
+    return videocheck.run(args.video, save=args.save, against=args.against)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

trekr/envcheck.py

@@ -0,0 +1,174 @@
+"""
+`trekr check`: is this computer ready for GPU video analysis? Every line says
+
+    OK     fine
+    NOTE   works, with a caveat (what, and by how much)
+    FAIL   will not work, or not correctly (why, and what to install)
+
+1. Python, NumPy, OpenCV and (if installed) PyTorch: their versions.
+2. Each GPU against the PyTorch build: a build carries code for some GPU generations
+   only, so a new card (e.g. the RTX 50 series) can need a newer build. And the NVIDIA
+   driver against the CUDA version the build was made for.
+3. Video decoding: a stored H.264 clip encoded as cameras write it (BT.709 colours,
+   TV range) against the frames a correct decoder gives. OpenCV 4.11 and 4.12 decode
+   such video with the wrong colour matrix: on the stored clip red is off by 5.4 and blue
+   by 2.5 grey levels on average, up to 22 (measured 2026-10-07; 4.13 and 5.0 decode it
+   exactly). That shifts every colour measured from the video.
+
+The exit status is 1 when anything fails.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import platform
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import numpy as np
+
+DATA = Path(__file__).parent / "data"
+CLIP = DATA / "clip.mp4"
+CLIP_EXPECTED = DATA / "clip.expected.npz"
+SAME_PIXELS = 0.5                 # mean grey levels up to which a decoded frame counts as the same
+
+OK, NOTE, FAIL = "OK", "NOTE", "FAIL"
+
+
+def driver():
+    """(the NVIDIA driver's version, the newest CUDA it runs), each None if unknown."""
+    ver = cuda = None
+    try:                                                   # Linux: no program to start
+        m = re.search(r"Kernel Module(?: for \S+)?\s+(\d+(?:\.\d+)+)", Path("/proc/driver/nvidia/version").read_text())
+        ver = m.group(1) if m else None
+    except OSError:
+        pass
+    if ver is None:
+        try:
+            out = subprocess.run(["nvidia-smi", "--query-gpu=driver_version", "--format=csv,noheader"],
+                                 capture_output=True, text=True, timeout=10)
+            ver = (out.stdout.strip().splitlines() or [None])[0]
+        except (OSError, subprocess.SubprocessError):
+            pass
+    try:
+        lib = ctypes.CDLL("nvcuda.dll" if sys.platform == "win32" else "libcuda.so.1")
+        v = ctypes.c_int()
+        if lib.cuDriverGetVersion(ctypes.byref(v)) == 0 and v.value:
+            cuda = f"{v.value // 1000}.{v.value % 1000 // 10}"
+    except (OSError, AttributeError):
+        pass
+    return ver, cuda
+
+
+def arch_support(capability, archs):
+    """How a PyTorch build (its arch list, e.g. ["sm_80", "sm_86", "compute_90"]) runs on a
+    GPU of this compute capability ((8, 9)): "native" (code for it, or for an earlier
+    minor of the same major), "jit" (only PTX of an earlier architecture: compiled when
+    first used), or None (it cannot run there)."""
+    major, minor = capability
+    native = jit = False
+    for a in archs:
+        m = re.fullmatch(r"(sm|compute)_(\d+)(\d)([a-z]?)", a)
+        if not m:
+            continue
+        kind, big, small, suffix = m.group(1), int(m.group(2)), int(m.group(3)), m.group(4)
+        if kind == "sm" and big == major and (small == minor or (small < minor and not suffix)):
+            native = True
+        elif kind == "compute" and not suffix and (big, small) <= (major, minor):
+            jit = True
+    return "native" if native else "jit" if jit else None
+
+
+def _span(archs):
+    sm = sorted((a for a in archs if a.startswith("sm_")), key=lambda a: int(re.sub(r"\D", "", a)))
+    return f"{sm[0]}-{sm[-1]}" if sm else "no GPU"
+
+
+def decoding():
+    """The stored clip as OpenCV decodes it here, against a correct decoder's frames:
+    {"frames" (None: cannot be read), "mean" (per channel, R G B), "max", "opencv", "reference"}."""
+    import cv2
+    e = np.load(CLIP_EXPECTED)
+    out = {"opencv": cv2.__version__, "reference": str(e["opencv"]), "frames": None, "mean": None, "max": None}
+    cap = cv2.VideoCapture(str(CLIP))
+    frames = []
+    try:
+        while len(frames) < len(e["frames"]):
+            ok, f = cap.read()
+            if not ok:
+                break
+            frames.append(cv2.cvtColor(f, cv2.COLOR_BGR2RGB))
+    finally:
+        cap.release()
+    if len(frames) != len(e["frames"]) or any(f.shape != e["frames"][0].shape for f in frames):
+        return out
+    d = np.abs(np.stack(frames).astype(int) - e["frames"].astype(int))
+    out.update(frames=len(frames), mean=d.mean((0, 1, 2)), max=int(d.max()))
+    return out
+
+
+def run(out=None):
+    """Print the check; 0 when nothing fails, else 1."""
+    out = out or sys.stdout
+    fails = []
+
+    def say(level, text):
+        print(f"{level:5s} {text}", file=out)
+        if level == FAIL:
+            fails.append(text)
+
+    import cv2
+    say(OK, f"Python {platform.python_version()}, NumPy {np.__version__}, OpenCV {cv2.__version__}")
+    try:
+        import torch
+    except ImportError:
+        torch = None
+        say(NOTE, "PyTorch is not installed: the GPU check is skipped (pytorch.org, a build for your GPU's CUDA)")
+    if torch is not None:
+        if not torch.cuda.is_available():
+            say(FAIL, f"PyTorch {torch.__version__} sees no GPU it can use (built for "
+                      f"{'CUDA ' + torch.version.cuda if torch.version.cuda else 'the CPU only'})")
+        else:
+            archs = torch.cuda.get_arch_list()
+            for i in range(torch.cuda.device_count()):
+                cap = torch.cuda.get_device_capability(i)
+                name = (f"GPU {i}: {torch.cuda.get_device_name(i)} (sm_{cap[0]}{cap[1]}, "
+                        f"{torch.cuda.get_device_properties(i).total_memory / 2 ** 30:.0f} GB)")
+                how = arch_support(cap, archs)
+                if how == "native":
+                    say(OK, f"{name}; PyTorch {torch.__version__} has code for {_span(archs)}")
+                elif how == "jit":
+                    say(NOTE, f"{name}: this PyTorch has code for {_span(archs)} only; it is compiled for this "
+                              f"GPU when first used (a slow start)")
+                else:
+                    say(FAIL, f"{name}: this PyTorch has code for {_span(archs)} only. Install a PyTorch build "
+                              f"whose architecture list includes sm_{cap[0]}{cap[1]} (pytorch.org; newer GPUs "
+                              f"need builds for newer CUDA)")
+            ver, dcuda = driver()
+            rt = torch.version.cuda
+            if ver is None or dcuda is None or rt is None:
+                say(NOTE, f"NVIDIA driver {ver or 'unknown'}: the CUDA it runs is unknown")
+            else:
+                d, r = tuple(map(int, dcuda.split("."))), tuple(map(int, rt.split(".")))
+                if d[0] < r[0]:
+                    say(FAIL, f"NVIDIA driver {ver} runs CUDA up to {dcuda}; this PyTorch is built for CUDA {rt}: "
+                              f"update the driver, or install a PyTorch build for CUDA {d[0]}")
+                else:
+                    say(OK, f"NVIDIA driver {ver} (CUDA {dcuda}); PyTorch built for CUDA {rt}"
+                            + (" runs on it by CUDA minor-version compatibility" if d < r else ""))
+    dec = decoding()
+    if dec["frames"] is None:
+        say(FAIL, f"OpenCV {dec['opencv']} cannot decode H.264 video (the stored test clip): install "
+                  f"opencv-python-headless from PyPI, which brings its own decoder")
+    elif dec["mean"].max() <= SAME_PIXELS:
+        say(OK, f"OpenCV {dec['opencv']} decodes camera video (H.264, BT.709) with the right colours")
+    else:
+        m = dec["mean"]
+        say(FAIL, f"OpenCV {dec['opencv']} decodes camera video (H.264 tagged BT.709) with other colours than a "
+                  f"correct decoder (OpenCV {dec['reference']}): R {m[0]:.1f}, G {m[1]:.1f}, B {m[2]:.1f} grey "
+                  f"levels off on average, up to {dec['max']}. OpenCV 4.11 and 4.12 apply the wrong colour "
+                  f"matrix; use 4.13 or newer")
+    print(f"\nNot ready: {len(fails)} problem(s) above (FAIL)." if fails else "\nReady.", file=out)
+    return 1 if fails else 0

trekr/labels/__init__.py

@@ -0,0 +1 @@
+"""`trekr labels`: find and fix label errors in a DeepLabCut project."""

trekr/labels/app.py

@@ -0,0 +1,385 @@
+"""
+`trekr labels`: a window to check and edit DeepLabCut labels.
+
+Left: the labelled animals, the one with the point that fits its animal worst first
+(To check; check.py), or every labelled image (Images). Middle: the image with its
+animals. Right: the selected animal's points and their scores.
+
+Mouse: hover a point to see which it is; drag a point to move it; right-click a point to
+remove it; click a keypoint in the list, then click in the image to place it; wheel to
+zoom; drag the background to pan.
+Keys: N / Space next to check, P previous; Left / Right images; Delete removes the
+selected point; Ctrl+Z / Ctrl+Y undo / redo; Ctrl+S saves; F5 checks again; F fits.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import numpy as np
+from PySide6 import QtCore, QtGui, QtWidgets
+
+from . import dlc
+from .check import Checker
+
+COLOURS = ["#4e9af1", "#f0a33a", "#5cc46b", "#e05d9b", "#a77de8", "#3fc6c0", "#e8d23f", "#ef6c4a",
+           "#8fb34a", "#c97bd6", "#5b8def", "#d9a066"]
+HELP = ("Drag a point to move it · right-click removes · pick a keypoint in the list, then click to place · "
+        "N / P next / previous to check · ← → images · Ctrl+Z undo · Ctrl+S save · F5 check again")
+
+
+class View(QtWidgets.QGraphicsView):
+    """The image and its points; reports what the mouse does to them."""
+    moved = QtCore.Signal(int, int, float, float)          # animal, keypoint, x, y (after a drag)
+    removed = QtCore.Signal(int, int)
+    clicked = QtCore.Signal(float, float)                   # on the image, not on a point
+    picked = QtCore.Signal(int, int)
+    hovered = QtCore.Signal(int, int)                       # the point under the mouse; (-1, -1): none
+
+    def __init__(self):
+        super().__init__()
+        self.setScene(QtWidgets.QGraphicsScene(self))
+        self.setRenderHint(QtGui.QPainter.Antialiasing)
+        self.setTransformationAnchor(QtWidgets.QGraphicsView.AnchorUnderMouse)
+        self.setBackgroundBrush(QtGui.QColor("#16181b"))
+        self.pix = self.scene().addPixmap(QtGui.QPixmap())
+        self.marks, self._drag, self._press, self._over = [], None, None, None
+        self.viewport().setMouseTracking(True)
+        self.hint = QtWidgets.QLabel(self.viewport())      # bottom left: the point under the mouse
+        self.hint.setStyleSheet("background: rgba(17,19,22,210); color: #f2f2f2; border-radius: 4px; padding: 3px 8px;")
+        self.hint.hide()
+
+    def show_hint(self, text):
+        if not text:
+            return self.hint.hide()
+        self.hint.setText(text)
+        self.hint.adjustSize()
+        self.hint.move(8, self.viewport().height() - self.hint.height() - 8)
+        self.hint.show()
+        self.hint.raise_()
+
+    def show_image(self, path):
+        pm = QtGui.QPixmap(str(path))
+        first = self.pix.pixmap().isNull() or pm.size() != self.pix.pixmap().size()
+        self.pix.setPixmap(pm)
+        self.scene().setSceneRect(QtCore.QRectF(pm.rect()).adjusted(-2000, -2000, 2000, 2000))
+        if first:
+            self.fit()
+        return not pm.isNull()
+
+    def fit(self):
+        if not self.pix.pixmap().isNull():
+            self.fitInView(self.pix, QtCore.Qt.KeepAspectRatio)
+
+    def draw(self, animals, edges, selected):
+        """animals: [(animal index, (K, 2), colour)]; selected: (animal, keypoint) or None."""
+        for it in self.marks:
+            self.scene().removeItem(it)
+        self.marks = []
+        for ai, pts, colour in animals:
+            pen = QtGui.QPen(QtGui.QColor(colour), 1.5)
+            pen.setCosmetic(True)
+            for a, b in edges:
+                if np.isfinite(pts[[a, b]]).all():
+                    self.marks.append(self.scene().addLine(*pts[a], *pts[b], pen))
+            for k, (x, y) in enumerate(pts):
+                if not np.isfinite([x, y]).all():
+                    continue
+                big = (ai, k) == selected
+                r = 6 if big else 4
+                dot = self.scene().addEllipse(-r, -r, 2 * r, 2 * r, QtGui.QPen(QtGui.QColor("white" if big else "black"), 1),
+                                              QtGui.QBrush(QtGui.QColor(colour)))
+                dot.setFlag(QtWidgets.QGraphicsItem.ItemIgnoresTransformations)
+                dot.setPos(x, y)
+                dot.setZValue(3)
+                dot.setData(0, (ai, k))
+                self.marks.append(dot)
+
+    def _point_at(self, pos):
+        for it in self.items(pos):
+            if it.data(0) is not None:
+                return it
+        return None
+
+    def mousePressEvent(self, e):
+        it = self._point_at(e.position().toPoint())
+        if it is not None and e.button() == QtCore.Qt.RightButton:
+            self.removed.emit(*it.data(0))
+            return
+        if it is not None and e.button() == QtCore.Qt.LeftButton:
+            self._drag = it
+            self.picked.emit(*it.data(0))
+            return
+        if e.button() == QtCore.Qt.LeftButton:
+            self._press = e.position().toPoint()
+            self.setDragMode(QtWidgets.QGraphicsView.ScrollHandDrag)
+        super().mousePressEvent(e)
+
+    def mouseMoveEvent(self, e):
+        if self._drag is not None:
+            self._drag.setPos(self.mapToScene(e.position().toPoint()))
+            return
+        it = self._point_at(e.position().toPoint())
+        over = it.data(0) if it is not None else None
+        if over != self._over and self._press is None:
+            self._over = over
+            self.viewport().setCursor(QtCore.Qt.OpenHandCursor if over else QtCore.Qt.ArrowCursor)
+            self.hovered.emit(*(over or (-1, -1)))
+        super().mouseMoveEvent(e)
+
+    def mouseReleaseEvent(self, e):
+        if self._drag is not None:
+            p, (ai, k) = self._drag.pos(), self._drag.data(0)
+            self._drag = None
+            self.moved.emit(ai, k, p.x(), p.y())
+            return
+        super().mouseReleaseEvent(e)
+        self.setDragMode(QtWidgets.QGraphicsView.NoDrag)
+        if self._press is not None and (e.position().toPoint() - self._press).manhattanLength() < 4:
+            p = self.mapToScene(e.position().toPoint())
+            self.clicked.emit(p.x(), p.y())
+        self._press = None
+
+    def wheelEvent(self, e):
+        f = 1.25 if e.angleDelta().y() > 0 else 0.8
+        self.scale(f, f)
+
+
+class Window(QtWidgets.QMainWindow):
+    def __init__(self, root):
+        super().__init__()
+        self.root = Path(root)
+        paths = dlc.find_files(self.root)
+        if not paths:
+            raise SystemExit(f"no CollectedData_*.csv under {self.root}")
+        self.files = [dlc.LabelFile(p) for p in paths]
+        bp = self.files[0].bodyparts
+        self.edges = [(bp.index(a), bp.index(b)) for a, b in dlc.skeleton(self.root) if a in bp and b in bp]
+        self.images = [(fi, r) for fi, f in enumerate(self.files) for r in range(len(f.rows)) if f.animals(r)]
+        self.cur, self.sel, self.undo_stack, self.redo_stack, self.stale = 0, None, [], [], False
+        self.setWindowTitle(f"TREKR labels · {self.root.name}")
+        self._build()
+        self.check_again()
+        self.show_image(0)
+
+    # ------------------------------------------------------------------ layout
+    def _build(self):
+        self.view = View()
+        self.setCentralWidget(self.view)
+        self.view.moved.connect(lambda a, k, x, y: self.edit(a, k, (x, y)))
+        self.view.removed.connect(lambda a, k: self.edit(a, k, None))
+        self.view.picked.connect(self.select)
+        self.view.clicked.connect(self.place)
+        self.view.hovered.connect(self.hover)
+        self.tabs = QtWidgets.QTabWidget()
+        self.todo, self.imglist = QtWidgets.QListWidget(), QtWidgets.QListWidget()
+        self.tabs.addTab(self.todo, "To check")
+        self.tabs.addTab(self.imglist, "Images")
+        self.todo.currentRowChanged.connect(self.go_todo)
+        self.imglist.currentRowChanged.connect(lambda i: i >= 0 and self.show_image(i))
+        for fi, r in self.images:
+            self.imglist.addItem(f"{self.files[fi].path.parent.name} / {self.files[fi].name(r)}")
+        left = QtWidgets.QDockWidget("Labels")
+        left.setWidget(self.tabs)
+        self.tabs.setMinimumWidth(330)
+        self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, left)
+        side = QtWidgets.QWidget()
+        lay = QtWidgets.QVBoxLayout(side)
+        self.animal = QtWidgets.QLabel("Click a point")
+        self.kps = QtWidgets.QListWidget()
+        self.kps.itemClicked.connect(lambda it: self.select(self.sel[0], self.kps.row(it)) if self.sel else None)
+        save, again = QtWidgets.QPushButton("Save  (Ctrl+S)"), QtWidgets.QPushButton("Check again  (F5)")
+        save.clicked.connect(self.save)
+        again.clicked.connect(self.check_again)
+        self.info = QtWidgets.QLabel()
+        self.info.setWordWrap(True)
+        for w in (self.animal, self.kps, save, again, self.info):
+            lay.addWidget(w)
+        right = QtWidgets.QDockWidget("Animal")
+        right.setWidget(side)
+        self.addDockWidget(QtCore.Qt.RightDockWidgetArea, right)
+        self.statusBar().showMessage(HELP)
+        for keys, fn in (("N", self.next_todo), ("Space", self.next_todo), ("P", lambda: self.next_todo(-1)),
+                         ("Right", lambda: self.show_image(self.cur + 1)), ("Left", lambda: self.show_image(self.cur - 1)),
+                         ("Delete", self.remove_selected), ("Ctrl+Z", self.undo), ("Ctrl+Y", self.redo),
+                         ("Ctrl+Shift+Z", self.redo), ("Ctrl+S", self.save), ("F5", self.check_again),
+                         ("F", self.view.fit)):
+            QtGui.QShortcut(QtGui.QKeySequence(keys), self, fn)
+        self.resize(1500, 950)
+
+    # ------------------------------------------------------------------ checking
+    def check_again(self):
+        self.checker = Checker(self.files)
+        self.ranking = self.checker.ranked()
+        self.todo.blockSignals(True)
+        self.todo.clear()
+        for d, i, k in self.ranking:
+            fi, r, ind, _ = self.checker.animals[i]
+            it = QtWidgets.QListWidgetItem(f"{d:6.1f}  {ind} · {self.checker.bodyparts[k]}")
+            it.setToolTip(f"{self.files[fi].path.parent.name} / {self.files[fi].name(r)}")
+            self.todo.addItem(it)
+        self.todo.blockSignals(False)
+        self.stale = False
+        self.info.setText(f"{self.checker.n} labelled animals in {len(self.images)} images. A point's score: how far "
+                          f"its distances to the animal's other points are from the usual ones, in their usual "
+                          f"spread (median over the other points); right points score about 1.")
+        if self.images:
+            self.redraw()
+
+    def go_todo(self, row):
+        if 0 <= row < len(self.ranking):
+            self.go_animal(self.ranking[row][1], self.ranking[row][2])
+
+    def go_animal(self, i, k):
+        fi, r, ind, _ = self.checker.animals[i]
+        self.show_image(self.images.index((fi, r)), keep=True)
+        self.select(i, k)
+        pts = self._points(i)
+        pts = pts[np.isfinite(pts).all(1)]
+        if len(pts):                                    # the whole animal, its stray point included
+            (x0, y0), (x1, y1) = pts.min(0), pts.max(0)
+            pad = max(x1 - x0, y1 - y0) * 0.25 + 20
+            self.view.fitInView(QtCore.QRectF(x0 - pad, y0 - pad, x1 - x0 + 2 * pad, y1 - y0 + 2 * pad),
+                                QtCore.Qt.KeepAspectRatio)
+
+    def next_todo(self, step=1):
+        self.tabs.setCurrentIndex(0)
+        self.todo.setCurrentRow(min(max(self.todo.currentRow() + step, 0), self.todo.count() - 1))
+
+    # ------------------------------------------------------------------ showing
+    def show_image(self, i, keep=False):
+        if not self.images:
+            return
+        self.cur = min(max(i, 0), len(self.images) - 1)
+        fi, r = self.images[self.cur]
+        ok = self.view.show_image(self.files[fi].image(r))
+        if not keep:
+            self.sel = None
+        self.imglist.blockSignals(True)
+        self.imglist.setCurrentRow(self.cur)
+        self.imglist.blockSignals(False)
+        self.statusBar().showMessage(("" if ok else f"image not found: {self.files[fi].image(r)} · ") + HELP)
+        self.redraw()
+
+    def _here(self):
+        """[(animal index, points as they are now, colour)] of the animals of this image."""
+        fi, r = self.images[self.cur]
+        f = self.files[fi]
+        return [(self.checker.index[(fi, r, ind)], self._points(self.checker.index[(fi, r, ind)]),
+                 COLOURS[f.individuals.index(ind) % len(COLOURS)])
+                for ind in f.individuals if (fi, r, ind) in self.checker.index]
+
+    def _points(self, ai):
+        """The animal's points as they are now (with edits), in the checker's keypoint order."""
+        f, fi, r, ind = self._where(ai)
+        p = f.points(r, ind)
+        return np.array([p[f.bodyparts.index(b)] if b in f.bodyparts else (np.nan, np.nan)
+                         for b in self.checker.bodyparts])
+
+    def redraw(self):
+        here = self._here()
+        self.view.draw(here, self.edges, self.sel)
+        self._fill_animal()
+
+    def _fill_animal(self):
+        self.kps.clear()
+        if not self.sel:
+            self.animal.setText("Click a point")
+            return
+        ai, k0 = self.sel
+        fi, r, ind, _ = self.checker.animals[ai]
+        pts = self._points(ai)
+        self.animal.setText(f"<b>{ind}</b> · {self.files[fi].name(r)}" + (" · edited: F5 to check again" if self.stale else ""))
+        for k, b in enumerate(self.checker.bodyparts):
+            d = self.checker.S[ai, k] if not self.stale else np.nan
+            placed = np.isfinite(pts[k]).all()
+            it = QtWidgets.QListWidgetItem(f"{b}   " + (f"{d:.1f}" if np.isfinite(d) else "" if placed else "(not placed)"))
+            self.kps.addItem(it)
+        self.kps.setCurrentRow(k0)
+
+    def hover(self, ai, k):
+        """Which point is under the mouse: animal, keypoint, score (bottom left)."""
+        if ai < 0:
+            return self.view.show_hint("")
+        fi, r, ind, _ = self.checker.animals[ai]
+        d = np.nan if self.stale else self.checker.S[ai, k]
+        self.view.show_hint(f"<b>{ind}</b> · {self.checker.bodyparts[k]}" + (f" · {d:.1f}" if np.isfinite(d) else ""))
+
+    def select(self, ai, k):
+        self.sel = (ai, k)
+        self.redraw()
+
+    # ------------------------------------------------------------------ editing
+    def _where(self, ai):
+        fi, r, ind, _ = self.checker.animals[ai]
+        return self.files[fi], fi, r, ind
+
+    def edit(self, ai, k, xy, record=True):
+        f, fi, r, ind = self._where(ai)
+        b = self.checker.bodyparts[k]
+        old = self._points(ai)[k]
+        f.set_point(r, ind, b, xy)
+        if record:
+            self.undo_stack.append((ai, k, None if not np.isfinite(old).all() else tuple(old), xy))
+            self.redo_stack.clear()
+        self.stale = True
+        self.sel = (ai, k)
+        self.setWindowTitle(f"TREKR labels · {self.root.name} *")
+        self.redraw()
+
+    def place(self, x, y):
+        """A click on the image places the selected keypoint, if it is not placed yet."""
+        if self.sel and not np.isfinite(self._points(self.sel[0])[self.sel[1]]).all():
+            self.edit(self.sel[0], self.sel[1], (x, y))
+
+    def remove_selected(self):
+        if self.sel:
+            self.edit(*self.sel, None)
+
+    def undo(self):
+        if self.undo_stack:
+            ai, k, old, new = self.undo_stack.pop()
+            self.redo_stack.append((ai, k, old, new))
+            self.edit(ai, k, old, record=False)
+
+    def redo(self):
+        if self.redo_stack:
+            ai, k, old, new = self.redo_stack.pop()
+            self.undo_stack.append((ai, k, old, new))
+            self.edit(ai, k, new, record=False)
+
+    def save(self):
+        changed = [f for f in self.files if f.dirty]
+        if not changed:
+            return self.statusBar().showMessage("nothing to save · " + HELP)
+        backups = [f.save() for f in changed]
+        stale = [dlc.h5_stale(f.path) for f in changed if dlc.h5_stale(f.path)]
+        self.setWindowTitle(f"TREKR labels · {self.root.name}")
+        msg = (f"Saved {len(changed)} label file(s); the originals are kept beside them "
+               f"({backups[0].name}{', …' if len(backups) > 1 else ''}).")
+        if stale:
+            msg += ("\n\nDeepLabCut trains from the .h5 files, which still hold the old labels. Make them again "
+                    "from the saved CSV files, in Python with DeepLabCut:\n\n"
+                    "    import deeplabcut\n"
+                    f"    deeplabcut.convertcsv2h5(r\"{self.root / 'config.yaml'}\", userfeedback=False)")
+        QtWidgets.QMessageBox.information(self, "Saved", msg)
+        self.check_again()
+
+    def closeEvent(self, e):
+        if any(f.dirty for f in self.files):
+            b = QtWidgets.QMessageBox.question(self, "Unsaved changes", "Save the changed labels before closing?",
+                                               QtWidgets.QMessageBox.Save | QtWidgets.QMessageBox.Discard
+                                               | QtWidgets.QMessageBox.Cancel)
+            if b == QtWidgets.QMessageBox.Cancel:
+                return e.ignore()
+            if b == QtWidgets.QMessageBox.Save:
+                self.save()
+        e.accept()
+
+
+def run(root):
+    app = QtWidgets.QApplication.instance() or QtWidgets.QApplication(sys.argv[:1])
+    w = Window(root)
+    w.show()
+    return app.exec()

trekr/labels/check.py

@@ -0,0 +1,95 @@
+"""
+Which labels to look at first: points that do not fit the rest of their animal.
+
+A wrong label is almost always one point -- on the neighbour, swapped with another,
+dropped in the background -- while the animal's other points are right. So each
+animal's points are compared through the distances between them, which do not change
+when the animal turns, moves, or is seen mirrored (upside down):
+
+- For every pair of keypoints, the typical distance is the median over all labelled
+  animals, each animal first scaled to the common size (the median ratio of its
+  distances to the typical ones).
+- How far a distance is from the typical one is measured as a log ratio, in the labels'
+  own spread of that distance (median absolute deviation), never below the label noise
+  (LABEL_NOISE_PX pixels).
+- A point's score is the median of that over the animal's other points. One wrong point
+  is off from almost every other point; a right point is off from that one only, so its
+  median stays low.
+
+Animals are ranked by their highest-scoring point. No cut-off: a score is in units of
+the labels' own spread, and where errors begin is read off the ranking (right points
+score about 1; on a tested project, most animals scoring above about 10 had a wrong point).
+"""
+
+from __future__ import annotations
+
+import warnings
+
+import numpy as np
+
+LABEL_NOISE_PX = 2.0      # how precisely a point can be placed by hand: the least spread of a distance
+MIN_OTHERS = 3            # fewer other points placed: no score (a median of one or two says little)
+
+
+class Checker:
+    def __init__(self, files):
+        """files: LabelFile list sharing their bodyparts (by name; the first file's order)."""
+        self.files = files
+        self.bodyparts = list(files[0].bodyparts) if files else []
+        self.refresh()
+
+    def _animals(self):
+        out = []                                            # (file index, row, individual, (K, 2))
+        for fi, f in enumerate(self.files):
+            take = [f.bodyparts.index(b) if b in f.bodyparts else None for b in self.bodyparts]
+            for r in range(len(f.rows)):
+                for ind, p in f.animals(r).items():
+                    out.append((fi, r, ind, np.array([p[k] if k is not None else (np.nan, np.nan) for k in take])))
+        return out
+
+    def refresh(self):
+        """Score every labelled point as the labels are now."""
+        self.animals = self._animals()
+        self.index = {(fi, r, ind): i for i, (fi, r, ind, _) in enumerate(self.animals)}
+        K = len(self.bodyparts)
+        P = np.array([a[3] for a in self.animals]) if self.animals else np.zeros((0, K, 2))
+        self.S = scores(P)
+
+    @property
+    def n(self):
+        return len(self.animals)
+
+    def ranked(self):
+        """[(score, animal index, keypoint index)] of every animal's highest-scoring point, highest first."""
+        out = []
+        for i, s in enumerate(self.S):
+            if np.isfinite(s).any():
+                k = int(np.nanargmax(s))
+                out.append((float(s[k]), i, k))
+        return sorted(out, reverse=True)
+
+
+def scores(P):
+    """Per point, how far it is from where the animal's other points put it: (n, K), NaN
+    where not placed or with fewer than MIN_OTHERS other points. P: (n, K, 2), NaN missing."""
+    n, K = P.shape[:2]
+    out = np.full((n, K), np.nan)
+    if n < 3 or K < MIN_OTHERS + 1:
+        return out
+    with np.errstate(all="ignore"), warnings.catch_warnings():
+        warnings.simplefilter("ignore", RuntimeWarning)
+        d = np.linalg.norm(P[:, :, None] - P[:, None, :], axis=-1)            # (n, K, K)
+        d[:, np.arange(K), np.arange(K)] = np.nan
+        L = np.log(np.where(d > 0, d, np.nan))
+        typical = np.nanmedian(L, axis=0)                                       # (K, K)
+        for _ in range(2):                                                      # each animal to the common size
+            size = np.nanmedian((L - typical[None]).reshape(n, -1), axis=1)
+            typical = np.nanmedian(L - size[:, None, None], axis=0)
+        R = L - size[:, None, None] - typical[None]
+        mad = 1.4826 * np.nanmedian(np.abs(R - np.nanmedian(R, axis=0)[None]), axis=0)
+        noise = LABEL_NOISE_PX / np.exp(typical)                                 # the label noise, as a log ratio
+        Z = np.abs(R) / np.fmax(mad, noise)[None]
+        s = np.nanmedian(Z, axis=2)                                              # over the animal's other points
+        enough = np.isfinite(Z).sum(axis=2) >= MIN_OTHERS
+        out[enough] = s[enough]
+    return out

trekr/labels/dlc.py

@@ -0,0 +1,163 @@
+"""
+DeepLabCut labels, read and written in place.
+
+A DeepLabCut project folder holds config.yaml and labeled-data/<video>/ with the
+labelled frames as PNG images and the labels as CollectedData_<scorer>.csv (and .h5,
+which DeepLabCut trains from; it is made from the CSV by deeplabcut.convertcsv2h5).
+
+The CSV: a few header rows -- scorer, (individuals,) bodyparts, coords -- then one row
+per image: the image's path in one or more leading columns, then x and y per
+(individual, bodypart); an empty cell is a point not placed. Multi-animal projects have
+the individuals row; an individual "single" holds unique bodyparts, which are kept as
+they are and not checked.
+
+Saving changes only the cells of points that were edited (written with Python's
+shortest exact float notation); every other byte of the file stays as it was, line
+endings included. The first save of a session keeps the original next to it.
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+import os
+import shutil
+import time
+from pathlib import Path
+
+import numpy as np
+
+SINGLE = "single"          # DeepLabCut's individual for unique bodyparts
+
+
+def find_files(root):
+    """The label files of a DeepLabCut project folder (or of its labeled-data folder, or
+    one video's folder), sorted."""
+    root = Path(root)
+    if root.is_file():
+        root = root.parent
+    base = root / "labeled-data" if (root / "labeled-data").is_dir() else root
+    return sorted(base.rglob("CollectedData_*.csv"))
+
+
+def skeleton(root):
+    """The skeleton of config.yaml, as [(a, b)] (empty without a config)."""
+    import yaml
+    root = Path(root)
+    cfg = root if root.suffix in (".yaml", ".yml") else root / "config.yaml"
+    if not cfg.is_file():
+        return []
+    doc = yaml.safe_load(cfg.read_text()) or {}
+    return [tuple(e) for e in doc.get("skeleton") or [] if isinstance(e, (list, tuple)) and len(e) == 2]
+
+
+class LabelFile:
+    """One CollectedData_*.csv: its animals per image, editable, saved in place."""
+
+    def __init__(self, path):
+        self.path = Path(path)
+        raw = self.path.read_bytes()
+        self.newline = "\r\n" if b"\r\n" in raw else "\n"
+        self.lines = raw.decode("utf-8").splitlines()
+        rows = list(csv.reader(self.lines))
+        names = [r[0].strip().lower() if r else "" for r in rows]
+        self.n_header = next((i for i, n in enumerate(names) if n not in ("scorer", "individuals", "bodyparts",
+                                                                           "coords")), len(rows))
+        head = {names[i]: rows[i] for i in range(self.n_header)}
+        if "bodyparts" not in head or "coords" not in head:
+            raise ValueError(f"{self.path}: not a DeepLabCut label file (no bodyparts/coords rows)")
+        scorer = head.get("scorer", rows[0])
+        self.n_index = next((i for i, c in enumerate(scorer) if i > 0 and c.strip()), 1)
+        n_cols = len(head["coords"])
+        inds = head.get("individuals", [""] * n_cols)
+        self.columns = {}                                  # (individual, bodypart, "x"/"y") -> column
+        for c in range(self.n_index, n_cols):
+            self.columns[(inds[c], head["bodyparts"][c], head["coords"][c])] = c
+        order = [(i, b) for (i, b, k) in self.columns if k == "x"]
+        self.individuals = list(dict.fromkeys(i for i, _ in order if i != SINGLE))
+        self.bodyparts = list(dict.fromkeys(b for i, b in order if i != SINGLE))
+        self.rows = rows[self.n_header:]
+        self.edited = set()                                # data rows changed since the last save
+        self.backup = None
+
+    # ------------------------------------------------------------------ reading
+    def image(self, r):
+        """The image path of data row r (Windows separators allowed)."""
+        parts = [p for p in self.rows[r][:self.n_index] if p]
+        rel = Path(*[q for p in parts for q in p.replace("\\", "/").split("/") if q])
+        root = self.path.parent
+        while root != root.parent and not (root / rel).exists():
+            root = root.parent                             # the paths start at the project folder
+        found = root / rel
+        return found if found.exists() else self.path.parent / rel.name
+
+    def name(self, r):
+        return str(Path(*[p for p in self.rows[r][:self.n_index] if p]).name or r)
+
+    def _cell(self, r, c):
+        row = self.rows[r]
+        v = row[c].strip() if c < len(row) else ""
+        try:
+            return float(v) if v else np.nan
+        except ValueError:
+            return np.nan
+
+    def points(self, r, ind):
+        """(K, 2) float, NaN where not placed (K = bodyparts)."""
+        out = np.full((len(self.bodyparts), 2), np.nan)
+        for k, b in enumerate(self.bodyparts):
+            for j, xy in enumerate("xy"):
+                c = self.columns.get((ind, b, xy))
+                if c is not None:
+                    out[k, j] = self._cell(r, c)
+        return out
+
+    def animals(self, r):
+        """{individual: (K, 2)} of the individuals with any point placed in data row r."""
+        out = {}
+        for ind in self.individuals:
+            p = self.points(r, ind)
+            if np.isfinite(p).any():
+                out[ind] = p
+        return out
+
+    # ------------------------------------------------------------------ editing
+    def set_point(self, r, ind, bodypart, xy):
+        """Place (xy = (x, y)) or remove (xy = None) one point."""
+        row = self.rows[r]
+        for j, k in enumerate("xy"):
+            c = self.columns[(ind, bodypart, k)]
+            while len(row) <= c:
+                row.append("")
+            row[c] = "" if xy is None else repr(float(xy[j]))
+        self.edited.add(r)
+
+    @property
+    def dirty(self):
+        return bool(self.edited)
+
+    def save(self):
+        """Write the edited rows into the file; other lines are left byte for byte. The
+        first save keeps the original as <name>.csv.<time>.orig. Returns the backup path."""
+        if not self.edited:
+            return self.backup
+        if self.backup is None:
+            self.backup = self.path.with_name(f"{self.path.name}.{time.strftime('%Y%m%d-%H%M%S')}.orig")
+            shutil.copy2(self.path, self.backup)
+        lines = list(self.lines)
+        for r in self.edited:
+            buf = io.StringIO()
+            csv.writer(buf, lineterminator="").writerow(self.rows[r])
+            lines[self.n_header + r] = buf.getvalue()
+        tmp = self.path.with_name(self.path.name + ".saving")
+        tmp.write_bytes((self.newline.join(lines) + self.newline).encode("utf-8"))
+        os.replace(tmp, self.path)
+        self.lines, self.edited = lines, set()
+        return self.backup
+
+
+def h5_stale(path):
+    """The .h5 beside a saved CSV, which DeepLabCut trains from: it must be made again
+    from the CSV (deeplabcut.convertcsv2h5)."""
+    h5 = Path(path).with_suffix(".h5")
+    return h5 if h5.exists() else None

trekr/videocheck.py

@@ -0,0 +1,80 @@
+"""
+`trekr videocheck`: is a video file still the one you recorded (or analysed)?
+
+A fingerprint is the file's size and a SHA-256 of its first and last megabyte, so it is
+fast for any file size and nothing is decoded; with it the stream facts (frames, frame
+rate, width, height) as OpenCV reads them. Save it next to your data once; later, the
+same command against that file says whether the video is the same, or what changed (a
+re-encode, a cut, a different file under the same name).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+CHUNK = 1 << 20          # bytes hashed at each end of the file
+
+
+def fingerprint(path):
+    """{"size", "ends_sha256"}: the file's size and a SHA-256 of its first and last CHUNK bytes."""
+    path = Path(path)
+    size = path.stat().st_size
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        h.update(f.read(CHUNK))
+        if size > CHUNK:
+            f.seek(max(size - CHUNK, CHUNK))
+            h.update(f.read(CHUNK))
+    return {"size": size, "ends_sha256": h.hexdigest()}
+
+
+def facts(path):
+    """{"frames", "fps", "width", "height"} as OpenCV reads them (None if it cannot open the file)."""
+    import cv2
+    cap = cv2.VideoCapture(str(path))
+    try:
+        if not cap.isOpened():
+            return None
+        return {"frames": int(cap.get(cv2.CAP_PROP_FRAME_COUNT)), "fps": round(float(cap.get(cv2.CAP_PROP_FPS)), 3),
+                "width": int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), "height": int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))}
+    finally:
+        cap.release()
+
+
+def describe(path):
+    path = Path(path)
+    return {"file": path.name, **fingerprint(path), "stream": facts(path)}
+
+
+def compare(path, ref):
+    """("same" | "changed", [what differs])."""
+    now = describe(path)
+    if now["size"] == ref.get("size") and now["ends_sha256"] == ref.get("ends_sha256"):
+        return "same", []
+    diffs = [f"size {ref.get('size')} -> {now['size']} bytes"] if now["size"] != ref.get("size") else ["content"]
+    then_s, now_s = ref.get("stream") or {}, now["stream"] or {}
+    diffs += [f"{k} {then_s.get(k)} -> {now_s.get(k)}" for k in ("frames", "fps", "width", "height")
+              if then_s.get(k) != now_s.get(k)]
+    return "changed", diffs
+
+
+def run(path, save=None, against=None, out=print):
+    """The command: print the fingerprint, save it, or compare with a saved one. Exit code
+    0 (same, or printed / saved), 2 (changed), 1 (cannot read)."""
+    path = Path(path)
+    if not path.is_file():
+        out(f"no such file: {path}")
+        return 1
+    if against:
+        state, diffs = compare(path, json.loads(Path(against).read_text()))
+        out(f"{path.name}: the same file" if state == "same" else f"{path.name}: changed ({'; '.join(diffs)})")
+        return 0 if state == "same" else 2
+    d = describe(path)
+    if save:
+        Path(save).write_text(json.dumps(d, indent=1))
+        out(f"saved the fingerprint of {path.name} to {save}")
+    else:
+        out(json.dumps(d, indent=1))
+    return 0

trekr-0.1.0.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: trekr
+Version: 0.1.0
+Summary: Checks for pose tracking: a window to find and fix label errors in DeepLabCut projects, the GPU against the PyTorch build, whether OpenCV decodes camera video with the right colours, and whether a video file changed.
+Author: Koen Freerks
+License-Expression: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Console
+Classifier: Environment :: X11 Applications :: Qt
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.26
+Requires-Dist: opencv-python-headless>=4.8
+Requires-Dist: PySide6>=6.5
+Requires-Dist: pyyaml>=6
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Dynamic: license-file
+
+# trekr
+
+An early, small release of **TREKR**, a pose-tracking tool in development. This
+release holds three checks that are useful on their own.
+
+```bash
+pip install trekr
+trekr labels PROJECT          # check and fix DeepLabCut labels (a window)
+trekr check
+trekr videocheck VIDEO [--save REF.json | --against REF.json]
+```
+
+## `trekr labels`: find and fix label errors in a DeepLabCut project
+
+```bash
+trekr labels path/to/my-dlc-project      # the folder with config.yaml and labeled-data/
+```
+
+A wrong label -- a leg point on the neighbour, two points swapped, a point dropped in
+the background -- trains a network to be wrong, and among hundreds of labelled animals
+it is hard to find by eye. Such an error is almost always one point while the rest of
+the animal is right. `trekr labels` compares each point with the rest of its animal
+through the distances between them (which do not change when the animal turns, or is
+seen upside down), against the usual distances in your own labels, and lists the
+animals with the point that fits worst first.
+
+- **To check:** click an animal: the image opens on it with its worst point selected.
+  A score is in units of the labels' own spread: right points score about 1; errors
+  stand far above (on a tested project, most animals above about 10 had a wrong point).
+- **Hover** a point to see which keypoint of which animal it is, and its score.
+- **Editing:** drag a point to move it, right-click to remove it; pick a keypoint in
+  the list and click to place it; Ctrl+Z / Ctrl+Y. F5 checks again after edits.
+- **Saving** (Ctrl+S) writes the edited points into `CollectedData_<scorer>.csv`;
+  every other byte of the file stays as it was, and the original is kept beside it
+  (`.orig`). DeepLabCut trains from the `.h5` file, which you make again from the CSV:
+
+  ```python
+  import deeplabcut
+  deeplabcut.convertcsv2h5("path/to/my-dlc-project/config.yaml", userfeedback=False)
+  ```
+
+One kind of animal per project (DeepLabCut's unique bodyparts are kept as they are and
+not checked); single- and multi-animal projects; the labelled frames are the PNG images
+in `labeled-data/`, so no videos are needed. The skeleton is drawn from `config.yaml`.
+
+## `trekr check`: is this computer ready?
+
+Every line says **OK**, **NOTE** (works, with a caveat) or **FAIL** (why, and what to
+install); the exit status is 1 when anything fails.
+
+- **The GPU against the PyTorch build** (if PyTorch is installed). A PyTorch build
+  carries compiled code for some GPU generations only, so a new card -- for example
+  the RTX 50 series -- can need a build for a newer CUDA. The check names the GPU's
+  architecture and the build's, and says which to install.
+- **The NVIDIA driver against that CUDA version.**
+- **Video decoding.** A tiny stored H.264 clip, encoded the way cameras write video
+  (BT.709 colour matrix, TV range), is decoded with the installed OpenCV and compared
+  with the frames a correct decoder gives. OpenCV 4.11 and 4.12 apply the wrong colour
+  matrix to such video: on the clip, red is off by 5.4 and blue by 2.5 grey levels on
+  average, up to 22. Every colour or brightness measured from video decoded that way
+  is shifted. OpenCV 4.13 and newer decode it exactly.
+
+## `trekr videocheck`: is a video file still the one you recorded?
+
+```bash
+trekr videocheck run1.mp4 --save run1.fingerprint.json     # once, next to your data
+trekr videocheck run1.mp4 --against run1.fingerprint.json  # later: the same file? (exit 2 if not)
+```
+
+The fingerprint is the file's size and a SHA-256 of its first and last megabyte (fast
+for any size; nothing is decoded), with the frame count, frame rate and size as OpenCV
+reads them. A re-encode, a cut or a different file under the same name shows up, with
+what changed.
+
+## Licence
+
+MIT (see LICENSE).

trekr-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+trekr/__init__.py,sha256=yAHIyPH_bs-MEN-BMvVo1-OFOH6zAX_eVsbdm1TPxq4,108
+trekr/__main__.py,sha256=8jseVsc_EkPppL12BvLuKmyarnVUV-oStItjURUCt1s,94
+trekr/cli.py,sha256=1qPxyiBaXQzySU9c1jjCGXGxiGcQs_rqQJoE6kNUx38,2268
+trekr/envcheck.py,sha256=b5Da6qhr3Z9atOFpzWBlfqp0cfnwkn99dV4HFZfIKqI,8071
+trekr/videocheck.py,sha256=MvZnxSm8JZZnAHUcaITBcN_E6RzD2pTMbiBFsBWpZTI,3044
+trekr/data/clip.expected.npz,sha256=QGZrWkszQct0ilT-3Yp42zumlPwNQhUk6fXkU64_uVU,8154
+trekr/data/clip.mp4,sha256=EP78Jiv674_gx1lcS7KYSKhzKk18_mggRByh75QeoLY,2374
+trekr/labels/__init__.py,sha256=VC7UL7qICr5-_fwUpKn_jAJBNMVOWPuq-IkEHyFXY_k,73
+trekr/labels/app.py,sha256=ENsE_tCIejssXKl_ufRcJLau5Lv70OltPCr7J6DaEbc,17520
+trekr/labels/check.py,sha256=fAq5frjfL0D-U3e4hVNJRXJ8kffxlkxonHkO1JXOY2g,4572
+trekr/labels/dlc.py,sha256=qPAFamI2wtQ9NHTTBKa3-o27EJ_oei2vtw6zsFW8lPE,6922
+trekr-0.1.0.dist-info/licenses/LICENSE,sha256=DaA65Q2z5RYoBCOybTYsbuTe2Kya4dB4r6_iXn-vg5c,1069
+trekr-0.1.0.dist-info/METADATA,sha256=_VtPD_gqJZGwLxPB6HylWmbf2T7Alvu02ATao6WtVb0,4773
+trekr-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+trekr-0.1.0.dist-info/entry_points.txt,sha256=2KWKypoUHCfVCuTIhrnnauiLltQz37On80Ge8j-vfHQ,41
+trekr-0.1.0.dist-info/top_level.txt,sha256=s72VbKy4hCsnyNY9BY5YtTtaDdsQq6v6lN35WcYITq0,6
+trekr-0.1.0.dist-info/RECORD,,

trekr-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

trekr-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+trekr = trekr.cli:main

trekr-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Koen Freerks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

trekr-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+trekr