ophyd-async 0.9.0a1__py3-none-any.whl → 0.10.0a1__py3-none-any.whl

ophyd_async/testing/_mock_signal_utils.py

@@ -1,4 +1,4 @@
-from collections.abc import Awaitable, Callable, Iterable
+from collections.abc import Awaitable, Callable, Iterable, Iterator
 from contextlib import contextmanager
 from unittest.mock import AsyncMock, Mock
 
@@ -14,6 +14,10 @@ from ophyd_async.core import (
 
 
 def get_mock(device: Device | Signal) -> Mock:
+    """Return the mock (which may have child mocks attached) for a Device.
+
+    The device must have been connected in mock mode.
+    """
     mock = device._mock  # noqa: SLF001
     assert isinstance(mock, LazyMock), f"Device {device} not connected in mock mode"
     return mock()
@@ -22,9 +26,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
 
 
@@ -34,36 +38,7 @@ def set_mock_value(signal: Signal[SignalDatatypeT], value: SignalDatatypeT):
     backend.set_value(value)
 
 
-def set_mock_put_proceeds(signal: Signal, proceeds: bool):
-    """Allow or block a put with wait=True from proceeding"""
-    backend = _get_mock_signal_backend(signal)
-
-    if proceeds:
-        backend.put_proceeds.set()
-    else:
-        backend.put_proceeds.clear()
-
-
-@contextmanager
-def mock_puts_blocked(*signals: Signal):
-    for signal in signals:
-        set_mock_put_proceeds(signal, False)
-    yield
-    for signal in signals:
-        set_mock_put_proceeds(signal, True)
-
-
-def get_mock_put(signal: Signal) -> AsyncMock:
-    """Get the mock associated with the put call on the signal."""
-    return _get_mock_signal_backend(signal).put_mock
-
-
-def reset_mock_put_calls(signal: Signal):
-    backend = _get_mock_signal_backend(signal)
-    backend.put_mock.reset_mock()
-
-
-class _SetValuesIterator:
+class _SetValuesIterator(Iterator[SignalDatatypeT]):
     # Garbage collected by the time __del__ is called unless we put it as a
     # global attrbute here.
     require_all_consumed: bool = False
@@ -78,13 +53,9 @@ class _SetValuesIterator:
         self.values = values
         self.require_all_consumed = require_all_consumed
         self.index = 0
-
         self.iterator = enumerate(values, start=1)
 
-    def __iter__(self):
-        return self
-
-    def __next__(self):
+    def __next__(self) -> SignalDatatypeT:
         # Will propogate StopIteration
         self.index, next_value = next(self.iterator)
         set_mock_value(self.signal, next_value)
@@ -113,33 +84,26 @@ def set_mock_values(
     signal: SignalR[SignalDatatypeT],
     values: Iterable[SignalDatatypeT],
     require_all_consumed: bool = False,
-) -> _SetValuesIterator:
-    """Iterator to set a signal to a sequence of values, optionally repeating the
-    sequence.
-
-    Parameters
-    ----------
-    signal:
-        A signal with a `MockSignalBackend` backend.
-    values:
-        An iterable of the values to set the signal to, on each iteration
-        the value will be set.
-    require_all_consumed:
-        If True, an AssertionError will be raised if the iterator is deleted before
-        all values have been consumed.
-
-    Notes
-    -----
-    Example usage::
-
-           for value_set in set_mock_values(signal, [1, 2, 3]):
-                # do something
-
-            cm = set_mock_values(signal, 1, 2, 3, require_all_consumed=True):
-            next(cm)
-            # do something
+) -> Iterator[SignalDatatypeT]:
+    """Set a signal to a sequence of values, optionally repeating.
+
+    :param signal: A signal connected in mock mode.
+    :param values:
+        An iterable of the values to set the signal to, on each iteration the
+        next value will be set.
+    :param require_all_consumed:
+        If True, an AssertionError will be raised if the iterator is deleted
+        before all values have been consumed.
+
+    :example:
+    ```python
+    for value_set in set_mock_values(signal, range(3)):
+        # do something
+
+    cm = set_mock_values(signal, [1, 3, 8], require_all_consumed=True):
+    next(cm) # do something
+    ```
     """
-
     return _SetValuesIterator(
         signal,
         values,
@@ -160,16 +124,38 @@ def callback_on_mock_put(
 ):
     """For setting a callback when a backend is put to.
 
-    Can either be used in a context, with the callback being
-    unset on exit, or as an ordinary function.
+    Can either be used in a context, with the callback being unset on exit, or
+    as an ordinary function.
 
-    Parameters
-    ----------
-    signal:
-        A signal with a `MockSignalBackend` backend.
-    callback:
-        The callback to call when the backend is put to during the context.
+    :param signal: A signal with a `MockSignalBackend` backend.
+    :param callback: The callback to call when the backend is put to during the
+        context.
     """
     backend = _get_mock_signal_backend(signal)
     backend.put_mock.side_effect = callback
     return _unset_side_effect_cm(backend.put_mock)
+
+
+def set_mock_put_proceeds(signal: Signal, proceeds: bool):
+    """Allow or block a put with wait=True from proceeding."""
+    backend = _get_mock_signal_backend(signal)
+
+    if proceeds:
+        backend.put_proceeds.set()
+    else:
+        backend.put_proceeds.clear()
+
+
+@contextmanager
+def mock_puts_blocked(*signals: Signal):
+    """Context manager to block puts at the start and unblock at the end."""
+    for signal in signals:
+        set_mock_put_proceeds(signal, False)
+    yield
+    for signal in signals:
+        set_mock_put_proceeds(signal, True)
+
+
+def get_mock_put(signal: Signal) -> AsyncMock:
+    """Get the mock associated with the put call on the signal."""
+    return _get_mock_signal_backend(signal).put_mock

ophyd_async/testing/_one_of_everything.py

@@ -0,0 +1,146 @@
+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):
+    """Example of a strict Enum datatype."""
+
+    A = "Aaa"
+    B = "Bbb"
+    C = "Ccc"
+
+
+class ExampleTable(Table):
+    a_bool: Array1D[np.bool_]
+    a_int: Array1D[np.int32]
+    a_float: Array1D[np.float64]
+    a_str: Sequence[str]
+    a_enum: Sequence[ExampleEnum]
+
+
+def int_array_value(dtype: type[DTypeScalar_co]):
+    iinfo = np.iinfo(dtype)  # type: ignore
+    return np.array([iinfo.min, iinfo.max, 0, 1, 2, 3, 4], dtype=dtype)
+
+
+def int_array_signal(
+    dtype: type[DTypeScalar_co], name: str = ""
+) -> SignalRW[Array1D[DTypeScalar_co]]:
+    value = int_array_value(dtype)
+    return soft_signal_rw(Array1D[dtype], value, name)
+
+
+def float_array_value(dtype: type[DTypeScalar_co]):
+    finfo = np.finfo(dtype)  # type: ignore
+    return np.array(
+        [
+            finfo.min,
+            finfo.max,
+            finfo.smallest_normal,
+            finfo.smallest_subnormal,
+            0,
+            1.234,
+            2.34e5,
+            3.45e-6,
+        ],
+        dtype=dtype,
+    )
+
+
+def float_array_signal(
+    dtype: type[DTypeScalar_co], name: str = ""
+) -> SignalRW[Array1D[DTypeScalar_co]]:
+    value = float_array_value(dtype)
+    return soft_signal_rw(Array1D[dtype], value, name)
+
+
+class OneOfEverythingDevice(StandardReadable):
+    """A device with one of every datatype allowed on signals."""
+
+    # 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.a_int = soft_signal_rw(int, 1)
+            self.a_float = soft_signal_rw(float, 1.234)
+            self.a_str = soft_signal_rw(str, "test_string")
+            self.a_bool = soft_signal_rw(bool, True)
+            self.a_enum = soft_signal_rw(ExampleEnum, ExampleEnum.B)
+            self.boola = soft_signal_rw(
+                Array1D[np.bool_], np.array([False, False, True])
+            )
+            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(
+                    a_bool=np.array([False, False, True, True], np.bool_),
+                    a_int=np.array([1, 8, -9, 32], np.int32),
+                    a_float=np.array([1.8, 8.2, -6, 32.9887], np.float64),
+                    a_str=["Hello", "World", "Foo", "Bar"],
+                    a_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(self):
+        return await _get_signal_values(self)
+
+
+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):
+    """Device containing subdevices with one of every datatype allowed on signals."""
+
+    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/_single_derived.py

@@ -0,0 +1,87 @@
+import asyncio
+
+from ophyd_async.core import (
+    Device,
+    DeviceVector,
+    StandardReadable,
+    StrictEnum,
+    derived_signal_r,
+    derived_signal_rw,
+    derived_signal_w,
+    soft_signal_rw,
+)
+
+
+class BeamstopPosition(StrictEnum):
+    IN_POSITION = "In position"
+    OUT_OF_POSITION = "Out of position"
+
+
+class ReadOnlyBeamstop(Device):
+    """Reads from 2 motors to work out if the beamstop is in position.
+
+    E.g. bps.rd(beamstop.position)
+    """
+
+    def __init__(self, name=""):
+        # Raw signals
+        self.x = soft_signal_rw(float)
+        self.y = soft_signal_rw(float)
+        # Derived signals
+        self.position = derived_signal_r(self._get_position, x=self.x, y=self.y)
+        super().__init__(name=name)
+
+    def _get_position(self, x: float, y: float) -> BeamstopPosition:
+        if abs(x) < 1 and abs(y) < 2:
+            return BeamstopPosition.IN_POSITION
+        else:
+            return BeamstopPosition.OUT_OF_POSITION
+
+
+class MovableBeamstop(Device):
+    """As well as reads, this one allows you to move it.
+
+    E.g. bps.mv(beamstop.position, BeamstopPosition.IN_POSITION)
+    """
+
+    def __init__(self, name=""):
+        # Raw signals
+        self.x = soft_signal_rw(float)
+        self.y = soft_signal_rw(float)
+        # Derived signals
+        self.position = derived_signal_rw(
+            self._get_position, self._set_from_position, x=self.x, y=self.y
+        )
+        super().__init__(name=name)
+
+    def _get_position(self, x: float, y: float) -> BeamstopPosition:
+        if abs(x) < 1 and abs(y) < 2:
+            return BeamstopPosition.IN_POSITION
+        else:
+            return BeamstopPosition.OUT_OF_POSITION
+
+    async def _set_from_position(self, position: BeamstopPosition) -> None:
+        if position == BeamstopPosition.IN_POSITION:
+            await asyncio.gather(self.x.set(0), self.y.set(0))
+        else:
+            await asyncio.gather(self.x.set(3), self.y.set(5))
+
+
+class Exploder(StandardReadable):
+    """This one takes a value and sets all its signal to that value.
+
+    This allows convenience "set all" functions, while the individual
+    signals are still free to be set to different values.
+    """
+
+    def __init__(self, num_signals: int, name=""):
+        with self.add_children_as_readables():
+            self.signals = DeviceVector(
+                {i: soft_signal_rw(int, units="cts") for i in range(1, num_signals + 1)}
+            )
+        self.set_all = derived_signal_w(self._set_all, derived_units="cts")
+        super().__init__(name=name)
+
+    async def _set_all(self, value: int) -> None:
+        coros = [sig.set(value) for sig in self.signals.values()]
+        await asyncio.gather(*coros)

ophyd_async/testing/_utils.py

@@ -0,0 +1,3 @@
+from typing import TypeVar
+
+T = TypeVar("T")

{ophyd_async-0.9.0a1.dist-info → ophyd_async-0.10.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.9.0a1
+Version: 0.10.0a1
 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
@@ -41,35 +41,33 @@ 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: numpy
-Requires-Dist: packaging
-Requires-Dist: pint
-Requires-Dist: bluesky>=1.13
+Requires-Dist: bluesky>=1.13.1rc2
 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-numpy
+Provides-Extra: sim
+Requires-Dist: h5py; extra == "sim"
 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"
+Requires-Dist: p4p>=4.2.0; extra == "pva"
 Provides-Extra: tango
-Requires-Dist: pytango>=10.0.0; extra == "tango"
+Requires-Dist: pytango==10.0.0; extra == "tango"
+Provides-Extra: demo
+Requires-Dist: ipython; extra == "demo"
+Requires-Dist: matplotlib; extra == "demo"
+Requires-Dist: pyqt6; extra == "demo"
 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[pva]; extra == "dev"
 Requires-Dist: ophyd_async[tango]; extra == "dev"
+Requires-Dist: ophyd_async[demo]; 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"
@@ -79,7 +77,6 @@ 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"
@@ -88,16 +85,15 @@ 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: sphinx-autodoc2; 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"
+Dynamic: license-file
 
 [![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)
@@ -114,16 +110,19 @@ 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.
+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 sync and ophyd-async are typically used with the [Bluesky Run Engine][] for experiment orchestration and data acquisition.
+
+The main differences from ophyd sync are:
 
-Both ophyd and ophyd-async are typically used with the [Bluesky Run Engine][] for experiment orchestration and data acquisition.
+- Asynchronous Signal access, simplifying the parallel control of multiple Signals
+- Support for [EPICS][] PVA and [Tango][] as well as the traditional EPICS CA
+- Better library support for splitting the logic from the hardware interface to avoid complex class heirarchies
 
-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:
+It was written with the aim of implementing flyscanning in a generic and extensible way with highly customizable devices like PandABox and the Delta Tau PMAC products. Using async code makes it possible to do the "put 3 PVs in parallel, then get from another PV" logic that is common in flyscanning without the performance and complexity overhead of multiple threads.
 
-* 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
+Devices from both ophyd sync and ophyd-async can be used in the same RunEngine and even in the same scan. This allows a per-device migration where devices are reimplemented in ophyd-async one by one.
 
 [Bluesky Run Engine]: http://blueskyproject.io/bluesky
 [EPICS]: http://www.aps.anl.gov/epics/