bec-widgets 1.0.1__py3-none-any.whl → 1.1.0__py3-none-any.whl

bec_widgets/widgets/device_line_edit/device_line_edit.py

@@ -1,13 +1,18 @@
-from typing import TYPE_CHECKING
-
+from bec_lib.callback_handler import EventType
+from bec_lib.device import ReadoutPriority
+from bec_lib.logger import bec_logger
 from qtpy.QtCore import QSize, Signal, Slot
-from qtpy.QtWidgets import QCompleter, QLineEdit, QSizePolicy
+from qtpy.QtGui import QPainter, QPaintEvent, QPen
+from qtpy.QtWidgets import QApplication, QCompleter, QLineEdit, QSizePolicy
 
-from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.widgets.base_classes.device_input_base import DeviceInputBase, DeviceInputConfig
+from bec_widgets.utils.colors import get_accent_colors
+from bec_widgets.widgets.base_classes.device_input_base import (
+    BECDeviceFilter,
+    DeviceInputBase,
+    DeviceInputConfig,
+)
 
-if TYPE_CHECKING:
-    from bec_widgets.widgets.base_classes.device_input_base import DeviceInputConfig
+logger = bec_logger.logger
 
 
 class DeviceLineEdit(DeviceInputBase, QLineEdit):
@@ -19,12 +24,13 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
         client: BEC client object.
         config: Device input configuration.
         gui_id: GUI ID.
-        device_filter: Device filter, name of the device class.
+        device_filter: Device filter, name of the device class from BECDeviceFilter and ReadoutPriority. Check DeviceInputBase for more details.
         default: Default device name.
         arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
     """
 
     device_selected = Signal(str)
+    device_config_update = Signal()
 
     ICON_NAME = "edit_note"
 
@@ -34,80 +40,137 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
         client=None,
         config: DeviceInputConfig = None,
         gui_id: str | None = None,
-        device_filter: str | list[str] | None = None,
+        device_filter: BECDeviceFilter | list[BECDeviceFilter] | None = None,
+        readout_priority_filter: (
+            str | ReadoutPriority | list[str] | list[ReadoutPriority] | None
+        ) = None,
+        available_devices: list[str] | None = None,
         default: str | None = None,
         arg_name: str | None = None,
     ):
+        self._callback_id = None
+        self._is_valid_input = False
+        self._accent_colors = get_accent_colors()
         super().__init__(client=client, config=config, gui_id=gui_id)
         QLineEdit.__init__(self, parent=parent)
-
         self.completer = QCompleter(self)
         self.setCompleter(self.completer)
-        self.populate_completer()
 
         if arg_name is not None:
             self.config.arg_name = arg_name
             self.arg_name = arg_name
-        if device_filter is not None:
-            self.set_device_filter(device_filter)
-        if default is not None:
-            self.set_default_device(default)
-
         self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
         self.setMinimumSize(QSize(100, 0))
 
-        self.editingFinished.connect(self.emit_device_selected)
-
-    @Slot()
-    def emit_device_selected(self):
-        """
-        Editing finished, let's see which device is selected and emit signal
-        """
-        device_name = self.text().lower()
-        device_obj = getattr(self.dev, device_name, None)
-        if device_obj is not None:
-            self.device_selected.emit(device_name)
-
-    def set_device_filter(self, device_filter: str | list[str]):
+        # We do not consider the config that is passed here, this produced problems
+        # with QtDesigner, since config and input arguments may differ and resolve properly
+        # Implementing this logic and config recoverage is postponed.
+        # Set available devices if passed
+        if available_devices is not None:
+            self.set_available_devices(available_devices)
+        # Set readout priority filter default is all
+        if readout_priority_filter is not None:
+            self.set_readout_priority_filter(readout_priority_filter)
+        else:
+            self.set_readout_priority_filter(
+                [
+                    ReadoutPriority.MONITORED,
+                    ReadoutPriority.BASELINE,
+                    ReadoutPriority.ASYNC,
+                    ReadoutPriority.CONTINUOUS,
+                    ReadoutPriority.ON_REQUEST,
+                ]
+            )
+        # Device filter default is None
+        if device_filter is not None:
+            self.set_device_filter(device_filter)
+        # Set default device if passed
+        if default is not None:
+            self.set_device(default)
+        self._callback_id = self.bec_dispatcher.client.callbacks.register(
+            EventType.DEVICE_UPDATE, self.on_device_update
+        )
+        self.device_config_update.connect(self.update_devices_from_filters)
+        self.textChanged.connect(self.check_validity)
+        self.check_validity(self.text())
+
+    def on_device_update(self, action: str, content: dict) -> None:
         """
-        Set the device filter.
+        Callback for device update events. Triggers the device_update signal.
 
         Args:
-            device_filter (str | list[str]): Device filter, name of the device class.
+            action (str): The action that triggered the event.
+            content (dict): The content of the config update.
         """
-        super().set_device_filter(device_filter)
-        self.populate_completer()
+        if action in ["add", "remove", "reload"]:
+            self.device_config_update.emit()
 
-    def set_default_device(self, default_device: str):
-        """
-        Set the default device.
+    def cleanup(self):
+        """Cleanup the widget."""
+        if self._callback_id is not None:
+            self.bec_dispatcher.client.callbacks.remove(self._callback_id)
 
-        Args:
-            default_device (str): Default device name.
+    def get_current_device(self) -> object:
         """
-        super().set_default_device(default_device)
-        self.setText(default_device)
-
-    def populate_completer(self):
-        """Populate the completer with the devices."""
-        self.devices = self.get_device_list(self.config.device_filter)
-        self.completer.setModel(self.create_completer_model(self.devices))
+        Get the current device object based on the current value.
 
-    def create_completer_model(self, devices: list[str]):
-        """Create a model for the completer."""
-        from qtpy.QtCore import QStringListModel
+        Returns:
+            object: Device object, can be device of type Device, Positioner, Signal or ComputedSignal.
+        """
+        dev_name = self.text()
+        return self.get_device_object(dev_name)
 
-        return QStringListModel(devices, self)
+    def paintEvent(self, event: QPaintEvent) -> None:
+        """Extend the paint event to set the border color based on the validity of the input.
 
-    def get_device(self) -> object:
+        Args:
+            event (PySide6.QtGui.QPaintEvent) : Paint event.
         """
-        Get the selected device object.
-
-        Returns:
-            object: Device object.
+        # logger.info(f"Received paint event: {event} in {self.__class__}")
+        super().paintEvent(event)
+
+        if self._is_valid_input is False and self.isEnabled() is True:
+            painter = QPainter(self)
+            pen = QPen()
+            pen.setWidth(2)
+            pen.setColor(self._accent_colors.emergency)
+            painter.setPen(pen)
+            painter.drawRect(self.rect().adjusted(1, 1, -1, -1))
+            painter.end()
+
+    @Slot(str)
+    def check_validity(self, input_text: str) -> None:
+        """
+        Check if the current value is a valid device name.
         """
-        device_name = self.text()
-        device_obj = getattr(self.dev, device_name.lower(), None)
-        if device_obj is None:
-            raise ValueError(f"Device {device_name} is not found.")
-        return device_obj
+        if self.validate_device(input_text) is True:
+            self._is_valid_input = True
+            self.device_selected.emit(input_text.lower())
+        else:
+            self._is_valid_input = False
+        self.update()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    # pylint: disable=import-outside-toplevel
+    from qtpy.QtWidgets import QVBoxLayout, QWidget
+
+    from bec_widgets.utils.colors import set_theme
+    from bec_widgets.widgets.signal_combobox.signal_combobox import SignalComboBox
+
+    app = QApplication([])
+    set_theme("dark")
+    widget = QWidget()
+    widget.setFixedSize(200, 200)
+    layout = QVBoxLayout()
+    widget.setLayout(layout)
+    line_edit = DeviceLineEdit()
+    line_edit.filter_to_positioner = True
+    signal_line_edit = SignalComboBox()
+    line_edit.textChanged.connect(signal_line_edit.set_device)
+    line_edit.set_available_devices(["samx", "samy", "samz"])
+    line_edit.set_device("samx")
+    layout.addWidget(line_edit)
+    layout.addWidget(signal_line_edit)
+    widget.show()
+    app.exec_()

bec_widgets/widgets/device_line_edit/device_line_edit_plugin.py

@@ -31,7 +31,7 @@ class DeviceLineEditPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return DOM_XML
 
     def group(self):
-        return "Device Control"
+        return "BEC Input Widgets"
 
     def icon(self):
         return designer_material_icon(DeviceLineEdit.ICON_NAME)

bec_widgets/widgets/image/image_widget.py

@@ -4,6 +4,7 @@ import sys
 from typing import Literal, Optional
 
 import pyqtgraph as pg
+from bec_lib.device import ReadoutPriority
 from qtpy.QtWidgets import QComboBox, QVBoxLayout, QWidget
 
 from bec_widgets.qt_utils.error_popups import SafeSlot, WarningPopupUtility
@@ -16,6 +17,7 @@ from bec_widgets.qt_utils.toolbar import (
     WidgetAction,
 )
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.widgets.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.device_combobox.device_combobox import DeviceComboBox
 from bec_widgets.widgets.figure import BECFigure
 from bec_widgets.widgets.figure.plots.axis_settings import AxisSettings
@@ -69,7 +71,11 @@ class BECImageWidget(BECWidget, QWidget):
         self.toolbar = ModularToolBar(
             actions={
                 "monitor": DeviceSelectionAction(
-                    "Monitor:", DeviceComboBox(device_filter="Device")
+                    "Monitor:",
+                    DeviceComboBox(
+                        device_filter=BECDeviceFilter.DEVICE,
+                        readout_priority_filter=[ReadoutPriority.ASYNC],
+                    ),
                 ),
                 "monitor_type": WidgetAction(widget=self.dim_combo_box),
                 "connect": MaterialIconAction(icon_name="link", tooltip="Connect Device"),

bec_widgets/widgets/motor_map/motor_map_widget.py

@@ -2,11 +2,13 @@ from __future__ import annotations
 
 import sys
 
+from bec_lib.device import ReadoutPriority
 from qtpy.QtWidgets import QVBoxLayout, QWidget
 
 from bec_widgets.qt_utils.settings_dialog import SettingsDialog
 from bec_widgets.qt_utils.toolbar import DeviceSelectionAction, MaterialIconAction, ModularToolBar
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.widgets.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.device_combobox.device_combobox import DeviceComboBox
 from bec_widgets.widgets.figure import BECFigure
 from bec_widgets.widgets.figure.plots.motor_map.motor_map import MotorMapConfig
@@ -50,10 +52,10 @@ class BECMotorMapWidget(BECWidget, QWidget):
         self.toolbar = ModularToolBar(
             actions={
                 "motor_x": DeviceSelectionAction(
-                    "Motor X:", DeviceComboBox(device_filter="Positioner")
+                    "Motor X:", DeviceComboBox(device_filter=[BECDeviceFilter.POSITIONER])
                 ),
                 "motor_y": DeviceSelectionAction(
-                    "Motor Y:", DeviceComboBox(device_filter="Positioner")
+                    "Motor Y:", DeviceComboBox(device_filter=[BECDeviceFilter.POSITIONER])
                 ),
                 "connect": MaterialIconAction(icon_name="link", tooltip="Connect Motors"),
                 "history": MaterialIconAction(icon_name="history", tooltip="Reset Trace History"),

bec_widgets/widgets/positioner_box/positioner_box.py

@@ -18,6 +18,7 @@ from bec_widgets.qt_utils.compact_popup import CompactPopupWidget
 from bec_widgets.utils import UILoader
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import get_accent_colors, set_theme
+from bec_widgets.widgets.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.device_line_edit.device_line_edit import DeviceLineEdit
 
 logger = bec_logger.logger
@@ -97,7 +98,9 @@ class PositionerBox(BECWidget, CompactPopupWidget):
         self._dialog = QDialog(self)
         self._dialog.setWindowTitle("Positioner Selection")
         layout = QVBoxLayout()
-        line_edit = DeviceLineEdit(self, client=self.client, device_filter="Positioner")
+        line_edit = DeviceLineEdit(
+            self, client=self.client, device_filter=[BECDeviceFilter.POSITIONER]
+        )
         line_edit.textChanged.connect(self.set_positioner)
         layout.addWidget(line_edit)
         close_button = QPushButton("Close")

bec_widgets/widgets/scan_control/scan_control.py

@@ -45,7 +45,7 @@ class ScanControl(BECWidget, QWidget):
     scan_started = Signal()
     scan_selected = Signal(str)
     device_selected = Signal(str)
-    scan_axis = Signal(str, float, float)
+    scan_args = Signal(list)
 
     def __init__(
         self,
@@ -457,8 +457,7 @@ class ScanControl(BECWidget, QWidget):
     def run_scan(self):
         """Starts the selected scan with the given parameters."""
         args, kwargs = self.get_scan_parameters()
-        for device, start, stop in zip(*[iter(args)] * 3):
-            self.scan_axis.emit(device.name, start, stop)
+        self.scan_args.emit(args)
         scan_function = getattr(self.scans, self.comboBox_scan_selection.currentText())
         if callable(scan_function):
             self.scan_started.emit()

bec_widgets/widgets/scan_control/scan_group_box.py

@@ -21,6 +21,7 @@ from qtpy.QtWidgets import (
 )
 
 from bec_widgets.utils.widget_io import WidgetIO
+from bec_widgets.widgets.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.device_line_edit.device_line_edit import DeviceLineEdit
 
 logger = bec_logger.logger
@@ -233,6 +234,7 @@ class ScanGroupBox(QGroupBox):
                 default = None
             widget = widget_class(arg_name=arg_name, default=default)
             if isinstance(widget, DeviceLineEdit):
+                widget.set_device_filter(BECDeviceFilter.DEVICE)
                 self.selected_devices[widget] = ""
                 widget.device_selected.connect(self.emit_device_selected)
             tooltip = item.get("tooltip", None)
@@ -306,7 +308,7 @@ class ScanGroupBox(QGroupBox):
                 try:  # In case that the bundle size changes
                     widget = self.layout.itemAtPosition(i, j).widget()
                     if isinstance(widget, DeviceLineEdit) and device_object:
-                        value = widget.get_device()
+                        value = widget.get_current_device()
                     else:
                         value = WidgetIO.get_value(widget)
                     args.append(value)

bec_widgets/widgets/signal_combobox/register_signal_combobox.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.signal_combobox.signal_combobox_plugin import SignalComboBoxPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(SignalComboBoxPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/signal_combobox/signal_combobox.py

@@ -0,0 +1,115 @@
+from bec_lib.device import Positioner
+from ophyd import Kind
+from qtpy.QtCore import QSize, Signal, Slot
+from qtpy.QtWidgets import QComboBox, QSizePolicy
+
+from bec_widgets.utils.filter_io import ComboBoxFilterHandler, FilterIO
+from bec_widgets.widgets.base_classes.device_signal_input_base import DeviceSignalInputBase
+
+
+class SignalComboBox(DeviceSignalInputBase, QComboBox):
+    """
+    Line edit widget for device input with autocomplete for device names.
+
+    Args:
+        parent: Parent widget.
+        client: BEC client object.
+        config: Device input configuration.
+        gui_id: GUI ID.
+        device_filter: Device filter, name of the device class from BECDeviceFilter and BECReadoutPriority. Check DeviceInputBase for more details.
+        default: Default device name.
+        arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
+    """
+
+    ICON_NAME = "list_alt"
+
+    device_signal_changed = Signal(str)
+
+    def __init__(
+        self,
+        parent=None,
+        client=None,
+        config: DeviceSignalInputBase = None,
+        gui_id: str | None = None,
+        device: str | None = None,
+        signal_filter: str | list[str] | None = None,
+        default: str | None = None,
+        arg_name: str | None = None,
+    ):
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        QComboBox.__init__(self, parent=parent)
+        if arg_name is not None:
+            self.config.arg_name = arg_name
+            self.arg_name = arg_name
+        if default is not None:
+            self.set_device(default)
+
+        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
+        self.setMinimumSize(QSize(100, 0))
+        # We do not consider the config that is passed here, this produced problems
+        # with QtDesigner, since config and input arguments may differ and resolve properly
+        # Implementing this logic and config recoverage is postponed.
+        self.currentTextChanged.connect(self.on_text_changed)
+        if signal_filter is not None:
+            self.set_filter(signal_filter)
+        else:
+            self.set_filter([Kind.hinted, Kind.normal, Kind.config])
+        if device is not None:
+            self.set_device(device)
+        if default is not None:
+            self.set_signal(default)
+
+    def update_signals_from_filters(self):
+        """Update the filters for the combobox"""
+        super().update_signals_from_filters()
+        # pylint: disable=protected-access
+        if FilterIO._find_handler(self) is ComboBoxFilterHandler:
+            if len(self._config_signals) > 0:
+                self.insertItem(
+                    len(self._hinted_signals) + len(self._normal_signals), "Config Signals"
+                )
+                self.model().item(len(self._hinted_signals) + len(self._normal_signals)).setEnabled(
+                    False
+                )
+            if len(self._normal_signals) > 0:
+                self.insertItem(len(self._hinted_signals), "Normal Signals")
+                self.model().item(len(self._hinted_signals)).setEnabled(False)
+            if len(self._hinted_signals) > 0:
+                self.insertItem(0, "Hinted Signals")
+                self.model().item(0).setEnabled(False)
+
+    @Slot(str)
+    def on_text_changed(self, text: str):
+        """Slot for text changed. If a device is selected and the signal is changed and valid it emits a signal.
+        For a positioner, the readback value has to be renamed to the device name.
+
+        Args:
+            text (str): Text in the combobox.
+        """
+        if self.validate_device(self.device) is False:
+            return
+        if self.validate_signal(text) is False:
+            return
+        if text == "readback" and isinstance(self.get_device_object(self.device), Positioner):
+            device_signal = self.device
+        else:
+            device_signal = f"{self.device}_{text}"
+        self.device_signal_changed.emit(device_signal)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    # pylint: disable=import-outside-toplevel
+    from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
+
+    from bec_widgets.utils.colors import set_theme
+
+    app = QApplication([])
+    set_theme("dark")
+    widget = QWidget()
+    widget.setFixedSize(200, 200)
+    layout = QVBoxLayout()
+    widget.setLayout(layout)
+    box = SignalComboBox(device="samx")
+    layout.addWidget(box)
+    widget.show()
+    app.exec_()

bec_widgets/widgets/signal_combobox/signal_combobox.pyproject

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

bec_widgets/widgets/signal_combobox/signal_combobox_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.signal_combobox.signal_combobox import SignalComboBox
+
+DOM_XML = """
+<ui language='c++'>
+    <widget class='SignalComboBox' name='signal_combobox'>
+    </widget>
+</ui>
+"""
+
+
+class SignalComboBoxPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+    def __init__(self):
+        super().__init__()
+        self._form_editor = None
+
+    def createWidget(self, parent):
+        t = SignalComboBox(parent)
+        return t
+
+    def domXml(self):
+        return DOM_XML
+
+    def group(self):
+        return "BEC Input Widgets"
+
+    def icon(self):
+        return designer_material_icon(SignalComboBox.ICON_NAME)
+
+    def includeFile(self):
+        return "signal_combobox"
+
+    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 "SignalComboBox"
+
+    def toolTip(self):
+        return ""
+
+    def whatsThis(self):
+        return self.toolTip()

bec_widgets/widgets/signal_line_edit/register_signal_line_edit.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.signal_line_edit.signal_line_edit_plugin import SignalLineEditPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(SignalLineEditPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()