bec-ipython-client 3.161.0__tar.gz → 3.162.0__tar.gz

{bec_ipython_client-3.161.0 → bec_ipython_client-3.162.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bec_ipython_client
-Version: 3.161.0
+Version: 3.162.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.161.0 → bec_ipython_client-3.162.0}/bec_ipython_client/callbacks/ipython_live_updates.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import collections
 import time
 from contextvars import Token
 from typing import TYPE_CHECKING, Any
@@ -41,12 +40,9 @@ class IPythonLiveUpdates:
         """
         self.client = client
         self._interrupted_request = None
-        self._active_callback = None
         self._processed_instructions = 0
         self._active_request: messages.ScanQueueMessage | None = None
         self._user_callback = None
-        self._request_block_index = collections.defaultdict(lambda: 0)
-        self._request_block_id = None
         self._current_queue = None
         self._status_live: Live | None = None
 
@@ -68,9 +64,6 @@ class IPythonLiveUpdates:
         """
         if not self._active_request:
             return
-        scan_type = self._active_request.scan_type
-        if scan_type == "close_scan_group":
-            return
 
         if not report_instructions:
             return
@@ -90,62 +83,33 @@ class IPythonLiveUpdates:
             instr (dict): The instruction to process.
         """
         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(
-                    self.client,
-                    report_instruction=instr,
-                    request=self._active_request,
-                    callbacks=self._user_callback,
-                ).run()
-            elif scan_report_type == "scan_progress":
-                LiveUpdatesTable(
-                    self.client,
-                    report_instruction=instr,
-                    request=self._active_request,
-                    callbacks=self._user_callback,
-                    print_table_data=self.print_table_data,
-                ).run()
-            elif scan_report_type == "device_progress":
-                LiveUpdatesDeviceProgress(
-                    self.client,
-                    report_instruction=instr,
-                    request=self._active_request,
-                    callbacks=self._user_callback,
-                ).run()
-            else:
-                raise ValueError(f"Unknown scan report type: {scan_report_type}")
-        else:
-            if self._active_callback:
-                if scan_report_type == "readback":
-                    LiveUpdatesReadbackProgressbar(
-                        self.client,
-                        report_instruction=instr,
-                        request=self._active_request,
-                        callbacks=self._user_callback,
-                    ).run()
-                else:
-                    self._active_callback.resume(
-                        request=self._active_request,
-                        report_instruction=instr,
-                        callbacks=self._user_callback,
-                    )
-
-                return
-
-            self._active_callback = LiveUpdatesTable(
+        if scan_report_type == "readback":
+            LiveUpdatesReadbackProgressbar(
+                self.client,
+                report_instruction=instr,
+                request=self._active_request,
+                callbacks=self._user_callback,
+            ).run()
+        elif scan_report_type == "scan_progress":
+            LiveUpdatesTable(
                 self.client,
                 report_instruction=instr,
                 request=self._active_request,
                 callbacks=self._user_callback,
                 print_table_data=self.print_table_data,
-            )
-            self._active_callback.run()
+            ).run()
+        elif scan_report_type == "device_progress":
+            LiveUpdatesDeviceProgress(
+                self.client,
+                report_instruction=instr,
+                request=self._active_request,
+                callbacks=self._user_callback,
+            ).run()
+        else:
+            raise ValueError(f"Unknown scan report type: {scan_report_type}")
 
     def _available_req_blocks(
         self, queue: QueueItem, request: messages.ScanQueueMessage
@@ -190,15 +154,14 @@ class IPythonLiveUpdates:
 
                 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", "CANCELLED"]:
                     request_context.queue_status = queue.status
-                    if self._process_queue(queue, request, req_id):
+                    if self._process_queue(queue, request):
                         break
 
                 available_blocks = self._available_req_blocks(queue, request)
-                req_block = available_blocks[self._request_block_index[req_id]]
+                req_block = available_blocks[0]
                 report_instructions = req_block.report_instructions or []
                 self._process_report_instructions(report_instructions)
 
@@ -218,15 +181,15 @@ class IPythonLiveUpdates:
             self._interrupted_request = (request,)
             if self._current_queue and self.client._service_config.abort_on_ctrl_c:
                 self._wait_for_cleanup()
-            self._reset(forced=True)
+            self._reset()
             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)
+                self._reset()
                 raise ScanInterruption("User abort.") from exc
-            self._reset(forced=True)
+            self._reset()
             raise
         finally:
             if context_token is not None:
@@ -285,16 +248,13 @@ class IPythonLiveUpdates:
             return False
         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
-    ) -> bool:
+    def _process_queue(self, queue: QueueItem, request: messages.ScanQueueMessage) -> bool:
         """
         Process the queue and return True if the scan is completed.
 
         Args:
             queue(QueueItem): The queue item to process.
             request(messages.ScanQueueMessage): The request message.
-            req_id(str): The request ID.
 
         Returns:
             bool: True if the scan is completed.
@@ -321,10 +281,9 @@ class IPythonLiveUpdates:
         available_blocks = self._available_req_blocks(queue, request)
         if not available_blocks:
             return False
-        req_block = available_blocks[self._request_block_index[req_id]]
+        req_block = available_blocks[0]
         if req_block.msg.scan_type in [
-            "mv",
-            "_v4_mv",
+            "mv"
         ]:  # TODO: make this more general for all scan types that don't have report instructions
             return True
 
@@ -333,13 +292,6 @@ class IPythonLiveUpdates:
             return False
         self._process_report_instructions(report_instructions)
 
-        complete_rbl = len(available_blocks) == self._request_block_index[req_id] + 1
-        if self._active_callback and complete_rbl:
-            return True
-
-        if complete_rbl and self.client.scans._interactive_scan:
-            return True
-
         if not queue.active_request_block:
             return True
 
@@ -395,28 +347,16 @@ class IPythonLiveUpdates:
             self._status_live.update(Panel(message, title="[yellow]Scan Status[/yellow]"))
         return
 
-    def _reset(self, forced=False):
-        """Reset the active request and callback.
-
-        Args:
-            forced(bool): If True, the reset is forced.
-        """
+    def _reset(self):
+        """Reset the active request."""
         self._stop_status_live()
         self._interrupted_request = None
 
         self._current_queue = None
         self._user_callback = None
         self._processed_instructions = 0
-        scan_closed = forced or self._active_request is None
         self._active_request = None
 
-        if self.client.scans._scan_def_id and not scan_closed:
-            self._request_block_index[self._request_block_id] += 1
-            return
-
-        if scan_closed:
-            self._active_callback = None
-
     def continue_request(self):
         """Continue the interrupted request."""
         if not self._interrupted_request:

{bec_ipython_client-3.161.0 → bec_ipython_client-3.162.0}/bec_ipython_client/callbacks/live_table.py

@@ -97,8 +97,6 @@ class LiveUpdatesTable(LiveUpdatesBase):
         """wait for scan completion"""
         while True:
             if self.scan_item.end_time:
-                if self.scan_item.open_queue_group:
-                    break
                 if self.scan_item.queue.queue_position is None:
                     break
             self.check_alarms()
@@ -110,13 +108,6 @@ class LiveUpdatesTable(LiveUpdatesBase):
         """check for alarms"""
         check_alarms(self.bec)
 
-    def resume(self, request: messages.ScanQueueMessage, report_instruction: str, callbacks):
-        """resume the scan after a pause"""
-        super().__init__(
-            self.bec, request=request, report_instruction=report_instruction, callbacks=callbacks
-        )
-        self.process_request()
-
     @property
     def devices(self):
         """get the devices for the callback"""

{bec_ipython_client-3.161.0 → bec_ipython_client-3.162.0}/demo.py

@@ -145,13 +145,6 @@ scans.umv(dev.samx, 5, dev.samy, 20, relative=False)
 # s = scans.line_scan(dev.samy, -5, 40, steps=10, exp_time=0.1)
 # s = scans.round_roi_scan(dev.samx, 50, dev.samy, 20, dr=2, nth=3, exp_time=0.1)
 
-# scan_def_id = str(uuid.uuid4())
-# scans.open_interactive_scan(dev.samx, dev.samy, exp_time=0.1, md={"scan_def_id": scan_def_id})
-# for ii in range(5):
-#     scans.mv(dev.samx, ii, dev.samy, ii + 3, md={"scan_def_id": scan_def_id})
-#     scans.interactive_scan_trigger(dev.samx, dev.samy, md={"scan_def_id": scan_def_id})
-# scans.close_interactive_scan(md={"scan_def_id": scan_def_id})
-
 
 # for ii in range(10):
 #     scans.umv(dev.samx, ii * 10)
@@ -164,15 +157,6 @@ scans.umv(dev.samx, 5, dev.samy, 20, relative=False)
 # scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.02)
 
 
-# @scans.scan_group
-# def scan_with_decorator():
-#     scans.umv(dev.samx, 5, relative=False)
-#     scans.line_scan(dev.samx, -5, 5, steps=100, exp_time=0.1, relative=True)
-#     scans.umv(dev.samx, 5, relative=False)
-#     scans.line_scan(dev.samx, -5, 5, steps=100, exp_time=0.1, relative=True)
-#     # scans.line_scan(dev.samx, -8, 8, steps=200, exp_time=0.1, relative=True)
-
-
 # with scans.dataset_id_on_hold:
 #     scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.1, relative=True)
 #     scans.line_scan(dev.samx, -8, 8, steps=10, exp_time=0.1, relative=True)
@@ -187,22 +171,6 @@ scans.umv(dev.samx, 5, dev.samy, 20, relative=False)
 # scans.umv(dev.samx, 1000)
 
 
-# @scans.scan_group
-# def alignment(*args, **kwargs):
-#     scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.02)
-#     scans.umv(dev.samx, 10)
-#     scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.02)
-#     scans.umv(dev.samx, 10)
-#     scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.02)
-
-
-# with scans.scan_group:
-#     scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.02, relative=True)
-#     scans.umv(dev.samx, 10, relative=True)
-
-# alignment()
-
-
 # scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.02, md={"queue_group": queue_group})
 # scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.02, md={"queue_group": queue_group})
 

{bec_ipython_client-3.161.0 → bec_ipython_client-3.162.0}/pyproject.toml

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

{bec_ipython_client-3.161.0 → bec_ipython_client-3.162.0}/tests/client_tests/test_ipython_live_updates.py

@@ -107,7 +107,7 @@ def test_live_updates_process_queue_pending(ipython_live_updates_with_mocked_liv
                 live_updates, "_available_req_blocks", return_value=[request_block]
             ):
                 with mock.patch.object(live_updates, "_process_report_instructions") as process:
-                    res = live_updates._process_queue(queue, request_msg, "req_id")
+                    res = live_updates._process_queue(queue, request_msg)
                     # Verify Live panel was created for showing queue status
                     mock_live.assert_called_once()
                     mock_live.return_value.start.assert_called_once()
@@ -141,7 +141,7 @@ def test_live_updates_process_queue_running(ipython_live_updates_with_mocked_liv
                 live_updates, "_available_req_blocks", return_value=[request_block]
             ):
                 with mock.patch.object(live_updates, "_process_instruction") as process:
-                    res = live_updates._process_queue(queue, request_msg, "req_id")
+                    res = live_updates._process_queue(queue, request_msg)
                     mock_live.assert_not_called()
                     process.assert_called_once_with({"wait_table": 10})
                     assert res is True
@@ -177,7 +177,7 @@ def test_live_updates_process_queue_waiting_for_device_locks(
     ):
         queue_pos.return_value = 0
 
-        assert live_updates._process_queue(queue, request_msg, "req_id") is False
+        assert live_updates._process_queue(queue, request_msg) is False
 
     process_pending.assert_called_once_with(queue)
 
@@ -214,7 +214,7 @@ def test_live_updates_process_queue_cancelled_pending_request_raises_interruptio
         mock.patch("bec_lib.queue_items.QueueItem.queue_position", new_callable=mock.PropertyMock),
         pytest.raises(ScanInterruption, match="Scan was cancelled."),
     ):
-        live_updates._process_queue(queue, request_msg, "something")
+        live_updates._process_queue(queue, request_msg)
 
 
 def test_live_updates_process_queue_stopped_started_request_raises_interruption(bec_client_mock):
@@ -259,7 +259,7 @@ def test_live_updates_process_queue_stopped_started_request_raises_interruption(
         mock.patch("bec_lib.queue_items.QueueItem.queue_position", new_callable=mock.PropertyMock),
         pytest.raises(ScanInterruption, match="Scan 1 was aborted by user."),
     ):
-        live_updates._process_queue(queue, request_msg, "something")
+        live_updates._process_queue(queue, request_msg)
 
 
 def test_live_updates_process_queue_stopped_restart_without_restart_message_waits_nonblocking(
@@ -300,7 +300,7 @@ def test_live_updates_process_queue_stopped_restart_without_restart_message_wait
             return_value=mock.MagicMock(status="aborted", restarted_msg=None),
         ),
     ):
-        assert live_updates._process_queue(queue, request_msg, "something") is False
+        assert live_updates._process_queue(queue, request_msg) is False
 
 
 def test_process_request_repeats_on_ScanRestart_error(
@@ -485,7 +485,7 @@ def test_process_request_keyboard_interrupt_pending_request_raises_scan_interrup
 
     abort_pending.assert_called_once()
     wait_for_cleanup.assert_called_once()
-    reset.assert_called_once_with(forced=True)
+    reset.assert_called_once_with()
 
 
 @pytest.mark.parametrize("queue_status", ["RUNNING", "LOCKED"])
@@ -515,7 +515,7 @@ def test_process_request_keyboard_interrupt_pending_request_aborts_local_request
 
     request_abort.assert_called_once_with(request_id="something")
     wait_for_cleanup.assert_called_once()
-    reset.assert_called_once_with(forced=True)
+    reset.assert_called_once_with()
 
 
 def test_process_request_keyboard_interrupt_non_pending_re_raises(
@@ -543,7 +543,7 @@ def test_process_request_keyboard_interrupt_non_pending_re_raises(
 
     abort_pending.assert_called_once()
     wait_for_cleanup.assert_not_called()
-    reset.assert_called_once_with(forced=True)
+    reset.assert_called_once_with()
 
 
 @pytest.mark.timeout(20)
@@ -552,7 +552,7 @@ def test_live_updates_process_queue_without_status(bec_client_mock, queue_elemen
     live_updates = IPythonLiveUpdates(client)
     queue, _, request_msg = queue_elements
     with mock.patch.object(queue, "_update_with_buffer"):
-        assert live_updates._process_queue(queue, request_msg, "req_id") is False
+        assert live_updates._process_queue(queue, request_msg) is False
 
 
 @pytest.mark.timeout(20)
@@ -574,7 +574,7 @@ def test_live_updates_process_queue_without_queue_number(bec_client_mock, queue_
         )
         queue_pos.return_value = None
         with mock.patch.object(queue, "_update_with_buffer"):
-            assert live_updates._process_queue(queue, request_msg, "req_id") is False
+            assert live_updates._process_queue(queue, request_msg) is False
 
 
 @pytest.mark.timeout(20)

{bec_ipython_client-3.161.0 → bec_ipython_client-3.162.0}/tests/end-2-end/test_acl_e2e.py

@@ -12,6 +12,9 @@ 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
 
+CLIENT_SHUTDOWN_TIMEOUT_S = 10
+SERVICE_STOP_TIMEOUT_S = 20
+
 
 @pytest.fixture
 def acl_enabled_bec_services(
@@ -61,7 +64,7 @@ def acl_enabled_bec_services(
         yield bec_services_config_file_path
     finally:
         if processes is not None:
-            service_handler.stop(processes)
+            service_handler.stop(processes, timeout_s=SERVICE_STOP_TIMEOUT_S)
         restore_connector = RedisConnector(redis_url)
         try:
             BECAccessDemo(restore_connector).reset()
@@ -77,7 +80,7 @@ def test_acl_admin_server_allows_default_user_scan(acl_enabled_bec_services):
     try:
         admin_client.config.load_demo_config(force=True)
     finally:
-        admin_client.shutdown()
+        admin_client.shutdown(per_thread_timeout_s=CLIENT_SHUTDOWN_TIMEOUT_S)
         admin_client._client._reset_singleton()
 
     user_config = ServiceConfig(acl_enabled_bec_services, acl={"env_file": "", "user": "user"})
@@ -97,7 +100,7 @@ def test_acl_admin_server_allows_default_user_scan(acl_enabled_bec_services):
 
         assert status.scan.num_points == 3
     finally:
-        user_client.shutdown()
+        user_client.shutdown(per_thread_timeout_s=CLIENT_SHUTDOWN_TIMEOUT_S)
         user_client._client._reset_singleton()
 
 
@@ -136,5 +139,5 @@ def test_acl_account_endpoint_allows_user_read_but_admin_only_write(acl_enabled_
         assert user_client.username == "user"
         assert user_client.connector.get_last(account_endpoint, "data") == updated_account_msg
     finally:
-        user_client.shutdown()
+        user_client.shutdown(per_thread_timeout_s=CLIENT_SHUTDOWN_TIMEOUT_S)
         user_client._client._reset_singleton()

{bec_ipython_client-3.161.0 → bec_ipython_client-3.162.0}/tests/end-2-end/test_scans_e2e.py

@@ -31,16 +31,13 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", ["grid_scan", "_v4_grid_scan"])
-def test_grid_scan(capsys, bec_ipython_client_fixture, scan_name):
+def test_grid_scan(capsys, bec_ipython_client_fixture):
     bec = bec_ipython_client_fixture
     scans = bec.scans
     bec.metadata.update({"unit_test": "test_grid_scan"})
     dev = bec.device_manager.devices
     scans.umv(dev.samx, 0, dev.samy, 0, relative=False)
-    status = getattr(scans, scan_name)(
-        dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.01, relative=True
-    )
+    status = scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.01, relative=True)
     assert len(status.scan.live_data) == 100
     assert status.scan.num_points == 100
     captured = capsys.readouterr()
@@ -48,13 +45,12 @@ def test_grid_scan(capsys, bec_ipython_client_fixture, scan_name):
 
 
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", ["fermat_scan", "_v4_fermat_scan"])
-def test_fermat_scan(capsys, bec_ipython_client_fixture, scan_name):
+def test_fermat_scan(capsys, bec_ipython_client_fixture):
     bec = bec_ipython_client_fixture
     scans = bec.scans
     bec.metadata.update({"unit_test": "test_fermat_scan"})
     dev = bec.device_manager.devices
-    status = getattr(scans, scan_name)(
+    status = scans.fermat_scan(
         dev.samx,
         -5,
         5,
@@ -66,25 +62,19 @@ def test_fermat_scan(capsys, bec_ipython_client_fixture, scan_name):
         relative=True,
         optim_trajectory="corridor",
     )
-    if scan_name == "_v4_fermat_scan":
-        # NOTE: v4 scan calculates the angle more accurately, which results in a slightly different number of points
-        assert len(status.scan.live_data) == 400
-        assert status.scan.num_points == 400
-    else:
-        assert len(status.scan.live_data) == 393
-        assert status.scan.num_points == 393
+    assert len(status.scan.live_data) == 400
+    assert status.scan.num_points == 400
     captured = capsys.readouterr()
     assert "finished. Scan ID" in captured.out
 
 
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
-def test_line_scan(capsys, bec_ipython_client_fixture, scan_name):
+def test_line_scan(capsys, bec_ipython_client_fixture):
     bec = bec_ipython_client_fixture
     scans = bec.scans
     bec.metadata.update({"unit_test": "test_line_scan"})
     dev = bec.device_manager.devices
-    status = getattr(scans, scan_name)(
+    status = scans.line_scan(
         dev.samx, -5, 5, dev.samy, -5, 5, steps=10, exp_time=0.01, relative=True
     )
     assert len(status.scan.live_data) == 10
@@ -95,13 +85,12 @@ def test_line_scan(capsys, bec_ipython_client_fixture, scan_name):
 
 @pytest.mark.flaky  # marked as flaky as the simulation might return a new readback value within the tolerance
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", [("mv", "umv"), ("_v4_mv", "_v4_umv")])
-def test_mv_scan(capsys, bec_ipython_client_fixture, scan_name):
+def test_mv_scan(capsys, bec_ipython_client_fixture):
     bec = bec_ipython_client_fixture
     scans = bec.scans
     bec.metadata.update({"unit_test": "test_mv_scan"})
     dev = bec.device_manager.devices
-    getattr(scans, scan_name[0])(dev.samx, 10, dev.samy, 20, relative=False).wait()
+    scans.mv(dev.samx, 10, dev.samy, 20, relative=False).wait()
     current_pos_samx = dev.samx.read(cached=True)["samx"]["value"]
     current_pos_samy = dev.samy.read(cached=True)["samy"]["value"]
     assert np.isclose(
@@ -110,7 +99,7 @@ def test_mv_scan(capsys, bec_ipython_client_fixture, scan_name):
     assert np.isclose(
         current_pos_samy, 20, atol=dev.samy._config["deviceConfig"].get("tolerance", 0.05)
     )
-    getattr(scans, scan_name[1])(dev.samx, 10, dev.samy, 20, relative=False)
+    scans.umv(dev.samx, 10, dev.samy, 20, relative=False)
     current_pos_samx = dev.samx.read(cached=True)["samx"]["value"]
     current_pos_samy = dev.samy.read(cached=True)["samy"]["value"]
     captured = capsys.readouterr()
@@ -122,13 +111,12 @@ def test_mv_scan(capsys, bec_ipython_client_fixture, scan_name):
 
 @pytest.mark.flaky  # marked as flaky as the simulation might return a new readback value within the tolerance
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", [("mv", "umv"), ("_v4_mv", "_v4_umv")])
-def test_mv_scan_nested_device(capsys, bec_ipython_client_fixture, scan_name):
+def test_mv_scan_nested_device(capsys, bec_ipython_client_fixture):
     bec = bec_ipython_client_fixture
     scans = bec.scans
     bec.metadata.update({"unit_test": "test_mv_scan_nested_device"})
     dev = bec.device_manager.devices
-    getattr(scans, scan_name[0])(dev.hexapod.x, 10, dev.hexapod.y, 20, relative=False).wait()
+    scans.mv(dev.hexapod.x, 10, dev.hexapod.y, 20, relative=False).wait()
     if not bec.connector._managed_connection._message_callbacks_queue.empty():
         print("Waiting for messages to be processed")
         time.sleep(0.5)
@@ -140,7 +128,7 @@ def test_mv_scan_nested_device(capsys, bec_ipython_client_fixture, scan_name):
     assert np.isclose(
         current_pos_hexapod_y, 20, atol=dev.hexapod._config["deviceConfig"].get("tolerance", 0.5)
     )
-    getattr(scans, scan_name[1])(dev.hexapod.x, 10, dev.hexapod.y, 20, relative=False)
+    scans.umv(dev.hexapod.x, 10, dev.hexapod.y, 20, relative=False)
     if not bec.connector._managed_connection._message_callbacks_queue.empty():
         print("Waiting for messages to be processed")
         time.sleep(0.5)
@@ -159,8 +147,7 @@ def test_mv_scan_nested_device(capsys, bec_ipython_client_fixture, scan_name):
 
 
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", [("umv", "grid_scan"), ("_v4_umv", "_v4_grid_scan")])
-def test_mv_scan_mv(bec_ipython_client_fixture, scan_name):
+def test_mv_scan_mv(bec_ipython_client_fixture):
     bec = bec_ipython_client_fixture
     scans = bec.scans
     bec.metadata.update({"unit_test": "test_mv_scan_mv"})
@@ -169,7 +156,7 @@ def test_mv_scan_mv(bec_ipython_client_fixture, scan_name):
 
     dev.samx.limits = [-50, 50]
     dev.samy.limits = [-50, 50]
-    getattr(scans, scan_name[0])(dev.samx, 10, dev.samy, 20, relative=False)
+    scans.umv(dev.samx, 10, dev.samy, 20, relative=False)
     tolerance_samx = dev.samx._config["deviceConfig"].get("tolerance", 0.05)
     tolerance_samy = dev.samy._config["deviceConfig"].get("tolerance", 0.05)
     current_pos_samx = dev.samx.read()["samx"]["value"]
@@ -179,9 +166,7 @@ def test_mv_scan_mv(bec_ipython_client_fixture, scan_name):
     assert np.isclose(current_pos_samx, 10, atol=tolerance_samx)
     assert np.isclose(current_pos_samy, 20, atol=tolerance_samy)
 
-    status = getattr(scans, scan_name[1])(
-        dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.01, relative=True
-    )
+    status = scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.01, relative=True)
 
     # make sure the scan completed the expected number of positions
     assert len(status.scan.live_data) == 100
@@ -201,7 +186,7 @@ def test_mv_scan_mv(bec_ipython_client_fixture, scan_name):
     assert np.isclose(current_pos_samx, 10, atol=tolerance_samx * 2)
     assert np.isclose(current_pos_samy, 20, atol=tolerance_samy * 2)
 
-    getattr(scans, scan_name[0])(dev.samx, 20, dev.samy, -20, relative=False)
+    scans.umv(dev.samx, 20, dev.samy, -20, relative=False)
     current_pos_samx = dev.samx.read()["samx"]["value"]
     current_pos_samy = dev.samy.read()["samy"]["value"]
 
@@ -209,7 +194,7 @@ def test_mv_scan_mv(bec_ipython_client_fixture, scan_name):
     assert np.isclose(current_pos_samx, 20, atol=tolerance_samx)
     assert np.isclose(current_pos_samy, -20, atol=tolerance_samy)
 
-    status = getattr(scans, scan_name[1])(
+    status = scans.grid_scan(
         dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.01, relative=False
     )
 
@@ -226,8 +211,7 @@ def test_mv_scan_mv(bec_ipython_client_fixture, scan_name):
 
 
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
-def test_scan_abort(bec_ipython_client_fixture: BECIPythonClient, scan_name: str):
+def test_scan_abort(bec_ipython_client_fixture: BECIPythonClient):
     def send_abort(bec):
         while True:
             current_scan_info = bec.queue.scan_storage.current_scan_info
@@ -256,7 +240,7 @@ def test_scan_abort(bec_ipython_client_fixture: BECIPythonClient, scan_name: str
     aborted_scan = False
     try:
         threading.Thread(target=send_abort, args=(bec,), daemon=True).start()
-        getattr(scans, scan_name)(dev.samx, -5, 5, steps=200, exp_time=0.1, relative=True)
+        scans.line_scan(dev.samx, -5, 5, steps=200, exp_time=0.1, relative=True)
     except ScanInterruption:
         logger.info("Raised ScanInterruption")
         time.sleep(2)
@@ -273,7 +257,7 @@ def test_scan_abort(bec_ipython_client_fixture: BECIPythonClient, scan_name: str
 
     assert len(bec.queue.scan_storage.storage[-1].live_data) < 200
 
-    getattr(scans, scan_name)(dev.samx, -5, 5, steps=10, exp_time=0.1, relative=True)
+    scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.1, relative=True)
     scan_number_end = bec.queue.next_scan_number
     assert scan_number_end == scan_number_start + 2
 
@@ -319,8 +303,8 @@ def test_umv_ctrl_c_stops_motion(bec_ipython_client_fixture: BECIPythonClient):
         dev.samx.velocity.set(original_velocity).wait()
 
 
-@pytest.mark.parametrize("scan_name", [("line_scan", "umv"), ("_v4_line_scan", "_v4_umv")])
-def test_limit_error(bec_ipython_client_fixture, scan_name):
+@pytest.mark.timeout(100)
+def test_limit_error(bec_ipython_client_fixture):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_limit_error"})
     scan_number_start = bec.queue.next_scan_number
@@ -329,7 +313,7 @@ def test_limit_error(bec_ipython_client_fixture, scan_name):
     aborted_scan = False
     dev.samx.limits = [-50, 50]
     try:
-        getattr(scans, scan_name[0])(dev.samx, -520, 5, steps=200, exp_time=0.1, relative=False)
+        scans.line_scan(dev.samx, -520, 5, steps=200, exp_time=0.1, relative=False)
     except AlarmBase as alarm:
         assert alarm.alarm_type == "LimitError"
         aborted_scan = True
@@ -339,7 +323,7 @@ def test_limit_error(bec_ipython_client_fixture, scan_name):
     aborted_scan = False
     dev.samx.limits = [-50, 50]
     try:
-        getattr(scans, scan_name[1])(dev.samx, 500, relative=False)
+        scans.umv(dev.samx, 500, relative=False)
     except AlarmBase as alarm:
         assert alarm.alarm_type == "LimitError"
         aborted_scan = True
@@ -350,17 +334,16 @@ def test_limit_error(bec_ipython_client_fixture, scan_name):
 
 
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
-def test_queued_scan(bec_ipython_client_fixture, scan_name):
+def test_queued_scan(bec_ipython_client_fixture):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_queued_scan"})
     scan_number_start = bec.queue.next_scan_number
     scans = bec.scans
     dev = bec.device_manager.devices
-    scan1 = getattr(scans, scan_name)(
+    scan1 = scans.line_scan(
         dev.samx, -5, 5, steps=100, exp_time=0.1, hide_report=True, relative=True
     )
-    scan2 = getattr(scans, scan_name)(
+    scan2 = scans.line_scan(
         dev.samx, -5, 5, steps=50, exp_time=0.1, hide_report=True, relative=True
     )
 
@@ -394,8 +377,7 @@ def test_fly_scan(bec_ipython_client_fixture):
 
 
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
-def test_scan_restart(bec_ipython_client_fixture, scan_name):
+def test_scan_restart(bec_ipython_client_fixture):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_scan_restart"})
     scans = bec.scans
@@ -417,12 +399,10 @@ def test_scan_restart(bec_ipython_client_fixture, scan_name):
 
     # We start two scans to ensure that the scan restart logic works correctly in a queued scenario
     # The first scan is started without printout to allow us to submit the second scan immediately after
-    getattr(scans, scan_name)(
-        dev.samx, -5, 5, steps=50, exp_time=0.1, hide_report=True, relative=True
-    )
+    scans.line_scan(dev.samx, -5, 5, steps=50, exp_time=0.1, hide_report=True, relative=True)
 
     # The second scan is using the live table printout. It should properly continue after the restart
-    scan2 = getattr(scans, scan_name)(dev.samx, -5, 5, steps=50, exp_time=0.1, relative=True)
+    scan2 = scans.line_scan(dev.samx, -5, 5, steps=50, exp_time=0.1, relative=True)
 
     scan2.wait()
 
@@ -435,8 +415,7 @@ def test_scan_restart(bec_ipython_client_fixture, scan_name):
 
 
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
-def test_scan_observer_repeat_queued(bec_ipython_client_fixture: BECIPythonClient, scan_name):
+def test_scan_observer_repeat_queued(bec_ipython_client_fixture: BECIPythonClient):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_scan_observer_repeat_queued"})
     scans = bec.scans
@@ -458,10 +437,10 @@ def test_scan_observer_repeat_queued(bec_ipython_client_fixture: BECIPythonClien
     # start repeat thread
     threading.Thread(target=send_repeat, args=(bec,), daemon=True).start()
     # start scan
-    scan1 = getattr(scans, scan_name)(
+    scan1 = scans.line_scan(
         dev.samx, -5, 5, steps=100, exp_time=0.1, hide_report=True, relative=True
     )
-    scan2 = getattr(scans, scan_name)(
+    scan2 = scans.line_scan(
         dev.samx, -5, 5, steps=100, exp_time=0.1, hide_report=True, relative=True
     )
 
@@ -476,8 +455,7 @@ def test_scan_observer_repeat_queued(bec_ipython_client_fixture: BECIPythonClien
 
 
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
-def test_scan_observer_repeat(bec_ipython_client_fixture, scan_name):
+def test_scan_observer_repeat(bec_ipython_client_fixture):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_scan_observer_repeat"})
     scans = bec.scans
@@ -497,7 +475,7 @@ def test_scan_observer_repeat(bec_ipython_client_fixture, scan_name):
     threading.Thread(target=send_repeat, args=(bec,), daemon=True).start()
     # start scan
     with pytest.raises(ScanAbortion):
-        scan1 = getattr(scans, scan_name)(
+        scan1 = scans.line_scan(
             dev.samx, -5, 5, steps=50, exp_time=0.1, hide_report=True, relative=True
         )
         scan1.wait()
@@ -512,8 +490,7 @@ def test_scan_observer_repeat(bec_ipython_client_fixture, scan_name):
 
 
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", ["grid_scan", "_v4_grid_scan"])
-def test_file_writer(bec_ipython_client_fixture, scan_name):
+def test_file_writer(bec_ipython_client_fixture):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_file_writer"})
     scans = bec.scans
@@ -523,7 +500,7 @@ def test_file_writer(bec_ipython_client_fixture, scan_name):
     dev.samx.velocity.set(98).wait()
     dev.samy.velocity.set(101).wait()
 
-    scan = getattr(scans, scan_name)(
+    scan = scans.grid_scan(
         dev.samx,
         -5,
         5,
@@ -576,37 +553,21 @@ def test_file_writer(bec_ipython_client_fixture, scan_name):
 
 
 @pytest.mark.timeout(100)
-def test_group_def(bec_ipython_client_fixture):
-    bec = bec_ipython_client_fixture
-    bec.metadata.update({"unit_test": "test_group_def"})
-    scans = bec.scans
-    dev = bec.device_manager.devices
-    scan_number = bec.queue.next_scan_number
-    with scans.scan_group:
-        scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.1, relative=False)
-        scans.umv(dev.samy, 5, relative=False)
-        scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.1, relative=False)
-
-    assert scan_number == bec.queue.next_scan_number - 2
-
-
-@pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", ["list_scan", "_v4_list_scan"])
-def test_list_scan(bec_ipython_client_fixture, scan_name):
+def test_list_scan(bec_ipython_client_fixture):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_list_scan"})
     scans = bec.scans
     dev = bec.device_manager.devices
 
-    status = getattr(scans, scan_name)(
+    status = scans.list_scan(
         dev.samx, [0, 1, 2, 3, 4], dev.samy, [0, 1, 2, 3, 4], exp_time=0.1, relative=False
     )
     assert len(status.scan.live_data) == 5
 
-    status = getattr(scans, scan_name)(dev.samx, [0, 1, 2, 3, 4, 5], exp_time=0.1, relative=False)
+    status = scans.list_scan(dev.samx, [0, 1, 2, 3, 4, 5], exp_time=0.1, relative=False)
     assert len(status.scan.live_data) == 6
 
-    status = getattr(scans, scan_name)(
+    status = scans.list_scan(
         dev.samx,
         [0, 1, 2, 3],
         dev.samy,
@@ -624,7 +585,7 @@ def test_time_scan(bec_ipython_client_fixture):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_time_scan"})
     scans = bec.scans
-    status = scans.time_scan(points=5, interval=0.5, exp_time=0.1, relative=False)
+    status = scans.time_scan(points=5, interval=0.5, exp_time=0.1)
     assert len(status.scan.live_data) == 5
 
 
@@ -881,8 +842,7 @@ def test_grid_scan_secondary_queue(capsys, bec_ipython_client_fixture):
 
 
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
-def test_scan_after_scan_lock(capsys, bec_ipython_client_fixture, scan_name):
+def test_scan_after_scan_lock(capsys, bec_ipython_client_fixture):
     """
     Test that pending scans are properly executed after a scan lock is released.
     """
@@ -891,10 +851,8 @@ def test_scan_after_scan_lock(capsys, bec_ipython_client_fixture, scan_name):
     bec.metadata.update({"unit_test": "test_scan_after_scan_lock"})
     dev = bec.device_manager.devices
     bec.queue.add_queue_lock(queue="primary", reason="unit_test_scan_lock", lock_id="test_lock")
-    getattr(scans, scan_name)(
-        dev.samx, -5, 5, steps=10, exp_time=0.01, relative=True, hide_report=True
-    )
-    scan2 = getattr(scans, scan_name)(
+    scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.01, relative=True, hide_report=True)
+    scan2 = scans.line_scan(
         dev.samx, -5, 5, steps=10, exp_time=0.01, relative=True, hide_report=True
     )
 
@@ -908,8 +866,7 @@ def test_scan_after_scan_lock(capsys, bec_ipython_client_fixture, scan_name):
 
 
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
-def test_scan_repeat_decorator(bec_ipython_client_fixture, scan_name):
+def test_scan_repeat_decorator(bec_ipython_client_fixture):
     """
     Test the scan_repeat decorator by simulating a communication failure during a scan.
     The scan should be retried according to the specified max_repeats and exc_handler.
@@ -953,9 +910,7 @@ def test_scan_repeat_decorator(bec_ipython_client_fixture, scan_name):
 
     @scan_repeat(max_repeats=2, exc_handler=exc_handler)
     def my_scan():
-        getattr(scans, scan_name)(
-            dev.positioner_with_failure, -5, 5, steps=10, exp_time=0.01, relative=True
-        )
+        scans.line_scan(dev.positioner_with_failure, -5, 5, steps=10, exp_time=0.01, relative=True)
 
     my_scan()
 
@@ -965,10 +920,7 @@ def test_scan_repeat_decorator(bec_ipython_client_fixture, scan_name):
 
 
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize(
-    "scan_name", [("grid_scan", "line_scan"), ("_v4_grid_scan", "_v4_line_scan")]
-)
-def test_scan_set_completed(bec_ipython_client_fixture, scan_name):
+def test_scan_set_completed(bec_ipython_client_fixture):
     """
     Test that a scan can be manually set to completed.
     """
@@ -988,9 +940,7 @@ def test_scan_set_completed(bec_ipython_client_fixture, scan_name):
 
     threading.Thread(target=_set_scan_completed, args=(bec,), daemon=True).start()
 
-    getattr(scans, scan_name[0])(
-        dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.01, relative=True
-    )
+    scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.01, relative=True)
 
     # Now add a second scan to ensure scans can continue after setting completed
-    getattr(scans, scan_name[1])(dev.samx, -5, 5, steps=10, exp_time=0.01, relative=True)
+    scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.01, relative=True)

{bec_ipython_client-3.161.0 → bec_ipython_client-3.162.0}/tests/end-2-end/test_scans_lib_e2e.py

@@ -16,31 +16,25 @@ logger = bec_logger.logger
 
 
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", [("umv", "grid_scan"), ("_v4_umv", "_v4_grid_scan")])
-def test_grid_scan_lib(bec_client_lib, scan_name):
+def test_grid_scan_lib(bec_client_lib):
     bec = bec_client_lib
     scans = bec.scans
     bec.metadata.update({"unit_test": "test_grid_scan_bec_client_lib"})
     dev = bec.device_manager.devices
-    getattr(scans, scan_name[0])(dev.samx, 0, dev.samy, 0, relative=False)
-    status = getattr(scans, scan_name[1])(
-        dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.01, relative=True
-    )
+    scans.umv(dev.samx, 0, dev.samy, 0, relative=False)
+    status = scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.01, relative=True)
     status.wait(num_points=True, file_written=True)
     assert len(status.scan.live_data) == 100
     assert status.scan.num_points == 100
 
 
 @pytest.mark.timeout(100)
-@pytest.mark.parametrize("scan_name", ["grid_scan", "_v4_grid_scan"])
-def test_grid_scan_lib_cancel(bec_client_lib, scan_name):
+def test_grid_scan_lib_cancel(bec_client_lib):
     bec = bec_client_lib
     scans = bec.scans
     bec.metadata.update({"unit_test": "test_grid_scan_bec_client_lib"})
     dev = bec.device_manager.devices
-    status = getattr(scans, scan_name)(
-        dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=1, relative=False
-    )
+    status = scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=1, relative=False)
     time.sleep(0.5)
     status.cancel()
 
@@ -352,6 +346,7 @@ def test_dap_fit(bec_client_lib):
         "invalid_device_class",
     ],
 )
+@pytest.mark.timeout(100)
 def test_config_reload(
     bec_test_config_file_path, bec_client_lib, config, raises_error, deletes_config, disabled_device
 ):
@@ -550,31 +545,6 @@ def test_cached_device_readout(bec_client_lib):
     assert timestamp_3 == timestamp_2
 
 
-@pytest.mark.timeout(100)
-@pytest.mark.skip(reason="Interactive scans are currently not supported in v4 scans.")
-def test_interactive_scan(bec_client_lib):
-    bec = bec_client_lib
-    bec.metadata.update({"unit_test": "test_interactive_scan"})
-    dev = bec.device_manager.devices
-    scans = bec.scans
-
-    with scans.interactive_scan(monitored=[dev.samx, dev.samy], exp_time=0.1) as scan:
-        for ii in range(10):
-            samx_status = dev.samx.set(ii)
-            samy_status = dev.samy.set(ii)
-            samx_status.wait()
-            samy_status.wait()
-            scan.trigger()
-            scan.read_monitored_devices(devices=[dev.samx, dev.samy])
-        report = scan.status
-
-    report.wait()
-
-    while len(report.scan.live_data) != 10:
-        time.sleep(0.1)
-    assert len(report.scan.live_data.samx.samx.val) == 10
-
-
 @pytest.mark.timeout(100)
 def test_bl_state(bec_client_lib):
     bec = bec_client_lib

{bec_ipython_client-3.161.0 → bec_ipython_client-3.162.0}/tests/end-2-end/test_scans_v4_lib_e2e.py

@@ -16,7 +16,7 @@ from bec_server.scan_server.scans import position_generators
 
 
 def _get_v4_scan_runner(bec, scan_name: str):
-    return getattr(bec.scans, f"_v4_{scan_name}")
+    return getattr(bec.scans, scan_name)
 
 
 def _run_v4_scan(
@@ -69,15 +69,6 @@ def _wait_for_live_data_count(bec, status, expected_count: int, timeout: float =
         time.sleep(0.1)
 
 
-def _wait_for_scan_status(status, expected_status: str, timeout: float = 10):
-    deadline = time.time() + timeout
-    while time.time() < deadline:
-        if status.status == expected_status:
-            return
-        time.sleep(0.1)
-    raise TimeoutError(f"Timed out waiting for scan status {expected_status!r}.")
-
-
 def _wait_for_queue_status(bec, queue_name: str, expected_status: str, timeout: float = 10):
     deadline = time.time() + timeout
     while time.time() < deadline:
@@ -240,7 +231,7 @@ def test_v4_fixed_point_scans_lib(
 
 
 @pytest.mark.timeout(120)
-def test_v4_mv_scan_lib(bec_client_lib):
+def test_mv_scan_lib(bec_client_lib):
     bec = bec_client_lib
     dev = bec.device_manager.devices
 
@@ -252,7 +243,7 @@ def test_v4_mv_scan_lib(bec_client_lib):
 
 
 @pytest.mark.timeout(120)
-def test_v4_umv_scan_lib(bec_client_lib):
+def test_umv_scan_lib(bec_client_lib):
     bec = bec_client_lib
     dev = bec.device_manager.devices
 
@@ -264,7 +255,7 @@ def test_v4_umv_scan_lib(bec_client_lib):
 
 
 @pytest.mark.timeout(120)
-def test_v4_cont_line_scan_lib(bec_client_lib):
+def test_cont_line_scan_lib(bec_client_lib):
     bec = bec_client_lib
     dev = bec.device_manager.devices
     original_velocity = dev.samx.velocity.get()
@@ -282,7 +273,7 @@ def test_v4_cont_line_scan_lib(bec_client_lib):
 
 
 @pytest.mark.timeout(120)
-def test_v4_line_sweep_scan_lib(bec_client_lib):
+def test_line_sweep_scan_lib(bec_client_lib):
     bec = bec_client_lib
     dev = bec.device_manager.devices
     scans = bec.scans