ophyd-async 0.7.0__py3-none-any.whl → 0.8.0a2__py3-none-any.whl

ophyd_async/core/_mock_signal_backend.py

@@ -1,84 +1,76 @@
 import asyncio
 from collections.abc import Callable
 from functools import cached_property
-from unittest.mock import AsyncMock
+from unittest.mock import AsyncMock, Mock
 
 from bluesky.protocols import Descriptor, Reading
 
-from ._signal_backend import SignalBackend
+from ._signal_backend import SignalBackend, SignalDatatypeT
 from ._soft_signal_backend import SoftSignalBackend
-from ._utils import DEFAULT_TIMEOUT, ReadingValueCallback, T
+from ._utils import Callback
 
 
-class MockSignalBackend(SignalBackend[T]):
+class MockSignalBackend(SignalBackend[SignalDatatypeT]):
     """Signal backend for testing, created by ``Device.connect(mock=True)``."""
 
     def __init__(
         self,
-        datatype: type[T] | None = None,
-        initial_backend: SignalBackend[T] | None = None,
+        initial_backend: SignalBackend[SignalDatatypeT],
+        mock: Mock,
     ) -> None:
         if isinstance(initial_backend, MockSignalBackend):
-            raise ValueError("Cannot make a MockSignalBackend for a MockSignalBackends")
+            raise ValueError("Cannot make a MockSignalBackend for a MockSignalBackend")
 
         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
+        if isinstance(self.initial_backend, SoftSignalBackend):
+            # Backend is already a SoftSignalBackend, so use it
+            self.soft_backend = self.initial_backend
+        else:
+            # Backend is not a SoftSignalBackend, so create one to mimic it
+            self.soft_backend = SoftSignalBackend(
+                datatype=self.initial_backend.datatype
+            )
 
-        self.datatype = datatype
+        # use existing Mock if provided
+        self.mock = mock
+        self.put_mock = AsyncMock(name="put", spec=Callable)
+        self.mock.attach_mock(self.put_mock, "put")
 
-        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 mimic it
+        super().__init__(datatype=self.initial_backend.datatype)
 
-            self.soft_backend = SoftSignalBackend(datatype=datatype)
-        else:
-            self.soft_backend = self.initial_backend
+    def set_value(self, value: SignalDatatypeT):
+        self.soft_backend.set_value(value)
 
-    def source(self, name: str) -> str:
-        if self.initial_backend:
-            return f"mock+{self.initial_backend.source(name)}"
-        return f"mock+{name}"
+    def source(self, name: str, read: bool) -> str:
+        return f"mock+{self.initial_backend.source(name, read)}"
 
-    async def connect(self, timeout: float = DEFAULT_TIMEOUT) -> None:
+    async def connect(self, timeout: float) -> None:
         pass
 
-    @cached_property
-    def put_mock(self) -> AsyncMock:
-        return AsyncMock(name="put", spec=Callable)
-
     @cached_property
     def put_proceeds(self) -> asyncio.Event:
         put_proceeds = asyncio.Event()
         put_proceeds.set()
         return put_proceeds
 
-    async def put(self, value: T | None, wait=True, timeout=None):
-        await self.put_mock(value, wait=wait, timeout=timeout)
-        await self.soft_backend.put(value, wait=wait, timeout=timeout)
-
+    async def put(self, value: SignalDatatypeT | None, wait: bool):
+        await self.put_mock(value, wait=wait)
+        await self.soft_backend.put(value, wait=wait)
         if wait:
-            await asyncio.wait_for(self.put_proceeds.wait(), timeout=timeout)
-
-    def set_value(self, value: T):
-        self.soft_backend.set_value(value)
+            await self.put_proceeds.wait()
 
     async def get_reading(self) -> Reading:
         return await self.soft_backend.get_reading()
 
-    async def get_value(self) -> T:
+    async def get_value(self) -> SignalDatatypeT:
         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."""
+    async def get_setpoint(self) -> SignalDatatypeT:
         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: ReadingValueCallback[T] | None) -> None:
+    def set_callback(self, callback: Callback[Reading[SignalDatatypeT]] | None) -> None:
         self.soft_backend.set_callback(callback)

ophyd_async/core/_mock_signal_utils.py

@@ -1,23 +1,21 @@
 from collections.abc import Awaitable, Callable, Iterable
 from contextlib import asynccontextmanager, contextmanager
-from typing import Any
-from unittest.mock import AsyncMock
+from unittest.mock import AsyncMock, Mock
 
+from ._device import Device, _device_mocks
 from ._mock_signal_backend import MockSignalBackend
-from ._signal import Signal
-from ._utils import T
+from ._signal import Signal, SignalR, _mock_signal_backends
+from ._soft_signal_backend import SignalDatatypeT
 
 
 def _get_mock_signal_backend(signal: Signal) -> MockSignalBackend:
-    backend = signal._backend  # noqa:SLF001
-    assert isinstance(backend, MockSignalBackend), (
-        "Expected to receive a `MockSignalBackend`, instead "
-        f" received {type(backend)}. "
-    )
-    return backend
+    assert (
+        signal in _mock_signal_backends
+    ), f"Signal {signal} not connected in mock mode"
+    return _mock_signal_backends[signal]
 
 
-def set_mock_value(signal: Signal[T], value: T):
+def set_mock_value(signal: Signal[SignalDatatypeT], value: SignalDatatypeT):
     """Set the value of a signal that is in mock mode."""
     backend = _get_mock_signal_backend(signal)
     backend.set_value(value)
@@ -47,6 +45,12 @@ def get_mock_put(signal: Signal) -> AsyncMock:
     return _get_mock_signal_backend(signal).put_mock
 
 
+def get_mock(device: Device | Signal) -> Mock:
+    if isinstance(device, Signal):
+        return _get_mock_signal_backend(device).mock
+    return _device_mocks[device]
+
+
 def reset_mock_put_calls(signal: Signal):
     backend = _get_mock_signal_backend(signal)
     backend.put_mock.reset_mock()
@@ -59,8 +63,8 @@ class _SetValuesIterator:
 
     def __init__(
         self,
-        signal: Signal,
-        values: Iterable[Any],
+        signal: SignalR[SignalDatatypeT],
+        values: Iterable[SignalDatatypeT],
         require_all_consumed: bool = False,
     ):
         self.signal = signal
@@ -99,8 +103,8 @@ class _SetValuesIterator:
 
 
 def set_mock_values(
-    signal: Signal,
-    values: Iterable[Any],
+    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
@@ -143,7 +147,9 @@ def _unset_side_effect_cm(put_mock: AsyncMock):
 
 
 def callback_on_mock_put(
-    signal: Signal[T], callback: Callable[[T], None] | Callable[[T], Awaitable[None]]
+    signal: Signal[SignalDatatypeT],
+    callback: Callable[[SignalDatatypeT, bool], None]
+    | Callable[[SignalDatatypeT, bool], Awaitable[None]],
 ):
     """For setting a callback when a backend is put to.
 

ophyd_async/core/_protocol.py

@@ -13,10 +13,38 @@ from typing import (
 from bluesky.protocols import HasName, Reading
 from event_model import DataKey
 
+from ._utils import DEFAULT_TIMEOUT
+
 if TYPE_CHECKING:
+    from unittest.mock import Mock
+
     from ._status import AsyncStatus
 
 
+@runtime_checkable
+class Connectable(Protocol):
+    @abstractmethod
+    async def connect(
+        self,
+        mock: bool | Mock = False,
+        timeout: float = DEFAULT_TIMEOUT,
+        force_reconnect: bool = False,
+    ):
+        """Connect self and all child Devices.
+
+        Contains a timeout that gets propagated to child.connect methods.
+
+        Parameters
+        ----------
+        mock:
+            If True then use ``MockSignalBackend`` for all Signals
+        timeout:
+            Time to wait before failing with a TimeoutError.
+        force_reconnect:
+            Reconnect even if previous connect was successful.
+        """
+
+
 @runtime_checkable
 class AsyncReadable(HasName, Protocol):
     @abstractmethod
@@ -33,7 +61,6 @@ class AsyncReadable(HasName, Protocol):
                          ('channel2',
                          {'value': 16, 'timestamp': 1472493713.539238}))
         """
-        ...
 
     @abstractmethod
     async def describe(self) -> dict[str, DataKey]:
@@ -53,7 +80,6 @@ class AsyncReadable(HasName, Protocol):
                           'dtype': 'number',
                           'shape': []}))
         """
-        ...
 
 
 @runtime_checkable
@@ -63,14 +89,12 @@ class AsyncConfigurable(HasName, Protocol):
         """Same API as ``read`` but for slow-changing fields related to configuration.
         e.g., exposure time. These will typically be read only once per run.
         """
-        ...
 
     @abstractmethod
     async def describe_configuration(self) -> dict[str, DataKey]:
         """Same API as ``describe``, but corresponding to the keys in
         ``read_configuration``.
         """
-        ...
 
 
 @runtime_checkable
@@ -78,12 +102,10 @@ class AsyncPausable(Protocol):
     @abstractmethod
     async def pause(self) -> None:
         """Perform device-specific work when the RunEngine pauses."""
-        ...
 
     @abstractmethod
     async def resume(self) -> None:
         """Perform device-specific work when the RunEngine resumes after a pause."""
-        ...
 
 
 @runtime_checkable
@@ -95,7 +117,6 @@ class AsyncStageable(Protocol):
         It should return a ``Status`` that is marked done when the device is
         done staging.
         """
-        ...
 
     @abstractmethod
     def unstage(self) -> AsyncStatus:
@@ -104,7 +125,6 @@ class AsyncStageable(Protocol):
         It should return a ``Status`` that is marked done when the device is finished
         unstaging.
         """
-        ...
 
 
 C = TypeVar("C", contravariant=True)

ophyd_async/core/_readable.py

@@ -150,19 +150,19 @@ class StandardReadable(
         :meth:`HintedSignal.uncached`
         """
 
-        dict_copy = self.__dict__.copy()
+        dict_copy = dict(self.children())
 
         yield
 
         # Set symmetric difference operator gives all newly added keys
-        new_keys = dict_copy.keys() ^ self.__dict__.keys()
-        new_values = [self.__dict__[key] for key in new_keys]
+        new_dict = dict(self.children())
+        new_keys = dict_copy.keys() ^ new_dict.keys()
+        new_values = [new_dict[key] for key in new_keys]
 
         flattened_values = []
         for value in new_values:
             if isinstance(value, DeviceVector):
-                children = value.children()
-                flattened_values.extend([x[1] for x in children])
+                flattened_values.extend(value.values())
             else:
                 flattened_values.append(value)