bec-widgets 0.99.15__py3-none-any.whl → 0.101.0__py3-none-any.whl

CHANGELOG.md

@@ -1,5 +1,29 @@
 # CHANGELOG
 
+## v0.101.0 (2024-09-02)
+
+### Feature
+
+* feat: add Dap dialog widget ([`9781b77`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/9781b77de27b2810fbb1047a61b1832dd186db01))
+
+### Refactor
+
+* refactor: add docs, cleanup ([`61ecf49`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/61ecf491e52bfbfa0d5a84764a9095310659043d))
+
+## v0.100.0 (2024-09-01)
+
+### Documentation
+
+* docs(becwidget): improvements to the bec widget base class docs; fixed type hint import for sphinx ([`99d5e8e`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/99d5e8e71c7f89a53d7967126f4056dde005534c))
+
+### Feature
+
+* feat(theme): added theme handler to bec widget base class; added tests ([`7fb938a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/7fb938a8506685278ee5eeb6fe9a03f74b713cf8))
+
+### Fix
+
+* fix(pyqt slot): removed slot decorator to avoid problems with pyqt6 ([`6c1f89a`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/6c1f89ad39b7240ab1d1c1123422b99ae195bf01))
+
 ## v0.99.15 (2024-08-31)
 
 ### Fix
@@ -129,29 +153,3 @@
 ### Build
 
 * build: updated min version of bec qthemes ([`d482434`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/d48243483ef8228cc5eb85e40a6b8f5da3b45520))
-
-### Fix
-
-* fix(cmaps): unified all defaults to magma cmap ([`1ca9499`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/1ca9499edd334c19fe1e7aac71d3940a80a1ec95))
-
-* fix(color maps): color maps should take the background color into account; fixed min colors to 10 ([`060935f`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/060935ffc5472a958c337bf60834c5291f104ece))
-
-## v0.99.2 (2024-08-27)
-
-### Ci
-
-* ci: additional tests are not allowed to fail ([`bb385f0`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/bb385f07ca18904461a541b5cadde05398c84438))
-
-### Fix
-
-* fix(widgets): fixed default theme for widgets
-
-If not theme is set, the init of the BECWidget base class sets the default theme to "dark" ([`cf28730`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/cf28730515e3c2d5914e0205768734c578711e5c))
-
-## v0.99.1 (2024-08-27)
-
-### Fix
-
-* fix(crosshair): emit all crosshair events, not just line coordinates ([`2265458`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/2265458dcc57970db18c62619f5877d542d72e81))
-
-## v0.99.0 (2024-08-25)

PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bec_widgets
-Version: 0.99.15
+Version: 0.101.0
 Summary: BEC Widgets
 Project-URL: Bug Tracker, https://gitlab.psi.ch/bec/bec_widgets/issues
 Project-URL: Homepage, https://gitlab.psi.ch/bec/bec_widgets

bec_widgets/cli/client.py

@@ -26,6 +26,7 @@ class Widgets(str, enum.Enum):
     DeviceBrowser = "DeviceBrowser"
     DeviceComboBox = "DeviceComboBox"
     DeviceLineEdit = "DeviceLineEdit"
+    LMFitDialog = "LMFitDialog"
     PositionerBox = "PositionerBox"
     PositionerControlLine = "PositionerControlLine"
     ResetButton = "ResetButton"
@@ -1811,6 +1812,15 @@ class BECWaveform(RPCBase):
             BECCurve: The curve object.
         """
 
+    @rpc_call
+    def get_dap_params(self) -> "dict":
+        """
+        Get the DAP parameters of all DAP curves.
+
+        Returns:
+            dict: DAP parameters of all DAP curves.
+        """
+
     @rpc_call
     def set_x(self, x_name: "str", x_entry: "str | None" = None):
         """
@@ -1825,15 +1835,6 @@ class BECWaveform(RPCBase):
             x_entry(str): Entry of the x signal.
         """
 
-    @rpc_call
-    def get_dap_params(self) -> "dict":
-        """
-        Get the DAP parameters of all DAP curves.
-
-        Returns:
-            dict: DAP parameters of all DAP curves.
-        """
-
     @rpc_call
     def remove_curve(self, *identifiers):
         """
@@ -2096,10 +2097,10 @@ class BECWaveformWidget(RPCBase):
         self,
         x_name: "str",
         y_name: "str",
+        dap: "str",
         x_entry: "str | None" = None,
         y_entry: "str | None" = None,
         color: "str | None" = None,
-        dap: "str" = "GaussianModel",
         validate_bec: "bool" = True,
         **kwargs,
     ) -> "BECCurve":
@@ -2313,7 +2314,7 @@ class BECWaveformWidget(RPCBase):
 
 class DarkModeButton(RPCBase):
     @rpc_call
-    def toggle_dark_mode(self) -> None:
+    def toggle_dark_mode(self) -> "None":
         """
         Toggle the dark mode state. This will change the theme of the entire
         application to dark or light mode.
@@ -2392,6 +2393,24 @@ class DeviceLineEdit(RPCBase):
         """
 
 
+class LMFitDialog(RPCBase):
+    @property
+    @rpc_call
+    def _config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+
+        Returns:
+            dict: The configuration of the widget.
+        """
+
+    @rpc_call
+    def _get_all_rpc(self) -> "dict":
+        """
+        Get all registered RPC objects.
+        """
+
+
 class PositionerBox(RPCBase):
     @rpc_call
     def set_positioner(self, positioner: "str | Positioner"):

bec_widgets/qt_utils/toolbar.py

@@ -1,4 +1,6 @@
 # pylint: disable=no-name-in-module
+from __future__ import annotations
+
 import os
 from abc import ABC, abstractmethod
 from collections import defaultdict

bec_widgets/utils/bec_widget.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+from qtpy.QtCore import Slot
 from qtpy.QtWidgets import QApplication, QWidget
 
 from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
@@ -11,7 +14,30 @@ class BECWidget(BECConnector):
     # from fonts.google.com/icons. Override this in subclasses to set the icon name.
     ICON_NAME = "widgets"
 
-    def __init__(self, client=None, config: ConnectionConfig = None, gui_id: str = None):
+    def __init__(
+        self,
+        client=None,
+        config: ConnectionConfig = None,
+        gui_id: str = None,
+        theme_update: bool = False,
+    ):
+        """
+        Base class for all BEC widgets. This class should be used as a mixin class for all BEC widgets, e.g.:
+
+
+        >>> class MyWidget(BECWidget, QWidget):
+        >>>     def __init__(self, parent=None, client=None, config=None, gui_id=None):
+        >>>         super().__init__(client=client, config=config, gui_id=gui_id)
+        >>>         QWidget.__init__(self, parent=parent)
+
+
+        Args:
+            client(BECClient, optional): The BEC client.
+            config(ConnectionConfig, optional): The connection configuration.
+            gui_id(str, optional): The GUI ID.
+            theme_update(bool, optional): Whether to subscribe to theme updates. Defaults to False. When set to True, the
+                widget's apply_theme method will be called when the theme changes.
+        """
         if not isinstance(self, QWidget):
             raise RuntimeError(f"{repr(self)} is not a subclass of QWidget")
         super().__init__(client, config, gui_id)
@@ -19,7 +45,35 @@ class BECWidget(BECConnector):
         # Set the theme to auto if it is not set yet
         app = QApplication.instance()
         if not hasattr(app, "theme"):
-            set_theme("dark")
+            set_theme("auto")
+
+        if theme_update:
+            self._connect_to_theme_change()
+
+    def _connect_to_theme_change(self):
+        """Connect to the theme change signal."""
+        qapp = QApplication.instance()
+        if hasattr(qapp, "theme_signal"):
+            qapp.theme_signal.theme_updated.connect(self._update_theme)
+
+    def _update_theme(self, theme: str):
+        """Update the theme."""
+        if theme is None:
+            qapp = QApplication.instance()
+            if hasattr(qapp, "theme"):
+                theme = qapp.theme["theme"]
+            else:
+                theme = "dark"
+        self.apply_theme(theme)
+
+    @Slot(str)
+    def apply_theme(self, theme: str):
+        """
+        Apply the theme to the widget.
+
+        Args:
+            theme(str, optional): The theme to be applied.
+        """
 
     def cleanup(self):
         """Cleanup the widget."""

bec_widgets/utils/colors.py

@@ -19,6 +19,17 @@ def get_theme_palette():
     return bec_qthemes.load_palette(theme)
 
 
+def _theme_update_callback():
+    """
+    Internal callback function to update the theme based on the system theme.
+    """
+    app = QApplication.instance()
+    # pylint: disable=protected-access
+    app.theme["theme"] = app.os_listener._theme.lower()
+    app.theme_signal.theme_updated.emit(app.theme["theme"])
+    apply_theme(app.os_listener._theme.lower())
+
+
 def set_theme(theme: Literal["dark", "light", "auto"]):
     """
     Set the theme for the application.
@@ -27,23 +38,17 @@ def set_theme(theme: Literal["dark", "light", "auto"]):
         theme (Literal["dark", "light", "auto"]): The theme to set. "auto" will automatically switch between dark and light themes based on the system theme.
     """
     app = QApplication.instance()
-    bec_qthemes.setup_theme(theme)
-    pg.setConfigOption("background", "w" if app.theme["theme"] == "light" else "k")
+    bec_qthemes.setup_theme(theme, install_event_filter=False)
+
     app.theme_signal.theme_updated.emit(theme)
     apply_theme(theme)
 
-    # pylint: disable=protected-access
     if theme != "auto":
         return
 
-    def callback():
-        app.theme["theme"] = listener._theme.lower()
-        app.theme_signal.theme_updated.emit(app.theme["theme"])
-        apply_theme(listener._theme.lower())
-
-    listener = OSThemeSwitchListener(callback)
-
-    app.installEventFilter(listener)
+    if not hasattr(app, "os_listener") or app.os_listener is None:
+        app.os_listener = OSThemeSwitchListener(_theme_update_callback)
+        app.installEventFilter(app.os_listener)
 
 
 def apply_theme(theme: Literal["dark", "light"]):
@@ -55,21 +60,12 @@ def apply_theme(theme: Literal["dark", "light"]):
     children = itertools.chain.from_iterable(
         top.findChildren(pg.GraphicsLayoutWidget) for top in app.topLevelWidgets()
     )
-    pg.setConfigOptions(foreground="d" if theme == "dark" else "k")
+    pg.setConfigOptions(
+        foreground="d" if theme == "dark" else "k", background="k" if theme == "dark" else "w"
+    )
     for pg_widget in children:
         pg_widget.setBackground("k" if theme == "dark" else "w")
 
-    dark_mode_buttons = [
-        button
-        for button in app.topLevelWidgets()
-        if hasattr(button, "dark_mode_enabled")
-        and hasattr(button, "mode_button")
-        and isinstance(button.mode_button, (QPushButton, QToolButton))
-    ]
-
-    for button in dark_mode_buttons:
-        button.dark_mode_enabled = theme == "dark"
-        button.update_mode_button()
     # now define stylesheet according to theme and apply it
     style = bec_qthemes.load_stylesheet(theme)
     app.setStyleSheet(style)

bec_widgets/widgets/dark_mode_button/dark_mode_button.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from bec_qthemes import material_icon
 from qtpy.QtCore import Property, Qt, Slot
 from qtpy.QtWidgets import QApplication, QHBoxLayout, QPushButton, QToolButton, QWidget
@@ -18,7 +20,7 @@ class DarkModeButton(BECWidget, QWidget):
         gui_id: str | None = None,
         toolbar: bool = False,
     ) -> None:
-        super().__init__(client=client, gui_id=gui_id)
+        super().__init__(client=client, gui_id=gui_id, theme_update=True)
         QWidget.__init__(self, parent)
 
         self._dark_mode_enabled = False
@@ -39,6 +41,17 @@ class DarkModeButton(BECWidget, QWidget):
         self.setLayout(self.layout)
         self.setFixedSize(40, 40)
 
+    @Slot(str)
+    def apply_theme(self, theme: str):
+        """
+        Apply the theme to the widget.
+
+        Args:
+            theme(str, optional): The theme to be applied.
+        """
+        self.dark_mode_enabled = theme == "dark"
+        self.update_mode_button()
+
     def _get_qapp_dark_mode_state(self) -> bool:
         """
         Get the dark mode state from the QApplication.

bec_widgets/widgets/figure/plots/plot_base.py

@@ -99,30 +99,32 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
 
         self.add_legend()
         self.crosshair = None
-        self.connect_to_theme_change()
-        self.apply_theme()
+        self._connect_to_theme_change()
 
-    def connect_to_theme_change(self):
+    def _connect_to_theme_change(self):
         """Connect to the theme change signal."""
         qapp = QApplication.instance()
         if hasattr(qapp, "theme_signal"):
-            qapp.theme_signal.theme_updated.connect(self.apply_theme)
+            qapp.theme_signal.theme_updated.connect(self._update_theme)
 
     @Slot(str)
-    @Slot()
-    def apply_theme(self, theme: str | None = None):
-        """
-        Apply the theme to the plot widget.
-
-        Args:
-            theme(str, optional): The theme to be applied.
-        """
+    def _update_theme(self, theme: str):
+        """Update the theme."""
         if theme is None:
             qapp = QApplication.instance()
             if hasattr(qapp, "theme"):
                 theme = qapp.theme["theme"]
             else:
                 theme = "dark"
+        self.apply_theme(theme)
+
+    def apply_theme(self, theme: str):
+        """
+        Apply the theme to the plot widget.
+
+        Args:
+            theme(str, optional): The theme to be applied.
+        """
         palette = bec_qthemes.load_palette(theme)
         text_pen = pg.mkPen(color=palette.text().color())
 

bec_widgets/widgets/figure/plots/waveform/waveform.py

@@ -49,8 +49,8 @@ class BECWaveform(BECPlotBase):
         "_config_dict",
         "plot",
         "add_dap",
-        "set_x",
         "get_dap_params",
+        "set_x",
         "remove_curve",
         "scan_history",
         "curves",
@@ -74,8 +74,8 @@ class BECWaveform(BECPlotBase):
     ]
     scan_signal_update = pyqtSignal()
     async_signal_update = pyqtSignal()
-    dap_params_update = pyqtSignal(dict)
-    dap_summary_update = pyqtSignal(dict)
+    dap_params_update = pyqtSignal(dict, dict)
+    dap_summary_update = pyqtSignal(dict, dict)
     autorange_signal = pyqtSignal()
     new_scan = pyqtSignal()
 
@@ -1085,8 +1085,9 @@ class BECWaveform(BECPlotBase):
                     curve.setData(x, y)
                     curve.dap_params = msg["data"][1]["fit_parameters"]
                     curve.dap_summary = msg["data"][1]["fit_summary"]
-                    self.dap_params_update.emit(curve.dap_params)
-                    self.dap_summary_update.emit(curve.dap_summary)
+                    metadata.update({"curve_id": curve_id_request})
+                    self.dap_params_update.emit(curve.dap_params, metadata)
+                    self.dap_summary_update.emit(curve.dap_summary, metadata)
                 break
 
     @Slot(dict, dict)

bec_widgets/widgets/lmfit_dialog/lm_fit_dialog.pyproject

@@ -0,0 +1 @@
+{'files': ['lmfit_dialog.py']}

bec_widgets/widgets/lmfit_dialog/lm_fit_dialog_plugin.py

@@ -0,0 +1,54 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+
+from bec_widgets.utils.bec_designer import designer_material_icon
+from bec_widgets.widgets.lmfit_dialog.lmfit_dialog import LMFitDialog
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='LMFitDialog' name='lm_fit_dialog'>
+    </widget>
+</ui>
+"""
+
+
+class LMFitDialogPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = LMFitDialog(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Utils"
+
+    def icon(self):
+        return designer_material_icon(LMFitDialog.ICON_NAME)
+
+    def includeFile(self):
+        return "lm_fit_dialog"
+
+    def initialize(self, form_editor):
+        self._form_editor = form_editor
+
+    def isContainer(self):
+        return False
+
+    def isInitialized(self):
+        return self._form_editor is not None
+
+    def name(self):
+        return "LMFitDialog"
+
+    def toolTip(self):
+        return "LMFitDialog"
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/lmfit_dialog/lmfit_dialog.py

@@ -0,0 +1,194 @@
+import os
+
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import Property, Signal, Slot
+from qtpy.QtWidgets import QTreeWidgetItem, QVBoxLayout, QWidget
+
+from bec_widgets.utils import UILoader
+from bec_widgets.utils.bec_widget import BECWidget
+
+logger = bec_logger.logger
+
+
+class LMFitDialog(BECWidget, QWidget):
+    """Dialog for displaying the fit summary and params for LMFit DAP processes"""
+
+    ICON_NAME = "monitoring"
+    selected_fit = Signal(str)
+
+    def __init__(
+        self,
+        parent=None,
+        client=None,
+        config=None,
+        target_widget=None,
+        gui_id: str | None = None,
+        ui_file="lmfit_dialog_vertical.ui",
+    ):
+        """
+        Initialises the LMFitDialog widget.
+
+        Args:
+            parent (QWidget): The parent widget.
+            client: BEC client object.
+            config: Configuration of the widget.
+            target_widget: The widget that the settings will be taken from and applied to.
+            gui_id (str): GUI ID.
+            ui_file (str): The UI file to be loaded.
+        """
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        QWidget.__init__(self, parent=parent)
+        self._ui_file = ui_file
+        self.target_widget = target_widget
+
+        current_path = os.path.dirname(__file__)
+        self.ui = UILoader(self).loader(os.path.join(current_path, self._ui_file))
+        self.layout = QVBoxLayout(self)
+        self.layout.addWidget(self.ui)
+        self.summary_data = {}
+        self._fit_curve_id = None
+        self._deci_precision = 3
+        self.ui.curve_list.currentItemChanged.connect(self.display_fit_details)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(self.layout)
+
+    @Property(bool)
+    def hide_curve_selection(self):
+        """Property for showing the curve selection."""
+        return not self.ui.group_curve_selection.isVisible()
+
+    @hide_curve_selection.setter
+    def hide_curve_selection(self, show: bool):
+        """Setter for showing the curve selection.
+
+        Args:
+            show (bool): Whether to show the curve selection.
+        """
+        self.ui.group_curve_selection.setVisible(not show)
+
+    @property
+    def fit_curve_id(self):
+        """Property for the currently displayed fit curve_id."""
+        return self._fit_curve_id
+
+    @fit_curve_id.setter
+    def fit_curve_id(self, curve_id: str):
+        """Setter for the currently displayed fit curve_id.
+
+        Args:
+            fit_curve_id (str): The curve_id of the fit curve to be displayed.
+        """
+        self._fit_curve_id = curve_id
+        self.selected_fit.emit(curve_id)
+
+    @Slot(str)
+    def remove_dap_data(self, curve_id: str):
+        """Remove the DAP data for the given curve_id.
+
+        Args:
+            curve_id (str): The curve_id of the DAP data to be removed.
+        """
+        self.summary_data.pop(curve_id, None)
+        self.refresh_curve_list()
+
+    @Slot(str)
+    def select_curve(self, curve_id: str):
+        """Select active curve_id in the curve list.
+
+        Args:
+            curve_id (str): curve_id to be selected.
+        """
+        self.fit_curve_id = curve_id
+
+    @Slot(dict, dict)
+    def update_summary_tree(self, data: dict, metadata: dict):
+        """Update the summary tree with the given data.
+
+        Args:
+            data (dict): Data for the DAP Summary.
+            metadata (dict): Metadata of the fit curve.
+        """
+        curve_id = metadata.get("curve_id", "")
+        self.summary_data.update({curve_id: data})
+        self.refresh_curve_list()
+        if self.fit_curve_id is None:
+            self.fit_curve_id = curve_id
+        if curve_id != self.fit_curve_id:
+            return
+        if data is None:
+            return
+        self.ui.summary_tree.clear()
+        properties = [
+            ("Model", data.get("model", "")),
+            ("Method", data.get("method", "")),
+            ("Chi-Squared", f"{data.get('chisqr', 0.0):.{self._deci_precision}f}"),
+            ("Reduced Chi-Squared", f"{data.get('redchi', 0.0):.{self._deci_precision}f}"),
+            ("R-Squared", f"{data.get('rsquared', 0.0):.{self._deci_precision}f}"),
+            ("Message", data.get("message", "")),
+        ]
+        for prop, val in properties:
+            QTreeWidgetItem(self.ui.summary_tree, [prop, val])
+        self.update_param_tree(data.get("params", []))
+
+    def _update_summary_data(self, curve_id: str, data: dict):
+        """Update the summary data with the given data.
+
+        Args:
+            curve_id (str): The curve_id of the fit curve.
+            data (dict): The data to be updated.
+        """
+        self.summary_data.update({curve_id: data})
+        if self.fit_curve_id is not None:
+            return
+        self.fit_curve_id = curve_id
+
+    def update_param_tree(self, params):
+        """Update the parameter tree with the given parameters.
+
+        Args:
+            params (list): List of LMFit parameters for the fit curve.
+        """
+        self.ui.param_tree.clear()
+        for param in params:
+            param_name, param_value, param_std = (
+                param[0],
+                f"{param[1]:.{self._deci_precision}f}",
+                f"{param[7]:.{self._deci_precision}f}",
+            )
+            QTreeWidgetItem(self.ui.param_tree, [param_name, param_value, param_std])
+
+    def populate_curve_list(self):
+        """Populate the curve list with the available fit curves."""
+        for curve_name in self.summary_data.keys():
+            self.ui.curve_list.addItem(curve_name)
+
+    def refresh_curve_list(self):
+        """Refresh the curve list with the updated data."""
+        self.ui.curve_list.clear()
+        self.populate_curve_list()
+
+    def display_fit_details(self, current):
+        """Callback for displaying the fit details of the selected curve.
+
+        Args:
+            current: The current item in the curve list.
+        """
+        if current:
+            curve_name = current.text()
+            self.fit_curve_id = curve_name
+            data = self.summary_data[curve_name]
+            if data is None:
+                return
+            self.update_summary_tree(data, {"curve_id": curve_name})
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    dialog = LMFitDialog()
+    dialog.show()
+    sys.exit(app.exec_())