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

dodal/devices/detector/det_dist_to_beam_converter.py

@@ -47,7 +47,7 @@ class DetectorDistanceToBeamXYConverter:
 
     def parse_table(self) -> list:
         rows = loadtxt(self.lookup_file, delimiter=" ", comments=["#", "Units"])
-        columns = list(zip(*rows))
+        columns = list(zip(*rows, strict=False))
 
         return columns
 

dodal/devices/detector/detector.py

@@ -1,7 +1,7 @@
 from enum import Enum, auto
-from typing import Any, Tuple
+from pathlib import Path
 
-from pydantic import BaseModel, root_validator, validator
+from pydantic import BaseModel, Field, field_serializer, field_validator
 
 from dodal.devices.detector.det_dim_constants import (
     EIGER2_X_16M_SIZE,
@@ -28,9 +28,12 @@ class DetectorParams(BaseModel):
     """Holds parameters for the detector. Provides access to a list of Dectris detector
     sizes and a converter for distance to beam centre."""
 
+    # https://github.com/pydantic/pydantic/issues/8379
+    # Must use model_dump(by_alias=True) if serialising!
+
     expected_energy_ev: float | None = None
     exposure_time: float
-    directory: str
+    directory: str  # : Path https://github.com/DiamondLightSource/dodal/issues/774
     prefix: str
     detector_distance: float
     omega_start: float
@@ -39,48 +42,46 @@ class DetectorParams(BaseModel):
     num_triggers: int
     use_roi_mode: bool
     det_dist_to_beam_converter_path: str
+    override_run_number: int | None = Field(default=None, alias="run_number")
     trigger_mode: TriggerMode = TriggerMode.SET_FRAMES
     detector_size_constants: DetectorSizeConstants = EIGER2_X_16M_SIZE
-    beam_xy_converter: DetectorDistanceToBeamXYConverter
-    run_number: int
     enable_dev_shm: bool = (
         False  # Remove in https://github.com/DiamondLightSource/hyperion/issues/1395
     )
 
-    class Config:
-        arbitrary_types_allowed = True
-        json_encoders = {
-            DetectorDistanceToBeamXYConverter: lambda _: None,
-            DetectorSizeConstants: lambda d: d.det_type_string,
-        }
-
-    # should be replaced with model_validator once move to pydantic 2 is complete
-    @root_validator(pre=True)
-    def create_beamxy_and_runnumber(cls, values: dict[str, Any]) -> dict[str, Any]:
-        values["beam_xy_converter"] = DetectorDistanceToBeamXYConverter(
-            values["det_dist_to_beam_converter_path"]
+    @property
+    def beam_xy_converter(self) -> DetectorDistanceToBeamXYConverter:
+        return DetectorDistanceToBeamXYConverter(self.det_dist_to_beam_converter_path)
+
+    @property
+    def run_number(self) -> int:
+        return (
+            get_run_number(self.directory, self.prefix)
+            if self.override_run_number is None
+            else self.override_run_number
         )
-        if values.get("run_number") is None:
-            values["run_number"] = get_run_number(values["directory"], values["prefix"])
-        return values
-
-    @validator("detector_size_constants", pre=True)
-    def _parse_detector_size_constants(
-        cls, det_type: str, values: dict[str, Any]
-    ) -> DetectorSizeConstants:
+
+    @field_serializer("detector_size_constants")
+    def serialize_detector_size_constants(self, size: DetectorSizeConstants):
+        return size.det_type_string
+
+    @field_validator("detector_size_constants", mode="before")
+    @classmethod
+    def _parse_detector_size_constants(cls, det_type: str) -> DetectorSizeConstants:
         return (
             det_type
             if isinstance(det_type, DetectorSizeConstants)
             else constants_from_type(det_type)
         )
 
-    @validator("directory", pre=True)
-    def _parse_directory(cls, directory: str, values: dict[str, Any]) -> str:
-        if not directory.endswith("/"):
-            directory += "/"
-        return directory
+    @field_validator("directory", mode="before")
+    @classmethod
+    def _parse_directory(cls, directory: str | Path) -> str:
+        path = Path(directory)
+        assert path.is_dir()
+        return str(path)
 
-    def get_beam_position_mm(self, detector_distance: float) -> Tuple[float, float]:
+    def get_beam_position_mm(self, detector_distance: float) -> tuple[float, float]:
         x_beam_mm = self.beam_xy_converter.get_beam_xy_from_det_dist(
             detector_distance, Axis.X_AXIS
         )
@@ -105,7 +106,7 @@ class DetectorParams(BaseModel):
         roi_size = self.detector_size_constants.roi_size_pixels
         return roi_size if self.use_roi_mode else full_size
 
-    def get_beam_position_pixels(self, detector_distance: float) -> Tuple[float, float]:
+    def get_beam_position_pixels(self, detector_distance: float) -> tuple[float, float]:
         full_size_pixels = self.detector_size_constants.det_size_pixels
         roi_size_pixels = self.get_detector_size_pizels()
 

dodal/devices/detector/detector_motion.py

@@ -1,37 +1,44 @@
-from enum import IntEnum
+from enum import Enum
 
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsMotor, EpicsSignal, EpicsSignalRO
+from ophyd_async.core import Device
+from ophyd_async.epics.motor import Motor
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
 
-class ShutterState(IntEnum):
-    CLOSED = 0
-    OPEN = 1
+class ShutterState(str, Enum):
+    CLOSED = "Closed"
+    OPEN = "Open"
 
 
 class DetectorMotion(Device):
-    """Physical motion and interlocks for detector travel"""
-
-    upstream_x = Cpt(EpicsMotor, "-MO-DET-01:UPSTREAMX")
-    downstream_x = Cpt(EpicsMotor, "-MO-DET-01:DOWNSTREAMX")
-    x = Cpt(EpicsMotor, "-MO-DET-01:X")
-    y = Cpt(EpicsMotor, "-MO-DET-01:Y")
-    z = Cpt(EpicsMotor, "-MO-DET-01:Z")
-    yaw = Cpt(EpicsMotor, "-MO-DET-01:YAW")
-    shutter = Cpt(EpicsSignal, "-MO-DET-01:SET_SHUTTER_STATE")  # 0=closed, 1=open
-    #   monitors
-    shutter_closed_lim = Cpt(
-        EpicsSignalRO, "-MO-DET-01:CLOSE_LIMIT"
-    )  # on limit = 1, off = 0
-    shutter_open_lim = Cpt(
-        EpicsSignalRO, "-MO-DET-01:OPEN_LIMIT"
-    )  # on limit = 1, off = 0
-    z_disabled = Cpt(
-        EpicsSignalRO, "-MO-DET-01:Z:DISABLED"
-    )  # robot interlock, 0=ok to move, 1=blocked
-    crate_power = Cpt(
-        EpicsSignalRO, "-MO-PMAC-02:CRATE2_HEALTHY"
-    )  # returns 0 if no power
-    in_robot_load_safe_position = Cpt(
-        EpicsSignalRO, "-MO-PMAC-02:GPIO_INP_BITS.B2"
-    )  # returns 1 if safe
+    def __init__(self, prefix: str, name: str = ""):
+        device_prefix = "-MO-DET-01:"
+        pmac_prefix = "-MO-PMAC-02:"
+
+        self.upstream_x = Motor(f"{prefix}{device_prefix}UPSTREAMX")
+        self.downstream_x = Motor(f"{prefix}{device_prefix}DOWNSTREAMX")
+        self.x = Motor(f"{prefix}{device_prefix}X")
+        self.y = Motor(f"{prefix}{device_prefix}Y")
+        self.z = Motor(f"{prefix}{device_prefix}Z")
+        self.yaw = Motor(f"{prefix}{device_prefix}YAW")
+
+        self.shutter = epics_signal_rw(
+            ShutterState, f"{prefix}{device_prefix}SET_SHUTTER_STATE"
+        )
+        self.shutter_closed_lim = epics_signal_r(
+            float, f"{prefix}{device_prefix}CLOSE_LIMIT"
+        )  # on limit = 1, off = 0
+        self.shutter_open_lim = epics_signal_r(
+            float, f"{prefix}{device_prefix}OPEN_LIMIT"
+        )  # on limit = 1, off = 0
+        self.z_disabled = epics_signal_r(
+            float, f"{prefix}{device_prefix}Z:DISABLED"
+        )  # robot interlock, 0=ok to move, 1=blocked
+        self.crate_power = epics_signal_r(
+            float, f"{prefix}{pmac_prefix}CRATE2_HEALTHY"
+        )  # returns 0 if no power
+        self.in_robot_load_safe_position = epics_signal_r(
+            int, f"{prefix}{pmac_prefix}GPIO_INP_BITS.B2"
+        )  # returns 1 if safe
+
+        super().__init__(name)

dodal/devices/eiger.py

@@ -1,3 +1,4 @@
+# type: ignore # Eiger will soon be ophyd-async https://github.com/DiamondLightSource/dodal/issues/700
 from enum import Enum
 
 from ophyd import Component, Device, EpicsSignalRO, Signal
@@ -12,10 +13,6 @@ from dodal.log import LOGGER
 
 FREE_RUN_MAX_IMAGES = 1000000
 
-# TODO present for testing purposes, remove
-TEST_1169_FIX = True
-TEST_1169_INJECT = False
-
 
 class InternalEigerTriggerMode(Enum):
     INTERNAL_SERIES = 0
@@ -56,17 +53,15 @@ class EigerDetector(Device):
         cls,
         params: DetectorParams,
         name: str = "EigerDetector",
-        *args,
-        **kwargs,
     ):
-        det = cls(name=name, *args, **kwargs)
+        det = cls(name=name)
         det.set_detector_parameters(params)
         return det
 
     def set_detector_parameters(self, detector_params: DetectorParams):
         self.detector_params = detector_params
         if self.detector_params is None:
-            raise Exception("Parameters for scan must be specified")
+            raise ValueError("Parameters for scan must be specified")
 
         to_check = [
             (
@@ -103,7 +98,7 @@ class EigerDetector(Device):
 
     def stage(self):
         self.wait_on_arming_if_started()
-        if TEST_1169_INJECT or not self.is_armed():
+        if not self.is_armed():
             LOGGER.info("Eiger not armed, arming")
 
             self.async_stage().wait(timeout=self.ARMING_TIMEOUT)
@@ -318,7 +313,9 @@ class EigerDetector(Device):
 
     def _finish_arm(self) -> Status:
         LOGGER.info("Eiger staging: Finishing arming")
-        return Status(done=True, success=True)
+        status = Status()
+        status.set_finished()
+        return status
 
     def forward_bit_depth_to_filewriter(self):
         bit_depth = self.bit_depth.get()
@@ -341,6 +338,10 @@ class EigerDetector(Device):
             functions_to_do_arm.append(self.enable_roi_mode)
 
         arming_sequence_funcs = [
+            # If a beam dump occurs after arming the eiger but prior to eiger staging,
+            # the odin may timeout which will cause the arming sequence to be retried;
+            # if this previously completed successfully we must reset the odin first
+            self.odin.stop,
             lambda: self.change_dev_shm(detector_params.enable_dev_shm),
             lambda: self.set_detector_threshold(detector_params.expected_energy_ev),
             self.set_cam_pvs,
@@ -354,11 +355,6 @@ class EigerDetector(Device):
             self._wait_fan_ready,
             self._finish_arm,
         ]
-        if TEST_1169_FIX:
-            # If a beam dump occurs after arming the eiger but prior to eiger staging,
-            # the odin may timeout which will cause the arming sequence to be retried;
-            # if this previously completed successfully we must reset the odin first
-            arming_sequence_funcs.insert(0, self.odin.stop)
 
         functions_to_do_arm.extend(arming_sequence_funcs)
 

dodal/devices/eiger_odin.py

@@ -1,5 +1,4 @@
-from typing import List, Tuple
-
+# type: ignore # Eiger will soon be ophyd-async https://github.com/DiamondLightSource/dodal/issues/700
 from ophyd import Component, Device, EpicsSignal, EpicsSignalRO, EpicsSignalWithRBV
 from ophyd.areadetector.plugins import HDF5Plugin_V22
 from ophyd.sim import NullStatus
@@ -59,12 +58,12 @@ class OdinNodesStatus(Device):
     node_3 = Component(OdinNode, "OD4:")
 
     @property
-    def nodes(self) -> List[OdinNode]:
+    def nodes(self) -> list[OdinNode]:
         return [self.node_0, self.node_1, self.node_2, self.node_3]
 
     def check_node_frames_from_attr(
         self, node_get_func, error_message_verb: str
-    ) -> Tuple[bool, str]:
+    ) -> tuple[bool, str]:
         nodes_frames_values = [0] * len(self.nodes)
         frames_details = []
         for node_number, node_pv in enumerate(self.nodes):
@@ -75,17 +74,17 @@ class OdinNodesStatus(Device):
         bad_frames = any(v != 0 for v in nodes_frames_values)
         return bad_frames, "\n".join(frames_details)
 
-    def check_frames_timed_out(self) -> Tuple[bool, str]:
+    def check_frames_timed_out(self) -> tuple[bool, str]:
         return self.check_node_frames_from_attr(
             lambda node: node.frames_timed_out.get(), "timed out"
         )
 
-    def check_frames_dropped(self) -> Tuple[bool, str]:
+    def check_frames_dropped(self) -> tuple[bool, str]:
         return self.check_node_frames_from_attr(
             lambda node: node.frames_dropped.get(), "dropped"
         )
 
-    def get_error_state(self) -> Tuple[bool, str]:
+    def get_error_state(self) -> tuple[bool, str]:
         is_error = []
         error_messages = []
         for node_number, node_pv in enumerate(self.nodes):
@@ -99,7 +98,7 @@ class OdinNodesStatus(Device):
 
     def get_init_state(self) -> bool:
         is_initialised = []
-        for node_number, node_pv in enumerate(self.nodes):
+        for node_pv in self.nodes:
             is_initialised.append(node_pv.fr_initialised.get())
             is_initialised.append(node_pv.fp_initialised.get())
         return all(is_initialised)
@@ -132,7 +131,7 @@ class EigerOdin(Device):
         frames_timed_out, frames_timed_out_details = self.nodes.check_frames_timed_out()
 
         if not is_initialised:
-            raise Exception(error_message)
+            raise RuntimeError(error_message)
         if frames_dropped:
             self.log.error(f"Frames dropped: {frames_dropped_details}")
         if frames_timed_out:
@@ -140,7 +139,7 @@ class EigerOdin(Device):
 
         return is_initialised and not frames_dropped and not frames_timed_out
 
-    def check_odin_initialised(self) -> Tuple[bool, str]:
+    def check_odin_initialised(self) -> tuple[bool, str]:
         is_error_state, error_messages = self.nodes.get_error_state()
         to_check = [
             (not self.fan.consumers_connected.get(), "EigerFan is not connected"),

dodal/devices/fast_grid_scan.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Any, Generic, TypeVar
+from typing import Generic, TypeVar
 
 import numpy as np
 from bluesky.plan_stubs import mv
@@ -20,7 +20,7 @@ from ophyd_async.epics.signal import (
     epics_signal_rw_rbv,
     epics_signal_x,
 )
-from pydantic import validator
+from pydantic import field_validator
 from pydantic.dataclasses import dataclass
 
 from dodal.log import LOGGER
@@ -69,9 +69,6 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
     y2_start: float = 0.1
     z1_start: float = 0.1
     z2_start: float = 0.1
-    x_axis: GridAxis = GridAxis(0, 0, 0)
-    y_axis: GridAxis = GridAxis(0, 0, 0)
-    z_axis: GridAxis = GridAxis(0, 0, 0)
 
     # Whether to set the stub offsets after centering
     set_stub_offsets: bool = False
@@ -91,28 +88,20 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
             "z2_start": self.z2_start,
         }
 
-    class Config:
-        arbitrary_types_allowed = True
-        fields = {
-            "x_axis": {"exclude": True},
-            "y_axis": {"exclude": True},
-            "z_axis": {"exclude": True},
-        }
-
-    @validator("x_axis", always=True)
-    def _get_x_axis(cls, x_axis: GridAxis, values: dict[str, Any]) -> GridAxis:
-        return GridAxis(values["x_start"], values["x_step_size"], values["x_steps"])
+    @property
+    def x_axis(self) -> GridAxis:
+        return GridAxis(self.x_start, self.x_step_size, self.x_steps)
 
-    @validator("y_axis", always=True)
-    def _get_y_axis(cls, y_axis: GridAxis, values: dict[str, Any]) -> GridAxis:
-        return GridAxis(values["y1_start"], values["y_step_size"], values["y_steps"])
+    @property
+    def y_axis(self) -> GridAxis:
+        return GridAxis(self.y1_start, self.y_step_size, self.y_steps)
 
-    @validator("z_axis", always=True)
-    def _get_z_axis(cls, z_axis: GridAxis, values: dict[str, Any]) -> GridAxis:
-        return GridAxis(values["z2_start"], values["z_step_size"], values["z_steps"])
+    @property
+    def z_axis(self) -> GridAxis:
+        return GridAxis(self.z2_start, self.z_step_size, self.z_steps)
 
     def get_num_images(self):
-        return self.x_steps * self.y_steps + self.x_steps * self.z_steps
+        return self.x_steps * (self.y_steps + self.z_steps)
 
     @property
     def is_3d_grid_scan(self):
@@ -126,7 +115,7 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
         :return: The motor position this corresponds to.
         :raises: IndexError if the desired position is outside the grid."""
         for position, axis in zip(
-            grid_position, [self.x_axis, self.y_axis, self.z_axis]
+            grid_position, [self.x_axis, self.y_axis, self.z_axis], strict=False
         ):
             if not axis.is_within(position):
                 raise IndexError(f"{grid_position} is outside the bounds of the grid")
@@ -155,7 +144,8 @@ class ZebraGridScanParams(GridScanParamsCommon):
         param_positions["dwell_time_ms"] = self.dwell_time_ms
         return param_positions
 
-    @validator("dwell_time_ms", always=True, check_fields=True)
+    @field_validator("dwell_time_ms")
+    @classmethod
     def non_integer_dwell_time(cls, dwell_time_ms: float) -> float:
         dwell_time_floor_rounded = np.floor(dwell_time_ms)
         dwell_time_is_close = np.isclose(
@@ -191,9 +181,10 @@ class MotionProgram(Device):
 class ExpectedImages(SignalR[int]):
     def __init__(self, parent: "FastGridScanCommon") -> None:
         super().__init__(SoftSignalBackend(int))
-        self.parent: "FastGridScanCommon" = parent
+        self.parent = parent
 
-    async def get_value(self):
+    async def get_value(self, cached: bool | None = None):
+        assert isinstance(self.parent, FastGridScanCommon)
         x = await self.parent.x_steps.get_value()
         y = await self.parent.y_steps.get_value()
         z = await self.parent.z_steps.get_value()

dodal/devices/fluorescence_detector_motion.py

@@ -1,9 +1,18 @@
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsSignal
+from enum import Enum
 
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.signal import epics_signal_r
 
-class FluorescenceDetector(Device):
+
+class FluorescenceDetectorControlState(Enum):
     OUT = 0
     IN = 1
 
-    pos = Cpt(EpicsSignal, "-EA-FLU-01:CTRL")
+
+class FluorescenceDetector(StandardReadable):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.pos = epics_signal_r(
+                FluorescenceDetectorControlState, prefix + "-EA-FLU-01:CTRL"
+            )
+        super().__init__(name)

dodal/devices/focusing_mirror.py

@@ -2,13 +2,15 @@ from enum import Enum
 
 from ophyd_async.core import (
     AsyncStatus,
+    ConfigSignal,
     Device,
     DeviceVector,
+    HintedSignal,
     StandardReadable,
     observe_value,
+    soft_signal_r_and_setter,
 )
-from ophyd_async.core.signal import 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,
     epics_signal_rw,
@@ -144,10 +146,8 @@ class FocusingMirror(StandardReadable):
         # regardless of orientation of the mirror
         self.incident_angle = Motor(prefix + "PITCH")
 
-        self.set_readable_signals(
-            read=[self.incident_angle.user_readback],
-            config=[self.type],
-        )
+        self.add_readables([self.incident_angle.user_readback], wrapper=HintedSignal)
+        self.add_readables([self.type], wrapper=ConfigSignal)
         super().__init__(name)
 
 

dodal/devices/hutch_shutter.py

@@ -74,20 +74,20 @@ class HutchShutter(StandardReadable, Movable):
         super().__init__(name)
 
     @AsyncStatus.wrap
-    async def set(self, position_demand: ShutterDemand):
+    async def set(self, value: ShutterDemand):
         interlock_state = await self.interlock.shutter_safe_to_operate()
         if not interlock_state:
             raise ShutterNotSafeToOperateError(
                 "The hutch has not been locked, not operating shutter."
             )
-        if position_demand == ShutterDemand.OPEN:
+        if value == ShutterDemand.OPEN:
             await self.control.set(ShutterDemand.RESET, wait=True)
-            await self.control.set(position_demand, wait=True)
+            await self.control.set(value, wait=True)
             return await wait_for_value(
                 self.status, match=ShutterState.OPEN, timeout=DEFAULT_TIMEOUT
             )
         else:
-            await self.control.set(position_demand, wait=True)
+            await self.control.set(value, wait=True)
             return await wait_for_value(
                 self.status, match=ShutterState.CLOSED, timeout=DEFAULT_TIMEOUT
             )

dodal/devices/i22/dcm.py

@@ -1,11 +1,12 @@
 import time
+from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import Dict, Literal, Sequence
+from typing import Literal
 
 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.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.signal import epics_signal_r
 
 # Conversion constant for energy and wavelength, taken from the X-Ray data booklet
@@ -127,7 +128,7 @@ class DoubleCrystalMonochromator(StandardReadable):
 
         super().__init__(name)
 
-    async def describe(self) -> Dict[str, DataKey]:
+    async def describe(self) -> dict[str, DataKey]:
         default_describe = await super().describe()
         return {
             f"{self.name}-wavelength": DataKey(
@@ -139,7 +140,7 @@ class DoubleCrystalMonochromator(StandardReadable):
             **default_describe,
         }
 
-    async def read(self) -> Dict[str, Reading]:
+    async def read(self) -> dict[str, Reading]:
         default_reading = await super().read()
         energy: float = default_reading[f"{self.name}-energy"]["value"]
         if energy > 0.0:

dodal/devices/i22/fswitch.py

@@ -1,11 +1,15 @@
 import asyncio
 import time
 from enum import Enum
-from typing import Dict
 
-from bluesky.protocols import DataKey, Reading
-from ophyd_async.core import ConfigSignal, StandardReadable, soft_signal_r_and_setter
-from ophyd_async.core.device import DeviceVector
+from bluesky.protocols import Reading
+from event_model import DataKey
+from ophyd_async.core import (
+    ConfigSignal,
+    DeviceVector,
+    StandardReadable,
+    soft_signal_r_and_setter,
+)
 from ophyd_async.epics.signal import epics_signal_r
 
 
@@ -74,7 +78,7 @@ class FSwitch(StandardReadable):
 
         super().__init__(name)
 
-    async def describe(self) -> Dict[str, DataKey]:
+    async def describe(self) -> dict[str, DataKey]:
         default_describe = await super().describe()
         return {
             FSwitch.NUM_LENSES_FIELD_NAME: DataKey(
@@ -83,7 +87,7 @@ class FSwitch(StandardReadable):
             **default_describe,
         }
 
-    async def read(self) -> Dict[str, Reading]:
+    async def read(self) -> dict[str, Reading]:
         result = await asyncio.gather(
             *(filter.get_value() for filter in self.filters.values())
         )