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

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

@@ -323,14 +323,14 @@ class EigerDetector(Device, Stageable):
         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)

dodal/devices/electron_analyser/base/base_controller.py

@@ -21,10 +21,19 @@ class ElectronAnalyserController(
     ConstantDeadTimeController[TAbstractAnalyserDriverIO],
     Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
 ):
-    """
-    Specialised controller for the electron analysers to provide additional setup logic
-    such as selecting the energy source to use from requested region and giving the
-    driver the correct region parameters.
+    """Specialised controller for the electron analysers to provide additional setup
+    logic such as selecting the energy source to use from requested region and giving
+    the driver the correct region parameters.
+
+    Args:
+        driver (TAbstractAnalyserDriverIO): The electron analyser driver to wrap
+            around that holds the PV's.
+        energy_source (AbstractEnergySource): Device that holds the excitation
+            energy and ability to switch between sources.
+        deadtime (float, optional): For a given exposure, what is the safest minimum
+            time between exposures that can be determined without reading signals.
+        image_mode (ADImageMode, optional): The image mode to configure the driver
+            with before measuring.
     """
 
     def __init__(
@@ -36,15 +45,6 @@ class ElectronAnalyserController(
         deadtime: float = 0,
         image_mode: ADImageMode = ADImageMode.SINGLE,
     ):
-        """
-        Parameters:
-            driver: The electron analyser driver to wrap around that holds the PV's.
-            energy_source: Device that holds the excitation energy and ability to switch
-                           between sources.
-            deadtime: For a given exposure, what is the safest minimum time between
-                      exposures that can be determined without reading signals.
-            image_mode: The image mode to configure the driver with before measuring.
-        """
         self.energy_source = energy_source
         self.shutter = shutter
         self.source_selector = source_selector

dodal/devices/electron_analyser/base/base_detector.py

@@ -33,9 +33,8 @@ class BaseElectronAnalyserDetector(
     AsyncConfigurable,
     Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
 ):
-    """
-    Detector for data acquisition of electron analyser. Can only acquire using settings
-    already configured for the device.
+    """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.
@@ -90,9 +89,8 @@ 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.
+    """Extends electron analyser detector to configure specific region settings before
+    data acquisition. It is designed to only exist inside a plan.
     """
 
     def __init__(
@@ -127,10 +125,9 @@ class ElectronAnalyserDetector(
     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.
+    """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__(
@@ -146,8 +143,7 @@ class ElectronAnalyserDetector(
 
     @AsyncStatus.wrap
     async def stage(self) -> None:
-        """
-        Prepare the detector for use by ensuring it is idle and ready.
+        """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
@@ -165,11 +161,10 @@ class ElectronAnalyserDetector(
         await self._controller.disarm()
 
     def load_sequence(self, filename: str) -> TAbstractBaseSequence:
-        """
-        Load the sequence data from a provided json file into a sequence class.
+        """Load the sequence data from a provided json file into a sequence class.
 
         Args:
-            filename: Path to the sequence file containing the region data.
+            filename (str): Path to the sequence file containing the region data.
 
         Returns:
             Pydantic model representing the sequence file.
@@ -181,17 +176,17 @@ class ElectronAnalyserDetector(
     ) -> list[
         ElectronAnalyserRegionDetector[TAbstractAnalyserDriverIO, TAbstractBaseRegion]
     ]:
-        """
-        Create a list of detectors equal to the number of regions in a sequence file.
+        """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.
+            filename (str): Path to the sequence file containing the region data.
+            enabled_only (bool, optional): If true, only include the region if enabled
+                is True.
 
         Returns:
             List of ElectronAnalyserRegionDetector, equal to the number of regions in
-            the sequence file.
+                the sequence file.
         """
         seq = self.load_sequence(filename)
         regions: list[TAbstractBaseRegion] = (