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

ophyd_async/plan_stubs/_settings.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable, Mapping
+from typing import Any
+
+import bluesky.plan_stubs as bps
+import numpy as np
+from bluesky.utils import MsgGenerator, plan
+
+from ophyd_async.core import (
+    Device,
+    Settings,
+    SettingsProvider,
+    SignalRW,
+    T,
+    walk_rw_signals,
+)
+from ophyd_async.core._table import Table
+
+from ._wait_for_awaitable import wait_for_awaitable
+
+
+@plan
+def _get_values_of_signals(
+    signals: Mapping[T, SignalRW],
+) -> MsgGenerator[dict[T, Any]]:
+    coros = [sig.get_value() for sig in signals.values()]
+    values = yield from wait_for_awaitable(asyncio.gather(*coros))
+    named_values = dict(zip(signals, values, strict=True))
+    return named_values
+
+
+@plan
+def get_current_settings(device: Device) -> MsgGenerator[Settings]:
+    signals = walk_rw_signals(device)
+    named_values = yield from _get_values_of_signals(signals)
+    signal_values = {signals[name]: value for name, value in named_values.items()}
+    return Settings(device, signal_values)
+
+
+@plan
+def store_settings(
+    provider: SettingsProvider, name: str, device: Device
+) -> MsgGenerator[None]:
+    """Walk a Device for SignalRWs and store their values with a provider associated
+    with the given name.
+    """
+    signals = walk_rw_signals(device)
+    named_values = yield from _get_values_of_signals(signals)
+    yield from wait_for_awaitable(provider.store(name, named_values))
+
+
+@plan
+def retrieve_settings(
+    provider: SettingsProvider, name: str, device: Device
+) -> MsgGenerator[Settings]:
+    """Retrieve named Settings for a Device from a provider."""
+    named_values = yield from wait_for_awaitable(provider.retrieve(name))
+    signals = walk_rw_signals(device)
+    unknown_names = set(named_values) - set(signals)
+    if unknown_names:
+        raise NameError(f"Unknown signal names {sorted(unknown_names)}")
+    signal_values = {signals[name]: value for name, value in named_values.items()}
+    return Settings(device, signal_values)
+
+
+@plan
+def apply_settings(settings: Settings) -> MsgGenerator[None]:
+    """Set every SignalRW to the given value in Settings. If value is None ignore it."""
+    signal_values = {
+        signal: value for signal, value in settings.items() if value is not None
+    }
+    if signal_values:
+        for signal, value in signal_values.items():
+            yield from bps.abs_set(signal, value, group="apply_settings")
+        yield from bps.wait("apply_settings")
+
+
+@plan
+def apply_settings_if_different(
+    settings: Settings,
+    apply_plan: Callable[[Settings], MsgGenerator[None]],
+    current_settings: Settings | None = None,
+) -> MsgGenerator[None]:
+    """Set every SignalRW in settings to its given value if it is different to the
+    current value.
+
+    Parameters
+    ----------
+    apply_plan:
+        A device specific plan which takes the Settings to apply and applies them to
+        the Device. Used to add device specific ordering to setting the signals.
+    current_settings:
+        If given, should be a superset of settings containing the current value of
+        the Settings in the Device. If not given it will be created by reading just
+        the signals given in settings.
+    """
+    if current_settings is None:
+        # If we aren't give the current settings, then get the
+        # values of just the signals we were asked to change.
+        # This allows us to use this plan with Settings for a subset
+        # of signals in the Device without retrieving them all
+        signal_values = yield from _get_values_of_signals(
+            {sig: sig for sig in settings}
+        )
+        current_settings = Settings(settings.device, signal_values)
+
+    def _is_different(current, required) -> bool:
+        if isinstance(current, Table):
+            current = current.model_dump()
+            if isinstance(required, Table):
+                required = required.model_dump()
+            return current.keys() != required.keys() or any(
+                _is_different(current[k], required[k]) for k in current
+            )
+        elif isinstance(current, np.ndarray):
+            return not np.array_equal(current, required)
+        else:
+            return current != required
+
+    settings_to_change, _ = settings.partition(
+        lambda sig: _is_different(current_settings[sig], settings[sig])
+    )
+    yield from apply_plan(settings_to_change)

ophyd_async/plan_stubs/_wait_for_awaitable.py

@@ -0,0 +1,13 @@
+from collections.abc import Awaitable
+
+import bluesky.plan_stubs as bps
+from bluesky.utils import MsgGenerator, plan
+
+from ophyd_async.core import T
+
+
+@plan
+def wait_for_awaitable(coro: Awaitable[T]) -> MsgGenerator[T]:
+    """Wait for a single awaitable to complete, and return the result."""
+    (task,) = yield from bps.wait_for([lambda: coro])
+    return task.result()

ophyd_async/sim/__init__.py

@@ -0,0 +1,19 @@
+from ._pattern_detector import (
+    DATA_PATH,
+    SUM_PATH,
+    PatternDetector,
+    PatternDetectorController,
+    PatternDetectorWriter,
+    PatternGenerator,
+)
+from ._sim_motor import SimMotor
+
+__all__ = [
+    "DATA_PATH",
+    "SUM_PATH",
+    "PatternGenerator",
+    "PatternDetector",
+    "PatternDetectorController",
+    "PatternDetectorWriter",
+    "SimMotor",
+]

ophyd_async/sim/{demo/_pattern_detector → _pattern_detector}/_pattern_detector_controller.py

@@ -27,8 +27,15 @@ class PatternDetectorController(DetectorController):
         )
 
     async def arm(self):
-        assert self._trigger_info.livetime
-        assert self.period
+        if not hasattr(self, "_trigger_info"):
+            msg = "TriggerInfo information is missing, has 'prepare' been called?"
+            raise RuntimeError(msg)
+        if not self._trigger_info.livetime:
+            msg = "Livetime information is missing in trigger info"
+            raise ValueError(msg)
+        if not self.period:
+            msg = "Period is not set"
+            raise ValueError(msg)
         self.task = asyncio.create_task(
             self._coroutine_for_image_writing(
                 self._trigger_info.livetime,

ophyd_async/sim/{demo/_pattern_detector → _pattern_detector}/_pattern_generator.py

@@ -67,11 +67,14 @@ class PatternGenerator:
 
     def write_data_to_dataset(self, path: str, data_shape: tuple[int, ...], data):
         """Write data to named dataset, resizing to fit and flushing after."""
-        assert self._handle_for_h5_file, "no file has been opened!"
+        if not self._handle_for_h5_file:
+            msg = "No file has been opened!"
+            raise OSError(msg)
+
         dset = self._handle_for_h5_file[path]
-        assert isinstance(
-            dset, h5py.Dataset
-        ), f"Expected {path} to be dataset, got {dset}"
+        if not isinstance(dset, h5py.Dataset):
+            msg = f"Expected {path} to be a dataset, got {type(dset).__name__}"
+            raise TypeError(msg)
         dset.resize((self.image_counter + 1,) + data_shape)
         dset[self.image_counter] = data
         dset.flush()
@@ -114,7 +117,9 @@ class PatternGenerator:
 
         self._handle_for_h5_file = h5py.File(self.target_path, "w", libver="latest")
 
-        assert self._handle_for_h5_file, "not loaded the file right"
+        if not self._handle_for_h5_file:
+            msg = f"Problem opening file {self.target_path}"
+            raise OSError(msg)
 
         self._handle_for_h5_file.create_dataset(
             name=DATA_PATH,
@@ -184,7 +189,9 @@ class PatternGenerator:
             # cannot get the full filename the HDF writer will write
             # until the first frame comes in
             if not self._hdf_stream_provider:
-                assert self.target_path, "open file has not been called"
+                if self.target_path is None:
+                    msg = "open file has not been called"
+                    raise RuntimeError(msg)
                 self._hdf_stream_provider = HDFFile(
                     self.target_path,
                     self._datasets,

ophyd_async/tango/core/_signal.py

@@ -28,6 +28,8 @@ from tango.asyncio import DeviceProxy as AsyncDeviceProxy
 
 from ._tango_transport import TangoSignalBackend, get_python_type
 
+logger = logging.getLogger("ophyd_async")
+
 
 def make_backend(
     datatype: type[SignalDatatypeT] | None,
@@ -205,7 +207,7 @@ async def infer_signal_type(
         if config.in_type == CmdArgType.DevVoid:
             return SignalX
         elif config.in_type != config.out_type:
-            logging.debug("Commands with different in and out dtypes are not supported")
+            logger.debug("Commands with different in and out dtypes are not supported")
             return None
         else:
             return SignalRW

ophyd_async/tango/core/_tango_transport.py

@@ -210,11 +210,11 @@ class AttributeProxy(TangoProxy):
                             await asyncio.sleep(A_BIT)
                             if to and (time.time() - start_time > to):
                                 raise TimeoutError(
-                                    f"{self._name} attr put failed:" f" Timeout"
+                                    f"{self._name} attr put failed: Timeout"
                                 ) from exc
                         else:
                             raise RuntimeError(
-                                f"{self._name} device failure:" f" {exc.args[0].desc}"
+                                f"{self._name} device failure: {exc.args[0].desc}"
                             ) from exc
 
             return AsyncStatus(wait_for_reply(rid, timeout))
@@ -422,7 +422,7 @@ class CommandProxy(TangoProxy):
                 raise TimeoutError(f"{self._name} command failed: Timeout") from te
             except DevFailed as de:
                 raise RuntimeError(
-                    f"{self._name} device" f" failure: {de.args[0].desc}"
+                    f"{self._name} device failure: {de.args[0].desc}"
                 ) from de
 
         else:
@@ -446,8 +446,7 @@ class CommandProxy(TangoProxy):
                                 ) from de_exc
                         else:
                             raise RuntimeError(
-                                f"{self._name} device failure:"
-                                f" {de_exc.args[0].desc}"
+                                f"{self._name} device failure: {de_exc.args[0].desc}"
                             ) from de_exc
 
             return AsyncStatus(wait_for_reply(rid, timeout))
@@ -733,22 +732,21 @@ class TangoSignalBackend(SignalBackend[SignalDatatypeT]):
                 " for which polling is disabled."
             )
 
+        if callback and self.proxies[self.read_trl].has_subscription():  # type: ignore
+            msg = "Cannot set a callback when one is already set"
+            raise RuntimeError(msg)
+
+        if self.proxies[self.read_trl].has_subscription():  # type: ignore
+            self.proxies[self.read_trl].unsubscribe_callback()  # type: ignore
+
         if callback:
             try:
-                assert not self.proxies[self.read_trl].has_subscription()  # type: ignore
                 self.proxies[self.read_trl].subscribe_callback(callback)  # type: ignore
-            except AssertionError as ae:
-                raise RuntimeError(
-                    "Cannot set a callback when one" " is already set"
-                ) from ae
             except RuntimeError as exc:
                 raise RuntimeError(
-                    f"Cannot set callback" f" for {self.read_trl}. {exc}"
+                    f"Cannot set callback for {self.read_trl}. {exc}"
                 ) from exc
 
-        else:
-            self.proxies[self.read_trl].unsubscribe_callback()  # type: ignore
-
     def set_polling(
         self,
         allow_polling: bool = True,

ophyd_async/tango/{demo → sim}/_mover.py

@@ -43,8 +43,11 @@ class TangoMover(TangoReadable, Movable, Stoppable):
         (old_position, velocity) = await asyncio.gather(
             self.position.get_value(), self.velocity.get_value()
         )
-        if timeout is CALCULATE_TIMEOUT:
-            assert velocity > 0, "Motor has zero velocity"
+        # TODO: check whether Tango does work with negative velocity
+        if timeout is CALCULATE_TIMEOUT and velocity == 0:
+            msg = "Motor has zero velocity"
+            raise ValueError(msg)
+        else:
             timeout = abs(value - old_position) / velocity + DEFAULT_TIMEOUT
 
         if not (isinstance(timeout, float) or timeout is None):

ophyd_async/testing/__init__.py

@@ -1,5 +1,10 @@
+from . import __pytest_assert_rewrite  # noqa: F401
 from ._assert import (
+    ApproxTable,
+    MonitorQueue,
+    approx_value,
     assert_configuration,
+    assert_describe_signal,
     assert_emitted,
     assert_reading,
     assert_value,
@@ -14,10 +19,18 @@ from ._mock_signal_utils import (
     set_mock_value,
     set_mock_values,
 )
+from ._one_of_everything import (
+    ExampleEnum,
+    ExampleTable,
+    OneOfEverythingDevice,
+    ParentOfEverythingDevice,
+)
 from ._wait_for_pending import wait_for_pending_wakeups
 
 __all__ = [
+    "approx_value",
     "assert_configuration",
+    "assert_describe_signal",
     "assert_emitted",
     "assert_reading",
     "assert_value",
@@ -30,4 +43,10 @@ __all__ = [
     "set_mock_value",
     "set_mock_values",
     "wait_for_pending_wakeups",
+    "ExampleEnum",
+    "ExampleTable",
+    "OneOfEverythingDevice",
+    "ParentOfEverythingDevice",
+    "MonitorQueue",
+    "ApproxTable",
 ]

ophyd_async/testing/__pytest_assert_rewrite.py

@@ -0,0 +1,4 @@
+import pytest
+
+# So that bare asserts give a nice pytest traceback
+pytest.register_assert_rewrite("ophyd_async.testing._assert")

ophyd_async/testing/_assert.py

@@ -1,20 +1,23 @@
-from collections.abc import Mapping
+import asyncio
+import time
+from contextlib import AbstractContextManager
 from typing import Any
 
+import pytest
 from bluesky.protocols import Reading
+from event_model import DataKey
 
-from ophyd_async.core import AsyncConfigurable, AsyncReadable, SignalDatatypeT, SignalR
+from ophyd_async.core import (
+    AsyncConfigurable,
+    AsyncReadable,
+    SignalDatatypeT,
+    SignalR,
+    Table,
+)
 
 
-def _generate_assert_error_msg(name: str, expected_result, actual_result) -> str:
-    WARNING = "\033[93m"
-    FAIL = "\033[91m"
-    ENDC = "\033[0m"
-    return (
-        f"Expected {WARNING}{name}{ENDC} to produce"
-        + f"\n{FAIL}{expected_result}{ENDC}"
-        + f"\nbut actually got \n{FAIL}{actual_result}{ENDC}"
-    )
+def approx_value(value: Any):
+    return ApproxTable(value) if isinstance(value, Table) else pytest.approx(value)
 
 
 async def assert_value(signal: SignalR[SignalDatatypeT], value: Any) -> None:
@@ -34,15 +37,11 @@ async def assert_value(signal: SignalR[SignalDatatypeT], value: Any) -> None:
 
     """
     actual_value = await signal.get_value()
-    assert actual_value == value, _generate_assert_error_msg(
-        name=signal.name,
-        expected_result=value,
-        actual_result=actual_value,
-    )
+    assert approx_value(value) == actual_value
 
 
 async def assert_reading(
-    readable: AsyncReadable, expected_reading: Mapping[str, Reading]
+    readable: AsyncReadable, expected_reading: dict[str, Reading]
 ) -> None:
     """Assert readings from readable.
 
@@ -61,16 +60,16 @@ async def assert_reading(
 
     """
     actual_reading = await readable.read()
-    assert expected_reading == actual_reading, _generate_assert_error_msg(
-        name=readable.name,
-        expected_result=expected_reading,
-        actual_result=actual_reading,
-    )
+    approx_expected_reading = {
+        k: dict(v, value=approx_value(expected_reading[k]["value"]))
+        for k, v in expected_reading.items()
+    }
+    assert actual_reading == approx_expected_reading
 
 
 async def assert_configuration(
     configurable: AsyncConfigurable,
-    configuration: Mapping[str, Reading],
+    configuration: dict[str, Reading],
 ) -> None:
     """Assert readings from Configurable.
 
@@ -88,15 +87,23 @@ async def assert_configuration(
         await assert_configuration(configurable configuration)
 
     """
-    actual_configurable = await configurable.read_configuration()
-    assert configuration == actual_configurable, _generate_assert_error_msg(
-        name=configurable.name,
-        expected_result=configuration,
-        actual_result=actual_configurable,
-    )
+    actual_configuration = await configurable.read_configuration()
+    approx_expected_configuration = {
+        k: dict(v, value=approx_value(configuration[k]["value"]))
+        for k, v in configuration.items()
+    }
+    assert actual_configuration == approx_expected_configuration
 
 
-def assert_emitted(docs: Mapping[str, list[dict]], **numbers: int):
+async def assert_describe_signal(signal: SignalR, /, **metadata):
+    actual_describe = await signal.describe()
+    assert list(actual_describe) == [signal.name]
+    (actual_datakey,) = actual_describe.values()
+    expected_datakey = DataKey(source=signal.source, **metadata)
+    assert actual_datakey == expected_datakey
+
+
+def assert_emitted(docs: dict[str, list[dict]], **numbers: int):
     """Assert emitted document generated by running a Bluesky plan
 
     Parameters
@@ -115,14 +122,55 @@ def assert_emitted(docs: Mapping[str, list[dict]], **numbers: int):
         RE(my_plan())
         assert_emitted(docs, start=1, descriptor=1, event=1, stop=1)
     """
-    assert list(docs) == list(numbers), _generate_assert_error_msg(
-        name="documents",
-        expected_result=list(numbers),
-        actual_result=list(docs),
-    )
+    assert list(docs) == list(numbers)
     actual_numbers = {name: len(d) for name, d in docs.items()}
-    assert actual_numbers == numbers, _generate_assert_error_msg(
-        name="emitted",
-        expected_result=numbers,
-        actual_result=actual_numbers,
-    )
+    assert actual_numbers == numbers
+
+
+class ApproxTable:
+    def __init__(self, expected: Table, rel=None, abs=None, nan_ok: bool = False):
+        self.expected = expected
+        self.rel = rel
+        self.abs = abs
+        self.nan_ok = nan_ok
+
+    def __eq__(self, value):
+        approx_fields = {
+            k: pytest.approx(v, self.rel, self.abs, self.nan_ok)
+            for k, v in self.expected
+        }
+        expected = type(self.expected).model_construct(**approx_fields)  # type: ignore
+        return expected == value
+
+
+class MonitorQueue(AbstractContextManager):
+    def __init__(self, signal: SignalR):
+        self.signal = signal
+        self.updates: asyncio.Queue[dict[str, Reading]] = asyncio.Queue()
+        self.signal.subscribe(self.updates.put_nowait)
+
+    async def assert_updates(self, expected_value):
+        # Get an update, value and reading
+        expected_type = type(expected_value)
+        expected_value = approx_value(expected_value)
+        update = await self.updates.get()
+        value = await self.signal.get_value()
+        reading = await self.signal.read()
+        # Check they match what we expected
+        assert value == expected_value
+        assert type(value) is expected_type
+        expected_reading = {
+            self.signal.name: {
+                "value": expected_value,
+                "timestamp": pytest.approx(time.time(), rel=0.1),
+                "alarm_severity": 0,
+            }
+        }
+        assert reading == update == expected_reading
+
+    def __enter__(self):
+        self.signal.subscribe(self.updates.put_nowait)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.signal.clear_sub(self.updates.put_nowait)

ophyd_async/testing/_mock_signal_utils.py

@@ -22,9 +22,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
 
 

ophyd_async/testing/_one_of_everything.py

@@ -0,0 +1,126 @@
+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):
+    A = "Aaa"
+    B = "Bbb"
+    C = "Ccc"
+
+
+class ExampleTable(Table):
+    bool: Array1D[np.bool_]
+    int: Array1D[np.int32]
+    float: Array1D[np.float64]
+    str: Sequence[str]
+    enum: Sequence[ExampleEnum]
+
+
+def int_array_signal(
+    dtype: type[DTypeScalar_co], name: str = ""
+) -> SignalRW[Array1D[DTypeScalar_co]]:
+    iinfo = np.iinfo(dtype)  # type: ignore
+    value = np.array([iinfo.min, iinfo.max, 0, 1, 2, 3, 4], dtype=dtype)
+    return soft_signal_rw(Array1D[dtype], value, name)
+
+
+def float_array_signal(
+    dtype: type[DTypeScalar_co], name: str = ""
+) -> SignalRW[Array1D[DTypeScalar_co]]:
+    finfo = np.finfo(dtype)  # type: ignore
+    value = np.array(
+        [
+            finfo.min,
+            finfo.max,
+            finfo.smallest_normal,
+            finfo.smallest_subnormal,
+            0,
+            1.234,
+            2.34e5,
+            3.45e-6,
+        ],
+        dtype=dtype,
+    )
+    return soft_signal_rw(Array1D[dtype], value, name)
+
+
+class OneOfEverythingDevice(StandardReadable):
+    # 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.int = soft_signal_rw(int, 1)
+            self.float = soft_signal_rw(float, 1.234)
+            self.str = soft_signal_rw(str, "test_string")
+            self.bool = soft_signal_rw(bool, True)
+            self.enum = soft_signal_rw(ExampleEnum, ExampleEnum.B)
+            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(
+                    bool=np.array([False, False, True, True], np.bool_),
+                    int=np.array([1, 8, -9, 32], np.int32),
+                    float=np.array([1.8, 8.2, -6, 32.9887], np.float64),
+                    str=["Hello", "World", "Foo", "Bar"],
+                    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(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):
+    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)