laboard 1.0.0__py3-none-any.whl

laboard/labels.py

@@ -0,0 +1,189 @@
+import json
+import zlib
+from collections import Counter
+from functools import lru_cache
+
+from PyQt6.QtCore import QPointF, QRectF, Qt
+from PyQt6.QtGui import QBitmap, QColor, QImage, QPainter, QPainterPath, QPen, QPixmap, QRegion, QTransform
+
+from . import remote
+from .theme import font
+
+PALETTE = ("#ff5c5c", "#ffb020", "#f7e14b", "#7bd84a", "#2ec4b6", "#3fa7ff", "#7c6cff", "#d45cff", "#ff6fb1",
+           "#00e0a0", "#ff8a3d", "#9fe870")
+COCO_SKELETON = ((16, 14), (14, 12), (17, 15), (15, 13), (12, 13), (6, 12), (7, 13), (6, 7), (6, 8), (7, 9), (8, 10),
+                 (9, 11), (2, 3), (1, 2), (1, 3), (2, 4), (3, 5), (4, 6), (5, 7))
+MAX_TEXT = 60
+
+
+@lru_cache(maxsize=256)
+def _loads(text):
+    try:
+        return json.loads(text)
+    except ValueError:
+        return text
+
+
+def parse(value):
+    if value is None or isinstance(value, (list, dict)):
+        return value
+    v = _loads(str(value)) if str(value)[:1] in "[{" else value
+    return v if isinstance(v, (list, dict)) else value
+
+
+def _objects(v):
+    if isinstance(v, dict):
+        v = v.get("segments_info", [])
+    return [o for o in v if isinstance(o, dict)] if isinstance(v, list) else []
+
+
+def categories(value):
+    v = parse(value)
+    if v is None:
+        return []
+    if not isinstance(v, (list, dict)):
+        return [str(v)]
+    if isinstance(v, list) and all(not isinstance(x, (list, dict)) for x in v):
+        return [str(x) for x in v]
+    return [str(o["category"]) for o in _objects(v) if o.get("category") is not None]
+
+
+def summary(value):
+    v = parse(value)
+    if v is None:
+        return None
+    if not isinstance(v, (list, dict)):
+        text = str(v)
+    elif isinstance(v, list) and all(not isinstance(x, (list, dict)) for x in v):
+        text = ", ".join(map(str, v)) or "none"
+    else:
+        objs = _objects(v)
+        counts = Counter(str(o.get("category", "?")) for o in objs)
+        what = ("segment" if isinstance(v, dict) else "object") + ("" if len(objs) == 1 else "s")
+        names = ", ".join(c if n == 1 else f"{c} ×{n}" for c, n in counts.most_common())
+        text = f"{len(objs)} {what}" + (f" · {names}" if names else "")
+    return text if len(text) <= MAX_TEXT else text[:MAX_TEXT - 1] + "…"
+
+
+def color(category):
+    return PALETTE[zlib.crc32(str(category).encode()) % len(PALETTE)]
+
+
+def _polygons(seg):
+    path = QPainterPath()
+    path.setFillRule(Qt.FillRule.WindingFill)
+    if isinstance(seg, list):
+        for poly in seg:
+            if isinstance(poly, list) and len(poly) >= 6:
+                path.moveTo(poly[0], poly[1])
+                for i in range(2, len(poly) - 1, 2):
+                    path.lineTo(poly[i], poly[i + 1])
+                path.closeSubpath()
+    elif isinstance(seg, dict) and isinstance(seg.get("counts"), list) and seg.get("size"):
+        h = seg["size"][0]
+        at = 0
+        for i, n in enumerate(seg["counts"]):
+            if i % 2:
+                start, end = at, at + n
+                while start < end:
+                    x, y = divmod(start, h)
+                    run = min(end - start, h - y)
+                    path.addRect(QRectF(x, y, 1, run))
+                    start += run
+            at += n
+    return path
+
+
+def _panoptic(path, segments):
+    ids = QImage(path).convertToFormat(QImage.Format.Format_RGB32)
+    if ids.isNull():
+        return None
+    out = QImage(ids.size(), QImage.Format.Format_ARGB32_Premultiplied)
+    out.fill(Qt.GlobalColor.transparent)
+    p = QPainter(out)
+    for seg in segments:
+        sid = seg.get("id")
+        if not isinstance(sid, int):
+            continue
+        mask = ids.createMaskFromColor(QColor(sid % 256, sid // 256 % 256, sid // 65536 % 256).rgb(), Qt.MaskMode.MaskOutColor)
+        fill = QColor(color(seg.get("category", "")))
+        fill.setAlpha(110)
+        p.setClipRegion(QRegion(QBitmap.fromImage(mask)))
+        p.fillRect(out.rect(), fill)
+    p.end()
+    return QPixmap.fromImage(out)
+
+
+class Overlay:
+    def __init__(self, value):
+        v = parse(value)
+        self.shapes = []
+        self.mask = None
+        if isinstance(v, dict) and v.get("mask_path"):
+            self.mask = _panoptic(remote.local(str(v["mask_path"])), _objects(v))
+        for o in _objects(v):
+            cat = str(o.get("category", ""))
+            if isinstance(v, dict):
+                path = QPainterPath()
+                if isinstance(o.get("bbox"), list) and len(o["bbox"]) == 4:
+                    path.addRect(QRectF(*o["bbox"]))
+                self.shapes.append((cat, path, None, [], []))
+                continue
+            path, filled = QPainterPath(), False
+            if o.get("segmentation") is not None:
+                path, filled = _polygons(o["segmentation"]), True
+            elif isinstance(o.get("bbox"), list) and len(o["bbox"]) == 4:
+                path.addRect(QRectF(*o["bbox"]))
+            points, limbs = [], []
+            kp = o.get("keypoints")
+            if isinstance(kp, list) and len(kp) >= 3:
+                points = [(kp[i], kp[i + 1]) if kp[i + 2] else None for i in range(0, len(kp) - 2, 3)]
+                limbs = [(a - 1, b - 1) for a, b in COCO_SKELETON] if len(points) == 17 else []
+            self.shapes.append((cat, path, filled, points, limbs))
+
+    def __bool__(self):
+        return bool(self.shapes) or self.mask is not None
+
+    def paint(self, p, rect, scale):
+        p.save()
+        to_view = QTransform(scale, 0, 0, scale, rect.x(), rect.y())
+        if self.mask is not None:
+            p.drawPixmap(rect, self.mask, QRectF(self.mask.rect()))
+        names = []
+        for cat, path, filled, points, limbs in self.shapes:
+            c = QColor(color(cat))
+            view = to_view.map(path)
+            if filled is not None and not path.isEmpty():
+                if filled:
+                    fill = QColor(c)
+                    fill.setAlpha(70)
+                    p.fillPath(view, fill)
+                p.setPen(QPen(c, 2))
+                p.setBrush(Qt.BrushStyle.NoBrush)
+                p.drawPath(view)
+            if points:
+                p.setPen(QPen(c, 2))
+                for a, b in limbs:
+                    if points[a] and points[b]:
+                        p.drawLine(to_view.map(QPointF(*points[a])), to_view.map(QPointF(*points[b])))
+                p.setPen(QPen(QColor("#ffffff"), 1))
+                p.setBrush(c)
+                for pt in points:
+                    if pt:
+                        p.drawEllipse(to_view.map(QPointF(*pt)), 3.5, 3.5)
+            if cat and not path.isEmpty():
+                box = view.boundingRect()
+                names.append((cat, c, QPointF(box.x(), box.y()) if filled is not None else box.center()))
+        p.setFont(font(11, 600))
+        fm = p.fontMetrics()
+        for cat, c, at in names:
+            w = fm.horizontalAdvance(cat) + 10
+            chip = QRectF(at.x(), at.y() - 18, w, 18) if at.y() >= rect.y() + 18 else QRectF(at.x(), at.y(), w, 18)
+            if self.mask is not None:
+                chip.moveCenter(at)
+            p.setPen(Qt.PenStyle.NoPen)
+            p.setBrush(c)
+            p.drawRoundedRect(chip, 4, 4)
+            p.setPen(QColor("#0e0f0c"))
+            p.drawText(chip, Qt.AlignmentFlag.AlignCenter, cat)
+        p.restore()

laboard/modelinfo.py

@@ -0,0 +1,218 @@
+import json
+import math
+import pickle
+import re
+import struct
+import zipfile
+from collections import Counter, OrderedDict
+from pathlib import Path
+
+MAX_LAYERS = 12
+_cache = {}
+
+
+class Tensor:
+    __slots__ = ("shape", "dtype")
+
+    def __init__(self, shape, dtype):
+        self.shape, self.dtype = tuple(int(d) for d in shape), str(dtype)
+
+    @property
+    def size(self):
+        return math.prod(self.shape)
+
+
+def count(n):
+    return f"{n / 1e9:.2f}B" if n >= 1e9 else f"{n / 1e6:.2f}M" if n >= 1e6 else f"{n / 1e3:.1f}K" if n >= 1e3 else str(n)
+
+
+def _onnx(p):
+    import onnx
+
+    m = onnx.load(str(p), load_external_data=False)
+    g = m.graph
+    dtype = onnx.TensorProto.DataType.Name
+    tensors = {t.name: Tensor(t.dims, dtype(t.data_type).lower()) for t in g.initializer}
+    for n in g.node:
+        if n.op_type == "Constant":
+            for a in n.attribute:
+                if a.name == "value" and a.t.dims:
+                    tensors.setdefault(n.output[0], Tensor(a.t.dims, dtype(a.t.data_type).lower()))
+    init = set(tensors)
+    users = {}
+    for n in g.node:
+        for i in n.input:
+            if i in init and i not in users:
+                users[i] = n.name.strip("/").rsplit("/", 1)[0] if "/" in n.name.strip("/") else n.op_type
+    tensors = {f"{users.get(k, 'unused')}:{k}": t for k, t in tensors.items()}
+
+    def shape(v):
+        dims = [d.dim_value or d.dim_param or "?" for d in v.type.tensor_type.shape.dim]
+        return f"{dtype(v.type.tensor_type.elem_type).lower()}[{','.join(map(str, dims))}]"
+
+    ops = Counter(n.op_type for n in g.node)
+    props = [("Format", f"ONNX IR v{m.ir_version}"), ("Producer", f"{m.producer_name} {m.producer_version}".strip() or "—"),
+             ("Opset", ", ".join(f"{o.domain or 'ai.onnx'} {o.version}" for o in m.opset_import)),
+             *[("Input", f"{v.name}: {shape(v)}") for v in g.input if v.name not in init],
+             *[("Output", f"{v.name}: {shape(v)}") for v in g.output],
+             ("Nodes", f"{len(g.node):,}"), ("Top ops", ", ".join(f"{k} {n}" for k, n in ops.most_common(4)))]
+    if any(t.data_location == onnx.TensorProto.EXTERNAL for t in g.initializer):
+        props.append(("Weights", "external data file (not loaded)"))
+    return tensors, props
+
+
+def _safetensors(p):
+    with open(p, "rb") as f:
+        n = struct.unpack("<Q", f.read(8))[0]
+        header = json.loads(f.read(n))
+    meta = header.pop("__metadata__", None) or {}
+    tensors = {k: Tensor(v["shape"], v["dtype"].lower()) for k, v in header.items()}
+    props = [("Format", "safetensors"), ("Tensors", f"{len(tensors):,}"),
+             ("Dtypes", ", ".join(sorted({t.dtype for t in tensors.values()})))]
+    props += [(f"meta · {k}", str(v)[:60]) for k, v in list(meta.items())[:4]]
+    return tensors, props
+
+
+def _msgpack(p):
+    import msgpack
+
+    def ext(code, data):
+        if code == 1:
+            shape, dtype, _ = msgpack.unpackb(data, raw=False)
+            return Tensor(shape, dtype)
+        if code == 3:
+            return Tensor((), msgpack.unpackb(data, raw=False)[0])
+        return msgpack.ExtType(code, data)
+
+    with open(p, "rb") as f:
+        tree = msgpack.unpackb(f.read(), ext_hook=ext, raw=False, strict_map_key=False)
+    tensors = dict(_leaves(tree))
+    return tensors, [("Format", "Flax msgpack"), ("Tensors", f"{len(tensors):,}"),
+                     ("Dtypes", ", ".join(sorted({t.dtype for t in tensors.values()})))]
+
+
+class _Obj:
+    def __new__(cls, *a, **k):
+        return object.__new__(cls)
+
+    def __init__(self, *a, **k):
+        self.args = a
+
+    def __setstate__(self, state):
+        self.state = state
+
+
+class _Unpickler(pickle.Unpickler):
+    def find_class(self, module, name):
+        if module == "collections" and name == "OrderedDict":
+            return OrderedDict
+        if module == "torch._utils" and name.startswith("_rebuild_tensor"):
+            return lambda storage, offset, size, *a, **k: Tensor(size, storage)
+        if module == "torch._utils" and name == "_rebuild_parameter":
+            return lambda data, *a, **k: data
+        if module == "torch" and name.endswith("Storage"):
+            return name[:-len("Storage")].lower() or "untyped"
+        if module == "torch" and name in ("float32", "float16", "bfloat16", "int64", "int32", "uint8", "bool"):
+            return name
+        return type(name, (_Obj,), {"__module__": "stub." + module})
+
+    def persistent_load(self, pid):
+        return pid[1] if isinstance(pid[1], str) else "untyped"
+
+
+CHECKPOINT_SKIP = re.compile(r"optim|sched|scaler|rng|history|ema_|swa_", re.I)
+
+
+def model_tensors(obj):
+    if isinstance(obj, dict) and not all(isinstance(v, Tensor) for v in obj.values()):
+        parts = {k: OrderedDict(_leaves(v)) for k, v in obj.items()
+                 if not CHECKPOINT_SKIP.search(str(k)) and not isinstance(v, Tensor)}
+        parts = {k: v for k, v in parts.items() if v}
+        if parts:
+            return max(parts.values(), key=len)
+    return OrderedDict(_leaves(obj))
+
+
+def _torch(p):
+    if not zipfile.is_zipfile(p):
+        raise ValueError("legacy (non-zip) torch file; re-save with torch>=1.6 to inspect")
+    with zipfile.ZipFile(p) as z:
+        names = z.namelist()
+        obj = _Unpickler(z.open(next(n for n in names if n.endswith("data.pkl")))).load()
+    tensors = model_tensors(obj)
+    kind = "state_dict" if isinstance(obj, dict) and all(isinstance(v, Tensor) for v in obj.values()) else \
+        "checkpoint dict" if isinstance(obj, dict) else type(obj).__name__
+    if any("/code/" in n for n in names):
+        kind = "TorchScript"
+    props = [("Format", f"PyTorch zip · {kind}"), ("Tensors", f"{len(tensors):,}")]
+    if isinstance(obj, dict):
+        extra = [k for k, v in obj.items() if not isinstance(v, Tensor)][:6]
+        if extra:
+            props.append(("Keys", ", ".join(map(str, extra))))
+    return tensors, props
+
+
+def _engine(p):
+    with open(p, "rb") as f:
+        head = f.read(32)
+    magic = head[:4].decode("latin-1")
+    props = [("Format", "TensorRT engine" if magic == "ftrt" else "TensorRT plan"),
+             ("Note", "built for one TensorRT/GPU combination; layers need that runtime")]
+    return {}, props
+
+
+_SKIP = {"_modules", "_parameters", "_buffers", "state", "args", "params"}
+
+
+def _leaves(obj, prefix=""):
+    if isinstance(obj, Tensor):
+        yield prefix.rstrip("."), obj
+    elif isinstance(obj, dict):
+        for k, v in obj.items():
+            yield from _leaves(v, prefix if str(k) in _SKIP else f"{prefix}{k}.")
+    elif isinstance(obj, (list, tuple)):
+        for i, v in enumerate(obj):
+            yield from _leaves(v, f"{prefix}{i}.")
+    elif isinstance(obj, _Obj):
+        yield from _leaves(getattr(obj, "state", None) or getattr(obj, "args", ()), prefix)
+
+
+def _layers(tensors):
+    parts = {k: [s for s in re.split(r"[./:]", k) if s] for k in tensors}
+    best = []
+    top = Counter()
+    for k, t in tensors.items():
+        top[parts[k][0] if parts[k] else k] += t.size
+    if len(top) > MAX_LAYERS:
+        head = top.most_common(MAX_LAYERS - 1)
+        return head + [("other", sum(top.values()) - sum(n for _, n in head))]
+    for depth in range(1, 8):
+        groups = OrderedDict()
+        for k, t in tensors.items():
+            key = ".".join(parts[k][:depth]) or k
+            groups[key] = groups.get(key, 0) + t.size
+        if len(groups) > MAX_LAYERS:
+            break
+        best = list(groups.items())
+        if all(len(p) <= depth for p in parts.values()):
+            break
+    return best
+
+
+READERS = {".onnx": _onnx, ".safetensors": _safetensors, ".msgpack": _msgpack, ".pt": _torch, ".pth": _torch,
+           ".ckpt": _torch, ".bin": _torch, ".engine": _engine, ".plan": _engine, ".trt": _engine}
+
+
+def inspect(path):
+    p = Path(path)
+    key = (str(p), p.stat().st_mtime)
+    if key not in _cache:
+        reader = READERS.get(p.suffix.lower())
+        try:
+            tensors, props = reader(p) if reader else ({}, [("Format", p.suffix[1:].upper() or "file")])
+        except Exception as e:
+            tensors, props = {}, [("Could not read", f"{type(e).__name__}: {str(e)[:80]}")]
+        total = sum(t.size for t in tensors.values())
+        stats = [("Parameters", count(total))] if tensors else []
+        _cache[key] = dict(stats=stats, props=props, layers=_layers(tensors))
+    return _cache[key]

laboard/netronview.py

@@ -0,0 +1,107 @@
+import logging
+import os
+
+from PyQt6.QtCore import QCoreApplication, Qt, QUrl
+from PyQt6.QtGui import QColor
+
+from . import theme
+
+try:
+    import netron
+    from PyQt6 import sip
+    from PyQt6.QtWebEngineCore import QWebEngineScript
+    from PyQt6.QtWebEngineWidgets import QWebEngineView
+    AVAILABLE = True
+except ImportError:
+    AVAILABLE = False
+
+logging.getLogger("netron").setLevel(logging.WARNING)
+_view, _path, _address = None, None, None
+_win = None
+SIDEBAR_FONT_PX = 14
+SIDEBAR_WIDTH = 0.7
+
+
+def prepare():
+    if AVAILABLE:
+        os.environ.setdefault("QTWEBENGINE_CHROMIUM_FLAGS", "--disable-gpu")
+        QCoreApplication.setAttribute(Qt.ApplicationAttribute.AA_ShareOpenGLContexts)
+
+
+def url():
+    return f"http://{_address[0]}:{_address[1]}" if _address else ""
+
+
+def _new_view(parent=None):
+    v = QWebEngineView(parent)
+    script = QWebEngineScript()
+    script.setName("laboard-sidebar-size")
+    script.setInjectionPoint(QWebEngineScript.InjectionPoint.DocumentReady)
+    script.setWorldId(QWebEngineScript.ScriptWorldId.ApplicationWorld)
+    script.setSourceCode(f"""(() => {{ const s = document.createElement('style');
+        s.textContent = '.sidebar {{ zoom: {SIDEBAR_FONT_PX / 11:.4f}; '
+            + 'width: calc(min(calc(100% * 0.6), 42em) * {SIDEBAR_WIDTH}) !important; }}';
+        document.head.appendChild(s); }})();""")
+    v.page().scripts().insert(script)
+    v.loadFinished.connect(lambda ok: _apply_theme(v))
+    return v
+
+
+def _apply_theme(v):
+    dark = theme.current == "dark"
+    v.page().setBackgroundColor(QColor(theme.T.stage))
+    v.page().runJavaScript(f"""(dark => {{
+        const seen = window.laboardDark = window.laboardDark || new Set();
+        for (const sheet of document.styleSheets) {{
+            let rules;
+            try {{ rules = sheet.cssRules; }} catch (e) {{ continue; }}
+            for (const r of rules)
+                if (r.media && (seen.has(r) || r.media.mediaText.includes('prefers-color-scheme: dark'))) {{
+                    seen.add(r);
+                    r.media.mediaText = dark ? 'all' : 'not all';
+                }}
+        }}
+        let s = document.getElementById('laboard-stage');
+        if (!s && document.head) {{
+            s = document.createElement('style');
+            s.id = 'laboard-stage';
+            document.head.appendChild(s);
+        }}
+        if (s) s.textContent = '.default, .target, .welcome {{ background-color: {theme.T.stage} !important; }}';
+    }})({'true' if dark else 'false'});""")
+
+
+def attach(win):
+    global _view, _win
+    _win = win
+    if AVAILABLE and _view is None:
+        _view = _new_view(win)
+        _view.load(QUrl("about:blank"))
+        _stow(_view)
+
+
+def _stow(v):
+    v.setGeometry(0, 0, 1, 1)
+    v.show()
+    v.lower()
+
+
+def park(win):
+    if _view is not None and not sip.isdeleted(_view) and _view.parent() is not win:
+        _view.setParent(win)
+        _stow(_view)
+
+
+def view(path):
+    global _view, _path, _address
+    if _view is None or sip.isdeleted(_view):
+        _view, _path = _new_view(_win), None
+    if path != _path:
+        if _address:
+            netron.stop(_address)
+        _address = netron.serve(path, address=("localhost", 0), browse=False)
+        _path = path
+        _view.load(QUrl(url()))
+    _apply_theme(_view)
+    _view.show()
+    return _view