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

dodal/devices/i22/dcm.py

@@ -1,32 +1,24 @@
 import time
-from collections.abc import Sequence
-from dataclasses import dataclass
-from typing import Literal
 
+import numpy as np
 from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
-from ophyd_async.core import ConfigSignal, StandardReadable, soft_signal_r_and_setter
+from ophyd_async.core import (
+    Array1D,
+    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
 
 # Conversion constant for energy and wavelength, taken from the X-Ray data booklet
 # Converts between energy in KeV and wavelength in angstrom
 _CONVERSION_CONSTANT = 12.3984
 
 
-@dataclass(frozen=True, unsafe_hash=True)
-class CrystalMetadata:
-    """
-    Metadata used in the NeXus format,
-    see https://manual.nexusformat.org/classes/base_classes/NXcrystal.html
-    """
-
-    usage: Literal["Bragg", "Laue"] | None = None
-    type: str | None = None
-    reflection: tuple[int, int, int] | None = None
-    d_spacing: tuple[float, str] | None = None
-
-
 class DoubleCrystalMonochromator(StandardReadable):
     """
     A double crystal monochromator (DCM), used to select the energy of the beam.
@@ -40,8 +32,8 @@ class DoubleCrystalMonochromator(StandardReadable):
     def __init__(
         self,
         temperature_prefix: str,
-        crystal_1_metadata: CrystalMetadata | None = None,
-        crystal_2_metadata: CrystalMetadata | None = None,
+        crystal_1_metadata: CrystalMetadata,
+        crystal_2_metadata: CrystalMetadata,
         prefix: str = "",
         name: str = "",
     ) -> None:
@@ -69,61 +61,37 @@ class DoubleCrystalMonochromator(StandardReadable):
 
         # Soft metadata
         # If supplied include crystal details in output of read_configuration
-        crystal_1_metadata = crystal_1_metadata or CrystalMetadata()
-        crystal_2_metadata = crystal_2_metadata or CrystalMetadata()
-        with self.add_children_as_readables(ConfigSignal):
-            if crystal_1_metadata.usage is not None:
-                self.crystal_1_usage, _ = soft_signal_r_and_setter(
-                    str, initial_value=crystal_1_metadata.usage
-                )
-            else:
-                self.crystal_1_usage = None
-            if crystal_1_metadata.type is not None:
-                self.crystal_1_type, _ = soft_signal_r_and_setter(
-                    str, initial_value=crystal_1_metadata.type
-                )
-            else:
-                self.crystal_1_type = None
-            if crystal_1_metadata.reflection is not None:
-                self.crystal_1_reflection, _ = soft_signal_r_and_setter(
-                    Sequence[int], initial_value=list(crystal_1_metadata.reflection)
-                )
-            else:
-                self.crystal_1_reflection = None
-            if crystal_1_metadata.d_spacing is not None:
-                self.crystal_1_d_spacing, _ = soft_signal_r_and_setter(
-                    float,
-                    initial_value=crystal_1_metadata.d_spacing[0],
-                    units=crystal_1_metadata.d_spacing[1],
-                )
-            else:
-                self.crystal_1_d_spacing = None
-            if crystal_2_metadata.usage is not None:
-                self.crystal_2_usage, _ = soft_signal_r_and_setter(
-                    str, initial_value=crystal_2_metadata.usage
-                )
-            else:
-                self.crystal_2_usage = None
-            if crystal_2_metadata.type is not None:
-                self.crystal_2_type, _ = soft_signal_r_and_setter(
-                    str, initial_value=crystal_2_metadata.type
-                )
-            else:
-                self.crystal_2_type = None
-            if crystal_2_metadata.reflection is not None:
-                self.crystal_2_reflection, _ = soft_signal_r_and_setter(
-                    Sequence[int], initial_value=list(crystal_2_metadata.reflection)
-                )
-            else:
-                self.crystal_2_reflection = None
-            if crystal_2_metadata.d_spacing is not None:
-                self.crystal_2_d_spacing, _ = soft_signal_r_and_setter(
-                    float,
-                    initial_value=crystal_2_metadata.d_spacing[0],
-                    units=crystal_2_metadata.d_spacing[1],
-                )
-            else:
-                self.crystal_2_d_spacing = None
+        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
+            )
+            self.crystal_1_type, _ = soft_signal_r_and_setter(
+                str, initial_value=crystal_1_metadata.type
+            )
+            self.crystal_1_reflection, _ = soft_signal_r_and_setter(
+                Array1D[np.int32],
+                initial_value=np.array(crystal_1_metadata.reflection),
+            )
+            self.crystal_1_d_spacing, _ = soft_signal_r_and_setter(
+                float,
+                initial_value=crystal_1_metadata.d_spacing[0],
+                units=crystal_1_metadata.d_spacing[1],
+            )
+            self.crystal_2_usage, _ = soft_signal_r_and_setter(
+                str, initial_value=crystal_2_metadata.usage
+            )
+            self.crystal_2_type, _ = soft_signal_r_and_setter(
+                str, initial_value=crystal_2_metadata.type
+            )
+            self.crystal_2_reflection, _ = soft_signal_r_and_setter(
+                Array1D[np.int32],
+                initial_value=np.array(crystal_2_metadata.reflection),
+            )
+            self.crystal_2_d_spacing, _ = soft_signal_r_and_setter(
+                float,
+                initial_value=crystal_2_metadata.d_spacing[0],
+                units=crystal_2_metadata.d_spacing[1],
+            )
 
         super().__init__(name)
 

dodal/devices/i22/fswitch.py

@@ -1,19 +1,19 @@
 import asyncio
 import time
-from enum import Enum
 
 from bluesky.protocols import Reading
 from event_model import DataKey
 from ophyd_async.core import (
-    ConfigSignal,
     DeviceVector,
     StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
     soft_signal_r_and_setter,
 )
-from ophyd_async.epics.signal import epics_signal_r
+from ophyd_async.epics.core import epics_signal_r
 
 
-class FilterState(str, Enum):
+class FilterState(StrictEnum):
     """
     Note that the in/out here refers to the internal rocker
     position so a PV value of IN implies a filter OUT of beam
@@ -54,7 +54,7 @@ class FSwitch(StandardReadable):
                 for i in range(FSwitch.NUM_FILTERS)
             }
         )
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             if lens_geometry is not None:
                 self.lens_geometry, _ = soft_signal_r_and_setter(
                     str, initial_value=lens_geometry

dodal/devices/i24/aperture.py

@@ -1,11 +1,9 @@
-from enum import Enum
-
-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 AperturePositions(str, Enum):
+class AperturePositions(StrictEnum):
     IN = "In"
     OUT = "Out"
     ROBOT = "Robot"

dodal/devices/i24/beamstop.py

@@ -1,11 +1,9 @@
-from enum import Enum
-
-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 BeamstopPositions(str, Enum):
+class BeamstopPositions(StrictEnum):
     CHECK_BEAM = "CheckBeam"
     DATA_COLLECTION = "Data Collection"
     DATA_COLLECTION_FAR = "Data Collection Far"

dodal/devices/i24/dcm.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 DCM(StandardReadable):

dodal/devices/i24/dual_backlight.py

@@ -1,10 +1,8 @@
-from enum import Enum
+from ophyd_async.core import AsyncStatus, StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw
 
-from ophyd_async.core import AsyncStatus, StandardReadable
-from ophyd_async.epics.signal import epics_signal_rw
 
-
-class BacklightPositions(str, Enum):
+class BacklightPositions(StrictEnum):
     OUT = "Out"
     IN = "In"
     LOAD_CHECK = "LoadCheck"
@@ -12,7 +10,7 @@ class BacklightPositions(str, Enum):
     DIODE = "Diode"
 
 
-class LEDStatus(str, Enum):
+class LEDStatus(StrictEnum):
     OFF = "OFF"
     ON = "ON"
 

dodal/devices/i24/pmac.py

@@ -1,21 +1,20 @@
 from asyncio import sleep
 from enum import Enum, IntEnum
 
-from bluesky.protocols import Flyable, Triggerable
+from bluesky.protocols import Flyable, Movable, Triggerable
 from ophyd_async.core import (
-    CALCULATE_TIMEOUT,
     DEFAULT_TIMEOUT,
     AsyncStatus,
-    SignalBackend,
+    Device,
+    Reference,
     SignalR,
     SignalRW,
-    SoftSignalBackend,
     StandardReadable,
     soft_signal_rw,
     wait_for_value,
 )
+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
 
 HOME_STR = r"\#1hmz\#2hmz\#3hmz"  # Command to home the PMAC motors
 ZERO_STR = "!x0y0z0"  # Command to blend any ongoing move into new position
@@ -64,61 +63,53 @@ class PMACStringMove(Triggerable):
         pmac_str_sig: SignalRW,
         string_to_send: str,
     ) -> None:
-        self.signal = pmac_str_sig
+        self.signal_ref = Reference(pmac_str_sig)
         self.cmd_string = string_to_send
 
     @AsyncStatus.wrap
     async def trigger(self):
-        await self.signal.set(self.cmd_string, wait=True)
+        await self.signal_ref().set(self.cmd_string, wait=True)
 
 
-class PMACStringLaser(SignalRW):
+class PMACStringLaser(Device, Movable):
     """Set the pmac_string to control the laser."""
 
     def __init__(
         self,
         pmac_str_sig: SignalRW,
-        backend: SignalBackend,
-        timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
-        self.signal = pmac_str_sig
-        super().__init__(backend, timeout, name)
+        self._signal_ref = Reference(pmac_str_sig)
+        super().__init__(name)
 
     @AsyncStatus.wrap
     async def set(
         self,
         value: LaserSettings,
-        wait=True,
-        timeout=CALCULATE_TIMEOUT,
     ):
-        await self.signal.set(value.value, wait, timeout)
+        await self._signal_ref().set(value.value)
 
 
-class PMACStringEncReset(SignalRW):
+class PMACStringEncReset(Device, Movable):
     """Set a pmac_string to control the encoder channels in the controller."""
 
     def __init__(
         self,
         pmac_str_sig: SignalRW,
-        backend: SignalBackend,
-        timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
-        self.signal = pmac_str_sig
-        super().__init__(backend, timeout, name)
+        self._signal_ref = Reference(pmac_str_sig)
+        super().__init__(name)
 
     @AsyncStatus.wrap
     async def set(
         self,
         value: EncReset,
-        wait=True,
-        timeout=CALCULATE_TIMEOUT,
     ):
-        await self.signal.set(value.value, wait, timeout)
+        await self._signal_ref().set(value.value)
 
 
-class ProgramRunner(SignalRW, Flyable):
+class ProgramRunner(Device, Flyable):
     """Run the collection by setting the program number on the PMAC string.
 
     Once the program number has been set, wait for the collection to be complete.
@@ -131,21 +122,18 @@ class ProgramRunner(SignalRW, Flyable):
         status_sig: SignalR,
         prog_num_sig: SignalRW,
         collection_time_sig: SignalRW,
-        backend: SignalBackend,
-        timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
-        self.signal = pmac_str_sig
-        self.status = status_sig
-        self.prog_num = prog_num_sig
+        self._signal_ref = Reference(pmac_str_sig)
+        self._status_ref = Reference(status_sig)
+        self._prog_num_ref = Reference(prog_num_sig)
 
-        self.collection_time = collection_time_sig
-        self.KICKOFF_TIMEOUT = timeout
+        self._collection_time_ref = Reference(collection_time_sig)
 
-        super().__init__(backend, timeout, name)
+        super().__init__(name)
 
     async def _get_prog_number_string(self) -> str:
-        prog_num = await self.prog_num.get_value()
+        prog_num = await self._prog_num_ref().get_value()
         return f"&2b{prog_num}r"
 
     @AsyncStatus.wrap
@@ -154,11 +142,11 @@ class ProgramRunner(SignalRW, Flyable):
             wait for the scan status PV to go to 1.
         """
         prog_num_str = await self._get_prog_number_string()
-        await self.signal.set(prog_num_str, wait=True)
+        await self._signal_ref().set(prog_num_str, wait=True)
         await wait_for_value(
-            self.status,
+            self._status_ref(),
             ScanState.RUNNING,
-            timeout=self.KICKOFF_TIMEOUT,
+            timeout=DEFAULT_TIMEOUT,
         )
 
     @AsyncStatus.wrap
@@ -169,8 +157,10 @@ class ProgramRunner(SignalRW, Flyable):
             complete_time (float): total time required by the collection to \
             finish correctly.
         """
-        scan_complete_time = await self.collection_time.get_value()
-        await wait_for_value(self.status, ScanState.DONE, timeout=scan_complete_time)
+        scan_complete_time = await self._collection_time_ref().get_value()
+        await wait_for_value(
+            self._status_ref(), ScanState.DONE, timeout=scan_complete_time
+        )
 
 
 class ProgramAbort(Triggerable):
@@ -183,16 +173,16 @@ class ProgramAbort(Triggerable):
         pmac_str_sig: SignalRW,
         status_sig: SignalR,
     ) -> None:
-        self.signal = pmac_str_sig
-        self.status = status_sig
+        self._signal_ref = Reference(pmac_str_sig)
+        self._status_ref = Reference(status_sig)
 
     @AsyncStatus.wrap
     async def trigger(self):
-        await self.signal.set("A", wait=True)
+        await self._signal_ref().set("A", wait=True)
         await sleep(1.0)  # TODO Check with scientist what this sleep is really for.
-        await self.signal.set("P2401=0", wait=True)
+        await self._signal_ref().set("P2401=0", wait=True)
         await wait_for_value(
-            self.status,
+            self._status_ref(),
             ScanState.DONE,
             timeout=DEFAULT_TIMEOUT,
         )
@@ -209,10 +199,10 @@ class PMAC(StandardReadable):
         )
         self.to_xyz_zero = PMACStringMove(self.pmac_string, ZERO_STR)
 
-        self.laser = PMACStringLaser(self.pmac_string, backend=SoftSignalBackend(str))
+        self.laser = PMACStringLaser(self.pmac_string)
 
         self.enc_reset = PMACStringEncReset(
-            self.pmac_string, backend=SoftSignalBackend(str)
+            self.pmac_string,
         )
 
         self.x = Motor(prefix + "X")
@@ -234,7 +224,6 @@ class PMAC(StandardReadable):
             self.scanstatus,
             self.program_number,
             self.collection_time,
-            backend=SoftSignalBackend(str),
         )
         self.abort_program = ProgramAbort(self.pmac_string, self.scanstatus)
 

dodal/devices/i24/vgonio.py

@@ -0,0 +1,16 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class VerticalGoniometer(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.x = Motor(prefix + "PINX")
+        self.z = Motor(prefix + "PINZ")
+        self.yh = Motor(prefix + "PINYH")
+        self.omega = Motor(prefix + "OMEGA")
+
+        self.real_x = Motor(prefix + "PINXS")
+        self.real_z = Motor(prefix + "PINZS")
+        self.fast_y = Motor(prefix + "PINYS")
+
+        super().__init__(name)

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)