bec-ipython-client 3.64.5__py3-none-any.whl → 3.89.3__py3-none-any.whl

tests/client_tests/test_ipython_live_updates.py

@@ -7,34 +7,94 @@ from bec_lib import messages
 from bec_lib.queue_items import QueueItem
 
 
-@pytest.mark.timeout(20)
-def test_live_updates_process_queue_pending(bec_client_mock):
+@pytest.fixture
+def queue_elements(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="req_id",
+        scan_motors=["samx"],
+        report_instructions=[],
+        readout_priority={"monitored": ["samx"]},
+        is_scan=True,
+        scan_number=1,
+        scan_id="scan_id",
+    )
     queue = QueueItem(
         scan_manager=client.queue,
         queue_id="queue_id",
-        request_blocks=[request_msg],
+        request_blocks=[request_block],
         status="PENDING",
         active_request_block={},
         scan_id=["scan_id"],
     )
-    client.queue.queue_storage.current_scan_queue = {"primary": {"status": "RUNNING"}}
+    return queue, request_block, request_msg
+
+
+@pytest.fixture
+def sample_request_msg():
+    return messages.ScanQueueMessage(
+        scan_type="grid_scan",
+        parameter={"args": {"samx": (-5, 5, 3)}, "kwargs": {}},
+        queue="primary",
+        metadata={"RID": "something"},
+    )
+
+
+@pytest.fixture
+def sample_request_block(sample_request_msg):
+    return messages.RequestBlock(
+        msg=sample_request_msg,
+        RID="req_id",
+        scan_motors=["samx"],
+        report_instructions=[],
+        readout_priority={"monitored": ["samx"]},
+        is_scan=True,
+        scan_number=1,
+        scan_id="scan_id",
+    )
+
+
+@pytest.fixture
+def sample_queue_info_entry(sample_request_block):
+    return messages.QueueInfoEntry(
+        queue_id="test_queue_id",
+        scan_id=["scan_id"],
+        is_scan=[True],
+        request_blocks=[sample_request_block],
+        scan_number=[1],
+        status="RUNNING",
+        active_request_block=None,
+    )
+
+
+@pytest.fixture
+def sample_scan_queue_status(sample_queue_info_entry):
+    return messages.ScanQueueStatus(info=[sample_queue_info_entry], status="RUNNING")
+
+
+@pytest.mark.timeout(20)
+def test_live_updates_process_queue_pending(bec_client_mock, queue_elements):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+    queue, request_block, request_msg = queue_elements
+
+    client.queue.queue_storage.current_scan_queue = {
+        "primary": messages.ScanQueueStatus(info=[], status="RUNNING")
+    }
     with mock.patch.object(queue, "_update_with_buffer"):
         with mock.patch(
             "bec_lib.queue_items.QueueItem.queue_position", new_callable=mock.PropertyMock
         ) as queue_pos:
             queue_pos.return_value = 2
             with mock.patch.object(
-                live_updates,
-                "_available_req_blocks",
-                return_value=[{"report_instructions": [], "content": {"scan_type": "grid_scan"}}],
+                live_updates, "_available_req_blocks", return_value=[request_block]
             ):
                 with mock.patch.object(live_updates, "_process_report_instructions") as process:
                     with mock.patch("builtins.print") as prt:
@@ -45,39 +105,30 @@ def test_live_updates_process_queue_pending(bec_client_mock):
 
 
 @pytest.mark.timeout(20)
-def test_live_updates_process_queue_running(bec_client_mock):
+def test_live_updates_process_queue_running(bec_client_mock, queue_elements):
     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, request_msg = queue_elements
     queue = QueueItem(
         scan_manager=client.queue,
         queue_id="queue_id",
-        request_blocks=[request_msg],
+        request_blocks=[request_block],
         status="RUNNING",
         active_request_block={},
         scan_id=["scan_id"],
     )
     live_updates._active_request = request_msg
-    client.queue.queue_storage.current_scan_queue = {"primary": {"status": "RUNNING"}}
+    request_block.report_instructions = [{"wait_table": 10}]
+    client.queue.queue_storage.current_scan_queue = {
+        "primary": messages.ScanQueueStatus(info=[], status="RUNNING")
+    }
     with mock.patch.object(queue, "_update_with_buffer"):
         with mock.patch(
             "bec_lib.queue_items.QueueItem.queue_position", new_callable=mock.PropertyMock
         ) as queue_pos:
             queue_pos.return_value = 2
             with mock.patch.object(
-                live_updates,
-                "_available_req_blocks",
-                return_value=[
-                    {
-                        "report_instructions": [{"wait_table": 10}],
-                        "content": {"scan_type": "grid_scan"},
-                    }
-                ],
+                live_updates, "_available_req_blocks", return_value=[request_block]
             ):
                 with mock.patch.object(live_updates, "_process_instruction") as process:
                     with mock.patch("builtins.print") as prt:
@@ -88,37 +139,19 @@ def test_live_updates_process_queue_running(bec_client_mock):
 
 
 @pytest.mark.timeout(20)
-def test_live_updates_process_queue_without_status(bec_client_mock):
+def test_live_updates_process_queue_without_status(bec_client_mock, queue_elements):
     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"},
-    )
-    queue = QueueItem(
-        scan_manager=client.queue,
-        queue_id="queue_id",
-        request_blocks=[request_msg],
-        status=None,
-        active_request_block={},
-        scan_id=["scan_id"],
-    )
+    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
 
 
 @pytest.mark.timeout(20)
-def test_live_updates_process_queue_without_queue_number(bec_client_mock):
+def test_live_updates_process_queue_without_queue_number(bec_client_mock, queue_elements):
     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"},
-    )
+    queue, _, request_msg = queue_elements
 
     with mock.patch(
         "bec_lib.queue_items.QueueItem.queue_position", new_callable=mock.PropertyMock
@@ -136,24 +169,182 @@ def test_live_updates_process_queue_without_queue_number(bec_client_mock):
             assert live_updates._process_queue(queue, request_msg, "req_id") is False
 
 
-# @pytest.mark.timeout(20)
-# @pytest.mark.asyncio
-# def test_live_updates_process_instruction_readback(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"},
-#     )
-#     live_updates._active_request = request_msg
-#     live_updates._user_callback = []
-#     client.queue.queue_storage.current_scan_queue = {"primary": {"status": "RUNNING"}}
-#     with mock.patch(
-#         "bec_client_mock.callbacks.ipython_live_updates.LiveUpdatesTable", new_callable=mock.Co
-#     ) as table:
-#         live_updates._process_instruction({"scan_progress": 10})
-#         table.assert_called_once_with(
-#             client, report_instructions={"scan_progress": 10}, request=request_msg, callbacks=[]
-#         )
+@pytest.mark.timeout(20)
+def test_available_req_blocks(bec_client_mock, queue_elements):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+    queue, request_block, request_msg = queue_elements
+
+    # Test with matching RID
+    available_blocks = live_updates._available_req_blocks(queue, request_msg)
+    assert (
+        len(available_blocks) == 0
+    )  # request_block.RID is "req_id", request_msg.metadata["RID"] is "something"
+
+    # Test with correct RID
+    request_block.RID = "something"
+    available_blocks = live_updates._available_req_blocks(queue, request_msg)
+    assert len(available_blocks) == 1
+    assert available_blocks[0] == request_block
+
+
+@pytest.mark.timeout(20)
+def test_available_req_blocks_multiple_blocks(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": "test_rid"},
+    )
+
+    request_block1 = messages.RequestBlock(
+        msg=request_msg,
+        RID="test_rid",
+        scan_motors=["samx"],
+        report_instructions=[],
+        readout_priority={"monitored": ["samx"]},
+        is_scan=True,
+        scan_number=1,
+        scan_id="scan_id_1",
+    )
+
+    request_block2 = messages.RequestBlock(
+        msg=request_msg,
+        RID="test_rid",
+        scan_motors=["samy"],
+        report_instructions=[],
+        readout_priority={"monitored": ["samy"]},
+        is_scan=True,
+        scan_number=2,
+        scan_id="scan_id_2",
+    )
+
+    request_block3 = messages.RequestBlock(
+        msg=request_msg,
+        RID="different_rid",
+        scan_motors=["samz"],
+        report_instructions=[],
+        readout_priority={"monitored": ["samz"]},
+        is_scan=True,
+        scan_number=3,
+        scan_id="scan_id_3",
+    )
+
+    queue = QueueItem(
+        scan_manager=client.queue,
+        queue_id="queue_id",
+        request_blocks=[request_block1, request_block2, request_block3],
+        status="RUNNING",
+        active_request_block={},
+        scan_id=["scan_id_1", "scan_id_2", "scan_id_3"],
+    )
+
+    available_blocks = live_updates._available_req_blocks(queue, request_msg)
+    assert len(available_blocks) == 2
+    assert request_block1 in available_blocks
+    assert request_block2 in available_blocks
+    assert request_block3 not in available_blocks
+
+
+@pytest.mark.timeout(20)
+def test_element_in_queue_no_queue(bec_client_mock):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    # Test when client.queue is None
+    client.queue = None
+    assert live_updates._element_in_queue() is False
+
+
+@pytest.mark.timeout(20)
+def test_element_in_queue_no_current_scan_queue(bec_client_mock):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    # Test when current_scan_queue is None
+    client.queue.queue_storage.current_scan_queue = None
+    assert live_updates._element_in_queue() is False
+
+
+@pytest.mark.timeout(20)
+def test_element_in_queue_no_primary_queue(bec_client_mock):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    # Test when primary queue doesn't exist
+    scan_queue_status = messages.ScanQueueStatus(info=[], status="RUNNING")
+    client.queue.queue_storage.current_scan_queue = {"secondary": scan_queue_status}
+    assert live_updates._element_in_queue() is False
+
+
+@pytest.mark.timeout(20)
+def test_element_in_queue_no_queue_info(bec_client_mock):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    # Test when queue_info is empty
+    scan_queue_status = messages.ScanQueueStatus(info=[], status="RUNNING")
+    client.queue.queue_storage.current_scan_queue = {"primary": scan_queue_status}
+    assert live_updates._element_in_queue() is False
+
+
+@pytest.mark.timeout(20)
+def test_element_in_queue_no_current_queue(bec_client_mock, sample_scan_queue_status):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    # Test when _current_queue is None
+    live_updates._current_queue = None
+    client.queue.queue_storage.current_scan_queue = {"primary": sample_scan_queue_status}
+    assert live_updates._element_in_queue() is False
+
+
+@pytest.mark.timeout(20)
+def test_element_in_queue_queue_id_not_in_info(bec_client_mock, sample_request_block):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    # Test when queue_id is not in info
+    current_queue = mock.MagicMock()
+    current_queue.queue_id = "my_queue_id"
+    live_updates._current_queue = current_queue
+
+    queue_info_entry = messages.QueueInfoEntry(
+        queue_id="different_queue_id",
+        scan_id=["scan_id"],
+        is_scan=[True],
+        request_blocks=[sample_request_block],
+        scan_number=[1],
+        status="RUNNING",
+        active_request_block=None,
+    )
+    scan_queue_status = messages.ScanQueueStatus(info=[queue_info_entry], status="RUNNING")
+    client.queue.queue_storage.current_scan_queue = {"primary": scan_queue_status}
+    assert live_updates._element_in_queue() is False
+
+
+@pytest.mark.timeout(20)
+def test_element_in_queue_queue_id_in_info(bec_client_mock, sample_request_block):
+    client = bec_client_mock
+    live_updates = IPythonLiveUpdates(client)
+
+    # Test when queue_id is in info (should return True)
+    current_queue = mock.MagicMock()
+    current_queue.queue_id = "my_queue_id"
+    live_updates._current_queue = current_queue
+
+    queue_info_entry = messages.QueueInfoEntry(
+        queue_id="my_queue_id",
+        scan_id=["scan_id"],
+        is_scan=[True],
+        request_blocks=[sample_request_block],
+        scan_number=[1],
+        status="RUNNING",
+        active_request_block=None,
+    )
+    scan_queue_status = messages.ScanQueueStatus(info=[queue_info_entry], status="RUNNING")
+    client.queue.queue_storage.current_scan_queue = {"primary": scan_queue_status}
+    assert live_updates._element_in_queue() is True

tests/client_tests/test_live_table.py

@@ -107,11 +107,12 @@ class TestLiveTable:
     )
     def test_get_devices_from_scan_data(self, bec_client_mock, request_msg, scan_report_devices):
         client = bec_client_mock
-        client.start()
         data = messages.ScanMessage(
             point_id=0, scan_id="", data={}, metadata={"scan_report_devices": scan_report_devices}
         )
-        live_update = LiveUpdatesTable(client, {"scan_progress": 10}, request_msg)
+        live_update = LiveUpdatesTable(
+            client, {"scan_progress": {"points": 10, "show_table": True}}, request_msg
+        )
         devices = live_update.get_devices_from_scan_data(data)
         assert devices[0 : len(scan_report_devices)] == scan_report_devices
 
@@ -123,7 +124,9 @@ class TestLiveTable:
         )
         client.queue.request_storage.update_with_request(request_msg)
         client.queue.request_storage.update_with_response(response_msg)
-        live_update = LiveUpdatesTable(client, {"scan_progress": 10}, request_msg)
+        live_update = LiveUpdatesTable(
+            client, {"scan_progress": {"points": 10, "show_table": True}}, request_msg
+        )
         with mock.patch.object(client.queue.queue_storage, "find_queue_item_by_requestID"):
             live_update.wait_for_request_acceptance()
 
@@ -138,7 +141,9 @@ class TestLiveTable:
         client = bec_client_mock
         client.start()
         data = messages.ScanMessage(point_id=0, scan_id="", data={}, metadata={})
-        live_update = LiveUpdatesTable(client, {"scan_progress": 10}, request_msg)
+        live_update = LiveUpdatesTable(
+            client, {"scan_progress": {"points": 10, "show_table": True}}, request_msg
+        )
         live_update.scan_item = scan_item
         scan_item.num_points = 2
         scan_item.live_data = {0: data}
@@ -163,7 +168,9 @@ class TestLiveTable:
         client = bec_client_mock
         client.start()
         data = messages.ScanMessage(point_id=0, scan_id="", data={}, metadata={})
-        live_update = LiveUpdatesTable(client, {"scan_progress": 10}, request_msg)
+        live_update = LiveUpdatesTable(
+            client, {"scan_progress": {"points": 10, "show_table": True}}, request_msg
+        )
         live_update.scan_item = scan_item
         scan_item.num_points = 2
         scan_item.live_data = {0: data}
@@ -193,7 +200,9 @@ class TestLiveTable:
         )
         client.queue.request_storage.update_with_request(request_msg)
         client.queue.request_storage.update_with_response(response_msg)
-        live_update = LiveUpdatesTable(client, {"scan_progress": 10}, request_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="",
@@ -212,7 +221,9 @@ class TestLiveTable:
         )
         client.queue.request_storage.update_with_request(request_msg)
         client.queue.request_storage.update_with_response(response_msg)
-        live_update = LiveUpdatesTable(client, {"scan_progress": 10}, request_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="",
@@ -231,7 +242,9 @@ class TestLiveTable:
         )
         client.queue.request_storage.update_with_request(request_msg)
         client.queue.request_storage.update_with_response(response_msg)
-        live_update = LiveUpdatesTable(client, {"scan_progress": 10}, request_msg)
+        live_update = LiveUpdatesTable(
+            client, {"scan_progress": {"points": 10, "show_table": True}}, request_msg
+        )
         client.device_manager.devices["samx"]._info["hints"] = {"fields": ["samx_hint"]}
         client.device_manager.devices["samx"].precision = 3
         live_update.point_data = messages.ScanMessage(
@@ -263,7 +276,9 @@ class TestLiveTable:
         )
         client.queue.request_storage.update_with_request(request_msg)
         client.queue.request_storage.update_with_response(response_msg)
-        live_update = LiveUpdatesTable(client, {"scan_progress": 10}, request_msg)
+        live_update = LiveUpdatesTable(
+            client, {"scan_progress": {"points": 10, "show_table": True}}, request_msg
+        )
         client.device_manager.devices["samx"]._info["hints"] = {"fields": ["samx_hint"]}
         client.device_manager.devices["samx"].precision = prec
         live_update.point_data = messages.ScanMessage(
@@ -312,7 +327,9 @@ class TestLiveTable:
         )
         client.queue.request_storage.update_with_request(request_msg)
         client.queue.request_storage.update_with_response(response_msg)
-        live_update = LiveUpdatesTable(client, {"scan_progress": 10}, request_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="",
@@ -355,7 +372,9 @@ class TestLiveTable:
             "find_queue_item_by_requestID",
             return_value=mock_queue_item,
         ):
-            live_update = LiveUpdatesTable(client, {"scan_progress": 10}, request_msg)
+            live_update = LiveUpdatesTable(
+                client, {"scan_progress": {"points": 10, "show_table": True}}, request_msg
+            )
             live_update.wait_for_request_acceptance()
             result = StringIO()
             with redirect_stdout(result):
@@ -376,7 +395,9 @@ class TestLiveTable:
         )
         client.queue.request_storage.update_with_request(request_msg)
         client.queue.request_storage.update_with_response(response_msg)
-        live_update = LiveUpdatesTable(client, {"scan_progress": 10}, request_msg)
+        live_update = LiveUpdatesTable(
+            client, {"scan_progress": {"points": 10, "show_table": True}}, request_msg
+        )
         client.device_manager.devices["samx"]._info["hints"] = {"fields": ["samx_hint"]}
         client.device_manager.devices["samx"].precision = prec
         live_update.point_data = messages.ScanMessage(