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

dodal/devices/i22/dcm.py

@@ -6,7 +6,7 @@ from typing import Literal
 from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
 from ophyd_async.core import ConfigSignal, StandardReadable, soft_signal_r_and_setter
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.signal import epics_signal_r
 
 # Conversion constant for energy and wavelength, taken from the X-Ray data booklet

dodal/devices/i22/fswitch.py

@@ -4,8 +4,12 @@ from enum import Enum
 
 from bluesky.protocols import Reading
 from event_model import DataKey
-from ophyd_async.core import ConfigSignal, StandardReadable, soft_signal_r_and_setter
-from ophyd_async.core.device import DeviceVector
+from ophyd_async.core import (
+    ConfigSignal,
+    DeviceVector,
+    StandardReadable,
+    soft_signal_r_and_setter,
+)
 from ophyd_async.epics.signal import epics_signal_r
 
 

dodal/devices/i22/nxsas.py

@@ -1,12 +1,33 @@
+import asyncio
+from collections.abc import Awaitable, Iterable
 from dataclasses import dataclass, fields
+from typing import TypeVar
 
 from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
-from ophyd_async.core import DirectoryProvider, merge_gathered_dicts
-from ophyd_async.epics.areadetector import AravisDetector, PilatusDetector
-from ophyd_async.epics.areadetector.aravis import AravisController
+from ophyd_async.core import PathProvider
+from ophyd_async.epics.adaravis import AravisController, AravisDetector
+from ophyd_async.epics.adpilatus import PilatusDetector
 
 ValueAndUnits = tuple[float, str]
+T = TypeVar("T")
+
+
+# TODO: Remove this file as part of github.com/DiamondLightSource/dodal/issues/595
+# Until which, temporarily duplicated non-public method from ophyd_async
+async def _merge_gathered_dicts(
+    coros: Iterable[Awaitable[dict[str, T]]],
+) -> dict[str, T]:
+    """Merge dictionaries produced by a sequence of coroutines.
+
+    Can be used for merging ``read()`` or ``describe``. For instance::
+
+        combined_read = await merge_gathered_dicts(s.read() for s in signals)
+    """
+    ret: dict[str, T] = {}
+    for result in await asyncio.gather(*coros):
+        ret.update(result)
+    return ret
 
 
 @dataclass
@@ -80,7 +101,7 @@ class NXSasPilatus(PilatusDetector):
     def __init__(
         self,
         prefix: str,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         drv_suffix: str,
         hdf_suffix: str,
         metadata_holder: NXSasMetadataHolder,
@@ -93,7 +114,7 @@ class NXSasPilatus(PilatusDetector):
         Writes hdf5 files."""
         super().__init__(
             prefix,
-            directory_provider,
+            path_provider,
             drv_suffix=drv_suffix,
             hdf_suffix=hdf_suffix,
             name=name,
@@ -101,7 +122,7 @@ class NXSasPilatus(PilatusDetector):
         self._metadata_holder = metadata_holder
 
     async def read_configuration(self) -> dict[str, Reading]:
-        return await merge_gathered_dicts(
+        return await _merge_gathered_dicts(
             r
             for r in (
                 super().read_configuration(),
@@ -110,7 +131,7 @@ class NXSasPilatus(PilatusDetector):
         )
 
     async def describe_configuration(self) -> dict[str, DataKey]:
-        return await merge_gathered_dicts(
+        return await _merge_gathered_dicts(
             r
             for r in (
                 super().describe_configuration(),
@@ -123,7 +144,7 @@ class NXSasOAV(AravisDetector):
     def __init__(
         self,
         prefix: str,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         drv_suffix: str,
         hdf_suffix: str,
         metadata_holder: NXSasMetadataHolder,
@@ -137,7 +158,7 @@ class NXSasOAV(AravisDetector):
         Writes hdf5 files."""
         super().__init__(
             prefix,
-            directory_provider,
+            path_provider,
             drv_suffix=drv_suffix,
             hdf_suffix=hdf_suffix,
             name=name,
@@ -146,7 +167,7 @@ class NXSasOAV(AravisDetector):
         self._metadata_holder = metadata_holder
 
     async def read_configuration(self) -> dict[str, Reading]:
-        return await merge_gathered_dicts(
+        return await _merge_gathered_dicts(
             r
             for r in (
                 super().read_configuration(),
@@ -155,7 +176,7 @@ class NXSasOAV(AravisDetector):
         )
 
     async def describe_configuration(self) -> dict[str, DataKey]:
-        return await merge_gathered_dicts(
+        return await _merge_gathered_dicts(
             r
             for r in (
                 super().describe_configuration(),

dodal/devices/i24/aperture.py

@@ -1,7 +1,7 @@
 from enum import Enum
 
 from ophyd_async.core import StandardReadable
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.signal import epics_signal_rw
 
 

dodal/devices/i24/beamstop.py

@@ -1,7 +1,7 @@
 from enum import Enum
 
 from ophyd_async.core import StandardReadable
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.signal import epics_signal_rw
 
 

dodal/devices/i24/dcm.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import StandardReadable
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.signal import epics_signal_r
 
 

dodal/devices/i24/i24_detector_motion.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import StandardReadable
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 
 
 class DetectorMotion(StandardReadable):

dodal/devices/i24/pmac.py

@@ -2,12 +2,18 @@ from enum import Enum, IntEnum
 from typing import SupportsFloat
 
 from bluesky.protocols import Triggerable
-from ophyd_async.core import AsyncStatus, StandardReadable, wait_for_value
-from ophyd_async.core.signal import CalculateTimeout, SignalR, SignalRW
-from ophyd_async.core.signal_backend import SignalBackend
-from ophyd_async.core.soft_signal_backend import SoftSignalBackend
-from ophyd_async.core.utils import DEFAULT_TIMEOUT
-from ophyd_async.epics.motion import Motor
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    CalculateTimeout,
+    SignalBackend,
+    SignalR,
+    SignalRW,
+    SoftSignalBackend,
+    StandardReadable,
+    wait_for_value,
+)
+from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
 HOME_STR = r"\#1hmz\#2hmz\#3hmz"  # Command to home the PMAC motors
@@ -79,7 +85,12 @@ class PMACStringLaser(SignalRW):
         super().__init__(backend, timeout, name)
 
     @AsyncStatus.wrap
-    async def set(self, value: LaserSettings, wait=True, timeout=CalculateTimeout):
+    async def set(
+        self,
+        value: LaserSettings,
+        wait=True,
+        timeout=CalculateTimeout,
+    ):
         await self.signal.set(value.value, wait, timeout)
 
 
@@ -97,7 +108,12 @@ class PMACStringEncReset(SignalRW):
         super().__init__(backend, timeout, name)
 
     @AsyncStatus.wrap
-    async def set(self, value: EncReset, wait=True, timeout=CalculateTimeout):
+    async def set(
+        self,
+        value: EncReset,
+        wait=True,
+        timeout=CalculateTimeout,
+    ):
         await self.signal.set(value.value, wait, timeout)
 
 

dodal/devices/linkam3.py

@@ -8,9 +8,9 @@ from ophyd_async.core import (
     HintedSignal,
     StandardReadable,
     WatchableAsyncStatus,
+    WatcherUpdate,
     observe_value,
 )
-from ophyd_async.core.utils import WatcherUpdate
 from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
 

dodal/devices/motors.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import Device
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 
 
 class XYZPositioner(Device):

dodal/devices/oav/oav_to_redis_forwarder.py

@@ -2,12 +2,18 @@ import asyncio
 import io
 import pickle
 import uuid
+from collections.abc import Awaitable, Callable
+from datetime import timedelta
 
 import numpy as np
 from aiohttp import ClientResponse, ClientSession
-from bluesky.protocols import Flyable
-from ophyd_async.core import AsyncStatus, StandardReadable
-from ophyd_async.core.signal import soft_signal_r_and_setter
+from bluesky.protocols import Flyable, Stoppable
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    soft_signal_r_and_setter,
+    soft_signal_rw,
+)
 from ophyd_async.epics.signal import epics_signal_r
 from PIL import Image
 from redis.asyncio import StrictRedis
@@ -24,7 +30,7 @@ async def get_next_jpeg(response: ClientResponse) -> bytes:
             return line + await response.content.readuntil(JPEG_STOP_BYTE)
 
 
-class OAVToRedisForwarder(StandardReadable, Flyable):
+class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
     """Forwards OAV image data to redis. To use call:
 
     > bps.kickoff(oav_forwarder)
@@ -33,6 +39,8 @@ class OAVToRedisForwarder(StandardReadable, Flyable):
 
     """
 
+    DATA_EXPIRY_DAYS = 7
+
     def __init__(
         self,
         prefix: str,
@@ -40,7 +48,6 @@ class OAVToRedisForwarder(StandardReadable, Flyable):
         redis_password: str,
         redis_db: int = 0,
         name: str = "",
-        redis_key: str = "test-image",
     ) -> None:
         """Reads image data from the MJPEG stream on an OAV and forwards it into a
         redis database. This is currently only used for murko integration.
@@ -51,9 +58,8 @@ class OAVToRedisForwarder(StandardReadable, Flyable):
             redis_password: str     the password for the redis database
             redis_db: int           which redis database to connect to, defaults to 0
             name: str               the name of this device
-            redis_key: str          the key to store data in, defaults to "test-image"
         """
-        self.stream_url = epics_signal_r(str, f"{prefix}-DI-OAV-01:MJPG:HOST_RBV")
+        self.stream_url = epics_signal_r(str, f"{prefix}MJPG:MJPG_URL_RBV")
 
         with self.add_children_as_readables():
             self.uuid, self.uuid_setter = soft_signal_r_and_setter(str)
@@ -63,7 +69,9 @@ class OAVToRedisForwarder(StandardReadable, Flyable):
             host=redis_host, password=redis_password, db=redis_db
         )
 
-        self.redis_key = redis_key
+        self._stop_flag = False
+
+        self.sample_id = soft_signal_rw(int, initial_value=0)
 
         # The uuid that images are being saved under, this should be monitored for
         # callbacks to correlate the data
@@ -79,22 +87,43 @@ class OAVToRedisForwarder(StandardReadable, Flyable):
         self.uuid_setter(image_uuid := str(uuid.uuid4()))
         img = Image.open(io.BytesIO(jpeg_bytes))
         image_data = pickle.dumps(np.asarray(img))
-        await self.redis_client.hset(self.redis_key, image_uuid, image_data)  # type: ignore
-        LOGGER.debug(f"Sent frame to redis key {self.redis_key} with uuid {image_uuid}")
-
-    async def _stream_to_redis(self):
+        sample_id = str(await self.sample_id.get_value())
+        await self.redis_client.hset(sample_id, image_uuid, image_data)  # type: ignore
+        await self.redis_client.expire(sample_id, timedelta(days=self.DATA_EXPIRY_DAYS))
+        LOGGER.debug(f"Sent frame to redis key {sample_id} with uuid {image_uuid}")
+
+    async def _open_connection_and_do_function(
+        self, function_to_do: Callable[[ClientResponse, str | None], Awaitable]
+    ):
         stream_url = await self.stream_url.get_value()
         async with ClientSession() as session:
             async with session.get(stream_url) as response:
-                while True:
-                    await self._get_frame_and_put_to_redis(response)
-                    await asyncio.sleep(0.01)
+                await function_to_do(response, stream_url)
+
+    async def _stream_to_redis(self, response, _):
+        while not self._stop_flag:
+            await self._get_frame_and_put_to_redis(response)
+            await asyncio.sleep(0.01)
+
+    async def _confirm_mjpg_stream(self, response, stream_url):
+        if response.content_type != "multipart/x-mixed-replace":
+            raise ValueError(f"{stream_url} is not an MJPG stream")
 
     @AsyncStatus.wrap
     async def kickoff(self):
-        self.forwarding_task = asyncio.create_task(self._stream_to_redis())
+        self._stop_flag = False
+        await self._open_connection_and_do_function(self._confirm_mjpg_stream)
+        self.forwarding_task = asyncio.create_task(
+            self._open_connection_and_do_function(self._stream_to_redis)
+        )
 
     @AsyncStatus.wrap
     async def complete(self):
         assert self.forwarding_task, "Device not kicked off"
-        self.forwarding_task.cancel()
+        await self.stop()
+
+    @AsyncStatus.wrap
+    async def stop(self, success=True):
+        if self.forwarding_task:
+            self._stop_flag = True
+            await self.forwarding_task

dodal/devices/robot.py

@@ -10,8 +10,7 @@ from ophyd_async.core import (
     set_and_wait_for_value,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_x
-from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw_rbv, epics_signal_x
 
 from dodal.log import LOGGER
 

dodal/devices/scatterguard.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import StandardReadable
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 
 
 class Scatterguard(StandardReadable):

dodal/devices/scintillator.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import StandardReadable
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 
 
 class Scintillator(StandardReadable):

dodal/devices/slits.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import StandardReadable
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 
 
 class Slits(StandardReadable):

dodal/devices/smargon.py

@@ -7,7 +7,7 @@ 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.motion import Motor
+from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.signal import epics_signal_r
 
 from dodal.devices.util.epics_util import SetWhenEnabled

dodal/devices/tetramm.py

@@ -1,23 +1,24 @@
 import asyncio
-from collections.abc import Sequence
 from enum import Enum
 
 from bluesky.protocols import Hints
 from ophyd_async.core import (
     AsyncStatus,
+    DatasetDescriber,
     DetectorControl,
     DetectorTrigger,
     Device,
-    DirectoryProvider,
-    ShapeProvider,
+    PathProvider,
     StandardDetector,
     set_and_wait_for_value,
     soft_signal_r_and_setter,
 )
-from ophyd_async.epics.areadetector.utils import stop_busy_record
-from ophyd_async.epics.areadetector.writers import HDFWriter, NDFileHDF
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
-from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
+from ophyd_async.epics.adcore import ADHDFWriter, NDFileHDFIO, stop_busy_record
+from ophyd_async.epics.signal import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_rw_rbv,
+)
 
 
 class TetrammRange(str, Enum):
@@ -108,7 +109,7 @@ class TetrammController(DetectorControl):
         self.minimum_values_per_reading = minimum_values_per_reading
         self.readings_per_frame = readings_per_frame
 
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         # 2 internal clock cycles. Best effort approximation
         return 2 / self.base_sample_rate
 
@@ -204,14 +205,17 @@ class TetrammController(DetectorControl):
         )
 
 
-class TetrammShapeProvider(ShapeProvider):
+class TetrammDatasetDescriber(DatasetDescriber):
     max_channels = 11
 
     def __init__(self, controller: TetrammController) -> None:
         self.controller = controller
 
-    async def __call__(self) -> Sequence[int]:
-        return [self.max_channels, self.controller.readings_per_frame]
+    async def np_datatype(self) -> str:
+        return "<f8"  # IEEE 754 double precision floating point
+
+    async def shape(self) -> tuple[int, int]:
+        return (self.max_channels, self.controller.readings_per_frame)
 
 
 # TODO: Support MeanValue signals https://github.com/DiamondLightSource/dodal/issues/337
@@ -219,13 +223,13 @@ class TetrammDetector(StandardDetector):
     def __init__(
         self,
         prefix: str,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         name: str,
         type: str | None = None,
         **scalar_sigs: str,
     ) -> None:
         self.drv = TetrammDriver(prefix + "DRV:")
-        self.hdf = NDFileHDF(prefix + "HDF5:")
+        self.hdf = NDFileHDFIO(prefix + "HDF5:")
         controller = TetrammController(self.drv)
         config_signals = [
             self.drv.values_per_reading,
@@ -239,11 +243,11 @@ class TetrammDetector(StandardDetector):
             self.type = None
         super().__init__(
             controller,
-            HDFWriter(
+            ADHDFWriter(
                 self.hdf,
-                directory_provider,
+                path_provider,
                 lambda: self.name,
-                TetrammShapeProvider(controller),
+                TetrammDatasetDescriber(controller),
                 **scalar_sigs,
             ),
             config_signals,

dodal/devices/training_rig/sample_stage.py

@@ -0,0 +1,10 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class TrainingRigSampleStage(StandardReadable):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "X")
+            self.theta = Motor(prefix + "A")
+        super().__init__(name)

dodal/devices/turbo_slit.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import Device
-from ophyd_async.epics.motion.motor import Motor
+from ophyd_async.epics.motor import Motor
 
 
 class TurboSlit(Device):

dodal/devices/undulator.py

@@ -1,7 +1,7 @@
 from enum import Enum
 
 from ophyd_async.core import ConfigSignal, StandardReadable, soft_signal_r_and_setter
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.signal import epics_signal_r
 
 # The acceptable difference, in mm, between the undulator gap and the DCM

dodal/devices/util/adjuster_plans.py

@@ -8,7 +8,7 @@ from collections.abc import Callable, Generator
 from bluesky import plan_stubs as bps
 from bluesky.utils import Msg
 from ophyd.epics_motor import EpicsMotor
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 
 from dodal.log import LOGGER
 

dodal/devices/util/save_panda.py

@@ -7,7 +7,7 @@ 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 ophyd_async.fastcs.panda import phase_sorter
 
 from dodal.beamlines import module_name_for_beamline
 from dodal.utils import make_device

dodal/devices/util/test_utils.py

@@ -2,7 +2,7 @@ from ophyd_async.core import (
     callback_on_mock_put,
     set_mock_value,
 )
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 
 
 def patch_motor(motor: Motor, initial_position=0):

dodal/devices/xbpm_feedback.py

@@ -1,8 +1,7 @@
 from enum import Enum
 
 from bluesky.protocols import Triggerable
-from ophyd_async.core import Device, observe_value
-from ophyd_async.core.async_status import AsyncStatus
+from ophyd_async.core import AsyncStatus, Device, observe_value
 from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
 

dodal/devices/xspress3/xspress3.py

@@ -9,7 +9,7 @@ from ophyd_async.core import (
     DeviceVector,
     wait_for_value,
 )
-from ophyd_async.epics.signal.signal import (
+from ophyd_async.epics.signal import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,

dodal/devices/zebra.py

@@ -37,6 +37,11 @@ TTL_SHUTTER = 2
 TTL_XSPRESS3 = 3
 TTL_PANDA = 4
 
+# The AND gate that controls the automatic shutter
+AUTO_SHUTTER_GATE = 2
+# The input that triggers the automatic shutter
+AUTO_SHUTTER_INPUT = 1
+
 
 class ArmSource(str, Enum):
     SOFT = "Soft"

dodal/devices/zebra_controlled_shutter.py

@@ -7,7 +7,7 @@ from ophyd_async.core import (
     StandardReadable,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_w
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_w
 
 
 class ZebraShutterState(str, Enum):
@@ -15,22 +15,37 @@ class ZebraShutterState(str, Enum):
     OPEN = "Open"
 
 
+class ZebraShutterControl(str, Enum):
+    MANUAL = "Manual"
+    AUTO = "Auto"
+
+
 class ZebraShutter(StandardReadable, Movable):
+    """The shutter on most MX beamlines is controlled by the zebra.
+
+    Internally in the zebra there are two AND gates, one for manual control and one for
+    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."""
+
     def __init__(self, prefix: str, name: str):
-        self.position_setpoint = epics_signal_w(
-            write_pv=prefix + "CTRL2",
-            datatype=ZebraShutterState,
+        self._manual_position_setpoint = epics_signal_w(
+            ZebraShutterState, prefix + "CTRL2"
         )
+        self.control_mode = epics_signal_rw(ZebraShutterControl, prefix + "CTRL1")
+
         with self.add_children_as_readables():
-            self.position_readback = epics_signal_r(
-                read_pv=prefix + "STA",
-                datatype=ZebraShutterState,
-            )
+            self.position_readback = epics_signal_r(ZebraShutterState, prefix + "STA")
         super().__init__(name=name)
 
     @AsyncStatus.wrap
     async def set(self, value: ZebraShutterState):
-        await self.position_setpoint.set(value)
+        if await self.control_mode.get_value() == ZebraShutterControl.AUTO:
+            raise UserWarning(
+                f"Tried to set shutter to {value.value} but the shutter is in auto mode."
+            )
+        await self._manual_position_setpoint.set(value)
         return await wait_for_value(
             signal=self.position_readback,
             match=value,