datalab-platform 0.0.1.dev0__py3-none-any.whl → 1.0.1__py3-none-any.whl

datalab/widgets/signaldeltax.py

@@ -0,0 +1,151 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+GUI dialog for analyzing signals and calculating full width at Y.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING
+
+import numpy as np
+from guidata.configtools import get_icon
+from plotpy.builder import make
+from plotpy.plot import PlotDialog
+from qtpy import QtGui as QG
+from qtpy import QtWidgets as QW
+from sigima.tools.signal.pulse import full_width_at_y
+
+from datalab.adapters_plotpy import CURVESTYLES, create_adapter_from_object
+from datalab.config import _
+from datalab.utils.qthelpers import resize_widget_to_parent
+
+if TYPE_CHECKING:
+    from plotpy.items import CurveItem, Marker, XRangeSelection
+    from qtpy.QtWidgets import QWidget
+    from sigima.objects import SignalObj
+
+
+class SignalDeltaXDialog(PlotDialog):
+    """Signal Delta X dialog.
+
+    Args:
+        signal: signal object
+        parent: parent widget. Defaults to None.
+    """
+
+    def __init__(self, signal: SignalObj, parent: QWidget | None = None) -> None:
+        self.__curve_styles = CURVESTYLES.style_generator()
+        self.__signal = signal
+        self.__coords: list[float, float, float, float] | None = None
+        self.curve: CurveItem | None = None
+        self.hcursor: Marker | None = None
+        self.delta_xrange: XRangeSelection | None = None
+        self.deltaxlineedit: QW.QLineEdit | None = None
+        self.ylineedit: QW.QLineEdit | None = None
+        title = _("Select Y value with cursor")
+        super().__init__(title=title, edit=True, parent=parent)
+        self.setObjectName("SignalCursorDialog")
+        if parent is None:
+            self.setWindowIcon(get_icon("DataLab.svg"))
+        legend = make.legend("TR")
+        self.get_plot().add_item(legend)
+        self.__setup_dialog()
+        resize_widget_to_parent(self, aspect_ratio=1.0)
+
+    def __setup_dialog(self) -> None:
+        """Setup dialog box"""
+        apply_button = QW.QPushButton(_("Apply"))
+        apply_button.setIcon(get_icon("apply.svg"))
+        apply_button.setToolTip(_("Apply cursor position"))
+        xlabel = QW.QLabel("∆X=")
+        ylabel = QW.QLabel("Y=")
+        self.deltaxlineedit = QW.QLineEdit()
+        self.deltaxlineedit.setReadOnly(True)
+        self.deltaxlineedit.setDisabled(True)
+        self.ylineedit = QW.QLineEdit()
+        self.ylineedit.editingFinished.connect(self.ylineedit_editing_finished)
+        self.ylineedit.setValidator(QG.QDoubleValidator())
+        xygroup = QW.QGroupBox(_("Cursor position"))
+        xylayout = QW.QHBoxLayout()
+        xylayout.addWidget(xlabel)
+        xylayout.addWidget(self.deltaxlineedit)
+        xylayout.addWidget(ylabel)
+        xylayout.addWidget(self.ylineedit)
+        xylayout.addWidget(apply_button)
+        vlayout = QW.QVBoxLayout()
+        vlayout.addLayout(xylayout)
+        self.warning_label = QW.QLabel()
+        vlayout.addWidget(self.warning_label)
+        apply_button.clicked.connect(self.ylineedit_editing_finished)
+        xygroup.setLayout(vlayout)
+        self.button_layout.insertWidget(0, xygroup)
+
+        obj = self.__signal
+        with CURVESTYLES.alternative(self.__curve_styles):
+            self.curve = create_adapter_from_object(obj).make_item()
+        plot = self.get_plot()
+        plot.set_antialiasing(True)
+
+        self.delta_xrange = make.xrange(0.0, 1.0)
+        self.delta_xrange.setVisible(False)
+        self.delta_xrange.set_style("roi", "s/readonly")
+        self.delta_xrange.set_selectable(False)
+
+        plot.SIG_MARKER_CHANGED.connect(self.cursor_changed)
+        self.hcursor = make.hcursor(np.mean(obj.y), "Y = %g")
+        for item in (self.curve, self.delta_xrange, self.hcursor):
+            plot.add_item(item)
+        plot.replot()
+        plot.set_active_item(self.hcursor)
+        self.cursor_changed(self.hcursor)
+
+    def cursor_changed(self, item: Marker) -> None:
+        """Cursor changed"""
+        sig = self.__signal
+        _x, y = item.get_pos()
+
+        try:
+            with warnings.catch_warnings(record=True) as w:
+                self.__coords = full_width_at_y(sig.x, sig.y, y)
+                if np.nan in self.__coords:
+                    raise ValueError("Invalid coordinates")
+                delta_str = f"{self.__coords[2] - self.__coords[0]:g}"
+                ok = True
+                if len(w) > 0:
+                    self.warning_label.setText("⚠️ " + str(w[-1].message))
+                else:
+                    self.warning_label.setText("")
+                self.delta_xrange.setVisible(True)
+                self.delta_xrange.set_range(self.__coords[0], self.__coords[2])
+        except ValueError:
+            delta_str = ""
+            ok = False
+            self.delta_xrange.setVisible(False)
+
+        self.button_box.button(QW.QDialogButtonBox.Ok).setEnabled(ok)
+        self.deltaxlineedit.setText(delta_str)
+        self.ylineedit.setText(f"{y:g}" if y is not None else "")
+
+    def ylineedit_editing_finished(self) -> None:
+        """Y line edit editing finished"""
+        try:
+            y = float(self.ylineedit.text())
+            x, _y = self.hcursor.get_pos()
+            self.hcursor.set_pos(x, y)
+        except ValueError:
+            pass
+        plot = self.get_plot()
+        plot.replot()
+
+    def get_coords(self) -> tuple[float, float, float, float]:
+        """Return coordinates of segment associated to the width at Y"""
+        return self.__coords
+
+    def get_y_value(self) -> float:
+        """Get cursor y value"""
+        _x, y = self.hcursor.get_pos()
+        return y

datalab/widgets/signalpeak.py

@@ -0,0 +1,199 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Signal peak detection feature"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from guidata.configtools import get_icon
+from plotpy.builder import make
+from plotpy.plot import PlotDialog
+from qtpy import QtCore as QC
+from qtpy import QtWidgets as QW
+from sigima.tools.signal.peakdetection import peak_indices
+
+from datalab.adapters_plotpy import CURVESTYLES, create_adapter_from_object
+from datalab.config import _
+from datalab.utils.qthelpers import resize_widget_to_parent
+
+if TYPE_CHECKING:
+    from plotpy.items import Marker
+    from qtpy.QtWidgets import QWidget
+    from sigima.objects import SignalObj
+
+
+class DistanceSlider(QW.QWidget):
+    """Minimum distance slider
+
+    Args:
+        parent: parent widget. Defaults to None.
+    """
+
+    TITLE = _("Minimum distance:")
+    SIG_VALUE_CHANGED = QC.Signal(int)
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self.slider = QW.QSlider(QC.Qt.Horizontal)
+        self.label = QW.QLabel()
+        layout = QW.QHBoxLayout()
+        layout.addWidget(self.label)
+        layout.addWidget(self.slider)
+        self.setLayout(layout)
+
+    def value_changed(self, value: int) -> None:
+        """Slider value has changed
+
+        Args:
+            value: slider value
+        """
+        plural = "s" if value > 1 else ""
+        self.label.setText(f"{self.TITLE} {value} point{plural}")
+        self.SIG_VALUE_CHANGED.emit(value)
+
+    def setup_slider(self, value: int, maxval: int) -> None:
+        """Setup slider
+
+        Args:
+            value: initial value
+            maxval: maximum value
+        """
+        self.slider.setMinimum(1)
+        self.slider.setMaximum(maxval)
+        self.slider.setValue(value)
+        self.slider.setTickPosition(QW.QSlider.TicksBothSides)
+        self.value_changed(value)
+        self.slider.valueChanged.connect(self.value_changed)
+
+
+class SignalPeakDetectionDialog(PlotDialog):
+    """Signal Peak detection dialog
+
+    Args:
+        signal: signal object
+        parent: parent widget. Defaults to None.
+    """
+
+    def __init__(self, signal: SignalObj, parent: QWidget | None = None) -> None:
+        self.__curve_styles = CURVESTYLES.style_generator()
+        self.peaks = None
+        self.peak_indices = None
+        self.in_curve = None
+        self.in_threshold = None
+        self.in_threshold_cursor = None
+        self.co_results = None
+        self.co_positions = None
+        self.co_markers = None
+        self.min_distance = None
+        self.distance_slider: DistanceSlider | None = None
+        super().__init__(title=_("Signal peak detection"), edit=True, parent=parent)
+        self.setObjectName("peakdetection")
+        if parent is None:
+            self.setWindowIcon(get_icon("DataLab.svg"))
+        legend = make.legend("TR")
+        self.get_plot().add_item(legend)
+        self.__signal = signal.copy()
+        self.__setup_dialog()
+        resize_widget_to_parent(self, parent, aspect_ratio=1.0)
+
+    def populate_plot_layout(self) -> None:  # Reimplement PlotDialog method
+        """Populate the plot layout"""
+        super().populate_plot_layout()
+        self.distance_slider = DistanceSlider(self)
+        self.add_widget(self.distance_slider, 1, 0, 1, 1)
+
+    def __setup_dialog(self) -> None:
+        """Setup dialog box"""
+        obj = self.__signal
+        with CURVESTYLES.alternative(self.__curve_styles):
+            self.in_curve = create_adapter_from_object(obj).make_item()
+        plot = self.get_plot()
+        plot.set_antialiasing(True)
+        plot.add_item(self.in_curve)
+        self.in_threshold = 0.5 * (np.max(obj.y) - np.min(obj.y)) + np.min(obj.y)
+        cursor = make.hcursor(self.in_threshold)
+        self.in_threshold_cursor = cursor
+        plot.add_item(self.in_threshold_cursor)
+        self.co_results = make.label("", "TL", (0, 0), "TL")
+        plot.add_item(self.co_results)
+        plot.SIG_MARKER_CHANGED.connect(self.hcursor_changed)
+        self.min_distance = 1
+        self.distance_slider.setup_slider(self.min_distance, len(obj.y) // 4)
+        self.distance_slider.SIG_VALUE_CHANGED.connect(self.minimum_distance_changed)
+        self.compute_peaks()
+        # Replot, otherwise, it's not possible to set active item:
+        plot.replot()
+        plot.set_active_item(cursor)
+
+    def get_peaks(self) -> list[tuple[float, float]]:
+        """Return peaks coordinates"""
+        return self.peaks
+
+    def get_peak_indices(self) -> list[int]:
+        """Return peak indices"""
+        return self.peak_indices
+
+    def get_threshold(self) -> float:
+        """Return relative threshold"""
+        y = self.__signal.y
+        return (self.in_threshold - np.min(y)) / (np.max(y) - np.min(y))
+
+    def get_min_dist(self) -> int:
+        """Return minimum distance"""
+        return self.min_distance
+
+    def compute_peaks(self) -> None:
+        """Compute peak detection"""
+        x, y = self.__signal.xydata
+        plot = self.get_plot()
+        self.peak_indices = peak_indices(
+            y,
+            thres=self.in_threshold,
+            min_dist=self.min_distance,
+            thres_abs=True,
+        )
+        self.peaks = [(x[index], y[index]) for index in self.peak_indices]
+        markers = [
+            make.marker(
+                pos,
+                movable=False,
+                color="orange",
+                markerstyle="|",
+                linewidth=1,
+                marker="NoSymbol",
+                linestyle="DashLine",
+            )
+            for pos in self.peaks
+        ]
+        if self.co_markers is not None:
+            plot.del_items(self.co_markers)
+        self.co_markers = markers
+        for item in self.co_markers:
+            plot.add_item(item)
+        positions = [str(marker.get_pos()[0]) for marker in markers]
+        prefix = f"<b>{_('Peaks:')}</b><br>"
+        self.co_results.set_text(prefix + "<br>".join(positions))
+
+    def hcursor_changed(self, marker: Marker) -> None:
+        """Horizontal cursor position has changed
+
+        Args:
+            marker: marker item
+        """
+        _x, y = marker.get_pos()
+        self.in_threshold = y
+        self.compute_peaks()
+
+    def minimum_distance_changed(self, value: int) -> None:
+        """Minimum distance changed
+
+        Args:
+            value: minimum distance value
+        """
+        self.min_distance = value
+        self.compute_peaks()
+        self.get_plot().replot()

datalab/widgets/status.py

@@ -0,0 +1,249 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+DataLab main window status bar widgets
+"""
+
+from __future__ import annotations
+
+import os
+
+import psutil
+from guidata.configtools import get_icon
+from guidata.qthelpers import get_std_icon
+from qtpy import QtCore as QC
+from qtpy import QtGui as QG
+from qtpy import QtWidgets as QW
+
+from datalab.config import DEBUG, Conf, _
+from datalab.env import execenv
+from datalab.plugins import PluginRegistry
+
+
+class BaseStatus(QW.QWidget):
+    """Base status widget.
+
+    Args:
+        delay (int | None): update interval (s). If None, widget will not be updated.
+        parent (QWidget): parent widget
+    """
+
+    def __init__(
+        self, delay: int | None = None, parent: QW.QWidget | None = None
+    ) -> None:
+        super().__init__(parent)
+        layout = QW.QHBoxLayout()
+        layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(layout)
+        self.icon = QW.QLabel()
+        self.label = QW.QLabel()
+        layout.addWidget(self.icon)
+        layout.addWidget(self.label)
+        if delay is not None:
+            self.timer = QC.QTimer()
+            self.timer.timeout.connect(self.update_status)
+            self.timer.start(delay * 1000)
+
+    def set_icon(self, icon: QG.QIcon | str | None) -> None:
+        """Set icon.
+
+        Args:
+            icon (QIcon | None): icon
+        """
+        size = self.label.sizeHint().height()
+        if isinstance(icon, str):
+            icon = get_icon(icon)
+        pixmap = QG.QPixmap() if icon is None else icon.pixmap(size, size)
+        self.icon.setPixmap(pixmap)
+
+    def update_status(self) -> None:
+        """Update status widget"""
+        raise NotImplementedError
+
+
+class ConsoleStatus(BaseStatus):
+    """Console status widget.
+
+    Shows a message if an error or warning has been logged to the console.
+    Shows a button to show the console, only if the console is hidden.
+
+    Args:
+        parent (QWidget): parent widget
+    """
+
+    SIG_SHOW_CONSOLE = QC.Signal()
+
+    def __init__(self, parent: QW.QWidget | None = None) -> None:
+        super().__init__(None, parent)
+        self.label.setText(_("Internal console"))
+        self.label.setToolTip(
+            _(
+                "Click to show the internal console.\n"
+                "The icon will turn red if an error or warning is logged."
+            )
+        )
+        self.label.setCursor(QG.QCursor(QC.Qt.PointingHandCursor))
+        self.label.mouseReleaseEvent = self.on_click
+        self.ok_icon = get_std_icon("MessageBoxInformation")
+        self.ko_icon = get_std_icon("MessageBoxWarning")
+        self.has_errors = False
+        self.update_status()
+
+    def on_click(self, event: QG.QMouseEvent) -> None:
+        """Handle mouse click event on label.
+
+        Args:
+            event: mouse event
+        """
+        if event.button() == QC.Qt.LeftButton:
+            self.SIG_SHOW_CONSOLE.emit()
+
+    def console_visibility_changed(self, visible: bool) -> None:
+        """Handle console visibility changed event.
+
+        Args:
+            visible (bool): console visibility
+        """
+        if visible:
+            # Hide this status widget when console is visible
+            self.hide()
+        else:
+            self.show()
+            self.update_status()
+
+    def exception_occurred(self) -> None:
+        """Handle exception occurred event"""
+        self.has_errors = True
+        self.update_status()
+
+    def update_status(self) -> None:
+        """Update status widget"""
+        if self.has_errors:
+            self.set_icon(self.ko_icon)
+            self.label.setStyleSheet("color: red")
+            self.label.setToolTip(
+                _(
+                    "Click to show the internal console.\n"
+                    "An error or warning has been logged."
+                )
+            )
+        else:
+            self.set_icon(self.ok_icon)
+            self.label.setStyleSheet("")
+            self.label.setToolTip(
+                _(
+                    "Click to show the internal console.\n"
+                    "No error or warning has been logged."
+                )
+            )
+
+
+class MemoryStatus(BaseStatus):
+    """Memory status widget.
+
+    Args:
+        threshold (int): available memory thresold (MB)
+        delay (int): update interval (s)
+        parent (QWidget): parent widget
+    """
+
+    SIG_MEMORY_ALARM = QC.Signal(bool)
+
+    def __init__(
+        self, threshold: int = 500, delay: int = 2, parent: QW.QWidget | None = None
+    ) -> None:
+        super().__init__(delay, parent)
+        self.demo_mode = False
+        self.ko_icon = get_std_icon("MessageBoxWarning")
+        self.__threshold = threshold * (1024**2)
+        self.label.setMinimumWidth(self.label.fontMetrics().width("000%"))
+        self.update_status()
+
+    def set_demo_mode(self, state: bool) -> None:
+        """Set demo mode state (used when taking screenshots).
+        The demo mode allows to take screenshots which always look the same.
+        (this will set memory usage to a constant value).
+        If demo mode is set to False, memory usage will be set to actual value.
+
+        Args:
+            state (bool): demo mode state
+        """
+        self.demo_mode = state
+        self.update_status()
+
+    def update_status(self) -> None:
+        """Update status widget"""
+        mem = psutil.virtual_memory()
+        memok = mem.available > self.__threshold
+        self.SIG_MEMORY_ALARM.emit(not memok)
+        txtlist = [
+            f"%s {mem.available // (1024**2)} MB" % _("Memory available:"),
+            f"%s {mem.used // (1024**2)} MB" % _("Memory used:"),
+            f"%s {self.__threshold // (1024**2)} MB" % _("Alarm threshold:"),
+        ]
+        txt = os.linesep.join(txtlist)
+        self.setToolTip(txt)
+        if DEBUG and not memok:
+            execenv.log(self, txt)
+        self.label.setStyleSheet("" if memok else "color: red")
+        self.set_icon("libre-tech-ram.svg" if memok else self.ko_icon)
+        mem_percent = 65 if self.demo_mode else int(mem.percent)
+        self.label.setText(_("Memory:") + f" {mem_percent}%")
+
+
+class PluginStatus(BaseStatus):
+    """Plugin status widget.
+    Shows the number of plugins loaded.
+
+    Args:
+        parent (QWidget): parent widget
+    """
+
+    def __init__(self, parent: QW.QWidget | None = None) -> None:
+        super().__init__(None, parent)
+        self.set_icon("libre-gui-plugin.svg")
+        self.update_status()
+
+    def update_status(self) -> None:
+        """Update status widget"""
+        text = _("Plugins:") + " "
+        if Conf.main.plugins_enabled.get():
+            nplugins = len(PluginRegistry.get_plugins())
+            text += str(nplugins)
+        else:
+            text += "-"
+        self.label.setText(text)
+        self.setToolTip(PluginRegistry.get_plugin_info())
+
+
+class XMLRPCStatus(BaseStatus):
+    """XML-RPC status widget.
+    Shows the XML-RPC server status and port number.
+
+    Args:
+        parent (QWidget): parent widget
+    """
+
+    def __init__(self, parent: QW.QWidget | None = None) -> None:
+        super().__init__(None, parent)
+        self.port: int | None = None
+
+    def set_port(self, port: int | None):
+        """Set XML-RPC server port number.
+
+        Args:
+            port (int | None): XML-RPC server port number.
+                If None, XML-RPC server is disabled.
+        """
+        self.port = port
+        self.update_status()
+
+    def update_status(self) -> None:
+        """Update status widget"""
+        text = _("XML-RPC:") + " "
+        if self.port is None:
+            self.label.setText(text + "-")
+            self.set_icon("libre-gui-unlink.svg")
+        else:
+            self.label.setText(text + str(self.port))
+            self.set_icon("libre-gui-link.svg")