ophyd-async 0.10.0a3__tar.gz → 0.10.0a4__tar.gz

{ophyd_async-0.10.0a3 → ophyd_async-0.10.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.10.0a3
+Version: 0.10.0a4
 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

{ophyd_async-0.10.0a3 → ophyd_async-0.10.0a4}/pyproject.toml

@@ -134,7 +134,6 @@ commands =
 """
 
 [tool.ruff]
-src = ["src", "tests", "system_tests"]
 line-length = 88
 lint.select = [
     "B",       # flake8-bugbear - https://docs.astral.sh/ruff/rules/#flake8-bugbear-b

{ophyd_async-0.10.0a3 → ophyd_async-0.10.0a4}/src/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.0a4'
+__version_tuple__ = version_tuple = (0, 10, 0, 'a4')

{ophyd_async-0.10.0a3 → ophyd_async-0.10.0a4}/src/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-0.10.0a3 → ophyd_async-0.10.0a4}/src/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 = (
@@ -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-0.10.0a3 → ophyd_async-0.10.0a4}/src/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-0.10.0a3 → ophyd_async-0.10.0a4}/src/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)
 
@@ -431,8 +436,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 +459,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 +475,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 +484,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-0.10.0a3 → ophyd_async-0.10.0a4}/src/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
@@ -167,7 +177,7 @@ def _datakey_dtype_numpy(
 
 
 def _datakey_shape(value: SignalDatatype) -> list[int]:
-    if type(value) in _primitive_dtype or isinstance(value, StrictEnum):
+    if type(value) in _primitive_dtype or isinstance(value, EnumTypes):
         return []
     elif isinstance(value, np.ndarray):
         return list(value.shape)

{ophyd_async-0.10.0a3 → ophyd_async-0.10.0a4}/src/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-0.10.0a3 → ophyd_async-0.10.0a4}/src/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-0.10.0a3 → ophyd_async-0.10.0a4}/src/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-0.10.0a3 → ophyd_async-0.10.0a4}/src/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-0.10.0a3 → ophyd_async-0.10.0a4}/src/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-0.10.0a3 → ophyd_async-0.10.0a4}/src/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-0.10.0a3 → ophyd_async-0.10.0a4}/src/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-0.10.0a3 → ophyd_async-0.10.0a4}/src/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-0.10.0a3 → ophyd_async-0.10.0a4}/src/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-0.10.0a3 → ophyd_async-0.10.0a4}/src/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(),