bec-widgets 0.87.0__py3-none-any.whl → 0.88.0__py3-none-any.whl

bec_widgets/widgets/motor_map/motor_map_widget.py

@@ -6,7 +6,7 @@ from qtpy.QtWidgets import QVBoxLayout, QWidget
 
 from bec_widgets.qt_utils.settings_dialog import SettingsDialog
 from bec_widgets.qt_utils.toolbar import ModularToolBar
-from bec_widgets.utils import BECConnector
+from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.widgets.figure import BECFigure
 from bec_widgets.widgets.figure.plots.motor_map.motor_map import MotorMapConfig
 from bec_widgets.widgets.motor_map.motor_map_dialog.motor_map_settings import MotorMapSettings
@@ -18,7 +18,7 @@ from bec_widgets.widgets.motor_map.motor_map_dialog.motor_map_toolbar import (
 )
 
 
-class BECMotorMapWidget(BECConnector, QWidget):
+class BECMotorMapWidget(BECWidget, QWidget):
     USER_ACCESS = [
         "change_motors",
         "set_max_points",
@@ -28,6 +28,7 @@ class BECMotorMapWidget(BECConnector, QWidget):
         "set_scatter_size",
         "get_data",
         "reset_history",
+        "export",
     ]
 
     def __init__(
@@ -202,16 +203,18 @@ class BECMotorMapWidget(BECConnector, QWidget):
         """
         self.map.set_scatter_size(scatter_size)
 
+    def export(self):
+        """
+        Show the export dialog for the motor map.
+        """
+        self.map.export()
+
     def cleanup(self):
         self.fig.cleanup()
         self.toolbar.widgets["motor_x"].device_combobox.cleanup()
         self.toolbar.widgets["motor_y"].device_combobox.cleanup()
         return super().cleanup()
 
-    def closeEvent(self, event):
-        self.cleanup()
-        QWidget().closeEvent(event)
-
 
 def main():  # pragma: no cover
     from qtpy.QtWidgets import QApplication

bec_widgets/widgets/ring_progress_bar/ring.py

@@ -288,7 +288,3 @@ class Ring(BECConnector):
         value = msg.get("signals").get(device).get("value")
         self.set_value(value)
         self.parent_progress_widget.update()
-
-    def cleanup(self):
-        self.reset_connection()
-        super().cleanup()

bec_widgets/widgets/ring_progress_bar/ring_progress_bar.py

@@ -10,7 +10,8 @@ from qtpy import QtCore, QtGui
 from qtpy.QtCore import QSize, Slot
 from qtpy.QtWidgets import QSizePolicy, QWidget
 
-from bec_widgets.utils import BECConnector, Colors, ConnectionConfig, EntryValidator
+from bec_widgets.utils import Colors, ConnectionConfig, EntryValidator
+from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.widgets.ring_progress_bar.ring import Ring, RingConfig
 
 
@@ -66,7 +67,7 @@ class RingProgressBarConfig(ConnectionConfig):
     _validate_colormap = field_validator("color_map")(Colors.validate_color_map)
 
 
-class RingProgressBar(BECConnector, QWidget):
+class RingProgressBar(BECWidget, QWidget):
     USER_ACCESS = [
         "_get_all_rpc",
         "_rpc_id",
@@ -208,7 +209,7 @@ class RingProgressBar(BECConnector, QWidget):
             index(int): Index of the progress bar to remove.
         """
         ring = self._find_ring_by_index(index)
-        ring.cleanup()
+        ring.reset_connection()
         self._rings.remove(ring)
         self.config.rings.remove(ring.config)
         self.config.num_bars -= 1
@@ -622,9 +623,8 @@ class RingProgressBar(BECConnector, QWidget):
 
     def clear_all(self):
         for ring in self._rings:
-            ring.cleanup()
-            del ring
-            self._rings = []
+            ring.reset_connection()
+        self._rings.clear()
         self.update()
         self.initialize_bars()
 
@@ -633,6 +633,6 @@ class RingProgressBar(BECConnector, QWidget):
             self.on_scan_queue_status, MessageEndpoints.scan_queue_status()
         )
         for ring in self._rings:
-            ring.cleanup()
-            del ring
+            ring.reset_connection()
+        self._rings.clear()
         super().cleanup()

bec_widgets/widgets/scan_control/scan_control.py

@@ -10,13 +10,13 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 
-from bec_widgets.utils import BECConnector
+from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import apply_theme
 from bec_widgets.widgets.scan_control.scan_group_box import ScanGroupBox
 from bec_widgets.widgets.stop_button.stop_button import StopButton
 
 
-class ScanControl(BECConnector, QWidget):
+class ScanControl(BECWidget, QWidget):
 
     def __init__(
         self, parent=None, client=None, gui_id: str | None = None, allowed_scans: list | None = None
@@ -196,10 +196,6 @@ class ScanControl(BECConnector, QWidget):
                     widget.cleanup()
         super().cleanup()
 
-    def closeEvent(self, event):
-        self.cleanup()
-        return QWidget.closeEvent(self, event)
-
 
 # Application example
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/widgets/stop_button/stop_button.py

@@ -1,10 +1,10 @@
 from qtpy.QtCore import Slot
 from qtpy.QtWidgets import QPushButton
 
-from bec_widgets.utils import BECConnector
+from bec_widgets.utils.bec_widget import BECWidget
 
 
-class StopButton(BECConnector, QPushButton):
+class StopButton(BECWidget, QPushButton):
     """A button that stops the current scan."""
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None):

bec_widgets/widgets/text_box/text_box.py

@@ -3,7 +3,8 @@ import re
 from pydantic import Field, field_validator
 from qtpy.QtWidgets import QTextEdit
 
-from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
+from bec_widgets.utils.bec_connector import ConnectionConfig
+from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import Colors
 
 
@@ -27,7 +28,7 @@ class TextBoxConfig(ConnectionConfig):
     _validate_background_color = field_validator("background_color")(Colors.validate_color)
 
 
-class TextBox(BECConnector, QTextEdit):
+class TextBox(BECWidget, QTextEdit):
 
     USER_ACCESS = ["set_color", "set_text", "set_font_size"]
 

bec_widgets/widgets/waveform/bec_waveform_widget.pyproject

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

bec_widgets/widgets/waveform/bec_waveform_widget_plugin.py

@@ -0,0 +1,59 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+import os
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+import bec_widgets
+from bec_widgets.widgets.waveform.waveform_widget import BECWaveformWidget
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='BECWaveformWidget' name='bec_waveform_widget'>
+    </widget>
+</ui>
+"""
+
+MODULE_PATH = os.path.dirname(bec_widgets.__file__)
+
+
+class BECWaveformWidgetPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = BECWaveformWidget(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Plots"
+
+    def icon(self):
+        icon_path = os.path.join(MODULE_PATH, "assets", "designer_icons", "BECWaveformWidget.png")
+        return QIcon(icon_path)
+
+    def includeFile(self):
+        return "bec_waveform_widget"
+
+    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 "BECWaveformWidget"
+
+    def toolTip(self):
+        return "BECWaveformWidget"
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/waveform/register_bec_waveform_widget.py

@@ -0,0 +1,15 @@
+def main():  # pragma: no cover
+    from qtpy import PYSIDE6
+
+    if not PYSIDE6:
+        print("PYSIDE6 is not available in the environment. Cannot patch designer.")
+        return
+    from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
+
+    from bec_widgets.widgets.waveform.bec_waveform_widget_plugin import BECWaveformWidgetPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(BECWaveformWidgetPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/waveform/waveform_toolbar/curve_dialog/curve_dialog.py

@@ -0,0 +1,341 @@
+from __future__ import annotations
+
+import os
+from typing import Literal
+
+from pydantic import BaseModel
+from qtpy.QtCore import QObject, QSize, Slot
+from qtpy.QtGui import QIcon
+from qtpy.QtWidgets import QComboBox, QLineEdit, QPushButton, QSpinBox, QTableWidget, QVBoxLayout
+
+import bec_widgets
+from bec_widgets.qt_utils.error_popups import WarningPopupUtility
+from bec_widgets.qt_utils.settings_dialog import SettingWidget
+from bec_widgets.utils import Colors, UILoader
+from bec_widgets.widgets.color_button.color_button import ColorButton
+from bec_widgets.widgets.device_line_edit.device_line_edit import DeviceLineEdit
+
+MODULE_PATH = os.path.dirname(bec_widgets.__file__)
+
+
+class CurveSettings(SettingWidget):
+    def __init__(self, parent=None, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+        current_path = os.path.dirname(__file__)
+
+        self.ui = UILoader(self).loader(os.path.join(current_path, "curve_dialog.ui"))
+        self._setup_icons()
+
+        self.warning_util = WarningPopupUtility(self)
+
+        self.layout = QVBoxLayout(self)
+        self.layout.addWidget(self.ui)
+
+        self.ui.add_curve.clicked.connect(self.add_curve)
+        self.ui.add_dap.clicked.connect(self.add_dap)
+        self.ui.x_mode.currentIndexChanged.connect(self.set_x_mode)
+        self.ui.normalize_colors_scan.clicked.connect(lambda: self.change_colormap("scan"))
+        self.ui.normalize_colors_dap.clicked.connect(lambda: self.change_colormap("dap"))
+
+    def _setup_icons(self):
+        add_icon = QIcon()
+        add_icon.addFile(
+            os.path.join(MODULE_PATH, "assets", "toolbar_icons", "add.svg"), size=QSize(20, 20)
+        )
+        self.ui.add_dap.setIcon(add_icon)
+        self.ui.add_dap.setToolTip("Add DAP Curve")
+        self.ui.add_curve.setIcon(add_icon)
+        self.ui.add_curve.setToolTip("Add Scan Curve")
+
+    @Slot(dict)
+    def display_current_settings(self, config: dict | BaseModel):
+
+        # What elements should be enabled
+        x_name = self.target_widget.waveform._x_axis_mode["name"]
+        x_entry = self.target_widget.waveform._x_axis_mode["entry"]
+        self._enable_ui_elements(x_name, x_entry)
+        cm = self.target_widget.config.color_palette
+        self.ui.color_map_selector_scan.combo.setCurrentText(cm)
+
+        # Scan Curve Table
+        for label, curve in config["scan_segment"].items():
+            row_count = self.ui.scan_table.rowCount()
+            self.ui.scan_table.insertRow(row_count)
+            DialogRow(
+                parent=self,
+                table_widget=self.ui.scan_table,
+                client=self.target_widget.client,
+                row=row_count,
+                config=curve.config,
+            ).add_scan_row()
+
+        # Add DAP Curves
+        for label, curve in config["DAP"].items():
+            row_count = self.ui.dap_table.rowCount()
+            self.ui.dap_table.insertRow(row_count)
+            DialogRow(
+                parent=self,
+                table_widget=self.ui.dap_table,
+                client=self.target_widget.client,
+                row=row_count,
+                config=curve.config,
+            ).add_dap_row()
+
+    def _enable_ui_elements(self, name, entry):
+        if name is None:
+            name = "best_effort"
+        if name in ["index", "timestamp", "best_effort"]:
+            self.ui.x_mode.setCurrentText(name)
+            self.set_x_mode()
+        else:
+            self.ui.x_mode.setCurrentText("device")
+            self.set_x_mode()
+            self.ui.x_name.setText(name)
+            self.ui.x_entry.setText(entry)
+
+    @Slot()
+    def set_x_mode(self):
+        x_mode = self.ui.x_mode.currentText()
+        if x_mode in ["index", "timestamp", "best_effort"]:
+            self.ui.x_name.setEnabled(False)
+            self.ui.x_entry.setEnabled(False)
+            self.ui.dap_table.setEnabled(False)
+            self.ui.add_dap.setEnabled(False)
+            if self.ui.dap_table.rowCount() > 0:
+                self.warning_util.show_warning(
+                    title="DAP Warning",
+                    message="DAP is not supported without specific x-axis device. All current DAP curves will be removed.",
+                    detailed_text=f"Affected curves: {[self.ui.dap_table.cellWidget(row, 0).text() for row in range(self.ui.dap_table.rowCount())]}",
+                )
+        else:
+            self.ui.x_name.setEnabled(True)
+            self.ui.x_entry.setEnabled(True)
+            self.ui.dap_table.setEnabled(True)
+            self.ui.add_dap.setEnabled(True)
+
+    @Slot()
+    def change_colormap(self, target: Literal["scan", "dap"]):
+        if target == "scan":
+            cm = self.ui.color_map_selector_scan.combo.currentText()
+            table = self.ui.scan_table
+        if target == "dap":
+            cm = self.ui.color_map_selector_dap.combo.currentText()
+            table = self.ui.dap_table
+        rows = table.rowCount()
+        colors = Colors.golden_angle_color(colormap=cm, num=rows + 1, format="HEX")
+        color_button_col = 2 if target == "scan" else 3
+        for row, color in zip(range(rows), colors):
+            table.cellWidget(row, color_button_col).setColor(color)
+
+    @Slot()
+    def accept_changes(self):
+        self.accept_curve_changes()
+
+    def accept_curve_changes(self):
+        old_curves_scans = list(self.target_widget.waveform._curves_data["scan_segment"].values())
+        old_curves_dap = list(self.target_widget.waveform._curves_data["DAP"].values())
+        for curve in old_curves_scans:
+            curve.remove()
+        for curve in old_curves_dap:
+            curve.remove()
+        self.get_curve_params()
+
+    def get_curve_params(self):
+        x_mode = self.ui.x_mode.currentText()
+
+        if x_mode in ["index", "timestamp", "best_effort"]:
+            x_name = x_mode
+            x_entry = x_mode
+        else:
+            x_name = self.ui.x_name.text()
+            x_entry = self.ui.x_entry.text()
+
+        self.target_widget.set_x(x_name=x_name, x_entry=x_entry)
+
+        for row in range(self.ui.scan_table.rowCount()):
+            y_name = self.ui.scan_table.cellWidget(row, 0).text()
+            y_entry = self.ui.scan_table.cellWidget(row, 1).text()
+            color = self.ui.scan_table.cellWidget(row, 2).get_color()
+            style = self.ui.scan_table.cellWidget(row, 3).currentText()
+            width = self.ui.scan_table.cellWidget(row, 4).value()
+            symbol_size = self.ui.scan_table.cellWidget(row, 5).value()
+            self.target_widget.plot(
+                y_name=y_name,
+                y_entry=y_entry,
+                color=color,
+                pen_style=style,
+                pen_width=width,
+                symbol_size=symbol_size,
+            )
+
+        if x_mode not in ["index", "timestamp", "best_effort"]:
+
+            for row in range(self.ui.dap_table.rowCount()):
+                y_name = self.ui.dap_table.cellWidget(row, 0).text()
+                y_entry = self.ui.dap_table.cellWidget(row, 1).text()
+                dap = self.ui.dap_table.cellWidget(row, 2).currentText()
+                color = self.ui.dap_table.cellWidget(row, 3).get_color()
+                style = self.ui.dap_table.cellWidget(row, 4).currentText()
+                width = self.ui.dap_table.cellWidget(row, 5).value()
+                symbol_size = self.ui.dap_table.cellWidget(row, 6).value()
+
+                self.target_widget.add_dap(
+                    x_name=x_name,
+                    x_entry=x_entry,
+                    y_name=y_name,
+                    y_entry=y_entry,
+                    dap=dap,
+                    color=color,
+                    pen_style=style,
+                    pen_width=width,
+                    symbol_size=symbol_size,
+                )
+        self.target_widget.scan_history(-1)
+
+    def add_curve(self):
+        row_count = self.ui.scan_table.rowCount()
+        self.ui.scan_table.insertRow(row_count)
+        DialogRow(
+            parent=self,
+            table_widget=self.ui.scan_table,
+            client=self.target_widget.client,
+            row=row_count,
+            config=None,
+        ).add_scan_row()
+
+    def add_dap(self):
+        row_count = self.ui.dap_table.rowCount()
+        self.ui.dap_table.insertRow(row_count)
+        DialogRow(
+            parent=self,
+            table_widget=self.ui.dap_table,
+            client=self.target_widget.client,
+            row=row_count,
+            config=None,
+        ).add_dap_row()
+
+
+class DialogRow(QObject):
+    def __init__(
+        self,
+        parent=None,
+        table_widget: QTableWidget = None,
+        row: int = None,
+        config: dict = None,
+        client=None,
+    ):
+
+        super().__init__(parent=parent)
+        self.client = client
+
+        self.table_widget = table_widget
+        self.row = row
+        self.config = config
+        self.init_default_widgets()
+
+    def init_default_widgets(self):
+
+        # Remove Button
+        self.remove_button = RemoveButton()
+
+        # Name and Entry
+        self.device_line_edit = DeviceLineEdit()
+        self.entry_line_edit = QLineEdit()
+
+        self.dap_combo = QComboBox()
+        self.populate_dap_combobox()
+
+        # Styling
+        self.color_button = ColorButton()
+        self.style_combo = StyleComboBox()
+        self.width = QSpinBox()
+        self.width.setMinimum(1)
+        self.width.setMaximum(20)
+        self.width.setValue(2)
+
+        self.symbol_size = QSpinBox()
+        self.symbol_size.setMinimum(1)
+        self.symbol_size.setMaximum(20)
+        self.symbol_size.setValue(5)
+
+        self.remove_button.clicked.connect(
+            lambda: self.remove_row()
+        )  # From some reason do not work without lambda
+
+    def populate_dap_combobox(self):
+        available_models = [
+            attr
+            for attr in dir(self.client.dap)
+            if not attr.startswith("__")
+            and not callable(getattr(self.client.dap, attr))
+            and not attr.startswith("_")
+        ]
+        self.dap_combo.addItems(available_models)
+
+    def add_scan_row(self):
+        if self.config is not None:
+            self.device_line_edit.setText(self.config.signals.y.name)
+            self.entry_line_edit.setText(self.config.signals.y.entry)
+            self.color_button.setColor(self.config.color)
+            self.style_combo.setCurrentText(self.config.pen_style)
+            self.width.setValue(self.config.pen_width)
+            self.symbol_size.setValue(self.config.symbol_size)
+        else:
+            default_color = Colors.golden_angle_color(
+                colormap="magma", num=self.row + 1, format="HEX"
+            )[-1]
+            self.color_button.setColor(default_color)
+
+        self.table_widget.setCellWidget(self.row, 0, self.device_line_edit)
+        self.table_widget.setCellWidget(self.row, 1, self.entry_line_edit)
+        self.table_widget.setCellWidget(self.row, 2, self.color_button)
+        self.table_widget.setCellWidget(self.row, 3, self.style_combo)
+        self.table_widget.setCellWidget(self.row, 4, self.width)
+        self.table_widget.setCellWidget(self.row, 5, self.symbol_size)
+        self.table_widget.setCellWidget(self.row, 6, self.remove_button)
+
+    def add_dap_row(self):
+        if self.config is not None:
+            self.device_line_edit.setText(self.config.signals.y.name)
+            self.entry_line_edit.setText(self.config.signals.y.entry)
+            self.dap_combo.setCurrentText(self.config.signals.dap)
+            self.color_button.setColor(self.config.color)
+            self.style_combo.setCurrentText(self.config.pen_style)
+            self.width.setValue(self.config.pen_width)
+            self.symbol_size.setValue(self.config.symbol_size)
+        else:
+            default_color = Colors.golden_angle_color(
+                colormap="magma", num=self.row + 1, format="HEX"
+            )[-1]
+            self.color_button.setColor(default_color)
+
+        self.table_widget.setCellWidget(self.row, 0, self.device_line_edit)
+        self.table_widget.setCellWidget(self.row, 1, self.entry_line_edit)
+        self.table_widget.setCellWidget(self.row, 2, self.dap_combo)
+        self.table_widget.setCellWidget(self.row, 3, self.color_button)
+        self.table_widget.setCellWidget(self.row, 4, self.style_combo)
+        self.table_widget.setCellWidget(self.row, 5, self.width)
+        self.table_widget.setCellWidget(self.row, 6, self.symbol_size)
+        self.table_widget.setCellWidget(self.row, 7, self.remove_button)
+
+    @Slot()
+    def remove_row(self):
+        row = self.table_widget.indexAt(self.remove_button.pos()).row()
+        self.cleanup()
+        self.table_widget.removeRow(row)
+
+    def cleanup(self):
+        self.device_line_edit.cleanup()
+
+
+class StyleComboBox(QComboBox):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.addItems(["solid", "dash", "dot", "dashdot"])
+
+
+class RemoveButton(QPushButton):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        icon_path = os.path.join(MODULE_PATH, "assets", "toolbar_icons", "remove.svg")
+        self.setIcon(QIcon(icon_path))