dls-dodal 1.33.0__py3-none-any.whl → 1.35.0__py3-none-any.whl

dodal/devices/oav/utils.py

@@ -5,8 +5,11 @@ import bluesky.plan_stubs as bps
 import numpy as np
 from bluesky.utils import Msg
 
-from dodal.devices.oav.oav_calculations import camera_coordinates_to_xyz
-from dodal.devices.oav.oav_detector import OAVConfigParams
+from dodal.devices.oav.oav_calculations import (
+    calculate_beam_distance,
+    camera_coordinates_to_xyz,
+)
+from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
 from dodal.devices.smargon import Smargon
 
@@ -36,21 +39,6 @@ def bottom_right_from_top_left(
     )
 
 
-class ColorMode(IntEnum):
-    """
-    Enum to store the various color modes of the camera. We use RGB1.
-    """
-
-    MONO = 0
-    BAYER = 1
-    RGB1 = 2
-    RGB2 = 3
-    RGB3 = 4
-    YUV444 = 5
-    YUV422 = 6
-    YUV421 = 7
-
-
 class EdgeOutputArrayImageType(IntEnum):
     """
     Enum to store the types of image to tweak the output array. We use Original.
@@ -64,7 +52,7 @@ class EdgeOutputArrayImageType(IntEnum):
 
 
 def get_move_required_so_that_beam_is_at_pixel(
-    smargon: Smargon, pixel: Pixel, oav_params: OAVConfigParams
+    smargon: Smargon, pixel: Pixel, oav: OAV
 ) -> Generator[Msg, None, np.ndarray]:
     """Calculate the required move so that the given pixel is in the centre of the beam."""
 
@@ -78,22 +66,35 @@ def get_move_required_so_that_beam_is_at_pixel(
     )
     current_angle = yield from bps.rd(smargon.omega)
 
-    return calculate_x_y_z_of_pixel(current_motor_xyz, current_angle, pixel, oav_params)
+    beam_x = yield from bps.rd(oav.beam_centre_i)
+    beam_y = yield from bps.rd(oav.beam_centre_j)
+    microns_per_pixel_x = yield from bps.rd(oav.microns_per_pixel_x)
+    microns_per_pixel_y = yield from bps.rd(oav.microns_per_pixel_y)
+
+    return calculate_x_y_z_of_pixel(
+        current_motor_xyz,
+        current_angle,
+        pixel,
+        (beam_x, beam_y),
+        (microns_per_pixel_x, microns_per_pixel_y),
+    )
 
 
 def calculate_x_y_z_of_pixel(
-    current_x_y_z, current_omega, pixel: Pixel, oav_params: OAVConfigParams
+    current_x_y_z,
+    current_omega,
+    pixel: Pixel,
+    beam_centre: tuple[int, int],
+    microns_per_pixel: tuple[float, float],
 ) -> np.ndarray:
-    beam_distance_px: Pixel = oav_params.calculate_beam_distance(*pixel)
+    beam_distance_px: Pixel = calculate_beam_distance(beam_centre, *pixel)
 
-    assert oav_params.micronsPerXPixel
-    assert oav_params.micronsPerYPixel
     return current_x_y_z + camera_coordinates_to_xyz(
         beam_distance_px[0],
         beam_distance_px[1],
         current_omega,
-        oav_params.micronsPerXPixel,
-        oav_params.micronsPerYPixel,
+        microns_per_pixel[0],
+        microns_per_pixel[1],
     )
 
 
@@ -102,8 +103,8 @@ def wait_for_tip_to_be_found(
 ) -> Generator[Msg, None, Pixel]:
     yield from bps.trigger(ophyd_pin_tip_detection, wait=True)
     found_tip = yield from bps.rd(ophyd_pin_tip_detection.triggered_tip)
-    if found_tip == ophyd_pin_tip_detection.INVALID_POSITION:
+    if all(found_tip == ophyd_pin_tip_detection.INVALID_POSITION):
         timeout = yield from bps.rd(ophyd_pin_tip_detection.validity_timeout)
         raise PinNotFoundException(f"No pin found after {timeout} seconds")
 
-    return found_tip  # type: ignore
+    return Pixel((int(found_tip[0]), int(found_tip[1])))

dodal/devices/p99/sample_stage.py

@@ -1,7 +1,5 @@
-from enum import Enum
-
-from ophyd_async.core import Device
-from ophyd_async.epics.signal import epics_signal_rw
+from ophyd_async.core import Device, SubsetEnum
+from ophyd_async.epics.core import epics_signal_rw
 
 
 class SampleAngleStage(Device):
@@ -18,7 +16,7 @@ class SampleAngleStage(Device):
         super().__init__(name=name)
 
 
-class p99StageSelections(str, Enum):
+class p99StageSelections(SubsetEnum):
     Empty = "Empty"
     Mn5um = "Mn 5um"
     Fe = "Fe (empty)"

dodal/devices/pgm.py

@@ -0,0 +1,40 @@
+from ophyd_async.core import (
+    StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
+)
+from ophyd_async.epics.core import epics_signal_rw
+from ophyd_async.epics.motor import Motor
+
+
+class PGM(StandardReadable):
+    """
+    Plane grating monochromator, it is use in soft x-ray beamline to generate monochromic beam.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        grating: type[StrictEnum],
+        gratingPv: str,
+        name: str = "",
+    ) -> None:
+        """
+        Parameters
+        ----------
+        prefix:
+            Beamline specific part of the PV
+        grating:
+            The Enum for the grating table.
+        gratingPv:
+            The suffix pv part of grating Pv
+        name:
+            Name of the device
+        """
+        with self.add_children_as_readables():
+            self.energy = Motor(prefix + "ENERGY")
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.grating = epics_signal_rw(grating, prefix + gratingPv)
+            self.cff = epics_signal_rw(float, prefix + "CFF")
+
+        super().__init__(name=name)

dodal/devices/qbpm.py

@@ -0,0 +1,18 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_r
+
+
+class QBPM(StandardReadable):
+    """
+    A beam position monitor that gives a position and intensity of the beam.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables():
+            self.intensity_uA = epics_signal_r(float, f"{prefix}INTEN")
+
+        super().__init__(name)

dodal/devices/robot.py

@@ -1,16 +1,16 @@
 import asyncio
 from asyncio import FIRST_COMPLETED, CancelledError, Task, wait_for
 from dataclasses import dataclass
-from enum import Enum
 
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
     StandardReadable,
+    StrictEnum,
     set_and_wait_for_value,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw_rbv, epics_signal_x
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv, epics_signal_x
 
 from dodal.log import LOGGER
 
@@ -33,7 +33,7 @@ class SampleLocation:
     pin: int
 
 
-class PinMounted(str, Enum):
+class PinMounted(StrictEnum):
     NO_PIN_MOUNTED = "No Pin Mounted"
     PIN_MOUNTED = "Pin Mounted"
 
@@ -63,8 +63,8 @@ class BartRobot(StandardReadable, Movable):
         self.current_puck = epics_signal_r(float, prefix + "CURRENT_PUCK_RBV")
         self.current_pin = epics_signal_r(float, prefix + "CURRENT_PIN_RBV")
 
-        self.next_sample_id = epics_signal_rw_rbv(float, prefix + "NEXT_ID")
-        self.sample_id = epics_signal_r(float, prefix + "CURRENT_ID_RBV")
+        self.next_sample_id = epics_signal_rw_rbv(int, prefix + "NEXT_ID")
+        self.sample_id = epics_signal_r(int, prefix + "CURRENT_ID_RBV")
 
         self.load = epics_signal_x(prefix + "LOAD.PROC")
         self.program_running = epics_signal_r(bool, prefix + "PROGRAM_RUNNING")

dodal/devices/smargon.py

@@ -7,8 +7,8 @@ from typing import cast
 from bluesky import plan_stubs as bps
 from bluesky.utils import Msg
 from ophyd_async.core import AsyncStatus, Device, StandardReadable, wait_for_value
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r
 
 from dodal.devices.util.epics_util import SetWhenEnabled
 
@@ -40,8 +40,8 @@ class StubOffsets(Device):
         super().__init__(name)
 
     @AsyncStatus.wrap
-    async def set(self, pos: StubPosition):
-        if pos == StubPosition.CURRENT_AS_CENTER:
+    async def set(self, value: StubPosition):
+        if value == StubPosition.CURRENT_AS_CENTER:
             await self.center_at_current_position.set(1)
             smargon = cast(Smargon, self.parent)
             await wait_for_value(

dodal/devices/synchrotron.py

@@ -1,7 +1,12 @@
 from enum import Enum
 
-from ophyd_async.core import ConfigSignal, StandardReadable, soft_signal_r_and_setter
-from ophyd_async.epics.signal import epics_signal_r
+from ophyd_async.core import (
+    StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
+    soft_signal_r_and_setter,
+)
+from ophyd_async.epics.core import epics_signal_r
 
 
 class Prefix(str, Enum):
@@ -19,7 +24,7 @@ class Suffix(str, Enum):
     END_COUNTDOWN = "ENDCOUNTDN"
 
 
-class SynchrotronMode(str, Enum):
+class SynchrotronMode(StrictEnum):
     SHUTDOWN = "Shutdown"
     INJECTION = "Injection"
     NOBEAM = "No Beam"
@@ -44,7 +49,7 @@ class Synchrotron(StandardReadable):
             self.current = epics_signal_r(float, signal_prefix + Suffix.SIGNAL)
             self.energy = epics_signal_r(float, status_prefix + Suffix.BEAM_ENERGY)
 
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.probe, _ = soft_signal_r_and_setter(str, initial_value="x-ray")
             self.type, _ = soft_signal_r_and_setter(
                 str, initial_value="Synchrotron X-ray Source"

dodal/devices/tetramm.py

@@ -1,50 +1,50 @@
 import asyncio
-from enum import Enum
 
 from bluesky.protocols import Hints
 from ophyd_async.core import (
     DatasetDescriber,
-    DetectorControl,
+    DetectorController,
     DetectorTrigger,
     Device,
     PathProvider,
     StandardDetector,
+    StrictEnum,
     TriggerInfo,
     set_and_wait_for_value,
     soft_signal_r_and_setter,
 )
 from ophyd_async.epics.adcore import ADHDFWriter, NDFileHDFIO, stop_busy_record
-from ophyd_async.epics.signal import (
+from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,
 )
 
 
-class TetrammRange(str, Enum):
+class TetrammRange(StrictEnum):
     uA = "+- 120 uA"
     nA = "+- 120 nA"
 
 
-class TetrammTrigger(str, Enum):
+class TetrammTrigger(StrictEnum):
     FreeRun = "Free run"
     ExtTrigger = "Ext. trig."
     ExtBulb = "Ext. bulb"
     ExtGate = "Ext. gate"
 
 
-class TetrammChannels(str, Enum):
+class TetrammChannels(StrictEnum):
     One = "1"
     Two = "2"
     Four = "4"
 
 
-class TetrammResolution(str, Enum):
+class TetrammResolution(StrictEnum):
     SixteenBits = "16 bits"
     TwentyFourBits = "24 bits"
 
 
-class TetrammGeometry(str, Enum):
+class TetrammGeometry(StrictEnum):
     Diamond = "Diamond"
     Square = "Square"
 
@@ -80,7 +80,7 @@ class TetrammDriver(Device):
         super().__init__(name=name)
 
 
-class TetrammController(DetectorControl):
+class TetrammController(DetectorController):
     """Controller for a TetrAMM current monitor
 
     Attributes:

dodal/devices/thawer.py

@@ -1,36 +1,42 @@
 from asyncio import Task, create_task, sleep
-from enum import Enum
 
 from bluesky.protocols import Stoppable
-from ophyd_async.core import AsyncStatus, Device, SignalRW, StandardReadable
-from ophyd_async.epics.signal import epics_signal_rw
+from ophyd_async.core import (
+    AsyncStatus,
+    Device,
+    Reference,
+    SignalRW,
+    StandardReadable,
+    StrictEnum,
+)
+from ophyd_async.epics.core import epics_signal_rw
 
 
 class ThawingException(Exception):
     pass
 
 
-class ThawerStates(str, Enum):
+class ThawerStates(StrictEnum):
     OFF = "Off"
     ON = "On"
 
 
 class ThawingTimer(Device, Stoppable):
     def __init__(self, control_signal: SignalRW[ThawerStates]) -> None:
-        self._control_signal = control_signal
+        self._control_signal_ref = Reference(control_signal)
         self._thawing_task: Task | None = None
         super().__init__("thaw_for_time_s")
 
     @AsyncStatus.wrap
     async def set(self, time_to_thaw_for: float):
-        await self._control_signal.set(ThawerStates.ON)
+        await self._control_signal_ref().set(ThawerStates.ON)
         if self._thawing_task and not self._thawing_task.done():
             raise ThawingException("Thawing task already in progress")
         self._thawing_task = create_task(sleep(time_to_thaw_for))
         try:
             await self._thawing_task
         finally:
-            await self._control_signal.set(ThawerStates.OFF)
+            await self._control_signal_ref().set(ThawerStates.OFF)
 
     @AsyncStatus.wrap
     async def stop(self, *args, **kwargs):

dodal/devices/undulator.py

@@ -1,16 +1,17 @@
-from enum import Enum
+import os
 
 import numpy as np
 from bluesky.protocols import Movable
 from numpy import argmin, ndarray
 from ophyd_async.core import (
     AsyncStatus,
-    ConfigSignal,
     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 ophyd_async.epics.signal import epics_signal_r
 
 from dodal.log import LOGGER
 
@@ -32,7 +33,7 @@ UNDULATOR_DISCREPANCY_THRESHOLD_MM = 2e-3
 STATUS_TIMEOUT_S: float = 10.0
 
 
-class UndulatorGapAccess(str, Enum):
+class UndulatorGapAccess(StrictEnum):
     ENABLED = "ENABLED"
     DISABLED = "DISABLED"
 
@@ -54,7 +55,7 @@ class Undulator(StandardReadable, Movable):
     def __init__(
         self,
         prefix: str,
-        id_gap_lookup_table_path: str,
+        id_gap_lookup_table_path: str = os.devnull,
         name: str = "",
         poles: int | None = None,
         length: float | None = None,
@@ -74,7 +75,7 @@ class Undulator(StandardReadable, Movable):
             self.current_gap = epics_signal_r(float, prefix + "CURRGAPD")
             self.gap_access = epics_signal_r(UndulatorGapAccess, prefix + "IDBLENA")
 
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.gap_discrepancy_tolerance_mm, _ = soft_signal_r_and_setter(
                 float,
                 initial_value=UNDULATOR_DISCREPANCY_THRESHOLD_MM,

dodal/devices/util/adjuster_plans.py

@@ -21,6 +21,6 @@ def lookup_table_adjuster(
     def adjust(group=None) -> Generator[Msg, None, None]:
         setpoint = lookup_table(input)
         LOGGER.info(f"lookup_table_adjuster setting {output_device.name} to {setpoint}")
-        yield from bps.abs_set(output_device, setpoint, group=group)
+        yield from bps.abs_set(output_device, setpoint, group=group)  # type: ignore # See: https://github.com/DiamondLightSource/dodal/issues/827
 
     return adjust

dodal/devices/util/epics_util.py

@@ -7,7 +7,7 @@ from ophyd import Device as OphydDevice
 from ophyd.status import Status, StatusBase
 from ophyd_async.core import AsyncStatus, wait_for_value
 from ophyd_async.core import Device as OphydAsyncDevice
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.log import LOGGER
 

dodal/devices/util/lookup_tables.py

@@ -33,7 +33,10 @@ async def energy_distance_table(lookup_table_path: str) -> np.ndarray:
 
 
 def linear_interpolation_lut(filename: str) -> Callable[[float], float]:
-    """Returns a callable that converts values by linear interpolation of lookup table values"""
+    """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."""
     LOGGER.info(f"Using lookup table {filename}")
     s_and_t_vals = zip(*loadtxt(filename, comments=["#", "Units"]), strict=False)
 
@@ -54,10 +57,6 @@ def linear_interpolation_lut(filename: str) -> Callable[[float], float]:
             )
 
     def s_to_t2(s: float) -> float:
-        if s < s_values[0] or s > s_values[len(s_values) - 1]:
-            raise ValueError(
-                f"Lookup table does not support extrapolation from file {filename}, s={s}"
-            )
         return float(interp(s, s_values, t_values))
 
     return s_to_t2

dodal/devices/watsonmarlow323_pump.py

@@ -0,0 +1,45 @@
+from ophyd_async.core import 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"
+
+
+class WatsonMarlow323PumpState(StrictEnum):
+    STOPPED = "STOP"
+    STARTED = "START"
+
+
+class WatsonMarlow323Pump(StandardReadable):
+    """Watson Marlow 323 Peristaltic Pump device"""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.direction = epics_signal_rw(
+                WatsonMarlow323PumpDirection,
+                read_pv=prefix + "INFO:DIR",
+                write_pv=prefix + "SET:DIR",
+            )
+            self.state = epics_signal_rw(
+                WatsonMarlow323PumpState,
+                read_pv=prefix + "INFO:RUN",
+                write_pv=prefix + "SET:RUN",
+            )
+            self.speed = epics_signal_rw(
+                float, read_pv=prefix + "INFO:SPD", write_pv=prefix + "SET:SPD"
+            )
+
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.enabled = epics_signal_rw(
+                WatsonMarlow323PumpEnable,
+                prefix + "DISABLE",
+            )
+
+        super().__init__(name=name)

dodal/devices/webcam.py

@@ -5,7 +5,12 @@ from pathlib import Path
 import aiofiles
 from aiohttp import ClientSession
 from bluesky.protocols import Triggerable
-from ophyd_async.core import AsyncStatus, HintedSignal, StandardReadable, soft_signal_rw
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    StandardReadableFormat,
+    soft_signal_rw,
+)
 from PIL import Image
 
 from dodal.log import LOGGER
@@ -27,7 +32,9 @@ class Webcam(StandardReadable, Triggerable):
         self.directory = soft_signal_rw(str, name="directory")
         self.last_saved_path = soft_signal_rw(str, name="last_saved_path")
 
-        self.add_readables([self.last_saved_path], wrapper=HintedSignal)
+        self.add_readables(
+            [self.last_saved_path], format=StandardReadableFormat.HINTED_SIGNAL
+        )
         super().__init__(name=name)
 
     async def _write_image(self, file_path: str, image: ByteString):

dodal/devices/xbpm_feedback.py

@@ -1,11 +1,9 @@
-from enum import Enum
-
 from bluesky.protocols import Triggerable
-from ophyd_async.core import AsyncStatus, Device, observe_value
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+from ophyd_async.core import AsyncStatus, Device, StrictEnum, observe_value
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 
-class Pause(str, Enum):
+class Pause(StrictEnum):
     PAUSE = "Paused"  # 0
     RUN = "Ok to Run"  # 1
 

dodal/devices/xspress3/xspress3.py

@@ -1,15 +1,14 @@
-from enum import Enum
-
 from bluesky.protocols import Stageable
 from numpy import float64
-from numpy.typing import NDArray
 from ophyd_async.core import (
+    Array1D,
     AsyncStatus,
     Device,
     DeviceVector,
+    StrictEnum,
     wait_for_value,
 )
-from ophyd_async.epics.signal import (
+from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,
@@ -23,7 +22,7 @@ from dodal.devices.xspress3.xspress3_channel import (
 from dodal.log import LOGGER
 
 
-class TriggerMode(str, Enum):
+class TriggerMode(StrictEnum):
     SOFTWARE = "Software"
     HARDWARE = "Hardware"
     BURST = "Burst"
@@ -35,17 +34,17 @@ class TriggerMode(str, Enum):
     LVDS_both = "LVDS Both"
 
 
-class UpdateRBV(str, Enum):
+class UpdateRBV(StrictEnum):
     DISABLED = "Disabled"
     ENABLED = "Enabled"
 
 
-class AcquireRBVState(str, Enum):
+class AcquireRBVState(StrictEnum):
     DONE = "Done"
     ACQUIRE = "Acquiring"
 
 
-class DetectorState(str, Enum):
+class DetectorState(StrictEnum):
     IDLE = "Idle"
     ACQUIRE = "Acquire"
     READOUT = "Readout"
@@ -101,7 +100,7 @@ class Xspress3(Device, Stageable):
         """signal for the corrected MCA spectrum (1d array)"""
         self.dt_corrected_latest_mca = DeviceVector(
             {
-                i: epics_signal_r(NDArray[float64], f"{prefix}ARR{i}:ArrayData")
+                i: epics_signal_r(Array1D[float64], f"{prefix}ARR{i}:ArrayData")
                 for i in range(1, num_channels + 1)
             }
         )

dodal/devices/xspress3/xspress3_channel.py

@@ -1,10 +1,8 @@
-from enum import Enum
+from ophyd_async.core import Device, StrictEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from ophyd_async.core import Device
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
-
-class AcquireState(str, Enum):
+class AcquireState(StrictEnum):
     DONE = "Done"
     ACQUIRE = "Acquire"