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

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

@@ -7,11 +7,15 @@ from functools import partialmethod
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
+    DeviceMock,
     DeviceVector,
     SignalRW,
     StandardReadable,
     StrictEnum,
+    callback_on_mock_put,
+    default_mock_class,
     observe_value,
+    set_mock_value,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
@@ -56,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"
@@ -88,9 +91,21 @@ class SoftInState(StrictEnum):
     NO = "No"
 
 
+class InstantArmMock(DeviceMock["ArmingDevice"]):
+    async def connect(self, device: ArmingDevice) -> None:
+        callback_on_mock_put(
+            device.arm_set, lambda *_, **__: set_mock_value(device.armed, 1)
+        )
+        callback_on_mock_put(
+            device.disarm_set, lambda *_, **__: set_mock_value(device.armed, 0)
+        )
+
+
+@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
 
@@ -215,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.
         """
@@ -253,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.

dodal/devices/zebra/zebra_constants_mapping.py

@@ -5,11 +5,14 @@ from pydantic import BaseModel, Field, model_validator
 
 class ZebraMappingValidations(BaseModel):
     """Raises an exception if field set to -1 is accessed, and validate against
-    multiple fields mapping to the same integer"""
+    multiple fields mapping to the same integer.
+    """
 
     def __getattribute__(self, name: str):
-        """To protect against mismatch between the Zebra configuration that a plan expects and the Zebra which has
-        been instantiated, raise exception if a field which has been set to -1 is accessed."""
+        """To protect against mismatch between the Zebra configuration that a plan
+        expects and the Zebra which has been instantiated, raise exception if a field
+        which has been set to -1 is accessed.
+        """
         value = object.__getattribute__(self, name)
         if not name.startswith("__"):
             if value == -1:
@@ -20,8 +23,7 @@ class ZebraMappingValidations(BaseModel):
 
     @model_validator(mode="after")
     def ensure_no_duplicate_connections(self):
-        """Check that TTL outputs and sources are mapped to unique integers"""
-
+        """Check that TTL outputs and sources are mapped to unique integers."""
         integer_fields = {
             key: value
             for key, value in self.model_dump().items()
@@ -40,7 +42,9 @@ class ZebraMappingValidations(BaseModel):
 
 class ZebraTTLOutputs(ZebraMappingValidations):
     """Maps hardware to the Zebra TTL output (1-4) that they're physically wired to, or
-    None if that hardware is not connected. A value of -1 means this hardware is not connected."""
+    None if that hardware is not connected. A value of -1 means this hardware is not
+    connected.
+    """
 
     TTL_EIGER: int = Field(default=-1, ge=-1, le=4)
     TTL_PILATUS: int = Field(default=-1, ge=-1, le=4)
@@ -49,10 +53,11 @@ class ZebraTTLOutputs(ZebraMappingValidations):
     TTL_SHUTTER: int = Field(default=-1, ge=-1, le=4)
     TTL_XSPRESS3: int = Field(default=-1, ge=-1, le=4)
     TTL_PANDA: int = Field(default=-1, ge=-1, le=4)
+    TTL_JUNGFRAU: int = Field(default=-1, ge=-1, le=4)
 
 
 class ZebraSources(ZebraMappingValidations):
-    """Maps internal Zebra signal source to their integer PV value"""
+    """Maps internal Zebra signal source to their integer PV value."""
 
     DISCONNECT: int = Field(default=0, ge=0, le=63)
     IN1_TTL: int = Field(default=1, ge=0, le=63)

dodal/devices/zebra/zebra_controlled_shutter.py

@@ -26,7 +26,8 @@ class ZebraShutter(StandardReadable, Movable[ZebraShutterState]):
     automatic control. A soft input (aliased to control_mode) will switch between
     which of these AND gates to use. For the manual gate the shutter is then controlled
     by a different soft input (aliased to manual_position_setpoint). Both these AND
-    gates then feed into an OR gate, which then feeds to the shutter."""
+    gates then feed into an OR gate, which then feeds to the shutter.
+    """
 
     def __init__(self, prefix: str, name: str = ""):
         self._manual_position_setpoint = epics_signal_w(

dodal/devices/zocalo/zocalo_interaction.py

@@ -22,14 +22,14 @@ def _get_zocalo_connection(environment):
 
 @dataclass
 class ZocaloStartInfo:
-    """
-    ispyb_dcid (int): The ID of the data collection in ISPyB
-    filename (str): The name of the file that the detector will store into dev/shm
-    start_frame_index (int): The index of the first image of this collection within the file
-                             written by the detector
-    number_of_frames (int): The number of frames in this collection
-    message_index (int): Which trigger this is in the detector collection e.g. 0 for the
-                         first collection after a single arm, 1 for the next...
+    """Attributes:
+    ispyb_dcid (int): The ID of the data collection in ISPyB.
+    filename (str): The name of the file that the detector will store into dev/shm.
+    start_frame_index (int): The index of the first image of this collection within
+        the file written by the detector.
+    number_of_frames (int): The number of frames in this collection.
+    message_index (int): Which trigger this is in the detector collection e.g. 0 for
+        the first collection after a single arm, 1 for the next...
     """
 
     ispyb_dcid: int
@@ -56,7 +56,8 @@ class ZocaloTrigger:
     into a plan, use the ZocaloResults ophyd device.
 
     see https://diamondlightsource.github.io/dodal/main/how-to/zocalo.html for
-    more information about zocalo."""
+    more information about zocalo.
+    """
 
     def __init__(self, environment: str = ZOCALO_ENV):
         self.zocalo_environment: str = environment
@@ -83,10 +84,10 @@ class ZocaloTrigger:
         start_data: ZocaloStartInfo,
     ):
         """Tells the data analysis pipeline we have started a run.
-        Assumes that appropriate data has already been put into ISPyB
+        Assumes that appropriate data has already been put into ISPyB.
 
         Args:
-            start_data (ZocaloStartInfo): Data about the collection to send to zocalo
+            start_data (ZocaloStartInfo): Data about the collection to send to zocalo.
         """
         LOGGER.info(f"Starting Zocalo job {start_data}")
         data = dataclasses.asdict(start_data)
@@ -95,12 +96,11 @@ class ZocaloTrigger:
 
     def run_end(self, data_collection_id: int):
         """Tells the data analysis pipeline we have finished a run.
-        Assumes that appropriate data has already been put into ISPyB
+        Assumes that appropriate data has already been put into ISPyB.
 
         Args:
             data_collection_id (int): The ID of the data collection representing the
-                                    gridscan in ISPyB
-
+                gridscan in ISPyB.
         """
         LOGGER.info(f"Ending Zocalo job with ispyb id {data_collection_id}")
         self._send_to_zocalo(