bec-widgets 0.55.0__py3-none-any.whl → 0.56.1__py3-none-any.whl

bec_widgets/widgets/motor_control/motor_table/motor_table.py

@@ -16,6 +16,7 @@ from qtpy.QtWidgets import (
     QTableWidgetItem,
 )
 
+from bec_widgets.utils import UILoader
 from bec_widgets.widgets.motor_control.motor_control import MotorControlWidget
 
 
@@ -37,25 +38,25 @@ class MotorCoordinateTable(MotorControlWidget):
     def _load_ui(self):
         """Load the UI for the coordinate table."""
         current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "motor_table.ui"), self)
+        self.ui = UILoader().load_ui(os.path.join(current_path, "motor_table.ui"), self)
 
     def _init_ui(self):
         """Initialize the UI"""
         # Setup table behaviour
         self._setup_table()
-        self.table.setSelectionBehavior(QTableWidget.SelectRows)
+        self.ui.table.setSelectionBehavior(QTableWidget.SelectRows)
 
         # for tag columns default tag
         self.tag_counter = 1
 
         # Connect signals and slots
-        self.checkBox_resize_auto.stateChanged.connect(self.resize_table_auto)
-        self.comboBox_mode.currentIndexChanged.connect(self.mode_switch)
+        self.ui.checkBox_resize_auto.stateChanged.connect(self.resize_table_auto)
+        self.ui.comboBox_mode.currentIndexChanged.connect(self.mode_switch)
 
         # Keyboard shortcuts for deleting a row
-        self.delete_shortcut = QShortcut(QKeySequence(Qt.Key_Delete), self.table)
+        self.delete_shortcut = QShortcut(QKeySequence(Qt.Key_Delete), self.ui.table)
         self.delete_shortcut.activated.connect(self.delete_selected_row)
-        self.backspace_shortcut = QShortcut(QKeySequence(Qt.Key_Backspace), self.table)
+        self.backspace_shortcut = QShortcut(QKeySequence(Qt.Key_Backspace), self.ui.table)
         self.backspace_shortcut.activated.connect(self.delete_selected_row)
 
         # Warning message for mode switch enable/disable
@@ -83,13 +84,13 @@ class MotorCoordinateTable(MotorControlWidget):
         self.mode = self.config["motor_control"].get("mode", "Individual")
 
         # Set combobox to default mode
-        self.comboBox_mode.setCurrentText(self.mode)
+        self.ui.comboBox_mode.setCurrentText(self.mode)
 
         self._init_ui()
 
     def _setup_table(self):
         """Setup the table with appropriate headers and configurations."""
-        mode = self.comboBox_mode.currentText()
+        mode = self.ui.comboBox_mode.currentText()
 
         if mode == "Individual":
             self._setup_individual_mode()
@@ -101,14 +102,14 @@ class MotorCoordinateTable(MotorControlWidget):
 
     def _setup_individual_mode(self):
         """Setup the table for individual mode."""
-        self.table.setColumnCount(5)
-        self.table.setHorizontalHeaderLabels(["Show", "Move", "Tag", "X", "Y"])
-        self.table.verticalHeader().setVisible(False)
+        self.ui.table.setColumnCount(5)
+        self.ui.table.setHorizontalHeaderLabels(["Show", "Move", "Tag", "X", "Y"])
+        self.ui.table.verticalHeader().setVisible(False)
 
     def _setup_start_stop_mode(self):
         """Setup the table for start/stop mode."""
-        self.table.setColumnCount(8)
-        self.table.setHorizontalHeaderLabels(
+        self.ui.table.setColumnCount(8)
+        self.ui.table.setHorizontalHeaderLabels(
             [
                 "Show",
                 "Move [start]",
@@ -120,15 +121,15 @@ class MotorCoordinateTable(MotorControlWidget):
                 "Y [end]",
             ]
         )
-        self.table.verticalHeader().setVisible(False)
+        self.ui.table.verticalHeader().setVisible(False)
         # Set flag to track if the coordinate is stat or the end of the entry
         self.is_next_entry_end = False
 
     def mode_switch(self):
         """Switch between individual and start/stop mode."""
-        last_selected_index = self.comboBox_mode.currentIndex()
+        last_selected_index = self.ui.comboBox_mode.currentIndex()
 
-        if self.table.rowCount() > 0 and self.warning_message is True:
+        if self.ui.table.rowCount() > 0 and self.warning_message is True:
             msgBox = QMessageBox()
             msgBox.setIcon(QMessageBox.Critical)
             msgBox.setText(
@@ -138,9 +139,9 @@ class MotorCoordinateTable(MotorControlWidget):
             returnValue = msgBox.exec()
 
             if returnValue is QMessageBox.Cancel:
-                self.comboBox_mode.blockSignals(True)  # Block signals
-                self.comboBox_mode.setCurrentIndex(last_selected_index)
-                self.comboBox_mode.blockSignals(False)  # Unblock signals
+                self.ui.comboBox_mode.blockSignals(True)  # Block signals
+                self.ui.comboBox_mode.setCurrentIndex(last_selected_index)
+                self.ui.comboBox_mode.blockSignals(False)  # Unblock signals
                 return
 
         # Wipe table
@@ -170,7 +171,7 @@ class MotorCoordinateTable(MotorControlWidget):
             y(float): Y coordinate.
         """
 
-        mode = self.comboBox_mode.currentText()
+        mode = self.ui.comboBox_mode.currentText()
         if mode == "Individual":
             checkbox_pos = 0
             button_pos = 1
@@ -181,8 +182,8 @@ class MotorCoordinateTable(MotorControlWidget):
             color = "green"
 
             # Add new row -> new entry
-            row_count = self.table.rowCount()
-            self.table.insertRow(row_count)
+            row_count = self.ui.table.rowCount()
+            self.ui.table.insertRow(row_count)
 
             # Add Widgets
             self._add_widgets(
@@ -213,8 +214,8 @@ class MotorCoordinateTable(MotorControlWidget):
                 color = "blue"
 
                 # Add new row -> new entry
-                row_count = self.table.rowCount()
-                self.table.insertRow(row_count)
+                row_count = self.ui.table.rowCount()
+                self.ui.table.insertRow(row_count)
 
                 # Add Widgets
                 self._add_widgets(
@@ -236,7 +237,7 @@ class MotorCoordinateTable(MotorControlWidget):
 
             elif self.is_next_entry_end is True:  # It is the end position of the entry
                 print("End position")
-                row_count = self.table.rowCount() - 1  # Current row
+                row_count = self.ui.table.rowCount() - 1  # Current row
                 button_pos = 2
                 x_pos = 6
                 y_pos = 7
@@ -294,7 +295,7 @@ class MotorCoordinateTable(MotorControlWidget):
         # Add widgets
         self._add_checkbox(row, checkBox_pos, x_pos, y_pos)
         self._add_move_button(row, button_pos, x_pos, y_pos)
-        self.table.setItem(row, tag_pos, QTableWidgetItem(tag))
+        self.ui.table.setItem(row, tag_pos, QTableWidgetItem(tag))
         self._add_line_edit(x, row, x_pos, x_pos, y_pos, coordinate_reference, color)
         self._add_line_edit(y, row, y_pos, x_pos, y_pos, coordinate_reference, color)
 
@@ -302,10 +303,10 @@ class MotorCoordinateTable(MotorControlWidget):
         self.emit_plot_coordinates(x_pos, y_pos, coordinate_reference, color)
 
         # Connect item edit to emit coordinates
-        self.table.itemChanged.connect(
+        self.ui.table.itemChanged.connect(
             lambda: print(f"item changed from {coordinate_reference} slot \n {x}-{y}-{color}")
         )
-        self.table.itemChanged.connect(
+        self.ui.table.itemChanged.connect(
             lambda: self.emit_plot_coordinates(x_pos, y_pos, coordinate_reference, color)
         )
 
@@ -321,7 +322,7 @@ class MotorCoordinateTable(MotorControlWidget):
         show_checkbox = QCheckBox()
         show_checkbox.setChecked(True)
         show_checkbox.stateChanged.connect(lambda: self.emit_plot_coordinates(x_pos, y_pos))
-        self.table.setCellWidget(row, checkBox_pos, show_checkbox)
+        self.ui.table.setCellWidget(row, checkBox_pos, show_checkbox)
 
     def _add_move_button(self, row: int, button_pos: int, x_pos: int, y_pos: int) -> None:
         """
@@ -334,7 +335,7 @@ class MotorCoordinateTable(MotorControlWidget):
         """
         move_button = QPushButton("Move")
         move_button.clicked.connect(lambda: self.handle_move_button_click(x_pos, y_pos))
-        self.table.setCellWidget(row, button_pos, move_button)
+        self.ui.table.setCellWidget(row, button_pos, move_button)
 
     def _add_line_edit(
         self,
@@ -367,7 +368,7 @@ class MotorCoordinateTable(MotorControlWidget):
         edit.setAlignment(Qt.AlignmentFlag.AlignCenter)
 
         # Add line edit to the table
-        self.table.setCellWidget(row, line_pos, edit)
+        self.ui.table.setCellWidget(row, line_pos, edit)
         edit.textChanged.connect(
             lambda: self.emit_plot_coordinates(x_pos, y_pos, coordinate_reference, color)
         )
@@ -375,10 +376,10 @@ class MotorCoordinateTable(MotorControlWidget):
     def wipe_motor_map_coordinates(self):
         """Wipe the motor map coordinates."""
         try:
-            self.table.itemChanged.disconnect()  # Disconnect all previous connections
+            self.ui.table.itemChanged.disconnect()  # Disconnect all previous connections
         except TypeError:
             print("No previous connections to disconnect")
-        self.table.setRowCount(0)
+        self.ui.table.setRowCount(0)
         reference_tags = ["Individual", "Start", "Stop"]
         for reference_tag in reference_tags:
             self.plot_coordinates_signal.emit([], reference_tag, "green")
@@ -391,7 +392,7 @@ class MotorCoordinateTable(MotorControlWidget):
             y_pos(int): Y position of the coordinate.
         """
         button = self.sender()
-        row = self.table.indexAt(button.pos()).row()
+        row = self.ui.table.indexAt(button.pos()).row()
 
         x = self.get_coordinate(row, x_pos)
         y = self.get_coordinate(row, y_pos)
@@ -410,8 +411,8 @@ class MotorCoordinateTable(MotorControlWidget):
             f"Emitting plot coordinates: x_pos={x_pos}, y_pos={y_pos}, reference_tag={reference_tag}, color={color}"
         )
         coordinates = []
-        for row in range(self.table.rowCount()):
-            show = self.table.cellWidget(row, 0).isChecked()
+        for row in range(self.ui.table.rowCount()):
+            show = self.ui.table.cellWidget(row, 0).isChecked()
             x = self.get_coordinate(row, x_pos)
             y = self.get_coordinate(row, y_pos)
 
@@ -427,27 +428,27 @@ class MotorCoordinateTable(MotorControlWidget):
         Returns:
             float: Value of the coordinate.
         """
-        edit = self.table.cellWidget(row, column)
+        edit = self.ui.table.cellWidget(row, column)
         value = float(edit.text()) if edit and edit.text() != "" else None
         if value:
             return value
 
     def delete_selected_row(self):
         """Delete the selected row from the table."""
-        selected_rows = self.table.selectionModel().selectedRows()
+        selected_rows = self.ui.table.selectionModel().selectedRows()
         for row in selected_rows:
-            self.table.removeRow(row.row())
-        if self.comboBox_mode.currentText() == "Start/Stop":
+            self.ui.table.removeRow(row.row())
+        if self.ui.comboBox_mode.currentText() == "Start/Stop":
             self.emit_plot_coordinates(x_pos=4, y_pos=5, reference_tag="Start", color="blue")
             self.emit_plot_coordinates(x_pos=6, y_pos=7, reference_tag="Stop", color="red")
             self.is_next_entry_end = False
-        elif self.comboBox_mode.currentText() == "Individual":
+        elif self.ui.comboBox_mode.currentText() == "Individual":
             self.emit_plot_coordinates(x_pos=3, y_pos=4, reference_tag="Individual", color="green")
 
     def resize_table_auto(self):
         """Resize the table to fit the contents."""
-        if self.checkBox_resize_auto.isChecked():
-            self.table.resizeColumnsToContents()
+        if self.ui.checkBox_resize_auto.isChecked():
+            self.ui.table.resizeColumnsToContents()
 
     def move_motor(self, x: float, y: float) -> None:
         """

bec_widgets/widgets/motor_control/movement_absolute/movement_absolute.py

@@ -3,8 +3,10 @@ import os
 from qtpy import uic
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtWidgets import QWidget
 
-from bec_widgets.widgets.motor_control.motor_control import MotorControlWidget
+from bec_widgets.utils import UILoader
+from bec_widgets.widgets.motor_control.motor_control import MotorControlErrors, MotorControlWidget
 
 
 class MotorControlAbsolute(MotorControlWidget):
@@ -23,26 +25,26 @@ class MotorControlAbsolute(MotorControlWidget):
     def _load_ui(self):
         """Load the UI from the .ui file."""
         current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "movement_absolute.ui"), self)
+        self.ui = UILoader().load_ui(os.path.join(current_path, "movement_absolute.ui"), self)
 
     def _init_ui(self):
         """Initialize the UI."""
 
         # Check if there are any motors connected
         if self.motor_x is None or self.motor_y is None:
-            self.motorControl_absolute.setEnabled(False)
+            self.ui.motorControl_absolute.setEnabled(False)
             return
 
         # Move to absolute coordinates
-        self.pushButton_go_absolute.clicked.connect(
+        self.ui.pushButton_go_absolute.clicked.connect(
             lambda: self.move_motor_absolute(
-                self.spinBox_absolute_x.value(), self.spinBox_absolute_y.value()
+                self.ui.spinBox_absolute_x.value(), self.ui.spinBox_absolute_y.value()
             )
         )
 
-        self.pushButton_set.clicked.connect(self.save_absolute_coordinates)
-        self.pushButton_save.clicked.connect(self.save_current_coordinates)
-        self.pushButton_stop.clicked.connect(self.motor_thread.stop_movement)
+        self.ui.pushButton_set.clicked.connect(self.save_absolute_coordinates)
+        self.ui.pushButton_save.clicked.connect(self.save_current_coordinates)
+        self.ui.pushButton_stop.clicked.connect(self.motor_thread.stop_movement)
 
         # Enable/Disable GUI
         self.motor_thread.lock_gui.connect(self.enable_motor_controls)
@@ -80,11 +82,11 @@ class MotorControlAbsolute(MotorControlWidget):
         """
 
         # Disable or enable all controls within the motorControl_absolute group box
-        for widget in self.motorControl_absolute.findChildren(QWidget):
+        for widget in self.ui.motorControl_absolute.findChildren(QWidget):
             widget.setEnabled(enable)
 
         # Enable the pushButton_stop if the motor is moving
-        self.pushButton_stop.setEnabled(True)
+        self.ui.pushButton_stop.setEnabled(True)
 
     @pyqtSlot(str, str)
     def change_motors(self, motor_x: str, motor_y: str):
@@ -109,8 +111,8 @@ class MotorControlAbsolute(MotorControlWidget):
         """
         self.precision = precision
         self.config["motor_control"]["precision"] = precision
-        self.spinBox_absolute_x.setDecimals(precision)
-        self.spinBox_absolute_y.setDecimals(precision)
+        self.ui.spinBox_absolute_x.setDecimals(precision)
+        self.ui.spinBox_absolute_y.setDecimals(precision)
 
     def move_motor_absolute(self, x: float, y: float) -> None:
         """
@@ -122,32 +124,32 @@ class MotorControlAbsolute(MotorControlWidget):
         # self._enable_motor_controls(False)
         target_coordinates = (x, y)
         self.motor_thread.move_absolute(self.motor_x, self.motor_y, target_coordinates)
-        if self.checkBox_save_with_go.isChecked():
+        if self.ui.checkBox_save_with_go.isChecked():
             self.save_absolute_coordinates()
 
     def _init_keyboard_shortcuts(self):
         """Initialize the keyboard shortcuts."""
         # Go absolute button
-        self.pushButton_go_absolute.setShortcut("Ctrl+G")
-        self.pushButton_go_absolute.setToolTip("Ctrl+G")
+        self.ui.pushButton_go_absolute.setShortcut("Ctrl+G")
+        self.ui.pushButton_go_absolute.setToolTip("Ctrl+G")
 
         # Set absolute coordinates
-        self.pushButton_set.setShortcut("Ctrl+D")
-        self.pushButton_set.setToolTip("Ctrl+D")
+        self.ui.pushButton_set.setShortcut("Ctrl+D")
+        self.ui.pushButton_set.setToolTip("Ctrl+D")
 
         # Save Current coordinates
-        self.pushButton_save.setShortcut("Ctrl+S")
-        self.pushButton_save.setToolTip("Ctrl+S")
+        self.ui.pushButton_save.setShortcut("Ctrl+S")
+        self.ui.pushButton_save.setToolTip("Ctrl+S")
 
         # Stop Button
-        self.pushButton_stop.setShortcut("Ctrl+X")
-        self.pushButton_stop.setToolTip("Ctrl+X")
+        self.ui.pushButton_stop.setShortcut("Ctrl+X")
+        self.ui.pushButton_stop.setToolTip("Ctrl+X")
 
     def save_absolute_coordinates(self):
         """Emit the setup coordinates from the spinboxes"""
 
-        x, y = round(self.spinBox_absolute_x.value(), self.precision), round(
-            self.spinBox_absolute_y.value(), self.precision
+        x, y = round(self.ui.spinBox_absolute_x.value(), self.precision), round(
+            self.ui.spinBox_absolute_y.value(), self.precision
         )
         self.coordinates_signal.emit((x, y))
 

bec_widgets/widgets/motor_control/movement_relative/movement_relative.py

@@ -7,6 +7,7 @@ from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtGui import QKeySequence
 from qtpy.QtWidgets import QDoubleSpinBox, QShortcut, QWidget
 
+from bec_widgets.utils import UILoader
 from bec_widgets.widgets.motor_control.motor_control import MotorControlWidget
 
 
@@ -27,7 +28,7 @@ class MotorControlRelative(MotorControlWidget):
         """Load the UI from the .ui file."""
         # Loading UI
         current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "movement_relative.ui"), self)
+        self.ui = UILoader().load_ui(os.path.join(current_path, "movement_relative.ui"), self)
 
     def _init_ui(self):
         """Initialize the UI."""
@@ -51,15 +52,15 @@ class MotorControlRelative(MotorControlWidget):
 
         # Update step precision
         self.precision = self.config["motor_control"]["precision"]
-        self.spinBox_precision.setValue(self.precision)
+        self.ui.spinBox_precision.setValue(self.precision)
 
         # Update step sizes
-        self.spinBox_step_x.setValue(self.config["motor_control"]["step_size_x"])
-        self.spinBox_step_y.setValue(self.config["motor_control"]["step_size_y"])
+        self.ui.spinBox_step_x.setValue(self.config["motor_control"]["step_size_x"])
+        self.ui.spinBox_step_y.setValue(self.config["motor_control"]["step_size_y"])
 
         # Checkboxes for keyboard shortcuts and x/y step size link
-        self.checkBox_same_xy.setChecked(self.config["motor_control"]["step_x_y_same"])
-        self.checkBox_enableArrows.setChecked(self.config["motor_control"]["move_with_arrows"])
+        self.ui.checkBox_same_xy.setChecked(self.config["motor_control"]["step_x_y_same"])
+        self.ui.checkBox_enableArrows.setChecked(self.config["motor_control"]["move_with_arrows"])
 
         self._init_ui()
 
@@ -67,30 +68,32 @@ class MotorControlRelative(MotorControlWidget):
         """Initialize the motor control elements"""
 
         # Connect checkbox and spinBoxes
-        self.checkBox_same_xy.stateChanged.connect(self._sync_step_sizes)
-        self.spinBox_step_x.valueChanged.connect(self._update_step_size_x)
-        self.spinBox_step_y.valueChanged.connect(self._update_step_size_y)
+        self.ui.checkBox_same_xy.stateChanged.connect(self._sync_step_sizes)
+        self.ui.spinBox_step_x.valueChanged.connect(self._update_step_size_x)
+        self.ui.spinBox_step_y.valueChanged.connect(self._update_step_size_y)
 
-        self.toolButton_right.clicked.connect(
+        self.ui.toolButton_right.clicked.connect(
             lambda: self.move_motor_relative(self.motor_x, "x", 1)
         )
-        self.toolButton_left.clicked.connect(
+        self.ui.toolButton_left.clicked.connect(
             lambda: self.move_motor_relative(self.motor_x, "x", -1)
         )
-        self.toolButton_up.clicked.connect(lambda: self.move_motor_relative(self.motor_y, "y", 1))
-        self.toolButton_down.clicked.connect(
+        self.ui.toolButton_up.clicked.connect(
+            lambda: self.move_motor_relative(self.motor_y, "y", 1)
+        )
+        self.ui.toolButton_down.clicked.connect(
             lambda: self.move_motor_relative(self.motor_y, "y", -1)
         )
 
         # Switch between key shortcuts active
-        self.checkBox_enableArrows.stateChanged.connect(self._update_arrow_key_shortcuts)
+        self.ui.checkBox_enableArrows.stateChanged.connect(self._update_arrow_key_shortcuts)
         self._update_arrow_key_shortcuts()
 
         # Enable/Disable GUI
         self.motor_thread.lock_gui.connect(self.enable_motor_controls)
 
         # Precision update
-        self.spinBox_precision.valueChanged.connect(lambda x: self._update_precision(x))
+        self.ui.spinBox_precision.valueChanged.connect(lambda x: self._update_precision(x))
 
         # Error messages
         self.motor_thread.motor_error.connect(
@@ -98,7 +101,7 @@ class MotorControlRelative(MotorControlWidget):
         )
 
         # Stop Button
-        self.pushButton_stop.clicked.connect(self.motor_thread.stop_movement)
+        self.ui.pushButton_stop.clicked.connect(self.motor_thread.stop_movement)
 
     def _init_keyboard_shortcuts(self) -> None:
         """Initialize the keyboard shortcuts"""
@@ -107,42 +110,42 @@ class MotorControlRelative(MotorControlWidget):
         increase_x_shortcut = QShortcut(QKeySequence("Ctrl+A"), self)
         decrease_x_shortcut = QShortcut(QKeySequence("Ctrl+Z"), self)
         increase_x_shortcut.activated.connect(
-            lambda: self._change_step_size(self.spinBox_step_x, 2)
+            lambda: self._change_step_size(self.ui.spinBox_step_x, 2)
         )
         decrease_x_shortcut.activated.connect(
-            lambda: self._change_step_size(self.spinBox_step_x, 0.5)
+            lambda: self._change_step_size(self.ui.spinBox_step_x, 0.5)
         )
-        self.spinBox_step_x.setToolTip("Increase step size: Ctrl+A\nDecrease step size: Ctrl+Z")
+        self.ui.spinBox_step_x.setToolTip("Increase step size: Ctrl+A\nDecrease step size: Ctrl+Z")
 
         # Increase/decrease step size for Y motor
         increase_y_shortcut = QShortcut(QKeySequence("Alt+A"), self)
         decrease_y_shortcut = QShortcut(QKeySequence("Alt+Z"), self)
         increase_y_shortcut.activated.connect(
-            lambda: self._change_step_size(self.spinBox_step_y, 2)
+            lambda: self._change_step_size(self.ui.spinBox_step_y, 2)
         )
         decrease_y_shortcut.activated.connect(
-            lambda: self._change_step_size(self.spinBox_step_y, 0.5)
+            lambda: self._change_step_size(self.ui.spinBox_step_y, 0.5)
         )
-        self.spinBox_step_y.setToolTip("Increase step size: Alt+A\nDecrease step size: Alt+Z")
+        self.ui.spinBox_step_y.setToolTip("Increase step size: Alt+A\nDecrease step size: Alt+Z")
 
         # Stop Button
-        self.pushButton_stop.setShortcut("Ctrl+X")
-        self.pushButton_stop.setToolTip("Ctrl+X")
+        self.ui.pushButton_stop.setShortcut("Ctrl+X")
+        self.ui.pushButton_stop.setToolTip("Ctrl+X")
 
     def _update_arrow_key_shortcuts(self) -> None:
         """Update the arrow key shortcuts based on the checkbox state."""
-        if self.checkBox_enableArrows.isChecked():
+        if self.ui.checkBox_enableArrows.isChecked():
             # Set the arrow key shortcuts for motor movement
-            self.toolButton_right.setShortcut(Qt.Key_Right)
-            self.toolButton_left.setShortcut(Qt.Key_Left)
-            self.toolButton_up.setShortcut(Qt.Key_Up)
-            self.toolButton_down.setShortcut(Qt.Key_Down)
+            self.ui.toolButton_right.setShortcut(Qt.Key_Right)
+            self.ui.toolButton_left.setShortcut(Qt.Key_Left)
+            self.ui.toolButton_up.setShortcut(Qt.Key_Up)
+            self.ui.toolButton_down.setShortcut(Qt.Key_Down)
         else:
             # Clear the shortcuts
-            self.toolButton_right.setShortcut("")
-            self.toolButton_left.setShortcut("")
-            self.toolButton_up.setShortcut("")
-            self.toolButton_down.setShortcut("")
+            self.ui.toolButton_right.setShortcut("")
+            self.ui.toolButton_left.setShortcut("")
+            self.ui.toolButton_up.setShortcut("")
+            self.ui.toolButton_down.setShortcut("")
 
     def _update_precision(self, precision: int) -> None:
         """
@@ -150,8 +153,8 @@ class MotorControlRelative(MotorControlWidget):
         Args:
             precision(int): Precision of the coordinates.
         """
-        self.spinBox_step_x.setDecimals(precision)
-        self.spinBox_step_y.setDecimals(precision)
+        self.ui.spinBox_step_x.setDecimals(precision)
+        self.ui.spinBox_step_y.setDecimals(precision)
         self.precision_signal.emit(precision)
 
     def _change_step_size(self, spinBox: QDoubleSpinBox, factor: float) -> None:
@@ -167,21 +170,21 @@ class MotorControlRelative(MotorControlWidget):
 
     def _sync_step_sizes(self):
         """Sync step sizes based on checkbox state."""
-        if self.checkBox_same_xy.isChecked():
-            value = self.spinBox_step_x.value()
-            self.spinBox_step_y.setValue(value)
+        if self.ui.checkBox_same_xy.isChecked():
+            value = self.ui.spinBox_step_x.value()
+            self.ui.spinBox_step_y.setValue(value)
 
     def _update_step_size_x(self):
         """Update step size for x if checkbox is checked."""
-        if self.checkBox_same_xy.isChecked():
-            value = self.spinBox_step_x.value()
-            self.spinBox_step_y.setValue(value)
+        if self.ui.checkBox_same_xy.isChecked():
+            value = self.ui.spinBox_step_x.value()
+            self.ui.spinBox_step_y.setValue(value)
 
     def _update_step_size_y(self):
         """Update step size for y if checkbox is checked."""
-        if self.checkBox_same_xy.isChecked():
-            value = self.spinBox_step_y.value()
-            self.spinBox_step_x.setValue(value)
+        if self.ui.checkBox_same_xy.isChecked():
+            value = self.ui.spinBox_step_y.value()
+            self.ui.spinBox_step_x.setValue(value)
 
     @pyqtSlot(str, str)
     def change_motors(self, motor_x: str, motor_y: str):
@@ -206,11 +209,11 @@ class MotorControlRelative(MotorControlWidget):
         """
 
         # Disable or enable all controls within the motorControl_absolute group box
-        for widget in self.motorControl.findChildren(QWidget):
+        for widget in self.ui.motorControl.findChildren(QWidget):
             widget.setEnabled(disable)
 
         # Enable the pushButton_stop if the motor is moving
-        self.pushButton_stop.setEnabled(True)
+        self.ui.pushButton_stop.setEnabled(True)
 
     def move_motor_relative(self, motor, axis: str, direction: int) -> None:
         """
@@ -221,7 +224,7 @@ class MotorControlRelative(MotorControlWidget):
             direction(int): Direction to move. 1 for positive, -1 for negative.
         """
         if axis == "x":
-            step = direction * self.spinBox_step_x.value()
+            step = direction * self.ui.spinBox_step_x.value()
         elif axis == "y":
-            step = direction * self.spinBox_step_y.value()
+            step = direction * self.ui.spinBox_step_y.value()
         self.motor_thread.move_relative(motor, step)

bec_widgets/widgets/spiral_progress_bar/ring.py

@@ -17,16 +17,16 @@ class RingConnections(BaseModel):
     @field_validator("endpoint")
     def validate_endpoint(cls, v, values):
         slot = values.data["slot"]
-        endpoint = v.endpoint if isinstance(v, EndpointInfo) else v
+        v = v.endpoint if isinstance(v, EndpointInfo) else v
         if slot == "on_scan_progress":
-            if endpoint != "scans/scan_progress":
+            if v != "scans/scan_progress":
                 raise PydanticCustomError(
                     "unsupported endpoint",
                     "For slot 'on_scan_progress', endpoint must be MessageEndpoint.scan_progress or 'scans/scan_progress'.",
                     {"wrong_value": v},
                 )
         elif slot == "on_device_readback":
-            if not endpoint.startswith("internal/devices/readback/"):
+            if not v.startswith("internal/devices/readback/"):
                 raise PydanticCustomError(
                     "unsupported endpoint",
                     "For slot 'on_device_readback', endpoint must be MessageEndpoint.device_readback(device) or 'internal/devices/readback/{device}'.",
@@ -54,8 +54,8 @@ class RingConfig(ConnectionConfig):
         description="Start position for the progress bars in degrees. Default is 90 degrees - corespons to "
         "the top of the ring.",
     )
-    min_value: int | None = Field(0, description="Minimum value for the progress bars.")
-    max_value: int | None = Field(100, description="Maximum value for the progress bars.")
+    min_value: int | float | None = Field(0, description="Minimum value for the progress bars.")
+    max_value: int | float | None = Field(100, description="Maximum value for the progress bars.")
     precision: int | None = Field(3, description="Precision for the progress bars.")
     update_behaviour: Literal["manual", "auto"] | None = Field(
         "auto", description="Update behaviour for the progress bars."

{bec_widgets-0.55.0.dist-info → bec_widgets-0.56.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bec_widgets
-Version: 0.55.0
+Version: 0.56.1
 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
@@ -31,3 +31,5 @@ Provides-Extra: pyqt5
 Requires-Dist: pyqt5>=5.9; extra == 'pyqt5'
 Provides-Extra: pyqt6
 Requires-Dist: pyqt6>=6.7; extra == 'pyqt6'
+Provides-Extra: pyside6
+Requires-Dist: pyside6>=6.7; extra == 'pyside6'