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

{ophyd_async-0.3a2 → ophyd_async-0.3a4}/.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.3a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3a2
+Version: 0.3a4
 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
@@ -48,6 +48,7 @@ Requires-Dist: bluesky>=1.13.0a3
 Requires-Dist: event-model<1.21.0
 Requires-Dist: p4p
 Requires-Dist: pyyaml
+Requires-Dist: colorlog
 Provides-Extra: ca
 Requires-Dist: aioca>=1.6; extra == "ca"
 Provides-Extra: pva
@@ -72,7 +73,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,6 +82,7 @@ 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"
@@ -92,7 +94,7 @@ Requires-Dist: types-pyyaml; extra == "dev"
 [![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.3a4}/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.3a4}/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.3a4/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.3a4/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.3a4/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.3a4/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.3a2 → ophyd_async-0.3a4}/docs/how-to/make-a-simple-device.rst

@@ -30,7 +30,8 @@ its Python type, which could be:
 
 - A primitive (`str`, `int`, `float`)
 - An array (`numpy.typing.NDArray` or ``Sequence[str]``)
-- An enum (`enum.Enum`). 
+- An enum (`enum.Enum`) which **must** also extend `str`
+    - `str` and ``EnumClass(str, Enum)`` are the only valid ``datatype`` for an enumerated signal.
 
 The rest of the arguments are PV connection information, in this case the PV suffix.
 

ophyd_async-0.3a4/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.3a4/docs/how-to/write-tests-for-devices.rst

@@ -0,0 +1,58 @@
+.. note::
+
+   Ophyd async is included on a provisional basis until the v1.0 release and 
+   may change API on minor release numbers before then
+
+Write Tests for Devices
+=======================
+
+Testing ophyd-async devices using tools like mocking, patching, and fixtures can become complicated very quickly. The library provides several utilities to make it easier.
+
+Async Tests
+-----------
+
+`pytest-asyncio <https://github.com/pytest-dev/pytest-asyncio>`_ is required for async tests. It is should be included as a dev dependency of your project. Tests can either be decorated with ``@pytest.mark.asyncio`` or the project can be automatically configured to detect async tests.
+
+.. code:: toml
+
+   # pyproject.toml
+
+   [tool.pytest.ini_options]
+   ...
+   asyncio_mode = "auto"
+
+Mock Backend
+------------
+
+Ophyd devices initialized with a mock backend behave in a similar way to mocks, without requiring you to mock out all the dependencies and internals. The `DeviceCollector` can initialize any number of devices, and their signals and sub-devices (recursively), with a mock backend.
+
+.. literalinclude:: ../../tests/epics/demo/test_demo.py
+   :pyobject: mock_sensor
+
+
+Mock Utility Functions
+----------------------
+
+Mock 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_mock_value``, to mock-set values for mock 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
+
+
+There are several other test utility functions:
+
+Use ``callback_on_mock_put``, for hooking in logic when a mock value changes (e.g. because someone puts to it). This can be called directly, or used as a context, with the callbacks ending after exit.
+
+.. 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.3a4}/docs/tutorials/using-existing-devices.rst

@@ -57,7 +57,7 @@ and run the following:
 - If ``connect=True`` (the default), then call `Device.connect` in parallel for
   all top level Devices, waiting for up to ``timeout`` seconds. For example,
   here we call ``asyncio.wait([det.connect(), samp.connect()])``
-- If ``sim=True`` is passed, then don't connect to PVs, but set Devices into
+- If ``mock=True`` is passed, then don't connect to PVs, but set Devices into
   simulation mode
 
 The Devices we create in this example are a "sample stage" with a couple of

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

@@ -20,6 +20,7 @@ dependencies = [
     "event-model<1.21.0",
     "p4p",
     "pyyaml",
+    "colorlog",
 ]
 dynamic = ["version"]
 license.file = "LICENSE"
@@ -49,7 +50,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,6 +59,7 @@ dev = [
     "pytest-timeout",
     "ruff",
     "sphinx-autobuild",
+    "sphinxcontrib-mermaid",
     "sphinx-copybutton",
     "sphinx-design",
     "tox-direct",
@@ -84,7 +86,6 @@ write_to = "src/ophyd_async/_version.py"
 addopts = """
     --tb=native -vv --strict-markers --doctest-modules
     --doctest-glob="*.rst" --doctest-glob="*.md" --ignore=docs/examples
-    --cov=src/ophyd_async --cov-report term --cov-report xml:cov.xml
     """
 # https://iscinumpy.gitlab.io/post/bound-version-constraints/#watch-for-warnings
 filterwarnings = "error"

{ophyd_async-0.3a2 → ophyd_async-0.3a4}/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.3a4'
 __version_tuple__ = version_tuple = (0, 3)

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

@@ -24,24 +24,37 @@ from .device_save_loader import (
     walk_rw_signals,
 )
 from .flyer import HardwareTriggeredFlyable, TriggerLogic
+from .mock_signal_backend import (
+    MockSignalBackend,
+)
+from .mock_signal_utils import (
+    assert_mock_put_called_with,
+    callback_on_mock_put,
+    mock_puts_blocked,
+    reset_mock_put_calls,
+    set_mock_put_proceeds,
+    set_mock_value,
+    set_mock_values,
+)
 from .signal import (
     Signal,
     SignalR,
     SignalRW,
     SignalW,
     SignalX,
+    assert_configuration,
+    assert_emitted,
+    assert_reading,
+    assert_value,
     observe_value,
     set_and_wait_for_value,
-    set_sim_callback,
-    set_sim_put_proceeds,
-    set_sim_value,
-    soft_signal_r_and_backend,
+    soft_signal_r_and_setter,
     soft_signal_rw,
     wait_for_value,
 )
 from .signal_backend import SignalBackend
-from .sim_signal_backend import SimSignalBackend
-from .standard_readable import StandardReadable
+from .soft_signal_backend import SoftSignalBackend
+from .standard_readable import ConfigSignal, HintedSignal, StandardReadable
 from .utils import (
     DEFAULT_TIMEOUT,
     Callback,
@@ -55,9 +68,15 @@ from .utils import (
 )
 
 __all__ = [
+    "assert_mock_put_called_with",
+    "callback_on_mock_put",
+    "mock_puts_blocked",
+    "set_mock_values",
+    "reset_mock_put_calls",
     "SignalBackend",
-    "SimSignalBackend",
+    "SoftSignalBackend",
     "DetectorControl",
+    "MockSignalBackend",
     "DetectorTrigger",
     "DetectorWriter",
     "StandardDetector",
@@ -69,13 +88,12 @@ __all__ = [
     "SignalW",
     "SignalRW",
     "SignalX",
-    "soft_signal_r_and_backend",
+    "soft_signal_r_and_setter",
     "soft_signal_rw",
     "observe_value",
     "set_and_wait_for_value",
-    "set_sim_callback",
-    "set_sim_put_proceeds",
-    "set_sim_value",
+    "set_mock_put_proceeds",
+    "set_mock_value",
     "wait_for_value",
     "AsyncStatus",
     "DirectoryInfo",
@@ -84,6 +102,8 @@ __all__ = [
     "ShapeProvider",
     "StaticDirectoryProvider",
     "StandardReadable",
+    "ConfigSignal",
+    "HintedSignal",
     "TriggerInfo",
     "TriggerLogic",
     "HardwareTriggeredFlyable",
@@ -103,4 +123,8 @@ __all__ = [
     "walk_rw_signals",
     "load_device",
     "save_device",
+    "assert_reading",
+    "assert_value",
+    "assert_configuration",
+    "assert_emitted",
 ]

{ophyd_async-0.3a2 → ophyd_async-0.3a4}/src/ophyd_async/core/async_status.py

@@ -21,7 +21,9 @@ class AsyncStatus(Status):
             self.task = awaitable
         else:
             self.task = asyncio.create_task(awaitable)  # type: ignore
+
         self.task.add_done_callback(self._run_callbacks)
+
         self._callbacks = cast(List[Callback[Status]], [])
         self._watchers = watchers