dls-dodal 1.29.3__py3-none-any.whl → 1.30.0__py3-none-any.whl

dodal/devices/oav/utils.py

@@ -1,19 +1,16 @@
+from collections.abc import Generator
 from enum import IntEnum
-from pathlib import Path
-from typing import Generator, Tuple
 
 import bluesky.plan_stubs as bps
 import numpy as np
 from bluesky.utils import Msg
-from PIL.Image import Image
 
 from dodal.devices.oav.oav_calculations import camera_coordinates_to_xyz
-from dodal.devices.oav.oav_parameters import OAVConfigParams
+from dodal.devices.oav.oav_detector import OAVConfigParams
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
 from dodal.devices.smargon import Smargon
-from dodal.log import LOGGER
 
-Pixel = Tuple[int, int]
+Pixel = tuple[int, int]
 
 
 class PinNotFoundException(Exception):
@@ -110,14 +107,3 @@ def wait_for_tip_to_be_found(
         raise PinNotFoundException(f"No pin found after {timeout} seconds")
 
     return found_tip  # type: ignore
-
-
-def save_thumbnail(full_file_path: Path, full_image: Image, new_height=192):
-    """Scales an image down to have the height specified in new_height and saves it
-    to the same location as the full image with a t appended to the filename"""
-    thumbnail_path = full_file_path.with_stem(full_file_path.stem + "t")
-    LOGGER.info(f"Saving thumbnail to {thumbnail_path}")
-    full_size = full_image.size
-    new_width = (new_height / full_size[1]) * full_size[0]
-    full_image.thumbnail((new_width, new_height))
-    full_image.save(thumbnail_path.as_posix())

dodal/devices/p99/sample_stage.py

@@ -0,0 +1,43 @@
+from enum import Enum
+
+from ophyd_async.core import Device
+from ophyd_async.epics.signal import epics_signal_rw
+
+
+class SampleAngleStage(Device):
+    def __init__(self, prefix: str, name: str):
+        self.theta = epics_signal_rw(
+            float, prefix + "WRITETHETA:RBV", prefix + "WRITETHETA"
+        )
+        self.roll = epics_signal_rw(
+            float, prefix + "WRITEROLL:RBV", prefix + "WRITEROLL"
+        )
+        self.pitch = epics_signal_rw(
+            float, prefix + "WRITEPITCH:RBV", prefix + "WRITEPITCH"
+        )
+        super().__init__(name=name)
+
+
+class p99StageSelections(str, Enum):
+    Empty = "Empty"
+    Mn5um = "Mn 5um"
+    Fe = "Fe (empty)"
+    Co5um = "Co 5um"
+    Ni5um = "Ni 5um"
+    Cu5um = "Cu 5um"
+    Zn5um = "Zn 5um"
+    Zr = "Zr (empty)"
+    Mo = "Mo (empty)"
+    Rh = "Rh (empty)"
+    Pd = "Pd (empty)"
+    Ag = "Ag (empty)"
+    Cd25um = "Cd 25um"
+    W = "W (empty)"
+    Pt = "Pt (empty)"
+    User = "User"
+
+
+class FilterMotor(Device):
+    def __init__(self, prefix: str, name: str):
+        self.user_setpoint = epics_signal_rw(p99StageSelections, prefix)
+        super().__init__(name=name)

dodal/devices/robot.py

@@ -1,5 +1,5 @@
 import asyncio
-from asyncio import FIRST_COMPLETED, Task
+from asyncio import FIRST_COMPLETED, CancelledError, Task
 from dataclasses import dataclass
 from enum import Enum
 
@@ -45,6 +45,9 @@ class BartRobot(StandardReadable, Movable):
     LOAD_TIMEOUT = 60
     NO_PIN_ERROR_CODE = 25
 
+    # How far the gonio position can be out before loading will fail
+    LOAD_TOLERANCE_MM = 0.02
+
     def __init__(
         self,
         name: str,
@@ -74,19 +77,28 @@ class BartRobot(StandardReadable, Movable):
             await wait_for_value(self.error_code, self.NO_PIN_ERROR_CODE, None)
             raise RobotLoadFailed(self.NO_PIN_ERROR_CODE, "Pin was not detected")
 
-        finished, unfinished = await asyncio.wait(
-            [
-                Task(raise_if_no_pin()),
-                Task(
-                    wait_for_value(self.gonio_pin_sensor, PinMounted.PIN_MOUNTED, None)
-                ),
-            ],
-            return_when=FIRST_COMPLETED,
-        )
-        for task in unfinished:
-            task.cancel()
-        for task in finished:
-            await task
+        async def wfv():
+            await wait_for_value(self.gonio_pin_sensor, PinMounted.PIN_MOUNTED, None)
+
+        tasks = [
+            (Task(raise_if_no_pin())),
+            (Task(wfv())),
+        ]
+        try:
+            finished, unfinished = await asyncio.wait(
+                tasks,
+                return_when=FIRST_COMPLETED,
+            )
+            for task in unfinished:
+                task.cancel()
+            for task in finished:
+                await task
+        except CancelledError:
+            # If the outer enclosing task cancels after LOAD_TIMEOUT, this causes CancelledError to be raised
+            # in the current task, when it propagates to here we should cancel all pending tasks before bubbling up
+            for task in tasks:
+                task.cancel()
+            raise
 
     async def _load_pin_and_puck(self, sample_location: SampleLocation):
         LOGGER.info(f"Loading pin {sample_location}")
@@ -108,12 +120,12 @@ class BartRobot(StandardReadable, Movable):
         await self.pin_mounted_or_no_pin_found()
 
     @AsyncStatus.wrap
-    async def set(self, sample_location: SampleLocation):
+    async def set(self, value: SampleLocation):
         try:
             await asyncio.wait_for(
-                self._load_pin_and_puck(sample_location), timeout=self.LOAD_TIMEOUT
+                self._load_pin_and_puck(value), timeout=self.LOAD_TIMEOUT
             )
-        except asyncio.TimeoutError:
+        except asyncio.TimeoutError as e:
             error_code = await self.error_code.get_value()
             error_string = await self.error_str.get_value()
-            raise RobotLoadFailed(error_code, error_string)
+            raise RobotLoadFailed(int(error_code), error_string) from e

dodal/devices/scintillator.py

@@ -1,7 +1,10 @@
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsMotor
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motion import Motor
 
 
-class Scintillator(Device):
-    y = Cpt(EpicsMotor, "-MO-SCIN-01:Y")
-    z = Cpt(EpicsMotor, "-MO-SCIN-01:Z")
+class Scintillator(StandardReadable):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.y = Motor(prefix + "-MO-SCIN-01:Y")
+            self.z = Motor(prefix + "-MO-SCIN-01:Z")
+        super().__init__(name)

dodal/devices/smargon.py

@@ -1,8 +1,8 @@
-from collections.abc import Generator
+from collections.abc import Collection, Generator
 from dataclasses import dataclass
 from enum import Enum
 from math import isclose
-from typing import Collection, cast
+from typing import cast
 
 from bluesky import plan_stubs as bps
 from bluesky.utils import Msg
@@ -87,7 +87,7 @@ class XYZLimits:
     def position_valid(self, pos: Collection[float]) -> bool:
         return all(
             axis_limits.contains(value)
-            for axis_limits, value in zip([self.x, self.y, self.z], pos)
+            for axis_limits, value in zip([self.x, self.y, self.z], pos, strict=False)
         )
 
 

dodal/devices/status.py

@@ -1,41 +1,12 @@
-from typing import Any, TypeVar
+from typing import Any
 
 from ophyd.status import SubscriptionStatus
 
-T = TypeVar("T")
-
 
 def await_value(
-    subscribable: Any, expected_value: T, timeout: None | int = None
+    subscribable: Any, expected_value: object, timeout: None | int = None
 ) -> SubscriptionStatus:
     def value_is(value, **_):
         return value == expected_value
 
     return SubscriptionStatus(subscribable, value_is, timeout=timeout)
-
-
-def await_value_in_list(
-    subscribable: Any, expected_value: list, timeout: None | int = None
-) -> SubscriptionStatus:
-    """Returns a status which is completed when the subscriptable contains a value
-    within the expected_value list"""
-
-    def value_is(value, **_):
-        return value in expected_value
-
-    if not isinstance(expected_value, list):
-        raise TypeError(f"expected value {expected_value} is not a list")
-    else:
-        return SubscriptionStatus(subscribable, value_is, timeout=timeout)
-
-
-def await_approx_value(
-    subscribable: Any,
-    expected_value: T,
-    deadband: float = 1e-09,
-    timeout: None | int = None,
-) -> SubscriptionStatus:
-    def value_is_approx(value, **_):
-        return abs(value - expected_value) <= deadband
-
-    return SubscriptionStatus(subscribable, value_is_approx, timeout=timeout)

dodal/devices/tetramm.py

@@ -1,6 +1,6 @@
 import asyncio
+from collections.abc import Sequence
 from enum import Enum
-from typing import Sequence
 
 from bluesky.protocols import Hints
 from ophyd_async.core import (
@@ -115,7 +115,7 @@ class TetrammController(DetectorControl):
     async def arm(
         self,
         num: int,
-        trigger: DetectorTrigger,
+        trigger: DetectorTrigger = DetectorTrigger.edge_trigger,
         exposure: float | None = None,
     ) -> AsyncStatus:
         if exposure is None:
@@ -132,7 +132,7 @@ class TetrammController(DetectorControl):
             self._drv.averaging_time.set(exposure), self.set_exposure(exposure)
         )
 
-        status = await set_and_wait_for_value(self._drv.acquire, 1)
+        status = await set_and_wait_for_value(self._drv.acquire, True)
 
         return status
 
@@ -150,7 +150,7 @@ class TetrammController(DetectorControl):
             )
 
     async def disarm(self):
-        await stop_busy_record(self._drv.acquire, 0, timeout=1)
+        await stop_busy_record(self._drv.acquire, False, timeout=1)
 
     async def set_exposure(self, exposure: float):
         """Tries to set the exposure time of a single frame.

dodal/devices/thawer.py

@@ -15,7 +15,7 @@ class ThawerStates(str, Enum):
     ON = "On"
 
 
-class ThawingTimer(Device):
+class ThawingTimer(Device, Stoppable):
     def __init__(self, control_signal: SignalRW[ThawerStates]) -> None:
         self._control_signal = control_signal
         self._thawing_task: Task | None = None
@@ -32,7 +32,8 @@ class ThawingTimer(Device):
         finally:
             await self._control_signal.set(ThawerStates.OFF)
 
-    async def stop(self):
+    @AsyncStatus.wrap
+    async def stop(self, *args, **kwargs):
         if self._thawing_task:
             self._thawing_task.cancel()
 
@@ -43,6 +44,7 @@ class Thawer(StandardReadable, Stoppable):
         self.thaw_for_time_s = ThawingTimer(self.control)
         super().__init__(name)
 
-    async def stop(self):
+    @AsyncStatus.wrap
+    async def stop(self, *args, **kwargs):
         await self.thaw_for_time_s.stop()
         await self.control.set(ThawerStates.OFF)

dodal/devices/undulator_dcm.py

@@ -74,14 +74,12 @@ class UndulatorDCM(StandardReadable, Movable):
             daq_configuration_path + "/domain/beamlineParameters"
         )["DCM_Perp_Offset_FIXED"]
 
-    def set(self, value: float) -> AsyncStatus:
-        async def _set():
-            await asyncio.gather(
-                self._set_dcm_energy(value),
-                self._set_undulator_gap_if_required(value),
-            )
-
-        return AsyncStatus(_set())
+    @AsyncStatus.wrap
+    async def set(self, value: float):
+        await asyncio.gather(
+            self._set_dcm_energy(value),
+            self._set_undulator_gap_if_required(value),
+        )
 
     async def _set_dcm_energy(self, energy_kev: float) -> None:
         access_level = await self.undulator.gap_access.get_value()

dodal/devices/util/adjuster_plans.py

@@ -3,10 +3,10 @@ All the methods in this module return a bluesky plan generator that adjusts a va
 according to some criteria either via feedback, preset positions, lookup tables etc.
 """
 
-from typing import Callable, Generator
+from collections.abc import Callable, Generator
 
 from bluesky import plan_stubs as bps
-from bluesky.run_engine import Msg
+from bluesky.utils import Msg
 from ophyd.epics_motor import EpicsMotor
 from ophyd_async.epics.motion import Motor
 

dodal/devices/util/epics_util.py

@@ -1,5 +1,5 @@
+from collections.abc import Callable, Sequence
 from functools import partial
-from typing import Callable
 
 from bluesky.protocols import Movable
 from ophyd import Component, EpicsSignal
@@ -26,7 +26,7 @@ def epics_signal_put_wait(pv_name: str, wait: float = 3.0) -> Component[EpicsSig
 
 
 def run_functions_without_blocking(
-    functions_to_chain: list[Callable[[], StatusBase]],
+    functions_to_chain: Sequence[Callable[[], StatusBase]],
     timeout: float = 60.0,
     associated_obj: OphydDevice | None = None,
 ) -> Status:
@@ -61,9 +61,9 @@ def run_functions_without_blocking(
     # Wrap each function by first checking the previous status and attaching a callback
     # to the next function in the chain
     def wrap_func(
-        old_status: Status, current_func: Callable[[], StatusBase], next_func
+        old_status: Status | None, current_func: Callable[[], StatusBase], next_func
     ):
-        if old_status.exception() is not None:
+        if old_status is not None and old_status.exception() is not None:
             set_global_exception_and_log(old_status)
             return
 
@@ -96,7 +96,7 @@ def run_functions_without_blocking(
     )
 
     # Wrap each function in reverse
-    for num, func in enumerate(list(reversed(functions_to_chain))[1:-1]):
+    for func in list(reversed(functions_to_chain))[1:-1]:
         wrapped_funcs.append(
             partial(
                 wrap_func,
@@ -105,10 +105,8 @@ def run_functions_without_blocking(
             )
         )
 
-    starting_status = Status(done=True, success=True)
-
     # Initiate the chain of functions
-    wrap_func(starting_status, functions_to_chain[0], wrapped_funcs[-1])
+    wrap_func(None, functions_to_chain[0], wrapped_funcs[-1])
     return full_status
 
 

dodal/devices/util/lookup_tables.py

@@ -3,9 +3,8 @@ 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.
 """
 
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from io import StringIO
-from typing import Callable
 
 import aiofiles
 import numpy as np
@@ -36,7 +35,7 @@ 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"""
     LOGGER.info(f"Using lookup table {filename}")
-    s_and_t_vals = zip(*loadtxt(filename, comments=["#", "Units"]))
+    s_and_t_vals = zip(*loadtxt(filename, comments=["#", "Units"]), strict=False)
 
     s_values: Sequence
     t_values: Sequence

dodal/devices/util/save_panda.py

@@ -0,0 +1,87 @@
+import argparse
+import os
+import sys
+from argparse import ArgumentParser
+from pathlib import Path
+from typing import cast
+
+from bluesky.run_engine import RunEngine
+from ophyd_async.core import Device, save_device
+from ophyd_async.panda import phase_sorter
+
+from dodal.beamlines import module_name_for_beamline
+from dodal.utils import make_device
+
+
+def main(argv: list[str]):
+    """CLI Utility to save the panda configuration."""
+    parser = ArgumentParser(description="Save an ophyd_async panda to yaml")
+    parser.add_argument(
+        "--beamline", help="beamline to save from e.g. i03. Defaults to BEAMLINE"
+    )
+    parser.add_argument(
+        "--device-name",
+        help='name of the device. The default is "panda"',
+        default="panda",
+    )
+    parser.add_argument(
+        "-f",
+        "--force",
+        action=argparse.BooleanOptionalAction,
+        help="Force overwriting an existing file",
+    )
+    parser.add_argument("output_file", help="output filename")
+
+    # this exit()s with message/help unless args parsed successfully
+    args = parser.parse_args(argv[1:])
+
+    beamline = args.beamline
+    device_name = args.device_name
+    output_file = args.output_file
+    force = args.force
+
+    if beamline:
+        os.environ["BEAMLINE"] = beamline
+    else:
+        beamline = os.environ.get("BEAMLINE", None)
+
+    if not beamline:
+        sys.stderr.write("BEAMLINE not set and --beamline not specified\n")
+        return 1
+
+    if Path(output_file).exists() and not force:
+        sys.stderr.write(
+            f"Output file {output_file} already exists and --force not specified."
+        )
+        return 1
+
+    _save_panda(beamline, device_name, output_file)
+
+    print("Done.")
+    return 0
+
+
+def _save_panda(beamline, device_name, output_file):
+    RE = RunEngine()
+    print("Creating devices...")
+    module_name = module_name_for_beamline(beamline)
+    try:
+        devices = make_device(f"dodal.beamlines.{module_name}", device_name)
+    except Exception as error:
+        sys.stderr.write(f"Couldn't create device {device_name}: {error}\n")
+        sys.exit(1)
+
+    panda = devices[device_name]
+    print(f"Saving to {output_file} from {device_name} on {beamline}...")
+    _save_panda_to_file(RE, cast(Device, panda), output_file)
+
+
+def _save_panda_to_file(RE: RunEngine, panda: Device, path: str):
+    def save_to_file():
+        yield from save_device(panda, path, sorter=phase_sorter)
+
+    RE(save_to_file())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main(sys.argv))

dodal/devices/util/test_utils.py

@@ -0,0 +1,17 @@
+from ophyd_async.core import (
+    callback_on_mock_put,
+    set_mock_value,
+)
+from ophyd_async.epics.motion import Motor
+
+
+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)
+    return callback_on_mock_put(
+        motor.user_setpoint,
+        lambda pos, *args, **kwargs: set_mock_value(motor.user_readback, pos),
+    )

dodal/devices/webcam.py

@@ -1,13 +1,10 @@
-import io
 from pathlib import Path
 
 import aiofiles
 from aiohttp import ClientSession
 from bluesky.protocols import Triggerable
-from ophyd_async.core import AsyncStatus, StandardReadable, soft_signal_rw
-from PIL import Image
+from ophyd_async.core import AsyncStatus, HintedSignal, StandardReadable, soft_signal_rw
 
-from dodal.devices.oav.utils import save_thumbnail
 from dodal.log import LOGGER
 
 
@@ -18,7 +15,7 @@ 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.set_readable_signals([self.last_saved_path])
+        self.add_readables([self.last_saved_path], wrapper=HintedSignal)
         super().__init__(name=name)
 
     async def _write_image(self, file_path: str):
@@ -26,10 +23,8 @@ class Webcam(StandardReadable, Triggerable):
             async with session.get(self.url) as response:
                 response.raise_for_status()
                 LOGGER.info(f"Saving webcam image from {self.url} to {file_path}")
-                data = await response.read()
                 async with aiofiles.open(file_path, "wb") as file:
-                    await file.write(data)
-                save_thumbnail(Path(file_path), Image.open(io.BytesIO(data)))
+                    await file.write(await response.read())
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:

dodal/devices/xbpm_feedback.py

@@ -1,9 +1,6 @@
 from enum import Enum
 
-import ophyd
 from bluesky.protocols import Triggerable
-from ophyd import Component, EpicsSignal, EpicsSignalRO
-from ophyd.status import StatusBase, SubscriptionStatus
 from ophyd_async.core import Device, observe_value
 from ophyd_async.core.async_status import AsyncStatus
 from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
@@ -31,23 +28,3 @@ class XBPMFeedback(Device, Triggerable):
         async for value in observe_value(self.pos_stable):
             if value:
                 return
-
-
-class XBPMFeedbackI04(ophyd.Device):
-    """The I04 version of this device has a slightly different trigger method"""
-
-    # Values to set to pause_feedback
-    PAUSE = 0
-    RUN = 1
-
-    pos_ok = Component(EpicsSignalRO, "-EA-FDBK-01:XBPM2POSITION_OK")
-    pause_feedback = Component(EpicsSignal, "-EA-FDBK-01:FB_PAUSE")
-    x = Component(EpicsSignalRO, "-EA-XBPM-02:PosX:MeanValue_RBV")
-    y = Component(EpicsSignalRO, "-EA-XBPM-02:PosY:MeanValue_RBV")
-
-    def trigger(self) -> StatusBase:
-        return SubscriptionStatus(
-            self.pos_ok,
-            lambda *, old_value, value, **kwargs: value == 1,
-            timeout=60,
-        )

dodal/devices/zebra.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import asyncio
 from enum import Enum
 from functools import partialmethod
-from typing import List
 
 from ophyd_async.core import (
     AsyncStatus,
@@ -95,7 +94,7 @@ class ArmingDevice(StandardReadable):
     """A useful device that can abstract some of the logic of arming.
     Allows a user to just call arm.set(ArmDemand.ARM)"""
 
-    TIMEOUT = 3
+    TIMEOUT: float = 3
 
     def __init__(self, prefix: str, name: str = "") -> None:
         self.arm_set = epics_signal_rw(float, prefix + "PC_ARM")
@@ -110,10 +109,9 @@ class ArmingDevice(StandardReadable):
             if reading == demand.value:
                 return
 
-    def set(self, demand: ArmDemand) -> AsyncStatus:
-        return AsyncStatus(
-            asyncio.wait_for(self._set_armed(demand), timeout=self.TIMEOUT)
-        )
+    @AsyncStatus.wrap
+    async def set(self, demand: ArmDemand):
+        await asyncio.wait_for(self._set_armed(demand), timeout=self.TIMEOUT)
 
 
 class PositionCompare(StandardReadable):
@@ -166,7 +164,7 @@ class ZebraOutputPanel(StandardReadable):
         super().__init__(name)
 
 
-def boolean_array_to_integer(values: List[bool]) -> int:
+def boolean_array_to_integer(values: list[bool]) -> int:
     """Converts a boolean array to integer by interpretting it in binary with LSB 0 bit
     numbering.
 
@@ -245,8 +243,8 @@ class LogicGateConfiguration:
     NUMBER_OF_INPUTS = 4
 
     def __init__(self, input_source: int, invert: bool = False) -> None:
-        self.sources: List[int] = []
-        self.invert: List[bool] = []
+        self.sources: list[int] = []
+        self.invert: list[bool] = []
         self.add_input(input_source, invert)
 
     def add_input(
@@ -271,7 +269,9 @@ class LogicGateConfiguration:
 
     def __str__(self) -> str:
         input_strings = []
-        for input, (source, invert) in enumerate(zip(self.sources, self.invert)):
+        for input, (source, invert) in enumerate(
+            zip(self.sources, self.invert, strict=False)
+        ):
             input_strings.append(f"INP{input+1}={'!' if invert else ''}{source}")
 
         return ", ".join(input_strings)

dodal/devices/zebra_controlled_shutter.py

@@ -29,10 +29,10 @@ class ZebraShutter(StandardReadable, Movable):
         super().__init__(name=name)
 
     @AsyncStatus.wrap
-    async def set(self, desired_position: ZebraShutterState):
-        await self.position_setpoint.set(desired_position)
+    async def set(self, value: ZebraShutterState):
+        await self.position_setpoint.set(value)
         return await wait_for_value(
             signal=self.position_readback,
-            match=desired_position,
+            match=value,
             timeout=DEFAULT_TIMEOUT,
         )