bec-ipython-client 3.138.0__tar.gz → 3.139.1__tar.gz

{bec_ipython_client-3.138.0 → bec_ipython_client-3.139.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bec_ipython_client
-Version: 3.138.0
+Version: 3.139.1
 Summary: BEC IPython client
 Project-URL: Bug Tracker, https://github.com/bec-project/bec/issues
 Project-URL: Homepage, https://github.com/bec-project/bec

{bec_ipython_client-3.138.0 → bec_ipython_client-3.139.1}/bec_ipython_client/callbacks/ipython_live_updates.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import collections
 import time
+from contextvars import Token
 from typing import TYPE_CHECKING, Any
 
 from rich.console import Console
@@ -11,6 +12,7 @@ from rich.panel import Panel
 from bec_ipython_client.callbacks.device_progress import LiveUpdatesDeviceProgress
 from bec_lib.bec_errors import ScanInterruption, ScanRestart
 from bec_lib.logger import bec_logger
+from bec_lib.request_context import ActiveRequestContext, active_request_context
 
 from .live_table import LiveUpdatesTable
 from .move_device import LiveUpdatesReadbackProgressbar
@@ -164,11 +166,15 @@ class IPythonLiveUpdates:
     def process_request(self, request: messages.ScanQueueMessage, callbacks: Any) -> None:
         """Process the request and report instructions."""
         # pylint: disable=protected-access
+        context_token: Token | None = None
         try:
             with self.client._sighandler:
                 # pylint: disable=protected-access
                 self._active_request = request
                 self._user_callback = callbacks
+                request_id = request.metadata["RID"]
+                request_context = ActiveRequestContext(request_id=request_id)
+                context_token = active_request_context.set(request_context)
                 scan_request = ScanRequestMixin(self.client, request.metadata["RID"])
                 scan_request.wait()
 
@@ -180,9 +186,11 @@ class IPythonLiveUpdates:
                     time.sleep(0.01)
 
                 self._current_queue = queue = scan_request.scan_queue_request.queue
+                request_context.queue_status = queue.status
                 self._request_block_id = req_id = self._active_request.metadata.get("RID")
 
-                while queue.status not in ["COMPLETED", "ABORTED", "HALTED"]:
+                while queue.status not in ["COMPLETED", "ABORTED", "HALTED", "CANCELLED"]:
+                    request_context.queue_status = queue.status
                     if self._process_queue(queue, request, req_id):
                         break
 
@@ -209,7 +217,17 @@ class IPythonLiveUpdates:
                 self._wait_for_cleanup()
             self._reset(forced=True)
             raise scan_interr
+        except KeyboardInterrupt as exc:
+            self._stop_status_live()
+            if self.client._service_config.abort_on_ctrl_c and self._abort_pending_request():
+                self._wait_for_cleanup()
+                self._reset(forced=True)
+                raise ScanInterruption("User abort.") from exc
+            self._reset(forced=True)
+            raise
         finally:
+            if context_token is not None:
+                active_request_context.reset(context_token)
             self._stop_status_live()
 
     def _wait_for_cleanup(self):
@@ -222,7 +240,32 @@ class IPythonLiveUpdates:
             while self._element_in_queue():
                 time.sleep(0.1)
         except KeyboardInterrupt:
-            self.client.queue.request_scan_halt()
+            request_id = self._get_tracked_request_id()
+            if request_id is None:
+                self.client.queue.request_scan_halt()
+                return
+            self.client.queue.request_scan_halt(request_id=request_id)
+
+    def _get_tracked_request_id(self) -> str | None:
+        """Return the request id associated with the active live-updates request."""
+        request_context = active_request_context.get()
+        if request_context is not None:
+            return request_context.request_id
+        if self._active_request is None:
+            return None
+        return self._active_request.metadata.get("RID")
+
+    def _abort_pending_request(self) -> bool:
+        """Abort the pending queue item currently being tracked by this live update."""
+        if self._current_queue is None or self.client.queue is None:
+            return False
+        if self._current_queue.status != "PENDING":
+            return False
+        request_id = self._get_tracked_request_id()
+        if request_id is None:
+            return False
+        self.client.queue.request_scan_abortion(request_id=request_id)
+        return True
 
     def _element_in_queue(self) -> bool:
         if self.client.queue is None:
@@ -237,7 +280,7 @@ class IPythonLiveUpdates:
             return False
         if self._current_queue is None:
             return False
-        return self._current_queue.queue_id == queue_info[0].queue_id
+        return any(queue_item.queue_id == self._current_queue.queue_id for queue_item in queue_info)
 
     def _process_queue(
         self, queue: QueueItem, request: messages.ScanQueueMessage, req_id: str
@@ -259,7 +302,7 @@ class IPythonLiveUpdates:
         if queue.scans:
             if queue.scans[-1] is not None and queue.scans[-1].status == "user_completed":
                 return True
-            if queue.scans[-1] is None and queue.status == "STOPPED":
+            if queue.scans[-1] is None and queue.status in ["STOPPED", "CANCELLED"]:
                 raise ScanInterruption("Scan was stopped by the user.")
 
         if queue.queue_position is None:
@@ -310,19 +353,20 @@ 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.queue_storage.current_scan_queue.get(
-            self.client.queue.get_default_scan_queue()
-        )
-        if target_queue is None:
+        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 = target_queue_status.status
         if status == "LOCKED":
-            lock_info = [f"{lock.identifier}: {lock.reason}\n" for lock in target_queue.locks]
+            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)}"
             )

{bec_ipython_client-3.138.0 → bec_ipython_client-3.139.1}/bec_ipython_client/callbacks/utils.py

@@ -74,20 +74,26 @@ class LiveUpdatesBase(abc.ABC):
         # pylint: disable=protected-access
         if self.scan_queue_request is None:
             return
-        msgs = self.scan_queue_request.queue.get_client_messages(only_asap=True)
+        queue = self.scan_queue_request.queue
+        if queue is None:
+            return
+        msgs = queue.get_client_messages(only_asap=True)
         if not msgs:
             return
         if self.bec.live_updates_config.print_client_messages is False:
             return
         for msg in msgs:
-            print(self.scan_queue_request.queue.format_client_msg(msg))
+            print(queue.format_client_msg(msg))
 
     def _print_client_msgs_all(self):
         """Print summary of client messages"""
         # pylint: disable=protected-access
         if self.scan_queue_request is None:
             return
-        msgs = self.scan_queue_request.queue.get_client_messages()
+        queue = self.scan_queue_request.queue
+        if queue is None:
+            return
+        msgs = queue.get_client_messages()
         if self.bec.live_updates_config.print_client_messages is False:
             return
         if not msgs:
@@ -97,7 +103,7 @@ class LiveUpdatesBase(abc.ABC):
         print("------------------------")
         # pylint: disable=protected-access
         for msg in msgs:
-            print(self.scan_queue_request.queue.format_client_msg(msg))
+            print(queue.format_client_msg(msg))
         print("------------------------")
 
 

{bec_ipython_client-3.138.0 → bec_ipython_client-3.139.1}/bec_ipython_client/signals.py

@@ -6,6 +6,7 @@ import time
 from typing import TYPE_CHECKING
 
 from bec_lib.bec_errors import ScanInterruption
+from bec_lib.request_context import active_request_context
 
 if TYPE_CHECKING:  # pragma: no cover
     from bec_lib.client import BECClient
@@ -100,14 +101,28 @@ class SigintHandler(SignalHandler):
         else:
             raise ValueError(f"Mode {self._operation_mode} not handled by SigintHandler")
 
+    @staticmethod
+    def _get_active_request_id() -> str | None:
+        request_context = active_request_context.get()
+        if request_context is None:
+            return None
+        return request_context.request_id
+
     def _procedure_mode(self):
         # Catch it here to only kill scans which were started here
         print("SIGINT received in procedure mode. Sending scan abort request and exiting.")
-        self.bec.queue.request_scan_abortion()
+        self.bec.queue.request_scan_abortion(request_id=self._get_active_request_id())
         # Let the procedure worker shut itself down
         raise KeyboardInterrupt
 
     def _normal_mode(self):
+        request_context = active_request_context.get()
+        request_id = request_context.request_id if request_context is not None else None
+        if request_context is not None and request_context.queue_status == "PENDING":
+            # A locally tracked request is still queued behind someone else.
+            # Let IPythonLiveUpdates handle Ctrl-C so we only target that request.
+            raise KeyboardInterrupt
+
         current_scan = self.bec.queue.scan_storage.current_scan_info
         if not current_scan:
             raise KeyboardInterrupt
@@ -126,7 +141,9 @@ class SigintHandler(SignalHandler):
                 print("It has been 10 seconds since the last SIGINT. Resetting SIGINT handler.")
 
             threading.Thread(
-                target=self.bec.queue.request_scan_interruption, args=(True,), daemon=True
+                target=self.bec.queue.request_scan_interruption,
+                kwargs={"deferred_pause": True, "request_id": request_id},
+                daemon=True,
             ).start()
             print(
                 "A 'deferred pause' has been requested. The "
@@ -141,10 +158,16 @@ class SigintHandler(SignalHandler):
         # - Ctrl-C twice within 10 seconds or a direct command (e.g. mv) -> hard pause
         if self.bec._service_config.abort_on_ctrl_c:
             print("The scan will be aborted.")
-            threading.Thread(target=self.bec.queue.request_scan_abortion, daemon=True).start()
+            threading.Thread(
+                target=self.bec.queue.request_scan_abortion,
+                kwargs={"request_id": request_id},
+                daemon=True,
+            ).start()
             raise ScanInterruption("User abort.")
         print("A hard pause will be requested.")
         threading.Thread(
-            target=self.bec.queue.request_scan_interruption, args=(False,), daemon=True
+            target=self.bec.queue.request_scan_interruption,
+            kwargs={"deferred_pause": False, "request_id": request_id},
+            daemon=True,
         ).start()
         raise ScanInterruption(PAUSE_MSG)

{bec_ipython_client-3.138.0 → bec_ipython_client-3.139.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_ipython_client"
-version = "3.138.0"
+version = "3.139.1"
 description = "BEC IPython client"
 requires-python = ">=3.11"
 classifiers = [
@@ -94,6 +94,8 @@ Homepage = "https://github.com/bec-project/bec"
 
 
 
+
+
 
 
 

{bec_ipython_client-3.138.0 → bec_ipython_client-3.139.1}/tests/client_tests/test_ipython_live_updates.py

@@ -6,6 +6,7 @@ from bec_ipython_client.callbacks.ipython_live_updates import IPythonLiveUpdates
 from bec_lib import messages
 from bec_lib.bec_errors import ScanInterruption, ScanRestart
 from bec_lib.queue_items import QueueItem
+from bec_lib.request_context import ActiveRequestContext, active_request_context
 
 
 @pytest.fixture
@@ -146,6 +147,41 @@ def test_live_updates_process_queue_running(ipython_live_updates_with_mocked_liv
                     assert res is True
 
 
+def test_live_updates_process_queue_cancelled_pending_request_raises_interruption(bec_client_mock):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+    request_msg = messages.ScanQueueMessage(
+        scan_type="grid_scan",
+        parameter={"args": {"samx": (-5, 5, 3)}, "kwargs": {}},
+        queue="primary",
+        metadata={"RID": "something"},
+    )
+    request_block = messages.RequestBlock(
+        msg=request_msg,
+        RID="something",
+        report_instructions=[],
+        readout_priority={"monitored": ["samx"]},
+        is_scan=True,
+        scan_number=1,
+        scan_id=None,
+    )
+    queue = QueueItem(
+        scan_manager=client.queue,
+        queue_id="queue_id",
+        request_blocks=[request_block],
+        status="CANCELLED",
+        active_request_block=None,
+        scan_id=[None],
+    )
+
+    with (
+        mock.patch.object(queue, "_update_with_buffer"),
+        mock.patch("bec_lib.queue_items.QueueItem.queue_position", new_callable=mock.PropertyMock),
+        pytest.raises(ScanInterruption, match="stopped by the user"),
+    ):
+        live_updates._process_queue(queue, request_msg, "something")
+
+
 def test_process_request_repeats_on_ScanRestart_error(
     ipython_live_updates_with_mocked_live, queue_elements
 ):
@@ -173,6 +209,222 @@ def test_process_request_repeats_on_ScanRestart_error(
         assert live_updates._stop_status_live.call_count == 5
 
 
+def test_abort_pending_request_requests_abortion_by_request_id(bec_client_mock, sample_request_msg):
+    live_updates = IPythonLiveUpdates(bec_client_mock)
+    live_updates._current_queue = mock.MagicMock(status="PENDING", scan_ids=["scan_id", None])
+    live_updates._active_request = sample_request_msg
+
+    with mock.patch.object(live_updates.client.queue, "request_scan_abortion") as request_abort:
+        assert live_updates._abort_pending_request() is True
+        request_abort.assert_called_once_with(request_id="something")
+
+
+def test_get_tracked_request_id_uses_contextvar(bec_client_mock):
+    live_updates = IPythonLiveUpdates(bec_client_mock)
+    live_updates._active_request = messages.ScanQueueMessage(
+        scan_type="grid_scan",
+        parameter={"args": {"samx": (-5, 5, 3)}, "kwargs": {}},
+        queue="primary",
+        metadata={"RID": "fallback-request"},
+    )
+    token = active_request_context.set(
+        ActiveRequestContext(request_id="context-request", queue_status="PENDING")
+    )
+
+    try:
+        assert live_updates._get_tracked_request_id() == "context-request"
+    finally:
+        active_request_context.reset(token)
+
+
+def test_abort_pending_request_falls_back_to_request_id(bec_client_mock, sample_request_msg):
+    live_updates = IPythonLiveUpdates(bec_client_mock)
+    live_updates._current_queue = mock.MagicMock(status="PENDING", scan_ids=[None])
+    live_updates._active_request = sample_request_msg
+
+    with mock.patch.object(live_updates.client.queue, "request_scan_abortion") as request_abort:
+        assert live_updates._abort_pending_request() is True
+        request_abort.assert_called_once_with(request_id="something")
+
+
+def test_abort_pending_request_returns_false_when_not_pending(bec_client_mock):
+    live_updates = IPythonLiveUpdates(bec_client_mock)
+    live_updates._current_queue = mock.MagicMock(status="RUNNING", scan_ids=["scan_id"])
+
+    with mock.patch.object(live_updates.client.queue, "request_scan_abortion") as request_abort:
+        assert live_updates._abort_pending_request() is False
+        request_abort.assert_not_called()
+
+
+def test_wait_for_cleanup_returns_immediately_when_queue_item_gone(bec_client_mock):
+    live_updates = IPythonLiveUpdates(bec_client_mock)
+
+    with (
+        mock.patch.object(live_updates, "_stop_status_live") as stop_status_live,
+        mock.patch.object(live_updates, "_element_in_queue", return_value=False) as in_queue,
+    ):
+        live_updates._wait_for_cleanup()
+
+    stop_status_live.assert_called_once()
+    in_queue.assert_called_once()
+
+
+def test_wait_for_cleanup_loops_until_queue_item_removed(bec_client_mock):
+    live_updates = IPythonLiveUpdates(bec_client_mock)
+
+    with (
+        mock.patch.object(
+            live_updates, "_element_in_queue", side_effect=[True, True, False]
+        ) as in_queue,
+        mock.patch("bec_ipython_client.callbacks.ipython_live_updates.time.sleep") as sleep,
+    ):
+        live_updates._wait_for_cleanup()
+
+    assert in_queue.call_count == 3
+    sleep.assert_called_once_with(0.1)
+
+
+def test_wait_for_cleanup_keyboard_interrupt_requests_halt(bec_client_mock):
+    live_updates = IPythonLiveUpdates(bec_client_mock)
+    live_updates._active_request = messages.ScanQueueMessage(
+        scan_type="grid_scan",
+        parameter={"args": {"samx": (-5, 5, 3)}, "kwargs": {}},
+        queue="primary",
+        metadata={"RID": "pending-request"},
+    )
+
+    with (
+        mock.patch.object(live_updates, "_element_in_queue", side_effect=KeyboardInterrupt),
+        mock.patch.object(live_updates.client.queue, "request_scan_halt") as request_halt,
+    ):
+        live_updates._wait_for_cleanup()
+
+    request_halt.assert_called_once_with(request_id="pending-request")
+
+
+def test_wait_for_cleanup_keyboard_interrupt_requests_halt_without_request_id(bec_client_mock):
+    live_updates = IPythonLiveUpdates(bec_client_mock)
+
+    with (
+        mock.patch.object(live_updates, "_element_in_queue", side_effect=KeyboardInterrupt),
+        mock.patch.object(live_updates.client.queue, "request_scan_halt") as request_halt,
+    ):
+        live_updates._wait_for_cleanup()
+
+    request_halt.assert_called_once_with()
+
+
+@pytest.fixture
+def process_request_keyboard_interrupt_setup(
+    ipython_live_updates_with_mocked_live, sample_request_msg
+):
+    live_updates, _ = ipython_live_updates_with_mocked_live
+    callbacks = mock.MagicMock()
+    live_updates.client._service_config = mock.MagicMock(abort_on_ctrl_c=True)
+
+    queue = mock.MagicMock()
+    queue.scan_ids = ["scan_id"]
+    queue.queue_id = "queue_id"
+
+    request_item = mock.MagicMock()
+    request_item.queue = queue
+    fake_scan_request = mock.MagicMock()
+    fake_scan_request.scan_queue_request = request_item
+    fake_scan_request.wait.return_value = None
+
+    live_updates.client._sighandler = mock.MagicMock()
+    live_updates.client._sighandler.__enter__.return_value = None
+    live_updates.client._sighandler.__exit__.return_value = None
+
+    return live_updates, callbacks, sample_request_msg, queue, fake_scan_request
+
+
+def test_process_request_keyboard_interrupt_pending_request_raises_scan_interruption(
+    process_request_keyboard_interrupt_setup,
+):
+    live_updates, callbacks, sample_request_msg, queue, fake_scan_request = (
+        process_request_keyboard_interrupt_setup
+    )
+    queue.status = "PENDING"
+
+    with (
+        mock.patch(
+            "bec_ipython_client.callbacks.ipython_live_updates.ScanRequestMixin",
+            return_value=fake_scan_request,
+        ),
+        mock.patch.object(live_updates, "_process_queue", side_effect=KeyboardInterrupt()),
+        mock.patch.object(
+            live_updates, "_abort_pending_request", return_value=True
+        ) as abort_pending,
+        mock.patch.object(live_updates, "_wait_for_cleanup") as wait_for_cleanup,
+        mock.patch.object(live_updates, "_reset") as reset,
+    ):
+        with pytest.raises(ScanInterruption, match="User abort."):
+            live_updates.process_request(sample_request_msg, callbacks)
+
+    abort_pending.assert_called_once()
+    wait_for_cleanup.assert_called_once()
+    reset.assert_called_once_with(forced=True)
+
+
+@pytest.mark.parametrize("queue_status", ["RUNNING", "LOCKED"])
+def test_process_request_keyboard_interrupt_pending_request_aborts_local_request_by_id(
+    process_request_keyboard_interrupt_setup, queue_status
+):
+    live_updates, callbacks, sample_request_msg, queue, fake_scan_request = (
+        process_request_keyboard_interrupt_setup
+    )
+    queue.status = "PENDING"
+    live_updates.client.queue.queue_storage.current_scan_queue = {
+        "primary": messages.ScanQueueStatus(info=[], status=queue_status)
+    }
+
+    with (
+        mock.patch(
+            "bec_ipython_client.callbacks.ipython_live_updates.ScanRequestMixin",
+            return_value=fake_scan_request,
+        ),
+        mock.patch.object(live_updates, "_process_queue", side_effect=KeyboardInterrupt()),
+        mock.patch.object(live_updates.client.queue, "request_scan_abortion") as request_abort,
+        mock.patch.object(live_updates, "_wait_for_cleanup") as wait_for_cleanup,
+        mock.patch.object(live_updates, "_reset") as reset,
+    ):
+        with pytest.raises(ScanInterruption, match="User abort."):
+            live_updates.process_request(sample_request_msg, callbacks)
+
+    request_abort.assert_called_once_with(request_id="something")
+    wait_for_cleanup.assert_called_once()
+    reset.assert_called_once_with(forced=True)
+
+
+def test_process_request_keyboard_interrupt_non_pending_re_raises(
+    process_request_keyboard_interrupt_setup,
+):
+    live_updates, callbacks, sample_request_msg, queue, fake_scan_request = (
+        process_request_keyboard_interrupt_setup
+    )
+    queue.status = "RUNNING"
+
+    with (
+        mock.patch(
+            "bec_ipython_client.callbacks.ipython_live_updates.ScanRequestMixin",
+            return_value=fake_scan_request,
+        ),
+        mock.patch.object(live_updates, "_process_queue", side_effect=KeyboardInterrupt()),
+        mock.patch.object(
+            live_updates, "_abort_pending_request", return_value=False
+        ) as abort_pending,
+        mock.patch.object(live_updates, "_wait_for_cleanup") as wait_for_cleanup,
+        mock.patch.object(live_updates, "_reset") as reset,
+    ):
+        with pytest.raises(KeyboardInterrupt):
+            live_updates.process_request(sample_request_msg, callbacks)
+
+    abort_pending.assert_called_once()
+    wait_for_cleanup.assert_not_called()
+    reset.assert_called_once_with(forced=True)
+
+
 @pytest.mark.timeout(20)
 def test_live_updates_process_queue_without_status(bec_client_mock, queue_elements):
     client = bec_client_mock
@@ -382,6 +634,39 @@ def test_element_in_queue_queue_id_in_info(bec_client_mock, sample_request_block
     assert live_updates._element_in_queue() is True
 
 
+@pytest.mark.timeout(20)
+def test_element_in_queue_queue_id_in_later_position(bec_client_mock, sample_request_block):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    current_queue = mock.MagicMock()
+    current_queue.queue_id = "my_queue_id"
+    live_updates._current_queue = current_queue
+
+    first_entry = messages.QueueInfoEntry(
+        queue_id="different_queue_id",
+        scan_id=["scan_id_1"],
+        is_scan=[True],
+        request_blocks=[sample_request_block],
+        scan_number=[1],
+        status="RUNNING",
+        active_request_block=None,
+    )
+    second_entry = messages.QueueInfoEntry(
+        queue_id="my_queue_id",
+        scan_id=["scan_id_2"],
+        is_scan=[True],
+        request_blocks=[sample_request_block],
+        scan_number=[2],
+        status="PENDING",
+        active_request_block=None,
+    )
+    scan_queue_status = messages.ScanQueueStatus(info=[first_entry, second_entry], status="LOCKED")
+    client.queue.queue_storage.current_scan_queue = {"primary": scan_queue_status}
+
+    assert live_updates._element_in_queue() is True
+
+
 @pytest.mark.timeout(20)
 def test_process_pending_queue_element_locked_queue(
     ipython_live_updates_with_mocked_live, queue_elements

bec_ipython_client-3.139.1/tests/client_tests/test_signals.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import threading
+from unittest import mock
+
+import pytest
+
+from bec_ipython_client.signals import SigintHandler
+from bec_lib.bec_errors import ScanInterruption
+from bec_lib.request_context import ActiveRequestContext, active_request_context
+
+
+@pytest.fixture
+def bec_with_pending_live_request():
+    bec = mock.MagicMock()
+    bec._service_config = mock.MagicMock(abort_on_ctrl_c=True)
+    return bec
+
+
+def test_sigint_handler_raises_keyboard_interrupt_for_pending_live_request(
+    bec_with_pending_live_request,
+):
+    handler = SigintHandler(bec_with_pending_live_request)
+    token = active_request_context.set(
+        ActiveRequestContext(request_id="pending-request", queue_status="PENDING")
+    )
+
+    try:
+        with pytest.raises(KeyboardInterrupt):
+            handler._normal_mode()
+    finally:
+        active_request_context.reset(token)
+
+    bec_with_pending_live_request.queue.request_scan_interruption.assert_not_called()
+    bec_with_pending_live_request.queue.request_scan_abortion.assert_not_called()
+
+
+def test_sigint_handler_pending_live_request_does_not_abort_running_scan_from_other_client():
+    bec = mock.MagicMock()
+    bec._service_config = mock.MagicMock(abort_on_ctrl_c=True)
+    bec.queue.scan_storage.current_scan_info = mock.MagicMock(
+        status="RUNNING",
+        is_scan=[True],
+        request_blocks=[mock.MagicMock(RID="other-client-request")],
+    )
+    handler = SigintHandler(bec)
+    token = active_request_context.set(
+        ActiveRequestContext(request_id="local-pending-request", queue_status="PENDING")
+    )
+
+    try:
+        with pytest.raises(KeyboardInterrupt):
+            handler._normal_mode()
+    finally:
+        active_request_context.reset(token)
+
+    bec.queue.request_scan_interruption.assert_not_called()
+    bec.queue.request_scan_abortion.assert_not_called()
+
+
+def test_sigint_handler_requests_deferred_pause_for_running_scan():
+    bec = mock.MagicMock()
+    bec._service_config = mock.MagicMock(abort_on_ctrl_c=True)
+    bec._live_updates = None
+    bec.queue.scan_storage.current_scan_info = mock.MagicMock(status="RUNNING", is_scan=[True])
+
+    handler = SigintHandler(bec)
+    token = active_request_context.set(
+        ActiveRequestContext(request_id="running-request", queue_status="RUNNING")
+    )
+
+    try:
+        with mock.patch.object(threading, "Thread") as thread_cls:
+            handler._normal_mode()
+    finally:
+        active_request_context.reset(token)
+
+    thread_cls.assert_called_once_with(
+        target=bec.queue.request_scan_interruption,
+        kwargs={"deferred_pause": True, "request_id": "running-request"},
+        daemon=True,
+    )
+    thread_cls.return_value.start.assert_called_once_with()
+
+
+def test_sigint_handler_requests_abort_for_running_scan_after_second_sigint():
+    bec = mock.MagicMock()
+    bec._service_config = mock.MagicMock(abort_on_ctrl_c=True)
+    bec._live_updates = None
+    bec.queue.scan_storage.current_scan_info = mock.MagicMock(
+        status="DEFERRED_PAUSE", is_scan=[True]
+    )
+
+    handler = SigintHandler(bec)
+    handler.last_sigint_time = 0
+    token = active_request_context.set(
+        ActiveRequestContext(request_id="running-request", queue_status="DEFERRED_PAUSE")
+    )
+
+    try:
+        with (
+            mock.patch("bec_ipython_client.signals.time.time", return_value=5),
+            mock.patch.object(threading, "Thread") as thread_cls,
+            pytest.raises(ScanInterruption, match="User abort."),
+        ):
+            handler._normal_mode()
+    finally:
+        active_request_context.reset(token)
+
+    thread_cls.assert_called_once_with(
+        target=bec.queue.request_scan_abortion,
+        kwargs={"request_id": "running-request"},
+        daemon=True,
+    )
+    thread_cls.return_value.start.assert_called_once_with()
+
+
+def test_sigint_handler_without_active_or_pending_scan_reraises_keyboard_interrupt():
+    bec = mock.MagicMock()
+    bec._service_config = mock.MagicMock(abort_on_ctrl_c=True)
+    bec.queue.scan_storage.current_scan_info = None
+    handler = SigintHandler(bec)
+
+    with pytest.raises(KeyboardInterrupt):
+        handler._normal_mode()
+
+    bec.queue.request_scan_interruption.assert_not_called()
+    bec.queue.request_scan_abortion.assert_not_called()
+
+
+def test_sigint_handler_without_request_context_passes_none_to_thread_target():
+    bec = mock.MagicMock()
+    bec._service_config = mock.MagicMock(abort_on_ctrl_c=True)
+    bec._live_updates = None
+    bec.queue.scan_storage.current_scan_info = mock.MagicMock(status="RUNNING", is_scan=[True])
+    handler = SigintHandler(bec)
+
+    with mock.patch.object(threading, "Thread") as thread_cls:
+        handler._normal_mode()
+
+    thread_cls.assert_called_once_with(
+        target=bec.queue.request_scan_interruption,
+        kwargs={"deferred_pause": True, "request_id": None},
+        daemon=True,
+    )