Add create_soft_signal_r and creates_soft_signal_rw methods

src/ophyd_async/core/__init__.py

@@ -35,6 +35,8 @@
     set_sim_callback,
     set_sim_put_proceeds,
     set_sim_value,
+    soft_signal_r_and_backend,
+    soft_signal_rw,
     wait_for_value,
 )
 from .signal_backend import SignalBackend
@@ -67,6 +69,8 @@
     "SignalW",
     "SignalRW",
     "SignalX",
+    "soft_signal_r_and_backend",
+    "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, Union
+from typing import AsyncGenerator, Callable, Dict, Generic, Optional, Tuple, Type, Union
 
 from bluesky.protocols import (
     Descriptor,
@@ -61,7 +61,7 @@ def set_name(self, name: str = ""):
     async def connect(self, sim=False, timeout=DEFAULT_TIMEOUT):
         if sim:
             self._backend = SimSignalBackend(
-                datatype=self._init_backend.datatype, source=self._init_backend.source
+                datatype=self._init_backend.datatype
             )
             _sim_backends[self] = self._backend
         else:
@@ -72,7 +72,7 @@ async def connect(self, sim=False, timeout=DEFAULT_TIMEOUT):
     @property
     def source(self) -> str:
         """Like ca://PV_PREFIX:SIGNAL, or "" if not set"""
-        return self._backend.source
+        return self._backend.source(self.name)
 
     __lt__ = __le__ = __eq__ = __ge__ = __gt__ = __ne__ = _fail
 
@@ -168,7 +168,7 @@ async def read(self, cached: Optional[bool] = None) -> Dict[str, Reading]:
     @_add_timeout
     async def describe(self) -> Dict[str, Descriptor]:
         """Return a single item dict with the descriptor in it"""
-        return {self.name: await self._backend.get_descriptor()}
+        return {self.name: await self._backend.get_descriptor(self.source)}
 
     @_add_timeout
     async def get_value(self, cached: Optional[bool] = None) -> T:
@@ -253,6 +253,34 @@ def set_sim_callback(signal: Signal[T], callback: ReadingValueCallback[T]) -> No
     return _sim_backends[signal].set_callback(callback)
 
 
+def soft_signal_rw(
+    datatype: Optional[Type[T]],
+    name: str,
+    initial_value: Optional[T] = None,
+) -> SignalRW[T]:
+    """Creates a read-writable Signal with a SimSignalBackend"""
+    signal = SignalRW(
+        SimSignalBackend(datatype, initial_value)
+    )
+    signal.set_name(name)
+    return signal
+
+
+def soft_signal_r_and_backend(
+    datatype: Optional[Type[T]],
+    name: str,
+    initial_value: Optional[T] = None,
+) -> 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, initial_value)
+    signal = SignalR(backend)
+    signal.set_name(name)
+    return (signal, backend)
+
+
 async def observe_value(signal: SignalR[T], timeout=None) -> AsyncGenerator[T, None]:
     """Subscribe to the value of a signal so it can be iterated from.
 

src/ophyd_async/core/signal_backend.py

@@ -13,7 +13,10 @@ class SignalBackend(Generic[T]):
     datatype: Optional[Type[T]] = None
 
     #: Like ca://PV_PREFIX:SIGNAL
-    source: str = ""
+    @abstractmethod
+    def source(name: str) -> str:
+        """Return source of signal. Signals may pass a name to the backend, which can be
+        used or discarded."""
 
     @abstractmethod
     async def connect(self, timeout: float = DEFAULT_TIMEOUT):
@@ -24,7 +27,7 @@ async def put(self, value: Optional[T], wait=True, timeout=None):
         """Put a value to the PV, if wait then wait for completion for up to timeout"""
 
     @abstractmethod
-    async def get_descriptor(self) -> Descriptor:
+    async def get_descriptor(self, source: str) -> Descriptor:
         """Metadata like source, dtype, shape, precision, units"""
 
     @abstractmethod

src/ophyd_async/core/sim_signal_backend.py

@@ -2,7 +2,6 @@
 
 import asyncio
 import inspect
-import re
 import time
 from collections import abc
 from dataclasses import dataclass
@@ -107,23 +106,32 @@ class SimSignalBackend(SignalBackend[T]):
     """An simulated backend to a Signal, created with ``Signal.connect(sim=True)``"""
 
     _value: T
-    _initial_value: T
+    _initial_value: Optional[T]
     _timestamp: float
     _severity: int
 
-    def __init__(self, datatype: Optional[Type[T]], source: str) -> None:
-        pv = re.split(r"://", source)[-1]
-        self.source = f"sim://{pv}"
+    def __init__(
+        self,
+        datatype: Optional[Type[T]],
+        initial_value: Optional[T] = None,
+    ) -> None:
         self.datatype = datatype
-        self.pv = source
         self.converter: SimConverter = DisconnectedSimConverter()
+        self._initial_value = initial_value
         self.put_proceeds = asyncio.Event()
         self.put_proceeds.set()
         self.callback: Optional[ReadingValueCallback[T]] = None
 
+    def source(self, name: str) -> str:
+        return f"soft://{name}"
+
     async def connect(self, timeout: float = DEFAULT_TIMEOUT) -> None:
         self.converter = make_converter(self.datatype)
-        self._initial_value = self.converter.make_initial_value(self.datatype)
+        if self._initial_value is None:
+            self._initial_value = self.converter.make_initial_value(self.datatype)
+        else:
+            # convert potentially unconverted initial value passed to init method
+            self._initial_value = self.converter.write_value(self._initial_value)
         self._severity = 0
 
         await self.put(None)
@@ -150,8 +158,8 @@ def _set_value(self, value: T):
         if self.callback:
             self.callback(reading, self._value)
 
-    async def get_descriptor(self) -> Descriptor:
-        return self.converter.descriptor(self.source, self._value)
+    async def get_descriptor(self, source: str) -> Descriptor:
+        return self.converter.descriptor(source, self._value)
 
     async def get_reading(self) -> Reading:
         return self.converter.reading(self._value, self._timestamp, self._severity)

src/ophyd_async/epics/_backend/_aioca.py

@@ -170,9 +170,11 @@ def __init__(self, datatype: Optional[Type[T]], read_pv: str, write_pv: str):
         self.write_pv = write_pv
         self.initial_values: Dict[str, AugmentedValue] = {}
         self.converter: CaConverter = DisconnectedCaConverter(None, None)
-        self.source = f"ca://{self.read_pv}"
         self.subscription: Optional[Subscription] = None
 
+    def source(self, name: str):
+        return f"ca://{self.read_pv}"
+
     async def _store_initial_value(self, pv, timeout: float = DEFAULT_TIMEOUT):
         try:
             self.initial_values[pv] = await caget(
@@ -216,9 +218,9 @@ async def _caget(self, format: Format) -> AugmentedValue:
             timeout=None,
         )
 
-    async def get_descriptor(self) -> Descriptor:
+    async def get_descriptor(self, source: str) -> Descriptor:
         value = await self._caget(FORMAT_CTRL)
-        return self.converter.descriptor(self.source, value)
+        return self.converter.descriptor(source, value)
 
     async def get_reading(self) -> Reading:
         value = await self._caget(FORMAT_TIME)

src/ophyd_async/epics/_backend/_p4p.py

@@ -236,9 +236,12 @@ def __init__(self, datatype: Optional[Type[T]], read_pv: str, write_pv: str):
         self.write_pv = write_pv
         self.initial_values: Dict[str, Any] = {}
         self.converter: PvaConverter = DisconnectedPvaConverter()
-        self.source = f"pva://{self.read_pv}"
         self.subscription: Optional[Subscription] = None
 
+    @property
+    def source(self, name: str):
+        return f"pva://{self.read_pv}"
+
     @property
     def ctxt(self) -> Context:
         if PvaSignalBackend._ctxt is None:
@@ -290,9 +293,9 @@ async def put(self, value: Optional[T], wait=True, timeout=None):
             )
             raise NotConnected(f"pva://{self.write_pv}") from exc
 
-    async def get_descriptor(self) -> Descriptor:
+    async def get_descriptor(self, source: str) -> Descriptor:
         value = await self.ctxt.get(self.read_pv)
-        return self.converter.descriptor(self.source, value)
+        return self.converter.descriptor(source, value)
 
     def _pva_request_string(self, fields: List[str]) -> str:
         """

src/ophyd_async/epics/pvi/pvi.py

@@ -172,8 +172,8 @@ def _sim_common_blocks(device: Device, stripped_type: Optional[Type] = None):
 
         if is_device_vector:
             if is_signal:
-                sub_device_1 = device_cls(SimSignalBackend(signal_dtype, device_name))
-                sub_device_2 = device_cls(SimSignalBackend(signal_dtype, device_name))
+                sub_device_1 = device_cls(SimSignalBackend(signal_dtype))
+                sub_device_2 = device_cls(SimSignalBackend(signal_dtype))
                 sub_device = DeviceVector({1: sub_device_1, 2: sub_device_2})
             else:
                 sub_device = DeviceVector({1: device_cls(), 2: device_cls()})
@@ -185,7 +185,7 @@ def _sim_common_blocks(device: Device, stripped_type: Optional[Type] = None):
                 value.parent = sub_device
         else:
             if is_signal:
-                sub_device = device_cls(SimSignalBackend(signal_dtype, device_name))
+                sub_device = device_cls(SimSignalBackend(signal_dtype))
             else:
                 sub_device = device_cls()
 

src/ophyd_async/sim/pattern_generator.py

@@ -54,7 +54,7 @@ def get_full_file_description(
 ):
     full_file_description: Dict[str, Descriptor] = {}
     for d in datasets:
-        source = f"sim://{d.name}"
+        source = f"soft://{d.name}"
         shape = outer_shape + tuple(d.shape)
         dtype = "number" if d.shape == [1] else "array"
         descriptor = Descriptor(
@@ -158,7 +158,7 @@ def __init__(
         self.written_images_counter: int = 0
 
         # it automatically initializes to 0
-        self.signal_backend = SimSignalBackend(int, "sim://sim_images_counter")
+        self.signal_backend = SimSignalBackend(int)
         self.sim_signal = SignalR(self.signal_backend)
         blob = np.array(
             generate_gaussian_blob(width=detector_width, height=detector_height)

tests/core/test_flyer.py

@@ -51,7 +51,7 @@ async def stop(self):
 
 class DummyWriter(DetectorWriter):
     def __init__(self, name: str, shape: Sequence[int]):
-        self.dummy_signal = SignalRW(backend=SimSignalBackend(int, source="test"))
+        self.dummy_signal = SignalRW(backend=SimSignalBackend(int))
         self._shape = shape
         self._name = name
         self._file: Optional[ComposeStreamResourceBundle] = None
@@ -61,7 +61,7 @@ def __init__(self, name: str, shape: Sequence[int]):
     async def open(self, multiplier: int = 1) -> Dict[str, Descriptor]:
         return {
             self._name: Descriptor(
-                source="sim://some-source",
+                source="soft://some-source",
                 shape=self._shape,
                 dtype="number",
                 external="STREAM:",

tests/core/test_signal.py

@@ -6,11 +6,14 @@
 
 from ophyd_async.core import (
     Signal,
+    SignalR,
     SignalRW,
     SimSignalBackend,
     set_and_wait_for_value,
     set_sim_put_proceeds,
     set_sim_value,
+    soft_signal_r_and_backend,
+    soft_signal_rw,
     wait_for_value,
 )
 from ophyd_async.core.utils import DEFAULT_TIMEOUT
@@ -26,7 +29,7 @@ async def connect(self, sim=False, timeout=DEFAULT_TIMEOUT):
 
 
 def test_signals_equality_raises():
-    sim_backend = SimSignalBackend(str, "test")
+    sim_backend = SimSignalBackend(str)
 
     s1 = MySignal(sim_backend)
     s2 = MySignal(sim_backend)
@@ -45,7 +48,7 @@ def test_signals_equality_raises():
 
 
 async def test_set_sim_put_proceeds():
-    sim_signal = Signal(SimSignalBackend(str, "test"))
+    sim_signal = Signal(SimSignalBackend(str))
     await sim_signal.connect(sim=True)
 
     assert sim_signal._backend.put_proceeds.is_set() is True
@@ -63,7 +66,7 @@ async def time_taken_by(coro) -> float:
 
 
 async def test_wait_for_value_with_value():
-    sim_signal = SignalRW(SimSignalBackend(str, "test"))
+    sim_signal = SignalRW(SimSignalBackend(str))
     sim_signal.set_name("sim_signal")
     await sim_signal.connect(sim=True)
     set_sim_value(sim_signal, "blah")
@@ -84,7 +87,7 @@ async def test_wait_for_value_with_value():
 
 
 async def test_wait_for_value_with_funcion():
-    sim_signal = SignalRW(SimSignalBackend(float, "test"))
+    sim_signal = SignalRW(SimSignalBackend(float))
     sim_signal.set_name("sim_signal")
     await sim_signal.connect(sim=True)
     set_sim_value(sim_signal, 45.8)
@@ -110,7 +113,7 @@ def less_than_42(v):
 
 
 async def test_set_and_wait_for_value():
-    sim_signal = SignalRW(SimSignalBackend(int, "test"))
+    sim_signal = SignalRW(SimSignalBackend(int))
     sim_signal.set_name("sim_signal")
     await sim_signal.connect(sim=True)
     set_sim_value(sim_signal, 0)
@@ -119,3 +122,24 @@ async def test_set_and_wait_for_value():
     assert not st.done
     set_sim_put_proceeds(sim_signal, True)
     assert await time_taken_by(st) < 0.1
+
+
+@pytest.mark.parametrize(
+    "signal_method,signal_class",
+    [(soft_signal_r_and_backend, SignalR), (soft_signal_rw, SignalRW)],
+)
+async def test_create_soft_signal(signal_method, signal_class):
+    SIGNAL_NAME = "TEST-PREFIX:SIGNAL"
+    INITIAL_VALUE = "INITIAL"
+    if signal_method == soft_signal_r_and_backend:
+        signal, backend = signal_method(str, SIGNAL_NAME, INITIAL_VALUE)
+    elif signal_method == soft_signal_rw:
+        signal = signal_method(str, SIGNAL_NAME, INITIAL_VALUE)
+        backend = signal._backend
+    assert signal.source == f"soft://{SIGNAL_NAME}"
+    assert isinstance(signal, signal_class)
+    assert isinstance(signal._backend, SimSignalBackend)
+    await signal.connect()
+    assert (await signal.get_value()) == INITIAL_VALUE
+    # connecting with sim=False uses existing SimSignalBackend
+    assert signal._backend is backend