dls-dodal 1.55.1__py3-none-any.whl → 1.57.0__py3-none-any.whl

dodal/devices/undulator.py

@@ -7,12 +7,12 @@ from ophyd_async.core import (
     AsyncStatus,
     StandardReadable,
     StandardReadableFormat,
-    StrictEnum,
     soft_signal_r_and_setter,
 )
 from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
 
+from dodal.common.enums import EnabledDisabledUpper
 from dodal.log import LOGGER
 
 from .util.lookup_tables import energy_distance_table
@@ -33,11 +33,6 @@ UNDULATOR_DISCREPANCY_THRESHOLD_MM = 2e-3
 STATUS_TIMEOUT_S: float = 10.0
 
 
-class UndulatorGapAccess(StrictEnum):
-    ENABLED = "ENABLED"
-    DISABLED = "DISABLED"
-
-
 def _get_gap_for_energy(
     dcm_energy_ev: float, energy_to_distance_table: ndarray
 ) -> float:
@@ -73,7 +68,7 @@ class Undulator(StandardReadable, Movable[float]):
         with self.add_children_as_readables():
             self.gap_motor = Motor(prefix + "BLGAPMTR")
             self.current_gap = epics_signal_r(float, prefix + "CURRGAPD")
-            self.gap_access = epics_signal_r(UndulatorGapAccess, prefix + "IDBLENA")
+            self.gap_access = epics_signal_r(EnabledDisabledUpper, prefix + "IDBLENA")
 
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.gap_discrepancy_tolerance_mm, _ = soft_signal_r_and_setter(
@@ -110,7 +105,7 @@ class Undulator(StandardReadable, Movable[float]):
 
     async def raise_if_not_enabled(self):
         access_level = await self.gap_access.get_value()
-        if access_level is UndulatorGapAccess.DISABLED and not TEST_MODE:
+        if access_level is EnabledDisabledUpper.DISABLED and not TEST_MODE:
             raise AccessError("Undulator gap access is disabled. Contact Control Room")
 
     async def _set_undulator_gap(self, energy_kev: float) -> None:

dodal/devices/util/epics_util.py

@@ -117,7 +117,7 @@ def call_func(func: Callable[[], StatusBase]) -> StatusBase:
 class SetWhenEnabled(OphydAsyncDevice, Movable[int]):
     """A device that sets the proc field of a PV when it becomes enabled."""
 
-    def __init__(self, name: str = "", prefix: str = ""):
+    def __init__(self, prefix: str, name: str = ""):
         self.proc = epics_signal_rw(int, prefix + ".PROC")
         self.disp = epics_signal_r(int, prefix + ".DISP")
         super().__init__(name)

dodal/devices/watsonmarlow323_pump.py

@@ -1,12 +1,12 @@
-from ophyd_async.core import StandardReadable, StandardReadableFormat, StrictEnum
+from ophyd_async.core import (
+    EnabledDisabled,
+    StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
+)
 from ophyd_async.epics.core import epics_signal_rw
 
 
-class WatsonMarlow323PumpEnable(StrictEnum):
-    DISABLED = "Disabled"
-    ENABLED = "Enabled"
-
-
 class WatsonMarlow323PumpDirection(StrictEnum):
     CLOCKWISE = "CW"
     COUNTER_CLOCKWISE = "CCW"
@@ -38,7 +38,7 @@ class WatsonMarlow323Pump(StandardReadable):
 
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.enabled = epics_signal_rw(
-                WatsonMarlow323PumpEnable,
+                EnabledDisabled,
                 prefix + "DISABLE",
             )
 

dodal/devices/webcam.py

@@ -51,6 +51,7 @@ class Webcam(StandardReadable, Triggerable):
                     )
                 try:
                     data = await response.read()
+                    Image.open(BytesIO(data)).verify()
                     LOGGER.info(f"Saving webcam image from {self.url} to {file_path}")
                 except Exception as e:
                     LOGGER.warning(

dodal/devices/xbpm_feedback.py

@@ -14,12 +14,10 @@ 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."""
 
-    def __init__(self, prefix: str = "", name: str = "xbpm_feedback") -> None:
-        self.pos_ok = epics_signal_r(float, prefix + "-EA-FDBK-01:XBPM2POSITION_OK")
-        self.pos_stable = epics_signal_r(float, prefix + "-EA-FDBK-01:XBPM2_STABLE")
-        self.pause_feedback = epics_signal_rw(Pause, prefix + "-EA-FDBK-01:FB_PAUSE")
-        self.x = epics_signal_r(float, prefix + "-EA-XBPM-02:PosX:MeanValue_RBV")
-        self.y = epics_signal_r(float, prefix + "-EA-XBPM-02:PosY:MeanValue_RBV")
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.pos_ok = epics_signal_r(float, prefix + "XBPM2POSITION_OK")
+        self.pos_stable = epics_signal_r(float, prefix + "XBPM2_STABLE")
+        self.pause_feedback = epics_signal_rw(Pause, prefix + "FB_PAUSE")
         super().__init__(name=name)
 
     @AsyncStatus.wrap

dodal/devices/xspress3/xspress3.py

@@ -34,11 +34,6 @@ class TriggerMode(StrictEnum):
     LVDS_BOTH = "LVDS Both"
 
 
-class UpdateRBV(StrictEnum):
-    DISABLED = "Disabled"
-    ENABLED = "Enabled"
-
-
 class AcquireRBVState(StrictEnum):
     DONE = "Done"
     ACQUIRE = "Acquiring"

dodal/devices/zocalo/zocalo_results.py

@@ -125,19 +125,17 @@ class ZocaloResults(StandardReadable, Triggerable):
 
     def __init__(
         self,
-        name: str = "zocalo",
+        name: str = "",
         zocalo_environment: str = ZOCALO_ENV,
         channel: str = "xrc.i03",
         sort_key: str = DEFAULT_SORT_KEY.value,
         timeout_s: float = DEFAULT_TIMEOUT,
-        prefix: str = "",
         results_source: ZocaloSource = ZocaloSource.CPU,
     ) -> None:
         self.zocalo_environment = zocalo_environment
         self.sort_key = SortKeys[sort_key]
         self.channel = channel
         self.timeout_s = timeout_s
-        self._prefix = prefix
         self._raw_results_received: Queue = Queue()
         self.transport: CommonTransport | None = None
         self.results_source = results_source

dodal/testing/__init__.py

@@ -0,0 +1,3 @@
+from .setup import patch_all_motors, patch_motor
+
+__all__ = ["patch_motor", "patch_all_motors"]

dodal/testing/electron_analyser/__init__.py

@@ -0,0 +1,6 @@
+from .device_factory import create_detector, create_driver
+
+__all__ = [
+    "create_detector",
+    "create_driver",
+]

dodal/testing/electron_analyser/device_factory.py

@@ -0,0 +1,59 @@
+from typing import Any, get_args, get_origin
+
+from dodal.devices.electron_analyser.abstract import (
+    TAbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.detector import TElectronAnalyserDetector
+from dodal.devices.electron_analyser.vgscienta import (
+    VGScientaAnalyserDriverIO,
+    VGScientaDetector,
+)
+
+
+async def create_driver(
+    driver_class: type[TAbstractAnalyserDriverIO],
+    **kwargs: Any,
+) -> TAbstractAnalyserDriverIO:
+    """
+    Helper function that helps to reduce the code to setup an analyser driver. The
+    parameters used for the enum types are taken directly from the subscripts of the
+    class so the user only needs to provide it in one place.
+
+    Args:
+        driver_class: The class for the driver which must include the enums in the
+                      subscript, for example MyDriverClass[MyLensMode, ...]
+        kwargs: Additional key worded arguments that the driver needs for initalisation.
+    """
+    parameters = {
+        "lens_mode_type": get_args(driver_class)[0],
+        "psu_mode_type": get_args(driver_class)[1],
+    }
+    if get_origin(driver_class) is VGScientaAnalyserDriverIO:
+        parameters["pass_energy_type"] = get_args(driver_class)[2]
+
+    return driver_class(**(parameters | kwargs))
+
+
+async def create_detector(
+    detector_class: type[TElectronAnalyserDetector],
+    **kwargs: Any,
+) -> TElectronAnalyserDetector:
+    """
+    Helper function that helps to reduce the code to setup an analyser detector. The
+    parameters used for the enum types are taken directly from the subscripts of the
+    class so the user only needs to provide it in one place.
+
+    Args:
+        detector_class: The class for the detector which must include the enums in the
+                        subscript, for example MyDetectorClass[MyLensMode, ...]
+        kwargs: Additional key worded arguments that the detector needs for
+                initalisation.
+    """
+    parameters = {
+        "lens_mode_type": get_args(detector_class)[0],
+        "psu_mode_type": get_args(detector_class)[1],
+    }
+    if get_origin(detector_class) is VGScientaDetector:
+        parameters["pass_energy_type"] = get_args(detector_class)[2]
+
+    return detector_class(**(parameters | kwargs))

dodal/testing/setup.py

@@ -0,0 +1,67 @@
+from contextlib import ExitStack
+
+from ophyd_async.core import Device
+from ophyd_async.epics.motor import Motor
+from ophyd_async.testing import (
+    callback_on_mock_put,
+    set_mock_value,
+)
+
+
+def patch_motor(
+    motor: Motor,
+    initial_position: float = 0,
+    deadband: float = 0.001,
+    velocity: float = 3,
+    max_velocity: float = 5,
+    low_limit_travel: float = float("-inf"),
+    high_limit_travel: float = float("inf"),
+):
+    """
+    Patch a mock motor with sensible default values so that it can still be used in
+    tests and plans without running into errors as default values are zero.
+
+    Parameters:
+        motor: The mock motor to set mock values with.
+        initial_position: The default initial position of the motor to be set.
+        deadband: The tolerance between readback value and demand setpoint which the
+                  motor is considered at position.
+        velocity: Requested move speed when the mock motor moves.
+        max_velocity: The maximum allowable velocity that can be set for the motor.
+        low_limit_travel: The lower limit that the motor can move to.
+        high_limit_travel: The higher limit that the motor can move to.
+    """
+    set_mock_value(motor.user_setpoint, initial_position)
+    set_mock_value(motor.user_readback, initial_position)
+    set_mock_value(motor.deadband, deadband)
+    set_mock_value(motor.motor_done_move, 1)
+    set_mock_value(motor.velocity, velocity)
+    set_mock_value(motor.max_velocity, max_velocity)
+    set_mock_value(motor.low_limit_travel, low_limit_travel)
+    set_mock_value(motor.high_limit_travel, high_limit_travel)
+    return callback_on_mock_put(
+        motor.user_setpoint,
+        lambda pos, *args, **kwargs: set_mock_value(motor.user_readback, pos),
+    )
+
+
+def patch_all_motors(parent_device: Device):
+    """
+    Check all children of a device and patch any motors with mock values.
+
+    Parameters:
+        parent_device: The device that hold motor(s) as children.
+    """
+    motors = []
+
+    def recursively_find_motors(device: Device):
+        for _, child_device in device.children():
+            if isinstance(child_device, Motor):
+                motors.append(child_device)
+            recursively_find_motors(child_device)
+
+    recursively_find_motors(parent_device)
+    motor_patch_stack = ExitStack()
+    for motor in motors:
+        motor_patch_stack.enter_context(patch_motor(motor))
+    return motor_patch_stack

dodal/devices/CTAB.py

@@ -1,41 +0,0 @@
-from ophyd_async.core import StandardReadable
-from ophyd_async.epics.core import epics_signal_r
-from ophyd_async.epics.motor import Motor
-
-
-class CTAB(StandardReadable):
-    """Basic collimantion table (CTAB) device for motion plus the motion disable signal
-    when laser curtain triggered and hutch not locked.
-
-    CTAB has 3 physical vertical motors, the jacks. 1 upstream and 2 downstream.
-    The two downstream jacks are labelled as outboard (away from the ring) and
-    inboard (towards the ring).
-    Together these 3 jacks provide compound motion for vertical motion and pitch/roll.
-    There are 2 physical horizontal motors 1 upstream, 1 downstream. These provide yaw.
-
-    CTAB motion is disabled by an object being within the laser curtain area and can be
-    overriden by use of the dead man's handle device or locking the hutch. The effect of
-    these disabling systems is to cut power to the motors - signal for this is crate_power
-    """
-
-    def __init__(self, prefix: str, name: str = ""):
-        with self.add_children_as_readables():
-            self.inboard_y = Motor(prefix + "-MO-TABLE-01:INBOARDY")
-            self.outboard_y = Motor(prefix + "-MO-TABLE-01:OUTBOARDY")
-            self.upstream_y = Motor(prefix + "-MO-TABLE-01:UPSTREAMY")
-            self.combined_downstream_y = Motor(prefix + "-MO-TABLE-01:DOWNSTREAMY")
-            self.combined_all_y = Motor(prefix + "-MO-TABLE-01:Y")
-
-            self.downstream_x = Motor(prefix + "-MO-TABLE-01:DOWNSTREAMX")
-            self.upstream_x = Motor(prefix + "-MO-TABLE-01:UPSTREAMX")
-            self.combined_all_x = Motor(prefix + "-MO-TABLE-01:X")
-
-            self.pitch = Motor(prefix + "-MO-TABLE-01:PITCH")
-            self.roll = Motor(prefix + "-MO-TABLE-01:ROLL")
-            self.yaw = Motor(prefix + "-MO-TABLE-01:YAW")
-
-            self.crate_power = epics_signal_r(
-                int, prefix + "-MO-PMAC-02:CRATE2_HEALTHY"
-            )  # returns 0 if no power
-
-            super().__init__(name)

dodal/devices/i24/pilatus_metadata.py

@@ -1,44 +0,0 @@
-"""A small temporary device to set and read the filename template from the pilatus"""
-
-import re
-
-from ophyd_async.core import StandardReadable, derived_signal_r
-from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
-
-
-class PilatusMetadata(StandardReadable):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        self.filename = epics_signal_rw(str, prefix + "cam1:FileName")
-        self.template = epics_signal_r(str, prefix + "cam1:FileTemplate_RBV")
-        self.filenumber = epics_signal_r(int, prefix + "cam1:FileNumber_RBV")
-        with self.add_children_as_readables():
-            self.filename_template = derived_signal_r(
-                self._get_full_filename_template,
-                filename=self.filename,
-                filename_template=self.template,
-                file_number=self.filenumber,
-            )
-        super().__init__(name)
-
-    def _get_full_filename_template(
-        self, filename: str, filename_template: str, file_number: int
-    ) -> str:
-        """
-        Get the template file path by querying the detector PVs.
-        Mirror the construction that the PPU does.
-
-        Returns: A template string, with the image numbers replaced with '#'
-        """
-        # Exploit fact that passing negative numbers will put the - before the 0's
-        expected_filename = str(
-            filename_template % (filename, f"{file_number:05d}_", -9)
-        )
-        # Now, find the -09 part of this
-        numberpart = re.search(r"(-0+9)", expected_filename)
-        assert numberpart is not None
-        template_fill = "#" * len(numberpart.group(0))
-        return (
-            expected_filename[: numberpart.start()]
-            + template_fill
-            + expected_filename[numberpart.end() :]
-        )

dodal/devices/util/test_utils.py

@@ -1,37 +0,0 @@
-from contextlib import ExitStack
-
-from ophyd_async.core import Device
-from ophyd_async.epics.motor import Motor
-from ophyd_async.testing import (
-    callback_on_mock_put,
-    set_mock_value,
-)
-
-
-def patch_motor(motor: Motor, initial_position=0):
-    set_mock_value(motor.user_setpoint, initial_position)
-    set_mock_value(motor.user_readback, initial_position)
-    set_mock_value(motor.deadband, 0.001)
-    set_mock_value(motor.motor_done_move, 1)
-    set_mock_value(motor.velocity, 3)
-    set_mock_value(motor.max_velocity, 5)
-    return callback_on_mock_put(
-        motor.user_setpoint,
-        lambda pos, *args, **kwargs: set_mock_value(motor.user_readback, pos),
-    )
-
-
-def patch_all_motors(parent_device: Device):
-    motors = []
-
-    def recursively_find_motors(device: Device):
-        for _, child_device in device.children():
-            if isinstance(child_device, Motor):
-                motors.append(child_device)
-            recursively_find_motors(child_device)
-
-    recursively_find_motors(parent_device)
-    motor_patch_stack = ExitStack()
-    for motor in motors:
-        motor_patch_stack.enter_context(patch_motor(motor))
-    return motor_patch_stack