bec-widgets 0.87.1__py3-none-any.whl → 0.88.1__py3-none-any.whl

bec_widgets/cli/client.py

@@ -19,6 +19,7 @@ class Widgets(str, enum.Enum):
     BECMotorMapWidget = "BECMotorMapWidget"
     BECQueue = "BECQueue"
     BECStatusBox = "BECStatusBox"
+    BECWaveformWidget = "BECWaveformWidget"
     DeviceBox = "DeviceBox"
     DeviceComboBox = "DeviceComboBox"
     DeviceLineEdit = "DeviceLineEdit"
@@ -184,7 +185,7 @@ class BECDock(RPCBase):
 
     @property
     @rpc_call
-    def widget_list(self) -> "list[BECConnector]":
+    def widget_list(self) -> "list[BECWidget]":
         """
         Get the widgets in the dock.
 
@@ -225,13 +226,13 @@ class BECDock(RPCBase):
     @rpc_call
     def add_widget(
         self,
-        widget: "BECConnector | str",
+        widget: "BECWidget | str",
         row=None,
         col=0,
         rowspan=1,
         colspan=1,
         shift: "Literal['down', 'up', 'left', 'right']" = "down",
-    ) -> "BECConnector":
+    ) -> "BECWidget":
         """
         Add a widget to the dock.
 
@@ -614,6 +615,12 @@ class BECFigure(RPCBase):
             theme(Literal["dark","light"]): The theme to set for the figure widget.
         """
 
+    @rpc_call
+    def export(self):
+        """
+        Export the plot widget.
+        """
+
     @rpc_call
     def clear_all(self):
         """
@@ -1096,6 +1103,12 @@ class BECImageShow(RPCBase):
             lock(bool): True to lock, False to unlock.
         """
 
+    @rpc_call
+    def export(self):
+        """
+        Show the Export Dialog of the plot widget.
+        """
+
     @rpc_call
     def remove(self):
         """
@@ -1204,6 +1217,12 @@ class BECMotorMap(RPCBase):
             dict: Data of the motor map.
         """
 
+    @rpc_call
+    def export(self):
+        """
+        Show the Export Dialog of the plot widget.
+        """
+
     @rpc_call
     def remove(self):
         """
@@ -1298,6 +1317,12 @@ class BECMotorMapWidget(RPCBase):
         Reset the history of the motor map.
         """
 
+    @rpc_call
+    def export(self):
+        """
+        Show the export dialog for the motor map.
+        """
+
 
 class BECPlotBase(RPCBase):
     @property
@@ -1426,6 +1451,12 @@ class BECPlotBase(RPCBase):
             lock(bool): True to lock, False to unlock.
         """
 
+    @rpc_call
+    def export(self):
+        """
+        Show the Export Dialog of the plot widget.
+        """
+
     @rpc_call
     def remove(self):
         """
@@ -1563,8 +1594,6 @@ class BECWaveform(RPCBase):
             y_name(str): Name of the y signal.
             y_entry(str): Entry of the y signal.
             color(str, optional): Color of the curve. Defaults to None.
-            color_map_z(str): The color map to use for the z-axis.
-            label(str, optional): Label of the curve. Defaults to None.
             dap(str): The dap model to use for the curve.
             validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
             **kwargs: Additional keyword arguments for the curve configuration.
@@ -1756,6 +1785,15 @@ class BECWaveform(RPCBase):
             y(bool): Show grid on the y-axis.
         """
 
+    @rpc_call
+    def set_colormap(self, colormap: "str | None" = None):
+        """
+        Set the colormap of the plot widget.
+
+        Args:
+            colormap(str, optional): Scale the colors of curves to colormap. If None, use the default color palette.
+        """
+
     @rpc_call
     def lock_aspect_ratio(self, lock):
         """
@@ -1765,6 +1803,12 @@ class BECWaveform(RPCBase):
             lock(bool): True to lock, False to unlock.
         """
 
+    @rpc_call
+    def export(self):
+        """
+        Show the Export Dialog of the plot widget.
+        """
+
     @rpc_call
     def remove(self):
         """
@@ -1787,6 +1831,277 @@ class BECWaveform(RPCBase):
         """
 
 
+class BECWaveformWidget(RPCBase):
+    @property
+    @rpc_call
+    def curves(self) -> "list[BECCurve]":
+        """
+        Get the curves of the plot widget as a list
+        Returns:
+            list: List of curves.
+        """
+
+    @rpc_call
+    def plot(
+        self,
+        arg1: "list | np.ndarray | str | None" = None,
+        x: "list | np.ndarray | None" = None,
+        y: "list | np.ndarray | None" = None,
+        x_name: "str | None" = None,
+        y_name: "str | None" = None,
+        z_name: "str | None" = None,
+        x_entry: "str | None" = None,
+        y_entry: "str | None" = None,
+        z_entry: "str | None" = None,
+        color: "str | None" = None,
+        color_map_z: "str | None" = "plasma",
+        label: "str | None" = None,
+        validate: "bool" = True,
+        dap: "str | None" = None,
+        **kwargs,
+    ) -> "BECCurve":
+        """
+        Plot a curve to the plot widget.
+        Args:
+            arg1(list | np.ndarray | str | None): First argument which can be x data(list | np.ndarray), y data(list | np.ndarray), or y_name(str).
+            x(list | np.ndarray): Custom x data to plot.
+            y(list | np.ndarray): Custom y data to plot.
+            x_name(str): The name of the device for the x-axis.
+            y_name(str): The name of the device for the y-axis.
+            z_name(str): The name of the device for the z-axis.
+            x_entry(str): The name of the entry for the x-axis.
+            y_entry(str): The name of the entry for the y-axis.
+            z_entry(str): The name of the entry for the z-axis.
+            color(str): The color of the curve.
+            color_map_z(str): The color map to use for the z-axis.
+            label(str): The label of the curve.
+            validate(bool): If True, validate the device names and entries.
+            dap(str): The dap model to use for the curve. If not specified, none will be added.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+
+    @rpc_call
+    def add_dap(
+        self,
+        x_name: "str",
+        y_name: "str",
+        x_entry: "str | None" = None,
+        y_entry: "str | None" = None,
+        color: "str | None" = None,
+        dap: "str" = "GaussianModel",
+        validate_bec: "bool" = True,
+        **kwargs,
+    ) -> "BECCurve":
+        """
+        Add LMFIT dap model curve to the plot widget.
+
+        Args:
+            x_name(str): Name of the x signal.
+            x_entry(str): Entry of the x signal.
+            y_name(str): Name of the y signal.
+            y_entry(str): Entry of the y signal.
+            color(str, optional): Color of the curve. Defaults to None.
+            dap(str): The dap model to use for the curve.
+            validate_bec(bool, optional): If True, validate the signal with BEC. Defaults to True.
+            **kwargs: Additional keyword arguments for the curve configuration.
+
+        Returns:
+            BECCurve: The curve object.
+        """
+
+    @rpc_call
+    def get_dap_params(self) -> "dict":
+        """
+        Get the DAP parameters of all DAP curves.
+
+        Returns:
+            dict: DAP parameters of all DAP curves.
+        """
+
+    @rpc_call
+    def remove_curve(self, *identifiers):
+        """
+        Remove a curve from the plot widget.
+
+        Args:
+            *identifiers: Identifier of the curve to be removed. Can be either an integer (index) or a string (curve_id).
+        """
+
+    @rpc_call
+    def scan_history(self, scan_index: "int" = None, scan_id: "str" = None):
+        """
+        Update the scan curves with the data from the scan storage.
+        Provide only one of scan_id or scan_index.
+
+        Args:
+            scan_id(str, optional): ScanID of the scan to be updated. Defaults to None.
+            scan_index(int, optional): Index of the scan to be updated. Defaults to None.
+        """
+
+    @rpc_call
+    def get_all_data(self, output: "Literal['dict', 'pandas']" = "dict") -> "dict | pd.DataFrame":
+        """
+        Extract all curve data into a dictionary or a pandas DataFrame.
+
+        Args:
+            output (Literal["dict", "pandas"]): Format of the output data.
+
+        Returns:
+            dict | pd.DataFrame: Data of all curves in the specified format.
+        """
+
+    @rpc_call
+    def set(self, **kwargs):
+        """
+        Set the properties of the plot widget.
+
+        Args:
+            **kwargs: Keyword arguments for the properties to be set.
+
+        Possible properties:
+            - title: str
+            - x_label: str
+            - y_label: str
+            - x_scale: Literal["linear", "log"]
+            - y_scale: Literal["linear", "log"]
+            - x_lim: tuple
+            - y_lim: tuple
+            - legend_label_size: int
+        """
+
+    @rpc_call
+    def set_x(self, x_name: "str", x_entry: "str | None" = None):
+        """
+        Change the x axis of the plot widget.
+
+        Args:
+            x_name(str): Name of the x signal.
+                - "best_effort": Use the best effort signal.
+                - "timestamp": Use the timestamp signal.
+                - "index": Use the index signal.
+                - Custom signal name of device from BEC.
+            x_entry(str): Entry of the x signal.
+        """
+
+    @rpc_call
+    def set_title(self, title: "str"):
+        """
+        Set the title of the plot widget.
+
+        Args:
+            title(str): Title of the plot.
+        """
+
+    @rpc_call
+    def set_x_label(self, x_label: "str"):
+        """
+        Set the x-axis label of the plot widget.
+
+        Args:
+            x_label(str): Label of the x-axis.
+        """
+
+    @rpc_call
+    def set_y_label(self, y_label: "str"):
+        """
+        Set the y-axis label of the plot widget.
+
+        Args:
+            y_label(str): Label of the y-axis.
+        """
+
+    @rpc_call
+    def set_x_scale(self, x_scale: "Literal['linear', 'log']"):
+        """
+        Set the scale of the x-axis of the plot widget.
+
+        Args:
+            x_scale(Literal["linear", "log"]): Scale of the x-axis.
+        """
+
+    @rpc_call
+    def set_y_scale(self, y_scale: "Literal['linear', 'log']"):
+        """
+        Set the scale of the y-axis of the plot widget.
+
+        Args:
+            y_scale(Literal["linear", "log"]): Scale of the y-axis.
+        """
+
+    @rpc_call
+    def set_x_lim(self, x_lim: "tuple"):
+        """
+        Set the limits of the x-axis of the plot widget.
+
+        Args:
+            x_lim(tuple): Limits of the x-axis.
+        """
+
+    @rpc_call
+    def set_y_lim(self, y_lim: "tuple"):
+        """
+        Set the limits of the y-axis of the plot widget.
+
+        Args:
+            y_lim(tuple): Limits of the y-axis.
+        """
+
+    @rpc_call
+    def set_legend_label_size(self, legend_label_size: "int"):
+        """
+        Set the size of the legend labels of the plot widget.
+
+        Args:
+            legend_label_size(int): Size of the legend labels.
+        """
+
+    @rpc_call
+    def set_auto_range(self, enabled: "bool", axis: "str" = "xy"):
+        """
+        Set the auto range of the plot widget.
+
+        Args:
+            enabled(bool): If True, enable the auto range.
+            axis(str, optional): The axis to enable the auto range.
+                - "xy": Enable auto range for both x and y axis.
+                - "x": Enable auto range for x axis.
+                - "y": Enable auto range for y axis.
+        """
+
+    @rpc_call
+    def set_grid(self, x_grid: "bool", y_grid: "bool"):
+        """
+        Set the grid visibility of the plot widget.
+
+        Args:
+            x_grid(bool): Visibility of the x-axis grid.
+            y_grid(bool): Visibility of the y-axis grid.
+        """
+
+    @rpc_call
+    def lock_aspect_ratio(self, lock: "bool"):
+        """
+        Lock the aspect ratio of the plot widget.
+
+        Args:
+            lock(bool): Lock the aspect ratio.
+        """
+
+    @rpc_call
+    def export(self):
+        """
+        Show the export dialog for the plot widget.
+        """
+
+    @rpc_call
+    def export_to_matplotlib(self):
+        """
+        Export the plot widget to Matplotlib.
+        """
+
+
 class DeviceBox(RPCBase):
     @property
     @rpc_call

bec_widgets/cli/server.py

@@ -202,7 +202,8 @@ def main():
             module_path = os.path.dirname(bec_widgets.__file__)
             icon = QIcon()
             icon.addFile(
-                os.path.join(module_path, "assets", "bec_widgets_icon.png"), size=QSize(48, 48)
+                os.path.join(module_path, "assets", "app_icons", "bec_widgets_icon.png"),
+                size=QSize(48, 48),
             )
             app.setWindowIcon(icon)
 

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -49,8 +49,9 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
                     "d0": self.d0,
                     "d1": self.d1,
                     "d2": self.d2,
-                    "plt": self.plt,
+                    "wave": self.wave,
                     "bar": self.bar,
+                    "cm": self.colormap,
                 }
             )
 
@@ -165,12 +166,16 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         self.fig1.plot(x_name="samx", y_name="bpm3a")
 
         self.d2 = self.dock.add_dock(name="dock_2", position="bottom")
-        self.fig2 = self.d2.add_widget("BECFigure", row=0, col=0)
-        self.plt = self.fig2.plot(x_name="samx", y_name="bpm3a")
-        self.plt.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
+        self.wave = self.d2.add_widget("BECWaveformWidget", row=0, col=0)
+        # self.wave.plot(x_name="samx", y_name="bpm3a")
+        # self.wave.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
         self.bar = self.d2.add_widget("RingProgressBar", row=0, col=1)
         self.bar.set_diameter(200)
 
+        self.d3 = self.dock.add_dock(name="dock_3", position="bottom")
+        self.colormap = pg.GradientWidget()
+        self.d3.add_widget(self.colormap, row=0, col=0)
+
         self.dock.save_state()
 
     def closeEvent(self, event):
@@ -196,7 +201,9 @@ if __name__ == "__main__":  # pragma: no cover
     app.setApplicationDisplayName("Jupyter Console")
     apply_theme("dark")
     icon = QIcon()
-    icon.addFile(os.path.join(module_path, "assets", "terminal_icon.png"), size=QSize(48, 48))
+    icon.addFile(
+        os.path.join(module_path, "assets", "app_icons", "terminal_icon.png"), size=QSize(48, 48)
+    )
     app.setWindowIcon(icon)
 
     bec_dispatcher = BECDispatcher()

bec_widgets/examples/plugin_example_pyside/tictactoe.py

@@ -16,6 +16,7 @@ class TicTacToe(QWidget):  # pragma: no cover
         super().__init__(parent)
         self._state = DEFAULT_STATE
         self._turn_number = 0
+        print("TicTac HERE !!!!!!")
 
     def minimumSizeHint(self):
         return QSize(200, 200)

bec_widgets/qt_utils/toolbar.py

@@ -1,12 +1,35 @@
+# pylint: disable=no-name-in-module
+import os
 from abc import ABC, abstractmethod
 from collections import defaultdict
 
-# pylint: disable=no-name-in-module
 from qtpy.QtCore import QSize
-from qtpy.QtWidgets import QToolBar, QToolButton, QWidget
+from qtpy.QtGui import QAction, QIcon
+from qtpy.QtWidgets import QHBoxLayout, QLabel, QToolBar, QToolButton, QWidget
+
+import bec_widgets
+
+MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
 
 class ToolBarAction(ABC):
+    """
+    Abstract base class for toolbar actions.
+
+    Args:
+        icon_path (str, optional): The name of the icon file from `assets/toolbar_icons`. Defaults to None.
+        tooltip (bool, optional): The tooltip for the action. Defaults to None.
+        checkable (bool, optional): Whether the action is checkable. Defaults to False.
+    """
+
+    def __init__(self, icon_path: str = None, tooltip: str = None, checkable: bool = False):
+        self.icon_path = (
+            os.path.join(MODULE_PATH, "assets", "toolbar_icons", icon_path) if icon_path else None
+        )
+        self.tooltip = tooltip
+        self.checkable = checkable
+        self.action = None
+
     @abstractmethod
     def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
         """Adds an action or widget to a toolbar.
@@ -26,6 +49,55 @@ class SeparatorAction(ToolBarAction):
         toolbar.addWidget(self.separator)
 
 
+class IconAction(ToolBarAction):
+    """
+    Action with an icon for the toolbar.
+
+    Args:
+        icon_path (str): The path to the icon file.
+        tooltip (str): The tooltip for the action.
+        checkable (bool, optional): Whether the action is checkable. Defaults to False.
+    """
+
+    def __init__(self, icon_path: str = None, tooltip: str = None, checkable: bool = False):
+        super().__init__(icon_path, tooltip, checkable)
+
+    def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
+        icon = QIcon()
+        icon.addFile(self.icon_path, size=QSize(20, 20))
+        self.action = QAction(icon, self.tooltip, target)
+        self.action.setCheckable(self.checkable)
+        toolbar.addAction(self.action)
+
+
+class DeviceSelectionAction(ToolBarAction):
+    """
+    Action for selecting a device in a combobox.
+
+    Args:
+        label (str): The label for the combobox.
+        device_combobox (DeviceComboBox): The combobox for selecting the device.
+
+    """
+
+    def __init__(self, label: str, device_combobox):
+        super().__init__()
+        self.label = label
+        self.device_combobox = device_combobox
+        self.device_combobox.currentIndexChanged.connect(lambda: self.set_combobox_style("#ffa700"))
+
+    def add_to_toolbar(self, toolbar, target):
+        widget = QWidget()
+        layout = QHBoxLayout(widget)
+        label = QLabel(f"{self.label}")
+        layout.addWidget(label)
+        layout.addWidget(self.device_combobox)
+        toolbar.addWidget(widget)
+
+    def set_combobox_style(self, color: str):
+        self.device_combobox.setStyleSheet(f"QComboBox {{ background-color: {color}; }}")
+
+
 class ModularToolBar(QToolBar):
     """Modular toolbar with optional automatic initialization.
     Args:

bec_widgets/widgets/{color_map_selector/color_map_selector.py → colormap_selector/colormap_selector.py}

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import pyqtgraph as pg
 from qtpy.QtCore import Property, Signal, Slot
 from qtpy.QtGui import QColor, QFontMetrics, QImage
@@ -46,7 +48,7 @@ class ColormapSelector(QWidget):
     colormap_changed_signal = Signal(str)
 
     def __init__(self, parent=None, default_colormaps=None):
-        super().__init__(parent)
+        super().__init__(parent=parent)
         self._colormaps = []
         self.initUI(default_colormaps)
 

bec_widgets/widgets/colormap_selector/colormap_selector.pyproject

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

bec_widgets/widgets/{color_map_selector/color_map_selector_plugin.py → colormap_selector/colormap_selector_plugin.py}

@@ -5,15 +5,18 @@ import os
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
 from qtpy.QtGui import QIcon
 
-from bec_widgets.widgets.color_map_selector.color_map_selector import ColormapSelector
+import bec_widgets
+from bec_widgets.widgets.colormap_selector.colormap_selector import ColormapSelector
 
 DOM_XML = """
 <ui language='c++'>
-    <widget class='ColormapSelector' name='color_map_selector'>
+    <widget class='ColormapSelector' name='colormap_selector'>
     </widget>
 </ui>
 """
 
+MODULE_PATH = os.path.dirname(bec_widgets.__file__)
+
 
 class ColormapSelectorPlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
@@ -31,12 +34,11 @@ class ColormapSelectorPlugin(QDesignerCustomWidgetInterface):  # pragma: no cove
         return "BEC Buttons"
 
     def icon(self):
-        current_path = os.path.dirname(__file__)
-        icon_path = os.path.join(current_path, "assets", "color_map_selector_icon.png")
+        icon_path = os.path.join(MODULE_PATH, "assets", "designer_icons", "colormap_selector.png")
         return QIcon(icon_path)
 
     def includeFile(self):
-        return "color_map_selector"
+        return "colormap_selector"
 
     def initialize(self, form_editor):
         self._form_editor = form_editor
@@ -51,7 +53,7 @@ class ColormapSelectorPlugin(QDesignerCustomWidgetInterface):  # pragma: no cove
         return "ColormapSelector"
 
     def toolTip(self):
-        return "A custom QComboBox widget for selecting colormaps."
+        return ""
 
     def whatsThis(self):
         return self.toolTip()

bec_widgets/widgets/{color_map_selector/register_color_map_selector.py → colormap_selector/register_colormap_selector.py}

@@ -6,7 +6,7 @@ def main():  # pragma: no cover
         return
     from PySide6.QtDesigner import QPyDesignerCustomWidgetCollection
 
-    from bec_widgets.widgets.color_map_selector.color_map_selector_plugin import (
+    from bec_widgets.widgets.colormap_selector.colormap_selector_plugin import (
         ColormapSelectorPlugin,
     )
 

bec_widgets/widgets/figure/figure.py

@@ -122,6 +122,7 @@ class BECFigure(BECWidget, pg.GraphicsLayoutWidget):
         "remove",
         "change_layout",
         "change_theme",
+        "export",
         "clear_all",
         "widget_list",
     ]
@@ -228,6 +229,17 @@ class BECFigure(BECWidget, pg.GraphicsLayoutWidget):
         """
         self._widgets = value
 
+    def export(self):
+        """Export the plot widget."""
+        try:
+            plot_item = self.widget_list[0]
+        except:
+            raise ValueError("No plot widget available to export.")
+
+        scene = plot_item.scene()
+        scene.contextMenuItem = plot_item
+        scene.showExportDialog()
+
     @typechecked
     def plot(
         self,