bec-widgets 0.50.2__py3-none-any.whl → 0.52.0__py3-none-any.whl

bec_widgets/cli/__init__.py

@@ -1,2 +1,2 @@
 from .auto_updates import AutoUpdates, ScanInfo
-from .client import BECFigure
+from .client import BECDockArea, BECFigure

bec_widgets/cli/client.py

@@ -2,7 +2,7 @@
 
 from typing import Literal, Optional, overload
 
-from bec_widgets.cli.client_utils import BECFigureClientMixin, RPCBase, rpc_call
+from bec_widgets.cli.client_utils import BECGuiClientMixin, RPCBase, rpc_call
 
 
 class BECPlotBase(RPCBase):
@@ -255,11 +255,11 @@ class BECWaveform(RPCBase):
         """
 
     @rpc_call
-    def apply_config(self, config: "dict | WidgetConfig", replot_last_scan: "bool" = False):
+    def apply_config(self, config: "dict | SubplotConfig", replot_last_scan: "bool" = False):
         """
         Apply the configuration to the 1D waveform widget.
         Args:
-            config(dict|WidgetConfig): Configuration settings.
+            config(dict|SubplotConfig): Configuration settings.
             replot_last_scan(bool, optional): If True, replot the last scan. Defaults to False.
         """
 
@@ -393,7 +393,7 @@ class BECWaveform(RPCBase):
         """
 
 
-class BECFigure(RPCBase, BECFigureClientMixin):
+class BECFigure(RPCBase):
     @property
     @rpc_call
     def rpc_id(self) -> "str":
@@ -426,7 +426,9 @@ class BECFigure(RPCBase, BECFigureClientMixin):
     @rpc_call
     def widgets(self) -> "dict":
         """
-        None
+        All widgets within the figure with gui ids as keys.
+        Returns:
+            dict: All widgets within the figure.
         """
 
     @rpc_call
@@ -1307,3 +1309,209 @@ class BECMotorMap(RPCBase):
         Returns:
             dict: Data of the motor map.
         """
+
+
+class BECDock(RPCBase):
+    @property
+    @rpc_call
+    def widget_list(self) -> "list":
+        """
+        Get the widgets in the dock.
+        Returns:
+            widgets(list): The widgets in the dock.
+        """
+
+    @rpc_call
+    def show_title_bar(self):
+        """
+        Hide the title bar of the dock.
+        """
+
+    @rpc_call
+    def hide_title_bar(self):
+        """
+        Hide the title bar of the dock.
+        """
+
+    @rpc_call
+    def get_widgets_positions(self) -> "dict":
+        """
+        Get the positions of the widgets in the dock.
+
+        Returns:
+            dict: The positions of the widgets in the dock as dict -> {(row, col, rowspan, colspan):widget}
+        """
+
+    @rpc_call
+    def set_title(self, title: "str"):
+        """
+        Set the title of the dock.
+
+        Args:
+            title(str): The title of the dock.
+        """
+
+    @rpc_call
+    def add_widget_bec(
+        self,
+        widget_type: "str",
+        row=None,
+        col=0,
+        rowspan=1,
+        colspan=1,
+        shift: "Literal['down', 'up', 'left', 'right']" = "down",
+    ):
+        """
+        Add a widget to the dock.
+        Args:
+            widget_type(str): The widget to add. Only BEC RPC widgets from RPCWidgetHandler are allowed.
+            row(int): The row to add the widget to. If None, the widget will be added to the next available row.
+            col(int): The column to add the widget to.
+            rowspan(int): The number of rows the widget should span.
+            colspan(int): The number of columns the widget should span.
+            shift(Literal["down", "up", "left", "right"]): The direction to shift the widgets if the position is occupied.
+        """
+
+    @rpc_call
+    def list_eligible_widgets(self) -> "list":
+        """
+        List all widgets that can be added to the dock.
+        Returns:
+            list: The list of eligible widgets.
+        """
+
+    @rpc_call
+    def move_widget(self, widget: "QWidget", new_row: "int", new_col: "int"):
+        """
+        Move a widget to a new position in the layout.
+        Args:
+            widget(QWidget): The widget to move.
+            new_row(int): The new row to move the widget to.
+            new_col(int): The new column to move the widget to.
+        """
+
+    @rpc_call
+    def remove_widget(self, widget: "QWidget"):
+        """
+        Remove a widget from the dock.
+        Args:
+            widget(QWidget): The widget to remove.
+        """
+
+    @rpc_call
+    def remove(self):
+        """
+        Remove the dock from the parent dock area.
+        """
+
+    @rpc_call
+    def attach(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def detach(self):
+        """
+        None
+        """
+
+
+class BECDockArea(RPCBase, BECGuiClientMixin):
+    @property
+    @rpc_call
+    def panels(self) -> "dict":
+        """
+        Get the docks in the dock area.
+        Returns:
+            dock_dict(dict): The docks in the dock area.
+        """
+
+    @rpc_call
+    def save_state(self) -> "dict":
+        """
+        Save the state of the dock area.
+        Returns:
+            dict: The state of the dock area.
+        """
+
+    @rpc_call
+    def remove_dock(self, name: "str"):
+        """
+        Remove a dock by name and ensure it is properly closed and cleaned up.
+        Args:
+            name(str): The name of the dock to remove.
+        """
+
+    @rpc_call
+    def restore_state(
+        self, state: "dict" = None, missing: "Literal['ignore', 'error']" = "ignore", extra="bottom"
+    ):
+        """
+        Restore the state of the dock area. If no state is provided, the last state is restored.
+        Args:
+            state(dict): The state to restore.
+            missing(Literal['ignore','error']): What to do if a dock is missing.
+            extra(str): Extra docks that are in the dockarea but that are not mentioned in state will be added to the bottom of the dockarea, unless otherwise specified by the extra argument.
+        """
+
+    @rpc_call
+    def add_dock(
+        self,
+        name: "str" = None,
+        position: "Literal['bottom', 'top', 'left', 'right', 'above', 'below']" = None,
+        relative_to: "Optional[BECDock]" = None,
+        closable: "bool" = False,
+        prefix: "str" = "dock",
+        widget: "QWidget" = None,
+        row: "int" = None,
+        col: "int" = 0,
+        rowspan: "int" = 1,
+        colspan: "int" = 1,
+    ) -> "BECDock":
+        """
+        Add a dock to the dock area. Dock has QGridLayout as layout manager by default.
+
+        Args:
+            name(str): The name of the dock to be displayed and for further references. Has to be unique.
+            position(Literal["bottom", "top", "left", "right", "above", "below"]): The position of the dock.
+            relative_to(BECDock): The dock to which the new dock should be added relative to.
+            closable(bool): Whether the dock is closable.
+            prefix(str): The prefix for the dock name if no name is provided.
+            widget(QWidget): The widget to be added to the dock.
+            row(int): The row of the added widget.
+            col(int): The column of the added widget.
+            rowspan(int): The rowspan of the added widget.
+            colspan(int): The colspan of the added widget.
+        Returns:
+            BECDock: The created dock.
+        """
+
+    @rpc_call
+    def clear_all(self):
+        """
+        Close all docks and remove all temp areas.
+        """
+
+    @rpc_call
+    def detach_dock(self, dock_name: "str") -> "BECDock":
+        """
+        Undock a dock from the dock area.
+        Args:
+            dock(BECDock): The dock to undock.
+
+        Returns:
+            BECDock: The undocked dock.
+        """
+
+    @rpc_call
+    def attach_all(self):
+        """
+        Return all floating docks to the dock area.
+        """
+
+    @rpc_call
+    def get_all_rpc(self) -> "dict":
+        """
+        Get all registered RPC objects.
+        """

bec_widgets/cli/client_utils.py

@@ -22,7 +22,7 @@ from bec_widgets.cli.auto_updates import AutoUpdates
 from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
 if TYPE_CHECKING:
-    from bec_widgets.cli.client import BECFigure
+    from bec_widgets.cli.client import BECDockArea, BECFigure
 
 
 def rpc_call(func):
@@ -56,7 +56,7 @@ def rpc_call(func):
     return wrapper
 
 
-class BECFigureClientMixin:
+class BECGuiClientMixin:
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
         self._process = None
@@ -94,7 +94,7 @@ class BECFigureClientMixin:
         )
 
     @staticmethod
-    def _handle_msg_update(msg: MessageObject, parent: BECFigureClientMixin) -> None:
+    def _handle_msg_update(msg: MessageObject, parent: BECGuiClientMixin) -> None:
         if parent.update_script is not None:
             # pylint: disable=protected-access
             parent._update_script_msg_parser(msg.value)
@@ -139,8 +139,19 @@ class BECFigureClientMixin:
         config = self._client._service_config.redis
         monitor_module = importlib.import_module("bec_widgets.cli.server")
         monitor_path = monitor_module.__file__
-
-        command = [sys.executable, "-u", monitor_path, "--id", self._gui_id, "--config", config]
+        gui_class = self.__class__.__name__
+
+        command = [
+            sys.executable,
+            "-u",
+            monitor_path,
+            "--id",
+            self._gui_id,
+            "--config",
+            config,
+            "--gui_class",
+            gui_class,
+        ]
         self._process = subprocess.Popen(
             command, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
         )

bec_widgets/cli/generate_cli.py

@@ -22,7 +22,7 @@ else:
 class ClientGenerator:
     def __init__(self):
         self.header = """# This file was automatically generated by generate_cli.py\n
-from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECFigureClientMixin
+from bec_widgets.cli.client_utils import rpc_call, RPCBase, BECGuiClientMixin
 from typing import Literal, Optional, overload"""
 
         self.content = ""
@@ -53,9 +53,9 @@ from typing import Literal, Optional, overload"""
         # from {module} import {class_name}"""
 
         # Generate the content
-        if cls.__name__ == "BECFigure":
+        if cls.__name__ == "BECDockArea":
             self.content += f"""
-class {class_name}(RPCBase, BECFigureClientMixin):"""
+class {class_name}(RPCBase, BECGuiClientMixin):"""
         else:
             self.content += f"""
 class {class_name}(RPCBase):"""
@@ -108,6 +108,7 @@ if __name__ == "__main__":  # pragma: no cover
     import os
 
     from bec_widgets.utils import BECConnector
+    from bec_widgets.widgets.dock import BECDock, BECDockArea
     from bec_widgets.widgets.figure import BECFigure
     from bec_widgets.widgets.plots import BECImageShow, BECMotorMap, BECPlotBase, BECWaveform
     from bec_widgets.widgets.plots.image import BECImageItem
@@ -124,6 +125,8 @@ if __name__ == "__main__":  # pragma: no cover
         BECConnector,
         BECImageItem,
         BECMotorMap,
+        BECDock,
+        BECDockArea,
     ]
     generator = ClientGenerator()
     generator.generate_client(clss)

bec_widgets/cli/rpc_wigdet_handler.py

@@ -0,0 +1,26 @@
+from bec_widgets.utils import BECConnector
+from bec_widgets.widgets.figure import BECFigure
+
+
+class RPCWidgetHandler:
+    """Handler class for creating widgets from RPC messages."""
+
+    widget_classes = {
+        "BECFigure": BECFigure,
+    }
+
+    @staticmethod
+    def create_widget(widget_type, **kwargs) -> BECConnector:
+        """
+        Create a widget from an RPC message.
+        Args:
+            widget_type(str): The type of the widget.
+            **kwargs: The keyword arguments for the widget.
+
+        Returns:
+            widget(BECConnector): The created widget.
+        """
+        widget_class = RPCWidgetHandler.widget_classes.get(widget_type)
+        if widget_class:
+            return widget_class(**kwargs)
+        raise ValueError(f"Unknown widget type: {widget_type}")

bec_widgets/cli/server.py

@@ -1,6 +1,7 @@
 import inspect
 import threading
 import time
+from typing import Literal, Union
 
 from bec_lib import MessageEndpoints, messages
 from qtpy.QtCore import QTimer
@@ -8,6 +9,7 @@ from qtpy.QtCore import QTimer
 from bec_widgets.cli.rpc_register import RPCRegister
 from bec_widgets.utils import BECDispatcher
 from bec_widgets.utils.bec_connector import BECConnector
+from bec_widgets.widgets.dock.dock_area import BECDockArea
 from bec_widgets.widgets.figure import BECFigure
 from bec_widgets.widgets.plots import BECCurve, BECImageShow, BECWaveform
 
@@ -16,15 +18,20 @@ class BECWidgetsCLIServer:
     WIDGETS = [BECWaveform, BECFigure, BECCurve, BECImageShow]
 
     def __init__(
-        self, gui_id: str = None, dispatcher: BECDispatcher = None, client=None, config=None
+        self,
+        gui_id: str = None,
+        dispatcher: BECDispatcher = None,
+        client=None,
+        config=None,
+        gui_class: Union["BECFigure", "BECDockArea"] = BECFigure,
     ) -> None:
         self.dispatcher = BECDispatcher(config=config) if dispatcher is None else dispatcher
         self.client = self.dispatcher.client if client is None else client
         self.client.start()
         self.gui_id = gui_id
-        self.fig = BECFigure(gui_id=self.gui_id)
+        self.gui = gui_class(gui_id=self.gui_id)
         self.rpc_register = RPCRegister()
-        self.rpc_register.add_rpc(self.fig)
+        self.rpc_register.add_rpc(self.gui)
 
         self.dispatcher.connect_slot(
             self.on_rpc_update, MessageEndpoints.gui_instructions(self.gui_id)
@@ -102,7 +109,7 @@ class BECWidgetsCLIServer:
                 expire=10,
             )
 
-    def shutdown(self):
+    def shutdown(self):  # TODO not sure if needed when cleanup is done at level of BECConnector
         self._shutdown_event = True
         self._heartbeat_timer.stop()
         self.client.shutdown()
@@ -110,6 +117,7 @@ class BECWidgetsCLIServer:
 
 if __name__ == "__main__":  # pragma: no cover
     import argparse
+    import os
     import sys
 
     from qtpy.QtCore import QSize
@@ -118,8 +126,9 @@ if __name__ == "__main__":  # pragma: no cover
 
     app = QApplication(sys.argv)
     app.setApplicationName("BEC Figure")
+    current_path = os.path.dirname(__file__)
     icon = QIcon()
-    icon.addFile("bec_widgets_icon.png", size=QSize(48, 48))
+    icon.addFile(os.path.join(current_path, "bec_widgets_icon.png"), size=QSize(48, 48))
     app.setWindowIcon(icon)
 
     win = QMainWindow()
@@ -127,15 +136,31 @@ if __name__ == "__main__":  # pragma: no cover
 
     parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
     parser.add_argument("--id", type=str, help="The id of the server")
+    parser.add_argument(
+        "--gui_class",
+        type=str,
+        help="Name of the gui class to be rendered. Possible values: \n- BECFigure\n- BECDockArea",
+    )
     parser.add_argument("--config", type=str, help="Config to connect to redis.")
 
     args = parser.parse_args()
 
-    server = BECWidgetsCLIServer(gui_id=args.id, config=args.config)
-    # server = BECWidgetsCLIServer(gui_id="test",config="awi-bec-dev-01:6379")
+    if args.gui_class == "BECFigure":
+        gui_class = BECFigure
+    elif args.gui_class == "BECDockArea":
+        gui_class = BECDockArea
+    else:
+        print(
+            "Please specify a valid gui_class to run. Use -h for help."
+            "\n Starting with default gui_class BECFigure."
+        )
+        gui_class = BECFigure
+
+    server = BECWidgetsCLIServer(gui_id=args.id, config=args.config, gui_class=gui_class)
 
-    fig = server.fig
-    win.setCentralWidget(fig)
+    gui = server.gui
+    win.setCentralWidget(gui)
+    win.resize(800, 600)
     win.show()
 
     app.aboutToQuit.connect(server.shutdown)

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -2,14 +2,17 @@ import os
 
 import numpy as np
 import pyqtgraph as pg
-from pyqtgraph.Qt import uic
+from pyqtgraph.Qt import QtWidgets, uic
 from qtconsole.inprocess import QtInProcessKernelManager
 from qtconsole.rich_jupyter_widget import RichJupyterWidget
+from qtpy.QtCore import QSize
+from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
 
 from bec_widgets.cli.rpc_register import RPCRegister
 from bec_widgets.utils import BECDispatcher
 from bec_widgets.widgets import BECFigure
+from bec_widgets.widgets.dock.dock_area import BECDockArea
 
 
 class JupyterConsoleWidget(RichJupyterWidget):  # pragma: no cover:
@@ -46,15 +49,22 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
 
         self.register = RPCRegister()
         self.register.add_rpc(self.figure)
-        print("Registered objects:", dict(self.register.list_all_connections()))
+
         # console push
         self.console.kernel_manager.kernel.shell.push(
             {
                 "fig": self.figure,
                 "register": self.register,
+                "dock": self.dock,
                 "w1": self.w1,
                 "w2": self.w2,
                 "w3": self.w3,
+                "d1": self.d1,
+                "d2": self.d2,
+                "d3": self.d3,
+                "b2a": self.button_2_a,
+                "b2b": self.button_2_b,
+                "b2c": self.button_2_c,
                 "bec": self.figure.client,
                 "scans": self.figure.client.scans,
                 "dev": self.figure.client.device_manager.devices,
@@ -67,9 +77,16 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         self.figure = BECFigure(parent=self, gui_id="remote")  # Create a new BECDeviceMonitor
         self.glw_1_layout.addWidget(self.figure)  # Add BECDeviceMonitor to the layout
 
+        self.dock_layout = QVBoxLayout(self.dock_placeholder)
+        self.dock = BECDockArea(gui_id="remote")
+        self.dock_layout.addWidget(self.dock)
+
         # add stuff to figure
         self._init_figure()
 
+        # init dock for testing
+        self._init_dock()
+
         self.console_layout = QVBoxLayout(self.widget_console)
         self.console = JupyterConsoleWidget()
         self.console_layout.addWidget(self.console)
@@ -91,6 +108,36 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         self.w1.add_curve_scan("samx", "samy", "bpm3a", pen_style="dash")
         self.c1 = self.w1.get_config()
 
+    def _init_dock(self):
+        self.button_1 = QtWidgets.QPushButton("Button 1 ")
+        self.button_2_a = QtWidgets.QPushButton("Button to be added at place 0,0 in d3")
+        self.button_2_b = QtWidgets.QPushButton("button after without postions specified")
+        self.button_2_c = QtWidgets.QPushButton("button super late")
+        self.button_3 = QtWidgets.QPushButton("Button above Figure ")
+        self.label_1 = QtWidgets.QLabel("some scan info label with useful information")
+
+        self.label_2 = QtWidgets.QLabel("label which is added separately")
+        self.label_3 = QtWidgets.QLabel("Label above figure")
+
+        self.d1 = self.dock.add_dock(widget=self.button_1, position="left")
+        self.d1.addWidget(self.label_2)
+        self.d2 = self.dock.add_dock(widget=self.label_1, position="right")
+        self.d3 = self.dock.add_dock(name="figure")
+        self.fig_dock3 = BECFigure()
+        self.fig_dock3.plot("samx", "bpm4d")
+        self.d3.add_widget(self.label_3)
+        self.d3.add_widget(self.button_3)
+        self.d3.add_widget(self.fig_dock3)
+
+        self.dock.save_state()
+
+    def closeEvent(self, event):
+        """Override to handle things when main window is closed."""
+        self.dock.cleanup()
+        self.figure.clear_all()
+        self.figure.client.shutdown()
+        super().closeEvent(event)
+
 
 if __name__ == "__main__":  # pragma: no cover
     import sys
@@ -101,7 +148,12 @@ if __name__ == "__main__":  # pragma: no cover
 
     app = QApplication(sys.argv)
     app.setApplicationName("Jupyter Console")
+    app.setApplicationDisplayName("Jupyter Console")
+    icon = QIcon()
+    icon.addFile("terminal_icon.png", size=QSize(48, 48))
+    app.setWindowIcon(icon)
     win = JupyterConsoleWindow()
     win.show()
 
+    app.aboutToQuit.connect(win.close)
     sys.exit(app.exec_())

bec_widgets/examples/jupyter_console/jupyter_console_window.ui

@@ -13,13 +13,37 @@
   <property name="windowTitle">
    <string>Plotting Console</string>
   </property>
-  <layout class="QVBoxLayout" name="verticalLayout">
+  <layout class="QVBoxLayout" name="verticalLayout_4">
    <item>
     <widget class="QSplitter" name="splitter">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
-     <widget class="QWidget" name="glw" native="true"/>
+     <widget class="QTabWidget" name="tabWidget">
+      <property name="currentIndex">
+       <number>0</number>
+      </property>
+      <widget class="QWidget" name="tab_1">
+       <attribute name="title">
+        <string>BECDock</string>
+       </attribute>
+       <layout class="QVBoxLayout" name="verticalLayout">
+        <item>
+         <widget class="QWidget" name="dock_placeholder" native="true"/>
+        </item>
+       </layout>
+      </widget>
+      <widget class="QWidget" name="tab_2">
+       <attribute name="title">
+        <string>BECFigure</string>
+       </attribute>
+       <layout class="QVBoxLayout" name="verticalLayout_3">
+        <item>
+         <widget class="QWidget" name="glw" native="true"/>
+        </item>
+       </layout>
+      </widget>
+     </widget>
      <widget class="QWidget" name="widget_console" native="true"/>
     </widget>
    </item>

bec_widgets/utils/__init__.py

@@ -5,5 +5,6 @@ from .colors import Colors
 from .container_utils import WidgetContainerUtils
 from .crosshair import Crosshair
 from .entry_validator import EntryValidator
+from .layout_manager import GridLayoutManager
 from .rpc_decorator import register_rpc_methods, rpc_public
 from .validator_delegate import DoubleValidationDelegate

bec_widgets/utils/bec_connector.py

@@ -148,6 +148,14 @@ class BECConnector:
         else:
             return self.config
 
-    def closeEvent(self, event):
-        self.client.shutdown()
-        super().closeEvent(event)
+    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.client.shutdown()
+
+    # def closeEvent(self, event):
+    #     self.cleanup()
+    #     super().closeEvent(event)