bec-widgets 0.51.0__py3-none-any.whl → 0.52.1__py3-none-any.whl

bec_widgets/utils/widget_io.py

@@ -114,6 +114,7 @@ class WidgetIO:
     def get_value(widget, ignore_errors=False):
         """
         Retrieve value from the widget instance.
+
         Args:
             widget: Widget instance.
             ignore_errors(bool, optional): Whether to ignore if no handler is found.
@@ -129,6 +130,7 @@ class WidgetIO:
     def set_value(widget, value, ignore_errors=False):
         """
         Set a value on the widget instance.
+
         Args:
             widget: Widget instance.
             value: Value to set.
@@ -155,6 +157,7 @@ class WidgetHierarchy:
     ) -> None:
         """
         Print the widget hierarchy to the console.
+
         Args:
             widget: Widget to print the hierarchy of
             indent(int, optional): Level of indentation.
@@ -196,6 +199,7 @@ class WidgetHierarchy:
     ) -> dict:
         """
         Export the widget hierarchy to a dictionary.
+
         Args:
             widget: Widget to print the hierarchy of.
             config(dict,optional): Dictionary to export the hierarchy to.
@@ -245,6 +249,7 @@ class WidgetHierarchy:
     def import_config_from_dict(widget, config: dict, set_values: bool = False) -> None:
         """
         Import the widget hierarchy from a dictionary.
+
         Args:
             widget: Widget to import the hierarchy to.
             config:

bec_widgets/utils/yaml_dialog.py

@@ -9,6 +9,7 @@ from qtpy.QtWidgets import QFileDialog
 def load_yaml(instance) -> Union[dict, None]:
     """
     Load YAML file from disk.
+
     Args:
         instance: Instance of the calling widget.
 
@@ -40,6 +41,7 @@ def load_yaml(instance) -> Union[dict, None]:
 def save_yaml(instance, config: dict) -> None:
     """
     Save YAML file to disk.
+
     Args:
         instance: Instance of the calling widget.
         config: Configuration data to be saved.

bec_widgets/validation/monitor_config_validator.py

@@ -8,7 +8,7 @@ class Signal(BaseModel):
     """
     Represents a signal in a plot configuration.
 
-    Attributes:
+    Args:
         name (str): The name of the signal.
         entry (Optional[str]): The entry point of the signal, optional.
     """
@@ -21,6 +21,7 @@ class Signal(BaseModel):
     def validate_fields(cls, values):
         """Validate the fields of the model.
         First validate the 'name' field, then validate the 'entry' field.
+
         Args:
             values (dict): The values to be validated."""
         devices = MonitorConfigValidator.devices

bec_widgets/widgets/__init__.py

@@ -1,3 +1,4 @@
+from .dock import BECDock, BECDockArea
 from .figure import BECFigure, FigureConfig
 from .monitor import BECMonitor
 from .motor_control import (

bec_widgets/widgets/dock/__init__.py

@@ -0,0 +1,2 @@
+from .dock import BECDock
+from .dock_area import BECDockArea

bec_widgets/widgets/dock/dock.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal, Optional
+
+from pydantic import Field
+from pyqtgraph.dockarea import Dock
+
+from bec_widgets.cli.rpc_wigdet_handler import RPCWidgetHandler
+from bec_widgets.utils import BECConnector, ConnectionConfig, GridLayoutManager
+
+if TYPE_CHECKING:
+    from qtpy.QtWidgets import QWidget
+
+    from bec_widgets.widgets import BECDockArea
+
+
+class DockConfig(ConnectionConfig):
+    widgets: dict[str, ConnectionConfig] = Field({}, description="The widgets in the dock.")
+    position: Literal["bottom", "top", "left", "right", "above", "below"] = Field(
+        "bottom", description="The position of the dock."
+    )
+    parent_dock_area: Optional[str] = Field(
+        None, description="The GUI ID of parent dock area of the dock."
+    )
+
+
+class BECDock(BECConnector, Dock):
+    USER_ACCESS = [
+        "rpc_id",
+        "widget_list",
+        "show_title_bar",
+        "hide_title_bar",
+        "get_widgets_positions",
+        "set_title",
+        "add_widget_bec",
+        "list_eligible_widgets",
+        "move_widget",
+        "remove_widget",
+        "remove",
+        "attach",
+        "detach",
+    ]
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        parent_dock_area: BECDockArea | None = None,
+        config: DockConfig | None = None,
+        name: str | None = None,
+        client=None,
+        gui_id: str | None = None,
+        **kwargs,
+    ) -> None:
+        if config is None:
+            config = DockConfig(
+                widget_class=self.__class__.__name__, parent_dock_area=parent_dock_area.gui_id
+            )
+        else:
+            if isinstance(config, dict):
+                config = DockConfig(**config)
+            self.config = config
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        Dock.__init__(self, name=name, **kwargs)
+
+        self.parent_dock_area = parent_dock_area
+
+        # Layout Manager
+        self.layout_manager = GridLayoutManager(self.layout)
+
+    def dropEvent(self, event):
+        source = event.source()
+        old_area = source.area
+        self.setOrientation("horizontal", force=True)
+        super().dropEvent(event)
+        if old_area in self.parent_dock_area.tempAreas and old_area != self.parent_dock_area:
+            self.parent_dock_area.removeTempArea(old_area)
+
+    def float(self):
+        """
+        Float the dock.
+        Overwrites the default pyqtgraph dock float.
+        """
+
+        # need to check if the dock is temporary and if it is the only dock in the area
+        # fixes bug in pyqtgraph detaching
+        if self.area.temporary == True and len(self.area.docks) <= 1:
+            return
+        elif self.area.temporary == True and len(self.area.docks) > 1:
+            self.area.docks.pop(self.name(), None)
+            super().float()
+        else:
+            super().float()
+
+    @property
+    def widget_list(self) -> list:
+        """
+        Get the widgets in the dock.
+
+        Returns:
+            widgets(list): The widgets in the dock.
+        """
+        return self.widgets
+
+    @widget_list.setter
+    def widget_list(self, value: list):
+        self.widgets = value
+
+    def hide_title_bar(self):
+        """
+        Hide the title bar of the dock.
+        """
+        # self.hideTitleBar() #TODO pyqtgraph looks bugged ATM, doing my implementation
+        self.label.hide()
+        self.labelHidden = True
+
+    def show_title_bar(self):
+        """
+        Hide the title bar of the dock.
+        """
+        # self.showTitleBar() #TODO pyqtgraph looks bugged ATM, doing my implementation
+        self.label.show()
+        self.labelHidden = False
+
+    def set_title(self, title: str):
+        """
+        Set the title of the dock.
+
+        Args:
+            title(str): The title of the dock.
+        """
+        self.parent_dock_area.docks[title] = self.parent_dock_area.docks.pop(self.name())
+        self.setTitle(title)
+
+    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}
+        """
+        return self.layout_manager.get_widgets_positions()
+
+    def list_eligible_widgets(
+        self,
+    ) -> list:  # TODO can be moved to some util mixin like container class for rpc widgets
+        """
+        List all widgets that can be added to the dock.
+
+        Returns:
+            list: The list of eligible widgets.
+        """
+        return list(RPCWidgetHandler.widget_classes.keys())
+
+    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.
+        """
+        if row is None:
+            row = self.layout.rowCount()
+
+        if self.layout_manager.is_position_occupied(row, col):
+            self.layout_manager.shift_widgets(shift, start_row=row)
+
+        widget = RPCWidgetHandler.create_widget(widget_type)
+        self.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
+
+        return widget
+
+    def add_widget(
+        self,
+        widget: QWidget,
+        row=None,
+        col=0,
+        rowspan=1,
+        colspan=1,
+        shift: Literal["down", "up", "left", "right"] = "down",
+    ):
+        """
+        Add a widget to the dock.
+
+        Args:
+            widget(QWidget): The widget to add.
+            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.
+        """
+        if row is None:
+            row = self.layout.rowCount()
+
+        if self.layout_manager.is_position_occupied(row, col):
+            self.layout_manager.shift_widgets(shift, start_row=row)
+
+        self.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
+
+    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.
+        """
+        self.layout_manager.move_widget(widget, new_row, new_col)
+
+    def attach(self):
+        """
+        Attach the dock to the parent dock area.
+        """
+        self.parent_dock_area.removeTempArea(self.area)
+
+    def detach(self):
+        """
+        Detach the dock from the parent dock area.
+        """
+        self.float()
+
+    def remove_widget(self, widget_rpc_id: str):
+        """
+        Remove a widget from the dock.
+
+        Args:
+            widget_rpc_id(str): The ID of the widget to remove.
+        """
+        widget = self.rpc_register.get_rpc_by_id(widget_rpc_id)
+        self.layout.removeWidget(widget)
+        widget.close()
+
+    def remove(self):
+        """
+        Remove the dock from the parent dock area.
+        """
+        # self.cleanup()
+        self.parent_dock_area.remove_dock(self.name())
+
+    def cleanup(self):
+        """
+        Clean up the dock, including all its widgets.
+        """
+        for widget in self.widgets:
+            if hasattr(widget, "cleanup"):
+                widget.cleanup()
+        super().cleanup()
+
+    def close(self):
+        """
+        Close the dock area and cleanup.
+        Has to be implemented to overwrite pyqtgraph event accept in Container close.
+        """
+        self.cleanup()
+        super().close()

bec_widgets/widgets/dock/dock_area.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+from typing import Literal, Optional
+from weakref import WeakValueDictionary
+
+from pydantic import Field
+from pyqtgraph.dockarea.DockArea import DockArea
+from qtpy.QtCore import Qt
+from qtpy.QtGui import QPainter, QPaintEvent
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils import BECConnector, ConnectionConfig, WidgetContainerUtils
+
+from .dock import BECDock, DockConfig
+
+
+class DockAreaConfig(ConnectionConfig):
+    docks: dict[str, DockConfig] = Field({}, description="The docks in the dock area.")
+
+
+class BECDockArea(BECConnector, DockArea):
+    USER_ACCESS = [
+        "panels",
+        "save_state",
+        "remove_dock",
+        "restore_state",
+        "add_dock",
+        "clear_all",
+        "detach_dock",
+        "attach_all",
+        "get_all_rpc",
+    ]
+
+    def __init__(
+        self,
+        parent: QWidget | None = None,
+        config: DockAreaConfig | None = None,
+        client=None,
+        gui_id: str = None,
+    ) -> None:
+        if config is None:
+            config = DockAreaConfig(widget_class=self.__class__.__name__)
+        else:
+            if isinstance(config, dict):
+                config = DockAreaConfig(**config)
+            self.config = config
+        super().__init__(client=client, config=config, gui_id=gui_id)
+        DockArea.__init__(self, parent=parent)
+
+        self._instructions_visible = True
+
+    def paintEvent(self, event: QPaintEvent):
+        super().paintEvent(event)
+        if self._instructions_visible:
+            painter = QPainter(self)
+            painter.drawText(self.rect(), Qt.AlignCenter, "Add docks using 'add_dock' method")
+
+    @property
+    def panels(self) -> dict:
+        """
+        Get the docks in the dock area.
+        Returns:
+            dock_dict(dict): The docks in the dock area.
+        """
+        return dict(self.docks)
+
+    @panels.setter
+    def panels(self, value: dict):
+
+        self.docks = WeakValueDictionary(value)
+
+    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.
+        """
+        if state is None:
+            state = self._last_state
+        self.restoreState(state, missing=missing, extra=extra)
+
+    def save_state(self) -> dict:
+        """
+        Save the state of the dock area.
+
+        Returns:
+            dict: The state of the dock area.
+        """
+        self._last_state = self.saveState()
+        return self._last_state
+
+    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.
+        """
+        dock = self.docks.pop(name, None)
+        if dock:
+            dock.close()
+            if len(self.docks) <= 1:
+                for dock in self.docks.values():
+                    dock.hide_title_bar()
+
+        else:
+            raise ValueError(f"Dock with name {name} does not exist.")
+
+    def add_dock(
+        self,
+        name: str = None,
+        position: Literal["bottom", "top", "left", "right", "above", "below"] = None,
+        relative_to: BECDock | None = None,
+        closable: bool = False,
+        prefix: str = "dock",
+        widget: str | QWidget | None = 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(str|QWidget|None): The widget to be added to the dock. While using RPC, only BEC RPC widgets from RPCWidgetHandler are allowed.
+            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.
+        """
+        if name is None:
+            name = WidgetContainerUtils.generate_unique_widget_id(
+                container=self.docks, prefix=prefix
+            )
+
+        if name in set(self.docks.keys()):
+            raise ValueError(f"Dock with name {name} already exists.")
+
+        if position is None:
+            position = "bottom"
+
+        dock = BECDock(name=name, parent_dock_area=self, closable=closable)
+        dock.config.position = position
+        self.config.docks[name] = dock.config
+
+        self.addDock(dock=dock, position=position, relativeTo=relative_to)
+
+        if len(self.docks) <= 1:
+            dock.hide_title_bar()
+        elif len(self.docks) > 1:
+            for dock in self.docks.values():
+                dock.show_title_bar()
+
+        if widget is not None and isinstance(widget, str):
+            dock.add_widget_bec(
+                widget_type=widget, row=row, col=col, rowspan=rowspan, colspan=colspan
+            )
+        elif widget is not None and isinstance(widget, QWidget):
+            dock.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
+        if self._instructions_visible:
+            self._instructions_visible = False
+            self.update()
+        return dock
+
+    def detach_dock(self, dock_name: str) -> BECDock:
+        """
+        Undock a dock from the dock area.
+
+        Args:
+            dock_name(str): The dock to undock.
+
+        Returns:
+            BECDock: The undocked dock.
+        """
+        dock = self.docks[dock_name]
+        self.floatDock(dock)
+        return dock
+
+    def attach_all(self):
+        """
+        Return all floating docks to the dock area.
+        """
+        while self.tempAreas:
+            for temp_area in self.tempAreas:
+                self.removeTempArea(temp_area)
+
+    def clear_all(self):
+        """
+        Close all docks and remove all temp areas.
+        """
+        self.attach_all()
+        for dock in dict(self.docks).values():
+            dock.remove()
+
+    def cleanup(self):
+        """
+        Cleanup the dock area.
+        """
+        self.clear_all()
+        super().cleanup()
+
+    def close(self):
+        """
+        Close the dock area and cleanup.
+        Has to be implemented to overwrite pyqtgraph event accept in Container close.
+        """
+        self.cleanup()
+        super().close()