ophyd-async 0.4.0__tar.gz → 0.5.1__tar.gz

{ophyd_async-0.4.0 → ophyd_async-0.5.1}/.github/workflows/_release.yml

@@ -23,7 +23,7 @@ jobs:
       - name: Create GitHub Release
         # 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: softprops/action-gh-release@a74c6b72af54cfa997e81df42d94703d6313a2d0 # v2.0.6
+        uses: softprops/action-gh-release@c062e08bd532815e2082a85e87e3ef29c3e6d191 # v2.0.8
         with:
           prerelease: ${{ contains(github.ref_name, 'a') || contains(github.ref_name, 'b') || contains(github.ref_name, 'rc') }}
           files: "*"

{ophyd_async-0.4.0 → ophyd_async-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.4.0
+Version: 0.5.1
 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
@@ -55,14 +55,16 @@ Provides-Extra: ca
 Requires-Dist: aioca>=1.6; extra == "ca"
 Provides-Extra: pva
 Requires-Dist: p4p; extra == "pva"
+Provides-Extra: sim
+Requires-Dist: h5py; extra == "sim"
 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: black; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
 Requires-Dist: flake8-isort; extra == "dev"
 Requires-Dist: Flake8-pyproject; extra == "dev"
-Requires-Dist: h5py; extra == "dev"
 Requires-Dist: inflection; extra == "dev"
 Requires-Dist: ipython; extra == "dev"
 Requires-Dist: ipywidgets; extra == "dev"

{ophyd_async-0.4.0 → ophyd_async-0.5.1}/docs/examples/foo_detector.py

@@ -3,22 +3,20 @@ 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.core import (
+    AsyncStatus,
+    DetectorControl,
+    DetectorTrigger,
+    PathProvider,
+    StandardDetector,
 )
-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
+from ophyd_async.epics import adcore
+from ophyd_async.epics.signal import epics_signal_rw_rbv
 
 
-class FooDriver(ADBase):
+class FooDriver(adcore.ADBaseIO):
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.trigger_mode = ad_rw(str, prefix + "TriggerMode")
+        self.trigger_mode = epics_signal_rw_rbv(str, prefix + "TriggerMode")
         super().__init__(prefix, name)
 
 
@@ -38,40 +36,40 @@ class FooController(DetectorControl):
     ) -> AsyncStatus:
         await asyncio.gather(
             self._drv.num_images.set(num),
-            self._drv.image_mode.set(ImageMode.multiple),
+            self._drv.image_mode.set(adcore.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)
+        return await adcore.start_acquiring_driver_and_ensure_status(self._drv)
 
     async def disarm(self):
-        await stop_busy_record(self._drv.acquire, False, timeout=1)
+        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)
 
 
 class FooDetector(StandardDetector, HasHints):
     _controller: FooController
-    _writer: HDFWriter
+    _writer: adcore.ADHDFWriter
 
     def __init__(
         self,
         prefix: str,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         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)
+        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
 
         super().__init__(
             FooController(self.drv),
-            HDFWriter(
+            adcore.ADHDFWriter(
                 self.hdf,
-                directory_provider,
+                path_provider,
                 lambda: self.name,
-                ADBaseShapeProvider(self.drv),
+                adcore.ADBaseShapeProvider(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

ophyd_async-0.5.1/docs/explanations/decisions/0007-subpackage-structure.md

@@ -0,0 +1,95 @@
+# 7. Sub-package Structure
+
+Date: 2024-04-22
+
+## Status
+
+Accepted
+
+## Context
+
+[](./0004-repository-structure) proposed a top level repository structure. This builds upon it, suggesting a top level structure divided into:
+
+- `ophyd_async.core`: Core classes like `Device`, `Signal` and `AsyncStatus`
+- `ophyd_async.epics`: Epics specific signals and devices
+- `ophyd_async.tango`: Tango specific signals and devices
+- `ophyd_async.fastcs`: FastCS (EPICS or Tango) devices like PandA
+- `ophyd_async.planstubs`: Plan stubs for various flyscan functionality
+- `ophyd_async.sim`: Simulated devices for demos and tests
+
+This ADR proposes a public sub-package structure. The internal private structure should be flat, but can change according to the number of classes in a public package.
+
+## Decision
+
+### core
+
+There will be a flat public namespace under core, with contents reimported from an underscore prefixed python files, e.g.:
+
+- `_status.py` for `AsyncStatus`, `WatchableAsyncStatus`, etc.
+- `_protocol.py` for `AsyncReadable`, `AsyncStageable`, etc.
+- `_device.py` for `Device`, `DeviceVector`, etc.
+- `_signal.py` for `Signal`, `SignalBackend`, `observe_signal`, etc.
+- `_mock.py` for `MockSignalBackend`, `get_mock_put`, etc.
+- `_readable.py` for `StandardReadable`, `ConfigSignal`, `HintedSignal`, etc.
+- `_detector.py` for `StandardDetector`, `DetectorWriter`, `DetectorControl`, `TriggerInfo`, etc.
+- `_flyer.py` for `StandardFlyer`, `FlyerControl`, etc.
+
+There are some renames that will be required, e.g. `HardwareTriggeredFlyable` -> `StandardFlyer`
+
+### epics
+
+Epics modules consist of 2 sorts of classes:
+- `IO` classes, which are `Device` subclasses containing `Signals` that map as closely as possible to the EPICS template hierarchy. Their name matches the EPICS template with the suffix `IO`.
+- `Control` and `Writer` classes that plug into `StandardDetector` and `StandardFlyer` telling them which logic to use during various bluesky verbs.
+
+There should be an additional level of packages that correspond to the epics support module, and contain classes that map to the EPICS database and logic classes e.g.:
+
+- `epics.signal`: containing `epics_signal_rw`, `CaSignalBackend`, etc.
+- `epics.adcore`: containing `ADDriverIO`, `NDFileHdfIO`, `ADHdfWriter` etc. 
+- `epics.adpilatus`: containing `ADPilatusIO`, `PilatusControl` etc.
+
+The name of the module is the EPICS module lowercased with dashes and other special characters converted to underscores.
+
+They can be imported from modules:
+
+```python
+from ophyd_async.epics import adcore, adpilatus
+
+drv = adpilatus.ADPilatusIO(prefix + "DRV:")
+hdf = adcore.NDFileHDFIO(prefix + "HDF:")
+```
+
+The structure is left to an individual module's size. For instance `motor` will probably be a single `motor.py`, while `ADCore` will likely be an `ADCore/` directory with `_io.py`, `_writer.py`, `_control.py`.
+
+Detector modules should include a reference `StandardDetector` subclass, but without making any site specific decisions about PV naming.
+
+### tango
+
+This has not been created at the time of writing, but it is envisioned that it will follow the EPICS structure where it makes sense.
+
+### fastcs
+
+There will be one subpackage for each FastCS Device. At the time of writing there are none of these, but PandA and Odin will shortly be converted to FastCS, so it makes sense to make:
+
+- `fastcs.panda`
+- `fastcs.odin`
+
+in preparation. 
+
+For PandA its namespace should contain `CommonPandaBlocks`, `SeqBlock`, `PandaHdfWriter`, `PandaPcapController`, etc. These should be included in files like `_control.py`, `_writer.py`, `_block.py`, `_table.py` and imported into the `panda` namespace.
+
+### planstubs
+
+There will be some planstubs for shared setup that may reach across modules like `epics` and `fastcs/panda`, these should live in a `planstubs/` package.
+
+### sim
+
+There will be 2 subpackages:
+- `sim.demo` for demo devices like `PatternDetector` and `SimMotor` used in tutorials.
+- `sim.testing` for devices that will support tests in `ophyd-async` and `bluesky`. Some test fixtures could be moved here
+
+There should probably be one file per Device, in an underscore prefixed file reimported into the public namespace, e.g. `demo/_sim_motor.py` and `demo/_pattern_detector.py`.
+
+## Consequences
+
+The public import paths are fixed, but the underlying implementation can move from modules to packages without change to the public interface.

{ophyd_async-0.4.0 → ophyd_async-0.5.1}/docs/how-to/compound-devices.rst

@@ -11,7 +11,7 @@ Assembly
 
 Compound assemblies can be used to group Devices into larger logical Devices:
 
-.. literalinclude:: ../../src/ophyd_async/epics/demo/__init__.py
+.. literalinclude:: ../../src/ophyd_async/epics/demo/_mover.py
    :pyobject: SampleStage
 
 This applies prefixes on construction:
@@ -35,7 +35,7 @@ Grouping by Index
 
 Sometimes, it makes sense to group devices by number, say an array of sensors:
 
-.. literalinclude:: ../../src/ophyd_async/epics/demo/__init__.py
+.. literalinclude:: ../../src/ophyd_async/epics/demo/_sensor.py
    :pyobject: SensorGroup
 
 :class:`~ophyd-async.core.DeviceVector` allows writing maintainable, arbitrary-length device groups instead of fixed classes for each possible grouping. A :class:`~ophyd-async.core.DeviceVector` can be accessed via indices, for example: ``my_sensor_group.sensors[2]``. Here ``sensors`` is a dictionary with integer indices rather than a list so that the most semantically sensible indices may be used, the sensor group above may be 1-indexed, for example, because the sensors' datasheet calls them "sensor 1", "sensor 2" etc. 

{ophyd_async-0.4.0 → ophyd_async-0.5.1}/docs/how-to/make-a-simple-device.rst

@@ -22,14 +22,14 @@ For a simple :external+bluesky:py:class:`bluesky.protocols.Readable` object like
 define some signals, then tell the superclass which signals should contribute to
 ``read()`` and ``read_configuration()``:
 
-.. literalinclude:: ../../src/ophyd_async/epics/demo/__init__.py
+.. literalinclude:: ../../src/ophyd_async/epics/demo/_sensor.py
    :pyobject: Sensor
 
 First some Signals are constructed and stored on the Device. Each one is passed
 its Python type, which could be:
 
 - A primitive (`str`, `int`, `float`)
-- An array (`numpy.typing.NDArray` or ``Sequence[str]``)
+- An array (`numpy.typing.NDArray` ie. ``numpy.typing.NDArray[numpy.uint16]`` or ``Sequence[str]``)
 - An enum (`enum.Enum`) which **must** also extend `str`
     - `str` and ``EnumClass(str, Enum)`` are the only valid ``datatype`` for an enumerated signal.
 
@@ -54,7 +54,7 @@ Movable
 For a more complicated device like a `Mover`, you can still use `StandardReadable`
 and implement some addition protocols:
 
-.. literalinclude:: ../../src/ophyd_async/epics/demo/__init__.py
+.. literalinclude:: ../../src/ophyd_async/epics/demo/_mover.py
    :pyobject: Mover
 
 The ``set()`` method implements :external+bluesky:py:class:`bluesky.protocols.Movable`. This
@@ -71,7 +71,7 @@ Assembly
 
 Compound assemblies can be used to group Devices into larger logical Devices:
 
-.. literalinclude:: ../../src/ophyd_async/epics/demo/__init__.py
+.. literalinclude:: ../../src/ophyd_async/epics/demo/_mover.py
    :pyobject: SampleStage
 
 This applies prefixes on construction:

{ophyd_async-0.4.0 → ophyd_async-0.5.1}/docs/how-to/make-a-standard-detector.rst

@@ -9,7 +9,7 @@ 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`)
+- `DetectorWriter` to handle data persistence, i/o and pass information about data to the RunEngine (usually an instance of :py:class:`ADHDFWriter`)
 - `DetectorControl` with logic for arming and disarming the detector. This will be unique to the StandardDetector implementation.
 
 Writing an AreaDetector StandardDetector
@@ -17,11 +17,11 @@ 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
+- An NDPluginFile instance (for :py:class:`ADHDFWriter` an instance of :py:class:`NDFileHDFIO`)
+- An :py:class:`ADBaseIO` 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`.
+Define a :py:class:`FooDriver` if the NDArray requires fields in addition to those on :py:class:`ADBaseIO` to be exposed. It should extend :py:class:`ADBaseIO`.
 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
@@ -50,15 +50,15 @@ 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
+.. literalinclude:: ../../src/ophyd_async/fastcs/panda/_control.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
+.. literalinclude:: ../../src/ophyd_async/fastcs/panda/_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
+.. literalinclude:: ../../src/ophyd_async/fastcs/panda/_hdf_panda.py
    :pyobject: HDFPanda

{ophyd_async-0.4.0 → ophyd_async-0.5.1}/docs/reference/api.rst

@@ -26,4 +26,4 @@ This is the internal API reference for ophyd_async
 
     core
     epics
-    panda
+    fastcs

{ophyd_async-0.4.0 → ophyd_async-0.5.1}/pyproject.toml

@@ -32,14 +32,15 @@ requires-python = ">=3.10"
 [project.optional-dependencies]
 ca = ["aioca>=1.6"]
 pva = ["p4p"]
+sim = ["h5py"]
 dev = [
     "ophyd_async[pva]",
+    "ophyd_async[sim]",
     "ophyd_async[ca]",
     "black",
     "flake8",
     "flake8-isort",
     "Flake8-pyproject",
-    "h5py",
     "inflection",
     "ipython",
     "ipywidgets",
@@ -146,4 +147,11 @@ lint.select = [
     "F",    # pyflakes rules - https://beta.ruff.rs/docs/rules/#pyflakes-f
     "W",    # pycodestyle warnings - https://beta.ruff.rs/docs/rules/#warning-w
     "I001", # isort
+    "SLF",  # self - https://docs.astral.sh/ruff/settings/#lintflake8-self
 ]
+
+[tool.ruff.lint.per-file-ignores]
+# By default, private member access is allowed in tests
+# See https://github.com/DiamondLightSource/python-copier-template/issues/154
+# Remove this line to forbid private member access in tests
+"tests/**/*" = ["SLF001"]

{ophyd_async-0.4.0 → ophyd_async-0.5.1}/src/ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.4.0'
-__version_tuple__ = version_tuple = (0, 4, 0)
+__version__ = version = '0.5.1'
+__version_tuple__ = version_tuple = (0, 5, 1)

{ophyd_async-0.4.0 → ophyd_async-0.5.1}/src/ophyd_async/core/__init__.py

@@ -1,26 +1,13 @@
-from ._providers import (
-    AutoIncrementFilenameProvider,
-    AutoIncrementingPathProvider,
-    FilenameProvider,
-    NameProvider,
-    PathInfo,
-    PathProvider,
-    ShapeProvider,
-    StaticFilenameProvider,
-    StaticPathProvider,
-    UUIDFilenameProvider,
-    YMDPathProvider,
-)
-from .async_status import AsyncStatus, WatchableAsyncStatus
-from .detector import (
+from ._detector import (
     DetectorControl,
     DetectorTrigger,
     DetectorWriter,
     StandardDetector,
     TriggerInfo,
 )
-from .device import Device, DeviceCollector, DeviceVector
-from .device_save_loader import (
+from ._device import Device, DeviceCollector, DeviceVector
+from ._device_save_loader import (
+    all_at_once,
     get_signal_values,
     load_device,
     load_from_yaml,
@@ -29,9 +16,11 @@ from .device_save_loader import (
     set_signal_values,
     walk_rw_signals,
 )
-from .flyer import HardwareTriggeredFlyable, TriggerLogic
-from .mock_signal_backend import MockSignalBackend
-from .mock_signal_utils import (
+from ._flyer import StandardFlyer, TriggerLogic
+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_put,
     mock_puts_blocked,
@@ -40,7 +29,22 @@ from .mock_signal_utils import (
     set_mock_value,
     set_mock_values,
 )
-from .signal import (
+from ._protocol import AsyncConfigurable, AsyncReadable, AsyncStageable
+from ._providers import (
+    AutoIncrementFilenameProvider,
+    AutoIncrementingPathProvider,
+    FilenameProvider,
+    NameProvider,
+    PathInfo,
+    PathProvider,
+    ShapeProvider,
+    StaticFilenameProvider,
+    StaticPathProvider,
+    UUIDFilenameProvider,
+    YMDPathProvider,
+)
+from ._readable import ConfigSignal, HintedSignal, StandardReadable
+from ._signal import (
     Signal,
     SignalR,
     SignalRW,
@@ -51,98 +55,107 @@ from .signal import (
     assert_reading,
     assert_value,
     observe_value,
+    set_and_wait_for_other_value,
     set_and_wait_for_value,
     soft_signal_r_and_setter,
     soft_signal_rw,
     wait_for_value,
 )
-from .signal_backend import RuntimeSubsetEnum, SignalBackend, SubsetEnum
-from .soft_signal_backend import SoftSignalBackend
-from .standard_readable import ConfigSignal, HintedSignal, StandardReadable
-from .utils import (
+from ._signal_backend import RuntimeSubsetEnum, SignalBackend, SubsetEnum
+from ._soft_signal_backend import SignalMetadata, SoftSignalBackend
+from ._status import AsyncStatus, WatchableAsyncStatus
+from ._utils import (
     DEFAULT_TIMEOUT,
     CalculatableTimeout,
     CalculateTimeout,
-    Callback,
     NotConnected,
     ReadingValueCallback,
     T,
+    WatcherUpdate,
     get_dtype,
     get_unique,
-    merge_gathered_dicts,
+    in_micros,
     wait_for_connection,
 )
 
 __all__ = [
-    "AsyncStatus",
-    "AutoIncrementFilenameProvider",
-    "AutoIncrementingPathProvider",
-    "CalculatableTimeout",
-    "CalculateTimeout",
-    "Callback",
-    "ConfigSignal",
-    "DEFAULT_TIMEOUT",
     "DetectorControl",
     "DetectorTrigger",
     "DetectorWriter",
+    "StandardDetector",
+    "TriggerInfo",
     "Device",
     "DeviceCollector",
     "DeviceVector",
-    "FilenameProvider",
-    "HardwareTriggeredFlyable",
-    "HintedSignal",
+    "all_at_once",
+    "get_signal_values",
+    "load_device",
+    "load_from_yaml",
+    "save_device",
+    "save_to_yaml",
+    "set_signal_values",
+    "walk_rw_signals",
+    "StandardFlyer",
+    "TriggerLogic",
+    "HDFDataset",
+    "HDFFile",
+    "config_ophyd_async_logging",
     "MockSignalBackend",
+    "callback_on_mock_put",
+    "get_mock_put",
+    "mock_puts_blocked",
+    "reset_mock_put_calls",
+    "set_mock_put_proceeds",
+    "set_mock_value",
+    "set_mock_values",
+    "AsyncConfigurable",
+    "AsyncReadable",
+    "AsyncStageable",
+    "AutoIncrementFilenameProvider",
+    "AutoIncrementingPathProvider",
+    "FilenameProvider",
     "NameProvider",
-    "NotConnected",
     "PathInfo",
     "PathProvider",
-    "ReadingValueCallback",
-    "RuntimeSubsetEnum",
     "ShapeProvider",
+    "StaticFilenameProvider",
+    "StaticPathProvider",
+    "UUIDFilenameProvider",
+    "YMDPathProvider",
+    "ConfigSignal",
+    "HintedSignal",
+    "StandardReadable",
     "Signal",
-    "SignalBackend",
     "SignalR",
     "SignalRW",
     "SignalW",
     "SignalX",
-    "SoftSignalBackend",
-    "StandardDetector",
-    "StandardReadable",
-    "StaticFilenameProvider",
-    "StaticPathProvider",
-    "SubsetEnum",
-    "T",
-    "TriggerInfo",
-    "TriggerLogic",
-    "UUIDFilenameProvider",
-    "WatchableAsyncStatus",
-    "YMDPathProvider",
-    # Lower-cased imports
     "assert_configuration",
     "assert_emitted",
     "assert_reading",
     "assert_value",
-    "callback_on_mock_put",
-    "get_dtype",
-    "get_mock_put",
-    "get_signal_values",
-    "get_unique",
-    "load_device",
-    "load_from_yaml",
-    "merge_gathered_dicts",
-    "mock_puts_blocked",
     "observe_value",
-    "reset_mock_put_calls",
-    "save_device",
-    "save_to_yaml",
     "set_and_wait_for_value",
-    "set_mock_put_proceeds",
-    "set_mock_value",
-    "set_mock_values",
-    "set_signal_values",
+    "set_and_wait_for_other_value",
     "soft_signal_r_and_setter",
     "soft_signal_rw",
-    "wait_for_connection",
     "wait_for_value",
-    "walk_rw_signals",
+    "RuntimeSubsetEnum",
+    "SignalBackend",
+    "SubsetEnum",
+    "SignalMetadata",
+    "SoftSignalBackend",
+    "AsyncStatus",
+    "WatchableAsyncStatus",
+    "DEFAULT_TIMEOUT",
+    "CalculatableTimeout",
+    "CalculateTimeout",
+    "NotConnected",
+    "ReadingValueCallback",
+    "T",
+    "WatcherUpdate",
+    "get_dtype",
+    "get_unique",
+    "in_micros",
+    "wait_for_connection",
 ]