dls-dodal 1.31.0__tar.gz → 1.32.0__tar.gz

{dls_dodal-1.31.0 → dls_dodal-1.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dls-dodal
-Version: 1.31.0
+Version: 1.32.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.5.2
+Requires-Dist: ophyd-async<0.7,>=0.6
 Requires-Dist: bluesky
 Requires-Dist: pyepics
 Requires-Dist: dataclasses-json
@@ -232,6 +232,7 @@ Requires-Dist: numpy<2.0
 Requires-Dist: aiofiles
 Requires-Dist: aiohttp
 Requires-Dist: redis
+Requires-Dist: deepdiff
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: diff-cover; extra == "dev"

{dls_dodal-1.31.0 → dls_dodal-1.32.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.5.2",
+    "ophyd-async>=0.6,<0.7",
     "bluesky",
     "pyepics",
     "dataclasses-json",
@@ -31,6 +31,7 @@ dependencies = [
     "aiofiles",
     "aiohttp",
     "redis",
+    "deepdiff",
 ]
 
 dynamic = ["version"]

{dls_dodal-1.31.0 → dls_dodal-1.32.0}/src/dls_dodal.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dls-dodal
-Version: 1.31.0
+Version: 1.32.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.5.2
+Requires-Dist: ophyd-async<0.7,>=0.6
 Requires-Dist: bluesky
 Requires-Dist: pyepics
 Requires-Dist: dataclasses-json
@@ -232,6 +232,7 @@ Requires-Dist: numpy<2.0
 Requires-Dist: aiofiles
 Requires-Dist: aiohttp
 Requires-Dist: redis
+Requires-Dist: deepdiff
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: diff-cover; extra == "dev"

{dls_dodal-1.31.0 → dls_dodal-1.32.0}/src/dls_dodal.egg-info/SOURCES.txt

@@ -321,6 +321,8 @@ tests/test_data/test_beamline_parameters.txt
 tests/test_data/test_det_dist_converter.txt
 tests/test_data/topup_long_delay.txt
 tests/test_data/topup_short_params.txt
+tests/test_data/test_images/oav_snapshot_expected.png
+tests/test_data/test_images/oav_snapshot_test.png
 tests/unit_tests/__init__.py
 tests/unit_tests/test_cli.py
 tests/unit_tests/test_log.py

{dls_dodal-1.31.0 → dls_dodal-1.32.0}/src/dls_dodal.egg-info/requires.txt

@@ -1,6 +1,6 @@
 click
 ophyd
-ophyd-async>=0.5.2
+ophyd-async<0.7,>=0.6
 bluesky
 pyepics
 dataclasses-json
@@ -16,6 +16,7 @@ numpy<2.0
 aiofiles
 aiohttp
 redis
+deepdiff
 
 [dev]
 black

{dls_dodal-1.31.0 → dls_dodal-1.32.0}/src/dodal/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.31.0'
-__version_tuple__ = version_tuple = (1, 31, 0)
+__version__ = version = '1.32.0'
+__version_tuple__ = version_tuple = (1, 32, 0)

{dls_dodal-1.31.0 → dls_dodal-1.32.0}/src/dodal/beamlines/i04.py

@@ -308,6 +308,7 @@ def undulator(
         wait_for_connection,
         fake_with_ophyd_sim,
         bl_prefix=False,
+        id_gap_lookup_table_path="/dls_sw/i04/software/gda/config/lookupTables/BeamLine_Undulator_toGap.txt",
     )
 
 

{dls_dodal-1.31.0 → dls_dodal-1.32.0}/src/dodal/beamlines/i22.py

@@ -199,6 +199,7 @@ def undulator(
         bl_prefix=False,
         poles=80,
         length=2.0,
+        id_gap_lookup_table_path="/dls_sw/i22/software/daq_configuration/lookup/BeamLine_Undulator_toGap.txt",
     )
 
 

{dls_dodal-1.31.0 → dls_dodal-1.32.0}/src/dodal/devices/aperturescatterguard.py

@@ -220,15 +220,15 @@ class ApertureScatterguard(StandardReadable, Movable):
                 self.aperture.y.set(aperture_y),
                 self.aperture.z.set(aperture_z),
             )
-            return
-        await asyncio.gather(
-            self.aperture.x.set(aperture_x),
-            self.aperture.y.set(aperture_y),
-            self.aperture.z.set(aperture_z),
-        )
+        else:
+            await asyncio.gather(
+                self.aperture.x.set(aperture_x),
+                self.aperture.y.set(aperture_y),
+                self.aperture.z.set(aperture_z),
+            )
 
-        await asyncio.gather(
-            self.scatterguard.x.set(scatterguard_x),
-            self.scatterguard.y.set(scatterguard_y),
-        )
+            await asyncio.gather(
+                self.scatterguard.x.set(scatterguard_x),
+                self.scatterguard.y.set(scatterguard_y),
+            )
         await self.selected_aperture.set(value)

{dls_dodal-1.31.0 → dls_dodal-1.32.0}/src/dodal/devices/areadetector/plugins/MJPG.py

@@ -87,11 +87,12 @@ class MJPG(Device, ABC):
 
 
 class SnapshotWithBeamCentre(MJPG):
-    """A child of MJPG which, when triggered, draws a crosshair at the beam centre in the
-    image and saves the image to disk."""
+    """A child of MJPG which, when triggered, draws an outlined crosshair at the beam
+    centre in the image and saves the image to disk."""
 
     CROSSHAIR_LENGTH_PX = 20
-    CROSSHAIR_COLOUR = "Blue"
+    CROSSHAIR_OUTLINE_COLOUR = "Black"
+    CROSSHAIR_FILL_COLOUR = "White"
 
     def post_processing(self, image: Image.Image):
         assert (
@@ -100,15 +101,38 @@ class SnapshotWithBeamCentre(MJPG):
         beam_x = self.oav_params.beam_centre_i
         beam_y = self.oav_params.beam_centre_j
 
+        SnapshotWithBeamCentre.draw_crosshair(image, beam_x, beam_y)
+
+        self._save_image(image)
+
+    @classmethod
+    def draw_crosshair(cls, image: Image.Image, beam_x: int, beam_y: int):
         draw = ImageDraw.Draw(image)
-        HALF_LEN = self.CROSSHAIR_LENGTH_PX / 2
+        OUTLINE_WIDTH = 1
+        HALF_LEN = cls.CROSSHAIR_LENGTH_PX / 2
+        draw.rectangle(
+            [
+                beam_x - OUTLINE_WIDTH,
+                beam_y - HALF_LEN - OUTLINE_WIDTH,
+                beam_x + OUTLINE_WIDTH,
+                beam_y + HALF_LEN + OUTLINE_WIDTH,
+            ],
+            fill=cls.CROSSHAIR_OUTLINE_COLOUR,
+        )
+        draw.rectangle(
+            [
+                beam_x - HALF_LEN - OUTLINE_WIDTH,
+                beam_y - OUTLINE_WIDTH,
+                beam_x + HALF_LEN + OUTLINE_WIDTH,
+                beam_y + OUTLINE_WIDTH,
+            ],
+            fill=cls.CROSSHAIR_OUTLINE_COLOUR,
+        )
         draw.line(
             ((beam_x, beam_y - HALF_LEN), (beam_x, beam_y + HALF_LEN)),
-            fill=self.CROSSHAIR_COLOUR,
+            fill=cls.CROSSHAIR_FILL_COLOUR,
         )
         draw.line(
             ((beam_x - HALF_LEN, beam_y), (beam_x + HALF_LEN, beam_y)),
-            fill=self.CROSSHAIR_COLOUR,
+            fill=cls.CROSSHAIR_FILL_COLOUR,
         )
-
-        self._save_image(image)

{dls_dodal-1.31.0 → dls_dodal-1.32.0}/src/dodal/devices/detector/detector.py

@@ -79,7 +79,7 @@ class DetectorParams(BaseModel):
     def _parse_directory(cls, directory: str | Path) -> str:
         path = Path(directory)
         assert path.is_dir()
-        return str(path)
+        return f"{path}/"
 
     def get_beam_position_mm(self, detector_distance: float) -> tuple[float, float]:
         x_beam_mm = self.beam_xy_converter.get_beam_xy_from_det_dist(

{dls_dodal-1.31.0 → dls_dodal-1.32.0}/src/dodal/devices/fast_grid_scan.py

@@ -3,6 +3,7 @@ from typing import Generic, TypeVar
 
 import numpy as np
 from bluesky.plan_stubs import mv
+from bluesky.protocols import Flyable
 from numpy import ndarray
 from ophyd_async.core import (
     AsyncStatus,
@@ -193,7 +194,7 @@ class ExpectedImages(SignalR[int]):
         return first_grid + second_grid
 
 
-class FastGridScanCommon(StandardReadable, ABC, Generic[ParamType]):
+class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
     """Device for a general fast grid scan
 
     When the motion program is started, the goniometer will move in a snake-like grid trajectory,

{dls_dodal-1.31.0 → dls_dodal-1.32.0}/src/dodal/devices/focusing_mirror.py

@@ -76,7 +76,7 @@ class MirrorVoltageDevice(Device):
             LOGGER.debug(f"{setpoint_v.name} already at {value} - skipping set")
             return
 
-        LOGGER.debug(f"setting {setpoint_v.name} to {value}")
+        LOGGER.debug(f"Setting {setpoint_v.name} to {value}")
 
         # Register an observer up front to ensure we don't miss events after we
         # perform the set
@@ -85,16 +85,14 @@ class MirrorVoltageDevice(Device):
         )
         # discard the current value (OK) so we can await a subsequent change
         await anext(demand_accepted_iterator)
-        await setpoint_v.set(value)
+        set_status = setpoint_v.set(value, wait=False)
 
         # The set should always change to SLEW regardless of whether we are
         # already at the set point, then change back to OK/FAIL depending on
         # success
         accepted_value = await anext(demand_accepted_iterator)
         assert accepted_value == MirrorVoltageDemand.SLEW
-        LOGGER.debug(
-            f"Demand not accepted for {setpoint_v.name}, waiting for acceptance..."
-        )
+        LOGGER.debug(f"Waiting for {setpoint_v.name} to set")
         while MirrorVoltageDemand.SLEW == (
             accepted_value := await anext(demand_accepted_iterator)
         ):
@@ -104,6 +102,7 @@ class MirrorVoltageDevice(Device):
             raise AssertionError(
                 f"Voltage slew failed for {setpoint_v.name}, new state={accepted_value}"
             )
+        await set_status
 
 
 class VFMMirrorVoltages(StandardReadable):

{dls_dodal-1.31.0 → dls_dodal-1.32.0}/src/dodal/devices/i24/pmac.py

@@ -1,16 +1,17 @@
+from asyncio import sleep
 from enum import Enum, IntEnum
-from typing import SupportsFloat
 
-from bluesky.protocols import Triggerable
+from bluesky.protocols import Flyable, Triggerable
 from ophyd_async.core import (
+    CALCULATE_TIMEOUT,
     DEFAULT_TIMEOUT,
     AsyncStatus,
-    CalculateTimeout,
     SignalBackend,
     SignalR,
     SignalRW,
     SoftSignalBackend,
     StandardReadable,
+    soft_signal_rw,
     wait_for_value,
 )
 from ophyd_async.epics.motor import Motor
@@ -89,7 +90,7 @@ class PMACStringLaser(SignalRW):
         self,
         value: LaserSettings,
         wait=True,
-        timeout=CalculateTimeout,
+        timeout=CALCULATE_TIMEOUT,
     ):
         await self.signal.set(value.value, wait, timeout)
 
@@ -112,13 +113,13 @@ class PMACStringEncReset(SignalRW):
         self,
         value: EncReset,
         wait=True,
-        timeout=CalculateTimeout,
+        timeout=CALCULATE_TIMEOUT,
     ):
         await self.signal.set(value.value, wait, timeout)
 
 
-class ProgramRunner(SignalRW):
-    """Trigger the collection by setting the program number on the PMAC string.
+class ProgramRunner(SignalRW, Flyable):
+    """Run the collection by setting the program number on the PMAC string.
 
     Once the program number has been set, wait for the collection to be complete.
     This will only be true when the status becomes 0.
@@ -128,22 +129,73 @@ class ProgramRunner(SignalRW):
         self,
         pmac_str_sig: SignalRW,
         status_sig: SignalR,
+        prog_num_sig: SignalRW,
+        collection_time_sig: SignalRW,
         backend: SignalBackend,
         timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
         self.signal = pmac_str_sig
         self.status = status_sig
+        self.prog_num = prog_num_sig
+
+        self.collection_time = collection_time_sig
+        self.KICKOFF_TIMEOUT = timeout
+
         super().__init__(backend, timeout, name)
 
+    async def _get_prog_number_string(self) -> str:
+        prog_num = await self.prog_num.get_value()
+        return f"&2b{prog_num}r"
+
+    @AsyncStatus.wrap
+    async def kickoff(self):
+        """Kick off the collection by sending a program number to the pmac_string and \
+            wait for the scan status PV to go to 1.
+        """
+        prog_num_str = await self._get_prog_number_string()
+        await self.signal.set(prog_num_str, wait=True)
+        await wait_for_value(
+            self.status,
+            ScanState.RUNNING,
+            timeout=self.KICKOFF_TIMEOUT,
+        )
+
+    @AsyncStatus.wrap
+    async def complete(self):
+        """Stop collecting when the scan status PV goes to 0.
+
+        Args:
+            complete_time (float): total time required by the collection to \
+            finish correctly.
+        """
+        scan_complete_time = await self.collection_time.get_value()
+        await wait_for_value(self.status, ScanState.DONE, timeout=scan_complete_time)
+
+
+class ProgramAbort(Triggerable):
+    """Abort a data collection by setting the PMAC string and then wait for the \
+        status value to go back to 0.
+    """
+
+    def __init__(
+        self,
+        pmac_str_sig: SignalRW,
+        status_sig: SignalR,
+    ) -> None:
+        self.signal = pmac_str_sig
+        self.status = status_sig
+
     @AsyncStatus.wrap
-    async def set(self, value: int, wait=True, timeout=None):
-        prog_str = f"&2b{value}r"
-        assert isinstance(timeout, SupportsFloat) or (
-            timeout is None
-        ), f"ProgramRunner does not support calculating timeout itself, {timeout=}"
-        await self.signal.set(prog_str, wait=wait)
-        await wait_for_value(self.status, ScanState.DONE, timeout)
+    async def trigger(self):
+        await self.signal.set("A", wait=True)
+        await sleep(1.0)  # TODO Check with scientist what this sleep is really for.
+        await self.signal.set("P2401=0", wait=True)
+        await wait_for_value(
+            self.status,
+            ScanState.DONE,
+            timeout=DEFAULT_TIMEOUT,
+        )
 
 
 class PMAC(StandardReadable):
@@ -172,8 +224,18 @@ class PMAC(StandardReadable):
         self.scanstatus = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2401")
         self.counter = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2402")
 
+        # A couple of soft signals for running a collection: program number to send to
+        # the PMAC_STRING and expected collection time.
+        self.program_number = soft_signal_rw(int)
+        self.collection_time = soft_signal_rw(float, initial_value=600.0, units="s")
+
         self.run_program = ProgramRunner(
-            self.pmac_string, self.scanstatus, backend=SoftSignalBackend(str)
+            self.pmac_string,
+            self.scanstatus,
+            self.program_number,
+            self.collection_time,
+            backend=SoftSignalBackend(str),
         )
+        self.abort_program = ProgramAbort(self.pmac_string, self.scanstatus)
 
         super().__init__(name)

{dls_dodal-1.31.0 → dls_dodal-1.32.0}/src/dodal/devices/robot.py

@@ -1,5 +1,5 @@
 import asyncio
-from asyncio import FIRST_COMPLETED, CancelledError, Task
+from asyncio import FIRST_COMPLETED, CancelledError, Task, wait_for
 from dataclasses import dataclass
 from enum import Enum
 
@@ -41,6 +41,9 @@ class PinMounted(str, Enum):
 class BartRobot(StandardReadable, Movable):
     """The sample changing robot."""
 
+    # How long to wait for the robot if it is busy soaking/drying
+    NOT_BUSY_TIMEOUT = 60
+    # How long to wait for the actual load to happen
     LOAD_TIMEOUT = 60
     NO_PIN_ERROR_CODE = 25
 
@@ -54,10 +57,15 @@ class BartRobot(StandardReadable, Movable):
     ) -> None:
         self.barcode = epics_signal_r(str, prefix + "BARCODE")
         self.gonio_pin_sensor = epics_signal_r(PinMounted, prefix + "PIN_MOUNTED")
+
         self.next_pin = epics_signal_rw_rbv(float, prefix + "NEXT_PIN")
         self.next_puck = epics_signal_rw_rbv(float, prefix + "NEXT_PUCK")
+        self.current_puck = epics_signal_r(float, prefix + "CURRENT_PUCK_RBV")
+        self.current_pin = epics_signal_r(float, prefix + "CURRENT_PIN_RBV")
+
         self.next_sample_id = epics_signal_rw_rbv(float, prefix + "NEXT_ID")
         self.sample_id = epics_signal_r(float, prefix + "CURRENT_ID_RBV")
+
         self.load = epics_signal_x(prefix + "LOAD.PROC")
         self.program_running = epics_signal_r(bool, prefix + "PROGRAM_RUNNING")
         self.program_name = epics_signal_r(str, prefix + "PROGRAM_NAME")
@@ -93,7 +101,7 @@ class BartRobot(StandardReadable, Movable):
             for task in finished:
                 await task
         except CancelledError:
-            # If the outer enclosing task cancels after LOAD_TIMEOUT, this causes CancelledError to be raised
+            # If the outer enclosing task cancels after a timeout, this causes CancelledError to be raised
             # in the current task, when it propagates to here we should cancel all pending tasks before bubbling up
             for task in tasks:
                 task.cancel()
@@ -105,7 +113,9 @@ class BartRobot(StandardReadable, Movable):
             LOGGER.info(
                 f"Waiting on robot to finish {await self.program_name.get_value()}"
             )
-            await wait_for_value(self.program_running, False, None)
+            await wait_for_value(
+                self.program_running, False, timeout=self.NOT_BUSY_TIMEOUT
+            )
         await asyncio.gather(
             set_and_wait_for_value(self.next_puck, sample_location.puck),
             set_and_wait_for_value(self.next_pin, sample_location.pin),
@@ -121,10 +131,12 @@ class BartRobot(StandardReadable, Movable):
     @AsyncStatus.wrap
     async def set(self, value: SampleLocation):
         try:
-            await asyncio.wait_for(
-                self._load_pin_and_puck(value), timeout=self.LOAD_TIMEOUT
+            await wait_for(
+                self._load_pin_and_puck(value),
+                timeout=self.LOAD_TIMEOUT + self.NOT_BUSY_TIMEOUT,
             )
-        except asyncio.TimeoutError as e:
+        except (asyncio.TimeoutError, TimeoutError) as e:
+            # Will only need to catch asyncio.TimeoutError after https://github.com/bluesky/ophyd-async/issues/572
             error_code = await self.error_code.get_value()
             error_string = await self.error_str.get_value()
             raise RobotLoadFailed(int(error_code), error_string) from e

{dls_dodal-1.31.0 → dls_dodal-1.32.0}/src/dodal/devices/tetramm.py

@@ -3,13 +3,13 @@ from enum import Enum
 
 from bluesky.protocols import Hints
 from ophyd_async.core import (
-    AsyncStatus,
     DatasetDescriber,
     DetectorControl,
     DetectorTrigger,
     Device,
     PathProvider,
     StandardDetector,
+    TriggerInfo,
     set_and_wait_for_value,
     soft_signal_r_and_setter,
 )
@@ -113,29 +113,24 @@ class TetrammController(DetectorControl):
         # 2 internal clock cycles. Best effort approximation
         return 2 / self.base_sample_rate
 
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.edge_trigger,
-        exposure: float | None = None,
-    ) -> AsyncStatus:
-        if exposure is None:
-            raise ValueError(
-                "Tetramm does not support arm without exposure time. "
-                "Is this a software scan? Tetramm only supports hardware scans."
-            )
-        self._validate_trigger(trigger)
+    async def prepare(self, trigger_info: TriggerInfo):
+        self._validate_trigger(trigger_info.trigger)
+        assert trigger_info.livetime is not None
 
         # trigger mode must be set first and on its own!
         await self._drv.trigger_mode.set(TetrammTrigger.ExtTrigger)
 
         await asyncio.gather(
-            self._drv.averaging_time.set(exposure), self.set_exposure(exposure)
+            self._drv.averaging_time.set(trigger_info.livetime),
+            self.set_exposure(trigger_info.livetime),
         )
 
-        status = await set_and_wait_for_value(self._drv.acquire, True)
+    async def arm(self):
+        self._arm_status = await set_and_wait_for_value(self._drv.acquire, True)
 
-        return status
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
 
     def _validate_trigger(self, trigger: DetectorTrigger) -> None:
         supported_trigger_types = {