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

dodal/devices/aperturescatterguard.py

@@ -1,12 +1,16 @@
+from __future__ import annotations
+
 import asyncio
-from collections import namedtuple
-from dataclasses import asdict, dataclass
 from enum import Enum
 
-from bluesky.protocols import Movable, Reading
-from event_model.documents.event_descriptor import DataKey
-from ophyd_async.core import AsyncStatus, HintedSignal, 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
@@ -17,100 +21,76 @@ 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
+    @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"],
+        )
 
+    @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,
+        )
 
-@dataclass
-class SingleAperturePosition:
-    name: str
-    GDA_name: str
-    radius_microns: float | None
-    location: ApertureFiveDimensionalLocation
 
+class ApertureValue(str, Enum):
+    """Maps from a short usable name to the value name in the GDA Beamline parameters"""
 
-# 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"
-
-    def __str__(self):
-        return str(self.value)
-
-
-def position_from_params(
-    name: str,
-    GDA_name: AperturePositionGDANames,
-    radius_microns: float | None,
-    params: GDABeamlineParameters,
-) -> 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 load_tolerances_from_beamline_params(
-    params: GDABeamlineParameters,
-) -> 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"],
-    )
-
-
-class AperturePosition(Enum):
-    ROBOT_LOAD = 0
-    SMALL = 1
-    MEDIUM = 2
-    LARGE = 3
+    SMALL = "SMALL_APERTURE"
+    MEDIUM = "MEDIUM_APERTURE"
+    LARGE = "LARGE_APERTURE"
 
 
 def load_positions_from_beamline_parameters(
     params: GDABeamlineParameters,
-) -> dict[AperturePosition, SingleAperturePosition]:
+) -> dict[ApertureValue, AperturePosition]:
     return {
-        AperturePosition.ROBOT_LOAD: position_from_params(
-            "Robot load", AperturePositionGDANames.ROBOT_LOAD, None, params
+        ApertureValue.ROBOT_LOAD: AperturePosition.from_gda_params(
+            ApertureValue.ROBOT_LOAD, None, params
         ),
-        AperturePosition.SMALL: position_from_params(
-            "Small", AperturePositionGDANames.SMALL_APERTURE, 20, params
+        ApertureValue.SMALL: AperturePosition.from_gda_params(
+            ApertureValue.SMALL, 20, params
         ),
-        AperturePosition.MEDIUM: position_from_params(
-            "Medium", AperturePositionGDANames.MEDIUM_APERTURE, 50, params
+        ApertureValue.MEDIUM: AperturePosition.from_gda_params(
+            ApertureValue.MEDIUM, 50, params
         ),
-        AperturePosition.LARGE: position_from_params(
-            "Large", AperturePositionGDANames.LARGE_APERTURE, 100, params
+        ApertureValue.LARGE: AperturePosition.from_gda_params(
+            ApertureValue.LARGE, 100, params
         ),
     }
 
@@ -118,119 +98,86 @@ def load_positions_from_beamline_parameters(
 class ApertureScatterguard(StandardReadable, Movable):
     def __init__(
         self,
-        loaded_positions: dict[AperturePosition, SingleAperturePosition],
-        tolerances: ApertureScatterguardTolerances,
+        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 = Aperture(prefix + "-MO-MAPT-01:")
+        self.scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
+        self.radius = soft_signal_rw(float, units="µm")
         self._loaded_positions = loaded_positions
         self._tolerances = tolerances
-        aperture_backend = SoftSignalBackend(
-            SingleAperturePosition, self._loaded_positions[AperturePosition.ROBOT_LOAD]
+        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.add_readables([self.selected_aperture], wrapper=HintedSignal)
-        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,
-            )
+        with self.add_children_as_readables(HintedSignal):
+            self.selected_aperture = soft_signal_rw(ApertureValue)
 
-    class SelectedAperture(SignalR):
-        async def read(self, *args, **kwargs):
-            assert isinstance(self.parent, ApertureScatterguard)
-            assert self._backend
-            await self._backend.put(await self.parent.get_current_aperture_position())
-            return {self.name: await self._backend.get_reading()}
-
-        async def describe(self) -> dict[str, DataKey]:
-            return {
-                self._name: DataKey(
-                    dtype="array",
-                    shape=[
-                        -1,
-                    ],  # TODO describe properly - see https://github.com/DiamondLightSource/dodal/issues/253,
-                    source=self._backend.source(self._name),  # type: ignore
-                )
-            }
+        super().__init__(name)
 
     def get_position_from_gda_aperture_name(
-        self, gda_aperture_name: AperturePositionGDANames
-    ) -> AperturePosition:
-        for aperture, detail in self._loaded_positions.items():
-            if detail.GDA_name == gda_aperture_name:
-                return aperture
-        raise ValueError(
-            f"Tried to convert unknown aperture name {gda_aperture_name} to a SingleAperturePosition"
-        )
-
-    def get_gda_name_for_position(self, position: AperturePosition) -> str:
-        detailed_position = self._loaded_positions[position]
-        return detailed_position.GDA_name
+        self, gda_aperture_name: str
+    ) -> ApertureValue:
+        return ApertureValue(gda_aperture_name)
 
     @AsyncStatus.wrap
-    async def set(self, value: AperturePosition):
+    async def set(self, value: ApertureValue):
         position = self._loaded_positions[value]
-        await self._safe_move_within_datacollection_range(position.location)
-
-    def _get_motor_list(self):
-        return [
-            self._aperture.x,
-            self._aperture.y,
-            self._aperture.z,
-            self._scatterguard.x,
-            self._scatterguard.y,
-        ]
+        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),
-            self._aperture.y.set(aperture_y),
-            self._aperture.z.set(aperture_z),
-            self._scatterguard.x.set(scatterguard_x),
-            self._scatterguard.y.set(scatterguard_y),
+            self.aperture.x.set(aperture_x),
+            self.aperture.y.set(aperture_y),
+            self.aperture.z.set(aperture_z),
+            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.
         """
-        current_ap_y = await self._aperture.y.user_readback.get_value(cached=False)
-        robot_load_ap_y = self._loaded_positions[
-            AperturePosition.ROBOT_LOAD
-        ].location.aperture_y
-        if await self._aperture.large.get_value(cached=False) == 1:
-            return self._loaded_positions[AperturePosition.LARGE]
-        elif await self._aperture.medium.get_value(cached=False) == 1:
-            return self._loaded_positions[AperturePosition.MEDIUM]
-        elif await self._aperture.small.get_value(cached=False) == 1:
-            return self._loaded_positions[AperturePosition.SMALL]
-        elif current_ap_y <= robot_load_ap_y + self._tolerances.ap_y:
-            return self._loaded_positions[AperturePosition.ROBOT_LOAD]
+        current_ap_y = await self.aperture.y.user_readback.get_value(cached=False)
+        robot_load_ap_y = self._loaded_positions[ApertureValue.ROBOT_LOAD].aperture_y
+        if await self.aperture.large.get_value(cached=False) == 1:
+            return ApertureValue.LARGE
+        elif await self.aperture.medium.get_value(cached=False) == 1:
+            return ApertureValue.MEDIUM
+        elif await self.aperture.small.get_value(cached=False) == 1:
+            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.
@@ -238,45 +185,50 @@ class ApertureScatterguard(StandardReadable, Movable):
         for why this is required.
         """
         assert self._loaded_positions is not None
-        # unpacking the position
-        aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = pos
 
-        ap_z_in_position = await self._aperture.z.motor_done_move.get_value()
+        ap_z_in_position = await self.aperture.z.motor_done_move.get_value()
         if not ap_z_in_position:
             raise InvalidApertureMove(
                 "ApertureScatterguard z is still moving. Wait for it to finish "
                 "before triggering another move."
             )
 
-        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._tolerances.ap_z:
+        current_ap_z = await self.aperture.z.user_readback.get_value()
+        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._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()
+        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),
+                self.scatterguard.x.set(scatterguard_x),
+                self.scatterguard.y.set(scatterguard_y),
             )
             await asyncio.gather(
-                self._aperture.x.set(aperture_x),
-                self._aperture.y.set(aperture_y),
-                self._aperture.z.set(aperture_z),
+                self.aperture.x.set(aperture_x),
+                self.aperture.y.set(aperture_y),
+                self.aperture.z.set(aperture_z),
             )
             return
         await asyncio.gather(
-            self._aperture.x.set(aperture_x),
-            self._aperture.y.set(aperture_y),
-            self._aperture.z.set(aperture_z),
+            self.aperture.x.set(aperture_x),
+            self.aperture.y.set(aperture_y),
+            self.aperture.z.set(aperture_z),
         )
 
         await asyncio.gather(
-            self._scatterguard.x.set(scatterguard_x),
-            self._scatterguard.y.set(scatterguard_y),
+            self.scatterguard.x.set(scatterguard_x),
+            self.scatterguard.y.set(scatterguard_y),
         )
+        await self.selected_aperture.set(value)

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/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/detector.py

@@ -1,7 +1,7 @@
 from enum import Enum, auto
-from typing import Any
+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,46 +42,44 @@ 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 = None  # type: ignore # Filled in by validator
-    run_number: int = None  # type: ignore # Filled in by validator
     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]:
         x_beam_mm = self.beam_xy_converter.get_beam_xy_from_det_dist(

dodal/devices/detector/detector_motion.py

@@ -1,7 +1,7 @@
 from enum import Enum
 
 from ophyd_async.core import Device
-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
 
 

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):
@@ -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(

dodal/devices/focusing_mirror.py

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