dls-dodal 1.34.1__py3-none-any.whl → 1.36.0__py3-none-any.whl

dodal/devices/ipin.py

@@ -1,11 +1,13 @@
-from ophyd_async.core import HintedSignal, StandardReadable
-from ophyd_async.epics.signal import epics_signal_r
+from ophyd_async.core import StandardReadable, StandardReadableFormat
+from ophyd_async.epics.core import epics_signal_r
 
 
 class IPin(StandardReadable):
     """Simple device to get the ipin reading"""
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        with self.add_children_as_readables(wrapper=HintedSignal):
+        with self.add_children_as_readables(
+            format=StandardReadableFormat.HINTED_SIGNAL
+        ):
             self.pin_readback = epics_signal_r(float, prefix + "I")
         super().__init__(name)

dodal/devices/linkam3.py

@@ -1,20 +1,19 @@
 import asyncio
 import time
-from enum import Enum
 
 from bluesky.protocols import Location
 from ophyd_async.core import (
-    ConfigSignal,
-    HintedSignal,
     StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
     WatchableAsyncStatus,
     WatcherUpdate,
     observe_value,
 )
-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 PumpControl(str, Enum):
+class PumpControl(StrictEnum):
     Manual = "Manual"
     Auto = "Auto"
 
@@ -62,9 +61,10 @@ class Linkam3(StandardReadable):
         # status is a bitfield stored in a double?
         self.status = epics_signal_r(float, prefix + "STATUS:")
 
-        self.add_readables((self.temp,), wrapper=HintedSignal)
+        self.add_readables((self.temp,), format=StandardReadableFormat.HINTED_SIGNAL)
         self.add_readables(
-            (self.ramp_rate, self.speed, self.set_point), wrapper=ConfigSignal
+            (self.ramp_rate, self.speed, self.set_point),
+            format=StandardReadableFormat.CONFIG_SIGNAL,
         )
 
         super().__init__(name=name)

dodal/devices/oav/oav_detector.py

@@ -1,7 +1,7 @@
 from enum import IntEnum
 
-from ophyd_async.core import DEFAULT_TIMEOUT, AsyncStatus, StandardReadable
-from ophyd_async.epics.signal import epics_signal_rw
+from ophyd_async.core import DEFAULT_TIMEOUT, AsyncStatus, LazyMock, StandardReadable
+from ophyd_async.epics.core import epics_signal_rw
 
 from dodal.common.signal_utils import create_hardware_backed_soft_signal
 from dodal.devices.areadetector.plugins.CAM import Cam
@@ -118,7 +118,7 @@ class OAV(StandardReadable):
 
     async def connect(
         self,
-        mock: bool = False,
+        mock: bool | LazyMock = False,
         timeout: float = DEFAULT_TIMEOUT,
         force_reconnect: bool = False,
     ):

dodal/devices/oav/oav_to_redis_forwarder.py

@@ -14,7 +14,7 @@ from ophyd_async.core import (
     soft_signal_r_and_setter,
     soft_signal_rw,
 )
-from ophyd_async.epics.signal import epics_signal_r
+from ophyd_async.epics.core import epics_signal_r
 from redis.asyncio import StrictRedis
 
 from dodal.log import LOGGER
@@ -42,6 +42,7 @@ class OAVSource(StandardReadable):
     ):
         self.url = epics_signal_r(str, f"{prefix}MJPG_URL_RBV")
         self.oav_name = oav_name
+        super().__init__()
 
 
 class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
@@ -78,13 +79,13 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
         """
         self.counter = epics_signal_r(int, f"{prefix}CAM:ArrayCounter_RBV")
 
-        self._sources = DeviceVector(
+        self.sources = DeviceVector(
             {
                 Source.ROI.value: OAVSource(f"{prefix}MJPG:", "roi"),
                 Source.FULL_SCREEN.value: OAVSource(f"{prefix}XTAL:", "fullscreen"),
             }
         )
-        self.selected_source = soft_signal_rw(Source)
+        self.selected_source = soft_signal_rw(int)
 
         self.forwarding_task = None
         self.redis_client = StrictRedis(
@@ -118,11 +119,11 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
     async def _open_connection_and_do_function(
         self, function_to_do: Callable[[ClientResponse, OAVSource], Awaitable]
     ):
-        source_name = await self.selected_source.get_value()
+        source_idx = await self.selected_source.get_value()
         LOGGER.info(
-            f"Forwarding data from sample {await self.sample_id.get_value()} and OAV {source_name}"
+            f"Forwarding data from sample {await self.sample_id.get_value()} and OAV {source_idx}"
         )
-        source = self._sources[source_name.value]
+        source = self.sources[source_idx]
         stream_url = await source.url.get_value()
         async with ClientSession() as session:
             async with session.get(stream_url) as response:
@@ -164,7 +165,7 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
     async def stop(self, success=True):
         if self.forwarding_task:
             LOGGER.info(
-                f"Stopping forwarding for {await self.selected_source.get_value()}"
+                f"Stopping forwarding for source id {await self.selected_source.get_value()}"
             )
             self._stop_flag.set()
             await self.forwarding_task

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -4,14 +4,15 @@ import time
 import numpy as np
 from numpy.typing import NDArray
 from ophyd_async.core import (
+    Array1D,
     AsyncStatus,
-    HintedSignal,
     StandardReadable,
+    StandardReadableFormat,
     observe_value,
     soft_signal_r_and_setter,
     soft_signal_rw,
 )
-from ophyd_async.epics.signal import epics_signal_r
+from ophyd_async.epics.core import epics_signal_r
 
 from dodal.devices.oav.pin_image_recognition.utils import (
     ARRAY_PROCESSING_FUNCTIONS_MAP,
@@ -22,7 +23,8 @@ from dodal.devices.oav.pin_image_recognition.utils import (
 )
 from dodal.log import LOGGER
 
-Tip = tuple[int | None, int | None]
+# Tip position in x, y pixel coordinates
+Tip = Array1D[np.int32]
 
 
 class InvalidPinException(Exception):
@@ -45,7 +47,7 @@ class PinTipDetection(StandardReadable):
     no tip is found after this time it will not error but instead return {INVALID_POSITION}.
     """
 
-    INVALID_POSITION = (None, None)
+    INVALID_POSITION = np.array([np.iinfo(np.int32).min, np.iinfo(np.int32).min])
 
     def __init__(self, prefix: str, name: str = ""):
         self._prefix: str = prefix
@@ -84,16 +86,16 @@ class PinTipDetection(StandardReadable):
                 self.triggered_top_edge,
                 self.triggered_bottom_edge,
             ],
-            wrapper=HintedSignal,
+            format=StandardReadableFormat.HINTED_SIGNAL,
         )
 
         super().__init__(name=name)
 
     def _set_triggered_values(self, results: SampleLocation):
-        tip = (results.tip_x, results.tip_y)
-        if tip == self.INVALID_POSITION:
+        if results.tip_x is None or results.tip_y is None:
             raise InvalidPinException
         else:
+            tip = np.array([results.tip_x, results.tip_y])
             self._tip_setter(tip)
         self._top_edge_setter(results.edge_top)
         self._bottom_edge_setter(results.edge_bottom)

dodal/devices/oav/snapshots/grid_overlay.py

@@ -14,7 +14,7 @@ def _add_parallel_lines_to_image(
     start_x: int,
     start_y: int,
     line_length: int,
-    spacing: int,
+    spacing: float,
     num_lines: int,
     orientation=Orientation.horizontal,
 ):
@@ -32,7 +32,7 @@ def _add_parallel_lines_to_image(
         start_x (int): The x coordinate (in pixels) of the start of the initial line.
         start_y (int): The y coordinate (in pixels) of the start of the initial line.
         line_length (int): The length of each of the parallel lines in pixels.
-        spacing (int): The spacing, in pixels, between each parallel line. Strictly, \
+        spacing (float): The spacing, in pixels, between each parallel line. Strictly, \
             there are spacing-1 pixels between each line
         num_lines (int): The total number of parallel lines to draw.
         orientation (Orientation): The orientation (horizontal or vertical) of the \
@@ -40,13 +40,13 @@ def _add_parallel_lines_to_image(
     lines = [
         (
             (
-                (start_x, start_y + i * spacing),
-                (start_x + line_length, start_y + i * spacing),
+                (start_x, start_y + int(i * spacing)),
+                (start_x + line_length, start_y + int(i * spacing)),
             )
             if orientation == Orientation.horizontal
             else (
-                (start_x + i * spacing, start_y),
-                (start_x + i * spacing, start_y + line_length),
+                (start_x + int(i * spacing), start_y),
+                (start_x + int(i * spacing), start_y + line_length),
             )
         )
         for i in range(num_lines)
@@ -70,7 +70,7 @@ def add_grid_border_overlay_to_image(
     image: Image.Image,
     top_left_x: int,
     top_left_y: int,
-    box_width: int,
+    box_width: float,
     num_boxes_x: int,
     num_boxes_y: int,
 ):
@@ -78,16 +78,16 @@ def add_grid_border_overlay_to_image(
         image,
         start_x=top_left_x,
         start_y=top_left_y,
-        line_length=num_boxes_y * box_width,
-        spacing=num_boxes_x * box_width,
+        line_length=int(num_boxes_y * box_width),
+        spacing=int(num_boxes_x * box_width),
         num_lines=2,
     )
     _add_horizontal_parallel_lines_to_image(
         image,
         start_x=top_left_x,
         start_y=top_left_y,
-        line_length=num_boxes_x * box_width,
-        spacing=num_boxes_y * box_width,
+        line_length=int(num_boxes_x * box_width),
+        spacing=int(num_boxes_y * box_width),
         num_lines=2,
     )
 
@@ -96,23 +96,23 @@ def add_grid_overlay_to_image(
     image: Image.Image,
     top_left_x: int,
     top_left_y: int,
-    box_width: int,
+    box_width: float,
     num_boxes_x: int,
     num_boxes_y: int,
 ):
     _add_vertical_parallel_lines_to_image(
         image,
-        start_x=top_left_x + box_width,
+        start_x=int(top_left_x + box_width),
         start_y=top_left_y,
-        line_length=num_boxes_y * box_width,
+        line_length=int(num_boxes_y * box_width),
         spacing=box_width,
         num_lines=num_boxes_x - 1,
     )
     _add_horizontal_parallel_lines_to_image(
         image,
         start_x=top_left_x,
-        start_y=top_left_y + box_width,
-        line_length=num_boxes_x * box_width,
+        start_y=int(top_left_y + box_width),
+        line_length=int(num_boxes_x * box_width),
         spacing=box_width,
         num_lines=num_boxes_y - 1,
     )

dodal/devices/oav/snapshots/snapshot_with_beam_centre.py

@@ -1,4 +1,4 @@
-from ophyd_async.core import SignalR
+from ophyd_async.core import Reference, SignalR
 from PIL import Image, ImageDraw
 
 from dodal.devices.areadetector.plugins.MJPG import MJPG
@@ -52,13 +52,13 @@ class SnapshotWithBeamCentre(MJPG):
         name: str = "",
     ) -> None:
         with self.add_children_as_readables():
-            self.beam_centre_i = beam_x_signal
-            self.beam_centre_j = beam_y_signal
+            self._beam_centre_i_ref = Reference(beam_x_signal)
+            self._beam_centre_j_ref = Reference(beam_y_signal)
         super().__init__(prefix, name)
 
     async def post_processing(self, image: Image.Image):
-        beam_x = await self.beam_centre_i.get_value()
-        beam_y = await self.beam_centre_j.get_value()
+        beam_x = await self._beam_centre_i_ref().get_value()
+        beam_y = await self._beam_centre_j_ref().get_value()
         draw_crosshair(image, beam_x, beam_y)
 
         await self._save_image(image)

dodal/devices/oav/snapshots/snapshot_with_grid.py

@@ -14,9 +14,9 @@ from dodal.log import LOGGER
 class SnapshotWithGrid(MJPG):
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
-            self.top_left_x = soft_signal_rw(int)
-            self.top_left_y = soft_signal_rw(int)
-            self.box_width = soft_signal_rw(int)
+            self.top_left_x = soft_signal_rw(float)
+            self.top_left_y = soft_signal_rw(float)
+            self.box_width = soft_signal_rw(float)
             self.num_boxes_x = soft_signal_rw(int)
             self.num_boxes_y = soft_signal_rw(int)
 
@@ -31,7 +31,7 @@ class SnapshotWithGrid(MJPG):
 
         top_left_x = await self.top_left_x.get_value()
         top_left_y = await self.top_left_y.get_value()
-        box_witdh = await self.box_width.get_value()
+        box_width = await self.box_width.get_value()
         num_boxes_x = await self.num_boxes_x.get_value()
         num_boxes_y = await self.num_boxes_y.get_value()
 
@@ -39,7 +39,7 @@ class SnapshotWithGrid(MJPG):
         assert isinstance(directory_str := await self.directory.get_value(), str)
 
         add_grid_border_overlay_to_image(
-            image, top_left_x, top_left_y, box_witdh, num_boxes_x, num_boxes_y
+            image, int(top_left_x), int(top_left_y), box_width, num_boxes_x, num_boxes_y
         )
 
         path = path_join(directory_str, f"{filename_str}_outer_overlay.{IMG_FORMAT}")
@@ -48,7 +48,7 @@ class SnapshotWithGrid(MJPG):
         await asyncio_save_image(image, path)
 
         add_grid_overlay_to_image(
-            image, top_left_x, top_left_y, box_witdh, num_boxes_x, num_boxes_y
+            image, int(top_left_x), int(top_left_y), box_width, num_boxes_x, num_boxes_y
         )
 
         path = path_join(directory_str, f"{filename_str}_grid_overlay.{IMG_FORMAT}")

dodal/devices/oav/utils.py

@@ -103,8 +103,8 @@ def wait_for_tip_to_be_found(
 ) -> Generator[Msg, None, Pixel]:
     yield from bps.trigger(ophyd_pin_tip_detection, wait=True)
     found_tip = yield from bps.rd(ophyd_pin_tip_detection.triggered_tip)
-    if found_tip == ophyd_pin_tip_detection.INVALID_POSITION:
+    if all(found_tip == ophyd_pin_tip_detection.INVALID_POSITION):
         timeout = yield from bps.rd(ophyd_pin_tip_detection.validity_timeout)
         raise PinNotFoundException(f"No pin found after {timeout} seconds")
 
-    return found_tip  # type: ignore
+    return Pixel((int(found_tip[0]), int(found_tip[1])))

dodal/devices/p99/sample_stage.py

@@ -1,7 +1,5 @@
-from enum import Enum
-
-from ophyd_async.core import Device
-from ophyd_async.epics.signal import epics_signal_rw
+from ophyd_async.core import Device, SubsetEnum
+from ophyd_async.epics.core import epics_signal_rw
 
 
 class SampleAngleStage(Device):
@@ -18,7 +16,7 @@ class SampleAngleStage(Device):
         super().__init__(name=name)
 
 
-class p99StageSelections(str, Enum):
+class p99StageSelections(SubsetEnum):
     Empty = "Empty"
     Mn5um = "Mn 5um"
     Fe = "Fe (empty)"

dodal/devices/pgm.py

@@ -1,11 +1,10 @@
-from enum import Enum
-
 from ophyd_async.core import (
-    ConfigSignal,
     StandardReadable,
+    StandardReadableFormat,
+    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 PGM(StandardReadable):
@@ -16,7 +15,7 @@ class PGM(StandardReadable):
     def __init__(
         self,
         prefix: str,
-        grating: type[Enum],
+        grating: type[StrictEnum],
         gratingPv: str,
         name: str = "",
     ) -> None:
@@ -34,7 +33,7 @@ class PGM(StandardReadable):
         """
         with self.add_children_as_readables():
             self.energy = Motor(prefix + "ENERGY")
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.grating = epics_signal_rw(grating, prefix + gratingPv)
             self.cff = epics_signal_rw(float, prefix + "CFF")
 

dodal/devices/qbpm.py

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

dodal/devices/robot.py

@@ -1,16 +1,16 @@
 import asyncio
 from asyncio import FIRST_COMPLETED, CancelledError, Task, wait_for
 from dataclasses import dataclass
-from enum import Enum
 
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
     StandardReadable,
+    StrictEnum,
     set_and_wait_for_value,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw_rbv, epics_signal_x
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv, epics_signal_x
 
 from dodal.log import LOGGER
 
@@ -33,7 +33,7 @@ class SampleLocation:
     pin: int
 
 
-class PinMounted(str, Enum):
+class PinMounted(StrictEnum):
     NO_PIN_MOUNTED = "No Pin Mounted"
     PIN_MOUNTED = "Pin Mounted"
 

dodal/devices/smargon.py

@@ -7,8 +7,8 @@ from typing import cast
 from bluesky import plan_stubs as bps
 from bluesky.utils import Msg
 from ophyd_async.core import AsyncStatus, Device, StandardReadable, wait_for_value
+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.devices.util.epics_util import SetWhenEnabled
 

dodal/devices/synchrotron.py

@@ -1,7 +1,12 @@
 from enum import Enum
 
-from ophyd_async.core import ConfigSignal, StandardReadable, soft_signal_r_and_setter
-from ophyd_async.epics.signal import epics_signal_r
+from ophyd_async.core import (
+    StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
+    soft_signal_r_and_setter,
+)
+from ophyd_async.epics.core import epics_signal_r
 
 
 class Prefix(str, Enum):
@@ -19,7 +24,7 @@ class Suffix(str, Enum):
     END_COUNTDOWN = "ENDCOUNTDN"
 
 
-class SynchrotronMode(str, Enum):
+class SynchrotronMode(StrictEnum):
     SHUTDOWN = "Shutdown"
     INJECTION = "Injection"
     NOBEAM = "No Beam"
@@ -44,7 +49,7 @@ class Synchrotron(StandardReadable):
             self.current = epics_signal_r(float, signal_prefix + Suffix.SIGNAL)
             self.energy = epics_signal_r(float, status_prefix + Suffix.BEAM_ENERGY)
 
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.probe, _ = soft_signal_r_and_setter(str, initial_value="x-ray")
             self.type, _ = soft_signal_r_and_setter(
                 str, initial_value="Synchrotron X-ray Source"

dodal/devices/tetramm.py

@@ -1,5 +1,4 @@
 import asyncio
-from enum import Enum
 
 from bluesky.protocols import Hints
 from ophyd_async.core import (
@@ -9,42 +8,43 @@ from ophyd_async.core import (
     Device,
     PathProvider,
     StandardDetector,
+    StrictEnum,
     TriggerInfo,
     set_and_wait_for_value,
     soft_signal_r_and_setter,
 )
 from ophyd_async.epics.adcore import ADHDFWriter, NDFileHDFIO, stop_busy_record
-from ophyd_async.epics.signal import (
+from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,
 )
 
 
-class TetrammRange(str, Enum):
+class TetrammRange(StrictEnum):
     uA = "+- 120 uA"
     nA = "+- 120 nA"
 
 
-class TetrammTrigger(str, Enum):
+class TetrammTrigger(StrictEnum):
     FreeRun = "Free run"
     ExtTrigger = "Ext. trig."
     ExtBulb = "Ext. bulb"
     ExtGate = "Ext. gate"
 
 
-class TetrammChannels(str, Enum):
+class TetrammChannels(StrictEnum):
     One = "1"
     Two = "2"
     Four = "4"
 
 
-class TetrammResolution(str, Enum):
+class TetrammResolution(StrictEnum):
     SixteenBits = "16 bits"
     TwentyFourBits = "24 bits"
 
 
-class TetrammGeometry(str, Enum):
+class TetrammGeometry(StrictEnum):
     Diamond = "Diamond"
     Square = "Square"
 

dodal/devices/thawer.py

@@ -1,36 +1,42 @@
 from asyncio import Task, create_task, sleep
-from enum import Enum
 
 from bluesky.protocols import Stoppable
-from ophyd_async.core import AsyncStatus, Device, SignalRW, StandardReadable
-from ophyd_async.epics.signal import epics_signal_rw
+from ophyd_async.core import (
+    AsyncStatus,
+    Device,
+    Reference,
+    SignalRW,
+    StandardReadable,
+    StrictEnum,
+)
+from ophyd_async.epics.core import epics_signal_rw
 
 
 class ThawingException(Exception):
     pass
 
 
-class ThawerStates(str, Enum):
+class ThawerStates(StrictEnum):
     OFF = "Off"
     ON = "On"
 
 
 class ThawingTimer(Device, Stoppable):
     def __init__(self, control_signal: SignalRW[ThawerStates]) -> None:
-        self._control_signal = control_signal
+        self._control_signal_ref = Reference(control_signal)
         self._thawing_task: Task | None = None
         super().__init__("thaw_for_time_s")
 
     @AsyncStatus.wrap
     async def set(self, time_to_thaw_for: float):
-        await self._control_signal.set(ThawerStates.ON)
+        await self._control_signal_ref().set(ThawerStates.ON)
         if self._thawing_task and not self._thawing_task.done():
             raise ThawingException("Thawing task already in progress")
         self._thawing_task = create_task(sleep(time_to_thaw_for))
         try:
             await self._thawing_task
         finally:
-            await self._control_signal.set(ThawerStates.OFF)
+            await self._control_signal_ref().set(ThawerStates.OFF)
 
     @AsyncStatus.wrap
     async def stop(self, *args, **kwargs):

dodal/devices/undulator.py

@@ -1,17 +1,17 @@
 import os
-from enum import Enum
 
 import numpy as np
 from bluesky.protocols import Movable
 from numpy import argmin, ndarray
 from ophyd_async.core import (
     AsyncStatus,
-    ConfigSignal,
     StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
     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.log import LOGGER
 
@@ -33,7 +33,7 @@ UNDULATOR_DISCREPANCY_THRESHOLD_MM = 2e-3
 STATUS_TIMEOUT_S: float = 10.0
 
 
-class UndulatorGapAccess(str, Enum):
+class UndulatorGapAccess(StrictEnum):
     ENABLED = "ENABLED"
     DISABLED = "DISABLED"
 
@@ -75,7 +75,7 @@ class Undulator(StandardReadable, Movable):
             self.current_gap = epics_signal_r(float, prefix + "CURRGAPD")
             self.gap_access = epics_signal_r(UndulatorGapAccess, prefix + "IDBLENA")
 
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.gap_discrepancy_tolerance_mm, _ = soft_signal_r_and_setter(
                 float,
                 initial_value=UNDULATOR_DISCREPANCY_THRESHOLD_MM,

dodal/devices/util/epics_util.py

@@ -7,7 +7,7 @@ from ophyd import Device as OphydDevice
 from ophyd.status import Status, StatusBase
 from ophyd_async.core import AsyncStatus, wait_for_value
 from ophyd_async.core import Device as OphydAsyncDevice
-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 dodal.log import LOGGER