ophyd-async 0.12.3__py3-none-any.whl → 0.13.0__py3-none-any.whl

ophyd_async/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.12.3'
-__version_tuple__ = version_tuple = (0, 12, 3)
+__version__ = version = '0.13.0'
+__version_tuple__ = version_tuple = (0, 13, 0)

ophyd_async/core/__init__.py

@@ -16,6 +16,12 @@ from ._detector import (
 )
 from ._device import Device, DeviceConnector, DeviceVector, init_devices
 from ._device_filler import DeviceFiller
+from ._enums import (
+    EnabledDisabled,
+    EnableDisable,
+    InOut,
+    OnOff,
+)
 from ._flyer import FlyerController, FlyMotorInfo, StandardFlyer
 from ._hdf_dataset import HDFDatasetDescription, HDFDocumentComposer
 from ._log import config_ophyd_async_logging
@@ -209,4 +215,9 @@ __all__ = [
     # Back compat - delete before 1.0
     "ConfigSignal",
     "HintedSignal",
+    # Standard enums
+    "EnabledDisabled",
+    "EnableDisable",
+    "InOut",
+    "OnOff",
 ]

ophyd_async/core/_detector.py

@@ -104,7 +104,11 @@ class DetectorController(ABC):
 
     @abstractmethod
     def get_deadtime(self, exposure: float | None) -> float:
-        """For a given exposure, how long should the time between exposures be."""
+        """Get state-independent deadtime.
+
+        For a given exposure, what is the safest minimum time between exposures that
+        can be determined without reading signals.
+        """
 
     @abstractmethod
     async def prepare(self, trigger_info: TriggerInfo) -> None:
@@ -313,14 +317,7 @@ class StandardDetector(
         if value.trigger != DetectorTrigger.INTERNAL and not value.deadtime:
             msg = "Deadtime must be supplied when in externally triggered mode"
             raise ValueError(msg)
-        required_deadtime = self._controller.get_deadtime(value.livetime)
-        if value.deadtime and required_deadtime > value.deadtime:
-            msg = (
-                f"Detector {self._controller} needs at least {required_deadtime}s "
-                f"deadtime, but trigger logic provides only {value.deadtime}s"
-            )
-            raise ValueError(msg)
-        elif not value.deadtime:
+        if not value.deadtime:
             value.deadtime = self._controller.get_deadtime(value.livetime)
         self._trigger_info = value
         self._number_of_events_iter = iter(

ophyd_async/core/_enums.py

@@ -0,0 +1,21 @@
+from ._utils import StrictEnum
+
+
+class OnOff(StrictEnum):
+    ON = "On"
+    OFF = "Off"
+
+
+class EnableDisable(StrictEnum):
+    ENABLE = "Enable"
+    DISABLE = "Disable"
+
+
+class EnabledDisabled(StrictEnum):
+    ENABLED = "Enabled"
+    DISABLED = "Disabled"
+
+
+class InOut(StrictEnum):
+    IN = "In"
+    OUT = "Out"

ophyd_async/epics/adaravis/__init__.py

@@ -5,12 +5,11 @@ https://github.com/areaDetector/ADAravis
 
 from ._aravis import AravisDetector
 from ._aravis_controller import AravisController
-from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
+from ._aravis_io import AravisDriverIO, AravisTriggerSource
 
 __all__ = [
     "AravisDetector",
     "AravisController",
     "AravisDriverIO",
-    "AravisTriggerMode",
     "AravisTriggerSource",
 ]

ophyd_async/epics/adaravis/_aravis_controller.py

@@ -1,9 +1,9 @@
 import asyncio
 
-from ophyd_async.core import DetectorTrigger, TriggerInfo
+from ophyd_async.core import DetectorTrigger, OnOff, TriggerInfo
 from ophyd_async.epics import adcore
 
-from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
+from ._aravis_io import AravisDriverIO, AravisTriggerSource
 
 # The deadtime of an ADaravis controller varies depending on the exact model of camera.
 # Ideally we would maximize performance by dynamically retrieving the deadtime at
@@ -23,14 +23,14 @@ class AravisController(adcore.ADBaseController[AravisDriverIO]):
 
         if trigger_info.trigger is DetectorTrigger.INTERNAL:
             # Set trigger mode off to ignore the trigger source
-            await self.driver.trigger_mode.set(AravisTriggerMode.OFF)
+            await self.driver.trigger_mode.set(OnOff.OFF)
         elif trigger_info.trigger in {
             DetectorTrigger.CONSTANT_GATE,
             DetectorTrigger.EDGE_TRIGGER,
         }:
             # Trigger on the rising edge of Line1
             # trigger mode must be set first and on it's own!
-            await self.driver.trigger_mode.set(AravisTriggerMode.ON)
+            await self.driver.trigger_mode.set(OnOff.ON)
             await self.driver.trigger_source.set(AravisTriggerSource.LINE1)
         else:
             raise ValueError(f"ADAravis does not support {trigger_info.trigger}")

ophyd_async/epics/adaravis/_aravis_io.py

@@ -1,20 +1,10 @@
 from typing import Annotated as A
 
-from ophyd_async.core import SignalRW, StrictEnum, SubsetEnum
+from ophyd_async.core import OnOff, SignalRW, SubsetEnum
 from ophyd_async.epics import adcore
 from ophyd_async.epics.core import PvSuffix
 
 
-class AravisTriggerMode(StrictEnum):
-    """GigEVision GenICAM standard TriggerMode."""
-
-    ON = "On"
-    """Use TriggerSource to trigger each frame"""
-
-    OFF = "Off"
-    """Just trigger as fast as you can"""
-
-
 class AravisTriggerSource(SubsetEnum):
     """Which trigger source to use when TriggerMode=On."""
 
@@ -27,5 +17,5 @@ class AravisDriverIO(adcore.ADBaseIO):
     This mirrors the interface provided by ADAravis/db/aravisCamera.template.
     """
 
-    trigger_mode: A[SignalRW[AravisTriggerMode], PvSuffix.rbv("TriggerMode")]
+    trigger_mode: A[SignalRW[OnOff], PvSuffix.rbv("TriggerMode")]
     trigger_source: A[SignalRW[AravisTriggerSource], PvSuffix.rbv("TriggerSource")]

ophyd_async/epics/adcore/__init__.py

@@ -7,7 +7,6 @@ from ._core_detector import AreaDetector, ContAcqAreaDetector
 from ._core_io import (
     ADBaseDatasetDescriber,
     ADBaseIO,
-    ADCallbacks,
     ADCompression,
     ADState,
     NDArrayBaseIO,
@@ -18,6 +17,7 @@ from ._core_io import (
     NDPluginBaseIO,
     NDPluginCBIO,
     NDPluginStatsIO,
+    NDROIStatIO,
 )
 from ._core_logic import DEFAULT_GOOD_STATES, ADBaseContAcqController, ADBaseController
 from ._core_writer import ADWriter
@@ -33,11 +33,11 @@ from ._utils import (
     NDAttributeParam,
     NDAttributePv,
     NDAttributePvDbrType,
+    ndattributes_to_xml,
 )
 
 __all__ = [
     "ADBaseIO",
-    "ADCallbacks",
     "ADCompression",
     "ADBaseContAcqController",
     "AreaDetector",
@@ -49,6 +49,7 @@ __all__ = [
     "NDFileHDFIO",
     "NDPluginBaseIO",
     "NDPluginStatsIO",
+    "NDROIStatIO",
     "DEFAULT_GOOD_STATES",
     "ADBaseDatasetDescriber",
     "ADBaseController",
@@ -66,4 +67,5 @@ __all__ = [
     "NDAttributePvDbrType",
     "NDCBFlushOnSoftTrgMode",
     "NDPluginCBIO",
+    "ndattributes_to_xml",
 ]

ophyd_async/epics/adcore/_core_io.py

@@ -1,17 +1,19 @@
 import asyncio
 from typing import Annotated as A
 
-from ophyd_async.core import DatasetDescriber, SignalR, SignalRW, StrictEnum
+from ophyd_async.core import (
+    DatasetDescriber,
+    DeviceVector,
+    EnableDisable,
+    SignalR,
+    SignalRW,
+    StrictEnum,
+)
 from ophyd_async.epics.core import EpicsDevice, PvSuffix
 
 from ._utils import ADBaseDataType, ADFileWriteMode, ADImageMode, convert_ad_dtype_to_np
 
 
-class ADCallbacks(StrictEnum):
-    ENABLE = "Enable"
-    DISABLE = "Disable"
-
-
 class NDArrayBaseIO(EpicsDevice):
     """Class responsible for passing detector data from drivers to pluglins.
 
@@ -53,7 +55,7 @@ class NDPluginBaseIO(NDArrayBaseIO):
     """
 
     nd_array_port: A[SignalRW[str], PvSuffix.rbv("NDArrayPort")]
-    enable_callbacks: A[SignalRW[ADCallbacks], PvSuffix.rbv("EnableCallbacks")]
+    enable_callbacks: A[SignalRW[EnableDisable], PvSuffix.rbv("EnableCallbacks")]
     nd_array_address: A[SignalRW[int], PvSuffix.rbv("NDArrayAddress")]
     array_size0: A[SignalR[int], PvSuffix("ArraySize0_RBV")]
     array_size1: A[SignalR[int], PvSuffix("ArraySize1_RBV")]
@@ -87,6 +89,56 @@ class NDPluginStatsIO(NDPluginBaseIO):
     hist_max: A[SignalRW[float], PvSuffix.rbv("HistMax")]
 
 
+class NDROIStatIO(NDPluginBaseIO):
+    """Plugin for calculating basic statistics for multiple ROIs.
+
+    Each ROI is implemented as an instance of NDROIStatNIO,
+    and the collection of ROIs is held as a DeviceVector.
+
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/NDPluginROIStat.html
+    """
+
+    def __init__(self, prefix, num_channels=8, with_pvi=False, name=""):
+        self.channels = DeviceVector(
+            {i: NDROIStatNIO(f"{prefix}{i}:") for i in range(1, num_channels + 1)}
+        )
+        super().__init__(prefix, with_pvi, name)
+
+
+class NDROIStatNIO(EpicsDevice):
+    """Defines the parameters for a single ROI used for statistics calculation.
+
+    Each instance represents a single ROI, with attributes for its position
+    (min_x, min_y) and size (size_x, size_y), as well as a name and use status.
+
+    See definition in ADApp/pluginSrc/NDPluginROIStat.h in https://github.com/areaDetector/ADCore.
+
+    Attributes:
+        name: The name of the ROI.
+        use: Flag indicating whether the ROI is used.
+        min_x: The start X-coordinate of the ROI.
+        min_y: The start Y-coordinate of the ROI.
+        size_x: The width of the ROI.
+        size_y: The height of the ROI.
+        min_value: Minimum count value in the ROI.
+        max_value: Maximum count value in the ROI.
+        mean_value: Mean counts value in the ROI.
+        total: Total counts in the ROI.
+    """
+
+    name_: A[SignalRW[str], PvSuffix("Name")]
+    use: A[SignalRW[bool], PvSuffix.rbv("Use")]
+    min_x: A[SignalRW[int], PvSuffix.rbv("MinX")]
+    min_y: A[SignalRW[int], PvSuffix.rbv("MinY")]
+    size_x: A[SignalRW[int], PvSuffix.rbv("SizeX")]
+    size_y: A[SignalRW[int], PvSuffix.rbv("SizeY")]
+    # stats
+    min_value: A[SignalR[float], PvSuffix("MinValue_RBV")]
+    max_value: A[SignalR[float], PvSuffix("MaxValue_RBV")]
+    mean_value: A[SignalR[float], PvSuffix("MeanValue_RBV")]
+    total: A[SignalR[float], PvSuffix("Total_RBV")]
+
+
 class ADState(StrictEnum):
     """Default set of states of an AreaDetector driver.
 

ophyd_async/epics/adcore/_core_logic.py

@@ -6,6 +6,7 @@ from ophyd_async.core import (
     AsyncStatus,
     DetectorController,
     DetectorTrigger,
+    EnableDisable,
     TriggerInfo,
     observe_value,
     set_and_wait_for_value,
@@ -14,7 +15,6 @@ from ophyd_async.epics.core import stop_busy_record
 
 from ._core_io import (
     ADBaseIO,
-    ADCallbacks,
     ADState,
     NDCBFlushOnSoftTrgMode,
     NDPluginCBIO,
@@ -199,7 +199,7 @@ class ADBaseContAcqController(ADBaseController[ADBaseIO]):
 
         # Configure the CB plugin to collect the correct number of triggers
         await asyncio.gather(
-            self.cb_plugin.enable_callbacks.set(ADCallbacks.ENABLE),
+            self.cb_plugin.enable_callbacks.set(EnableDisable.ENABLE),
             self.cb_plugin.pre_count.set(0),
             self.cb_plugin.post_count.set(trigger_info.total_number_of_exposures),
             self.cb_plugin.preset_trigger_count.set(1),

ophyd_async/epics/adcore/_core_writer.py

@@ -12,6 +12,7 @@ from event_model import (  # type: ignore
 from pydantic import PositiveInt
 
 from ophyd_async.core._detector import DetectorWriter
+from ophyd_async.core._enums import EnableDisable
 from ophyd_async.core._providers import DatasetDescriber, PathInfo, PathProvider
 from ophyd_async.core._signal import (
     observe_value,
@@ -24,7 +25,6 @@ from ophyd_async.epics.core import stop_busy_record
 # from ophyd_async.epics.adcore._core_logic import ADBaseDatasetDescriber
 from ._core_io import (
     ADBaseDatasetDescriber,
-    ADCallbacks,
     NDArrayBaseIO,
     NDFileIO,
     NDFilePluginIO,
@@ -89,7 +89,7 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         )
 
         if isinstance(self.fileio, NDFilePluginIO):
-            await self.fileio.enable_callbacks.set(ADCallbacks.ENABLE)
+            await self.fileio.enable_callbacks.set(EnableDisable.ENABLE)
 
         # Set the directory creation depth first, since dir creation callback happens
         # when directory path PV is processed.

ophyd_async/epics/adcore/_hdf_writer.py

@@ -99,12 +99,6 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
             )
         ]
 
-        self._composer = HDFDocumentComposer(
-            # See https://github.com/bluesky/ophyd-async/issues/122
-            f"{self._path_info.directory_uri}{self._path_info.filename}{self._file_extension}",
-            self._datasets,
-        )
-
         # And all the scalar datasets
         for plugin in self._plugins.values():
             maybe_xml = await plugin.nd_attributes_file.get_value()
@@ -136,6 +130,12 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
                         )
                     )
 
+        self._composer = HDFDocumentComposer(
+            # See https://github.com/bluesky/ophyd-async/issues/122
+            f"{self._path_info.directory_uri}{self._path_info.filename}{self._file_extension}",
+            self._datasets,
+        )
+
         describe = {
             ds.data_key: DataKey(
                 source=self.fileio.full_file_name.source,

ophyd_async/epics/adcore/_utils.py

@@ -1,4 +1,6 @@
+from collections.abc import Sequence
 from dataclasses import dataclass
+from xml.etree import ElementTree as ET
 
 from ophyd_async.core import (
     SignalR,
@@ -130,3 +132,39 @@ class NDAttributeParam:
     datatype: NDAttributeDataType  # The datatype of the parameter
     addr: int = 0  # The address as seen in the INP link of the record
     description: str = ""  # A description that appears in the HDF file as an attribute
+
+
+def ndattributes_to_xml(
+    ndattributes: Sequence[NDAttributeParam | NDAttributePv],
+) -> str:
+    """Convert a set of NDAttribute params to XML."""
+    root = ET.Element("Attributes")
+    for ndattribute in ndattributes:
+        if isinstance(ndattribute, NDAttributeParam):
+            ET.SubElement(
+                root,
+                "Attribute",
+                name=ndattribute.name,
+                type="PARAM",
+                source=ndattribute.param,
+                addr=str(ndattribute.addr),
+                datatype=ndattribute.datatype.value,
+                description=ndattribute.description,
+            )
+        elif isinstance(ndattribute, NDAttributePv):
+            ET.SubElement(
+                root,
+                "Attribute",
+                name=ndattribute.name,
+                type="EPICS_PV",
+                source=ndattribute.signal.source.split("ca://")[-1],
+                dbrtype=ndattribute.dbrtype.value,
+                description=ndattribute.description,
+            )
+        else:
+            raise ValueError(
+                f"Invalid type for ndattributes: {type(ndattribute)}. "
+                "Expected NDAttributePv or NDAttributeParam."
+            )
+    xml_text = ET.tostring(root, encoding="unicode")
+    return xml_text

ophyd_async/epics/advimba/__init__.py

@@ -4,7 +4,6 @@ from ._vimba_io import (
     VimbaConvertFormat,
     VimbaDriverIO,
     VimbaExposeOutMode,
-    VimbaOnOff,
     VimbaOverlap,
     VimbaTriggerSource,
 )
@@ -14,7 +13,6 @@ __all__ = [
     "VimbaController",
     "VimbaDriverIO",
     "VimbaExposeOutMode",
-    "VimbaOnOff",
     "VimbaTriggerSource",
     "VimbaOverlap",
     "VimbaConvertFormat",

ophyd_async/epics/advimba/_vimba_controller.py

@@ -1,18 +1,15 @@
 import asyncio
 
-from ophyd_async.core import (
-    DetectorTrigger,
-    TriggerInfo,
-)
+from ophyd_async.core import DetectorTrigger, OnOff, TriggerInfo
 from ophyd_async.epics import adcore
 
-from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaOnOff, VimbaTriggerSource
+from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaTriggerSource
 
 TRIGGER_MODE = {
-    DetectorTrigger.INTERNAL: VimbaOnOff.OFF,
-    DetectorTrigger.CONSTANT_GATE: VimbaOnOff.ON,
-    DetectorTrigger.VARIABLE_GATE: VimbaOnOff.ON,
-    DetectorTrigger.EDGE_TRIGGER: VimbaOnOff.ON,
+    DetectorTrigger.INTERNAL: OnOff.OFF,
+    DetectorTrigger.CONSTANT_GATE: OnOff.ON,
+    DetectorTrigger.VARIABLE_GATE: OnOff.ON,
+    DetectorTrigger.EDGE_TRIGGER: OnOff.ON,
 }
 
 EXPOSE_OUT_MODE = {

ophyd_async/epics/advimba/_vimba_io.py

@@ -1,6 +1,6 @@
 from typing import Annotated as A
 
-from ophyd_async.core import SignalRW, StrictEnum
+from ophyd_async.core import OnOff, SignalRW, StrictEnum
 from ophyd_async.epics import adcore
 from ophyd_async.epics.core import PvSuffix
 
@@ -30,17 +30,10 @@ class VimbaTriggerSource(StrictEnum):
 class VimbaOverlap(StrictEnum):
     """Overlap modes for the Vimba detector."""
 
-    OFF = "Off"
+    OFF = OnOff.OFF
     PREV_FRAME = "PreviousFrame"
 
 
-class VimbaOnOff(StrictEnum):
-    """On/Off modes on the Vimba detector."""
-
-    ON = "On"
-    OFF = "Off"
-
-
 class VimbaExposeOutMode(StrictEnum):
     """Exposure control modes for Vimba detectors."""
 
@@ -55,6 +48,6 @@ class VimbaDriverIO(adcore.ADBaseIO):
         SignalRW[VimbaConvertFormat], PvSuffix("ConvertPixelFormat")
     ]
     trigger_source: A[SignalRW[VimbaTriggerSource], PvSuffix("TriggerSource")]
-    trigger_mode: A[SignalRW[VimbaOnOff], PvSuffix("TriggerMode")]
+    trigger_mode: A[SignalRW[OnOff], PvSuffix("TriggerMode")]
     trigger_overlap: A[SignalRW[VimbaOverlap], PvSuffix("TriggerOverlap")]
     exposure_mode: A[SignalRW[VimbaExposeOutMode], PvSuffix("ExposureMode")]

ophyd_async/epics/core/_aioca.py

@@ -1,4 +1,5 @@
 import logging
+import os
 import sys
 import typing
 from collections.abc import Mapping, Sequence
@@ -40,6 +41,10 @@ from ._util import EpicsSignalBackend, format_datatype, get_supported_values
 logger = logging.getLogger("ophyd_async")
 
 
+def _all_updates() -> bool:
+    return os.environ.get("OPHYD_ASYNC_EPICS_CA_KEEP_ALL_UPDATES", "True") == "True"
+
+
 def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
     def get_limits(limit: str) -> LimitsRange | None:
         low = getattr(value, f"lower_{limit}_limit", nan)
@@ -250,12 +255,11 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
         datatype: type[SignalDatatypeT] | None,
         read_pv: str = "",
         write_pv: str = "",
-        all_updates: bool = True,
     ):
         self.converter: CaConverter = DisconnectedCaConverter(float, dbr.DBR_DOUBLE)
         self.initial_values: dict[str, AugmentedValue] = {}
         self.subscription: Subscription | None = None
-        self._all_updates = all_updates
+        self._all_updates = _all_updates()
         super().__init__(datatype, read_pv, write_pv)
 
     def source(self, name: str, read: bool):

ophyd_async/epics/pmac/__init__.py

@@ -1,3 +1,8 @@
 from ._pmac_io import PmacAxisAssignmentIO, PmacCoordIO, PmacIO, PmacTrajectoryIO
 
-__all__ = ["PmacAxisAssignmentIO", "PmacCoordIO", "PmacIO", "PmacTrajectoryIO"]
+__all__ = [
+    "PmacAxisAssignmentIO",
+    "PmacCoordIO",
+    "PmacIO",
+    "PmacTrajectoryIO",
+]

ophyd_async/epics/pmac/_pmac_io.py

@@ -69,6 +69,7 @@ class PmacCoordIO(Device):
 
     def __init__(self, prefix: str, name: str = "") -> None:
         self.defer_moves = epics_signal_rw(bool, f"{prefix}DeferMoves")
+        self.cs_port = epics_signal_r(str, f"{prefix}Port")
         self.cs_axis_setpoint = DeviceVector(
             {
                 i + 1: epics_signal_rw(np.float64, f"{prefix}M{i + 1}:DirectDemand")

ophyd_async/epics/pmac/_utils.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+import numpy as np
+import numpy.typing as npt
+from scanspec.core import Slice
+
+from ophyd_async.core import error_if_none, gather_dict
+from ophyd_async.epics.motor import Motor
+
+from ._pmac_io import CS_LETTERS, PmacIO
+
+# PMAC durations are in milliseconds
+# We must convert from scanspec durations (seconds) to milliseconds
+# PMAC motion program multiples durations by 0.001
+# (see https://github.com/DiamondLightSource/pmac/blob/afe81f8bb9179c3a20eff351f30bc6cfd1539ad9/pmacApp/pmc/trajectory_scan_code_ppmac.pmc#L241)
+# Therefore, we must divide scanspec durations by 10e-6
+TICK_S = 0.000001
+
+
+@dataclass
+class _Trajectory:
+    positions: dict[Motor, np.ndarray]
+    velocities: dict[Motor, np.ndarray]
+    user_programs: npt.NDArray[np.int32]
+    durations: npt.NDArray[np.float64]
+
+    @classmethod
+    def from_slice(cls, slice: Slice[Motor], ramp_up_time: float) -> _Trajectory:
+        """Parse a trajectory with no gaps from a slice.
+
+        :param slice: Information about a series of scan frames along a number of axes
+        :param ramp_up_duration: Time required to ramp up to speed
+        :param ramp_down: Booleon representing if we ramp down or not
+        :returns Trajectory: Data class representing our parsed trajectory
+        :raises RuntimeError: Slice must have no gaps and a duration array
+        """
+        slice_duration = error_if_none(slice.duration, "Slice must have a duration")
+
+        # Check if any gaps other than initial gap.
+        if any(slice.gap[1:]):
+            raise RuntimeError(
+                f"Cannot parse trajectory with gaps. Slice has gaps: {slice.gap}"
+            )
+
+        scan_size = len(slice)
+        motors = slice.axes()
+
+        positions: dict[Motor, npt.NDArray[np.float64]] = {}
+        velocities: dict[Motor, npt.NDArray[np.float64]] = {}
+
+        # Initialise arrays
+        positions = {motor: np.empty(2 * scan_size + 1, float) for motor in motors}
+        velocities = {motor: np.empty(2 * scan_size + 1, float) for motor in motors}
+        durations: npt.NDArray[np.float64] = np.empty(2 * scan_size + 1, float)
+        user_programs: npt.NDArray[np.int32] = np.ones(2 * scan_size + 1, float)
+        user_programs[-1] = 8
+
+        # Ramp up time for start of collection window
+        durations[0] = int(ramp_up_time / TICK_S)
+        # Half the time per point
+        durations[1:] = np.repeat(slice_duration / (2 * TICK_S), 2)
+
+        # Fill profile assuming no gaps
+        # Excluding starting points, we begin at our next frame
+        half_durations = slice_duration / 2
+        for motor in motors:
+            # Set the first position to be lower bound, then
+            # alternate mid and upper as the upper and lower
+            # bounds of neighbouring points are the same as gap is false
+            positions[motor][0] = slice.lower[motor][0]
+            positions[motor][1::2] = slice.midpoints[motor]
+            positions[motor][2::2] = slice.upper[motor]
+            # For velocities we will need the relative distances
+            mid_to_upper_velocities = (
+                slice.upper[motor] - slice.midpoints[motor]
+            ) / half_durations
+            lower_to_mid_velocities = (
+                slice.midpoints[motor] - slice.lower[motor]
+            ) / half_durations
+            # First velocity is the lower -> mid of first point
+            velocities[motor][0] = lower_to_mid_velocities[0]
+            # For the midpoints, we take the average of the
+            # lower -> mid and mid-> upper velocities of the same point
+            velocities[motor][1::2] = (
+                lower_to_mid_velocities + mid_to_upper_velocities
+            ) / 2
+            # For the upper points, we need to take the average of the
+            # mid -> upper velocity of the previous point and
+            # lower -> mid velocity of the current point
+            velocities[motor][2:-1:2] = (
+                mid_to_upper_velocities[:-1] + lower_to_mid_velocities[1:]
+            ) / 2
+            # For the last velocity take the mid to upper velocity
+            velocities[motor][-1] = mid_to_upper_velocities[-1]
+
+        return cls(
+            positions=positions,
+            velocities=velocities,
+            user_programs=user_programs,
+            durations=durations,
+        )
+
+
+@dataclass
+class _PmacMotorInfo:
+    cs_port: str
+    cs_number: int
+    motor_cs_index: dict[Motor, int]
+    motor_acceleration_rate: dict[Motor, float]
+
+    @classmethod
+    async def from_motors(cls, pmac: PmacIO, motors: Sequence[Motor]) -> _PmacMotorInfo:
+        """Creates a _PmacMotorInfo instance based on a  controller and list of motors.
+
+        :param pmac: The PMAC device
+        :param motors: Sequence of motors involved in trajectory
+        :raises RuntimeError:
+            if motors do not share common CS port or CS number, or if
+            motors do not have unique CS index assignments
+        :returns:
+            _PmacMotorInfo instance with motor's common CS port and CS number, and
+            dictionaries of motor's to their unique CS index and accelerate rate
+
+        """
+        assignments = {
+            motor: pmac.assignment[pmac.motor_assignment_index[motor]]
+            for motor in motors
+        }
+
+        cs_ports, cs_numbers, cs_axes, velocities, accls = await asyncio.gather(
+            gather_dict(
+                {motor: assignments[motor].cs_port.get_value() for motor in motors}
+            ),
+            gather_dict(
+                {motor: assignments[motor].cs_number.get_value() for motor in motors}
+            ),
+            gather_dict(
+                {
+                    motor: assignments[motor].cs_axis_letter.get_value()
+                    for motor in motors
+                }
+            ),
+            gather_dict({motor: motor.max_velocity.get_value() for motor in motors}),
+            gather_dict(
+                {motor: motor.acceleration_time.get_value() for motor in motors}
+            ),
+        )
+
+        # check if the values in cs_port and cs_number are the same
+        cs_ports = set(cs_ports.values())
+
+        if len(cs_ports) != 1:
+            raise RuntimeError(
+                "Failed to fetch common CS port."
+                "Motors passed are assigned to multiple CS ports:"
+                f"{list(cs_ports)}"
+            )
+
+        cs_port = cs_ports.pop()
+
+        cs_numbers = set(cs_numbers.values())
+        if len(cs_numbers) != 1:
+            raise RuntimeError(
+                "Failed to fetch common CS number."
+                "Motors passed are assigned to multiple CS numbers:"
+                f"{list(cs_numbers)}"
+            )
+
+        cs_number = cs_numbers.pop()
+
+        motor_cs_index = {}
+        for motor in cs_axes:
+            try:
+                if not cs_axes[motor]:
+                    raise ValueError
+                motor_cs_index[motor] = CS_LETTERS.index(cs_axes[motor])
+            except ValueError as err:
+                raise ValueError(
+                    "Failed to get motor CS index. "
+                    f"Motor {motor.name} assigned to '{cs_axes[motor]}' "
+                    f"but must be assignmed to '{CS_LETTERS}"
+                ) from err
+            if len(set(motor_cs_index.values())) != len(motor_cs_index.items()):
+                raise RuntimeError(
+                    "Failed to fetch distinct CS Axes."
+                    "Motors passed are assigned to the same CS Axis"
+                    f"{list(motor_cs_index)}"
+                )
+
+        motor_acceleration_rate = {
+            motor: float(velocities[motor]) / float(accls[motor])
+            for motor in velocities
+        }
+
+        return _PmacMotorInfo(
+            cs_port, cs_number, motor_cs_index, motor_acceleration_rate
+        )
+
+
+def calculate_ramp_position_and_duration(
+    slice: Slice[Motor], motor_info: _PmacMotorInfo, is_up: bool
+) -> tuple[dict[Motor, float], float]:
+    if slice.duration is None:
+        raise ValueError("Slice must have a duration")
+
+    scan_axes = slice.axes()
+    idx = 0 if is_up else -1
+
+    velocities: dict[Motor, float] = {}
+    ramp_times: list[float] = []
+    for axis in scan_axes:
+        velocity = (slice.upper[axis][idx] - slice.lower[axis][idx]) / slice.duration[
+            idx
+        ]
+        velocities[axis] = velocity
+        ramp_times.append(abs(velocity) / motor_info.motor_acceleration_rate[axis])
+
+    max_ramp_time = max(ramp_times)
+
+    motor_to_ramp_position = {}
+    sign = -1 if is_up else 1
+    for axis, v in velocities.items():
+        ref_pos = slice.lower[axis][0] if is_up else slice.upper[axis][-1]
+        displacement = 0.5 * v * max_ramp_time
+        motor_to_ramp_position[axis] = ref_pos + sign * displacement
+
+    return (motor_to_ramp_position, max_ramp_time)

ophyd_async/plan_stubs/_nd_attributes.py

@@ -1,57 +1,31 @@
 from collections.abc import Sequence
-from xml.etree import ElementTree as ET
 
 import bluesky.plan_stubs as bps
 
-from ophyd_async.core import Device
 from ophyd_async.epics.adcore import (
+    AreaDetector,
     NDArrayBaseIO,
     NDAttributeDataType,
     NDAttributeParam,
     NDAttributePv,
     NDFileHDFIO,
+    ndattributes_to_xml,
 )
 
 
 def setup_ndattributes(
-    device: NDArrayBaseIO, ndattributes: Sequence[NDAttributePv | NDAttributeParam]
+    device: NDArrayBaseIO, ndattributes: Sequence[NDAttributeParam | NDAttributePv]
 ):
-    """Set up attributes on NdArray devices."""
-    root = ET.Element("Attributes")
-
-    for ndattribute in ndattributes:
-        if isinstance(ndattribute, NDAttributeParam):
-            ET.SubElement(
-                root,
-                "Attribute",
-                name=ndattribute.name,
-                type="PARAM",
-                source=ndattribute.param,
-                addr=str(ndattribute.addr),
-                datatype=ndattribute.datatype.value,
-                description=ndattribute.description,
-            )
-        elif isinstance(ndattribute, NDAttributePv):
-            ET.SubElement(
-                root,
-                "Attribute",
-                name=ndattribute.name,
-                type="EPICS_PV",
-                source=ndattribute.signal.source.split("ca://")[-1],
-                dbrtype=ndattribute.dbrtype.value,
-                description=ndattribute.description,
-            )
-        else:
-            raise ValueError(
-                f"Invalid type for ndattributes: {type(ndattribute)}. "
-                "Expected NDAttributePv or NDAttributeParam."
-            )
-    xml_text = ET.tostring(root, encoding="unicode")
-    yield from bps.abs_set(device.nd_attributes_file, xml_text, wait=True)
+    xml = ndattributes_to_xml(ndattributes)
+    yield from bps.abs_set(
+        device.nd_attributes_file,
+        xml,
+        wait=True,
+    )
 
 
-def setup_ndstats_sum(detector: Device):
-    """Set up nd stats for a detector."""
+def setup_ndstats_sum(detector: AreaDetector):
+    """Set up nd stats sum nd attribute for a detector."""
     hdf = getattr(detector, "fileio", None)
     if not isinstance(hdf, NDFileHDFIO):
         msg = (

{ophyd_async-0.12.3.dist-info → ophyd_async-0.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.12.3
+Version: 0.13.0
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License
@@ -49,6 +49,7 @@ Requires-Dist: colorlog
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-numpy
 Requires-Dist: stamina>=23.1.0
+Requires-Dist: scanspec>=1.0a1
 Provides-Extra: sim
 Requires-Dist: h5py; extra == "sim"
 Provides-Extra: ca

{ophyd_async-0.12.3.dist-info → ophyd_async-0.13.0.dist-info}/RECORD

@@ -1,14 +1,15 @@
 ophyd_async/__init__.py,sha256=dcAA3qsj1nNIMe5l-v2tlduZ_ypwBmyuHe45Lsq4k4w,206
 ophyd_async/__main__.py,sha256=n_U4O9bgm97OuboUB_9eK7eFiwy8BZSgXJ0OzbE0DqU,481
 ophyd_async/_docs_parser.py,sha256=gPYrigfSbYCF7QoSf2UvE-cpQu4snSssl7ZWN-kKDzI,352
-ophyd_async/_version.py,sha256=QKKPnNa5xCXCbNQc8EGW9uiKKjn_cC1ywc6jE5v1hDo,513
+ophyd_async/_version.py,sha256=irlt-ETr2vtyV_bhp1DlVRDx0Kx9LTwnA5UW4gdE8ZA,513
 ophyd_async/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/core/__init__.py,sha256=RtYk6FdJxc7lxoSReRV1D7weTRYFu9ylhNNd3DyN904,4752
+ophyd_async/core/__init__.py,sha256=yRb_6ufTXFtf3fagShfmSDfiMduIhvNPgQyM-7GGwas,4929
 ophyd_async/core/_derived_signal.py,sha256=TuZza_j3J1Bw4QSqBYB9Ta2FyQP5BycO3nSHVtJ890Q,13015
 ophyd_async/core/_derived_signal_backend.py,sha256=PYyyont_nUR9LBC9eqVwueHCMwLJfQ_F7R_14sivBTU,12510
-ophyd_async/core/_detector.py,sha256=x1o-eSkvemQ-fTk47440owkTmYhuckA2ILNOCoJlHCY,15201
+ophyd_async/core/_detector.py,sha256=Bl0_bpeAlo8hsp98dCkZnlKwRI0_gtXKKDE0-KrA-3k,14937
 ophyd_async/core/_device.py,sha256=lSm8FBul9NTn9VO0rsAlV9pctJyUsMdU2ztEf5CqH5M,14716
 ophyd_async/core/_device_filler.py,sha256=MDz8eQQ-eEAwo-UEMxfqPfpcBuMG01tLCGR6utwVnmE,14825
+ophyd_async/core/_enums.py,sha256=7VpEvh9tFa-E3wn3x0SdXUlCG7AxSPwCRkf37B-0JbM,313
 ophyd_async/core/_flyer.py,sha256=8zKyU5aQOr_t59GIUwsYeb8NSabdvBp0swwuRe4v5VQ,3457
 ophyd_async/core/_hdf_dataset.py,sha256=0bIX_ZbFSMdXqDwRtEvV-0avHnwXhjPddE5GVNmo7H8,2608
 ophyd_async/core/_log.py,sha256=DxKR4Nz3SgTaTzKBZWqt-w48yT8WUAr_3Qr223TEWRw,3587
@@ -31,20 +32,20 @@ ophyd_async/epics/adandor/__init__.py,sha256=dlitllrAdhvh16PAcVMUSSEytTDNMu6_HuY
 ophyd_async/epics/adandor/_andor.py,sha256=SxAIP9OLefUqKcxrxhjNzil5D8-59Ps0vADdR6scO44,1281
 ophyd_async/epics/adandor/_andor_controller.py,sha256=i0AwWdk9tqB802C9d5gTgYugZ1UOcJCQLk130gVQNeo,1779
 ophyd_async/epics/adandor/_andor_io.py,sha256=DOrni8vcncQ3lW1JOpXo_jwMCLx1qsggbg6FXlsl5Ew,819
-ophyd_async/epics/adaravis/__init__.py,sha256=ZQaJVQiwcQn9hUZADrYgBE1sDfFEwjhVBJRPth1_LBo,395
+ophyd_async/epics/adaravis/__init__.py,sha256=OY3hu1MpHbmQRZMulHC0uWfzoHmhLTvLdSrIhIQZoT0,351
 ophyd_async/epics/adaravis/_aravis.py,sha256=Ju2wuebz9_ovl-Kza39s5VQ1pV-Omt_BaIWKqP4kcGA,1315
-ophyd_async/epics/adaravis/_aravis_controller.py,sha256=WiFR7_FAAu6_88zG-yzGLsR9YcO4L6xR73Wnjw9n0i4,1908
-ophyd_async/epics/adaravis/_aravis_io.py,sha256=af5RxeXF2ligvAXwMNMKHA4QHTR_WmNFz-f18qD2dbg,855
-ophyd_async/epics/adcore/__init__.py,sha256=L7muAe24Uo-ow0CoUTf_ooI2ntA1ZS57TTFimJeBQJ8,1579
+ophyd_async/epics/adaravis/_aravis_controller.py,sha256=aqIIj6awD2h870HAT3rPXg3Ro3G6Hp_vA5TvPbfS05o,1872
+ophyd_async/epics/adaravis/_aravis_io.py,sha256=af639qsO2V8NU5I0LgxK8jrxuhXgM6eMxEFJwsCPdjQ,624
+ophyd_async/epics/adcore/__init__.py,sha256=NWNLe2uFqU86P5mYbKINfHHrUVoTHeDN6829-7lBHxE,1631
 ophyd_async/epics/adcore/_core_detector.py,sha256=mRDaHgXCTZF-MIVsU1csoQx9jObutYDpMWayugx2-jI,2631
-ophyd_async/epics/adcore/_core_io.py,sha256=c1GqAUdv8lAQjklbKHtraLMhPOWEttDCsH9ow7M5I0U,7690
-ophyd_async/epics/adcore/_core_logic.py,sha256=eMS9mIF6Ef2oXg1PmzMyyVviAbhujzYGbZZGq9vzf5k,8896
-ophyd_async/epics/adcore/_core_writer.py,sha256=pcnJhMHuWeZvlCyGSlW1QE_bNZjGbMuI8IsYEVHDtL0,8507
-ophyd_async/epics/adcore/_hdf_writer.py,sha256=AvCv_5dd2HdQoE12_CR6vH2hig2EdEIWklOu6CbPVlc,5816
+ophyd_async/epics/adcore/_core_io.py,sha256=w4IO3OiwCewVWWAJAB9txL_FFjdplE5ggP1OV4lCaKs,9646
+ophyd_async/epics/adcore/_core_logic.py,sha256=uVg5gJCihYLnMbXQjKwb3prM-KoHM5wxjSor9v0HFK0,8900
+ophyd_async/epics/adcore/_core_writer.py,sha256=vRCEPn_52PgMejgtpp00hRlzF20CT9jb3ooR9rZtNRs,8542
+ophyd_async/epics/adcore/_hdf_writer.py,sha256=8rl6NQUt8r_9gTHAUWJq_YJ86f5iUiWadcaROarpLrE,5816
 ophyd_async/epics/adcore/_jpeg_writer.py,sha256=VYpUWQGEjrKG2kiRGQZlBCPXVJ1BzWb9GyB9KhxPWgo,688
 ophyd_async/epics/adcore/_single_trigger.py,sha256=tFGLT1b_rZzAvbqWP-hyCccxJMRY26T5IER-VAqKXmc,1275
 ophyd_async/epics/adcore/_tiff_writer.py,sha256=197Ky9ltsJjUKNwl8_OAuoCe8dWIc7zCFs7wautwC7Y,689
-ophyd_async/epics/adcore/_utils.py,sha256=eujvN4Tip_lIM2gYkbwkH_0cLRQSrQkylQOXUlpCo4k,3868
+ophyd_async/epics/adcore/_utils.py,sha256=L7YQBrsNt6gL1JqVK_rW4fkHaRiDrDYlOtiLakMbXE8,5233
 ophyd_async/epics/adkinetix/__init__.py,sha256=A9xq3lGMrmza9lfukRixC0Up_kUDVFII8JguLr2x7Bw,308
 ophyd_async/epics/adkinetix/_kinetix.py,sha256=zZv0JZ8i1RSx7KBDn_1HGNOY0BoIP81mRK5TKq7d4eA,1302
 ophyd_async/epics/adkinetix/_kinetix_controller.py,sha256=UI-XcQpGj7jq-_e1ceoMOZkyfejwG6H5wX-Ntp_NJjg,1481
@@ -57,12 +58,12 @@ ophyd_async/epics/adsimdetector/__init__.py,sha256=EQqxP5DUvZGLxpvSXPagTPy3ROwE-
 ophyd_async/epics/adsimdetector/_sim.py,sha256=r3SuBENGkOU-8X-i3zDyZljFxf0SmsUfryNPFvP1_os,1147
 ophyd_async/epics/adsimdetector/_sim_controller.py,sha256=EmoorPTvRomEwfioA9UcrnhYaUBkvtLI2WY3zBLd4ec,476
 ophyd_async/epics/adsimdetector/_sim_io.py,sha256=TOQcawMtb0ypwUlPcbwGfvp5ZI9jceB9OXm53WBF1_o,233
-ophyd_async/epics/advimba/__init__.py,sha256=Onoe4N1DgjUZ0-00krm2-iJPXnNF8nPGs6I8pY9wB1g,429
+ophyd_async/epics/advimba/__init__.py,sha256=fPfuakXOwQsFej26gLksqkfBiP6BZlfTyutw1q0tXOM,395
 ophyd_async/epics/advimba/_vimba.py,sha256=4XlEnsJMGDzHLuYaIDUmaxx0gtOAehn5BKBZMUAzoHQ,1241
-ophyd_async/epics/advimba/_vimba_controller.py,sha256=v0av2bGnaJ01w9Igksupt2IlkuBEFlAeRCPOVma-Xa4,1980
-ophyd_async/epics/advimba/_vimba_io.py,sha256=cb2Nfp05fBZAcNVXpz-rqRIRS-TiZW5DPUJOmaFyAw0,1589
+ophyd_async/epics/advimba/_vimba_controller.py,sha256=KSbP4LHqYkCDplpmBk7hdf0Yz9J2vOxWn0fStFFAklA,1942
+ophyd_async/epics/advimba/_vimba_io.py,sha256=CwAUGiCXcu7me7vHjGd2FfUBxUux1eidziYKhKiYoC4,1486
 ophyd_async/epics/core/__init__.py,sha256=q73i4aJ_0HApVNmf3eAw-q30XuazAyZW2MW5TXk-pOY,648
-ophyd_async/epics/core/_aioca.py,sha256=elNR5c2-YcDUoyzuvTEVURoqx92wkVoMDNjwjeZ0WmA,13136
+ophyd_async/epics/core/_aioca.py,sha256=38aW5dd3MzwhoweNMjkOfnfZHI2JZFateO0YABGVSfQ,13230
 ophyd_async/epics/core/_epics_connector.py,sha256=S4z_wbj-aogVcjqCyUgjhcq5Y4gDC7y6wXbsSz2nODY,1918
 ophyd_async/epics/core/_epics_device.py,sha256=wGdR24I7GSPh3HmM7jsWKZhBZgt4IyLrCn4Ut7Wx_xo,510
 ophyd_async/epics/core/_p4p.py,sha256=uWh3oWPme74G4YfeJ6k8ZlHdKOwcf8Xp1J82b9aa_JI,16407
@@ -81,8 +82,9 @@ ophyd_async/epics/demo/point_detector.db,sha256=8kBa3XKpmfXCxetT4tq5_RFXa_XqS1Z2
 ophyd_async/epics/demo/point_detector_channel.db,sha256=FZ9H6HjqplhcF2jgimv_dT1nn-CBlfjs7Y--iCfHp5Y,632
 ophyd_async/epics/eiger/__init__.py,sha256=7kRqVzwoD8PVtp7Nj9iQWlgbLeoWE_8oiq-B0kixwTE,93
 ophyd_async/epics/eiger/_odin_io.py,sha256=JTnsADwNszWJoXpFmdcrZrCDc_RshGlM3Bg_aeUdrUg,6491
-ophyd_async/epics/pmac/__init__.py,sha256=QNL1imf90-4Jedsl1UU0bOF2SH5SWlmqAEVd2OD9_9I,163
-ophyd_async/epics/pmac/_pmac_io.py,sha256=3ngcNE5ytTW8TSnl34roqR9jtAKG0qlHjb44b0fd3Fk,3962
+ophyd_async/epics/pmac/__init__.py,sha256=fQAFnVtzEiPlzXI5XgB62HyburMbUKDfOgkIO_JBPYc,182
+ophyd_async/epics/pmac/_pmac_io.py,sha256=_lTUdNHTWOwPitAxXottyLrmiwhf36WfTbrdneqeg34,4022
+ophyd_async/epics/pmac/_utils.py,sha256=6bb_yKNcmWSfuaYunRv5GcA8ML4jEUsf1jkXko_LSEo,8888
 ophyd_async/epics/testing/__init__.py,sha256=aTIv4D2DYrpnGco5RQF8QuLG1SfFkIlTyM2uYEKXltA,522
 ophyd_async/epics/testing/_example_ioc.py,sha256=uUmfMXV_Pd2SMFyb0y_4uTc6gkGRUqU1cJ-XQC2ROW8,3915
 ophyd_async/epics/testing/_utils.py,sha256=9gxpwaWX0HGtacu1LTupcw7viXN8G78RmuNciU_-cjs,1702
@@ -105,7 +107,7 @@ ophyd_async/fastcs/panda/_writer.py,sha256=UqsU44u0uIqkDNky3mIzhW3OhLeZ8TSqFS666
 ophyd_async/plan_stubs/__init__.py,sha256=sRe1Jna_6i7aKjE3pPzsP4iNMWeWdtiptLnOq9pov9M,619
 ophyd_async/plan_stubs/_ensure_connected.py,sha256=YR6VRj7koccJ4x35NV-Ugl4ZbxgAoGN9PjVIjhv0gpw,894
 ophyd_async/plan_stubs/_fly.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/plan_stubs/_nd_attributes.py,sha256=kwzyUSeidUH714gaZQtJLxCgDZtmIRyyoKBBRbvqg38,2350
+ophyd_async/plan_stubs/_nd_attributes.py,sha256=1g41uLjBGFl9j_xs3I2RlL_IV7aPcRYvdJ_HmNy5urc,1246
 ophyd_async/plan_stubs/_panda.py,sha256=5_Mf9kGzNjXpf_YscpCUE8tgq284nOHWCG7o_LNFfII,463
 ophyd_async/plan_stubs/_settings.py,sha256=e3dGVSUV-Htay_9fKXyQTAQLdjunetGI3OBYp_oC_FY,5574
 ophyd_async/plan_stubs/_utils.py,sha256=zClRo5ve8RGia7wQnby41W-Zprj-slOA5da1LfYnuhw,45
@@ -145,8 +147,8 @@ ophyd_async/testing/_one_of_everything.py,sha256=Di0hPoKwrDOSsx50-2UdSHM2EbIKrPG
 ophyd_async/testing/_single_derived.py,sha256=5-HOTzgePcZ354NK_ssVpyIbJoJmKyjVQCxSwQXUC-4,2730
 ophyd_async/testing/_utils.py,sha256=zClRo5ve8RGia7wQnby41W-Zprj-slOA5da1LfYnuhw,45
 ophyd_async/testing/_wait_for_pending.py,sha256=YZAR48n-CW0GsPey3zFRzMJ4byDAr3HvMIoawjmTrHw,732
-ophyd_async-0.12.3.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.12.3.dist-info/METADATA,sha256=iFBZBqmWlXn03HELUSW5OPBsJdcYikFX6w1BjfMdUP4,7114
-ophyd_async-0.12.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ophyd_async-0.12.3.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.12.3.dist-info/RECORD,,
+ophyd_async-0.13.0.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.13.0.dist-info/METADATA,sha256=VfG70R_jA05hUvMrhl61ySxIeeQ0JGRkw7Yqp6bxpeM,7145
+ophyd_async-0.13.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ophyd_async-0.13.0.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.13.0.dist-info/RECORD,,