ophyd-async 0.8.0a6__py3-none-any.whl → 0.9.0a1__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.8.0a6'
-__version_tuple__ = version_tuple = (0, 8, 0)
+__version__ = version = '0.9.0a1'
+__version_tuple__ = version_tuple = (0, 9, 0)

ophyd_async/core/__init__.py

@@ -21,16 +21,6 @@ from ._flyer import FlyerController, StandardFlyer
 from ._hdf_dataset import HDFDataset, HDFFile
 from ._log import config_ophyd_async_logging
 from ._mock_signal_backend import MockSignalBackend
-from ._mock_signal_utils import (
-    callback_on_mock_put,
-    get_mock,
-    get_mock_put,
-    mock_puts_blocked,
-    reset_mock_put_calls,
-    set_mock_put_proceeds,
-    set_mock_value,
-    set_mock_values,
-)
 from ._protocol import AsyncConfigurable, AsyncReadable, AsyncStageable
 from ._providers import (
     AutoIncrementFilenameProvider,
@@ -53,14 +43,11 @@ from ._readable import (
 )
 from ._signal import (
     Signal,
+    SignalConnector,
     SignalR,
     SignalRW,
     SignalW,
     SignalX,
-    assert_configuration,
-    assert_emitted,
-    assert_reading,
-    assert_value,
     observe_signals_value,
     observe_value,
     set_and_wait_for_other_value,
@@ -123,14 +110,6 @@ __all__ = [
     "HDFFile",
     "config_ophyd_async_logging",
     "MockSignalBackend",
-    "callback_on_mock_put",
-    "get_mock",
-    "get_mock_put",
-    "mock_puts_blocked",
-    "reset_mock_put_calls",
-    "set_mock_put_proceeds",
-    "set_mock_value",
-    "set_mock_values",
     "AsyncConfigurable",
     "AsyncReadable",
     "AsyncStageable",
@@ -150,14 +129,11 @@ __all__ = [
     "StandardReadable",
     "StandardReadableFormat",
     "Signal",
+    "SignalConnector",
     "SignalR",
     "SignalRW",
     "SignalW",
     "SignalX",
-    "assert_configuration",
-    "assert_emitted",
-    "assert_reading",
-    "assert_value",
     "observe_value",
     "observe_signals_value",
     "set_and_wait_for_value",

ophyd_async/core/_detector.py

@@ -30,13 +30,13 @@ class DetectorTrigger(StrictEnum):
     """Type of mechanism for triggering a detector to take frames"""
 
     #: Detector generates internal trigger for given rate
-    internal = "internal"
+    INTERNAL = "internal"
     #: Expect a series of arbitrary length trigger signals
-    edge_trigger = "edge_trigger"
+    EDGE_TRIGGER = "edge_trigger"
     #: Expect a series of constant width external gate signals
-    constant_gate = "constant_gate"
+    CONSTANT_GATE = "constant_gate"
     #: Expect a series of variable width external gate signals
-    variable_gate = "variable_gate"
+    VARIABLE_GATE = "variable_gate"
 
 
 class TriggerInfo(BaseModel):
@@ -53,7 +53,7 @@ class TriggerInfo(BaseModel):
     #:     - 3 times for final flat field images
     number_of_triggers: NonNegativeInt | list[NonNegativeInt]
     #: Sort of triggers that will be sent
-    trigger: DetectorTrigger = Field(default=DetectorTrigger.internal)
+    trigger: DetectorTrigger = Field(default=DetectorTrigger.INTERNAL)
     #: What is the minimum deadtime between triggers
     deadtime: float | None = Field(default=None, ge=0)
     #: What is the maximum high time of the triggers
@@ -265,14 +265,14 @@ class StandardDetector(
             await self.prepare(
                 TriggerInfo(
                     number_of_triggers=1,
-                    trigger=DetectorTrigger.internal,
+                    trigger=DetectorTrigger.INTERNAL,
                     deadtime=None,
                     livetime=None,
                     frame_timeout=None,
                 )
             )
         assert self._trigger_info
-        assert self._trigger_info.trigger is DetectorTrigger.internal
+        assert self._trigger_info.trigger is DetectorTrigger.INTERNAL
         # Arm the detector and wait for it to finish.
         indices_written = await self.writer.get_indices_written()
         await self.controller.arm()
@@ -303,7 +303,7 @@ class StandardDetector(
         Args:
             value: TriggerInfo describing how to trigger the detector
         """
-        if value.trigger != DetectorTrigger.internal:
+        if value.trigger != DetectorTrigger.INTERNAL:
             assert (
                 value.deadtime
             ), "Deadtime must be supplied when in externally triggered mode"
@@ -323,7 +323,7 @@ class StandardDetector(
         self._describe, _ = await asyncio.gather(
             self.writer.open(value.multiplier), self.controller.prepare(value)
         )
-        if value.trigger != DetectorTrigger.internal:
+        if value.trigger != DetectorTrigger.INTERNAL:
             await self.controller.arm()
             self._fly_start = time.monotonic()
 

ophyd_async/core/_device.py

@@ -10,7 +10,6 @@ from typing import Any, TypeVar
 from bluesky.protocols import HasName
 from bluesky.run_engine import call_in_bluesky_event_loop, in_bluesky_event_loop
 
-from ._protocol import Connectable
 from ._utils import DEFAULT_TIMEOUT, LazyMock, NotConnected, wait_for_connection
 
 
@@ -61,7 +60,7 @@ class DeviceConnector:
         await wait_for_connection(**coros)
 
 
-class Device(HasName, Connectable):
+class Device(HasName):
     """Common base class for all Ophyd Async Devices."""
 
     _name: str = ""
@@ -71,13 +70,16 @@ class Device(HasName, Connectable):
     _connect_task: asyncio.Task | None = None
     # The mock if we have connected in mock mode
     _mock: LazyMock | None = None
+    # The separator to use when making child names
+    _child_name_separator: str = "-"
 
     def __init__(
         self, name: str = "", connector: DeviceConnector | None = None
     ) -> None:
         self._connector = connector or DeviceConnector()
         self._connector.create_children_from_annotations(self)
-        self.set_name(name)
+        if name:
+            self.set_name(name)
 
     @property
     def name(self) -> str:
@@ -97,21 +99,30 @@ class Device(HasName, Connectable):
             getLogger("ophyd_async.devices"), {"ophyd_async_device_name": self.name}
         )
 
-    def set_name(self, name: str):
+    def set_name(self, name: str, *, child_name_separator: str | None = None) -> None:
         """Set ``self.name=name`` and each ``self.child.name=name+"-child"``.
 
         Parameters
         ----------
         name:
             New name to set
+        child_name_separator:
+            Use this as a separator instead of "-". Use "_" instead to make the same
+            names as the equivalent ophyd sync device.
         """
         self._name = name
+        if child_name_separator:
+            self._child_name_separator = child_name_separator
         # Ensure logger is recreated after a name change
         if "log" in self.__dict__:
             del self.log
-        for child_name, child in self.children():
-            child_name = f"{self.name}-{child_name.strip('_')}" if self.name else ""
-            child.set_name(child_name)
+        for attr_name, child in self.children():
+            child_name = (
+                f"{self.name}{self._child_name_separator}{attr_name}"
+                if self.name
+                else ""
+            )
+            child.set_name(child_name, child_name_separator=self._child_name_separator)
 
     def __setattr__(self, name: str, value: Any) -> None:
         # Bear in mind that this function is called *a lot*, so
@@ -147,6 +158,10 @@ class Device(HasName, Connectable):
         timeout:
             Time to wait before failing with a TimeoutError.
         """
+        assert hasattr(self, "_connector"), (
+            f"{self}: doesn't have attribute `_connector`,"
+            " did you call `super().__init__` in your `__init__` method?"
+        )
         if mock:
             # Always connect in mock mode serially
             if isinstance(mock, LazyMock):
@@ -247,6 +262,8 @@ class DeviceCollector:
     set_name:
         If True, call ``device.set_name(variable_name)`` on all collected
         Devices
+    child_name_separator:
+        Use this as a separator if we call ``set_name``.
     connect:
         If True, call ``device.connect(mock)`` in parallel on all
         collected Devices
@@ -271,11 +288,13 @@ class DeviceCollector:
     def __init__(
         self,
         set_name=True,
+        child_name_separator: str = "-",
         connect=True,
         mock=False,
         timeout: float = 10.0,
     ):
         self._set_name = set_name
+        self._child_name_separator = child_name_separator
         self._connect = connect
         self._mock = mock
         self._timeout = timeout
@@ -311,7 +330,7 @@ class DeviceCollector:
         for name, obj in self._objects_on_exit.items():
             if name not in self._names_on_enter and isinstance(obj, Device):
                 if self._set_name and not obj.name:
-                    obj.set_name(name)
+                    obj.set_name(name, child_name_separator=self._child_name_separator)
                 if self._connect:
                     connect_coroutines[name] = obj.connect(
                         self._mock, timeout=self._timeout

ophyd_async/core/_protocol.py

@@ -13,38 +13,10 @@ from typing import (
 from bluesky.protocols import HasName, Reading
 from event_model import DataKey
 
-from ._utils import DEFAULT_TIMEOUT
-
 if TYPE_CHECKING:
-    from unittest.mock import Mock
-
     from ._status import AsyncStatus
 
 
-@runtime_checkable
-class Connectable(Protocol):
-    @abstractmethod
-    async def connect(
-        self,
-        mock: bool | Mock = False,
-        timeout: float = DEFAULT_TIMEOUT,
-        force_reconnect: bool = False,
-    ):
-        """Connect self and all child Devices.
-
-        Contains a timeout that gets propagated to child.connect methods.
-
-        Parameters
-        ----------
-        mock:
-            If True then use ``MockSignalBackend`` for all Signals
-        timeout:
-            Time to wait before failing with a TimeoutError.
-        force_reconnect:
-            Reconnect even if previous connect was successful.
-        """
-
-
 @runtime_checkable
 class AsyncReadable(HasName, Protocol):
     @abstractmethod

ophyd_async/core/_signal.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import asyncio
 import functools
-from collections.abc import AsyncGenerator, Awaitable, Callable, Mapping
-from typing import Any, Generic, cast
+import time
+from collections.abc import AsyncGenerator, Awaitable, Callable
+from typing import Generic, cast
 
 from bluesky.protocols import (
     Locatable,
@@ -17,7 +18,6 @@ from event_model import DataKey
 from ._device import Device, DeviceConnector
 from ._mock_signal_backend import MockSignalBackend
 from ._protocol import (
-    AsyncConfigurable,
     AsyncReadable,
     AsyncStageable,
     Reading,
@@ -122,7 +122,7 @@ class _SignalCache(Generic[SignalDatatypeT]):
 
     def _callback(self, reading: Reading[SignalDatatypeT]):
         self._signal.log.debug(
-            f"Updated subscription: reading of source {self._signal.source} changed"
+            f"Updated subscription: reading of source {self._signal.source} changed "
             f"from {self._reading} to {reading}"
         )
         self._reading = reading
@@ -301,130 +301,11 @@ def soft_signal_r_and_setter(
     return (signal, backend.set_value)
 
 
-def _generate_assert_error_msg(name: str, expected_result, actual_result) -> str:
-    WARNING = "\033[93m"
-    FAIL = "\033[91m"
-    ENDC = "\033[0m"
-    return (
-        f"Expected {WARNING}{name}{ENDC} to produce"
-        + f"\n{FAIL}{expected_result}{ENDC}"
-        + f"\nbut actually got \n{FAIL}{actual_result}{ENDC}"
-    )
-
-
-async def assert_value(signal: SignalR[SignalDatatypeT], value: Any) -> None:
-    """Assert a signal's value and compare it an expected signal.
-
-    Parameters
-    ----------
-    signal:
-        signal with get_value.
-    value:
-        The expected value from the signal.
-
-    Notes
-    -----
-    Example usage::
-        await assert_value(signal, value)
-
-    """
-    actual_value = await signal.get_value()
-    assert actual_value == value, _generate_assert_error_msg(
-        name=signal.name,
-        expected_result=value,
-        actual_result=actual_value,
-    )
-
-
-async def assert_reading(
-    readable: AsyncReadable, expected_reading: Mapping[str, Reading]
-) -> None:
-    """Assert readings from readable.
-
-    Parameters
-    ----------
-    readable:
-        Callable with readable.read function that generate readings.
-
-    reading:
-        The expected readings from the readable.
-
-    Notes
-    -----
-    Example usage::
-        await assert_reading(readable, reading)
-
-    """
-    actual_reading = await readable.read()
-    assert expected_reading == actual_reading, _generate_assert_error_msg(
-        name=readable.name,
-        expected_result=expected_reading,
-        actual_result=actual_reading,
-    )
-
-
-async def assert_configuration(
-    configurable: AsyncConfigurable,
-    configuration: Mapping[str, Reading],
-) -> None:
-    """Assert readings from Configurable.
-
-    Parameters
-    ----------
-    configurable:
-        Configurable with Configurable.read function that generate readings.
-
-    configuration:
-        The expected readings from configurable.
-
-    Notes
-    -----
-    Example usage::
-        await assert_configuration(configurable configuration)
-
-    """
-    actual_configurable = await configurable.read_configuration()
-    assert configuration == actual_configurable, _generate_assert_error_msg(
-        name=configurable.name,
-        expected_result=configuration,
-        actual_result=actual_configurable,
-    )
-
-
-def assert_emitted(docs: Mapping[str, list[dict]], **numbers: int):
-    """Assert emitted document generated by running a Bluesky plan
-
-    Parameters
-    ----------
-    Doc:
-        A dictionary
-
-    numbers:
-        expected emission in kwarg from
-
-    Notes
-    -----
-    Example usage::
-        assert_emitted(docs, start=1, descriptor=1,
-        resource=1, datum=1, event=1, stop=1)
-    """
-    assert list(docs) == list(numbers), _generate_assert_error_msg(
-        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(
-        name="emitted",
-        expected_result=numbers,
-        actual_result=actual_numbers,
-    )
-
-
 async def observe_value(
     signal: SignalR[SignalDatatypeT],
     timeout: float | None = None,
     done_status: Status | None = None,
+    done_timeout: float | None = None,
 ) -> AsyncGenerator[SignalDatatypeT, None]:
     """Subscribe to the value of a signal so it can be iterated from.
 
@@ -439,9 +320,17 @@ async def observe_value(
     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 iterator.
+    done_timeout:
+        If given, the maximum time to watch a signal, in seconds. If the loop is still
+        being watched after this length, raise asyncio.TimeoutError. This should be used
+        instead of on an 'asyncio.wait_for' timeout
 
     Notes
     -----
+    Due to a rare condition with busy signals, it is not recommended to use this
+    function with asyncio.timeout, including in an 'asyncio.wait_for' loop. Instead,
+    this timeout should be given to the done_timeout parameter.
+
     Example usage::
 
         async for value in observe_value(sig):
@@ -449,15 +338,26 @@ async def observe_value(
     """
 
     async for _, value in observe_signals_value(
-        signal, timeout=timeout, done_status=done_status
+        signal,
+        timeout=timeout,
+        done_status=done_status,
+        done_timeout=done_timeout,
     ):
         yield value
 
 
+def _get_iteration_timeout(
+    timeout: float | None, overall_deadline: float | None
+) -> float | None:
+    overall_deadline = overall_deadline - time.monotonic() if overall_deadline else None
+    return min([x for x in [overall_deadline, timeout] if x is not None], default=None)
+
+
 async def observe_signals_value(
     *signals: SignalR[SignalDatatypeT],
     timeout: float | None = None,
     done_status: Status | None = None,
+    done_timeout: float | None = None,
 ) -> AsyncGenerator[tuple[SignalR[SignalDatatypeT], SignalDatatypeT], None]:
     """Subscribe to the value of a signal so it can be iterated from.
 
@@ -472,6 +372,10 @@ async def observe_signals_value(
     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 iterator.
+    done_timeout:
+        If given, the maximum time to watch a signal, in seconds. If the loop is still
+        being watched after this length, raise asyncio.TimeoutError. This should be used
+        instead of on an 'asyncio.wait_for' timeout
 
     Notes
     -----
@@ -486,12 +390,6 @@ async def observe_signals_value(
     q: asyncio.Queue[tuple[SignalR[SignalDatatypeT], SignalDatatypeT] | Status] = (
         asyncio.Queue()
     )
-    if timeout is None:
-        get_value = q.get
-    else:
-
-        async def get_value():
-            return await asyncio.wait_for(q.get(), timeout)
 
     cbs: dict[SignalR, Callback] = {}
     for signal in signals:
@@ -504,13 +402,17 @@ async def observe_signals_value(
 
     if done_status is not None:
         done_status.add_callback(q.put_nowait)
-
+    overall_deadline = time.monotonic() + done_timeout if done_timeout else None
     try:
         while True:
-            # yield here in case something else is filling the queue
-            # like in test_observe_value_times_out_with_no_external_task()
-            await asyncio.sleep(0)
-            item = await get_value()
+            if overall_deadline and time.monotonic() >= overall_deadline:
+                raise asyncio.TimeoutError(
+                    f"observe_value was still observing signals "
+                    f"{[signal.source for signal in signals]} after "
+                    f"timeout {done_timeout}s"
+                )
+            iteration_timeout = _get_iteration_timeout(timeout, overall_deadline)
+            item = await asyncio.wait_for(q.get(), iteration_timeout)
             if done_status and item is done_status:
                 if exc := done_status.exception():
                     raise exc

ophyd_async/core/_utils.py

@@ -17,11 +17,20 @@ DEFAULT_TIMEOUT = 10.0
 ErrorText = str | Mapping[str, Exception]
 
 
-class StrictEnum(str, Enum):
+class StrictEnumMeta(EnumMeta):
+    def __new__(metacls, *args, **kwargs):
+        ret = super().__new__(metacls, *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(EnumMeta):
+class SubsetEnumMeta(StrictEnumMeta):
     def __call__(self, value, *args, **kwargs):  # type: ignore
         if isinstance(value, str) and not isinstance(value, self):
             return value

ophyd_async/epics/adaravis/_aravis_controller.py

@@ -31,9 +31,9 @@ class AravisController(DetectorController):
 
     async def prepare(self, trigger_info: TriggerInfo):
         if trigger_info.total_number_of_triggers == 0:
-            image_mode = adcore.ImageMode.continuous
+            image_mode = adcore.ImageMode.CONTINUOUS
         else:
-            image_mode = adcore.ImageMode.multiple
+            image_mode = adcore.ImageMode.MULTIPLE
         if (exposure := trigger_info.livetime) is not None:
             await self._drv.acquire_time.set(exposure)
 
@@ -58,9 +58,9 @@ class AravisController(DetectorController):
         self, trigger: DetectorTrigger
     ) -> tuple[AravisTriggerMode, AravisTriggerSource]:
         supported_trigger_types = (
-            DetectorTrigger.constant_gate,
-            DetectorTrigger.edge_trigger,
-            DetectorTrigger.internal,
+            DetectorTrigger.CONSTANT_GATE,
+            DetectorTrigger.EDGE_TRIGGER,
+            DetectorTrigger.INTERNAL,
         )
         if trigger not in supported_trigger_types:
             raise ValueError(
@@ -68,10 +68,10 @@ class AravisController(DetectorController):
                 f"types: {supported_trigger_types} but was asked to "
                 f"use {trigger}"
             )
-        if trigger == DetectorTrigger.internal:
-            return AravisTriggerMode.off, AravisTriggerSource.freerun
+        if trigger == DetectorTrigger.INTERNAL:
+            return AravisTriggerMode.OFF, AravisTriggerSource.FREERUN
         else:
-            return (AravisTriggerMode.on, f"Line{self.gpio_number}")  # type: ignore
+            return (AravisTriggerMode.ON, f"Line{self.gpio_number}")  # type: ignore
 
     async def disarm(self):
         await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/adaravis/_aravis_io.py

@@ -6,8 +6,8 @@ from ophyd_async.epics.core import epics_signal_rw_rbv
 class AravisTriggerMode(StrictEnum):
     """GigEVision GenICAM standard: on=externally triggered"""
 
-    on = "On"
-    off = "Off"
+    ON = "On"
+    OFF = "Off"
 
 
 """A minimal set of TriggerSources that must be supported by the underlying record.
@@ -20,8 +20,8 @@ class AravisTriggerMode(StrictEnum):
 
 
 class AravisTriggerSource(SubsetEnum):
-    freerun = "Freerun"
-    line1 = "Line1"
+    FREERUN = "Freerun"
+    LINE1 = "Line1"
 
 
 class AravisDriverIO(adcore.ADBaseIO):

ophyd_async/epics/adcore/_core_io.py

@@ -9,8 +9,8 @@ from ._utils import ADBaseDataType, FileWriteMode, ImageMode
 
 
 class Callback(StrictEnum):
-    Enable = "Enable"
-    Disable = "Disable"
+    ENABLE = "Enable"
+    DISABLE = "Disable"
 
 
 class NDArrayBaseIO(Device):
@@ -72,17 +72,17 @@ class DetectorState(StrictEnum):
     See definition in ADApp/ADSrc/ADDriver.h in https://github.com/areaDetector/ADCore
     """
 
-    Idle = "Idle"
-    Acquire = "Acquire"
-    Readout = "Readout"
-    Correct = "Correct"
-    Saving = "Saving"
-    Aborting = "Aborting"
-    Error = "Error"
-    Waiting = "Waiting"
-    Initializing = "Initializing"
-    Disconnected = "Disconnected"
-    Aborted = "Aborted"
+    IDLE = "Idle"
+    ACQUIRE = "Acquire"
+    READOUT = "Readout"
+    CORRECT = "Correct"
+    SAVING = "Saving"
+    ABORTING = "Aborting"
+    ERROR = "Error"
+    WAITING = "Waiting"
+    INITIALIZING = "Initializing"
+    DISCONNECTED = "Disconnected"
+    ABORTED = "Aborted"
 
 
 class ADBaseIO(NDArrayBaseIO):
@@ -99,14 +99,14 @@ class ADBaseIO(NDArrayBaseIO):
 
 
 class Compression(StrictEnum):
-    none = "None"
-    nbit = "N-bit"
-    szip = "szip"
-    zlib = "zlib"
-    blosc = "Blosc"
-    bslz4 = "BSLZ4"
-    lz4 = "LZ4"
-    jpeg = "JPEG"
+    NONE = "None"
+    NBIT = "N-bit"
+    SZIP = "szip"
+    ZLIB = "zlib"
+    BLOSC = "Blosc"
+    BSLZ4 = "BSLZ4"
+    LZ4 = "LZ4"
+    JPEG = "JPEG"
 
 
 class NDFileHDFIO(NDPluginBaseIO):