bec-ipython-client 3.154.0__tar.gz → 3.156.0__tar.gz

{bec_ipython_client-3.154.0 → bec_ipython_client-3.156.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bec_ipython_client
-Version: 3.154.0
+Version: 3.156.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.154.0 → bec_ipython_client-3.156.0}/bec_ipython_client/callbacks/ipython_live_updates.py

@@ -322,9 +322,10 @@ class IPythonLiveUpdates:
         if not available_blocks:
             return False
         req_block = available_blocks[self._request_block_index[req_id]]
-        if (
-            req_block.msg.scan_type == "mv"
-        ):  # TODO: make this more general for scans without report instructions
+        if req_block.msg.scan_type in [
+            "mv",
+            "_v4_mv",
+        ]:  # TODO: make this more general for all scan types that don't have report instructions
             return True
 
         report_instructions = req_block.report_instructions or []

{bec_ipython_client-3.154.0 → bec_ipython_client-3.156.0}/bec_ipython_client/callbacks/live_table.py

@@ -45,6 +45,8 @@ class LiveUpdatesTable(LiveUpdatesBase):
 
     MAX_DEVICES = 10
     REPORT_TYPE = "scan_progress"
+    STEP_SCAN_TYPES = {"step", "software_triggered", "hardware_triggered"}
+    FLY_SCAN_TYPES = {"fly"}
 
     def __init__(
         self,
@@ -118,9 +120,9 @@ class LiveUpdatesTable(LiveUpdatesBase):
     @property
     def devices(self):
         """get the devices for the callback"""
-        if self.point_data.metadata["scan_type"] == "step":
+        if self.point_data.metadata["scan_type"] in self.STEP_SCAN_TYPES:
             return self.get_devices_from_scan_data(self.scan_item.live_data[0])
-        if self.point_data.metadata["scan_type"] == "fly":
+        if self.point_data.metadata["scan_type"] in self.FLY_SCAN_TYPES:
             devices = list(self.point_data.content["data"].keys())
             if len(devices) > self.MAX_DEVICES:
                 return devices[0 : self.MAX_DEVICES]

{bec_ipython_client-3.154.0 → bec_ipython_client-3.156.0}/pyproject.toml

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

{bec_ipython_client-3.154.0 → bec_ipython_client-3.156.0}/tests/client_tests/test_live_table.py

@@ -251,6 +251,48 @@ class TestLiveTable:
             live_update.print_table_data()
             assert mock_client_msgs.called
 
+    def test_print_table_data_with_v4_software_triggered_scan(self, client_with_grid_scan):
+        client, request_msg = client_with_grid_scan
+        response_msg = messages.RequestResponseMessage(
+            accepted=True, message={"msg": ""}, metadata={"RID": "something"}
+        )
+        client.queue.request_storage.update_with_request(request_msg)
+        client.queue.request_storage.update_with_response(response_msg)
+        live_update = LiveUpdatesTable(
+            client, {"scan_progress": {"points": 10, "show_table": True}}, request_msg
+        )
+        live_update.point_data = messages.ScanMessage(
+            point_id=0,
+            scan_id="",
+            data={"samx": {"samx": {"value": 0}}},
+            metadata={"scan_report_devices": ["samx"], "scan_type": "software_triggered"},
+        )
+        live_update.scan_item = ScanItemMock(live_data={0: live_update.point_data})
+        with mock.patch.object(live_update, "_print_client_msgs_asap") as mock_client_msgs:
+            live_update.print_table_data()
+            assert mock_client_msgs.called
+
+    def test_print_table_data_with_v4_hardware_triggered_scan(self, client_with_grid_scan):
+        client, request_msg = client_with_grid_scan
+        response_msg = messages.RequestResponseMessage(
+            accepted=True, message={"msg": ""}, metadata={"RID": "something"}
+        )
+        client.queue.request_storage.update_with_request(request_msg)
+        client.queue.request_storage.update_with_response(response_msg)
+        live_update = LiveUpdatesTable(
+            client, {"scan_progress": {"points": 10, "show_table": True}}, request_msg
+        )
+        live_update.point_data = messages.ScanMessage(
+            point_id=0,
+            scan_id="",
+            data={"samx": {"samx": {"value": 0}}},
+            metadata={"scan_report_devices": ["samx"], "scan_type": "hardware_triggered"},
+        )
+        live_update.scan_item = ScanItemMock(live_data={0: live_update.point_data})
+        with mock.patch.object(live_update, "_print_client_msgs_asap") as mock_client_msgs:
+            live_update.print_table_data()
+            assert mock_client_msgs.called
+
     def test_print_table_data_lamni_flyer(self, client_with_grid_scan):
         client, request_msg = client_with_grid_scan
         response_msg = messages.RequestResponseMessage(

{bec_ipython_client-3.154.0 → bec_ipython_client-3.156.0}/tests/end-2-end/test_scans_e2e.py

@@ -31,13 +31,16 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 @pytest.mark.timeout(100)
-def test_grid_scan(capsys, bec_ipython_client_fixture):
+@pytest.mark.parametrize("scan_name", ["grid_scan", "_v4_grid_scan"])
+def test_grid_scan(capsys, bec_ipython_client_fixture, scan_name):
     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 = scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.01, relative=True)
+    status = getattr(scans, scan_name)(
+        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()
@@ -45,12 +48,13 @@ def test_grid_scan(capsys, bec_ipython_client_fixture):
 
 
 @pytest.mark.timeout(100)
-def test_fermat_scan(capsys, bec_ipython_client_fixture):
+@pytest.mark.parametrize("scan_name", ["fermat_scan", "_v4_fermat_scan"])
+def test_fermat_scan(capsys, bec_ipython_client_fixture, scan_name):
     bec = bec_ipython_client_fixture
     scans = bec.scans
     bec.metadata.update({"unit_test": "test_fermat_scan"})
     dev = bec.device_manager.devices
-    status = scans.fermat_scan(
+    status = getattr(scans, scan_name)(
         dev.samx,
         -5,
         5,
@@ -62,19 +66,27 @@ def test_fermat_scan(capsys, bec_ipython_client_fixture):
         relative=True,
         optim_trajectory="corridor",
     )
-    assert len(status.scan.live_data) == 393
-    assert status.scan.num_points == 393
+    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
     captured = capsys.readouterr()
     assert "finished. Scan ID" in captured.out
 
 
 @pytest.mark.timeout(100)
-def test_line_scan(capsys, bec_ipython_client_fixture):
+@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
+def test_line_scan(capsys, bec_ipython_client_fixture, scan_name):
     bec = bec_ipython_client_fixture
     scans = bec.scans
     bec.metadata.update({"unit_test": "test_line_scan"})
     dev = bec.device_manager.devices
-    status = scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.01, relative=True)
+    status = getattr(scans, scan_name)(
+        dev.samx, -5, 5, dev.samy, -5, 5, steps=10, exp_time=0.01, relative=True
+    )
     assert len(status.scan.live_data) == 10
     assert status.scan.num_points == 10
     captured = capsys.readouterr()
@@ -83,12 +95,13 @@ def test_line_scan(capsys, bec_ipython_client_fixture):
 
 @pytest.mark.flaky  # marked as flaky as the simulation might return a new readback value within the tolerance
 @pytest.mark.timeout(100)
-def test_mv_scan(capsys, bec_ipython_client_fixture):
+@pytest.mark.parametrize("scan_name", [("mv", "umv"), ("_v4_mv", "_v4_umv")])
+def test_mv_scan(capsys, bec_ipython_client_fixture, scan_name):
     bec = bec_ipython_client_fixture
     scans = bec.scans
     bec.metadata.update({"unit_test": "test_mv_scan"})
     dev = bec.device_manager.devices
-    scans.mv(dev.samx, 10, dev.samy, 20, relative=False).wait()
+    getattr(scans, scan_name[0])(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(
@@ -97,7 +110,7 @@ def test_mv_scan(capsys, bec_ipython_client_fixture):
     assert np.isclose(
         current_pos_samy, 20, atol=dev.samy._config["deviceConfig"].get("tolerance", 0.05)
     )
-    scans.umv(dev.samx, 10, dev.samy, 20, relative=False)
+    getattr(scans, scan_name[1])(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()
@@ -109,12 +122,13 @@ def test_mv_scan(capsys, bec_ipython_client_fixture):
 
 @pytest.mark.flaky  # marked as flaky as the simulation might return a new readback value within the tolerance
 @pytest.mark.timeout(100)
-def test_mv_scan_nested_device(capsys, bec_ipython_client_fixture):
+@pytest.mark.parametrize("scan_name", [("mv", "umv"), ("_v4_mv", "_v4_umv")])
+def test_mv_scan_nested_device(capsys, bec_ipython_client_fixture, scan_name):
     bec = bec_ipython_client_fixture
     scans = bec.scans
     bec.metadata.update({"unit_test": "test_mv_scan_nested_device"})
     dev = bec.device_manager.devices
-    scans.mv(dev.hexapod.x, 10, dev.hexapod.y, 20, relative=False).wait()
+    getattr(scans, scan_name[0])(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)
@@ -126,7 +140,7 @@ def test_mv_scan_nested_device(capsys, bec_ipython_client_fixture):
     assert np.isclose(
         current_pos_hexapod_y, 20, atol=dev.hexapod._config["deviceConfig"].get("tolerance", 0.5)
     )
-    scans.umv(dev.hexapod.x, 10, dev.hexapod.y, 20, relative=False)
+    getattr(scans, scan_name[1])(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)
@@ -145,7 +159,8 @@ def test_mv_scan_nested_device(capsys, bec_ipython_client_fixture):
 
 
 @pytest.mark.timeout(100)
-def test_mv_scan_mv(bec_ipython_client_fixture):
+@pytest.mark.parametrize("scan_name", [("umv", "grid_scan"), ("_v4_umv", "_v4_grid_scan")])
+def test_mv_scan_mv(bec_ipython_client_fixture, scan_name):
     bec = bec_ipython_client_fixture
     scans = bec.scans
     bec.metadata.update({"unit_test": "test_mv_scan_mv"})
@@ -154,7 +169,7 @@ def test_mv_scan_mv(bec_ipython_client_fixture):
 
     dev.samx.limits = [-50, 50]
     dev.samy.limits = [-50, 50]
-    scans.umv(dev.samx, 10, dev.samy, 20, relative=False)
+    getattr(scans, scan_name[0])(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"]
@@ -164,7 +179,9 @@ def test_mv_scan_mv(bec_ipython_client_fixture):
     assert np.isclose(current_pos_samx, 10, atol=tolerance_samx)
     assert np.isclose(current_pos_samy, 20, atol=tolerance_samy)
 
-    status = scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.01, relative=True)
+    status = getattr(scans, scan_name[1])(
+        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
@@ -184,7 +201,7 @@ def test_mv_scan_mv(bec_ipython_client_fixture):
     assert np.isclose(current_pos_samx, 10, atol=tolerance_samx * 2)
     assert np.isclose(current_pos_samy, 20, atol=tolerance_samy * 2)
 
-    scans.umv(dev.samx, 20, dev.samy, -20, relative=False)
+    getattr(scans, scan_name[0])(dev.samx, 20, dev.samy, -20, relative=False)
     current_pos_samx = dev.samx.read()["samx"]["value"]
     current_pos_samy = dev.samy.read()["samy"]["value"]
 
@@ -192,7 +209,7 @@ def test_mv_scan_mv(bec_ipython_client_fixture):
     assert np.isclose(current_pos_samx, 20, atol=tolerance_samx)
     assert np.isclose(current_pos_samy, -20, atol=tolerance_samy)
 
-    status = scans.grid_scan(
+    status = getattr(scans, scan_name[1])(
         dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.01, relative=False
     )
 
@@ -209,7 +226,8 @@ def test_mv_scan_mv(bec_ipython_client_fixture):
 
 
 @pytest.mark.timeout(100)
-def test_scan_abort(bec_ipython_client_fixture: BECIPythonClient):
+@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
+def test_scan_abort(bec_ipython_client_fixture: BECIPythonClient, scan_name: str):
     def send_abort(bec):
         while True:
             current_scan_info = bec.queue.scan_storage.current_scan_info
@@ -238,7 +256,7 @@ def test_scan_abort(bec_ipython_client_fixture: BECIPythonClient):
     aborted_scan = False
     try:
         threading.Thread(target=send_abort, args=(bec,), daemon=True).start()
-        scans.line_scan(dev.samx, -5, 5, steps=200, exp_time=0.1, relative=True)
+        getattr(scans, scan_name)(dev.samx, -5, 5, steps=200, exp_time=0.1, relative=True)
     except ScanInterruption:
         logger.info("Raised ScanInterruption")
         time.sleep(2)
@@ -255,7 +273,7 @@ def test_scan_abort(bec_ipython_client_fixture: BECIPythonClient):
 
     assert len(bec.queue.scan_storage.storage[-1].live_data) < 200
 
-    scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.1, relative=True)
+    getattr(scans, scan_name)(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
 
@@ -301,8 +319,8 @@ def test_umv_ctrl_c_stops_motion(bec_ipython_client_fixture: BECIPythonClient):
         dev.samx.velocity.set(original_velocity).wait()
 
 
-@pytest.mark.timeout(100)
-def test_limit_error(bec_ipython_client_fixture):
+@pytest.mark.parametrize("scan_name", [("line_scan", "umv"), ("_v4_line_scan", "_v4_umv")])
+def test_limit_error(bec_ipython_client_fixture, scan_name):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_limit_error"})
     scan_number_start = bec.queue.next_scan_number
@@ -311,7 +329,7 @@ def test_limit_error(bec_ipython_client_fixture):
     aborted_scan = False
     dev.samx.limits = [-50, 50]
     try:
-        scans.line_scan(dev.samx, -520, 5, steps=200, exp_time=0.1, relative=False)
+        getattr(scans, scan_name[0])(dev.samx, -520, 5, steps=200, exp_time=0.1, relative=False)
     except AlarmBase as alarm:
         assert alarm.alarm_type == "LimitError"
         aborted_scan = True
@@ -321,7 +339,7 @@ def test_limit_error(bec_ipython_client_fixture):
     aborted_scan = False
     dev.samx.limits = [-50, 50]
     try:
-        scans.umv(dev.samx, 500, relative=False)
+        getattr(scans, scan_name[1])(dev.samx, 500, relative=False)
     except AlarmBase as alarm:
         assert alarm.alarm_type == "LimitError"
         aborted_scan = True
@@ -332,16 +350,17 @@ def test_limit_error(bec_ipython_client_fixture):
 
 
 @pytest.mark.timeout(100)
-def test_queued_scan(bec_ipython_client_fixture):
+@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
+def test_queued_scan(bec_ipython_client_fixture, scan_name):
     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 = scans.line_scan(
+    scan1 = getattr(scans, scan_name)(
         dev.samx, -5, 5, steps=100, exp_time=0.1, hide_report=True, relative=True
     )
-    scan2 = scans.line_scan(
+    scan2 = getattr(scans, scan_name)(
         dev.samx, -5, 5, steps=50, exp_time=0.1, hide_report=True, relative=True
     )
 
@@ -375,7 +394,8 @@ def test_fly_scan(bec_ipython_client_fixture):
 
 
 @pytest.mark.timeout(100)
-def test_scan_restart(bec_ipython_client_fixture):
+@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
+def test_scan_restart(bec_ipython_client_fixture, scan_name):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_scan_restart"})
     scans = bec.scans
@@ -397,10 +417,12 @@ def test_scan_restart(bec_ipython_client_fixture):
 
     # 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
-    scans.line_scan(dev.samx, -5, 5, steps=50, exp_time=0.1, hide_report=True, relative=True)
+    getattr(scans, scan_name)(
+        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 = scans.line_scan(dev.samx, -5, 5, steps=50, exp_time=0.1, relative=True)
+    scan2 = getattr(scans, scan_name)(dev.samx, -5, 5, steps=50, exp_time=0.1, relative=True)
 
     scan2.wait()
 
@@ -413,7 +435,8 @@ def test_scan_restart(bec_ipython_client_fixture):
 
 
 @pytest.mark.timeout(100)
-def test_scan_observer_repeat_queued(bec_ipython_client_fixture: BECIPythonClient):
+@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
+def test_scan_observer_repeat_queued(bec_ipython_client_fixture: BECIPythonClient, scan_name):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_scan_observer_repeat_queued"})
     scans = bec.scans
@@ -435,10 +458,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 = scans.line_scan(
+    scan1 = getattr(scans, scan_name)(
         dev.samx, -5, 5, steps=100, exp_time=0.1, hide_report=True, relative=True
     )
-    scan2 = scans.line_scan(
+    scan2 = getattr(scans, scan_name)(
         dev.samx, -5, 5, steps=100, exp_time=0.1, hide_report=True, relative=True
     )
 
@@ -453,7 +476,8 @@ def test_scan_observer_repeat_queued(bec_ipython_client_fixture: BECIPythonClien
 
 
 @pytest.mark.timeout(100)
-def test_scan_observer_repeat(bec_ipython_client_fixture):
+@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
+def test_scan_observer_repeat(bec_ipython_client_fixture, scan_name):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_scan_observer_repeat"})
     scans = bec.scans
@@ -473,7 +497,7 @@ def test_scan_observer_repeat(bec_ipython_client_fixture):
     threading.Thread(target=send_repeat, args=(bec,), daemon=True).start()
     # start scan
     with pytest.raises(ScanAbortion):
-        scan1 = scans.line_scan(
+        scan1 = getattr(scans, scan_name)(
             dev.samx, -5, 5, steps=50, exp_time=0.1, hide_report=True, relative=True
         )
         scan1.wait()
@@ -488,7 +512,8 @@ def test_scan_observer_repeat(bec_ipython_client_fixture):
 
 
 @pytest.mark.timeout(100)
-def test_file_writer(bec_ipython_client_fixture):
+@pytest.mark.parametrize("scan_name", ["grid_scan", "_v4_grid_scan"])
+def test_file_writer(bec_ipython_client_fixture, scan_name):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_file_writer"})
     scans = bec.scans
@@ -498,7 +523,7 @@ def test_file_writer(bec_ipython_client_fixture):
     dev.samx.velocity.set(98).wait()
     dev.samy.velocity.set(101).wait()
 
-    scan = scans.grid_scan(
+    scan = getattr(scans, scan_name)(
         dev.samx,
         -5,
         5,
@@ -566,21 +591,22 @@ def test_group_def(bec_ipython_client_fixture):
 
 
 @pytest.mark.timeout(100)
-def test_list_scan(bec_ipython_client_fixture):
+@pytest.mark.parametrize("scan_name", ["list_scan", "_v4_list_scan"])
+def test_list_scan(bec_ipython_client_fixture, scan_name):
     bec = bec_ipython_client_fixture
     bec.metadata.update({"unit_test": "test_list_scan"})
     scans = bec.scans
     dev = bec.device_manager.devices
 
-    status = scans.list_scan(
+    status = getattr(scans, scan_name)(
         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 = scans.list_scan(dev.samx, [0, 1, 2, 3, 4, 5], exp_time=0.1, relative=False)
+    status = getattr(scans, scan_name)(dev.samx, [0, 1, 2, 3, 4, 5], exp_time=0.1, relative=False)
     assert len(status.scan.live_data) == 6
 
-    status = scans.list_scan(
+    status = getattr(scans, scan_name)(
         dev.samx,
         [0, 1, 2, 3],
         dev.samy,
@@ -855,7 +881,8 @@ def test_grid_scan_secondary_queue(capsys, bec_ipython_client_fixture):
 
 
 @pytest.mark.timeout(100)
-def test_scan_after_scan_lock(capsys, bec_ipython_client_fixture):
+@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
+def test_scan_after_scan_lock(capsys, bec_ipython_client_fixture, scan_name):
     """
     Test that pending scans are properly executed after a scan lock is released.
     """
@@ -864,8 +891,10 @@ def test_scan_after_scan_lock(capsys, bec_ipython_client_fixture):
     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")
-    scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.01, relative=True, hide_report=True)
-    scan2 = scans.line_scan(
+    getattr(scans, scan_name)(
+        dev.samx, -5, 5, steps=10, exp_time=0.01, relative=True, hide_report=True
+    )
+    scan2 = getattr(scans, scan_name)(
         dev.samx, -5, 5, steps=10, exp_time=0.01, relative=True, hide_report=True
     )
 
@@ -879,7 +908,8 @@ def test_scan_after_scan_lock(capsys, bec_ipython_client_fixture):
 
 
 @pytest.mark.timeout(100)
-def test_scan_repeat_decorator(bec_ipython_client_fixture):
+@pytest.mark.parametrize("scan_name", ["line_scan", "_v4_line_scan"])
+def test_scan_repeat_decorator(bec_ipython_client_fixture, scan_name):
     """
     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.
@@ -923,7 +953,9 @@ def test_scan_repeat_decorator(bec_ipython_client_fixture):
 
     @scan_repeat(max_repeats=2, exc_handler=exc_handler)
     def my_scan():
-        scans.line_scan(dev.positioner_with_failure, -5, 5, steps=10, exp_time=0.01, relative=True)
+        getattr(scans, scan_name)(
+            dev.positioner_with_failure, -5, 5, steps=10, exp_time=0.01, relative=True
+        )
 
     my_scan()
 
@@ -933,7 +965,10 @@ def test_scan_repeat_decorator(bec_ipython_client_fixture):
 
 
 @pytest.mark.timeout(100)
-def test_scan_set_completed(bec_ipython_client_fixture):
+@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):
     """
     Test that a scan can be manually set to completed.
     """
@@ -953,7 +988,9 @@ def test_scan_set_completed(bec_ipython_client_fixture):
 
     threading.Thread(target=_set_scan_completed, args=(bec,), daemon=True).start()
 
-    scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.01, relative=True)
+    getattr(scans, scan_name[0])(
+        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
-    scans.line_scan(dev.samx, -5, 5, steps=10, exp_time=0.01, relative=True)
+    getattr(scans, scan_name[1])(dev.samx, -5, 5, steps=10, exp_time=0.01, relative=True)

{bec_ipython_client-3.154.0 → bec_ipython_client-3.156.0}/tests/end-2-end/test_scans_lib_e2e.py

@@ -16,25 +16,31 @@ logger = bec_logger.logger
 
 
 @pytest.mark.timeout(100)
-def test_grid_scan_lib(bec_client_lib):
+@pytest.mark.parametrize("scan_name", [("umv", "grid_scan"), ("_v4_umv", "_v4_grid_scan")])
+def test_grid_scan_lib(bec_client_lib, scan_name):
     bec = bec_client_lib
     scans = bec.scans
     bec.metadata.update({"unit_test": "test_grid_scan_bec_client_lib"})
     dev = bec.device_manager.devices
-    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)
+    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
+    )
     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)
-def test_grid_scan_lib_cancel(bec_client_lib):
+@pytest.mark.parametrize("scan_name", ["grid_scan", "_v4_grid_scan"])
+def test_grid_scan_lib_cancel(bec_client_lib, scan_name):
     bec = bec_client_lib
     scans = bec.scans
     bec.metadata.update({"unit_test": "test_grid_scan_bec_client_lib"})
     dev = bec.device_manager.devices
-    status = scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=1, relative=False)
+    status = getattr(scans, scan_name)(
+        dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=1, relative=False
+    )
     time.sleep(0.5)
     status.cancel()
 
@@ -375,6 +381,7 @@ def test_config_reload(
         assert bec.device_manager.devices[dev].enabled is False
 
 
+@pytest.mark.timeout(100)
 def test_config_reload_with_describe_failure(bec_test_config_file_path, bec_client_lib):
     bec = bec_client_lib
     bec.metadata.update({"unit_test": "test_config_reload"})
@@ -404,34 +411,43 @@ def test_config_reload_with_describe_failure(bec_test_config_file_path, bec_clie
         },
     }
 
-    # set hexapod to fail
-    bec.connector.set(
-        f"e2e_test_hexapod_fail", messages.DeviceStatusMessage(device="hexapod", status=1)
-    )
+    try:
+        # set hexapod to fail
+        bec.connector.set(
+            "e2e_test_hexapod_fail", messages.DeviceStatusMessage(device="hexapod", status=1)
+        )
 
-    # write new config to disk
-    with open(runtime_config_file_path, "w") as f:
-        f.write(yaml.dump(config))
+        # write new config to disk
+        with open(runtime_config_file_path, "w") as f:
+            f.write(yaml.dump(config))
 
-    with pytest.raises(DeviceConfigError):
-        bec.config.update_session_with_file(runtime_config_file_path, force=True, validate=False)
+        with pytest.raises(DeviceConfigError):
+            bec.config.update_session_with_file(
+                runtime_config_file_path, force=True, validate=False
+            )
 
-    assert len(bec.device_manager.devices) == 2
-    assert bec.device_manager.devices["eyefoc"].enabled is True
-    assert bec.device_manager.devices["hexapod"].enabled is False
+        assert len(bec.device_manager.devices) == 2
+        assert bec.device_manager.devices["eyefoc"].enabled is True
+        assert bec.device_manager.devices["hexapod"].enabled is False
 
-    # set hexapod to pass
-    bec.connector.set(
-        f"e2e_test_hexapod_fail", messages.DeviceStatusMessage(device="hexapod", status=0)
-    )
+        # set hexapod to pass
+        bec.connector.set(
+            "e2e_test_hexapod_fail", messages.DeviceStatusMessage(device="hexapod", status=0)
+        )
 
-    bec.config.update_session_with_file(runtime_config_file_path, force=True)
-    assert len(bec.device_manager.devices) == 2
-    assert bec.device_manager.devices["eyefoc"].enabled is True
-    assert bec.device_manager.devices["hexapod"].enabled is True
-    assert bec.device_manager.devices["hexapod"].precision == 3
+        bec.config.update_session_with_file(runtime_config_file_path, force=True)
+        assert len(bec.device_manager.devices) == 2
+        assert bec.device_manager.devices["eyefoc"].enabled is True
+        assert bec.device_manager.devices["hexapod"].enabled is True
+        assert bec.device_manager.devices["hexapod"].precision == 3
+    finally:
+        bec.connector.set(
+            "e2e_test_hexapod_fail", messages.DeviceStatusMessage(device="hexapod", status=0)
+        )
+        bec.config.update_session_with_file(bec_test_config_file_path, force=True)
 
 
+@pytest.mark.timeout(100)
 def test_config_add_remove_device(bec_client_lib):
     bec = bec_client_lib
     bec.metadata.update({"unit_test": "test_config_add_device"})
@@ -474,6 +490,7 @@ def test_config_add_remove_device(bec_client_lib):
     assert "samx" in dev
 
 
+@pytest.mark.timeout(100)
 def test_computed_signal(bec_client_lib):
     bec = bec_client_lib
     bec.metadata.update({"unit_test": "test_computed_signal"})
@@ -494,6 +511,7 @@ def test_computed_signal(bec_client_lib):
     assert dev.pseudo_signal1.read()["pseudo_signal1"]["value"] == 5
 
 
+@pytest.mark.timeout(100)
 def test_cached_device_readout(bec_client_lib):
     bec = bec_client_lib
     bec.metadata.update({"unit_test": "test_cached_device_readout"})
@@ -532,6 +550,8 @@ 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"})