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

dodal/devices/robot.py

@@ -1,6 +1,7 @@
 import asyncio
 from asyncio import FIRST_COMPLETED, CancelledError, Task, wait_for
 from dataclasses import dataclass
+from enum import IntEnum
 
 from bluesky.protocols import Movable
 from ophyd_async.core import (
@@ -21,8 +22,8 @@ from ophyd_async.epics.core import (
 
 from dodal.log import LOGGER
 
-WAIT_FOR_OLD_PIN_MSG = "Waiting on old pin unloaded"
-WAIT_FOR_NEW_PIN_MSG = "Waiting on new pin loaded"
+WAIT_FOR_BEAMLINE_DISABLE_MSG = "Waiting on beamline disable"
+WAIT_FOR_BEAMLINE_ENABLE_MSG = "Waiting on beamline enable"
 
 
 class RobotLoadError(Exception):
@@ -43,11 +44,19 @@ class SampleLocation:
     pin: int
 
 
+SAMPLE_LOCATION_EMPTY = SampleLocation(-1, -1)
+
+
 class PinMounted(StrictEnum):
     NO_PIN_MOUNTED = "No Pin Mounted"
     PIN_MOUNTED = "Pin Mounted"
 
 
+class BeamlineStatus(IntEnum):
+    ENABLED = 0
+    DISABLED = 1
+
+
 class ErrorStatus(Device):
     def __init__(self, prefix: str) -> None:
         self.str = epics_signal_r(str, prefix + "_ERR_MSG")
@@ -61,7 +70,7 @@ class ErrorStatus(Device):
             raise RobotLoadError(int(error_code), error_string) from raise_from
 
 
-class BartRobot(StandardReadable, Movable[SampleLocation | None]):
+class BartRobot(StandardReadable, Movable[SampleLocation]):
     """The sample changing robot."""
 
     # How long to wait for the robot if it is busy soaking/drying
@@ -78,6 +87,11 @@ class BartRobot(StandardReadable, Movable[SampleLocation | None]):
     # How far the gonio position can be out before loading will fail
     LOAD_TOLERANCE_MM = 0.02
 
+    # mode constants for CRYO_MODE - TODO when https://jira.diamond.ac.uk/browse/I03-1056
+    # is completed these should be made into a proper enum
+    CRYO_MODE_WARM = 0.0
+    CRYO_MODE_CRYO = 1.0
+
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.barcode = epics_signal_r(str, prefix + "BARCODE")
@@ -86,6 +100,8 @@ class BartRobot(StandardReadable, Movable[SampleLocation | None]):
             self.current_puck = epics_signal_r(float, prefix + "CURRENT_PUCK_RBV")
             self.current_pin = epics_signal_r(float, prefix + "CURRENT_PIN_RBV")
 
+        self.beamline_disabled = epics_signal_r(int, prefix + "ROBOT_OP_16_BITS.B8")
+
         self.next_pin = epics_signal_rw_rbv(float, prefix + "NEXT_PIN")
         self.next_puck = epics_signal_rw_rbv(float, prefix + "NEXT_PUCK")
 
@@ -116,8 +132,8 @@ class BartRobot(StandardReadable, Movable[SampleLocation | None]):
         )
         super().__init__(name=name)
 
-    async def pin_state_or_error(self, expected_state=PinMounted.PIN_MOUNTED):
-        """This co-routine will finish when either the pin sensor reaches the specified
+    async def beamline_status_or_error(self, expected_state: BeamlineStatus):
+        """This co-routine will finish when either the beamline reaches the specified
         state or the robot gives an error (whichever happens first). In the case where
         there is an error a RobotLoadError error is raised.
         """
@@ -130,12 +146,12 @@ class BartRobot(StandardReadable, Movable[SampleLocation | None]):
             error_msg = await self.prog_error.str.get_value()
             raise RobotLoadError(error_code, error_msg)
 
-        async def wfv():
-            await wait_for_value(self.gonio_pin_sensor, expected_state, None)
+        async def wait_for_expected_state():
+            await wait_for_value(self.beamline_disabled, expected_state.value, None)
 
         tasks = [
             (Task(raise_if_error())),
-            (Task(wfv())),
+            (Task(wait_for_expected_state())),
         ]
         try:
             finished, unfinished = await asyncio.wait(
@@ -171,31 +187,40 @@ class BartRobot(StandardReadable, Movable[SampleLocation | None]):
             set_and_wait_for_value(self.next_pin, sample_location.pin),
         )
         await self.load.trigger()
-        if await self.gonio_pin_sensor.get_value() == PinMounted.PIN_MOUNTED:
-            LOGGER.info(WAIT_FOR_OLD_PIN_MSG)
-            await self.pin_state_or_error(PinMounted.NO_PIN_MOUNTED)
-        LOGGER.info(WAIT_FOR_NEW_PIN_MSG)
+        await self._wait_for_beamline_enabled_after_load_or_unload()
+
+    async def _wait_for_beamline_enabled_after_load_or_unload(self):
+        if await self.beamline_disabled.get_value() == BeamlineStatus.ENABLED.value:
+            LOGGER.info(WAIT_FOR_BEAMLINE_DISABLE_MSG)
+            await self.beamline_status_or_error(BeamlineStatus.DISABLED)
 
-        await self.pin_state_or_error()
+        LOGGER.info(WAIT_FOR_BEAMLINE_ENABLE_MSG)
+        await self.beamline_status_or_error(BeamlineStatus.ENABLED)
 
     @AsyncStatus.wrap
-    async def set(self, value: SampleLocation | None):
-        """
-        Perform a sample load from the specified sample location
+    async def set(self, value: SampleLocation):
+        """Perform a sample load from the specified sample location.
+
         Args:
-            value: The pin and puck to load, or None to unload the sample.
+            value (SampleLocation): The pin and puck to load, or SAMPLE_LOCATION_EMPTY
+                to unload the sample.
+
         Raises:
-            RobotLoadError if a timeout occurs, or if an error occurs loading the smaple.
+            RobotLoadError: If a timeout occurs, or if an error occurs loading the
+                sample.
         """
         try:
-            if value is not None:
+            if value != SAMPLE_LOCATION_EMPTY:
                 await wait_for(
                     self._load_pin_and_puck(value),
                     timeout=self.LOAD_TIMEOUT + self.NOT_BUSY_TIMEOUT,
                 )
             else:
                 await self.unload.trigger(timeout=self.LOAD_TIMEOUT)
-                await wait_for_value(self.program_running, False, self.NOT_BUSY_TIMEOUT)
+                await wait_for(
+                    self._wait_for_beamline_enabled_after_load_or_unload(),
+                    timeout=self.LOAD_TIMEOUT + self.NOT_BUSY_TIMEOUT,
+                )
         except TimeoutError as e:
             await self.prog_error.raise_if_error(e)
             await self.controller_error.raise_if_error(e)

dodal/devices/s4_slit_gaps.py

@@ -3,7 +3,7 @@ from ophyd_async.epics.motor import Motor
 
 
 class S4SlitGaps(StandardReadable):
-    """Note that the S4 slits have a different PV fromat to other beamline slits"""
+    """Note that the S4 slits have a different PV fromat to other beamline slits."""
 
     def __init__(self, prefix: str, name="") -> None:
         with self.add_children_as_readables():

dodal/devices/selectable_source.py

@@ -0,0 +1,41 @@
+from typing import TypeVar
+
+from bluesky.protocols import Movable
+from ophyd_async.core import AsyncStatus, StandardReadable, StrictEnum, soft_signal_rw
+
+
+class SelectedSource(StrictEnum):
+    SOURCE1 = "source1"
+    SOURCE2 = "source2"
+
+
+T = TypeVar("T")
+
+
+def get_obj_from_selected_source(selected_source: SelectedSource, s1: T, s2: T) -> T:
+    """Util function that maps enum values for SelectedSource to two objects. It then
+    returns one of the objects that corrosponds to the selected_source value.
+    """
+    match selected_source:
+        case SelectedSource.SOURCE1:
+            return s1
+        case SelectedSource.SOURCE2:
+            return s2
+
+
+class SourceSelector(StandardReadable, Movable[SelectedSource]):
+    """Device that holds a selected_source signal enum of SelectedSource. Useful for
+    beamlines with multiple sources to coordinate which energy source or shutter to
+    use.
+    """
+
+    def __init__(self, name: str = ""):
+        with self.add_children_as_readables():
+            self.selected_source = soft_signal_rw(
+                SelectedSource, SelectedSource.SOURCE1
+            )
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: SelectedSource):
+        await self.selected_source.set(value)

dodal/devices/slits.py

@@ -19,8 +19,7 @@ class MinimalSlits(StandardReadable):
 
 
 class Slits(MinimalSlits):
-    """
-    Representation of a 4-blade set of slits. Allows control/readout of the gap
+    """Representation of a 4-blade set of slits. Allows control/readout of the gap
     between each pair of blades.
     """
 
@@ -40,9 +39,7 @@ class Slits(MinimalSlits):
 
 
 class SlitsY(StandardReadable):
-    """
-    Representation of a 2-blade slits.
-    """
+    """Representation of a 2-blade slits."""
 
     def __init__(
         self,

dodal/devices/smargon.py

@@ -68,7 +68,7 @@ class DeferMoves(StrictEnum):
 
 
 class CombinedMove(TypedDict, total=False):
-    """A move on multiple axes at once using a deferred move"""
+    """A move on multiple axes at once using a deferred move."""
 
     x: float | None
     y: float | None
@@ -79,8 +79,7 @@ class CombinedMove(TypedDict, total=False):
 
 
 class Smargon(XYZOmegaStage, Movable):
-    """
-    Real motors added to allow stops following pin load (e.g. real_x1.stop() )
+    """Real motors added to allow stops following pin load (e.g. real_x1.stop() )
     X1 and X2 real motors provide compound chi motion as well as the compound X travel,
     increasing the gap between x1 and x2 changes chi, moving together changes virtual x.
     Robot loading can nudge these and lead to errors.

dodal/devices/temperture_controller/lakeshore/lakeshore.py

@@ -24,31 +24,28 @@ class Heater336Settings(StrictEnum):
 
 
 class Lakeshore(LakeshoreBaseIO, StandardReadable, Movable[float]):
-    """
-    Device for controlling and reading from a Lakeshore temperature controller.
+    """Device for controlling and reading from a Lakeshore temperature controller.
     It supports multiple channels and PID control.
 
-    Attributes
-    ----------
-    temperature : LakeshoreBaseIO
-        Temperature IO interface.
-    PID : PIDBaseIO
-        PID IO interface.
-    control_channel : derived_signal_rw
-        Signal for selecting the control channel,
-        optional readback as hinted signal
-        (default readback channel is the same as control channel).
-
-    temperature_high_limit: soft_signal_rw
-        Signal to store the soft high temperature limit.
-    temperature_low_limit: soft_signal_rw
-        Signal to store the soft low temperature limit.
-
-
-    Methods
-    -------
-    set(value: float)
-        Set the temperature setpoint for the selected control channel.
+    Attributes:
+        temperature (LakeshoreBaseIO): Temperature IO interface.
+        PID (PIDBaseIO): PID IO interface.
+        control_channel (derived_signal_rw): Signal for selecting the control channel,
+            optional readback as hinted signal (default readback channel is the same
+            as control channel).
+        temperature_high_limit (soft_signal_rw): Signal to store the soft high
+            temperature limit.
+        temperature_low_limit (soft_signal_rw): Signal to store the soft low
+            temperature limit.
+
+    Args:
+        prefix (str): The EPICS prefix for the device.
+        no_channels (int): Number of temperature channels.
+        heater_setting (type[SignalDatatypeT]): Enum type for heater settings.
+        control_channel (int, optional): The initial control channel (default is 1).
+        single_control_channel (bool, optional): Whether to use a single control
+            channel (default is False).
+        name (str, optional): Name of the device.
     """
 
     def __init__(
@@ -60,22 +57,6 @@ class Lakeshore(LakeshoreBaseIO, StandardReadable, Movable[float]):
         single_control_channel: bool = False,
         name: str = "",
     ):
-        """
-        Parameters
-        ----------
-        prefix : str
-            The EPICS prefix for the device.
-        no_channels : int
-            Number of temperature channels.
-        heater_setting : type[SignalDatatypeT]
-            Enum type for heater settings.
-        control_channel : int, optional
-            The initial control channel (default is 1).
-        single_control_channel : bool, optional
-            Whether to use a single control channel (default is False).
-        name : str, optional
-            Name of the device.
-        """
         self._control_channel = soft_signal_rw(int, initial_value=control_channel)
         self.temperature_high_limit = soft_signal_rw(float, initial_value=400)
         self.temperature_low_limit = soft_signal_rw(float, initial_value=0)
@@ -113,9 +94,7 @@ class Lakeshore(LakeshoreBaseIO, StandardReadable, Movable[float]):
 
     @AsyncStatus.wrap
     async def set(self, value: float) -> None:
-        """
-        Set the temperature setpoint for the active control channel.
-        """
+        """Set the temperature setpoint for the active control channel."""
         high, low = await gather(
             self.temperature_high_limit.get_value(),
             self.temperature_low_limit.get_value(),
@@ -149,22 +128,20 @@ class Lakeshore(LakeshoreBaseIO, StandardReadable, Movable[float]):
 
 
 class Lakeshore336(Lakeshore):
+    """Lakeshore 336 temperature controller. With 4 readback and control channels.
+    Heater settings are: Off, Low, Medium, High.
+
+    Args:
+        prefix (str): The EPICS prefix for the device.
+        control_channel (int, optional): The initial control channel (default is 1).
+    """
+
     def __init__(
         self,
         prefix: str,
         control_channel: int = 1,
         name: str = "",
     ):
-        """
-        Lakeshore 336 temperature controller. With 4 readback and control channels.
-        Heater settings are: Off, Low, Medium, High.
-        Parameters
-        ----------
-        prefix : str
-            The EPICS prefix for the device.
-        control_channel : int, optional
-            The initial control channel (default is 1).
-        """
         super().__init__(
             prefix=prefix,
             num_readback_channel=4,
@@ -176,24 +153,21 @@ class Lakeshore336(Lakeshore):
 
 
 class Lakeshore340(Lakeshore):
+    """Lakeshore 340 temperature controller. With 4 readback channels and a single
+    control channel.
+    Heater settings are in power from 0 to 5. 0 is 0 watt, 5 is 50 watt.
+
+    Args:
+        prefix (str): The EPICS prefix for the device.
+        control_channel (int, optional): The initial control channel (default is 1).
+    """
+
     def __init__(
         self,
         prefix: str,
         control_channel: int = 1,
         name: str = "",
     ):
-        """Lakeshore 340 temperature controller. With 4 readback channels and a single
-        control channel.
-        Heater settings are in power from 0 to 5. 0 is 0 watt, 5 is 50 watt.
-
-        Parameters
-        ----------
-        prefix : str
-            The EPICS prefix for the device.
-        control_channel : int, optional
-            The initial control channel (default is 1).
-        """
-
         super().__init__(
             prefix=prefix,
             num_readback_channel=4,

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)