ophyd-async 0.10.0a3__py3-none-any.whl → 0.10.1__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.10.0a3'
-__version_tuple__ = version_tuple = (0, 10, 0, 'a3')
+__version__ = version = '0.10.1'
+__version_tuple__ = version_tuple = (0, 10, 1)

ophyd_async/core/__init__.py

@@ -75,11 +75,13 @@ from ._utils import (
     DEFAULT_TIMEOUT,
     CalculatableTimeout,
     Callback,
+    EnumTypes,
     LazyMock,
     NotConnected,
     Reference,
     StrictEnum,
     SubsetEnum,
+    SupersetEnum,
     WatcherUpdate,
     gather_dict,
     get_dtype,
@@ -122,6 +124,8 @@ __all__ = [
     "Array1D",
     "StrictEnum",
     "SubsetEnum",
+    "SupersetEnum",
+    "EnumTypes",
     "Table",
     "SignalMetadata",
     # Soft signal

ophyd_async/core/_derived_signal.py

@@ -1,5 +1,7 @@
 from collections.abc import Awaitable, Callable
-from typing import Any, Generic, get_type_hints, is_typeddict
+from typing import Any, Generic, get_args, get_origin, get_type_hints, is_typeddict
+
+from bluesky.protocols import Locatable
 
 from ._derived_signal_backend import (
     DerivedSignalBackend,
@@ -8,7 +10,7 @@ from ._derived_signal_backend import (
     TransformT,
 )
 from ._device import Device
-from ._signal import SignalR, SignalRW, SignalT, SignalW
+from ._signal import Signal, SignalR, SignalRW, SignalT, SignalW
 from ._signal_backend import SignalDatatypeT
 
 
@@ -35,15 +37,27 @@ class DerivedSignalFactory(Generic[TransformT]):
         self._set_derived = set_derived
         # Check the raw and transform devices match the input arguments of the Transform
         if transform_cls is not Transform:
-            expected = list(transform_cls.model_fields) + [
-                x
-                for x in get_type_hints(transform_cls.raw_to_derived)
-                if x not in ["self", "return"]
-            ]
-            if set(expected) != set(raw_and_transform_devices):
+            # Populate expected parameters and types
+            expected = {
+                **{k: f.annotation for k, f in transform_cls.model_fields.items()},
+                **{
+                    k: v
+                    for k, v in get_type_hints(transform_cls.raw_to_derived).items()
+                    if k not in {"self", "return"}
+                },
+            }
+
+            # Populate received parameters and types
+            # Use Signal datatype, or Locatable datatype, or set type as None
+            received = {
+                k: v.datatype if isinstance(v, Signal) else get_locatable_type(v)
+                for k, v in raw_and_transform_devices.items()
+            }
+
+            if expected != received:
                 msg = (
-                    f"Expected devices to be passed as keyword arguments {expected}, "
-                    f"got {list(raw_and_transform_devices)}"
+                    f"Expected devices to be passed as keyword arguments "
+                    f"{expected}, got {received}"
                 )
                 raise TypeError(msg)
         self._set_derived_takes_dict = (
@@ -234,7 +248,7 @@ def derived_signal_rw(
     if raw_to_derived_datatype != set_derived_datatype:
         msg = (
             f"{raw_to_derived} has datatype {raw_to_derived_datatype} "
-            f"!= {set_derived_datatype} dataype {set_derived_datatype}"
+            f"!= {set_derived_datatype} datatype {set_derived_datatype}"
         )
         raise TypeError(msg)
 
@@ -269,3 +283,17 @@ def derived_signal_w(
         units=derived_units,
         precision=derived_precision,
     )
+
+
+def get_locatable_type(obj: object) -> type | None:
+    """Extract datatype from Locatable parent class.
+
+    :param obj: Object with possible Locatable inheritance
+    :return: Type hint associated with Locatable, or None if not found.
+    """
+    for base in getattr(obj.__class__, "__orig_bases__", []):
+        if get_origin(base) is Locatable:
+            args = get_args(base)
+            if args:
+                return args[0]
+    return None

ophyd_async/core/_derived_signal_backend.py

@@ -61,7 +61,7 @@ class Transform(BaseModel, Generic[RawT, DerivedT]):
 TransformT = TypeVar("TransformT", bound=Transform)
 
 
-def filter_by_type(raw_devices: Mapping[str, Any], type_: type[T]) -> dict[str, T]:
+def validate_by_type(raw_devices: Mapping[str, Any], type_: type[T]) -> dict[str, T]:
     filtered_devices: dict[str, T] = {}
     for name, device in raw_devices.items():
         if not isinstance(device, type_):
@@ -91,21 +91,23 @@ class SignalTransformer(Generic[TransformT]):
 
     @cached_property
     def raw_locatables(self) -> dict[str, AsyncLocatable]:
-        return filter_by_type(self._raw_devices, AsyncLocatable)
+        return validate_by_type(self._raw_devices, AsyncLocatable)
 
     @cached_property
     def transform_readables(self) -> dict[str, AsyncReadable]:
-        return filter_by_type(self._transform_devices, AsyncReadable)
+        return validate_by_type(self._transform_devices, AsyncReadable)
 
     @cached_property
     def raw_and_transform_readables(self) -> dict[str, AsyncReadable]:
-        return filter_by_type(
+        return validate_by_type(
             self._raw_devices | self._transform_devices, AsyncReadable
         )
 
     @cached_property
     def raw_and_transform_subscribables(self) -> dict[str, Subscribable]:
-        return filter_by_type(self._raw_devices | self._transform_devices, Subscribable)
+        return validate_by_type(
+            self._raw_devices | self._transform_devices, Subscribable
+        )
 
     def _complete_cached_reading(self) -> dict[str, Reading] | None:
         if self._cached_readings and len(self._cached_readings) == len(

ophyd_async/core/_detector.py

@@ -328,10 +328,10 @@ class StandardDetector(
             if isinstance(value.number_of_events, list)
             else [value.number_of_events]
         )
-        self._describe, _ = await asyncio.gather(
-            self._writer.open(self.name, value.exposures_per_event),
-            self._controller.prepare(value),
-        )
+
+        await self._controller.prepare(value)
+        self._describe = await self._writer.open(self.name, value.exposures_per_event)
+
         self._initial_frame = await self._writer.get_indices_written()
         if value.trigger != DetectorTrigger.INTERNAL:
             await self._controller.arm()

ophyd_async/core/_hdf_dataset.py

@@ -23,7 +23,7 @@ class HDFDatasetDescription(BaseModel):
     """The dataset name within the HDF file,
     e.g. /entry/data/data or /entry/instrument/NDAttributes/sum"""
 
-    shape: tuple[int, ...] = Field(default_factory=tuple)
+    shape: tuple[int | None, ...] = Field(default_factory=tuple)
     """The shape of a single event's data in the HDF file,
     e.g. (1, 768, 1024) for arrays or () for scalars"""
 

ophyd_async/core/_providers.py

@@ -228,5 +228,5 @@ class DatasetDescriber(Protocol):
         """Return the numpy datatype for this dataset."""
 
     @abstractmethod
-    async def shape(self) -> tuple[int, ...]:
+    async def shape(self) -> tuple[int | None, ...]:
         """Get the shape of the data collection."""

ophyd_async/core/_signal.py

@@ -100,6 +100,11 @@ class Signal(Device, Generic[SignalDatatypeT]):
         """
         return self._connector.backend.source(self.name, read=True)
 
+    @property
+    def datatype(self) -> type[SignalDatatypeT] | None:
+        """Returns the datatype of the signal."""
+        return self._connector.backend.datatype
+
 
 SignalT = TypeVar("SignalT", bound=Signal)
 
@@ -158,7 +163,12 @@ class _SignalCache(Generic[SignalDatatypeT]):
             self._notify(function, want_value)
 
     def unsubscribe(self, function: Callback) -> bool:
-        self._listeners.pop(function)
+        _listener = self._listeners.pop(function, None)
+        if not _listener:
+            self._signal.log.warning(
+                f"Unsubscribe failed: subscriber {function} was not found "
+                f" in listeners list: {list(self._listeners)}"
+            )
         return self._staged or bool(self._listeners)
 
     def set_staged(self, staged: bool) -> bool:
@@ -431,8 +441,8 @@ async def observe_signals_value(
         Call subscribe_value on all the signals at the start, and clear_sub on
         it at the end.
     :param timeout:
-        If given, how long to wait for each updated value in seconds. If an
-        update is not produced in this time then raise asyncio.TimeoutError.
+        If given, how long to wait for ANY updated value from shared queue in seconds.
+        If an update is not produced in this time then raise asyncio.TimeoutError.
     :param done_status:
         If this status is complete, stop observing and make the iterator return.
         If it raises an exception then this exception will be raised by the
@@ -454,8 +464,10 @@ async def observe_signals_value(
     q: asyncio.Queue[tuple[SignalR[SignalDatatypeT], SignalDatatypeT] | Status] = (
         asyncio.Queue()
     )
-
+    # dict to store signal subscription to remove it later
     cbs: dict[SignalR, Callback] = {}
+
+    # subscribe signal to update queue and fill cbs dict
     for signal in signals:
 
         def queue_value(value: SignalDatatypeT, signal=signal):
@@ -468,6 +480,7 @@ async def observe_signals_value(
         done_status.add_callback(q.put_nowait)
     overall_deadline = time.monotonic() + done_timeout if done_timeout else None
     try:
+        last_item = ()
         while True:
             if overall_deadline and time.monotonic() >= overall_deadline:
                 raise asyncio.TimeoutError(
@@ -476,14 +489,22 @@ async def observe_signals_value(
                     f"timeout {done_timeout}s"
                 )
             iteration_timeout = _get_iteration_timeout(timeout, overall_deadline)
-            item = await asyncio.wait_for(q.get(), iteration_timeout)
+            try:
+                item = await asyncio.wait_for(q.get(), iteration_timeout)
+            except asyncio.TimeoutError as exc:
+                raise asyncio.TimeoutError(
+                    f"Timeout Error while waiting {iteration_timeout}s to update "
+                    f"{[signal.source for signal in signals]}. "
+                    f"Last observed signal and value were {last_item}"
+                ) from exc
             if done_status and item is done_status:
                 if exc := done_status.exception():
                     raise exc
                 else:
                     break
             else:
-                yield cast(tuple[SignalR[SignalDatatypeT], SignalDatatypeT], item)
+                last_item = cast(tuple[SignalR[SignalDatatypeT], SignalDatatypeT], item)
+                yield last_item
     finally:
         for signal, cb in cbs.items():
             signal.clear_sub(cb)

ophyd_async/core/_signal_backend.py

@@ -6,8 +6,16 @@ import numpy as np
 from bluesky.protocols import Reading
 from event_model import DataKey, Dtype, Limits
 
+from ophyd_async.core._utils import (
+    Callback,
+    EnumTypes,
+    StrictEnum,
+    SubsetEnum,
+    SupersetEnum,
+    get_enum_cls,
+)
+
 from ._table import Table
-from ._utils import Callback, StrictEnum, get_enum_cls
 
 DTypeScalar_co = TypeVar("DTypeScalar_co", covariant=True, bound=np.generic)
 """A numpy dtype like [](#numpy.float64)."""
@@ -24,7 +32,7 @@ E.g. `Array1D[np.float64]` is a 1D numpy array of 64-bit floats."""
 Primitive = bool | int | float | str
 SignalDatatype = (
     Primitive
-    | StrictEnum
+    | EnumTypes
     | Array1D[np.bool_]
     | Array1D[np.int8]
     | Array1D[np.uint8]
@@ -39,16 +47,18 @@ SignalDatatype = (
     | np.ndarray
     | Sequence[str]
     | Sequence[StrictEnum]
+    | Sequence[SubsetEnum]
+    | Sequence[SupersetEnum]
     | Table
 )
 """The supported [](#Signal) datatypes:
 
 - A python primitive [](#bool), [](#int), [](#float), [](#str)
-- A [](#StrictEnum) or [](#SubsetEnum) subclass
+- An [](#EnumTypes) subclass
 - A fixed datatype [](#Array1D) of numpy bool, signed and unsigned integers or float
 - A [](#numpy.ndarray) which can change dimensions and datatype at runtime
 - A sequence of [](#str)
-- A sequence of [](#StrictEnum) or [](#SubsetEnum) subclass
+- A sequence of [](#EnumTypes) subclasses
 - A [](#Table) subclass
 """
 # TODO: These typevars will not be needed when we drop python 3.11
@@ -58,7 +68,7 @@ PrimitiveT = TypeVar("PrimitiveT", bound=Primitive)
 SignalDatatypeT = TypeVar("SignalDatatypeT", bound=SignalDatatype)
 """A typevar for a [](#SignalDatatype)."""
 SignalDatatypeV = TypeVar("SignalDatatypeV", bound=SignalDatatype)
-EnumT = TypeVar("EnumT", bound=StrictEnum)
+EnumT = TypeVar("EnumT", bound=EnumTypes)
 TableT = TypeVar("TableT", bound=Table)
 
 
@@ -136,7 +146,7 @@ def _datakey_dtype(datatype: type[SignalDatatype]) -> Dtype:
         or issubclass(datatype, Table)
     ):
         return "array"
-    elif issubclass(datatype, StrictEnum):
+    elif issubclass(datatype, EnumTypes):
         return "string"
     elif issubclass(datatype, Primitive):
         return _primitive_dtype[datatype]
@@ -153,7 +163,7 @@ def _datakey_dtype_numpy(
     elif (
         get_origin(datatype) is Sequence
         or datatype is str
-        or issubclass(datatype, StrictEnum)
+        or issubclass(datatype, EnumTypes)
     ):
         # TODO: use np.dtypes.StringDType when we can use in structured arrays
         # https://github.com/numpy/numpy/issues/25693
@@ -166,8 +176,8 @@ def _datakey_dtype_numpy(
         raise TypeError(f"Can't make dtype_numpy for {datatype}")
 
 
-def _datakey_shape(value: SignalDatatype) -> list[int]:
-    if type(value) in _primitive_dtype or isinstance(value, StrictEnum):
+def _datakey_shape(value: SignalDatatype) -> list[int | None]:
+    if type(value) in _primitive_dtype or isinstance(value, EnumTypes):
         return []
     elif isinstance(value, np.ndarray):
         return list(value.shape)

ophyd_async/core/_utils.py

@@ -5,7 +5,15 @@ import logging
 from collections.abc import Awaitable, Callable, Iterable, Mapping, Sequence
 from dataclasses import dataclass
 from enum import Enum, EnumMeta
-from typing import Any, Generic, Literal, ParamSpec, TypeVar, get_args, get_origin
+from typing import (
+    Any,
+    Generic,
+    Literal,
+    ParamSpec,
+    TypeVar,
+    get_args,
+    get_origin,
+)
 from unittest.mock import Mock
 
 import numpy as np
@@ -19,20 +27,16 @@ DEFAULT_TIMEOUT = 10.0
 logger = logging.getLogger("ophyd_async")
 
 
-class StrictEnumMeta(EnumMeta):
-    def __new__(metacls, *args, **kwargs):
-        ret = super().__new__(metacls, *args, **kwargs)
+class UppercaseNameEnumMeta(EnumMeta):
+    def __new__(cls, *args, **kwargs):
+        ret = super().__new__(cls, *args, **kwargs)
         lowercase_names = [x.name for x in ret if not x.name.isupper()]  # type: ignore
         if lowercase_names:
             raise TypeError(f"Names {lowercase_names} should be uppercase")
         return ret
 
 
-class StrictEnum(str, Enum, metaclass=StrictEnumMeta):
-    """All members should exist in the Backend, and there will be no extras."""
-
-
-class SubsetEnumMeta(StrictEnumMeta):
+class AnyStringUppercaseNameEnumMeta(UppercaseNameEnumMeta):
     def __call__(self, value, *args, **kwargs):  # type: ignore
         """Return given value if it is a string and not a member of the enum.
 
@@ -54,10 +58,21 @@ class SubsetEnumMeta(StrictEnumMeta):
         return super().__call__(value, *args, **kwargs)
 
 
-class SubsetEnum(StrictEnum, metaclass=SubsetEnumMeta):
+class StrictEnum(str, Enum, metaclass=UppercaseNameEnumMeta):
+    """All members should exist in the Backend, and there will be no extras."""
+
+
+class SubsetEnum(str, Enum, metaclass=AnyStringUppercaseNameEnumMeta):
     """All members should exist in the Backend, but there may be extras."""
 
 
+class SupersetEnum(str, Enum, metaclass=UppercaseNameEnumMeta):
+    """Some members should exist in the Backend, and there should be no extras."""
+
+
+EnumTypes = StrictEnum | SubsetEnum | SupersetEnum
+
+
 CALCULATE_TIMEOUT = "CALCULATE_TIMEOUT"
 """Sentinel used to implement ``myfunc(timeout=CalculateTimeout)``
 
@@ -207,10 +222,11 @@ def get_dtype(datatype: type) -> np.dtype:
     return np.dtype(get_args(get_args(datatype)[1])[0])
 
 
-def get_enum_cls(datatype: type | None) -> type[StrictEnum] | None:
+def get_enum_cls(datatype: type | None) -> type[EnumTypes] | None:
     """Get the enum class from a datatype.
 
-    :raises TypeError: if type is not a [](#StrictEnum) or [](#SubsetEnum) subclass
+    :raises TypeError: if type is not a [](#StrictEnum) or [](#SubsetEnum)
+    or [](#SupersetEnum) subclass
     ```python
     >>> from ophyd_async.core import StrictEnum
     >>> from collections.abc import Sequence
@@ -227,10 +243,11 @@ def get_enum_cls(datatype: type | None) -> type[StrictEnum] | None:
     if get_origin(datatype) is Sequence:
         datatype = get_args(datatype)[0]
     if datatype and issubclass(datatype, Enum):
-        if not issubclass(datatype, StrictEnum):
+        if not issubclass(datatype, EnumTypes):
             raise TypeError(
                 f"{datatype} should inherit from ophyd_async.core.SubsetEnum "
-                "or ophyd_async.core.StrictEnum"
+                "or ophyd_async.core.StrictEnum "
+                "or ophyd_async.core.SupersetEnum."
             )
         return datatype
     return None

ophyd_async/epics/adcore/_core_detector.py

@@ -22,8 +22,8 @@ class AreaDetector(StandardDetector[ADBaseControllerT, ADWriter]):
         self.fileio = writer.fileio
 
         if plugins is not None:
-            for name, plugin in plugins.items():
-                setattr(self, name, plugin)
+            for plugin_name, plugin in plugins.items():
+                setattr(self, plugin_name, plugin)
 
         super().__init__(
             controller,

ophyd_async/epics/adcore/_core_io.py

@@ -70,14 +70,14 @@ class NDPluginStatsIO(NDPluginBaseIO):
     # Basic statistics
     compute_statistics: A[SignalRW[bool], PvSuffix.rbv("ComputeStatistics")]
     bgd_width: A[SignalRW[int], PvSuffix.rbv("BgdWidth")]
-    total_array: A[SignalRW[float], PvSuffix.rbv("TotalArray")]
+    total: A[SignalR[float], PvSuffix.rbv("Total")]
     # Centroid statistics
     compute_centroid: A[SignalRW[bool], PvSuffix.rbv("ComputeCentroid")]
     centroid_threshold: A[SignalRW[float], PvSuffix.rbv("CentroidThreshold")]
     # X and Y Profiles
     compute_profiles: A[SignalRW[bool], PvSuffix.rbv("ComputeProfiles")]
-    profile_size_x: A[SignalRW[int], PvSuffix.rbv("ProfileSizeX")]
-    profile_size_y: A[SignalRW[int], PvSuffix.rbv("ProfileSizeY")]
+    profile_size_x: A[SignalR[int], PvSuffix.rbv("ProfileSizeX")]
+    profile_size_y: A[SignalR[int], PvSuffix.rbv("ProfileSizeY")]
     cursor_x: A[SignalRW[int], PvSuffix.rbv("CursorX")]
     cursor_y: A[SignalRW[int], PvSuffix.rbv("CursorY")]
     # Array Histogram

ophyd_async/epics/adcore/_core_logic.py

@@ -7,6 +7,7 @@ from ophyd_async.core import (
     DetectorController,
     DetectorTrigger,
     TriggerInfo,
+    observe_value,
     set_and_wait_for_value,
 )
 
@@ -89,34 +90,57 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
                 self.driver.acquire_period.set(full_frame_time, timeout=timeout),
             )
 
-    async def start_acquiring_driver_and_ensure_status(self) -> AsyncStatus:
+    async def start_acquiring_driver_and_ensure_status(
+        self,
+        start_timeout: float = DEFAULT_TIMEOUT,
+        state_timeout: float = DEFAULT_TIMEOUT,
+    ) -> AsyncStatus:
         """Start acquiring driver, raising ValueError if the detector is in a bad state.
 
         This sets driver.acquire to True, and waits for it to be True up to a timeout.
         Then, it checks that the DetectorState PV is in DEFAULT_GOOD_STATES,
         and otherwise raises a ValueError.
 
+
+        :param start_timeout:
+            Timeout used for waiting for the driver to start
+            acquiring.
+        :param state_timeout:
+            Timeout used for waiting for the detector to be in a good
+            state after it stops acquiring.
         :returns AsyncStatus:
             An AsyncStatus that can be awaited to set driver.acquire to True and perform
             subsequent raising (if applicable) due to detector state.
+
         """
         status = await set_and_wait_for_value(
             self.driver.acquire,
             True,
-            timeout=DEFAULT_TIMEOUT,
+            timeout=start_timeout,
             wait_for_set_completion=False,
         )
 
         async def complete_acquisition() -> None:
-            # NOTE: possible race condition here between the callback from
-            # set_and_wait_for_value and the detector state updating.
             await status
-            state = await self.driver.detector_state.get_value()
-            if state not in self.good_states:
-                raise ValueError(
-                    f"Final detector state {state.value} not "
-                    "in valid end states: {self.good_states}"
-                )
+            state = None
+            try:
+                async for state in observe_value(
+                    self.driver.detector_state, done_timeout=state_timeout
+                ):
+                    if state in self.good_states:
+                        return
+            except asyncio.TimeoutError as exc:
+                if state is not None:
+                    raise ValueError(
+                        f"Final detector state {state.value} not in valid end "
+                        f"states: {self.good_states}"
+                    ) from exc
+                else:
+                    # No updates from the detector, something else is wrong
+                    raise asyncio.TimeoutError(
+                        "Could not monitor detector state: "
+                        + self.driver.detector_state.source
+                    ) from exc
 
         return AsyncStatus(complete_acquisition())
 

ophyd_async/epics/adcore/_hdf_writer.py

@@ -1,6 +1,7 @@
 import asyncio
 from collections.abc import AsyncIterator
 from pathlib import Path
+from typing import TypeGuard
 from xml.etree import ElementTree as ET
 
 from bluesky.protocols import StreamAsset
@@ -22,6 +23,10 @@ from ._utils import (
 )
 
 
+def _is_fully_described(shape: tuple[int | None, ...]) -> TypeGuard[tuple[int, ...]]:
+    return None not in shape
+
+
 class ADHDFWriter(ADWriter[NDFileHDFIO]):
     """Allow `NDFileHDFIO` to be used within `StandardDetector`."""
 
@@ -75,6 +80,16 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         # Determine number of frames that will be saved per HDF chunk
         frames_per_chunk = await self.fileio.num_frames_chunks.get_value()
 
+        if not _is_fully_described(detector_shape):
+            # Questions:
+            # - Can AreaDetector support this?
+            # - How to deal with chunking?
+            # Don't support for now - leave option open to support it later
+            raise ValueError(
+                "Datasets with partially unknown dimensionality "
+                "are not currently supported by ADHDFWriter."
+            )
+
         # Add the main data
         self._datasets = [
             HDFDatasetDescription(

ophyd_async/epics/adcore/_utils.py

@@ -7,11 +7,12 @@ from ophyd_async.core import (
     SignalRW,
     StrictEnum,
     SubsetEnum,
+    SupersetEnum,
     wait_for_value,
 )
 
 
-class ADBaseDataType(StrictEnum):
+class ADBaseDataType(SupersetEnum):
     INT8 = "Int8"
     UINT8 = "UInt8"
     INT16 = "Int16"
@@ -22,6 +23,9 @@ class ADBaseDataType(StrictEnum):
     UINT64 = "UInt64"
     FLOAT32 = "Float32"
     FLOAT64 = "Float64"
+    # Driver database override will blank the enum string if it doesn't
+    # support a datatype
+    UNDEFINED = ""
 
 
 def convert_ad_dtype_to_np(ad_dtype: ADBaseDataType) -> str:
@@ -37,7 +41,12 @@ def convert_ad_dtype_to_np(ad_dtype: ADBaseDataType) -> str:
         ADBaseDataType.FLOAT32: "<f4",
         ADBaseDataType.FLOAT64: "<f8",
     }
-    return ad_dtype_to_np_dtype[ad_dtype]
+    np_type = ad_dtype_to_np_dtype.get(ad_dtype)
+    if np_type is None:
+        raise ValueError(
+            "Areadetector driver has a blank DataType, this is not supported"
+        )
+    return np_type
 
 
 def convert_pv_dtype_to_np(datatype: str) -> str:

ophyd_async/epics/adpilatus/_pilatus.py

@@ -27,7 +27,7 @@ class PilatusDetector(AreaDetector[PilatusController]):
         config_sigs: Sequence[SignalR] = (),
     ):
         driver = PilatusDriverIO(prefix + drv_suffix)
-        controller = PilatusController(driver)
+        controller = PilatusController(driver, readout_time=readout_time)
 
         writer = writer_cls.with_io(
             prefix,

ophyd_async/epics/adpilatus/_pilatus_controller.py

@@ -29,6 +29,7 @@ class PilatusController(adcore.ADBaseController[PilatusDriverIO]):
         DetectorTrigger.INTERNAL: PilatusTriggerMode.INTERNAL,
         DetectorTrigger.CONSTANT_GATE: PilatusTriggerMode.EXT_ENABLE,
         DetectorTrigger.VARIABLE_GATE: PilatusTriggerMode.EXT_ENABLE,
+        DetectorTrigger.EDGE_TRIGGER: PilatusTriggerMode.EXT_TRIGGER,
     }
 
     def __init__(
@@ -49,7 +50,9 @@ class PilatusController(adcore.ADBaseController[PilatusDriverIO]):
                 trigger_info.livetime
             )
         await asyncio.gather(
-            self.driver.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
+            self.driver.trigger_mode.set(
+                self._supported_trigger_types[trigger_info.trigger]
+            ),
             self.driver.num_images.set(
                 999_999
                 if trigger_info.total_number_of_exposures == 0
@@ -70,13 +73,3 @@ class PilatusController(adcore.ADBaseController[PilatusDriverIO]):
             True,
             timeout=DEFAULT_TIMEOUT,
         )
-
-    @classmethod
-    def _get_trigger_mode(cls, trigger: DetectorTrigger) -> PilatusTriggerMode:
-        if trigger not in cls._supported_trigger_types.keys():
-            raise ValueError(
-                f"{cls.__name__} only supports the following trigger "
-                f"types: {cls._supported_trigger_types.keys()} but was asked to "
-                f"use {trigger}"
-            )
-        return cls._supported_trigger_types[trigger]

ophyd_async/epics/core/_aioca.py

@@ -1,7 +1,7 @@
 import logging
 import sys
 import typing
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from functools import cache
 from math import isnan, nan
 from typing import Any, Generic, cast
@@ -146,7 +146,7 @@ class CaBoolConverter(CaConverter[bool]):
 
 
 class CaEnumConverter(CaConverter[str]):
-    def __init__(self, supported_values: dict[str, str]):
+    def __init__(self, supported_values: Mapping[str, str]):
         self.supported_values = supported_values
         super().__init__(
             str, dbr.DBR_STRING, metadata=SignalMetadata(choices=list(supported_values))

ophyd_async/epics/core/_util.py

@@ -1,16 +1,20 @@
-from collections.abc import Sequence
-from typing import Any, get_args, get_origin
+from collections.abc import Mapping, Sequence
+from typing import Any, TypeVar, get_args, get_origin
 
 import numpy as np
 
 from ophyd_async.core import (
     SignalBackend,
     SignalDatatypeT,
+    StrictEnum,
     SubsetEnum,
+    SupersetEnum,
     get_dtype,
     get_enum_cls,
 )
 
+T = TypeVar("T")
+
 
 def get_pv_basename_and_field(pv: str) -> tuple[str, str | None]:
     """Split PV into record name and field."""
@@ -23,26 +27,30 @@ def get_pv_basename_and_field(pv: str) -> tuple[str, str | None]:
 
 def get_supported_values(
     pv: str,
-    datatype: type,
+    datatype: type[T],
     pv_choices: Sequence[str],
-) -> dict[str, str]:
+) -> Mapping[str, T | str]:
     enum_cls = get_enum_cls(datatype)
     if not enum_cls:
         raise TypeError(f"{datatype} is not an Enum")
     choices = [v.value for v in enum_cls]
     error_msg = f"{pv} has choices {pv_choices}, but {datatype} requested {choices} "
-    if issubclass(enum_cls, SubsetEnum):
+    if issubclass(enum_cls, StrictEnum):
+        if set(choices) != set(pv_choices):
+            raise TypeError(error_msg + "to be strictly equal to them.")
+    elif issubclass(enum_cls, SubsetEnum):
         if not set(choices).issubset(pv_choices):
             raise TypeError(error_msg + "to be a subset of them.")
+    elif issubclass(enum_cls, SupersetEnum):
+        if not set(pv_choices).issubset(choices):
+            raise TypeError(error_msg + "to be a superset of them.")
     else:
-        if set(choices) != set(pv_choices):
-            raise TypeError(error_msg + "to be strictly equal to them.")
-
-    # Take order from the pv choices
-    supported_values = {x: x for x in pv_choices}
-    # But override those that we specify via the datatype
-    for v in enum_cls:
-        supported_values[v.value] = v
+        raise TypeError(f"{datatype} is not a StrictEnum, SubsetEnum, or SupersetEnum")
+    # Create a map from the string value to the enum instance
+    # For StrictEnum and SupersetEnum, all values here will be enum values
+    # For SubsetEnum, only the values in choices will be enum values, the rest will be
+    # strings
+    supported_values = {x: enum_cls(x) for x in pv_choices}
     return supported_values
 
 

ophyd_async/epics/eiger/_odin_io.py

@@ -10,9 +10,10 @@ from ophyd_async.core import (
     Device,
     DeviceVector,
     PathProvider,
+    Reference,
+    SignalR,
     StrictEnum,
     observe_value,
-    set_and_wait_for_other_value,
     set_and_wait_for_value,
     wait_for_value,
 )
@@ -51,7 +52,7 @@ class Odin(Device):
 
         self.capture = epics_signal_rw(Writing, f"{prefix}Capture")
         self.capture_rbv = epics_signal_r(str, prefix + "Capture_RBV")
-        self.num_captured = epics_signal_r(int, f"{prefix}NumCapture_RBV")
+        self.num_captured = epics_signal_r(int, f"{prefix}NumCaptured_RBV")
         self.num_to_capture = epics_signal_rw_rbv(int, f"{prefix}NumCapture")
 
         self.start_timeout = epics_signal_rw(str, f"{prefix}StartTimeout")
@@ -80,9 +81,11 @@ class OdinWriter(DetectorWriter):
         self,
         path_provider: PathProvider,
         odin_driver: Odin,
+        eiger_bit_depth: SignalR[int],
     ) -> None:
         self._drv = odin_driver
         self._path_provider = path_provider
+        self._eiger_bit_depth = Reference(eiger_bit_depth)
         super().__init__()
 
     async def open(self, name: str, exposures_per_event: int = 1) -> dict[str, DataKey]:
@@ -92,24 +95,20 @@ class OdinWriter(DetectorWriter):
         await asyncio.gather(
             self._drv.file_path.set(str(info.directory_path)),
             self._drv.file_name.set(info.filename),
-            self._drv.data_type.set(
-                "UInt16"
-            ),  # TODO: Get from eiger https://github.com/bluesky/ophyd-async/issues/529
+            self._drv.data_type.set(f"UInt{await self._eiger_bit_depth().get_value()}"),
             self._drv.num_to_capture.set(0),
         )
 
         await wait_for_value(self._drv.meta_active, "Active", timeout=DEFAULT_TIMEOUT)
 
-        await set_and_wait_for_other_value(
-            self._drv.capture,
-            Writing.CAPTURE,
-            self._drv.capture_rbv,
-            "Capturing",
-            set_timeout=None,
-            wait_for_set_completion=False,
+        await self._drv.capture.set(
+            Writing.CAPTURE, wait=False
         )  # TODO: Investigate why we do not get a put callback when setting capture pv https://github.com/bluesky/ophyd-async/issues/866
 
-        await wait_for_value(self._drv.meta_writing, "Writing", timeout=DEFAULT_TIMEOUT)
+        await asyncio.gather(
+            wait_for_value(self._drv.capture_rbv, "Capturing", timeout=DEFAULT_TIMEOUT),
+            wait_for_value(self._drv.meta_writing, "Writing", timeout=DEFAULT_TIMEOUT),
+        )
 
         return await self._describe()
 

ophyd_async/epics/motor.py

@@ -260,10 +260,11 @@ class Motor(
             (await self.acceleration_time.get_value()) * fly_velocity * 0.5
         )
 
-        self._fly_completed_position = end_position + run_up_distance
+        direction = 1 if end_position > start_position else -1
+        self._fly_completed_position = end_position + (run_up_distance * direction)
 
         # Prepared position not used after prepare, so no need to store in self
-        fly_prepared_position = start_position - run_up_distance
+        fly_prepared_position = start_position - (run_up_distance * direction)
 
         motor_lower_limit, motor_upper_limit, egu = await asyncio.gather(
             self.low_limit_travel.get_value(),

ophyd_async/fastcs/eiger/_eiger.py

@@ -1,6 +1,11 @@
 from pydantic import Field
 
-from ophyd_async.core import AsyncStatus, PathProvider, StandardDetector, TriggerInfo
+from ophyd_async.core import (
+    AsyncStatus,
+    PathProvider,
+    StandardDetector,
+    TriggerInfo,
+)
 from ophyd_async.epics.eiger import Odin, OdinWriter
 
 from ._eiger_controller import EigerController
@@ -30,7 +35,11 @@ class EigerDetector(StandardDetector):
 
         super().__init__(
             EigerController(self.drv),
-            OdinWriter(path_provider, self.odin),
+            OdinWriter(
+                path_provider,
+                self.odin,
+                self.drv.detector.bit_depth_readout,
+            ),
             name=name,
         )
 

ophyd_async/fastcs/eiger/_eiger_controller.py

@@ -5,6 +5,7 @@ from ophyd_async.core import (
     DetectorController,
     DetectorTrigger,
     TriggerInfo,
+    wait_for_value,
 )
 
 from ._eiger_io import EigerDriverIO, EigerTriggerMode
@@ -51,14 +52,17 @@ class EigerController(DetectorController):
                     self._drv.detector.frame_time.set(trigger_info.livetime),
                 ]
             )
+
         await asyncio.gather(*coros)
 
     async def arm(self):
-        self._arm_status = self._drv.detector.arm.trigger(timeout=DEFAULT_TIMEOUT)
+        # NOTE: This will return immedietly on FastCS 0.8.0,
+        # but will return after the Eiger has completed arming in 0.9.0.
+        # https://github.com/DiamondLightSource/FastCS/pull/141
+        await self._drv.detector.arm.trigger(timeout=DEFAULT_TIMEOUT)
 
     async def wait_for_idle(self):
-        if self._arm_status:
-            await self._arm_status
+        await wait_for_value(self._drv.detector.state, "idle", timeout=DEFAULT_TIMEOUT)
 
     async def disarm(self):
         await self._drv.detector.disarm.trigger()

ophyd_async/fastcs/eiger/_eiger_io.py

@@ -39,6 +39,7 @@ class EigerDetectorIO(Device):
     omega_increment: SignalRW[float]
     arm: SignalX
     disarm: SignalX
+    trigger: SignalX
 
 
 class EigerDriverIO(Device):

ophyd_async/sim/_motor.py

@@ -3,7 +3,7 @@ import contextlib
 import time
 
 import numpy as np
-from bluesky.protocols import Location, Reading, Stoppable, Subscribable
+from bluesky.protocols import Locatable, Location, Reading, Stoppable, Subscribable
 from pydantic import BaseModel, ConfigDict, Field
 
 from ophyd_async.core import (
@@ -50,7 +50,7 @@ class FlySimMotorInfo(BaseModel):
         return self.cv_end + acceleration_time * self.velocity / 2
 
 
-class SimMotor(StandardReadable, Stoppable, Subscribable[float]):
+class SimMotor(StandardReadable, Stoppable, Subscribable[float], Locatable[float]):
     """For usage when simulating a motor."""
 
     def __init__(self, name="", instant=True) -> None:

ophyd_async/tango/core/_base_device.py

@@ -3,10 +3,11 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any, Generic, TypeVar
 
-from ophyd_async.core import Device, DeviceConnector, DeviceFiller, LazyMock
 from tango import DeviceProxy
 from tango.asyncio import DeviceProxy as AsyncDeviceProxy
 
+from ophyd_async.core import Device, DeviceConnector, DeviceFiller, LazyMock
+
 from ._signal import TangoSignalBackend, infer_python_type, infer_signal_type
 from ._utils import get_full_attr_trl
 

ophyd_async/tango/core/_converters.py

@@ -2,13 +2,9 @@ from typing import Any, Generic
 
 import numpy as np
 from numpy.typing import NDArray
+from tango import DevState
 
-from ophyd_async.core import (
-    SignalDatatypeT,
-)
-from tango import (
-    DevState,
-)
+from ophyd_async.core import SignalDatatypeT
 
 from ._utils import DevStateEnum
 

ophyd_async/tango/core/_signal.py

@@ -6,6 +6,14 @@ import logging
 from enum import Enum, IntEnum
 
 import numpy.typing as npt
+from tango import (
+    AttrDataFormat,
+    AttrWriteType,
+    CmdArgType,
+    DeviceProxy,
+    DevState,
+)
+from tango.asyncio import DeviceProxy as AsyncDeviceProxy
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
@@ -16,14 +24,6 @@ from ophyd_async.core import (
     SignalW,
     SignalX,
 )
-from tango import (
-    AttrDataFormat,
-    AttrWriteType,
-    CmdArgType,
-    DeviceProxy,
-    DevState,
-)
-from tango.asyncio import DeviceProxy as AsyncDeviceProxy
 
 from ._tango_transport import TangoSignalBackend, get_python_type
 from ._utils import get_device_trl_and_attr

ophyd_async/tango/core/_tango_transport.py

@@ -10,18 +10,6 @@ from typing import Any, ParamSpec, TypeVar, cast
 import numpy as np
 from bluesky.protocols import Reading
 from event_model import DataKey
-
-from ophyd_async.core import (
-    AsyncStatus,
-    Callback,
-    NotConnected,
-    SignalBackend,
-    SignalDatatypeT,
-    StrictEnum,
-    get_dtype,
-    get_unique,
-    wait_for_connection,
-)
 from tango import (
     AttrDataFormat,
     AttributeInfoEx,
@@ -40,6 +28,18 @@ from tango.asyncio_executor import (
 )
 from tango.utils import is_array, is_binary, is_bool, is_float, is_int, is_str
 
+from ophyd_async.core import (
+    AsyncStatus,
+    Callback,
+    NotConnected,
+    SignalBackend,
+    SignalDatatypeT,
+    StrictEnum,
+    get_dtype,
+    get_unique,
+    wait_for_connection,
+)
+
 from ._converters import (
     TangoConverter,
     TangoDevStateArrayConverter,

ophyd_async/tango/demo/_tango/_servers.py

@@ -2,7 +2,6 @@ import asyncio
 import time
 
 import numpy as np
-
 from tango import AttrWriteType, DevState, GreenMode
 from tango.server import Device, attribute, command
 

ophyd_async/tango/testing/_one_of_everything.py

@@ -3,6 +3,8 @@ from dataclasses import dataclass
 from typing import Any, Generic, TypeVar
 
 import numpy as np
+from tango import AttrDataFormat, AttrWriteType, DevState
+from tango.server import Device, attribute, command
 
 from ophyd_async.core import (
     Array1D,
@@ -10,8 +12,6 @@ from ophyd_async.core import (
     StrictEnum,
 )
 from ophyd_async.testing import float_array_value, int_array_value
-from tango import AttrDataFormat, AttrWriteType, DevState
-from tango.server import Device, attribute, command
 
 T = TypeVar("T")
 

{ophyd_async-0.10.0a3.dist-info → ophyd_async-0.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.10.0a3
+Version: 0.10.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
@@ -43,7 +43,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: bluesky>=1.13.1rc2
-Requires-Dist: event-model>=1.22.1
+Requires-Dist: event-model>=1.23
 Requires-Dist: pyyaml
 Requires-Dist: colorlog
 Requires-Dist: pydantic>=2.0

{ophyd_async-0.10.0a3.dist-info → ophyd_async-0.10.1.dist-info}/RECORD

@@ -1,31 +1,31 @@
 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=-EBD05g6kq94GHd6lTD2fVHvQZpXxxsDi5077QEreeE,521
+ophyd_async/_version.py,sha256=StiR6uxiq6hqMzT3MUIl_ZooIq2cetH9oWrHUI_qWFU,513
 ophyd_async/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/core/__init__.py,sha256=3hj-8M2bRbYUjr8lgjp-DLOOtVQZQnPVLEJKhnlskQs,4446
-ophyd_async/core/_derived_signal.py,sha256=s8VSOkjl8QVg5RTusCOAeGM_cAAJkfjO5e0cyTJ4qwg,10482
-ophyd_async/core/_derived_signal_backend.py,sha256=pci61vJkGnsMYxB54AZHyOr4rJECRpigNFtUZTM0P20,12211
-ophyd_async/core/_detector.py,sha256=MUkZusj7yIUKiULW2H__PQ76-Mykm1pwEcRpxuh9ho4,15232
+ophyd_async/core/__init__.py,sha256=mSoldXL3hou1UifwsUcos2Q3Vy_pAaNJJWdMc0VInyg,4516
+ophyd_async/core/_derived_signal.py,sha256=7ZZrDUnS2DGVwJZNX6_u0u-lAHKHCC7bL5auIfYV9w8,11440
+ophyd_async/core/_derived_signal_backend.py,sha256=AZpyMmt3-ssymtDIa3138qPp1srmaId137A_yzQuFD0,12243
+ophyd_async/core/_detector.py,sha256=PbWpv7lyBvYEJV-prG9qU0DadmxhyzMhQ9oLC0N7vwQ,15193
 ophyd_async/core/_device.py,sha256=QSOgjXkvBpPWE1VhQ21tIC8d9z4Oadr6C_1tk4J21W4,14617
 ophyd_async/core/_device_filler.py,sha256=MDz8eQQ-eEAwo-UEMxfqPfpcBuMG01tLCGR6utwVnmE,14825
 ophyd_async/core/_flyer.py,sha256=YPCGAokF0GofOOO2OLrsSLoZSXs_RzmmrNglBunA31o,1924
-ophyd_async/core/_hdf_dataset.py,sha256=jOYcrJUvZy9VarHCxs-eOIYME5u1yGOZK9CqccCEA6E,2868
+ophyd_async/core/_hdf_dataset.py,sha256=MKgA-6uxtCg-cxpGKAIxdWOw55CZp66si8lsak5e9CA,2875
 ophyd_async/core/_log.py,sha256=DxKR4Nz3SgTaTzKBZWqt-w48yT8WUAr_3Qr223TEWRw,3587
 ophyd_async/core/_mock_signal_backend.py,sha256=SPdCbVWss6-iL9C3t9u0IvR_Ln9JeDypVd18WlivdjE,3156
 ophyd_async/core/_protocol.py,sha256=wQ_snxhTprHqEjQb1HgFwBljwolMY6A8C3xgV1PXwdU,4051
-ophyd_async/core/_providers.py,sha256=0R--Slh_E16l4AQoNtessQZpOwIn7uBowvcnzh8jYgk,7538
+ophyd_async/core/_providers.py,sha256=1XuLUw9sT1pKMfH_PsDEpIi1gulla7NfPSp3IR3KfEA,7545
 ophyd_async/core/_readable.py,sha256=iBo1YwA5bsAbzLbznvmSnzKDWUuGkLh850Br3BXsgeU,11707
 ophyd_async/core/_settings.py,sha256=_ZccbXKP7j5rG6-bMKk7aaLr8hChdRDAPY_YSR71XXM,4213
-ophyd_async/core/_signal.py,sha256=kqIvQXRP3n34-uhgTmbwm2fTIz_phJYyTT4Rm7P-gSs,26412
-ophyd_async/core/_signal_backend.py,sha256=T8vJi-QuMfjB_uBB6iu_aApAY0j5pAFkDn5g2oSCbmI,6826
+ophyd_async/core/_signal.py,sha256=1XHhnYwXa0yusSKdaRAiPUoVA5atcWd0S1ztBSaEi9k,27369
+ophyd_async/core/_signal_backend.py,sha256=PvwTbbSVEGqM-2s5BNRrKGwM_MiYL71qMxYAgyZ7wRM,6930
 ophyd_async/core/_soft_signal_backend.py,sha256=zrE7H2ojHY6oQBucLkFgukszrkdvbIZuavLjEUqc_xM,6227
 ophyd_async/core/_status.py,sha256=h4TtWFM7wFtpxxyAYYSITgcVzArYZdYBHbya6qIX5t0,6553
 ophyd_async/core/_table.py,sha256=l5GzL3La68ZkXpcOOVntnYr8ofFV8kWGr1hzY1ek83w,6897
-ophyd_async/core/_utils.py,sha256=zEA3lLeOP0N17XGUH8irxvEW8hq0slkxY4gJV3f4YzE,11382
+ophyd_async/core/_utils.py,sha256=742wGL3cJD4wlDlNlS-KAbaTN5FkYDY7RXU7m6wpYaw,11737
 ophyd_async/core/_yaml_settings.py,sha256=txy4_Igbsr8Yo132yv8jnCcsLpal8klM7DcPNow2KBs,2078
 ophyd_async/epics/__init__.py,sha256=ou4yEaH9VZHz70e8oM614-arLMQvUfQyXhRJsnEpWn8,60
-ophyd_async/epics/motor.py,sha256=6AyLQmgqzabcJ4T2yTJBP1omSxxWeya5RbR_r4zYr10,10458
+ophyd_async/epics/motor.py,sha256=OgfETz_7wCLmG4WCYDpaYyUB4TomDFyCyZzwyhW1Tiw,10549
 ophyd_async/epics/signal.py,sha256=0A-supp9ajr63O6aD7F9oG0-Q26YmRjk-ZGh57-jo1Y,239
 ophyd_async/epics/adandor/__init__.py,sha256=qsBoZdljSaqM-kJSvTf0uq5TNwXAih9lP3yOZpKxOFQ,204
 ophyd_async/epics/adandor/_andor.py,sha256=SxAIP9OLefUqKcxrxhjNzil5D8-59Ps0vADdR6scO44,1281
@@ -36,22 +36,22 @@ ophyd_async/epics/adaravis/_aravis.py,sha256=Ju2wuebz9_ovl-Kza39s5VQ1pV-Omt_BaIW
 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=GipuBZwaAju4g15WjvGs78S4zjGVxmbPel4E29zHFvE,1583
-ophyd_async/epics/adcore/_core_detector.py,sha256=a7S9RViLXd9XnKFWFOhcMrSbubqZoxdQt09BZr8apUQ,2617
-ophyd_async/epics/adcore/_core_io.py,sha256=-MEsDO736idCrAxvT4BnX-NBWLvZGHTNO22c5H09_J8,7406
-ophyd_async/epics/adcore/_core_logic.py,sha256=CjzrfC5HiwoLI1igqRKIn2SSH86T_QmAFi1-kEdyGyM,8075
+ophyd_async/epics/adcore/_core_detector.py,sha256=mRDaHgXCTZF-MIVsU1csoQx9jObutYDpMWayugx2-jI,2631
+ophyd_async/epics/adcore/_core_io.py,sha256=jm4gQUSq727xnPriuH6jFHqlDBZceKxr_XyBNj5F65U,7392
+ophyd_async/epics/adcore/_core_logic.py,sha256=IH7iOSVIsVj4e97ClhdBFpmdMkb8TznSaLkd3ohEhUs,8884
 ophyd_async/epics/adcore/_core_writer.py,sha256=S58plRmbNzig-r7gubKjDVDni_nf4CASaV1OJvudbHw,8019
-ophyd_async/epics/adcore/_hdf_writer.py,sha256=ns7T9tb54ReGnyYs0fITg3Cb_0DSz4EDKlKtjBkmG3k,5572
+ophyd_async/epics/adcore/_hdf_writer.py,sha256=GW_3NKRTF3kc9Wwz6vf5a7eqlnl81LXgk8afLgZaeNU,6134
 ophyd_async/epics/adcore/_jpeg_writer.py,sha256=7XC4Twx_MaCBjeol27UA-hStOCQEjkEAb3ToVMPUlZ8,670
 ophyd_async/epics/adcore/_single_trigger.py,sha256=tFGLT1b_rZzAvbqWP-hyCccxJMRY26T5IER-VAqKXmc,1275
 ophyd_async/epics/adcore/_tiff_writer.py,sha256=Na30osfkgrq4VQhUzDcuS52Gy7FS08CzbgEmKwljTmk,671
-ophyd_async/epics/adcore/_utils.py,sha256=wGWpvm2hi-80N-RxbKOO0-GcMf-vs7B9ZDBxpzGd4mA,3952
+ophyd_async/epics/adcore/_utils.py,sha256=jMmZnyDwRDBq-N_x8qOWjW2RMN9uw2KuoAmukPbb404,4252
 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
 ophyd_async/epics/adkinetix/_kinetix_io.py,sha256=5u4TknhcoCSjyp16HQIEp_aOmvfNAKOBoGlMRJoVxuw,770
 ophyd_async/epics/adpilatus/__init__.py,sha256=So7PrLHij7LWOqMbsHUhfqRzKp9iKtrojuWTDS1lID8,406
-ophyd_async/epics/adpilatus/_pilatus.py,sha256=SqNjGpZde_9RVSghjx6h9g2SnoJP-EWU4ew3TMXPayc,1511
-ophyd_async/epics/adpilatus/_pilatus_controller.py,sha256=kpdfTPt2_gmchrMP8S3vwLfr8ixbRRMYkbWeNRRFktU,2852
+ophyd_async/epics/adpilatus/_pilatus.py,sha256=CaViuom2oKxYWRU4Y_GltHA-LxqguoTW9k67b76Q5SY,1538
+ophyd_async/epics/adpilatus/_pilatus_controller.py,sha256=21NVM_xwS5De1R6Vi_4GKpbTfdxByMzmZNwU3qBV1-A,2515
 ophyd_async/epics/adpilatus/_pilatus_io.py,sha256=EhCj--x4yYy5AtRBG6Ts3A6gsKS6Ut-LaMihAuYDvE0,819
 ophyd_async/epics/adsimdetector/__init__.py,sha256=EQqxP5DUvZGLxpvSXPagTPy3ROwE-PikyRfcnZfD1KM,281
 ophyd_async/epics/adsimdetector/_sim.py,sha256=r3SuBENGkOU-8X-i3zDyZljFxf0SmsUfryNPFvP1_os,1147
@@ -62,13 +62,13 @@ ophyd_async/epics/advimba/_vimba.py,sha256=4XlEnsJMGDzHLuYaIDUmaxx0gtOAehn5BKBZM
 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/core/__init__.py,sha256=8NoQxEEc2Ny_L9nrD2fnGSf_2gJr1wCR1LwUeLNcIJo,588
-ophyd_async/epics/core/_aioca.py,sha256=HcGYyYUQZmhdUgovf0M9xxL5Ly56ELJDAoRvyRCPq8U,13003
+ophyd_async/epics/core/_aioca.py,sha256=py5dM5hbT2OXah_Lzt_fAZ9RdaHhv8pdUtkOF8iOYO4,13015
 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
 ophyd_async/epics/core/_pvi_connector.py,sha256=nAReSiasZA3j_0f8XhuWVO4_ck0MrusnKR9Jg-RT-ok,5584
 ophyd_async/epics/core/_signal.py,sha256=2Cp5f5Xb2junnVigypjb3hWu4MuMmbrcHOBgPl5Mhv4,5776
-ophyd_async/epics/core/_util.py,sha256=DcfX4VUTeqLrMhVlt1Q7cvBTuYzHePAA-jdR-OWcxMM,2056
+ophyd_async/epics/core/_util.py,sha256=G2kYfwsQ5iS3EgGrGuPA8bgC_PEN_XxO28oBurIqJFQ,2522
 ophyd_async/epics/demo/__init__.py,sha256=WR2M3D8dbHcisJW2OIU2ManZu5SWez8ytZEp4jSBfDY,416
 ophyd_async/epics/demo/__main__.py,sha256=o6M0FSWduPHe2lN9yNEdsXb48NckSd54-XJGoLe20Pc,1116
 ophyd_async/epics/demo/_ioc.py,sha256=UtwTReKTR-1_tPIhdGBr7OxP_Vqi6xWyCcFABd9BYPY,1040
@@ -80,7 +80,7 @@ ophyd_async/epics/demo/motor.db,sha256=3xb6WTXo4crrvk-M8Y16G9pUidp27vD5vIKKBpLTU
 ophyd_async/epics/demo/point_detector.db,sha256=8kBa3XKpmfXCxetT4tq5_RFXa_XqS1Z2ZNzsa2AtLds,1366
 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=g3mknGWSzMYzCggHCYR_nWf72VBlUHMZK5WobNzkZ1U,5568
+ophyd_async/epics/eiger/_odin_io.py,sha256=4JHHeQ2R6ukq_JROGFeWVpez1UZqKpmWP1jaDCA71gQ,5567
 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=6sqJ0BCwubSkK-WOJbmpKNqZKG0AmCoevzaMGaRmuJs,1702
@@ -89,9 +89,9 @@ ophyd_async/epics/testing/test_records_pva.db,sha256=HJAJSvLtPWG5B5dKv8OZ0_hPJxR
 ophyd_async/fastcs/__init__.py,sha256=qlIM9-pjJ8yWfnzTM9-T9cw7zQLKjeeNROQTni5Dr6M,80
 ophyd_async/fastcs/core.py,sha256=pL_srtTrfuoBHUjDFpxES92owFq9M4Jve0Skk1oeuFA,517
 ophyd_async/fastcs/eiger/__init__.py,sha256=kwYs1PuetEOTeNcFNxtyhTvfbJvWCOu8wtEw3Knotuw,354
-ophyd_async/fastcs/eiger/_eiger.py,sha256=tUjTIhDvnnnNQwMjlfmCTxc6Gbg2xzo1y_wJxCVUSG4,1120
-ophyd_async/fastcs/eiger/_eiger_controller.py,sha256=oeX16Vt4CRtrL87ntGbVtvFFtmCFNCeGOZpfjYDoXX0,2131
-ophyd_async/fastcs/eiger/_eiger_io.py,sha256=8cyhYGRSFdW2zTfUZS82bMucW0HVHZysGkG1pIdZLEc,1195
+ophyd_async/fastcs/eiger/_eiger.py,sha256=5mpao2j2Xc11OuecvimPTmZ9mkEndzgMlDj1x-K-5hg,1241
+ophyd_async/fastcs/eiger/_eiger_controller.py,sha256=Cucj-1M-1CaxSJxHZmHs3f_OXwtTIspcqUFhRNGzn_E,2361
+ophyd_async/fastcs/eiger/_eiger_io.py,sha256=KS1ppYt6PJvPpHiR2AaDaPAhkhYwC2ei8VuZnBBiBs8,1216
 ophyd_async/fastcs/odin/__init__.py,sha256=da1PTClDMl-IBkrSvq6JC1lnS-K_BASzCvxVhNxN5Ls,13
 ophyd_async/fastcs/panda/__init__.py,sha256=ugrScVm4HPQFc-d1kTAfZ5UUzW9T3SPgTi0OD2s8ZH0,1003
 ophyd_async/fastcs/panda/_block.py,sha256=SM7NaWCRwLz2Pl4wgjZMrDgx3ZLdGPTw6nU0bA-65yA,2394
@@ -115,26 +115,26 @@ ophyd_async/sim/_blob_detector_controller.py,sha256=y1aSNQJUPnsT2qnj2sk254Mp18an
 ophyd_async/sim/_blob_detector_writer.py,sha256=4sC3Kkyk4-sSaN7mSKk4A4zDH4IU_qkc1gaqt4QyTAM,3636
 ophyd_async/sim/_mirror_horizontal.py,sha256=_AfsHxp5V3rYbK-goI0iwPuDDvx1BrNoUQ4smXzqFbc,1452
 ophyd_async/sim/_mirror_vertical.py,sha256=PyWpyCrW_FCzzGN7Dk0tTB-SKbDIV4GD1fl8AXUJbEI,2029
-ophyd_async/sim/_motor.py,sha256=-YMANsq4ZvI7nZolrYaTYe44kMoIcvPKCpBbCeC7pxw,10167
+ophyd_async/sim/_motor.py,sha256=jrI83A6kPCkZztHDKcd1XaXq7sc6GD2Ylkn7JxlULp0,10196
 ophyd_async/sim/_pattern_generator.py,sha256=FjPEWiBQh_7tYP_8WPhbVXnTGPPOaV6By7Skz7YNIrY,3722
 ophyd_async/sim/_point_detector.py,sha256=nXgL_1aJZciNBw8Zr2wMYaMbzzAEKXV3yV8FQz2nS_4,2940
 ophyd_async/sim/_stage.py,sha256=qaeyZbUVL1v2pTHJiZxq-y6BKpA1l_DAKyzAQppQx70,772
 ophyd_async/tango/__init__.py,sha256=g9xzjlzPpUAP12YI-kYwfAoLSYPAQdL1S11R2c-cius,60
 ophyd_async/tango/core/__init__.py,sha256=IMvQ7MWcTof99h_pr483KWKvQV2-h7zo_iRpLA2PUYQ,1108
-ophyd_async/tango/core/_base_device.py,sha256=mXQnhCzFAdSrynelubhz7iLx_akINJ6s1M08mikFFME,5032
-ophyd_async/tango/core/_converters.py,sha256=auBUdvbsEU8XXNDzX-fiBap0SvvID3ZOAUEP_wjHgBU,2201
-ophyd_async/tango/core/_signal.py,sha256=XZ38hPnThZ-__RDgwH8UfUk78NLcrZ8zVCH8sklr_3U,5798
+ophyd_async/tango/core/_base_device.py,sha256=e9oqSL-fDOj8r9nUUFZkbibhRGbI6HYtlnZjK5B_2fE,5033
+ophyd_async/tango/core/_converters.py,sha256=xI_RhMR8dY6IVORUZVVCL9LdYnEE6TA6BBPX_lTu06w,2183
+ophyd_async/tango/core/_signal.py,sha256=6KXDzV8Z08hrtCqG8J4AYnhemQjtL6Eofngo6yNo52o,5798
 ophyd_async/tango/core/_tango_readable.py,sha256=ctR6YcBGGatW6Jp2kvddA1hVZ2v1CidPsF9FmJK9BYg,406
-ophyd_async/tango/core/_tango_transport.py,sha256=FlvadKRW9H_ggcQ3MTiAGHE4HDTKu_rAk5WODMxwk_E,31903
+ophyd_async/tango/core/_tango_transport.py,sha256=6ngUybtSYqABFKsxZgA-rVms21LDmxIwfQ_VMS7h5qU,31903
 ophyd_async/tango/core/_utils.py,sha256=FrX524jwa-0EQxpcGaKF6yqyHm5BWIFSE82FcIB0aAY,1430
 ophyd_async/tango/demo/__init__.py,sha256=_j-UicTnckuIBp8PnieFMOMnLFGivnaKdmo9o0hYtzc,256
 ophyd_async/tango/demo/_counter.py,sha256=2J4SCHnBWLF0O5mFWlJdO4tmnElvlx5sRrk4op_AC9U,1139
 ophyd_async/tango/demo/_detector.py,sha256=X5YWHAjukKZ7iYF1fBNle4CBDj1X5rvj0lnPMOcnRCU,1340
 ophyd_async/tango/demo/_mover.py,sha256=c-IxrWQN0YX-Iuf720xlKfsPbNfh7bUz_AVnbwYkW08,2984
 ophyd_async/tango/demo/_tango/__init__.py,sha256=FfONT7vM49nNo3a1Lv-LcMZO9EHv6bv91yY-RnxIib4,85
-ophyd_async/tango/demo/_tango/_servers.py,sha256=nyuKgufKKqtngDeaufbUcHO6byV5MEElf9442ivtUk0,2992
+ophyd_async/tango/demo/_tango/_servers.py,sha256=putvERDyibibaTbhdWyqZB_axj2fURXqzDsZb9oSW14,2991
 ophyd_async/tango/testing/__init__.py,sha256=SYXPAS00ny3jlUMOJKpaewO4ljPjK1_z1smj7IfsBQg,148
-ophyd_async/tango/testing/_one_of_everything.py,sha256=rPAgOoNGvaHMVhB79Gz70NI9tWk3QV5iKg5wAlAtqxU,6571
+ophyd_async/tango/testing/_one_of_everything.py,sha256=tsxWgy2f_m9f0FH4XCVO_I8OtEquKbJQZbr4KaXMJL4,6571
 ophyd_async/testing/__init__.py,sha256=f53HUj2hpIfrza9OlcOpHmq5wnziQNwixawAK4F1xgc,1698
 ophyd_async/testing/__pytest_assert_rewrite.py,sha256=_SU2UfChPgEf7CFY7aYH2B7MLp-07_qYnVLyu6QtDL8,129
 ophyd_async/testing/_assert.py,sha256=FrMgMfo-ABq_cMT-hJmoaTxhAY4TwAvGe4ae1SF1rME,7657
@@ -143,8 +143,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.10.0a3.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.10.0a3.dist-info/METADATA,sha256=XnOI_0W1kd8zTWRvAnf0XQr96aAKyxuH6CiSUAqL2TE,7075
-ophyd_async-0.10.0a3.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-ophyd_async-0.10.0a3.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.10.0a3.dist-info/RECORD,,
+ophyd_async-0.10.1.dist-info/licenses/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.10.1.dist-info/METADATA,sha256=T43wg7KEoYRyA7xllFJLv9fM7OvNqYjuA047uX2zNlw,7071
+ophyd_async-0.10.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ophyd_async-0.10.1.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.10.1.dist-info/RECORD,,

{ophyd_async-0.10.0a3.dist-info → ophyd_async-0.10.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any