dls-dodal 1.57.0__tar.gz → 1.58.0__tar.gz

{dls_dodal-1.57.0 → dls_dodal-1.58.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dls-dodal
-Version: 1.57.0
+Version: 1.58.0
 Summary: Ophyd devices and other utils that could be used across DLS beamlines
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>, Joseph Ware <joseph.ware@diamond.ac.uk>, Oliver Silvester <Oliver.Silvester@diamond.ac.uk>, Noemi Frisina <noemi.frisina@diamond.ac.uk>
 License:                                  Apache License

{dls_dodal-1.57.0 → dls_dodal-1.58.0}/src/dls_dodal.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dls-dodal
-Version: 1.57.0
+Version: 1.58.0
 Summary: Ophyd devices and other utils that could be used across DLS beamlines
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>, Joseph Ware <joseph.ware@diamond.ac.uk>, Oliver Silvester <Oliver.Silvester@diamond.ac.uk>, Noemi Frisina <noemi.frisina@diamond.ac.uk>
 License:                                  Apache License

{dls_dodal-1.57.0 → dls_dodal-1.58.0}/src/dls_dodal.egg-info/SOURCES.txt

@@ -143,6 +143,7 @@ src/dodal/common/watcher_utils.py
 src/dodal/common/beamlines/__init__.py
 src/dodal/common/beamlines/beamline_parameters.py
 src/dodal/common/beamlines/beamline_utils.py
+src/dodal/common/beamlines/commissioning_mode.py
 src/dodal/common/beamlines/device_helpers.py
 src/dodal/devices/__init__.py
 src/dodal/devices/aperture.py
@@ -267,6 +268,7 @@ src/dodal/devices/i13_1/merlin_controller.py
 src/dodal/devices/i18/KBMirror.py
 src/dodal/devices/i18/diode.py
 src/dodal/devices/i19/__init__.py
+src/dodal/devices/i19/backlight.py
 src/dodal/devices/i19/beamstop.py
 src/dodal/devices/i19/blueapi_device.py
 src/dodal/devices/i19/diffractometer.py
@@ -371,6 +373,7 @@ tests/common/test_watcher_utils.py
 tests/common/beamlines/__init__.py
 tests/common/beamlines/test_beamline_parameters.py
 tests/common/beamlines/test_beamline_utils.py
+tests/common/beamlines/test_commissioning_mode.py
 tests/common/beamlines/test_device_instantiation.py
 tests/devices/__init__.py
 tests/devices/test.png
@@ -466,6 +469,7 @@ tests/devices/i11/test_mythen.py
 tests/devices/i13_1/test_merlin.py
 tests/devices/i18/test_kb_mirror.py
 tests/devices/i19/__init__.py
+tests/devices/i19/test_backlight.py
 tests/devices/i19/test_beamstop.py
 tests/devices/i19/test_diffractometer.py
 tests/devices/i19/test_shutter.py

{dls_dodal-1.57.0 → dls_dodal-1.58.0}/src/dodal/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.57.0'
-__version_tuple__ = version_tuple = (1, 57, 0)
+__version__ = version = '1.58.0'
+__version_tuple__ = version_tuple = (1, 58, 0)
 
-__commit_id__ = commit_id = 'gb8eec3d54'
+__commit_id__ = commit_id = 'g52d34a5bc'

{dls_dodal-1.57.0 → dls_dodal-1.58.0}/src/dodal/beamlines/i03.py

@@ -261,6 +261,7 @@ def undulator(daq_configuration_path: str | None = None) -> Undulator:
         f"{BeamlinePrefix(BL).insertion_prefix}-MO-SERVC-01:",
         # evaluate here not as parameter default to enable post-import mocking
         id_gap_lookup_table_path=f"{daq_configuration_path or DAQ_CONFIGURATION_PATH}/lookup/BeamLine_Undulator_toGap.txt",
+        baton=baton(),
     )
 
 
@@ -333,7 +334,7 @@ def xbpm_feedback() -> XBPMFeedback:
     """Get the i03 XBPM feeback device, instantiate it if it hasn't already been.
     If this is called when already instantiated in i03, it will return the existing object.
     """
-    return XBPMFeedback(f"{PREFIX.beamline_prefix}-EA-FDBK-01:")
+    return XBPMFeedback(f"{PREFIX.beamline_prefix}-EA-FDBK-01:", baton=baton())
 
 
 @device_factory()

{dls_dodal-1.57.0 → dls_dodal-1.58.0}/src/dodal/beamlines/i04.py

@@ -1,3 +1,5 @@
+from ophyd_async.core import Reference
+
 from dodal.common.beamlines.beamline_parameters import get_beamline_parameters
 from dodal.common.beamlines.beamline_utils import (
     device_factory,
@@ -30,6 +32,7 @@ from dodal.devices.oav.oav_to_redis_forwarder import OAVToRedisForwarder
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
 from dodal.devices.robot import BartRobot
 from dodal.devices.s4_slit_gaps import S4SlitGaps
+from dodal.devices.scintillator import Scintillator
 from dodal.devices.smargon import Smargon
 from dodal.devices.synchrotron import Synchrotron
 from dodal.devices.thawer import Thawer
@@ -357,3 +360,15 @@ def pin_tip_detection() -> PinTipDetection:
     If this is called when already instantiated in i04, it will return the existing object.
     """
     return PinTipDetection(f"{PREFIX.beamline_prefix}-DI-OAV-01:")
+
+
+@device_factory()
+def scintillator() -> Scintillator:
+    """Get the i04 scintillator device, instantiate it if it hasn't already been.
+    If this is called when already instantiated in i04, it will return the existing object.
+    """
+    return Scintillator(
+        f"{PREFIX.beamline_prefix}-MO-SCIN-01:",
+        Reference(aperture_scatterguard()),
+        get_beamline_parameters(),
+    )

{dls_dodal-1.57.0 → dls_dodal-1.58.0}/src/dodal/beamlines/i19_2.py

@@ -4,6 +4,7 @@ from dodal.common.beamlines.beamline_utils import (
 from dodal.common.beamlines.beamline_utils import (
     set_beamline as set_utils_beamline,
 )
+from dodal.devices.i19.backlight import BacklightPosition
 from dodal.devices.i19.beamstop import BeamStop
 from dodal.devices.i19.blueapi_device import HutchState
 from dodal.devices.i19.diffractometer import FourCircleDiffractometer
@@ -75,3 +76,11 @@ def synchrotron() -> Synchrotron:
     If this is called when already instantiated in i19-2, it will return the existing object.
     """
     return Synchrotron()
+
+
+@device_factory()
+def backlight() -> BacklightPosition:
+    """Get the i19-2 backlight device, instantiate it if it hasn't already been.
+    If this is called when already instantiated in i19-2, it will return the existing object.
+    """
+    return BacklightPosition(prefix=f"{PREFIX.beamline_prefix}-EA-IOC-12:")

dls_dodal-1.58.0/src/dodal/common/beamlines/commissioning_mode.py

@@ -0,0 +1,33 @@
+"""Functions relating to commissioning mode.
+
+Commissioning Mode can be enabled for a production beamline when there is no
+beam. The intent is that when it is enabled, bluesky plans may be run without beam
+and plans and devices will as far as is possible behave normally.
+"""
+
+import bluesky.plan_stubs as bps
+from bluesky.utils import MsgGenerator
+from ophyd_async.core import SignalR
+
+_commissioning_signal: SignalR | None = None
+
+
+def read_commissioning_mode() -> MsgGenerator[bool]:
+    """Utility method for reading the commissioning mode state from the context
+    of a bluesky plan, where a baton may or may not be present, or
+    commissioning mode is provided by some other mechanism."""
+    if _commissioning_signal:
+        return (yield from bps.rd(_commissioning_signal))
+    else:
+        return False
+
+
+def set_commissioning_signal(signal: SignalR[bool] | None):
+    """Commissioning mode is enabled by a PV which when set enables commissioning mode.
+    This allows beamline staff to ensure that commissioning mode is disabled prior
+    to production use, via their own 'good morning' startup scripts.
+    Args:
+        signal: The signal which will be read in order to determine whether
+        commissioning mode is enabled."""
+    global _commissioning_signal
+    _commissioning_signal = signal

{dls_dodal-1.57.0 → dls_dodal-1.58.0}/src/dodal/devices/baton.py

@@ -1,6 +1,7 @@
 from typing import Annotated as A
 
 from ophyd_async.core import (
+    SignalR,
     SignalRW,
     StandardReadable,
 )
@@ -15,3 +16,6 @@ class Baton(StandardReadable, EpicsDevice):
     current_user: A[
         SignalRW[str], PvSuffix("CURRENT_USER"), Format.HINTED_UNCACHED_SIGNAL
     ]
+    commissioning: A[
+        SignalR[bool], PvSuffix("COMMISSIONING"), Format.HINTED_UNCACHED_SIGNAL
+    ]

dls_dodal-1.58.0/src/dodal/devices/i19/backlight.py

@@ -0,0 +1,17 @@
+from bluesky.protocols import Movable
+from ophyd_async.core import AsyncStatus, StandardReadable
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.common.enums import InOutUpper
+
+
+class BacklightPosition(StandardReadable, Movable[InOutUpper]):
+    """Device moves backlight to the IN or OUT position since controls side manages switching the light on/off"""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.position = epics_signal_rw(InOutUpper, f"{prefix}AD1:choiceButton")
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: InOutUpper):
+        await self.position.set(value, wait=True)

{dls_dodal-1.57.0 → dls_dodal-1.58.0}/src/dodal/devices/undulator.py

@@ -5,6 +5,7 @@ from bluesky.protocols import Movable
 from numpy import ndarray
 from ophyd_async.core import (
     AsyncStatus,
+    Reference,
     StandardReadable,
     StandardReadableFormat,
     soft_signal_r_and_setter,
@@ -15,6 +16,7 @@ from ophyd_async.epics.motor import Motor
 from dodal.common.enums import EnabledDisabledUpper
 from dodal.log import LOGGER
 
+from .baton import Baton
 from .util.lookup_tables import energy_distance_table
 
 
@@ -22,11 +24,6 @@ class AccessError(Exception):
     pass
 
 
-# Enable to allow testing when the beamline is down, do not change in production!
-TEST_MODE = False
-# will be made more generic in https://github.com/DiamondLightSource/dodal/issues/754
-
-
 # The acceptable difference, in mm, between the undulator gap and the DCM
 # energy, when the latter is converted to mm using lookup tables
 UNDULATOR_DISCREPANCY_THRESHOLD_MM = 2e-3
@@ -54,6 +51,7 @@ class Undulator(StandardReadable, Movable[float]):
         name: str = "",
         poles: int | None = None,
         length: float | None = None,
+        baton: Baton | None = None,
     ) -> None:
         """Constructor
 
@@ -64,6 +62,7 @@ class Undulator(StandardReadable, Movable[float]):
             name (str, optional): Name for device. Defaults to "".
         """
 
+        self.baton_ref = Reference(baton) if baton else None
         self.id_gap_lookup_table_path = id_gap_lookup_table_path
         with self.add_children_as_readables():
             self.gap_motor = Motor(prefix + "BLGAPMTR")
@@ -105,7 +104,8 @@ class Undulator(StandardReadable, Movable[float]):
 
     async def raise_if_not_enabled(self):
         access_level = await self.gap_access.get_value()
-        if access_level is EnabledDisabledUpper.DISABLED and not TEST_MODE:
+        commissioning_mode = await self._is_commissioning_mode_enabled()
+        if access_level is EnabledDisabledUpper.DISABLED and not commissioning_mode:
             raise AccessError("Undulator gap access is disabled. Contact Control Room")
 
     async def _set_undulator_gap(self, energy_kev: float) -> None:
@@ -124,21 +124,25 @@ class Undulator(StandardReadable, Movable[float]):
                 f"Undulator gap mismatch. {difference:.3f}mm is outside tolerance.\
                 Moving gap to nominal value, {target_gap:.3f}mm"
             )
-            if not TEST_MODE:
+            commissioning_mode = await self._is_commissioning_mode_enabled()
+            if not commissioning_mode:
                 # Only move if the gap is sufficiently different to the value from the
-                # DCM lookup table AND we're not in TEST_MODE
+                # DCM lookup table AND we're not in commissioning mode
                 await self.gap_motor.set(
                     target_gap,
                     timeout=STATUS_TIMEOUT_S,
                 )
             else:
-                LOGGER.debug("In test mode, not moving ID gap")
+                LOGGER.warning("In test mode, not moving ID gap")
         else:
             LOGGER.debug(
                 "Gap is already in the correct place for the new energy value "
                 f"{energy_kev}, no need to ask it to move"
             )
 
+    async def _is_commissioning_mode_enabled(self):
+        return self.baton_ref and await self.baton_ref().commissioning.get_value()
+
     async def _get_gap_to_match_energy(self, energy_kev: float) -> float:
         """
         get a 2d np.array from lookup table that

{dls_dodal-1.57.0 → dls_dodal-1.58.0}/src/dodal/devices/xbpm_feedback.py

@@ -1,8 +1,10 @@
 from bluesky.protocols import Triggerable
-from ophyd_async.core import AsyncStatus, Device, StrictEnum, observe_value
+from ophyd_async.core import AsyncStatus, Device, Reference, StrictEnum, observe_value
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.common.device_utils import periodic_reminder
+from dodal.devices.baton import Baton
+from dodal.log import LOGGER
 
 
 class Pause(StrictEnum):
@@ -14,15 +16,19 @@ class XBPMFeedback(Device, Triggerable):
     """The XBPM feedback device is an IOC that moves the DCM, HFM and VFM to automatically
     hold the beam into place, as measured by the XBPM sensor."""
 
-    def __init__(self, prefix: str, name: str = "") -> None:
+    def __init__(self, prefix: str, name: str = "", baton: Baton | None = None) -> None:
         self.pos_ok = epics_signal_r(float, prefix + "XBPM2POSITION_OK")
         self.pos_stable = epics_signal_r(float, prefix + "XBPM2_STABLE")
         self.pause_feedback = epics_signal_rw(Pause, prefix + "FB_PAUSE")
+        self.baton_ref = Reference(baton) if baton else None
         super().__init__(name=name)
 
     @AsyncStatus.wrap
     async def trigger(self):
-        async with periodic_reminder("Waiting for XBPM"):
-            async for value in observe_value(self.pos_stable):
-                if value:
-                    return
+        if self.baton_ref and await self.baton_ref().commissioning.get_value():
+            LOGGER.warning("Commissioning mode enabled, ignoring feedback")
+        else:
+            async with periodic_reminder("Waiting for XBPM"):
+                async for value in observe_value(self.pos_stable):
+                    if value:
+                        return

dls_dodal-1.58.0/tests/common/beamlines/test_commissioning_mode.py

@@ -0,0 +1,35 @@
+import pytest
+from bluesky import RunEngine
+from bluesky.utils import MsgGenerator
+from ophyd_async.testing import set_mock_value
+
+from dodal.common.beamlines.commissioning_mode import read_commissioning_mode
+from dodal.devices.baton import Baton
+
+
+@pytest.mark.parametrize("mode", [True, False])
+def test_read_commissioning_mode_returns_signal_status_when_signal_registered(
+    RE: RunEngine, baton_in_commissioning_mode: Baton, mode: bool
+):
+    actual_mode = False
+
+    def check_commissioning_mode() -> MsgGenerator:
+        nonlocal actual_mode
+        actual_mode = yield from read_commissioning_mode()
+
+    set_mock_value(baton_in_commissioning_mode.commissioning, mode)
+    RE(check_commissioning_mode())
+    assert actual_mode == mode
+
+
+def test_read_commissioning_mode_returns_false_when_no_signal_registered(
+    RE: RunEngine,
+):
+    actual_mode = False
+
+    def check_commissioning_mode() -> MsgGenerator:
+        nonlocal actual_mode
+        actual_mode = yield from read_commissioning_mode()
+
+    RE(check_commissioning_mode())
+    assert not actual_mode

{dls_dodal-1.57.0 → dls_dodal-1.58.0}/tests/conftest.py

@@ -1,13 +1,18 @@
 import importlib
 import os
+from collections.abc import AsyncGenerator
 from pathlib import Path
 from types import ModuleType
 from unittest.mock import patch
 
 import pytest
+from ophyd_async.core import init_devices
+from ophyd_async.testing import set_mock_value
 
 from conftest import mock_attributes_table
 from dodal.common.beamlines import beamline_parameters, beamline_utils
+from dodal.common.beamlines.commissioning_mode import set_commissioning_signal
+from dodal.devices.baton import Baton
 from dodal.devices.detector import DetectorParams
 from dodal.devices.detector.det_dim_constants import EIGER2_X_16M_SIZE
 from dodal.utils import (
@@ -61,3 +66,13 @@ def eiger_params(tmp_path: Path) -> DetectorParams:
         det_dist_to_beam_converter_path=TEST_LUT_TXT,
         detector_size_constants=EIGER2_X_16M_SIZE.det_type_string,  # type: ignore
     )
+
+
+@pytest.fixture
+async def baton_in_commissioning_mode() -> AsyncGenerator[Baton]:
+    async with init_devices(mock=True):
+        baton = Baton("BATON-01")
+    set_commissioning_signal(baton.commissioning)
+    set_mock_value(baton.commissioning, True)
+    yield baton
+    set_commissioning_signal(None)

{dls_dodal-1.57.0 → dls_dodal-1.58.0}/tests/devices/i03/test_undulator_dcm.py

@@ -7,6 +7,7 @@ from ophyd_async.core import AsyncStatus, init_devices
 from ophyd_async.testing import get_mock_put, set_mock_value
 
 from dodal.common.enums import EnabledDisabledUpper
+from dodal.devices.baton import Baton
 from dodal.devices.i03.dcm import DCM
 from dodal.devices.i03.undulator_dcm import UndulatorDCM
 from dodal.devices.undulator import AccessError, Undulator
@@ -36,12 +37,14 @@ def flush_event_loop_on_finish():
 @pytest.fixture
 async def fake_undulator_dcm() -> UndulatorDCM:
     async with init_devices(mock=True):
+        baton = Baton("BATON-01:")
         undulator = Undulator(
             "UND-01",
             name="undulator",
             poles=80,
             id_gap_lookup_table_path=TEST_BEAMLINE_UNDULATOR_TO_GAP_LUT,
             length=2.0,
+            baton=baton,
         )
         dcm = DCM("DCM-01", name="dcm")
         undulator_dcm = UndulatorDCM(
@@ -55,6 +58,12 @@ async def fake_undulator_dcm() -> UndulatorDCM:
     return undulator_dcm
 
 
+@pytest.fixture
+def undulator_in_commissioning_mode(fake_undulator_dcm: UndulatorDCM):
+    set_mock_value(fake_undulator_dcm.undulator_ref().baton_ref().commissioning, True)  # type: ignore
+    yield fake_undulator_dcm
+
+
 def test_lookup_table_paths_passed(fake_undulator_dcm: UndulatorDCM):
     assert (
         fake_undulator_dcm.undulator_ref().id_gap_lookup_table_path
@@ -100,33 +109,41 @@ async def test_if_gap_is_wrong_then_logger_info_is_called_and_gap_is_set_correct
 
 @patch("dodal.devices.util.lookup_tables.loadtxt")
 @patch("dodal.devices.undulator.LOGGER")
-@patch("dodal.devices.undulator.TEST_MODE", True)
-async def test_when_gap_access_is_not_checked_if_test_mode_enabled(
-    mock_logger: MagicMock, mock_load: MagicMock, fake_undulator_dcm: UndulatorDCM
+async def test_when_gap_access_is_not_checked_if_commissioning_mode_enabled(
+    mock_logger: MagicMock,
+    mock_load: MagicMock,
+    undulator_in_commissioning_mode: UndulatorDCM,
 ):
     set_mock_value(
-        fake_undulator_dcm.undulator_ref().gap_access, EnabledDisabledUpper.DISABLED
+        undulator_in_commissioning_mode.undulator_ref().gap_access,
+        EnabledDisabledUpper.DISABLED,
+    )
+    set_mock_value(undulator_in_commissioning_mode.undulator_ref().current_gap, 5.3)
+    set_mock_value(
+        undulator_in_commissioning_mode.dcm_ref().energy_in_kev.user_readback, 5.7
     )
-    set_mock_value(fake_undulator_dcm.undulator_ref().current_gap, 5.3)
-    set_mock_value(fake_undulator_dcm.dcm_ref().energy_in_kev.user_readback, 5.7)
 
-    set_mock_value(fake_undulator_dcm.undulator_ref().gap_motor.user_setpoint, 0.0)
-    set_mock_value(fake_undulator_dcm.undulator_ref().gap_motor.user_readback, 0.0)
+    set_mock_value(
+        undulator_in_commissioning_mode.undulator_ref().gap_motor.user_setpoint, 0.0
+    )
+    set_mock_value(
+        undulator_in_commissioning_mode.undulator_ref().gap_motor.user_readback, 0.0
+    )
 
     mock_load.return_value = np.array([[5700, 5.4606], [7000, 6.045], [9700, 6.404]])
 
-    await fake_undulator_dcm.set(6.9)
+    await undulator_in_commissioning_mode.set(6.9)
 
     assert (
-        await fake_undulator_dcm.dcm_ref().energy_in_kev.user_setpoint.get_value()
+        await undulator_in_commissioning_mode.dcm_ref().energy_in_kev.user_setpoint.get_value()
     ) == 6.9
     # Verify undulator has not been asked to move
     assert (
-        await fake_undulator_dcm.undulator_ref().gap_motor.user_setpoint.get_value()
+        await undulator_in_commissioning_mode.undulator_ref().gap_motor.user_setpoint.get_value()
     ) == 0.0
 
     mock_logger.info.assert_called()
-    mock_logger.debug.assert_called_once()
+    mock_logger.warning.assert_called_once()
 
 
 @patch("dodal.devices.util.lookup_tables.loadtxt")

dls_dodal-1.58.0/tests/devices/i19/test_backlight.py

@@ -0,0 +1,18 @@
+import pytest
+from ophyd_async.core import init_devices
+
+from dodal.common.enums import InOutUpper
+from dodal.devices.i19.backlight import BacklightPosition
+
+
+@pytest.fixture
+async def fake_backlight():
+    async with init_devices(mock=True):
+        backlight = BacklightPosition("test", "backlight")
+    return backlight
+
+
+@pytest.mark.parametrize("position", [InOutUpper.IN, InOutUpper.OUT])
+async def test_backlight_set_position(fake_backlight, position):
+    await fake_backlight.set(position)
+    assert await fake_backlight.position.get_value() == position

{dls_dodal-1.57.0 → dls_dodal-1.58.0}/tests/devices/test_baton.py

@@ -12,5 +12,6 @@ async def test_mock_baton_can_be_initialised_and_read():
         {
             "baton-current_user": partial_reading(""),
             "baton-requested_user": partial_reading(""),
+            "baton-commissioning": partial_reading(False),
         },
     )

{dls_dodal-1.57.0 → dls_dodal-1.58.0}/tests/devices/test_undulator.py

@@ -1,19 +1,25 @@
+from collections.abc import Generator
+from unittest.mock import AsyncMock, patch
+
 import numpy as np
 import pytest
 from ophyd_async.core import init_devices
 from ophyd_async.testing import (
     assert_configuration,
     assert_reading,
+    get_mock_put,
     partial_reading,
     set_mock_value,
 )
 
 from dodal.common.enums import EnabledDisabledUpper
+from dodal.devices.baton import Baton
 from dodal.devices.undulator import (
     AccessError,
     Undulator,
     _get_gap_for_energy,
 )
+from dodal.testing import patch_all_motors
 from tests.devices.test_data import (
     TEST_BEAMLINE_UNDULATOR_TO_GAP_LUT,
 )
@@ -22,16 +28,26 @@ from tests.devices.test_data import (
 @pytest.fixture
 async def undulator() -> Undulator:
     async with init_devices(mock=True):
+        baton = Baton("BATON-01")
         undulator = Undulator(
             "UND-01",
             name="undulator",
             poles=80,
             length=2.0,
             id_gap_lookup_table_path=TEST_BEAMLINE_UNDULATOR_TO_GAP_LUT,
+            baton=baton,
         )
     return undulator
 
 
+@pytest.fixture
+def undulator_in_commissioning_mode(
+    undulator: Undulator,
+) -> Generator[Undulator, None, None]:
+    set_mock_value(undulator.baton_ref().commissioning, True)  # type: ignore
+    yield undulator
+
+
 async def test_reading_includes_read_fields(undulator: Undulator):
     await assert_reading(
         undulator,
@@ -98,3 +114,36 @@ async def test_when_gap_access_is_disabled_set_then_error_is_raised(
     set_mock_value(undulator.gap_access, EnabledDisabledUpper.DISABLED)
     with pytest.raises(AccessError):
         await undulator.set(5)
+
+
+@patch(
+    "dodal.devices.undulator.energy_distance_table",
+    AsyncMock(return_value=np.array([[0, 10], [10, 20]])),
+)
+async def test_gap_access_check_disabled_and_move_inhibited_when_commissioning_mode_enabled(
+    undulator_in_commissioning_mode: Undulator,
+):
+    set_mock_value(
+        undulator_in_commissioning_mode.gap_access, EnabledDisabledUpper.DISABLED
+    )
+    await undulator_in_commissioning_mode.set(5)
+
+    get_mock_put(
+        undulator_in_commissioning_mode.gap_motor.user_setpoint
+    ).assert_not_called()
+
+
+@patch(
+    "dodal.devices.undulator.energy_distance_table",
+    AsyncMock(return_value=np.array([[0, 10], [10000, 20]])),
+)
+async def test_gap_access_check_move_not_inhibited_when_commissioning_mode_disabled(
+    undulator: Undulator,
+):
+    with patch_all_motors(undulator):
+        set_mock_value(undulator.gap_access, EnabledDisabledUpper.ENABLED)
+        await undulator.set(5)
+
+        get_mock_put(undulator.gap_motor.user_setpoint).assert_called_once_with(
+            15.0, wait=True
+        )

{dls_dodal-1.57.0 → dls_dodal-1.58.0}/tests/devices/test_xbpm_feedback.py

@@ -1,4 +1,5 @@
 import asyncio
+from collections.abc import Generator
 from unittest.mock import AsyncMock, patch
 
 import pytest
@@ -7,16 +8,26 @@ from bluesky.run_engine import RunEngine
 from ophyd_async.core import init_devices
 from ophyd_async.testing import set_mock_value
 
+from dodal.devices.baton import Baton
 from dodal.devices.xbpm_feedback import XBPMFeedback
 
 
 @pytest.fixture
 async def fake_xbpm_feedback() -> XBPMFeedback:
     async with init_devices(mock=True):
-        xbpm_feedback = XBPMFeedback("")
+        baton = Baton("BATON-01:")
+        xbpm_feedback = XBPMFeedback("", baton=baton)
     return xbpm_feedback
 
 
+@pytest.fixture
+def xbpm_feedback_in_commissioning_mode(
+    fake_xbpm_feedback,
+) -> Generator[XBPMFeedback, None, None]:
+    set_mock_value(fake_xbpm_feedback.baton_ref().commissioning, True)  # type: ignore
+    yield fake_xbpm_feedback
+
+
 def test_given_pos_stable_when_xbpm_feedback_kickoff_then_return_immediately(
     RE: RunEngine,
     fake_xbpm_feedback: XBPMFeedback,
@@ -84,3 +95,17 @@ def test_logging_while_waiting_for_XBPM(
         record.getMessage() == "Waiting for XBPM" for record in caplog.records
     )
     assert log_messages == expected_log_messages
+
+
+@patch("dodal.devices.xbpm_feedback.observe_value")
+@patch("dodal.devices.xbpm_feedback.periodic_reminder")
+def test_xbpm_feedback_does_not_wait_if_commissioning_mode_enabled(
+    mock_periodic_reminder: AsyncMock,
+    mock_observe_value: AsyncMock,
+    xbpm_feedback_in_commissioning_mode: XBPMFeedback,
+    RE: RunEngine,
+):
+    set_mock_value(xbpm_feedback_in_commissioning_mode.pos_stable, False)
+    RE(bps.trigger(xbpm_feedback_in_commissioning_mode, wait=True))
+    mock_periodic_reminder.assert_not_called()
+    mock_observe_value.assert_not_called()