Update to latest ophyd async (#1143)

* Fix import errors

* Fix tests

* Remove ophyd-async pin

* Skip broken test

* Fix types for amplifiers

* Fix minor typing issue

* Use Motor types in motor_utils

Author: DominicOram

pyproject.toml

@@ -15,8 +15,7 @@ description = "Ophyd devices and other utils that could be used across DLS beaml
 dependencies = [
     "click",
     "ophyd",
-    # Pinned due to https://github.com/DiamondLightSource/dodal/issues/1141
-    "ophyd-async == 0.9.0",
+    "ophyd-async>=0.10.0a1",
     "bluesky",
     "pyepics",
     "dataclasses-json",

src/dodal/devices/current_amplifiers/current_amplifier.py

@@ -23,15 +23,13 @@ def __init__(self, gain_conversion_table: type[Enum], name: str = "") -> None:
         super().__init__(name)
 
     @abstractmethod
-    @AsyncStatus.wrap
     async def increase_gain(self, value: int = 1) -> None:
         """Increase gain, increment by 1 by default.
 
         Returns:
             bool: True if success.
         """
 
-    @AsyncStatus.wrap
     @abstractmethod
     async def decrease_gain(self, value: int = 1) -> None:
         """Decrease gain, decrement by 1 by default.
@@ -40,21 +38,18 @@ async def decrease_gain(self, value: int = 1) -> None:
             bool: True if success.
         """
 
-    @AsyncStatus.wrap
     @abstractmethod
-    async def get_gain(self) -> type[Enum]:
+    async def get_gain(self) -> Enum:
         """Get the current gain setting
 
         Returns:
             Enum: The member name of the current gain setting in gain_conversion_table.
         """
 
-    @AsyncStatus.wrap
     @abstractmethod
     async def get_upperlimit(self) -> float:
         """Get the upper limit of the current amplifier"""
 
-    @AsyncStatus.wrap
     @abstractmethod
     async def get_lowerlimit(self) -> float:
         """Get the lower limit of the current amplifier"""

src/dodal/devices/current_amplifiers/current_amplifier_detector.py

@@ -92,8 +92,8 @@ async def get_corrected_current(self) -> float:
             self.current_amp().get_gain(),
             self.counter().get_voltage_per_sec(),
         )
-        correction_factor = current_gain.value
-        corrected_current = voltage_per_sec / correction_factor
+        assert isinstance(current_gain.value, float)
+        corrected_current = voltage_per_sec / current_gain.value
         return corrected_current
 
     @AsyncStatus.wrap

src/dodal/devices/current_amplifiers/femto.py

@@ -114,30 +114,25 @@ async def set(self, value) -> None:
         # wait for current amplifier's bandpass filter to settle.
         await asyncio.sleep(self.raise_timetable[SEN_setting].value)
 
-    @AsyncStatus.wrap
     async def increase_gain(self, value: int = 1) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain += value
         if current_gain > len(self.gain_table):
             raise ValueError("Gain at max value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def decrease_gain(self, value: int = 1) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain -= value
         if current_gain < 1:
             raise ValueError("Gain at min value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def get_gain(self) -> Enum:
         return self.gain_conversion_table[(await self.gain.get_value()).name]
 
-    @AsyncStatus.wrap
     async def get_upperlimit(self) -> float:
         return self.upperlimit
 
-    @AsyncStatus.wrap
     async def get_lowerlimit(self) -> float:
         return self.lowerlimit

src/dodal/devices/current_amplifiers/sr570.py

@@ -178,7 +178,6 @@ async def set(self, value) -> None:
         )
         await asyncio.sleep(self.raise_timetable[coarse_gain.name].value)
 
-    @AsyncStatus.wrap
     async def increase_gain(self, value=3) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain += value
@@ -189,7 +188,6 @@ async def increase_gain(self, value=3) -> None:
             raise ValueError("Gain at max value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def decrease_gain(self, value=3) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain -= value
@@ -198,17 +196,14 @@ async def decrease_gain(self, value=3) -> None:
             raise ValueError("Gain at min value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def get_gain(self) -> Enum:
         result = await asyncio.gather(
             self.coarse_gain.get_value(), self.fine_gain.get_value()
         )
         return self.gain_conversion_table[self.combined_table(result).name]
 
-    @AsyncStatus.wrap
     async def get_upperlimit(self) -> float:
         return self.upperlimit
 
-    @AsyncStatus.wrap
     async def get_lowerlimit(self) -> float:
         return self.lowerlimit

src/dodal/devices/i13_1/merlin.py

@@ -3,7 +3,6 @@
 
 from dodal.common.beamlines.device_helpers import CAM_SUFFIX, HDF5_SUFFIX
 from dodal.devices.i13_1.merlin_controller import MerlinController
-from dodal.devices.i13_1.merlin_io import MerlinDriverIO
 
 
 class Merlin(StandardDetector):
@@ -18,7 +17,7 @@ def __init__(
         fileio_suffix=HDF5_SUFFIX,
         name: str = "",
     ):
-        self.drv = MerlinDriverIO(prefix + drv_suffix)
+        self.drv = adcore.ADBaseIO(prefix + drv_suffix)
         self.hdf = adcore.NDFileHDFIO(prefix + fileio_suffix)
 
         super().__init__(

src/dodal/devices/i13_1/merlin_controller.py

@@ -6,17 +6,21 @@
     AsyncStatus,
     TriggerInfo,
 )
-from ophyd_async.epics import adcore
-from ophyd_async.epics.adcore import ADBaseController
-
-from dodal.devices.i13_1.merlin_io import MerlinDriverIO, MerlinImageMode
+from ophyd_async.epics.adcore import (
+    DEFAULT_GOOD_STATES,
+    ADBaseController,
+    ADBaseIO,
+    ADImageMode,
+    ADState,
+    stop_busy_record,
+)
 
 
 class MerlinController(ADBaseController):
     def __init__(
         self,
-        driver: MerlinDriverIO,
-        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+        driver: ADBaseIO,
+        good_states: frozenset[ADState] = DEFAULT_GOOD_STATES,
     ) -> None:
         self.driver = driver
         self.good_states = good_states
@@ -34,7 +38,7 @@ async def prepare(self, trigger_info: TriggerInfo):
         )
         await asyncio.gather(
             self.driver.num_images.set(trigger_info.total_number_of_triggers),
-            self.driver.image_mode.set(MerlinImageMode.MULTIPLE),
+            self.driver.image_mode.set(ADImageMode.MULTIPLE),
         )
 
     async def wait_for_idle(self):
@@ -44,4 +48,4 @@ async def wait_for_idle(self):
     async def disarm(self):
         # We can't use caput callback as we already used it in arm() and we can't have
         # 2 or they will deadlock
-        await adcore.stop_busy_record(self.driver.acquire, False, timeout=1)
+        await stop_busy_record(self.driver.acquire, False, timeout=1)

src/dodal/devices/i13_1/merlin_io.py

@@ -6,7 +6,7 @@
 from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
 from ophyd_async.core import PathProvider
-from ophyd_async.epics.adaravis import AravisController, AravisDetector
+from ophyd_async.epics.adaravis import AravisDetector
 from ophyd_async.epics.adpilatus import PilatusDetector
 
 ValueAndUnits = tuple[float, str]
@@ -149,7 +149,6 @@ def __init__(
         fileio_suffix: str,
         metadata_holder: NXSasMetadataHolder,
         name: str = "",
-        gpio_number: AravisController.GPIO_NUMBER = 1,
     ):
         """Extends detector with configuration metadata required or desired
         to comply with the NXsas application definition.
@@ -162,7 +161,6 @@ def __init__(
             drv_suffix=drv_suffix,
             fileio_suffix=fileio_suffix,
             name=name,
-            gpio_number=gpio_number,
         )
         self._metadata_holder = metadata_holder
 

src/dodal/devices/i22/nxsas.py

@@ -1,21 +1,21 @@
 import uuid
 from collections.abc import Generator
-from typing import Any, TypeVar, cast
+from typing import Any
 
 from bluesky import plan_stubs as bps
 from bluesky.preprocessors import finalize_wrapper, pchain
 from bluesky.utils import Msg, MsgGenerator, make_decorator
 from ophyd_async.core import Device
 from ophyd_async.epics.motor import Motor
 
-from dodal.utils import MovableReadable
-
-MovableReadableDevice = TypeVar("MovableReadableDevice", bound=MovableReadable)
-
 
 class MoveTooLarge(Exception):
     def __init__(
-        self, axis: MovableReadable, maximum_move: float, position: float, *args: object
+        self,
+        axis: Motor,
+        maximum_move: float,
+        position: float,
+        *args: object,
     ) -> None:
         self.axis = axis
         self.maximum_move = maximum_move
@@ -24,10 +24,10 @@ def __init__(
 
 
 def check_and_cache_values(
-    devices_and_positions: dict[MovableReadableDevice, float],
+    devices_and_positions: dict[Motor, float],
     smallest_move: float,
     maximum_move: float,
-) -> Generator[Msg, Any, dict[MovableReadableDevice, float]]:
+) -> Generator[Msg, Any, dict[Motor, float]]:
     """Caches the positions of all Motors on specified device if they are within
     smallest_move of home_position. Throws MoveTooLarge if they are outside maximum_move
     of the home_position
@@ -51,9 +51,7 @@ def home_and_reset_wrapper(
     wait_for_all: bool = True,
 ) -> MsgGenerator:
     home_positions = {
-        cast(MovableReadable, axis): 0.0
-        for _, axis in device.children()
-        if isinstance(axis, Motor)
+        axis: 0.0 for _, axis in device.children() if isinstance(axis, Motor)
     }
     return move_and_reset_wrapper(
         plan, home_positions, smallest_move, maximum_move, group, wait_for_all
@@ -62,7 +60,7 @@ def home_and_reset_wrapper(
 
 def move_and_reset_wrapper(
     plan: MsgGenerator,
-    device_and_positions: dict[MovableReadable, float],
+    device_and_positions: dict[Motor, float],
     smallest_move: float,
     maximum_move: float,
     group: str | None = None,