bec-widgets 0.78.1__py3-none-any.whl → 0.79.1__py3-none-any.whl

bec_widgets/widgets/motor_map/assets/settings.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="48px" viewBox="0 0 24 24" width="48px" fill="#FFFFFF">
+    <path d="M0 0h24v24H0V0z" fill="none"/>
+    <path d="M19.43 12.98c.04-.32.07-.64.07-.98 0-.34-.03-.66-.07-.98l2.11-1.65c.19-.15.24-.42.12-.64l-2-3.46c-.09-.16-.26-.25-.44-.25-.06 0-.12.01-.17.03l-2.49 1c-.52-.4-1.08-.73-1.69-.98l-.38-2.65C14.46 2.18 14.25 2 14 2h-4c-.25 0-.46.18-.49.42l-.38 2.65c-.61.25-1.17.59-1.69.98l-2.49-1c-.06-.02-.12-.03-.18-.03-.17 0-.34.09-.43.25l-2 3.46c-.13.22-.07.49.12.64l2.11 1.65c-.04.32-.07.65-.07.98 0 .33.03.66.07.98l-2.11 1.65c-.19.15-.24.42-.12.64l2 3.46c.09.16.26.25.44.25.06 0 .12-.01.17-.03l2.49-1c.52.4 1.08.73 1.69.98l.38 2.65c.03.24.24.42.49.42h4c.25 0 .46-.18.49-.42l.38-2.65c.61-.25 1.17-.59 1.69-.98l2.49 1c.06.02.12.03.18.03.17 0 .34-.09.43-.25l2-3.46c.12-.22.07-.49-.12-.64l-2.11-1.65zm-1.98-1.71c.04.31.05.52.05.73 0 .21-.02.43-.05.73l-.14 1.13.89.7 1.08.84-.7 1.21-1.27-.51-1.04-.42-.9.68c-.43.32-.84.56-1.25.73l-1.06.43-.16 1.13-.2 1.35h-1.4l-.19-1.35-.16-1.13-1.06-.43c-.43-.18-.83-.41-1.23-.71l-.91-.7-1.06.43-1.27.51-.7-1.21 1.08-.84.89-.7-.14-1.13c-.03-.31-.05-.54-.05-.74s.02-.43.05-.73l.14-1.13-.89-.7-1.08-.84.7-1.21 1.27.51 1.04.42.9-.68c.43-.32.84-.56 1.25-.73l1.06-.43.16-1.13.2-1.35h1.39l.19 1.35.16 1.13 1.06.43c.43.18.83.41 1.23.71l.91.7 1.06-.43 1.27-.51.7 1.21-1.07.85-.89.7.14 1.13zM12 8c-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4-1.79-4-4-4zm0 6c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2z"/>
+</svg>

bec_widgets/widgets/motor_map/bec_motor_map_widget.pyproject

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

bec_widgets/widgets/motor_map/bec_motor_map_widget_plugin.py

@@ -0,0 +1,55 @@
+import os
+
+from qtpy.QtDesigner import QDesignerCustomWidgetInterface
+from qtpy.QtGui import QIcon
+
+from bec_widgets.widgets.motor_map.motor_map_widget import BECMotorMapWidget
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='BECMotorMapWidget' name='bec_motor_map_widget'>
+    </widget>
+</ui>
+"""
+
+
+class BECMotorMapWidgetPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = BECMotorMapWidget(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Visualization Widgets"
+
+    def icon(self):
+        current_path = os.path.dirname(__file__)
+        icon_path = os.path.join(current_path, "assets", "motor_map.png")
+        return QIcon(icon_path)
+
+    def includeFile(self):
+        return "bec_motor_map_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 "BECMotorMapWidget"
+
+    def toolTip(self):
+        return "BECMotorMapWidget"
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/motor_map/motor_map_dialog/motor_map_settings.py

@@ -0,0 +1,73 @@
+import os
+
+from qtpy.QtCore import Slot
+from qtpy.QtWidgets import QDialog, QDialogButtonBox, QLabel, QVBoxLayout, QWidget
+
+from bec_widgets.utils import UILoader
+from bec_widgets.utils.widget_io import WidgetIO
+
+
+class MotorMapSettings(QWidget):
+    def __init__(self, parent=None, target_widget: QWidget = None, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+        current_path = os.path.dirname(__file__)
+
+        self.ui = UILoader(self).loader(os.path.join(current_path, "motor_map_settings.ui"))
+        self.target_widget = target_widget
+
+        self.layout = QVBoxLayout(self)
+        self.layout.addWidget(self.ui)
+
+    @Slot(dict)
+    def display_current_settings(self, config: dict):
+        WidgetIO.set_value(self.ui.max_points, config["max_points"])
+        WidgetIO.set_value(self.ui.trace_dim, config["num_dim_points"])
+        WidgetIO.set_value(self.ui.precision, config["precision"])
+        WidgetIO.set_value(self.ui.scatter_size, config["scatter_size"])
+        background_intensity = int((config["background_value"] / 255) * 100)
+        WidgetIO.set_value(self.ui.background_value, background_intensity)
+        color = config["color"]
+        self.ui.color.setColor(color)
+
+    @Slot()
+    def accept_changes(self):
+        max_points = WidgetIO.get_value(self.ui.max_points)
+        num_dim_points = WidgetIO.get_value(self.ui.trace_dim)
+        precision = WidgetIO.get_value(self.ui.precision)
+        scatter_size = WidgetIO.get_value(self.ui.scatter_size)
+        background_intensity = int(WidgetIO.get_value(self.ui.background_value) * 0.01 * 255)
+        color = self.ui.color.color().toTuple()
+
+        if self.target_widget is not None:
+            self.target_widget.set_max_points(max_points)
+            self.target_widget.set_num_dim_points(num_dim_points)
+            self.target_widget.set_precision(precision)
+            self.target_widget.set_scatter_size(scatter_size)
+            self.target_widget.set_background_value(background_intensity)
+            self.target_widget.set_color(color)
+
+
+class MotorMapDialog(QDialog):
+    def __init__(self, parent=None, target_widget: QWidget = None, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+
+        self.setModal(False)
+
+        self.setWindowTitle("Motor Map Settings")
+
+        self.target_widget = target_widget
+        self.widget = MotorMapSettings(target_widget=self.target_widget)
+        self.widget.display_current_settings(self.target_widget._config_dict)
+        self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+
+        self.button_box.accepted.connect(self.accept)
+        self.button_box.rejected.connect(self.reject)
+
+        self.layout = QVBoxLayout(self)
+        self.layout.addWidget(self.widget)
+        self.layout.addWidget(self.button_box)
+
+    @Slot()
+    def accept(self):
+        self.widget.accept_changes()
+        super().accept()

bec_widgets/widgets/motor_map/motor_map_dialog/motor_map_settings.ui

@@ -0,0 +1,108 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>243</width>
+    <height>233</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="3" column="1">
+    <widget class="QSpinBox" name="scatter_size">
+     <property name="maximum">
+      <number>20</number>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="0">
+    <widget class="QLabel" name="trace_label">
+     <property name="text">
+      <string>Trace Dim</string>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="0">
+    <widget class="QLabel" name="precision_label">
+     <property name="text">
+      <string>Precision</string>
+     </property>
+    </widget>
+   </item>
+   <item row="4" column="0">
+    <widget class="QLabel" name="background_label">
+     <property name="text">
+      <string>Background Intensity</string>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="1">
+    <widget class="QSpinBox" name="precision">
+     <property name="maximum">
+      <number>15</number>
+     </property>
+    </widget>
+   </item>
+   <item row="4" column="1">
+    <widget class="QSpinBox" name="background_value">
+     <property name="maximum">
+      <number>100</number>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="0">
+    <widget class="QLabel" name="max_point_label">
+     <property name="text">
+      <string>Max Points</string>
+     </property>
+    </widget>
+   </item>
+   <item row="3" column="0">
+    <widget class="QLabel" name="scatter_size_label">
+     <property name="text">
+      <string>Scatter Size</string>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="1">
+    <widget class="QSpinBox" name="max_points">
+     <property name="maximum">
+      <number>10000</number>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="1">
+    <widget class="QSpinBox" name="trace_dim">
+     <property name="maximum">
+      <number>1000</number>
+     </property>
+    </widget>
+   </item>
+   <item row="5" column="0">
+    <widget class="QLabel" name="color_label">
+     <property name="text">
+      <string>Color</string>
+     </property>
+    </widget>
+   </item>
+   <item row="5" column="1">
+    <widget class="ColorButton" name="color"/>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>ColorButton</class>
+   <extends>QPushButton</extends>
+   <header>color_button</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/widgets/motor_map/motor_map_dialog/motor_map_toolbar.py

@@ -0,0 +1,59 @@
+import os
+
+from qtpy.QtCore import QSize
+from qtpy.QtGui import QAction, QIcon
+from qtpy.QtWidgets import QHBoxLayout, QLabel, QWidget
+
+from bec_widgets.widgets.device_inputs import DeviceComboBox
+from bec_widgets.widgets.toolbar.toolbar import ToolBarAction
+
+
+class DeviceSelectionAction(ToolBarAction):
+    def __init__(self, label: str):
+        self.label = label
+        self.device_combobox = DeviceComboBox(device_filter="Positioner")
+
+        self.device_combobox.currentIndexChanged.connect(lambda: self.set_combobox_style("#ffa700"))
+
+    def add_to_toolbar(self, toolbar, target):
+        widget = QWidget()
+        layout = QHBoxLayout(widget)
+
+        label = QLabel(f"{self.label}")
+
+        layout.addWidget(label)
+        layout.addWidget(self.device_combobox)
+        toolbar.addWidget(widget)
+
+    def set_combobox_style(self, color: str):
+        self.device_combobox.setStyleSheet(f"QComboBox {{ background-color: {color}; }}")
+
+
+class ConnectAction(ToolBarAction):
+    def add_to_toolbar(self, toolbar, target):
+        current_path = os.path.dirname(__file__)
+        parent_path = os.path.dirname(current_path)
+        icon = QIcon()
+        icon.addFile(os.path.join(parent_path, "assets", "connection.svg"), size=QSize(20, 20))
+        self.action = QAction(icon, "Connect Motors", target)
+        toolbar.addAction(self.action)
+
+
+class ResetHistoryAction(ToolBarAction):
+    def add_to_toolbar(self, toolbar, target):
+        current_path = os.path.dirname(__file__)
+        parent_path = os.path.dirname(current_path)
+        icon = QIcon()
+        icon.addFile(os.path.join(parent_path, "assets", "history.svg"), size=QSize(20, 20))
+        self.action = QAction(icon, "Reset Trace History", target)
+        toolbar.addAction(self.action)
+
+
+class SettingsAction(ToolBarAction):
+    def add_to_toolbar(self, toolbar, target):
+        current_path = os.path.dirname(__file__)
+        parent_path = os.path.dirname(current_path)
+        icon = QIcon()
+        icon.addFile(os.path.join(parent_path, "assets", "settings.svg"), size=QSize(20, 20))
+        self.action = QAction(icon, "Open Configuration Dialog", target)
+        toolbar.addAction(self.action)

bec_widgets/widgets/motor_map/motor_map_widget.py

@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+import sys
+
+from qtpy import PYSIDE6
+from qtpy.QtWidgets import QVBoxLayout, QWidget
+
+from bec_widgets.utils import BECConnector
+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 MotorMapDialog
+from bec_widgets.widgets.motor_map.motor_map_dialog.motor_map_toolbar import (
+    ConnectAction,
+    DeviceSelectionAction,
+    ResetHistoryAction,
+    SettingsAction,
+)
+from bec_widgets.widgets.toolbar import ModularToolBar
+
+
+class BECMotorMapWidget(BECConnector, QWidget):
+    USER_ACCESS = [
+        "change_motors",
+        "set_max_points",
+        "set_precision",
+        "set_num_dim_points",
+        "set_background_value",
+        "set_scatter_size",
+        "get_data",
+        "reset_history",
+    ]
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        config: MotorMapConfig | None = None,
+        client=None,
+        gui_id: str | None = None,
+    ) -> None:
+        if not PYSIDE6:
+            raise RuntimeError(
+                "PYSIDE6 is not available in the environment. This widget is compatible only with PySide6."
+            )
+        if config is None:
+            config = MotorMapConfig(widget_class=self.__class__.__name__)
+        else:
+            if isinstance(config, dict):
+                config = MotorMapConfig(**config)
+        super().__init__(client=client, gui_id=gui_id)
+        QWidget.__init__(self, parent)
+
+        self.layout = QVBoxLayout(self)
+        self.layout.setSpacing(0)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+
+        self.fig = BECFigure()
+        self.toolbar = ModularToolBar(
+            actions={
+                "motor_x": DeviceSelectionAction("Motor X:"),
+                "motor_y": DeviceSelectionAction("Motor Y:"),
+                "connect": ConnectAction(),
+                "history": ResetHistoryAction(),
+                "config": SettingsAction(),
+            },
+            target_widget=self,
+        )
+
+        self.layout.addWidget(self.toolbar)
+        self.layout.addWidget(self.fig)
+
+        self.map = self.fig.motor_map()
+        self.map.apply_config(config)
+
+        self._hook_actions()
+
+        self.config = config
+
+    def _hook_actions(self):
+        self.toolbar.widgets["connect"].action.triggered.connect(self._action_motors)
+        self.toolbar.widgets["config"].action.triggered.connect(self.show_settings)
+        self.toolbar.widgets["history"].action.triggered.connect(self.reset_history)
+
+        if self.map.motor_x is None and self.map.motor_y is None:
+            self._enable_actions(False)
+
+    def _enable_actions(self, enable: bool):
+        self.toolbar.widgets["config"].action.setEnabled(enable)
+        self.toolbar.widgets["history"].action.setEnabled(enable)
+
+    def _action_motors(self):
+        toolbar_x = self.toolbar.widgets["motor_x"].device_combobox
+        toolbar_y = self.toolbar.widgets["motor_y"].device_combobox
+        motor_x = toolbar_x.currentText()
+        motor_y = toolbar_y.currentText()
+        self.change_motors(motor_x, motor_y, None, None, True)
+        toolbar_x.setStyleSheet("QComboBox {{ background-color: " "; }}")
+        toolbar_y.setStyleSheet("QComboBox {{ background-color: " "; }}")
+
+    def show_settings(self) -> None:
+        dialog = MotorMapDialog(self, target_widget=self)
+        dialog.exec()
+
+    ###################################
+    # User Access Methods from MotorMap
+    ###################################
+
+    def change_motors(
+        self,
+        motor_x: str,
+        motor_y: str,
+        motor_x_entry: str = None,
+        motor_y_entry: str = None,
+        validate_bec: bool = True,
+    ) -> None:
+        """
+        Change the active motors for the plot.
+
+        Args:
+            motor_x(str): Motor name for the X axis.
+            motor_y(str): Motor name for the Y axis.
+            motor_x_entry(str): Motor entry for the X axis.
+            motor_y_entry(str): Motor entry for the Y axis.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+        """
+        self.map.change_motors(motor_x, motor_y, motor_x_entry, motor_y_entry, validate_bec)
+        if self.map.motor_x is not None and self.map.motor_y is not None:
+            self._enable_actions(True)
+        toolbar_x = self.toolbar.widgets["motor_x"].device_combobox
+        toolbar_y = self.toolbar.widgets["motor_y"].device_combobox
+
+        if toolbar_x.currentText() != motor_x:
+            toolbar_x.setCurrentText(motor_x)
+            toolbar_x.setStyleSheet("QComboBox {{ background-color: " "; }}")
+        if toolbar_y.currentText() != motor_y:
+            toolbar_y.setCurrentText(motor_y)
+            toolbar_y.setStyleSheet("QComboBox {{ background-color: " "; }}")
+
+    def get_data(self) -> dict:
+        """
+        Get the data of the motor map.
+
+        Returns:
+            dict: Data of the motor map.
+        """
+        return self.map.get_data()
+
+    def reset_history(self) -> None:
+        """
+        Reset the history of the motor map.
+        """
+        self.map.reset_history()
+
+    def set_color(self, color: str | tuple):
+        """
+        Set the color of the motor map.
+
+        Args:
+            color(str, tuple): Color to set.
+        """
+        self.map.set_color(color)
+
+    def set_max_points(self, max_points: int) -> None:
+        """
+        Set the maximum number of points to display on the motor map.
+
+        Args:
+            max_points(int): Maximum number of points to display.
+        """
+        self.map.set_max_points(max_points)
+
+    def set_precision(self, precision: int) -> None:
+        """
+        Set the precision of the motor map.
+
+        Args:
+            precision(int): Precision to set.
+        """
+        self.map.set_precision(precision)
+
+    def set_num_dim_points(self, num_dim_points: int) -> None:
+        """
+        Set the number of points to display on the motor map.
+
+        Args:
+            num_dim_points(int): Number of points to display.
+        """
+        self.map.set_num_dim_points(num_dim_points)
+
+    def set_background_value(self, background_value: int) -> None:
+        """
+        Set the background value of the motor map.
+
+        Args:
+            background_value(int): Background value of the motor map.
+        """
+        self.map.set_background_value(background_value)
+
+    def set_scatter_size(self, scatter_size: int) -> None:
+        """
+        Set the scatter size of the motor map.
+
+        Args:
+            scatter_size(int): Scatter size of the motor map.
+        """
+        self.map.set_scatter_size(scatter_size)
+
+    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
+
+    if not PYSIDE6:
+        print(
+            "PYSIDE6 is not available in the environment. UI files with BEC custom widgets are runnable only with PySide6."
+        )
+        return
+
+    from qtpy.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    widget = BECMotorMapWidget()
+    widget.show()
+    sys.exit(app.exec_())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/motor_map/register_bec_motor_map_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.motor_map.bec_motor_map_widget_plugin import BECMotorMapWidgetPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(BECMotorMapWidgetPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()