bec-widgets 0.112.1__py3-none-any.whl → 0.113.0__py3-none-any.whl

bec_widgets/qt_utils/toolbar.py

@@ -9,7 +9,7 @@ from typing import Literal
 from bec_qthemes._icon.material_icons import material_icon
 from qtpy.QtCore import QSize
 from qtpy.QtGui import QAction, QColor, QIcon
-from qtpy.QtWidgets import QHBoxLayout, QLabel, QMenu, QToolBar, QToolButton, QWidget
+from qtpy.QtWidgets import QHBoxLayout, QLabel, QMenu, QSizePolicy, QToolBar, QToolButton, QWidget
 
 import bec_widgets
 
@@ -165,7 +165,9 @@ class WidgetAction(ToolBarAction):
         layout.setContentsMargins(0, 0, 0, 0)
         if self.label is not None:
             label = QLabel(f"{self.label}")
+            label.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
             layout.addWidget(label)
+        self.widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
         layout.addWidget(self.widget)
         toolbar.addWidget(widget)
 

bec_widgets/utils/bec_signal_proxy.py

@@ -0,0 +1,54 @@
+""" This custom class is a thin wrapper around the SignalProxy class to allow signal calls to be blocked.
+Unblocking the proxy needs to be done through the slot unblock_proxy. The most likely use case for this class is
+when the callback function is potentially initiating a slower progress, i.e. requesting a data analysis routine to 
+analyse data. Requesting a new fit may lead to request piling up and an overall slow done of performance. This proxy
+will allow you to decide by yourself when to unblock and execute the callback again."""
+
+from pyqtgraph import SignalProxy
+from qtpy.QtCore import Signal, Slot
+
+
+class BECSignalProxy(SignalProxy):
+    """Thin wrapper around the SignalProxy class to allow signal calls to be blocked, but args still being stored
+
+    Args:
+        *args: Arguments to pass to the SignalProxy class
+        rateLimit (int): The rateLimit of the proxy
+        **kwargs: Keyword arguments to pass to the SignalProxy class
+
+    Example:
+    >>> proxy = BECSignalProxy(signal, rate_limit=25, slot=callback)"""
+
+    is_blocked = Signal(bool)
+
+    def __init__(self, *args, rateLimit=25, **kwargs):
+        super().__init__(*args, rateLimit=rateLimit, **kwargs)
+        self._blocking = False
+        self.old_args = None
+        self.new_args = None
+
+    @property
+    def blocked(self):
+        """Returns if the proxy is blocked"""
+        return self._blocking
+
+    @blocked.setter
+    def blocked(self, value: bool):
+        self._blocking = value
+        self.is_blocked.emit(value)
+
+    def signalReceived(self, *args):
+        """Receive signal, store the args and call signalReceived from the parent class if not blocked"""
+        self.new_args = args
+        if self.blocked is True:
+            return
+        self.blocked = True
+        self.old_args = args
+        super().signalReceived(*args)
+
+    @Slot()
+    def unblock_proxy(self):
+        """Unblock the proxy, and call the signalReceived method in case there was an update of the args."""
+        self.blocked = False
+        if self.new_args != self.old_args:
+            self.signalReceived(*self.new_args)

bec_widgets/utils/linear_region_selector.py

@@ -23,11 +23,14 @@ class LinearRegionWrapper(QObject):
         self, plot_item: pg.PlotItem, color: QColor = None, hover_color: QColor = None, parent=None
     ):
         super().__init__(parent)
+        self.is_log_x = None
         self._edge_width = 2
         self.plot_item = plot_item
         self.linear_region_selector = pg.LinearRegionItem()
         self.proxy = None
         self.change_roi_color((color, hover_color))
+        self.plot_item.ctrl.logXCheck.checkStateChanged.connect(self.check_log)
+        self.plot_item.ctrl.logYCheck.checkStateChanged.connect(self.check_log)
 
     # Slot for changing the color of the region selector (edge and fill)
     @Slot(tuple)
@@ -63,9 +66,18 @@ class LinearRegionWrapper(QObject):
         self.plot_item.removeItem(self.linear_region_selector)
 
     def _region_change_proxy(self):
-        """Emit the region change signal"""
-        region = self.linear_region_selector.getRegion()
-        self.region_changed.emit(region)
+        """Emit the region change signal. If the plot is in log mode, convert the region to log."""
+        x_low, x_high = self.linear_region_selector.getRegion()
+        if self.is_log_x:
+            x_low = 10**x_low
+            x_high = 10**x_high
+        self.region_changed.emit((x_low, x_high))
+
+    @Slot()
+    def check_log(self):
+        """Check if the plot is in log mode."""
+        self.is_log_x = self.plot_item.ctrl.logXCheck.isChecked()
+        self.is_log_y = self.plot_item.ctrl.logYCheck.isChecked()
 
     def cleanup(self):
         """Cleanup the widget."""

bec_widgets/utils/plot_indicator_items.py

@@ -0,0 +1,247 @@
+"""Module to create an arrow item for a pyqtgraph plot"""
+
+import numpy as np
+import pyqtgraph as pg
+from bec_lib.logger import bec_logger
+from qtpy.QtCore import QObject, QPointF, Signal, Slot
+
+from bec_widgets.utils.colors import get_accent_colors
+
+logger = bec_logger.logger
+
+
+class BECIndicatorItem(QObject):
+
+    def __init__(self, plot_item: pg.PlotItem = None, parent=None):
+        super().__init__(parent=parent)
+        self.accent_colors = get_accent_colors()
+        self.plot_item = plot_item
+        self._item_on_plot = False
+        self._pos = None
+        self.is_log_x = False
+        self.is_log_y = False
+
+    @property
+    def item_on_plot(self) -> bool:
+        """Returns if the item is on the plot"""
+        return self._item_on_plot
+
+    @item_on_plot.setter
+    def item_on_plot(self, value: bool) -> None:
+        self._item_on_plot = value
+
+    def add_to_plot(self) -> None:
+        """Add the item to the plot"""
+        raise NotImplementedError("Method add_to_plot not implemented")
+
+    def remove_from_plot(self) -> None:
+        """Remove the item from the plot"""
+        raise NotImplementedError("Method remove_from_plot not implemented")
+
+    def set_position(self, pos) -> None:
+        """This method should implement the logic to set the position of the
+        item on the plot. Depending on the child class, the position can be
+        a tuple (x,y) or a single value, i.e. x position where y position is fixed.
+        """
+        raise NotImplementedError("Method set_position not implemented")
+
+    def check_log(self):
+        """Checks if the x or y axis is in log scale and updates the internal state accordingly."""
+        self.is_log_x = self.plot_item.ctrl.logXCheck.isChecked()
+        self.is_log_y = self.plot_item.ctrl.logYCheck.isChecked()
+        self.set_position(self._pos)
+
+
+class BECTickItem(BECIndicatorItem):
+    """Class to create a tick item which can be added to a pyqtgraph plot.
+    The tick item will be added to the layout of the plot item and can be used to indicate
+    a position"""
+
+    position_changed = Signal(float)
+    position_changed_str = Signal(str)
+
+    def __init__(self, plot_item: pg.PlotItem = None, parent=None):
+        super().__init__(plot_item=plot_item, parent=parent)
+        self.tick_item = pg.TickSliderItem(
+            parent=parent, allowAdd=False, allowRemove=False, orientation="bottom"
+        )
+        self.tick_item.skip_auto_range = True
+        self.tick = None
+        self._pos = 0.0
+        self._range = [0, 1]
+
+    @Slot(float)
+    def set_position(self, pos: float) -> None:
+        """Set the x position of the tick item
+
+        Args:
+            pos (float): The position of the tick item.
+        """
+        if self.is_log_x is True:
+            pos = pos if pos > 0 else 1e-10
+            pos = np.log10(pos)
+        self._pos = pos
+        view_box = self.plot_item.getViewBox()  # Ensure you're accessing the correct view box
+        view_range = view_box.viewRange()[0]
+        self.update_range(self.plot_item.vb, view_range)
+        self.position_changed.emit(pos)
+        self.position_changed_str.emit(str(pos))
+
+    @Slot()
+    def update_range(self, _, view_range: tuple[float, float]) -> None:
+        """Update the range of the tick item
+
+        Args:
+            vb (pg.ViewBox): The view box.
+            viewRange (tuple): The view range.
+        """
+        if self._pos < view_range[0] or self._pos > view_range[1]:
+            self.tick_item.setVisible(False)
+        else:
+            self.tick_item.setVisible(True)
+
+        if self.tick_item.isVisible():
+            origin = self.tick_item.tickSize / 2.0
+            length = self.tick_item.length
+
+            length_with_padding = length + self.tick_item.tickSize + 2
+
+            self._range = view_range
+            tick_with_padding = (self._pos - view_range[0]) / (view_range[1] - view_range[0])
+            tick_value = (tick_with_padding * length_with_padding - origin) / length
+            self.tick_item.setTickValue(self.tick, tick_value)
+
+    def add_to_plot(self):
+        """Add the tick item to the view box or plot item."""
+        if self.plot_item is None:
+            return
+
+        self.plot_item.layout.addItem(self.tick_item, 2, 1)
+        self.tick_item.setOrientation("top")
+        self.tick = self.tick_item.addTick(0, movable=False, color=self.accent_colors.highlight)
+        self.update_tick_pos_y()
+        self.plot_item.vb.sigXRangeChanged.connect(self.update_range)
+        self.plot_item.ctrl.logXCheck.checkStateChanged.connect(self.check_log)
+        self.plot_item.ctrl.logYCheck.checkStateChanged.connect(self.check_log)
+        self.plot_item.vb.geometryChanged.connect(self.update_tick_pos_y)
+        self.item_on_plot = True
+
+    @Slot()
+    def update_tick_pos_y(self):
+        """Update tick position, while respecting the tick_item coordinates"""
+        pos = self.tick.pos()
+        pos = self.tick_item.mapToParent(pos)
+        new_pos = self.plot_item.vb.geometry().bottom()
+        new_pos = self.tick_item.mapFromParent(QPointF(pos.x(), new_pos))
+        self.tick.setPos(new_pos)
+
+    def remove_from_plot(self):
+        """Remove the tick item from the view box or plot item."""
+        if self.plot_item is not None and self.item_on_plot is True:
+            self.plot_item.vb.sigXRangeChanged.disconnect(self.update_range)
+            self.plot_item.ctrl.logXCheck.checkStateChanged.disconnect(self.check_log)
+            self.plot_item.ctrl.logYCheck.checkStateChanged.disconnect(self.check_log)
+            if self.plot_item.layout is not None:
+                self.plot_item.layout.removeItem(self.tick_item)
+        self.item_on_plot = False
+
+    def cleanup(self) -> None:
+        """Cleanup the item"""
+        self.remove_from_plot()
+        if self.tick_item is not None:
+            self.tick_item.close()
+            self.tick_item.deleteLater()
+            self.tick_item = None
+
+
+class BECArrowItem(BECIndicatorItem):
+    """Class to create an arrow item which can be added to a pyqtgraph plot.
+    It can be either added directly to a view box or a plot item.
+    To add the arrow item to a view box or plot item, use the add_to_plot method.
+
+    Args:
+        view_box (pg.ViewBox | pg.PlotItem): The view box or plot item to which the arrow item should be added.
+        parent (QObject): The parent object.
+
+    Signals:
+        position_changed (tuple[float, float]): Signal emitted when the position of the arrow item has changed.
+        position_changed_str (tuple[str, str]): Signal emitted when the position of the arrow item has changed.
+    """
+
+    # Signal to emit if the position of the arrow item has changed
+    position_changed = Signal(tuple)
+    position_changed_str = Signal(tuple)
+
+    def __init__(self, plot_item: pg.PlotItem = None, parent=None):
+        super().__init__(plot_item=plot_item, parent=parent)
+        self.arrow_item = pg.ArrowItem(parent=parent)
+        self.arrow_item.skip_auto_range = True
+        self._pos = (0, 0)
+        self.arrow_item.setVisible(False)
+
+    @Slot(dict)
+    def set_style(self, style: dict) -> None:
+        """Set the style of the arrow item
+
+        Args:
+            style (dict): The style of the arrow item. Dictionary with key,
+                          value pairs which are accepted from the pg.ArrowItem.setStyle method.
+        """
+        self.arrow_item.setStyle(**style)
+
+    @Slot(tuple)
+    def set_position(self, pos: tuple[float, float]) -> None:
+        """Set the position of the arrow item
+
+        Args:
+            pos (tuple): The position of the arrow item as a tuple (x, y).
+        """
+        self._pos = pos
+        pos_x = pos[0]
+        pos_y = pos[1]
+        if self.is_log_x is True:
+            pos_x = np.log10(pos_x) if pos_x > 0 else 1e-10
+            view_box = self.plot_item.getViewBox()  # Ensure you're accessing the correct view box
+            view_range = view_box.viewRange()[0]
+            # Avoid values outside the view range in the negative direction. Otherwise, there is
+            # a buggy behaviour of the arrow item and it appears at the wrong position.
+            if pos_x < view_range[0]:
+                pos_x = view_range[0]
+        if self.is_log_y is True:
+            pos_y = np.log10(pos_y) if pos_y > 0 else 1e-10
+
+        self.arrow_item.setPos(pos_x, pos_y)
+        self.position_changed.emit(self._pos)
+        self.position_changed_str.emit((str(self._pos[0]), str(self._pos[1])))
+
+    def add_to_plot(self):
+        """Add the arrow item to the view box or plot item."""
+        if not self.arrow_item:
+            logger.warning(f"Arrow item was already destroyed, cannot be created")
+            return
+
+        self.arrow_item.setStyle(
+            angle=-90,
+            pen=pg.mkPen(self.accent_colors.emergency, width=1),
+            brush=pg.mkBrush(self.accent_colors.highlight),
+            headLen=20,
+        )
+        self.arrow_item.setVisible(True)
+        if self.plot_item is not None:
+            self.plot_item.addItem(self.arrow_item)
+            self.plot_item.ctrl.logXCheck.checkStateChanged.connect(self.check_log)
+            self.plot_item.ctrl.logYCheck.checkStateChanged.connect(self.check_log)
+            self.item_on_plot = True
+
+    def remove_from_plot(self):
+        """Remove the arrow item from the view box or plot item."""
+        if self.plot_item is not None and self.item_on_plot is True:
+            self.plot_item.ctrl.logXCheck.checkStateChanged.disconnect(self.check_log)
+            self.plot_item.ctrl.logYCheck.checkStateChanged.disconnect(self.check_log)
+            self.plot_item.removeItem(self.arrow_item)
+        self.item_on_plot = False
+
+    def cleanup(self) -> None:
+        """Cleanup the item"""
+        self.remove_from_plot()
+        self.arrow_item = None

bec_widgets/widgets/bec_status_box/bec_status_box.py

@@ -14,7 +14,7 @@ from qtpy.QtCore import QObject, QTimer, Signal, Slot
 from qtpy.QtWidgets import QHBoxLayout, QTreeWidget, QTreeWidgetItem, QWidget
 
 from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.colors import apply_theme
+from bec_widgets.utils.colors import set_theme
 from bec_widgets.widgets.bec_status_box.status_item import StatusItem
 
 if TYPE_CHECKING:
@@ -303,17 +303,13 @@ class BECStatusBox(BECWidget, QWidget):
         return super().cleanup()
 
 
-def main():
-    """Main method to run the BECStatusBox widget."""
-    # pylint: disable=import-outside-toplevel
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
     from qtpy.QtWidgets import QApplication
 
     app = QApplication(sys.argv)
-    apply_theme("dark")
+    set_theme("dark")
     main_window = BECStatusBox()
     main_window.show()
     sys.exit(app.exec())
-
-
-if __name__ == "__main__":
-    main()

bec_widgets/widgets/bec_status_box/status_item.py

@@ -6,11 +6,13 @@ import os
 from datetime import datetime
 
 from bec_lib.utils.import_utils import lazy_import_from
+from bec_qthemes import material_icon
 from qtpy.QtCore import Qt, Slot
-from qtpy.QtGui import QIcon
+from qtpy.QtGui import QIcon, QPainter
 from qtpy.QtWidgets import QDialog, QHBoxLayout, QLabel, QVBoxLayout, QWidget
 
 import bec_widgets
+from bec_widgets.utils.colors import get_accent_colors
 
 # TODO : Put normal imports back when Pydantic gets faster
 BECStatus = lazy_import_from("bec_lib.messages", ("BECStatus",))
@@ -21,11 +23,11 @@ MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 class IconsEnum(enum.Enum):
     """Enum class for icons in the status item widget."""
 
-    RUNNING = os.path.join(MODULE_PATH, "assets", "status_icons", "running.svg")
-    BUSY = os.path.join(MODULE_PATH, "assets", "status_icons", "refresh.svg")
-    IDLE = os.path.join(MODULE_PATH, "assets", "status_icons", "warning.svg")
-    ERROR = os.path.join(MODULE_PATH, "assets", "status_icons", "error.svg")
-    NOTCONNECTED = os.path.join(MODULE_PATH, "assets", "status_icons", "not_connected.svg")
+    RUNNING = "done_outline"
+    BUSY = "progress_activity"
+    IDLE = "progress_activity"
+    ERROR = "emergency_home"
+    NOTCONNECTED = "signal_disconnected"
 
 
 class StatusItem(QWidget):
@@ -43,13 +45,13 @@ class StatusItem(QWidget):
             raise ValueError(
                 "Please initialize the StatusItem with a BECServiceInfoContainer for config, received None."
             )
+        self.accent_colors = get_accent_colors()
         self.config = config
         self.parent = parent
         self.layout = None
         self._label = None
         self._icon = None
         self.icon_size = (24, 24)
-
         self._popup_label_ref = {}
         self.init_ui()
 
@@ -97,8 +99,15 @@ class StatusItem(QWidget):
 
     def set_status(self) -> None:
         """Set the status icon for the status item widget."""
-        icon_path = IconsEnum[self.config.status].value
-        icon = QIcon(icon_path)
+        status = self.config.status
+        if status in ["RUNNING", "BUSY"]:
+            color = self.accent_colors.success
+        elif status == "IDLE":
+            color = self.accent_colors.warning
+        elif status in ["ERROR", "NOTCONNECTED"]:
+            color = self.accent_colors.emergency
+        icon = QIcon(material_icon(IconsEnum[status].value, filled=True, color=color))
+
         self._icon.setPixmap(icon.pixmap(*self.icon_size))
         self._icon.setAlignment(Qt.AlignmentFlag.AlignRight)
 

bec_widgets/widgets/dap_combo_box/dap_combo_box.py

@@ -124,6 +124,7 @@ class DapComboBox(BECWidget, QWidget):
             x_axis(str): X axis.
         """
         self.x_axis = x_axis
+        self._update_current_fit(self.fit_model_combobox.currentText())
 
     @Slot(str)
     def select_y_axis(self, y_axis: str):
@@ -133,6 +134,7 @@ class DapComboBox(BECWidget, QWidget):
             y_axis(str): Y axis.
         """
         self.y_axis = y_axis
+        self._update_current_fit(self.fit_model_combobox.currentText())
 
     @Slot(str)
     def select_fit_model(self, fit_name: str | None):

bec_widgets/widgets/figure/plots/plot_base.py

@@ -12,6 +12,7 @@ from qtpy.QtWidgets import QApplication, QWidget
 
 from bec_widgets.utils import BECConnector, ConnectionConfig
 from bec_widgets.utils.crosshair import Crosshair
+from bec_widgets.utils.plot_indicator_items import BECArrowItem, BECTickItem
 
 logger = bec_logger.logger
 
@@ -105,6 +106,8 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
 
         self.add_legend()
         self.crosshair = None
+        self.tick_item = BECTickItem(parent=self, plot_item=self.plot_item)
+        self.arrow_item = BECArrowItem(parent=self, plot_item=self.plot_item)
         self._connect_to_theme_change()
 
     def _connect_to_theme_change(self):
@@ -428,6 +431,8 @@ class BECPlotBase(BECConnector, pg.GraphicsLayout):
     def cleanup_pyqtgraph(self):
         """Cleanup pyqtgraph items."""
         self.unhook_crosshair()
+        self.tick_item.cleanup()
+        self.arrow_item.cleanup()
         item = self.plot_item
         item.vb.menu.close()
         item.vb.menu.deleteLater()

bec_widgets/widgets/figure/plots/waveform/waveform.py

@@ -1,3 +1,4 @@
+# pylint: disable=too_many_lines
 from __future__ import annotations
 
 from collections import defaultdict
@@ -12,7 +13,7 @@ from bec_lib.logger import bec_logger
 from pydantic import Field, ValidationError, field_validator
 from pyqtgraph.exporters import MatplotlibExporter
 from qtpy.QtCore import Signal as pyqtSignal
-from qtpy.QtWidgets import QApplication, QWidget
+from qtpy.QtWidgets import QWidget
 
 from bec_widgets.qt_utils.error_popups import SafeSlot as Slot
 from bec_widgets.utils import Colors, EntryValidator
@@ -165,7 +166,7 @@ class BECWaveform(BECPlotBase):
             self.roi_select.linear_region_selector.setRegion(region)
         except Exception as e:
             logger.error(f"Error setting region {tuple}; Exception raised: {e}")
-            raise ValueError(f"Error setting region {tuple}; Exception raised: {e}")
+            raise ValueError(f"Error setting region {tuple}; Exception raised: {e}") from e
 
     def _hook_roi(self):
         """Hook the linear region selector to the plot."""
@@ -219,7 +220,7 @@ class BECWaveform(BECPlotBase):
         # Reset curves
         self._curves_data = defaultdict(dict)
         self._curves = self.plot_item.curves
-        for curve_id, curve_config in self.config.curves.items():
+        for curve_config in self.config.curves.values():
             self.add_curve_by_config(curve_config)
         if replot_last_scan:
             self.scan_history(scan_index=-1)
@@ -342,7 +343,7 @@ class BECWaveform(BECPlotBase):
         Returns:
             CurveConfig|dict: Configuration of the curve.
         """
-        for source, curves in self._curves_data.items():
+        for curves in self._curves_data.values():
             if curve_id in curves:
                 if dict_output:
                     return curves[curve_id].config.model_dump()
@@ -362,7 +363,7 @@ class BECWaveform(BECPlotBase):
         if isinstance(identifier, int):
             return self.plot_item.curves[identifier]
         elif isinstance(identifier, str):
-            for source_type, curves in self._curves_data.items():
+            for curves in self._curves_data.values():
                 if identifier in curves:
                     return curves[identifier]
             raise ValueError(f"Curve with ID '{identifier}' not found.")
@@ -513,6 +514,7 @@ class BECWaveform(BECPlotBase):
 
     @Slot()
     def auto_range(self):
+        """Manually set auto range of the plotitem"""
         self.plot_item.autoRange()
 
     def set_auto_range(self, enabled: bool, axis: str = "xy"):
@@ -551,7 +553,6 @@ class BECWaveform(BECPlotBase):
         Returns:
             BECCurve: The curve object.
         """
-        curve_source = curve_source
         curve_id = label or f"Curve {len(self.plot_item.curves) + 1}"
 
         curve_exits = self._check_curve_id(curve_id, self._curves_data)
@@ -725,7 +726,7 @@ class BECWaveform(BECPlotBase):
 
         if self.x_axis_mode["readout_priority"] == "async":
             raise ValueError(
-                f"Async signals cannot be fitted at the moment. Please switch to 'monitored' or 'baseline' signals."
+                "Async signals cannot be fitted at the moment. Please switch to 'monitored' or 'baseline' signals."
             )
 
         if validate_bec is True:
@@ -999,7 +1000,7 @@ class BECWaveform(BECPlotBase):
         Args:
             curve_id(str): ID of the curve to be removed.
         """
-        for source, curves in self._curves_data.items():
+        for curves in self._curves_data.values():
             if curve_id in curves:
                 curve = curves.pop(curve_id)
                 self.plot_item.removeItem(curve)
@@ -1022,7 +1023,7 @@ class BECWaveform(BECPlotBase):
             self.plot_item.removeItem(curve)
             del self.config.curves[curve_id]
             # Remove from self.curve_data
-            for source, curves in self._curves_data.items():
+            for curves in self._curves_data.values():
                 if curve_id in curves:
                     del curves[curve_id]
                     break
@@ -1052,7 +1053,7 @@ class BECWaveform(BECPlotBase):
             if self._curves_data["DAP"]:
                 self.setup_dap(self.old_scan_id, self.scan_id)
             if self._curves_data["async"]:
-                for curve_id, curve in self._curves_data["async"].items():
+                for curve in self._curves_data["async"].values():
                     self.setup_async(
                         name=curve.config.signals.y.name, entry=curve.config.signals.y.entry
                     )
@@ -1184,7 +1185,9 @@ class BECWaveform(BECPlotBase):
 
     @Slot(dict, dict)
     def update_dap(self, msg, metadata):
-        self.msg = msg
+        """Callback for DAP response message."""
+
+        # pylint: disable=unused-variable
         scan_id, x_name, x_entry, y_name, y_entry = msg["dap_request"].content["config"]["args"]
         model = msg["dap_request"].content["config"]["class_kwargs"]["model"]
 
@@ -1213,7 +1216,7 @@ class BECWaveform(BECPlotBase):
             metadata(dict): Metadata of the message.
         """
         instruction = metadata.get("async_update")
-        for curve_id, curve in self._curves_data["async"].items():
+        for curve in self._curves_data["async"].values():
             y_name = curve.config.signals.y.name
             y_entry = curve.config.signals.y.entry
             x_name = self._x_axis_mode["name"]
@@ -1337,7 +1340,7 @@ class BECWaveform(BECPlotBase):
         if self._x_axis_mode["name"] is None or self._x_axis_mode["name"] == "best_effort":
             if len(self._curves_data["async"]) > 0:
                 x_data = None
-                self._x_axis_mode["label_suffix"] = f" [auto: index]"
+                self._x_axis_mode["label_suffix"] = " [auto: index]"
                 current_label = "" if self.config.axis.x_label is None else self.config.axis.x_label
                 self.plot_item.setLabel(
                     "bottom", f"{current_label}{self._x_axis_mode['label_suffix']}"
@@ -1414,7 +1417,6 @@ class BECWaveform(BECPlotBase):
         self.scan_signal_update.emit()
         self.async_signal_update.emit()
 
-    # pylint: ignore: undefined-variable
     def get_all_data(self, output: Literal["dict", "pandas"] = "dict") -> dict:  # | pd.DataFrame:
         """
         Extract all curve data into a dictionary or a pandas DataFrame.
@@ -1484,7 +1486,7 @@ class BECWaveform(BECPlotBase):
         self.bec_dispatcher.disconnect_slot(
             self.update_dap, MessageEndpoints.dap_response(self.scan_id)
         )
-        for curve_id, curve in self._curves_data["async"].items():
+        for curve_id in self._curves_data["async"]:
             self.bec_dispatcher.disconnect_slot(
                 self.on_async_readback,
                 MessageEndpoints.device_async_readback(self.scan_id, curve_id),