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

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -5,6 +5,7 @@ import numpy as np
 from numpy.typing import NDArray
 from ophyd_async.core import (
     AsyncStatus,
+    HintedSignal,
     StandardReadable,
     observe_value,
     soft_signal_r_and_setter,
@@ -77,12 +78,13 @@ class PinTipDetection(StandardReadable):
         self.min_tip_height = soft_signal_rw(int, 5, name="min_tip_height")
         self.validity_timeout = soft_signal_rw(float, 5.0, name="validity_timeout")
 
-        self.set_readable_signals(
-            read=[
+        self.add_readables(
+            [
                 self.triggered_tip,
                 self.triggered_top_edge,
                 self.triggered_bottom_edge,
             ],
+            wrapper=HintedSignal,
         )
 
         super().__init__(name=name)
@@ -134,9 +136,7 @@ class PinTipDetection(StandardReadable):
         location = sample_detection.processArray(array_data)
         end_time = time.time()
         LOGGER.debug(
-            "Sample location detection took {}ms".format(
-                (end_time - start_time) * 1000.0
-            )
+            f"Sample location detection took {(end_time - start_time) * 1000.0}ms"
         )
         return location
 
@@ -154,7 +154,7 @@ class PinTipDetection(StandardReadable):
                     location = await self._get_tip_and_edge_data(value)
                     self._set_triggered_values(location)
                 except Exception as e:
-                    LOGGER.warn(
+                    LOGGER.warning(
                         f"Failed to detect pin-tip location, will retry with next image: {e}"
                     )
                 else:

dodal/devices/oav/pin_image_recognition/utils.py

@@ -1,6 +1,7 @@
+from collections.abc import Callable
 from dataclasses import dataclass
 from enum import Enum
-from typing import Callable, Final, Tuple
+from typing import Final
 
 import cv2
 import numpy as np
@@ -103,7 +104,7 @@ class SampleLocation:
     edge_bottom: np.ndarray
 
 
-class MxSampleDetect(object):
+class MxSampleDetect:
     def __init__(
         self,
         *,
@@ -161,7 +162,7 @@ class MxSampleDetect(object):
     @staticmethod
     def _first_and_last_nonzero_by_columns(
         arr: np.ndarray,
-    ) -> Tuple[np.ndarray, np.ndarray]:
+    ) -> tuple[np.ndarray, np.ndarray]:
         """
         Finds the indexes of the first & last non-zero values by column in a 2d array.
 
@@ -243,9 +244,7 @@ class MxSampleDetect(object):
             bottom[x + 1 :] = NONE_VALUE
 
         LOGGER.info(
-            "pin-tip detection: Successfully located pin tip at (x={}, y={})".format(
-                tip_x, tip_y
-            )
+            f"pin-tip detection: Successfully located pin tip at (x={tip_x}, y={tip_y})"
         )
         return SampleLocation(
             tip_x=tip_x, tip_y=tip_y, edge_bottom=bottom, edge_top=top

dodal/devices/oav/utils.py

@@ -1,5 +1,5 @@
+from collections.abc import Generator
 from enum import IntEnum
-from typing import Generator, Tuple
 
 import bluesky.plan_stubs as bps
 import numpy as np
@@ -10,7 +10,7 @@ from dodal.devices.oav.oav_detector import OAVConfigParams
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
 from dodal.devices.smargon import Smargon
 
-Pixel = Tuple[int, int]
+Pixel = tuple[int, int]
 
 
 class PinNotFoundException(Exception):

dodal/devices/p99/sample_stage.py

@@ -0,0 +1,43 @@
+from enum import Enum
+
+from ophyd_async.core import Device
+from ophyd_async.epics.signal import epics_signal_rw
+
+
+class SampleAngleStage(Device):
+    def __init__(self, prefix: str, name: str):
+        self.theta = epics_signal_rw(
+            float, prefix + "WRITETHETA:RBV", prefix + "WRITETHETA"
+        )
+        self.roll = epics_signal_rw(
+            float, prefix + "WRITEROLL:RBV", prefix + "WRITEROLL"
+        )
+        self.pitch = epics_signal_rw(
+            float, prefix + "WRITEPITCH:RBV", prefix + "WRITEPITCH"
+        )
+        super().__init__(name=name)
+
+
+class p99StageSelections(str, Enum):
+    Empty = "Empty"
+    Mn5um = "Mn 5um"
+    Fe = "Fe (empty)"
+    Co5um = "Co 5um"
+    Ni5um = "Ni 5um"
+    Cu5um = "Cu 5um"
+    Zn5um = "Zn 5um"
+    Zr = "Zr (empty)"
+    Mo = "Mo (empty)"
+    Rh = "Rh (empty)"
+    Pd = "Pd (empty)"
+    Ag = "Ag (empty)"
+    Cd25um = "Cd 25um"
+    W = "W (empty)"
+    Pt = "Pt (empty)"
+    User = "User"
+
+
+class FilterMotor(Device):
+    def __init__(self, prefix: str, name: str):
+        self.user_setpoint = epics_signal_rw(p99StageSelections, prefix)
+        super().__init__(name=name)

dodal/devices/robot.py

@@ -1,5 +1,5 @@
 import asyncio
-from asyncio import FIRST_COMPLETED, Task
+from asyncio import FIRST_COMPLETED, CancelledError, Task
 from dataclasses import dataclass
 from enum import Enum
 
@@ -10,8 +10,7 @@ from ophyd_async.core import (
     set_and_wait_for_value,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_x
-from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw_rbv, epics_signal_x
 
 from dodal.log import LOGGER
 
@@ -45,6 +44,9 @@ class BartRobot(StandardReadable, Movable):
     LOAD_TIMEOUT = 60
     NO_PIN_ERROR_CODE = 25
 
+    # How far the gonio position can be out before loading will fail
+    LOAD_TOLERANCE_MM = 0.02
+
     def __init__(
         self,
         name: str,
@@ -74,19 +76,28 @@ class BartRobot(StandardReadable, Movable):
             await wait_for_value(self.error_code, self.NO_PIN_ERROR_CODE, None)
             raise RobotLoadFailed(self.NO_PIN_ERROR_CODE, "Pin was not detected")
 
-        finished, unfinished = await asyncio.wait(
-            [
-                Task(raise_if_no_pin()),
-                Task(
-                    wait_for_value(self.gonio_pin_sensor, PinMounted.PIN_MOUNTED, None)
-                ),
-            ],
-            return_when=FIRST_COMPLETED,
-        )
-        for task in unfinished:
-            task.cancel()
-        for task in finished:
-            await task
+        async def wfv():
+            await wait_for_value(self.gonio_pin_sensor, PinMounted.PIN_MOUNTED, None)
+
+        tasks = [
+            (Task(raise_if_no_pin())),
+            (Task(wfv())),
+        ]
+        try:
+            finished, unfinished = await asyncio.wait(
+                tasks,
+                return_when=FIRST_COMPLETED,
+            )
+            for task in unfinished:
+                task.cancel()
+            for task in finished:
+                await task
+        except CancelledError:
+            # If the outer enclosing task cancels after LOAD_TIMEOUT, this causes CancelledError to be raised
+            # in the current task, when it propagates to here we should cancel all pending tasks before bubbling up
+            for task in tasks:
+                task.cancel()
+            raise
 
     async def _load_pin_and_puck(self, sample_location: SampleLocation):
         LOGGER.info(f"Loading pin {sample_location}")
@@ -108,12 +119,12 @@ class BartRobot(StandardReadable, Movable):
         await self.pin_mounted_or_no_pin_found()
 
     @AsyncStatus.wrap
-    async def set(self, sample_location: SampleLocation):
+    async def set(self, value: SampleLocation):
         try:
             await asyncio.wait_for(
-                self._load_pin_and_puck(sample_location), timeout=self.LOAD_TIMEOUT
+                self._load_pin_and_puck(value), timeout=self.LOAD_TIMEOUT
             )
-        except asyncio.TimeoutError:
+        except asyncio.TimeoutError as e:
             error_code = await self.error_code.get_value()
             error_string = await self.error_str.get_value()
-            raise RobotLoadFailed(error_code, error_string)
+            raise RobotLoadFailed(int(error_code), error_string) from e

dodal/devices/scatterguard.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
 
 
 class Scatterguard(StandardReadable):

dodal/devices/scintillator.py

@@ -1,7 +1,10 @@
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsMotor
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
 
 
-class Scintillator(Device):
-    y = Cpt(EpicsMotor, "-MO-SCIN-01:Y")
-    z = Cpt(EpicsMotor, "-MO-SCIN-01:Z")
+class Scintillator(StandardReadable):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.y = Motor(prefix + "-MO-SCIN-01:Y")
+            self.z = Motor(prefix + "-MO-SCIN-01:Z")
+        super().__init__(name)

dodal/devices/slits.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
 
 
 class Slits(StandardReadable):

dodal/devices/smargon.py

@@ -1,13 +1,13 @@
-from collections.abc import Generator
+from collections.abc import Collection, Generator
 from dataclasses import dataclass
 from enum import Enum
 from math import isclose
-from typing import Collection, cast
+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.motion import Motor
+from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.signal import epics_signal_r
 
 from dodal.devices.util.epics_util import SetWhenEnabled
@@ -87,7 +87,7 @@ class XYZLimits:
     def position_valid(self, pos: Collection[float]) -> bool:
         return all(
             axis_limits.contains(value)
-            for axis_limits, value in zip([self.x, self.y, self.z], pos)
+            for axis_limits, value in zip([self.x, self.y, self.z], pos, strict=False)
         )
 
 

dodal/devices/status.py

@@ -1,41 +1,12 @@
-from typing import Any, TypeVar
+from typing import Any
 
 from ophyd.status import SubscriptionStatus
 
-T = TypeVar("T")
-
 
 def await_value(
-    subscribable: Any, expected_value: T, timeout: None | int = None
+    subscribable: Any, expected_value: object, timeout: None | int = None
 ) -> SubscriptionStatus:
     def value_is(value, **_):
         return value == expected_value
 
     return SubscriptionStatus(subscribable, value_is, timeout=timeout)
-
-
-def await_value_in_list(
-    subscribable: Any, expected_value: list, timeout: None | int = None
-) -> SubscriptionStatus:
-    """Returns a status which is completed when the subscriptable contains a value
-    within the expected_value list"""
-
-    def value_is(value, **_):
-        return value in expected_value
-
-    if not isinstance(expected_value, list):
-        raise TypeError(f"expected value {expected_value} is not a list")
-    else:
-        return SubscriptionStatus(subscribable, value_is, timeout=timeout)
-
-
-def await_approx_value(
-    subscribable: Any,
-    expected_value: T,
-    deadband: float = 1e-09,
-    timeout: None | int = None,
-) -> SubscriptionStatus:
-    def value_is_approx(value, **_):
-        return abs(value - expected_value) <= deadband
-
-    return SubscriptionStatus(subscribable, value_is_approx, timeout=timeout)

dodal/devices/tetramm.py

@@ -1,23 +1,24 @@
 import asyncio
 from enum import Enum
-from typing import Sequence
 
 from bluesky.protocols import Hints
 from ophyd_async.core import (
     AsyncStatus,
+    DatasetDescriber,
     DetectorControl,
     DetectorTrigger,
     Device,
-    DirectoryProvider,
-    ShapeProvider,
+    PathProvider,
     StandardDetector,
     set_and_wait_for_value,
     soft_signal_r_and_setter,
 )
-from ophyd_async.epics.areadetector.utils import stop_busy_record
-from ophyd_async.epics.areadetector.writers import HDFWriter, NDFileHDF
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
-from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
+from ophyd_async.epics.adcore import ADHDFWriter, NDFileHDFIO, stop_busy_record
+from ophyd_async.epics.signal import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_rw_rbv,
+)
 
 
 class TetrammRange(str, Enum):
@@ -108,14 +109,14 @@ class TetrammController(DetectorControl):
         self.minimum_values_per_reading = minimum_values_per_reading
         self.readings_per_frame = readings_per_frame
 
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         # 2 internal clock cycles. Best effort approximation
         return 2 / self.base_sample_rate
 
     async def arm(
         self,
         num: int,
-        trigger: DetectorTrigger,
+        trigger: DetectorTrigger = DetectorTrigger.edge_trigger,
         exposure: float | None = None,
     ) -> AsyncStatus:
         if exposure is None:
@@ -132,7 +133,7 @@ class TetrammController(DetectorControl):
             self._drv.averaging_time.set(exposure), self.set_exposure(exposure)
         )
 
-        status = await set_and_wait_for_value(self._drv.acquire, 1)
+        status = await set_and_wait_for_value(self._drv.acquire, True)
 
         return status
 
@@ -150,7 +151,7 @@ class TetrammController(DetectorControl):
             )
 
     async def disarm(self):
-        await stop_busy_record(self._drv.acquire, 0, timeout=1)
+        await stop_busy_record(self._drv.acquire, False, timeout=1)
 
     async def set_exposure(self, exposure: float):
         """Tries to set the exposure time of a single frame.
@@ -204,14 +205,17 @@ class TetrammController(DetectorControl):
         )
 
 
-class TetrammShapeProvider(ShapeProvider):
+class TetrammDatasetDescriber(DatasetDescriber):
     max_channels = 11
 
     def __init__(self, controller: TetrammController) -> None:
         self.controller = controller
 
-    async def __call__(self) -> Sequence[int]:
-        return [self.max_channels, self.controller.readings_per_frame]
+    async def np_datatype(self) -> str:
+        return "<f8"  # IEEE 754 double precision floating point
+
+    async def shape(self) -> tuple[int, int]:
+        return (self.max_channels, self.controller.readings_per_frame)
 
 
 # TODO: Support MeanValue signals https://github.com/DiamondLightSource/dodal/issues/337
@@ -219,13 +223,13 @@ class TetrammDetector(StandardDetector):
     def __init__(
         self,
         prefix: str,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         name: str,
         type: str | None = None,
         **scalar_sigs: str,
     ) -> None:
         self.drv = TetrammDriver(prefix + "DRV:")
-        self.hdf = NDFileHDF(prefix + "HDF5:")
+        self.hdf = NDFileHDFIO(prefix + "HDF5:")
         controller = TetrammController(self.drv)
         config_signals = [
             self.drv.values_per_reading,
@@ -239,11 +243,11 @@ class TetrammDetector(StandardDetector):
             self.type = None
         super().__init__(
             controller,
-            HDFWriter(
+            ADHDFWriter(
                 self.hdf,
-                directory_provider,
+                path_provider,
                 lambda: self.name,
-                TetrammShapeProvider(controller),
+                TetrammDatasetDescriber(controller),
                 **scalar_sigs,
             ),
             config_signals,

dodal/devices/thawer.py

@@ -15,7 +15,7 @@ class ThawerStates(str, Enum):
     ON = "On"
 
 
-class ThawingTimer(Device):
+class ThawingTimer(Device, Stoppable):
     def __init__(self, control_signal: SignalRW[ThawerStates]) -> None:
         self._control_signal = control_signal
         self._thawing_task: Task | None = None
@@ -32,7 +32,8 @@ class ThawingTimer(Device):
         finally:
             await self._control_signal.set(ThawerStates.OFF)
 
-    async def stop(self):
+    @AsyncStatus.wrap
+    async def stop(self, *args, **kwargs):
         if self._thawing_task:
             self._thawing_task.cancel()
 
@@ -43,6 +44,7 @@ class Thawer(StandardReadable, Stoppable):
         self.thaw_for_time_s = ThawingTimer(self.control)
         super().__init__(name)
 
-    async def stop(self):
+    @AsyncStatus.wrap
+    async def stop(self, *args, **kwargs):
         await self.thaw_for_time_s.stop()
         await self.control.set(ThawerStates.OFF)

dodal/devices/training_rig/sample_stage.py

@@ -0,0 +1,10 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class TrainingRigSampleStage(StandardReadable):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "X")
+            self.theta = Motor(prefix + "A")
+        super().__init__(name)

dodal/devices/turbo_slit.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import Device
-from ophyd_async.epics.motion.motor import Motor
+from ophyd_async.epics.motor import Motor
 
 
 class TurboSlit(Device):

dodal/devices/undulator.py

@@ -1,7 +1,7 @@
 from enum import Enum
 
 from ophyd_async.core import ConfigSignal, StandardReadable, soft_signal_r_and_setter
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.signal import epics_signal_r
 
 # The acceptable difference, in mm, between the undulator gap and the DCM

dodal/devices/undulator_dcm.py

@@ -74,14 +74,12 @@ class UndulatorDCM(StandardReadable, Movable):
             daq_configuration_path + "/domain/beamlineParameters"
         )["DCM_Perp_Offset_FIXED"]
 
-    def set(self, value: float) -> AsyncStatus:
-        async def _set():
-            await asyncio.gather(
-                self._set_dcm_energy(value),
-                self._set_undulator_gap_if_required(value),
-            )
-
-        return AsyncStatus(_set())
+    @AsyncStatus.wrap
+    async def set(self, value: float):
+        await asyncio.gather(
+            self._set_dcm_energy(value),
+            self._set_undulator_gap_if_required(value),
+        )
 
     async def _set_dcm_energy(self, energy_kev: float) -> None:
         access_level = await self.undulator.gap_access.get_value()

dodal/devices/util/adjuster_plans.py

@@ -3,12 +3,12 @@ All the methods in this module return a bluesky plan generator that adjusts a va
 according to some criteria either via feedback, preset positions, lookup tables etc.
 """
 
-from typing import Callable, Generator
+from collections.abc import Callable, Generator
 
 from bluesky import plan_stubs as bps
-from bluesky.run_engine import Msg
+from bluesky.utils import Msg
 from ophyd.epics_motor import EpicsMotor
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 
 from dodal.log import LOGGER
 

dodal/devices/util/epics_util.py

@@ -1,5 +1,5 @@
+from collections.abc import Callable, Sequence
 from functools import partial
-from typing import Callable, Sequence
 
 from bluesky.protocols import Movable
 from ophyd import Component, EpicsSignal
@@ -61,9 +61,9 @@ def run_functions_without_blocking(
     # Wrap each function by first checking the previous status and attaching a callback
     # to the next function in the chain
     def wrap_func(
-        old_status: Status, current_func: Callable[[], StatusBase], next_func
+        old_status: Status | None, current_func: Callable[[], StatusBase], next_func
     ):
-        if old_status.exception() is not None:
+        if old_status is not None and old_status.exception() is not None:
             set_global_exception_and_log(old_status)
             return
 
@@ -96,7 +96,7 @@ def run_functions_without_blocking(
     )
 
     # Wrap each function in reverse
-    for num, func in enumerate(list(reversed(functions_to_chain))[1:-1]):
+    for func in list(reversed(functions_to_chain))[1:-1]:
         wrapped_funcs.append(
             partial(
                 wrap_func,
@@ -105,10 +105,8 @@ def run_functions_without_blocking(
             )
         )
 
-    starting_status = Status(done=True, success=True)
-
     # Initiate the chain of functions
-    wrap_func(starting_status, functions_to_chain[0], wrapped_funcs[-1])
+    wrap_func(None, functions_to_chain[0], wrapped_funcs[-1])
     return full_status
 
 

dodal/devices/util/lookup_tables.py

@@ -3,9 +3,8 @@ All the public methods in this module return a lookup table of some kind that
 converts the source value s to a target value t for different values of s.
 """
 
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from io import StringIO
-from typing import Callable
 
 import aiofiles
 import numpy as np
@@ -36,7 +35,7 @@ async def energy_distance_table(lookup_table_path: str) -> np.ndarray:
 def linear_interpolation_lut(filename: str) -> Callable[[float], float]:
     """Returns a callable that converts values by linear interpolation of lookup table values"""
     LOGGER.info(f"Using lookup table {filename}")
-    s_and_t_vals = zip(*loadtxt(filename, comments=["#", "Units"]))
+    s_and_t_vals = zip(*loadtxt(filename, comments=["#", "Units"]), strict=False)
 
     s_values: Sequence
     t_values: Sequence