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

dodal/devices/electron_analyser/specs/specs_detector.py

@@ -5,15 +5,14 @@ from dodal.devices.electron_analyser.base.base_controller import (
 )
 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.base.energy_sources import AbstractEnergySource
 from dodal.devices.electron_analyser.specs.specs_driver_io import SpecsAnalyserDriverIO
 from dodal.devices.electron_analyser.specs.specs_region import (
     SpecsRegion,
     SpecsSequence,
 )
+from dodal.devices.fast_shutter import FastShutter
+from dodal.devices.selectable_source import SourceSelector
 
 
 class SpecsDetector(
@@ -29,7 +28,9 @@ class SpecsDetector(
         prefix: str,
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
-        energy_source: DualEnergySource | EnergySource,
+        energy_source: AbstractEnergySource,
+        shutter: FastShutter | None = None,
+        source_selector: SourceSelector | None = None,
         name: str = "",
     ):
         # Save to class so takes part with connect()
@@ -39,7 +40,7 @@ class SpecsDetector(
 
         controller = ElectronAnalyserController[
             SpecsAnalyserDriverIO[TLensMode, TPsuMode], SpecsRegion[TLensMode, TPsuMode]
-        ](self.driver, energy_source, 0)
+        ](self.driver, energy_source, shutter, source_selector)
 
         sequence_class = SpecsSequence[lens_mode_type, psu_mode_type]
 

dodal/devices/electron_analyser/vgscienta/vgscienta_detector.py

@@ -5,10 +5,7 @@ from dodal.devices.electron_analyser.base.base_controller import (
 )
 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.base.energy_sources import AbstractEnergySource
 from dodal.devices.electron_analyser.vgscienta.vgscienta_driver_io import (
     VGScientaAnalyserDriverIO,
 )
@@ -17,6 +14,8 @@ from dodal.devices.electron_analyser.vgscienta.vgscienta_region import (
     VGScientaRegion,
     VGScientaSequence,
 )
+from dodal.devices.fast_shutter import FastShutter
+from dodal.devices.selectable_source import SourceSelector
 
 
 class VGScientaDetector(
@@ -33,7 +32,9 @@ class VGScientaDetector(
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
         pass_energy_type: type[TPassEnergyEnum],
-        energy_source: DualEnergySource | EnergySource,
+        energy_source: AbstractEnergySource,
+        shutter: FastShutter | None = None,
+        source_selector: SourceSelector | None = None,
         name: str = "",
     ):
         # Save to class so takes part with connect()
@@ -44,7 +45,7 @@ class VGScientaDetector(
         controller = ElectronAnalyserController[
             VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum],
             VGScientaRegion[TLensMode, TPassEnergyEnum],
-        ](self.driver, energy_source, 0)
+        ](self.driver, energy_source, shutter, source_selector)
 
         sequence_class = VGScientaSequence[
             lens_mode_type, psu_mode_type, pass_energy_type

dodal/devices/eurotherm.py

@@ -37,7 +37,7 @@ _EUROTHERM_RBV: str = ":RBV"
 
 
 class EurothermPID(StandardReadable):
-    """The class for the Eurotherm PID values"""
+    """The class for the Eurotherm PID values."""
 
     def __init__(
         self,
@@ -111,7 +111,8 @@ class UpdatingEurothermGeneral(EurothermGeneral):
 
 class EurothermAutotune(StandardReadable):
     """Newer versions of Eurotherm controllers have the ability to Autotune the
-    PID values, and this is the device"""
+    PID values, and this is the device.
+    """
 
     def __init__(
         self,

dodal/devices/fast_grid_scan.py

@@ -44,34 +44,32 @@ class GridAxis:
     full_steps: int
 
     def steps_to_motor_position(self, steps):
-        """Gives the motor position based on steps, where steps are 0 indexed"""
+        """Gives the motor position based on steps, where steps are 0 indexed."""
         return self.start + self.step_size_mm * steps
 
     @property
     def end(self):
-        """Gives the point where the final frame is taken"""
+        """Gives the point where the final frame is taken."""
         # Note that full_steps is one indexed e.g. if there is one step then the end is
         # refering to the first position
         return self.steps_to_motor_position(self.full_steps - 1)
 
     def is_within(self, steps: float):
-        """
-        Determine whether a single axis coordinate is within the grid.
+        """Determine whether a single axis coordinate is within the grid.
         The coordinate is from a continuous coordinate space based on the
         XRC grid where the origin corresponds to the centre of the first grid box.
 
         Args:
-            steps: The coordinate to check
+            steps (float): The coordinate to check.
 
         Returns:
-            True if the coordinate falls within the grid.
+            bool: True if the coordinate falls within the grid.
         """
         return -0.5 <= steps <= self.full_steps - 0.5
 
 
 class GridScanParamsCommon(AbstractExperimentWithBeamParams):
-    """
-    Common holder class for the parameters of a grid scan in a similar
+    """Common holder class for the parameters of a grid scan in a similar
     layout to EPICS. The parameters and functions of this class are common
     to both the zebra and panda triggered fast grid scans in 2d or 3d.
 
@@ -108,10 +106,12 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
         to a real motor position.
 
         Args:
-            grid_position: The x, y, z position in grid steps. The origin is at the
-                centre of the first grid box
+            grid_position (ndarray): The x, y, z position in grid steps. The origin is
+                at the centre of the first grid box
+
         Returns:
-            The motor position this corresponds to.
+            ndarray: The motor position this corresponds to.
+
         Raises:
             IndexError if the desired position is outside the grid.
         """
@@ -133,8 +133,8 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
 class GridScanParamsThreeD(GridScanParamsCommon):
     """Additional parameters required to do a 3 dimensional gridscan.
 
-    A 3D gridscan works by doing two 2D gridscans. The first of these grids is x_steps by
-    y_steps. The sample is then rotated by 90 degrees, and then the second grid is
+    A 3D gridscan works by doing two 2D gridscans. The first of these grids is x_steps
+    by y_steps. The sample is then rotated by 90 degrees, and then the second grid is
     x_steps by z_steps.
     """
 
@@ -173,16 +173,13 @@ class WithDwellTime(BaseModel):
 
 
 class ZebraGridScanParamsThreeD(GridScanParamsThreeD, WithDwellTime):
-    """
-    Params for standard Zebra FGS. Adds on the dwell time, which is really the time
+    """Params for standard Zebra FGS. Adds on the dwell time, which is really the time
     between trigger positions.
     """
 
 
 class PandAGridScanParams(GridScanParamsThreeD):
-    """
-    Params for panda constant-motion scan. Adds on the goniometer run-up distance
-    """
+    """Params for panda constant-motion scan. Adds on the goniometer run-up distance."""
 
     run_up_distance_mm: float = 0.17
 
@@ -203,8 +200,8 @@ class FastGridScanCommon(
 ):
     """Device containing the minimal signals for a general fast grid scan.
 
-    When the motion program is started, the goniometer will move in a snake-like grid trajectory,
-    with X as the fast axis and Y as the slow axis.
+    When the motion program is started, the goniometer will move in a snake-like grid
+    trajectory, with X as the fast axis and Y as the slow axis.
 
     See ZebraFastGridScanThreeD as an example of how to implement.
     """
@@ -297,14 +294,14 @@ class FastGridScanCommon(
 
     @AsyncStatus.wrap
     async def prepare(self, value: ParamType):
-        """
-        Submit the gridscan parameters to the device for validation prior to
-        gridscan kickoff
+        """Submit the gridscan parameters to the device for validation prior to
+        gridscan kickoff.
+
         Args:
-            value: the gridscan parameters
+            value (ParamType): The gridscan parameters.
 
         Raises:
-            GridScanInvalidError: if the gridscan parameters were not valid
+            GridScanInvalidError: If the gridscan parameters were not valid.
         """
         set_statuses = []
 
@@ -426,8 +423,8 @@ class FastGridScanThreeD(FastGridScanCommon[ParamType]):
 class ZebraFastGridScanThreeD(FastGridScanThreeD[ZebraGridScanParamsThreeD]):
     """Device for standard Zebra 3D FGS.
 
-    In this scan, the goniometer's velocity profile follows a parabolic shape between X steps,
-    with the slowest points occuring at each X step.
+    In this scan, the goniometer's velocity profile follows a parabolic shape between X
+    steps, with the slowest points occuring at each X step.
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
@@ -448,8 +445,8 @@ class ZebraFastGridScanThreeD(FastGridScanThreeD[ZebraGridScanParamsThreeD]):
 class PandAFastGridScan(FastGridScanThreeD[PandAGridScanParams]):
     """Device for panda constant-motion scan.
 
-    In this scan, the goniometer's velocity
-    is constant through each row. It doesn't slow down when going through trigger points.
+    In this scan, the goniometer's velocity is constant through each row. It doesn't
+    slow down when going through trigger points.
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
@@ -475,13 +472,13 @@ class PandAFastGridScan(FastGridScanThreeD[PandAGridScanParams]):
 
 
 def set_fast_grid_scan_params(scan: FastGridScanCommon[ParamType], params: ParamType):
-    """
-    Apply the fast grid scan parameters to the grid scan device and validate them
+    """Apply the fast grid scan parameters to the grid scan device and validate them.
+
     Args:
-        scan: The fast grid scan device
-        params: The parameters to set
+        scan (FastGridScancommon[ParamType]): The fast grid scan device.
+        params (ParamType): The parameters to set.
 
     Raises:
-        GridScanInvalidError: if the grid scan parameters are not valid
+        GridScanInvalidError: if the grid scan parameters are not valid.
     """
     yield from prepare(scan, params, wait=True)

dodal/devices/fast_shutter.py

@@ -1,69 +1,155 @@
-from typing import TypeVar
+from typing import Generic, Protocol, TypeVar
 
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
     EnumTypes,
+    Reference,
+    SignalRW,
     StandardReadable,
+    StandardReadableFormat,
+    derived_signal_rw,
+    soft_signal_r_and_setter,
 )
 from ophyd_async.epics.core import epics_signal_rw
 
-StrictEnumT = TypeVar("StrictEnumT", bound=EnumTypes)
+from dodal.devices.selectable_source import SelectedSource, get_obj_from_selected_source
 
+EnumTypesT = TypeVar("EnumTypesT", bound=EnumTypes)
 
-class GenericFastShutter(StandardReadable, Movable[StrictEnumT]):
-    """
-    Basic enum device specialised for a fast shutter with configured open_state and
+
+class FastShutter(Movable[EnumTypesT], Protocol, Generic[EnumTypesT]):
+    """Enum device specialised for a fast shutter with configured open_state and
     close_state so it is generic enough to be used with any device or plan without
     knowing the specific enum to use.
 
-    For example:
+    For example::
+
         await shutter.set(shutter.open_state)
         await shutter.set(shutter.close_state)
-    OR
+
+    OR::
+
         run_engine(bps.mv(shutter, shutter.open_state))
         run_engine(bps.mv(shutter, shutter.close_state))
     """
 
+    open_state: EnumTypesT
+    close_state: EnumTypesT
+    shutter_state: SignalRW[EnumTypesT]
+
+    @AsyncStatus.wrap
+    async def set(self, state: EnumTypesT):
+        await self.shutter_state.set(state)
+
+
+class GenericFastShutter(
+    StandardReadable, FastShutter[EnumTypesT], Generic[EnumTypesT]
+):
+    """Implementation of fast shutter that connects to an epics pv. This pv is an enum that
+    controls the open and close state of the shutter.
+
+    Args:
+        pv (str): The pv to connect to the shutter device.
+        open_state (EnumTypesT): The enum value that corresponds with opening the
+            shutter.
+        close_state (EnumTypesT): The enum value that corresponds with closing the
+            shutter.
+        name (str, optional): The name of the shutter.
+    """
+
     def __init__(
         self,
         pv: str,
-        open_state: StrictEnumT,
-        close_state: StrictEnumT,
+        open_state: EnumTypesT,
+        close_state: EnumTypesT,
         name: str = "",
     ):
-        """
-        Arguments:
-            pv: The pv to connect to the shutter device.
-            open_state: The enum value that corresponds with opening the shutter.
-            close_state: The enum value that corresponds with closing the shutter.
-        """
         self.open_state = open_state
         self.close_state = close_state
         with self.add_children_as_readables():
-            self.state = epics_signal_rw(type(self.open_state), pv)
+            self.shutter_state = epics_signal_rw(type(self.open_state), pv)
         super().__init__(name)
 
-    @AsyncStatus.wrap
-    async def set(self, value: StrictEnumT) -> None:
-        await self.state.set(value)
-
-    async def is_open(self) -> bool:
-        """
-        Checks to see if shutter is in open_state. Should not be used directly inside a
-        plan. A user should use the following instead in a plan:
-
-            from bluesky import plan_stubs as bps
-            is_open = yield from bps.rd(shutter.state) == shutter.open_state
-        """
-        return await self.state.get_value() == self.open_state
-
-    async def is_closed(self) -> bool:
-        """
-        Checks to see if shutter is in close_state. Should not be used directly inside a
-        plan. A user should use the following instead in a plan:
-
-            from bluesky import plan_stubs as bps
-            is_closed = yield from bps.rd(shutter.state) == shutter.close_state
-        """
-        return await self.state.get_value() == self.close_state
+
+class DualFastShutter(StandardReadable, FastShutter[EnumTypesT], Generic[EnumTypesT]):
+    """A fast shutter device that handles the positions of two other fast shutters. The
+    "active" shutter is the one that corrosponds to the selected_shutter signal. For
+    example, active shutter is shutter1 if selected_source is at SelectedSource.SOURCE1
+    and vise versa for shutter2 and SelectedSource.SOURCE2. Whenever a move is done on
+    this device, the inactive shutter is always set to the close_state.
+
+    Args:
+        shutter1 (GenericFastShutter): Active shutter that corrosponds to
+            SelectedSource.SOURCE1.
+        shutter2 (GenericFastShutter): Active shutter that corrosponds to
+            SelectedSource.SOURCE2.
+        selected_source (SignalRW): Signal that decides the active shutter.
+        name (str, optional): Name of this device.
+    """
+
+    def __init__(
+        self,
+        shutter1: GenericFastShutter[EnumTypesT],
+        shutter2: GenericFastShutter[EnumTypesT],
+        selected_source: SignalRW[SelectedSource],
+        name: str = "",
+    ):
+        self._validate_shutter_states(shutter1.open_state, shutter2.open_state)
+        self._validate_shutter_states(shutter1.close_state, shutter2.close_state)
+        self.open_state = shutter1.open_state
+        self.close_state = shutter1.close_state
+
+        self._shutter1_ref = Reference(shutter1)
+        self._shutter2_ref = Reference(shutter2)
+        self._selected_shutter_ref = Reference(selected_source)
+
+        with self.add_children_as_readables():
+            self.shutter_state = derived_signal_rw(
+                self._read_shutter_state,
+                self._set_shutter_state,
+                selected_shutter=selected_source,
+                shutter1=shutter1.shutter_state,
+                shutter2=shutter2.shutter_state,
+            )
+
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.shutter1_device_name, _ = soft_signal_r_and_setter(
+                str, initial_value=shutter1.name
+            )
+            self.shutter2_device_name, _ = soft_signal_r_and_setter(
+                str, initial_value=shutter2.name
+            )
+
+        self.add_readables([shutter1, shutter2, selected_source])
+
+        super().__init__(name)
+
+    def _validate_shutter_states(self, state1: EnumTypesT, state2: EnumTypesT) -> None:
+        if state1 is not state2:
+            raise ValueError(
+                f"{state1} is not same value as {state2}. They must be the same to be compatible."
+            )
+
+    def _read_shutter_state(
+        self,
+        selected_shutter: SelectedSource,
+        shutter1: EnumTypesT,
+        shutter2: EnumTypesT,
+    ) -> EnumTypesT:
+        return get_obj_from_selected_source(selected_shutter, shutter1, shutter2)
+
+    async def _set_shutter_state(self, value: EnumTypesT):
+        selected_shutter = await self._selected_shutter_ref().get_value()
+        active_shutter = get_obj_from_selected_source(
+            selected_shutter,
+            self._shutter1_ref(),
+            self._shutter2_ref(),
+        )
+        inactive_shutter = get_obj_from_selected_source(
+            selected_shutter,
+            self._shutter2_ref(),
+            self._shutter1_ref(),
+        )
+        await inactive_shutter.set(inactive_shutter.close_state)
+        await active_shutter.set(value)

dodal/devices/flux.py

@@ -6,7 +6,7 @@ from ophyd_async.epics.core import epics_signal_r
 
 
 class Flux(StandardReadable):
-    """Simple device to get the flux reading"""
+    """Simple device to get the flux reading."""
 
     def __init__(self, prefix: str, name="") -> None:
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):

dodal/devices/focusing_mirror.py

@@ -27,7 +27,7 @@ DEFAULT_SETTLE_TIME_S = 60
 
 
 class MirrorType(StrictEnum):
-    """See https://manual.nexusformat.org/classes/base_classes/NXmirror.html"""
+    """See https://manual.nexusformat.org/classes/base_classes/NXmirror.html."""
 
     SINGLE = "single"
     MULTI = "multi"
@@ -53,8 +53,9 @@ class MirrorVoltageDemand(StrictEnum):
 
 
 class SingleMirrorVoltage(Device):
-    """Abstract the bimorph mirror voltage PVs into a single device that can be set asynchronously and returns when
-    the demanded voltage setpoint is accepted, without blocking the caller as this process can take significant time.
+    """Abstract the bimorph mirror voltage PVs into a single device that can be set
+    asynchronously and returns when the demanded voltage setpoint is accepted, without
+    blocking the caller as this process can take significant time.
     """
 
     def __init__(self, prefix: str, name: str = ""):
@@ -66,11 +67,14 @@ class SingleMirrorVoltage(Device):
     @AsyncStatus.wrap
     async def set(self, value, *args, **kwargs):
         """Combine the following operations into a single set:
-        1. apply the value to the setpoint PV
-        3. Wait until demand is accepted
-        4. When either demand is accepted or DEFAULT_SETTLE_TIME expires, signal the result on the Status
-        """
 
+        1. apply the value to the setpoint PV.
+
+        3. Wait until demand is accepted.
+
+        4. When either demand is accepted or DEFAULT_SETTLE_TIME expires, signal the
+           result on the Status.
+        """  # noqa D415
         setpoint_v = self._setpoint_v
         demand_accepted = self._demand_accepted
 
@@ -136,7 +140,7 @@ class MirrorVoltages(StandardReadable):
 
 
 class SimpleMirror(XYPitchStage):
-    """Simple Focusing Mirror"""
+    """Simple Focusing Mirror."""
 
     def __init__(
         self,
@@ -165,7 +169,7 @@ class SimpleMirror(XYPitchStage):
 
 
 class FocusingMirror(StandardReadable):
-    """Focusing Mirror"""
+    """Focusing Mirror."""
 
     def __init__(
         self,
@@ -202,7 +206,8 @@ class FocusingMirror(StandardReadable):
 
 class FocusingMirrorWithStripes(FocusingMirror):
     """A focusing mirror where the stripe material can be changed. This is usually done
-    based on the energy of the beamline."""
+    based on the energy of the beamline.
+    """
 
     def __init__(self, prefix: str, name: str = "", *args, **kwargs):
         self.stripe = epics_signal_rw(MirrorStripe, prefix + "STRP:DVAL")
@@ -212,9 +217,22 @@ class FocusingMirrorWithStripes(FocusingMirror):
         super().__init__(prefix, name, *args, **kwargs)
 
     def energy_to_stripe(self, energy_kev) -> MirrorStripeConfiguration:
-        """Return the stripe, yaw angle and lateral position for the specified energy"""
+        """Return the stripe, yaw angle and lateral position for the specified energy."""
         # In future, this should be configurable per-mirror
         if energy_kev < 7:
             return {"stripe": MirrorStripe.BARE, "yaw_mrad": 6.2, "lat_mm": 0.0}
         else:
             return {"stripe": MirrorStripe.RHODIUM, "yaw_mrad": 0.0, "lat_mm": 10.0}
+
+
+class FocusingMirrorWithPiezo(FocusingMirror):
+    """A focusing mirror which also has a piezoelectric actuator.
+    A voltage can be applied to the piezo to steer the beam by making the material
+    shrink or expand.
+    """
+
+    def __init__(self, prefix: str, name: str = "", *args, **kwargs):
+        with self.add_children_as_readables():
+            self.piezo = epics_signal_rw(float, f"{prefix}AOFPITCH")
+            self.piezo_rbv = epics_signal_r(float, f"{prefix}AOFPITCH:RBV")
+        super().__init__(prefix, name, *args, **kwargs)

dodal/devices/hutch_shutter.py

@@ -58,14 +58,14 @@ class HutchInterlock(StandardReadable):
 class HutchShutter(StandardReadable, Movable[ShutterDemand]):
     """Device to operate the hutch shutter.
 
-    When a demand is sent, the device should first check the hutch status \
-    and raise an error if it's not interlocked (searched and locked), meaning it's not \
+    When a demand is sent, the device should first check the hutch status
+    and raise an error if it's not interlocked (searched and locked), meaning it's not
     safe to operate the shutter.
 
-    If the requested shutter position is "Open", the shutter control PV should first \
-    go to "Reset" and then move to "Open". This is because before opening the hutch \
-    shutter, the interlock status PV (`-PS-SHTR-01:ILKSTA`) will show as `failed` until \
-    the hutch shutter is reset. This will set the interlock status to `OK`, allowing \
+    If the requested shutter position is "Open", the shutter control PV should first
+    go to "Reset" and then move to "Open". This is because before opening the hutch
+    shutter, the interlock status PV (`-PS-SHTR-01:ILKSTA`) will show as `failed` until
+    the hutch shutter is reset. This will set the interlock status to `OK`, allowing
     for shutter operations. Until this step is done, the hutch shutter can't be opened.
     The reset is not needed for closing the shutter.
     """

dodal/devices/insertion_device/__init__.py

@@ -1,38 +1,48 @@
-from .apple2_undulator import (
-    DEFAULT_MOTOR_MIN_TIMEOUT,
+from .apple2_controller import (
     MAXIMUM_MOVE_TIME,
-    Apple2,
     Apple2Controller,
     Apple2EnforceLHMoveController,
+    Apple2Type,
+    EnergyMotorConvertor,
+)
+from .apple2_undulator import (
+    DEFAULT_MOTOR_MIN_TIMEOUT,
+    Apple2,
     Apple2LockedPhasesVal,
     Apple2PhasesVal,
     Apple2Val,
-    BeamEnergy,
     EnabledDisabledUpper,
-    EnergyMotorConvertor,
-    InsertionDeviceEnergy,
-    InsertionDevicePolarisation,
     UndulatorGap,
     UndulatorJawPhase,
     UndulatorLockedPhaseAxes,
     UndulatorPhaseAxes,
+    UnstoppableMotor,
+)
+from .apple_knot_controller import (
+    AppleKnotController,
+    AppleKnotPathFinder,
 )
+from .energy import BeamEnergy, InsertionDeviceEnergy, InsertionDeviceEnergyBase
 from .energy_motor_lookup import (
     ConfigServerEnergyMotorLookup,
     EnergyMotorLookup,
 )
-from .id_enum import Pol, UndulatorGateStatus
+from .enum import Pol, UndulatorGateStatus
 from .lookup_table_models import (
     EnergyCoverage,
     LookupTable,
     LookupTableColumnConfig,
     convert_csv_to_lookup,
 )
+from .polarisation import InsertionDevicePolarisation
 
 __all__ = [
     "Apple2",
+    "Apple2Type",
     "Apple2Controller",
     "Apple2EnforceLHMoveController",
+    "AppleKnotController",
+    "AppleKnotPathFinder",
     "UndulatorGap",
     "UndulatorPhaseAxes",
     "UndulatorJawPhase",
@@ -55,4 +65,6 @@ __all__ = [
     "EnergyMotorLookup",
     "ConfigServerEnergyMotorLookup",
     "EnergyMotorConvertor",
+    "UnstoppableMotor",
+    "InsertionDeviceEnergyBase",
 ]