Added AsyncReadable, AsyncConfigurable and AsyncPausable

Also replaced imports of bluesky.protocols for each with their new async counterparts.

src/ophyd_async/core/detector.py

@@ -19,17 +19,16 @@
 
 from bluesky.protocols import (
     Collectable,
-    Configurable,
     Descriptor,
     Flyable,
     Preparable,
-    Readable,
     Reading,
     Stageable,
     StreamAsset,
     Triggerable,
     WritesStreamAssets,
 )
+from ophyd_async.protocols import AsyncReadable, AsyncConfigurable
 
 from .async_status import AsyncStatus
 from .device import Device
@@ -143,8 +142,8 @@ async def close(self) -> None:
 class StandardDetector(
     Device,
     Stageable,
-    Configurable,
-    Readable,
+    AsyncConfigurable,
+    AsyncReadable,
     Triggerable,
     Preparable,
     Flyable,

src/ophyd_async/core/signal.py

@@ -9,11 +9,11 @@
     Locatable,
     Location,
     Movable,
-    Readable,
     Reading,
     Stageable,
     Subscribable,
 )
+from ophyd_async.protocols import AsyncReadable
 
 from .async_status import AsyncStatus
 from .device import Device
@@ -133,7 +133,7 @@ def set_staged(self, staged: bool):
         return self._staged or bool(self._listeners)
 
 
-class SignalR(Signal[T], Readable, Stageable, Subscribable):
+class SignalR(Signal[T], AsyncReadable, Stageable, Subscribable):
     """Signal that can be read from and monitored"""
 
     _cache: Optional[_SignalCache] = None

src/ophyd_async/core/standard_readable.py

@@ -1,14 +1,15 @@
 from typing import Dict, Sequence, Tuple
 
-from bluesky.protocols import Configurable, Descriptor, Readable, Reading, Stageable
+from bluesky.protocols import Descriptor, Reading, Stageable
+from ophyd_async.protocols import AsyncConfigurable, AsyncReadable
 
 from .async_status import AsyncStatus
 from .device import Device
 from .signal import SignalR
 from .utils import merge_gathered_dicts
 
 
-class StandardReadable(Device, Readable, Configurable, Stageable):
+class StandardReadable(Device, AsyncReadable, AsyncConfigurable, Stageable):
     """Device that owns its children and provides useful default behavior.
 
     - When its name is set it renames child Devices

src/ophyd_async/protocols/__init__.py

@@ -0,0 +1,3 @@
+from .protocols import AsyncReadable, AsyncConfigurable, AsyncPausable
+
+__all__ = ["AsyncReadable", "AsyncConfigurable", "AsyncPausable"]

src/ophyd_async/protocols/protocols.py

@@ -0,0 +1,72 @@
+from abc import abstractmethod
+from typing import Any, Coroutine, Dict, Protocol, runtime_checkable
+from bluesky.protocols import HasName, Reading, Descriptor
+
+
+@runtime_checkable
+class AsyncReadable(HasName, Protocol):
+    @abstractmethod
+    async def read(self) -> Coroutine[Any, Any, Dict[str, Reading]]:
+        """Return an OrderedDict mapping string field name(s) to dictionaries
+        of values and timestamps and optional per-point metadata.
+
+        Example return value:
+
+        .. code-block:: python
+
+            OrderedDict(('channel1',
+                         {'value': 5, 'timestamp': 1472493713.271991}),
+                         ('channel2',
+                         {'value': 16, 'timestamp': 1472493713.539238}))
+        """
+        ...
+
+    @abstractmethod
+    async def describe(self) -> Coroutine[Any, Any, Dict[str, Descriptor]]:
+        """Return an OrderedDict with exactly the same keys as the ``read``
+        method, here mapped to per-scan metadata about each field.
+
+        Example return value:
+
+        .. code-block:: python
+
+            OrderedDict(('channel1',
+                         {'source': 'XF23-ID:SOME_PV_NAME',
+                          'dtype': 'number',
+                          'shape': []}),
+                        ('channel2',
+                         {'source': 'XF23-ID:SOME_PV_NAME',
+                          'dtype': 'number',
+                          'shape': []}))
+        """
+        ...
+
+
+@runtime_checkable
+class AsyncConfigurable(Protocol):
+    @abstractmethod
+    async def read_configuration(self) -> Coroutine[Any, Any, Dict[str, Reading]]:
+        """Same API as ``read`` but for slow-changing fields related to configuration.
+        e.g., exposure time. These will typically be read only once per run.
+        """
+        ...
+
+    @abstractmethod
+    async def describe_configuration(self) -> Coroutine[Any, Any, Dict[str, Descriptor]]:
+        """Same API as ``describe``, but corresponding to the keys in
+        ``read_configuration``.
+        """
+        ...
+
+
+@runtime_checkable
+class AsyncPausable(Protocol):
+    @abstractmethod
+    async def pause(self) -> None:
+        """Perform device-specific work when the RunEngine pauses."""
+        ...
+
+    @abstractmethod
+    async def resume(self) -> None:
+        """Perform device-specific work when the RunEngine resumes after a pause."""
+        ...