ophyd-async 0.8.0a5__py3-none-any.whl → 0.9.0__py3-none-any.whl

ophyd_async/tango/{demo → sim}/_counter.py

@@ -2,18 +2,17 @@ from typing import Annotated as A
 
 from ophyd_async.core import DEFAULT_TIMEOUT, AsyncStatus, SignalR, SignalRW, SignalX
 from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.tango import TangoReadable, tango_polling
+from ophyd_async.tango.core import TangoPolling, TangoReadable
 
 
-# Enable device level polling, useful for servers that do not support events
-# Polling for individual signal can be enabled with a dict
-@tango_polling({"counts": (1.0, 0.1, 0.1), "sample_time": (0.1, 0.1, 0.1)})
 class TangoCounter(TangoReadable):
     # Enter the name and type of the signals you want to use
-    # If type is None or Signal, the type will be inferred from the Tango device
-    counts: A[SignalR[int], Format.HINTED_SIGNAL]
-    sample_time: A[SignalRW[float], Format.CONFIG_SIGNAL]
+    # If the server doesn't support events, the TangoPolling annotation gives
+    # the parameters for ophyd to poll instead
+    counts: A[SignalR[int], Format.HINTED_SIGNAL, TangoPolling(1.0, 0.1, 0.1)]
+    sample_time: A[SignalRW[float], Format.CONFIG_SIGNAL, TangoPolling(0.1, 0.1, 0.1)]
     start: SignalX
+    # If a tango name clashes with a bluesky verb, add a trailing underscore
     reset_: SignalX
 
     @AsyncStatus.wrap

ophyd_async/tango/{demo → sim}/_mover.py

@@ -1,4 +1,5 @@
 import asyncio
+from typing import Annotated as A
 
 from bluesky.protocols import Movable, Stoppable
 
@@ -16,18 +17,18 @@ from ophyd_async.core import (
     wait_for_value,
 )
 from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.tango import TangoReadable, tango_polling
+from ophyd_async.tango.core import TangoPolling, TangoReadable
 from tango import DevState
 
 
-# Enable device level polling, useful for servers that do not support events
-@tango_polling((0.1, 0.1, 0.1))
 class TangoMover(TangoReadable, Movable, Stoppable):
     # Enter the name and type of the signals you want to use
-    # If type is None or Signal, the type will be inferred from the Tango device
-    position: SignalRW[float]
-    velocity: SignalRW[float]
-    state: SignalR[DevState]
+    # If the server doesn't support events, the TangoPolling annotation gives
+    # the parameters for ophyd to poll instead
+    position: A[SignalRW[float], TangoPolling(0.1, 0.1, 0.1)]
+    velocity: A[SignalRW[float], TangoPolling(0.1, 0.1, 0.1)]
+    state: A[SignalR[DevState], TangoPolling(0.1)]
+    # If a tango name clashes with a bluesky verb, add a trailing underscore
     stop_: SignalX
 
     def __init__(self, trl: str | None = "", name=""):
@@ -42,8 +43,11 @@ class TangoMover(TangoReadable, Movable, Stoppable):
         (old_position, velocity) = await asyncio.gather(
             self.position.get_value(), self.velocity.get_value()
         )
-        if timeout is CALCULATE_TIMEOUT:
-            assert velocity > 0, "Motor has zero velocity"
+        # TODO: check whether Tango does work with negative velocity
+        if timeout is CALCULATE_TIMEOUT and velocity == 0:
+            msg = "Motor has zero velocity"
+            raise ValueError(msg)
+        else:
             timeout = abs(value - old_position) / velocity + DEFAULT_TIMEOUT
 
         if not (isinstance(timeout, float) or timeout is None):

ophyd_async/testing/__init__.py

@@ -0,0 +1,52 @@
+from . import __pytest_assert_rewrite  # noqa: F401
+from ._assert import (
+    ApproxTable,
+    MonitorQueue,
+    approx_value,
+    assert_configuration,
+    assert_describe_signal,
+    assert_emitted,
+    assert_reading,
+    assert_value,
+)
+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 ._one_of_everything import (
+    ExampleEnum,
+    ExampleTable,
+    OneOfEverythingDevice,
+    ParentOfEverythingDevice,
+)
+from ._wait_for_pending import wait_for_pending_wakeups
+
+__all__ = [
+    "approx_value",
+    "assert_configuration",
+    "assert_describe_signal",
+    "assert_emitted",
+    "assert_reading",
+    "assert_value",
+    "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",
+    "wait_for_pending_wakeups",
+    "ExampleEnum",
+    "ExampleTable",
+    "OneOfEverythingDevice",
+    "ParentOfEverythingDevice",
+    "MonitorQueue",
+    "ApproxTable",
+]

ophyd_async/testing/__pytest_assert_rewrite.py

@@ -0,0 +1,4 @@
+import pytest
+
+# So that bare asserts give a nice pytest traceback
+pytest.register_assert_rewrite("ophyd_async.testing._assert")

ophyd_async/testing/_assert.py

@@ -0,0 +1,176 @@
+import asyncio
+import time
+from contextlib import AbstractContextManager
+from typing import Any
+
+import pytest
+from bluesky.protocols import Reading
+from event_model import DataKey
+
+from ophyd_async.core import (
+    AsyncConfigurable,
+    AsyncReadable,
+    SignalDatatypeT,
+    SignalR,
+    Table,
+)
+
+
+def approx_value(value: Any):
+    return ApproxTable(value) if isinstance(value, Table) else pytest.approx(value)
+
+
+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 approx_value(value) == actual_value
+
+
+async def assert_reading(
+    readable: AsyncReadable, expected_reading: dict[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()
+    approx_expected_reading = {
+        k: dict(v, value=approx_value(expected_reading[k]["value"]))
+        for k, v in expected_reading.items()
+    }
+    assert actual_reading == approx_expected_reading
+
+
+async def assert_configuration(
+    configurable: AsyncConfigurable,
+    configuration: dict[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_configuration = await configurable.read_configuration()
+    approx_expected_configuration = {
+        k: dict(v, value=approx_value(configuration[k]["value"]))
+        for k, v in configuration.items()
+    }
+    assert actual_configuration == approx_expected_configuration
+
+
+async def assert_describe_signal(signal: SignalR, /, **metadata):
+    actual_describe = await signal.describe()
+    assert list(actual_describe) == [signal.name]
+    (actual_datakey,) = actual_describe.values()
+    expected_datakey = DataKey(source=signal.source, **metadata)
+    assert actual_datakey == expected_datakey
+
+
+def assert_emitted(docs: dict[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::
+        docs = defaultdict(list)
+        RE.subscribe(lambda name, doc: docs[name].append(doc))
+        RE(my_plan())
+        assert_emitted(docs, start=1, descriptor=1, event=1, stop=1)
+    """
+    assert list(docs) == list(numbers)
+    actual_numbers = {name: len(d) for name, d in docs.items()}
+    assert actual_numbers == numbers
+
+
+class ApproxTable:
+    def __init__(self, expected: Table, rel=None, abs=None, nan_ok: bool = False):
+        self.expected = expected
+        self.rel = rel
+        self.abs = abs
+        self.nan_ok = nan_ok
+
+    def __eq__(self, value):
+        approx_fields = {
+            k: pytest.approx(v, self.rel, self.abs, self.nan_ok)
+            for k, v in self.expected
+        }
+        expected = type(self.expected).model_construct(**approx_fields)  # type: ignore
+        return expected == value
+
+
+class MonitorQueue(AbstractContextManager):
+    def __init__(self, signal: SignalR):
+        self.signal = signal
+        self.updates: asyncio.Queue[dict[str, Reading]] = asyncio.Queue()
+        self.signal.subscribe(self.updates.put_nowait)
+
+    async def assert_updates(self, expected_value):
+        # Get an update, value and reading
+        expected_type = type(expected_value)
+        expected_value = approx_value(expected_value)
+        update = await self.updates.get()
+        value = await self.signal.get_value()
+        reading = await self.signal.read()
+        # Check they match what we expected
+        assert value == expected_value
+        assert type(value) is expected_type
+        expected_reading = {
+            self.signal.name: {
+                "value": expected_value,
+                "timestamp": pytest.approx(time.time(), rel=0.1),
+                "alarm_severity": 0,
+            }
+        }
+        assert reading == update == expected_reading
+
+    def __enter__(self):
+        self.signal.subscribe(self.updates.put_nowait)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.signal.clear_sub(self.updates.put_nowait)

ophyd_async/{core → testing}/_mock_signal_utils.py

@@ -1,12 +1,16 @@
 from collections.abc import Awaitable, Callable, Iterable
-from contextlib import asynccontextmanager, contextmanager
+from contextlib import contextmanager
 from unittest.mock import AsyncMock, Mock
 
-from ._device import Device
-from ._mock_signal_backend import MockSignalBackend
-from ._signal import Signal, SignalConnector, SignalR
-from ._soft_signal_backend import SignalDatatypeT
-from ._utils import LazyMock
+from ophyd_async.core import (
+    Device,
+    LazyMock,
+    MockSignalBackend,
+    Signal,
+    SignalConnector,
+    SignalDatatypeT,
+    SignalR,
+)
 
 
 def get_mock(device: Device | Signal) -> Mock:
@@ -18,9 +22,9 @@ def get_mock(device: Device | Signal) -> Mock:
 def _get_mock_signal_backend(signal: Signal) -> MockSignalBackend:
     connector = signal._connector  # noqa: SLF001
     assert isinstance(connector, SignalConnector), f"Expected Signal, got {signal}"
-    assert isinstance(
-        connector.backend, MockSignalBackend
-    ), f"Signal {signal} not connected in mock mode"
+    assert isinstance(connector.backend, MockSignalBackend), (
+        f"Signal {signal} not connected in mock mode"
+    )
     return connector.backend
 
 
@@ -40,8 +44,8 @@ def set_mock_put_proceeds(signal: Signal, proceeds: bool):
         backend.put_proceeds.clear()
 
 
-@asynccontextmanager
-async def mock_puts_blocked(*signals: Signal):
+@contextmanager
+def mock_puts_blocked(*signals: Signal):
     for signal in signals:
         set_mock_put_proceeds(signal, False)
     yield

ophyd_async/testing/_one_of_everything.py

@@ -0,0 +1,126 @@
+from collections.abc import Sequence
+from typing import Any
+
+import numpy as np
+
+from ophyd_async.core import (
+    Array1D,
+    Device,
+    DTypeScalar_co,
+    SignalRW,
+    StandardReadable,
+    StrictEnum,
+    Table,
+    soft_signal_r_and_setter,
+    soft_signal_rw,
+)
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.core._device import DeviceVector
+
+
+class ExampleEnum(StrictEnum):
+    A = "Aaa"
+    B = "Bbb"
+    C = "Ccc"
+
+
+class ExampleTable(Table):
+    bool: Array1D[np.bool_]
+    int: Array1D[np.int32]
+    float: Array1D[np.float64]
+    str: Sequence[str]
+    enum: Sequence[ExampleEnum]
+
+
+def int_array_signal(
+    dtype: type[DTypeScalar_co], name: str = ""
+) -> SignalRW[Array1D[DTypeScalar_co]]:
+    iinfo = np.iinfo(dtype)  # type: ignore
+    value = np.array([iinfo.min, iinfo.max, 0, 1, 2, 3, 4], dtype=dtype)
+    return soft_signal_rw(Array1D[dtype], value, name)
+
+
+def float_array_signal(
+    dtype: type[DTypeScalar_co], name: str = ""
+) -> SignalRW[Array1D[DTypeScalar_co]]:
+    finfo = np.finfo(dtype)  # type: ignore
+    value = np.array(
+        [
+            finfo.min,
+            finfo.max,
+            finfo.smallest_normal,
+            finfo.smallest_subnormal,
+            0,
+            1.234,
+            2.34e5,
+            3.45e-6,
+        ],
+        dtype=dtype,
+    )
+    return soft_signal_rw(Array1D[dtype], value, name)
+
+
+class OneOfEverythingDevice(StandardReadable):
+    # make a detector to test assert_configuration
+    def __init__(self, name=""):
+        # add all signals to configuration
+        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
+            self.int = soft_signal_rw(int, 1)
+            self.float = soft_signal_rw(float, 1.234)
+            self.str = soft_signal_rw(str, "test_string")
+            self.bool = soft_signal_rw(bool, True)
+            self.enum = soft_signal_rw(ExampleEnum, ExampleEnum.B)
+            self.int8a = int_array_signal(np.int8)
+            self.uint8a = int_array_signal(np.uint8)
+            self.int16a = int_array_signal(np.int16)
+            self.uint16a = int_array_signal(np.uint16)
+            self.int32a = int_array_signal(np.int32)
+            self.uint32a = int_array_signal(np.uint32)
+            self.int64a = int_array_signal(np.int64)
+            self.uint64a = int_array_signal(np.uint64)
+            self.float32a = float_array_signal(np.float32)
+            self.float64a = float_array_signal(np.float64)
+            self.stra = soft_signal_rw(
+                Sequence[str],
+                ["one", "two", "three"],
+            )
+            self.enuma = soft_signal_rw(
+                Sequence[ExampleEnum],
+                [ExampleEnum.A, ExampleEnum.C],
+            )
+            self.table = soft_signal_rw(
+                ExampleTable,
+                ExampleTable(
+                    bool=np.array([False, False, True, True], np.bool_),
+                    int=np.array([1, 8, -9, 32], np.int32),
+                    float=np.array([1.8, 8.2, -6, 32.9887], np.float64),
+                    str=["Hello", "World", "Foo", "Bar"],
+                    enum=[ExampleEnum.A, ExampleEnum.B, ExampleEnum.A, ExampleEnum.C],
+                ),
+            )
+            self.ndarray = soft_signal_rw(np.ndarray, np.array(([1, 2, 3], [4, 5, 6])))
+        super().__init__(name)
+
+
+async def _get_signal_values(child: Device) -> dict[SignalRW, Any]:
+    if isinstance(child, SignalRW):
+        return {child: await child.get_value()}
+    ret = {}
+    for _, c in child.children():
+        ret.update(await _get_signal_values(c))
+    return ret
+
+
+class ParentOfEverythingDevice(Device):
+    def __init__(self, name=""):
+        self.child = OneOfEverythingDevice()
+        self.vector = DeviceVector(
+            {1: OneOfEverythingDevice(), 3: OneOfEverythingDevice()}
+        )
+        self.sig_rw = soft_signal_rw(str, "Top level SignalRW")
+        self.sig_r, _ = soft_signal_r_and_setter(str, "Top level SignalR")
+        self._sig_rw = soft_signal_rw(str, "Top level private SignalRW")
+        super().__init__(name=name)
+
+    async def get_signal_values(self):
+        return await _get_signal_values(self)

ophyd_async/testing/_wait_for_pending.py

@@ -0,0 +1,22 @@
+import asyncio
+
+
+async def wait_for_pending_wakeups(max_yields=20, raise_if_exceeded=True):
+    """Allow any ready asyncio tasks to be woken up.
+
+    Used in:
+
+    - Tests to allow tasks like ``set()`` to start so that signal
+      puts can be tested
+    - `observe_value` to allow it to be wrapped in `asyncio.wait_for`
+      with a timeout
+    """
+    loop = asyncio.get_event_loop()
+    # If anything has called loop.call_soon or is scheduled a wakeup
+    # then let it run
+    for _ in range(max_yields):
+        await asyncio.sleep(0)
+        if not loop._ready:  # type: ignore # noqa: SLF001
+            return
+    if raise_if_exceeded:
+        raise RuntimeError(f"Tasks still scheduling wakeups after {max_yields} yields")

{ophyd_async-0.8.0a5.dist-info → ophyd_async-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: ophyd-async
-Version: 0.8.0a5
+Version: 0.9.0
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License
@@ -37,65 +37,67 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: networkx >=2.0
+Requires-Dist: networkx>=2.0
 Requires-Dist: numpy
 Requires-Dist: packaging
 Requires-Dist: pint
-Requires-Dist: bluesky >=1.13
-Requires-Dist: event-model >=1.22.1
-Requires-Dist: p4p >=4.2.0a3
+Requires-Dist: bluesky>=1.13
+Requires-Dist: event-model>=1.22.1
+Requires-Dist: p4p>=4.2.0a3
 Requires-Dist: pyyaml
 Requires-Dist: colorlog
-Requires-Dist: pydantic >=2.0
+Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-numpy
 Provides-Extra: ca
-Requires-Dist: aioca >=1.6 ; extra == 'ca'
-Provides-Extra: dev
-Requires-Dist: ophyd-async[pva] ; extra == 'dev'
-Requires-Dist: ophyd-async[sim] ; extra == 'dev'
-Requires-Dist: ophyd-async[ca] ; extra == 'dev'
-Requires-Dist: ophyd-async[tango] ; extra == 'dev'
-Requires-Dist: inflection ; extra == 'dev'
-Requires-Dist: ipython ; extra == 'dev'
-Requires-Dist: ipywidgets ; extra == 'dev'
-Requires-Dist: matplotlib ; extra == 'dev'
-Requires-Dist: myst-parser ; extra == 'dev'
-Requires-Dist: numpydoc ; extra == 'dev'
-Requires-Dist: ophyd ; extra == 'dev'
-Requires-Dist: pickleshare ; extra == 'dev'
-Requires-Dist: pipdeptree ; extra == 'dev'
-Requires-Dist: pre-commit ; extra == 'dev'
-Requires-Dist: pydata-sphinx-theme >=0.12 ; extra == 'dev'
-Requires-Dist: pyepics >=3.4.2 ; extra == 'dev'
-Requires-Dist: pyright ; extra == 'dev'
-Requires-Dist: pyside6 ==6.7.0 ; extra == 'dev'
-Requires-Dist: pytest ; extra == 'dev'
-Requires-Dist: pytest-asyncio ; extra == 'dev'
-Requires-Dist: pytest-cov ; extra == 'dev'
-Requires-Dist: pytest-faulthandler ; extra == 'dev'
-Requires-Dist: pytest-forked ; extra == 'dev'
-Requires-Dist: pytest-rerunfailures ; extra == 'dev'
-Requires-Dist: pytest-timeout ; extra == 'dev'
-Requires-Dist: ruff ; extra == 'dev'
-Requires-Dist: sphinx <7.4.0 ; extra == 'dev'
-Requires-Dist: sphinx-autobuild ; extra == 'dev'
-Requires-Dist: autodoc-pydantic ; extra == 'dev'
-Requires-Dist: sphinxcontrib-mermaid ; extra == 'dev'
-Requires-Dist: sphinx-copybutton ; extra == 'dev'
-Requires-Dist: sphinx-design ; extra == 'dev'
-Requires-Dist: super-state-machine ; extra == 'dev'
-Requires-Dist: tox-direct ; extra == 'dev'
-Requires-Dist: types-mock ; extra == 'dev'
-Requires-Dist: types-pyyaml ; extra == 'dev'
+Requires-Dist: aioca>=1.6; extra == "ca"
 Provides-Extra: pva
-Requires-Dist: p4p ; extra == 'pva'
+Requires-Dist: p4p; extra == "pva"
 Provides-Extra: sim
-Requires-Dist: h5py ; extra == 'sim'
+Requires-Dist: h5py; extra == "sim"
 Provides-Extra: tango
-Requires-Dist: pytango >=10.0.0 ; extra == 'tango'
+Requires-Dist: pytango>=10.0.0; extra == "tango"
+Provides-Extra: dev
+Requires-Dist: ophyd_async[pva]; extra == "dev"
+Requires-Dist: ophyd_async[sim]; extra == "dev"
+Requires-Dist: ophyd_async[ca]; extra == "dev"
+Requires-Dist: ophyd_async[tango]; extra == "dev"
+Requires-Dist: inflection; extra == "dev"
+Requires-Dist: ipython; extra == "dev"
+Requires-Dist: ipywidgets; extra == "dev"
+Requires-Dist: import-linter; extra == "dev"
+Requires-Dist: matplotlib; extra == "dev"
+Requires-Dist: myst-parser; extra == "dev"
+Requires-Dist: numpydoc; extra == "dev"
+Requires-Dist: ophyd; extra == "dev"
+Requires-Dist: pickleshare; extra == "dev"
+Requires-Dist: pipdeptree; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pydata-sphinx-theme>=0.12; extra == "dev"
+Requires-Dist: pyepics>=3.4.2; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+Requires-Dist: pyside6==6.7.0; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-faulthandler; extra == "dev"
+Requires-Dist: pytest-forked; extra == "dev"
+Requires-Dist: pytest-rerunfailures; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: sphinx<7.4.0; extra == "dev"
+Requires-Dist: sphinx-autobuild; extra == "dev"
+Requires-Dist: autodoc-pydantic; extra == "dev"
+Requires-Dist: sphinxcontrib-mermaid; extra == "dev"
+Requires-Dist: sphinx-copybutton; extra == "dev"
+Requires-Dist: sphinx-design; extra == "dev"
+Requires-Dist: super_state_machine; extra == "dev"
+Requires-Dist: tox-direct; extra == "dev"
+Requires-Dist: types-mock; extra == "dev"
+Requires-Dist: types-pyyaml; extra == "dev"
 
 [![CI](https://github.com/bluesky/ophyd-async/actions/workflows/ci.yml/badge.svg)](https://github.com/bluesky/ophyd-async/actions/workflows/ci.yml)
 [![Coverage](https://codecov.io/gh/bluesky/ophyd-async/branch/main/graph/badge.svg)](https://codecov.io/gh/bluesky/ophyd-async)