ophyd-async 0.3rc2__py3-none-any.whl → 0.3.1__py3-none-any.whl

ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3rc2'
-__version_tuple__ = version_tuple = (0, 3)
+__version__ = version = '0.3.1'
+__version_tuple__ = version_tuple = (0, 3, 1)

ophyd_async/core/detector.py

@@ -63,6 +63,8 @@ class TriggerInfo:
     deadtime: float
     #: What is the maximum high time of the triggers
     livetime: float
+    #: What is the maximum timeout on waiting for a frame
+    frame_timeout: float | None = None
 
 
 class DetectorControl(ABC):
@@ -162,7 +164,6 @@ class StandardDetector(
         writer: DetectorWriter,
         config_sigs: Sequence[AsyncReadable] = (),
         name: str = "",
-        writer_timeout: float = DEFAULT_TIMEOUT,
     ) -> None:
         """
         Constructor
@@ -173,16 +174,11 @@ class StandardDetector(
             config_sigs: Signals to read when describe and read
             configuration are called. Defaults to ().
             name: Device name. Defaults to "".
-            writer_timeout: Timeout for frame writing to start, if the
-            timeout is reached, ophyd-async assumes the detector
-            has a problem and raises an error.
-            Defaults to DEFAULT_TIMEOUT.
         """
         self._controller = controller
         self._writer = writer
         self._describe: Dict[str, DataKey] = {}
         self._config_sigs = list(config_sigs)
-        self._frame_writing_timeout = writer_timeout
         # For prepare
         self._arm_status: Optional[AsyncStatus] = None
         self._trigger_info: Optional[TriggerInfo] = None
@@ -245,17 +241,21 @@ class StandardDetector(
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:
+        # set default trigger_info
+        self._trigger_info = TriggerInfo(
+            num=1, trigger=DetectorTrigger.internal, deadtime=0.0, livetime=0.0
+        )
         # Arm the detector and wait for it to finish.
         indices_written = await self.writer.get_indices_written()
         written_status = await self.controller.arm(
-            num=1,
-            trigger=DetectorTrigger.internal,
+            num=self._trigger_info.num,
+            trigger=self._trigger_info.trigger,
         )
         await written_status
         end_observation = indices_written + 1
 
         async for index in self.writer.observe_indices_written(
-            self._frame_writing_timeout
+            DEFAULT_TIMEOUT + self._trigger_info.livetime + self._trigger_info.deadtime
         ):
             if index >= end_observation:
                 break
@@ -309,7 +309,12 @@ class StandardDetector(
         assert self._arm_status, "Prepare not run"
         assert self._trigger_info
         async for index in self.writer.observe_indices_written(
-            self._frame_writing_timeout
+            self._trigger_info.frame_timeout
+            or (
+                DEFAULT_TIMEOUT
+                + self._trigger_info.livetime
+                + self._trigger_info.deadtime
+            )
         ):
             yield WatcherUpdate(
                 name=self.name,

ophyd_async/core/device_save_loader.py

@@ -1,6 +1,5 @@
 from enum import Enum
-from functools import partial
-from typing import Any, Callable, Dict, Generator, List, Optional, Sequence, Union
+from typing import Any, Callable, Dict, Generator, List, Optional, Sequence
 
 import numpy as np
 import numpy.typing as npt
@@ -8,13 +7,10 @@ import yaml
 from bluesky.plan_stubs import abs_set, wait
 from bluesky.protocols import Location
 from bluesky.utils import Msg
-from epicscorelibs.ca.dbr import ca_array, ca_float, ca_int, ca_str
 
 from .device import Device
 from .signal import SignalRW
 
-CaType = Union[ca_float, ca_int, ca_str, ca_array]
-
 
 def ndarray_representer(dumper: yaml.Dumper, array: npt.NDArray[Any]) -> yaml.Node:
     return dumper.represent_sequence(
@@ -22,19 +18,6 @@ def ndarray_representer(dumper: yaml.Dumper, array: npt.NDArray[Any]) -> yaml.No
     )
 
 
-def ca_dbr_representer(dumper: yaml.Dumper, value: CaType) -> yaml.Node:
-    # if it's an array, just call ndarray_representer...
-    represent_array = partial(ndarray_representer, dumper)
-
-    representers: Dict[CaType, Callable[[CaType], yaml.Node]] = {
-        ca_float: dumper.represent_float,
-        ca_int: dumper.represent_int,
-        ca_str: dumper.represent_str,
-        ca_array: represent_array,
-    }
-    return representers[type(value)](value)
-
-
 class OphydDumper(yaml.Dumper):
     def represent_data(self, data: Any) -> Any:
         if isinstance(data, Enum):
@@ -152,11 +135,6 @@ def save_to_yaml(phases: Sequence[Dict[str, Any]], save_path: str) -> None:
 
     yaml.add_representer(np.ndarray, ndarray_representer, Dumper=yaml.Dumper)
 
-    yaml.add_representer(ca_float, ca_dbr_representer, Dumper=yaml.Dumper)
-    yaml.add_representer(ca_int, ca_dbr_representer, Dumper=yaml.Dumper)
-    yaml.add_representer(ca_str, ca_dbr_representer, Dumper=yaml.Dumper)
-    yaml.add_representer(ca_array, ca_dbr_representer, Dumper=yaml.Dumper)
-
     with open(save_path, "w") as file:
         yaml.dump(phases, file, Dumper=OphydDumper, default_flow_style=False)
 

ophyd_async/core/mock_signal_utils.py

@@ -79,8 +79,22 @@ class _SetValuesIterator:
         return next_value
 
     def __del__(self):
-        if self.require_all_consumed and self.index != len(list(self.values)):
-            raise AssertionError("Not all values have been consumed.")
+        if self.require_all_consumed:
+            # Values is cast to a list here because the user has supplied
+            # require_all_consumed=True, we can therefore assume they
+            # supplied a finite list.
+            # In the case of require_all_consumed=False, an infinite
+            # iterble is permitted
+            values = list(self.values)
+            if self.index != len(values):
+                # Report the values consumed and the values yet to be
+                # consumed
+                consumed = values[0 : self.index]
+                to_be_consumed = values[self.index :]
+                raise AssertionError(
+                    f"{self.signal.name}: {consumed} were consumed "
+                    f"but {to_be_consumed} were not consumed"
+                )
 
 
 def set_mock_values(

ophyd_async/core/signal.py

@@ -57,7 +57,7 @@ class Signal(Device, Generic[T]):
 
     def __init__(
         self,
-        backend: SignalBackend[T],
+        backend: Optional[SignalBackend[T]] = None,
         timeout: Optional[float] = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
@@ -66,13 +66,24 @@ class Signal(Device, Generic[T]):
         super().__init__(name)
 
     async def connect(
-        self, mock=False, timeout=DEFAULT_TIMEOUT, force_reconnect: bool = False
+        self,
+        mock=False,
+        timeout=DEFAULT_TIMEOUT,
+        force_reconnect: bool = False,
+        backend: Optional[SignalBackend[T]] = None,
     ):
+        if backend:
+            if self._initial_backend and backend is not self._initial_backend:
+                raise ValueError(
+                    "Backend at connection different from initialised one."
+                )
+            self._backend = backend
         if mock and not isinstance(self._backend, MockSignalBackend):
             # Using a soft backend, look to the initial value
-            self._backend = MockSignalBackend(
-                initial_backend=self._initial_backend,
-            )
+            self._backend = MockSignalBackend(initial_backend=self._backend)
+
+        if self._backend is None:
+            raise RuntimeError("`connect` called on signal without backend")
         self.log.debug(f"Connecting to {self.source}")
         await self._backend.connect(timeout=timeout)
 
@@ -283,15 +294,15 @@ def soft_signal_r_and_setter(
 
 
 def _generate_assert_error_msg(
-    name: str, expected_result: str, actuall_result: str
+    name: str, expected_result: str, actual_result: str
 ) -> str:
     WARNING = "\033[93m"
     FAIL = "\033[91m"
     ENDC = "\033[0m"
     return (
         f"Expected {WARNING}{name}{ENDC} to produce"
-        + f"\n{FAIL}{actuall_result}{ENDC}"
-        + f"\nbut actually got \n{FAIL}{expected_result}{ENDC}"
+        + f"\n{FAIL}{expected_result}{ENDC}"
+        + f"\nbut actually got \n{FAIL}{actual_result}{ENDC}"
     )
 
 
@@ -313,7 +324,9 @@ async def assert_value(signal: SignalR[T], value: Any) -> None:
     """
     actual_value = await signal.get_value()
     assert actual_value == value, _generate_assert_error_msg(
-        signal.name, value, actual_value
+        name=signal.name,
+        expected_result=value,
+        actual_result=actual_value,
     )
 
 
@@ -338,7 +351,9 @@ async def assert_reading(
     """
     actual_reading = await readable.read()
     assert expected_reading == actual_reading, _generate_assert_error_msg(
-        readable.name, expected_reading, actual_reading
+        name=readable.name,
+        expected_result=expected_reading,
+        actual_result=actual_reading,
     )
 
 
@@ -364,7 +379,9 @@ async def assert_configuration(
     """
     actual_configurable = await configurable.read_configuration()
     assert configuration == actual_configurable, _generate_assert_error_msg(
-        configurable.name, configuration, actual_configurable
+        name=configurable.name,
+        expected_result=configuration,
+        actual_result=actual_configurable,
     )
 
 
@@ -386,11 +403,15 @@ def assert_emitted(docs: Mapping[str, list[dict]], **numbers: int):
         resource=1, datum=1, event=1, stop=1)
     """
     assert list(docs) == list(numbers), _generate_assert_error_msg(
-        "documents", list(numbers), list(docs)
+        name="documents",
+        expected_result=list(numbers),
+        actual_result=list(docs),
     )
     actual_numbers = {name: len(d) for name, d in docs.items()}
     assert actual_numbers == numbers, _generate_assert_error_msg(
-        "emitted", numbers, actual_numbers
+        name="emitted",
+        expected_result=numbers,
+        actual_result=actual_numbers,
     )
 
 

ophyd_async/core/standard_readable.py

@@ -254,6 +254,8 @@ class HintedSignal(HasHints, AsyncReadable):
 
     @property
     def hints(self) -> Hints:
+        if self.signal.name == "":
+            return {"fields": []}
         return {"fields": [self.signal.name]}
 
     @classmethod

ophyd_async/epics/_backend/_aioca.py

@@ -2,8 +2,10 @@ import logging
 import sys
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Dict, Optional, Sequence, Type, Union
+from math import isnan, nan
+from typing import Any, Dict, List, Optional, Type, Union
 
+import numpy as np
 from aioca import (
     FORMAT_CTRL,
     FORMAT_RAW,
@@ -28,7 +30,7 @@ from ophyd_async.core import (
 )
 from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
 
-from .common import get_supported_values
+from .common import LimitPair, Limits, common_meta, get_supported_values
 
 dbr_to_dtype: Dict[Dbr, Dtype] = {
     dbr.DBR_STRING: "string",
@@ -40,6 +42,64 @@ dbr_to_dtype: Dict[Dbr, Dtype] = {
 }
 
 
+def _data_key_from_augmented_value(
+    value: AugmentedValue,
+    *,
+    choices: Optional[List[str]] = None,
+    dtype: Optional[str] = None,
+) -> DataKey:
+    """Use the return value of get with FORMAT_CTRL to construct a DataKey
+    describing the signal. See docstring of AugmentedValue for expected
+    value fields by DBR type.
+
+    Args:
+        value (AugmentedValue): Description of the the return type of a DB record
+        choices: Optional list of enum choices to pass as metadata in the datakey
+        dtype: Optional override dtype when AugmentedValue is ambiguous, e.g. booleans
+
+    Returns:
+        DataKey: A rich DataKey describing the DB record
+    """
+    source = f"ca://{value.name}"
+    assert value.ok, f"Error reading {source}: {value}"
+
+    scalar = value.element_count == 1
+    dtype = dtype or dbr_to_dtype[value.datatype]
+
+    d = DataKey(
+        source=source,
+        dtype=dtype if scalar else "array",
+        # strictly value.element_count >= len(value)
+        shape=[] if scalar else [len(value)],
+    )
+    for key in common_meta:
+        attr = getattr(value, key, nan)
+        if isinstance(attr, str) or not isnan(attr):
+            d[key] = attr
+
+    if choices is not None:
+        d["choices"] = choices
+
+    if limits := _limits_from_augmented_value(value):
+        d["limits"] = limits
+
+    return d
+
+
+def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
+    def get_limits(limit: str) -> LimitPair:
+        low = getattr(value, f"lower_{limit}_limit", None)
+        high = getattr(value, f"upper_{limit}_limit", None)
+        return LimitPair(low=low, high=high)
+
+    return Limits(
+        alarm=get_limits("alarm"),
+        control=get_limits("ctrl"),
+        display=get_limits("disp"),
+        warning=get_limits("warning"),
+    )
+
+
 @dataclass
 class CaConverter:
     read_dbr: Optional[Dbr]
@@ -49,7 +109,10 @@ class CaConverter:
         return value
 
     def value(self, value: AugmentedValue):
-        return value
+        # for channel access ca_xxx classes, this
+        # invokes __pos__ operator to return an instance of
+        # the builtin base class
+        return +value
 
     def reading(self, value: AugmentedValue):
         return {
@@ -58,8 +121,8 @@ class CaConverter:
             "alarm_severity": -1 if value.severity > 2 else value.severity,
         }
 
-    def get_datakey(self, source: str, value: AugmentedValue) -> DataKey:
-        return {"source": source, "dtype": dbr_to_dtype[value.datatype], "shape": []}
+    def get_datakey(self, value: AugmentedValue) -> DataKey:
+        return _data_key_from_augmented_value(value)
 
 
 class CaLongStrConverter(CaConverter):
@@ -73,12 +136,17 @@ class CaLongStrConverter(CaConverter):
 
 
 class CaArrayConverter(CaConverter):
-    def get_datakey(self, source: str, value: AugmentedValue) -> DataKey:
-        return {"source": source, "dtype": "array", "shape": [len(value)]}
+    def value(self, value: AugmentedValue):
+        return np.array(value, copy=False)
 
 
 @dataclass
 class CaEnumConverter(CaConverter):
+    """To prevent issues when a signal is restarted and returns with different enum
+    values or orders, we put treat an Enum signal as a string, and cache the
+    choices on this class.
+    """
+
     choices: dict[str, str]
 
     def write_value(self, value: Union[Enum, str]):
@@ -90,13 +158,18 @@ class CaEnumConverter(CaConverter):
     def value(self, value: AugmentedValue):
         return self.choices[value]
 
-    def get_datakey(self, source: str, value: AugmentedValue) -> DataKey:
-        return {
-            "source": source,
-            "dtype": "string",
-            "shape": [],
-            "choices": list(self.choices),
-        }
+    def get_datakey(self, value: AugmentedValue) -> DataKey:
+        # Sometimes DBR_TYPE returns as String, must pass choices still
+        return _data_key_from_augmented_value(value, choices=list(self.choices.keys()))
+
+
+@dataclass
+class CaBoolConverter(CaConverter):
+    def value(self, value: AugmentedValue) -> bool:
+        return bool(value)
+
+    def get_datakey(self, value: AugmentedValue) -> DataKey:
+        return _data_key_from_augmented_value(value, dtype="bool")
 
 
 class DisconnectedCaConverter(CaConverter):
@@ -115,8 +188,10 @@ def make_converter(
         return CaLongStrConverter()
     elif is_array and pv_dbr == dbr.DBR_STRING:
         # Waveform of strings, check we wanted this
-        if datatype and datatype != Sequence[str]:
-            raise TypeError(f"{pv} has type [str] not {datatype.__name__}")
+        if datatype:
+            datatype_dtype = get_dtype(datatype)
+            if not datatype_dtype or not np.can_cast(datatype_dtype, np.str_):
+                raise TypeError(f"{pv} has type [str] not {datatype.__name__}")
         return CaArrayConverter(pv_dbr, None)
     elif is_array:
         pv_dtype = get_unique({k: v.dtype for k, v in values.items()}, "dtypes")
@@ -136,7 +211,7 @@ def make_converter(
         )
         if pv_choices_len != 2:
             raise TypeError(f"{pv} has {pv_choices_len} choices, can't map to bool")
-        return CaConverter(dbr.DBR_SHORT, dbr.DBR_SHORT)
+        return CaBoolConverter(dbr.DBR_SHORT, dbr.DBR_SHORT)
     elif pv_dbr == dbr.DBR_ENUM:
         # This is an Enum
         pv_choices = get_unique(
@@ -224,7 +299,7 @@ class CaSignalBackend(SignalBackend[T]):
 
     async def get_datakey(self, source: str) -> DataKey:
         value = await self._caget(FORMAT_CTRL)
-        return self.converter.get_datakey(source, value)
+        return self.converter.get_datakey(value)
 
     async def get_reading(self) -> Reading:
         value = await self._caget(FORMAT_TIME)

ophyd_async/epics/_backend/_p4p.py

@@ -4,6 +4,7 @@ import logging
 import time
 from dataclasses import dataclass
 from enum import Enum
+from math import isnan, nan
 from typing import Any, Dict, List, Optional, Sequence, Type, Union
 
 from bluesky.protocols import DataKey, Dtype, Reading
@@ -20,7 +21,7 @@ from ophyd_async.core import (
 )
 from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
 
-from .common import get_supported_values
+from .common import LimitPair, Limits, common_meta, get_supported_values
 
 # https://mdavidsaver.github.io/p4p/values.html
 specifier_to_dtype: Dict[str, Dtype] = {
@@ -39,6 +40,67 @@ specifier_to_dtype: Dict[str, Dtype] = {
 }
 
 
+def _data_key_from_value(
+    source: str,
+    value: Value,
+    *,
+    shape: Optional[list[int]] = None,
+    choices: Optional[list[str]] = None,
+    dtype: Optional[str] = None,
+) -> DataKey:
+    """
+    Args:
+        value (Value): Description of the the return type of a DB record
+        shape: Optional override shape when len(shape) > 1
+        choices: Optional list of enum choices to pass as metadata in the datakey
+        dtype: Optional override dtype when AugmentedValue is ambiguous, e.g. booleans
+
+    Returns:
+        DataKey: A rich DataKey describing the DB record
+    """
+    shape = shape or []
+    dtype = dtype or specifier_to_dtype[value.type().aspy("value")]
+    display_data = getattr(value, "display", None)
+
+    d = DataKey(
+        source=source,
+        dtype=dtype,
+        shape=shape,
+    )
+    if display_data is not None:
+        for key in common_meta:
+            attr = getattr(display_data, key, nan)
+            if isinstance(attr, str) or not isnan(attr):
+                d[key] = attr
+
+    if choices is not None:
+        d["choices"] = choices
+
+    if limits := _limits_from_value(value):
+        d["limits"] = limits
+
+    return d
+
+
+def _limits_from_value(value: Value) -> Limits:
+    def get_limits(
+        substucture_name: str, low_name: str = "limitLow", high_name: str = "limitHigh"
+    ) -> LimitPair:
+        substructure = getattr(value, substucture_name, None)
+        low = getattr(substructure, low_name, nan)
+        high = getattr(substructure, high_name, nan)
+        return LimitPair(
+            low=None if isnan(low) else low, high=None if isnan(high) else high
+        )
+
+    return Limits(
+        alarm=get_limits("valueAlarm", "lowAlarmLimit", "highAlarmLimit"),
+        control=get_limits("control"),
+        display=get_limits("display"),
+        warning=get_limits("valueAlarm", "lowWarningLimit", "highWarningLimit"),
+    )
+
+
 class PvaConverter:
     def write_value(self, value):
         return value
@@ -56,8 +118,7 @@ class PvaConverter:
         }
 
     def get_datakey(self, source: str, value) -> DataKey:
-        dtype = specifier_to_dtype[value.type().aspy("value")]
-        return {"source": source, "dtype": dtype, "shape": []}
+        return _data_key_from_value(source, value)
 
     def metadata_fields(self) -> List[str]:
         """
@@ -74,7 +135,9 @@ class PvaConverter:
 
 class PvaArrayConverter(PvaConverter):
     def get_datakey(self, source: str, value) -> DataKey:
-        return {"source": source, "dtype": "array", "shape": [len(value["value"])]}
+        return _data_key_from_value(
+            source, value, dtype="array", shape=[len(value["value"])]
+        )
 
 
 class PvaNDArrayConverter(PvaConverter):
@@ -98,7 +161,7 @@ class PvaNDArrayConverter(PvaConverter):
 
     def get_datakey(self, source: str, value) -> DataKey:
         dims = self._get_dimensions(value)
-        return {"source": source, "dtype": "array", "shape": dims}
+        return _data_key_from_value(source, value, dtype="array", shape=dims)
 
     def write_value(self, value):
         # No clear use-case for writing directly to an NDArray, and some
@@ -109,6 +172,11 @@ class PvaNDArrayConverter(PvaConverter):
 
 @dataclass
 class PvaEnumConverter(PvaConverter):
+    """To prevent issues when a signal is restarted and returns with different enum
+    values or orders, we put treat an Enum signal as a string, and cache the
+    choices on this class.
+    """
+
     def __init__(self, choices: dict[str, str]):
         self.choices = tuple(choices.values())
 
@@ -122,20 +190,17 @@ class PvaEnumConverter(PvaConverter):
         return self.choices[value["value"]["index"]]
 
     def get_datakey(self, source: str, value) -> DataKey:
-        return {
-            "source": source,
-            "dtype": "string",
-            "shape": [],
-            "choices": list(self.choices),
-        }
+        return _data_key_from_value(
+            source, value, choices=list(self.choices), dtype="string"
+        )
 
 
-class PvaEnumBoolConverter(PvaConverter):
+class PvaEmumBoolConverter(PvaConverter):
     def value(self, value):
-        return value["value"]["index"]
+        return bool(value["value"]["index"])
 
     def get_datakey(self, source: str, value) -> DataKey:
-        return {"source": source, "dtype": "integer", "shape": []}
+        return _data_key_from_value(source, value, dtype="bool")
 
 
 class PvaTableConverter(PvaConverter):
@@ -144,7 +209,7 @@ class PvaTableConverter(PvaConverter):
 
     def get_datakey(self, source: str, value) -> DataKey:
         # This is wrong, but defer until we know how to actually describe a table
-        return {"source": source, "dtype": "object", "shape": []}  # type: ignore
+        return _data_key_from_value(source, value, dtype="object")
 
 
 class PvaDictConverter(PvaConverter):
@@ -213,7 +278,7 @@ def make_converter(datatype: Optional[Type], values: Dict[str, Any]) -> PvaConve
         )
         if pv_choices_len != 2:
             raise TypeError(f"{pv} has {pv_choices_len} choices, can't map to bool")
-        return PvaEnumBoolConverter()
+        return PvaEmumBoolConverter()
     elif "NTEnum" in typeid:
         # This is an Enum
         pv_choices = get_unique(

ophyd_async/epics/_backend/common.py

@@ -1,5 +1,28 @@
 from enum import Enum
-from typing import Dict, Optional, Tuple, Type
+from typing import Dict, Optional, Tuple, Type, TypedDict
+
+common_meta = {
+    "units",
+    "precision",
+}
+
+
+class LimitPair(TypedDict):
+    high: float | None
+    low: float | None
+
+    def __bool__(self) -> bool:
+        return self.low is None and self.high is None
+
+
+class Limits(TypedDict):
+    alarm: LimitPair
+    control: LimitPair
+    display: LimitPair
+    warning: LimitPair
+
+    def __bool__(self) -> bool:
+        return any(self.alarm, self.control, self.display, self.warning)
 
 
 def get_supported_values(

ophyd_async/epics/areadetector/controllers/pilatus_controller.py

@@ -1,6 +1,7 @@
 import asyncio
 from typing import Optional
 
+from ophyd_async.core import DEFAULT_TIMEOUT, wait_for_value
 from ophyd_async.core.async_status import AsyncStatus
 from ophyd_async.core.detector import DetectorControl, DetectorTrigger
 from ophyd_async.epics.areadetector.drivers.ad_base import (
@@ -23,14 +24,13 @@ class PilatusController(DetectorControl):
     def __init__(
         self,
         driver: PilatusDriver,
+        readout_time: float,
     ) -> None:
         self._drv = driver
+        self._readout_time = readout_time
 
     def get_deadtime(self, exposure: float) -> float:
-        # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
-        """The required minimum time difference between ExpPeriod and ExpTime
-        (readout time) is 2.28 ms"""
-        return 2.28e-3
+        return self._readout_time
 
     async def arm(
         self,
@@ -45,7 +45,20 @@ class PilatusController(DetectorControl):
             self._drv.num_images.set(999_999 if num == 0 else num),
             self._drv.image_mode.set(ImageMode.multiple),
         )
-        return await start_acquiring_driver_and_ensure_status(self._drv)
+
+        # Standard arm the detector and wait for the acquire PV to be True
+        idle_status = await start_acquiring_driver_and_ensure_status(self._drv)
+
+        # The pilatus has an additional PV that goes True when the camserver
+        # is actually ready. Should wait for that too or we risk dropping
+        # a frame
+        await wait_for_value(
+            self._drv.armed_for_triggers,
+            True,
+            timeout=DEFAULT_TIMEOUT,
+        )
+
+        return idle_status
 
     @classmethod
     def _get_trigger_mode(cls, trigger: DetectorTrigger) -> PilatusTriggerMode:

ophyd_async/epics/areadetector/drivers/pilatus_driver.py

@@ -1,7 +1,6 @@
 from enum import Enum
 
-from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
-
+from ...signal import epics_signal_r, epics_signal_rw_rbv
 from .ad_base import ADBase
 
 
@@ -18,4 +17,5 @@ class PilatusDriver(ADBase):
         self.trigger_mode = epics_signal_rw_rbv(
             PilatusTriggerMode, prefix + "TriggerMode"
         )
+        self.armed_for_triggers = epics_signal_r(bool, prefix + "Armed")
         super().__init__(prefix, name)

ophyd_async/epics/areadetector/pilatus.py

@@ -1,3 +1,5 @@
+from enum import Enum
+
 from bluesky.protocols import Hints
 
 from ophyd_async.core import DirectoryProvider
@@ -11,6 +13,20 @@ from ophyd_async.epics.areadetector.writers.hdf_writer import HDFWriter
 from ophyd_async.epics.areadetector.writers.nd_file_hdf import NDFileHDF
 
 
+#: Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
+#: The required minimum time difference between ExpPeriod and ExpTime
+#: (readout time) is 2.28 ms
+#: We provide an option to override for newer Pilatus models
+class PilatusReadoutTime(float, Enum):
+    """Pilatus readout time per model in ms"""
+
+    # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
+    pilatus2 = 2.28e-3
+
+    # Cite: https://media.dectris.com/user-manual-pilatus3-2020.pdf
+    pilatus3 = 0.95e-3
+
+
 class PilatusDetector(StandardDetector):
     """A Pilatus StandardDetector writing HDF files"""
 
@@ -21,15 +37,16 @@ class PilatusDetector(StandardDetector):
         self,
         prefix: str,
         directory_provider: DirectoryProvider,
-        drv_suffix="cam1:",
-        hdf_suffix="HDF1:",
-        name="",
+        readout_time: PilatusReadoutTime = PilatusReadoutTime.pilatus3,
+        drv_suffix: str = "cam1:",
+        hdf_suffix: str = "HDF1:",
+        name: str = "",
     ):
         self.drv = PilatusDriver(prefix + drv_suffix)
         self.hdf = NDFileHDF(prefix + hdf_suffix)
 
         super().__init__(
-            PilatusController(self.drv),
+            PilatusController(self.drv, readout_time=readout_time.value),
             HDFWriter(
                 self.hdf,
                 directory_provider,

ophyd_async/epics/pvi/pvi.py

@@ -179,7 +179,15 @@ def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
                 sub_device_2 = device_cls(SoftSignalBackend(signal_dtype))
                 sub_device = DeviceVector({1: sub_device_1, 2: sub_device_2})
             else:
-                sub_device = DeviceVector({1: device_cls(), 2: device_cls()})
+                if hasattr(device, device_name):
+                    sub_device = getattr(device, device_name)
+                else:
+                    sub_device = DeviceVector(
+                        {
+                            1: device_cls(),
+                            2: device_cls(),
+                        }
+                    )
 
                 for sub_device_in_vector in sub_device.values():
                     _mock_common_blocks(sub_device_in_vector, stripped_type=device_cls)
@@ -296,7 +304,9 @@ async def fill_pvi_entries(
 
 
 def create_children_from_annotations(
-    device: Device, included_optional_fields: Tuple[str, ...] = ()
+    device: Device,
+    included_optional_fields: Tuple[str, ...] = (),
+    device_vectors: Optional[Dict[str, int]] = None,
 ):
     """For intializing blocks at __init__ of ``device``."""
     for name, device_type in get_type_hints(type(device)).items():
@@ -307,12 +317,22 @@ def create_children_from_annotations(
             continue
         is_device_vector, device_type = _strip_device_vector(device_type)
         if (
-            is_device_vector
+            (is_device_vector and (not device_vectors or name not in device_vectors))
             or ((origin := get_origin(device_type)) and issubclass(origin, Signal))
             or (isclass(device_type) and issubclass(device_type, Signal))
         ):
             continue
 
-        sub_device = device_type()
-        setattr(device, name, sub_device)
-        create_children_from_annotations(sub_device)
+        if is_device_vector:
+            n_device_vector = DeviceVector(
+                {i: device_type() for i in range(1, device_vectors[name] + 1)}
+            )
+            setattr(device, name, n_device_vector)
+            for sub_device in n_device_vector.values():
+                create_children_from_annotations(
+                    sub_device, device_vectors=device_vectors
+                )
+        else:
+            sub_device = device_type()
+            setattr(device, name, sub_device)
+            create_children_from_annotations(sub_device, device_vectors=device_vectors)

ophyd_async/panda/_hdf_panda.py

@@ -38,7 +38,6 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
             writer=writer,
             config_sigs=config_sigs,
             name=name,
-            writer_timeout=DEFAULT_TIMEOUT,
         )
 
     async def connect(

ophyd_async/plan_stubs/fly.py

@@ -18,6 +18,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
     shutter_time: float,
     repeats: int = 1,
     period: float = 0.0,
+    frame_timeout: float | None = None,
 ):
     """Prepare a hardware triggered flyable and one or more detectors.
 
@@ -39,6 +40,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
         trigger=DetectorTrigger.constant_gate,
         deadtime=deadtime,
         livetime=exposure,
+        frame_timeout=frame_timeout,
     )
     trigger_time = number_of_frames * (exposure + deadtime)
     pre_delay = max(period - 2 * shutter_time - trigger_time, 0)
@@ -120,6 +122,7 @@ def time_resolved_fly_and_collect_with_static_seq_table(
     shutter_time: float,
     repeats: int = 1,
     period: float = 0.0,
+    frame_timeout: float | None = None,
 ):
     """Run a scan wth a flyer and multiple detectors.
 
@@ -144,6 +147,7 @@ def time_resolved_fly_and_collect_with_static_seq_table(
         shutter_time=shutter_time,
         repeats=repeats,
         period=period,
+        frame_timeout=frame_timeout,
     )
     # Run the fly scan
     yield from fly_and_collect(stream_name, flyer, detectors)

ophyd_async/sim/sim_pattern_generator.py

@@ -16,7 +16,6 @@ class SimPatternDetector(StandardDetector):
         path: Path,
         config_sigs: Sequence[AsyncReadable] = [],
         name: str = "sim_pattern_detector",
-        writer_timeout: float = 1,
     ) -> None:
         self.directory_provider: DirectoryProvider = StaticDirectoryProvider(path)
         self.pattern_generator = PatternGenerator()
@@ -33,5 +32,4 @@ class SimPatternDetector(StandardDetector):
             writer=writer,
             config_sigs=config_sigs,
             name=name,
-            writer_timeout=writer_timeout,
         )

{ophyd_async-0.3rc2.dist-info → ophyd_async-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3rc2
+Version: 0.3.1
 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
@@ -96,7 +96,7 @@ Requires-Dist: p4p ; extra == 'pva'
 
 # ophyd-async
 
-Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
+Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango.
 
 |    Source     |     <https://github.com/bluesky/ophyd-async>      |
 | :-----------: | :-----------------------------------------------: |

{ophyd_async-0.3rc2.dist-info → ophyd_async-0.3.1.dist-info}/RECORD

@@ -1,31 +1,31 @@
 ophyd_async/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
 ophyd_async/__main__.py,sha256=G-Zcv_G9zK7Nhx6o5L5w-wyhMxdl_WgyMELu8IMFqAE,328
-ophyd_async/_version.py,sha256=Q6NCoABIZDCaoLXsuU8odM9VJngCLNAvP46RIhMvPN0,409
+ophyd_async/_version.py,sha256=HzPz9rq3s1AiZXregKlqKaJJ2wGMtvH_a3V9la9CnpM,411
 ophyd_async/log.py,sha256=DbMjt0bkfUOLHIinZYt0Q0FHZmCXXi5x8y0uFiEmqoQ,3587
 ophyd_async/protocols.py,sha256=EF2W9nfElV-0QNMYrX1zusL1PqDJR3kNsjlalR29j0I,3412
 ophyd_async/core/__init__.py,sha256=znjVeRfrDVJbGLEkUczeKMW46kV6HDrlE4lV0SqvZt4,2952
 ophyd_async/core/_providers.py,sha256=LrlTMPHKXWOPVkpAOw-pqBq0kip-c3C9ZZPoFfiaV4M,2212
 ophyd_async/core/async_status.py,sha256=9TOgOXIAuH62RDo5t-Y5GdjrJ76d_6TFlBxYv-5_a88,4367
-ophyd_async/core/detector.py,sha256=8mdLKphirgit5CVCklJI9eHqKKiCz4CYs9BElo10-lc,11007
+ophyd_async/core/detector.py,sha256=NMX8y_yiViHbv3CaJ7LxzXYkH6tCWI3LocpQ3w4lGEQ,11176
 ophyd_async/core/device.py,sha256=280zFnLCoiMZAA-Dh1_AjUSnhxUfKYGgj4H_2S1njOA,7086
-ophyd_async/core/device_save_loader.py,sha256=RXA3dPUPihAR2ZGDStlGiA-TAsr_xqL0snsCjMsMnfA,9138
+ophyd_async/core/device_save_loader.py,sha256=EK7FB5oWiLI_s2KZ1BNDQ2AUKVbFLlimMl0vXfsjcgo,8223
 ophyd_async/core/flyer.py,sha256=bIjzBkrl8HVAlKgsZ_FF0WL69Qvksyzp9ZWmTLl8Yrw,2304
 ophyd_async/core/mock_signal_backend.py,sha256=Ug6jK72wm9vM6EueoUrYgcXtiFzdPUEISRe86LdyYKc,2844
-ophyd_async/core/mock_signal_utils.py,sha256=bF8MVZA1j9zCmS2tBbgUdfwNmcHniHixnmotjd0g7hs,4083
-ophyd_async/core/signal.py,sha256=FbTb5qDPLhVxEbh6gimqXfkZwcqB4ymHTEYVXZVZYrk,16456
+ophyd_async/core/mock_signal_utils.py,sha256=LE8VxNq3jfaTePnHHpZpKCi1vwKi8EIg-g1jfw-Q5bQ,4726
+ophyd_async/core/signal.py,sha256=_sEe__VbP7fZfdOG2NjiTMZRFHQ0ckSmwhq1qiAEiXM,17144
 ophyd_async/core/signal_backend.py,sha256=fT3q0WED3JHmNKYCs7PzDLCK4cUPVin3wQjDNPdHqAY,1525
 ophyd_async/core/soft_signal_backend.py,sha256=56zvcEi4c8n1yYbafTbp7X0VhSkhoehm3L8RBhu2fik,5596
-ophyd_async/core/standard_readable.py,sha256=uVG3vs3s7-Kzg5dRCtT4I2mhZPqwVGYy2dxNmaOpDVU,8980
+ophyd_async/core/standard_readable.py,sha256=fhq_WAZtLYWrw6DvvrFRYRAPOUP2_IcX4qLucoEEeOg,9049
 ophyd_async/core/utils.py,sha256=3oZcXNqAUHX4ZWMBH5gSuK6cFWEhSkZ9GSDYv0pf8jc,5783
 ophyd_async/epics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ophyd_async/epics/_backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/epics/_backend/_aioca.py,sha256=cpPNZmRMi7FnAh2-3ec5uklLVFOqsmEmpI1nh5Ud1Ls,8794
-ophyd_async/epics/_backend/_p4p.py,sha256=lIKx7kQ2o8h3M4wPwrq8JBo8xuDnasJxpDH2ATVBY78,12257
-ophyd_async/epics/_backend/common.py,sha256=16mAuxDwA3eZFjUW8DHMabaW3CtEI0Qe8DLpP2xlW7Y,814
+ophyd_async/epics/_backend/_aioca.py,sha256=dDwzjR8Xez7qF50b0cH3f0lAteaFMlQu2HLpBtkmz5c,11250
+ophyd_async/epics/_backend/_p4p.py,sha256=oCT8MeVWlhmsxZ8YRSrelrY8W3NvfpXcMlfAKL_AUNY,14331
+ophyd_async/epics/_backend/common.py,sha256=VDL4hiSn-C_yF3-PZoc46IXnmOHyrClNwIwLzEvx9Ww,1259
 ophyd_async/epics/areadetector/__init__.py,sha256=ViKzx-wUxkRyNR33wfpL11QB97o0J47_KMyI2C_NphI,510
 ophyd_async/epics/areadetector/aravis.py,sha256=YklN4V0loqUQBs4swVX304N49JIGPvrNOk8iA5EWofg,2127
 ophyd_async/epics/areadetector/kinetix.py,sha256=7rE2MLnz9DEmeiN9pCekDfpXuZ2DErnMajRp_9eoLZY,1359
-ophyd_async/epics/areadetector/pilatus.py,sha256=ki-BOBCEIiUD2wAtmujBIB1eX-nbXB4yMLJK_Q3opRM,1398
+ophyd_async/epics/areadetector/pilatus.py,sha256=hs3v8QUIwTHNg7i1mRSg9SbIIsoUZg90OxJ740gEKpo,2044
 ophyd_async/epics/areadetector/single_trigger_det.py,sha256=U92dqhioIfnve3jtCThq9gXBCdEzzqzY4ezk6rZV19g,1182
 ophyd_async/epics/areadetector/utils.py,sha256=p66UbVdKRFj6Sm1Qvm23kmlVyBMMqIvXFxA3x17YnSk,2824
 ophyd_async/epics/areadetector/vimba.py,sha256=IxG8KLzfb84iLtzf6ZoX9JikqZLP49lwkWu33bkDV9Y,1291
@@ -33,13 +33,13 @@ ophyd_async/epics/areadetector/controllers/__init__.py,sha256=af58ci7X2z2s_FyUwR
 ophyd_async/epics/areadetector/controllers/ad_sim_controller.py,sha256=mthZ6WxajMEgUKptq3bnkIctbLhjzTagV66i1auB8cg,1587
 ophyd_async/epics/areadetector/controllers/aravis_controller.py,sha256=CIfnZdq_NobO_UMC2TJoAfUEP9GlzZg5z5bz6Dn1DxY,2669
 ophyd_async/epics/areadetector/controllers/kinetix_controller.py,sha256=9QmydX85QOXfQL_UX49M9EQ2b2hUZPVzLxgGQn-A9Oc,1611
-ophyd_async/epics/areadetector/controllers/pilatus_controller.py,sha256=cd1CKkaXlwkpQ0I1VL7nN0U8R4VweTsa08WhvHYI4nY,2243
+ophyd_async/epics/areadetector/controllers/pilatus_controller.py,sha256=jJdY97JATz-bWtEPtmnyQ-Zyjvhy2M78i0wUuXO2dtE,2617
 ophyd_async/epics/areadetector/controllers/vimba_controller.py,sha256=Eh4Hr9rWgq1mKvE93JzgixntjPHxF3_07GTFqiOdZqE,2123
 ophyd_async/epics/areadetector/drivers/__init__.py,sha256=-Ib0Lz4fFQQmB7K0uFxMDvAerkLxadMQERH7lNAvrs4,495
 ophyd_async/epics/areadetector/drivers/ad_base.py,sha256=18WFAiWEUg0H2LcvTQHrKYj2wThGafQzDpiyAWki6vo,3411
 ophyd_async/epics/areadetector/drivers/aravis_driver.py,sha256=PmIygsVNoxxYHvZZzFAbAm2DXmXFc13nAzL_DJB6YSU,1464
 ophyd_async/epics/areadetector/drivers/kinetix_driver.py,sha256=yIV23BkGBJ4i0VskLiLL7AFbadCCR6Ch1UwUDJ9r2YM,743
-ophyd_async/epics/areadetector/drivers/pilatus_driver.py,sha256=0DsUu9vAPXDa2v8_V0f_kPjBtLu3y4_EkmFfFjYO4Gk,553
+ophyd_async/epics/areadetector/drivers/pilatus_driver.py,sha256=0DBBuiR_FtwzVVdDW0ifdSrdKZtnprWuy87g66o8RlQ,619
 ophyd_async/epics/areadetector/drivers/vimba_driver.py,sha256=J54VtWkOklfbSqZYxGWH1e6Uzm9_Gph_ZbCf9Zax0LU,1713
 ophyd_async/epics/areadetector/writers/__init__.py,sha256=tpPcrYd1hs8WS7C0gmCnR2EBwjE5RzCljI7WwZ2V_LM,191
 ophyd_async/epics/areadetector/writers/_hdfdataset.py,sha256=E0C9VgsPyY35h7k0mvcIhjsIVNavApLxizqNWlM388w,167
@@ -54,13 +54,13 @@ ophyd_async/epics/demo/sensor.db,sha256=AVtiydrdtwAz2EFurO2Ult9SSRtre3r0akOBbL98
 ophyd_async/epics/motion/__init__.py,sha256=tnmVRIwKa9PdN_xonJdAUD04UpEceh-hoD7XI62yDB0,46
 ophyd_async/epics/motion/motor.py,sha256=G8cc-okSXJ6s2fGxRO155xm7PrBbVImBmBMRWts895k,3630
 ophyd_async/epics/pvi/__init__.py,sha256=TbOQNY4enQWgtr1T7x129vpo2p7FIFlr8cyZqqv5Lk4,158
-ophyd_async/epics/pvi/pvi.py,sha256=PJdY3rCRyIQbsbHDru-TJ-IVOItyaQwCQKAC0Widu6A,11363
+ophyd_async/epics/pvi/pvi.py,sha256=Kc3klnA9F82h_p2atFYXe-wFO9OzN5TV69Tc56tD2do,12204
 ophyd_async/epics/signal/__init__.py,sha256=JXKBSGpRL9y3auh27JRxsqDn_rBOXpJjtd4nCuDOX2g,261
 ophyd_async/epics/signal/_epics_transport.py,sha256=DEIL0iYUAWssysVEgWGu1fHSM1l-ATV2kjUgPtDN9LY,858
 ophyd_async/epics/signal/signal.py,sha256=M8ZVG_zLdYJfroCRX-u_w8c3yIhswSRw8e3RkW2szio,3166
 ophyd_async/panda/__init__.py,sha256=FuSnvp-RtdA0X4RcHEF0nTiXymRts2MNdFmF_1_i41w,775
 ophyd_async/panda/_common_blocks.py,sha256=n0PPc1rar43oDSIA-yNubTc8fR5YCW1tyjQU58whsg0,1038
-ophyd_async/panda/_hdf_panda.py,sha256=QjfZyYos0ZBlIqBiZ5UbyEd_wuh_cGzwV8QE9jvLiIY,1419
+ophyd_async/panda/_hdf_panda.py,sha256=TWzBnyJcLmltQyOr5nXbCAZdVRqY633ogBX6pY06p3g,1375
 ophyd_async/panda/_panda_controller.py,sha256=dIqcjmaIHVrki8UXSoDx46kk6I2Lhpe2o3sXNg5f-RQ,1238
 ophyd_async/panda/_table.py,sha256=dLoRP4zYNOkD_s0Vkp2wVYAwkjVG8nNdf8-FaXOTfPo,5655
 ophyd_async/panda/_trigger.py,sha256=tBH8uq_4o1ASG9yofVxq3tjf5v8LPzniDTRL4yjramI,1195
@@ -70,17 +70,17 @@ ophyd_async/panda/writers/_hdf_writer.py,sha256=vnyIg3JmlzMIIq75o0IDMfGzBm_GJAhO
 ophyd_async/panda/writers/_panda_hdf_file.py,sha256=42iHaTax4JjOBpNC7d4nkNL9SM14OTnFPTIcXv2jg-4,1759
 ophyd_async/plan_stubs/__init__.py,sha256=nO9ELG9J7fYwfVTVRWVorz4kffeszYpwk1ROh6Ha--w,405
 ophyd_async/plan_stubs/ensure_connected.py,sha256=1MkDu8UqVRPHLnW9IXRn-QvKiG8-rCV8T4KDbjf9K6w,557
-ophyd_async/plan_stubs/fly.py,sha256=nl8XLoY7hvlam6H3zl4NcPRUiEJ3xIjopHEfA0ehTDg,4845
+ophyd_async/plan_stubs/fly.py,sha256=fQwBeLw57-NeBsroVxKDa8kpuu6fgTWYWimbsatCL28,4999
 ophyd_async/sim/__init__.py,sha256=ScjH1g7FMo5yPACfJRZE6xGBWCHU4bKDzNQk1tqObnA,366
 ophyd_async/sim/pattern_generator.py,sha256=pvSk2zb82D08j2jiKAMqMAfRohGnYd_rpjUraLrCD6c,10640
 ophyd_async/sim/sim_pattern_detector_control.py,sha256=Ypz8IuRYAY2J243IhVbNyGr_Z-XtpJZ1qxma6NR3TgM,1838
 ophyd_async/sim/sim_pattern_detector_writer.py,sha256=ESpcVyHd1TP7Cojznv2hJAwLinu3XbgAiVKfX12FCII,1237
-ophyd_async/sim/sim_pattern_generator.py,sha256=fbcwWxTPYKLK33OzIY15vGylnonOO8HIudz1y_56GZU,1336
+ophyd_async/sim/sim_pattern_generator.py,sha256=L4jTnEVUFBRXIWq_UMHqx00YDdbGO2pjo_IuuVwpzXE,1258
 ophyd_async/sim/demo/__init__.py,sha256=9mxKpslrL89cfSj4g3og8Br3O--pMj3hhWZS-Xu6kyA,56
 ophyd_async/sim/demo/sim_motor.py,sha256=a2p5wnHXjF-V5zOFai7jnszk4kbGmrZRnUqBtkOgEfQ,3733
-ophyd_async-0.3rc2.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.3rc2.dist-info/METADATA,sha256=TRb7FrOHb4YrISGe-fkGY_W3kkrnBvioFJsgErNLmo8,6285
-ophyd_async-0.3rc2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-ophyd_async-0.3rc2.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
-ophyd_async-0.3rc2.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.3rc2.dist-info/RECORD,,
+ophyd_async-0.3.1.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.3.1.dist-info/METADATA,sha256=1xYSDLCGtf6W32lecy26DElymc-bVECyyKjtKhAU-Eg,6285
+ophyd_async-0.3.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+ophyd_async-0.3.1.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
+ophyd_async-0.3.1.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.3.1.dist-info/RECORD,,