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

dodal/devices/apple2_undulator.py

@@ -1,26 +1,26 @@
 import abc
 import asyncio
 from dataclasses import dataclass
-from enum import Enum
 from typing import Any
 
 import numpy as np
 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
 
 
-class UndulatorGateStatus(str, Enum):
+class UndulatorGateStatus(StrictEnum):
     open = "Open"
     close = "Closed"
 
@@ -128,12 +128,12 @@ class UndulatorGap(StandardReadable, Movable):
         )
         # 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 @@ class UndulatorPhaseMotor(StandardReadable):
         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,10 @@ class Apple2(StandardReadable, Movable):
 
         # 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,16 +437,16 @@ class Apple2(StandardReadable, Movable):
         """
 
         # 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}"
@@ -454,10 +454,12 @@ class Apple2(StandardReadable, Movable):
         )
 
         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 +524,11 @@ class Apple2(StandardReadable, Movable):
         (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"

dodal/devices/areadetector/plugins/CAM.py

@@ -1,10 +1,8 @@
-from enum import Enum
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from ophyd_async.core import StandardReadable
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
-
-class ColorMode(str, Enum):
+class ColorMode(StrictEnum):
     """
     Enum to store the various color modes of the camera. We use RGB1.
     """

dodal/devices/areadetector/plugins/MJPG.py

@@ -6,7 +6,7 @@ import aiofiles
 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

dodal/devices/attenuator.py

@@ -9,7 +9,7 @@ from ophyd_async.core import (
     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
 

dodal/devices/backlight.py

@@ -1,17 +1,16 @@
 from asyncio import sleep
-from enum import Enum
 
 from bluesky.protocols import Movable
-from ophyd_async.core import AsyncStatus, StandardReadable
-from ophyd_async.epics.signal import epics_signal_rw
+from ophyd_async.core import AsyncStatus, StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw
 
 
-class BacklightPower(str, Enum):
+class BacklightPower(StrictEnum):
     ON = "On"
     OFF = "Off"
 
 
-class BacklightPosition(str, Enum):
+class BacklightPosition(StrictEnum):
     IN = "In"
     OUT = "Out"
 

dodal/devices/cryostream.py

@@ -1,10 +1,8 @@
-from enum import Enum
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from ophyd_async.core import StandardReadable
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
-
-class InOut(str, Enum):
+class InOut(StrictEnum):
     IN = "In"
     OUT = "Out"
 

dodal/devices/dcm.py

@@ -1,6 +1,14 @@
-from ophyd_async.core import StandardReadable
+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,
+    MaterialsEnum,
+    make_crystal_metadata_from_material,
+)
 
 
 class DCM(StandardReadable):
@@ -17,7 +25,11 @@ class DCM(StandardReadable):
         self,
         prefix: str,
         name: str = "",
+        crystal_metadata: CrystalMetadata | None = None,
     ) -> None:
+        cm = crystal_metadata or make_crystal_metadata_from_material(
+            MaterialsEnum.Si, (1, 1, 1)
+        )
         with self.add_children_as_readables():
             self.bragg_in_degrees = Motor(prefix + "BRAGG")
             self.roll_in_mrad = Motor(prefix + "ROLL")
@@ -36,4 +48,16 @@ class DCM(StandardReadable):
             self.perp_temp = epics_signal_r(float, prefix + "TEMP6")
             self.perp_sub_assembly_temp = epics_signal_r(float, prefix + "TEMP7")
 
+            self.crystal_metadata_usage, _ = soft_signal_r_and_setter(
+                str, initial_value=cm.usage
+            )
+            self.crystal_metadata_type, _ = soft_signal_r_and_setter(
+                str, initial_value=cm.type
+            )
+            reflection_array = np.array(cm.reflection)
+            self.crystal_metadata_reflection, _ = soft_signal_r_and_setter(
+                NDArray[np.uint64],
+                initial_value=reflection_array,
+            )
+            self.crystal_metadata_d_spacing = epics_signal_r(float, "DSPACING:RBV")
         super().__init__(name)

dodal/devices/detector/detector_motion.py

@@ -1,11 +1,9 @@
-from enum import Enum
-
-from ophyd_async.core import Device
+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(str, Enum):
+class ShutterState(StrictEnum):
     CLOSED = "Closed"
     OPEN = "Open"
 

dodal/devices/diamond_filter.py

@@ -1,12 +1,11 @@
-from enum import Enum
 from typing import Generic, TypeVar
 
-from ophyd_async.core import StandardReadable
+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(str, Enum):
+class _Filters(StrictEnum):
     pass
 
 

dodal/devices/fast_grid_scan.py

@@ -15,7 +15,7 @@ from ophyd_async.core import (
     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,

dodal/devices/fluorescence_detector_motion.py

@@ -1,12 +1,10 @@
-from enum import Enum
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_r
 
-from ophyd_async.core import StandardReadable
-from ophyd_async.epics.signal import epics_signal_r
 
-
-class FluorescenceDetectorControlState(Enum):
-    OUT = 0
-    IN = 1
+class FluorescenceDetectorControlState(StrictEnum):
+    OUT = "Out"
+    IN = "In"
 
 
 class FluorescenceDetector(StandardReadable):

dodal/devices/focusing_mirror.py

@@ -1,21 +1,19 @@
-from enum import Enum
-
 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
 
@@ -25,20 +23,20 @@ VOLTAGE_POLLING_DELAY_S = 0.5
 DEFAULT_SETTLE_TIME_S = 60
 
 
-class MirrorType(str, Enum):
+class MirrorType(StrictEnum):
     """See https://manual.nexusformat.org/classes/base_classes/NXmirror.html"""
 
     SINGLE = "single"
     MULTI = "multi"
 
 
-class MirrorStripe(str, Enum):
+class MirrorStripe(StrictEnum):
     RHODIUM = "Rhodium"
     BARE = "Bare"
     PLATINUM = "Platinum"
 
 
-class MirrorVoltageDemand(str, Enum):
+class MirrorVoltageDemand(StrictEnum):
     N_A = "N/A"
     OK = "OK"
     FAIL = "FAIL"
@@ -151,8 +149,11 @@ class FocusingMirror(StandardReadable):
         # 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)
 
 

dodal/devices/hutch_shutter.py

@@ -1,13 +1,12 @@
-from enum import Enum
-
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     StandardReadable,
+    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
 
@@ -16,13 +15,13 @@ class ShutterNotSafeToOperateError(Exception):
     pass
 
 
-class ShutterDemand(str, Enum):
+class ShutterDemand(StrictEnum):
     OPEN = "Open"
     CLOSE = "Close"
     RESET = "Reset"
 
 
-class ShutterState(str, Enum):
+class ShutterState(StrictEnum):
     FAULT = "Fault"
     OPEN = "Open"
     OPENING = "Opening"

dodal/devices/i10/i10_apple2.py

@@ -2,14 +2,15 @@ import asyncio
 import csv
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
+from typing import Any, SupportsFloat
 
 import numpy as np
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
-    HintedSignal,
+    Reference,
     StandardReadable,
+    StandardReadableFormat,
     soft_signal_r_and_setter,
     soft_signal_rw,
 )
@@ -118,14 +119,15 @@ class I10Apple2(Apple2):
             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: float) -> None:
+    async def set(self, value: SupportsFloat) -> None:
         """
         Check polarisation state and use it together with the energy(value)
         to calculate the required gap and phases before setting it.
         """
+        value = float(value)
         if self.pol is None:
             LOGGER.warning("Polarisation not set attempting to read from hardware")
             pol, phase = await self.determinePhaseFromHardware()
@@ -146,8 +148,8 @@ class I10Apple2(Apple2):
         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):
         """
@@ -195,18 +197,17 @@ class I10Apple2PGM(StandardReadable, Movable):
             New device name.
         """
         super().__init__(name=name)
-        with self.add_children_as_readables():
-            self.id = id
-            self.pgm = pgm
-        with self.add_children_as_readables(HintedSignal):
+        self.id_ref = Reference(id)
+        self.pgm_ref = Reference(pgm)
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.energy_offset = soft_signal_rw(float, initial_value=0)
 
     @AsyncStatus.wrap
     async def set(self, value: float) -> None:
         LOGGER.info(f"Moving f{self.name} energy to {value}.")
         await asyncio.gather(
-            self.id.set(value=value + await self.energy_offset.get_value()),
-            self.pgm.energy.set(value),
+            self.id_ref().set(value=value + await self.energy_offset.get_value()),
+            self.pgm_ref().energy.set(value),
         )
 
 
@@ -273,22 +274,22 @@ class LinearArbitraryAngle(StandardReadable, Movable):
             polynomial parameters highest power first.
         """
         super().__init__(name=name)
-        with self.add_children_as_readables():
-            self.id = id
+        self.id_ref = Reference(id)
         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
             )
 
     @AsyncStatus.wrap
-    async def set(self, value: float) -> None:
-        pol = self.id.pol
+    async def set(self, value: SupportsFloat) -> None:
+        value = float(value)
+        pol = self.id_ref().pol
         if pol != "la":
             raise RuntimeError(
-                f"Angle control is not available in polarisation {pol} with {self.id.name}"
+                f"Angle control is not available in polarisation {pol} with {self.id_ref().name}"
             )
         # Moving to real angle which is 210 to 30.
         alpha_real = value if value > self.angle_threshold_deg else value + ALPHA_OFFSET
@@ -298,7 +299,7 @@ class LinearArbitraryAngle(StandardReadable, Movable):
                 f"jaw_phase position for angle ({value}) is outside permitted range"
                 f" [-{self.jaw_phase_limit}, {self.jaw_phase_limit}]"
             )
-        await self.id.id_jaw_phase.set(jaw_phase)
+        await self.id_ref().id_jaw_phase().set(jaw_phase)
         self._angle_set(value)
 
 

dodal/devices/i10/i10_setting_data.py

@@ -1,7 +1,7 @@
-from enum import Enum
+from ophyd_async.core import StrictEnum
 
 
-class I10Grating(str, Enum):
+class I10Grating(StrictEnum):
     Au400 = "400 line/mm Au"
     Si400 = "400 line/mm Si"
     Au1200 = "1200 line/mm Au"