dls-dodal 1.38.0__tar.gz → 1.39.0__tar.gz

{dls_dodal-1.38.0 → dls_dodal-1.39.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dls-dodal
-Version: 1.38.0
+Version: 1.39.0
 Summary: Ophyd devices and other utils that could be used across DLS beamlines
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>
 License:                                  Apache License
@@ -216,7 +216,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click
 Requires-Dist: ophyd
-Requires-Dist: ophyd-async>=0.9.0a1
+Requires-Dist: ophyd-async==0.9.0a1
 Requires-Dist: bluesky
 Requires-Dist: pyepics
 Requires-Dist: dataclasses-json

{dls_dodal-1.38.0 → dls_dodal-1.39.0}/pyproject.toml

@@ -15,7 +15,7 @@ description = "Ophyd devices and other utils that could be used across DLS beaml
 dependencies = [
     "click",
     "ophyd",
-    "ophyd-async >= 0.9.0a1",
+    "ophyd-async == 0.9.0a1",
     "bluesky",
     "pyepics",
     "dataclasses-json",

{dls_dodal-1.38.0 → dls_dodal-1.39.0}/src/dls_dodal.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dls-dodal
-Version: 1.38.0
+Version: 1.39.0
 Summary: Ophyd devices and other utils that could be used across DLS beamlines
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>
 License:                                  Apache License
@@ -216,7 +216,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click
 Requires-Dist: ophyd
-Requires-Dist: ophyd-async>=0.9.0a1
+Requires-Dist: ophyd-async==0.9.0a1
 Requires-Dist: bluesky
 Requires-Dist: pyepics
 Requires-Dist: dataclasses-json

{dls_dodal-1.38.0 → dls_dodal-1.39.0}/src/dls_dodal.egg-info/requires.txt

@@ -1,6 +1,6 @@
 click
 ophyd
-ophyd-async>=0.9.0a1
+ophyd-async==0.9.0a1
 bluesky
 pyepics
 dataclasses-json

{dls_dodal-1.38.0 → dls_dodal-1.39.0}/src/dodal/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.38.0'
-__version_tuple__ = version_tuple = (1, 38, 0)
+__version__ = version = '1.39.0'
+__version_tuple__ = version_tuple = (1, 39, 0)

{dls_dodal-1.38.0 → dls_dodal-1.39.0}/src/dodal/beamlines/i03.py

@@ -335,7 +335,9 @@ def synchrotron(
 
 
 def undulator(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+    wait_for_connection: bool = True,
+    fake_with_ophyd_sim: bool = False,
+    daq_configuration_path: str | None = None,
 ) -> Undulator:
     """Get the i03 undulator device, instantiate it if it hasn't already been.
     If this is called when already instantiated in i03, it will return the existing object.
@@ -347,12 +349,15 @@ def undulator(
         wait_for_connection,
         fake_with_ophyd_sim,
         bl_prefix=False,
-        id_gap_lookup_table_path="/dls_sw/i03/software/daq_configuration/lookup/BeamLine_Undulator_toGap.txt",
+        # 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",
     )
 
 
 def undulator_dcm(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+    wait_for_connection: bool = True,
+    fake_with_ophyd_sim: bool = False,
+    daq_configuration_path: str | None = None,
 ) -> UndulatorDCM:
     """Get the i03 undulator DCM device, instantiate it if it hasn't already been.
     If this is called when already instantiated in i03, it will return the existing object.
@@ -363,9 +368,14 @@ def undulator_dcm(
         prefix="",
         wait=wait_for_connection,
         fake=fake_with_ophyd_sim,
-        undulator=undulator(wait_for_connection, fake_with_ophyd_sim),
+        undulator=undulator(
+            wait_for_connection,
+            fake_with_ophyd_sim,
+            daq_configuration_path=daq_configuration_path,
+        ),
         dcm=dcm(wait_for_connection, fake_with_ophyd_sim),
-        daq_configuration_path=DAQ_CONFIGURATION_PATH,
+        # evaluate here not as parameter default to enable post-import mocking
+        daq_configuration_path=daq_configuration_path or DAQ_CONFIGURATION_PATH,
     )
 
 

{dls_dodal-1.38.0 → dls_dodal-1.39.0}/src/dodal/devices/eiger.py

@@ -62,6 +62,9 @@ class EigerDetector(Device):
     arming_status = Status()
     arming_status.set_finished()
 
+    disarming_status = Status()
+    disarming_status.set_finished()
+
     def __init__(self, beamline: str = "i03", *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.beamline = beamline
@@ -140,6 +143,7 @@ class EigerDetector(Device):
     def unstage(self) -> bool:
         assert self.detector_params is not None
         try:
+            self.disarming_status = Status()
             self.wait_on_arming_if_started()
             if self.detector_params.trigger_mode == TriggerMode.FREE_RUN:
                 # In free run mode we have to manually stop odin
@@ -158,23 +162,28 @@ class EigerDetector(Device):
                 self.timeouts.general_status_timeout
             )
             self.disable_roi_mode()
+        self.disarming_status.set_finished()
         return status_ok
 
     def stop(self, *args):
         """Emergency stop the device, mainly used to clean up after error."""
         LOGGER.info("Eiger stop() called - cleaning up...")
-        self.wait_on_arming_if_started()
-        stop_status = self.odin.stop()
-        self.odin.file_writer.start_timeout.set(1).wait(
-            self.timeouts.general_status_timeout
-        )
-        self.disarm_detector()
-        stop_status &= self.disable_roi_mode()
-        stop_status.wait(self.timeouts.general_status_timeout)
-        # See https://github.com/DiamondLightSource/hyperion/issues/1395
-        LOGGER.info("Turning off Eiger dev/shm streaming")
-        self.odin.fan.dev_shm_enable.set(0).wait()
-        LOGGER.info("Eiger has successfully been stopped")
+        if not self.disarming_status.done:
+            LOGGER.info("Eiger still disarming, waiting on disarm")
+            self.disarming_status.wait(self.timeouts.arming_timeout)
+        else:
+            self.wait_on_arming_if_started()
+            stop_status = self.odin.stop()
+            self.odin.file_writer.start_timeout.set(1).wait(
+                self.timeouts.general_status_timeout
+            )
+            self.disarm_detector()
+            stop_status &= self.disable_roi_mode()
+            stop_status.wait(self.timeouts.general_status_timeout)
+            # See https://github.com/DiamondLightSource/hyperion/issues/1395
+            LOGGER.info("Turning off Eiger dev/shm streaming")
+            self.odin.fan.dev_shm_enable.set(0).wait()
+            LOGGER.info("Eiger has successfully been stopped")
 
     def disable_roi_mode(self):
         return self.change_roi_mode(False)

{dls_dodal-1.38.0 → dls_dodal-1.39.0}/src/dodal/devices/fast_grid_scan.py

@@ -45,8 +45,19 @@ class GridAxis:
         # refering to the first position
         return self.steps_to_motor_position(self.full_steps - 1)
 
-    def is_within(self, steps):
-        return 0 <= steps <= self.full_steps
+    def is_within(self, steps: float):
+        """
+        Determine whether a single axis coordinate is within the grid.
+        The coordinate is from a continuous coordinate space based on the
+        XRC grid where the origin corresponds to the centre of the first grid box.
+
+        Args:
+            steps: The coordinate to check
+
+        Returns:
+            True if the coordinate falls within the grid.
+        """
+        return -0.5 <= steps <= self.full_steps - 0.5
 
 
 class GridScanParamsCommon(AbstractExperimentWithBeamParams):

{dls_dodal-1.38.0 → dls_dodal-1.39.0}/src/dodal/devices/i04/transfocator.py

@@ -37,32 +37,18 @@ class Transfocator(StandardReadable):
 
         super().__init__(name=name)
 
-    async def _observe_beamsize_microns(self):
-        is_set_filters_done = False
-
-        async def set_based_on_prediction(value: float):
-            if not math.isclose(
-                self.latest_pred_vertical_num_lenses, value, abs_tol=1e-8
-            ):
-                # We can only put an integer number of lenses in the beam but the
-                # calculation in the IOC returns the theoretical float number of lenses
-                nonlocal is_set_filters_done
-                value = round(value)
-                LOGGER.info(f"Transfocator setting {value} filters")
-                await self.number_filters_sp.set(value)
-                await self.start.set(1)
-                LOGGER.info("Waiting for start_rbv to change to 1")
-                await wait_for_value(self.start_rbv, 1, self.TIMEOUT)
-                LOGGER.info("Waiting for start_rbv to change to 0")
-                await wait_for_value(self.start_rbv, 0, self.TIMEOUT)
-                self.latest_pred_vertical_num_lenses = value
-                is_set_filters_done = True
-
-        # The value hasn't changed so assume the device is already set up correctly
-        async for value in observe_value(self.predicted_vertical_num_lenses):
-            await set_based_on_prediction(value)
-            if is_set_filters_done:
-                break
+    async def set_based_on_prediction(self, value: float):
+        # We can only put an integer number of lenses in the beam but the
+        # calculation in the IOC returns the theoretical float number of lenses
+        value = round(value)
+        LOGGER.info(f"Transfocator setting {value} filters")
+        await self.number_filters_sp.set(value)
+        await self.start.set(1)
+        LOGGER.info("Waiting for start_rbv to change to 1")
+        await wait_for_value(self.start_rbv, 1, self.TIMEOUT)
+        LOGGER.info("Waiting for start_rbv to change to 0")
+        await wait_for_value(self.start_rbv, 0, self.TIMEOUT)
+        self.latest_pred_vertical_num_lenses = value
 
     @AsyncStatus.wrap
     async def set(self, value: float):
@@ -81,10 +67,17 @@ class Transfocator(StandardReadable):
 
         if await self.beamsize_set_microns.get_value() != value:
             # Logic in the IOC calculates predicted_vertical_num_lenses when beam_set_microns changes
-            await asyncio.gather(
-                self.beamsize_set_microns.set(value),
-                self._observe_beamsize_microns(),
+
+            # Register an observer before setting beamsize_set_microns to ensure we don't miss changes
+            predicted_vertical_num_lenses_iterator = observe_value(
+                self.predicted_vertical_num_lenses, timeout=self.TIMEOUT
             )
+            # Keep initial prediction before setting to later compare with change after setting
+            current_prediction = await anext(predicted_vertical_num_lenses_iterator)
+            await self.beamsize_set_microns.set(value)
+            accepted_prediction = await anext(predicted_vertical_num_lenses_iterator)
+            if not math.isclose(current_prediction, accepted_prediction, abs_tol=1e-8):
+                await self.set_based_on_prediction(accepted_prediction)
 
         number_filters_rbv, vertical_lens_size_rbv = await asyncio.gather(
             self.number_filters_sp.get_value(),

{dls_dodal-1.38.0 → dls_dodal-1.39.0}/tests/devices/i04/test_transfocator.py

@@ -32,16 +32,16 @@ async def set_beamsize_to_same_value_as_mock_signal(
     await transfocator.set(value)
 
 
-@patch("dodal.devices.i04.transfocator.Transfocator._observe_beamsize_microns")
+@patch("dodal.devices.i04.transfocator.Transfocator.set_based_on_prediction")
 async def test_given_beamsize_already_set_then_when_transfocator_set_then_returns_immediately(
-    mock_observe_beamsize_microns,
+    mock_set_based_on_prediction,
     fake_transfocator: Transfocator,
 ):
     await asyncio.wait_for(
         set_beamsize_to_same_value_as_mock_signal(fake_transfocator, 100.0),
         timeout=0.01,
     )
-    mock_observe_beamsize_microns.assert_not_awaited()
+    mock_set_based_on_prediction.assert_not_awaited()
 
 
 @patch("dodal.devices.i04.transfocator.wait_for_value")
@@ -72,3 +72,11 @@ async def test_if_timeout_exceeded_and_start_rbv_not_equal_to_set_value_then_tim
         fake_transfocator.start_rbv.get_value = AsyncMock(side_effect=[0, 1])
         with pytest.raises((TimeoutError, asyncio.exceptions.TimeoutError)):
             await fake_transfocator.set(315)
+
+
+async def test_given_number_of_lenses_is_already_correct_then_transfocator_set_returns_immediately(
+    fake_transfocator: Transfocator,
+):
+    given_predicted_lenses_is_half_of_beamsize(fake_transfocator)
+    set_mock_value(fake_transfocator.predicted_vertical_num_lenses, 10)
+    await fake_transfocator.set(20)

{dls_dodal-1.38.0 → dls_dodal-1.39.0}/tests/devices/unit_tests/test_eiger.py

@@ -740,3 +740,15 @@ def test_for_other_beamlines_i03_used_as_default(params: DetectorParams):
     )
     assert fake_eiger.beamline == "ixx"
     assert fake_eiger.timeouts == AVAILABLE_TIMEOUTS["i03"]
+
+
+def test_given_eiger_is_disarming_when_eiger_is_stopped_then_wait_for_disarming_to_finish(
+    fake_eiger: EigerDetector,
+):
+    fake_eiger.disarm_detector = MagicMock()
+    fake_eiger.disarming_status = (disarming_status := MagicMock())
+    disarming_status.done = False
+    fake_eiger.stop()
+
+    disarming_status.wait.assert_called_once()
+    fake_eiger.disarm_detector.assert_not_called()

{dls_dodal-1.38.0 → dls_dodal-1.39.0}/tests/devices/unit_tests/test_gridscan.py

@@ -1,4 +1,5 @@
 from asyncio import TimeoutError, wait_for
+from contextlib import nullcontext
 from dataclasses import dataclass
 
 import numpy as np
@@ -12,6 +13,7 @@ from ophyd_async.testing import get_mock_put, set_mock_value
 
 from dodal.devices.fast_grid_scan import (
     FastGridScanCommon,
+    GridScanParamsCommon,
     PandAFastGridScan,
     PandAGridScanParams,
     ZebraFastGridScan,
@@ -246,63 +248,62 @@ def panda_grid_scan_params():
     )
 
 
-@pytest.mark.parametrize(
-    "grid_position",
-    [
-        (np.array([-1, 2, 4])),
-        (np.array([11, 2, 4])),
-        (np.array([1, 17, 4])),
-        (np.array([1, 5, 22])),
-    ],
-)
-def test_given_x_y_z_out_of_range_then_converting_to_motor_coords_raises(
-    zebra_grid_scan_params: ZebraGridScanParams,
-    panda_grid_scan_params: PandAGridScanParams,
-    grid_position,
-):
-    with pytest.raises(IndexError):
-        zebra_grid_scan_params.grid_position_to_motor_position(grid_position)
-    with pytest.raises(IndexError):
-        panda_grid_scan_params.grid_position_to_motor_position(grid_position)
-
-
-def test_given_x_y_z_of_origin_when_get_motor_positions_then_initial_positions_returned(
-    zebra_grid_scan_params: ZebraGridScanParams,
-    panda_grid_scan_params: PandAGridScanParams,
-):
-    motor_positions = [
-        zebra_grid_scan_params.grid_position_to_motor_position(np.array([0, 0, 0])),
-        panda_grid_scan_params.grid_position_to_motor_position(np.array([0, 0, 0])),
-    ]
-    assert [np.allclose(position, np.array([0, 1, 4])) for position in motor_positions]
+@pytest.fixture(params=["zebra_grid_scan_params", "panda_grid_scan_params"])
+def common_grid_scan_params(request):
+    return request.getfixturevalue(request.param)
 
 
 @pytest.mark.parametrize(
-    "grid_position, expected_x, expected_y, expected_z",
+    "grid_position, expected",
     [
-        (np.array([1, 1, 1]), 0.3, 1.2, 4.1),
-        (np.array([2, 11, 16]), 0.6, 3.2, 5.6),
-        (np.array([6, 5, 5]), 1.8, 2.0, 4.5),
+        [np.array([-1, 2, 4]), pytest.raises(IndexError)],
+        [np.array([11, 2, 4]), pytest.raises(IndexError)],
+        [np.array([1, 17, 4]), pytest.raises(IndexError)],
+        [np.array([1, 5, 22]), pytest.raises(IndexError)],
+        [np.array([0, 0, 0]), nullcontext(np.array([0, 1, 4]))],
+        [np.array([1, 1, 1]), nullcontext(np.array([0.3, 1.2, 4.1]))],
+        [np.array([2, 11, 16]), nullcontext(np.array([0.6, 3.2, 5.6]))],
+        [np.array([6, 5, 5]), nullcontext(np.array([1.8, 2.0, 4.5]))],
+        [np.array([-0.51, 5, 5]), pytest.raises(IndexError)],
+        [
+            np.array([-0.5, 5, 5]),
+            nullcontext(np.array([-0.5 * 0.3, 1 + 5 * 0.2, 4 + 5 * 0.1])),
+        ],
+        [np.array([5, -0.51, 5]), pytest.raises(IndexError)],
+        [
+            np.array([5, -0.5, 5]),
+            nullcontext(np.array([5 * 0.3, 1 - 0.5 * 0.2, 4 + 5 * 0.1])),
+        ],
+        [np.array([5, 5, -0.51]), pytest.raises(IndexError)],
+        [
+            np.array([5, 5, -0.5]),
+            nullcontext(np.array([5 * 0.3, 1 + 5 * 0.2, 4 - 0.5 * 0.1])),
+        ],
+        [np.array([9.51, 5, 5]), pytest.raises(IndexError)],
+        [
+            np.array([9.5, 5, 5]),
+            nullcontext(np.array([9.5 * 0.3, 1 + 5 * 0.2, 4 + 5 * 0.1])),
+        ],
+        [np.array([5, 14.51, 5]), pytest.raises(IndexError)],
+        [
+            np.array([5, 14.5, 5]),
+            nullcontext(np.array([5 * 0.3, 1 + 14.5 * 0.2, 4 + 5 * 0.1])),
+        ],
+        [np.array([5, 5, 19.51]), pytest.raises(IndexError)],
+        [
+            np.array([5, 5, 19.5]),
+            nullcontext(np.array([5 * 0.3, 1 + 5 * 0.2, 4 + 19.5 * 0.1])),
+        ],
     ],
 )
-def test_given_various_x_y_z_when_get_motor_positions_then_expected_positions_returned(
-    zebra_grid_scan_params: ZebraGridScanParams,
-    panda_grid_scan_params: PandAGridScanParams,
-    grid_position,
-    expected_x,
-    expected_y,
-    expected_z,
+def test_given_x_y_z_out_of_range_then_converting_to_motor_coords_raises(
+    common_grid_scan_params: GridScanParamsCommon, grid_position, expected
 ):
-    motor_positions = [
-        zebra_grid_scan_params.grid_position_to_motor_position(grid_position),
-        panda_grid_scan_params.grid_position_to_motor_position(grid_position),
-    ]
-    [
-        np.testing.assert_allclose(
-            position, np.array([expected_x, expected_y, expected_z])
+    with expected as expected_value:
+        motor_position = common_grid_scan_params.grid_position_to_motor_position(
+            grid_position
         )
-        for position in motor_positions
-    ]
+        assert np.allclose(motor_position, expected_value)
 
 
 @pytest.mark.parametrize(
@@ -333,11 +334,9 @@ def test_can_run_fast_grid_scan_in_run_engine(
 
 
 def test_given_x_y_z_steps_when_full_number_calculated_then_answer_is_as_expected(
-    zebra_grid_scan_params: ZebraGridScanParams,
-    panda_grid_scan_params: PandAGridScanParams,
+    common_grid_scan_params: GridScanParamsCommon,
 ):
-    assert zebra_grid_scan_params.get_num_images() == 350
-    assert panda_grid_scan_params.get_num_images() == 350
+    assert common_grid_scan_params.get_num_images() == 350
 
 
 @pytest.mark.parametrize(