dls-dodal 1.29.4__py3-none-any.whl → 1.31.0__py3-none-any.whl

dodal/devices/aperturescatterguard.py

@@ -1,226 +1,147 @@
+from __future__ import annotations
+
 import asyncio
-from collections import OrderedDict, namedtuple
-from dataclasses import asdict, dataclass
 from enum import Enum
 
-from bluesky.protocols import Movable, Reading
-from ophyd_async.core import AsyncStatus, SignalR, StandardReadable
-from ophyd_async.core.soft_signal_backend import SoftConverter, SoftSignalBackend
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    AsyncStatus,
+    HintedSignal,
+    StandardReadable,
+    soft_signal_rw,
+)
+from pydantic import BaseModel, Field
 
+from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
 from dodal.devices.aperture import Aperture
 from dodal.devices.scatterguard import Scatterguard
-from dodal.log import LOGGER
 
 
 class InvalidApertureMove(Exception):
     pass
 
 
-ApertureFiveDimensionalLocation = namedtuple(
-    "ApertureFiveDimensionalLocation",
-    [
-        "aperture_x",
-        "aperture_y",
-        "aperture_z",
-        "scatterguard_x",
-        "scatterguard_y",
-    ],
-)
-
+class AperturePosition(BaseModel):
+    aperture_x: float
+    aperture_y: float
+    aperture_z: float
+    scatterguard_x: float
+    scatterguard_y: float
+    radius: float | None = Field(json_schema_extra={"units": "µm"}, default=None)
+
+    @property
+    def values(self) -> tuple[float, float, float, float, float]:
+        return (
+            self.aperture_x,
+            self.aperture_y,
+            self.aperture_z,
+            self.scatterguard_x,
+            self.scatterguard_y,
+        )
 
-@dataclass
-class ApertureScatterguardTolerances:
-    ap_x: float
-    ap_y: float
-    ap_z: float
-    sg_x: float
-    sg_y: float
-
-
-@dataclass
-class SingleAperturePosition:
-    # Default values are needed as ophyd_async sim does not respect initial_values of
-    # soft signal backends see https://github.com/bluesky/ophyd-async/issues/266
-    name: str = ""
-    GDA_name: str = ""
-    radius_microns: float | None = None
-    location: ApertureFiveDimensionalLocation = ApertureFiveDimensionalLocation(
-        0, 0, 0, 0, 0
-    )
-
-
-# Use StrEnum once we stop python 3.10 support
-class AperturePositionGDANames(str, Enum):
-    LARGE_APERTURE = "LARGE_APERTURE"
-    MEDIUM_APERTURE = "MEDIUM_APERTURE"
-    SMALL_APERTURE = "SMALL_APERTURE"
-    ROBOT_LOAD = "ROBOT_LOAD"
+    @staticmethod
+    def tolerances_from_gda_params(
+        params: GDABeamlineParameters,
+    ) -> AperturePosition:
+        return AperturePosition(
+            aperture_x=params["miniap_x_tolerance"],
+            aperture_y=params["miniap_y_tolerance"],
+            aperture_z=params["miniap_z_tolerance"],
+            scatterguard_x=params["sg_x_tolerance"],
+            scatterguard_y=params["sg_y_tolerance"],
+        )
 
-    def __str__(self):
-        return str(self.value)
-
-
-def position_from_params(
-    name: str,
-    GDA_name: AperturePositionGDANames,
-    radius_microns: float | None,
-    params: dict,
-) -> SingleAperturePosition:
-    return SingleAperturePosition(
-        name,
-        GDA_name,
-        radius_microns,
-        ApertureFiveDimensionalLocation(
-            params[f"miniap_x_{GDA_name}"],
-            params[f"miniap_y_{GDA_name}"],
-            params[f"miniap_z_{GDA_name}"],
-            params[f"sg_x_{GDA_name}"],
-            params[f"sg_y_{GDA_name}"],
-        ),
-    )
-
-
-def tolerances_from_params(params: dict) -> ApertureScatterguardTolerances:
-    return ApertureScatterguardTolerances(
-        ap_x=params["miniap_x_tolerance"],
-        ap_y=params["miniap_y_tolerance"],
-        ap_z=params["miniap_z_tolerance"],
-        sg_x=params["sg_x_tolerance"],
-        sg_y=params["sg_y_tolerance"],
-    )
-
-
-@dataclass
-class AperturePositions:
-    """Holds the motor positions needed to select a particular aperture size. This class should be instantiated with definitions for its sizes
-    using from_gda_beamline_params"""
-
-    LARGE: SingleAperturePosition
-    MEDIUM: SingleAperturePosition
-    SMALL: SingleAperturePosition
-    ROBOT_LOAD: SingleAperturePosition
-
-    tolerances: ApertureScatterguardTolerances
-
-    UNKNOWN = SingleAperturePosition(
-        "Unknown", "UNKNOWN", None, ApertureFiveDimensionalLocation(0, 0, 0, 0, 0)
-    )
-
-    @classmethod
-    def from_gda_beamline_params(cls, params):
-        return cls(
-            LARGE=position_from_params(
-                "Large", AperturePositionGDANames.LARGE_APERTURE, 100, params
-            ),
-            MEDIUM=position_from_params(
-                "Medium", AperturePositionGDANames.MEDIUM_APERTURE, 50, params
-            ),
-            SMALL=position_from_params(
-                "Small", AperturePositionGDANames.SMALL_APERTURE, 20, params
-            ),
-            ROBOT_LOAD=position_from_params(
-                "Robot load", AperturePositionGDANames.ROBOT_LOAD, None, params
-            ),
-            tolerances=tolerances_from_params(params),
+    @staticmethod
+    def from_gda_params(
+        name: ApertureValue,
+        radius: float | None,
+        params: GDABeamlineParameters,
+    ) -> AperturePosition:
+        return AperturePosition(
+            aperture_x=params[f"miniap_x_{name.value}"],
+            aperture_y=params[f"miniap_y_{name.value}"],
+            aperture_z=params[f"miniap_z_{name.value}"],
+            scatterguard_x=params[f"sg_x_{name.value}"],
+            scatterguard_y=params[f"sg_y_{name.value}"],
+            radius=radius,
         )
 
-    def get_position_from_gda_aperture_name(
-        self, gda_aperture_name: AperturePositionGDANames
-    ) -> SingleAperturePosition:
-        apertures = [ap for ap in self.as_list() if ap.GDA_name == gda_aperture_name]
-        if not apertures:
-            raise ValueError(
-                f"Tried to convert unknown aperture name {gda_aperture_name} to a SingleAperturePosition"
-            )
-        else:
-            return apertures[0]
 
-    def as_list(self) -> list[SingleAperturePosition]:
-        return [
-            self.LARGE,
-            self.MEDIUM,
-            self.SMALL,
-            self.ROBOT_LOAD,
-        ]
+class ApertureValue(str, Enum):
+    """Maps from a short usable name to the value name in the GDA Beamline parameters"""
+
+    ROBOT_LOAD = "ROBOT_LOAD"
+    SMALL = "SMALL_APERTURE"
+    MEDIUM = "MEDIUM_APERTURE"
+    LARGE = "LARGE_APERTURE"
+
+
+def load_positions_from_beamline_parameters(
+    params: GDABeamlineParameters,
+) -> dict[ApertureValue, AperturePosition]:
+    return {
+        ApertureValue.ROBOT_LOAD: AperturePosition.from_gda_params(
+            ApertureValue.ROBOT_LOAD, None, params
+        ),
+        ApertureValue.SMALL: AperturePosition.from_gda_params(
+            ApertureValue.SMALL, 20, params
+        ),
+        ApertureValue.MEDIUM: AperturePosition.from_gda_params(
+            ApertureValue.MEDIUM, 50, params
+        ),
+        ApertureValue.LARGE: AperturePosition.from_gda_params(
+            ApertureValue.LARGE, 100, params
+        ),
+    }
 
 
 class ApertureScatterguard(StandardReadable, Movable):
-    def __init__(self, prefix: str = "", name: str = "") -> None:
+    def __init__(
+        self,
+        loaded_positions: dict[ApertureValue, AperturePosition],
+        tolerances: AperturePosition,
+        prefix: str = "",
+        name: str = "",
+    ) -> None:
         self.aperture = Aperture(prefix + "-MO-MAPT-01:")
         self.scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
-        self.aperture_positions: AperturePositions | None = None
-        self.TOLERANCE_STEPS = 3  # Number of MRES steps
-        aperture_backend = SoftSignalBackend(
-            SingleAperturePosition, AperturePositions.UNKNOWN
+        self.radius = soft_signal_rw(float, units="µm")
+        self._loaded_positions = loaded_positions
+        self._tolerances = tolerances
+        self.add_readables(
+            [
+                self.aperture.x.user_readback,
+                self.aperture.y.user_readback,
+                self.aperture.z.user_readback,
+                self.scatterguard.x.user_readback,
+                self.scatterguard.y.user_readback,
+                self.radius,
+            ],
         )
-        aperture_backend.converter = self.ApertureConverter()
-        self.selected_aperture = self.SelectedAperture(backend=aperture_backend)
-        self.set_readable_signals(
-            read=[
-                self.selected_aperture,
-            ]
-        )
-        super().__init__(name)
-
-    class ApertureConverter(SoftConverter):
-        # Ophyd-async #311 should add a default converter for dataclasses to do this
-        def reading(
-            self, value: SingleAperturePosition, timestamp: float, severity: int
-        ) -> Reading:
-            return Reading(
-                value=asdict(value),
-                timestamp=timestamp,
-                alarm_severity=-1 if severity > 2 else severity,
-            )
-
-    class SelectedAperture(SignalR):
-        async def read(self, *args, **kwargs):
-            assert isinstance(self.parent, ApertureScatterguard)
-            await self._backend.put(await self.parent._get_current_aperture_position())
-            return {self.name: await self._backend.get_reading()}
-
-        async def describe(self):
-            return OrderedDict(
-                [
-                    (
-                        self._name,
-                        {
-                            "source": self._backend.source(self._name),  # type: ignore
-                            "dtype": "array",
-                            "shape": [
-                                -1,
-                            ],  # TODO describe properly - see https://github.com/DiamondLightSource/dodal/issues/253
-                        },
-                    ),
-                ],
-            )
+        with self.add_children_as_readables(HintedSignal):
+            self.selected_aperture = soft_signal_rw(ApertureValue)
 
-    def load_aperture_positions(self, positions: AperturePositions):
-        LOGGER.info(f"{self.name} loaded in {positions}")
-        self.aperture_positions = positions
-
-    def set(self, pos: SingleAperturePosition) -> AsyncStatus:
-        assert isinstance(self.aperture_positions, AperturePositions)
-        if pos not in self.aperture_positions.as_list():
-            raise InvalidApertureMove(f"Unknown aperture: {pos}")
+        super().__init__(name)
 
-        return AsyncStatus(self._safe_move_within_datacollection_range(pos.location))
+    def get_position_from_gda_aperture_name(
+        self, gda_aperture_name: str
+    ) -> ApertureValue:
+        return ApertureValue(gda_aperture_name)
 
-    def _get_motor_list(self):
-        return [
-            self.aperture.x,
-            self.aperture.y,
-            self.aperture.z,
-            self.scatterguard.x,
-            self.scatterguard.y,
-        ]
+    @AsyncStatus.wrap
+    async def set(self, value: ApertureValue):
+        position = self._loaded_positions[value]
+        await self._safe_move_within_datacollection_range(position, value)
 
     @AsyncStatus.wrap
-    async def _set_raw_unsafe(self, positions: ApertureFiveDimensionalLocation):
+    async def _set_raw_unsafe(self, position: AperturePosition):
         """Accept the risks and move in an unsafe way. Collisions possible."""
+        if position.radius is not None:
+            await self.radius.set(position.radius)
 
-        # unpacking the position
-        aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = positions
+        aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = (
+            position.values
+        )
 
         await asyncio.gather(
             self.aperture.x.set(aperture_x),
@@ -229,39 +150,41 @@ class ApertureScatterguard(StandardReadable, Movable):
             self.scatterguard.x.set(scatterguard_x),
             self.scatterguard.y.set(scatterguard_y),
         )
+        try:
+            value = await self.get_current_aperture_position()
+            self.selected_aperture.set(value)
+        except InvalidApertureMove:
+            self.selected_aperture.set(None)  # type: ignore
 
-    async def _get_current_aperture_position(self) -> SingleAperturePosition:
+    async def get_current_aperture_position(self) -> ApertureValue:
         """
         Returns the current aperture position using readback values
         for SMALL, MEDIUM, LARGE. ROBOT_LOAD position defined when
         mini aperture y <= ROBOT_LOAD.location.aperture_y + tolerance.
         If no position is found then raises InvalidApertureMove.
         """
-        assert isinstance(self.aperture_positions, AperturePositions)
         current_ap_y = await self.aperture.y.user_readback.get_value(cached=False)
-        robot_load_ap_y = self.aperture_positions.ROBOT_LOAD.location.aperture_y
+        robot_load_ap_y = self._loaded_positions[ApertureValue.ROBOT_LOAD].aperture_y
         if await self.aperture.large.get_value(cached=False) == 1:
-            return self.aperture_positions.LARGE
+            return ApertureValue.LARGE
         elif await self.aperture.medium.get_value(cached=False) == 1:
-            return self.aperture_positions.MEDIUM
+            return ApertureValue.MEDIUM
         elif await self.aperture.small.get_value(cached=False) == 1:
-            return self.aperture_positions.SMALL
-        elif current_ap_y <= robot_load_ap_y + self.aperture_positions.tolerances.ap_y:
-            return self.aperture_positions.ROBOT_LOAD
+            return ApertureValue.SMALL
+        elif current_ap_y <= robot_load_ap_y + self._tolerances.aperture_y:
+            return ApertureValue.ROBOT_LOAD
 
         raise InvalidApertureMove("Current aperture/scatterguard state unrecognised")
 
     async def _safe_move_within_datacollection_range(
-        self, pos: ApertureFiveDimensionalLocation
+        self, position: AperturePosition, value: ApertureValue
     ):
         """
         Move the aperture and scatterguard combo safely to a new position.
         See https://github.com/DiamondLightSource/hyperion/wiki/Aperture-Scatterguard-Collisions
         for why this is required.
         """
-        assert self.aperture_positions is not None
-        # unpacking the position
-        aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = pos
+        assert self._loaded_positions is not None
 
         ap_z_in_position = await self.aperture.z.motor_done_move.get_value()
         if not ap_z_in_position:
@@ -271,17 +194,23 @@ class ApertureScatterguard(StandardReadable, Movable):
             )
 
         current_ap_z = await self.aperture.z.user_readback.get_value()
-        diff_on_z = abs(current_ap_z - aperture_z)
-        if diff_on_z > self.aperture_positions.tolerances.ap_z:
+        diff_on_z = abs(current_ap_z - position.aperture_z)
+        if diff_on_z > self._tolerances.aperture_z:
             raise InvalidApertureMove(
                 "ApertureScatterguard safe move is not yet defined for positions "
                 "outside of LARGE, MEDIUM, SMALL, ROBOT_LOAD. "
-                f"Current aperture z ({current_ap_z}), outside of tolerance ({self.aperture_positions.tolerances.ap_z}) from target ({aperture_z})."
+                f"Current aperture z ({current_ap_z}), outside of tolerance ({self._tolerances.aperture_z}) from target ({position.aperture_z})."
             )
 
         current_ap_y = await self.aperture.y.user_readback.get_value()
+        if position.radius is not None:
+            await self.radius.set(position.radius)
+
+        aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = (
+            position.values
+        )
 
-        if aperture_y > current_ap_y:
+        if position.aperture_y > current_ap_y:
             await asyncio.gather(
                 self.scatterguard.x.set(scatterguard_x),
                 self.scatterguard.y.set(scatterguard_y),
@@ -302,3 +231,4 @@ class ApertureScatterguard(StandardReadable, Movable):
             self.scatterguard.x.set(scatterguard_x),
             self.scatterguard.y.set(scatterguard_y),
         )
+        await self.selected_aperture.set(value)

dodal/devices/areadetector/adaravis.py

@@ -1,7 +1,7 @@
-from typing import Any, Mapping
+from collections.abc import Mapping
+from typing import Any
 
-from ophyd import Component as Cpt
-from ophyd import DetectorBase, EpicsSignal, Signal
+from ophyd import EpicsSignal, Signal
 from ophyd.areadetector.base import ADComponent as Cpt
 from ophyd.areadetector.detectors import DetectorBase
 
@@ -60,7 +60,7 @@ class AdAravisDetector(SingleTriggerV33, DetectorBase):
                 signal.put_complete = True
         self.cam.acquire.put_complete = True
 
-    def stage(self, *args, **kwargs):
+    def stage(self, *args, **kwargs) -> list[object]:
         # We have to manually set the acquire period bcause the EPICS driver
         # doesn't do it for us. If acquire time is a staged signal, we use the
         # stage value to calculate the acquire period, otherwise we perform
@@ -69,13 +69,15 @@ class AdAravisDetector(SingleTriggerV33, DetectorBase):
             acquire_time = self.stage_sigs[self.cam.acquire_time]
         else:
             acquire_time = self.cam.acquire_time.get()
-        self.stage_sigs[self.cam.acquire_period] = acquire_time + _ACQUIRE_BUFFER_PERIOD
+        self.stage_sigs[self.cam.acquire_period] = (
+            float(acquire_time) + _ACQUIRE_BUFFER_PERIOD
+        )
 
         # Ensure detector warmed up
         self._prime_hdf()
 
         # Now calling the super method should set the acquire period
-        super(AdAravisDetector, self).stage(*args, **kwargs)
+        return super().stage(*args, **kwargs)
 
     def _prime_hdf(self) -> None:
         """

dodal/devices/areadetector/adsim.py

@@ -1,4 +1,3 @@
-from ophyd import Component as Cpt
 from ophyd.areadetector.base import ADComponent as Cpt
 from ophyd.areadetector.detectors import DetectorBase
 
@@ -33,7 +32,7 @@ class AdSimDetector(SingleTriggerV33, DetectorBase):
             **self.stage_sigs,  # type: ignore
         }
 
-    def stage(self, *args, **kwargs):
+    def stage(self, *args, **kwargs) -> list[object]:
         # We have to manually set the acquire period bcause the EPICS driver
         # doesn't do it for us. If acquire time is a staged signal, we use the
         # stage value to calculate the acquire period, otherwise we perform
@@ -45,4 +44,4 @@ class AdSimDetector(SingleTriggerV33, DetectorBase):
         self.stage_sigs[self.cam.acquire_period] = acquire_time
 
         # Now calling the super method should set the acquire period
-        super(AdSimDetector, self).stage(*args, **kwargs)
+        return super().stage(*args, **kwargs)

dodal/devices/areadetector/adutils.py

@@ -1,7 +1,7 @@
 import time as ttime
 
 from ophyd import Component as Cpt
-from ophyd import EpicsSignal, EpicsSignalRO, Staged
+from ophyd import DetectorBase, Device, EpicsSignal, EpicsSignalRO, Staged
 from ophyd.areadetector import ADTriggerStatus, TriggerBase
 from ophyd.areadetector.cam import AreaDetectorCam
 from ophyd.areadetector.filestore_mixins import FileStoreHDF5, FileStoreIterativeWrite
@@ -14,6 +14,8 @@ class SingleTriggerV33(TriggerBase):
     def __init__(self, *args, image_name=None, **kwargs):
         super().__init__(*args, **kwargs)
         if image_name is None:
+            # Ensure that this mixin is part of valid device with name
+            assert isinstance(self, Device)
             image_name = "_".join([self.name, "image"])
         self._image_name = image_name
 
@@ -29,10 +31,12 @@ class SingleTriggerV33(TriggerBase):
 
         def _acq_done(*args, **kwargs):
             # TODO sort out if anything useful in here
-            self._status._finished()
+            self._status._finished()  # noqa: SLF001
 
         self._acquisition_signal.put(1, use_complete=True, callback=_acq_done)
-        self.dispatch(self._image_name, ttime.time())
+        # Ensure that this mixin is part of valid Detector with generate_datum
+        assert isinstance(self, DetectorBase)
+        self.generate_datum(self._image_name, ttime.time())
         return self._status
 
 
@@ -54,15 +58,18 @@ class SynchronisedAdDriverBase(AreaDetectorCam):
 
     def ensure_nonblocking(self):
         self.stage_sigs["wait_for_plugins"] = "Yes"
-        for c in self.parent.component_names:
-            cpt = getattr(self.parent, c)
-            if cpt is self:
-                continue
-            if hasattr(cpt, "ensure_nonblocking"):
-                cpt.ensure_nonblocking()
-
-
-class Hdf5Writer(HDF5Plugin, FileStoreHDF5, FileStoreIterativeWrite):
+        if self.parent is not None:
+            for c in self.parent.component_names:
+                cpt = getattr(self.parent, c)
+                if cpt is self:
+                    continue
+                if hasattr(cpt, "ensure_nonblocking"):
+                    cpt.ensure_nonblocking()
+
+
+# ophyd code to be removed, only used for adim
+# https://github.com/DiamondLightSource/dodal/issues/404
+class Hdf5Writer(HDF5Plugin, FileStoreHDF5, FileStoreIterativeWrite):  # type: ignore
     """ """
 
     pool_max_buffers = None
@@ -70,4 +77,5 @@ class Hdf5Writer(HDF5Plugin, FileStoreHDF5, FileStoreIterativeWrite):
     file_number_write = None
 
     def get_frames_per_point(self):
+        assert isinstance(self.parent, DetectorBase)
         return self.parent.cam.num_images.get()

dodal/devices/areadetector/plugins/MJPG.py

@@ -1,6 +1,7 @@
 import os
 import threading
 from abc import ABC, abstractmethod
+from io import BytesIO
 from pathlib import Path
 
 import requests
@@ -70,7 +71,7 @@ class MJPG(Device, ABC):
             try:
                 response = requests.get(url_str, stream=True)
                 response.raise_for_status()
-                with Image.open(response.raw) as image:
+                with Image.open(BytesIO(response.content)) as image:
                     self.post_processing(image)
                     st.set_finished()
             except requests.HTTPError as e:

dodal/devices/backlight.py

@@ -1,3 +1,4 @@
+from asyncio import sleep
 from enum import Enum
 
 from ophyd_async.core import AsyncStatus, StandardReadable
@@ -17,6 +18,8 @@ class BacklightPosition(str, Enum):
 class Backlight(StandardReadable):
     """Simple device to trigger the pneumatic in/out."""
 
+    TIME_TO_MOVE_S = 1  # Tested using a stopwatch on the beamline 09/2024
+
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
             self.power = epics_signal_rw(BacklightPower, prefix + "-EA-BLIT-01:TOGGLE")
@@ -28,9 +31,17 @@ class Backlight(StandardReadable):
     @AsyncStatus.wrap
     async def set(self, position: BacklightPosition):
         """This setter will turn the backlight on when we move it in to the beam and off
-        when we move it out."""
+        when we move it out.
+
+        Moving the backlight in/out is a pneumatic axis and we have no readback on its
+        position so it appears to us to instantly move. In fact it does take some time
+        to move completely in/out so we sleep here to simulate this.
+        """
+        old_position = await self.position.get_value()
         await self.position.set(position)
         if position == BacklightPosition.OUT:
             await self.power.set(BacklightPower.OFF)
         else:
             await self.power.set(BacklightPower.ON)
+        if old_position != position:
+            await sleep(self.TIME_TO_MOVE_S)

dodal/devices/cryostream.py

@@ -1,9 +1,21 @@
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsSignal, EpicsSignalRO
+from enum import Enum
 
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
-class Cryo(Device):
-    course = Cpt(EpicsSignal, "-EA-CJET-01:COARSE:CTRL")
-    fine = Cpt(EpicsSignal, "-EA-CJET-01:FINE:CTRL")
-    temp = Cpt(EpicsSignalRO, "-EA-CSTRM-01:TEMP")
-    backpress = Cpt(EpicsSignalRO, "-EA-CSTRM-01:BACKPRESS")
+
+class InOut(str, Enum):
+    IN = "In"
+    OUT = "Out"
+
+
+class CryoStream(StandardReadable):
+    def __init__(self, prefix: str, name: str = ""):
+        self.course = epics_signal_rw(InOut, f"{prefix}-EA-CJET-01:COARSE:CTRL")
+        self.fine = epics_signal_rw(InOut, f"{prefix}-EA-CJET-01:FINE:CTRL")
+        self.temperature_k = epics_signal_r(float, f"{prefix}-EA-CSTRM-01:TEMP")
+        self.back_pressure_bar = epics_signal_r(
+            float, f"{prefix}-EA-CSTRM-01:BACKPRESS"
+        )
+
+        super().__init__(name)

dodal/devices/dcm.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import StandardReadable
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.signal import epics_signal_r
 
 

dodal/devices/detector/__init__.py

@@ -1,2 +1,13 @@
-# export GDA detector names for convenience
-from dodal.devices.detector.detector import *  # noqa: F403
+from dodal.devices.detector.det_dim_constants import EIGER2_X_16M_SIZE
+from dodal.devices.detector.detector import (
+    DetectorDistanceToBeamXYConverter,
+    DetectorParams,
+    TriggerMode,
+)
+
+__all__ = [
+    "DetectorParams",
+    "EIGER2_X_16M_SIZE",
+    "TriggerMode",
+    "DetectorDistanceToBeamXYConverter",
+]

dodal/devices/detector/det_dim_constants.py

@@ -1,4 +1,4 @@
-from typing import Dict, Generic, TypeVar
+from typing import Generic, TypeVar
 
 from pydantic.dataclasses import dataclass
 
@@ -11,7 +11,7 @@ class DetectorSize(Generic[T]):
     height: T
 
 
-ALL_DETECTORS: Dict[str, "DetectorSizeConstants"] = {}
+ALL_DETECTORS: dict[str, "DetectorSizeConstants"] = {}
 
 
 @dataclass