bec-widgets 1.25.1__py3-none-any.whl → 2.0.1__py3-none-any.whl

bec_widgets/widgets/{plots_next_gen → plots}/toolbar_bundles/plot_export.py

@@ -1,7 +1,9 @@
+import traceback
+
 from pyqtgraph.exporters import MatplotlibExporter
 
-from bec_widgets.qt_utils.error_popups import SafeSlot, WarningPopupUtility
-from bec_widgets.qt_utils.toolbar import MaterialIconAction, SwitchableToolBarAction, ToolbarBundle
+from bec_widgets.utils.error_popups import SafeSlot, WarningPopupUtility
+from bec_widgets.utils.toolbar import MaterialIconAction, SwitchableToolBarAction, ToolbarBundle
 
 
 class PlotExportBundle(ToolbarBundle):
@@ -60,7 +62,7 @@ class PlotExportBundle(ToolbarBundle):
                 import matplotlib as mpl
 
                 MatplotlibExporter(self.target_widget.plot_item).export()
-            except:
+            except ModuleNotFoundError:
                 warning_util = WarningPopupUtility()
                 warning_util.show_warning(
                     title="Matplotlib not installed",
@@ -68,3 +70,12 @@ class PlotExportBundle(ToolbarBundle):
                     detailed_text="Please install matplotlib in your Python environment by using 'pip install matplotlib'.",
                 )
                 return
+            except TypeError:
+                warning_util = WarningPopupUtility()
+                error_msg = traceback.format_exc()
+                warning_util.show_warning(
+                    title="Matplotlib TypeError",
+                    message="Matplotlib exporter could not resolve the plot item.",
+                    detailed_text=error_msg,
+                )
+                return

bec_widgets/widgets/{plots_next_gen → plots}/toolbar_bundles/roi_bundle.py

@@ -1,4 +1,4 @@
-from bec_widgets.qt_utils.toolbar import MaterialIconAction, ToolbarBundle
+from bec_widgets.utils.toolbar import MaterialIconAction, ToolbarBundle
 
 
 class ROIBundle(ToolbarBundle):
@@ -18,9 +18,14 @@ class ROIBundle(ToolbarBundle):
         crosshair = MaterialIconAction(
             icon_name="point_scan", tooltip="Show Crosshair", checkable=True
         )
+        reset_legend = MaterialIconAction(
+            icon_name="restart_alt", tooltip="Reset the position of legend.", checkable=False
+        )
 
         # Add them to the bundle
         self.add_action("crosshair", crosshair)
+        self.add_action("reset_legend", reset_legend)
 
         # Immediately connect signals
         crosshair.action.toggled.connect(self.target_widget.toggle_crosshair)
+        reset_legend.action.triggered.connect(self.target_widget.reset_legend)

bec_widgets/widgets/{plots_next_gen → plots}/toolbar_bundles/save_state.py

@@ -1,5 +1,5 @@
-from bec_widgets.qt_utils.error_popups import SafeSlot
-from bec_widgets.qt_utils.toolbar import MaterialIconAction, ToolbarBundle
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.toolbar import MaterialIconAction, ToolbarBundle
 
 
 class SaveStateBundle(ToolbarBundle):

bec_widgets/widgets/{containers/figure/plots/waveform/waveform_curve.py → plots/waveform/curve.py}

@@ -1,75 +1,67 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Literal, Optional
+from typing import TYPE_CHECKING, Literal
 
 import numpy as np
 import pyqtgraph as pg
-from bec_lib.logger import bec_logger
+from bec_lib import bec_logger
 from pydantic import BaseModel, Field, field_validator
 from qtpy import QtCore
 
 from bec_widgets.utils import BECConnector, Colors, ConnectionConfig
 
-if TYPE_CHECKING:
-    from bec_widgets.widgets.containers.figure.plots.waveform import BECWaveform1D
+if TYPE_CHECKING:  # pragma: no cover
+    from bec_widgets.widgets.plots.waveform.waveform import Waveform
 
 logger = bec_logger.logger
 
 
-class SignalData(BaseModel):
-    """The data configuration of a signal in the 1D waveform widget for x and y axis."""
+# noinspection PyDataclass
+class DeviceSignal(BaseModel):
+    """The configuration of a signal in the 1D waveform widget."""
 
     name: str
     entry: str
-    unit: Optional[str] = None  # todo implement later
-    modifier: Optional[str] = None  # todo implement later
-    limits: Optional[list[float]] = None  # todo implement later
-    model_config: dict = {"validate_assignment": True}
+    dap: str | None = None
+    dap_oversample: int = 1
 
-
-class Signal(BaseModel):
-    """The configuration of a signal in the 1D waveform widget."""
-
-    source: str
-    x: Optional[SignalData] = None
-    y: SignalData
-    z: Optional[SignalData] = None
-    dap: Optional[str] = None
     model_config: dict = {"validate_assignment": True}
 
 
+# noinspection PyDataclass
 class CurveConfig(ConnectionConfig):
-    parent_id: Optional[str] = Field(None, description="The parent plot of the curve.")
-    label: Optional[str] = Field(None, description="The label of the curve.")
-    color: Optional[str | tuple] = Field(None, description="The color of the curve.")
-    symbol: Optional[str | None] = Field("o", description="The symbol of the curve.")
-    symbol_color: Optional[str | tuple] = Field(
+    parent_id: str | None = Field(None, description="The parent plot of the curve.")
+    label: str | None = Field(None, description="The label of the curve.")
+    color: str | tuple | None = Field(None, description="The color of the curve.")
+    symbol: str | None = Field("o", description="The symbol of the curve.")
+    symbol_color: str | tuple | None = Field(
         None, description="The color of the symbol of the curve."
     )
-    symbol_size: Optional[int] = Field(7, description="The size of the symbol of the curve.")
-    pen_width: Optional[int] = Field(4, description="The width of the pen of the curve.")
-    pen_style: Optional[Literal["solid", "dash", "dot", "dashdot"]] = Field(
+    symbol_size: int | None = Field(7, description="The size of the symbol of the curve.")
+    pen_width: int | None = Field(4, description="The width of the pen of the curve.")
+    pen_style: Literal["solid", "dash", "dot", "dashdot"] | None = Field(
         "solid", description="The style of the pen of the curve."
     )
-    source: Optional[str] = Field(None, description="The source of the curve.")
-    signals: Optional[Signal] = Field(None, description="The signal of the curve.")
-    color_map_z: Optional[str] = Field(
-        "magma", description="The colormap of the curves z gradient.", validate_default=True
+    source: Literal["device", "dap", "custom"] = Field(
+        "custom", description="The source of the curve."
+    )
+    signal: DeviceSignal | None = Field(None, description="The signal of the curve.")
+    parent_label: str | None = Field(
+        None, description="The label of the parent plot, only relevant for dap curves."
     )
 
     model_config: dict = {"validate_assignment": True}
 
-    _validate_color_map_z = field_validator("color_map_z")(Colors.validate_color_map)
     _validate_color = field_validator("color")(Colors.validate_color)
     _validate_symbol_color = field_validator("symbol_color")(Colors.validate_color)
 
 
-class BECCurve(BECConnector, pg.PlotDataItem):
+class Curve(BECConnector, pg.PlotDataItem):
     USER_ACCESS = [
         "remove",
-        "dap_params",
         "_rpc_id",
         "_config_dict",
+        "_get_displayed_data",
         "set",
         "set_data",
         "set_color",
@@ -81,14 +73,17 @@ class BECCurve(BECConnector, pg.PlotDataItem):
         "set_pen_style",
         "get_data",
         "dap_params",
+        "dap_summary",
+        "dap_oversample",
+        "dap_oversample.setter",
     ]
 
     def __init__(
         self,
-        name: Optional[str] = None,
-        config: Optional[CurveConfig] = None,
-        gui_id: Optional[str] = None,
-        parent_item: Optional[BECWaveform1D] = None,
+        name: str | None = None,
+        config: CurveConfig | None = None,
+        gui_id: str | None = None,
+        parent_item: Waveform | None = None,
         **kwargs,
     ):
         if config is None:
@@ -96,18 +91,35 @@ class BECCurve(BECConnector, pg.PlotDataItem):
             self.config = config
         else:
             self.config = config
-            # config.widget_class = self.__class__.__name__
-        super().__init__(config=config, gui_id=gui_id, **kwargs)
-        pg.PlotDataItem.__init__(self, name=name)
-
         self.parent_item = parent_item
+        object_name = name.replace("-", "_").replace(" ", "_") if name else None
+        super().__init__(name=name, object_name=object_name, config=config, gui_id=gui_id, **kwargs)
+
         self.apply_config()
         self.dap_params = None
         self.dap_summary = None
+        self.slice_index = None
         if kwargs:
             self.set(**kwargs)
+        # Activate setClipToView, to boost performance for large datasets per default
+        self.setClipToView(True)
+
+    def parent(self):
+        return self.parent_item
+
+    def apply_config(self, config: dict | CurveConfig | None = None, **kwargs) -> None:
+        """
+        Apply the configuration to the curve.
+
+        Args:
+            config(dict|CurveConfig, optional): The configuration to apply.
+        """
+
+        if config is not None:
+            if isinstance(config, dict):
+                config = CurveConfig(**config)
+            self.config = config
 
-    def apply_config(self):
         pen_style_map = {
             "solid": QtCore.Qt.SolidLine,
             "dash": QtCore.Qt.DashLine,
@@ -129,21 +141,64 @@ class BECCurve(BECConnector, pg.PlotDataItem):
 
     @property
     def dap_params(self):
+        """
+        Get the dap parameters.
+        """
         return self._dap_params
 
     @dap_params.setter
     def dap_params(self, value):
+        """
+        Set the dap parameters.
+
+        Args:
+            value(dict): The dap parameters.
+        """
         self._dap_params = value
 
     @property
     def dap_summary(self):
+        """
+        Get the dap summary.
+        """
         return self._dap_report
 
     @dap_summary.setter
     def dap_summary(self, value):
+        """
+        Set the dap summary.
+        """
         self._dap_report = value
 
-    def set_data(self, x, y):
+    @property
+    def dap_oversample(self):
+        """
+        Get the dap oversample.
+        """
+        return self.config.signal.dap_oversample
+
+    @dap_oversample.setter
+    def dap_oversample(self, value):
+        """
+        Set the dap oversample.
+
+        Args:
+            value(int): The dap oversample.
+        """
+        self.config.signal.dap_oversample = value
+        self.parent_item.request_dap()  # do immediate request for dap update
+
+    def set_data(self, x: list | np.ndarray, y: list | np.ndarray):
+        """
+        Set the data of the curve.
+
+        Args:
+            x(list|np.ndarray): The x data.
+            y(list|np.ndarray): The y data.
+
+        Raises:
+            ValueError: If the source is not custom.
+        """
         if self.config.source == "custom":
             self.setData(x, y)
         else:
@@ -181,7 +236,7 @@ class BECCurve(BECConnector, pg.PlotDataItem):
             else:
                 logger.warning(f"Warning: '{key}' is not a recognized property.")
 
-    def set_color(self, color: str, symbol_color: Optional[str] = None):
+    def set_color(self, color: str, symbol_color: str | None = None):
         """
         Change the color of the curve.
 
@@ -253,25 +308,40 @@ class BECCurve(BECConnector, pg.PlotDataItem):
         """
         self.config.color_map_z = colormap
         self.apply_config()
-        self.parent_item.scan_history(-1)
+        self.parent_item.update_with_scan_history(-1)
 
-    def get_data(self) -> tuple[np.ndarray, np.ndarray]:
+    def get_data(self) -> tuple[np.ndarray | None, np.ndarray | None]:
         """
         Get the data of the curve.
         Returns:
             tuple[np.ndarray,np.ndarray]: X and Y data of the curve.
         """
         try:
-            x_data, y_data = self.getData()
+            x_data, y_data = self.getOriginalDataset()
         except TypeError:
             x_data, y_data = np.array([]), np.array([])
         return x_data, y_data
 
     def clear_data(self):
+        """
+        Clear the data of the curve.
+        """
         self.setData([], [])
 
     def remove(self):
         """Remove the curve from the plot."""
         # self.parent_item.removeItem(self)
         self.parent_item.remove_curve(self.name())
-        self.rpc_register.remove_rpc(self)
+        super().remove()
+
+    def _get_displayed_data(self) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Get the displayed data of the curve.
+
+        Returns:
+            tuple[np.ndarray, np.ndarray]: The x and y data of the curve.
+        """
+        x_data, y_data = self.getData()
+        if x_data is None or y_data is None:
+            return np.array([]), np.array([])
+        return x_data, y_data

bec_widgets/widgets/plots/waveform/register_waveform.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.plots.waveform.waveform_plugin import WaveformPlugin
+
+    QPyDesignerCustomWidgetCollection.addCustomWidget(WaveformPlugin())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

bec_widgets/widgets/plots/waveform/settings/curve_settings/curve_setting.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from qtpy.QtWidgets import (
+    QComboBox,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QSizePolicy,
+    QVBoxLayout,
+    QWidget,
+)
+
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.settings_dialog import SettingWidget
+from bec_widgets.widgets.control.device_input.device_line_edit.device_line_edit import (
+    DeviceLineEdit,
+)
+from bec_widgets.widgets.plots.waveform.settings.curve_settings.curve_tree import CurveTree
+
+if TYPE_CHECKING:  # pragma: no cover
+    from bec_widgets.widgets.plots.waveform.waveform import Waveform
+
+
+class CurveSetting(SettingWidget):
+    def __init__(self, parent=None, target_widget: Waveform = None, *args, **kwargs):
+        super().__init__(parent=parent, *args, **kwargs)
+        self.setProperty("skip_settings", True)
+        self.target_widget = target_widget
+
+        self.layout = QVBoxLayout(self)
+
+        self._init_x_box()
+        self._init_y_box()
+
+        self.setFixedWidth(580)  # TODO height is still debate
+
+    def _init_x_box(self):
+        self.x_axis_box = QGroupBox("X Axis")
+        self.x_axis_box.layout = QHBoxLayout(self.x_axis_box)
+        self.x_axis_box.layout.setContentsMargins(10, 10, 10, 10)
+        self.x_axis_box.layout.setSpacing(10)
+
+        self.mode_combo_label = QLabel("Mode")
+        self.mode_combo = QComboBox()
+        self.mode_combo.addItems(["auto", "index", "timestamp", "device"])
+
+        self.spacer = QWidget()
+        self.spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+
+        self.device_x_label = QLabel("Device")
+        self.device_x = DeviceLineEdit(parent=self)
+
+        self.signal_x_label = QLabel("Signal")
+        self.signal_x = QLineEdit()
+
+        self._get_x_mode_from_waveform()
+        self.switch_x_device_selection()
+
+        self.mode_combo.currentTextChanged.connect(self.switch_x_device_selection)
+
+        self.x_axis_box.layout.addWidget(self.mode_combo_label)
+        self.x_axis_box.layout.addWidget(self.mode_combo)
+        self.x_axis_box.layout.addWidget(self.spacer)
+        self.x_axis_box.layout.addWidget(self.device_x_label)
+        self.x_axis_box.layout.addWidget(self.device_x)
+        self.x_axis_box.layout.addWidget(self.signal_x_label)
+        self.x_axis_box.layout.addWidget(self.signal_x)
+
+        self.x_axis_box.setFixedHeight(80)
+        self.layout.addWidget(self.x_axis_box)
+
+    def _get_x_mode_from_waveform(self):
+        if self.target_widget.x_mode in ["auto", "index", "timestamp"]:
+            self.mode_combo.setCurrentText(self.target_widget.x_mode)
+        else:
+            self.mode_combo.setCurrentText("device")
+
+    def switch_x_device_selection(self):
+        if self.mode_combo.currentText() == "device":
+            self.device_x.setEnabled(True)
+            self.device_x.setText(self.target_widget.x_axis_mode["name"])
+            self.signal_x.setText(self.target_widget.x_axis_mode["entry"])
+        else:
+            self.device_x.setEnabled(False)
+
+    def _init_y_box(self):
+        self.y_axis_box = QGroupBox("Y Axis")
+        self.y_axis_box.layout = QVBoxLayout(self.y_axis_box)
+        self.y_axis_box.layout.setContentsMargins(0, 0, 0, 0)
+        self.y_axis_box.layout.setSpacing(0)
+
+        self.curve_manager = CurveTree(self, waveform=self.target_widget)
+        self.y_axis_box.layout.addWidget(self.curve_manager)
+
+        self.layout.addWidget(self.y_axis_box)
+
+    @SafeSlot()
+    def accept_changes(self):
+        """
+        Accepts the changes made in the settings widget and applies them to the target widget.
+        """
+        if self.mode_combo.currentText() == "device":
+            self.target_widget.x_mode = self.device_x.text()
+            signal_x = self.signal_x.text()
+            if signal_x != "":
+                self.target_widget.x_entry = signal_x
+        else:
+            self.target_widget.x_mode = self.mode_combo.currentText()
+        self.curve_manager.send_curve_json()
+
+    @SafeSlot()
+    def refresh(self):
+        """Refresh the curve tree and the x axis combo box in the case Waveform is modified from rpc."""
+        self.curve_manager.refresh_from_waveform()
+        self._get_x_mode_from_waveform()
+
+    def cleanup(self):
+        """Cleanup the widget."""
+        self.device_x.close()
+        self.device_x.deleteLater()
+        self.curve_manager.close()
+        self.curve_manager.deleteLater()