dls-dodal 1.29.3__py3-none-any.whl → 1.30.0__py3-none-any.whl

dodal/devices/detector/detector_motion.py

@@ -1,37 +1,44 @@
-from enum import IntEnum
+from enum import Enum
 
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsMotor, EpicsSignal, EpicsSignalRO
+from ophyd_async.core import Device
+from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
 
-class ShutterState(IntEnum):
-    CLOSED = 0
-    OPEN = 1
+class ShutterState(str, Enum):
+    CLOSED = "Closed"
+    OPEN = "Open"
 
 
 class DetectorMotion(Device):
-    """Physical motion and interlocks for detector travel"""
-
-    upstream_x = Cpt(EpicsMotor, "-MO-DET-01:UPSTREAMX")
-    downstream_x = Cpt(EpicsMotor, "-MO-DET-01:DOWNSTREAMX")
-    x = Cpt(EpicsMotor, "-MO-DET-01:X")
-    y = Cpt(EpicsMotor, "-MO-DET-01:Y")
-    z = Cpt(EpicsMotor, "-MO-DET-01:Z")
-    yaw = Cpt(EpicsMotor, "-MO-DET-01:YAW")
-    shutter = Cpt(EpicsSignal, "-MO-DET-01:SET_SHUTTER_STATE")  # 0=closed, 1=open
-    #   monitors
-    shutter_closed_lim = Cpt(
-        EpicsSignalRO, "-MO-DET-01:CLOSE_LIMIT"
-    )  # on limit = 1, off = 0
-    shutter_open_lim = Cpt(
-        EpicsSignalRO, "-MO-DET-01:OPEN_LIMIT"
-    )  # on limit = 1, off = 0
-    z_disabled = Cpt(
-        EpicsSignalRO, "-MO-DET-01:Z:DISABLED"
-    )  # robot interlock, 0=ok to move, 1=blocked
-    crate_power = Cpt(
-        EpicsSignalRO, "-MO-PMAC-02:CRATE2_HEALTHY"
-    )  # returns 0 if no power
-    in_robot_load_safe_position = Cpt(
-        EpicsSignalRO, "-MO-PMAC-02:GPIO_INP_BITS.B2"
-    )  # returns 1 if safe
+    def __init__(self, prefix: str, name: str = ""):
+        device_prefix = "-MO-DET-01:"
+        pmac_prefix = "-MO-PMAC-02:"
+
+        self.upstream_x = Motor(f"{prefix}{device_prefix}UPSTREAMX")
+        self.downstream_x = Motor(f"{prefix}{device_prefix}DOWNSTREAMX")
+        self.x = Motor(f"{prefix}{device_prefix}X")
+        self.y = Motor(f"{prefix}{device_prefix}Y")
+        self.z = Motor(f"{prefix}{device_prefix}Z")
+        self.yaw = Motor(f"{prefix}{device_prefix}YAW")
+
+        self.shutter = epics_signal_rw(
+            ShutterState, f"{prefix}{device_prefix}SET_SHUTTER_STATE"
+        )
+        self.shutter_closed_lim = epics_signal_r(
+            float, f"{prefix}{device_prefix}CLOSE_LIMIT"
+        )  # on limit = 1, off = 0
+        self.shutter_open_lim = epics_signal_r(
+            float, f"{prefix}{device_prefix}OPEN_LIMIT"
+        )  # on limit = 1, off = 0
+        self.z_disabled = epics_signal_r(
+            float, f"{prefix}{device_prefix}Z:DISABLED"
+        )  # robot interlock, 0=ok to move, 1=blocked
+        self.crate_power = epics_signal_r(
+            float, f"{prefix}{pmac_prefix}CRATE2_HEALTHY"
+        )  # returns 0 if no power
+        self.in_robot_load_safe_position = epics_signal_r(
+            int, f"{prefix}{pmac_prefix}GPIO_INP_BITS.B2"
+        )  # returns 1 if safe
+
+        super().__init__(name)

dodal/devices/eiger.py

@@ -1,8 +1,9 @@
+# type: ignore # Eiger will soon be ophyd-async https://github.com/DiamondLightSource/dodal/issues/700
 from enum import Enum
 
 from ophyd import Component, Device, EpicsSignalRO, Signal
 from ophyd.areadetector.cam import EigerDetectorCam
-from ophyd.status import AndStatus, Status, SubscriptionStatus
+from ophyd.status import AndStatus, Status, StatusBase
 
 from dodal.devices.detector import DetectorParams, TriggerMode
 from dodal.devices.eiger_odin import EigerOdin
@@ -12,10 +13,6 @@ from dodal.log import LOGGER
 
 FREE_RUN_MAX_IMAGES = 1000000
 
-# TODO present for testing purposes, remove
-TEST_1169_FIX = True
-TEST_1169_INJECT = False
-
 
 class InternalEigerTriggerMode(Enum):
     INTERNAL_SERIES = 0
@@ -27,6 +24,7 @@ class InternalEigerTriggerMode(Enum):
 class EigerDetector(Device):
     class ArmingSignal(Signal):
         def set(self, value, *, timeout=None, settle_time=None, **kwargs):
+            assert isinstance(self.parent, EigerDetector)
             return self.parent.async_stage()
 
     do_arm = Component(ArmingSignal)
@@ -38,10 +36,12 @@ class EigerDetector(Device):
 
     STALE_PARAMS_TIMEOUT = 60
     GENERAL_STATUS_TIMEOUT = 10
+    # Long timeout for meta file to compensate for filesystem issues
+    META_FILE_READY_TIMEOUT = 30
     ALL_FRAMES_TIMEOUT = 120
     ARMING_TIMEOUT = 60
 
-    filewriters_finished: SubscriptionStatus
+    filewriters_finished: StatusBase
 
     detector_params: DetectorParams | None = None
 
@@ -53,17 +53,15 @@ class EigerDetector(Device):
         cls,
         params: DetectorParams,
         name: str = "EigerDetector",
-        *args,
-        **kwargs,
     ):
-        det = cls(name=name, *args, **kwargs)
+        det = cls(name=name)
         det.set_detector_parameters(params)
         return det
 
     def set_detector_parameters(self, detector_params: DetectorParams):
         self.detector_params = detector_params
         if self.detector_params is None:
-            raise Exception("Parameters for scan must be specified")
+            raise ValueError("Parameters for scan must be specified")
 
         to_check = [
             (
@@ -100,7 +98,7 @@ class EigerDetector(Device):
 
     def stage(self):
         self.wait_on_arming_if_started()
-        if TEST_1169_INJECT or not self.is_armed():
+        if not self.is_armed():
             LOGGER.info("Eiger not armed, arming")
 
             self.async_stage().wait(timeout=self.ARMING_TIMEOUT)
@@ -155,7 +153,7 @@ class EigerDetector(Device):
     def enable_roi_mode(self):
         return self.change_roi_mode(True)
 
-    def change_roi_mode(self, enable: bool) -> Status:
+    def change_roi_mode(self, enable: bool) -> StatusBase:
         assert self.detector_params is not None
         detector_dimensions = (
             self.detector_params.detector_size_constants.roi_size_pixels
@@ -206,7 +204,7 @@ class EigerDetector(Device):
         )
         return status
 
-    def set_odin_pvs(self) -> Status:
+    def set_odin_pvs(self) -> StatusBase:
         assert self.detector_params is not None
         file_prefix = self.detector_params.full_filename
         status = self.odin.file_writer.file_path.set(
@@ -264,7 +262,7 @@ class EigerDetector(Device):
             status.set_finished()
             return status
 
-    def set_num_triggers_and_captures(self) -> Status:
+    def set_num_triggers_and_captures(self) -> StatusBase:
         """Sets the number of triggers and the number of images for the Eiger to capture
         during the datacollection. The number of images is the number of images per
         trigger.
@@ -295,7 +293,7 @@ class EigerDetector(Device):
 
         return status
 
-    def _wait_for_odin_status(self) -> Status:
+    def _wait_for_odin_status(self) -> StatusBase:
         self.forward_bit_depth_to_filewriter()
         await_value(self.odin.meta.active, 1).wait(self.GENERAL_STATUS_TIMEOUT)
 
@@ -304,18 +302,20 @@ class EigerDetector(Device):
         )
         LOGGER.info("Eiger staging: awaiting odin metadata")
         status &= await_value(
-            self.odin.meta.ready, 1, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.odin.meta.ready, 1, timeout=self.META_FILE_READY_TIMEOUT
         )
         return status
 
-    def _wait_fan_ready(self) -> Status:
+    def _wait_fan_ready(self) -> StatusBase:
         self.filewriters_finished = self.odin.create_finished_status()
         LOGGER.info("Eiger staging: awaiting odin fan ready")
         return await_value(self.odin.fan.ready, 1, self.GENERAL_STATUS_TIMEOUT)
 
     def _finish_arm(self) -> Status:
         LOGGER.info("Eiger staging: Finishing arming")
-        return Status(done=True, success=True)
+        status = Status()
+        status.set_finished()
+        return status
 
     def forward_bit_depth_to_filewriter(self):
         bit_depth = self.bit_depth.get()
@@ -332,11 +332,16 @@ class EigerDetector(Device):
 
     def do_arming_chain(self) -> Status:
         functions_to_do_arm = []
+        assert self.detector_params
         detector_params: DetectorParams = self.detector_params
         if detector_params.use_roi_mode:
             functions_to_do_arm.append(self.enable_roi_mode)
 
         arming_sequence_funcs = [
+            # If a beam dump occurs after arming the eiger but prior to eiger staging,
+            # the odin may timeout which will cause the arming sequence to be retried;
+            # if this previously completed successfully we must reset the odin first
+            self.odin.stop,
             lambda: self.change_dev_shm(detector_params.enable_dev_shm),
             lambda: self.set_detector_threshold(detector_params.expected_energy_ev),
             self.set_cam_pvs,
@@ -350,11 +355,6 @@ class EigerDetector(Device):
             self._wait_fan_ready,
             self._finish_arm,
         ]
-        if TEST_1169_FIX:
-            # If a beam dump occurs after arming the eiger but prior to eiger staging,
-            # the odin may timeout which will cause the arming sequence to be retried;
-            # if this previously completed successfully we must reset the odin first
-            arming_sequence_funcs.insert(0, self.odin.stop)
 
         functions_to_do_arm.extend(arming_sequence_funcs)
 

dodal/devices/eiger_odin.py

@@ -1,9 +1,8 @@
-from typing import List, Tuple
-
+# type: ignore # Eiger will soon be ophyd-async https://github.com/DiamondLightSource/dodal/issues/700
 from ophyd import Component, Device, EpicsSignal, EpicsSignalRO, EpicsSignalWithRBV
 from ophyd.areadetector.plugins import HDF5Plugin_V22
 from ophyd.sim import NullStatus
-from ophyd.status import Status, SubscriptionStatus
+from ophyd.status import StatusBase
 
 from dodal.devices.status import await_value
 
@@ -59,12 +58,12 @@ class OdinNodesStatus(Device):
     node_3 = Component(OdinNode, "OD4:")
 
     @property
-    def nodes(self) -> List[OdinNode]:
+    def nodes(self) -> list[OdinNode]:
         return [self.node_0, self.node_1, self.node_2, self.node_3]
 
     def check_node_frames_from_attr(
         self, node_get_func, error_message_verb: str
-    ) -> Tuple[bool, str]:
+    ) -> tuple[bool, str]:
         nodes_frames_values = [0] * len(self.nodes)
         frames_details = []
         for node_number, node_pv in enumerate(self.nodes):
@@ -75,17 +74,17 @@ class OdinNodesStatus(Device):
         bad_frames = any(v != 0 for v in nodes_frames_values)
         return bad_frames, "\n".join(frames_details)
 
-    def check_frames_timed_out(self) -> Tuple[bool, str]:
+    def check_frames_timed_out(self) -> tuple[bool, str]:
         return self.check_node_frames_from_attr(
             lambda node: node.frames_timed_out.get(), "timed out"
         )
 
-    def check_frames_dropped(self) -> Tuple[bool, str]:
+    def check_frames_dropped(self) -> tuple[bool, str]:
         return self.check_node_frames_from_attr(
             lambda node: node.frames_dropped.get(), "dropped"
         )
 
-    def get_error_state(self) -> Tuple[bool, str]:
+    def get_error_state(self) -> tuple[bool, str]:
         is_error = []
         error_messages = []
         for node_number, node_pv in enumerate(self.nodes):
@@ -99,7 +98,7 @@ class OdinNodesStatus(Device):
 
     def get_init_state(self) -> bool:
         is_initialised = []
-        for node_number, node_pv in enumerate(self.nodes):
+        for node_pv in self.nodes:
             is_initialised.append(node_pv.fr_initialised.get())
             is_initialised.append(node_pv.fp_initialised.get())
         return all(is_initialised)
@@ -120,7 +119,7 @@ class EigerOdin(Device):
     meta = Component(OdinMetaListener, "OD:META:")
     nodes = Component(OdinNodesStatus, "")
 
-    def create_finished_status(self) -> SubscriptionStatus:
+    def create_finished_status(self) -> StatusBase:
         writing_finished = await_value(self.meta.ready, 0)
         for node_pv in self.nodes.nodes:
             writing_finished &= await_value(node_pv.writing, 0)
@@ -132,7 +131,7 @@ class EigerOdin(Device):
         frames_timed_out, frames_timed_out_details = self.nodes.check_frames_timed_out()
 
         if not is_initialised:
-            raise Exception(error_message)
+            raise RuntimeError(error_message)
         if frames_dropped:
             self.log.error(f"Frames dropped: {frames_dropped_details}")
         if frames_timed_out:
@@ -140,7 +139,7 @@ class EigerOdin(Device):
 
         return is_initialised and not frames_dropped and not frames_timed_out
 
-    def check_odin_initialised(self) -> Tuple[bool, str]:
+    def check_odin_initialised(self) -> tuple[bool, str]:
         is_error_state, error_messages = self.nodes.get_error_state()
         to_check = [
             (not self.fan.consumers_connected.get(), "EigerFan is not connected"),
@@ -157,7 +156,7 @@ class EigerOdin(Device):
 
         return not errors, "\n".join(errors)
 
-    def stop(self) -> Status:
+    def stop(self) -> StatusBase:
         """Stop odin manually"""
         status = self.file_writer.capture.set(0)
         status &= self.meta.stop_writing.set(1)

dodal/devices/fast_grid_scan.py

@@ -126,7 +126,7 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
         :return: The motor position this corresponds to.
         :raises: IndexError if the desired position is outside the grid."""
         for position, axis in zip(
-            grid_position, [self.x_axis, self.y_axis, self.z_axis]
+            grid_position, [self.x_axis, self.y_axis, self.z_axis], strict=False
         ):
             if not axis.is_within(position):
                 raise IndexError(f"{grid_position} is outside the bounds of the grid")
@@ -191,9 +191,10 @@ class MotionProgram(Device):
 class ExpectedImages(SignalR[int]):
     def __init__(self, parent: "FastGridScanCommon") -> None:
         super().__init__(SoftSignalBackend(int))
-        self.parent: "FastGridScanCommon" = parent
+        self.parent = parent
 
-    async def get_value(self):
+    async def get_value(self, cached: bool | None = None):
+        assert isinstance(self.parent, FastGridScanCommon)
         x = await self.parent.x_steps.get_value()
         y = await self.parent.y_steps.get_value()
         z = await self.parent.z_steps.get_value()

dodal/devices/fluorescence_detector_motion.py

@@ -1,9 +1,18 @@
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsSignal
+from enum import Enum
 
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.signal import epics_signal_r
 
-class FluorescenceDetector(Device):
+
+class FluorescenceDetectorControlState(Enum):
     OUT = 0
     IN = 1
 
-    pos = Cpt(EpicsSignal, "-EA-FLU-01:CTRL")
+
+class FluorescenceDetector(StandardReadable):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.pos = epics_signal_r(
+                FluorescenceDetectorControlState, prefix + "-EA-FLU-01:CTRL"
+            )
+        super().__init__(name)

dodal/devices/focusing_mirror.py

@@ -1,12 +1,18 @@
-from enum import Enum, IntEnum
-from typing import Any
-
-from ophyd import Component, Device, EpicsSignal
-from ophyd.status import Status, StatusBase
-from ophyd_async.core import StandardReadable
+from enum import Enum
+
+from ophyd_async.core import (
+    AsyncStatus,
+    ConfigSignal,
+    Device,
+    DeviceVector,
+    HintedSignal,
+    StandardReadable,
+    observe_value,
+)
 from ophyd_async.core.signal import soft_signal_r_and_setter
 from ophyd_async.epics.motion import Motor
 from ophyd_async.epics.signal import (
+    epics_signal_r,
     epics_signal_rw,
     epics_signal_x,
 )
@@ -32,11 +38,11 @@ class MirrorStripe(str, Enum):
     PLATINUM = "Platinum"
 
 
-class MirrorVoltageDemand(IntEnum):
-    N_A = 0
-    OK = 1
-    FAIL = 2
-    SLEW = 3
+class MirrorVoltageDemand(str, Enum):
+    N_A = "N/A"
+    OK = "OK"
+    FAIL = "FAIL"
+    SLEW = "SLEW"
 
 
 class MirrorVoltageDevice(Device):
@@ -44,14 +50,16 @@ class MirrorVoltageDevice(Device):
     the demanded voltage setpoint is accepted, without blocking the caller as this process can take significant time.
     """
 
-    _actual_v: EpicsSignal = Component(EpicsSignal, "R")
-    _setpoint_v: EpicsSignal = Component(EpicsSignal, "D")
-    _demand_accepted: EpicsSignal = Component(EpicsSignal, "DSEV")
+    def __init__(self, name: str = "", prefix: str = ""):
+        self._actual_v = epics_signal_r(int, prefix + "R")
+        self._setpoint_v = epics_signal_rw(int, prefix + "D")
+        self._demand_accepted = epics_signal_r(MirrorVoltageDemand, prefix + "DSEV")
+        super().__init__(name=name)
 
-    def set(self, value, *args, **kwargs) -> StatusBase:
+    @AsyncStatus.wrap
+    async def set(self, value, *args, **kwargs):
         """Combine the following operations into a single set:
         1. apply the value to the setpoint PV
-        2. Return to the caller with a Status future
         3. Wait until demand is accepted
         4. When either demand is accepted or DEFAULT_SETTLE_TIME expires, signal the result on the Status
         """
@@ -59,66 +67,60 @@ class MirrorVoltageDevice(Device):
         setpoint_v = self._setpoint_v
         demand_accepted = self._demand_accepted
 
-        if demand_accepted.get() != MirrorVoltageDemand.OK:
+        if await demand_accepted.get_value() != MirrorVoltageDemand.OK:
             raise AssertionError(
                 f"Attempted to set {setpoint_v.name} when demand is not accepted."
             )
 
-        if setpoint_v.get() == value:
+        if await setpoint_v.get_value() == value:
             LOGGER.debug(f"{setpoint_v.name} already at {value} - skipping set")
-            return Status(success=True, done=True)
+            return
 
         LOGGER.debug(f"setting {setpoint_v.name} to {value}")
-        demand_accepted_status = Status(self, DEFAULT_SETTLE_TIME_S)
-
-        subscription: dict[str, Any] = {"handle": None}
-
-        def demand_check_callback(old_value, value, **kwargs):
-            LOGGER.debug(f"Got event old={old_value} new={value} for {setpoint_v.name}")
-            if old_value != MirrorVoltageDemand.OK and value == MirrorVoltageDemand.OK:
-                LOGGER.debug(f"Demand accepted for {setpoint_v.name}")
-                subs_handle = subscription.pop("handle", None)
-                if subs_handle is None:
-                    raise AssertionError("Demand accepted before set attempted")
-                demand_accepted.unsubscribe(subs_handle)
 
-                demand_accepted_status.set_finished()
-            # else timeout handled by parent demand_accepted_status
+        # Register an observer up front to ensure we don't miss events after we
+        # perform the set
+        demand_accepted_iterator = observe_value(
+            demand_accepted, timeout=DEFAULT_SETTLE_TIME_S
+        )
+        # discard the current value (OK) so we can await a subsequent change
+        await anext(demand_accepted_iterator)
+        await setpoint_v.set(value)
+
+        # 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..."
+        )
+        while MirrorVoltageDemand.SLEW == (
+            accepted_value := await anext(demand_accepted_iterator)
+        ):
+            pass
 
-        subscription["handle"] = demand_accepted.subscribe(demand_check_callback)
-        setpoint_status = setpoint_v.set(value)
-        status = setpoint_status & demand_accepted_status
-        return status
+        if accepted_value != MirrorVoltageDemand.OK:
+            raise AssertionError(
+                f"Voltage slew failed for {setpoint_v.name}, new state={accepted_value}"
+            )
 
 
-class VFMMirrorVoltages(Device):
-    def __init__(self, *args, daq_configuration_path: str, **kwargs):
-        super().__init__(*args, **kwargs)
+class VFMMirrorVoltages(StandardReadable):
+    def __init__(
+        self, name: str, prefix: str, *args, daq_configuration_path: str, **kwargs
+    ):
         self.voltage_lookup_table_path = (
             daq_configuration_path + "/json/mirrorFocus.json"
         )
-
-    _channel14_voltage_device = Component(MirrorVoltageDevice, "BM:V14")
-    _channel15_voltage_device = Component(MirrorVoltageDevice, "BM:V15")
-    _channel16_voltage_device = Component(MirrorVoltageDevice, "BM:V16")
-    _channel17_voltage_device = Component(MirrorVoltageDevice, "BM:V17")
-    _channel18_voltage_device = Component(MirrorVoltageDevice, "BM:V18")
-    _channel19_voltage_device = Component(MirrorVoltageDevice, "BM:V19")
-    _channel20_voltage_device = Component(MirrorVoltageDevice, "BM:V20")
-    _channel21_voltage_device = Component(MirrorVoltageDevice, "BM:V21")
-
-    @property
-    def voltage_channels(self) -> list[MirrorVoltageDevice]:
-        return [
-            self._channel14_voltage_device,
-            self._channel15_voltage_device,
-            self._channel16_voltage_device,
-            self._channel17_voltage_device,
-            self._channel18_voltage_device,
-            self._channel19_voltage_device,
-            self._channel20_voltage_device,
-            self._channel21_voltage_device,
-        ]
+        with self.add_children_as_readables():
+            self.voltage_channels = DeviceVector(
+                {
+                    i - 14: MirrorVoltageDevice(prefix=f"{prefix}BM:V{i}")
+                    for i in range(14, 22)
+                }
+            )
+        super().__init__(*args, name=name, **kwargs)
 
 
 class FocusingMirror(StandardReadable):
@@ -144,10 +146,8 @@ class FocusingMirror(StandardReadable):
         # regardless of orientation of the mirror
         self.incident_angle = Motor(prefix + "PITCH")
 
-        self.set_readable_signals(
-            read=[self.incident_angle.user_readback],
-            config=[self.type],
-        )
+        self.add_readables([self.incident_angle.user_readback], wrapper=HintedSignal)
+        self.add_readables([self.type], wrapper=ConfigSignal)
         super().__init__(name)
 
 

dodal/devices/hutch_shutter.py

@@ -74,20 +74,20 @@ class HutchShutter(StandardReadable, Movable):
         super().__init__(name)
 
     @AsyncStatus.wrap
-    async def set(self, position_demand: ShutterDemand):
+    async def set(self, value: ShutterDemand):
         interlock_state = await self.interlock.shutter_safe_to_operate()
         if not interlock_state:
             raise ShutterNotSafeToOperateError(
                 "The hutch has not been locked, not operating shutter."
             )
-        if position_demand == ShutterDemand.OPEN:
+        if value == ShutterDemand.OPEN:
             await self.control.set(ShutterDemand.RESET, wait=True)
-            await self.control.set(position_demand, wait=True)
+            await self.control.set(value, wait=True)
             return await wait_for_value(
                 self.status, match=ShutterState.OPEN, timeout=DEFAULT_TIMEOUT
             )
         else:
-            await self.control.set(position_demand, wait=True)
+            await self.control.set(value, wait=True)
             return await wait_for_value(
                 self.status, match=ShutterState.CLOSED, timeout=DEFAULT_TIMEOUT
             )

dodal/devices/i22/dcm.py

@@ -1,6 +1,7 @@
 import time
+from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import Dict, Literal, Sequence
+from typing import Literal
 
 from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
@@ -127,7 +128,7 @@ class DoubleCrystalMonochromator(StandardReadable):
 
         super().__init__(name)
 
-    async def describe(self) -> Dict[str, DataKey]:
+    async def describe(self) -> dict[str, DataKey]:
         default_describe = await super().describe()
         return {
             f"{self.name}-wavelength": DataKey(
@@ -139,7 +140,7 @@ class DoubleCrystalMonochromator(StandardReadable):
             **default_describe,
         }
 
-    async def read(self) -> Dict[str, Reading]:
+    async def read(self) -> dict[str, Reading]:
         default_reading = await super().read()
         energy: float = default_reading[f"{self.name}-energy"]["value"]
         if energy > 0.0:

dodal/devices/i22/fswitch.py

@@ -1,9 +1,9 @@
 import asyncio
 import time
 from enum import Enum
-from typing import Dict
 
-from bluesky.protocols import DataKey, Reading
+from bluesky.protocols import Reading
+from event_model import DataKey
 from ophyd_async.core import ConfigSignal, StandardReadable, soft_signal_r_and_setter
 from ophyd_async.core.device import DeviceVector
 from ophyd_async.epics.signal import epics_signal_r
@@ -74,7 +74,7 @@ class FSwitch(StandardReadable):
 
         super().__init__(name)
 
-    async def describe(self) -> Dict[str, DataKey]:
+    async def describe(self) -> dict[str, DataKey]:
         default_describe = await super().describe()
         return {
             FSwitch.NUM_LENSES_FIELD_NAME: DataKey(
@@ -83,7 +83,7 @@ class FSwitch(StandardReadable):
             **default_describe,
         }
 
-    async def read(self) -> Dict[str, Reading]:
+    async def read(self) -> dict[str, Reading]:
         result = await asyncio.gather(
             *(filter.get_value() for filter in self.filters.values())
         )