From 8db8da2ccffa879762d0dc8128e76dbd6ab26697 Mon Sep 17 00:00:00 2001
From: James Souter <james.souter@diamond.ac.uk>
Date: Tue, 16 Apr 2024 08:44:55 +0000
Subject: [PATCH] rename to soft_signal_r/rw and return backend with
 soft_signal_r

---
 src/ophyd_async/core/__init__.py |  8 ++++----
 src/ophyd_async/core/signal.py   | 17 ++++++++++++-----
 tests/core/test_signal.py        | 31 ++++++++++++++++++-------------
 3 files changed, 34 insertions(+), 22 deletions(-)

diff --git a/src/ophyd_async/core/__init__.py b/src/ophyd_async/core/__init__.py
index efeff77fa8..3bbb12006c 100644
--- a/src/ophyd_async/core/__init__.py
+++ b/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",
diff --git a/src/ophyd_async/core/signal.py b/src/ophyd_async/core/signal.py
index 6397d8a0f3..8f0e9eebb1 100644
--- a/src/ophyd_async/core/signal.py
+++ b/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]:
diff --git a/tests/core/test_signal.py b/tests/core/test_signal.py
index dfc0ba1ed5..8bc161d592 100644
--- a/tests/core/test_signal.py
+++ b/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