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

dodal/devices/bimorph_mirror.py

@@ -43,10 +43,19 @@ class BimorphMirrorChannel(StandardReadable, EpicsDevice):
     """Collection of PVs comprising a single bimorph channel.
 
     Attributes:
-        target_voltage: Float RW_RBV for target voltage, which can be set using parent mirror's all target proc
-        output_voltage: Float RW_RBV for current voltage on bimorph
-        status: BimorphMirrorOnOff readable for ON/OFF status of channel
-        shift: Float writeable shifting channel voltage
+        target_voltage (SignalRW): Float RW_RBV for target voltage, which can be set
+            using parent mirror's all target proc.
+        output_voltage (SignalRW): Float RW_RBV for current voltage on bimorph.
+        status (SignalR): BimorphMirrorOnOff readable for ON/OFF status of channel.
+        shift (SignalW): Float writeable shifting channel voltage.
+
+    Args:
+        prefix (str): PV prefix.
+        number_of_channels (int): Number of channels on bimorph mirror (can be zero).
+        name (str, optional): Name of device.
+
+    Raises:
+        ValueError: number_of_channels is less than zero.
     """
 
     target_voltage: A[SignalRW[float], PvSuffix.rbv("VTRGT"), Format.CONFIG_SIGNAL]
@@ -59,21 +68,14 @@ 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
-        status: Readable BimorphMirrorStatus Busy/Idle status
-        err: Alarm status"""
+        channels (DeviceVector): DeviceVector of BimorphMirrorChannel, indexed from 1,
+            for each channel.
+        enabled (SignalW): Writeable BimorphOnOff.
+        status (SignalR): Readable BimorphMirrorStatus Busy/Idle status.
+        err (SignalR): Alarm status.
+    """
 
     def __init__(self, prefix: str, number_of_channels: int, name=""):
-        """
-        Args:
-            prefix: str PV prefix
-            number_of_channels: int number of channels on bimorph mirror (can be zero)
-            name: str name of device
-
-        Raises:
-            ValueError: number_of_channels is less than zero"""
-
         if number_of_channels < 0:
             raise ValueError(f"Number of channels is below zero: {number_of_channels}")
 
@@ -95,11 +97,11 @@ class BimorphMirror(StandardReadable, Movable[list[float]]):
         """Sets bimorph voltages in parallel via target voltage and all proc.
 
         Args:
-            value: List of float target voltages
+            value (list[float]): List of float target voltages.
 
         Raises:
-            ValueError: On set to non-existent channel"""
-
+            ValueError: On set to non-existent channel.
+        """
         if len(value) != len(self.channels):
             raise ValueError(
                 f"Length of value input array does not match number of \

dodal/devices/collimation_table.py

@@ -13,8 +13,9 @@ class CollimationTable(StandardReadable):
     There are 2 physical horizontal motors 1 upstream, 1 downstream. These provide yaw.
 
     Table motion is disabled by an object being within the laser curtain area and can be
-    overridden by use of the dead man's handle device or locking the hutch. The effect of
-    these disabling systems is to cut power to the motors - signal for this is crate_power
+    overridden by use of the dead man's handle device or locking the hutch. The effect
+    of these disabling systems is to cut power to the motors - signal for this is
+    `crate_power`.
     """
 
     def __init__(self, prefix: str, name: str = ""):

dodal/devices/common_dcm.py

@@ -33,19 +33,23 @@ Xtal_2 = TypeVar("Xtal_2", bound=StationaryCrystal)
 
 
 class DoubleCrystalMonochromatorBase(StandardReadable, Generic[Xtal_1, Xtal_2]):
-    """
-    Base device for the double crystal monochromator (DCM), used to select the energy of the beam.
+    """Base device for the double crystal monochromator (DCM), used to select the energy
+    of the beam.
 
-    Features common across all DCM's should include virtual motors to set energy/wavelength and contain two crystals,
-    each of which can be movable. Some DCM's contain crystals with roll motors, and some contain crystals with roll and pitch motors.
-    This base device accounts for all combinations of this.
+    Features common across all DCM's should include virtual motors to set
+    energy/wavelength and contain two crystals, each of which can be movable. Some DCM's
+    contain crystals with roll motors, and some contain crystals with roll and pitch
+    motors. This base device accounts for all combinations of this.
+
+    This device should act as a parent for beamline-specific DCM's which do not match
+    the standard EPICS interface, it provides only energy and the crystal configuration.
+    Most beamlines should use DoubleCrystalMonochromator instead.
 
-    This device should act as a parent for beamline-specific DCM's which do not match the standard EPICS interface, it provides
-    only energy and the crystal configuration.  Most beamlines should use DoubleCrystalMonochromator instead
+    Bluesky plans using DCM's should be typed to specify which types of crystals are
+    required. For example, a plan which only requires one crystal which can roll should
+    be typed::
 
-    Bluesky plans using DCM's should be typed to specify which types of crystals are required. For example, a plan
-    which only requires one crystal which can roll should be typed
-    'def my_plan(dcm: DoubleCrystalMonochromatorBase[RollCrystal, StationaryCrystal])`
+        def my_plan(dcm: DoubleCrystalMonochromatorBase[RollCrystal,StationaryCrystal])
     """
 
     def __init__(
@@ -78,17 +82,23 @@ class DoubleCrystalMonochromatorBase(StandardReadable, Generic[Xtal_1, Xtal_2]):
 class DoubleCrystalMonochromator(
     DoubleCrystalMonochromatorBase, Generic[Xtal_1, Xtal_2]
 ):
-    """
-    Common device for the double crystal monochromator (DCM), used to select the energy of the beam.
+    """Common device for the double crystal monochromator (DCM), used to select the
+    energy of the beam.
 
-    Features common across all DCM's should include virtual motors to set energy/wavelength and contain two crystals,
-    each of which can be movable. Some DCM's contain crystals with roll motors, and some contain crystals with roll and pitch motors.
+    Features common across all DCM's should include virtual motors to set
+    energy/wavelength and contain two crystals, each of which can be movable. Some DCM's
+    contain crystals with roll motors, and some contain crystals with roll and pitch
+    motors.
     This base device accounts for all combinations of this.
 
-    This device should act as a parent for beamline-specific DCM's, in which any other missing signals can be added.
+    This device should act as a parent for beamline-specific DCM's, in which any other
+    missing signals can be added.
+
+    Bluesky plans using DCM's should be typed to specify which types of crystals are
+    required. For example, a plan which only requires one crystal which can roll should
+    be typed::
 
-    Bluesky plans using DCM's should be typed to specify which types of crystals are required. For example, a plan which only
-    requires one crystal which can roll should be typed 'def my_plan(dcm: DoubleCrystalMonochromator[RollCrystal, StationaryCrystal])`
+        def my_plan(dcm: DoubleCrystalMonochromator[RollCrystal, StationaryCrystal])
     """
 
     def __init__(
@@ -109,9 +119,9 @@ class DoubleCrystalMonochromator(
 class DoubleCrystalMonochromatorWithDSpacing(
     DoubleCrystalMonochromator, Generic[Xtal_1, Xtal_2]
 ):
-    """
-    Adds crystal D-spacing metadata to the DoubleCrystalMonochromator class.  This should be used in preference to the
-    DoubleCrystalMonochromator on beamlines which have a "DSPACING:RBV" pv on their DCM.
+    """Adds crystal D-spacing metadata to the DoubleCrystalMonochromator class.  This
+    should be used in preference to the DoubleCrystalMonochromator on beamlines which
+    have a "DSPACING:RBV" pv on their DCM.
     """
 
     def __init__(

dodal/devices/controllers.py

@@ -6,8 +6,8 @@ ADBaseIOT = TypeVar("ADBaseIOT", bound=ADBaseIO)
 
 
 class ConstantDeadTimeController(ADBaseController[ADBaseIOT]):
-    """
-    ADBaseController with a configured constant deadtime for a driver of type ADBaseIO.
+    """ADBaseController with a configured constant deadtime for a driver of type
+    ADBaseIO.
     """
 
     def __init__(

dodal/devices/cryostream.py

@@ -87,6 +87,14 @@ class OxfordCryoJet(StandardReadable):
 
 
 class CryoStreamGantry(StandardReadable):
+    """Gantry controlling whether the standard Cryostream or the
+    HC1 cryostream is in position.
+
+    Note: this device is currently implemented read-only; moving the gantry without
+    adequate checks risks a collision if the gantry is moved while HC1 is selected
+    and in the IN position.
+    """
+
     def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.cryostream_selector = epics_signal_r(

dodal/devices/current_amplifiers/current_amplifier.py

@@ -9,14 +9,13 @@ from ophyd_async.core import AsyncStatus, StandardReadable
 
 
 class CurrentAmp(ABC, StandardReadable, Movable):
-    """
-    Base class for current amplifier, it contains the minimal functionality
-     a current amplifier needs:
+    """Base class for current amplifier, it contains the minimal functionality
+    a current amplifier needs:
 
     Attributes:
         gain_conversion_table (Enum): The conversion table between current
-        and gain setting.
-    """
+            and gain setting.
+    """  # noqa D415
 
     def __init__(self, gain_conversion_table: type[Enum], name: str = "") -> None:
         self.gain_conversion_table = gain_conversion_table
@@ -40,7 +39,7 @@ class CurrentAmp(ABC, StandardReadable, Movable):
 
     @abstractmethod
     async def get_gain(self) -> Enum:
-        """Get the current gain setting
+        """Get the current gain setting.
 
         Returns:
             Enum: The member name of the current gain setting in gain_conversion_table.
@@ -48,17 +47,16 @@ class CurrentAmp(ABC, StandardReadable, Movable):
 
     @abstractmethod
     async def get_upperlimit(self) -> float:
-        """Get the upper limit of the current amplifier"""
+        """Get the upper limit of the current amplifier."""
 
     @abstractmethod
     async def get_lowerlimit(self) -> float:
-        """Get the lower limit of the current amplifier"""
+        """Get the lower limit of the current amplifier."""
 
 
 class CurrentAmpCounter(ABC, StandardReadable, Preparable):
-    """
-    Base class for current amplifier counter, it contain the minimal implementations
-      required for a counter/detector to function with CurrentAmpDet:
+    """Base class for current amplifier counter, it contain the minimal implementations
+        required for a counter/detector to function with CurrentAmpDet.
 
     Attributes:
         count_per_volt (float): The conversion factor between counter output and voltage.
@@ -70,29 +68,29 @@ class CurrentAmpCounter(ABC, StandardReadable, Preparable):
 
     @abstractmethod
     async def get_count(self) -> float:
-        """ "Get count
+        """Get count.
 
         Returns:
-            float: Current count
+            float: Current count.
         """
 
     @abstractmethod
     async def get_count_per_sec(self) -> float:
-        """Get count per second
+        """Get count per second.
 
         Returns:
-            float: Current count per second
+            float: Current count per second.
         """
 
     @abstractmethod
     async def get_voltage_per_sec(self) -> float:
-        """Get count per second in voltage
+        """Get count per second in voltage.
 
         Returns:
-            float: Current count in volt per second
+            float: Current count in volt per second.
         """
 
     @abstractmethod
     @AsyncStatus.wrap
     async def prepare(self, value: float) -> None:
-        """Prepare method for setting up the counter"""
+        """Prepare method for setting up the counter."""

dodal/devices/current_amplifiers/current_amplifier_detector.py

@@ -18,11 +18,11 @@ from dodal.log import LOGGER
 
 
 class CurrentAmpDet(StandardReadable, Preparable):
-    """
-    CurrentAmpDet composed of a CurrentAmp and a CurrentAmpCounter. It provides
-      the option for automatically changing the CurrentAmp gain to within the optimal
-      range. It also converts the currentAmp/counter output back into the detector
-      current output in Amp.
+    """CurrentAmpDet composed of a CurrentAmp and a CurrentAmpCounter. It provides
+    the option for automatically changing the CurrentAmp gain to within the optimal
+    range. It also converts the currentAmp/counter output back into the detector
+    current output in Amp.
+
     Attributes:
         current_amp (currentAmp): Current amplifier type device.
         counter (CurrentAmpCounter): Counter that capture the current amplifier output.
@@ -48,9 +48,8 @@ class CurrentAmpDet(StandardReadable, Preparable):
         super().__init__(name)
 
     async def read(self) -> dict[str, Reading]:
-        """
-        Read is modified so that if auto_mode is true it will optimise gain before
-         taking the final reading
+        """Read is modified so that if auto_mode is true it will optimise gain before
+        taking the final reading.
         """
         if await self.auto_mode.get_value():
             LOGGER.info(f"{self.name}-Attempting auto-gain")
@@ -85,8 +84,8 @@ class CurrentAmpDet(StandardReadable, Preparable):
                 within_limits = True
 
     async def get_corrected_current(self) -> float:
-        """
-        Convert the output(count and gain) back into the read detector output in Amp.
+        """Convert the output (count and gain) back into the read detector output in
+        Amp.
         """
         current_gain, voltage_per_sec = await asyncio.gather(
             self.current_amp().get_gain(),

dodal/devices/current_amplifiers/femto.py

@@ -13,7 +13,7 @@ from dodal.log import LOGGER
 
 
 class Femto3xxGainTable(StrictEnum):
-    """These are the sensitivity setting for Femto 3xx current amplifier"""
+    """These are the sensitivity setting for Femto 3xx current amplifier."""
 
     SEN_1 = "10^4"
     SEN_2 = "10^5"
@@ -28,7 +28,7 @@ class Femto3xxGainTable(StrictEnum):
 
 
 class Femto3xxGainToCurrentTable(float, Enum):
-    """These are the voltage to current setting for Femto 3xx current amplifier"""
+    """These are the voltage to current setting for Femto 3xx current amplifier."""
 
     SEN_1 = 1e4
     SEN_2 = 1e5
@@ -43,7 +43,7 @@ class Femto3xxGainToCurrentTable(float, Enum):
 
 
 class Femto3xxRaiseTime(float, Enum):
-    """These are the gain dependent raise time(s) for Femto 3xx current amplifier"""
+    """These are the gain dependent raise time(s) for Femto 3xx current amplifier."""
 
     SEN_1 = 0.8e-3
     SEN_2 = 0.8e-3
@@ -58,10 +58,10 @@ class Femto3xxRaiseTime(float, Enum):
 
 
 class FemtoDDPCA(CurrentAmp):
-    """
-    Femto current amplifier device, this class should cover all DDPCA Femto current
-      amplifiers, As the main different between all the DDPCA Femto is their gain table
-        and response time table.
+    """Femto current amplifier device, this class should cover all DDPCA Femto current
+    amplifiers, As the main different between all the DDPCA Femto is their gain table
+    and response time table.
+
     Attributes:
         gain (SignalRW): This is the epic signal that control current amplifier gain.
         gain_table (strictEnum): The table epic use to set gain.
@@ -69,8 +69,7 @@ class FemtoDDPCA(CurrentAmp):
         lowerlimit (float): lowerlimit of the current amplifier
         timeout (float): Maximum waiting time in second for setting gain.
         raise_timetable (Enum): Table contain the minimum amount of time to wait after
-         changing gain.
-
+            changing gain.
     """
 
     def __init__(

dodal/devices/current_amplifiers/sr570.py

@@ -13,7 +13,7 @@ from dodal.log import LOGGER
 
 
 class SR570GainTable(StrictEnum):
-    """Coarse/unit sensitivity setting for SR570 current amplifier"""
+    """Coarse/unit sensitivity setting for SR570 current amplifier."""
 
     SEN_1 = "mA/V"
     SEN_2 = "uA/V"
@@ -22,7 +22,7 @@ class SR570GainTable(StrictEnum):
 
 
 class SR570FineGainTable(StrictEnum):
-    """Fine sensitivity setting for SR570 current amplifier"""
+    """Fine sensitivity setting for SR570 current amplifier."""
 
     SEN_1 = "1"
     SEN_2 = "2"
@@ -36,7 +36,7 @@ class SR570FineGainTable(StrictEnum):
 
 
 class SR570RaiseTimeTable(float, Enum):
-    """These are the gain dependent raise time(s) for SR570 current amplifier"""
+    """These are the gain dependent raise time(s) for SR570 current amplifier."""
 
     SEN_1 = 1e-4
     SEN_2 = 1e-2
@@ -46,7 +46,8 @@ class SR570RaiseTimeTable(float, Enum):
 
 class SR570FullGainTable(Enum):
     """Combined gain table, as each gain step is a combination of both coarse gain and
-    fine gain setting"""
+    fine gain setting.
+    """
 
     SEN_1 = [SR570GainTable.SEN_1, SR570FineGainTable.SEN_1]
     SEN_2 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_9]
@@ -79,7 +80,7 @@ class SR570FullGainTable(Enum):
 
 
 class SR570GainToCurrentTable(float, Enum):
-    """Conversion table for gain (sensitivity) to current"""
+    """Conversion table for gain (sensitivity) to current."""
 
     SEN_1 = 1e3
     SEN_2 = 2e3
@@ -112,10 +113,10 @@ class SR570GainToCurrentTable(float, Enum):
 
 
 class SR570(CurrentAmp):
-    """
-    SR570 current amplifier device. This is similar to Femto with the only different
-     is SR570 has two gain setting fine and coarse, therefore it requires extra
-     gain tables.
+    """SR570 current amplifier device. This is similar to Femto with the only different
+    is SR570 has two gain setting fine and coarse, therefore it requires extra
+    gain tables.
+
     Attributes:
         fine_gain (SignalRW): This is the epic signal that control SR570 fine gain.
         coarse_gain (SignalRW): This is the epic signal that control SR570 coarse gain.
@@ -129,18 +130,17 @@ class SR570(CurrentAmp):
             setting in gain_conversion_table.
         upperlimit (float): upperlimit of the current amplifier
         lowerlimit (float): lowerlimit of the current amplifier
-
     """
 
     def __init__(
         self,
         prefix: str,
-        suffix: str,
-        fine_gain_table: type[StrictEnum],
-        coarse_gain_table: type[StrictEnum],
-        combined_table: type[Enum],
-        gain_to_current_table: type[Enum],
-        raise_timetable: type[Enum],
+        suffix: str = "SENS:SEL",
+        fine_gain_table: type[StrictEnum] = SR570FineGainTable,
+        coarse_gain_table: type[StrictEnum] = SR570GainTable,
+        combined_table: type[Enum] = SR570FullGainTable,
+        gain_to_current_table: type[Enum] = SR570GainToCurrentTable,
+        raise_timetable: type[Enum] = SR570RaiseTimeTable,
         upperlimit: float = 4.8,
         lowerlimit: float = 0.4,
         timeout: float = 1,

dodal/devices/current_amplifiers/struck_scaler_counter.py

@@ -25,11 +25,11 @@ COUNT_PER_VOLTAGE = 100000
 
 
 class StruckScaler(CurrentAmpCounter):
-    """
-    StruckScaler is a counting card that record the output signal from a wide
-      range of detectors. This class contains the basic control to run the struckscaler
-      card together with a current amplifier. It has functions that provide conversion
-      between count and voltage.
+    """StruckScaler is a counting card that record the output signal from a wide
+    range of detectors. This class contains the basic control to run the struckscaler
+    card together with a current amplifier. It has functions that provide conversion
+    between count and voltage.
+
     Attributes:
         readout(SignalR): Scaler card output.
         count_mode (SignalR[CountMode]): Counting card setting.

dodal/devices/detector/det_resolution.py

@@ -47,17 +47,18 @@ def _calc_useful_radius(detector_radius_mm, beam_x_mm, beam_y_mm):
 
 
 def _calc_res_at_angle(wavelength_angstroms, angular_shift_radians):
-    """Base definition of maximum resolution (from Bragg's Law with n=1)"""
+    """Base definition of maximum resolution (from Bragg's Law with n=1)."""
     return 0.5 * wavelength_angstroms / sin(angular_shift_radians)
 
 
 def _calc_res_off_axis_detector(
     wavelength_angstroms, usable_radius, det_distance_mm, two_theta_radians
 ):
-    """
-    Calculate maximum resolution given detector distance and extent (radius) that detector face extends
-    No correction for position of beam centre on detector face at twoTheta=0
-    Here radius and distance parameters can be in any length unit, provided it is the same, millimetres is the convention
+    """Calculate maximum resolution given detector distance and extent (radius) that
+    detector face extends.
+    No correction for position of beam centre on detector face at twoTheta=0.
+    Here radius and distance parameters can be in any length unit, provided it is the
+    same, millimetres is the convention.
     """
     angular_shift_radians = atan(usable_radius / det_distance_mm)
     return _calc_res_at_angle(
@@ -68,9 +69,9 @@ def _calc_res_off_axis_detector(
 def _max_res_for_mx(
     wavelength_angstroms, detector_radius_mm, det_distance_mm, beam_x_mm, beam_y_mm
 ):
-    """
-    Calculate maximum resolution given MX Use Case (detector at twoTheta=0) and beam centre on detector face
-    Correct the radius for position of beam centre on detector face at twoTheta=0
+    """Calculate maximum resolution given MX Use Case (detector at twoTheta=0) and beam
+    centre on detector face.
+    Correct the radius for position of beam centre on detector face at twoTheta=0.
     """
     usable_radius = _calc_useful_radius(detector_radius_mm, beam_x_mm, beam_y_mm)
     return _calc_res_off_axis_detector(

dodal/devices/detector/detector.py

@@ -19,7 +19,8 @@ from dodal.utils import get_run_number
 
 class TriggerMode(Enum):
     """In set frames the number of frames is known at arm time. In free run they are
-    not known until the detector is unstaged."""
+    not known until the detector is unstaged.
+    """
 
     SET_FRAMES = auto()
     FREE_RUN = auto()
@@ -27,7 +28,8 @@ class TriggerMode(Enum):
 
 class DetectorParams(BaseModel):
     """Holds parameters for the detector. Provides access to a list of Dectris detector
-    sizes and a converter for distance to beam centre."""
+    sizes and a converter for distance to beam centre.
+    """
 
     # https://github.com/pydantic/pydantic/issues/8379
     # Must use model_dump(by_alias=True) if serialising!

dodal/devices/diamond_filter.py

@@ -26,9 +26,8 @@ T = TypeVar("T", bound=_Filters)
 
 
 class DiamondFilter(Positioner1D[T]):
-    """
-    A filter set that is used to reduce the heat load on the monochromator.
+    """A filter set that is used to reduce the heat load on the monochromator.
 
-    It has 4 slots that can contain filters of different thickness. Changing the thickness
-    signal will move the filter set to select this filter.
+    It has 4 slots that can contain filters of different thickness. Changing the
+    thickness signal will move the filter set to select this filter.
     """

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,36 +302,35 @@ 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:
-        """Ensures the energy threshold on the detector is set to the specified energy (in eV),
-        within the specified tolerance.
+        """Ensures the energy threshold on the detector is set to the specified energy
+        (in eV), within the specified tolerance.
+
         Args:
             energy (float): The energy to set (in eV)
             tolerance (float, optional): If the energy is already set to within
                 this tolerance it is not set again. Defaults to 0.1eV.
         """
-
         current_energy = float(self.cam.photon_energy.get())
         if abs(current_energy - energy) > tolerance:
             LOGGER.info(f"Setting detector threshold to {energy}")

dodal/devices/eiger_odin.py

@@ -167,7 +167,7 @@ class EigerOdin(Device):
         return not error_strings, "\n".join(error_strings)
 
     def stop(self) -> StatusBase:
-        """Stop odin manually"""
+        """Stop odin manually."""
         LOGGER.info("Stopping Odin...")
         status = self.file_writer.capture.set(0)
         status &= self.meta.stop_writing.set(1)