bec-ipython-client 3.35.6__py3-none-any.whl → 3.84.0__py3-none-any.whl

.gitignore

@@ -9,6 +9,9 @@
 **/*.egg*
 **/*.env
 
+# bec_widgets saved profiles
+widgets_settings/profiles/*
+
 # recovery_config files
 recovery_config_*
 

PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: bec_ipython_client
-Version: 3.35.6
+Version: 3.84.0
 Summary: BEC IPython client
-Project-URL: Bug Tracker, https://gitlab.psi.ch/bec/bec/issues
-Project-URL: Homepage, https://gitlab.psi.ch/bec/bec
+Project-URL: Bug Tracker, https://github.com/bec-project/bec/issues
+Project-URL: Homepage, https://github.com/bec-project/bec
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: bec-lib~=3.0
 Requires-Dist: ipython~=8.22
 Requires-Dist: numpy<3.0,>=1.24

bec_ipython_client/bec_startup.py

@@ -32,9 +32,12 @@ except (BECAuthenticationError, KeyboardInterrupt) as exc:
 except Exception:
     sys.excepthook(*sys.exc_info())
 else:
-    if bec.started and not _main_dict["args"].nogui and BECGuiClient is not None:
+    if bec.started and BECGuiClient is not None:
         gui = bec.gui = BECGuiClient()
-        gui.start()
+        if _main_dict["args"].gui_id:
+            gui.connect_to_gui_server(_main_dict["args"].gui_id)
+        if not _main_dict["args"].nogui:
+            gui.show()
 
     _available_plugins = plugin_helper.get_ipython_client_startup_plugins(state="post")
     if _available_plugins:

bec_ipython_client/callbacks/device_progress.py

@@ -14,11 +14,16 @@ class LiveUpdatesDeviceProgress(LiveUpdatesTable):
 
     REPORT_TYPE = "device_progress"
 
-    def _run_update(self, device_names: str):
+    def core(self):
+        """core function to run the live updates for the table"""
+        self._wait_for_report_instructions()
+        self._run_update(self.report_instruction[self.REPORT_TYPE])
+
+    def _run_update(self, device_names: list[str]):
         """Run the update loop for the progress bar.
 
         Args:
-            device_names (str): The name of the device to monitor.
+            device_names (list[str]): The name of the device to monitor.
         """
         with ScanProgressBar(
             scan_number=self.scan_item.scan_number, clear_on_exit=False
@@ -29,7 +34,7 @@ class LiveUpdatesDeviceProgress(LiveUpdatesTable):
                 self._print_client_msgs_asap()
         self._print_client_msgs_all()
 
-    def _update_progressbar(self, progressbar: ScanProgressBar, device_names: str) -> bool:
+    def _update_progressbar(self, progressbar: ScanProgressBar, device_names: list[str]) -> bool:
         """Update the progressbar based on the device status message
 
         Args:
@@ -41,17 +46,17 @@ class LiveUpdatesDeviceProgress(LiveUpdatesTable):
         self.check_alarms()
         status = self.bec.connector.get(MessageEndpoints.device_progress(device_names[0]))
         if not status:
-            logger.debug("waiting for new data point")
+            logger.trace("waiting for new data point")
             time.sleep(0.1)
             return False
         if status.metadata.get("scan_id") != self.scan_item.scan_id:
-            logger.debug("waiting for new data point")
+            logger.trace("waiting for new data point")
             time.sleep(0.1)
             return False
 
         point_id = status.content.get("value")
         if point_id is None:
-            logger.debug("waiting for new data point")
+            logger.trace("waiting for new data point")
             time.sleep(0.1)
             return False
 

bec_ipython_client/callbacks/ipython_live_updates.py

@@ -49,7 +49,7 @@ class IPythonLiveUpdates:
         """
         scan_type = self._active_request.content["scan_type"]
         if scan_type in ["open_scan_def", "close_scan_def"]:
-            self._process_instruction({"scan_progress": 0})
+            self._process_instruction({"scan_progress": {"points": 0, "show_table": True}})
             return
         if scan_type == "close_scan_group":
             return
@@ -151,11 +151,14 @@ class IPythonLiveUpdates:
                 scan_request = ScanRequestMixin(self.client, request.metadata["RID"])
                 scan_request.wait()
 
+                # After .wait, we can be sure that the queue item is available, so we can
+                assert scan_request.scan_queue_request is not None
+
                 # get the corresponding queue item
-                while not scan_request.request_storage.storage[-1].queue:
+                while not scan_request.scan_queue_request.queue:
                     time.sleep(0.01)
 
-                self._current_queue = queue = scan_request.request_storage.storage[-1].queue
+                self._current_queue = queue = scan_request.scan_queue_request.queue
                 self._request_block_id = req_id = self._active_request.metadata.get("RID")
 
                 while queue.status not in ["COMPLETED", "ABORTED", "HALTED"]:
@@ -223,6 +226,8 @@ class IPythonLiveUpdates:
                 flush=True,
             )
         available_blocks = self._available_req_blocks(queue, request)
+        if not available_blocks:
+            return False
         req_block = available_blocks[self._request_block_index[req_id]]
         if req_block["content"]["scan_type"] in [
             "open_scan_def",

bec_ipython_client/callbacks/live_table.py

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 import time
 from collections.abc import Callable
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, SupportsFloat
+
+import numpy as np
 
 from bec_ipython_client.prettytable import PrettyTable
 from bec_ipython_client.progressbar import ScanProgressBar
@@ -66,6 +68,7 @@ class LiveUpdatesTable(LiveUpdatesBase):
             if print_table_data is not None
             else self.REPORT_TYPE == "scan_progress"
         )
+        self._devices_with_bad_precision = set()
 
     def wait_for_scan_to_start(self):
         """wait until the scan starts"""
@@ -75,7 +78,7 @@ class LiveUpdatesTable(LiveUpdatesBase):
             if self.scan_item.status == "closed":
                 break
             if queue_pos is None:
-                logger.debug(f"Could not find queue entry for scan_id {self.scan_item.scan_id}")
+                logger.trace(f"Could not find queue entry for scan_id {self.scan_item.scan_id}")
                 continue
             if queue_pos == 0:
                 break
@@ -168,6 +171,13 @@ class LiveUpdatesTable(LiveUpdatesBase):
 
     def core(self):
         """core function to run the live updates for the table"""
+        self._wait_for_report_instructions()
+        show_table = self.report_instruction[self.REPORT_TYPE].get("show_table", True)
+        self._print_table_data = show_table
+        self._run_update(self.report_instruction[self.REPORT_TYPE]["points"])
+
+    def _wait_for_report_instructions(self):
+        """wait until the report instructions are available"""
         req_ID = self.scan_queue_request.requestID
         while True:
             request_block = [
@@ -179,8 +189,6 @@ class LiveUpdatesTable(LiveUpdatesBase):
                 break
             self.check_alarms()
 
-        self._run_update(self.report_instruction[self.REPORT_TYPE])
-
     def _run_update(self, target_num_points: int):
         """run the update loop with the progress bar
 
@@ -208,7 +216,7 @@ class LiveUpdatesTable(LiveUpdatesBase):
                     self.bec.callbacks.poll()
                     self.scan_item.poll_callbacks()
                 else:
-                    logger.debug("waiting for new data point")
+                    logger.trace("waiting for new data point")
                     time.sleep(0.1)
 
                 if not self.scan_item.num_points:
@@ -219,6 +227,24 @@ class LiveUpdatesTable(LiveUpdatesBase):
                 if self.point_id > self.scan_item.num_points:
                     raise RuntimeError("Received more points than expected.")
 
+                if len(self.scan_item.live_data) == 0 and self.scan_item.status == "closed":
+                    msg = self.scan_item.status_message
+                    if not msg:
+                        continue
+                    if msg.readout_priority.get("monitored", []):
+                        continue
+
+                    logger.warning(
+                        f"\n Scan {self.scan_item.scan_number} finished. No monitored devices enabled, please check your config."
+                    )
+                    break
+
+    def _warn_bad_precisions(self):
+        if self._devices_with_bad_precision != set():
+            for dev, prec in self._devices_with_bad_precision:
+                logger.warning(f"Device {dev} reported malformed precision of {prec}!")
+            self._devices_with_bad_precision = set()
+
     @property
     def _print_table_data(self) -> bool:
         """Checks if the table should be printed or not.
@@ -261,40 +287,41 @@ class LiveUpdatesTable(LiveUpdatesBase):
 
         if self.point_id % 100 == 0:
             print(self.table.get_header_lines())
-        ind = 0
+
+        signals_precisions = []
         for dev in self.devices:
             if dev in self.bec.device_manager.devices:
                 obj = self.bec.device_manager.devices[dev]
                 for hint in obj._hints:
                     signal = self.point_data.content["data"].get(obj.root.name, {}).get(hint)
-                    if signal is None or signal.get("value") is None:
-                        print_value = "N/A"
+                    if signal is None:
+                        signals_precisions.append((None, None))
                     else:
-                        try:
-                            precision = getattr(obj, "precision")
-                        except AttributeError:
-                            precision = 2
-                        value = signal.get("value")
-                        if isinstance(value, (int, float)):
-                            print_value = f"{value:.{precision}f}"
-                        else:
-                            print_value = str(value)
-                    self.dev_values[ind] = print_value
-                    ind += 1
+                        prec = getattr(obj, "precision", 2)
+                        if not isinstance(prec, int):
+                            self._devices_with_bad_precision.add((dev, prec))
+                            prec = 2
+                        signals_precisions.append((signal, prec))
             else:
-                signal = self.point_data.content["data"].get(dev, {})
-                value = signal.get("value")
-                if value is not None:
-                    if isinstance(value, (int, float)):
-                        print_value = f"{value:.2f}"
-                    else:
-                        print_value = str(value)
-                else:
-                    print_value = "N/A"
-                self.dev_values[ind] = print_value
-                ind += 1
+                signals_precisions.append((self.point_data.content["data"].get(dev, {}), 2))
+
+        for i, (signal, precision) in enumerate(signals_precisions):
+            self.dev_values[i] = self._format_value(signal, precision)
+
         print(self.table.get_row(str(self.point_id), *self.dev_values))
 
+    def _format_value(self, signal: dict | None, precision: int = 2):
+        if signal is None:
+            return "N/A"
+        val = signal.get("value")
+        if isinstance(val, SupportsFloat) and not isinstance(val, np.ndarray):
+            if precision < 0:
+                # This is to cover the special case when EPICS returns a negative precision.
+                # More info: https://epics.anl.gov/tech-talk/2004/msg00434.php
+                return f"{float(val):.{-precision}g}"
+            return f"{float(val):.{precision}f}"
+        return str(val)
+
     def close_table(self):
         """close the table and print the footer"""
         if not self.table:
@@ -305,6 +332,7 @@ class LiveUpdatesTable(LiveUpdatesBase):
                 f"Scan {self.scan_item.scan_number} finished. Scan ID {self.scan_item.scan_id}. Elapsed time: {elapsed_time:.2f} s"
             )
         )
+        self._warn_bad_precisions()
 
     def process_request(self):
         """process the request and start the core loop for live updates"""

bec_ipython_client/callbacks/move_device.py

@@ -1,31 +1,110 @@
 from __future__ import annotations
 
+import threading
 from collections.abc import Callable
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 import numpy as np
 
 from bec_ipython_client.progressbar import DeviceProgressBar
+from bec_lib import messages
 from bec_lib.endpoints import MessageEndpoints
+from bec_lib.redis_connector import MessageObject
 
 from .utils import LiveUpdatesBase, check_alarms
 
 if TYPE_CHECKING:
-    from bec_lib import messages
     from bec_lib.client import BECClient
     from bec_lib.devicemanager import DeviceManagerBase
 
 
-class ReadbackDataMixin:
-    def __init__(self, device_manager: DeviceManagerBase, devices: list) -> None:
-        """Mixin to get the current device values and request-done messages.
+class ReadbackDataHandler:
+    """Helper class to get the current device values and request-done messages."""
+
+    def __init__(
+        self, device_manager: DeviceManagerBase, devices: list[str], request_id: str
+    ) -> None:
+        """Helper class to get the current device values and request-done messages.
 
         Args:
             device_manager (DeviceManagerBase): device manager
             devices (list): list of devices to monitor
+            request_id (str): request ID
         """
         self.device_manager = device_manager
         self.devices = devices
+        self.connector = device_manager.connector
+        self.request_id = request_id
+        self._devices_received = {dev: False for dev in devices}
+        self.data: dict[str, messages.DeviceMessage] = {}
+        self._devices_done_state: dict[str, tuple[bool, bool]] = {
+            dev: (False, False) for dev in devices
+        }
+        self.requests_done = threading.Event()
+        self._register_callbacks()
+
+    def _register_callbacks(self):
+        """register callbacks for device readback messages."""
+        for dev in self.devices:
+            self.connector.register(
+                MessageEndpoints.device_readback(dev), cb=self.on_readback, parent=self, device=dev
+            )
+        self.connector.register(
+            MessageEndpoints.device_req_status(self.request_id),
+            cb=self.on_req_status,
+            from_start=True,
+            parent=self,
+        )
+
+    def _unregister_callbacks(self):
+        """unregister callbacks for device readback messages."""
+        for dev in self.devices:
+            self.connector.unregister(MessageEndpoints.device_readback(dev), cb=self.on_readback)
+        self.connector.unregister(
+            MessageEndpoints.device_req_status(self.request_id), cb=self.on_req_status
+        )
+
+    @staticmethod
+    def on_req_status(
+        msg_obj: dict[str, messages.DeviceReqStatusMessage], parent: ReadbackDataHandler
+    ):
+        """Callback for device request status messages to track which devices are done.
+
+        Args:
+            msg_obj (dict[str, messages.DeviceReqStatusMessage]): message object or device request status message
+            parent (ReadbackDataHandler): parent instance
+        """
+        # pylint: disable=protected-access
+        msg = msg_obj["data"]
+        if msg.request_id != parent.request_id:
+            return
+        device = msg.device
+        parent._devices_done_state[device] = (True, msg.success)
+
+        if (
+            all(done for done, _ in parent._devices_done_state.values())
+            and not parent.requests_done.is_set()
+        ):
+            parent._on_request_done()
+
+    @staticmethod
+    def on_readback(msg_obj: MessageObject, parent: ReadbackDataHandler, device: str):
+        """Callback for updating device readback data.
+
+        Args:
+            msg_obj (MessageObject): message object
+            parent (ReadbackDataHandler): parent instance
+            device (str): device name
+        """
+        # pylint: disable=protected-access
+        msg: messages.DeviceMessage = cast(messages.DeviceMessage, msg_obj.value)
+        parent._devices_received[device] = True
+        parent.data[device] = msg
+
+    def _on_request_done(self):
+        """Callback for when all requests are done."""
+        self.requests_done.set()
+        self._unregister_callbacks()
 
     def get_device_values(self) -> list:
         """get the current device values
@@ -35,57 +114,55 @@ class ReadbackDataMixin:
         """
         values = []
         for dev in self.devices:
-            val = self.device_manager.devices[dev].read(cached=True)
-            if not val:
-                values.append(np.nan)
-                continue
+            val = self.data.get(dev)
+            if val is None:
+                signal_data = self.device_manager.devices[dev].read(cached=True)
+            else:
+                signal_data = val.signals
             # pylint: disable=protected-access
             hints = self.device_manager.devices[dev]._hints
             # if we have hints, use them to get the value, otherwise just use the first value
             if hints:
-                values.append(val.get(hints[0]).get("value"))
+                values.append(signal_data.get(hints[0]).get("value"))
             else:
-                values.append(val.get(list(val.keys())[0]).get("value"))
+                values.append(signal_data.get(list(signal_data.keys())[0]).get("value"))
         return values
 
-    def get_request_done_msgs(self):
-        """get all request-done messages"""
-        pipe = self.device_manager.connector.pipeline()
-        for dev in self.devices:
-            self.device_manager.connector.get(MessageEndpoints.device_req_status(dev), pipe)
-        return self.device_manager.connector.execute_pipeline(pipe)
+    def done(self) -> bool:
+        """check if all devices are done
 
-    def wait_for_RID(self, request: messages.ScanQueueMessage) -> None:
-        """wait for the readback's metadata to match the request ID
+        Returns:
+            bool: True if all devices are done, False otherwise
+        """
+        return self.requests_done.is_set()
 
-        Args:
-            request (messages.ScanQueueMessage): request message
+    def device_states(self) -> dict[str, tuple[bool, bool]]:
         """
-        while True:
-            msgs = [
-                self.device_manager.connector.get(MessageEndpoints.device_readback(dev))
-                for dev in self.devices
-            ]
-            if all(msg.metadata.get("RID") == request.metadata["RID"] for msg in msgs if msg):
-                break
-            check_alarms(self.device_manager.parent)
+        Return the current device done states.
+
+        Returns:
+            dict: dictionary with device names as keys and tuples of (done, success) as values
+        """
+        return self._devices_done_state
 
 
 class LiveUpdatesReadbackProgressbar(LiveUpdatesBase):
     """Live feedback on motor movements using a progressbar.
 
     Args:
-        dm (DeviceManagerBase): device_manager
-        request (ScanQueueMessage): request that should be monitored
+        bec (BECClient): BECClient instance
+        report_instruction (list, optional): report instruction for the scan. Defaults to None.
+        request (messages.ScanQueueMessage, optional): scan queue request message. Defaults to None.
+        callbacks (list[Callable], optional): list of callbacks to register. Defaults to None.
 
     """
 
     def __init__(
         self,
         bec: BECClient,
-        report_instruction: list = None,
-        request: messages.ScanQueueMessage = None,
-        callbacks: list[Callable] = None,
+        report_instruction: list | None = None,
+        request: messages.ScanQueueMessage | None = None,
+        callbacks: list[Callable] | None = None,
     ) -> None:
         super().__init__(
             bec, report_instruction=report_instruction, request=request, callbacks=callbacks
@@ -97,18 +174,20 @@ class LiveUpdatesReadbackProgressbar(LiveUpdatesBase):
 
     def core(self):
         """core function to monitor the device values and update the progressbar accordingly."""
-        data_source = ReadbackDataMixin(self.bec.device_manager, self.devices)
+        request_id = self.request.metadata["RID"]
+        if self.report_instruction:
+            self.devices = self.report_instruction["readback"]["devices"]
+            request_id = self.report_instruction["readback"]["RID"]
+        data_source = ReadbackDataHandler(self.bec.device_manager, self.devices, request_id)
         start_values = data_source.get_device_values()
         self.wait_for_request_acceptance()
-        data_source.wait_for_RID(self.request)
+
         if self.report_instruction:
-            self.devices = self.report_instruction["readback"]["devices"]
             target_values = self.report_instruction["readback"]["end"]
 
             start_instr = self.report_instruction["readback"].get("start")
             if start_instr:
                 start_values = self.report_instruction["readback"]["start"]
-            data_source = ReadbackDataMixin(self.bec.device_manager, self.devices)
         else:
             target_values = [
                 x for xs in self.request.content["parameter"]["args"].values() for x in xs
@@ -119,33 +198,16 @@ class LiveUpdatesReadbackProgressbar(LiveUpdatesBase):
         with DeviceProgressBar(
             self.devices, start_values=start_values, target_values=target_values
         ) as progress:
-            req_done = False
-            while not progress.finished or not req_done:
+
+            while not progress.finished or not data_source.done():
                 check_alarms(self.bec)
 
                 values = data_source.get_device_values()
                 progress.update(values=values)
                 self._print_client_msgs_asap()
 
-                msgs = data_source.get_request_done_msgs()
-                request_ids = [
-                    msg.metadata["RID"] if (msg and msg.metadata.get("RID")) else None
-                    for msg in msgs
-                ]
-
-                if self.report_instruction:
-                    compare_rids = set([self.report_instruction["readback"]["RID"]])
-                else:
-                    compare_rids = set([self.request.metadata["RID"]])
-                if set(request_ids) != set(compare_rids):
-                    progress.sleep()
-                    continue
-
-                req_done = True
-                for dev, msg in zip(self.devices, msgs):
-                    if not msg:
-                        continue
-                    if msg.content.get("success", False):
+                for dev, (done, success) in data_source.device_states().items():
+                    if done and success:
                         progress.set_finished(dev)
                 # pylint: disable=protected-access
                 progress._progress.refresh()

bec_ipython_client/callbacks/utils.py

@@ -138,22 +138,22 @@ class ScanRequestMixin:
         Returns:
             RequestItem: scan queue request
         """
-        logger.debug("Waiting for request ID")
+        logger.trace("Waiting for request ID")
         start = time.time()
         while self.request_storage.find_request_by_ID(self.RID) is None:
             time.sleep(0.1)
             check_alarms(self.bec)
-        logger.debug(f"Waiting for request ID finished after {time.time()-start} s.")
+        logger.trace(f"Waiting for request ID finished after {time.time()-start} s.")
         return self.request_storage.find_request_by_ID(self.RID)
 
     def _wait_for_scan_request_decision(self):
         """wait for a scan queuest decision"""
-        logger.debug("Waiting for decision")
+        logger.trace("Waiting for decision")
         start = time.time()
         while self.scan_queue_request.decision_pending:
             time.sleep(0.1)
             check_alarms(self.bec)
-        logger.debug(f"Waiting for decision finished after {time.time()-start} s.")
+        logger.trace(f"Waiting for decision finished after {time.time()-start} s.")
 
     def wait(self):
         """wait for the request acceptance"""