bec-widgets 1.25.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

bec_widgets/widgets/plots/waveform/waveform.pyproject

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

bec_widgets/widgets/plots/waveform/{bec_waveform_widget_plugin.py → waveform_plugin.py}

@@ -1,43 +1,39 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-import os
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
 
-import bec_widgets
 from bec_widgets.utils.bec_designer import designer_material_icon
-from bec_widgets.widgets.plots.waveform.waveform_widget import BECWaveformWidget
+from bec_widgets.widgets.plots.waveform.waveform import Waveform
 
 DOM_XML = """
 <ui language='c++'>
-    <widget class='BECWaveformWidget' name='bec_waveform_widget'>
+    <widget class='Waveform' name='waveform'>
     </widget>
 </ui>
 """
 
-MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
-
-class BECWaveformWidgetPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
+class WaveformPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
         super().__init__()
         self._form_editor = None
 
     def createWidget(self, parent):
-        t = BECWaveformWidget(parent)
+        t = Waveform(parent)
         return t
 
     def domXml(self):
         return DOM_XML
 
     def group(self):
-        return "BEC Plots"
+        return "Plot Widgets"
 
     def icon(self):
-        return designer_material_icon(BECWaveformWidget.ICON_NAME)
+        return designer_material_icon(Waveform.ICON_NAME)
 
     def includeFile(self):
-        return "bec_waveform_widget"
+        return "waveform"
 
     def initialize(self, form_editor):
         self._form_editor = form_editor
@@ -49,10 +45,10 @@ class BECWaveformWidgetPlugin(QDesignerCustomWidgetInterface):  # pragma: no cov
         return self._form_editor is not None
 
     def name(self):
-        return "BECWaveformWidget"
+        return "Waveform"
 
     def toolTip(self):
-        return "BECWaveformWidget"
+        return "Waveform"
 
     def whatsThis(self):
         return self.toolTip()

bec_widgets/widgets/progress/bec_progressbar/bec_progressbar.py

@@ -25,8 +25,7 @@ class BECProgressBar(BECWidget, QWidget):
     ICON_NAME = "page_control"
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, **kwargs):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
-        QWidget.__init__(self, parent=parent)
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
 
         accent_colors = get_accent_colors()
 

bec_widgets/widgets/progress/ring_progress_bar/ring.py

@@ -6,6 +6,7 @@ from bec_lib.endpoints import EndpointInfo, MessageEndpoints
 from pydantic import BaseModel, Field, field_validator
 from pydantic_core import PydanticCustomError
 from qtpy import QtGui
+from qtpy.QtCore import QObject
 
 from bec_widgets.utils import BECConnector, ConnectionConfig
 
@@ -77,7 +78,7 @@ class RingConfig(ProgressbarConfig):
     )
 
 
-class Ring(BECConnector):
+class Ring(BECConnector, QObject):
     USER_ACCESS = [
         "_get_all_rpc",
         "_rpc_id",
@@ -95,7 +96,6 @@ class Ring(BECConnector):
     def __init__(
         self,
         parent=None,
-        parent_progress_widget=None,
         config: RingConfig | dict | None = None,
         client=None,
         gui_id: Optional[str] = None,
@@ -108,9 +108,10 @@ class Ring(BECConnector):
             if isinstance(config, dict):
                 config = RingConfig(**config)
             self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
+        super().__init__(parent=parent, client=client, config=config, gui_id=gui_id, **kwargs)
+
+        self.parent_progress_widget = parent
 
-        self.parent_progress_widget = parent_progress_widget
         self.color = None
         self.background_color = None
         self.start_position = None
@@ -227,9 +228,9 @@ class Ring(BECConnector):
             self.config.connections.slot = None
             self.config.connections.endpoint = None
         elif mode == "scan":
-            self.set_connections("on_scan_progress", "scans/scan_progress")
+            self.set_connections("on_scan_progress", MessageEndpoints.scan_progress())
         elif mode == "device":
-            self.set_connections("on_device_readback", f"internal/devices/readback/{device}")
+            self.set_connections("on_device_readback", MessageEndpoints.device_readback(device))
 
         self.parent_progress_widget.enable_auto_updates(False)
 
@@ -243,12 +244,12 @@ class Ring(BECConnector):
         """
         if self.config.connections.endpoint == endpoint and self.config.connections.slot == slot:
             return
-        else:
+        if self.config.connections.slot is not None:
             self.bec_dispatcher.disconnect_slot(
-                self.config.connections.slot, self.config.connections.endpoint
+                getattr(self, self.config.connections.slot), self.config.connections.endpoint
             )
-            self.config.connections = ProgressbarConnections(slot=slot, endpoint=endpoint)
-            self.bec_dispatcher.connect_slot(getattr(self, slot), endpoint)
+        self.config.connections = ProgressbarConnections(slot=slot, endpoint=endpoint)
+        self.bec_dispatcher.connect_slot(getattr(self, slot), endpoint)
 
     def reset_connection(self):
         """

bec_widgets/widgets/progress/ring_progress_bar/ring_progress_bar.py

@@ -20,7 +20,7 @@ logger = bec_logger.logger
 
 class RingProgressBarConfig(ConnectionConfig):
     color_map: Optional[str] = Field(
-        "magma", description="Color scheme for the progress bars.", validate_default=True
+        "plasma", description="Color scheme for the progress bars.", validate_default=True
     )
     min_number_of_bars: int | None = Field(
         1, description="Minimum number of progress bars to display."
@@ -71,6 +71,10 @@ class RingProgressBarConfig(ConnectionConfig):
 
 
 class RingProgressBar(BECWidget, QWidget):
+    """
+    Show the progress of devices, scans or custom values in the form of ring progress bars.
+    """
+
     PLUGIN = True
     ICON_NAME = "track_changes"
     USER_ACCESS = [
@@ -110,8 +114,7 @@ class RingProgressBar(BECWidget, QWidget):
             if isinstance(config, dict):
                 config = RingProgressBarConfig(**config, widget_class=self.__class__.__name__)
             self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
-        QWidget.__init__(self, parent=parent)
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
 
         self.get_bec_shortcuts()
         self.entry_validator = EntryValidator(self.dev)
@@ -120,7 +123,7 @@ class RingProgressBar(BECWidget, QWidget):
 
         # For updating bar behaviour
         self._auto_updates = True
-        self._rings = None
+        self._rings = []
 
         if num_bars is not None:
             self.config.num_bars = max(
@@ -131,11 +134,12 @@ class RingProgressBar(BECWidget, QWidget):
         self.enable_auto_updates(self.config.auto_updates)
 
     @property
-    def rings(self):
+    def rings(self) -> list[Ring]:
+        """Returns a list of all rings in the progress bar."""
         return self._rings
 
     @rings.setter
-    def rings(self, value):
+    def rings(self, value: list[Ring]):
         self._rings = value
 
     def update_config(self, config: RingProgressBarConfig | dict):
@@ -166,15 +170,15 @@ class RingProgressBar(BECWidget, QWidget):
             )
             for i in range(self.config.num_bars)
         ]
-        self._rings = [
-            Ring(parent_progress_widget=self, config=config) for config in self.config.rings
-        ]
+        self._rings = [Ring(parent=self, config=config) for config in self.config.rings]
 
         if self.config.color_map:
             self.set_colors_from_map(self.config.color_map)
 
         min_size = self._calculate_minimum_size()
         self.setMinimumSize(min_size)
+        # Set outer ring to listen to scan progress
+        self.rings[0].set_update(mode="scan")
         self.update()
 
     def add_ring(self, **kwargs) -> Ring:
@@ -196,7 +200,7 @@ class RingProgressBar(BECWidget, QWidget):
                 directions=-1,
                 **kwargs,
             )
-            ring = Ring(parent_progress_widget=self, config=ring_config)
+            ring = Ring(parent=self, config=ring_config)
             self.config.num_bars += 1
             self._rings.append(ring)
             self.config.rings.append(ring.config)
@@ -215,6 +219,10 @@ class RingProgressBar(BECWidget, QWidget):
             index(int): Index of the progress bar to remove.
         """
         ring = self._find_ring_by_index(index)
+        self._cleanup_ring(ring)
+        self.update()
+
+    def _cleanup_ring(self, ring: Ring) -> None:
         ring.reset_connection()
         self._rings.remove(ring)
         self.config.rings.remove(ring.config)
@@ -222,8 +230,10 @@ class RingProgressBar(BECWidget, QWidget):
         self._reindex_rings()
         if self.config.color_map:
             self.set_colors_from_map(self.config.color_map)
-        del ring
-        self.update()
+        # Remove ring from rpc, afterwards call close event.
+        ring.rpc_register.remove_rpc(ring)
+        ring.deleteLater()
+        # del ring
 
     def _reindex_rings(self):
         """
@@ -289,7 +299,7 @@ class RingProgressBar(BECWidget, QWidget):
                     widget_class="Ring", index=i, start_positions=90 * 16, directions=-1
                 )
                 self.config.rings.append(new_ring_config)
-                new_ring = Ring(parent_progress_widget=self, config=new_ring_config)
+                new_ring = Ring(parent=self, config=new_ring_config)
                 self._rings.append(new_ring)
 
         elif num_bars < current_num_bars:
@@ -639,6 +649,6 @@ class RingProgressBar(BECWidget, QWidget):
             self.on_scan_queue_status, MessageEndpoints.scan_queue_status()
         )
         for ring in self._rings:
-            ring.reset_connection()
+            self._cleanup_ring(ring)
         self._rings.clear()
         super().cleanup()

bec_widgets/widgets/services/bec_queue/bec_queue.py

@@ -6,10 +6,10 @@ from qtpy.QtCore import Property, Qt, Signal, Slot
 from qtpy.QtGui import QColor
 from qtpy.QtWidgets import QHeaderView, QLabel, QTableWidget, QTableWidgetItem, QVBoxLayout, QWidget
 
-from bec_widgets.qt_utils.compact_popup import CompactPopupWidget
-from bec_widgets.qt_utils.toolbar import ModularToolBar, SeparatorAction, WidgetAction
 from bec_widgets.utils.bec_connector import ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.compact_popup import CompactPopupWidget
+from bec_widgets.utils.toolbar import ModularToolBar, SeparatorAction, WidgetAction
 from bec_widgets.widgets.control.buttons.button_abort.button_abort import AbortButton
 from bec_widgets.widgets.control.buttons.button_reset.button_reset import ResetButton
 from bec_widgets.widgets.control.buttons.button_resume.button_resume import ResumeButton
@@ -44,8 +44,9 @@ class BECQueue(BECWidget, CompactPopupWidget):
         refresh_upon_start: bool = True,
         **kwargs,
     ):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
-        CompactPopupWidget.__init__(self, parent=parent, layout=QVBoxLayout)
+        super().__init__(
+            parent=parent, layout=QVBoxLayout, client=client, gui_id=gui_id, config=config, **kwargs
+        )
         self.layout.setSpacing(0)
         self.layout.setContentsMargins(0, 0, 0, 0)
 
@@ -56,6 +57,7 @@ class BECQueue(BECWidget, CompactPopupWidget):
         # self.layout.addWidget(self.table)
         self.table.setColumnCount(4)
         self.table.setHorizontalHeaderLabels(["Scan Number", "Type", "Status", "Cancel"])
+
         header = self.table.horizontalHeader()
         header.setSectionResizeMode(QHeaderView.Stretch)
 
@@ -72,15 +74,16 @@ class BECQueue(BECWidget, CompactPopupWidget):
         """
         Set the toolbar.
         """
-        widget_label = QLabel("Live Queue")
+        widget_label = QLabel(text="Live Queue", parent=self)
         widget_label.setStyleSheet("font-weight: bold;")
         self.toolbar = ModularToolBar(
+            parent=self,
             actions={
                 "widget_label": WidgetAction(widget=widget_label),
                 "separator_1": SeparatorAction(),
-                "resume": WidgetAction(widget=ResumeButton(toolbar=False)),
-                "stop": WidgetAction(widget=StopButton(toolbar=False)),
-                "reset": WidgetAction(widget=ResetButton(toolbar=False)),
+                "resume": WidgetAction(widget=ResumeButton(parent=self, toolbar=False)),
+                "stop": WidgetAction(widget=StopButton(parent=self, toolbar=False)),
+                "reset": WidgetAction(widget=ResetButton(parent=self, toolbar=False)),
             },
             target_widget=self,
         )
@@ -222,7 +225,7 @@ class BECQueue(BECWidget, CompactPopupWidget):
         Returns:
             AbortButton: The abort button.
         """
-        abort_button = AbortButton(scan_id=scan_id)
+        abort_button = AbortButton(parent=self, scan_id=scan_id)
 
         abort_button.button.setText("")
         abort_button.button.setIcon(
@@ -230,7 +233,6 @@ class BECQueue(BECWidget, CompactPopupWidget):
         )
         abort_button.button.setStyleSheet("background-color:  rgba(0,0,0,0) ")
         abort_button.button.setFlat(True)
-
         return abort_button
 
     def delete_selected_row(self):
@@ -238,7 +240,7 @@ class BECQueue(BECWidget, CompactPopupWidget):
         button = self.sender()
         row = self.table.indexAt(button.pos()).row()
         self.table.removeRow(row)
-
+        button.close()
         button.deleteLater()
 
     def reset_content(self):

bec_widgets/widgets/services/bec_status_box/bec_status_box.py

@@ -12,11 +12,11 @@ from bec_lib.utils.import_utils import lazy_import_from
 from qtpy.QtCore import QObject, QTimer, Signal, Slot
 from qtpy.QtWidgets import QHBoxLayout, QTreeWidget, QTreeWidgetItem
 
-from bec_widgets.qt_utils.compact_popup import CompactPopupWidget
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.compact_popup import CompactPopupWidget
 from bec_widgets.widgets.services.bec_status_box.status_item import StatusItem
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     from bec_lib.client import BECClient
 
 # TODO : Put normal imports back when Pydantic gets faster
@@ -89,8 +89,7 @@ class BECStatusBox(BECWidget, CompactPopupWidget):
         gui_id: str = None,
         **kwargs,
     ):
-        super().__init__(client=client, gui_id=gui_id, **kwargs)
-        CompactPopupWidget.__init__(self, parent=parent, layout=QHBoxLayout)
+        super().__init__(parent=parent, layout=QHBoxLayout, client=client, gui_id=gui_id, **kwargs)
 
         self.box_name = box_name
         self.status_container = defaultdict(lambda: {"info": None, "item": None, "widget": None})

bec_widgets/widgets/services/device_browser/device_browser.py

@@ -13,6 +13,10 @@ from bec_widgets.widgets.services.device_browser.device_item import DeviceItem
 
 
 class DeviceBrowser(BECWidget, QWidget):
+    """
+    DeviceBrowser is a widget that displays all available devices in the current BEC session.
+    """
+
     device_update: Signal = Signal()
     PLUGIN = True
     ICON_NAME = "lists"
@@ -25,8 +29,7 @@ class DeviceBrowser(BECWidget, QWidget):
         gui_id: Optional[str] = None,
         **kwargs,
     ) -> None:
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
-        QWidget.__init__(self, parent)
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
 
         self.get_bec_shortcuts()
         self.ui = None

bec_widgets/widgets/services/device_browser/device_item/device_item.py

@@ -7,7 +7,7 @@ from qtpy.QtCore import QMimeData, Qt
 from qtpy.QtGui import QDrag
 from qtpy.QtWidgets import QApplication, QHBoxLayout, QLabel, QWidget
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     from qtpy.QtGui import QMouseEvent
 
 logger = bec_logger.logger

bec_widgets/widgets/utility/logpanel/logpanel.py

@@ -1,4 +1,4 @@
-""" Module for a LogPanel widget to display BEC log messages """
+"""Module for a LogPanel widget to display BEC log messages"""
 
 from __future__ import annotations
 
@@ -15,7 +15,8 @@ from bec_lib.connector import ConnectorBase
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import LogLevel, bec_logger
 from bec_lib.messages import LogMessage, StatusMessage
-from qtpy.QtCore import QDateTime, Qt, Signal  # type: ignore
+from PySide6.QtCore import QObject
+from qtpy.QtCore import QDateTime, Qt, Signal
 from qtpy.QtGui import QFont
 from qtpy.QtWidgets import (
     QApplication,
@@ -34,8 +35,8 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 
-from bec_widgets.qt_utils.error_popups import SafeSlot
 from bec_widgets.utils.colors import get_theme_palette, set_theme
+from bec_widgets.utils.error_popups import SafeSlot
 from bec_widgets.widgets.editors.text_box.text_box import TextBox
 from bec_widgets.widgets.services.bec_status_box.bec_status_box import BECServiceStatusMixin
 from bec_widgets.widgets.utility.logpanel._util import (
@@ -51,8 +52,8 @@ from bec_widgets.widgets.utility.logpanel._util import (
     simple_color_format,
 )
 
-if TYPE_CHECKING:
-    from PySide6.QtCore import SignalInstance
+if TYPE_CHECKING:  # pragma: no cover
+    from qtpy.QtCore import SignalInstance
 
 logger = bec_logger.logger
 
@@ -68,20 +69,22 @@ DEFAULT_LOG_COLORS = {
 }
 
 
-class BecLogsQueue:
+class BecLogsQueue(QObject):
     """Manages getting logs from BEC Redis and formatting them for display"""
 
+    new_message = Signal()
+
     def __init__(
         self,
+        parent: QObject | None,
         conn: ConnectorBase,
-        new_message_signal: SignalInstance,
         maxlen: int = 1000,
         line_formatter: LineFormatter = noop_format,
     ) -> None:
+        super().__init__(parent=parent)
         self._timestamp_start: QDateTime | None = None
         self._timestamp_end: QDateTime | None = None
         self._conn = conn
-        self._new_message_signal: SignalInstance | None = new_message_signal
         self._max_length = maxlen
         self._data: deque[LogMessage] = deque([], self._max_length)
         self._display_queue: deque[str] = deque([], self._max_length)
@@ -91,9 +94,9 @@ class BecLogsQueue:
         self._set_formatter_and_update_filter(line_formatter)
         self._conn.register([MessageEndpoints.log()], None, self._process_incoming_log_msg)
 
-    def disconnect(self):
+    def unsub_from_redis(self):
+        """Stop listening to the Redis log stream"""
         self._conn.unregister([MessageEndpoints.log()], None, self._process_incoming_log_msg)
-        self._new_message_signal.disconnect()
 
     def _process_incoming_log_msg(self, msg: dict):
         try:
@@ -101,10 +104,9 @@ class BecLogsQueue:
             self._data.append(_msg)
             if self.filter is None or self.filter(_msg):
                 self._display_queue.append(self._line_formatter(_msg))
-                if self._new_message_signal:
-                    self._new_message_signal.emit()
-        except Exception:
-            logger.warning("Error in LogPanel incoming message callback!")
+                self.new_message.emit()
+        except Exception as e:
+            logger.warning(f"Error in LogPanel incoming message callback: {e}")
 
     def _set_formatter_and_update_filter(self, line_formatter: LineFormatter = noop_format):
         self._line_formatter: LineFormatter = line_formatter
@@ -144,6 +146,7 @@ class BecLogsQueue:
 
     @property
     def filter(self) -> LineFilter:
+        """A function which filters a log message based on all applied criteria"""
         thresh = LogLevel[self._log_level].value if self._log_level is not None else 0
         return self._combine_filters(
             partial(level_filter, thresh=thresh),
@@ -153,6 +156,7 @@ class BecLogsQueue:
         )
 
     def update_level_filter(self, level: str):
+        """Change the log-level of the level filter"""
         if level not in [l.name for l in LogLevel]:
             logger.error(f"Logging level {level} unrecognized for filter!")
             return
@@ -160,34 +164,42 @@ class BecLogsQueue:
         self._set_formatter_and_update_filter(self._line_formatter)
 
     def update_search_filter(self, search_query: Pattern | str | None = None):
+        """Change the string or regex to filter against"""
         self._search_query = search_query
         self._set_formatter_and_update_filter(self._line_formatter)
 
     def update_time_filter(self, start: QDateTime | None, end: QDateTime | None):
+        """Change the start and/or end times to filter against"""
         self._timestamp_start = start
         self._timestamp_end = end
         self._set_formatter_and_update_filter(self._line_formatter)
 
     def update_service_filter(self, services: set[str]):
+        """Change the selected services to display"""
         self._selected_services = services
         self._set_formatter_and_update_filter(self._line_formatter)
 
     def update_line_formatter(self, line_formatter: LineFormatter):
+        """Update the formatter"""
         self._set_formatter_and_update_filter(line_formatter)
 
     def display_all(self) -> str:
+        """Return formatted output for all log messages"""
         return "\n".join(self._queue_formatter(self._data.copy()))
 
     def format_new(self):
+        """Return formatted output for the display queue"""
         res = "\n".join(self._display_queue)
         self._display_queue = deque([], self._max_length)
         return res
 
     def clear_logs(self):
+        """Clear the cache and display queue"""
         self._data = deque([])
         self._display_queue = deque([])
 
     def fetch_history(self):
+        """Fetch all available messages from Redis"""
         self._data = deque(
             item["data"]
             for item in self._conn.xread(
@@ -196,14 +208,16 @@ class BecLogsQueue:
         )
 
     def unique_service_names_from_history(self) -> set[str]:
+        """Go through the log history to determine active service names"""
         return set(msg.log_msg["service_name"] for msg in self._data)
 
 
 class LogPanelToolbar(QWidget):
 
-    services_selected: pyqtBoundSignal = Signal(set)
+    services_selected: SignalInstance = Signal(set)
 
     def __init__(self, parent: QWidget | None = None) -> None:
+        """A toolbar for the logpanel, mainly used for managing the states of filters"""
         super().__init__(parent)
 
         # in unix time
@@ -337,6 +351,7 @@ class LogPanelToolbar(QWidget):
     def service_list_update(
         self, services_info: dict[str, StatusMessage], services_from_history: set[str], *_, **__
     ):
+        """Change the list of services which can be selected"""
         self._unique_service_names = set([s.split("/")[0] for s in services_info.keys()])
         self._unique_service_names |= services_from_history
         if self._services_selected is None:
@@ -396,10 +411,11 @@ class LogPanel(TextBox):
         self._update_colors()
         self._service_status = service_status or BECServiceStatusMixin(self, client=self.client)  # type: ignore
         self._log_manager = BecLogsQueue(
+            parent,
             self.client.connector,  # type: ignore
-            new_message_signal=self._new_messages,
             line_formatter=partial(simple_color_format, colors=self._colors),
         )
+        self._log_manager.new_message.connect(self._new_messages)
 
         self.toolbar = LogPanelToolbar(parent=parent)
         self.toolbar_area = QScrollArea()
@@ -513,7 +529,10 @@ class LogPanel(TextBox):
 
     def cleanup(self):
         self._service_status.cleanup()
-        self._log_manager.disconnect()
+        self._log_manager.unsub_from_redis()
+        self._log_manager.new_message.disconnect(self._new_messages)
+        self._new_messages.disconnect(self._on_append)
+        super().cleanup()
 
 
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/widgets/utility/spinbox/decimal_spinbox.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import sys
 
 from bec_qthemes import material_icon
@@ -30,10 +32,8 @@ class BECSpinBox(BECWidget, QDoubleSpinBox):
     ) -> None:
         if config is None:
             config = ConnectionConfig(widget_class=self.__class__.__name__)
-        super().__init__(client=client, gui_id=gui_id, config=config, **kwargs)
-        QDoubleSpinBox.__init__(self, parent=parent)
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
 
-        self.setObjectName("BECSpinBox")
         # Make the widget as compact as possible horizontally.
         self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
         self.setAlignment(Qt.AlignHCenter)

bec_widgets/widgets/utility/spinner/spinner.py

@@ -23,8 +23,8 @@ class SpinnerWidget(QWidget):
         self.timer = QTimer(self)
         self.timer.timeout.connect(self.rotate)
         self.time = 0
-        self.duration = 50
-        self.speed = 50
+        self.duration = 40
+        self.speed = 40
         self._started = False
 
     def start(self):

bec_widgets/widgets/utility/visual/color_button/color_button.py

@@ -6,7 +6,7 @@ import pyqtgraph as pg
 from qtpy.QtCore import Qt, Signal
 from qtpy.QtWidgets import QHBoxLayout, QWidget
 
-from bec_widgets.qt_utils.error_popups import SafeSlot
+from bec_widgets.utils.error_popups import SafeSlot
 
 
 class ColorButton(QWidget):

bec_widgets/widgets/utility/visual/colormap_widget/colormap_widget.py

@@ -9,18 +9,16 @@ from bec_widgets.utils.bec_widget import BECWidget
 class BECColorMapWidget(BECWidget, QWidget):
     colormap_changed_signal = Signal(str)
     ICON_NAME = "palette"
-    USER_ACCESS = ["colormap"]
     PLUGIN = True
+    RPC = False
 
-    def __init__(self, parent=None, cmap: str = "magma", **kwargs):
-        super().__init__(**kwargs)
-        QWidget.__init__(self, parent=parent)
-
+    def __init__(self, parent=None, cmap: str = "plasma", **kwargs):
+        super().__init__(parent=parent, **kwargs)
         # Create the ColorMapButton
         self.button = ColorMapButton()
 
         # Set the size policy and minimum width
-        size_policy = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
+        size_policy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
         self.button.setSizePolicy(size_policy)
         self.button.setMinimumWidth(100)
         self.button.setMinimumHeight(30)