ophyd-async 0.3a3__py3-none-any.whl → 0.3a4__py3-none-any.whl

ophyd_async/_version.py

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

ophyd_async/core/__init__.py

@@ -24,6 +24,18 @@ 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,
@@ -36,15 +48,12 @@ from .signal import (
     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 .soft_signal_backend import SoftSignalBackend
 from .standard_readable import ConfigSignal, HintedSignal, StandardReadable
 from .utils import (
     DEFAULT_TIMEOUT,
@@ -59,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",
@@ -73,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",

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
 

ophyd_async/core/device.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import sys
+from functools import cached_property
+from logging import LoggerAdapter, getLogger
 from typing import (
     Any,
     Coroutine,
@@ -39,6 +41,12 @@ class Device(HasName):
         """Return the name of the Device"""
         return self._name
 
+    @cached_property
+    def log(self):
+        return LoggerAdapter(
+            getLogger("ophyd_async.devices"), {"ophyd_async_device_name": self.name}
+        )
+
     def children(self) -> Iterator[Tuple[str, Device]]:
         for attr_name, attr in self.__dict__.items():
             if attr_name != "parent" and isinstance(attr, Device):
@@ -52,26 +60,31 @@ class Device(HasName):
         name:
             New name to set
         """
+
+        # Ensure self.log is recreated after a name change
+        if hasattr(self, "log"):
+            del self.log
+
         self._name = name
         for attr_name, child in self.children():
             child_name = f"{name}-{attr_name.rstrip('_')}" if name else ""
             child.set_name(child_name)
             child.parent = self
 
-    async def connect(self, sim: bool = False, timeout: float = DEFAULT_TIMEOUT):
+    async def connect(self, mock: bool = False, timeout: float = DEFAULT_TIMEOUT):
         """Connect self and all child Devices.
 
         Contains a timeout that gets propagated to child.connect methods.
 
         Parameters
         ----------
-        sim:
-            If True then connect in simulation mode.
+        mock:
+            If True then use ``MockSignalBackend`` for all Signals
         timeout:
             Time to wait before failing with a TimeoutError.
         """
         coros = {
-            name: child_device.connect(sim, timeout=timeout)
+            name: child_device.connect(mock=mock, timeout=timeout)
             for name, child_device in self.children()
         }
         if coros:
@@ -105,9 +118,9 @@ class DeviceCollector:
         If True, call ``device.set_name(variable_name)`` on all collected
         Devices
     connect:
-        If True, call ``device.connect(sim)`` in parallel on all
+        If True, call ``device.connect(mock)`` in parallel on all
         collected Devices
-    sim:
+    mock:
         If True, connect Signals in simulation mode
     timeout:
         How long to wait for connect before logging an exception
@@ -129,12 +142,12 @@ class DeviceCollector:
         self,
         set_name=True,
         connect=True,
-        sim=False,
+        mock=False,
         timeout: float = 10.0,
     ):
         self._set_name = set_name
         self._connect = connect
-        self._sim = sim
+        self._mock = mock
         self._timeout = timeout
         self._names_on_enter: Set[str] = set()
         self._objects_on_exit: Dict[str, Any] = {}
@@ -168,7 +181,7 @@ class DeviceCollector:
                     obj.set_name(name)
                 if self._connect:
                     connect_coroutines[name] = obj.connect(
-                        self._sim, timeout=self._timeout
+                        self._mock, timeout=self._timeout
                     )
 
         # Connect to all the devices

ophyd_async/core/mock_signal_backend.py

@@ -0,0 +1,86 @@
+import asyncio
+from typing import Optional, Type
+from unittest.mock import MagicMock
+
+from bluesky.protocols import Descriptor, Reading
+
+from ophyd_async.core.signal_backend import SignalBackend
+from ophyd_async.core.soft_signal_backend import SoftSignalBackend
+from ophyd_async.core.utils import DEFAULT_TIMEOUT, ReadingValueCallback, T
+
+
+class MockSignalBackend(SignalBackend):
+    def __init__(
+        self,
+        datatype: Optional[Type[T]] = None,
+        initial_backend: Optional[SignalBackend[T]] = None,
+    ) -> None:
+        if isinstance(initial_backend, MockSignalBackend):
+            raise ValueError("Cannot make a MockSignalBackend for a MockSignalBackends")
+
+        self.initial_backend = initial_backend
+
+        if datatype is None:
+            assert (
+                self.initial_backend
+            ), "Must supply either initial_backend or datatype"
+            datatype = self.initial_backend.datatype
+
+        self.datatype = datatype
+
+        if not isinstance(self.initial_backend, SoftSignalBackend):
+            # If the backend is a hard signal backend, or not provided,
+            # then we create a soft signal to mimick it
+
+            self.soft_backend = SoftSignalBackend(datatype=datatype)
+        else:
+            self.soft_backend = initial_backend
+
+        self.mock = MagicMock()
+
+        self.put_proceeds = asyncio.Event()
+        self.put_proceeds.set()
+
+    def source(self, name: str) -> str:
+        self.mock.source(name)
+        if self.initial_backend:
+            return f"mock+{self.initial_backend.source(name)}"
+        return f"mock+{name}"
+
+    async def connect(self, timeout: float = DEFAULT_TIMEOUT) -> None:
+        self.mock.connect(timeout=timeout)
+
+    async def put(self, value: Optional[T], wait=True, timeout=None):
+        self.mock.put(value, wait=wait, timeout=timeout)
+        await self.soft_backend.put(value, wait=wait, timeout=timeout)
+
+        if wait:
+            await asyncio.wait_for(self.put_proceeds.wait(), timeout=timeout)
+
+    def set_value(self, value: T):
+        self.mock.set_value(value)
+        self.soft_backend.set_value(value)
+
+    async def get_descriptor(self, source: str) -> Descriptor:
+        self.mock.get_descriptor(source)
+        return await self.soft_backend.get_descriptor(source)
+
+    async def get_reading(self) -> Reading:
+        self.mock.get_reading()
+        return await self.soft_backend.get_reading()
+
+    async def get_value(self) -> T:
+        self.mock.get_value()
+        return await self.soft_backend.get_value()
+
+    async def get_setpoint(self) -> T:
+        """For a soft signal, the setpoint and readback values are the same."""
+        self.mock.get_setpoint()
+        return await self.soft_backend.get_setpoint()
+
+    async def get_datakey(self, source: str) -> Descriptor:
+        return await self.soft_backend.get_datakey(source)
+
+    def set_callback(self, callback: Optional[ReadingValueCallback[T]]) -> None:
+        self.mock.set_callback(callback)
+        self.soft_backend.set_callback(callback)

ophyd_async/core/mock_signal_utils.py

@@ -0,0 +1,149 @@
+from contextlib import asynccontextmanager, contextmanager
+from typing import Any, Callable, Generator, Iterable, Iterator, List
+from unittest.mock import ANY
+
+from ophyd_async.core.signal import Signal
+from ophyd_async.core.utils import T
+
+from .mock_signal_backend import MockSignalBackend
+
+
+def _get_mock_signal_backend(signal: Signal) -> MockSignalBackend:
+    assert isinstance(signal._backend, MockSignalBackend), (
+        "Expected to receive a `MockSignalBackend`, instead "
+        f" received {type(signal._backend)}. "
+    )
+    return signal._backend
+
+
+def set_mock_value(signal: Signal[T], value: T):
+    """Set the value of a signal that is in mock mode."""
+    backend = _get_mock_signal_backend(signal)
+    backend.set_value(value)
+
+
+def set_mock_put_proceeds(signal: Signal[T], 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()
+
+
+@asynccontextmanager
+async def mock_puts_blocked(*signals: List[Signal]):
+    for signal in signals:
+        set_mock_put_proceeds(signal, False)
+    yield
+    for signal in signals:
+        set_mock_put_proceeds(signal, True)
+
+
+def assert_mock_put_called_with(signal: Signal, value: Any, wait=ANY, timeout=ANY):
+    backend = _get_mock_signal_backend(signal)
+    backend.mock.put.assert_called_with(value, wait=wait, timeout=timeout)
+
+
+def reset_mock_put_calls(signal: Signal):
+    backend = _get_mock_signal_backend(signal)
+    backend.mock.put.reset_mock()
+
+
+class _SetValuesIterator:
+    # Garbage collected by the time __del__ is called unless we put it as a
+    # global attrbute here.
+    require_all_consumed: bool = False
+
+    def __init__(
+        self,
+        signal: Signal,
+        values: Iterable[Any],
+        require_all_consumed: bool = False,
+    ):
+        self.signal = signal
+        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):
+        # Will propogate StopIteration
+        self.index, next_value = next(self.iterator)
+        set_mock_value(self.signal, next_value)
+        return next_value
+
+    def __del__(self):
+        if self.require_all_consumed and self.index != len(self.values):
+            raise AssertionError("Not all values have been consumed.")
+
+
+def set_mock_values(
+    signal: Signal,
+    values: Iterable[Any],
+    require_all_consumed: bool = False,
+) -> Iterator[Any]:
+    """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
+    """
+
+    return _SetValuesIterator(
+        signal,
+        values,
+        require_all_consumed=require_all_consumed,
+    )
+
+
+@contextmanager
+def _unset_side_effect_cm(mock):
+    yield
+    mock.put.side_effect = None
+
+
+# linting isn't smart enought to realize @contextmanager will give use a
+# ContextManager[None]
+def callback_on_mock_put(
+    signal: Signal, callback: Callable[[T], None]
+) -> Generator[None, None, None]:
+    """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.
+
+    Parameters
+    ----------
+    signal:
+        A signal with a `MockSignalBackend` backend.
+    callback:
+        The callback to call when the backend is put to during the context.
+    """
+    backend = _get_mock_signal_backend(signal)
+    backend.mock.put.side_effect = callback
+    return _unset_side_effect_cm(backend.mock)

ophyd_async/core/signal.py

@@ -24,15 +24,14 @@ from bluesky.protocols import (
     Subscribable,
 )
 
+from ophyd_async.core.mock_signal_backend import MockSignalBackend
 from ophyd_async.protocols import AsyncConfigurable, AsyncReadable, AsyncStageable
 
 from .async_status import AsyncStatus
 from .device import Device
 from .signal_backend import SignalBackend
-from .sim_signal_backend import SimSignalBackend
-from .utils import DEFAULT_TIMEOUT, Callback, ReadingValueCallback, T
-
-_sim_backends: Dict[Signal, SimSignalBackend] = {}
+from .soft_signal_backend import SoftSignalBackend
+from .utils import DEFAULT_TIMEOUT, Callback, T
 
 
 def _add_timeout(func):
@@ -61,17 +60,17 @@ class Signal(Device, Generic[T]):
         timeout: Optional[float] = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
-        super().__init__(name)
         self._timeout = timeout
-        self._init_backend = self._backend = backend
+        self._initial_backend = self._backend = backend
+        super().__init__(name)
 
-    async def connect(self, sim=False, timeout=DEFAULT_TIMEOUT):
-        if sim:
-            self._backend = SimSignalBackend(datatype=self._init_backend.datatype)
-            _sim_backends[self] = self._backend
-        else:
-            self._backend = self._init_backend
-            _sim_backends.pop(self, None)
+    async def connect(self, mock=False, timeout=DEFAULT_TIMEOUT):
+        if mock and not isinstance(self._backend, MockSignalBackend):
+            # Using a soft backend, look to the initial value
+            self._backend = MockSignalBackend(
+                initial_backend=self._initial_backend,
+            )
+        self.log.debug(f"Connecting to {self.source}")
         await self._backend.connect(timeout=timeout)
 
     @property
@@ -96,10 +95,12 @@ class _SignalCache(Generic[T]):
         self._value: Optional[T] = None
 
         self.backend = backend
+        signal.log.debug(f"Making subscription on source {signal.source}")
         backend.set_callback(self._callback)
 
     def close(self):
         self.backend.set_callback(None)
+        self._signal.log.debug(f"Closing subscription on source {self._signal.source}")
 
     async def get_reading(self) -> Reading:
         await self._valid.wait()
@@ -112,6 +113,10 @@ class _SignalCache(Generic[T]):
         return self._value
 
     def _callback(self, reading: Reading, value: T):
+        self._signal.log.debug(
+            f"Updated subscription: reading of source {self._signal.source} changed"
+            f"from {self._reading} to {reading}"
+        )
         self._reading = reading
         self._value = value
         self._valid.set()
@@ -178,7 +183,9 @@ class SignalR(Signal[T], AsyncReadable, AsyncStageable, Subscribable):
     @_add_timeout
     async def get_value(self, cached: Optional[bool] = None) -> T:
         """The current value"""
-        return await self._backend_or_cache(cached).get_value()
+        value = await self._backend_or_cache(cached).get_value()
+        self.log.debug(f"get_value() on source {self.source} returned {value}")
+        return value
 
     def subscribe_value(self, function: Callback[T]):
         """Subscribe to updates in value of a device"""
@@ -213,8 +220,15 @@ class SignalW(Signal[T], Movable):
         """Set the value and return a status saying when it's done"""
         if timeout is USE_DEFAULT_TIMEOUT:
             timeout = self._timeout
-        coro = self._backend.put(value, wait=wait, timeout=timeout)
-        return AsyncStatus(coro)
+
+        async def do_set():
+            self.log.debug(f"Putting value {value} to backend at source {self.source}")
+            await self._backend.put(value, wait=wait, timeout=timeout)
+            self.log.debug(
+                f"Successfully put value {value} to backend at source {self.source}"
+            )
+
+        return AsyncStatus(do_set())
 
 
 class SignalRW(SignalR[T], SignalW[T], Locatable):
@@ -239,47 +253,29 @@ class SignalX(Signal):
         return AsyncStatus(coro)
 
 
-def set_sim_value(signal: Signal[T], value: T):
-    """Set the value of a signal that is in sim mode."""
-    _sim_backends[signal]._set_value(value)
-
-
-def set_sim_put_proceeds(signal: Signal[T], proceeds: bool):
-    """Allow or block a put with wait=True from proceeding"""
-    event = _sim_backends[signal].put_proceeds
-    if proceeds:
-        event.set()
-    else:
-        event.clear()
-
-
-def set_sim_callback(signal: Signal[T], callback: ReadingValueCallback[T]) -> None:
-    """Monitor the value of a signal that is in sim mode"""
-    return _sim_backends[signal].set_callback(callback)
-
-
 def soft_signal_rw(
     datatype: Optional[Type[T]] = None,
     initial_value: Optional[T] = None,
     name: str = "",
 ) -> SignalRW[T]:
-    """Creates a read-writable Signal with a SimSignalBackend"""
-    signal = SignalRW(SimSignalBackend(datatype, initial_value), name=name)
+    """Creates a read-writable Signal with a SoftSignalBackend"""
+    signal = SignalRW(SoftSignalBackend(datatype, initial_value), name=name)
     return signal
 
 
-def soft_signal_r_and_backend(
+def soft_signal_r_and_setter(
     datatype: Optional[Type[T]] = None,
     initial_value: Optional[T] = None,
     name: str = "",
-) -> Tuple[SignalR[T], SimSignalBackend]:
-    """Returns a tuple of a read-only Signal and its SimSignalBackend through
+) -> Tuple[SignalR[T], Callable[[T]]]:
+    """Returns a tuple of a read-only Signal and a callable through
     which the signal can be internally modified within the device. Use
     soft_signal_rw if you want a device that is externally modifiable
     """
-    backend = SimSignalBackend(datatype, initial_value)
+    backend = SoftSignalBackend(datatype, initial_value)
     signal = SignalR(backend, name=name)
-    return (signal, backend)
+
+    return (signal, backend.set_value)
 
 
 async def assert_value(signal: SignalR[T], value: Any) -> None: