bec-ipython-client 3.64.1__py3-none-any.whl → 3.86.1__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.64.1
+Version: 3.86.1
 Summary: BEC IPython client
 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/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

@@ -31,7 +31,7 @@ class IPythonLiveUpdates:
         self._interrupted_request = None
         self._active_callback = None
         self._processed_instructions = 0
-        self._active_request = None
+        self._active_request: messages.ScanQueueMessage | None = None
         self._user_callback = None
         self._request_block_index = collections.defaultdict(lambda: 0)
         self._request_block_id = None
@@ -47,9 +47,11 @@ class IPythonLiveUpdates:
         Args:
             report_instructions (list): The list of report instructions.
         """
-        scan_type = self._active_request.content["scan_type"]
+        if not self._active_request:
+            return
+        scan_type = self._active_request.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
@@ -74,6 +76,9 @@ class IPythonLiveUpdates:
         scan_report_type = list(instr.keys())[0]
         scan_def_id = self.client.scans._scan_def_id
         interactive_scan = self.client.scans._interactive_scan
+        if self._active_request is None:
+            # Already checked in caller method. It is just for type checking purposes.
+            return
         if scan_def_id is None or interactive_scan:
             if scan_report_type == "readback":
                 LiveUpdatesReadbackProgressbar(
@@ -126,17 +131,22 @@ class IPythonLiveUpdates:
             )
             self._active_callback.run()
 
-    def _available_req_blocks(self, queue: QueueItem, request: messages.ScanQueueMessage):
+    def _available_req_blocks(
+        self, queue: QueueItem, request: messages.ScanQueueMessage
+    ) -> list[messages.RequestBlock]:
         """Get the available request blocks.
 
         Args:
             queue (QueueItem): The queue item.
             request (messages.ScanQueueMessage): The request message.
+
+        Returns:
+            list[messages.RequestBlock]: The list of available request blocks.
         """
         available_blocks = [
             req_block
             for req_block in queue.request_blocks
-            if req_block["RID"] == request.metadata["RID"]
+            if req_block.RID == request.metadata["RID"]
         ]
         return available_blocks
 
@@ -151,11 +161,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"]:
@@ -164,7 +177,7 @@ class IPythonLiveUpdates:
 
                 available_blocks = self._available_req_blocks(queue, request)
                 req_block = available_blocks[self._request_block_index[req_id]]
-                report_instructions = req_block.get("report_instructions", [])
+                report_instructions = req_block.report_instructions or []
                 self._process_report_instructions(report_instructions)
 
             self._reset()
@@ -188,12 +201,19 @@ class IPythonLiveUpdates:
             self.client.queue.request_scan_halt()
 
     def _element_in_queue(self) -> bool:
-        queue = self.client.queue.queue_storage.current_scan_queue.get("primary", {}).get(
-            "info", []
-        )
-        if not queue:
+        if self.client.queue is None:
+            return False
+        if (csq := self.client.queue.queue_storage.current_scan_queue) is None:
             return False
-        return self._current_queue.queue_id in queue[0].get("queue_id")
+        scan_queue_status = csq.get("primary")
+        if scan_queue_status is None:
+            return False
+        queue_info = scan_queue_status.info
+        if not queue_info:
+            return False
+        if self._current_queue is None:
+            return False
+        return self._current_queue.queue_id == queue_info[0].queue_id
 
     def _process_queue(
         self, queue: QueueItem, request: messages.ScanQueueMessage, req_id: str
@@ -213,9 +233,11 @@ class IPythonLiveUpdates:
         if not queue.request_blocks or not queue.status or queue.queue_position is None:
             return False
         if queue.status == "PENDING" and queue.queue_position > 0:
-            status = self.client.queue.queue_storage.current_scan_queue.get("primary", {}).get(
-                "status"
-            )
+            primary_queue = self.client.queue.queue_storage.current_scan_queue.get("primary")
+
+            if primary_queue is None:
+                return False
+            status = primary_queue.status
             print(
                 "Scan is enqueued and is waiting for execution. Current position in queue:"
                 f" {queue.queue_position + 1}. Queue status: {status}.",
@@ -223,14 +245,16 @@ 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 [
+        if req_block.msg.scan_type in [
             "open_scan_def",
             "mv",
         ]:  # TODO: make this more general for all scan types that don't have report instructions
             return True
 
-        report_instructions = req_block["report_instructions"]
+        report_instructions = req_block.report_instructions or []
         if not report_instructions:
             return False
         self._process_report_instructions(report_instructions)
@@ -258,7 +282,11 @@ class IPythonLiveUpdates:
         self._current_queue = None
         self._user_callback = None
         self._processed_instructions = 0
-        scan_closed = forced or (self._active_request.content["scan_type"] == "close_scan_def")
+        scan_closed = (
+            forced
+            or self._active_request is None
+            or (self._active_request.scan_type == "close_scan_def")
+        )
         self._active_request = None
 
         if self.client.scans._scan_def_id and not scan_closed:

bec_ipython_client/callbacks/live_table.py

@@ -56,7 +56,6 @@ class LiveUpdatesTable(LiveUpdatesBase):
         super().__init__(
             bec, report_instruction=report_instruction, request=request, callbacks=callbacks
         )
-        self.scan_queue_request = None
         self.scan_item = None
         self.dev_values = None
         self.point_data = None
@@ -73,12 +72,14 @@ class LiveUpdatesTable(LiveUpdatesBase):
     def wait_for_scan_to_start(self):
         """wait until the scan starts"""
         while True:
+            if not self.scan_item or not self.scan_item.queue:
+                raise RuntimeError("No scan item or scan queue available.")
             queue_pos = self.scan_item.queue.queue_position
             self.check_alarms()
             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
@@ -160,7 +161,20 @@ class LiveUpdatesTable(LiveUpdatesBase):
         return header
 
     def update_scan_item(self, timeout: float = 15):
-        """get the current scan item"""
+        """
+        Get the current scan item and update self.scan_item
+
+        Args:
+            timeout (float): timeout in seconds
+
+        Raises:
+            RuntimeError: if no scan queue request is available
+            TimeoutError: if no scan item is found before reaching the timeout
+
+        """
+        if not self.scan_queue_request:
+            raise RuntimeError("No scan queue request available.")
+
         start = time.time()
         while self.scan_queue_request.scan is None:
             self.check_alarms()
@@ -171,25 +185,38 @@ 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"""
+        if not self.scan_queue_request or not self.scan_item or not self.scan_item.queue:
+            logger.warning(
+                f"Cannot wait for report instructions. scan_queue_request: {self.scan_queue_request}, scan_item: {self.scan_item}, scan_item.queue: {getattr(self.scan_item, 'queue', None)}"
+            )
+            return
         req_ID = self.scan_queue_request.requestID
         while True:
             request_block = [
-                req for req in self.scan_item.queue.request_blocks if req["RID"] == req_ID
+                req for req in self.scan_item.queue.request_blocks if req.RID == req_ID
             ][0]
-            if not request_block["is_scan"]:
+            if not request_block.is_scan:
                 break
-            if request_block["report_instructions"]:
+            if request_block.report_instructions:
                 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
 
         Args:
             target_num_points (int): number of points to be collected
         """
+        if not self.scan_item:
+            logger.warning("No scan item available for live updates.")
+            return
         with ScanProgressBar(
             scan_number=self.scan_item.scan_number, clear_on_exit=self._print_table_data
         ) as progressbar:
@@ -211,7 +238,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:

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

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import abc
-import threading
 import time
 import traceback
 from collections.abc import Callable
@@ -21,23 +20,6 @@ class ScanRequestError(Exception):
     """Error raised when a scan request is rejected"""
 
 
-def set_event_delayed(event: threading.Event, delay: int) -> None:
-    """Set event with a delay
-
-    Args:
-        event (threading.Event): event that should be set
-        delay (int): delay time in seconds
-
-    """
-
-    def call_set():
-        time.sleep(delay)
-        event.set()
-
-    thread = threading.Thread(target=call_set, daemon=True)
-    thread.start()
-
-
 def check_alarms(bec):
     """check for alarms and raise them if needed"""
     bec.alarm_handler.raise_alarms()
@@ -62,7 +44,7 @@ class LiveUpdatesBase(abc.ABC):
         self.bec = bec
         self.request = request
         self.RID = request.metadata["RID"]
-        self.scan_queue_request = None
+        self.scan_queue_request: RequestItem | None = None
         self.report_instruction = report_instruction
         if callbacks is None:
             self.callbacks = []
@@ -138,22 +120,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"""