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

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"
 

dodal/devices/zebra.py

@@ -9,9 +9,10 @@ from ophyd_async.core import (
     DeviceVector,
     SignalRW,
     StandardReadable,
+    StrictEnum,
     observe_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 # These constants refer to I03's Zebra. See https://github.com/DiamondLightSource/dodal/issues/772
 # Sources
@@ -46,18 +47,18 @@ AUTO_SHUTTER_INPUT_1 = 1
 AUTO_SHUTTER_INPUT_2 = 2
 
 
-class ArmSource(str, Enum):
+class ArmSource(StrictEnum):
     SOFT = "Soft"
     EXTERNAL = "External"
 
 
-class TrigSource(str, Enum):
+class TrigSource(StrictEnum):
     POSITION = "Position"
     TIME = "Time"
     EXTERNAL = "External"
 
 
-class EncEnum(str, Enum):
+class EncEnum(StrictEnum):
     Enc1 = "Enc1"
     Enc2 = "Enc2"
     Enc3 = "Enc3"
@@ -79,7 +80,7 @@ class I24Axes:
     VGON_YH = EncEnum.Enc4
 
 
-class RotationDirection(str, Enum):
+class RotationDirection(StrictEnum):
     POSITIVE = "Positive"
     NEGATIVE = "Negative"
 
@@ -93,7 +94,7 @@ class ArmDemand(Enum):
     DISARM = 0
 
 
-class SoftInState(str, Enum):
+class SoftInState(StrictEnum):
     YES = "Yes"
     NO = "No"
 

dodal/devices/zebra_controlled_shutter.py

@@ -1,21 +1,20 @@
-from enum import Enum
-
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     StandardReadable,
+    StrictEnum,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_w
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
 
 
-class ZebraShutterState(str, Enum):
+class ZebraShutterState(StrictEnum):
     CLOSE = "Close"
     OPEN = "Open"
 
 
-class ZebraShutterControl(str, Enum):
+class ZebraShutterControl(StrictEnum):
     MANUAL = "Manual"
     AUTO = "Auto"
 
@@ -26,7 +25,7 @@ class ZebraShutter(StandardReadable, Movable):
     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
+    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):

dodal/devices/zocalo/__init__.py

@@ -4,14 +4,14 @@ from dodal.devices.zocalo.zocalo_results import (
     NoZocaloSubscription,
     XrcResult,
     ZocaloResults,
-    get_processing_result,
+    get_full_processing_results,
 )
 
 __all__ = [
     "ZocaloResults",
     "XrcResult",
     "ZocaloTrigger",
-    "get_processing_result",
+    "get_full_processing_results",
     "ZOCALO_READING_PLAN_NAME",
     "NoResultsFromZocalo",
     "NoZocaloSubscription",

dodal/devices/zocalo/zocalo_constants.py

@@ -0,0 +1,3 @@
+from dodal.utils import is_test_mode
+
+ZOCALO_ENV = "dev_bluesky" if is_test_mode() else "bluesky"

dodal/devices/zocalo/zocalo_interaction.py

@@ -7,6 +7,7 @@ from dataclasses import dataclass
 import zocalo.configuration
 from workflows.transport import lookup
 
+from dodal.devices.zocalo.zocalo_constants import ZOCALO_ENV
 from dodal.log import LOGGER
 
 
@@ -56,7 +57,7 @@ class ZocaloTrigger:
 
     see https://github.com/DiamondLightSource/dodal/wiki/How-to-Interact-with-Zocalo"""
 
-    def __init__(self, environment: str = "artemis"):
+    def __init__(self, environment: str = ZOCALO_ENV):
         self.zocalo_environment: str = environment
 
     def _send_to_zocalo(self, parameters: dict):

dodal/devices/zocalo/zocalo_results.py

@@ -1,7 +1,7 @@
 import asyncio
-from collections import OrderedDict
 from collections.abc import Generator, Sequence
 from enum import Enum
+from inspect import get_annotations
 from queue import Empty, Queue
 from typing import Any, TypedDict
 
@@ -9,17 +9,19 @@ import bluesky.plan_stubs as bps
 import numpy as np
 import workflows.recipe
 import workflows.transport
-from bluesky.protocols import Descriptor, Triggerable
+from bluesky.protocols import Triggerable
+from bluesky.utils import Msg
 from deepdiff import DeepDiff
 from numpy.typing import NDArray
 from ophyd_async.core import (
     AsyncStatus,
-    HintedSignal,
     StandardReadable,
+    StandardReadableFormat,
     soft_signal_r_and_setter,
 )
 from workflows.transport.common_transport import CommonTransport
 
+from dodal.devices.zocalo.zocalo_constants import ZOCALO_ENV
 from dodal.devices.zocalo.zocalo_interaction import _get_zocalo_connection
 from dodal.log import LOGGER
 
@@ -51,7 +53,7 @@ ZOCALO_STAGE_GROUP = "clear zocalo queue"
 
 
 class XrcResult(TypedDict):
-    centre_of_mass: list[int]
+    centre_of_mass: list[float]
     max_voxel: list[int]
     max_count: int
     n_voxels: int
@@ -114,7 +116,7 @@ class ZocaloResults(StandardReadable, Triggerable):
     def __init__(
         self,
         name: str = "zocalo",
-        zocalo_environment: str = "dev_artemis",
+        zocalo_environment: str = ZOCALO_ENV,
         channel: str = "xrc.i03",
         sort_key: str = DEFAULT_SORT_KEY.value,
         timeout_s: float = DEFAULT_TIMEOUT,
@@ -130,14 +132,23 @@ class ZocaloResults(StandardReadable, Triggerable):
         self.transport: CommonTransport | None = None
         self.use_cpu_and_gpu = use_cpu_and_gpu
 
-        self.results, self._results_setter = soft_signal_r_and_setter(
-            list[XrcResult], name="results"
+        self.centre_of_mass, self._com_setter = soft_signal_r_and_setter(
+            NDArray[np.uint64], name="centre_of_mass"
         )
-        self.centres_of_mass, self._com_setter = soft_signal_r_and_setter(
-            NDArray[np.uint64], name="centres_of_mass"
+        self.bounding_box, self._bounding_box_setter = soft_signal_r_and_setter(
+            NDArray[np.uint64], name="bounding_box"
         )
-        self.bbox_sizes, self._bbox_setter = soft_signal_r_and_setter(
-            NDArray[np.uint64], "bbox_sizes", self.name
+        self.max_voxel, self._max_voxel_setter = soft_signal_r_and_setter(
+            NDArray[np.uint64], name="max_voxel"
+        )
+        self.max_count, self._max_count_setter = soft_signal_r_and_setter(
+            NDArray[np.uint64], name="max_count"
+        )
+        self.n_voxels, self._n_voxels_setter = soft_signal_r_and_setter(
+            NDArray[np.uint64], name="n_voxels"
+        )
+        self.total_count, self._total_count_setter = soft_signal_r_and_setter(
+            NDArray[np.uint64], name="total_count"
         )
         self.ispyb_dcid, self._ispyb_dcid_setter = soft_signal_r_and_setter(
             int, name="ispyb_dcid"
@@ -147,22 +158,27 @@ class ZocaloResults(StandardReadable, Triggerable):
         )
         self.add_readables(
             [
-                self.results,
-                self.centres_of_mass,
-                self.bbox_sizes,
+                self.max_voxel,
+                self.max_count,
+                self.n_voxels,
+                self.total_count,
+                self.centre_of_mass,
+                self.bounding_box,
                 self.ispyb_dcid,
                 self.ispyb_dcgid,
             ],
-            wrapper=HintedSignal,
+            format=StandardReadableFormat.HINTED_SIGNAL,
         )
         super().__init__(name)
 
     async def _put_results(self, results: Sequence[XrcResult], recipe_parameters):
-        self._results_setter(list(results))
         centres_of_mass = np.array([r["centre_of_mass"] for r in results])
-        bbox_sizes = np.array([bbox_size(r) for r in results])
         self._com_setter(centres_of_mass)
-        self._bbox_setter(bbox_sizes)
+        self._bounding_box_setter(np.array([r["bounding_box"] for r in results]))
+        self._max_voxel_setter(np.array([r["max_voxel"] for r in results]))
+        self._max_count_setter(np.array([r["max_count"] for r in results]))
+        self._n_voxels_setter(np.array([r["n_voxels"] for r in results]))
+        self._total_count_setter(np.array([r["total_count"] for r in results]))
         self._ispyb_dcid_setter(recipe_parameters["dcid"])
         self._ispyb_dcgid_setter(recipe_parameters["dcgid"])
 
@@ -286,48 +302,6 @@ class ZocaloResults(StandardReadable, Triggerable):
         finally:
             self._kickoff_run = False
 
-    async def describe(self) -> dict[str, Descriptor]:
-        zocalo_array_type: Descriptor = {
-            "source": f"zocalo_service:{self.zocalo_environment}",
-            "dtype": "array",
-            "shape": [-1, 3],
-        }
-        zocalo_int_type: Descriptor = {
-            "source": f"zocalo_service:{self.zocalo_environment}",
-            "dtype": "integer",
-            "shape": [0],
-        }
-        return OrderedDict(
-            [
-                (
-                    self._name + "-results",
-                    {
-                        "source": f"zocalo_service:{self.zocalo_environment}",
-                        "dtype": "array",
-                        "shape": [
-                            -1,
-                        ],  # TODO describe properly - see https://github.com/DiamondLightSource/dodal/issues/253
-                    },
-                ),
-                (
-                    self._name + "-centres_of_mass",
-                    zocalo_array_type,
-                ),
-                (
-                    self._name + "-bbox_sizes",
-                    zocalo_array_type,
-                ),
-                (
-                    self._name + "-ispyb_dcid",
-                    zocalo_int_type,
-                ),
-                (
-                    self._name + "-ispyb_dcgid",
-                    zocalo_int_type,
-                ),
-            ],
-        )
-
     def _subscribe_to_results(self):
         self.transport = _get_zocalo_connection(self.zocalo_environment)
 
@@ -364,23 +338,62 @@ class ZocaloResults(StandardReadable, Triggerable):
         )
 
 
-def get_processing_result(
+def _corrected_xrc_result(uncorrected: XrcResult) -> XrcResult:
+    corrected = XrcResult(**uncorrected)
+    corrected["centre_of_mass"] = [
+        coord - 0.5 for coord in uncorrected["centre_of_mass"]
+    ]
+    return corrected
+
+
+def get_full_processing_results(
     zocalo: ZocaloResults,
-) -> Generator[Any, Any, tuple[np.ndarray, np.ndarray] | tuple[None, None]]:
-    """A minimal plan which will extract the top ranked xray centre and crystal bounding
-    box size from the zocalo results. Returns (None, None) if no crystals were found."""
-
-    LOGGER.info("Getting zocalo processing results.")
-    centres_of_mass = yield from bps.rd(zocalo.centres_of_mass, default_value=[])  # type: ignore
-    LOGGER.debug(f"Centres of mass: {centres_of_mass}")
-    centre_of_mass = (
-        None
-        if len(centres_of_mass) == 0  # type: ignore
-        else centres_of_mass[0] - np.array([0.5, 0.5, 0.5])  # type: ignore
-    )
-    LOGGER.debug(f"Adjusted top centring result: {centre_of_mass}")
-    bbox_sizes = yield from bps.rd(zocalo.bbox_sizes, default_value=[])  # type: ignore
-    LOGGER.debug(f"Bounding box sizes: {centres_of_mass}")
-    bbox_size = None if len(bbox_sizes) == 0 else bbox_sizes[0]  # type: ignore
-    LOGGER.debug(f"Top bbox size: {bbox_size}")
-    return centre_of_mass, bbox_size
+) -> Generator[Msg, Any, Sequence[XrcResult]]:
+    """A plan that will return the raw zocalo results, ranked in descending order according to the sort key.
+    Returns empty list in the event no results found."""
+    LOGGER.info("Retrieving raw zocalo processing results")
+    com = yield from bps.rd(zocalo.centre_of_mass, default_value=[])  # type: ignore
+    max_voxel = yield from bps.rd(zocalo.max_voxel, default_value=[])  # type: ignore
+    max_count = yield from bps.rd(zocalo.max_count, default_value=[])  # type: ignore
+    n_voxels = yield from bps.rd(zocalo.n_voxels, default_value=[])  # type: ignore
+    total_count = yield from bps.rd(zocalo.total_count, default_value=[])  # type: ignore
+    bounding_box = yield from bps.rd(zocalo.bounding_box, default_value=[])  # type: ignore
+    return [
+        _corrected_xrc_result(
+            XrcResult(
+                centre_of_mass=com.tolist(),
+                max_voxel=mv.tolist(),
+                max_count=int(mc),
+                n_voxels=int(n),
+                total_count=int(tc),
+                bounding_box=bb.tolist(),
+            )
+        )
+        for com, mv, mc, n, tc, bb in zip(
+            com, max_voxel, max_count, n_voxels, total_count, bounding_box, strict=True
+        )
+    ]
+
+
+def get_processing_results_from_event(
+    device_name: str, doc: dict
+) -> Sequence[XrcResult]:
+    """
+    Decode an event document into the corresponding x-ray centring results
+
+    Args:
+    doc         A bluesky event document containing the signals read from the ZocaloResults
+    device_name The device name prefix to prepend to the document keys
+
+    Returns:
+        The list of XrcResults decoded from the event document
+    """
+    results_keys = get_annotations(XrcResult).keys()
+    results_dict = {k: doc["data"][f"{device_name}-{k}"] for k in results_keys}
+    results_values = [results_dict[k].tolist() for k in results_keys]
+
+    def create_result(*argv):
+        kwargs = dict(zip(results_keys, argv, strict=False))
+        return XrcResult(**kwargs)
+
+    return list(map(create_result, *results_values))

dodal/{plans/data_session_metadata.py → plan_stubs/data_session.py}

@@ -2,7 +2,7 @@ from bluesky import plan_stubs as bps
 from bluesky import preprocessors as bpp
 from bluesky.utils import MsgGenerator, make_decorator
 
-from dodal.common.beamlines import beamline_utils
+from dodal.common.beamlines.beamline_utils import get_path_provider
 from dodal.common.types import UpdatingPathProvider
 
 DATA_SESSION = "data_session"
@@ -31,7 +31,7 @@ def attach_data_session_metadata_wrapper(
         Iterator[Msg]: Plan messages
     """
     if provider is None:
-        provider = beamline_utils.get_path_provider()
+        provider = get_path_provider()
     yield from bps.wait_for([provider.update])
     ress = yield from bps.wait_for([provider.data_session])
     data_session = ress[0].result()

dodal/{plans/motor_util_plans.py → plan_stubs/motor_utils.py}

@@ -23,7 +23,7 @@ class MoveTooLarge(Exception):
         super().__init__(*args)
 
 
-def _check_and_cache_values(
+def check_and_cache_values(
     devices_and_positions: dict[MovableReadableDevice, float],
     smallest_move: float,
     maximum_move: float,
@@ -89,7 +89,7 @@ def move_and_reset_wrapper(
                                        on. If false it is left up to the caller to wait on
                                        them. Defaults to True.
     """
-    initial_positions = yield from _check_and_cache_values(
+    initial_positions = yield from check_and_cache_values(
         device_and_positions, smallest_move, maximum_move
     )