dls-dodal 1.48.0__py3-none-any.whl → 1.49.0__py3-none-any.whl

dodal/devices/bimorph_mirror.py

@@ -1,10 +1,8 @@
 import asyncio
-from collections.abc import Mapping
 from typing import Annotated as A
 
 from bluesky.protocols import Movable
 from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
     AsyncStatus,
     DeviceVector,
     SignalR,
@@ -12,6 +10,7 @@ from ophyd_async.core import (
     SignalW,
     StandardReadable,
     StrictEnum,
+    set_and_wait_for_other_value,
     wait_for_value,
 )
 from ophyd_async.core import StandardReadableFormat as Format
@@ -23,6 +22,8 @@ from ophyd_async.epics.core import (
     epics_signal_x,
 )
 
+DEFAULT_TIMEOUT = 60
+
 
 class BimorphMirrorOnOff(StrictEnum):
     ON = "ON"
@@ -41,7 +42,7 @@ class BimorphMirrorStatus(StrictEnum):
     ERROR = "Error"
 
 
-class BimorphMirrorChannel(StandardReadable, Movable[float], EpicsDevice):
+class BimorphMirrorChannel(StandardReadable, EpicsDevice):
     """Collection of PVs comprising a single bimorph channel.
 
     Attributes:
@@ -56,23 +57,13 @@ class BimorphMirrorChannel(StandardReadable, Movable[float], EpicsDevice):
     status: A[SignalR[BimorphMirrorOnOff], PvSuffix("STATUS"), Format.CONFIG_SIGNAL]
     shift: A[SignalW[float], PvSuffix("SHIFT")]
 
-    @AsyncStatus.wrap
-    async def set(self, value: float):
-        """Sets channel's VOUT to given value.
-
-        Args:
-            value: float to set VOUT to
-        """
-        await self.output_voltage.set(value)
-
 
-class BimorphMirror(StandardReadable, Movable[Mapping[int, float]]):
+class BimorphMirror(StandardReadable, Movable[list[float]]):
     """Class to represent CAENels Bimorph Mirrors.
 
     Attributes:
         channels: DeviceVector of BimorphMirrorChannel, indexed from 1, for each channel
         enabled: Writeable BimorphOnOff
-        commit_target_voltages: Procable signal that writes values in each channel's VTRGT to VOUT
         status: Readable BimorphMirrorStatus Busy/Idle status
         err: Alarm status"""
 
@@ -103,49 +94,51 @@ class BimorphMirror(StandardReadable, Movable[Mapping[int, float]]):
         super().__init__(name=name)
 
     @AsyncStatus.wrap
-    async def set(self, value: Mapping[int, float], tolerance: float = 0.0001) -> None:
-        """Sets bimorph voltages in parrallel via target voltage and all proc.
+    async def set(self, value: list[float]) -> None:
+        """Sets bimorph voltages in parallel via target voltage and all proc.
 
         Args:
-            value: Dict of channel numbers to target voltages
+            value: List of float target voltages
 
         Raises:
             ValueError: On set to non-existent channel"""
 
-        if any(key not in self.channels for key in value):
+        if len(value) != len(self.channels):
             raise ValueError(
-                f"Attempting to put to non-existent channels: {[key for key in value if (key not in self.channels)]}"
+                f"Length of value input array does not match number of \
+                             channels: {len(value)} and {len(self.channels)}"
             )
 
-        # Write target voltages:
-        await asyncio.gather(
-            *[
-                self.channels[i].target_voltage.set(target, wait=True)
-                for i, target in value.items()
-            ]
-        )
+        # Write target voltages in serial
+        # Voltages are written in serial as bimorph PSU cannot handle simultaneous sets
+        for i, target in enumerate(value):
+            await wait_for_value(
+                self.status, BimorphMirrorStatus.IDLE, timeout=DEFAULT_TIMEOUT
+            )
+            await set_and_wait_for_other_value(
+                self.channels[i + 1].target_voltage,
+                target,
+                self.status,
+                BimorphMirrorStatus.BUSY,
+            )
 
         # Trigger set target voltages:
+        await wait_for_value(
+            self.status, BimorphMirrorStatus.IDLE, timeout=DEFAULT_TIMEOUT
+        )
         await self.commit_target_voltages.trigger()
 
         # Wait for values to propogate to voltage out rbv:
         await asyncio.gather(
             *[
                 wait_for_value(
-                    self.channels[i].output_voltage,
-                    tolerance_func_builder(tolerance, target),
+                    self.channels[i + 1].output_voltage,
+                    target,
                     timeout=DEFAULT_TIMEOUT,
                 )
-                for i, target in value.items()
+                for i, target in enumerate(value)
             ],
             wait_for_value(
                 self.status, BimorphMirrorStatus.IDLE, timeout=DEFAULT_TIMEOUT
             ),
         )
-
-
-def tolerance_func_builder(tolerance: float, target_value: float):
-    def is_within_value(x):
-        return abs(x - target_value) <= tolerance
-
-    return is_within_value

dodal/devices/electron_analyser/__init__.py

@@ -1,10 +1,16 @@
-from .abstract.base_detector import (
+from .detector import (
     ElectronAnalyserDetector,
     ElectronAnalyserRegionDetector,
     TElectronAnalyserDetector,
     TElectronAnalyserRegionDetector,
 )
-from .types import EnergyMode
+from .enums import EnergyMode
+from .types import (
+    ElectronAnalyserDetectorImpl,
+    ElectronAnalyserDriverImpl,
+    GenericElectronAnalyserDetector,
+    GenericElectronAnalyserRegionDetector,
+)
 from .util import to_binding_energy, to_kinetic_energy
 
 __all__ = [
@@ -12,7 +18,11 @@ __all__ = [
     "to_kinetic_energy",
     "EnergyMode",
     "ElectronAnalyserDetector",
+    "ElectronAnalyserDetectorImpl",
+    "ElectronAnalyserDriverImpl",
     "TElectronAnalyserDetector",
     "ElectronAnalyserRegionDetector",
     "TElectronAnalyserRegionDetector",
+    "GenericElectronAnalyserDetector",
+    "GenericElectronAnalyserRegionDetector",
 ]

dodal/devices/electron_analyser/abstract/base_detector.py

@@ -1,30 +1,23 @@
 import asyncio
 from abc import abstractmethod
-from typing import Generic, TypeVar
+from typing import Generic
 
-from bluesky.protocols import Preparable, Reading, Stageable, Triggerable
+from bluesky.protocols import Reading, Stageable, Triggerable
 from event_model import DataKey
 from ophyd_async.core import (
     AsyncConfigurable,
     AsyncReadable,
     AsyncStatus,
     Device,
-    Reference,
 )
 from ophyd_async.epics.adcore import (
     ADBaseController,
 )
-from ophyd_async.epics.motor import Motor
 
-from dodal.common.data_util import load_json_file_to_class
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
     AbstractAnalyserDriverIO,
     TAbstractAnalyserDriverIO,
 )
-from dodal.devices.electron_analyser.abstract.base_region import (
-    TAbstractBaseRegion,
-    TAbstractBaseSequence,
-)
 
 
 class ElectronAnalyserController(ADBaseController[AbstractAnalyserDriverIO]):
@@ -51,8 +44,8 @@ class AbstractElectronAnalyserDetector(
 
     def __init__(
         self,
-        name: str,
         driver: TAbstractAnalyserDriverIO,
+        name: str = "",
     ):
         self.controller: ElectronAnalyserController = ElectronAnalyserController(
             driver=driver
@@ -103,121 +96,3 @@ class AbstractElectronAnalyserDetector(
         Returns:
             instance of the driver.
         """
-
-
-class ElectronAnalyserRegionDetector(
-    AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
-    Preparable,
-    Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
-):
-    """
-    Extends electron analyser detector to configure specific region settings before data
-    acqusition. This object must be passed in a driver and store it as a reference. It
-    is designed to only exist inside a plan.
-    """
-
-    def __init__(
-        self, name: str, driver: TAbstractAnalyserDriverIO, region: TAbstractBaseRegion
-    ):
-        self._driver_ref = Reference(driver)
-        self.region = region
-        super().__init__(name, driver)
-
-    @property
-    def driver(self) -> TAbstractAnalyserDriverIO:
-        # Store as a reference, this implementation will be given a driver so needs to
-        # make sure we don't get conflicting parents.
-        return self._driver_ref()
-
-    @AsyncStatus.wrap
-    async def prepare(self, value: Motor) -> None:
-        """
-        Prepare driver with the region stored and energy_source motor.
-
-        Args:
-            value: The excitation energy source that the region has selected.
-        """
-        excitation_energy_source = value
-        await self.driver.prepare(excitation_energy_source)
-        await self.driver.set(self.region)
-
-
-TElectronAnalyserRegionDetector = TypeVar(
-    "TElectronAnalyserRegionDetector",
-    bound=ElectronAnalyserRegionDetector,
-)
-
-
-class ElectronAnalyserDetector(
-    AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
-    Generic[
-        TAbstractAnalyserDriverIO,
-        TAbstractBaseSequence,
-        TAbstractBaseRegion,
-    ],
-):
-    """
-    Electron analyser detector with the additional functionality to load a sequence file
-    and create a list of temporary ElectronAnalyserRegionDetector objects. These will
-    setup configured region settings before data acquisition.
-    """
-
-    def __init__(
-        self,
-        prefix: str,
-        sequence_class: type[TAbstractBaseSequence],
-        driver: TAbstractAnalyserDriverIO,
-        name: str = "",
-    ):
-        # Pass in driver
-        self._driver = driver
-        self._sequence_class = sequence_class
-        super().__init__(name, self.driver)
-
-    @property
-    def driver(self) -> TAbstractAnalyserDriverIO:
-        # This implementation creates the driver and wants this to be the parent so it
-        # can be used with connect() method.
-        return self._driver
-
-    def load_sequence(self, filename: str) -> TAbstractBaseSequence:
-        """
-        Load the sequence data from a provided json file into a sequence class.
-
-        Args:
-            filename: Path to the sequence file containing the region data.
-
-        Returns:
-            Pydantic model representing the sequence file.
-        """
-        return load_json_file_to_class(self._sequence_class, filename)
-
-    def create_region_detector_list(
-        self, filename: str, enabled_only=True
-    ) -> list[
-        ElectronAnalyserRegionDetector[TAbstractAnalyserDriverIO, TAbstractBaseRegion]
-    ]:
-        """
-        Create a list of detectors equal to the number of regions in a sequence file.
-        Each detector is responsible for setting up a specific region.
-
-        Args:
-            filename:     Path to the sequence file containing the region data.
-            enabled_only: If true, only include the region if enabled is True.
-
-        Returns:
-            List of ElectronAnalyserRegionDetector, equal to the number of regions in
-            the sequence file.
-        """
-        seq = self.load_sequence(filename)
-        regions = seq.get_enabled_regions() if enabled_only else seq.regions
-        return [
-            ElectronAnalyserRegionDetector(self.name + "_" + r.name, self.driver, r)
-            for r in regions
-        ]
-
-
-TElectronAnalyserDetector = TypeVar(
-    "TElectronAnalyserDetector",
-    bound=ElectronAnalyserDetector,
-)

dodal/devices/electron_analyser/abstract/base_driver_io.py

@@ -10,6 +10,7 @@ from ophyd_async.core import (
     SignalR,
     StandardReadable,
     StandardReadableFormat,
+    StrictEnum,
     derived_signal_r,
     soft_signal_rw,
 )
@@ -20,7 +21,7 @@ from ophyd_async.epics.motor import Motor
 from dodal.devices.electron_analyser.abstract.base_region import (
     TAbstractBaseRegion,
 )
-from dodal.devices.electron_analyser.types import EnergyMode
+from dodal.devices.electron_analyser.enums import EnergyMode
 from dodal.devices.electron_analyser.util import to_binding_energy, to_kinetic_energy
 
 
@@ -37,7 +38,9 @@ class AbstractAnalyserDriverIO(
     Electron analysers should inherit from this class for further specialisation.
     """
 
-    def __init__(self, prefix: str, name: str = "") -> None:
+    def __init__(
+        self, prefix: str, acquisition_mode_type: type[StrictEnum], name: str = ""
+    ) -> None:
         with self.add_children_as_readables():
             self.image = epics_signal_r(Array1D[np.float64], prefix + "IMAGE")
             self.spectrum = epics_signal_r(Array1D[np.float64], prefix + "INT_SPECTRUM")
@@ -61,7 +64,9 @@ class AbstractAnalyserDriverIO(
             )
             self.energy_step = epics_signal_rw(float, prefix + "STEP_SIZE")
             self.iterations = epics_signal_rw(int, prefix + "NumExposures")
-            self.acquisition_mode = epics_signal_rw(str, prefix + "ACQ_MODE")
+            self.acquisition_mode = epics_signal_rw(
+                acquisition_mode_type, prefix + "ACQ_MODE"
+            )
             self.excitation_energy_source = soft_signal_rw(str, initial_value="")
 
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):

dodal/devices/electron_analyser/abstract/base_region.py

@@ -3,9 +3,12 @@ from abc import ABC
 from collections.abc import Callable
 from typing import Generic, TypeVar
 
+from ophyd_async.core import StrictEnum
 from pydantic import BaseModel, Field, model_validator
 
-from dodal.devices.electron_analyser.types import EnergyMode
+from dodal.devices.electron_analyser.enums import EnergyMode
+
+TStrictEnum = TypeVar("TStrictEnum", bound=StrictEnum)
 
 
 def java_to_python_case(java_str: str) -> str:
@@ -43,7 +46,7 @@ def energy_mode_validation(data: dict) -> dict:
     return data
 
 
-class AbstractBaseRegion(ABC, JavaToPythonModel):
+class AbstractBaseRegion(ABC, JavaToPythonModel, Generic[TStrictEnum]):
     """
     Generic region model that holds the data. Specialised region models should inherit
     this to extend functionality. All energy units are assumed to be in eV.
@@ -57,7 +60,7 @@ class AbstractBaseRegion(ABC, JavaToPythonModel):
     # These ones we need subclasses to provide default values
     lens_mode: str
     pass_energy: int
-    acquisition_mode: str
+    acquisition_mode: TStrictEnum
     low_energy: float
     high_energy: float
     step_time: float

dodal/devices/electron_analyser/detector.py

@@ -0,0 +1,141 @@
+from typing import Generic, TypeVar
+
+from bluesky.protocols import Preparable
+from ophyd_async.core import (
+    AsyncStatus,
+    Reference,
+)
+from ophyd_async.epics.motor import Motor
+
+from dodal.common.data_util import load_json_file_to_class
+from dodal.devices.electron_analyser.abstract.base_detector import (
+    AbstractElectronAnalyserDetector,
+)
+from dodal.devices.electron_analyser.abstract.base_driver_io import (
+    TAbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.abstract.base_region import (
+    TAbstractBaseRegion,
+    TAbstractBaseSequence,
+)
+
+
+class ElectronAnalyserRegionDetector(
+    AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
+    Preparable,
+    Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
+):
+    """
+    Extends electron analyser detector to configure specific region settings before data
+    acqusition. This object must be passed in a driver and store it as a reference. It
+    is designed to only exist inside a plan.
+    """
+
+    def __init__(
+        self,
+        driver: TAbstractAnalyserDriverIO,
+        region: TAbstractBaseRegion,
+        name: str = "",
+    ):
+        self._driver_ref = Reference(driver)
+        self.region = region
+        super().__init__(driver, name)
+
+    @property
+    def driver(self) -> TAbstractAnalyserDriverIO:
+        # Store as a reference, this implementation will be given a driver so needs to
+        # make sure we don't get conflicting parents.
+        return self._driver_ref()
+
+    @AsyncStatus.wrap
+    async def prepare(self, value: Motor) -> None:
+        """
+        Prepare driver with the region stored and energy_source motor.
+
+        Args:
+            value: The excitation energy source that the region has selected.
+        """
+        excitation_energy_source = value
+        await self.driver.prepare(excitation_energy_source)
+        await self.driver.set(self.region)
+
+
+TElectronAnalyserRegionDetector = TypeVar(
+    "TElectronAnalyserRegionDetector",
+    bound=ElectronAnalyserRegionDetector,
+)
+
+
+class ElectronAnalyserDetector(
+    AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
+    Generic[
+        TAbstractAnalyserDriverIO,
+        TAbstractBaseSequence,
+        TAbstractBaseRegion,
+    ],
+):
+    """
+    Electron analyser detector with the additional functionality to load a sequence file
+    and create a list of temporary ElectronAnalyserRegionDetector objects. These will
+    setup configured region settings before data acquisition.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        sequence_class: type[TAbstractBaseSequence],
+        driver: TAbstractAnalyserDriverIO,
+        name: str = "",
+    ):
+        # Pass in driver
+        self._driver = driver
+        self._sequence_class = sequence_class
+        super().__init__(self.driver, name)
+
+    @property
+    def driver(self) -> TAbstractAnalyserDriverIO:
+        # This implementation creates the driver and wants this to be the parent so it
+        # can be used with connect() method.
+        return self._driver
+
+    def load_sequence(self, filename: str) -> TAbstractBaseSequence:
+        """
+        Load the sequence data from a provided json file into a sequence class.
+
+        Args:
+            filename: Path to the sequence file containing the region data.
+
+        Returns:
+            Pydantic model representing the sequence file.
+        """
+        return load_json_file_to_class(self._sequence_class, filename)
+
+    def create_region_detector_list(
+        self, filename: str, enabled_only=True
+    ) -> list[
+        ElectronAnalyserRegionDetector[TAbstractAnalyserDriverIO, TAbstractBaseRegion]
+    ]:
+        """
+        Create a list of detectors equal to the number of regions in a sequence file.
+        Each detector is responsible for setting up a specific region.
+
+        Args:
+            filename:     Path to the sequence file containing the region data.
+            enabled_only: If true, only include the region if enabled is True.
+
+        Returns:
+            List of ElectronAnalyserRegionDetector, equal to the number of regions in
+            the sequence file.
+        """
+        seq = self.load_sequence(filename)
+        regions = seq.get_enabled_regions() if enabled_only else seq.regions
+        return [
+            ElectronAnalyserRegionDetector(self.driver, r, self.name + "_" + r.name)
+            for r in regions
+        ]
+
+
+TElectronAnalyserDetector = TypeVar(
+    "TElectronAnalyserDetector",
+    bound=ElectronAnalyserDetector,
+)

dodal/devices/electron_analyser/enums.py

@@ -0,0 +1,6 @@
+from ophyd_async.core import StrictEnum
+
+
+class EnergyMode(StrictEnum):
+    KINETIC = "Kinetic"
+    BINDING = "Binding"

dodal/devices/electron_analyser/specs/__init__.py

@@ -1,10 +1,12 @@
 from .detector import SpecsDetector
 from .driver_io import SpecsAnalyserDriverIO
+from .enums import AcquisitionMode
 from .region import SpecsRegion, SpecsSequence
 
 __all__ = [
     "SpecsDetector",
     "SpecsAnalyserDriverIO",
+    "AcquisitionMode",
     "SpecsRegion",
     "SpecsSequence",
 ]

dodal/devices/electron_analyser/specs/detector.py

@@ -1,4 +1,4 @@
-from dodal.devices.electron_analyser.abstract.base_detector import (
+from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
 from dodal.devices.electron_analyser.specs.driver_io import SpecsAnalyserDriverIO

dodal/devices/electron_analyser/specs/driver_io.py

@@ -13,6 +13,7 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
+from dodal.devices.electron_analyser.specs.enums import AcquisitionMode
 from dodal.devices.electron_analyser.specs.region import SpecsRegion
 
 
@@ -28,7 +29,7 @@ class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO[SpecsRegion]):
             self.min_angle_axis = epics_signal_r(float, prefix + "Y_MIN_RBV")
             self.max_angle_axis = epics_signal_r(float, prefix + "Y_MAX_RBV")
 
-        super().__init__(prefix, name)
+        super().__init__(prefix, AcquisitionMode, name)
 
     @AsyncStatus.wrap
     async def set(self, region: SpecsRegion):
@@ -38,12 +39,10 @@ class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO[SpecsRegion]):
             self.snapshot_values.set(region.values),
             self.psu_mode.set(region.psu_mode),
         )
-        # ToDo - This needs to be changed to an Enum
-        # https://github.com/DiamondLightSource/dodal/issues/1258
-        if region.acquisition_mode == "Fixed Transmission":
+        if region.acquisition_mode == AcquisitionMode.FIXED_TRANSMISSION:
             await self.centre_energy.set(region.centre_energy)
 
-        if self.acquisition_mode == "Fixed Energy":
+        if self.acquisition_mode == AcquisitionMode.FIXED_ENERGY:
             await self.energy_step.set(region.energy_step)
 
     def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:

dodal/devices/electron_analyser/specs/enums.py

@@ -0,0 +1,8 @@
+from ophyd_async.core import StrictEnum
+
+
+class AcquisitionMode(StrictEnum):
+    FIXED_TRANSMISSION = "Fixed Transmission"
+    SNAPSHOT = "Snapshot"
+    FIXED_RETARDING_RATIO = "Fixed Retarding Ratio"
+    FIXED_ENERGY = "Fixed Energy"

dodal/devices/electron_analyser/specs/region.py

@@ -4,13 +4,14 @@ from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
 )
+from dodal.devices.electron_analyser.specs.enums import AcquisitionMode
 
 
-class SpecsRegion(AbstractBaseRegion):
+class SpecsRegion(AbstractBaseRegion[AcquisitionMode]):
     # Override base class with defaults
     lens_mode: str = "SmallArea"
     pass_energy: int = 5
-    acquisition_mode: str = "Fixed Transmission"
+    acquisition_mode: AcquisitionMode = AcquisitionMode.FIXED_TRANSMISSION
     low_energy: float = Field(default=800, alias="start_energy")
     high_energy: float = Field(default=850, alias="end_energy")
     step_time: float = Field(default=1.0, alias="exposure_time")

dodal/devices/electron_analyser/types.py

@@ -1,6 +1,32 @@
-from ophyd_async.core import StrictEnum
+from dodal.devices.electron_analyser.abstract.base_driver_io import (
+    AbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.abstract.base_region import (
+    AbstractBaseRegion,
+    AbstractBaseSequence,
+)
+from dodal.devices.electron_analyser.detector import (
+    ElectronAnalyserDetector,
+    ElectronAnalyserRegionDetector,
+)
+from dodal.devices.electron_analyser.specs.detector import (
+    SpecsAnalyserDriverIO,
+    SpecsDetector,
+)
+from dodal.devices.electron_analyser.vgscienta.detector import (
+    VGScientaAnalyserDriverIO,
+    VGScientaDetector,
+)
 
+ElectronAnalyserDetectorImpl = VGScientaDetector | SpecsDetector
+ElectronAnalyserDriverImpl = VGScientaAnalyserDriverIO | SpecsAnalyserDriverIO
 
-class EnergyMode(StrictEnum):
-    KINETIC = "Kinetic"
-    BINDING = "Binding"
+GenericElectronAnalyserDetector = ElectronAnalyserDetector[
+    AbstractAnalyserDriverIO[AbstractBaseRegion],
+    AbstractBaseSequence,
+    AbstractBaseRegion,
+]
+
+GenericElectronAnalyserRegionDetector = ElectronAnalyserRegionDetector[
+    AbstractAnalyserDriverIO[AbstractBaseRegion], AbstractBaseRegion
+]

dodal/devices/electron_analyser/util.py

@@ -1,4 +1,4 @@
-from dodal.devices.electron_analyser.types import EnergyMode
+from dodal.devices.electron_analyser.enums import EnergyMode
 
 
 def to_kinetic_energy(