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

dodal/devices/temperture_controller/lakeshore/lakeshore_io.py

@@ -3,11 +3,16 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 
 class LakeshoreControlChannel(Device):
-    """
-    Single control channel for a Lakeshore temperature controller.
+    """Single control channel for a Lakeshore temperature controller.
+
+    Provides access to setpoint, ramp rate, ramp enable, heater output, heater output
+    range, PID parameters (P, I, D), and manual output for the channel.
 
-    Provides access to setpoint, ramp rate, ramp enable, heater output, heater output range,
-    PID parameters (P, I, D), and manual output for the channel.
+    Args:
+        prefix (str): The EPICS prefix for the Lakeshore device.
+        suffix (str): Suffix for the channel, used to differentiate multiple channels.
+        heater_type (SignalDatatypeT): Type of the heater output range.
+        name (str, optional): Name for the device.
     """
 
     def __init__(
@@ -17,19 +22,6 @@ class LakeshoreControlChannel(Device):
         heater_type: type[SignalDatatypeT],
         name: str = "",
     ):
-        """Initialize the LakeshoreControlChannel device.
-        Parameters
-        ----------
-            prefix: str
-                The EPICS prefix for the Lakeshore device.
-            suffix: str
-                Suffix for the channel, used to differentiate multiple channels.
-            heater_type: SignalDatatypeT
-                Type of the heater output range.
-            name: str
-                Optional name for the device.
-        """
-
         def channel_rw(channel_type, pv_name):
             return epics_signal_rw(
                 channel_type,
@@ -53,11 +45,21 @@ class LakeshoreControlChannel(Device):
 class LakeshoreBaseIO(Device):
     """Base class for Lakeshore temperature controller IO.
 
-    Provides access to control channels and readback channels for setpoint, ramp rate, heater output,
-    and PID parameters. Supports both single and multiple control channel configurations.
+    Provides access to control channels and readback channels for setpoint, ramp rate,
+    heater output, and PID parameters. Supports both single and multiple control channel
+    configurations.
+
     Note:
         Almost all models have a controller for each readback channel but some models
             only has a single controller for multiple readback channels.
+
+    Args:
+        prefix (str): The EPICS prefix for the Lakeshore device.
+        num_readback_channel (int): Number of readback channels to create.
+        heater_setting (SignalDatatypeT): Type of the heater setting.
+        name (str, optional): Name for the device.
+        single_control_channel (bool): If True, use a single control channel for
+            all readback.
     """
 
     def __init__(
@@ -68,22 +70,6 @@ class LakeshoreBaseIO(Device):
         name: str = "",
         single_control_channel: bool = False,
     ):
-        """Initialize the LakeshoreBaseIO device.
-
-        Parameters
-        -----------
-            prefix: str
-                The EPICS prefix for the Lakeshore device.
-            num_readback_channel: int
-                Number of readback channels to create.
-            heater_setting: SignalDatatypeT
-                Type of the heater setting.
-            name: str
-                Optional name for the device.
-            single_control_channel: bool
-                If True, use a single control channel for all readback.
-        """
-
         suffixes = (
             [""]
             if single_control_channel

dodal/devices/tetramm.py

@@ -75,7 +75,7 @@ class TetrammDriver(NDArrayBaseIO):
 
 
 class TetrammController(DetectorController):
-    """Controller for a TetrAMM current monitor"""
+    """Controller for a TetrAMM current monitor."""
 
     _supported_trigger_types = {
         DetectorTrigger.EDGE_TRIGGER: TetrammTrigger.EXT_TRIGGER,
@@ -164,9 +164,8 @@ class TetrammController(DetectorController):
         sample rate, it will be lowered to the prior multiple ot ensure triggers
         are not missed.
 
-        :param exposure: Desired exposure time.
-        :type exposure: How long to wait for the exposure time and acquire
-            period to be set.
+        Args:
+            exposure (float): Desired exposure time.
         """
         sample_time = await self.driver.sample_time.get_value()
         minimum_samples = self._minimal_values_per_reading[
@@ -189,9 +188,10 @@ class TetrammController(DetectorController):
         Then, it checks that the DetectorState PV is in DEFAULT_GOOD_STATES,
         and otherwise raises a ValueError.
 
-        :returns AsyncStatus:
-            An AsyncStatus that can be awaited to set driver.acquire to True and perform
-            subsequent raising (if applicable) due to detector state.
+        Returns:
+            AsyncStatus: An AsyncStatus that can be awaited to set driver.acquire to
+                True and perform subsequent raising (if applicable) due to detector
+                state.
         """
         status = await set_and_wait_for_value(
             self.driver.acquire,

dodal/devices/turbo_slit.py

@@ -4,18 +4,19 @@ from ophyd_async.epics.motor import Motor
 
 
 class TurboSlit(StandardReadable, Movable[float]):
-    """
-    This collection of motors coordinates time resolved XAS experiments.
+    """This collection of motors coordinates time resolved XAS experiments.
     It selects a beam out of the polychromatic fan.
     There is a 0.1 degrees beam that can move along a 90-ish degree arc.
     A turboslit device moves after the beam, so that the gap aligns with the beam.
     The turboslit gap can be made smaller to increase energy resolution.
-    The xfine motor can move the slit in x direction at high frequencies for different scans.
+    The xfine motor can move the slit in x direction at high frequencies for different
+    scans.
     These slits can be scanned continously or in step mode.
     The relationship between the three motors is as follows:
-        - arc - position of the middle of the gap in degrees (coarse/ macro) extension
-        - gap - width in mm, provides energy resolution
-        - xfine - main scanning axis in mm, selects the energy as part of the high frequency scan
+        - arc - position of the middle of the gap in degrees (coarse/ macro) extension.
+        - gap - width in mm, provides energy resolution.
+        - xfine - main scanning axis in mm, selects the energy as part of the high
+          frequency scan.
     """
 
     def __init__(self, prefix: str, name: str = ""):
@@ -27,5 +28,5 @@ class TurboSlit(StandardReadable, Movable[float]):
 
     @AsyncStatus.wrap
     async def set(self, value: float):
-        """This will move the default XFINE"""
+        """This will move the default XFINE."""
         await self.xfine.set(value)

dodal/devices/undulator.py

@@ -41,9 +41,16 @@ def _get_gap_for_energy(
 
 
 class BaseUndulator(StandardReadable, Movable[float], ABC):
-    """
-    Base class for undulator devices providing gap control and access management.
+    """Base class for undulator devices providing gap control and access management.
     This class expects target gap value [mm] passed in set method.
+
+    Args:
+        prefix (str): PV prefix.
+        poles (int, optional): Number of magnetic poles built into the undulator.
+        length (float, optional): Length of the undulator in meters.
+        undulator_period(int, optional): Undulator period.
+        baton (Baton, optional): Baton object if provided.
+        name (str, optional): Name for device. Defaults to "".
     """
 
     def __init__(
@@ -55,15 +62,6 @@ class BaseUndulator(StandardReadable, Movable[float], ABC):
         baton: Baton | None = None,
         name: str = "",
     ) -> None:
-        """
-        Args:
-            prefix: PV prefix
-            poles (int, optional): Number of magnetic poles built into the undulator
-            length (float, optional): Length of the undulator in meters
-            undulator_period(int, optional): Undulator period
-            baton (optional): Baton object if provided.
-            name (str, optional): Name for device. Defaults to "".
-        """
         self.baton_ref = Reference(baton) if baton else None
 
         with self.add_children_as_readables():
@@ -91,18 +89,16 @@ class BaseUndulator(StandardReadable, Movable[float], ABC):
     @abstractmethod
     @AsyncStatus.wrap
     async def set(self, value: float) -> None:
-        """
-        Move undulator to a given position.
+        """Move undulator to a given position.
         Abstract method - must be implemented by subclasses.
 
         Args:
-            value: target position - units depend on implementation
+            value (float): Target Position - units depend on implementation.
         """
         ...
 
     async def _set_gap(self, value: float) -> None:
-        """
-        Set the undulator gap to a given value in mm.
+        """Set the undulator gap to a given value in mm.
 
         Args:
             value: gap in mm
@@ -129,11 +125,11 @@ class BaseUndulator(StandardReadable, Movable[float], ABC):
             LOGGER.warning("In test mode, not moving ID gap")
 
     async def _check_gap_within_threshold(self, target_gap: float) -> bool:
-        """
-        Check if the undulator gap is within the acceptable threshold of the target gap.
+        """Check if the undulator gap is within the acceptable threshold of the target gap.
 
         Args:
             target_gap: target gap in mm
+
         Returns:
             True if the gap is within the threshold, False otherwise
         """
@@ -142,14 +138,14 @@ class BaseUndulator(StandardReadable, Movable[float], ABC):
         return abs(target_gap - current_gap) <= tolerance
 
     async def _is_commissioning_mode_enabled(self) -> bool | None:
-        """
-        Asynchronously checks if commissioning mode is enabled via the baton reference.
+        """Asynchronously checks if commissioning mode is enabled via the baton
+        reference.
         """
         return self.baton_ref and await self.baton_ref().commissioning.get_value()
 
     async def raise_if_not_enabled(self) -> AccessError | None:
-        """
-        Asynchronously raises AccessError if gap access is disabled and not in commissioning mode.
+        """Asynchronously raises AccessError if gap access is disabled and not in
+        commissioning mode.
         """
         access_level = await self.gap_access.get_value()
         commissioning_mode = await self._is_commissioning_mode_enabled()
@@ -158,10 +154,19 @@ class BaseUndulator(StandardReadable, Movable[float], ABC):
 
 
 class UndulatorInKeV(BaseUndulator):
-    """
-    An Undulator-type insertion device, used to control photon emission at a given beam energy.
+    """An Undulator-type insertion device, used to control photon emission at a given
+    beam energy.
     This class expects energy [keV] passed in set method and does conversion to gap
     internally, for which it requires path to lookup table file in constructor.
+
+    Args:
+        prefix (str): PV prefix.
+        id_gap_lookup_table_path (str): Path to a lookup table file.
+        poles (int, optional): Number of magnetic poles built into the undulator.
+        length (float, optional): Length of the undulator in meters.
+        undulator_period(int, optional): Undulator period.
+        baton (Baton, optional): Baton object if provided.
+        name (str, optional): Name for device. Defaults to "".
     """
 
     def __init__(
@@ -174,18 +179,6 @@ class UndulatorInKeV(BaseUndulator):
         baton: Baton | None = None,
         name: str = "",
     ) -> None:
-        """Constructor
-
-        Args:
-            prefix: PV prefix
-            id_gap_lookup_table_path (str): Path to a lookup table file
-            poles (int, optional): Number of magnetic poles built into the undulator
-            length (float, optional): Length of the undulator in meters
-            undulator_period(int, optional): Undulator period
-            baton (optional): Baton object if provided.
-            name (str, optional): Name for device. Defaults to "".
-        """
-
         self.id_gap_lookup_table_path = id_gap_lookup_table_path
         super().__init__(
             prefix=prefix,
@@ -198,11 +191,10 @@ class UndulatorInKeV(BaseUndulator):
 
     @AsyncStatus.wrap
     async def set(self, value: float):
-        """
-        Check conditions and Set undulator gap to a given energy in keV
+        """Check conditions and Set undulator gap to a given energy in keV.
 
         Args:
-            value: energy in keV
+            value (float): Energy in keV.
         """
         # Convert energy in keV to gap in mm first
         target_gap = await self._get_gap_to_match_energy(value)
@@ -212,9 +204,8 @@ class UndulatorInKeV(BaseUndulator):
         await self._set_gap(target_gap)
 
     async def _get_gap_to_match_energy(self, energy_kev: float) -> float:
-        """
-        get a 2d np.array from lookup table that
-        converts energies to undulator gap distance
+        """Get a 2d np.array from lookup table that converts energies to undulator gap
+        distance.
         """
         energy_to_distance_table: np.ndarray = await energy_distance_table(
             self.id_gap_lookup_table_path
@@ -228,32 +219,27 @@ class UndulatorInKeV(BaseUndulator):
 
 
 class UndulatorInMm(BaseUndulator):
-    """
-    An Undulator-type insertion device, used to control photon emission.
+    """An Undulator-type insertion device, used to control photon emission.
     This class expects gap [mm] passed in set method.
+
+    Args:
+        value (float): Value in mm.
     """
 
     @AsyncStatus.wrap
     async def set(self, value: float):
-        """
-        Check conditions and Set undulator gap to a given value in mm
-
-        Args:
-            value: value in mm
-        """
         await self._set_gap(value)
 
 
 class UndulatorOrder(StandardReadable, Locatable[int]):
-    """
-    Represents the order of an undulator device. Allows setting and locating the order.
+    """Represents the order of an undulator device. Allows setting and locating the
+    order.
+
+    Args:
+        name (str): Name for device. Defaults to ""
     """
 
     def __init__(self, name: str = "") -> None:
-        """
-        Args:
-            name: Name for device. Defaults to ""
-        """
         with self.add_children_as_readables():
             self.value = soft_signal_rw(int, initial_value=3)
         super().__init__(name=name)

dodal/devices/util/adjuster_plans.py

@@ -1,5 +1,4 @@
-"""
-All the methods in this module return a bluesky plan generator that adjusts a value
+"""All the methods in this module return a bluesky plan generator that adjusts a value
 according to some criteria either via feedback, preset positions, lookup tables etc.
 """
 
@@ -15,7 +14,7 @@ from dodal.log import LOGGER
 def lookup_table_adjuster(
     lookup_table: Callable[[float], float], output_device: Motor, input
 ):
-    """Returns a callable that adjusts a value according to a lookup table"""
+    """Returns a callable that adjusts a value according to a lookup table."""
 
     def adjust(group=None) -> Generator[Msg, None, None]:
         setpoint = lookup_table(input)

dodal/devices/util/epics_util.py

@@ -16,7 +16,7 @@ def epics_signal_put_wait(pv_name: str, wait: float = 3.0) -> Component[EpicsSig
     """Creates a `Component` around an `EpicsSignal` that waits for a callback on a put.
 
     Args:
-        pv_name (str): The name of the PV for the `EpicsSignal`
+        pv_name (str): The name of the PV for the `EpicsSignal`.
         wait (str, optional): The timeout to wait for a callback. Defaults to 3.0.
 
     Returns:
@@ -30,24 +30,24 @@ def run_functions_without_blocking(
     timeout: float = 60.0,
     associated_obj: OphydDevice | None = None,
 ) -> Status:
-    """Creates and initiates an asynchronous chaining of functions which return a status
+    """Creates and initiates an asynchronous chaining of functions which return a status.
 
     Usage:
     This function can be used to take a series of status-returning functions and run
     them all sequentially and in the background by making use of callbacks. It also
-    ensures exceptions on each returned status are propagated
+    ensures exceptions on each returned status are propagated.
 
     Args:
-    functions_to_chain( list(function - > StatusBase) ): A list of functions which each
-                                                            return a status object
-    associated_obj (Device | None): The device that should be associated with the
-                                        returned status
+        functions_to_chain (Sequence(function - > StatusBase)): A list of functions
+            which each return a status object.
+        timeout (float, optional): The timeout period, defaults to 60.
+        associated_obj (OphydDevice, optional): The device that should be associated
+            with the returned status.
 
     Returns:
-    Status: A status object which is marked as complete once all of the Status objects
-    returned by the unwrapped functions have completed.
+        Status: A status object which is marked as complete once all of the Status
+            objects returned by the unwrapped functions have completed.
     """
-
     # The returned status - marked as finished at the end of the callback chain. If any
     # intermediate statuses have an exception, the full_status will timeout.
     full_status = Status(obj=associated_obj, timeout=timeout)

dodal/devices/util/lookup_tables.py

@@ -1,5 +1,4 @@
-"""
-All the public methods in this module return a lookup table of some kind that
+"""All the public methods in this module return a lookup table of some kind that
 converts the source value s to a target value t for different values of s.
 """
 
@@ -18,19 +17,18 @@ async def energy_distance_table(
     comments: Sequence[str] = ["#", "Units"],
     skiprows: int = 0,
 ) -> np.ndarray:
-    """
-    Returns a numpy formatted lookup table for required positions of an ID gap to
+    """Returns a numpy formatted lookup table for required positions of an ID gap to
     provide emission at a given beam energy.
 
     Args:
-        lookup_table_path: Path to lookup table
-        comments: Lines starting with any of these strings will be ignored
-        skiprows: Number of rows to skip at the start of the file
+        lookup_table_path (str): Path to lookup table.
+        comments (Sequence[str], optional): Lines starting with any of these strings
+            will be ignored.
+        skiprows (int, optional): Number of rows to skip at the start of the file.
 
     Returns:
-        ndarray: Lookup table
+        ndarray: Lookup table.
     """
-
     # Slight cheat to make the file IO async, numpy doesn't do any real IO now, just
     # decodes the text
     async with aiofiles.open(lookup_table_path) as stream:
@@ -40,7 +38,8 @@ async def energy_distance_table(
 
 def parse_lookup_table(filename: str) -> list[Sequence]:
     """Parse a generic lookup table with a number of columns >= 2 and return a list \
-        in column major order of the values in it."""
+        in column major order of the values in it.
+    """
     LOGGER.info(f"Parsing lookup table file {filename}")
 
     lut_vals = zip(*loadtxt(filename, comments=["#", "Units"]), strict=False)
@@ -53,7 +52,8 @@ def linear_interpolation_lut(
     """Returns a callable that converts values by linear interpolation of lookup table
     values.
 
-    If the value falls outside the lookup table then the closest value will be used."""
+    If the value falls outside the lookup table then the closest value will be used.
+    """
     # numpy interp expects x-values to be increasing
     if not np.all(np.diff(s_values) > 0):
         LOGGER.info(
@@ -75,17 +75,16 @@ def linear_interpolation_lut(
 def linear_extrapolation_lut(
     s_values: Sequence[float], t_values: Sequence[float]
 ) -> Callable[[float], float]:
-    """
-    Return a callable that implements f(s) = t according to the conversion table data
-    supplied, with linear extrapolation outside that range. Inside the range of the table,
-    the function is equivalent to that returned by linear_interpolation_lut
+    """Return a callable that implements f(s) = t according to the conversion table data
+    supplied, with linear extrapolation outside that range. Inside the range of the
+    table, the function is equivalent to that returned by linear_interpolation_lut.
 
     Args:
-        s_values:  Values of the independent axis
-        t_values:  Values of the dependent axis
+        s_values (Sequence[float]): Values of the independent axis.
+        t_values (Sequence[float]): Values of the dependent axis.
 
     Returns:
-        A callable that returns t for the given s
+        Callable: A callable that returns t for the given s.
     """
     assert len(s_values) == len(t_values), (
         "Lookup table does not have the same number of values for each axis"

dodal/devices/v2f.py

@@ -20,9 +20,8 @@ class V2FGain(StrictEnum):
 
 
 class QDV2F(StandardReadable):
-    """
-    A Quantum Detectors V2F low noise voltage to frequency converter.
-    Two channel V2F - 50mHz
+    """A Quantum Detectors V2F low noise voltage to frequency converter.
+    Two channel V2F - 50mHz.
     """
 
     def __init__(

dodal/devices/watsonmarlow323_pump.py

@@ -18,7 +18,7 @@ class WatsonMarlow323PumpState(StrictEnum):
 
 
 class WatsonMarlow323Pump(StandardReadable):
-    """Watson Marlow 323 Peristaltic Pump device"""
+    """Watson Marlow 323 Peristaltic Pump device."""
 
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():

dodal/devices/xbpm_feedback.py

@@ -13,8 +13,9 @@ class Pause(StrictEnum):
 
 
 class XBPMFeedback(Device, Triggerable):
-    """The XBPM feedback device is an IOC that moves the DCM, HFM and VFM to automatically
-    hold the beam into place, as measured by the XBPM sensor."""
+    """The XBPM feedback device is an IOC that moves the DCM, HFM and VFM to
+    automatically hold the beam into place, as measured by the XBPM sensor.
+    """
 
     def __init__(self, prefix: str, name: str = "", baton: Baton | None = None) -> None:
         self.pos_ok = epics_signal_r(float, prefix + "XBPM2POSITION_OK")

dodal/devices/xspress3/xspress3.py

@@ -56,19 +56,16 @@ class DetectorState(StrictEnum):
 class Xspress3(Device, Stageable):
     """Xpress/XpressMini is a region of interest (ROI) picker that sums the detector
     output into a scaler with user-defined regions. It is often used as a signal
-    discriminator to provide better energy resolution and signal to noise in X-ray detection experiments.
+    discriminator to provide better energy resolution and signal to noise in X-ray
+    detection experiments.
     This currently only provide staging functionality.
 
-    Parameters
-    ----------
-    prefix:
-        Beamline part of PV
-    name:
-        Name of the device
-    num_channels:
-        Number of channel xspress3 has, default is 1 for mini.
-    timeout:
-        How long to wait for before timing out for staging/arming of detector default is 1 sec
+    Args:
+        prefix (str): Beamline part of PV.
+        name (str, optional): Name of the device.
+        num_channels (int): Number of channel xspress3 has, default is 1 for mini.
+        timeout (float): How long to wait for before timing out for staging/arming of
+            detector, the default is 1 sec.
     """
 
     def __init__(

dodal/devices/xspress3/xspress3_channel.py

@@ -8,9 +8,8 @@ class AcquireState(StrictEnum):
 
 
 class Xspress3Channel(Device):
-    """
-    Xspress3 Channel contains the truncated detector data and its collection conditions
-     including the definition of ROI(region of interest).
+    """Xspress3 Channel contains the truncated detector data and its collection conditions
+    including the definition of ROI(region of interest).
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
@@ -30,9 +29,7 @@ class Xspress3Channel(Device):
 
 
 class Xspress3ROIChannel(Device):
-    """
-    This is the Xspress3 multi-channel analyzer range
-    """
+    """This is the Xspress3 multi-channel analyzer range."""
 
     def __init__(self, prefix: str, name: str = "") -> None:
         self.roi_start_x = epics_signal_rw(int, prefix + "MinX")

dodal/devices/zebra/zebra.py

@@ -60,9 +60,8 @@ class I23Axes:
 
 
 class RotationDirection(StrictEnum):
-    """
-    Defines for a swept angle whether the scan width (sweep) is to be added or subtracted from
-    the initial angle to obtain the final angle.
+    """Defines for a swept angle whether the scan width (sweep) is to be added or
+    subtracted from the initial angle to obtain the final angle.
     """
 
     POSITIVE = "Positive"
@@ -105,7 +104,8 @@ class InstantArmMock(DeviceMock["ArmingDevice"]):
 @default_mock_class(InstantArmMock)
 class ArmingDevice(StandardReadable, Movable[ArmDemand]):
     """A useful device that can abstract some of the logic of arming.
-    Allows a user to just call arm.set(ArmDemand.ARM)"""
+    Allows a user to just call arm.set(ArmDemand.ARM).
+    """
 
     TIMEOUT: float = 3
 
@@ -230,7 +230,7 @@ class LogicGateConfigurer(StandardReadable):
         """Uses the specified `LogicGateConfiguration` to configure a gate on the Zebra.
 
         Args:
-            type (GateType): The type of gate e.g. AND/OR
+            type (GateType): The type of gate e.g. AND/OR.
             gate_number (int): Which gate to configure.
             config (LogicGateConfiguration): A configuration for the gate.
         """
@@ -268,8 +268,7 @@ class LogicGateConfiguration:
 
         Args:
             input_source (int): The source for the input (must be between 0 and 63).
-            invert (bool, optional): Whether the input should be inverted. Default
-                False.
+            invert (bool, optional): Whether the input should be inverted. Default False.
 
         Returns:
             LogicGateConfiguration: A description of the gate configuration.