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

dodal/devices/electron_analyser/base/base_driver_io.py

@@ -41,10 +41,24 @@ class AbstractAnalyserDriverIO(
     Movable[TAbstractBaseRegion],
     Generic[TAbstractBaseRegion, TAcquisitionMode, TLensMode, TPsuMode, TPassEnergy],
 ):
-    """
-    Driver device that defines signals and readables that should be common to all
+    """Driver device that defines signals and readables that should be common to all
     electron analysers. Implementations of electron analyser devices should inherit
     from this class and define additional specialised signals and methods.
+
+    Args:
+        prefix (str): Base PV to connect to EPICS for this device.
+        acquisition_mode_type (type[TAcquisitionMode]): Enum that determines the
+            available acquisition modes for this device.
+        lens_mode_type (type[TLensMode]): Enum that determines the available lens
+            mode for this device.
+        psu_mode_type (type[TPsuMode]): Enum that determines the available psu modes
+            for this device.
+        pass_energy_type (type[TPassEnergy]): Can be enum or float, depending on
+            electron analyser model. If enum, it determines the available pass
+            energies for this device.
+        energy_source: Device that can give us the correct excitation energy (in eV)
+            and switch sources if applicable.
+        name (str, optional): Name of the device.
     """
 
     def __init__(
@@ -56,24 +70,6 @@ class AbstractAnalyserDriverIO(
         pass_energy_type: type[TPassEnergy],
         name: str = "",
     ) -> None:
-        """
-        Constructor method for setting up electron analyser.
-
-        Args:
-            prefix: Base PV to connect to EPICS for this device.
-            acquisition_mode_type: Enum that determines the available acquisition modes
-                                   for this device.
-            lens_mode_type: Enum that determines the available lens mode for this
-                            device.
-            psu_mode_type: Enum that determines the available psu modes for this device.
-            pass_energy_type: Can be enum or float, depends on electron analyser model.
-                              If enum, it determines the available pass energies for
-                              this device.
-            energy_source: Device that can give us the correct excitation energy and
-                           switch sources if applicable.
-                            (in eV).
-            name: Name of the device.
-        """
         self.acquisition_mode_type = acquisition_mode_type
         self.lens_mode_type = lens_mode_type
         self.psu_mode_type = psu_mode_type
@@ -140,33 +136,31 @@ class AbstractAnalyserDriverIO(
     @abstractmethod
     @AsyncStatus.wrap
     async def set(self, epics_region: TAbstractBaseRegion):
-        """
-        Move a group of signals defined in a region. Each implementation of this class
-        is responsible for implementing this method correctly.
+        """Move a group of signals defined in a region. Each implementation of this
+        class is responsible for implementing this method correctly.
 
         Args:
-            region: Contains the parameters to setup the driver for a scan.
+            epics_region (TAbstractBaseRegion): Contains the parameters to setup the
+                driver for a scan.
         """
 
     @abstractmethod
     def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
-        """
-        The signal that defines the angle axis. Depends on analyser model.
+        """The signal that defines the angle axis. Depends on analyser model.
 
         Args:
-            prefix: PV string used for connecting to angle axis.
+            prefix (str): PV string used for connecting to angle axis.
 
         Returns:
-            Signal that can give us angle axis array data.
+            SignalR that can give us angle axis array data.
         """
 
     @abstractmethod
     def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
-        """
-        The signal that defines the energy axis. Depends on analyser model.
+        """The signal that defines the energy axis. Depends on analyser model.
 
         Args:
-            prefix: PV string used for connecting to energy axis.
+            prefix (str): PV string used for connecting to energy axis.
 
         Returns:
             Signal that can give us energy axis array data.
@@ -178,16 +172,16 @@ class AbstractAnalyserDriverIO(
         excitation_energy: float,
         energy_mode: EnergyMode,
     ) -> Array1D[np.float64]:
-        """
-        Calculate the binding energy axis to calibrate the spectra data. Function for a
-        derived signal.
+        """Calculate the binding energy axis to calibrate the spectra data. Function for
+        a derived signal.
 
         Args:
-            energy_axis:       Array data of the original energy_axis from epics.
-            excitation_energy: The excitation energy value used for the scan of this
-                               region.
-            energy_mode:       The energy_mode of the region that was used for the scan
-                               of this region.
+            energy_axis (Array1D[np.float64]): Array data of the original energy_axis
+                from epics.
+            excitation_energy (float): The excitation energy value used for the scan of
+                this region.
+            energy_mode (EnergyMode): The energy_mode of the region that was used for
+                the scan of this region.
 
         Returns:
             Array that is the correct axis for the spectra data.
@@ -205,17 +199,16 @@ class AbstractAnalyserDriverIO(
     def _calculate_total_time(
         self, total_steps: int, step_time: float, iterations: int
     ) -> float:
-        """
-        Calulcate the total time the scan takes for this region. Function for a derived
-        signal.
+        """Calulcate the total time the scan takes for this region. Function for a
+        derived signal.
 
         Args:
-            total_steps: Number of steps for the region.
-            step_time: Time for each step for the region.
-            iterations: The number of iterations the region collected data for.
+            total_steps (int): Number of steps for the region.
+            step_time (float): Time for each step for the region.
+            iterations (int): The number of iterations the region collected data for.
 
         Returns:
-            Calculated total time in seconds.
+            Float: Calculated total time in seconds.
         """
         return total_steps * step_time * iterations
 

dodal/devices/electron_analyser/base/base_region.py

@@ -28,11 +28,13 @@ TPsuMode = TypeVar("TPsuMode", bound=AnyPsuMode)
 
 
 def java_to_python_case(java_str: str) -> str:
-    """
-    Convert a camelCase Java-style string to a snake_case Python-style string.
+    """Convert a camelCase Java-style string to a snake_case Python-style string.
+
+    Args:
+        java_str (str): The Java-style camelCase string.
 
-    :param java_str: The Java-style camelCase string.
-    :return: The Python-style snake_case string.
+    Returns:
+        str: The Python-style snake_case string.
     """
     new_value = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", java_str)
     new_value = re.sub("([a-z0-9])([A-Z])", r"\1_\2", new_value).lower()
@@ -67,9 +69,8 @@ class AbstractBaseRegion(
     JavaToPythonModel,
     Generic[TAcquisitionMode, TLensMode, TPassEnergy],
 ):
-    """
-    Generic region model that holds the data. Specialised region models should inherit
-    this to extend functionality. All energy units are assumed to be in eV.
+    """Generic region model that holds the data. Specialised region models should
+    inherit this to extend functionality. All energy units are assumed to be in eV.
     """
 
     name: str = "New_region"
@@ -89,15 +90,11 @@ class AbstractBaseRegion(
     energy_mode: EnergyMode = EnergyMode.KINETIC
 
     def is_binding_energy(self) -> bool:
-        """
-        Returns true if the energy_mode is binding.
-        """
+        """Returns true if the energy_mode is binding."""
         return self.energy_mode == EnergyMode.BINDING
 
     def is_kinetic_energy(self) -> bool:
-        """
-        Returns true if the energy_mode is kinetic.
-        """
+        """Returns true if the energy_mode is kinetic."""
         return self.energy_mode == EnergyMode.KINETIC
 
     def switch_energy_mode(
@@ -106,19 +103,18 @@ class AbstractBaseRegion(
         excitation_energy: float,
         copy: bool = True,
     ) -> Self:
-        """
-        Get a region with a new energy mode: Kinetic or Binding.
+        """Get a region with a new energy mode: Kinetic or Binding.
         It caculates new values for low_energy, centre_energy, high_energy, via the
         excitation enerrgy. It doesn't calculate anything if the region is already of
         the same energy mode.
 
-        Parameters:
-            energy_mode: Mode you want to switch the region to.
-            excitation_energy: Energy conversion for low_energy, centre_energy, and
-                               high_energy for new energy mode.
-            copy: Defaults to True. If true, create a copy of this region to alter for
-                  the new energy_mode and return it. If False, alter this region for the
-                  energy_mode and return it self.
+        Args:
+            energy_mode (EnergyMode): Mode you want to switch the region to.
+            excitation_energy (float): Energy conversion for low_energy, centre_energy,
+                and high_energy for new energy mode.
+            copy (bool, optional): Defaults to True. If true, create a copy of this
+                region to alter for the new energy_mode and return it. If False, alter
+                this region for the energy_mode and return it self.
 
         Returns:
             Region with selected energy mode and new calculated energy values.
@@ -147,14 +143,16 @@ class AbstractBaseRegion(
         new values for low_energy, centre_energy, and high_energy while also preserving
         the original energy mode e.g mode BINDING will stay as BINDING.
 
-        Parameters:
-            excitation_energy: Energy conversion for low_energy, centre_energy, and
-                               high_energy for new energy mode.
-            copy: Defaults to True. If true, create a copy of this region to alter to
-                  calculate new energy values to return. If false, alter this region.
+        Args:
+            excitation_energy (float): Energy conversion for low_energy, centre_energy,
+                and high_energy for new energy mode.
+            copy (bool, optional): Defaults to True. If true, create a copy of this
+                region to alter to calculate new energy values to return. If false,
+                alter this region.
+
         Returns:
             Region with selected original energy mode and new calculated KINETIC energy
-            values for epics.
+                values for epics.
         """
         original_energy_mode = self.energy_mode
         r = self.switch_energy_mode(EnergyMode.KINETIC, excitation_energy, copy)
@@ -177,8 +175,7 @@ class AbstractBaseSequence(
     JavaToPythonModel,
     Generic[TAbstractBaseRegion],
 ):
-    """
-    Generic sequence model that holds the list of region data. Specialised sequence
+    """Generic sequence model that holds the list of region data. Specialised sequence
     models should inherit this to extend functionality and define type of region to
     hold.
     """

dodal/devices/electron_analyser/base/base_util.py

@@ -4,15 +4,16 @@ from dodal.devices.electron_analyser.base.base_enums import EnergyMode
 def to_kinetic_energy(
     value: float, value_mode: EnergyMode, excitation_energy: float
 ) -> float:
-    """
-    Convert a value that is binding energy to kinetic energy.
-    Parameters:
-        value: The value to convert.
-        value_mode: Energy mode of the value. If it is already kinetic, return the
-                    same value. If it is binding, convert to kinetic.
-        excitation_energy: Value to calculate the conversion.
+    """Convert a value that is binding energy to kinetic energy.
+
+    Args:
+        value (float): The value to convert.
+        value_mode (EnergyMode): Energy mode of the value. If it is already kinetic,
+            return the same value. If it is binding, convert to kinetic.
+        excitation_energy (float): Value to calculate the conversion.
+
     Returns:
-        Caluclated kinetic energy value
+        float: Caluclated kinetic energy value.
     """
     return value if value_mode == EnergyMode.KINETIC else excitation_energy - value
 
@@ -20,14 +21,15 @@ def to_kinetic_energy(
 def to_binding_energy(
     value: float, value_mode: EnergyMode, excitation_energy: float
 ) -> float:
-    """
-    Convert a value that is kinetic energy to binding energy.
-    Parameters:
-        value: The value to convert.
-        value_mode: Energy mode of the value. If it is already binding, return the
-                    same value. If it is kinetic, convert to binding.
-        excitation_energy: Value to calculate the conversion.
+    """Convert a value that is kinetic energy to binding energy.
+
+    Args:
+        value (float): The value to convert.
+        value_mode (EnergyMode): Energy mode of the value. If it is already binding,
+            return the same value. If it is kinetic, convert to binding.
+        excitation_energy (float): Value to calculate the conversion.
+
     Returns:
-        Caluclated binding energy value
+        float: Caluclated binding energy value.
     """
     return value if value_mode == EnergyMode.BINDING else excitation_energy - value

dodal/devices/electron_analyser/base/energy_sources.py

@@ -14,9 +14,8 @@ from dodal.devices.selectable_source import SelectedSource, get_obj_from_selecte
 
 
 class AbstractEnergySource(StandardReadable):
-    """
-    Abstract device that wraps an energy source signal and provides common interface via
-    a energy signal.
+    """Abstract device that wraps an energy source signal and provides common interface
+    via a energy signal.
     """
 
     def __init__(self, name: str = "") -> None:
@@ -25,14 +24,11 @@ class AbstractEnergySource(StandardReadable):
     @property
     @abstractmethod
     def energy(self) -> SignalR[float]:
-        """
-        Signal to provide the excitation energy value in eV.
-        """
+        """Signal to provide the excitation energy value in eV."""
 
 
 class EnergySource(AbstractEnergySource):
-    """
-    Wraps a signal that relates to energy and provides common interface via energy
+    """Wraps a signal that relates to energy and provides common interface via energy
     signal. It provides the name of the wrapped signal as a child signal in the
     read_configuration via wrapped_device_name and adds the signal as a readable.
     """
@@ -59,11 +55,17 @@ def get_float_from_selected_source(
 
 
 class DualEnergySource(AbstractEnergySource):
-    """
-    Holds two EnergySource devices and provides a signal to read energy depending on
+    """Holds two EnergySource devices and provides a signal to read energy depending on
     which source is selected. The energy is the one that corrosponds to the
     selected_source signal. For example, selected_source is source1 if selected_source
-    is at SelectedSource.SOURCE1 and vise versa for source2 and SelectedSource.SOURCE2.
+    is at SelectedSource.SOURCE1 and vise versa for source2 and
+    SelectedSource.SOURCE2.
+
+    Args:
+        source1 (SignalR): Energy source that corrosponds to SelectedSource.SOURCE1.
+        source2 (SignalR): Energy source that corrosponds to SelectedSource.SOURCE2.
+        selected_source (SignalRW): Signal that decides the active energy source.
+        name (str, optional): Name of this device.
     """
 
     def __init__(
@@ -73,14 +75,6 @@ class DualEnergySource(AbstractEnergySource):
         selected_source: SignalRW[SelectedSource],
         name: str = "",
     ):
-        """
-        Args:
-            source1: Energy source that corrosponds to SelectedSource.SOURCE1.
-            source2: Energy source that corrosponds to SelectedSource.SOURCE2.
-            selected_source: Signal that decides the active energy source.
-            name: Name of this device.
-        """
-
         self.selected_source_ref = Reference(selected_source)
         with self.add_children_as_readables():
             self.source1 = EnergySource(source1)

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

@@ -19,15 +19,17 @@ EnumTypesT = TypeVar("EnumTypesT", bound=EnumTypes)
 
 
 class FastShutter(Movable[EnumTypesT], Protocol, Generic[EnumTypesT]):
-    """
-    Enum device specialised for a fast shutter with configured open_state and
+    """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))
     """
@@ -44,9 +46,16 @@ class FastShutter(Movable[EnumTypesT], Protocol, Generic[EnumTypesT]):
 class GenericFastShutter(
     StandardReadable, FastShutter[EnumTypesT], Generic[EnumTypesT]
 ):
-    """
-    Implementation of fast shutter that connects to an epics pv. This pv is an enum that
+    """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__(
@@ -56,12 +65,6 @@ class GenericFastShutter(
         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():
@@ -70,12 +73,19 @@ class GenericFastShutter(
 
 
 class DualFastShutter(StandardReadable, FastShutter[EnumTypesT], Generic[EnumTypesT]):
-    """
-    A fast shutter device that handles the positions of two other fast shutters. The
+    """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__(
@@ -85,13 +95,6 @@ class DualFastShutter(StandardReadable, FastShutter[EnumTypesT], Generic[EnumTyp
         selected_source: SignalRW[SelectedSource],
         name: str = "",
     ):
-        """
-        Arguments:
-            shutter1: Active shutter that corrosponds to SelectedSource.SOURCE1.
-            shutter2: Active shutter that corrosponds to SelectedSource.SOURCE2.
-            selected_source: Signal that decides the active shutter.
-            name: Name of this device.
-        """
         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

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):