rename to soft_signal_r/rw and return backend with soft_signal_r

src/ophyd_async/core/__init__.py

@@ -30,8 +30,8 @@
     SignalRW,
     SignalW,
     SignalX,
-    create_soft_signal_r,
-    create_soft_signal_rw,
+    soft_signal_r,
+    soft_signal_rw,
     observe_value,
     set_and_wait_for_value,
     set_sim_callback,
@@ -69,8 +69,8 @@
     "SignalW",
     "SignalRW",
     "SignalX",
-    "create_soft_signal_r",
-    "create_soft_signal_rw",
+    "soft_signal_r",
+    "soft_signal_rw",
     "observe_value",
     "set_and_wait_for_value",
     "set_sim_callback",

src/ophyd_async/core/signal.py

@@ -2,7 +2,7 @@
 
 import asyncio
 import functools
-from typing import AsyncGenerator, Callable, Dict, Generic, Optional, Type, Union
+from typing import AsyncGenerator, Callable, Dict, Generic, Optional, Tuple, Type, Union
 
 from bluesky.protocols import (
     Descriptor,
@@ -253,16 +253,23 @@ def set_sim_callback(signal: Signal[T], callback: ReadingValueCallback[T]) -> No
     return _sim_backends[signal].set_callback(callback)
 
 
-def create_soft_signal_rw(
+def soft_signal_rw(
     datatype: Optional[Type[T]], name: str, source_prefix: str
 ) -> SignalRW[T]:
+    """Creates a read-writable Signal with a SimSignalBackend"""
     return SignalRW(SimSignalBackend(datatype, f"sim://{source_prefix}:{name}"))
 
 
-def create_soft_signal_r(
+def soft_signal_r(
     datatype: Optional[Type[T]], name: str, source_prefix: str
-) -> SignalR[T]:
-    return SignalR(SimSignalBackend(datatype, f"sim://{source_prefix}:{name}"))
+) -> Tuple[SignalR[T], SimSignalBackend]:
+    """Returns a tuple of a read-only Signal and its SimSignalBackend 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, f"sim://{source_prefix}:{name}")
+    signal = SignalR(backend)
+    return (signal, backend)
 
 
 async def observe_value(signal: SignalR[T], timeout=None) -> AsyncGenerator[T, None]:

tests/core/test_signal.py

@@ -9,11 +9,11 @@
     SignalR,
     SignalRW,
     SimSignalBackend,
-    create_soft_signal_r,
-    create_soft_signal_rw,
     set_and_wait_for_value,
     set_sim_put_proceeds,
     set_sim_value,
+    soft_signal_r,
+    soft_signal_rw,
     wait_for_value,
 )
 from ophyd_async.core.utils import DEFAULT_TIMEOUT
@@ -124,16 +124,21 @@ async def test_set_and_wait_for_value():
     assert await time_taken_by(st) < 0.1
 
 
-async def test_create_soft_signal():
+@pytest.mark.parametrize(
+    "signal_method,signal_class",
+    [(soft_signal_r, SignalR), (soft_signal_rw, SignalRW)],
+)
+async def test_create_soft_signal(signal_method, signal_class):
     TEST_PREFIX = "TEST-PREFIX"
-    ro_signal = create_soft_signal_r(str, "RO-SIGNAL", TEST_PREFIX)
-    assert isinstance(ro_signal, SignalR)
-    assert isinstance(ro_signal._backend, SimSignalBackend)
-    rw_signal = create_soft_signal_rw(str, "RW-SIGNAL", TEST_PREFIX)
-    assert isinstance(rw_signal, SignalRW)
-    assert isinstance(ro_signal._backend, SimSignalBackend)
-    await ro_signal.connect()
-    await rw_signal.connect()
+    SIGNAL_NAME = "SIGNAL"
+    if signal_method == soft_signal_r:
+        signal, backend = signal_method(str, SIGNAL_NAME, TEST_PREFIX)
+    elif signal_method == soft_signal_rw:
+        signal = signal_method(str, SIGNAL_NAME, TEST_PREFIX)
+        backend = signal._backend
+    assert signal._backend.source == f"sim://{TEST_PREFIX}:{SIGNAL_NAME}"
+    assert isinstance(signal, signal_class)
+    assert isinstance(signal._backend, SimSignalBackend)
+    await signal.connect()
     # connecting with sim=False uses existing SimSignalBackend
-    assert ro_signal._backend is ro_signal._init_backend
-    assert rw_signal._backend is rw_signal._init_backend
+    assert signal._backend is backend