Allow disabling stats calculation (#36)

Add an API to the stats calculator table to disable calculation and
plumb this through to the CSV viewer. This can reduce latency when
capturing long data sets.

Author: ducky64

pyqtgraph_scope_plots/csv/csv_plots.py

@@ -247,6 +247,10 @@ def _on_line_width_action(self) -> None:
         self._plots.set_thickness(value)
         self._table.set_thickness(value)
 
+    def _on_disable_stats(self, checked: bool) -> None:
+        assert isinstance(self._table, StatsSignalsTable)
+        self._table.disable_stats(checked)
+
     def _make_controls(self) -> QWidget:
         button_load = QToolButton()
         button_load.setText("Load CSV")
@@ -295,6 +299,10 @@ def _make_controls(self) -> QWidget:
         line_width_action = QAction("Set Line Width", button_menu)
         line_width_action.triggered.connect(self._on_line_width_action)
         button_menu.addAction(line_width_action)
+        self._disable_stats_action = QAction("Disable Stats", button_menu)
+        self._disable_stats_action.setCheckable(True)
+        self._disable_stats_action.toggled.connect(self._on_disable_stats)
+        button_menu.addAction(self._disable_stats_action)
         animation_action = QAction("Create Animation", button_menu)
         animation_action.triggered.connect(partial(self._start_animation_ui_flow, ""))
         button_menu.addAction(animation_action)
@@ -503,6 +511,8 @@ def _do_load_config(self, filename: str, model: CsvLoaderStateModel) -> None:
         data = self._data
         self._set_data({})  # blank the data while updates happen, for performance
         self._load_model(model)
+        assert isinstance(self._table, StatsSignalsTable)
+        self._disable_stats_action.setChecked(self._table.stats_disabled())
 
         # force-update data items and data
         data_items = [(name, int_color(i), data_type) for i, (name, data_type) in enumerate(self._data_items.items())]

pyqtgraph_scope_plots/stats_signals_table.py

@@ -15,18 +15,23 @@
 import math
 import time
 import weakref
-from typing import Dict, Tuple, List, Any
+from typing import Dict, Tuple, List, Any, Optional
 
 import numpy as np
 import numpy.typing as npt
-from PySide6.QtCore import Signal, QThread, QMutex, QMutexLocker, QThreadPool, QRunnable, QObject
+from PySide6.QtCore import Signal, QThread, QMutex, QMutexLocker, QThreadPool, QRunnable, QObject, Qt
 from PySide6.QtWidgets import QTableWidgetItem
+from pydantic import BaseModel
 
 from .signals_table import HasRegionSignalsTable
-from .util import IdentityCacheDict, not_none
+from .util import IdentityCacheDict, HasSaveLoadDataConfig, not_none
 
 
-class StatsSignalsTable(HasRegionSignalsTable):
+class StatsTableStateModel(BaseModel):
+    stats_disabled: Optional[bool] = None
+
+
+class StatsSignalsTable(HasRegionSignalsTable, HasSaveLoadDataConfig):
     """Mixin into SignalsTable with statistics rows. Optional range to specify computation of statistics.
     Values passed into set_data must all be numeric."""
 
@@ -44,6 +49,8 @@ class StatsSignalsTable(HasRegionSignalsTable):
         COL_STAT_STDEV,
     ]
 
+    _MODEL_BASES = [StatsTableStateModel]
+
     _FULL_RANGE = (-float("inf"), float("inf"))
 
     class StatsCalculatorSignals(QObject):
@@ -80,6 +87,8 @@ def run(self) -> None:
                 self._parent._last_region = request_region
 
             for xs_ys_ref in request_data:
+                if self._parent._stats_calculation_disabled:  # terminate if disabled
+                    return
                 with QMutexLocker(self._parent._request_mutex):
                     if self._parent._debounce_target_ns != debounce_target_ns:
                         return
@@ -125,6 +134,8 @@ def _init_table(self) -> None:
         self.setHorizontalHeaderItem(self.COL_STAT + self.COL_STAT_STDEV, QTableWidgetItem("StDev"))
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self._stats_calculation_disabled = False
+
         super().__init__(*args, **kwargs)
         # since calculating stats across the full range is VERY EXPENSIVE, cache the results
         self._full_range_stats = IdentityCacheDict[npt.NDArray[np.float64], Dict[int, float]]()  # array -> stats dict
@@ -148,6 +159,43 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
         self._stats_signals = self.StatsCalculatorSignals()
         self._stats_signals.update.connect(self._on_stats_updated)
 
+    def _update(self) -> None:
+        super()._update()
+        self._update_stats_disabled()
+
+    def _write_model(self, model: BaseModel) -> None:
+        assert isinstance(model, StatsTableStateModel)
+        super()._write_model(model)
+        model.stats_disabled = self._stats_calculation_disabled
+
+    def _load_model(self, model: BaseModel) -> None:
+        assert isinstance(model, StatsTableStateModel)
+        super()._load_model(model)
+        if model.stats_disabled is not None:
+            self.disable_stats(model.stats_disabled)
+
+    def stats_disabled(self) -> bool:
+        """Returns whether stats calculation is disabled."""
+        return self._stats_calculation_disabled
+
+    def disable_stats(self, disable: bool = True) -> None:
+        """Call this to disable stats calculation and to blank the table, or re-enable the calculation."""
+        self._stats_calculation_disabled = disable
+        self._update_stats_disabled()
+        if not disable:
+            self._update_stats_task(0, True)  # populate the table again
+
+    def _update_stats_disabled(self) -> None:
+        """Updates the table visuals for stats disabled"""
+        for row, name in enumerate(self._data_items.keys()):
+            for col in self.STATS_COLS:
+                item = not_none(self.item(row, self.COL_STAT + col))
+                if self._stats_calculation_disabled:  # clear table on disable
+                    item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEnabled)
+                    item.setText("")
+                else:
+                    item.setFlags(item.flags() | Qt.ItemFlag.ItemIsEnabled)
+
     def _on_stats_updated(
         self, input_arr: npt.NDArray[np.float64], input_region: Tuple[float, float], stats_dict: Dict[int, float]
     ) -> None:
@@ -160,6 +208,9 @@ def _on_stats_updated(
             self._update_stats_display(False)
 
     def _update_stats_task(self, delay_ms: int, clear_table: bool) -> None:
+        if self._stats_calculation_disabled:  # don't create a calculation task if disabled
+            return
+
         region = HasRegionSignalsTable._region_of_plot(self._plots)
         data_items = [  # filter out enum types
             (name, (xs, ys)) for name, (xs, ys) in self._plots._data.items() if np.issubdtype(ys.dtype, np.number)
@@ -183,6 +234,9 @@ def _update_stats_task(self, delay_ms: int, clear_table: bool) -> None:
         self._update_stats_display(clear_table)
 
     def _update_stats_display(self, clear_table: bool) -> None:
+        if self._stats_calculation_disabled:  # don't update the display if disabled
+            return
+
         for row, name in enumerate(self._data_items.keys()):
             xs, ys = self._plots._data.get(name, (None, None))
             if xs is None or ys is None:

tests/test_stats_table.py

@@ -11,12 +11,14 @@
 #    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
+from typing import cast
 
 import pytest
 from pytestqt.qtbot import QtBot
 
 
 from pyqtgraph_scope_plots import LinkedMultiPlotWidget, StatsSignalsTable
+from pyqtgraph_scope_plots.stats_signals_table import StatsTableStateModel
 from .common_testdata import DATA_ITEMS, DATA
 
 
@@ -90,3 +92,38 @@ def test_region_empty(qtbot: QtBot, table: StatsSignalsTable) -> None:
     assert table.item(2, table.COL_STAT + table.COL_STAT_AVG).text() == ""
     assert table.item(2, table.COL_STAT + table.COL_STAT_RMS).text() == ""
     assert table.item(2, table.COL_STAT + table.COL_STAT_STDEV).text() == ""
+
+
+def test_disable_enable(qtbot: QtBot, table: StatsSignalsTable) -> None:
+    qtbot.waitUntil(lambda: table.item(0, table.COL_STAT + table.COL_STAT_MIN).text() != "")
+
+    table.disable_stats(True)
+    qtbot.waitUntil(lambda: table.item(0, table.COL_STAT + table.COL_STAT_MIN).text() == "")
+    for row in [0, 1, 2]:
+        for col in table.STATS_COLS:
+            assert table.item(row, table.COL_STAT + col).text() == ""
+
+    table.disable_stats(False)
+    qtbot.waitUntil(lambda: table.item(0, table.COL_STAT + table.COL_STAT_MIN).text() != "")
+
+
+def test_stats_table_save(qtbot: QtBot, table: StatsSignalsTable) -> None:
+    assert cast(StatsTableStateModel, table._dump_data_model([])).stats_disabled == False
+
+    table.disable_stats(True)
+    assert cast(StatsTableStateModel, table._dump_data_model([])).stats_disabled == True
+
+    table.disable_stats(False)
+    assert cast(StatsTableStateModel, table._dump_data_model([])).stats_disabled == False
+
+
+def test_stats_table_load(qtbot: QtBot, table: StatsSignalsTable) -> None:
+    model = cast(StatsTableStateModel, table._dump_data_model([]))
+
+    model.stats_disabled = True
+    table._load_model(model)
+    qtbot.waitUntil(lambda: table.item(0, table.COL_STAT + table.COL_STAT_MIN).text() == "")
+
+    model.stats_disabled = False
+    table._load_model(model)
+    qtbot.waitUntil(lambda: table.item(0, table.COL_STAT + table.COL_STAT_MIN).text() != "")