triplot 1.1.0__py3-none-any.whl

dscpanel/ui/loading.py

@@ -0,0 +1,95 @@
+"""Reading files without freezing the window.
+
+Measured on real files: 1.09 s for a 16 MB `.tri` (seven segments,
+13 200 points each, eighteen stored analyses) and 0.51 s for an 11 MB one. A
+drop of five files is therefore several seconds, and several seconds of a
+frozen window is a program that looks broken.
+
+So every read runs on a thread pool and the window is told as each one
+arrives. Two things this deliberately does NOT do: it does not parse on the
+GUI thread "just for one small file" (the small file is the one that turns
+out to be 40 MB), and it does not hand a half-built sample to the window
+(the reader either returns a `Sample` or raises, and the failure carries the
+file's name so a bad file in a drop of five costs one line and not the drop).
+"""
+
+from PySide6.QtCore import QObject, QRunnable, QThreadPool, Signal
+
+from ..core import loader
+
+
+class _JobSignals(QObject):
+    done = Signal(object, str, str)          # sample, path, error
+
+
+class _Job(QRunnable):
+    def __init__(self, path, signals):
+        QRunnable.__init__(self)
+        self.path = str(path)
+        self.signals = signals
+
+    def run(self):
+        try:
+            sample = loader.read_sample(self.path)
+        except Exception as exc:             # the reader raises many kinds
+            self.signals.done.emit(None, self.path, str(exc))
+            return
+        self.signals.done.emit(sample, self.path, "")
+
+
+class Loader(QObject):
+    """Reads files in the background and reports each one as it lands."""
+
+    loaded = Signal(object)                  # Sample
+    failed = Signal(str, str)                # path, message
+    progress = Signal(int, int)              # done, total
+    finished = Signal()
+
+    def __init__(self, parent=None):
+        QObject.__init__(self, parent)
+        self._pool = QThreadPool(self)
+        # Two at a time. The reader is numpy-heavy and mostly holds the GIL,
+        # so more threads would not read faster, and a bounded pool keeps a
+        # drop of twenty files from starting twenty reads at once.
+        self._pool.setMaxThreadCount(2)
+        self._signals = _JobSignals()
+        self._signals.done.connect(self._one_done)
+        self._pending = 0
+        self._total = 0
+
+    def busy(self):
+        return self._pending > 0
+
+    def load(self, paths):
+        """Queue every readable path. Returns how many were queued."""
+        queued = 0
+        for path in paths or ():
+            if not loader.looks_readable(path):
+                continue
+            self._pending += 1
+            self._total += 1
+            self._pool.start(_Job(path, self._signals))
+            queued += 1
+        if queued:
+            self.progress.emit(self._total - self._pending, self._total)
+        return queued
+
+    def wait(self, timeout_ms=30000):
+        """For tests: block until the queue is empty."""
+        return self._pool.waitForDone(timeout_ms)
+
+    def _one_done(self, sample, path, error):
+        self._pending = max(0, self._pending - 1)
+        if sample is None:
+            self.failed.emit(path, error)
+        else:
+            self.loaded.emit(sample)
+        self.progress.emit(self._total - self._pending, self._total)
+        if not self._pending:
+            self._total = 0
+            self.finished.emit()
+
+# Qt calls the handlers here by itself; an error in one is logged and
+# survived rather than the end of the program (`core/log.py`).
+from ..core import log as _log
+_log.guard_classes(globals(), __name__)

dscpanel/ui/numbox.py

@@ -0,0 +1,103 @@
+"""Number boxes that take a sum as well as a number.
+
+"255-20" in a box is 235. Every number box of the program is one of these
+(`NumberBox`, `WholeBox`).
+"""
+
+from PySide6.QtCore import QLocale
+from PySide6.QtGui import QValidator
+from PySide6.QtWidgets import QDoubleSpinBox, QSpinBox
+
+from ..core import numbers
+
+
+class _Sums(object):
+    """A spin box that takes a SUM as well as a number: "255-20" is 235
+    worked out on Enter or when the box is left.
+    `core.numbers.evaluate`: + - * / and brackets, a comma is a decimal
+    point. A sum past the range is clamped to it."""
+
+    def _setup(self):
+        locale = QLocale(QLocale.C)
+        locale.setNumberOptions(QLocale.OmitGroupSeparator)
+        self.setLocale(locale)
+        self.setKeyboardTracking(False)
+
+    def _core(self, text):
+        """The typed text without the box's prefix and suffix."""
+        text = str(text).strip()
+        suffix, prefix = self.suffix().strip(), self.prefix().strip()
+        if suffix and text.endswith(suffix):
+            text = text[:-len(suffix)]
+        if prefix and text.startswith(prefix):
+            text = text[len(prefix):]
+        return text.strip()
+
+    def _sum(self, text):
+        """The value of a typed sum, clamped; None if it is not one."""
+        core = self._core(text)
+        if not numbers.is_sum(core):
+            return None
+        value = numbers.evaluate(core)
+        if value is None:
+            return None
+        return min(max(value, self.minimum()), self.maximum())
+
+    def validate(self, text, pos):
+        core = self._core(text)
+        if numbers.is_sum(core):
+            # Still being typed ("255-") is fine; Enter works it out.
+            state = (QValidator.Acceptable
+                     if numbers.evaluate(core) is not None
+                     else QValidator.Intermediate)
+            return state, text, pos
+        state, _fixed, position = self._base.validate(
+            self, self._normalise(text), pos)
+        return state, text, position
+
+    def valueFromText(self, text):
+        value = self._sum(text)
+        if value is not None:
+            return self._cast(value)
+        return self._base.valueFromText(self, self._normalise(text))
+
+    def fixup(self, text):
+        value = self._sum(text)
+        if value is not None:
+            return self.textFromValue(self._cast(value))
+        return text
+
+    @staticmethod
+    def _normalise(text):
+        return str(text).strip().replace(",", ".")
+
+
+class NumberBox(_Sums, QDoubleSpinBox):
+    """A spin box that reads "1.5" and "1,5" alike, takes a sum, and
+    commits on Enter."""
+
+    _base = QDoubleSpinBox
+    _cast = float
+
+    def __init__(self, parent=None):
+        QDoubleSpinBox.__init__(self, parent)
+        self._setup()
+
+
+class WholeBox(_Sums, QSpinBox):
+    """`NumberBox` for whole numbers: a sum is rounded."""
+
+    _base = QSpinBox
+
+    def __init__(self, parent=None):
+        QSpinBox.__init__(self, parent)
+        self._setup()
+
+    @staticmethod
+    def _cast(value):
+        return int(round(value))
+
+# Qt calls the handlers here by itself; an error in one is logged and
+# survived rather than the end of the program (`core/log.py`).
+from ..core import log as _log
+_log.guard_classes(globals(), __name__)