bec-ipython-client 3.64.5__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.64.5
+Version: 3.84.0
 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

@@ -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

@@ -78,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
@@ -171,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 = [
@@ -182,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
 
@@ -211,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:

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"""

bec_ipython_client/main.py

@@ -1,4 +1,8 @@
+from __future__ import annotations
+
 import argparse
+import collections
+import functools
 import os
 import sys
 from importlib.metadata import version
@@ -7,16 +11,18 @@ from typing import Iterable, Literal, Tuple
 import IPython
 import redis
 import redis.exceptions
-import requests
 from IPython.terminal.ipapp import TerminalIPythonApp
 from IPython.terminal.prompts import Prompts, Token
+from pydantic import ValidationError
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
 
 from bec_ipython_client.beamline_mixin import BeamlineMixin
 from bec_ipython_client.bec_magics import BECMagics
 from bec_ipython_client.callbacks.ipython_live_updates import IPythonLiveUpdates
 from bec_ipython_client.signals import ScanInterruption, SigintHandler
 from bec_lib import plugin_helper
-from bec_lib.acl_login import BECAuthenticationError
 from bec_lib.alarm_handler import AlarmBase
 from bec_lib.bec_errors import DeviceConfigError
 from bec_lib.bec_service import parse_cmdline_args
@@ -25,6 +31,7 @@ from bec_lib.client import BECClient
 from bec_lib.logger import bec_logger
 from bec_lib.redis_connector import RedisConnector
 from bec_lib.service_config import ServiceConfig
+from bec_lib.utils.pydantic_pretty_print import pretty_print_pydantic_validation_error
 
 logger = bec_logger.logger
 
@@ -79,6 +86,7 @@ class BECIPythonClient:
         self._client.callbacks.register(
             event_type=EventType.NAMESPACE_UPDATE, callback=self._update_namespace_callback
         )
+        self._alarm_history = collections.deque(maxlen=100)
 
     def __getattr__(self, name):
         return getattr(self._client, name)
@@ -136,7 +144,7 @@ class BECIPythonClient:
         self._refresh_ipython_username()
         self._load_magics()
         self._ip.events.register("post_run_cell", log_console)
-        self._ip.set_custom_exc((Exception,), _ip_exception_handler)  # register your handler
+        self._ip.set_custom_exc((Exception,), self._create_exception_handler())
         # represent objects using __str__, if overwritten, otherwise use __repr__
         self._ip.display_formatter.formatters["text/plain"].for_type(
             object,
@@ -187,10 +195,66 @@ class BECIPythonClient:
             pass
         self._client.shutdown()
 
+    def _create_exception_handler(self):
+        return functools.partial(_ip_exception_handler, parent=self)
+
+    def show_last_alarm(self, offset: int = 0):
+        """
+        Show the last alarm raised in this session with rich formatting.
+        """
+        try:
+            alarm: AlarmBase = self._alarm_history[-1 - offset][1]
+        except IndexError:
+            print("No alarm has been raised in this session.")
+            return
 
-def _ip_exception_handler(self, etype, evalue, tb, tb_offset=None):
-    if issubclass(etype, (AlarmBase, ScanInterruption, DeviceConfigError)):
-        print(f"\x1b[31m BEC alarm:\x1b[0m {evalue}")
+        console = Console()
+
+        # --- HEADER ---
+        header = Text()
+        header.append("Alarm Raised\n", style="bold red")
+        header.append(f"Severity: {alarm.severity.name}\n", style="bold")
+        header.append(f"Type: {alarm.alarm_type}\n", style="bold")
+        if alarm.alarm.info.device:
+            header.append(f"Device: {alarm.alarm.info.device}\n", style="bold")
+
+        console.print(Panel(header, title="Alarm Info", border_style="red", expand=False))
+
+        # --- SHOW SUMMARY
+        if alarm.alarm.info.compact_error_message:
+            console.print(
+                Panel(
+                    Text(alarm.alarm.info.compact_error_message, style="yellow"),
+                    title="Summary",
+                    border_style="yellow",
+                    expand=False,
+                )
+            )
+
+        # --- SHOW FULL TRACEBACK
+        tb_str = alarm.alarm.info.error_message
+        if tb_str:
+            try:
+                console.print(tb_str)
+            except Exception:
+                # fallback in case msg is not a traceback
+                console.print(Panel(tb_str, title="Message", border_style="cyan"))
+
+
+def _ip_exception_handler(
+    self, etype, evalue, tb, tb_offset=None, parent: BECIPythonClient = None, **kwargs
+):
+    if issubclass(etype, AlarmBase):
+        parent._alarm_history.append((etype, evalue, tb, tb_offset))
+        print("\x1b[31m BEC alarm:\x1b[0m")
+        evalue.pretty_print()
+        print("For more details, use 'bec.show_last_alarm()'")
+        return
+    if issubclass(etype, ValidationError):
+        pretty_print_pydantic_validation_error(evalue)
+        return
+    if issubclass(etype, (ScanInterruption, DeviceConfigError)):
+        print(f"\x1b[31m {evalue.__class__.__name__}:\x1b[0m {evalue}")
         return
     if issubclass(etype, redis.exceptions.NoPermissionError):
         # pylint: disable=protected-access
@@ -220,9 +284,14 @@ class BECClientPrompt(Prompts):
             next_scan_number = str(self.client.queue.next_scan_number)
         except Exception:
             next_scan_number = "?"
+
+        if self.client.active_account:
+            username = f"{self.client.active_account} | {self.username}"
+        else:
+            username = self.username
         return [
             (status_led, "\u2022"),
-            (Token.Prompt, " " + self.username),
+            (Token.Prompt, " " + username),  # BEC ACL username and pgroup
             (Token.Prompt, "@" + self.session_name),
             (Token.Prompt, " ["),
             (Token.PromptNum, str(self.shell.execution_count)),

{bec_ipython_client-3.64.5.dist-info → bec_ipython_client-3.84.0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: bec_ipython_client
-Version: 3.64.5
+Version: 3.84.0
 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