bec-lib 3.151.2__tar.gz → 3.152.0__tar.gz

{bec_lib-3.151.2 → bec_lib-3.152.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bec_lib
-Version: 3.151.2
+Version: 3.152.0
 Summary: BEC library
 Project-URL: Bug Tracker, https://github.com/bec-project/bec/issues
 Project-URL: Homepage, https://github.com/bec-project/bec

{bec_lib-3.151.2 → bec_lib-3.152.0}/bec_lib/devicemanager.py

@@ -315,7 +315,9 @@ class DeviceContainer(dict):
         return list(tags)
 
     def get_software_triggered_devices(self) -> list:
-        """get a list of all devices that should receive a software trigger detectors"""
+        """
+        Get a list of all enabled devices that should receive a software trigger during a scan.
+        """
         # pylint: disable=protected-access
         devices = [
             dev for _, dev in self.items() if dev._config.get("softwareTrigger", False) is True

{bec_lib-3.151.2 → bec_lib-3.152.0}/bec_lib/messages.py

@@ -415,6 +415,8 @@ class RequestBlock(BaseModel):
         scan_number (int | None): Scan number if applicable
         scan_id (str | None): Scan ID if applicable
         report_instructions (list[dict] | None): List of report instructions for the scan, if any
+        owned_device_locks (list[str]): List of device locks owned by the request
+        pending_device_locks (list[str]): List of device locks pending for the request
 
     """
 
@@ -427,6 +429,8 @@ class RequestBlock(BaseModel):
     scan_number: int | None
     scan_id: str | None
     report_instructions: list[dict] | None = None
+    owned_device_locks: list[str] = Field(default_factory=list)
+    pending_device_locks: list[str] = Field(default_factory=list)
 
 
 class QueueInfoEntry(BaseModel):

{bec_lib-3.151.2 → bec_lib-3.152.0}/bec_lib/queue_items.py

@@ -54,6 +54,7 @@ class QueueItem:
         self.active_request_block = active_request_block
         self.scan_ids = scan_id
         self.reason = reason
+        self._lock = threading.RLock()
         if client_messages is None:
             client_messages = []
         self.client_messages = client_messages
@@ -85,6 +86,44 @@ class QueueItem:
     def status(self):
         return self._status
 
+    @threadlocked
+    def _get_device_lock_state(self) -> tuple[list[str], list[str]]:
+        """
+        Return a snapshot of owned and pending device locks.
+
+        Returns:
+            tuple[list[str], list[str]]: A tuple containing two lists:
+                - The first list contains the names of devices whose locks are currently owned.
+                - The second list contains the names of devices whose locks are pending.
+        """
+        owned_device_locks = sorted(
+            {
+                device
+                for request_block in self.request_blocks
+                for device in request_block.owned_device_locks
+            }
+        )
+        pending_device_locks = sorted(
+            {
+                device
+                for request_block in self.request_blocks
+                for device in request_block.pending_device_locks
+            }
+        )
+        return owned_device_locks, pending_device_locks
+
+    def get_device_lock_state(self) -> tuple[list[str], list[str]]:
+        """
+        Refresh and return a consistent snapshot of device-lock state.
+
+        Returns:
+            tuple[list[str], list[str]]: A tuple containing two lists:
+                - The first list contains the names of devices whose locks are currently owned.
+                - The second list contains the names of devices whose locks are pending.
+        """
+        self._update_with_buffer()
+        return self._get_device_lock_state()
+
     def _update_with_buffer(self):
         current_queue = self.scan_manager.queue_storage.current_scan_queue
         if not current_queue:
@@ -103,6 +142,7 @@ class QueueItem:
                 self.update_queue_item(queue_item.info)
                 return
 
+    @threadlocked
     def update_queue_item(self, queue_item: messages.QueueInfoEntry):
         """update the queue item"""
         self.request_blocks = queue_item.request_blocks

{bec_lib-3.151.2 → bec_lib-3.152.0}/bec_lib/redis_connector/managed_redis_connection.py

@@ -595,7 +595,9 @@ class ManagedRedisConnection:
         unsubscribe_list = []
         with self._topics_cb_lock:
             for topic in topics:
-                topics_cb = self._topics_cb[topic]
+                topics_cb = self._topics_cb.get(topic)
+                if topics_cb is None:
+                    continue
                 # remove callback from list
                 self._topics_cb[topic] = list(
                     filter(lambda item: cb and item[0]() != cb, topics_cb)
@@ -631,9 +633,16 @@ class ManagedRedisConnection:
                     self._pubsub_conn.unsubscribe(unsubscribe_list)
         else:
             with self._topics_cb_lock:
-                topics = list(self._topics_cb.keys())
-            self.unregister(topics, cb)
-            self.unregister(self._stream_subs.all_topics, cb)
+                registered_topics = list(self._topics_cb.keys())
+            direct_topics = [
+                topic for topic in registered_topics if not set("*?[]").intersection(topic)
+            ]
+            pattern_topics = [topic for topic in registered_topics if topic not in direct_topics]
+            if direct_topics:
+                self.unregister(topics=direct_topics, cb=cb)
+            if pattern_topics:
+                self.unregister(patterns=pattern_topics, cb=cb)
+            self.unregister(topics=self._stream_subs.all_topics, cb=cb)
 
     def _unregister_stream(self, topics: list[str], cb: Callable | None = None) -> bool:
         """Unregister callbacks from a list of topics. Returns true if any were removed"""

{bec_lib-3.151.2 → bec_lib-3.152.0}/bec_lib/scan_input_validator.py

@@ -13,7 +13,7 @@ from bec_lib.scan_args import ScanArgument
 from bec_lib.signature_serializer import deserialize_dtype, dict_to_signature
 
 # Internal scan kwargs that are automatically added to the scan request
-INTERNAL_SCAN_KWARGS = {"user_metadata", "system_config", "scan_queue"}
+INTERNAL_SCAN_KWARGS = {"user_metadata", "system_config", "scan_queue", "monitored", "on_request"}
 
 
 class ScanInputValidator:

{bec_lib-3.151.2 → bec_lib-3.152.0}/bec_lib/scans.py

@@ -58,6 +58,7 @@ class ScanObject:
         hide_report: bool = False,
         metadata: dict | None = None,
         monitored: list[str | DeviceBase] | None = None,
+        on_request: list[str | DeviceBase] | None = None,
         file_suffix: str | None = None,
         file_directory: str | None = None,
         scan_queue: str | None = None,
@@ -72,7 +73,8 @@ class ScanObject:
             async_callback: Asynchronous callback function
             hide_report: Hide the report
             metadata: Metadata dictionary
-            monitored: List of monitored devices
+            monitored: List of devices to be put on the readout priority `monitored`
+            on_request: List of devices to be put on the readout priority `on_request`
             file_suffix: File suffix for the scan data
             file_directory: File directory for the scan data
             scan_queue: Scan queue name. If None, the default queue will be used.
@@ -110,13 +112,25 @@ class ScanObject:
                 monitored = [monitored]
             for mon_device in monitored:
                 if isinstance(mon_device, str):
-                    mon_device = self.client.device_manager.devices.get(mon_device)
-                    if not mon_device:
+                    mon_device_obj = self.client.device_manager.devices.get(mon_device)
+                    if not mon_device_obj:
                         raise RuntimeError(
                             f"Specified monitored device {mon_device} does not exist in the current device configuration."
                         )
             kwargs["monitored"] = monitored
 
+        if on_request is not None:
+            if not isinstance(on_request, list):
+                on_request = [on_request]
+            for or_device in on_request:
+                if isinstance(or_device, str):
+                    or_device_obj = self.client.device_manager.devices.get(or_device)
+                    if not or_device_obj:
+                        raise RuntimeError(
+                            f"Specified on_request device {or_device} does not exist in the current device configuration."
+                        )
+            kwargs["on_request"] = on_request
+
         sys_config = sys_config.model_dump()
         # pylint: disable=protected-access
         if scans._scan_group:

{bec_lib-3.151.2 → bec_lib-3.152.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_lib"
-version = "3.151.2"
+version = "3.152.0"
 description = "BEC library"
 requires-python = ">=3.11"
 classifiers = [

{bec_lib-3.151.2 → bec_lib-3.152.0}/tests/test_queue_items.py

@@ -520,6 +520,73 @@ def test_queue_item_status_property(queue_item, scan_queue_status_message):
     assert queue_item._status == "pending"
 
 
+def test_queue_item_device_lock_properties(queue_item):
+    queue_item.request_blocks = [
+        messages.RequestBlock(
+            msg=messages.ScanQueueMessage(
+                queue="primary",
+                scan_type="step",
+                parameter={"args": {}, "kwargs": {}},
+                metadata={"RID": "rid_1"},
+            ),
+            RID="rid_1",
+            readout_priority={"monitored": []},
+            is_scan=True,
+            scan_number=1,
+            scan_id="scan_1",
+            owned_device_locks=["samx", "samy"],
+            pending_device_locks=["bpm4i"],
+        ),
+        messages.RequestBlock(
+            msg=messages.ScanQueueMessage(
+                queue="primary",
+                scan_type="step",
+                parameter={"args": {}, "kwargs": {}},
+                metadata={"RID": "rid_2"},
+            ),
+            RID="rid_2",
+            readout_priority={"monitored": []},
+            is_scan=True,
+            scan_number=2,
+            scan_id="scan_2",
+            owned_device_locks=["samy", "samz"],
+            pending_device_locks=["bpm4i", "bpm5i"],
+        ),
+    ]
+    queue_item.scan_manager.queue_storage.current_scan_queue = None
+
+    owned_device_locks, pending_device_locks = queue_item.get_device_lock_state()
+
+    assert owned_device_locks == ["samx", "samy", "samz"]
+    assert pending_device_locks == ["bpm4i", "bpm5i"]
+
+
+def test_queue_item_get_device_lock_state(queue_item):
+    queue_item.request_blocks = [
+        messages.RequestBlock(
+            msg=messages.ScanQueueMessage(
+                queue="primary",
+                scan_type="step",
+                parameter={"args": {}, "kwargs": {}},
+                metadata={"RID": "rid_1"},
+            ),
+            RID="rid_1",
+            readout_priority={"monitored": []},
+            is_scan=True,
+            scan_number=1,
+            scan_id="scan_1",
+            owned_device_locks=["samx", "samy"],
+            pending_device_locks=["bpm4i"],
+        )
+    ]
+    queue_item.scan_manager.queue_storage.current_scan_queue = None
+
+    owned_device_locks, pending_device_locks = queue_item.get_device_lock_state()
+
+    assert owned_device_locks == ["samx", "samy"]
+    assert pending_device_locks == ["bpm4i"]
+
+
 def test_queue_item_scans_property(queue_item, scan_queue_status_message):
     """Test scans property retrieves scan items."""
     queue_item.scan_ids = ["scan_1", "scan_2"]

{bec_lib-3.151.2 → bec_lib-3.152.0}/tests/test_redis_connector_fakeredis.py

@@ -148,6 +148,35 @@ def test_redis_connector_unregister(connected_connector):
     assert len(connector._topics_cb) == 0
 
 
+def test_redis_connector_unregister_all_for_callback(connected_connector):
+    connector = connected_connector
+    cb_mock = mock.Mock(spec=[])
+
+    connector.register(topics=["topic1"], cb=cb_mock, start_thread=False)
+    connector.register(patterns=["topic2:*"], cb=cb_mock, start_thread=False)
+    connector.register(TestStreamEndpoint, cb=cb_mock, start_thread=False)
+
+    connector.send("topic1", TestMessage(msg="topic1"))
+    connector.poll_messages(timeout=1)
+    connector.send("topic2:a", TestMessage(msg="topic2"))
+    connector.poll_messages(timeout=1)
+    connector.xadd("test", {"data": 1})
+    connector.poll_messages(timeout=1)
+    assert cb_mock.call_count == 3
+
+    cb_mock.reset_mock()
+    connector.unregister(cb=cb_mock)
+
+    connector.send("topic1", TestMessage(msg="topic1"))
+    connector.send("topic2:a", TestMessage(msg="topic2"))
+    connector.xadd("test", {"data": 2})
+    with pytest.raises(TimeoutError):
+        connector.poll_messages(timeout=1)
+    assert cb_mock.call_count == 0
+    assert len(connector._topics_cb) == 0
+    assert connector._stream_subs.all_topics == []
+
+
 def test_redis_connector_register_identical(connected_connector):
     connector = connected_connector
 

{bec_lib-3.151.2 → bec_lib-3.152.0}/tests/test_scan_object.py

@@ -115,6 +115,16 @@ def test_scan_object_v4_rejects_additional_kwargs(scan_obj_no_args, dev):
     assert "Unknown keyword argument(s) for scan: 'additional_device'" in str(exc.value)
 
 
+def test_scan_object_v4_accepts_monitored_kwarg(scan_obj_no_args):
+    scan_obj_no_args.scan_info["base_class"] = "ScanBaseV4"
+
+    with mock.patch.object(scan_obj_no_args, "_send_scan_request") as send_scan_request:
+        scan_obj_no_args._run(points=10, interval=1.5, monitored=["samx"])
+
+    sent_msg = send_scan_request.call_args.args[0]
+    assert sent_msg.parameter["kwargs"]["monitored"] == ["samx"]
+
+
 def test_scan_object_raises_signature_kwargs_type_for_arg_input_scan(scan_obj, dev):
     with pytest.raises(ScanInputValidationError, match="step': .*float or int"):
         scan_obj._run(dev.samx, -5, 5, dev.samy, -5, 5, step="bad", exp_time=0.1, relative=False)