ophyd-async 0.3a2__tar.gz → 0.3a3__tar.gz

{ophyd_async-0.3a2 → ophyd_async-0.3a3}/.github/workflows/_docs.yml

@@ -47,7 +47,7 @@ jobs:
         if: github.ref_type == 'tag' || github.ref_name == 'main'
         # We pin to the SHA, not the tag, for security reasons.
         # https://docs.github.com/en/actions/learn-github-actions/security-hardening-for-github-actions#using-third-party-actions
-        uses: peaceiris/actions-gh-pages@373f7f263a76c20808c831209c920827a82a2847 # v3.9.3
+        uses: peaceiris/actions-gh-pages@4f9cc6602d3f66b9c108549d475ec49e8ef4d45e # v4.0.0
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           publish_dir: .github/pages

{ophyd_async-0.3a2 → ophyd_async-0.3a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3a2
+Version: 0.3a3
 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
@@ -72,7 +72,7 @@ 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: pyside6==6.6.2; 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"
@@ -81,18 +81,20 @@ Requires-Dist: pytest-rerunfailures; extra == "dev"
 Requires-Dist: pytest-timeout; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: sphinx-autobuild; extra == "dev"
+Requires-Dist: sphinxcontrib-mermaid; extra == "dev"
 Requires-Dist: sphinx-copybutton; extra == "dev"
 Requires-Dist: sphinx-design; extra == "dev"
 Requires-Dist: tox-direct; extra == "dev"
 Requires-Dist: types-mock; extra == "dev"
 Requires-Dist: types-pyyaml; extra == "dev"
+Requires-Dist: colorlog; 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)
 [![PyPI](https://img.shields.io/pypi/v/ophyd-async.svg)](https://pypi.org/project/ophyd-async)
 [![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
 
-# ophyd_async
+# ophyd-async
 
 Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 
@@ -102,6 +104,21 @@ Asynchronous Bluesky hardware abstraction code, compatible with control systems
 | Documentation |      <https://bluesky.github.io/ophyd-async>      |
 |   Releases    | <https://github.com/bluesky/ophyd-async/releases> |
 
+Ophyd-async is a Python library for asynchronously interfacing with hardware, intended to 
+be used as an abstraction layer that enables experiment orchestration and data acquisition code to operate above the specifics of particular devices and control
+systems.
+
+Both ophyd and ophyd-async are typically used with the [Bluesky Run Engine][] for experiment orchestration and data acquisition.
+
+While [EPICS][] is the most common control system layer that ophyd-async can interface with, support for other control systems like [Tango][] will be supported in the future. The focus of ophyd-async is:
+
+* Asynchronous signal access, opening the possibility for hardware-triggered scanning (also known as fly-scanning)
+* Simpler instantiation of devices (groupings of signals) with less reliance upon complex class hierarchies
+
+[Bluesky Run Engine]: http://blueskyproject.io/bluesky
+[EPICS]: http://www.aps.anl.gov/epics/
+[Tango]: https://www.tango-controls.org/
+
 <!-- README only content. Anything below this line won't be included in index.md -->
 
 See https://bluesky.github.io/ophyd-async for more detailed documentation.

{ophyd_async-0.3a2 → ophyd_async-0.3a3}/README.md

@@ -3,7 +3,7 @@
 [![PyPI](https://img.shields.io/pypi/v/ophyd-async.svg)](https://pypi.org/project/ophyd-async)
 [![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
 
-# ophyd_async
+# ophyd-async
 
 Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 
@@ -13,6 +13,21 @@ Asynchronous Bluesky hardware abstraction code, compatible with control systems
 | Documentation |      <https://bluesky.github.io/ophyd-async>      |
 |   Releases    | <https://github.com/bluesky/ophyd-async/releases> |
 
+Ophyd-async is a Python library for asynchronously interfacing with hardware, intended to 
+be used as an abstraction layer that enables experiment orchestration and data acquisition code to operate above the specifics of particular devices and control
+systems.
+
+Both ophyd and ophyd-async are typically used with the [Bluesky Run Engine][] for experiment orchestration and data acquisition.
+
+While [EPICS][] is the most common control system layer that ophyd-async can interface with, support for other control systems like [Tango][] will be supported in the future. The focus of ophyd-async is:
+
+* Asynchronous signal access, opening the possibility for hardware-triggered scanning (also known as fly-scanning)
+* Simpler instantiation of devices (groupings of signals) with less reliance upon complex class hierarchies
+
+[Bluesky Run Engine]: http://blueskyproject.io/bluesky
+[EPICS]: http://www.aps.anl.gov/epics/
+[Tango]: https://www.tango-controls.org/
+
 <!-- README only content. Anything below this line won't be included in index.md -->
 
 See https://bluesky.github.io/ophyd-async for more detailed documentation.

{ophyd_async-0.3a2 → ophyd_async-0.3a3}/docs/conf.py

@@ -32,6 +32,8 @@ else:
     version = release
 
 extensions = [
+    # for diagrams
+    "sphinxcontrib.mermaid",
     # Use this for generating API docs
     "sphinx.ext.autodoc",
     "sphinx.ext.doctest",
@@ -57,6 +59,9 @@ extensions = [
     "numpydoc",
 ]
 
+# So we can use the ::: syntax
+myst_enable_extensions = ["colon_fence"]
+
 napoleon_google_docstring = False
 napoleon_numpy_docstring = True
 
@@ -184,11 +189,6 @@ html_theme_options = {
             "url": f"https://pypi.org/project/{project}",
             "icon": "fas fa-cube",
         },
-        {
-            "name": "Gitter",
-            "url": "https://gitter.im/NSLS-II/DAMA",
-            "icon": "fas fa-person-circle-question",
-        },
     ],
     "switcher": {
         "json_url": switcher_json,
@@ -201,10 +201,6 @@ html_theme_options = {
             "name": "Bluesky Project",
             "url": "https://blueskyproject.io",
         },
-        {
-            "name": "Release Notes",
-            "url": f"https://github.com/{github_user}/{github_repo}/releases",
-        },
     ],
     "navigation_with_keys": False,
 }

ophyd_async-0.3a3/docs/examples/foo_detector.py

@@ -0,0 +1,82 @@
+import asyncio
+from typing import Optional
+
+from bluesky.protocols import HasHints, Hints
+
+from ophyd_async.core import DirectoryProvider
+from ophyd_async.core.async_status import AsyncStatus
+from ophyd_async.core.detector import DetectorControl, DetectorTrigger, StandardDetector
+from ophyd_async.epics.areadetector.drivers.ad_base import (
+    ADBase,
+    ADBaseShapeProvider,
+    start_acquiring_driver_and_ensure_status,
+)
+from ophyd_async.epics.areadetector.utils import ImageMode, ad_rw, stop_busy_record
+from ophyd_async.epics.areadetector.writers.hdf_writer import HDFWriter
+from ophyd_async.epics.areadetector.writers.nd_file_hdf import NDFileHDF
+
+
+class FooDriver(ADBase):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.trigger_mode = ad_rw(str, prefix + "TriggerMode")
+        super().__init__(prefix, name)
+
+
+class FooController(DetectorControl):
+    def __init__(self, driver: FooDriver) -> None:
+        self._drv = driver
+
+    def get_deadtime(self, exposure: float) -> float:
+        # FooDetector deadtime handling
+        return 0.001
+
+    async def arm(
+        self,
+        num: int,
+        trigger: DetectorTrigger = DetectorTrigger.internal,
+        exposure: Optional[float] = None,
+    ) -> AsyncStatus:
+        await asyncio.gather(
+            self._drv.num_images.set(num),
+            self._drv.image_mode.set(ImageMode.multiple),
+            self._drv.trigger_mode.set(f"FOO{trigger}"),
+        )
+        if exposure is not None:
+            await self._drv.acquire_time.set(exposure)
+        return await start_acquiring_driver_and_ensure_status(self._drv)
+
+    async def disarm(self):
+        await stop_busy_record(self._drv.acquire, False, timeout=1)
+
+
+class FooDetector(StandardDetector, HasHints):
+    _controller: FooController
+    _writer: HDFWriter
+
+    def __init__(
+        self,
+        prefix: str,
+        directory_provider: DirectoryProvider,
+        drv_suffix="cam1:",
+        hdf_suffix="HDF1:",
+        name="",
+    ):
+        # Must be children to pick up connect
+        self.drv = FooDriver(prefix + drv_suffix)
+        self.hdf = NDFileHDF(prefix + hdf_suffix)
+
+        super().__init__(
+            FooController(self.drv),
+            HDFWriter(
+                self.hdf,
+                directory_provider,
+                lambda: self.name,
+                ADBaseShapeProvider(self.drv),
+            ),
+            config_sigs=(self.drv.acquire_time,),
+            name=name,
+        )
+
+    @property
+    def hints(self) -> Hints:
+        return self._writer.hints

ophyd_async-0.3a3/docs/explanations/design-goals.rst

@@ -0,0 +1,57 @@
+Design Goals
+============
+
+
+Parity with Ophyd
+-----------------
+
+It should be possible to migrate applications that use ophyd_ to ophyd-async. Meaning it must support:
+
+- Definition of devices
+- Conformity to the bluesky protocols
+- Epics (ChannelAccess) as a backend
+
+Ophyd-async should provide built-in support logic for controlling `the same set of devices as ophyd <https://blueskyproject.io/ophyd/user/reference/builtin-devices.html>`_. 
+
+
+Clean Device Definition
+-----------------------
+
+It should be easy to define devices with signals that talk to multiple backends and to cleanly organize device logic via composition.
+
+We need to be able to:
+
+- Separate the Device interface from the multiple pieces of logic that might use that Device in a particular way
+- Define that Signals of a particular type exist without creating them so backends like Tango or EPICS + PVI can fill them in
+
+
+Parity with Malcolm
+-------------------
+
+.. seealso:: `./flyscanning`
+
+Ophyd-async should provide the same building blocks for defining flyscans scans as malcolm_. It should support PandA and Zebra as timing masters by default, but also provide easy helpers for developers to write support for their own devices.
+
+It should enable `motor trajectory scanning <motortraj_>` and `multiple triggering rates<detectorsync_>` based around a base rate, and pausing/resuming scans. Scans should be modelled using scanspec_, which serves as a universal language for defining trajectory and time-resolved scans, and converted to the underlying format of the given motion controller. It should also be possible to define an `outer scan <outerscan_>`.
+
+
+Improved Trajectory Calculation
+-------------------------------
+
+Ophyd-async will provide and improve upon the algorithms that malcolm_ uses to calculate trajectories for supported hardware.
+
+The EPICS pmac_ module supports trajectory scanning, specifying a growing array of positions, velocities and time for axes to move through to perform a scan. 
+Ophyd-async will provide mechanisms for specifying these scans via a scanspec_, calculating run-ups and turnarounds based on motor parameters, keeping the trajectory scan arrays filled based on the ScanSpec, and allowing this scan to be paused and resumed.
+
+
+Outstanding Design Decisions
+----------------------------
+
+To view and contribute to discussions on outstanding decisions, please see the design_ label in our Github issues.
+
+
+.. _ophyd: https://github.com/bluesky/ophyd
+.. _malcolm: https://github.com/dls-controls/pymalcolm
+.. _scanspec: https://github.com/dls-controls/scanspec
+.. _design: https://github.com/bluesky/ophyd-async/issues?q=is%3Aissue+is%3Aopen+label%3Adesign
+.. _pmac: https://github.com/dls-controls/pmac

ophyd_async-0.3a3/docs/explanations/flyscanning.rst

@@ -0,0 +1,63 @@
+Flyscanning
+===========
+
+Flyscanning (also known as hardware triggered scanning, asynchronous acquisition, and hardware synchronized scanning) is the practice of accelerating the rate of data collection by handing control over to an external hardware system that can control and synchronize the triggering of detectors with other signals and/or commands. Flyscans take many forms.
+
+.. _detectorsync_:
+
+Detector Synchronization
+------------------------
+
+.. figure:: ../images/simple-hardware-scan.png
+    :alt: hardware-triggered setup
+    :width: 300
+
+A triggering system can send pulses to two or more detectors to make them expose simultaneously, or at different multiples of the same base rate (e.g. 200Hz and 400Hz).
+
+.. _motortraj_:
+
+Motor Trajectory Scanning
+-------------------------
+ 
+.. figure:: ../images/hardware-triggered-scan.png
+    :alt: trajectory scanning setup
+
+The triggering system can be configured to trigger the detectors at the same time as the motion controller commands the motors to go to certain points, or even exactly when they reach those points, using the readback values. This can be achieved on the scale of microseconds/nanoseconds, in comparison to traditional soft scans controlled via a network, which normally synchronize on the scale of seconds.
+
+.. _outerscan_:
+
+Outer Scanning
+--------------
+
+Outer scans are flyscans nested inside soft scans. 
+
+.. figure:: ../images/outer-scan.png
+    :alt: hardware-triggered setup
+
+In the example above a 2D grid scan in ``x`` and ``y`` is repeated in a third dimension: ``z``. Given that ``z`` only needs to move for every 1 in every 25 points, it could be synchronized via software rather than hardware without significantly affecting scan time (and saving the effort/expense of wiring it into a triggering system). It then becomes the responsibility of the software to move ``z``, hand control to the external hardware, wait for one grid's worth of points, take control back, and repeat. 
+
+
+Hardware
+--------
+
+Ophyd-async ships with support for Quantum Detectors' PandA_ and Zebra_ as triggering mechanisms.
+
+These are very modular and can be used to trigger a variety of detectors and handle readback signals from a variety of sample control devices. See full specs for more information.
+
+It is possible to write support for additional systems/devices.
+
+
+Role of Ophyd-Async
+-------------------
+
+Bluesky supports devices that configure acquisition and then hand over control to an external system via the ``Flyer`` protocol. 
+
+Ophyd-async's job is to provide devices that implement ``Flyer`` and can:
+
+- Configure all necessary hardware for a scan
+- Kickoff a scan and monitor progress until complete
+- Produce documents representing the progress of the scan
+- Allow handing control back and forth to enable outer scanning
+
+.. _PandA: https://quantumdetectors.com/products/pandabox/
+.. _Zebra: https://quantumdetectors.com/products/zebra/

ophyd_async-0.3a3/docs/how-to/choose-interfaces-for-devices.md

@@ -0,0 +1,15 @@
+# Decision Flowchart for Creating a New ophyd_async Device
+
+This document contains a decision flowchart designed to guide developers through the process of creating a new ophyd_async device in the Ophyd library. It outlines a series of decisions based on the device's capabilities, such as file writing, reading values from process variables (PVs), and mobility within scans. The flowchart helps in determining the appropriate class inheritance and methods to override for optimal device functionality and integration into the system.
+
+```{mermaid}
+
+  flowchart TD
+    start([Start]) --> isFileWriting{Is it a File Writing Detector?}
+    isFileWriting -- Yes --> useStandardDetector[Use StandardDetector]
+    isFileWriting -- No --> producesPVValue{Does it produce a value from a PV you want to read in a scan?}
+    producesPVValue -- Yes --> isMovable{Is it something that you move in a scan?}
+    isMovable -- Yes --> useReadableMovable[Use StandardReadable + AsyncMovable + Override set method]
+    isMovable -- No --> useReadable[Use StandardReadable]
+    producesPVValue -- No --> useDevice[Use Device]
+```

ophyd_async-0.3a3/docs/how-to/make-a-standard-detector.rst

@@ -0,0 +1,64 @@
+.. note::
+
+   Ophyd async is included on a provisional basis until the v1.0 release and 
+   may change API on minor release numbers before then
+
+Make a StandardDetector
+=======================
+
+`StandardDetector` is an abstract class to assist in creating Device classes for hardware that writes its own data e.g. an AreaDetector implementation, or a PandA writing motor encoder positions to file.
+The `StandardDetector` is a simple compound device, with 2 standard components: 
+
+- `DetectorWriter` to handle data persistence, i/o and pass information about data to the RunEngine (usually an instance of :py:class:`HDFWriter`)
+- `DetectorControl` with logic for arming and disarming the detector. This will be unique to the StandardDetector implementation.
+
+Writing an AreaDetector StandardDetector
+----------------------------------------
+
+For an AreaDetector implementation of the StandardDetector, two entity objects which are subdevices of the `StandardDetector` are used to map to AreaDetector plugins:
+
+- An NDPluginFile instance (for :py:class:`HDFWriter` an instance of :py:class:`NDFileHDF`)
+- An :py:class:`ADBase` instance mapping to NDArray for the "driver" of the detector implementation
+
+
+Define a :py:class:`FooDriver` if the NDArray requires fields in addition to those on :py:class:`ADBase` to be exposed. It should extend :py:class:`ADBase`.
+Enumeration fields should be named to prevent namespace collision, i.e. for a Signal named "TriggerSource" use the enum "FooTriggerSource"
+
+.. literalinclude:: ../examples/foo_detector.py
+   :language: python
+   :pyobject: FooDriver
+
+Define a :py:class:`FooController` with handling for converting the standard pattern of :py:meth:`ophyd_async.core.DetectorControl.arm` and :py:meth:`ophyd_async.core.DetectorControl.disarm` to required state of :py:class:`FooDriver` e.g. setting a compatible "FooTriggerSource" for a given `DetectorTrigger`, or raising an exception if incompatible with the `DetectorTrigger`.
+
+The :py:meth:`ophyd_async.core.DetectorControl.get_deadtime` method is used when constructing sequence tables for hardware controlled scanning. Details on how to calculate the deadtime may be only available from technical manuals or otherwise complex. **If it requires fetching from signals, it is recommended to cache the value during the StandardDetector `prepare` method.**
+
+.. literalinclude:: ../examples/foo_detector.py
+   :pyobject: FooController
+
+:py:class:`FooDetector` ties the Driver, Controller and data persistence layer together. The example :py:class:`FooDetector` writes h5 files using the standard NDPlugin. It additionally supports the :py:class:`HasHints` protocol which is optional but recommended.
+
+Its initialiser assumes the NSLS-II AreaDetector plugin EPICS address suffixes as defaults but allows overriding: **this pattern is recommended for consistency**.
+If the :py:class:`FooDriver` signals that should be read as configuration, they should be added to the "config_sigs" passed to the super.
+
+.. literalinclude:: ../examples/foo_detector.py
+   :pyobject: FooDetector
+
+
+Writing a non-AreaDetector StandardDetector
+-------------------------------------------
+
+A non-AreaDetector `StandardDetector` should implement `DetectorControl` and `DetectorWriter` directly.
+Here we construct a `DetectorControl` that co-ordinates signals on a PandA PositionCapture block - a child device "pcap" of the `StandardDetector` implementation, analogous to the :py:class:`FooDriver`.
+
+.. literalinclude:: ../../src/ophyd_async/panda/_panda_controller.py
+   :pyobject: PandaPcapController
+
+The PandA may write a number of fields, and the :py:class:`PandaHDFWriter` co-ordinates those, configures the filewriter and describes the data for the RunEngine.
+
+.. literalinclude:: ../../src/ophyd_async/panda/writers/_hdf_writer.py
+   :pyobject: PandaHDFWriter
+
+The PandA StandardDetector implementation simply ties the component parts and its child devices together.
+
+.. literalinclude:: ../../src/ophyd_async/panda/_hdf_panda.py
+   :pyobject: HDFPanda

{ophyd_async-0.3a2 → ophyd_async-0.3a3}/docs/how-to/write-tests-for-devices.rst

@@ -35,6 +35,8 @@ Sim Utility Functions
 
 Sim signals behave as simply as possible, holding a sensible default value when initialized and retaining any value (in memory) to which they are set. This model breaks down in the case of read-only signals, which cannot be set because there is an expectation of some external device setting them in the real world. There is a utility function, ``set_sim_value``, to mock-set values for sim signals, including read-only ones.
 
+In addition this example also utilizes helper functions like ``assert_reading`` and ``assert_value`` to ensure the validity of device readings and values. For more information see: :doc:`API.core<../generated/ophyd_async.core>`
+
 .. literalinclude:: ../../tests/epics/demo/test_demo.py
    :pyobject: test_sensor_reading_shows_value
 
@@ -43,3 +45,12 @@ There is another utility function, ``set_sim_callback``, for hooking in logic wh
 
 .. literalinclude:: ../../tests/epics/demo/test_demo.py
    :pyobject: test_mover_stopped
+
+
+Testing a Device in a Plan with the RunEngine
+---------------------------------------------
+.. literalinclude:: ../../tests/epics/demo/test_demo.py
+   :pyobject: test_sensor_in_plan
+
+
+This test verifies that the sim_sensor behaves as expected within a plan. The plan we use here is a ``count``, which takes a specified number of readings from the ``sim_sensor``. Since we set the ``repeat`` to two in this test, the sensor should emit two "event" documents along with "start", "stop" and "descriptor" documents. Finally, we use the helper function ``assert_emitted`` to confirm that the emitted documents match our expectations.

{ophyd_async-0.3a2 → ophyd_async-0.3a3}/pyproject.toml

@@ -49,7 +49,7 @@ dev = [
     "pre-commit",
     "pydata-sphinx-theme>=0.12",
     "pyepics>=3.4.2",
-    "pyside6==6.6.2",
+    "pyside6==6.7.0",
     "pytest",
     "pytest-asyncio",
     "pytest-cov",
@@ -58,11 +58,13 @@ dev = [
     "pytest-timeout",
     "ruff",
     "sphinx-autobuild",
+    "sphinxcontrib-mermaid",
     "sphinx-copybutton",
     "sphinx-design",
     "tox-direct",
     "types-mock",
     "types-pyyaml",
+    "colorlog"
 ]
 
 [project.scripts]

{ophyd_async-0.3a2 → ophyd_async-0.3a3}/src/ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3a2'
+__version__ = version = '0.3a3'
 __version_tuple__ = version_tuple = (0, 3)

{ophyd_async-0.3a2 → ophyd_async-0.3a3}/src/ophyd_async/core/__init__.py

@@ -30,6 +30,10 @@ from .signal import (
     SignalRW,
     SignalW,
     SignalX,
+    assert_configuration,
+    assert_emitted,
+    assert_reading,
+    assert_value,
     observe_value,
     set_and_wait_for_value,
     set_sim_callback,
@@ -41,7 +45,7 @@ from .signal import (
 )
 from .signal_backend import SignalBackend
 from .sim_signal_backend import SimSignalBackend
-from .standard_readable import StandardReadable
+from .standard_readable import ConfigSignal, HintedSignal, StandardReadable
 from .utils import (
     DEFAULT_TIMEOUT,
     Callback,
@@ -84,6 +88,8 @@ __all__ = [
     "ShapeProvider",
     "StaticDirectoryProvider",
     "StandardReadable",
+    "ConfigSignal",
+    "HintedSignal",
     "TriggerInfo",
     "TriggerLogic",
     "HardwareTriggeredFlyable",
@@ -103,4 +109,8 @@ __all__ = [
     "walk_rw_signals",
     "load_device",
     "save_device",
+    "assert_reading",
+    "assert_value",
+    "assert_configuration",
+    "assert_emitted",
 ]

{ophyd_async-0.3a2 → ophyd_async-0.3a3}/src/ophyd_async/core/detector.py

@@ -19,7 +19,7 @@ from typing import (
 
 from bluesky.protocols import (
     Collectable,
-    Descriptor,
+    DataKey,
     Flyable,
     Preparable,
     Reading,
@@ -33,7 +33,6 @@ from ophyd_async.protocols import AsyncConfigurable, AsyncReadable
 
 from .async_status import AsyncStatus
 from .device import Device
-from .signal import SignalR
 from .utils import DEFAULT_TIMEOUT, merge_gathered_dicts
 
 T = TypeVar("T")
@@ -110,7 +109,7 @@ class DetectorWriter(ABC):
     (e.g. an HDF5 file)"""
 
     @abstractmethod
-    async def open(self, multiplier: int = 1) -> Dict[str, Descriptor]:
+    async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
         """Open writer and wait for it to be ready for data.
 
         Args:
@@ -161,7 +160,7 @@ class StandardDetector(
         self,
         controller: DetectorControl,
         writer: DetectorWriter,
-        config_sigs: Sequence[SignalR] = (),
+        config_sigs: Sequence[AsyncReadable] = (),
         name: str = "",
         writer_timeout: float = DEFAULT_TIMEOUT,
     ) -> None:
@@ -181,7 +180,7 @@ class StandardDetector(
         """
         self._controller = controller
         self._writer = writer
-        self._describe: Dict[str, Descriptor] = {}
+        self._describe: Dict[str, DataKey] = {}
         self._config_sigs = list(config_sigs)
         self._frame_writing_timeout = writer_timeout
         # For prepare
@@ -214,7 +213,7 @@ class StandardDetector(
     async def _check_config_sigs(self):
         """Checks configuration signals are named and connected."""
         for signal in self._config_sigs:
-            if signal._name == "":
+            if signal.name == "":
                 raise Exception(
                     "config signal must be named before it is passed to the detector"
                 )
@@ -234,14 +233,14 @@ class StandardDetector(
     async def read_configuration(self) -> Dict[str, Reading]:
         return await merge_gathered_dicts(sig.read() for sig in self._config_sigs)
 
-    async def describe_configuration(self) -> Dict[str, Descriptor]:
+    async def describe_configuration(self) -> Dict[str, DataKey]:
         return await merge_gathered_dicts(sig.describe() for sig in self._config_sigs)
 
     async def read(self) -> Dict[str, Reading]:
         # All data is in StreamResources, not Events, so nothing to output here
         return {}
 
-    async def describe(self) -> Dict[str, Descriptor]:
+    async def describe(self) -> Dict[str, DataKey]:
         return self._describe
 
     @AsyncStatus.wrap
@@ -330,7 +329,7 @@ class StandardDetector(
         assert self._fly_status, "Kickoff not run"
         return await self._fly_status
 
-    async def describe_collect(self) -> Dict[str, Descriptor]:
+    async def describe_collect(self) -> Dict[str, DataKey]:
         return self._describe
 
     async def collect_asset_docs(

{ophyd_async-0.3a2 → ophyd_async-0.3a3}/src/ophyd_async/core/flyer.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import Dict, Generic, Sequence, TypeVar
 
-from bluesky.protocols import Descriptor, Flyable, Preparable, Reading, Stageable
+from bluesky.protocols import DataKey, Flyable, Preparable, Reading, Stageable
 
 from .async_status import AsyncStatus
 from .device import Device
@@ -74,7 +74,7 @@ class HardwareTriggeredFlyable(
     async def complete(self) -> None:
         await self._trigger_logic.complete()
 
-    async def describe_configuration(self) -> Dict[str, Descriptor]:
+    async def describe_configuration(self) -> Dict[str, DataKey]:
         return await merge_gathered_dicts(
             [sig.describe() for sig in self._configuration_signals]
         )