dls-dodal 1.32.0__py3-none-any.whl → 1.34.1__py3-none-any.whl

dodal/devices/areadetector/plugins/MJPG.py

@@ -1,138 +1,83 @@
-import os
-import threading
 from abc import ABC, abstractmethod
 from io import BytesIO
 from pathlib import Path
 
-import requests
-from ophyd import Component, Device, DeviceStatus, EpicsSignal, EpicsSignalRO, Signal
-from PIL import Image, ImageDraw
+import aiofiles
+from aiohttp import ClientSession
+from bluesky.protocols import Triggerable
+from ophyd_async.core import AsyncStatus, StandardReadable, soft_signal_rw
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+from PIL import Image
 
-from dodal.devices.oav.oav_parameters import OAVConfigParams
 from dodal.log import LOGGER
 
+IMG_FORMAT = "png"
 
-class MJPG(Device, ABC):
+
+async def asyncio_save_image(image: Image.Image, path: str):
+    buffer = BytesIO()
+    image.save(buffer, format=IMG_FORMAT)
+    async with aiofiles.open(path, "wb") as fh:
+        await fh.write(buffer.getbuffer())
+
+
+class MJPG(StandardReadable, Triggerable, ABC):
     """The MJPG areadetector plugin creates an MJPG video stream of the camera's output.
 
     This devices uses that stream to grab images. When it is triggered it will send the
     latest image from the stream to the `post_processing` method for child classes to handle.
     """
 
-    filename = Component(Signal)
-    directory = Component(Signal)
-    last_saved_path = Component(Signal)
-    url = Component(EpicsSignal, "JPG_URL_RBV", string=True)
-    x_size = Component(EpicsSignalRO, "ArraySize1_RBV")
-    y_size = Component(EpicsSignalRO, "ArraySize2_RBV")
-    input_rbpv = Component(EpicsSignalRO, "NDArrayPort_RBV")
-    input_plugin = Component(EpicsSignal, "NDArrayPort")
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.url = epics_signal_rw(str, prefix + "JPG_URL_RBV")
 
-    # scaling factors for the snapshot at the time it was triggered
-    microns_per_pixel_x = Component(Signal)
-    microns_per_pixel_y = Component(Signal)
+        self.x_size = epics_signal_r(int, prefix + "ArraySize1_RBV")
+        self.y_size = epics_signal_r(int, prefix + "ArraySize2_RBV")
 
-    oav_params: OAVConfigParams | None = None
+        with self.add_children_as_readables():
+            self.filename = soft_signal_rw(str)
+            self.directory = soft_signal_rw(str)
+            self.last_saved_path = soft_signal_rw(str)
 
-    KICKOFF_TIMEOUT: float = 30.0
+        self.KICKOFF_TIMEOUT = 30.0
 
-    def _save_image(self, image: Image.Image):
-        """A helper function to save a given image to the path supplied by the directory
-        and filename signals. The full resultant path is put on the last_saved_path signal
+        super().__init__(name)
+
+    async def _save_image(self, image: Image.Image):
+        """A helper function to save a given image to the path supplied by the \
+            directory and filename signals. The full resultant path is put on the \
+            last_saved_path signal
         """
-        filename_str = self.filename.get()
-        directory_str: str = self.directory.get()  # type: ignore
+        filename_str = await self.filename.get_value()
+        directory_str = await self.directory.get_value()
 
-        path = Path(f"{directory_str}/{filename_str}.png").as_posix()
-        if not os.path.isdir(Path(directory_str)):
+        path = Path(f"{directory_str}/{filename_str}.{IMG_FORMAT}").as_posix()
+        if not Path(directory_str).is_dir():
             LOGGER.info(f"Snapshot folder {directory_str} does not exist, creating...")
-            os.mkdir(directory_str)
+            Path(directory_str).mkdir(parents=True)
 
         LOGGER.info(f"Saving image to {path}")
-        image.save(path)
-        self.last_saved_path.put(path)
 
-    def trigger(self):
+        await asyncio_save_image(image, path)
+
+        await self.last_saved_path.set(path, wait=True)
+
+    @AsyncStatus.wrap
+    async def trigger(self):
         """This takes a snapshot image from the MJPG stream and send it to the
         post_processing method, expected to be implemented by a child of this class.
 
-        It is the responsibility of the child class to save any resulting images.
+        It is the responsibility of the child class to save any resulting images by \
+        calling _save_image.
         """
-        st = DeviceStatus(device=self, timeout=self.KICKOFF_TIMEOUT)
-        url_str = self.url.get()
+        url_str = await self.url.get_value()
 
-        assert isinstance(
-            self.oav_params, OAVConfigParams
-        ), "MJPG does not have valid OAV parameters"
-        self.microns_per_pixel_x.set(self.oav_params.micronsPerXPixel)
-        self.microns_per_pixel_y.set(self.oav_params.micronsPerYPixel)
-
-        def get_snapshot():
-            try:
-                response = requests.get(url_str, stream=True)
-                response.raise_for_status()
-                with Image.open(BytesIO(response.content)) as image:
-                    self.post_processing(image)
-                    st.set_finished()
-            except requests.HTTPError as e:
-                st.set_exception(e)
-
-        threading.Thread(target=get_snapshot, daemon=True).start()
-
-        return st
+        async with ClientSession(raise_for_status=True) as session:
+            async with session.get(url_str) as response:
+                data = await response.read()
+                with Image.open(BytesIO(data)) as image:
+                    await self.post_processing(image)
 
     @abstractmethod
-    def post_processing(self, image: Image.Image):
+    async def post_processing(self, image: Image.Image):
         pass
-
-
-class SnapshotWithBeamCentre(MJPG):
-    """A child of MJPG which, when triggered, draws an outlined crosshair at the beam
-    centre in the image and saves the image to disk."""
-
-    CROSSHAIR_LENGTH_PX = 20
-    CROSSHAIR_OUTLINE_COLOUR = "Black"
-    CROSSHAIR_FILL_COLOUR = "White"
-
-    def post_processing(self, image: Image.Image):
-        assert (
-            self.oav_params is not None
-        ), "Snapshot device does not have valid OAV parameters"
-        beam_x = self.oav_params.beam_centre_i
-        beam_y = self.oav_params.beam_centre_j
-
-        SnapshotWithBeamCentre.draw_crosshair(image, beam_x, beam_y)
-
-        self._save_image(image)
-
-    @classmethod
-    def draw_crosshair(cls, image: Image.Image, beam_x: int, beam_y: int):
-        draw = ImageDraw.Draw(image)
-        OUTLINE_WIDTH = 1
-        HALF_LEN = cls.CROSSHAIR_LENGTH_PX / 2
-        draw.rectangle(
-            [
-                beam_x - OUTLINE_WIDTH,
-                beam_y - HALF_LEN - OUTLINE_WIDTH,
-                beam_x + OUTLINE_WIDTH,
-                beam_y + HALF_LEN + OUTLINE_WIDTH,
-            ],
-            fill=cls.CROSSHAIR_OUTLINE_COLOUR,
-        )
-        draw.rectangle(
-            [
-                beam_x - HALF_LEN - OUTLINE_WIDTH,
-                beam_y - OUTLINE_WIDTH,
-                beam_x + HALF_LEN + OUTLINE_WIDTH,
-                beam_y + OUTLINE_WIDTH,
-            ],
-            fill=cls.CROSSHAIR_OUTLINE_COLOUR,
-        )
-        draw.line(
-            ((beam_x, beam_y - HALF_LEN), (beam_x, beam_y + HALF_LEN)),
-            fill=cls.CROSSHAIR_FILL_COLOUR,
-        )
-        draw.line(
-            ((beam_x - HALF_LEN, beam_y), (beam_x + HALF_LEN, beam_y)),
-            fill=cls.CROSSHAIR_FILL_COLOUR,
-        )

dodal/devices/backlight.py

@@ -1,6 +1,7 @@
 from asyncio import sleep
 from enum import Enum
 
+from bluesky.protocols import Movable
 from ophyd_async.core import AsyncStatus, StandardReadable
 from ophyd_async.epics.signal import epics_signal_rw
 
@@ -15,10 +16,10 @@ class BacklightPosition(str, Enum):
     OUT = "Out"
 
 
-class Backlight(StandardReadable):
+class Backlight(StandardReadable, Movable):
     """Simple device to trigger the pneumatic in/out."""
 
-    TIME_TO_MOVE_S = 1  # Tested using a stopwatch on the beamline 09/2024
+    TIME_TO_MOVE_S = 1.0  # Tested using a stopwatch on the beamline 09/2024
 
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
@@ -29,7 +30,7 @@ class Backlight(StandardReadable):
         super().__init__(name)
 
     @AsyncStatus.wrap
-    async def set(self, position: BacklightPosition):
+    async def set(self, value: BacklightPosition):
         """This setter will turn the backlight on when we move it in to the beam and off
         when we move it out.
 
@@ -38,10 +39,10 @@ class Backlight(StandardReadable):
         to move completely in/out so we sleep here to simulate this.
         """
         old_position = await self.position.get_value()
-        await self.position.set(position)
-        if position == BacklightPosition.OUT:
+        await self.position.set(value)
+        if value == BacklightPosition.OUT:
             await self.power.set(BacklightPower.OFF)
         else:
             await self.power.set(BacklightPower.ON)
-        if old_position != position:
+        if old_position != value:
             await sleep(self.TIME_TO_MOVE_S)

dodal/devices/diamond_filter.py

@@ -0,0 +1,47 @@
+from enum import Enum
+from typing import Generic, TypeVar
+
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+from ophyd_async.epics.signal import epics_signal_rw
+
+
+class _Filters(str, Enum):
+    pass
+
+
+class I03Filters(_Filters):
+    EMPTY = "Empty"
+    TWO_HUNDRED = "200um"
+    ONE_HUNDRED = "100um"
+
+
+class I04Filters(_Filters):
+    EMPTY = "Empty"
+    TWO_HUNDRED = "200um"
+    FIFTY = "50um"
+    OUT = "Out"
+
+
+T = TypeVar("T", bound=_Filters)
+
+
+class DiamondFilter(StandardReadable, Generic[T]):
+    """
+    A filter set that is used to reduce the heat load on the monochromator.
+
+    It has 4 slots that can contain filters of different thickness. Changing the thickness
+    signal will move the filter set to select this filter.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        data_type: type[T],
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables():
+            self.y_motor = Motor(prefix + "Y")
+            self.thickness = epics_signal_rw(data_type, f"{prefix}Y:MP:SELECT")
+
+        super().__init__(name)

dodal/devices/eiger.py

@@ -81,7 +81,9 @@ class EigerDetector(Device):
 
     def async_stage(self):
         self.odin.nodes.clear_odin_errors()
-        status_ok, error_message = self.odin.check_odin_initialised()
+        status_ok, error_message = self.odin.wait_for_odin_initialised(
+            self.GENERAL_STATUS_TIMEOUT
+        )
         if not status_ok:
             raise Exception(f"Odin not initialised: {error_message}")
 
@@ -129,7 +131,9 @@ class EigerDetector(Device):
             LOGGER.info("Disarming detector")
         finally:
             self.disarm_detector()
-            status_ok = self.odin.check_odin_state()
+            status_ok = self.odin.check_and_wait_for_odin_state(
+                self.GENERAL_STATUS_TIMEOUT
+            )
             self.disable_roi_mode()
         return status_ok
 

dodal/devices/eiger_odin.py

@@ -1,8 +1,10 @@
 # type: ignore # Eiger will soon be ophyd-async https://github.com/DiamondLightSource/dodal/issues/700
+from functools import partial, reduce
+
 from ophyd import Component, Device, EpicsSignal, EpicsSignalRO, EpicsSignalWithRBV
 from ophyd.areadetector.plugins import HDF5Plugin_V22
 from ophyd.sim import NullStatus
-from ophyd.status import StatusBase
+from ophyd.status import StatusBase, SubscriptionStatus
 
 from dodal.devices.status import await_value
 
@@ -61,47 +63,47 @@ class OdinNodesStatus(Device):
     def nodes(self) -> list[OdinNode]:
         return [self.node_0, self.node_1, self.node_2, self.node_3]
 
-    def check_node_frames_from_attr(
+    def _check_node_frames_from_attr(
         self, node_get_func, error_message_verb: str
     ) -> tuple[bool, str]:
         nodes_frames_values = [0] * len(self.nodes)
         frames_details = []
         for node_number, node_pv in enumerate(self.nodes):
-            nodes_frames_values[node_number] = node_get_func(node_pv)
-            error_message = f"Filewriter {node_number} {error_message_verb} \
-                    {nodes_frames_values[node_number]} frames"
-            frames_details.append(error_message)
+            node_state = node_get_func(node_pv)
+            nodes_frames_values[node_number] = node_state
+            if node_state != 0:
+                error_message = f"Filewriter {node_number} {error_message_verb} \
+                        {nodes_frames_values[node_number]} frames"
+                frames_details.append(error_message)
         bad_frames = any(v != 0 for v in nodes_frames_values)
         return bad_frames, "\n".join(frames_details)
 
     def check_frames_timed_out(self) -> tuple[bool, str]:
-        return self.check_node_frames_from_attr(
+        return self._check_node_frames_from_attr(
             lambda node: node.frames_timed_out.get(), "timed out"
         )
 
     def check_frames_dropped(self) -> tuple[bool, str]:
-        return self.check_node_frames_from_attr(
+        return self._check_node_frames_from_attr(
             lambda node: node.frames_dropped.get(), "dropped"
         )
 
-    def get_error_state(self) -> tuple[bool, str]:
-        is_error = []
-        error_messages = []
+    def wait_for_no_errors(self, timeout) -> dict[SubscriptionStatus, str]:
+        errors = {}
         for node_number, node_pv in enumerate(self.nodes):
-            is_error.append(node_pv.error_status.get())
-            if is_error[node_number]:
-                error_messages.append(
-                    f"Filewriter {node_number} is in an error state with error message\
+            errors[
+                await_value(node_pv.error_status, False, timeout)
+            ] = f"Filewriter {node_number} is in an error state with error message\
                      - {node_pv.error_message.get()}"
-                )
-        return any(is_error), "\n".join(error_messages)
 
-    def get_init_state(self) -> bool:
+        return errors
+
+    def get_init_state(self, timeout) -> SubscriptionStatus:
         is_initialised = []
         for node_pv in self.nodes:
-            is_initialised.append(node_pv.fr_initialised.get())
-            is_initialised.append(node_pv.fp_initialised.get())
-        return all(is_initialised)
+            is_initialised.append(await_value(node_pv.fr_initialised, True, timeout))
+            is_initialised.append(await_value(node_pv.fp_initialised, True, timeout))
+        return reduce(lambda x, y: x & y, is_initialised)
 
     def clear_odin_errors(self):
         clearing_status = NullStatus()
@@ -125,8 +127,8 @@ class EigerOdin(Device):
             writing_finished &= await_value(node_pv.writing, 0)
         return writing_finished
 
-    def check_odin_state(self) -> bool:
-        is_initialised, error_message = self.check_odin_initialised()
+    def check_and_wait_for_odin_state(self, timeout) -> bool:
+        is_initialised, error_message = self.wait_for_odin_initialised(timeout)
         frames_dropped, frames_dropped_details = self.nodes.check_frames_dropped()
         frames_timed_out, frames_timed_out_details = self.nodes.check_frames_timed_out()
 
@@ -139,22 +141,29 @@ class EigerOdin(Device):
 
         return is_initialised and not frames_dropped and not frames_timed_out
 
-    def check_odin_initialised(self) -> tuple[bool, str]:
-        is_error_state, error_messages = self.nodes.get_error_state()
-        to_check = [
-            (not self.fan.consumers_connected.get(), "EigerFan is not connected"),
-            (not self.fan.on.get(), "EigerFan is not initialised"),
-            (not self.meta.initialised.get(), "MetaListener is not initialised"),
-            (is_error_state, error_messages),
-            (
-                not self.nodes.get_init_state(),
-                "One or more filewriters is not initialised",
-            ),
-        ]
-
-        errors = [message for check_result, message in to_check if check_result]
-
-        return not errors, "\n".join(errors)
+    def wait_for_odin_initialised(self, timeout) -> tuple[bool, str]:
+        errors = self.nodes.wait_for_no_errors(timeout)
+        await_true = partial(await_value, expected_value=True, timeout=timeout)
+        errors[
+            await_value(
+                self.fan.consumers_connected, expected_value=True, timeout=timeout
+            )
+        ] = "EigerFan is not connected"
+        errors[await_true(self.fan.on)] = "EigerFan is not initialised"
+        errors[await_true(self.meta.initialised)] = "MetaListener is not initialised"
+        errors[self.nodes.get_init_state(timeout)] = (
+            "One or more filewriters is not initialised"
+        )
+
+        error_strings = []
+
+        for error_status, string in errors.items():
+            try:
+                error_status.wait(timeout=timeout)
+            except Exception:
+                error_strings.append(string)
+
+        return not error_strings, "\n".join(error_strings)
 
     def stop(self) -> StatusBase:
         """Stop odin manually"""

dodal/devices/focusing_mirror.py

@@ -45,7 +45,7 @@ class MirrorVoltageDemand(str, Enum):
     SLEW = "SLEW"
 
 
-class MirrorVoltageDevice(Device):
+class SingleMirrorVoltage(Device):
     """Abstract the bimorph mirror voltage PVs into a single device that can be set asynchronously and returns when
     the demanded voltage setpoint is accepted, without blocking the caller as this process can take significant time.
     """
@@ -105,22 +105,28 @@ class MirrorVoltageDevice(Device):
         await set_status
 
 
-class VFMMirrorVoltages(StandardReadable):
+class MirrorVoltages(StandardReadable):
     def __init__(
         self, name: str, prefix: str, *args, daq_configuration_path: str, **kwargs
     ):
         self.voltage_lookup_table_path = (
             daq_configuration_path + "/json/mirrorFocus.json"
         )
+
         with self.add_children_as_readables():
-            self.voltage_channels = DeviceVector(
-                {
-                    i - 14: MirrorVoltageDevice(prefix=f"{prefix}BM:V{i}")
-                    for i in range(14, 22)
-                }
-            )
+            self.horizontal_voltages = self._channels_in_range(prefix, 0, 14)
+            self.vertical_voltages = self._channels_in_range(prefix, 14, 22)
+
         super().__init__(*args, name=name, **kwargs)
 
+    def _channels_in_range(self, prefix, start_idx, end_idx):
+        return DeviceVector(
+            {
+                i - start_idx: SingleMirrorVoltage(prefix=f"{prefix}BM:V{i}")
+                for i in range(start_idx, end_idx)
+            }
+        )
+
 
 class FocusingMirror(StandardReadable):
     """Focusing Mirror"""