bec-server 4.1.7__tar.gz → 4.2.0__tar.gz

{bec_server-4.1.7 → bec_server-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bec-server
-Version: 4.1.7
+Version: 4.2.0
 Summary: BEC server
 Project-URL: Bug Tracker, https://github.com/bec-project/bec/issues
 Project-URL: Homepage, https://github.com/bec-project/bec
@@ -14,7 +14,7 @@ Requires-Dist: libtmux~=0.37
 Requires-Dist: lmfit>=1.3.3,~=1.3
 Requires-Dist: msgpack~=1.0
 Requires-Dist: numpy<3.0,>=1.24
-Requires-Dist: ophyd-devices>=1.47.1
+Requires-Dist: ophyd-devices>=1.51.0
 Requires-Dist: ophyd~=1.9
 Requires-Dist: podman>=5.4
 Requires-Dist: psutil

{bec_server-4.1.7 → bec_server-4.2.0}/bec_server/device_server/device_server.py

@@ -10,7 +10,7 @@ from concurrent.futures import ThreadPoolExecutor
 from typing import TYPE_CHECKING, Any
 
 import ophyd
-from ophyd import DeviceStatus, Kind, OphydObject, Staged, StatusBase
+from ophyd import Device, DeviceStatus, Kind, OphydObject, Staged, StatusBase
 from ophyd.utils import errors as ophyd_errors
 
 from bec_lib import messages
@@ -23,7 +23,7 @@ from bec_lib.logger import bec_logger
 from bec_lib.messages import BECStatus
 from bec_lib.serialization import json_ext
 from bec_lib.utils.rpc_utils import rgetattr
-from bec_server.device_server.devices.devicemanager import DeviceManagerDS
+from bec_server.device_server.devices.devicemanager import BECMessageSignal, DeviceManagerDS
 from bec_server.device_server.friendly_device_exceptions import reformat_known_device_exceptions
 from bec_server.device_server.ophyd_callback_monitor import OphydCallbackMonitor
 from bec_server.device_server.rpc_handler import RPCHandler
@@ -566,11 +566,14 @@ class DeviceServer(BECService):
 
         """
         action = None
+        instructions = msg
         try:
-            instructions = msg
+            action = instructions.content["action"]
+            if action == "broadcast_scan_device_info" and not instructions.content["device"]:
+                self._broadcast_scan_device_info(instructions)
+                return
             if not instructions.content["device"]:
                 return
-            action = instructions.content["action"]
             self.assert_device_is_valid(instructions)
             if action != "rpc":
                 # rpc has its own error handling
@@ -595,6 +598,8 @@ class DeviceServer(BECService):
                 self._unstage_device(instructions)
             elif action == "pre_scan":
                 self._pre_scan(instructions)
+            elif action == "broadcast_scan_device_info":
+                self._broadcast_scan_device_info(instructions)
             else:
                 logger.warning(f"Received unknown device instruction: {instructions}")
         except ophyd_errors.LimitError as limit_error:
@@ -606,10 +611,10 @@ class DeviceServer(BECService):
                 exception_type=limit_error.__class__.__name__,
                 device=self.get_device_from_exception(limit_error),
             )
+
             self._ensure_request_registered(instructions)
-            self.requests_handler.set_finished(
-                instructions.metadata["device_instr_id"], success=False, error_info=error_info
-            )
+            if diid := instructions.metadata.get("device_instr_id"):
+                self.requests_handler.set_finished(diid, success=False, error_info=error_info)
 
             logger.error(content)
         except Exception as exc:  # pylint: disable=broad-except
@@ -631,9 +636,9 @@ class DeviceServer(BECService):
                 self.rpc_handler.send_rpc_exception(exc, instructions)
             else:
                 logger.error(content)
-            self.requests_handler.set_finished(
-                instructions.metadata["device_instr_id"], success=False, error_info=error_info
-            )
+
+            if diid := instructions.metadata.get("device_instr_id"):
+                self.requests_handler.set_finished(diid, success=False, error_info=error_info)
 
     @staticmethod
     def get_device_from_exception(exc: Exception) -> str | None:
@@ -1123,3 +1128,52 @@ class DeviceServer(BECService):
             self.requests_handler.add_status_object(instr.metadata["device_instr_id"], status)
 
         self.requests_handler.patch_num_status_objects(instr, num_status_objects)
+
+    def _broadcast_scan_device_info(self, instr: messages.DeviceInstructionMessage) -> None:
+        """
+        Broadcast a snapshot of device runtime information for the scan.
+
+        Args:
+            instr (messages.DeviceInstructionMessage): The request containing the devices
+                and scan ID.
+        """
+        instr_id = instr.metadata["device_instr_id"]
+        self.requests_handler.add_request(instr, num_status_objects=0)
+
+        devices = instr.content["device"]
+        if not isinstance(devices, list):
+            devices = [devices]
+
+        device_info: dict[str, messages.DeviceRuntimeInfo] = {}
+        scan_id = instr.parameter.get("scan_id")
+        if scan_id is None:
+            self.requests_handler.set_finished(instr_id, success=True)
+            return
+
+        for dev in devices:
+            if dev not in self.device_manager.devices:
+                logger.warning(f"Device {dev} not found in device manager. Skipping.")
+                continue
+            obj = self.device_manager.devices.get(dev).obj
+
+            signal_info: dict[str, messages.SignalInfo] = {}
+            if isinstance(obj, Device):
+                for _, sub_name, item in obj.walk_signals():
+                    if not isinstance(item, BECMessageSignal):
+                        continue
+                    signal_info[sub_name] = item.signal_info
+
+            if not signal_info:
+                continue
+            device_info[dev] = messages.DeviceRuntimeInfo(signal_info=signal_info)
+
+        self.connector.xadd(
+            MessageEndpoints.scan_device_info(),
+            {
+                "data": messages.ScanDeviceInfoMessage(
+                    devices=device_info, scan_id=scan_id, metadata=instr.metadata
+                )
+            },
+            max_size=10,
+        )
+        self.requests_handler.set_finished(instr_id, success=True)

{bec_server-4.1.7 → bec_server-4.2.0}/bec_server/scan_server/direct_scan_worker.py

@@ -87,6 +87,7 @@ class DirectScanWorker:
                         raise ScanAbortion(f"Scan is missing required method: {step}")
                     self.check_for_interruption()
                     method()
+                    self.run_post_scan_step(step, scan)
         except ScanAbortion as exc:
             if not self._prepare_exception_cleanup(queue, exc):
                 return
@@ -272,3 +273,14 @@ class DirectScanWorker:
         self.worker.parent.queue_manager.queues[self.worker.queue_name].abort()
         self.reset()
         self.worker.status = InstructionQueueStatus.RUNNING
+
+    def run_post_scan_step(self, step: str, scan: ScanBase) -> None:
+        """
+        Run the post-scan step for the given scan step.
+
+        Args:
+            step (str): The scan step to run the post-scan method for.
+            scan (ScanBase): The scan object to run the post-scan method on.
+        """
+        if step == "stage":
+            scan.actions._broadcast_scan_device_info()

{bec_server-4.1.7 → bec_server-4.2.0}/bec_server/scan_server/scans/scan_actions.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import functools
 import os
-import time
 import uuid
 from collections.abc import Iterable
 from string import Template
@@ -1529,3 +1528,23 @@ class ScanActions:
             raise ValueError(
                 f"Invalid template variable: {exc} in the file base path. Please check your service config."
             ) from exc
+
+    def _broadcast_scan_device_info(self) -> None:
+        """
+        Emit a device instruction to capture runtime information for this scan.
+        All currently locked devices will be included in this update.
+
+        Note that this is an internal method and should not be called directly by scan implementations.
+        """
+        devices = self.get_owned_device_locks()
+        if not self._scan.is_scan or self._scan.scan_info.scan_id is None:
+            return
+        status = self._create_status(name="broadcast_scan_device_info")
+        instr = messages.DeviceInstructionMessage(
+            device=devices,
+            action="broadcast_scan_device_info",
+            parameter={"scan_id": self._scan.scan_info.scan_id},
+            metadata={"device_instr_id": status._device_instr_id},
+        )
+        self._send(instr)
+        status.wait()

{bec_server-4.1.7 → bec_server-4.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec-server"
-version = "4.1.7"
+version = "4.2.0"
 description = "BEC server"
 requires-python = ">=3.11"
 classifiers = [
@@ -20,7 +20,7 @@ dependencies = [
     "msgpack~=1.0",
     "numpy>=1.24, <3.0",
     "ophyd~=1.9",
-    "ophyd_devices>=1.47.1",
+    "ophyd_devices>=1.51.0",
     "podman>=5.4",
     "psutil",
     "pydantic~=2.8",

{bec_server-4.1.7 → bec_server-4.2.0}/tests/tests_device_server/test_device_server.py

@@ -7,9 +7,10 @@ from unittest.mock import ANY, patch
 import numpy as np
 import pytest
 from loguru import logger
-from ophyd import Device, DeviceStatus, Kind, Staged
+from ophyd import Component as Cpt
+from ophyd import Device, DeviceStatus, Kind, Signal, Staged
 from ophyd.utils import errors as ophyd_errors
-from ophyd_devices import StatusBase
+from ophyd_devices import PreviewSignal, StatusBase
 
 from bec_lib import messages
 from bec_lib.alarm_handler import Alarms
@@ -1026,6 +1027,190 @@ def test_handle_device_instructions_rpc(device_server_mock, instructions):
                     update_device_metadata_mock.assert_called_once_with(instructions)
 
 
+@pytest.mark.parametrize("device", ["samx", []])
+def test_handle_device_instructions_broadcast_scan_device_info(device_server_mock, device):
+    instructions = messages.DeviceInstructionMessage(
+        device=device,
+        action="broadcast_scan_device_info",
+        parameter={"scan_id": "scan-id-1"},
+        metadata={"RID": "rid-1", "device_instr_id": "broadcast-diid"},
+    )
+
+    with mock.patch.object(
+        device_server_mock,
+        "assert_device_is_valid",
+        wraps=device_server_mock.assert_device_is_valid,
+    ) as valid_mock:
+        with mock.patch.object(
+            device_server_mock,
+            "assert_device_is_enabled",
+            wraps=device_server_mock.assert_device_is_enabled,
+        ) as enabled_mock:
+            with mock.patch.object(
+                device_server_mock, "_broadcast_scan_device_info"
+            ) as broadcast_mock:
+                device_server_mock.handle_device_instructions(instructions)
+
+    broadcast_mock.assert_called_once_with(instructions)
+    if device:
+        valid_mock.assert_called_once_with(instructions)
+        enabled_mock.assert_called_once_with(instructions)
+    else:
+        valid_mock.assert_not_called()
+        enabled_mock.assert_not_called()
+
+
+def test_broadcast_scan_device_info_publishes_device_records(device_server_mock):
+    class Detector(Device):
+        preview = Cpt(PreviewSignal, ndim=2)
+        plain = Cpt(Signal, value=0)
+
+    detector = Detector(name="eiger")
+    detector.preview.signal_info.acquisition_group = "fly-scan"
+    detector.preview.signal_info.use_alias = True
+    detector.preview.signal_info.signal_metadata["processing"] = {"rotation": 90}
+    expected_info = detector.preview.signal_info
+
+    device_server_mock.device_manager.devices = {
+        "eiger": SimpleNamespace(obj=detector),
+        "samx": SimpleNamespace(obj=Signal(name="samx", value=0)),
+    }
+    device_server_mock.connector.xadd = mock.MagicMock()
+    instructions = messages.DeviceInstructionMessage(
+        device=["eiger", "samx"],
+        action="broadcast_scan_device_info",
+        parameter={"scan_id": "scan-id-1"},
+        metadata={"RID": "rid-1", "device_instr_id": "broadcast-diid"},
+    )
+
+    with mock.patch.object(device_server_mock.connector, "send") as send_mock:
+        device_server_mock._broadcast_scan_device_info(instructions)
+
+    device_server_mock.connector.xadd.assert_called_once()
+    endpoint, payload = device_server_mock.connector.xadd.call_args.args
+    msg = payload["data"]
+    assert endpoint == MessageEndpoints.scan_device_info()
+    assert device_server_mock.connector.xadd.call_args.kwargs == {"max_size": 10}
+    assert msg == messages.ScanDeviceInfoMessage(
+        scan_id="scan-id-1",
+        devices={"eiger": messages.DeviceRuntimeInfo(signal_info={"preview": expected_info})},
+        metadata={"RID": "rid-1", "device_instr_id": "broadcast-diid"},
+    )
+    responses = [call.args[1] for call in send_mock.call_args_list]
+    assert [response.status for response in responses] == ["running", "completed"]
+    assert all(response.instruction_id == "broadcast-diid" for response in responses)
+    assert all(response.instruction == instructions for response in responses)
+    assert device_server_mock.requests_handler.get_request("broadcast-diid") is None
+
+
+def test_broadcast_scan_device_info_uses_runtime_metadata(device_server_mock):
+    class SubDetector(Device):
+        preview = Cpt(PreviewSignal, ndim=2)
+
+    class Detector(Device):
+        sub = Cpt(SubDetector)
+        plain = Cpt(Signal, value=0)
+
+    detector = Detector(name="eiger")
+    signal = detector.sub.preview
+    runtime_info = messages.SignalInfo(
+        saved=False,
+        ndim=2,
+        role="preview",
+        enabled=False,
+        use_alias=True,
+        signals=[("image", Kind.hinted.value)],
+        signal_metadata={"units": "counts", "processing": {"rotation": 90}},
+        correlation_group="fly-scan",
+    )
+    signal.signal_info = runtime_info
+    signal.describe = mock.Mock(side_effect=AssertionError("Use the live signal_info model"))
+
+    device_server_mock.device_manager.devices = {"eiger": SimpleNamespace(obj=detector)}
+    device_server_mock.connector.xadd = mock.MagicMock()
+    instructions = messages.DeviceInstructionMessage(
+        device="eiger",
+        action="broadcast_scan_device_info",
+        parameter={"scan_id": "scan-id-1"},
+        metadata={"device_instr_id": "broadcast-diid"},
+    )
+
+    device_server_mock._broadcast_scan_device_info(instructions)
+
+    msg = device_server_mock.connector.xadd.call_args.args[1]["data"]
+    snapshot = msg.devices["eiger"].signal_info["sub.preview"]
+    assert snapshot == runtime_info
+    assert snapshot is runtime_info
+
+
+@pytest.mark.parametrize("devices", [[], ["samx"], ["samx", "empty"]])
+def test_broadcast_scan_device_info_omits_empty_devices(device_server_mock, devices):
+    class EmptyDetector(Device):
+        plain = Cpt(Signal, value=0)
+
+    device_server_mock.device_manager.devices = {
+        "samx": SimpleNamespace(obj=Signal(name="samx", value=0), enabled=True),
+        "empty": SimpleNamespace(obj=EmptyDetector(name="empty"), enabled=True),
+    }
+    device_server_mock.connector.xadd = mock.MagicMock()
+    instructions = messages.DeviceInstructionMessage(
+        device=devices,
+        action="broadcast_scan_device_info",
+        parameter={"scan_id": "scan-id-1"},
+        metadata={"RID": "rid-1", "device_instr_id": "broadcast-diid"},
+    )
+
+    with mock.patch.object(device_server_mock.connector, "send") as send_mock:
+        device_server_mock.handle_device_instructions(instructions)
+
+    device_server_mock.connector.xadd.assert_called_once()
+    endpoint, payload = device_server_mock.connector.xadd.call_args.args
+    assert endpoint == MessageEndpoints.scan_device_info()
+    assert payload["data"] == messages.ScanDeviceInfoMessage(
+        scan_id="scan-id-1", devices={}, metadata=instructions.metadata
+    )
+    assert [call.args[1].status for call in send_mock.call_args_list] == ["running", "completed"]
+    assert device_server_mock.requests_handler.get_request("broadcast-diid") is None
+
+
+def test_broadcast_scan_device_info_resolves_failure_when_publish_raises(device_server_mock):
+    instructions = messages.DeviceInstructionMessage(
+        device=[],
+        action="broadcast_scan_device_info",
+        parameter={"scan_id": "scan-id-1"},
+        metadata={"RID": "rid-1", "device_instr_id": "broadcast-diid"},
+    )
+    device_server_mock.connector.xadd = mock.MagicMock(side_effect=RuntimeError("publish failed"))
+
+    with mock.patch.object(device_server_mock.connector, "send") as send_mock:
+        device_server_mock.handle_device_instructions(instructions)
+
+    responses = [call.args[1] for call in send_mock.call_args_list]
+    assert [response.status for response in responses] == ["running", "error"]
+    assert responses[-1].error_info.exception_type == "RuntimeError"
+    assert device_server_mock.requests_handler.get_request("broadcast-diid") is None
+
+
+def test_broadcast_scan_device_info_skips_without_scan_id(device_server_mock):
+    device_server_mock.connector.xadd = mock.MagicMock()
+    instructions = messages.DeviceInstructionMessage(
+        device="samx",
+        action="broadcast_scan_device_info",
+        parameter={},
+        metadata={"RID": "rid-1", "device_instr_id": "broadcast-diid"},
+    )
+
+    with mock.patch.object(device_server_mock.connector, "send") as send_mock:
+        device_server_mock._broadcast_scan_device_info(instructions)
+
+    device_server_mock.connector.xadd.assert_not_called()
+    responses = [call.args[1] for call in send_mock.call_args_list]
+    assert [response.status for response in responses] == ["running", "completed"]
+    assert all(response.instruction_id == "broadcast-diid" for response in responses)
+    assert all(response.instruction == instructions for response in responses)
+    assert device_server_mock.requests_handler.get_request("broadcast-diid") is None
+
+
 @pytest.mark.parametrize(
     "instructions",
     [

{bec_server-4.1.7 → bec_server-4.2.0}/tests/tests_scan_server/scans/test_scan_actions.py

@@ -442,6 +442,56 @@ def test_device_instruction_actions_emit_expected_messages(action_context):
     assert unstage_msg.metadata["device_instr_id"] == unstage_status._device_instr_id
 
 
+def test_broadcast_scan_device_info_emits_owned_devices(action_context):
+    ctx = action_context()
+    ctx.scan.scan_info.metadata["RID"] = "rid-123"
+    ctx.device_manager.parent.device_lock_registry = mock.MagicMock()
+    ctx.device_manager.parent.device_lock_registry.get_owned_devices.return_value = ["samy", "samx"]
+    status = mock.MagicMock(_device_instr_id="diid-123")
+    ctx.actions._create_status = mock.MagicMock(return_value=status)
+
+    ctx.actions._broadcast_scan_device_info()
+
+    msg = _last_device_instruction(ctx, "broadcast_scan_device_info")
+    assert msg.device == ["samx", "samy"]
+    assert msg.parameter == {"scan_id": "scan-id-test"}
+    assert msg.metadata["device_instr_id"] == "diid-123"
+    assert msg.metadata["RID"] == "rid-123"
+    assert msg.metadata["scan_id"] == "scan-id-test"
+    status.wait.assert_called_once_with()
+
+
+def test_broadcast_scan_device_info_emits_without_owned_devices(action_context):
+    ctx = action_context()
+    ctx.scan.scan_info.metadata["RID"] = "rid-123"
+    ctx.device_manager.parent.device_lock_registry = mock.MagicMock()
+    ctx.device_manager.parent.device_lock_registry.get_owned_devices.return_value = []
+    status = mock.MagicMock(_device_instr_id="diid-empty")
+    ctx.actions._create_status = mock.MagicMock(return_value=status)
+
+    ctx.actions._broadcast_scan_device_info()
+
+    msg = _last_device_instruction(ctx, "broadcast_scan_device_info")
+    assert msg.device == []
+    assert msg.parameter == {"scan_id": "scan-id-test"}
+    assert msg.metadata["device_instr_id"] == "diid-empty"
+    status.wait.assert_called_once_with()
+
+
+@pytest.mark.parametrize(("is_scan", "scan_id"), [(False, "scan-id-test"), (True, None)])
+def test_broadcast_scan_device_info_skips_when_not_scan_or_missing_scan_id(
+    action_context, is_scan, scan_id
+):
+    ctx = action_context()
+    ctx.scan.is_scan = is_scan
+    ctx.scan.scan_info.scan_id = scan_id
+    ctx.actions._send = mock.MagicMock()
+
+    ctx.actions._broadcast_scan_device_info()
+
+    ctx.actions._send.assert_not_called()
+
+
 def test_device_instruction_actions_use_dotted_name_for_nested_devices(action_context):
     ctx = action_context()
     setpoint = ctx.device_manager.devices.samx.setpoint

{bec_server-4.1.7 → bec_server-4.2.0}/tests/tests_scan_server/test_direct_scan_worker.py

@@ -173,6 +173,7 @@ def make_scan(direct_worker_context):
         scan.scan_info.metadata["RID"] = "rid-1"
         scan.actions._send_scan_status = mock.MagicMock()
         scan.actions.send_client_info = mock.MagicMock()
+        scan.actions._broadcast_scan_device_info = mock.MagicMock()
         scan._shutdown_event = mock.MagicMock()
         return scan
 
@@ -301,6 +302,22 @@ def test_run_executes_full_scan_sequence_in_order(direct_worker_context, make_sc
     assert direct_worker_context.direct_worker.scan is None
 
 
+def test_run_broadcasts_scan_device_info_after_stage(direct_worker_context, make_scan):
+    called_steps = []
+    scan = make_scan(called_steps=called_steps)
+    direct_worker_context.queue.active_scan = scan
+    direct_worker_context.scan_worker.current_instruction_queue_item = direct_worker_context.queue
+    direct_worker_context.device_manager._rpc_method = mock.MagicMock(return_value=mock.MagicMock())
+    scan.actions._broadcast_scan_device_info = mock.MagicMock(
+        side_effect=lambda: called_steps.append("broadcast_scan_device_info")
+    )
+
+    direct_worker_context.direct_worker.run(scan)
+
+    scan.actions._broadcast_scan_device_info.assert_called_once_with()
+    assert called_steps[:4] == ["prepare_scan", "open_scan", "stage", "broadcast_scan_device_info"]
+
+
 def test_run_initializes_scan_before_scan_sequence(direct_worker_context, make_scan):
     called_steps = []
     scan = make_scan(called_steps=called_steps)