dls-dodal 1.66.0__py3-none-any.whl → 1.68.0__py3-none-any.whl

dodal/devices/electron_analyser/base/base_detector.py

@@ -0,0 +1,214 @@
+from typing import Generic, TypeVar
+
+from bluesky.protocols import Reading, Stageable, Triggerable
+from event_model import DataKey
+from ophyd_async.core import (
+    AsyncConfigurable,
+    AsyncReadable,
+    AsyncStatus,
+    Device,
+    TriggerInfo,
+)
+
+from dodal.common.data_util import load_json_file_to_class
+from dodal.devices.electron_analyser.base.base_controller import (
+    ElectronAnalyserController,
+)
+from dodal.devices.electron_analyser.base.base_driver_io import (
+    GenericAnalyserDriverIO,
+    TAbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.base.base_region import (
+    GenericRegion,
+    GenericSequence,
+    TAbstractBaseRegion,
+    TAbstractBaseSequence,
+)
+
+
+class BaseElectronAnalyserDetector(
+    Device,
+    Triggerable,
+    AsyncReadable,
+    AsyncConfigurable,
+    Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
+):
+    """
+    Detector for data acquisition of electron analyser. Can only acquire using settings
+    already configured for the device.
+
+    If possible, this should be changed to inherit from a StandardDetector. Currently,
+    StandardDetector forces you to use a file writer which doesn't apply here.
+    See issue https://github.com/bluesky/ophyd-async/issues/888
+    """
+
+    def __init__(
+        self,
+        controller: ElectronAnalyserController[
+            TAbstractAnalyserDriverIO, TAbstractBaseRegion
+        ],
+        name: str = "",
+    ):
+        self._controller = controller
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, region: TAbstractBaseRegion) -> None:
+        await self._controller.setup_with_region(region)
+
+    @AsyncStatus.wrap
+    async def trigger(self) -> None:
+        await self._controller.prepare(TriggerInfo())
+        await self._controller.arm()
+        await self._controller.wait_for_idle()
+
+    async def read(self) -> dict[str, Reading]:
+        return await self._controller.driver.read()
+
+    async def describe(self) -> dict[str, DataKey]:
+        data = await self._controller.driver.describe()
+        # Correct the shape for image
+        prefix = self._controller.driver.name + "-"
+        energy_size = len(await self._controller.driver.energy_axis.get_value())
+        angle_size = len(await self._controller.driver.angle_axis.get_value())
+        data[prefix + "image"]["shape"] = [angle_size, energy_size]
+        return data
+
+    async def read_configuration(self) -> dict[str, Reading]:
+        return await self._controller.driver.read_configuration()
+
+    async def describe_configuration(self) -> dict[str, DataKey]:
+        return await self._controller.driver.describe_configuration()
+
+
+GenericBaseElectronAnalyserDetector = BaseElectronAnalyserDetector[
+    GenericAnalyserDriverIO, GenericRegion
+]
+
+
+class ElectronAnalyserRegionDetector(
+    BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
+    Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
+):
+    """
+    Extends electron analyser detector to configure specific region settings before data
+    acquisition. It is designed to only exist inside a plan.
+    """
+
+    def __init__(
+        self,
+        controller: ElectronAnalyserController[
+            TAbstractAnalyserDriverIO, TAbstractBaseRegion
+        ],
+        region: TAbstractBaseRegion,
+        name: str = "",
+    ):
+        self.region = region
+        super().__init__(controller, name)
+
+    @AsyncStatus.wrap
+    async def trigger(self) -> None:
+        # Configure region parameters on the driver first before data collection.
+        await self.set(self.region)
+        await super().trigger()
+
+
+GenericElectronAnalyserRegionDetector = ElectronAnalyserRegionDetector[
+    GenericAnalyserDriverIO, GenericRegion
+]
+TElectronAnalyserRegionDetector = TypeVar(
+    "TElectronAnalyserRegionDetector",
+    bound=ElectronAnalyserRegionDetector,
+)
+
+
+class ElectronAnalyserDetector(
+    BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
+    Stageable,
+    Generic[TAbstractBaseSequence, TAbstractAnalyserDriverIO, 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,
+        sequence_class: type[TAbstractBaseSequence],
+        controller: ElectronAnalyserController[
+            TAbstractAnalyserDriverIO, TAbstractBaseRegion
+        ],
+        name: str = "",
+    ):
+        self._sequence_class = sequence_class
+        super().__init__(controller, name)
+
+    @AsyncStatus.wrap
+    async def stage(self) -> None:
+        """
+        Prepare the detector for use by ensuring it is idle and ready.
+
+        This method asynchronously stages the detector by first disarming the controller
+        to ensure the detector is not actively acquiring data, then invokes the driver's
+        stage procedure. This ensures the detector is in a known, ready state
+        before use.
+
+        Raises:
+            Any exceptions raised by the driver's stage or controller's disarm methods.
+        """
+        await self._controller.disarm()
+
+    @AsyncStatus.wrap
+    async def unstage(self) -> None:
+        """Disarm the detector."""
+        await self._controller.disarm()
+
+    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: list[TAbstractBaseRegion] = (
+            seq.get_enabled_regions() if enabled_only else seq.regions
+        )
+        return [
+            ElectronAnalyserRegionDetector[
+                TAbstractAnalyserDriverIO, TAbstractBaseRegion
+            ](self._controller, r, self.name + "_" + r.name)
+            for r in regions
+        ]
+
+
+GenericElectronAnalyserDetector = ElectronAnalyserDetector[
+    GenericSequence, GenericAnalyserDriverIO, GenericRegion
+]
+TElectronAnalyserDetector = TypeVar(
+    "TElectronAnalyserDetector",
+    bound=ElectronAnalyserDetector,
+)

dodal/devices/electron_analyser/{abstract → base}/base_driver_io.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Generic, TypeVar
+from typing import Generic, TypeAlias, TypeVar
 
 import numpy as np
 from bluesky.protocols import Movable
@@ -9,27 +9,29 @@ from ophyd_async.core import (
     SignalR,
     StandardReadable,
     StandardReadableFormat,
+    StrictEnum,
+    SupersetEnum,
     derived_signal_r,
     soft_signal_rw,
 )
-from ophyd_async.epics.adcore import ADBaseIO, ADImageMode
+from ophyd_async.epics.adcore import ADBaseIO
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.devices.electron_analyser.abstract.base_region import (
+from dodal.devices.electron_analyser.base.base_enums import EnergyMode
+from dodal.devices.electron_analyser.base.base_region import (
+    AnyAcqMode,
+    AnyLensMode,
+    AnyPassEnergy,
+    GenericRegion,
     TAbstractBaseRegion,
-)
-from dodal.devices.electron_analyser.abstract.types import (
     TAcquisitionMode,
     TLensMode,
     TPassEnergy,
-    TPsuMode,
-)
-from dodal.devices.electron_analyser.energy_sources import (
-    DualEnergySource,
-    EnergySource,
 )
-from dodal.devices.electron_analyser.enums import EnergyMode
-from dodal.devices.electron_analyser.util import to_binding_energy
+from dodal.devices.electron_analyser.base.base_util import to_binding_energy
+
+AnyPsuMode: TypeAlias = SupersetEnum | StrictEnum
+TPsuMode = TypeVar("TPsuMode", bound=AnyPsuMode)
 
 
 class AbstractAnalyserDriverIO(
@@ -52,7 +54,6 @@ class AbstractAnalyserDriverIO(
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
         pass_energy_type: type[TPassEnergy],
-        energy_source: EnergySource | DualEnergySource,
         name: str = "",
     ) -> None:
         """
@@ -87,7 +88,6 @@ class AbstractAnalyserDriverIO(
             self.total_intensity = derived_signal_r(
                 self._calculate_total_intensity, spectrum=self.spectrum
             )
-            self.energy_source = energy_source
 
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Read once per scan after data acquired
@@ -96,6 +96,9 @@ class AbstractAnalyserDriverIO(
             self.energy_mode = soft_signal_rw(
                 EnergyMode, initial_value=EnergyMode.KINETIC
             )
+            self.cached_excitation_energy = soft_signal_rw(
+                float, initial_value=0, units="eV"
+            )
             self.low_energy = epics_signal_rw(float, prefix + "LOW_ENERGY")
             self.centre_energy = epics_signal_rw(float, prefix + "CENTRE_ENERGY")
             self.high_energy = epics_signal_rw(float, prefix + "HIGH_ENERGY")
@@ -121,7 +124,7 @@ class AbstractAnalyserDriverIO(
                 self._calculate_binding_energy_axis,
                 "eV",
                 energy_axis=self.energy_axis,
-                excitation_energy=self.energy_source.energy,
+                excitation_energy=self.cached_excitation_energy,
                 energy_mode=self.energy_mode,
             )
             self.angle_axis = self._create_angle_axis_signal(prefix)
@@ -134,34 +137,9 @@ class AbstractAnalyserDriverIO(
                 iterations=self.iterations,
             )
 
-    @AsyncStatus.wrap
-    async def stage(self) -> None:
-        await self.image_mode.set(ADImageMode.SINGLE)
-        await super().stage()
-
-    @AsyncStatus.wrap
-    async def set(self, region: TAbstractBaseRegion):
-        """
-        Take a region object and setup the driver with it. If using a DualEnergySource,
-        set it to use the source selected by the region. It also converts the region to
-        kinetic mode before we move the driver signals to the region parameter values:
-
-        Args:
-            region: Contains the parameters to setup the driver for a scan.
-        """
-        if isinstance(self.energy_source, DualEnergySource):
-            self.energy_source.selected_source.set(region.excitation_energy_source)
-        excitation_energy = await self.energy_source.energy.get_value()
-
-        # Switch to kinetic energy as epics doesn't support BINDING.
-        ke_region = region.switch_energy_mode(EnergyMode.KINETIC, excitation_energy)
-        await self._set_region(ke_region)
-        # Set the true energy mode from original region so binding_energy_axis can be
-        # calculated correctly.
-        await self.energy_mode.set(region.energy_mode)
-
     @abstractmethod
-    async def _set_region(self, ke_region: TAbstractBaseRegion):
+    @AsyncStatus.wrap
+    async def set(self, epics_region: TAbstractBaseRegion):
         """
         Move a group of signals defined in a region. Each implementation of this class
         is responsible for implementing this method correctly.
@@ -245,6 +223,9 @@ class AbstractAnalyserDriverIO(
         return float(np.sum(spectrum, dtype=np.float64))
 
 
+GenericAnalyserDriverIO = AbstractAnalyserDriverIO[
+    GenericRegion, AnyAcqMode, AnyLensMode, AnyPsuMode, AnyPassEnergy
+]
 TAbstractAnalyserDriverIO = TypeVar(
     "TAbstractAnalyserDriverIO", bound=AbstractAnalyserDriverIO
 )

dodal/devices/electron_analyser/{abstract → base}/base_region.py

@@ -1,17 +1,29 @@
 import re
 from abc import ABC
 from collections.abc import Callable
-from typing import Generic, Self, TypeVar
+from typing import Generic, Self, TypeAlias, TypeVar
 
+from ophyd_async.core import StrictEnum, SupersetEnum
 from pydantic import BaseModel, Field, model_validator
 
-from dodal.devices.electron_analyser.abstract.types import (
-    TAcquisitionMode,
-    TLensMode,
-    TPassEnergy,
+from dodal.devices.electron_analyser.base.base_enums import EnergyMode, SelectedSource
+from dodal.devices.electron_analyser.base.base_util import (
+    to_binding_energy,
+    to_kinetic_energy,
 )
-from dodal.devices.electron_analyser.enums import EnergyMode, SelectedSource
-from dodal.devices.electron_analyser.util import to_binding_energy, to_kinetic_energy
+
+AnyAcqMode: TypeAlias = StrictEnum
+AnyLensMode: TypeAlias = SupersetEnum | StrictEnum
+AnyPassEnergy: TypeAlias = StrictEnum | float
+AnyPsuMode: TypeAlias = SupersetEnum | StrictEnum
+
+TAcquisitionMode = TypeVar("TAcquisitionMode", bound=AnyAcqMode)
+# Allow SupersetEnum. Specs analysers can connect to Lens and Psu mode separately to the
+# analyser which leaves the enum to either be "Not connected" OR the available enums
+# when connected.
+TLensMode = TypeVar("TLensMode", bound=AnyLensMode)
+TPassEnergy = TypeVar("TPassEnergy", bound=AnyPassEnergy)
+TPsuMode = TypeVar("TPsuMode", bound=AnyPsuMode)
 
 
 def java_to_python_case(java_str: str) -> str:
@@ -88,10 +100,13 @@ class AbstractBaseRegion(
         return self.energy_mode == EnergyMode.KINETIC
 
     def switch_energy_mode(
-        self, energy_mode: EnergyMode, excitation_energy: float, copy: bool = True
+        self,
+        energy_mode: EnergyMode,
+        excitation_energy: float,
+        copy: bool = True,
     ) -> Self:
         """
-        Switch region with to a new energy mode with a new energy mode: Kinetic or Binding.
+        Get a region with a new energy mode: Kinetic or Binding.
         It caculates new values for low_energy, centre_energy, high_energy, via the
         excitation enerrgy. It doesn't calculate anything if the region is already of
         the same energy mode.
@@ -100,8 +115,8 @@ class AbstractBaseRegion(
             energy_mode: Mode you want to switch the region to.
             excitation_energy: Energy conversion for low_energy, centre_energy, and
                                high_energy for new energy mode.
-            copy: Defaults to True. If true, create a copy of this region for the new
-                  energy_mode and return it. If False, alter this region for the
+            copy: Defaults to True. If true, create a copy of this region to alter for
+                  the new energy_mode and return it. If False, alter this region for the
                   energy_mode and return it self.
 
         Returns:
@@ -126,6 +141,25 @@ class AbstractBaseRegion(
 
         return switched_r
 
+    def prepare_for_epics(self, excitation_energy: float, copy: bool = True) -> Self:
+        """Prepares a region for epics by converting BINDING to KINETIC by calculating
+        new values for low_energy, centre_energy, and high_energy while also preserving
+        the original energy mode e.g mode BINDING will stay as BINDING.
+
+        Parameters:
+            excitation_energy: Energy conversion for low_energy, centre_energy, and
+                               high_energy for new energy mode.
+            copy: Defaults to True. If true, create a copy of this region to alter to
+                  calculate new energy values to return. If false, alter this region.
+        Returns:
+            Region with selected original energy mode and new calculated KINETIC energy
+            values for epics.
+        """
+        original_energy_mode = self.energy_mode
+        r = self.switch_energy_mode(EnergyMode.KINETIC, excitation_energy, copy)
+        r.energy_mode = original_energy_mode
+        return r
+
     @model_validator(mode="before")
     @classmethod
     def before_validation(cls, data: dict) -> dict:
@@ -133,6 +167,7 @@ class AbstractBaseRegion(
         return energy_mode_validation(data)
 
 
+GenericRegion = AbstractBaseRegion[AnyAcqMode, AnyLensMode, AnyPassEnergy]
 TAbstractBaseRegion = TypeVar("TAbstractBaseRegion", bound=AbstractBaseRegion)
 
 
@@ -163,4 +198,5 @@ class AbstractBaseSequence(
         return next((region for region in self.regions if region.name == name), None)
 
 
+GenericSequence = AbstractBaseSequence[GenericRegion]
 TAbstractBaseSequence = TypeVar("TAbstractBaseSequence", bound=AbstractBaseSequence)

dodal/devices/electron_analyser/{util.py → base/base_util.py}

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

dodal/devices/electron_analyser/{energy_sources.py → base/energy_sources.py}

@@ -10,7 +10,7 @@ from ophyd_async.core import (
     soft_signal_rw,
 )
 
-from dodal.devices.electron_analyser.enums import SelectedSource
+from dodal.devices.electron_analyser.base.base_enums import SelectedSource
 
 
 class AbstractEnergySource(StandardReadable):

dodal/devices/electron_analyser/specs/__init__.py

@@ -1,7 +1,7 @@
-from .detector import SpecsDetector
-from .driver_io import SpecsAnalyserDriverIO
-from .enums import AcquisitionMode
-from .region import SpecsRegion, SpecsSequence
+from .specs_detector import SpecsDetector
+from .specs_driver_io import SpecsAnalyserDriverIO
+from .specs_enums import AcquisitionMode
+from .specs_region import SpecsRegion, SpecsSequence
 
 __all__ = [
     "SpecsDetector",

dodal/devices/electron_analyser/specs/specs_detector.py

@@ -0,0 +1,46 @@
+from typing import Generic
+
+from dodal.devices.electron_analyser.base.base_controller import (
+    ElectronAnalyserController,
+)
+from dodal.devices.electron_analyser.base.base_detector import ElectronAnalyserDetector
+from dodal.devices.electron_analyser.base.base_region import TLensMode, TPsuMode
+from dodal.devices.electron_analyser.base.energy_sources import (
+    DualEnergySource,
+    EnergySource,
+)
+from dodal.devices.electron_analyser.specs.specs_driver_io import SpecsAnalyserDriverIO
+from dodal.devices.electron_analyser.specs.specs_region import (
+    SpecsRegion,
+    SpecsSequence,
+)
+
+
+class SpecsDetector(
+    ElectronAnalyserDetector[
+        SpecsSequence[TLensMode, TPsuMode],
+        SpecsAnalyserDriverIO[TLensMode, TPsuMode],
+        SpecsRegion[TLensMode, TPsuMode],
+    ],
+    Generic[TLensMode, TPsuMode],
+):
+    def __init__(
+        self,
+        prefix: str,
+        lens_mode_type: type[TLensMode],
+        psu_mode_type: type[TPsuMode],
+        energy_source: DualEnergySource | EnergySource,
+        name: str = "",
+    ):
+        # Save to class so takes part with connect()
+        self.driver = SpecsAnalyserDriverIO[TLensMode, TPsuMode](
+            prefix, lens_mode_type, psu_mode_type
+        )
+
+        controller = ElectronAnalyserController[
+            SpecsAnalyserDriverIO[TLensMode, TPsuMode], SpecsRegion[TLensMode, TPsuMode]
+        ](self.driver, energy_source, 0)
+
+        sequence_class = SpecsSequence[lens_mode_type, psu_mode_type]
+
+        super().__init__(sequence_class, controller, name)

dodal/devices/electron_analyser/specs/{driver_io.py → specs_driver_io.py}

@@ -4,22 +4,19 @@ from typing import Generic
 import numpy as np
 from ophyd_async.core import (
     Array1D,
+    AsyncStatus,
     SignalR,
     StandardReadableFormat,
     derived_signal_r,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.devices.electron_analyser.abstract.base_driver_io import (
+from dodal.devices.electron_analyser.base.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
-from dodal.devices.electron_analyser.abstract.types import TLensMode, TPsuMode
-from dodal.devices.electron_analyser.energy_sources import (
-    DualEnergySource,
-    EnergySource,
-)
-from dodal.devices.electron_analyser.specs.enums import AcquisitionMode
-from dodal.devices.electron_analyser.specs.region import SpecsRegion
+from dodal.devices.electron_analyser.base.base_region import TLensMode, TPsuMode
+from dodal.devices.electron_analyser.specs.specs_enums import AcquisitionMode
+from dodal.devices.electron_analyser.specs.specs_region import SpecsRegion
 
 
 class SpecsAnalyserDriverIO(
@@ -37,7 +34,6 @@ class SpecsAnalyserDriverIO(
         prefix: str,
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
-        energy_source: EnergySource | DualEnergySource,
         name: str = "",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
@@ -59,29 +55,30 @@ class SpecsAnalyserDriverIO(
             lens_mode_type=lens_mode_type,
             psu_mode_type=psu_mode_type,
             pass_energy_type=float,
-            energy_source=energy_source,
             name=name,
         )
 
-    async def _set_region(self, ke_region: SpecsRegion[TLensMode, TPsuMode]):
+    @AsyncStatus.wrap
+    async def set(self, epics_region: SpecsRegion[TLensMode, TPsuMode]):
         await asyncio.gather(
-            self.region_name.set(ke_region.name),
-            self.low_energy.set(ke_region.low_energy),
-            self.high_energy.set(ke_region.high_energy),
-            self.slices.set(ke_region.slices),
-            self.acquire_time.set(ke_region.acquire_time),
-            self.lens_mode.set(ke_region.lens_mode),
-            self.pass_energy.set(ke_region.pass_energy),
-            self.iterations.set(ke_region.iterations),
-            self.acquisition_mode.set(ke_region.acquisition_mode),
-            self.snapshot_values.set(ke_region.values),
-            self.psu_mode.set(ke_region.psu_mode),
+            self.region_name.set(epics_region.name),
+            self.low_energy.set(epics_region.low_energy),
+            self.high_energy.set(epics_region.high_energy),
+            self.slices.set(epics_region.slices),
+            self.acquire_time.set(epics_region.acquire_time),
+            self.lens_mode.set(epics_region.lens_mode),
+            self.pass_energy.set(epics_region.pass_energy),
+            self.iterations.set(epics_region.iterations),
+            self.acquisition_mode.set(epics_region.acquisition_mode),
+            self.snapshot_values.set(epics_region.values),
+            self.psu_mode.set(epics_region.psu_mode),
+            self.energy_mode.set(epics_region.energy_mode),
         )
-        if ke_region.acquisition_mode == AcquisitionMode.FIXED_TRANSMISSION:
-            await self.energy_step.set(ke_region.energy_step)
+        if epics_region.acquisition_mode == AcquisitionMode.FIXED_TRANSMISSION:
+            await self.energy_step.set(epics_region.energy_step)
 
-        if ke_region.acquisition_mode == AcquisitionMode.FIXED_ENERGY:
-            await self.centre_energy.set(ke_region.centre_energy)
+        if epics_region.acquisition_mode == AcquisitionMode.FIXED_ENERGY:
+            await self.centre_energy.set(epics_region.centre_energy)
 
     def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
         angle_axis = derived_signal_r(

dodal/devices/electron_analyser/specs/{region.py → specs_region.py}

@@ -2,12 +2,13 @@ from typing import Generic
 
 from pydantic import Field
 
-from dodal.devices.electron_analyser.abstract.base_region import (
+from dodal.devices.electron_analyser.base.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
+    TLensMode,
+    TPsuMode,
 )
-from dodal.devices.electron_analyser.abstract.types import TLensMode, TPsuMode
-from dodal.devices.electron_analyser.specs.enums import AcquisitionMode
+from dodal.devices.electron_analyser.specs.specs_enums import AcquisitionMode
 
 
 class SpecsRegion(

dodal/devices/electron_analyser/vgscienta/__init__.py

@@ -1,7 +1,7 @@
-from .detector import VGScientaDetector
-from .driver_io import VGScientaAnalyserDriverIO
-from .enums import AcquisitionMode, DetectorMode
-from .region import VGScientaRegion, VGScientaSequence
+from .vgscienta_detector import VGScientaDetector
+from .vgscienta_driver_io import VGScientaAnalyserDriverIO
+from .vgscienta_enums import AcquisitionMode, DetectorMode
+from .vgscienta_region import VGScientaRegion, VGScientaSequence
 
 __all__ = [
     "VGScientaDetector",