bec-widgets 0.87.0__py3-none-any.whl → 0.88.0__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,264 @@ 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_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,22 +166,25 @@ 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):
         """Override to handle things when main window is closed."""
-        self.dock.clear_all()
         self.dock.cleanup()
         self.dock.close()
-        self.figure.clear_all()
         self.figure.cleanup()
         self.figure.close()
+        self.console.close()
 
         super().closeEvent(event)
 
@@ -197,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/utils/bec_connector.py

@@ -11,10 +11,10 @@ from bec_lib.utils.import_utils import lazy_import_from
 from pydantic import BaseModel, Field, field_validator
 from qtpy.QtCore import QObject, QRunnable, QThreadPool, Signal
 from qtpy.QtCore import Slot as pyqtSlot
+from qtpy.QtWidgets import QApplication
 
 from bec_widgets.cli.rpc_register import RPCRegister
 from bec_widgets.qt_utils.error_popups import ErrorPopupUtility
-from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.yaml_dialog import load_yaml, load_yaml_gui, save_yaml, save_yaml_gui
 
 BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
@@ -65,16 +65,30 @@ class Worker(QRunnable):
         self.signals.completed.emit()
 
 
-class BECConnector(BECWidget):
-    """Connection mixin class for all BEC widgets, to handle BEC client and device manager"""
+class BECConnector:
+    """Connection mixin class to handle BEC client and device manager"""
 
     USER_ACCESS = ["_config_dict", "_get_all_rpc"]
+    EXIT_HANDLERS = {}
 
     def __init__(self, client=None, config: ConnectionConfig = None, gui_id: str = None):
         # BEC related connections
         self.bec_dispatcher = BECDispatcher(client=client)
         self.client = self.bec_dispatcher.client if client is None else client
 
+        if not self.client in BECConnector.EXIT_HANDLERS:
+            # register function to clean connections at exit;
+            # the function depends on BECClient, and BECDispatcher
+            @pyqtSlot()
+            def terminate(client=self.client, dispatcher=self.bec_dispatcher):
+                print("Disconnecting", repr(dispatcher))
+                dispatcher.disconnect_all()
+                print("Shutting down BEC Client", repr(client))
+                client.shutdown()
+
+            BECConnector.EXIT_HANDLERS[self.client] = terminate
+            QApplication.instance().aboutToQuit.connect(terminate)
+
         if config:
             self.config = config
             self.config.widget_class = self.__class__.__name__
@@ -92,6 +106,8 @@ class BECConnector(BECWidget):
             self.gui_id = self.config.gui_id
 
         # register widget to rpc register
+        # be careful: when registering, and the object is not a BECWidget,
+        # cleanup has to called manually since there is no 'closeEvent'
         self.rpc_register = RPCRegister()
         self.rpc_register.add_rpc(self)
 
@@ -284,18 +300,3 @@ class BECConnector(BECWidget):
             return self.config.model_dump()
         else:
             return self.config
-
-    def cleanup(self):
-        """Cleanup the widget."""
-        self.rpc_register.remove_rpc(self)
-        all_connections = self.rpc_register.list_all_connections()
-        if len(all_connections) == 0:
-            print("No more connections. Shutting down GUI BEC client.")
-            self.bec_dispatcher.disconnect_all()
-            self.client.shutdown()
-        if hasattr(super(), "cleanup"):
-            super().cleanup()
-
-    # def closeEvent(self, event):
-    #     self.cleanup()
-    #     super().closeEvent(event)

bec_widgets/utils/bec_widget.py

@@ -1,8 +1,23 @@
-class BECWidget:
-    """Base class for all BEC widgets."""
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
+
+
+class BECWidget(BECConnector):
+    """Mixin class for all BEC widgets, to handle cleanup"""
+
+    def __init__(self, client=None, config: ConnectionConfig = None, gui_id: str = None):
+        if not isinstance(self, QWidget):
+            raise RuntimeError(f"{repr(self)} is not a subclass of QWidget")
+        super().__init__(client, config, gui_id)
+
+    def cleanup(self):
+        """Cleanup the widget."""
+        pass
 
     def closeEvent(self, event):
-        if hasattr(self, "cleanup"):
+        self.rpc_register.remove_rpc(self)
+        try:
             self.cleanup()
-        if hasattr(super(), "closeEvent"):
+        finally:
             super().closeEvent(event)

bec_widgets/widgets/base_classes/device_input_base.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from bec_widgets.utils import BECConnector, ConnectionConfig
+from bec_widgets.utils import ConnectionConfig
+from bec_widgets.utils.bec_widget import BECWidget
 
 
 class DeviceInputConfig(ConnectionConfig):
@@ -9,7 +10,7 @@ class DeviceInputConfig(ConnectionConfig):
     arg_name: str | None = None
 
 
-class DeviceInputBase(BECConnector):
+class DeviceInputBase(BECWidget):
     """
     Mixin class for device input widgets. This class provides methods to get the device list and device object based
     on the current text of the widget.
@@ -120,6 +121,3 @@ class DeviceInputBase(BECConnector):
         """
         if device not in self.get_device_list(self.config.device_filter):
             raise ValueError(f"Device {device} is not valid.")
-
-    def cleanup(self):
-        super().cleanup()

bec_widgets/widgets/bec_queue/bec_queue.py

@@ -2,10 +2,11 @@ from bec_lib.endpoints import MessageEndpoints
 from qtpy.QtCore import Qt, Slot
 from qtpy.QtWidgets import QHeaderView, QTableWidget, QTableWidgetItem, QWidget
 
-from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
+from bec_widgets.utils.bec_connector import ConnectionConfig
+from bec_widgets.utils.bec_widget import BECWidget
 
 
-class BECQueue(BECConnector, QTableWidget):
+class BECQueue(BECWidget, QTableWidget):
     """
     Widget to display the BEC queue.
     """

bec_widgets/widgets/bec_status_box/bec_status_box.py

@@ -13,7 +13,7 @@ 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, QWidget
 
-from bec_widgets.utils.bec_connector import BECConnector
+from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import apply_theme
 from bec_widgets.widgets.bec_status_box.status_item import StatusItem
 
@@ -57,7 +57,7 @@ class BECServiceStatusMixin(QObject):
         self.services_update.emit(self.client._services_info, self.client._services_metric)
 
 
-class BECStatusBox(BECConnector, QWidget):
+class BECStatusBox(BECWidget, QWidget):
     """An autonomous widget to display the status of BEC services.
 
     Args:
@@ -290,15 +290,6 @@ class BECStatusBox(BECConnector, QWidget):
             if objects["item"] == item:
                 objects["widget"].show_popup()
 
-    def closeEvent(self, event):
-        """Upon closing the widget, clean up the BECStatusBox and the QWidget.
-
-        Args:
-            event: The close event.
-        """
-        super().cleanup()
-        super().closeEvent(event)
-
 
 def main():
     """Main method to run the BECStatusBox widget."""

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']}