npyquick 0.1.0__py3-none-any.whl

npyquick/core/stats.py

@@ -0,0 +1,90 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from . import limits
+
+
+@dataclass(frozen=True)
+class ArrayStats:
+    finite_min: float | None  # None when no finite values exist
+    finite_max: float | None
+    nan_count: int
+    pos_inf_count: int
+    neg_inf_count: int
+    sampled: bool = False  # computed from a subsample of a large array
+
+    @property
+    def has_anomaly(self) -> bool:
+        return self.nan_count > 0 or self.pos_inf_count > 0 or self.neg_inf_count > 0
+
+    def anomaly_str(self) -> str:
+        """Compact anomaly summary, e.g. 'NaN: 3  +Inf: 1'.
+
+        For sampled stats, exact counts would be misleading (sparse anomalies
+        may be missed or over-represented), so only a qualitative note is given.
+        """
+        if self.sampled:
+            return "NaN/Inf present in sample" if self.has_anomaly else "no anomaly in sample"
+        parts = []
+        if self.nan_count:
+            parts.append(f"NaN: {self.nan_count}")
+        if self.pos_inf_count:
+            parts.append(f"+Inf: {self.pos_inf_count}")
+        if self.neg_inf_count:
+            parts.append(f"-Inf: {self.neg_inf_count}")
+        return "  ".join(parts)
+
+    def range_str(self) -> str:
+        """Return 'finite range [a, b]', plain 'range [a, b]', or 'no finite values'."""
+        if self.finite_min is None:
+            return "no finite values"
+        prefix = "finite range" if self.has_anomaly else "range"
+        approx = " (approx)" if self.sampled else ""
+        return f"{prefix} [{self.finite_min:.4g}, {self.finite_max:.4g}]{approx}"
+
+
+def is_real_numeric(array: np.ndarray) -> bool:
+    """True for real integer and floating dtypes; False for complex and non-numeric."""
+    return (
+        np.issubdtype(array.dtype, np.number)
+        and not np.issubdtype(array.dtype, np.complexfloating)
+    )
+
+
+def array_stats(array: np.ndarray) -> ArrayStats | None:
+    """Compute finite range and anomaly counts for numeric arrays.
+
+    Returns None for non-numeric, complex, or empty arrays.
+    Integer arrays cannot contain NaN/Inf, so anomaly counts are always 0.
+    Arrays whose element count exceeds HIST_MAX_SAMPLES are subsampled
+    (range/counts become approximate, ``sampled=True``) to avoid materializing a
+    full finite mask. This is a compute budget independent of the byte-based I/O
+    threshold; downsample_stride returns 1 when within budget.
+    """
+    if not is_real_numeric(array) or array.size == 0:
+        return None
+
+    flat = array.reshape(-1)
+    stride = limits.downsample_stride(flat.size, limits.HIST_MAX_SAMPLES)
+    sampled = stride > 1
+    sample = np.asarray(flat[::stride]) if sampled else array
+
+    if np.issubdtype(array.dtype, np.integer):
+        lo, hi = float(sample.min()), float(sample.max())
+        return ArrayStats(lo, hi, 0, 0, 0, sampled)
+
+    nan_count = int(np.sum(np.isnan(sample)))
+    pos_inf_count = int(np.sum(np.isposinf(sample)))
+    neg_inf_count = int(np.sum(np.isneginf(sample)))
+    finite = sample[np.isfinite(sample)]
+    if finite.size == 0:
+        return ArrayStats(None, None, nan_count, pos_inf_count, neg_inf_count, sampled)
+    return ArrayStats(
+        float(finite.min()), float(finite.max()),
+        nan_count, pos_inf_count, neg_inf_count, sampled,
+    )

npyquick/main.py

@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# Copyright (C) 2026 LiukDiihMieu
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from PySide6.QtWidgets import QApplication
+
+from npyquick.app import MainWindow
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="npyquick — a fast, lightweight viewer for NumPy arrays (.npy / .npz)"
+    )
+    parser.add_argument(
+        "file", nargs="?", help="Path to a .npy or .npz file to open on launch"
+    )
+    args, qt_argv = parser.parse_known_args()
+
+    app = QApplication([sys.argv[0]] + qt_argv)
+    app.setApplicationName("npyquick")
+
+    window = MainWindow()
+    window.show()
+
+    if args.file:
+        window.load_file(args.file)
+
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

npyquick/model.py

@@ -0,0 +1,84 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+import numpy as np
+
+from .core import limits
+from .core.npyheader import MemberMeta, peek_npy, peek_npz
+
+
+class NpyDataModel:
+    def __init__(self) -> None:
+        self.array: np.ndarray | None = None
+        self.path: str = ""
+        self._is_npz = False
+        self._metas: dict[str, MemberMeta] = {}
+        self._selected_key: str = ""
+
+    def load(self, path: str) -> None:
+        if path.endswith(".npz"):
+            metas = peek_npz(path)
+            if not metas:
+                raise ValueError("NPZ archive contains no arrays")
+            # Deliberately do NOT materialize any member here: the first member
+            # may be huge (or even over NPZ_MEMBER_CEILING). Caller discovers
+            # available arrays via available_array_meta(), then calls
+            # select_array() to materialize the chosen one.
+            self._is_npz = True
+            self._metas = metas
+            self._selected_key = ""
+            self.array = None
+            self.path = path
+            return
+
+        meta = peek_npy(path)
+        # Materialize up front so a bad file raises before we commit state.
+        array = self._materialize(path, False, "", meta)
+
+        self._is_npz = False
+        self._metas = {"": meta}
+        self._selected_key = ""
+        self.array = array
+        self.path = path
+
+    def _materialize(
+        self, path: str, is_npz: bool, key: str, meta: MemberMeta
+    ) -> np.ndarray:
+        if is_npz:
+            if meta.nbytes > limits.NPZ_MEMBER_CEILING:
+                raise ValueError(
+                    f"Array '{key}' is {meta.nbytes / 1024**3:.1f} GiB, exceeding the "
+                    f"{limits.NPZ_MEMBER_CEILING / 1024**3:.0f} GiB limit for .npz "
+                    f"members (they cannot be memory-mapped)."
+                )
+            with np.load(path, allow_pickle=False) as f:
+                return f[key]
+        return self._load_npy(path, meta)
+
+    @staticmethod
+    def _load_npy(path: str, meta: MemberMeta) -> np.ndarray:
+        # 0-d arrays are always tiny and pointless to map; everything else,
+        # including structured dtypes, is memory-mappable and should be mapped
+        # when large. (Structured arrays load fine here but only the table view
+        # handles them — image/histogram/stats gate on is_real_numeric.)
+        zero_d = meta.shape == ()
+        if zero_d or meta.nbytes <= limits.LARGE_BYTES:
+            return np.load(path, allow_pickle=False)
+        # Large array: memory-map. Do NOT silently fall back to a full load on
+        # failure — that would defeat the protection and risk OOM.
+        try:
+            return np.load(path, mmap_mode="r", allow_pickle=False)
+        except (ValueError, OSError) as exc:
+            raise RuntimeError(
+                f"Array is {meta.nbytes / 1024**3:.1f} GiB and could not be "
+                f"memory-mapped: {exc}"
+            ) from exc
+
+    def available_array_meta(self) -> dict[str, MemberMeta]:
+        return dict(self._metas)
+
+    def select_array(self, name: str) -> None:
+        meta = self._metas[name]
+        self.array = self._materialize(self.path, self._is_npz, name, meta)
+        self._selected_key = name

npyquick/views/__init__.py

@@ -0,0 +1 @@
+# SPDX-License-Identifier: GPL-3.0-or-later

npyquick/views/base.py

@@ -0,0 +1,117 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+import io
+import os
+import re
+from typing import TYPE_CHECKING
+
+import numpy as np
+from PySide6.QtCore import Qt, QSettings
+from PySide6.QtGui import QImage
+from PySide6.QtWidgets import (
+    QApplication, QFileDialog, QMainWindow, QMenu, QWidget,
+)
+
+if TYPE_CHECKING:
+    from ..core.stats import ArrayStats
+
+
+class ExportableMixin:
+    """Right-click + Ctrl+C / Ctrl+S export for any FigureCanvas subclass."""
+    panel_name: str = "Figure"
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        # matplotlib canvases default to NoFocus; ClickFocus lets a click mark
+        # this panel as the Ctrl+C / Ctrl+S target (resolved via focusWidget).
+        self.setFocusPolicy(Qt.ClickFocus)
+
+    def _show_status(self, msg: str, timeout: int = 2000) -> None:
+        win = self.window()
+        if isinstance(win, QMainWindow):
+            win.statusBar().showMessage(msg, timeout)
+
+    def _exports_allowed(self) -> bool:
+        # Duck-typed so the mixin stays decoupled from MainWindow (and works in
+        # standalone tests where the parent has no _has_data method).
+        check = getattr(self.window(), "_has_data", None)
+        return bool(check()) if callable(check) else True
+
+    def contextMenuEvent(self, ev) -> None:
+        if not self._exports_allowed():
+            return
+        menu = QMenu(self)
+        menu.addAction("Export this plot…", self._export_figure)
+        menu.addAction("Copy to clipboard", self._copy_to_clipboard)
+        menu.exec(ev.globalPos())
+
+    def _copy_to_clipboard(self) -> None:
+        buf = io.BytesIO()
+        self.figure.savefig(buf, format="png", dpi=300, bbox_inches="tight")
+        buf.seek(0)
+        QApplication.clipboard().setImage(QImage.fromData(buf.getvalue()))
+        self._show_status(f"{self.panel_name} copied to clipboard")
+
+    def _export_figure(self) -> None:
+        s = QSettings("npyquick", "npyquick")
+        start = s.value("last_export_dir") or s.value("last_dir", "")
+        # Seed the dialog with a panel-named default (no extension) so it is
+        # clear which plot is being saved without locking in a format — the
+        # chosen filter's extension is appended below at save time.
+        default_name = self.panel_name.replace(" ", "_")
+        path, selected_filter = QFileDialog.getSaveFileName(
+            self, f"Export {self.panel_name}",
+            os.path.join(start, default_name) if start else default_name,
+            "PNG (*.png);;SVG (*.svg);;PDF (*.pdf)",
+        )
+        if not path:
+            return
+        # Qt does not auto-append the extension — extract it from the chosen filter.
+        m = re.search(r'\*(\.\w+)', selected_filter)
+        if m:
+            ext = m.group(1).lower()
+            if not path.lower().endswith(ext):
+                path += ext
+        s.setValue("last_export_dir", os.path.dirname(os.path.abspath(path)))
+        self.figure.savefig(path, dpi=300, bbox_inches="tight")
+        self._show_status(f"{self.panel_name} saved to {os.path.basename(path)}", 3000)
+
+
+class SpatialView:
+    """Mixin: view supports physical pixel-size scaling."""
+    def set_pixel_size(self, ps: float, unit: str) -> None:
+        raise NotImplementedError
+
+
+class ColormappedView:
+    """Mixin: view supports matplotlib colormap selection."""
+    def set_colormap(self, name: str) -> None:
+        raise NotImplementedError
+
+
+class BaseView(QWidget):
+    VIEW_ID: str = ""
+    VIEW_NAME: str = ""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._on_status: callable = lambda _: None
+
+    def set_on_status(self, cb: callable) -> None:
+        self._on_status = cb
+
+    def refresh_status(self) -> None:
+        """Push the view's current status to the status bar. Called on tab switch."""
+
+    @classmethod
+    def can_handle(cls, array: np.ndarray) -> bool:
+        raise NotImplementedError
+
+    def set_data(self, array: np.ndarray, stats: ArrayStats | None = None) -> None:
+        raise NotImplementedError
+
+    def export_targets(self) -> list[tuple[str, callable]]:
+        """Return [(panel_name, export_fn), …] for File › Export Plot menu."""
+        return []

npyquick/views/histogram.py

@@ -0,0 +1,333 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from __future__ import annotations
+
+import numpy as np
+from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.figure import Figure
+from PySide6.QtCore import Qt, QSettings
+from PySide6.QtWidgets import (
+    QCheckBox, QComboBox, QHBoxLayout, QLabel, QPushButton, QVBoxLayout, QWidget,
+)
+
+from ..core import limits
+from ..core.stats import ArrayStats, array_stats, is_real_numeric
+from .base import BaseView, ExportableMixin
+
+_BIN_OPTIONS = ["auto", "64", "128", "256", "512"]
+
+
+def finite_sample(array: np.ndarray) -> tuple[np.ndarray, int, int]:
+    """Return (finite_values, n_total, n_used) for histogram and statistics.
+
+    Subsampling is driven by element count against HIST_MAX_SAMPLES (a compute
+    budget independent of the byte-based I/O threshold), applied before the
+    finite mask so a memmap is never fully read. downsample_stride returns 1
+    when within budget. n_used is the sample size before masking.
+    """
+    flat = array.reshape(-1)
+    n_total = flat.size
+    stride = limits.downsample_stride(n_total, limits.HIST_MAX_SAMPLES)
+    sample = np.asarray(flat[::stride])
+    n_used = sample.size
+    if np.issubdtype(array.dtype, np.inexact):
+        finite = sample[np.isfinite(sample)]
+    else:
+        finite = sample
+    return finite, n_total, n_used
+
+
+class HistogramCanvas(ExportableMixin, FigureCanvas):
+    panel_name = "Histogram"
+    def __init__(self) -> None:
+        self._fig = Figure(constrained_layout=True)
+        super().__init__(self._fig)
+        self._ax = self._fig.add_subplot(111)
+        self._on_status: callable = lambda _: None
+        self._idle_status: str = ""
+        self._n_bins: int | str = "auto"
+        self._log: bool = False
+        self._array: np.ndarray | None = None
+        self._finite: np.ndarray | None = None
+        self._n_total: int = 0
+        self._n_used: int = 0
+        self._edges: np.ndarray | None = None
+        self._counts: np.ndarray | None = None
+        self._clim: tuple[float, float] | None = None
+        self._vline_lo = None
+        self._vline_hi = None
+        self._vtext_lo = None
+        self._vtext_hi = None
+
+        self.mpl_connect("button_press_event", self._on_press)
+        self.mpl_connect("motion_notify_event", self._on_motion)
+        self.mpl_connect("axes_leave_event", self._on_axes_leave)
+        self.mpl_connect("scroll_event", self._on_scroll)
+
+    def set_on_status(self, cb: callable) -> None:
+        self._on_status = cb
+
+    def set_idle_status(self, s: str) -> None:
+        self._idle_status = s
+
+    def plot(self, array: np.ndarray) -> None:
+        self._array = array
+        finite, self._n_total, self._n_used = finite_sample(array)
+        self._finite = finite
+        self._render()
+
+    def _render(self) -> None:
+        """Redraw bars from the cached _finite sample (no re-sampling)."""
+        self._ax.cla()
+        self._ax.set_xlabel("Value")
+        self._ax.set_ylabel("Count")
+        self._edges = None
+        self._counts = None
+        self._vline_lo = None
+        self._vline_hi = None
+        self._vtext_lo = None
+        self._vtext_hi = None
+        finite = self._finite
+
+        if finite is None or finite.size == 0:
+            self._ax.text(
+                0.5, 0.5, "No finite values",
+                transform=self._ax.transAxes, ha="center", va="center",
+                color="gray", fontsize=12,
+            )
+        else:
+            bins = self._n_bins if self._n_bins == "auto" else int(self._n_bins)
+            counts, edges = np.histogram(finite, bins=bins)
+            self._counts = counts
+            self._edges = edges
+            self._ax.bar(
+                edges[:-1], counts, width=np.diff(edges), align="edge",
+                color="steelblue", edgecolor="none",
+            )
+            if self._clim is not None:
+                self._draw_clim_markers(*self._clim)
+
+        self._ax.set_yscale("log" if self._log else "linear")
+        self.draw_idle()
+
+    def _draw_clim_markers(self, vmin: float, vmax: float) -> None:
+        self._vline_lo = self._ax.axvline(
+            vmin, color="tomato", lw=1.5, ls="--", alpha=0.85, zorder=5
+        )
+        self._vline_hi = self._ax.axvline(
+            vmax, color="tomato", lw=1.5, ls="--", alpha=0.85, zorder=5
+        )
+        tr = self._ax.get_xaxis_transform()
+        self._vtext_lo = self._ax.text(
+            vmin, 0.98, "vmin", transform=tr,
+            ha="center", va="top", color="tomato", fontsize=7, clip_on=True,
+        )
+        self._vtext_lo.set_in_layout(False)
+        self._vtext_hi = self._ax.text(
+            vmax, 0.98, "vmax", transform=tr,
+            ha="center", va="top", color="tomato", fontsize=7, clip_on=True,
+        )
+        self._vtext_hi.set_in_layout(False)
+
+    def set_bins(self, n: int | str) -> None:
+        self._n_bins = n
+        if self._array is not None:
+            self._render()  # re-bin the cached sample; no re-sampling
+
+    def set_log_scale(self, enable: bool) -> None:
+        self._log = enable
+        if self._array is not None:
+            # Only the y-axis scale changes — no need to re-sample or re-bin.
+            self._ax.set_yscale("log" if enable else "linear")
+            self.draw_idle()
+
+    def set_clim_marker(self, vmin: float | None, vmax: float | None) -> None:
+        """Store clim without redrawing — called before plot()."""
+        self._clim = (vmin, vmax) if vmin is not None and vmax is not None else None
+
+    def update_clim_marker(self, vmin: float | None, vmax: float | None) -> None:
+        """Live-update vlines on an already-rendered histogram."""
+        self._clim = (vmin, vmax) if vmin is not None and vmax is not None else None
+        for artist in (self._vline_lo, self._vline_hi, self._vtext_lo, self._vtext_hi):
+            if artist is not None:
+                artist.remove()
+        self._vline_lo = self._vline_hi = None
+        self._vtext_lo = self._vtext_hi = None
+        if self._clim is not None and self._edges is not None:
+            self._draw_clim_markers(*self._clim)
+        self.draw_idle()
+
+    def _on_press(self, ev) -> None:
+        if ev.dblclick and ev.inaxes is self._ax:
+            self.xlim_full()
+
+    def _on_motion(self, ev) -> None:
+        if ev.inaxes is not self._ax or self._edges is None or ev.xdata is None:
+            return
+        idx = min(int(np.searchsorted(self._edges[1:], ev.xdata)), len(self._counts) - 1)
+        lo, hi = self._edges[idx], self._edges[idx + 1]
+        self._on_status(f"bin [{lo:.4g}, {hi:.4g})  count: {self._counts[idx]}")
+
+    def _on_axes_leave(self, ev) -> None:
+        self._on_status(self._idle_status)
+
+    def _on_scroll(self, ev) -> None:
+        if ev.inaxes is not self._ax or self._edges is None:
+            return
+        factor = 0.8 if ev.step > 0 else 1.25
+        xc = ev.xdata
+        xl = self._ax.get_xlim()
+        self._ax.set_xlim(xc + (xl[0] - xc) * factor, xc + (xl[1] - xc) * factor)
+        self.draw_idle()
+
+    def xlim_full(self) -> None:
+        if self._edges is None:
+            return
+        self._ax.set_xlim(self._edges[0], self._edges[-1])
+        self.draw_idle()
+
+    def xlim_robust(self) -> None:
+        if self._finite is None or self._finite.size < 2:
+            return
+        lo, hi = np.percentile(self._finite, [2, 98])
+        if lo == hi:
+            delta = abs(lo) * 0.05 if lo != 0 else 0.5
+            lo, hi = lo - delta, hi + delta
+        self._ax.set_xlim(lo, hi)
+        self.draw_idle()
+
+
+class HistogramView(BaseView):
+    VIEW_ID = "histogram"
+    VIEW_NAME = "Histogram"
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._status: str = ""
+        self._canvas = HistogramCanvas()
+
+        _s = QSettings("npyquick", "npyquick")
+
+        self._bins_combo = QComboBox()
+        self._bins_combo.addItems(_BIN_OPTIONS)
+        self._bins_combo.setFixedWidth(80)
+        self._bins_combo.currentTextChanged.connect(self._on_bins_changed)
+        _saved_bins = _s.value("histogram_bins", "auto")
+        if _saved_bins in _BIN_OPTIONS:
+            self._bins_combo.setCurrentText(_saved_bins)
+
+        self._log_check = QCheckBox("Log scale")
+        self._log_check.toggled.connect(self._canvas.set_log_scale)
+        self._log_check.toggled.connect(
+            lambda checked: QSettings("npyquick", "npyquick").setValue("histogram_log", checked)
+        )
+        if _s.value("histogram_log", False, type=bool):
+            self._log_check.setChecked(True)
+
+        self._full_btn = QPushButton("Full")
+        self._full_btn.setFixedWidth(48)
+        self._full_btn.clicked.connect(self._canvas.xlim_full)
+
+        self._robust_btn = QPushButton("Robust")
+        self._robust_btn.setFixedWidth(56)
+        self._robust_btn.setToolTip("Set x-range to p2–p98")
+        self._robust_btn.clicked.connect(self._canvas.xlim_robust)
+
+        self._stats_label = QLabel()
+        self._stats_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+
+        self._sample_label = QLabel()
+        self._sample_label.setStyleSheet("color: #b8860b;")
+        self._sample_label.setVisible(False)
+
+        self._anomaly_label = QLabel()
+        self._anomaly_label.setStyleSheet("color: red;")
+        self._anomaly_label.setVisible(False)
+
+        ctrl = QWidget()
+        ctrl_layout = QHBoxLayout(ctrl)
+        ctrl_layout.setContentsMargins(6, 3, 6, 3)
+        ctrl_layout.addWidget(QLabel("Bins:"))
+        ctrl_layout.addWidget(self._bins_combo)
+        ctrl_layout.addSpacing(12)
+        ctrl_layout.addWidget(self._log_check)
+        ctrl_layout.addSpacing(16)
+        ctrl_layout.addWidget(QLabel("X range:"))
+        ctrl_layout.addWidget(self._full_btn)
+        ctrl_layout.addWidget(self._robust_btn)
+        ctrl_layout.addStretch()
+        ctrl_layout.addWidget(self._stats_label)
+        ctrl_layout.addSpacing(8)
+        ctrl_layout.addWidget(self._sample_label)
+        ctrl_layout.addSpacing(8)
+        ctrl_layout.addWidget(self._anomaly_label)
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        layout.addWidget(ctrl)
+        layout.addWidget(self._canvas)
+
+    @classmethod
+    def can_handle(cls, array: np.ndarray) -> bool:
+        return is_real_numeric(array) and array.size > 0
+
+    def set_data(self, array: np.ndarray, stats: ArrayStats | None = None) -> None:
+        self._canvas.set_clim_marker(None, None)  # reset; app.py syncs from ImageView
+        self._canvas.plot(array)  # samples once; stores _finite / _n_total / _n_used
+
+        finite = self._canvas._finite
+        n_total = self._canvas._n_total
+        n_used = self._canvas._n_used
+
+        if finite is not None and finite.size > 0:
+            fmin, fmax = float(finite.min()), float(finite.max())
+            mean = float(np.mean(finite))
+            std = float(np.std(finite))
+            p1, p50, p99 = (float(v) for v in np.percentile(finite, [1, 50, 99]))
+            stats_str = (
+                f"min {fmin:.4g}  max {fmax:.4g}"
+                f"  mean {mean:.4g}  std {std:.4g}"
+                f"  |  p1 {p1:.4g}  p50 {p50:.4g}  p99 {p99:.4g}"
+            )
+        else:
+            stats_str = "no finite values"
+        self._stats_label.setText(stats_str)
+
+        sampled = n_used < n_total
+        if sampled:
+            self._sample_label.setText(f"sampled {n_used:,} / {n_total:,}")
+            self._sample_label.setVisible(True)
+        else:
+            self._sample_label.setVisible(False)
+
+        self._status = f"shape {array.shape}  dtype {array.dtype}  |  {stats_str}"
+        if sampled:
+            self._status += "  (sampled)"
+
+        if stats is None:
+            stats = array_stats(array)
+        if stats is not None and stats.has_anomaly:
+            self._anomaly_label.setText(stats.anomaly_str())
+            self._anomaly_label.setVisible(True)
+        else:
+            self._anomaly_label.setVisible(False)
+
+        self._canvas.set_idle_status(self._status)
+
+    def update_clim_marker(self, vmin: float | None, vmax: float | None) -> None:
+        self._canvas.update_clim_marker(vmin, vmax)
+
+    def refresh_status(self) -> None:
+        self._on_status(self._status)
+
+    def export_targets(self):
+        return [("Histogram", self._canvas._export_figure)]
+
+    def set_on_status(self, cb: callable) -> None:
+        super().set_on_status(cb)
+        self._canvas.set_on_status(cb)
+
+    def _on_bins_changed(self, text: str) -> None:
+        QSettings("npyquick", "npyquick").setValue("histogram_bins", text)
+        self._canvas.set_bins(text if text == "auto" else int(text))