Test ophyd async speedup

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.8.0a2",
+    "ophyd-async @ git+https://github.com/bluesky/ophyd-async.git@connect-mock-speed",
     "bluesky",
     "pyepics",
     "dataclasses-json",
@@ -24,10 +24,10 @@ dependencies = [
     "requests",
     "graypy",
     "pydantic>=2.0",
-    "opencv-python-headless",    # For pin-tip detection.
-    "aioca",                     # Required for CA support with ophyd-async.
-    "p4p",                       # Required for PVA support with ophyd-async.
-    "numpy<2.0",                 # Unpin when https://github.com/bluesky/ophyd-async/issues/387 resolved
+    "opencv-python-headless",                                                          # For pin-tip detection.
+    "aioca",                                                                           # Required for CA support with ophyd-async.
+    "p4p",                                                                             # Required for PVA support with ophyd-async.
+    "numpy<2.0",                                                                       # Unpin when https://github.com/bluesky/ophyd-async/issues/387 resolved
     "aiofiles",
     "aiohttp",
     "redis",
@@ -92,7 +92,7 @@ version_file = "src/dodal/_version.py"
 
 [tool.pyright]
 typeCheckingMode = "standard"
-reportMissingImports = false # Ignore missing stubs in imported modules
+reportMissingImports = false  # Ignore missing stubs in imported modules
 
 [tool.pytest.ini_options]
 # Run pytest with all our checkers, and don't spam us with massive tracebacks on error

src/dodal/devices/CTAB.py

@@ -1,6 +1,6 @@
 from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r
 
 
 class CTAB(StandardReadable):

src/dodal/devices/aperture.py

@@ -1,6 +1,6 @@
 from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r
 
 
 class Aperture(StandardReadable):

src/dodal/devices/aperturescatterguard.py

@@ -5,8 +5,8 @@
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
-    HintedSignal,
     StandardReadable,
+    StandardReadableFormat,
     StrictEnum,
 )
 from pydantic import BaseModel, Field
@@ -132,7 +132,7 @@ def __init__(
                 self.radius,
             ],
         )
-        with self.add_children_as_readables(HintedSignal):
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.selected_aperture = create_hardware_backed_soft_signal(
                 ApertureValue, self._get_current_aperture_position
             )

src/dodal/devices/apple2_undulator.py

@@ -7,14 +7,14 @@
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
-    ConfigSignal,
-    HintedSignal,
+    Reference,
     StandardReadable,
+    StandardReadableFormat,
     StrictEnum,
     soft_signal_r_and_setter,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_w
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
 from pydantic import BaseModel, ConfigDict, RootModel
 
 from dodal.log import LOGGER
@@ -128,12 +128,12 @@ def __init__(self, prefix: str, name: str = ""):
         )
         # This is calculated acceleration from speed
         self.acceleration_time = epics_signal_r(float, prefix + "IDGSETACC")
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Unit
             self.motor_egu = epics_signal_r(str, prefix + "BLGAPMTR.EGU")
             # Gap velocity
             self.velocity = epics_signal_rw(float, prefix + "BLGSETVEL")
-        with self.add_children_as_readables(HintedSignal):
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             # Gap readback value
             self.user_readback = epics_signal_r(float, prefix + "CURRGAPD")
         super().__init__(name)
@@ -187,10 +187,10 @@ def __init__(self, prefix: str, infix: str, name: str = ""):
         self.user_setpoint_demand_readback = epics_signal_r(float, fullPV + "DMD")
 
         fullPV = fullPV + "MTR"
-        with self.add_children_as_readables(HintedSignal):
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.user_setpoint_readback = epics_signal_r(float, fullPV + ".RBV")
 
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.motor_egu = epics_signal_r(str, fullPV + ".EGU")
             self.velocity = epics_signal_rw(float, fullPV + ".VELO")
 
@@ -388,10 +388,9 @@ def __init__(
 
         # Attributes are set after super call so they are not renamed to
         # <name>-undulator, etc.
-        with self.add_children_as_readables():
-            self.gap = id_gap
-            self.phase = id_phase
-        with self.add_children_as_readables(HintedSignal):
+        self.gap = Reference(id_gap)
+        self.phase = Reference(id_phase)
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             # Store the polarisation for readback.
             self.polarisation, self._polarisation_set = soft_signal_r_and_setter(
                 str, initial_value=None
@@ -437,27 +436,29 @@ async def _set(self, value: Apple2Val, energy: float) -> None:
         """
 
         # Only need to check gap as the phase motors share both fault and gate with gap.
-        await self.gap.check_id_status()
+        await self.gap().check_id_status()
         await asyncio.gather(
-            self.phase.top_outer.user_setpoint.set(value=value.top_outer),
-            self.phase.top_inner.user_setpoint.set(value=value.top_inner),
-            self.phase.btm_inner.user_setpoint.set(value=value.btm_inner),
-            self.phase.btm_outer.user_setpoint.set(value=value.btm_outer),
-            self.gap.user_setpoint.set(value=value.gap),
+            self.phase().top_outer.user_setpoint.set(value=value.top_outer),
+            self.phase().top_inner.user_setpoint.set(value=value.top_inner),
+            self.phase().btm_inner.user_setpoint.set(value=value.btm_inner),
+            self.phase().btm_outer.user_setpoint.set(value=value.btm_outer),
+            self.gap().user_setpoint.set(value=value.gap),
         )
         timeout = np.max(
-            await asyncio.gather(self.gap.get_timeout(), self.phase.get_timeout())
+            await asyncio.gather(self.gap().get_timeout(), self.phase().get_timeout())
         )
         LOGGER.info(
             f"Moving f{self.name} energy and polorisation to {energy}, {self.pol}"
             + f"with motor position {value}, timeout = {timeout}"
         )
 
         await asyncio.gather(
-            self.gap.set_move.set(value=1, timeout=timeout),
-            self.phase.set_move.set(value=1, timeout=timeout),
+            self.gap().set_move.set(value=1, timeout=timeout),
+            self.phase().set_move.set(value=1, timeout=timeout),
+        )
+        await wait_for_value(
+            self.gap().gate, UndulatorGateStatus.close, timeout=timeout
         )
-        await wait_for_value(self.gap.gate, UndulatorGateStatus.close, timeout=timeout)
         self._energy_set(energy)  # Update energy for after move for readback.
 
     def _get_id_gap_phase(self, energy: float) -> tuple[float, float]:
@@ -522,12 +523,11 @@ async def determinePhaseFromHardware(self) -> tuple[str | None, float]:
         (May be for future one can use the inverse poly to work out the energy and try to match it with the current energy
         to workout the polarisation but during my test the inverse poly is too unstable for general use.)
         """
-        cur_loc = await self.read()
-        top_outer = cur_loc[self.phase.top_outer.user_setpoint_readback.name]["value"]
-        top_inner = cur_loc[self.phase.top_inner.user_setpoint_readback.name]["value"]
-        btm_inner = cur_loc[self.phase.btm_inner.user_setpoint_readback.name]["value"]
-        btm_outer = cur_loc[self.phase.btm_outer.user_setpoint_readback.name]["value"]
-        gap = cur_loc[self.gap.user_readback.name]["value"]
+        top_outer = await self.phase().top_outer.user_setpoint_readback.get_value()
+        top_inner = await self.phase().top_inner.user_setpoint_readback.get_value()
+        btm_inner = await self.phase().btm_inner.user_setpoint_readback.get_value()
+        btm_outer = await self.phase().btm_outer.user_setpoint_readback.get_value()
+        gap = await self.gap().user_readback.get_value()
         if gap > MAXIMUM_GAP_MOTOR_POSITION:
             raise RuntimeError(
                 f"{self.name} is not in use, close gap or set polarisation to use this ID"

src/dodal/devices/areadetector/plugins/CAM.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import StandardReadable, StrictEnum
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 
 class ColorMode(StrictEnum):

src/dodal/devices/areadetector/plugins/MJPG.py

@@ -6,7 +6,7 @@
 from aiohttp import ClientSession
 from bluesky.protocols import Triggerable
 from ophyd_async.core import AsyncStatus, StandardReadable, soft_signal_rw
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from PIL import Image
 
 from dodal.log import LOGGER

src/dodal/devices/attenuator.py

@@ -9,7 +9,7 @@
     StandardReadable,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_x
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
 
 from dodal.log import LOGGER
 

src/dodal/devices/backlight.py

@@ -2,7 +2,7 @@
 
 from bluesky.protocols import Movable
 from ophyd_async.core import AsyncStatus, StandardReadable, StrictEnum
-from ophyd_async.epics.signal import epics_signal_rw
+from ophyd_async.epics.core import epics_signal_rw
 
 
 class BacklightPower(StrictEnum):

src/dodal/devices/cryostream.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import StandardReadable, StrictEnum
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 
 class InOut(StrictEnum):

src/dodal/devices/dcm.py

@@ -1,8 +1,8 @@
 import numpy as np
 from numpy.typing import NDArray
 from ophyd_async.core import StandardReadable, soft_signal_r_and_setter
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r
 
 from dodal.common.crystal_metadata import (
     CrystalMetadata,

src/dodal/devices/detector/detector_motion.py

@@ -1,6 +1,6 @@
 from ophyd_async.core import Device, StrictEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
 
 class ShutterState(StrictEnum):

src/dodal/devices/diamond_filter.py

@@ -1,8 +1,8 @@
 from typing import Generic, TypeVar
 
 from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_rw
 
 
 class _Filters(StrictEnum):

src/dodal/devices/fast_grid_scan.py

@@ -15,7 +15,7 @@
     StandardReadable,
     wait_for_value,
 )
-from ophyd_async.epics.signal import (
+from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,

src/dodal/devices/fluorescence_detector_motion.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import StandardReadable, StrictEnum
-from ophyd_async.epics.signal import epics_signal_r
+from ophyd_async.epics.core import epics_signal_r
 
 
 class FluorescenceDetectorControlState(StrictEnum):

src/dodal/devices/focusing_mirror.py

@@ -1,20 +1,19 @@
 from ophyd_async.core import (
     AsyncStatus,
-    ConfigSignal,
     Device,
     DeviceVector,
-    HintedSignal,
     StandardReadable,
+    StandardReadableFormat,
     StrictEnum,
     observe_value,
     soft_signal_r_and_setter,
 )
-from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import (
+from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_x,
 )
+from ophyd_async.epics.motor import Motor
 
 from dodal.log import LOGGER
 
@@ -150,8 +149,11 @@ def __init__(
         # regardless of orientation of the mirror
         self.incident_angle = Motor(prefix + "PITCH")
 
-        self.add_readables([self.incident_angle.user_readback], wrapper=HintedSignal)
-        self.add_readables([self.type], wrapper=ConfigSignal)
+        self.add_readables(
+            [self.incident_angle.user_readback],
+            format=StandardReadableFormat.HINTED_SIGNAL,
+        )
+        self.add_readables([self.type], format=StandardReadableFormat.CONFIG_SIGNAL)
         super().__init__(name)
 
 

src/dodal/devices/hutch_shutter.py

@@ -6,7 +6,7 @@
     StrictEnum,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_w
+from ophyd_async.epics.core import epics_signal_r, epics_signal_w
 
 HUTCH_SAFE_FOR_OPERATIONS = 0  # Hutch is locked and can't be entered
 

src/dodal/devices/i10/i10_apple2.py

@@ -8,9 +8,9 @@
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
-    HintedSignal,
     Reference,
     StandardReadable,
+    StandardReadableFormat,
     soft_signal_r_and_setter,
     soft_signal_rw,
 )
@@ -119,7 +119,7 @@ def __init__(
             name=name,
         )
         with self.add_children_as_readables():
-            self.id_jaw_phase = id_jaw_phase
+            self.id_jaw_phase = Reference(id_jaw_phase)
 
     @AsyncStatus.wrap
     async def set(self, value: SupportsFloat) -> None:
@@ -148,8 +148,8 @@ async def set(self, value: SupportsFloat) -> None:
         LOGGER.info(f"Setting polarisation to {self.pol}, with {id_set_val}")
         await self._set(value=id_set_val, energy=value)
         if self.pol != "la":
-            await self.id_jaw_phase.set(0)
-            await self.id_jaw_phase.set_move.set(1)
+            await self.id_jaw_phase().set(0)
+            await self.id_jaw_phase().set_move.set(1)
 
     def update_lookuptable(self):
         """
@@ -199,7 +199,7 @@ def __init__(
         super().__init__(name=name)
         self.id_ref = Reference(id)
         self.pgm_ref = Reference(pgm)
-        with self.add_children_as_readables(HintedSignal):
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.energy_offset = soft_signal_rw(float, initial_value=0)
 
     @AsyncStatus.wrap
@@ -278,7 +278,7 @@ def __init__(
         self.jaw_phase_from_angle = np.poly1d(jaw_phase_poly_param)
         self.angle_threshold_deg = angle_threshold_deg
         self.jaw_phase_limit = jaw_phase_limit
-        with self.add_children_as_readables(HintedSignal):
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.angle, self._angle_set = soft_signal_r_and_setter(
                 float, initial_value=None
             )
@@ -299,7 +299,7 @@ async def set(self, value: SupportsFloat) -> None:
                 f"jaw_phase position for angle ({value}) is outside permitted range"
                 f" [-{self.jaw_phase_limit}, {self.jaw_phase_limit}]"
             )
-        await self.id_ref().id_jaw_phase.set(jaw_phase)
+        await self.id_ref().id_jaw_phase().set(jaw_phase)
         self._angle_set(value)
 
 

src/dodal/devices/i22/dcm.py

@@ -5,12 +5,12 @@
 from event_model.documents.event_descriptor import DataKey
 from ophyd_async.core import (
     Array1D,
-    ConfigSignal,
     StandardReadable,
+    StandardReadableFormat,
     soft_signal_r_and_setter,
 )
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r
 
 from dodal.common.crystal_metadata import CrystalMetadata
 
@@ -61,7 +61,7 @@ def __init__(
 
         # Soft metadata
         # If supplied include crystal details in output of read_configuration
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.crystal_1_usage, _ = soft_signal_r_and_setter(
                 str, initial_value=crystal_1_metadata.usage
             )