bec-ipython-client 3.151.3__tar.gz → 3.153.0__tar.gz

{bec_ipython_client-3.151.3 → bec_ipython_client-3.153.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bec_ipython_client
-Version: 3.151.3
+Version: 3.153.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

{bec_ipython_client-3.151.3 → bec_ipython_client-3.153.0}/bec_ipython_client/callbacks/ipython_live_updates.py

@@ -16,7 +16,13 @@ from bec_lib.request_context import ActiveRequestContext, active_request_context
 
 from .live_table import LiveUpdatesTable
 from .move_device import LiveUpdatesReadbackProgressbar
-from .utils import ScanRequestMixin, ScanState, check_alarms, evaluate_scan_state
+from .utils import (
+    ScanRequestMixin,
+    ScanState,
+    check_alarms,
+    evaluate_scan_state,
+    pending_queue_message,
+)
 
 if TYPE_CHECKING:
     from bec_lib import messages
@@ -308,7 +314,7 @@ class IPythonLiveUpdates:
         if queue.queue_position is None:
             return False
 
-        if queue.status == "PENDING":
+        if self._is_pending_queue_state(queue):
             self._process_pending_queue_element(queue)
             return False
 
@@ -342,6 +348,28 @@ class IPythonLiveUpdates:
 
         return False
 
+    def _is_pending_queue_state(self, queue: QueueItem) -> bool:
+        """
+        Check if the queue is in a pending state, which can be due to either the queue
+        being locked or other scans being ahead in the queue.
+
+        Args:
+            queue(QueueItem): The queue item to check.
+
+        Returns:
+            bool: True if the queue is in a pending state, False otherwise.
+        """
+        if queue.status == "PENDING":
+            return True
+
+        active_request_block = queue.active_request_block
+        if active_request_block is not None and getattr(
+            active_request_block, "pending_device_locks", None
+        ):
+            return True
+
+        return False
+
     def _process_pending_queue_element(self, queue: QueueItem) -> None:
         """
         Process a pending queue element.
@@ -353,45 +381,22 @@ class IPythonLiveUpdates:
 
         if self.client.queue is None or self.client.queue.queue_storage.current_scan_queue is None:
             return
-        target_queue = self.client.queue.get_default_scan_queue()
-        target_queue_status = self.client.queue.queue_storage.current_scan_queue.get(target_queue)
-        if target_queue_status is None:
-            return
 
         queue_position = queue.queue_position
         if queue_position is None:
             return
 
-        status = target_queue_status.status
-        if status == "LOCKED" and any(queue.scan_ids):
-            lock_info = [
-                f"{lock.identifier}: {lock.reason}\n" for lock in target_queue_status.locks
-            ]
-            message = (
-                f"Scan is waiting for the lock to be released. Active locks: \n{''.join(lock_info)}"
-            )
-            if self._status_live is None:
-                self._status_live = Live(
-                    Panel(message, title="[yellow]Scan Status[/yellow]"), refresh_per_second=4
-                )
-                self._status_live.start()
-            else:
-                self._status_live.update(Panel(message, title="[yellow]Scan Status[/yellow]"))
+        message = pending_queue_message(bec=self.client, queue=queue, queue_position=queue_position)
+        if message is None:
             return
-
-        if queue_position > 0:
-            message = (
-                f"Scan is enqueued and is waiting for execution. Current position in queue {target_queue}:"
-                f" {queue_position + 1}. Queue status: {status}."
+        if self._status_live is None:
+            self._status_live = Live(
+                Panel(message, title="[yellow]Scan Status[/yellow]"), refresh_per_second=4
             )
-            if self._status_live is None:
-                self._status_live = Live(
-                    Panel(message, title="[yellow]Scan Status[/yellow]"), refresh_per_second=4
-                )
-                self._status_live.start()
-            else:
-                self._status_live.update(Panel(message, title="[yellow]Scan Status[/yellow]"))
-            return
+            self._status_live.start()
+        else:
+            self._status_live.update(Panel(message, title="[yellow]Scan Status[/yellow]"))
+        return
 
     def _reset(self, forced=False):
         """Reset the active request and callback.

{bec_ipython_client-3.151.3 → bec_ipython_client-3.153.0}/bec_ipython_client/callbacks/live_table.py

@@ -11,7 +11,7 @@ from bec_ipython_client.progressbar import ScanProgressBar
 from bec_lib.bec_errors import ScanInterruption, ScanRestart
 from bec_lib.logger import bec_logger
 
-from .utils import LiveUpdatesBase, check_alarms
+from .utils import LiveUpdatesBase, check_alarms, pending_queue_message
 
 if TYPE_CHECKING:
     from bec_lib import messages
@@ -75,20 +75,18 @@ class LiveUpdatesTable(LiveUpdatesBase):
         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
+            queue = self.scan_item.queue
+            queue_pos = queue.queue_position
             self.check_alarms()
             if self.scan_item.status == "closed":
                 break
             if queue_pos is None:
                 logger.trace(f"Could not find queue entry for scan_id {self.scan_item.scan_id}")
                 continue
-            if queue_pos == 0:
+            message = pending_queue_message(bec=self.bec, queue=queue, queue_position=queue_pos)
+            if message is None:
                 break
-            print(
-                f"Scan is enqueued and is waiting for execution. Current position in queue: {queue_pos + 1}.",
-                end="\r",
-                flush=True,
-            )
+            print(message, end="\r", flush=True)
             time.sleep(0.1)
         while not self.scan_item.scan_number:
             time.sleep(0.05)

{bec_ipython_client-3.151.3 → bec_ipython_client-3.153.0}/bec_ipython_client/callbacks/move_device.py

@@ -12,7 +12,13 @@ from bec_lib import messages
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.redis_connector import MessageObject
 
-from .utils import LiveUpdatesBase, ScanState, check_alarms, evaluate_scan_state
+from .utils import (
+    LiveUpdatesBase,
+    ScanState,
+    check_alarms,
+    evaluate_scan_state,
+    pending_queue_message,
+)
 
 if TYPE_CHECKING:
     from bec_lib.client import BECClient
@@ -183,6 +189,7 @@ class LiveUpdatesReadbackProgressbar(LiveUpdatesBase):
         data_source = ReadbackDataHandler(self.bec.device_manager, self.devices, request_id)
         start_values = data_source.get_device_values()
         self.wait_for_request_acceptance()
+        self._wait_for_move_to_start(data_source)
 
         if self.report_instruction:
             target_values = self.report_instruction["readback"]["end"]
@@ -231,3 +238,36 @@ class LiveUpdatesReadbackProgressbar(LiveUpdatesBase):
         if self.scan_queue_request is None or self.scan_queue_request.queue is None:
             return ScanState.CONTINUE
         return evaluate_scan_state(queue=self.scan_queue_request.queue)
+
+    def _wait_for_move_to_start(self, data_source: ReadbackDataHandler) -> None:
+        """Wait until the move starts, mirroring the queue wait behavior of live table updates."""
+        if self.scan_queue_request is None or self.scan_queue_request.queue is None:
+            return
+
+        while True:
+            if self.scan_queue_request is None or self.scan_queue_request.queue is None:
+                return
+
+            queue = self.scan_queue_request.queue
+            check_alarms(self.bec)
+            scan_state = self._check_scan_state()
+            if scan_state == ScanState.WAIT:
+                time.sleep(0.05)
+                continue
+
+            queue_position = getattr(queue, "queue_position", None)
+
+            if queue_position is None:
+                if data_source.done():
+                    return
+                time.sleep(0.05)
+                continue
+
+            message = pending_queue_message(
+                bec=self.bec, queue=queue, queue_position=queue_position
+            )
+            if message is None:
+                break
+
+            print(message, end="\r", flush=True)
+            time.sleep(0.1)

{bec_ipython_client-3.151.3 → bec_ipython_client-3.153.0}/bec_ipython_client/callbacks/utils.py

@@ -81,6 +81,69 @@ def evaluate_scan_state(
     return ScanState.CONTINUE
 
 
+def pending_queue_message(
+    *, bec: BECClient, queue: QueueItem, queue_position: int | None = None
+) -> str | None:
+    """Return a user-facing message for queue states that are still waiting to start."""
+    if queue_position is None:
+        queue_position = getattr(queue, "queue_position", None)
+    if not isinstance(queue_position, int):
+        return None
+
+    target_queue = None
+    target_queue_status = None
+    if bec.queue is not None:
+        current_scan_queue = getattr(bec.queue.queue_storage, "current_scan_queue", None)
+        if current_scan_queue is not None:
+            target_queue = bec.queue.get_default_scan_queue()
+            target_queue_status = current_scan_queue.get(target_queue)
+
+    request_blocks = getattr(queue, "request_blocks", None) or []
+    has_scan_request = any(
+        getattr(request_block, "is_scan", False) for request_block in request_blocks
+    )
+    if (
+        target_queue_status is not None
+        and getattr(target_queue_status, "status", None) == "LOCKED"
+        and has_scan_request
+    ):
+        lock_info = [
+            f"{lock.identifier}: {lock.reason}\n"
+            for lock in getattr(target_queue_status, "locks", None) or []
+        ]
+        return f"Scan is waiting for the lock to be released. Active locks: \n{''.join(lock_info)}"
+
+    owned_device_locks: list[str] = []
+    pending_device_locks: list[str] = []
+    get_device_lock_state = getattr(queue, "get_device_lock_state", None)
+    if callable(get_device_lock_state):
+        try:
+            owned_device_locks, pending_device_locks = get_device_lock_state()
+        except Exception:
+            owned_device_locks, pending_device_locks = [], []
+    if pending_device_locks:
+        pending_locks = ", ".join(pending_device_locks)
+        message = f"Scan is waiting for device locks to be released. Pending device locks: {pending_locks}."
+        if owned_device_locks:
+            owned_locks = ", ".join(owned_device_locks)
+            message += f" Currently owned device locks: {owned_locks}."
+        return message
+
+    if getattr(queue, "status", None) == "PENDING" and queue_position > 0:
+        if target_queue is not None:
+            status = getattr(target_queue_status, "status", getattr(queue, "status", None))
+            return (
+                "Scan is enqueued and is waiting for execution. "
+                f"Current position in queue {target_queue}: {queue_position + 1}. Queue status: {status}."
+            )
+        return (
+            "Scan is enqueued and is waiting for execution. "
+            f"Current position in queue: {queue_position + 1}."
+        )
+
+    return None
+
+
 def _restart_signal(
     *, scan_item: ScanItem | None = None, queue: QueueItem | None = None
 ) -> messages.ScanQueueMessage | None:

{bec_ipython_client-3.151.3 → bec_ipython_client-3.153.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_ipython_client"
-version = "3.151.3"
+version = "3.153.0"
 description = "BEC IPython client"
 requires-python = ">=3.11"
 classifiers = [

{bec_ipython_client-3.151.3 → bec_ipython_client-3.153.0}/tests/client_tests/test_ipython_live_updates.py

@@ -147,6 +147,41 @@ def test_live_updates_process_queue_running(ipython_live_updates_with_mocked_liv
                     assert res is True
 
 
+@pytest.mark.timeout(20)
+def test_live_updates_process_queue_waiting_for_device_locks(
+    ipython_live_updates_with_mocked_live, queue_elements
+):
+    live_updates, _ = ipython_live_updates_with_mocked_live
+    client = live_updates.client
+    queue, request_block, request_msg = queue_elements
+
+    request_block.pending_device_locks = ["samx"]
+    queue = QueueItem(
+        scan_manager=client.queue,
+        queue_id="queue_id",
+        request_blocks=[request_block],
+        status="RUNNING",
+        active_request_block=request_block,
+        scan_id=["scan_id"],
+    )
+    client.queue.queue_storage.current_scan_queue = {
+        "primary": messages.ScanQueueStatus(info=[], status="RUNNING")
+    }
+
+    with (
+        mock.patch.object(queue, "_update_with_buffer"),
+        mock.patch(
+            "bec_lib.queue_items.QueueItem.queue_position", new_callable=mock.PropertyMock
+        ) as queue_pos,
+        mock.patch.object(live_updates, "_process_pending_queue_element") as process_pending,
+    ):
+        queue_pos.return_value = 0
+
+        assert live_updates._process_queue(queue, request_msg, "req_id") is False
+
+    process_pending.assert_called_once_with(queue)
+
+
 def test_live_updates_process_queue_cancelled_pending_request_raises_interruption(bec_client_mock):
     client = bec_client_mock
     live_updates = IPythonLiveUpdates(client)
@@ -1016,3 +1051,137 @@ def test_process_pending_queue_element_locked_then_position(
         assert "user123" in panel_renderable
         # Should not show position info
         assert "position in queue" not in panel_renderable
+
+
+@pytest.mark.timeout(20)
+def test_process_pending_queue_element_waiting_for_device_locks(
+    ipython_live_updates_with_mocked_live, queue_elements
+):
+    live_updates, mock_live = ipython_live_updates_with_mocked_live
+    client = live_updates.client
+    queue, request_block, _ = queue_elements
+
+    request_block.pending_device_locks = ["bpm4i", "samz"]
+    request_block.owned_device_locks = ["samx"]
+    queue.active_request_block = request_block
+
+    running_scan_queue_status = messages.ScanQueueStatus(info=[], status="RUNNING")
+    client.queue.queue_storage.current_scan_queue = {"primary": running_scan_queue_status}
+
+    with mock.patch(
+        "bec_lib.queue_items.QueueItem.queue_position", new_callable=mock.PropertyMock
+    ) as queue_pos:
+        queue_pos.return_value = 0
+
+        live_updates._process_pending_queue_element(queue)
+
+        mock_live.assert_called_once()
+        call_args = mock_live.call_args[0][0]
+        panel_renderable = call_args.renderable
+        assert "waiting for device locks" in panel_renderable
+        assert "bpm4i, samz" in panel_renderable
+        assert "Currently owned device locks: samx" in panel_renderable
+
+
+@pytest.mark.timeout(20)
+def test_process_pending_queue_element_waiting_for_device_locks_without_scan_id(
+    ipython_live_updates_with_mocked_live, queue_elements
+):
+    live_updates, mock_live = ipython_live_updates_with_mocked_live
+    client = live_updates.client
+    queue, request_block, _ = queue_elements
+
+    request_block.pending_device_locks = ["bpm4i", "samz"]
+    request_block.owned_device_locks = ["samx"]
+    queue.active_request_block = request_block
+    queue.scan_ids = [None]
+
+    running_scan_queue_status = messages.ScanQueueStatus(info=[], status="RUNNING")
+    client.queue.queue_storage.current_scan_queue = {"primary": running_scan_queue_status}
+
+    with mock.patch(
+        "bec_lib.queue_items.QueueItem.queue_position", new_callable=mock.PropertyMock
+    ) as queue_pos:
+        queue_pos.return_value = 0
+
+        live_updates._process_pending_queue_element(queue)
+
+        mock_live.assert_called_once()
+        call_args = mock_live.call_args[0][0]
+        panel_renderable = call_args.renderable
+        assert "waiting for device locks" in panel_renderable
+        assert "bpm4i, samz" in panel_renderable
+        assert "Currently owned device locks: samx" in panel_renderable
+
+
+@pytest.mark.timeout(20)
+def test_process_pending_queue_element_waiting_for_device_locks_beats_queue_position(
+    ipython_live_updates_with_mocked_live, queue_elements
+):
+    live_updates, mock_live = ipython_live_updates_with_mocked_live
+    client = live_updates.client
+    queue, request_block, _ = queue_elements
+
+    request_block.pending_device_locks = ["bpm4i"]
+    queue.active_request_block = request_block
+
+    running_scan_queue_status = messages.ScanQueueStatus(info=[], status="RUNNING")
+    client.queue.queue_storage.current_scan_queue = {"primary": running_scan_queue_status}
+
+    with mock.patch(
+        "bec_lib.queue_items.QueueItem.queue_position", new_callable=mock.PropertyMock
+    ) as queue_pos:
+        queue_pos.return_value = 2
+
+        live_updates._process_pending_queue_element(queue)
+
+        call_args = mock_live.call_args[0][0]
+        panel_renderable = call_args.renderable
+        assert "waiting for device locks" in panel_renderable
+        assert "position in queue" not in panel_renderable
+
+
+@pytest.mark.timeout(20)
+def test_process_pending_queue_element_waiting_for_device_locks_on_secondary_queue(
+    ipython_live_updates_with_mocked_live, queue_elements
+):
+    live_updates, mock_live = ipython_live_updates_with_mocked_live
+    client = live_updates.client
+    queue, request_block, _ = queue_elements
+
+    queue.queue_id = "secondary_queue_id"
+    request_block.pending_device_locks = ["bpm4i"]
+    request_block.owned_device_locks = ["samx"]
+    queue.active_request_block = request_block
+
+    client.queue.queue_storage.current_scan_queue = {
+        "primary": messages.ScanQueueStatus(info=[], status="RUNNING"),
+        "secondary": messages.ScanQueueStatus(
+            info=[
+                messages.QueueInfoEntry(
+                    queue_id="secondary_queue_id",
+                    scan_id=["scan_id"],
+                    is_scan=[True],
+                    request_blocks=[request_block],
+                    scan_number=[1],
+                    status="PENDING",
+                    active_request_block=request_block,
+                )
+            ],
+            status="RUNNING",
+        ),
+    }
+
+    with mock.patch(
+        "bec_lib.queue_items.QueueItem.queue_position", new_callable=mock.PropertyMock
+    ) as queue_pos:
+        queue_pos.return_value = 0
+
+        live_updates._process_pending_queue_element(queue)
+
+        mock_live.assert_called_once()
+        call_args = mock_live.call_args[0][0]
+        panel_renderable = call_args.renderable
+        assert "waiting for device locks" in panel_renderable
+        assert "bpm4i" in panel_renderable
+        assert "Currently owned device locks: samx" in panel_renderable

{bec_ipython_client-3.151.3 → bec_ipython_client-3.153.0}/tests/client_tests/test_live_table.py

@@ -130,6 +130,39 @@ class TestLiveTable:
         with mock.patch.object(client.queue.queue_storage, "find_queue_item_by_requestID"):
             live_update.wait_for_request_acceptance()
 
+    def test_wait_for_scan_to_start_prints_pending_queue_message(self, client_with_grid_scan):
+        client, request_msg = client_with_grid_scan
+        live_update = LiveUpdatesTable(
+            client, {"scan_progress": {"points": 10, "show_table": True}}, request_msg
+        )
+        client.queue.queue_storage.current_scan_queue = None
+
+        class QueueStub:
+            def __init__(self):
+                self.status = "PENDING"
+                self.request_blocks = []
+                self._positions = iter([2, 0])
+
+            @property
+            def queue_position(self):
+                return next(self._positions)
+
+            def get_device_lock_state(self):
+                return ([], [])
+
+        live_update.scan_item = mock.MagicMock(
+            queue=QueueStub(), status="open", scan_id="scan_id", scan_number=1
+        )
+
+        with mock.patch("bec_ipython_client.callbacks.live_table.print") as mock_print:
+            live_update.wait_for_scan_to_start()
+
+        mock_print.assert_called_once_with(
+            "Scan is enqueued and is waiting for execution. Current position in queue: 3.",
+            end="\r",
+            flush=True,
+        )
+
     @pytest.mark.timeout(20)
     def test_run_update(self, bec_client_mock, scan_item):
         request_msg = messages.ScanQueueMessage(

{bec_ipython_client-3.151.3 → bec_ipython_client-3.153.0}/tests/client_tests/test_move_callback.py

@@ -8,7 +8,7 @@ from bec_ipython_client.callbacks.move_device import (
     LiveUpdatesReadbackProgressbar,
     ReadbackDataHandler,
 )
-from bec_ipython_client.callbacks.utils import ScanState
+from bec_ipython_client.callbacks.utils import ScanState, pending_queue_message
 from bec_lib import messages
 from bec_lib.bec_errors import ScanInterruption, ScanRestart
 from bec_lib.endpoints import MessageEndpoints
@@ -218,6 +218,133 @@ def test_move_callback_check_scan_state_restart_without_restart_message_is_nonbl
     assert live_update._check_scan_state() == ScanState.WAIT
 
 
+def test_move_callback_pending_queue_message_for_device_locks(bec_client_mock):
+    bec_client_mock.queue.queue_storage.current_scan_queue = None
+    request_block = mock.MagicMock(is_scan=True)
+    queue = mock.MagicMock(status="RUNNING", request_blocks=[request_block])
+    queue.get_device_lock_state.return_value = (["samz"], ["samx", "bpm4i"])
+
+    message = pending_queue_message(bec=bec_client_mock, queue=queue, queue_position=0)
+
+    assert (
+        message
+        == "Scan is waiting for device locks to be released. Pending device locks: samx, bpm4i. "
+        "Currently owned device locks: samz."
+    )
+
+
+def test_move_callback_pending_queue_message_for_queue_position(bec_client_mock):
+    bec_client_mock.queue.queue_storage.current_scan_queue = None
+    queue = mock.MagicMock(status="PENDING", request_blocks=[])
+    queue.get_device_lock_state.return_value = ([], [])
+
+    message = pending_queue_message(bec=bec_client_mock, queue=queue, queue_position=2)
+
+    assert message == "Scan is enqueued and is waiting for execution. Current position in queue: 3."
+
+
+def test_move_callback_wait_for_move_to_start_prints_pending_message(bec_client_mock):
+    request = messages.ScanQueueMessage(
+        scan_type="umv",
+        parameter={"args": {"samx": [10]}, "kwargs": {"relative": True}},
+        metadata={"RID": "something"},
+    )
+    live_update = LiveUpdatesReadbackProgressbar(bec=bec_client_mock, request=request)
+    bec_client_mock.queue.queue_storage.current_scan_queue = None
+
+    class QueueStub:
+        def __init__(self):
+            self.status = "PENDING"
+            self.request_blocks = []
+            self._positions = iter([2, 0])
+
+        @property
+        def queue_position(self):
+            return next(self._positions)
+
+        def get_device_lock_state(self):
+            return ([], [])
+
+    queue = QueueStub()
+    live_update.scan_queue_request = mock.MagicMock(queue=queue)
+    data_source = mock.MagicMock()
+    data_source.done.return_value = False
+
+    with (
+        mock.patch("bec_ipython_client.callbacks.move_device.print") as mock_print,
+        mock.patch("bec_ipython_client.callbacks.move_device.time.sleep") as sleep,
+        mock.patch.object(live_update, "_check_scan_state", return_value=ScanState.CONTINUE),
+    ):
+        live_update._wait_for_move_to_start(data_source)
+
+    mock_print.assert_called_once_with(
+        "Scan is enqueued and is waiting for execution. Current position in queue: 3.",
+        end="\r",
+        flush=True,
+    )
+    sleep.assert_called()
+
+
+def test_move_callback_wait_for_move_to_start_returns_when_queue_entry_is_gone(bec_client_mock):
+    request = messages.ScanQueueMessage(
+        scan_type="umv",
+        parameter={"args": {"samx": [10]}, "kwargs": {"relative": True}},
+        metadata={"RID": "something"},
+    )
+    live_update = LiveUpdatesReadbackProgressbar(bec=bec_client_mock, request=request)
+    queue = mock.MagicMock()
+    queue.queue_position = None
+    live_update.scan_queue_request = mock.MagicMock(queue=queue)
+    data_source = mock.MagicMock()
+    data_source.done.return_value = True
+
+    with (
+        mock.patch("bec_ipython_client.callbacks.move_device.print") as mock_print,
+        mock.patch("bec_ipython_client.callbacks.move_device.time.sleep") as sleep,
+        mock.patch.object(live_update, "_check_scan_state", return_value=ScanState.CONTINUE),
+    ):
+        live_update._wait_for_move_to_start(data_source)
+
+    mock_print.assert_not_called()
+    sleep.assert_not_called()
+
+
+def test_move_callback_wait_for_move_to_start_keeps_waiting_when_not_yet_registered(
+    bec_client_mock,
+):
+    request = messages.ScanQueueMessage(
+        scan_type="umv",
+        parameter={"args": {"samx": [10]}, "kwargs": {"relative": True}},
+        metadata={"RID": "something"},
+    )
+    live_update = LiveUpdatesReadbackProgressbar(bec=bec_client_mock, request=request)
+
+    class QueueStub:
+        def __init__(self):
+            self._positions = iter([None, None, 0])
+
+        @property
+        def queue_position(self):
+            return next(self._positions)
+
+    live_update.scan_queue_request = mock.MagicMock(queue=QueueStub())
+    data_source = mock.MagicMock()
+    data_source.done.return_value = False
+
+    with (
+        mock.patch("bec_ipython_client.callbacks.move_device.print") as mock_print,
+        mock.patch("bec_ipython_client.callbacks.move_device.time.sleep") as sleep,
+        mock.patch.object(live_update, "_check_scan_state", return_value=ScanState.CONTINUE),
+        mock.patch(
+            "bec_ipython_client.callbacks.move_device.pending_queue_message", return_value=None
+        ),
+    ):
+        live_update._wait_for_move_to_start(data_source)
+
+    mock_print.assert_not_called()
+    assert sleep.call_count == 2
+
+
 def test_move_callback_run_waits_for_restart_message_before_exiting(bec_client_mock):
     client = bec_client_mock
     request = messages.ScanQueueMessage(

bec_ipython_client-3.153.0/tests/end-2-end/test_acl_e2e.py

@@ -0,0 +1,140 @@
+import shutil
+
+import pytest
+import redis.exceptions
+
+from bec_lib import messages
+from bec_lib.client import BECClient
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.redis_connector import RedisConnector
+from bec_lib.service_config import ServiceConfig, ServiceConfigModel
+from bec_lib.tests.utils import wait_for_empty_queue
+from bec_lib.utils.user_acls_test import BECAccessDemo
+from bec_server.bec_server_utils.service_handler import ServiceHandler
+
+
+@pytest.fixture
+def acl_enabled_bec_services(
+    request,
+    bec_files_path,
+    bec_services_config_file_path,
+    bec_test_config_file_path,
+    bec_redis_host_port,
+    test_config_yaml_file_path,
+):
+    if not request.config.getoption("--start-servers") or not request.config.getoption(
+        "--flush-redis"
+    ):
+        pytest.skip("ACL e2e test mutates Redis ACLs and requires isolated pytest BEC services.")
+
+    redis_host, redis_port = bec_redis_host_port
+    redis_url = f"{redis_host}:{redis_port}"
+    acl_env_file = bec_services_config_file_path.parent / ".bec_acl.env"
+    acl_env_file.write_text("REDIS_USER=admin\nREDIS_PASSWORD=admin\n", encoding="utf-8")
+    shutil.copyfile(test_config_yaml_file_path, bec_test_config_file_path)
+
+    service_config = ServiceConfigModel(
+        redis={"host": redis_host, "port": redis_port},
+        file_writer={"base_path": str(bec_services_config_file_path.parent)},
+        acl={"env_file": str(acl_env_file)},
+    )
+    bec_services_config_file_path.write_text(
+        service_config.model_dump_json(indent=4), encoding="utf-8"
+    )
+
+    service_handler = ServiceHandler(
+        bec_path=bec_files_path, config_path=bec_services_config_file_path, interface="subprocess"
+    )
+    processes = None
+    try:
+        acl_connector = RedisConnector(redis_url)
+        try:
+            access_control = BECAccessDemo(acl_connector)
+            access_control.reset()
+            access_control.add_user()
+            access_control.add_admin()
+            access_control.set_default_non_admin()
+        finally:
+            acl_connector.shutdown()
+
+        processes = service_handler.start()
+        yield bec_services_config_file_path
+    finally:
+        if processes is not None:
+            service_handler.stop(processes)
+        restore_connector = RedisConnector(redis_url)
+        try:
+            BECAccessDemo(restore_connector).reset()
+        finally:
+            restore_connector.shutdown()
+
+
+@pytest.mark.timeout(120)
+def test_acl_admin_server_allows_default_user_scan(acl_enabled_bec_services):
+    admin_config = ServiceConfig(acl_enabled_bec_services)
+    admin_client = BECClient(admin_config, RedisConnector, forced=True, wait_for_server=True)
+    admin_client.start()
+    try:
+        admin_client.config.load_demo_config(force=True)
+    finally:
+        admin_client.shutdown()
+        admin_client._client._reset_singleton()
+
+    user_config = ServiceConfig(acl_enabled_bec_services, acl={"env_file": "", "user": "user"})
+    user_client = BECClient(user_config, RedisConnector, forced=True, wait_for_server=True)
+    user_client.start()
+    try:
+        user_client.queue.request_queue_reset()
+        user_client.queue.request_scan_continuation()
+        wait_for_empty_queue(user_client)
+        assert user_client.username == "user"
+
+        dev = user_client.device_manager.devices
+        status = user_client.scans.line_scan(
+            dev.samx, -0.1, 0.1, steps=3, exp_time=0.01, relative=False
+        )
+        status.wait(num_points=True, file_written=True)
+
+        assert status.scan.num_points == 3
+    finally:
+        user_client.shutdown()
+        user_client._client._reset_singleton()
+
+
+@pytest.mark.timeout(120)
+def test_acl_account_endpoint_allows_user_read_but_admin_only_write(acl_enabled_bec_services):
+    account_endpoint = MessageEndpoints.account()
+    initial_account_msg = messages.VariableMessage(value="initial-admin-account")
+    updated_account_msg = messages.VariableMessage(value="updated-admin-account")
+
+    user_config = ServiceConfig(acl_enabled_bec_services, acl={"env_file": "", "user": "user"})
+    user_client = BECClient(user_config, RedisConnector, forced=True, wait_for_server=True)
+    user_client.start()
+    try:
+        assert user_client.username == "user"
+        with user_client.acl.temporary_user(username="admin", token="admin"):
+            user_client._update_username()
+            assert user_client.username == "admin"
+            user_client.connector.xadd(account_endpoint, {"data": initial_account_msg})
+            assert user_client.connector.get_last(account_endpoint, "data") == initial_account_msg
+
+        user_client._update_username()
+        assert user_client.username == "user"
+        assert user_client.connector.get_last(account_endpoint, "data") == initial_account_msg
+        with pytest.raises(redis.exceptions.NoPermissionError):
+            user_client.connector.xadd(
+                account_endpoint, {"data": messages.VariableMessage(value="user-account")}
+            )
+
+        with user_client.acl.temporary_user(username="admin", token="admin"):
+            user_client._update_username()
+            assert user_client.username == "admin"
+            user_client.connector.xadd(account_endpoint, {"data": updated_account_msg})
+            assert user_client.connector.get_last(account_endpoint, "data") == updated_account_msg
+
+        user_client._update_username()
+        assert user_client.username == "user"
+        assert user_client.connector.get_last(account_endpoint, "data") == updated_account_msg
+    finally:
+        user_client.shutdown()
+        user_client._client._reset_singleton()

{bec_ipython_client-3.151.3 → bec_ipython_client-3.153.0}/tests/end-2-end/test_scans_e2e.py

@@ -260,6 +260,47 @@ def test_scan_abort(bec_ipython_client_fixture: BECIPythonClient):
     assert scan_number_end == scan_number_start + 2
 
 
+@pytest.mark.timeout(100)
+def test_umv_ctrl_c_stops_motion(bec_ipython_client_fixture: BECIPythonClient):
+    def send_abort_after_delay():
+        time.sleep(1)
+        _thread.interrupt_main()
+
+    bec = bec_ipython_client_fixture
+    bec.metadata.update({"unit_test": "test_umv_ctrl_c_stops_motion"})
+    scans = bec.scans
+    dev = bec.device_manager.devices
+    original_velocity = dev.samx.velocity.get()
+    aborted_scan = False
+
+    try:
+        dev.samx.velocity.set(100).wait()
+        scans.umv(dev.samx, 0, relative=False)
+        dev.samx.velocity.set(1).wait()
+
+        threading.Thread(target=send_abort_after_delay, daemon=True).start()
+        try:
+            scans.umv(dev.samx, 40, relative=False)
+        except ScanInterruption:
+            aborted_scan = True
+
+        assert aborted_scan is True
+
+        timeout = time.time() + 10
+        while dev.samx.motor_is_moving.get() and time.time() < timeout:
+            time.sleep(0.1)
+
+        assert not dev.samx.motor_is_moving.get()
+        assert dev.samx.readback.get() < 40
+    finally:
+        if dev.samx.motor_is_moving.get():
+            dev.samx.stop()
+            timeout = time.time() + 10
+            while dev.samx.motor_is_moving.get() and time.time() < timeout:
+                time.sleep(0.1)
+        dev.samx.velocity.set(original_velocity).wait()
+
+
 @pytest.mark.timeout(100)
 def test_limit_error(bec_ipython_client_fixture):
     bec = bec_ipython_client_fixture