bec-widgets 0.49.1__tar.gz → 0.50.1__tar.gz

{bec_widgets-0.49.1 → bec_widgets-0.50.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bec_widgets
-Version: 0.49.1
+Version: 0.50.1
 Summary: BEC Widgets
 Home-page: https://gitlab.psi.ch/bec/bec-widgets
 Project-URL: Bug Tracker, https://gitlab.psi.ch/bec/bec-widgets/issues

{bec_widgets-0.49.1 → bec_widgets-0.50.1}/bec_widgets/cli/client.py

@@ -136,6 +136,13 @@ class BECPlotBase(RPCBase):
 
 
 class BECWaveform(RPCBase):
+    @property
+    @rpc_call
+    def rpc_id(self) -> "str":
+        """
+        Get the RPC ID of the widget.
+        """
+
     @property
     @rpc_call
     def config_dict(self) -> "dict":
@@ -387,6 +394,13 @@ class BECWaveform(RPCBase):
 
 
 class BECFigure(RPCBase, BECFigureClientMixin):
+    @property
+    @rpc_call
+    def rpc_id(self) -> "str":
+        """
+        Get the RPC ID of the widget.
+        """
+
     @property
     @rpc_call
     def config_dict(self) -> "dict":
@@ -396,13 +410,16 @@ class BECFigure(RPCBase, BECFigureClientMixin):
             dict: The configuration of the widget.
         """
 
-    @property
     @rpc_call
-    def axes(self) -> "list[BECPlotBase]":
+    def axes(self, row: "int", col: "int") -> "BECPlotBase":
         """
-        Access all widget in BECFigure as a list
+        Get widget by its coordinates in the figure.
+        Args:
+            row(int): the row coordinate
+            col(int): the column coordinate
+
         Returns:
-            list[BECPlotBase]: List of all widgets in the figure.
+            BECPlotBase: the widget at the given coordinates
         """
 
     @property
@@ -614,8 +631,36 @@ class BECFigure(RPCBase, BECFigureClientMixin):
         Clear all widgets from the figure and reset to default state
         """
 
+    @rpc_call
+    def get_all_rpc(self) -> "dict":
+        """
+        Get all registered RPC objects.
+        """
+
+    @property
+    @rpc_call
+    def widget_list(self) -> "list[BECPlotBase]":
+        """
+        Access all widget in BECFigure as a list
+        Returns:
+            list[BECPlotBase]: List of all widgets in the figure.
+        """
+
 
 class BECCurve(RPCBase):
+    @rpc_call
+    def remove(self):
+        """
+        Remove the curve from the plot.
+        """
+
+    @property
+    @rpc_call
+    def rpc_id(self) -> "str":
+        """
+        Get the RPC ID of the widget.
+        """
+
     @property
     @rpc_call
     def config_dict(self) -> "dict":
@@ -713,6 +758,13 @@ class BECCurve(RPCBase):
 
 
 class BECImageShow(RPCBase):
+    @property
+    @rpc_call
+    def rpc_id(self) -> "str":
+        """
+        Get the RPC ID of the widget.
+        """
+
     @property
     @rpc_call
     def config_dict(self) -> "dict":
@@ -1045,8 +1097,21 @@ class BECConnector(RPCBase):
             dict: The configuration of the widget.
         """
 
+    @rpc_call
+    def get_all_rpc(self) -> "dict":
+        """
+        Get all registered RPC objects.
+        """
+
 
 class BECImageItem(RPCBase):
+    @property
+    @rpc_call
+    def rpc_id(self) -> "str":
+        """
+        Get the RPC ID of the widget.
+        """
+
     @property
     @rpc_call
     def config_dict(self) -> "dict":

{bec_widgets-0.49.1 → bec_widgets-0.50.1}/bec_widgets/cli/client_utils.py

@@ -12,7 +12,7 @@ import uuid
 from functools import wraps
 from typing import TYPE_CHECKING
 
-from bec_lib import MessageEndpoints, messages
+from bec_lib import MessageEndpoints, ServiceConfig, messages
 from bec_lib.connector import MessageObject
 from bec_lib.device import DeviceBase
 from qtpy.QtCore import QCoreApplication
@@ -136,10 +136,11 @@ class BECFigureClientMixin:
         """
         self._start_update_script()
         # pylint: disable=subprocess-run-check
+        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]
+        command = [sys.executable, "-u", monitor_path, "--id", self._gui_id, "--config", config]
         self._process = subprocess.Popen(
             command, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
         )
@@ -157,17 +158,24 @@ class BECFigureClientMixin:
         self.stderr_output.clear()
 
     def _get_output(self) -> str:
-        os.set_blocking(self._process.stdout.fileno(), False)
-        os.set_blocking(self._process.stderr.fileno(), False)
-        while self._process.poll() is None:
-            readylist, _, _ = select.select([self._process.stdout, self._process.stderr], [], [], 1)
-            if self._process.stdout in readylist:
-                # print("*"*10, self._process.stdout.read(1024), flush=True, end="")
-                self._process.stdout.read(1024)
-            if self._process.stderr in readylist:
-                # print("!"*10, self._process.stderr.read(1024), flush=True, end="", file=sys.stderr)
-                print(self._process.stderr.read(1024), flush=True, end="", file=sys.stderr)
-                self.stderr_output.append(self._process.stderr.read(1024))
+        try:
+            os.set_blocking(self._process.stdout.fileno(), False)
+            os.set_blocking(self._process.stderr.fileno(), False)
+            while self._process.poll() is None:
+                readylist, _, _ = select.select(
+                    [self._process.stdout, self._process.stderr], [], [], 1
+                )
+                if self._process.stdout in readylist:
+                    output = self._process.stdout.read(1024)
+                    if output:
+                        print(output, end="")
+                if self._process.stderr in readylist:
+                    error_output = self._process.stderr.read(1024)
+                    if error_output:
+                        print(error_output, end="", file=sys.stderr)
+                        self.stderr_output.append(error_output)
+        except Exception as e:
+            print(f"Error reading process output: {str(e)}")
 
 
 class RPCResponseTimeoutError(Exception):

bec_widgets-0.50.1/bec_widgets/cli/rpc_register.py

@@ -0,0 +1,76 @@
+from threading import Lock
+from weakref import WeakValueDictionary
+
+from qtpy.QtCore import QObject
+
+
+class RPCRegister:
+    """
+    A singleton class that keeps track of all the RPC objects registered in the system for CLI usage.
+    """
+
+    _instance = None
+    _initialized = False
+    _lock = Lock()
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(RPCRegister, cls).__new__(cls)
+            cls._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+        self._rpc_register = WeakValueDictionary()
+        self._initialized = True
+
+    def add_rpc(self, rpc: QObject):
+        """
+        Add an RPC object to the register.
+        Args:
+            rpc(QObject): The RPC object to be added to the register.
+        """
+        if not hasattr(rpc, "gui_id"):
+            raise ValueError("RPC object must have a 'gui_id' attribute.")
+        self._rpc_register[rpc.gui_id] = rpc
+
+    def remove_rpc(self, rpc: str):
+        """
+        Remove an RPC object from the register.
+        Args:
+            rpc(str): The RPC object to be removed from the register.
+        """
+        if not hasattr(rpc, "gui_id"):
+            raise ValueError(f"RPC object {rpc} must have a 'gui_id' attribute.")
+        self._rpc_register.pop(rpc.gui_id, None)
+
+    def get_rpc_by_id(self, gui_id: str) -> QObject:
+        """
+        Get an RPC object by its ID.
+        Args:
+            gui_id(str): The ID of the RPC object to be retrieved.
+
+        Returns:
+            QObject: The RPC object with the given ID.
+        """
+        rpc_object = self._rpc_register.get(gui_id, None)
+        return rpc_object
+
+    def list_all_connections(self) -> dict:
+        """
+        List all the registered RPC objects.
+        Returns:
+            dict: A dictionary containing all the registered RPC objects.
+        """
+        with self._lock:
+            connections = dict(self._rpc_register)
+        return connections
+
+    @classmethod
+    def reset_singleton(cls):
+        """
+        Reset the singleton instance.
+        """
+        cls._instance = None
+        cls._initialized = False

{bec_widgets-0.49.1 → bec_widgets-0.50.1}/bec_widgets/cli/server.py

@@ -5,6 +5,7 @@ import time
 from bec_lib import MessageEndpoints, messages
 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.figure import BECFigure
@@ -14,12 +15,16 @@ from bec_widgets.widgets.plots import BECCurve, BECImageShow, BECWaveform
 class BECWidgetsCLIServer:
     WIDGETS = [BECWaveform, BECFigure, BECCurve, BECImageShow]
 
-    def __init__(self, gui_id: str = None, dispatcher: BECDispatcher = None, client=None) -> None:
-        self.dispatcher = BECDispatcher() if dispatcher is None else dispatcher
+    def __init__(
+        self, gui_id: str = None, dispatcher: BECDispatcher = None, client=None, config=None
+    ) -> 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.rpc_register = RPCRegister()
+        self.rpc_register.add_rpc(self.fig)
 
         self.dispatcher.connect_slot(
             self.on_rpc_update, MessageEndpoints.gui_instructions(self.gui_id)
@@ -29,15 +34,15 @@ class BECWidgetsCLIServer:
         self._shutdown_event = False
         self._heartbeat_timer = QTimer()
         self._heartbeat_timer.timeout.connect(self.emit_heartbeat)
-        self._heartbeat_timer.start(1000)  # Emit heartbeat every 1 seconds
+        self._heartbeat_timer.start(200)  # Emit heartbeat every 1 seconds
 
     def on_rpc_update(self, msg: dict, metadata: dict):
         request_id = metadata.get("request_id")
         try:
+            obj = self.get_object_from_config(msg["parameter"])
             method = msg["action"]
             args = msg["parameter"].get("args", [])
             kwargs = msg["parameter"].get("kwargs", {})
-            obj = self.get_object_from_config(msg["parameter"])
             res = self.run_rpc(obj, method, args, kwargs)
         except Exception as e:
             print(e)
@@ -54,20 +59,10 @@ class BECWidgetsCLIServer:
 
     def get_object_from_config(self, config: dict):
         gui_id = config.get("gui_id")
-        # check if the object is the figure
-        if gui_id == self.fig.gui_id:
-            return self.fig
-        # check if the object is a widget
-        if gui_id in self.fig._widgets:
-            obj = self.fig._widgets[config["gui_id"]]
-            return obj
-        if self.fig._widgets:
-            for widget in self.fig._widgets.values():
-                item = widget.find_widget_by_id(gui_id)
-                if item:
-                    return item
-
-        raise ValueError(f"Object with gui_id {gui_id} not found")
+        obj = self.rpc_register.get_rpc_by_id(gui_id)
+        if obj is None:
+            raise ValueError(f"Object with gui_id {gui_id} not found")
+        return obj
 
     def run_rpc(self, obj, method, args, kwargs):
         method_obj = getattr(obj, method)
@@ -106,7 +101,6 @@ class BECWidgetsCLIServer:
                 messages.StatusMessage(name=self.gui_id, status=1, info={}),
                 expire=10,
             )
-        print("Heartbeat emitted")
 
     def shutdown(self):
         self._shutdown_event = True
@@ -133,11 +127,12 @@ 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("--config", type=str, help="Config to connect to redis.")
 
     args = parser.parse_args()
 
-    server = BECWidgetsCLIServer(gui_id=args.id)
-    # server = BECWidgetsCLIServer(gui_id="test")
+    server = BECWidgetsCLIServer(gui_id=args.id, config=args.config)
+    # server = BECWidgetsCLIServer(gui_id="test",config="awi-bec-dev-01:6379")
 
     fig = server.fig
     win.setCentralWidget(fig)

{bec_widgets-0.49.1 → bec_widgets-0.50.1}/bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -7,6 +7,7 @@ from qtconsole.inprocess import QtInProcessKernelManager
 from qtconsole.rich_jupyter_widget import RichJupyterWidget
 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
 
@@ -43,10 +44,14 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         self.safe_close = False
         # self.figure.clean_signal.connect(self.confirm_close)
 
+        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,
                 "w1": self.w1,
                 "w2": self.w2,
                 "w3": self.w3,

{bec_widgets-0.49.1 → bec_widgets-0.50.1}/bec_widgets/utils/bec_connector.py

@@ -7,6 +7,7 @@ from typing import Optional, Type
 from pydantic import BaseModel, Field, field_validator
 from qtpy.QtCore import Slot as pyqtSlot
 
+from bec_widgets.cli.rpc_register import RPCRegister
 from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
 
@@ -31,7 +32,7 @@ class ConnectionConfig(BaseModel):
 class BECConnector:
     """Connection mixin class for all BEC widgets, to handle BEC client and device manager"""
 
-    USER_ACCESS = ["config_dict"]
+    USER_ACCESS = ["config_dict", "get_all_rpc"]
 
     def __init__(self, client=None, config: ConnectionConfig = None, gui_id: str = None):
         # BEC related connections
@@ -54,6 +55,25 @@ class BECConnector:
         else:
             self.gui_id = self.config.gui_id
 
+        # register widget to rpc register
+        self.rpc_register = RPCRegister()
+        self.rpc_register.add_rpc(self)
+
+    def get_all_rpc(self) -> dict:
+        """Get all registered RPC objects."""
+        all_connections = self.rpc_register.list_all_connections()
+        return dict(all_connections)
+
+    @property
+    def rpc_id(self) -> str:
+        """Get the RPC ID of the widget."""
+        return self.gui_id
+
+    @rpc_id.setter
+    def rpc_id(self, rpc_id: str) -> None:
+        """Set the RPC ID of the widget."""
+        self.gui_id = rpc_id
+
     @property
     def config_dict(self) -> dict:
         """

{bec_widgets-0.49.1 → bec_widgets-0.50.1}/bec_widgets/utils/bec_dispatcher.py

@@ -6,7 +6,7 @@ from collections.abc import Callable
 from typing import TYPE_CHECKING, Union
 
 import redis
-from bec_lib import BECClient
+from bec_lib import BECClient, ServiceConfig
 from bec_lib.redis_connector import MessageObject, RedisConnector
 from qtpy.QtCore import QObject
 from qtpy.QtCore import Signal as pyqtSignal
@@ -71,13 +71,13 @@ class BECDispatcher:
     _instance = None
     _initialized = False
 
-    def __new__(cls, client=None, *args, **kwargs):
+    def __new__(cls, client=None, config: str = None, *args, **kwargs):
         if cls._instance is None:
             cls._instance = super(BECDispatcher, cls).__new__(cls)
             cls._initialized = False
         return cls._instance
 
-    def __init__(self, client=None):
+    def __init__(self, client=None, config: str = None):
         if self._initialized:
             return
 
@@ -85,7 +85,14 @@ class BECDispatcher:
         self.client = client
 
         if self.client is None:
-            self.client = BECClient(connector_cls=QtRedisConnector, forced=True)
+            if config is not None:
+                host, port = config.split(":")
+                redis_config = {"host": host, "port": port}
+                self.client = BECClient(
+                    config=ServiceConfig(redis=redis_config), connector_cls=QtRedisConnector
+                )  # , forced=True)
+            else:
+                self.client = BECClient(connector_cls=QtRedisConnector)  # , forced=True)
         else:
             if self.client.started:
                 # have to reinitialize client to use proper connector

{bec_widgets-0.49.1 → bec_widgets-0.50.1}/bec_widgets/widgets/figure/figure.py

@@ -97,6 +97,7 @@ class WidgetHandler:
 
 class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
     USER_ACCESS = [
+        "rpc_id",
         "config_dict",
         "axes",
         "widgets",
@@ -110,6 +111,8 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         "change_layout",
         "change_theme",
         "clear_all",
+        "get_all_rpc",
+        "widget_list",
     ]
 
     clean_signal = pyqtSignal()
@@ -138,8 +141,21 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         # Container to keep track of the grid
         self.grid = []
 
+    def __getitem__(self, key: tuple | str):
+        if isinstance(key, tuple) and len(key) == 2:
+            return self.axes(*key)
+        elif isinstance(key, str):
+            widget = self._widgets.get(key)
+            if widget is None:
+                raise KeyError(f"No widget with ID {key}")
+            return self._widgets.get(key)
+        else:
+            raise TypeError(
+                "Key must be a string (widget id) or a tuple of two integers (grid coordinates)"
+            )
+
     @property
-    def axes(self) -> list[BECPlotBase]:
+    def widget_list(self) -> list[BECPlotBase]:
         """
         Access all widget in BECFigure as a list
         Returns:
@@ -148,8 +164,8 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
         axes = [value for value in self._widgets.values() if isinstance(value, BECPlotBase)]
         return axes
 
-    @axes.setter
-    def axes(self, value: list[BECPlotBase]):
+    @widget_list.setter
+    def widget_list(self, value: list[BECPlotBase]):
         self._axes = value
 
     @property
@@ -623,7 +639,7 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             row(int): The row coordinate of the widget to remove.
             col(int): The column coordinate of the widget to remove.
         """
-        widget = self._get_widget_by_coordinates(row, col)
+        widget = self.axes(row, col)
         if widget:
             widget_id = widget.config.gui_id
             if widget_id in self._widgets:
@@ -643,24 +659,10 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
             self._reindex_grid()
             if widget_id in self.config.widgets:
                 self.config.widgets.pop(widget_id)
-            print(f"Removed widget {widget_id}.")
         else:
             raise ValueError(f"Widget with ID '{widget_id}' does not exist.")
 
-    def __getitem__(self, key: tuple | str):
-        if isinstance(key, tuple) and len(key) == 2:
-            return self._get_widget_by_coordinates(*key)
-        elif isinstance(key, str):
-            widget = self._widgets.get(key)
-            if widget is None:
-                raise KeyError(f"No widget with ID {key}")
-            return self._widgets.get(key)
-        else:
-            raise TypeError(
-                "Key must be a string (widget id) or a tuple of two integers (grid coordinates)"
-            )
-
-    def _get_widget_by_coordinates(self, row: int, col: int) -> BECPlotBase:
+    def axes(self, row: int, col: int) -> BECPlotBase:
         """
         Get widget by its coordinates in the figure.
         Args:
@@ -699,7 +701,6 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
 
     def _reindex_grid(self):
         """Reindex the grid to remove empty rows and columns."""
-        print(f"old grid: {self.grid}")
         new_grid = []
         for row in self.grid:
             new_row = [widget for widget in row if widget is not None]
@@ -766,8 +767,8 @@ class BECFigure(BECConnector, pg.GraphicsLayoutWidget):
 
     def clear_all(self):
         """Clear all widgets from the figure and reset to default state"""
-        # for widget in self._widgets.values():
-        #     widget.cleanup()
+        for widget in self._widgets.values():
+            widget.cleanup()
         self.clear()
         self._widgets = defaultdict(dict)
         self.grid = []

{bec_widgets-0.49.1 → bec_widgets-0.50.1}/bec_widgets/widgets/plots/image.py

@@ -59,6 +59,7 @@ class ImageConfig(WidgetConfig):
 
 class BECImageItem(BECConnector, pg.ImageItem):
     USER_ACCESS = [
+        "rpc_id",
         "config_dict",
         "set",
         "set_fft",
@@ -287,9 +288,14 @@ class BECImageItem(BECConnector, pg.ImageItem):
         else:
             raise ValueError("style should be 'simple' or 'full'")
 
+    def cleanup(self):
+        """Clean up widget."""
+        self.rpc_register.remove_rpc(self)
+
 
 class BECImageShow(BECPlotBase):
     USER_ACCESS = [
+        "rpc_id",
         "config_dict",
         "add_image_by_config",
         "get_image_config",
@@ -358,20 +364,6 @@ class BECImageShow(BECPlotBase):
 
         thread.start()
 
-    def find_widget_by_id(self, item_id: str) -> BECImageItem:
-        """
-        Find the widget by its gui_id.
-        Args:
-            item_id(str): The gui_id of the widget.
-
-        Returns:
-            BECImageItem: The widget with the given gui_id.
-        """
-        for source, images in self._images.items():
-            for monitor, image_item in images.items():
-                if image_item.gui_id == item_id:
-                    return image_item
-
     def find_image_by_monitor(self, item_id: str) -> BECImageItem:
         """
         Find the widget by its gui_id.
@@ -719,10 +711,8 @@ class BECImageShow(BECPlotBase):
         processing_config = image_to_update.config.processing
         self.processor.set_config(processing_config)
         if self.use_threading:
-            print("using threaded version")
             self._create_thread_worker(device, data)
         else:
-            print("using NON-threaded version")
             data = self.processor.process_image(data)
             self.update_image(device, data)
 
@@ -809,14 +799,14 @@ class BECImageShow(BECPlotBase):
         """
         Clean up the widget.
         """
-        print(f"Cleaning up {self.gui_id}")
-        # for monitor in self._images["device_monitor"]:
-        #     self.bec_dispatcher.disconnect_slot(
-        #         self.on_image_update, MessageEndpoints.device_monitor(monitor)
-        #     )
-        # if self.thread is not None and self.thread.isRunning():
-        #     self.thread.quit()
-        #     self.thread.wait()
+        for monitor in self._images["device_monitor"]:
+            self.bec_dispatcher.disconnect_slot(
+                self.on_image_update, MessageEndpoints.device_monitor(monitor)
+            )
+        for image in self.images:
+            image.cleanup()
+
+        self.rpc_register.remove_rpc(self)
 
 
 class ImageProcessor: