bec-ipython-client 2.21.2__tar.gz → 3.86.2__tar.gz

{bec_ipython_client-2.21.2 → bec_ipython_client-3.86.2}/.gitignore

@@ -7,6 +7,10 @@
 **/.vscode
 **/.pytest_cache
 **/*.egg*
+**/*.env
+
+# bec_widgets saved profiles
+widgets_settings/profiles/*
 
 # recovery_config files
 recovery_config_*

{bec_ipython_client-2.21.2 → bec_ipython_client-3.86.2}/PKG-INFO

@@ -1,25 +1,25 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: bec_ipython_client
-Version: 2.21.2
+Version: 3.86.2
 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-Dist: bec-lib
+Requires-Python: >=3.11
+Requires-Dist: bec-lib~=3.0
 Requires-Dist: ipython~=8.22
-Requires-Dist: numpy~=1.24
+Requires-Dist: numpy<3.0,>=1.24
 Requires-Dist: pyepics~=3.5
 Requires-Dist: requests~=2.31
 Requires-Dist: rich~=13.7
 Provides-Extra: dev
-Requires-Dist: black~=24.0; extra == 'dev'
+Requires-Dist: black~=25.0; extra == 'dev'
 Requires-Dist: coverage~=7.0; extra == 'dev'
 Requires-Dist: isort>=5.13.2,~=5.13; extra == 'dev'
 Requires-Dist: pylint~=3.0; extra == 'dev'
-Requires-Dist: pytest-bec-e2e; extra == 'dev'
+Requires-Dist: pytest-bec-e2e~=3.0; extra == 'dev'
 Requires-Dist: pytest-random-order~=1.1; extra == 'dev'
 Requires-Dist: pytest-redis~=3.1; extra == 'dev'
 Requires-Dist: pytest-retry~=1.1; extra == 'dev'

{bec_ipython_client-2.21.2 → bec_ipython_client-3.86.2}/bec_ipython_client/bec_magics.py

@@ -2,15 +2,18 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+import rich
 from IPython.core.magic import Magics, line_magic, magics_class
 
+from bec_lib.metadata_schema import get_metadata_schema_for_scan
+
 if TYPE_CHECKING:
-    from bec_ipython_client import BECClient
+    from bec_ipython_client import BECIPythonClient
 
 
 @magics_class
 class BECMagics(Magics):
-    def __init__(self, shell, client: BECClient):
+    def __init__(self, shell, client: BECIPythonClient):
         super(BECMagics, self).__init__(shell)
         self.client = client
 
@@ -28,7 +31,7 @@ class BECMagics(Magics):
     def resume(self, line):
         "Resume the scan"
         self.client.queue.request_scan_continuation()
-        return self.client.live_updates.continue_request()
+        return self.client._live_updates.continue_request()
 
     @line_magic
     def pause(self, line):
@@ -52,9 +55,31 @@ class BECMagics(Magics):
         scan_report = self.client.scans._available_scans["fermat_scan"]._get_scan_report_type(
             hide_report
         )
-        return self.client.live_updates.process_request(request, scan_report, [])
+        return self.client._live_updates.process_request(request, scan_report, [])
 
     @line_magic
     def halt(self, line):
         "Request a scan halt, i.e. abort without cleanup."
         return self.client.queue.request_scan_halt()
+
+    @line_magic
+    def server_restart(self, line):
+        "Request a server restart"
+        return self.client._request_server_restart()
+
+    @line_magic
+    def schema(self, line):
+        "print the metadata schema for a given scan"
+        scans = self.shell.user_ns["scans"]
+        if not hasattr(scans, line):
+            print(f"Scan {line} does not exist.")
+        else:
+            rich.print_json(data=get_metadata_schema_for_scan(line).model_json_schema())
+
+    @line_magic
+    def su(self, line):
+        "Switch user"
+        # pylint: disable=protected-access
+        self.client._client.acl.login(line)
+        self.client._client._update_username()
+        self.client._refresh_ipython_username()

{bec_ipython_client-2.21.2 → bec_ipython_client-3.86.2}/bec_ipython_client/bec_startup.py

@@ -1,19 +1,20 @@
 import os
 import sys
+import threading
 
 import numpy as np  # not needed but always nice to have
 
 from bec_ipython_client.main import BECIPythonClient as _BECIPythonClient
 from bec_ipython_client.main import main_dict as _main_dict
 from bec_lib import plugin_helper
+from bec_lib.acl_login import BECAuthenticationError
 from bec_lib.logger import bec_logger as _bec_logger
 from bec_lib.redis_connector import RedisConnector as _RedisConnector
 
 try:
-    from bec_widgets.cli.auto_updates import AutoUpdates
-    from bec_widgets.cli.client import BECDockArea as _BECDockArea
+    from bec_widgets.cli.client_utils import BECGuiClient
 except ImportError:
-    _BECDockArea = None
+    BECGuiClient = None
 
 logger = _bec_logger.logger
 
@@ -22,21 +23,21 @@ bec = _BECIPythonClient(
 )
 _main_dict["bec"] = bec
 
+
 try:
     bec.start()
+except (BECAuthenticationError, KeyboardInterrupt) as exc:
+    logger.error(f"{exc} Exiting.")
+    os._exit(0)
 except Exception:
     sys.excepthook(*sys.exc_info())
 else:
-    if bec.started and not _main_dict["args"].nogui and _BECDockArea is not None:
-        gui = bec.gui = _BECDockArea()
-        gui.show()
-        if gui.auto_updates is None:
-            AutoUpdates.create_default_dock = True
-            AutoUpdates.enabled = True
-            gui.auto_updates = AutoUpdates(gui=gui)
-        if gui.auto_updates.create_default_dock:
-            gui.auto_updates.start_default_dock()
-        fig = gui.auto_updates.get_default_figure()
+    if bec.started and BECGuiClient is not None:
+        gui = bec.gui = BECGuiClient()
+        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-2.21.2 → bec_ipython_client-3.86.2}/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
@@ -27,11 +32,9 @@ class LiveUpdatesDeviceProgress(LiveUpdatesTable):
                 if self._update_progressbar(progressbar, device_names):
                     break
                 self._print_client_msgs_asap()
+        self._print_client_msgs_all()
 
-        # TODO #286
-        # 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:
@@ -43,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-2.21.2 → bec_ipython_client-3.86.2}/bec_ipython_client/callbacks/ipython_live_updates.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import collections
 import time
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from bec_ipython_client.callbacks.device_progress import LiveUpdatesDeviceProgress
 from bec_lib.bec_errors import ScanInterruption
@@ -31,22 +31,27 @@ 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
-        self.print_table_data = True
         self._current_queue = None
 
+    @property
+    def print_table_data(self):
+        return self.client.live_updates_config.print_live_table
+
     def _process_report_instructions(self, report_instructions: list) -> None:
         """Process instructions for the live updates.
 
         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
@@ -70,7 +75,11 @@ class IPythonLiveUpdates:
         """
         scan_report_type = list(instr.keys())[0]
         scan_def_id = self.client.scans._scan_def_id
-        if scan_def_id is None:
+        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(
                     self.client,
@@ -122,21 +131,26 @@ 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
 
-    def process_request(self, request: messages.ScanQueueMessage, callbacks: any) -> None:
+    def process_request(self, request: messages.ScanQueueMessage, callbacks: Any) -> None:
         """Process the request and report instructions."""
         # pylint: disable=protected-access
         try:
@@ -147,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"]:
@@ -160,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()
@@ -184,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
@@ -209,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}.",
@@ -219,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)
@@ -235,6 +263,9 @@ class IPythonLiveUpdates:
         if self._active_callback and complete_rbl:
             return True
 
+        if complete_rbl and self.client.scans._interactive_scan:
+            return True
+
         if not queue.active_request_block:
             return True
 
@@ -251,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-2.21.2 → bec_ipython_client-3.86.2}/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
@@ -20,7 +22,9 @@ logger = bec_logger.logger
 def sort_devices(devices, scan_devices) -> list:
     """sort the devices to ensure that the table starts with scan motors"""
     for scan_dev in list(scan_devices)[::-1]:
-        devices.remove(scan_dev)
+        root_dev = scan_dev.split(".")[0]
+        if root_dev in devices:
+            devices.remove(root_dev)
         devices.insert(0, scan_dev)
     return devices
 
@@ -52,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
@@ -64,16 +67,19 @@ 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"""
         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
@@ -112,7 +118,7 @@ class LiveUpdatesTable(LiveUpdatesBase):
     def devices(self):
         """get the devices for the callback"""
         if self.point_data.metadata["scan_type"] == "step":
-            return self.get_devices_from_scan_data(self.scan_item.data[0])
+            return self.get_devices_from_scan_data(self.scan_item.live_data[0])
         if self.point_data.metadata["scan_type"] == "fly":
             devices = list(self.point_data.content["data"].keys())
             if len(devices) > self.MAX_DEVICES:
@@ -127,7 +133,6 @@ class LiveUpdatesTable(LiveUpdatesBase):
         monitored_devices = device_manager.devices.monitored_devices(
             [device_manager.devices[dev] for dev in scan_devices]
         )
-        # devices = [hint for dev in monitored_devices for hint in dev._hints]
         devices = [dev.name for dev in monitored_devices]
         devices = sort_devices(devices, scan_devices)
         if len(devices) > self.MAX_DEVICES:
@@ -156,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()
@@ -167,31 +185,44 @@ 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:
             while True:
                 self.check_alarms()
-                self.point_data = self.scan_item.data.get(self.point_id)
+                self.point_data = self.scan_item.live_data.get(self.point_id)
                 if self.scan_item.num_points:
                     progressbar.max_points = self.scan_item.num_points
                     if target_num_points == 0:
@@ -207,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:
@@ -218,6 +249,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.
@@ -248,6 +297,8 @@ class LiveUpdatesTable(LiveUpdatesBase):
 
     def print_table_data(self):
         """print the table data for the current point_id"""
+        # pylint: disable=protected-access
+        self._print_client_msgs_asap()
         if not self._print_table_data:
             return
 
@@ -258,41 +309,40 @@ 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(dev, {}).get(hint)
-                    if signal is None or signal.get("value") is None:
-                        print_value = "N/A"
+                    signal = self.point_data.content["data"].get(obj.root.name, {}).get(hint)
+                    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))
-        # pylint: disable=protected-access
-        self._print_client_msgs_asap()
+
+    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"""
@@ -304,8 +354,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"
             )
         )
-        # TODO #286
-        # self._print_client_msgs_all()
+        self._warn_bad_precisions()
 
     def process_request(self):
         """process the request and start the core loop for live updates"""
@@ -335,3 +384,4 @@ class LiveUpdatesTable(LiveUpdatesBase):
         self.wait_for_scan_item_to_finish()
         if self._print_table_data:
             self.close_table()
+        self._print_client_msgs_all()