ophyd-async 0.3a6__tar.gz → 0.3.1a1__tar.gz

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3a6
+Version: 0.3.1a1
 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
@@ -96,7 +96,7 @@ Requires-Dist: types-pyyaml; extra == "dev"
 
 # ophyd-async
 
-Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
+Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango.
 
 |    Source     |     <https://github.com/bluesky/ophyd-async>      |
 | :-----------: | :-----------------------------------------------: |

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/README.md

@@ -5,7 +5,7 @@
 
 # ophyd-async
 
-Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
+Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango.
 
 |    Source     |     <https://github.com/bluesky/ophyd-async>      |
 | :-----------: | :-----------------------------------------------: |

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/docs/how-to/write-tests-for-devices.rst

@@ -41,6 +41,11 @@ In addition this example also utilizes helper functions like ``assert_reading``
    :pyobject: test_sensor_reading_shows_value
 
 
+Given that the mock signal holds a ``unittest.mock.Mock`` object you can retrieve this object and assert that the device has been set correctly using ``get_mock_put``. You are also free to use any other behaviour that ``unittest.mock.Mock`` provides, such as in this example which sets the parent of the mock to allow ordering across signals to be asserted:
+
+.. literalinclude:: ../../tests/epics/demo/test_demo.py
+   :pyobject: test_retrieve_mock_and_assert
+
 There are several other test utility functions:
 
 Use ``callback_on_mock_put``, for hooking in logic when a mock value changes (e.g. because someone puts to it). This can be called directly, or used as a context, with the callbacks ending after exit.

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/src/ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3a6'
-__version_tuple__ = version_tuple = (0, 3)
+__version__ = version = '0.3.1a1'
+__version_tuple__ = version_tuple = (0, 3, 1)

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/src/ophyd_async/core/__init__.py

@@ -24,12 +24,10 @@ from .device_save_loader import (
     walk_rw_signals,
 )
 from .flyer import HardwareTriggeredFlyable, TriggerLogic
-from .mock_signal_backend import (
-    MockSignalBackend,
-)
+from .mock_signal_backend import MockSignalBackend
 from .mock_signal_utils import (
-    assert_mock_put_called_with,
     callback_on_mock_put,
+    get_mock_put,
     mock_puts_blocked,
     reset_mock_put_calls,
     set_mock_put_proceeds,
@@ -70,7 +68,7 @@ from .utils import (
 )
 
 __all__ = [
-    "assert_mock_put_called_with",
+    "get_mock_put",
     "callback_on_mock_put",
     "mock_puts_blocked",
     "set_mock_values",

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/src/ophyd_async/core/detector.py

@@ -63,6 +63,8 @@ class TriggerInfo:
     deadtime: float
     #: What is the maximum high time of the triggers
     livetime: float
+    #: What is the maximum timeout on waiting for a frame
+    frame_timeout: float | None = None
 
 
 class DetectorControl(ABC):
@@ -162,7 +164,6 @@ class StandardDetector(
         writer: DetectorWriter,
         config_sigs: Sequence[AsyncReadable] = (),
         name: str = "",
-        writer_timeout: float = DEFAULT_TIMEOUT,
     ) -> None:
         """
         Constructor
@@ -173,16 +174,11 @@ class StandardDetector(
             config_sigs: Signals to read when describe and read
             configuration are called. Defaults to ().
             name: Device name. Defaults to "".
-            writer_timeout: Timeout for frame writing to start, if the
-            timeout is reached, ophyd-async assumes the detector
-            has a problem and raises an error.
-            Defaults to DEFAULT_TIMEOUT.
         """
         self._controller = controller
         self._writer = writer
         self._describe: Dict[str, DataKey] = {}
         self._config_sigs = list(config_sigs)
-        self._frame_writing_timeout = writer_timeout
         # For prepare
         self._arm_status: Optional[AsyncStatus] = None
         self._trigger_info: Optional[TriggerInfo] = None
@@ -245,17 +241,21 @@ class StandardDetector(
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:
+        # set default trigger_info
+        self._trigger_info = TriggerInfo(
+            num=1, trigger=DetectorTrigger.internal, deadtime=0.0, livetime=0.0
+        )
         # Arm the detector and wait for it to finish.
         indices_written = await self.writer.get_indices_written()
         written_status = await self.controller.arm(
-            num=1,
-            trigger=DetectorTrigger.internal,
+            num=self._trigger_info.num,
+            trigger=self._trigger_info.trigger,
         )
         await written_status
         end_observation = indices_written + 1
 
         async for index in self.writer.observe_indices_written(
-            self._frame_writing_timeout
+            DEFAULT_TIMEOUT + self._trigger_info.livetime + self._trigger_info.deadtime
         ):
             if index >= end_observation:
                 break
@@ -309,7 +309,12 @@ class StandardDetector(
         assert self._arm_status, "Prepare not run"
         assert self._trigger_info
         async for index in self.writer.observe_indices_written(
-            self._frame_writing_timeout
+            self._trigger_info.frame_timeout
+            or (
+                DEFAULT_TIMEOUT
+                + self._trigger_info.livetime
+                + self._trigger_info.deadtime
+            )
         ):
             yield WatcherUpdate(
                 name=self.name,

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/src/ophyd_async/core/mock_signal_backend.py

@@ -1,6 +1,6 @@
 import asyncio
 from functools import cached_property
-from typing import Optional, Type
+from typing import Callable, Optional, Type
 from unittest.mock import Mock
 
 from bluesky.protocols import Descriptor, Reading
@@ -10,7 +10,7 @@ from ophyd_async.core.soft_signal_backend import SoftSignalBackend
 from ophyd_async.core.utils import DEFAULT_TIMEOUT, ReadingValueCallback, T
 
 
-class MockSignalBackend(SignalBackend):
+class MockSignalBackend(SignalBackend[T]):
     def __init__(
         self,
         datatype: Optional[Type[T]] = None,
@@ -31,11 +31,11 @@ class MockSignalBackend(SignalBackend):
 
         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
+            # then we create a soft signal to mimic it
 
             self.soft_backend = SoftSignalBackend(datatype=datatype)
         else:
-            self.soft_backend = initial_backend
+            self.soft_backend = self.initial_backend
 
     def source(self, name: str) -> str:
         if self.initial_backend:
@@ -47,7 +47,7 @@ class MockSignalBackend(SignalBackend):
 
     @cached_property
     def put_mock(self) -> Mock:
-        return Mock(name="put")
+        return Mock(name="put", spec=Callable)
 
     @cached_property
     def put_proceeds(self) -> asyncio.Event:
@@ -65,9 +65,6 @@ class MockSignalBackend(SignalBackend):
     def set_value(self, value: T):
         self.soft_backend.set_value(value)
 
-    async def get_descriptor(self, source: str) -> Descriptor:
-        return await self.soft_backend.get_descriptor(source)
-
     async def get_reading(self) -> Reading:
         return await self.soft_backend.get_reading()
 

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/src/ophyd_async/core/mock_signal_utils.py

@@ -1,6 +1,6 @@
 from contextlib import asynccontextmanager, contextmanager
-from typing import Any, Callable, Iterable, Iterator, List
-from unittest.mock import ANY, Mock
+from typing import Any, Callable, Iterable
+from unittest.mock import Mock
 
 from ophyd_async.core.signal import Signal
 from ophyd_async.core.utils import T
@@ -22,7 +22,7 @@ def set_mock_value(signal: Signal[T], value: T):
     backend.set_value(value)
 
 
-def set_mock_put_proceeds(signal: Signal[T], proceeds: bool):
+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)
 
@@ -33,7 +33,7 @@ def set_mock_put_proceeds(signal: Signal[T], proceeds: bool):
 
 
 @asynccontextmanager
-async def mock_puts_blocked(*signals: List[Signal]):
+async def mock_puts_blocked(*signals: Signal):
     for signal in signals:
         set_mock_put_proceeds(signal, False)
     yield
@@ -41,9 +41,9 @@ async def mock_puts_blocked(*signals: List[Signal]):
         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.put_mock.assert_called_with(value, wait=wait, timeout=timeout)
+def get_mock_put(signal: Signal) -> Mock:
+    """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):
@@ -79,15 +79,29 @@ class _SetValuesIterator:
         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.")
+        if self.require_all_consumed:
+            # Values is cast to a list here because the user has supplied
+            # require_all_consumed=True, we can therefore assume they
+            # supplied a finite list.
+            # In the case of require_all_consumed=False, an infinite
+            # iterble is permitted
+            values = list(self.values)
+            if self.index != len(values):
+                # Report the values consumed and the values yet to be
+                # consumed
+                consumed = values[0 : self.index]
+                to_be_consumed = values[self.index :]
+                raise AssertionError(
+                    f"{self.signal.name}: {consumed} were consumed "
+                    f"but {to_be_consumed} were not consumed"
+                )
 
 
 def set_mock_values(
     signal: Signal,
     values: Iterable[Any],
     require_all_consumed: bool = False,
-) -> Iterator[Any]:
+) -> _SetValuesIterator:
     """Iterator to set a signal to a sequence of values, optionally repeating the
     sequence.
 
@@ -127,7 +141,7 @@ def _unset_side_effect_cm(put_mock: Mock):
     put_mock.side_effect = None
 
 
-def callback_on_mock_put(signal: Signal, callback: Callable[[T], None]):
+def callback_on_mock_put(signal: Signal[T], callback: Callable[[T], None]):
     """For setting a callback when a backend is put to.
 
     Can either be used in a context, with the callback being

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/src/ophyd_async/core/signal_backend.py

@@ -14,7 +14,7 @@ class SignalBackend(Generic[T]):
 
     #: Like ca://PV_PREFIX:SIGNAL
     @abstractmethod
-    def source(name: str) -> str:
+    def source(self, name: str) -> str:
         """Return source of signal. Signals may pass a name to the backend, which can be
         used or discarded."""
 

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/src/ophyd_async/core/standard_readable.py

@@ -254,6 +254,8 @@ class HintedSignal(HasHints, AsyncReadable):
 
     @property
     def hints(self) -> Hints:
+        if self.signal.name == "":
+            return {"fields": []}
         return {"fields": [self.signal.name]}
 
     @classmethod

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/src/ophyd_async/epics/areadetector/controllers/pilatus_controller.py

@@ -1,6 +1,7 @@
 import asyncio
 from typing import Optional
 
+from ophyd_async.core import DEFAULT_TIMEOUT, wait_for_value
 from ophyd_async.core.async_status import AsyncStatus
 from ophyd_async.core.detector import DetectorControl, DetectorTrigger
 from ophyd_async.epics.areadetector.drivers.ad_base import (
@@ -23,14 +24,13 @@ class PilatusController(DetectorControl):
     def __init__(
         self,
         driver: PilatusDriver,
+        readout_time: float,
     ) -> None:
         self._drv = driver
+        self._readout_time = readout_time
 
     def get_deadtime(self, exposure: float) -> float:
-        # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
-        """The required minimum time difference between ExpPeriod and ExpTime
-        (readout time) is 2.28 ms"""
-        return 2.28e-3
+        return self._readout_time
 
     async def arm(
         self,
@@ -45,7 +45,20 @@ class PilatusController(DetectorControl):
             self._drv.num_images.set(999_999 if num == 0 else num),
             self._drv.image_mode.set(ImageMode.multiple),
         )
-        return await start_acquiring_driver_and_ensure_status(self._drv)
+
+        # Standard arm the detector and wait for the acquire PV to be True
+        idle_status = await start_acquiring_driver_and_ensure_status(self._drv)
+
+        # The pilatus has an additional PV that goes True when the camserver
+        # is actually ready. Should wait for that too or we risk dropping
+        # a frame
+        await wait_for_value(
+            self._drv.armed_for_triggers,
+            True,
+            timeout=DEFAULT_TIMEOUT,
+        )
+
+        return idle_status
 
     @classmethod
     def _get_trigger_mode(cls, trigger: DetectorTrigger) -> PilatusTriggerMode:

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/src/ophyd_async/epics/areadetector/drivers/pilatus_driver.py

@@ -1,7 +1,6 @@
 from enum import Enum
 
-from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
-
+from ...signal import epics_signal_r, epics_signal_rw_rbv
 from .ad_base import ADBase
 
 
@@ -18,4 +17,5 @@ class PilatusDriver(ADBase):
         self.trigger_mode = epics_signal_rw_rbv(
             PilatusTriggerMode, prefix + "TriggerMode"
         )
+        self.armed_for_triggers = epics_signal_r(bool, prefix + "Armed")
         super().__init__(prefix, name)

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/src/ophyd_async/epics/areadetector/pilatus.py

@@ -1,3 +1,5 @@
+from enum import Enum
+
 from bluesky.protocols import Hints
 
 from ophyd_async.core import DirectoryProvider
@@ -11,6 +13,20 @@ from ophyd_async.epics.areadetector.writers.hdf_writer import HDFWriter
 from ophyd_async.epics.areadetector.writers.nd_file_hdf import NDFileHDF
 
 
+#: Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
+#: The required minimum time difference between ExpPeriod and ExpTime
+#: (readout time) is 2.28 ms
+#: We provide an option to override for newer Pilatus models
+class PilatusReadoutTime(float, Enum):
+    """Pilatus readout time per model in ms"""
+
+    # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
+    pilatus2 = 2.28e-3
+
+    # Cite: https://media.dectris.com/user-manual-pilatus3-2020.pdf
+    pilatus3 = 0.95e-3
+
+
 class PilatusDetector(StandardDetector):
     """A Pilatus StandardDetector writing HDF files"""
 
@@ -21,15 +37,16 @@ class PilatusDetector(StandardDetector):
         self,
         prefix: str,
         directory_provider: DirectoryProvider,
-        drv_suffix="cam1:",
-        hdf_suffix="HDF1:",
-        name="",
+        readout_time: PilatusReadoutTime = PilatusReadoutTime.pilatus3,
+        drv_suffix: str = "cam1:",
+        hdf_suffix: str = "HDF1:",
+        name: str = "",
     ):
         self.drv = PilatusDriver(prefix + drv_suffix)
         self.hdf = NDFileHDF(prefix + hdf_suffix)
 
         super().__init__(
-            PilatusController(self.drv),
+            PilatusController(self.drv, readout_time=readout_time.value),
             HDFWriter(
                 self.hdf,
                 directory_provider,

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/src/ophyd_async/panda/_hdf_panda.py

@@ -38,7 +38,6 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
             writer=writer,
             config_sigs=config_sigs,
             name=name,
-            writer_timeout=DEFAULT_TIMEOUT,
         )
 
     async def connect(

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/src/ophyd_async/plan_stubs/fly.py

@@ -18,6 +18,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
     shutter_time: float,
     repeats: int = 1,
     period: float = 0.0,
+    frame_timeout: float | None = None,
 ):
     """Prepare a hardware triggered flyable and one or more detectors.
 
@@ -39,6 +40,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
         trigger=DetectorTrigger.constant_gate,
         deadtime=deadtime,
         livetime=exposure,
+        frame_timeout=frame_timeout,
     )
     trigger_time = number_of_frames * (exposure + deadtime)
     pre_delay = max(period - 2 * shutter_time - trigger_time, 0)
@@ -120,6 +122,7 @@ def time_resolved_fly_and_collect_with_static_seq_table(
     shutter_time: float,
     repeats: int = 1,
     period: float = 0.0,
+    frame_timeout: float | None = None,
 ):
     """Run a scan wth a flyer and multiple detectors.
 
@@ -144,6 +147,7 @@ def time_resolved_fly_and_collect_with_static_seq_table(
         shutter_time=shutter_time,
         repeats=repeats,
         period=period,
+        frame_timeout=frame_timeout,
     )
     # Run the fly scan
     yield from fly_and_collect(stream_name, flyer, detectors)

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/src/ophyd_async/sim/sim_pattern_generator.py

@@ -16,7 +16,6 @@ class SimPatternDetector(StandardDetector):
         path: Path,
         config_sigs: Sequence[AsyncReadable] = [],
         name: str = "sim_pattern_detector",
-        writer_timeout: float = 1,
     ) -> None:
         self.directory_provider: DirectoryProvider = StaticDirectoryProvider(path)
         self.pattern_generator = PatternGenerator()
@@ -33,5 +32,4 @@ class SimPatternDetector(StandardDetector):
             writer=writer,
             config_sigs=config_sigs,
             name=name,
-            writer_timeout=writer_timeout,
         )

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/src/ophyd_async.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3a6
+Version: 0.3.1a1
 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
@@ -96,7 +96,7 @@ Requires-Dist: types-pyyaml; extra == "dev"
 
 # ophyd-async
 
-Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
+Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango.
 
 |    Source     |     <https://github.com/bluesky/ophyd-async>      |
 | :-----------: | :-----------------------------------------------: |

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/tests/core/test_flyer.py

@@ -124,13 +124,11 @@ async def detectors(RE: RunEngine) -> tuple[StandardDetector, StandardDetector]:
         Mock(spec=DetectorControl, get_deadtime=lambda num: num, arm=dummy_arm_1),
         writers[0],
         name="detector_1",
-        writer_timeout=3,
     )
     detector_2: StandardDetector[Any] = StandardDetector(
         Mock(spec=DetectorControl, get_deadtime=lambda num: num, arm=dummy_arm_2),
         writers[1],
         name="detector_2",
-        writer_timeout=3,
     )
 
     return (detector_1, detector_2)

{ophyd_async-0.3a6 → ophyd_async-0.3.1a1}/tests/core/test_mock_signal_backend.py

@@ -1,26 +1,22 @@
 import asyncio
 import re
 from itertools import repeat
-from unittest.mock import MagicMock, call
+from unittest.mock import ANY, MagicMock, call
 
 import pytest
 
 from ophyd_async.core import MockSignalBackend, SignalRW
 from ophyd_async.core.device import Device, DeviceCollector
 from ophyd_async.core.mock_signal_utils import (
-    assert_mock_put_called_with,
     callback_on_mock_put,
+    get_mock_put,
     mock_puts_blocked,
     reset_mock_put_calls,
     set_mock_put_proceeds,
     set_mock_value,
     set_mock_values,
 )
-from ophyd_async.core.signal import (
-    SignalW,
-    soft_signal_r_and_setter,
-    soft_signal_rw,
-)
+from ophyd_async.core.signal import SignalW, soft_signal_r_and_setter, soft_signal_rw
 from ophyd_async.core.soft_signal_backend import SoftSignalBackend
 from ophyd_async.epics.signal.signal import epics_signal_r, epics_signal_rw
 
@@ -31,6 +27,7 @@ async def test_mock_signal_backend(connect_mock_mode):
     # If mock is false it will be handled like a normal signal, otherwise it will
     # initalize a new backend from the one in the line above
     await mock_signal.connect(mock=connect_mock_mode)
+    assert isinstance(mock_signal._backend, MockSignalBackend)
 
     assert await mock_signal._backend.get_value() == ""
     await mock_signal._backend.put("test")
@@ -74,6 +71,8 @@ async def test_set_mock_put_proceeds():
     mock_signal = SignalW(SoftSignalBackend(str))
     await mock_signal.connect(mock=True)
 
+    assert isinstance(mock_signal._backend, MockSignalBackend)
+
     assert mock_signal._backend.put_proceeds.is_set() is True
 
     set_mock_put_proceeds(mock_signal, False)
@@ -95,6 +94,7 @@ async def test_set_mock_put_proceeds_timeout():
 async def test_put_proceeds_timeout():
     mock_signal = SignalW(SoftSignalBackend(str))
     await mock_signal.connect(mock=True)
+    assert isinstance(mock_signal._backend, MockSignalBackend)
 
     assert mock_signal._backend.put_proceeds.is_set() is True
 
@@ -112,14 +112,14 @@ async def test_mock_utils_throw_error_if_backend_isnt_mock_signal_backend():
         set_mock_value(signal, 10)
     exc_msgs.append(str(exc.value))
     with pytest.raises(AssertionError) as exc:
-        assert_mock_put_called_with(signal, 10)
+        get_mock_put(signal).assert_called_once_with(10)
     exc_msgs.append(str(exc.value))
     with pytest.raises(AssertionError) as exc:
-        async with mock_puts_blocked(signal, 10):
+        async with mock_puts_blocked(signal):
             ...
     exc_msgs.append(str(exc.value))
     with pytest.raises(AssertionError) as exc:
-        with callback_on_mock_put(signal, 10):
+        with callback_on_mock_put(signal, lambda x: _):
             ...
     exc_msgs.append(str(exc.value))
     with pytest.raises(AssertionError) as exc:
@@ -137,16 +137,13 @@ async def test_mock_utils_throw_error_if_backend_isnt_mock_signal_backend():
         )
 
 
-async def test_assert_mock_put_called_with():
+async def test_get_mock_put():
     mock_signal = epics_signal_rw(str, "READ_PV", "WRITE_PV", name="mock_name")
     await mock_signal.connect(mock=True)
     await mock_signal.set("test_value", wait=True, timeout=100)
 
-    # can leave out kwargs
-    assert_mock_put_called_with(mock_signal, "test_value")
-    assert_mock_put_called_with(mock_signal, "test_value", wait=True)
-    assert_mock_put_called_with(mock_signal, "test_value", timeout=100)
-    assert_mock_put_called_with(mock_signal, "test_value", wait=True, timeout=100)
+    mock = get_mock_put(mock_signal)
+    mock.assert_called_once_with("test_value", wait=True, timeout=100)
 
     def err_text(text, wait, timeout):
         return (
@@ -162,7 +159,7 @@ async def test_assert_mock_put_called_with():
         ("test_value", False, 0),  # wait and timeout wrong
     ]:
         with pytest.raises(AssertionError) as exc:
-            assert_mock_put_called_with(mock_signal, text, wait=wait, timeout=timeout)
+            mock.assert_called_once_with(text, wait=wait, timeout=timeout)
         for err_substr in err_text(text, wait, timeout):
             assert err_substr in str(exc.value)
 
@@ -216,10 +213,8 @@ async def test_callback_on_mock_put_no_ctx():
     mock_signal = SignalRW(SoftSignalBackend(float))
     await mock_signal.connect(mock=True)
     calls = []
-    (
-        callback_on_mock_put(
-            mock_signal, lambda *args, **kwargs: calls.append({**kwargs, "_args": args})
-        ),
+    callback_on_mock_put(
+        mock_signal, lambda *args, **kwargs: calls.append({**kwargs, "_args": args})
     )
     await mock_signal.set(10.0)
     assert calls == [
@@ -249,16 +244,16 @@ async def test_callback_on_mock_put_fails_if_args_are_not_correct():
 async def test_set_mock_values(mock_signals):
     signal1, signal2 = mock_signals
 
-    await signal2.get_value() == "first_value"
+    assert await signal2.get_value() == "first_value"
     for value_set in set_mock_values(signal1, ["second_value", "third_value"]):
         assert await signal1.get_value() == value_set
 
     iterator = set_mock_values(signal2, ["second_value", "third_value"])
-    await signal2.get_value() == "first_value"
+    assert await signal2.get_value() == "first_value"
     next(iterator)
-    await signal2.get_value() == "second_value"
+    assert await signal2.get_value() == "second_value"
     next(iterator)
-    await signal2.get_value() == "third_value"
+    assert await signal2.get_value() == "third_value"
 
 
 async def test_set_mock_values_exhausted_passes(mock_signals):
@@ -300,10 +295,10 @@ async def test_set_mock_values_exhausted_fails(mock_signals):
 async def test_reset_mock_put_calls(mock_signals):
     signal1, signal2 = mock_signals
     await signal1.set("test_value", wait=True, timeout=1)
-    assert_mock_put_called_with(signal1, "test_value")
+    get_mock_put(signal1).assert_called_with("test_value", wait=ANY, timeout=ANY)
     reset_mock_put_calls(signal1)
     with pytest.raises(AssertionError) as exc:
-        assert_mock_put_called_with(signal1, "test_value")
+        get_mock_put(signal1).assert_called_with("test_value", wait=ANY, timeout=ANY)
     # Replacing spaces because they change between runners
     # (e.g the github actions runner has more)
     assert str(exc.value).replace(" ", "").replace("\n", "") == (
@@ -350,3 +345,13 @@ async def test_writing_to_soft_signals_in_mock():
     assert await signal.get_value() == 0
     backend_put(100)
     assert await signal.get_value() == 100
+
+
+async def test_when_put_mock_called_with_typo_then_fails_but_calling_directly_passes():
+    mock_signal = SignalRW(SoftSignalBackend(int))
+    await mock_signal.connect(mock=True)
+    assert isinstance(mock_signal._backend, MockSignalBackend)
+    mock = mock_signal._backend.put_mock
+    with pytest.raises(AttributeError):
+        mock.asssert_called_once()  # Note typo here is deliberate!
+    mock()