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

dodal/beamlines/i20_1.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 
 from ophyd_async.epics.motor import Motor
+from ophyd_async.epics.pmac import PmacIO
 from ophyd_async.fastcs.panda import HDFPanda
 
 from dodal.common.beamlines.beamline_utils import (
@@ -58,6 +59,19 @@ def turbo_slit_x() -> Motor:
     return Motor(f"{PREFIX.beamline_prefix}-OP-PCHRO-01:TS:XFINE")
 
 
+@device_factory()
+def turbo_slit_pmac() -> PmacIO:
+    """
+    PMac controller using running fly scans with trajectory
+    """
+    motor = turbo_slit_x()
+    return PmacIO(
+        prefix=f"{PREFIX.beamline_prefix}-MO-STEP-06:",
+        raw_motors=[motor],
+        coord_nums=[3],
+    )
+
+
 @device_factory()
 def panda() -> HDFPanda:
     return HDFPanda(

dodal/beamlines/i21.py

@@ -24,6 +24,9 @@ from dodal.devices.insertion_device.energy_motor_lookup import (
 from dodal.devices.insertion_device.lookup_table_models import LookupTableColumnConfig
 from dodal.devices.pgm import PlaneGratingMonochromator
 from dodal.devices.synchrotron import Synchrotron
+from dodal.devices.temperture_controller import (
+    Lakeshore336,
+)
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
 
@@ -71,18 +74,18 @@ def id_phase() -> UndulatorPhaseAxes:
 
 
 @device_factory()
-def id() -> Apple2:
+def id() -> Apple2[UndulatorPhaseAxes]:
     """I21 insertion device."""
-    return Apple2(
+    return Apple2[UndulatorPhaseAxes](
         id_gap=id_gap(),
         id_phase=id_phase(),
     )
 
 
 @device_factory()
-def id_controller() -> Apple2EnforceLHMoveController:
+def id_controller() -> Apple2EnforceLHMoveController[UndulatorPhaseAxes]:
     """i21 insertion device controller."""
-    return Apple2EnforceLHMoveController(
+    return Apple2EnforceLHMoveController[UndulatorPhaseAxes](
         apple2=id(),
         gap_energy_motor_lut=ConfigServerEnergyMotorLookup(
             lut_config=LookupTableColumnConfig(grating=I21_GRATING_COLUMNS),
@@ -114,3 +117,8 @@ def id_polarisation() -> InsertionDevicePolarisation:
 def energy_jid() -> BeamEnergy:
     """Beam energy."""
     return BeamEnergy(id_energy=id_energy(), mono=pgm().energy)
+
+
+@device_factory()
+def sample_temperature_controller() -> Lakeshore336:
+    return Lakeshore336(prefix=f"{PREFIX.beamline_prefix}-EA-TCTRL-01:")

dodal/beamlines/i23.py

@@ -1,16 +1,13 @@
+from functools import cache
 from pathlib import Path
 
-from ophyd_async.core import InOut, StrictEnum
+from ophyd_async.core import InOut, PathProvider, StrictEnum
 from ophyd_async.epics.adpilatus import PilatusDetector
 
-from dodal.common.beamlines.beamline_utils import (
-    device_factory,
-    get_path_provider,
-    set_path_provider,
-)
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
 from dodal.common.beamlines.device_helpers import HDF5_SUFFIX
 from dodal.common.visit import LocalDirectoryServiceClient, StaticVisitPathProvider
+from dodal.device_manager import DeviceManager
 from dodal.devices.motors import SixAxisGonio
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
 from dodal.devices.positioner import Positioner1D
@@ -25,18 +22,22 @@ from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name, get_hostname
 
 BL = get_beamline_name("i23")
+PREFIX = BeamlinePrefix(BL)
 set_log_beamline(BL)
 set_utils_beamline(BL)
 
-set_path_provider(
-    StaticVisitPathProvider(
+devices = DeviceManager()
+
+
+@devices.fixture
+@cache
+def path_provider() -> PathProvider:
+    return StaticVisitPathProvider(
         BL,
         Path("/tmp"),
         client=LocalDirectoryServiceClient(),
     )
-)
 
-PREFIX = BeamlinePrefix(BL)
 
 I23_ZEBRA_MAPPING = ZebraMapping(
     outputs=ZebraTTLOutputs(TTL_DETECTOR=1, TTL_SHUTTER=4),
@@ -59,51 +60,44 @@ def _is_i23_machine():
     return hostname.startswith("i23-ws") or hostname.startswith("i23-control")
 
 
-@device_factory(skip=lambda: not _is_i23_machine())
+@devices.factory(skip=lambda: not _is_i23_machine())
 def oav_pin_tip_detection() -> PinTipDetection:
-    """Get the i23 OAV pin-tip detection device."""
-
     return PinTipDetection(
         f"{PREFIX.beamline_prefix}-DI-OAV-01:",
         "pin_tip_detection",
     )
 
 
-@device_factory()
+@devices.factory()
 def shutter() -> ZebraShutter:
-    """Get the i23 zebra controlled shutter."""
     return ZebraShutter(f"{PREFIX.beamline_prefix}-EA-SHTR-01:")
 
 
-@device_factory()
+@devices.factory()
 def gonio() -> SixAxisGonio:
-    """Get the i23 goniometer"""
     return SixAxisGonio(f"{PREFIX.beamline_prefix}-MO-GONIO-01:")
 
 
-@device_factory()
+@devices.factory()
 def zebra() -> Zebra:
-    """Get the i23 zebra"""
     return Zebra(
         prefix=f"{PREFIX.beamline_prefix}-EA-ZEBRA-01:ZEBRA:",
         mapping=I23_ZEBRA_MAPPING,
     )
 
 
-@device_factory()
-def pilatus() -> PilatusDetector:
-    """Get the i23 pilatus"""
+@devices.factory()
+def pilatus(path_provider: PathProvider) -> PilatusDetector:
     return PilatusDetector(
         prefix=f"{PREFIX.beamline_prefix}-EA-PILAT-01:",
-        path_provider=get_path_provider(),
+        path_provider=path_provider,
         drv_suffix="cam1:",
         fileio_suffix=HDF5_SUFFIX,
     )
 
 
-@device_factory()
+@devices.factory()
 def detector_motion() -> Positioner1D[I23DetectorPositions]:
-    """Get the i23 detector"""
     return Positioner1D[I23DetectorPositions](
         f"{PREFIX.beamline_prefix}-EA-DET-01:Z",
         datatype=I23DetectorPositions,

dodal/beamlines/i24.py

@@ -1,12 +1,12 @@
-from pathlib import PurePath
+from functools import cache
+from pathlib import Path
 
-from ophyd_async.core import AutoIncrementingPathProvider, StaticFilenameProvider
+from ophyd_async.core import AutoMaxIncrementingPathProvider, PathProvider
 
-from dodal.common.beamlines.beamline_utils import (
-    BL,
-    device_factory,
-)
+from dodal.common.beamlines.beamline_utils import BL
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.common.visit import LocalDirectoryServiceClient, StaticVisitPathProvider
+from dodal.device_manager import DeviceManager
 from dodal.devices.attenuator.attenuator import EnumFilterAttenuator
 from dodal.devices.attenuator.filter_selections import (
     I24FilterOneSelections,
@@ -25,12 +25,14 @@ from dodal.devices.i24.vgonio import VerticalGoniometer
 from dodal.devices.motors import YZStage
 from dodal.devices.oav.oav_detector import OAVBeamCentreFile
 from dodal.devices.oav.oav_parameters import OAVConfigBeamCentre
+from dodal.devices.synchrotron import Synchrotron
 from dodal.devices.zebra.zebra import Zebra
 from dodal.devices.zebra.zebra_constants_mapping import (
     ZebraMapping,
     ZebraSources,
     ZebraTTLOutputs,
 )
+from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
 
@@ -45,111 +47,67 @@ set_log_beamline(BL)
 set_utils_beamline(BL)
 
 I24_ZEBRA_MAPPING = ZebraMapping(
-    outputs=ZebraTTLOutputs(TTL_EIGER=1, TTL_PILATUS=2, TTL_FAST_SHUTTER=4),
+    outputs=ZebraTTLOutputs(TTL_EIGER=1, TTL_JUNGFRAU=2, TTL_FAST_SHUTTER=4),
     sources=ZebraSources(),
 )
 
 PREFIX = BeamlinePrefix(BL)
 
+devices = DeviceManager()
+
+
+@devices.fixture
+@cache
+def path_provider() -> PathProvider:
+    return StaticVisitPathProvider(
+        BL,
+        Path("/tmp"),
+        client=LocalDirectoryServiceClient(),
+    )
+
 
-@device_factory()
+@devices.factory()
 def attenuator() -> EnumFilterAttenuator:
-    """Get a read-only attenuator device for i24, instantiate it if it hasn't already
-    been. If this is called when already instantiated in i24, it will return the
-    existing object."""
     return EnumFilterAttenuator(
         f"{PREFIX.beamline_prefix}-OP-ATTN-01:",
         filter_selection=(I24FilterOneSelections, I24FilterTwoSelections),
     )
 
 
-@device_factory()
+@devices.factory()
 def aperture() -> Aperture:
-    """Get the i24 aperture device, instantiate it if it hasn't already been.
-    If this is called when already instantiated in i24, it will return the existing object.
-    """
-    return Aperture(
-        f"{PREFIX.beamline_prefix}-AL-APTR-01:",
-    )
+    return Aperture(f"{PREFIX.beamline_prefix}-AL-APTR-01:")
 
 
-@device_factory()
+@devices.factory()
 def beamstop() -> Beamstop:
-    """Get the i24 beamstop device, instantiate it if it hasn't already been.
-    If this is called when already instantiated in i24, it will return the existing object.
-    """
-    return Beamstop(
-        f"{PREFIX.beamline_prefix}-MO-BS-01:",
-    )
+    return Beamstop(f"{PREFIX.beamline_prefix}-MO-BS-01:")
 
 
-@device_factory()
+@devices.factory()
 def backlight() -> DualBacklight:
-    """Get the i24 backlight device, instantiate it if it hasn't already been.
-    If this is called when already instantiated in i24, it will return the existing object.
-    """
-    return DualBacklight(
-        prefix=PREFIX.beamline_prefix,
-    )
+    return DualBacklight(prefix=PREFIX.beamline_prefix)
 
 
-@device_factory()
+@devices.factory()
 def detector_motion() -> YZStage:
-    """Get the i24 detector motion device, instantiate it if it hasn't already been.
-    If this is called when already instantiated in i24, it will return the existing object.
-    """
-    return YZStage(
-        prefix=f"{PREFIX.beamline_prefix}-EA-DET-01:",
-    )
+    return YZStage(prefix=f"{PREFIX.beamline_prefix}-EA-DET-01:")
 
 
-@device_factory()
+@devices.factory()
 def dcm() -> DCM:
-    """Get the i24 DCM device, instantiate it if it hasn't already been.
-    If this is called when already instantiated in i24, it will return the existing object.
-    """
     return DCM(
         prefix=f"{PREFIX.beamline_prefix}-DI-DCM-01:",
         motion_prefix=f"{PREFIX.beamline_prefix}-MO-DCM-01:",
     )
 
 
-# TODO implement ophyd-async eiger see
-# https://github.com/DiamondLightSource/mx-bluesky/issues/62
-# @skip_device(lambda: BL == "s24")
-# def eiger(
-#     wait_for_connection: bool = True,
-#     fake_with_ophyd_sim: bool = False,
-#     params: DetectorParams | None = None,
-# ) -> EigerDetector:
-#     """Get the i24 Eiger device, instantiate it if it hasn't already been.
-#     If this is called when already instantiated, it will return the existing object.
-#     If called with params, will update those params to the Eiger object.
-#     """
-#
-#     def set_params(eiger: EigerDetector):
-#         if params is not None:
-#             eiger.set_detector_parameters(params)
-#
-#     return device_instantiation(
-#         device_factory=EigerDetector,
-#         name="eiger",
-#         prefix="-EA-EIGER-01:",
-#         wait=wait_for_connection,
-#         fake=fake_with_ophyd_sim,
-#         post_create=set_params,
-#     )
-
-
-@device_factory()
+@devices.factory()
 def pmac() -> PMAC:
-    """Get the i24 PMAC device, instantiate it if it hasn't already been.
-    If this is called when already instantiated in i24, it will return the existing object.
-    """
     return PMAC(PREFIX.beamline_prefix)
 
 
-@device_factory()
+@devices.factory()
 def oav() -> OAVBeamCentreFile:
     return OAVBeamCentreFile(
         prefix=f"{PREFIX.beamline_prefix}-DI-OAV-01:",
@@ -157,62 +115,54 @@ def oav() -> OAVBeamCentreFile:
     )
 
 
-@device_factory()
+@devices.factory()
 def vgonio() -> VerticalGoniometer:
-    """Get the i24 vertical goniometer device, instantiate it if it hasn't already been.
-    If this is called when already instantiated, it will return the existing object.
-    """
     return VerticalGoniometer(f"{PREFIX.beamline_prefix}-MO-VGON-01:")
 
 
-@device_factory()
+@devices.factory()
 def zebra() -> Zebra:
-    """Get the i24 zebra device, instantiate it if it hasn't already been.
-    If this is called when already instantiated in i24, it will return the existing object.
-    """
     return Zebra(
         prefix=f"{PREFIX.beamline_prefix}-EA-ZEBRA-01:",
         mapping=I24_ZEBRA_MAPPING,
     )
 
 
-@device_factory()
+@devices.factory()
 def shutter() -> HutchShutter:
-    """Get the i24 hutch shutter device, instantiate it if it hasn't already been.
-    If this is called when already instantiated, it will return the existing object.
-    """
     return HutchShutter(f"{PREFIX.beamline_prefix}-PS-SHTR-01:")
 
 
-@device_factory()
+@devices.factory()
 def focus_mirrors() -> FocusMirrorsMode:
-    """Get the i24 focus mirror devise to find the beam size."""
     return FocusMirrorsMode(f"{PREFIX.beamline_prefix}-OP-MFM-01:")
 
 
-@device_factory()
+@devices.factory()
 def eiger_beam_center() -> DetectorBeamCenter:
-    """A device for setting/reading the beamcenter from the eiger on i24."""
-    return DetectorBeamCenter(
-        f"{PREFIX.beamline_prefix}-EA-EIGER-01:CAM:",
-        "eiger_bc",
-    )
+    return DetectorBeamCenter(f"{PREFIX.beamline_prefix}-EA-EIGER-01:CAM:", "eiger_bc")
 
 
-@device_factory()
+@devices.factory()
 def commissioning_jungfrau(
-    path_to_dir: str = "/tmp/jf",  # Device factory doesn't allow for required args,
-    filename: str = "jf_output",  # but these should be manually entered when commissioning
+    path_provider: PathProvider,
 ) -> CommissioningJungfrau:
     """Get the commissionning Jungfrau 9M device, which uses a temporary filewriter
-    device in place of Odin while the detector is in commissioning.
-    Instantiates the device if it hasn't already been.
-    If this is called when already instantiated, it will return the existing object."""
-
+    device in place of Odin while the detector is in commissioning."""
     return CommissioningJungfrau(
         f"{PREFIX.beamline_prefix}-EA-JFRAU-01:",
         f"{PREFIX.beamline_prefix}-JUNGFRAU-META:FD:",
-        AutoIncrementingPathProvider(
-            StaticFilenameProvider(filename), PurePath(path_to_dir)
-        ),
+        AutoMaxIncrementingPathProvider(path_provider),
+    )
+
+
+@devices.factory()
+def synchrotron() -> Synchrotron:
+    return Synchrotron()
+
+
+@devices.factory()
+def sample_shutter() -> ZebraShutter:
+    return ZebraShutter(
+        f"{PREFIX.beamline_prefix}-EA-SHTR-01:",
     )

dodal/beamlines/p60.py

@@ -11,6 +11,7 @@ from dodal.devices.p60 import (
     PassEnergy,
     PsuMode,
 )
+from dodal.devices.selectable_source import SourceSelector
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
 
@@ -20,6 +21,11 @@ set_log_beamline(BL)
 set_utils_beamline(BL)
 
 
+@device_factory()
+def source_selector() -> SourceSelector:
+    return SourceSelector()
+
+
 @device_factory()
 def al_kalpha_source() -> LabXraySourceReadable:
     return LabXraySourceReadable(LabXraySource.AL_KALPHA)
@@ -32,7 +38,11 @@ def mg_kalpha_source() -> LabXraySourceReadable:
 
 @device_factory()
 def energy_source() -> DualEnergySource:
-    return DualEnergySource(al_kalpha_source().energy_ev, mg_kalpha_source().energy_ev)
+    return DualEnergySource(
+        al_kalpha_source().energy_ev,
+        mg_kalpha_source().energy_ev,
+        source_selector().selected_source,
+    )
 
 
 # Connect will work again after this work completed

dodal/common/__init__.py

@@ -1,6 +1,6 @@
 from .coordination import group_uuid, inject
 from .enums import EnabledDisabledUpper, InOutUpper, OnOffUpper
-from .maths import in_micros, step_to_num
+from .maths import Rectangle2D, in_micros, step_to_num
 from .types import MsgGenerator, PlanGenerator
 
 __all__ = [
@@ -13,4 +13,5 @@ __all__ = [
     "MsgGenerator",
     "PlanGenerator",
     "step_to_num",
+    "Rectangle2D",
 ]

dodal/common/maths.py

@@ -48,3 +48,83 @@ def in_micros(t: float) -> int:
     if t < 0:
         raise ValueError(f"Expected a positive time in seconds, got {t!r}")
     return int(np.ceil(t * 1e6))
+
+
+class Rectangle2D:
+    """
+    A 2D rectangle defined by two opposite corners.
+
+    This class represents a rectangle in 2D space using two points: (x1, y1) and (x2, y2).
+    It provides methods to query rectangle properties and check point containment.
+
+    Attributes:
+        x1 (float): The x-coordinate of the first corner.
+        y1 (float): The y-coordinate of the first corner.
+        x2 (float): The x-coordinate of the second corner.
+        y2 (float): The y-coordinate of the second corner.
+    """
+
+    def __init__(self, x1: float, y1: float, x2: float, y2: float):
+        """
+        Initialize a Rectangle2D with two corner points.
+
+        Args:
+            x1 (float): The x-coordinate of the first corner.
+            y1 (float): The y-coordinate of the first corner.
+            x2 (float): The x-coordinate of the second corner.
+            y2 (float): The y-coordinate of the second corner.
+        """
+        self.x1, self.y1 = x1, y1
+        self.x2, self.y2 = x2, y2
+
+    def get_max_x(self) -> float:
+        """
+        Get the maximum x-coordinate of the rectangle.
+
+        Returns:
+            float: The larger of the two x-coordinates (x1, x2).
+        """
+        return max(self.x1, self.x2)
+
+    def get_min_x(self) -> float:
+        """
+        Get the minimum x-coordinate of the rectangle.
+
+        Returns:
+            float: The smaller of the two x-coordinates (x1, x2).
+        """
+        return min(self.x1, self.x2)
+
+    def get_max_y(self) -> float:
+        """
+        Get the maximum y-coordinate of the rectangle.
+
+        Returns:
+            float: The larger of the two y-coordinates (y1, y2).
+        """
+        return max(self.y1, self.y2)
+
+    def get_min_y(self) -> float:
+        """
+        Get the minimum y-coordinate of the rectangle.
+
+        Returns:
+            float: The smaller of the two y-coordinates (y1, y2).
+        """
+        return min(self.y1, self.y2)
+
+    def contains(self, x: float, y: float) -> bool:
+        """
+        Check if a point is contained within the rectangle.
+
+        Args:
+            x (float): The x-coordinate of the point.
+            y (float): The y-coordinate of the point.
+
+        Returns:
+            bool: True if the point is within the rectangle bounds, False otherwise.
+        """
+        return (
+            self.get_min_x() <= x <= self.get_max_x()
+            and self.get_min_y() <= y <= self.get_max_y()
+        )

dodal/devices/eiger.py

@@ -4,6 +4,7 @@ from enum import Enum
 from bluesky.protocols import Stageable
 from ophyd import Component, Device, EpicsSignalRO, Signal
 from ophyd.areadetector.cam import EigerDetectorCam
+from ophyd.signal import AttributeSignal
 from ophyd.status import AndStatus, Status, StatusBase, SubscriptionStatus
 
 from dodal.devices.detector import DetectorParams, TriggerMode
@@ -55,7 +56,6 @@ class EigerDetector(Device, Stageable):
 
     stale_params = Component(EpicsSignalRO, "CAM:StaleParameters_RBV")
     bit_depth = Component(EpicsSignalRO, "CAM:BitDepthImage_RBV")
-
     filewriters_finished: StatusBase
 
     detector_params: DetectorParams | None = None
@@ -63,9 +63,24 @@ class EigerDetector(Device, Stageable):
     arming_status = Status()
     arming_status.set_finished()
 
-    def __init__(self, beamline: str = "i03", *args, **kwargs):
+    def __init__(
+        self,
+        beamline: str = "i03",
+        ispyb_detector_id: int | None = None,
+        *args,
+        **kwargs,
+    ):
         super().__init__(*args, **kwargs)
         self.beamline = beamline
+
+        self.detector_id = ispyb_detector_id
+        self.ispyb_detector_id = AttributeSignal(
+            attr="detector_id",
+            parent=self,
+            name="eiger-ispyb_detector_id",
+            write_access=False,
+        )
+
         # using i03 timeouts as default
         self.timeouts = AVAILABLE_TIMEOUTS.get(beamline, AVAILABLE_TIMEOUTS["i03"])
         self.disarming_status = None
@@ -74,10 +89,11 @@ class EigerDetector(Device, Stageable):
     def with_params(
         cls,
         params: DetectorParams,
-        name: str = "EigerDetector",
         beamline: str = "i03",
+        ispyb_detector_id: int | None = None,
+        name: str = "EigerDetector",
     ):
-        det = cls(name=name, beamline=beamline)
+        det = cls(name=name, beamline=beamline, ispyb_detector_id=ispyb_detector_id)
         det.set_detector_parameters(params)
         return det
 
@@ -286,25 +302,24 @@ class EigerDetector(Device, Stageable):
         beam_x_pixels, beam_y_pixels = self.detector_params.get_beam_position_pixels(
             self.detector_params.detector_distance
         )
-        status = self.cam.beam_center_x.set(
+        self.cam.beam_center_x.set(
             beam_x_pixels, timeout=self.timeouts.general_status_timeout
-        )
-        status &= self.cam.beam_center_y.set(
+        ).wait(timeout=self.timeouts.general_status_timeout)
+        self.cam.beam_center_y.set(
             beam_y_pixels, timeout=self.timeouts.general_status_timeout
-        )
-        status &= self.cam.det_distance.set(
+        ).wait(timeout=self.timeouts.general_status_timeout)
+        self.cam.det_distance.set(
             self.detector_params.detector_distance,
             timeout=self.timeouts.general_status_timeout,
-        )
-        status &= self.cam.omega_start.set(
+        ).wait(timeout=self.timeouts.general_status_timeout)
+        self.cam.omega_start.set(
             self.detector_params.omega_start,
             timeout=self.timeouts.general_status_timeout,
-        )
-        status &= self.cam.omega_incr.set(
+        ).wait(timeout=self.timeouts.general_status_timeout)
+        status = self.cam.omega_incr.set(
             self.detector_params.omega_increment,
             timeout=self.timeouts.general_status_timeout,
         )
-
         return status
 
     def set_detector_threshold(self, energy: float, tolerance: float = 0.1) -> Status:

dodal/devices/electron_analyser/base/__init__.py

@@ -15,7 +15,7 @@ from .base_driver_io import (
     GenericAnalyserDriverIO,
     TAbstractAnalyserDriverIO,
 )
-from .base_enums import EnergyMode, SelectedSource
+from .base_enums import EnergyMode
 from .base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
@@ -27,7 +27,7 @@ from .base_region import (
     TLensMode,
 )
 from .base_util import to_binding_energy, to_kinetic_energy
-from .energy_sources import DualEnergySource, EnergySource
+from .energy_sources import AbstractEnergySource, DualEnergySource, EnergySource
 
 __all__ = [
     "ElectronAnalyserController",
@@ -42,7 +42,6 @@ __all__ = [
     "GenericAnalyserDriverIO",
     "TAbstractAnalyserDriverIO",
     "EnergyMode",
-    "SelectedSource",
     "AbstractBaseRegion",
     "AbstractBaseSequence",
     "GenericRegion",
@@ -53,6 +52,7 @@ __all__ = [
     "TLensMode",
     "to_binding_energy",
     "to_kinetic_energy",
+    "AbstractEnergySource",
     "DualEnergySource",
     "EnergySource",
 ]