bec-widgets 0.54.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

CHANGELOG.md

@@ -2,6 +2,13 @@
 
 
 
+## v0.55.0 (2024-05-24)
+
+### Feature
+
+* feat(widgets/progressbar): SpiralProgressBar added with rpc interface ([`76bd0d3`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/76bd0d339ac9ae9e8a3baa0d0d4e951ec1d09670))
+
+
 ## v0.54.0 (2024-05-24)
 
 ### Build
@@ -162,11 +169,3 @@
 
 
 ## v0.49.1 (2024-04-26)
-
-### Build
-
-* build(pyqt6): fixing PyQt6-Qt6 package to 6.6.3 ([`a222298`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/a22229849cbb57c15e4c1bae02d7e52e672f8c4c))
-
-### Fix
-
-* fix(widgets/editor): qscintilla editor removed ([`ab85374`](https://gitlab.psi.ch/bec/bec_widgets/-/commit/ab8537483da6c87cb9a0b0f01706208c964f292d))

PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bec_widgets
-Version: 0.54.0
+Version: 0.55.0
 Summary: BEC Widgets
 Project-URL: Bug Tracker, https://gitlab.psi.ch/bec/bec_widgets/issues
 Project-URL: Homepage, https://gitlab.psi.ch/bec/bec_widgets

bec_widgets/cli/client.py

@@ -1630,3 +1630,255 @@ class BECDockArea(RPCBase, BECGuiClientMixin):
         """
         Get all registered RPC objects.
         """
+
+
+class SpiralProgressBar(RPCBase):
+    @rpc_call
+    def get_all_rpc(self) -> "dict":
+        """
+        Get all registered RPC objects.
+        """
+
+    @property
+    @rpc_call
+    def rpc_id(self) -> "str":
+        """
+        Get the RPC ID of the widget.
+        """
+
+    @property
+    @rpc_call
+    def config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+
+        Returns:
+            dict: The configuration of the widget.
+        """
+
+    @property
+    @rpc_call
+    def rings(self):
+        """
+        None
+        """
+
+    @rpc_call
+    def update_config(self, config: "SpiralProgressBarConfig | dict"):
+        """
+        Update the configuration of the widget.
+
+        Args:
+            config(SpiralProgressBarConfig|dict): Configuration to update.
+        """
+
+    @rpc_call
+    def add_ring(self, **kwargs) -> "Ring":
+        """
+        Add a new progress bar.
+
+        Args:
+            **kwargs: Keyword arguments for the new progress bar.
+
+        Returns:
+            Ring: Ring object.
+        """
+
+    @rpc_call
+    def remove_ring(self, index: "int"):
+        """
+        Remove a progress bar by index.
+
+        Args:
+            index(int): Index of the progress bar to remove.
+        """
+
+    @rpc_call
+    def set_precision(self, precision: "int", bar_index: "int" = None):
+        """
+        Set the precision for the progress bars. If bar_index is not provide, the precision will be set for all progress bars.
+
+        Args:
+            precision(int): Precision for the progress bars.
+            bar_index(int): Index of the progress bar to set the precision for. If provided, only a single precision can be set.
+        """
+
+    @rpc_call
+    def set_min_max_values(
+        self,
+        min_values: "int | float | list[int | float]",
+        max_values: "int | float | list[int | float]",
+    ):
+        """
+        Set the minimum and maximum values for the progress bars.
+
+        Args:
+            min_values(int|float | list[float]): Minimum value(s) for the progress bars. If multiple progress bars are displayed, provide a list of minimum values for each progress bar.
+            max_values(int|float | list[float]): Maximum value(s) for the progress bars. If multiple progress bars are displayed, provide a list of maximum values for each progress bar.
+        """
+
+    @rpc_call
+    def set_number_of_bars(self, num_bars: "int"):
+        """
+        Set the number of progress bars to display.
+
+        Args:
+            num_bars(int): Number of progress bars to display.
+        """
+
+    @rpc_call
+    def set_value(self, values: "int | list", ring_index: "int" = None):
+        """
+        Set the values for the progress bars.
+
+        Args:
+            values(int | tuple): Value(s) for the progress bars. If multiple progress bars are displayed, provide a tuple of values for each progress bar.
+            ring_index(int): Index of the progress bar to set the value for. If provided, only a single value can be set.
+
+        Examples:
+            >>> SpiralProgressBar.set_value(50)
+            >>> SpiralProgressBar.set_value([30, 40, 50]) # (outer, middle, inner)
+            >>> SpiralProgressBar.set_value(60, bar_index=1) # Set the value for the middle progress bar.
+        """
+
+    @rpc_call
+    def set_colors_from_map(self, colormap, color_format: "Literal['RGB', 'HEX']" = "RGB"):
+        """
+        Set the colors for the progress bars from a colormap.
+
+        Args:
+            colormap(str): Name of the colormap.
+            color_format(Literal["RGB","HEX"]): Format of the returned colors ('RGB', 'HEX').
+        """
+
+    @rpc_call
+    def set_colors_directly(
+        self, colors: "list[str | tuple] | str | tuple", bar_index: "int" = None
+    ):
+        """
+        Set the colors for the progress bars directly.
+
+        Args:
+            colors(list[str | tuple] | str | tuple): Color(s) for the progress bars. If multiple progress bars are displayed, provide a list of colors for each progress bar.
+            bar_index(int): Index of the progress bar to set the color for. If provided, only a single color can be set.
+        """
+
+    @rpc_call
+    def set_line_widths(self, widths: "int | list[int]", bar_index: "int" = None):
+        """
+        Set the line widths for the progress bars.
+
+        Args:
+            widths(int | list[int]): Line width(s) for the progress bars. If multiple progress bars are displayed, provide a list of line widths for each progress bar.
+            bar_index(int): Index of the progress bar to set the line width for. If provided, only a single line width can be set.
+        """
+
+    @rpc_call
+    def set_gap(self, gap: "int"):
+        """
+        Set the gap between the progress bars.
+
+        Args:
+            gap(int): Gap between the progress bars.
+        """
+
+    @rpc_call
+    def set_diameter(self, diameter: "int"):
+        """
+        Set the diameter of the widget.
+
+        Args:
+            diameter(int): Diameter of the widget.
+        """
+
+    @rpc_call
+    def reset_diameter(self):
+        """
+        Reset the fixed size of the widget.
+        """
+
+    @rpc_call
+    def enable_auto_updates(self, enable: "bool" = True):
+        """
+        Enable or disable updates based on scan status. Overrides manual updates.
+        The behaviour of the whole progress bar widget will be driven by the scan queue status.
+
+        Args:
+            enable(bool): True or False.
+
+        Returns:
+            bool: True if scan segment updates are enabled.
+        """
+
+
+class Ring(RPCBase):
+    @rpc_call
+    def get_all_rpc(self) -> "dict":
+        """
+        Get all registered RPC objects.
+        """
+
+    @property
+    @rpc_call
+    def rpc_id(self) -> "str":
+        """
+        Get the RPC ID of the widget.
+        """
+
+    @property
+    @rpc_call
+    def config_dict(self) -> "dict":
+        """
+        Get the configuration of the widget.
+
+        Returns:
+            dict: The configuration of the widget.
+        """
+
+    @rpc_call
+    def set_value(self, value: "int | float"):
+        """
+        None
+        """
+
+    @rpc_call
+    def set_color(self, color: "str | tuple"):
+        """
+        None
+        """
+
+    @rpc_call
+    def set_background(self, color: "str | tuple"):
+        """
+        None
+        """
+
+    @rpc_call
+    def set_line_width(self, width: "int"):
+        """
+        None
+        """
+
+    @rpc_call
+    def set_min_max_values(self, min_value: "int", max_value: "int"):
+        """
+        None
+        """
+
+    @rpc_call
+    def set_start_angle(self, start_angle: "int"):
+        """
+        None
+        """
+
+    @rpc_call
+    def set_connections(self, slot: "str", endpoint: "str | EndpointInfo"):
+        """
+        None
+        """
+
+    @rpc_call
+    def reset_connection(self):
+        """
+        None
+        """

bec_widgets/cli/generate_cli.py

@@ -109,13 +109,14 @@ if __name__ == "__main__":  # pragma: no cover
     import os
 
     from bec_widgets.utils import BECConnector
-    from bec_widgets.widgets import BECDock, BECDockArea, BECFigure
+    from bec_widgets.widgets import BECDock, BECDockArea, BECFigure, SpiralProgressBar
     from bec_widgets.widgets.figure.plots.image.image import BECImageShow
     from bec_widgets.widgets.figure.plots.image.image_item import BECImageItem
     from bec_widgets.widgets.figure.plots.motor_map.motor_map import BECMotorMap
     from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase
     from bec_widgets.widgets.figure.plots.waveform.waveform import BECWaveform
     from bec_widgets.widgets.figure.plots.waveform.waveform_curve import BECCurve
+    from bec_widgets.widgets.spiral_progress_bar.ring import Ring
 
     current_path = os.path.dirname(__file__)
     client_path = os.path.join(current_path, "client.py")
@@ -130,6 +131,8 @@ if __name__ == "__main__":  # pragma: no cover
         BECMotorMap,
         BECDock,
         BECDockArea,
+        SpiralProgressBar,
+        Ring,
     ]
     generator = ClientGenerator()
     generator.generate_client(clss)

bec_widgets/cli/rpc_wigdet_handler.py

@@ -1,11 +1,12 @@
 from bec_widgets.utils import BECConnector
 from bec_widgets.widgets.figure import BECFigure
+from bec_widgets.widgets.spiral_progress_bar.spiral_progress_bar import SpiralProgressBar
 
 
 class RPCWidgetHandler:
     """Handler class for creating widgets from RPC messages."""
 
-    widget_classes = {"BECFigure": BECFigure}
+    widget_classes = {"BECFigure": BECFigure, "SpiralProgressBar": SpiralProgressBar}
 
     @staticmethod
     def create_widget(widget_type, **kwargs) -> BECConnector:

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -13,6 +13,7 @@ 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
+from bec_widgets.widgets.spiral_progress_bar.spiral_progress_bar import SpiralProgressBar
 
 
 class JupyterConsoleWidget(RichJupyterWidget):  # pragma: no cover:
@@ -62,6 +63,7 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
                 "d1": self.d1,
                 "d2": self.d2,
                 "d3": self.d3,
+                "bar": self.bar,
                 "b2a": self.button_2_a,
                 "b2b": self.button_2_b,
                 "b2c": self.button_2_c,
@@ -114,14 +116,14 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         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.bar = SpiralProgressBar()
 
         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.d2 = self.dock.add_dock(widget=self.bar, position="right")
         self.d3 = self.dock.add_dock(name="figure")
         self.fig_dock3 = BECFigure()
         self.fig_dock3.plot(x_name="samx", y_name="bpm4d")

bec_widgets/widgets/__init__.py

@@ -1,3 +1,4 @@
 from .dock import BECDock, BECDockArea
 from .figure import BECFigure, FigureConfig
 from .scan_control import ScanControl
+from .spiral_progress_bar import SpiralProgressBar

bec_widgets/widgets/spiral_progress_bar/__init__.py

@@ -0,0 +1 @@
+from .spiral_progress_bar import SpiralProgressBar

bec_widgets/widgets/spiral_progress_bar/ring.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+from typing import Literal, Optional
+
+from bec_lib.endpoints import EndpointInfo
+from pydantic import BaseModel, Field, field_validator
+from pydantic_core import PydanticCustomError
+from qtpy import QtGui
+
+from bec_widgets.utils import BECConnector, ConnectionConfig
+
+
+class RingConnections(BaseModel):
+    slot: Literal["on_scan_progress", "on_device_readback"] = None
+    endpoint: EndpointInfo | str = None
+
+    @field_validator("endpoint")
+    def validate_endpoint(cls, v, values):
+        slot = values.data["slot"]
+        endpoint = v.endpoint if isinstance(v, EndpointInfo) else v
+        if slot == "on_scan_progress":
+            if endpoint != "scans/scan_progress":
+                raise PydanticCustomError(
+                    "unsupported endpoint",
+                    "For slot 'on_scan_progress', endpoint must be MessageEndpoint.scan_progress or 'scans/scan_progress'.",
+                    {"wrong_value": v},
+                )
+        elif slot == "on_device_readback":
+            if not endpoint.startswith("internal/devices/readback/"):
+                raise PydanticCustomError(
+                    "unsupported endpoint",
+                    "For slot 'on_device_readback', endpoint must be MessageEndpoint.device_readback(device) or 'internal/devices/readback/{device}'.",
+                    {"wrong_value": v},
+                )
+        return v
+
+
+class RingConfig(ConnectionConfig):
+    direction: int | None = Field(
+        -1, description="Direction of the progress bars. -1 for clockwise, 1 for counter-clockwise."
+    )
+    color: str | tuple | None = Field(
+        (0, 159, 227, 255),
+        description="Color for the progress bars. Can be tuple (R, G, B, A) or string HEX Code.",
+    )
+    background_color: str | tuple | None = Field(
+        (200, 200, 200, 50),
+        description="Background color for the progress bars. Can be tuple (R, G, B, A) or string HEX Code.",
+    )
+    index: int | None = Field(0, description="Index of the progress bar. 0 is outer ring.")
+    line_width: int | None = Field(5, description="Line widths for the progress bars.")
+    start_position: int | None = Field(
+        90,
+        description="Start position for the progress bars in degrees. Default is 90 degrees - corespons to "
+        "the top of the ring.",
+    )
+    min_value: int | None = Field(0, description="Minimum value for the progress bars.")
+    max_value: int | None = Field(100, description="Maximum value for the progress bars.")
+    precision: int | None = Field(3, description="Precision for the progress bars.")
+    update_behaviour: Literal["manual", "auto"] | None = Field(
+        "auto", description="Update behaviour for the progress bars."
+    )
+    connections: RingConnections | None = Field(
+        default_factory=RingConnections, description="Connections for the progress bars."
+    )
+
+
+class Ring(BECConnector):
+    USER_ACCESS = [
+        "get_all_rpc",
+        "rpc_id",
+        "config_dict",
+        "set_value",
+        "set_color",
+        "set_background",
+        "set_line_width",
+        "set_min_max_values",
+        "set_start_angle",
+        "set_connections",
+        "reset_connection",
+    ]
+
+    def __init__(
+        self,
+        parent=None,
+        parent_progress_widget=None,
+        config: RingConfig | dict | None = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ):
+        if config is None:
+            config = RingConfig(widget_class=self.__class__.__name__)
+            self.config = config
+        else:
+            if isinstance(config, dict):
+                config = RingConfig(**config)
+            self.config = config
+        super().__init__(client=client, config=config, gui_id=gui_id)
+
+        self.parent_progress_widget = parent_progress_widget
+        self.color = None
+        self.background_color = None
+        self.start_position = None
+        self.config = config
+        self.value = 0
+        self.RID = None
+        self._init_config_params()
+
+    def _init_config_params(self):
+        self.color = self.convert_color(self.config.color)
+        self.background_color = self.convert_color(self.config.background_color)
+        self.set_start_angle(self.config.start_position)
+        if self.config.connections:
+            self.set_connections(self.config.connections.slot, self.config.connections.endpoint)
+
+    def set_value(self, value: int | float):
+        self.value = round(
+            max(self.config.min_value, min(self.config.max_value, value)), self.config.precision
+        )
+
+    def set_color(self, color: str | tuple):
+        self.config.color = color
+        self.color = self.convert_color(color)
+
+    def set_background(self, color: str | tuple):
+        self.config.background_color = color
+        self.color = self.convert_color(color)
+
+    def set_line_width(self, width: int):
+        self.config.line_width = width
+
+    def set_min_max_values(self, min_value: int, max_value: int):
+        self.config.min_value = min_value
+        self.config.max_value = max_value
+
+    def set_start_angle(self, start_angle: int):
+        self.config.start_position = start_angle
+        self.start_position = start_angle * 16
+
+    @staticmethod
+    def convert_color(color):
+        converted_color = None
+        if isinstance(color, str):
+            converted_color = QtGui.QColor(color)
+        elif isinstance(color, tuple):
+            converted_color = QtGui.QColor(*color)
+        return converted_color
+
+    def set_connections(self, slot: str, endpoint: str | EndpointInfo):
+        if self.config.connections.endpoint == endpoint and self.config.connections.slot == slot:
+            return
+        else:
+            self.bec_dispatcher.disconnect_slot(
+                self.config.connections.slot, self.config.connections.endpoint
+            )
+            self.config.connections = RingConnections(slot=slot, endpoint=endpoint)
+            self.bec_dispatcher.connect_slot(getattr(self, slot), endpoint)
+
+    def reset_connection(self):
+        self.bec_dispatcher.disconnect_slot(
+            self.config.connections.slot, self.config.connections.endpoint
+        )
+        self.config.connections = RingConnections()
+
+    def on_scan_progress(self, msg, meta):
+        current_RID = meta.get("RID", None)
+        if current_RID != self.RID:
+            self.set_min_max_values(0, msg.get("max_value", 100))
+        self.set_value(msg.get("value", 0))
+        self.parent_progress_widget.update()
+
+    def on_device_readback(self, msg, meta):
+        if isinstance(self.config.connections.endpoint, EndpointInfo):
+            endpoint = self.config.connections.endpoint.endpoint
+        else:
+            endpoint = self.config.connections.endpoint
+        device = endpoint.split("/")[-1]
+        value = msg.get("signals").get(device).get("value")
+        self.set_value(value)
+        self.parent_progress_widget.update()
+
+    def cleanup(self):
+        self.reset_connection()
+        super().cleanup()