bec-ipython-client 3.37.0__tar.gz → 3.88.0__tar.gz

{bec_ipython_client-3.37.0 → bec_ipython_client-3.88.0}/.gitignore

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

{bec_ipython_client-3.37.0 → bec_ipython_client-3.88.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: bec_ipython_client
-Version: 3.37.0
+Version: 3.88.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-3.37.0 → bec_ipython_client-3.88.0}/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-3.37.0 → bec_ipython_client-3.88.0}/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-3.37.0 → bec_ipython_client-3.88.0}/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-3.37.0 → bec_ipython_client-3.88.0}/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
@@ -54,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
@@ -66,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
@@ -157,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()
@@ -168,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:
@@ -208,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,12 +248,25 @@ class LiveUpdatesTable(LiveUpdatesBase):
                     break
                 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.
@@ -266,40 +309,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:
@@ -310,6 +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"
             )
         )
+        self._warn_bad_precisions()
 
     def process_request(self):
         """process the request and start the core loop for live updates"""

bec_ipython_client-3.88.0/bec_ipython_client/callbacks/move_device.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import threading
+from collections.abc import Callable
+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.client import BECClient
+    from bec_lib.devicemanager import DeviceManagerBase
+
+
+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
+
+        Returns:
+            list: list of device values
+        """
+        values = []
+        for dev in self.devices:
+            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(signal_data.get(hints[0]).get("value"))
+            else:
+                values.append(signal_data.get(list(signal_data.keys())[0]).get("value"))
+        return values
+
+    def done(self) -> bool:
+        """check if all devices are done
+
+        Returns:
+            bool: True if all devices are done, False otherwise
+        """
+        return self.requests_done.is_set()
+
+    def device_states(self) -> dict[str, tuple[bool, bool]]:
+        """
+        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:
+        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 = None,
+        request: messages.ScanQueueMessage | None = None,
+        callbacks: list[Callable] | None = None,
+    ) -> None:
+        super().__init__(
+            bec, report_instruction=report_instruction, request=request, callbacks=callbacks
+        )
+        if report_instruction:
+            self.devices = report_instruction["readback"]["devices"]
+        else:
+            self.devices = list(request.content["parameter"]["args"].keys())
+
+    def core(self):
+        """core function to monitor the device values and update the progressbar accordingly."""
+        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()
+
+        if self.report_instruction:
+            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"]
+        else:
+            target_values = [
+                x for xs in self.request.content["parameter"]["args"].values() for x in xs
+            ]
+            if self.request.content["parameter"]["kwargs"].get("relative"):
+                target_values = np.asarray(target_values) + np.asarray(start_values)
+
+        with DeviceProgressBar(
+            self.devices, start_values=start_values, target_values=target_values
+        ) as progress:
+
+            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()
+
+                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()
+        self._print_client_msgs_all()
+
+    def run(self):
+        """run the progressbar."""
+        self.core()