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

dodal/devices/i22/nxsas.py

@@ -1,19 +1,39 @@
+import asyncio
+from collections.abc import Awaitable, Iterable
 from dataclasses import dataclass, fields
-from typing import Dict
+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
 class MetadataHolder:
     # TODO: just in case this is useful more widely...
-    async def describe(self, parent_name: str) -> Dict[str, DataKey]:
+    async def describe(self, parent_name: str) -> dict[str, DataKey]:
         def datakey(value) -> DataKey:
             if isinstance(value, tuple):
                 return {"units": value[1], **datakey(value[0])}
@@ -40,8 +60,8 @@ class MetadataHolder:
             if getattr(self, field.name, None) is not None
         }
 
-    async def read(self, parent_name: str) -> Dict[str, Reading]:
-        def reading(value):
+    async def read(self, parent_name: str) -> dict[str, Reading]:
+        def reading(value) -> Reading:
             if isinstance(value, tuple):
                 return reading(value[0])
             return {"timestamp": -1, "value": value}
@@ -81,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,
@@ -94,32 +114,28 @@ class NXSasPilatus(PilatusDetector):
         Writes hdf5 files."""
         super().__init__(
             prefix,
-            directory_provider,
+            path_provider,
             drv_suffix=drv_suffix,
             hdf_suffix=hdf_suffix,
             name=name,
         )
         self._metadata_holder = metadata_holder
 
-    async def read_configuration(self) -> Dict[str, Reading]:
-        return await merge_gathered_dicts(
-            (
-                r
-                for r in (
-                    super().read_configuration(),
-                    self._metadata_holder.read(self.name),
-                )
+    async def read_configuration(self) -> dict[str, Reading]:
+        return await _merge_gathered_dicts(
+            r
+            for r in (
+                super().read_configuration(),
+                self._metadata_holder.read(self.name),
             )
         )
 
-    async def describe_configuration(self) -> Dict[str, DataKey]:
-        return await merge_gathered_dicts(
-            (
-                r
-                for r in (
-                    super().describe_configuration(),
-                    self._metadata_holder.describe(self.name),
-                )
+    async def describe_configuration(self) -> dict[str, DataKey]:
+        return await _merge_gathered_dicts(
+            r
+            for r in (
+                super().describe_configuration(),
+                self._metadata_holder.describe(self.name),
             )
         )
 
@@ -128,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,
@@ -142,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,
@@ -150,24 +166,20 @@ class NXSasOAV(AravisDetector):
         )
         self._metadata_holder = metadata_holder
 
-    async def read_configuration(self) -> Dict[str, Reading]:
-        return await merge_gathered_dicts(
-            (
-                r
-                for r in (
-                    super().read_configuration(),
-                    self._metadata_holder.read(self.name),
-                )
+    async def read_configuration(self) -> dict[str, Reading]:
+        return await _merge_gathered_dicts(
+            r
+            for r in (
+                super().read_configuration(),
+                self._metadata_holder.read(self.name),
             )
         )
 
-    async def describe_configuration(self) -> Dict[str, DataKey]:
-        return await merge_gathered_dicts(
-            (
-                r
-                for r in (
-                    super().describe_configuration(),
-                    self._metadata_holder.describe(self.name),
-                )
+    async def describe_configuration(self) -> dict[str, DataKey]:
+        return await _merge_gathered_dicts(
+            r
+            for r in (
+                super().describe_configuration(),
+                self._metadata_holder.describe(self.name),
             )
         )

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 → 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

@@ -1,18 +1,30 @@
-from enum import Enum
+from enum import Enum, IntEnum
+from typing import SupportsFloat
 
 from bluesky.protocols import Triggerable
-from ophyd_async.core import AsyncStatus, StandardReadable
-from ophyd_async.core.signal import 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
 ZERO_STR = "!x0y0z0"  # Command to blend any ongoing move into new position
 
 
+class ScanState(IntEnum):
+    RUNNING = 1
+    DONE = 0
+
+
 class LaserSettings(str, Enum):
     """PMAC strings to switch laser on and off.
     Note. On the PMAC, M-variables usually have to do with position compare
@@ -73,26 +85,65 @@ class PMACStringLaser(SignalRW):
         super().__init__(backend, timeout, name)
 
     @AsyncStatus.wrap
-    async def set(self, laser_setting: LaserSettings):
-        await self.signal.set(laser_setting.value, wait=True)
+    async def set(
+        self,
+        value: LaserSettings,
+        wait=True,
+        timeout=CalculateTimeout,
+    ):
+        await self.signal.set(value.value, wait, timeout)
 
 
 class PMACStringEncReset(SignalRW):
-    """"""
+    """Set a pmac_string to control the encoder channels in the controller."""
+
+    def __init__(
+        self,
+        pmac_str_sig: SignalRW,
+        backend: SignalBackend,
+        timeout: float | None = DEFAULT_TIMEOUT,
+        name: str = "",
+    ) -> None:
+        self.signal = pmac_str_sig
+        super().__init__(backend, timeout, name)
+
+    @AsyncStatus.wrap
+    async def set(
+        self,
+        value: EncReset,
+        wait=True,
+        timeout=CalculateTimeout,
+    ):
+        await self.signal.set(value.value, wait, timeout)
+
+
+class ProgramRunner(SignalRW):
+    """Trigger the collection by setting the program number on the PMAC string.
+
+    Once the program number has been set, wait for the collection to be complete.
+    This will only be true when the status becomes 0.
+    """
 
     def __init__(
         self,
         pmac_str_sig: SignalRW,
+        status_sig: SignalR,
         backend: SignalBackend,
         timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
         self.signal = pmac_str_sig
+        self.status = status_sig
         super().__init__(backend, timeout, name)
 
     @AsyncStatus.wrap
-    async def set(self, enc_string: EncReset):
-        await self.signal.set(enc_string.value, wait=True)
+    async def set(self, value: int, wait=True, timeout=None):
+        prog_str = f"&2b{value}r"
+        assert isinstance(timeout, SupportsFloat) or (
+            timeout is None
+        ), f"ProgramRunner does not support calculating timeout itself, {timeout=}"
+        await self.signal.set(prog_str, wait=wait)
+        await wait_for_value(self.status, ScanState.DONE, timeout)
 
 
 class PMAC(StandardReadable):
@@ -121,4 +172,8 @@ class PMAC(StandardReadable):
         self.scanstatus = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2401")
         self.counter = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2402")
 
+        self.run_program = ProgramRunner(
+            self.pmac_string, self.scanstatus, backend=SoftSignalBackend(str)
+        )
+
         super().__init__(name)

dodal/devices/ipin.py

@@ -1,8 +1,11 @@
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsSignalRO, Kind
+from ophyd_async.core import HintedSignal, StandardReadable
+from ophyd_async.epics.signal import epics_signal_r
 
 
-class IPin(Device):
+class IPin(StandardReadable):
     """Simple device to get the ipin reading"""
 
-    reading = Cpt(EpicsSignalRO, "I", kind=Kind.hinted)
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables(wrapper=HintedSignal):
+            self.pin_readback = epics_signal_r(float, prefix + "I")
+        super().__init__(name)

dodal/devices/linkam3.py

@@ -1,11 +1,16 @@
 import asyncio
 import time
 from enum import Enum
-from typing import Optional
 
 from bluesky.protocols import Location
-from ophyd_async.core import StandardReadable, WatchableAsyncStatus, observe_value
-from ophyd_async.core.utils import WatcherUpdate
+from ophyd_async.core import (
+    ConfigSignal,
+    HintedSignal,
+    StandardReadable,
+    WatchableAsyncStatus,
+    WatcherUpdate,
+    observe_value,
+)
 from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
 
@@ -57,14 +62,15 @@ class Linkam3(StandardReadable):
         # status is a bitfield stored in a double?
         self.status = epics_signal_r(float, prefix + "STATUS:")
 
-        self.set_readable_signals(
-            read=(self.temp,), config=(self.ramp_rate, self.speed, self.set_point)
+        self.add_readables((self.temp,), wrapper=HintedSignal)
+        self.add_readables(
+            (self.ramp_rate, self.speed, self.set_point), wrapper=ConfigSignal
         )
 
         super().__init__(name=name)
 
     @WatchableAsyncStatus.wrap
-    async def set(self, new_position: float, timeout: Optional[float] = None):
+    async def set(self, new_position: float, timeout: float | None = None):
         # time.monotonic won't go backwards in case of NTP corrections
         start = time.monotonic()
         old_position = await self.set_point.get_value()

dodal/devices/logging_ophyd_device.py

@@ -3,7 +3,7 @@ from ophyd.log import logger as ophyd_logger
 
 
 class InfoLoggingDevice(Device):
-    def wait_for_connection(self, all_signals=False, timeout=2):
+    def wait_for_connection(self, all_signals=False, timeout=2.0):
         class_name = self.__class__.__name__
         ophyd_logger.info(
             f"{class_name} waiting for connection, {'not' if all_signals else ''} waiting for all signals, timeout = {timeout}s.",

dodal/devices/motors.py

@@ -1,10 +1,36 @@
 from ophyd_async.core import Device
-from ophyd_async.epics.motion import Motor
+from ophyd_async.epics.motor import Motor
 
 
 class XYZPositioner(Device):
-    def __init__(self, prefix: str, name: str):
-        self.x = Motor(prefix + "X")
-        self.y = Motor(prefix + "Y")
-        self.z = Motor(prefix + "Z")
-        super().__init__(name)
+    """
+
+    Standard ophyd_async xyz motor stage, by combining 3 Motors,
+    with added infix for extra flexibliy to allow different axes other than x,y,z.
+
+    Parameters
+    ----------
+    prefix:
+        EPICS PV (Common part up to and including :).
+    name:
+        name for the stage.
+    infix:
+        EPICS PV, default is the ["X", "Y", "Z"].
+    Notes
+    -----
+    Example usage::
+        async with DeviceCollector():
+            xyz_stage = XYZPositioner("BLXX-MO-STAGE-XX:")
+    Or::
+        with DeviceCollector():
+            xyz_stage = XYZPositioner("BLXX-MO-STAGE-XX:", suffix = ["A", "B", "C"])
+
+    """
+
+    def __init__(self, prefix: str, name: str, infix: list[str] | None = None):
+        if infix is None:
+            infix = ["X", "Y", "Z"]
+        self.x = Motor(prefix + infix[0])
+        self.y = Motor(prefix + infix[1])
+        self.z = Motor(prefix + infix[2])
+        super().__init__(name=name)

dodal/devices/oav/grid_overlay.py

@@ -1,3 +1,4 @@
+# type: ignore # OAV will soon be ophyd-async, see https://github.com/DiamondLightSource/dodal/issues/716
 from enum import Enum
 from functools import partial
 from os.path import join as path_join

dodal/devices/oav/microns_for_zoom_levels.json

@@ -52,4 +52,4 @@
         "micronsPerXPixel": 0.227,
         "micronsPerYPixel": 0.314
     }
-}
+}

dodal/devices/oav/oav_detector.py

@@ -1,3 +1,4 @@
+# type: ignore # OAV will soon be ophyd-async, see https://github.com/DiamondLightSource/dodal/issues/716
 from functools import partial
 
 from ophyd import ADComponent as ADC
@@ -46,7 +47,7 @@ class ZoomController(Device):
     sxst = Component(EpicsSignal, "MP:SELECT.SXST")
 
     def set_flatfield_on_zoom_level_one(self, value):
-        self.parent: "OAV"
+        self.parent: OAV
         flat_applied = self.parent.proc.port_name.get()
         no_flat_applied = self.parent.cam.port_name.get()
         return self.parent.grid_snapshot.input_plugin.set(

dodal/devices/oav/oav_parameters.py

@@ -1,7 +1,8 @@
 import json
-import xml.etree.cElementTree as et
+import xml.etree.ElementTree as et
 from collections import ChainMap
-from typing import Any, Tuple
+from typing import Any
+from xml.etree.ElementTree import Element
 
 from dodal.devices.oav.oav_errors import (
     OAVError_BeamPositionNotFound,
@@ -20,6 +21,13 @@ OAV_CONFIG_JSON = (
 )
 
 
+def _get_element_as_float(node: Element, element_name: str) -> float:
+    element = node.find(element_name)
+    assert element is not None, f"{element_name} not found in {node}"
+    assert element.text
+    return float(element.text)
+
+
 class OAVParameters:
     """
     The parameters to set up the OAV depending on the context.
@@ -65,11 +73,11 @@ class OAVParameters:
             try:
                 param = param_type(param)
                 return param
-            except AssertionError:
+            except AssertionError as e:
                 raise TypeError(
                     f"OAV param {name} from the OAV centring params json file has the "
                     f"wrong type, should be {param_type} but is {type(param)}."
-                )
+                ) from e
 
         self.exposure: float = update("exposure", float)
         self.acquire_period: float = update("acqPeriod", float)
@@ -134,14 +142,14 @@ class OAVConfigParams:
         root = tree.getroot()
         levels = root.findall(".//zoomLevel")
         for node in levels:
-            if float(node.find("level").text) == zoom:
+            if _get_element_as_float(node, "level") == zoom:
                 self.micronsPerXPixel = (
-                    float(node.find("micronsPerXPixel").text)
+                    _get_element_as_float(node, "micronsPerXPixel")
                     * DEFAULT_OAV_WINDOW[0]
                     / xsize
                 )
                 self.micronsPerYPixel = (
-                    float(node.find("micronsPerYPixel").text)
+                    _get_element_as_float(node, "micronsPerYPixel")
                     * DEFAULT_OAV_WINDOW[1]
                     / ysize
                 )
@@ -155,7 +163,7 @@ class OAVConfigParams:
 
     def get_beam_position_from_zoom(
         self, zoom: float, xsize: int, ysize: int
-    ) -> Tuple[int, int]:
+    ) -> tuple[int, int]:
         """
         Extracts the beam location in pixels `xCentre` `yCentre`, for a requested zoom \
         level. The beam location is manually inputted by the beamline operator on GDA \
@@ -164,7 +172,7 @@ class OAVConfigParams:
         """
         crosshair_x_line = None
         crosshair_y_line = None
-        with open(self.display_config, "r") as f:
+        with open(self.display_config) as f:
             file_lines = f.readlines()
             for i in range(len(file_lines)):
                 if file_lines[i].startswith("zoomLevel = " + str(zoom)):
@@ -188,7 +196,7 @@ class OAVConfigParams:
 
     def calculate_beam_distance(
         self, horizontal_pixels: int, vertical_pixels: int
-    ) -> Tuple[int, int]:
+    ) -> tuple[int, int]:
         """
         Calculates the distance between the beam centre and the given (horizontal, vertical).
 

dodal/devices/oav/oav_to_redis_forwarder.py

@@ -0,0 +1,129 @@
+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, 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
+
+from dodal.log import LOGGER
+
+
+async def get_next_jpeg(response: ClientResponse) -> bytes:
+    JPEG_START_BYTE = b"\xff\xd8"
+    JPEG_STOP_BYTE = b"\xff\xd9"
+    while True:
+        line = await response.content.readline()
+        if line.startswith(JPEG_START_BYTE):
+            return line + await response.content.readuntil(JPEG_STOP_BYTE)
+
+
+class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
+    """Forwards OAV image data to redis. To use call:
+
+    > bps.kickoff(oav_forwarder)
+    > bps.monitor(oav_forwarder.uuid)
+    > bps.complete(oav_forwarder)
+
+    """
+
+    DATA_EXPIRY_DAYS = 7
+
+    def __init__(
+        self,
+        prefix: str,
+        redis_host: str,
+        redis_password: str,
+        redis_db: int = 0,
+        name: str = "",
+    ) -> 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.
+
+        Arguments:
+            prefix: str             the PV prefix of the OAV
+            redis_host: str         the host where the redis database is running
+            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
+        """
+        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)
+
+        self.forwarding_task = None
+        self.redis_client = StrictRedis(
+            host=redis_host, password=redis_password, db=redis_db
+        )
+
+        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
+        self.uuid, self.uuid_setter = soft_signal_r_and_setter(str)
+
+        super().__init__(name=name)
+
+    async def _get_frame_and_put_to_redis(self, response: ClientResponse):
+        """Converts the data that comes in as a jpeg byte stream into a numpy array of
+        RGB values, pickles this array then writes it to redis.
+        """
+        jpeg_bytes = await get_next_jpeg(response)
+        self.uuid_setter(image_uuid := str(uuid.uuid4()))
+        img = Image.open(io.BytesIO(jpeg_bytes))
+        image_data = pickle.dumps(np.asarray(img))
+        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:
+                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._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"
+        await self.stop()
+
+    @AsyncStatus.wrap
+    async def stop(self, success=True):
+        if self.forwarding_task:
+            self._stop_flag = True
+            await self.forwarding_task