Allow PVI devices to be initialized before connection

src/ophyd_async/core/signal.py

@@ -57,7 +57,7 @@ class Signal(Device, Generic[T]):
 
     def __init__(
         self,
-        backend: SignalBackend[T],
+        backend: Optional[SignalBackend[T]] = None,
         timeout: Optional[float] = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
@@ -66,13 +66,21 @@ def __init__(
         super().__init__(name)
 
     async def connect(
-        self, mock=False, timeout=DEFAULT_TIMEOUT, force_reconnect: bool = False
+        self,
+        mock=False,
+        timeout=DEFAULT_TIMEOUT,
+        force_reconnect: bool = False,
+        backend: Optional[SignalBackend[T]] = None,
     ):
+        if backend:
+            if self._initial_backend and backend is not self._initial_backend:
+                raise ValueError(
+                    "Backend at connection different from initialised one."
+                )
+            self._backend = backend
         if mock and not isinstance(self._backend, MockSignalBackend):
             # Using a soft backend, look to the initial value
-            self._backend = MockSignalBackend(
-                initial_backend=self._initial_backend,
-            )
+            self._backend = MockSignalBackend(initial_backend=self._backend)
         self.log.debug(f"Connecting to {self.source}")
         await self._backend.connect(timeout=timeout)
 

src/ophyd_async/epics/pvi/pvi.py

@@ -179,7 +179,12 @@ def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
                 sub_device_2 = device_cls(SoftSignalBackend(signal_dtype))
                 sub_device = DeviceVector({1: sub_device_1, 2: sub_device_2})
             else:
-                sub_device = DeviceVector({1: device_cls(), 2: device_cls()})
+                sub_device = DeviceVector(
+                    {
+                        1: getattr(device, device_name, device_cls()),
+                        2: getattr(device, device_name, device_cls()),
+                    }
+                )
 
                 for sub_device_in_vector in sub_device.values():
                     _mock_common_blocks(sub_device_in_vector, stripped_type=device_cls)
@@ -296,7 +301,9 @@ async def fill_pvi_entries(
 
 
 def create_children_from_annotations(
-    device: Device, included_optional_fields: Tuple[str, ...] = ()
+    device: Device,
+    included_optional_fields: Tuple[str, ...] = (),
+    device_vectors: Optional[Dict[str, int]] = None,
 ):
     """For intializing blocks at __init__ of ``device``."""
     for name, device_type in get_type_hints(type(device)).items():
@@ -306,13 +313,15 @@ def create_children_from_annotations(
         if is_optional and name not in included_optional_fields:
             continue
         is_device_vector, device_type = _strip_device_vector(device_type)
+        if is_device_vector and not device_vectors:
+            continue
         if (
-            is_device_vector
+            (is_device_vector and name not in device_vectors.keys())
             or ((origin := get_origin(device_type)) and issubclass(origin, Signal))
             or (isclass(device_type) and issubclass(device_type, Signal))
         ):
             continue
 
         sub_device = device_type()
         setattr(device, name, sub_device)
-        create_children_from_annotations(sub_device)
+        create_children_from_annotations(sub_device, device_vectors=device_vectors)

tests/core/test_signal.py

@@ -12,6 +12,8 @@
     ConfigSignal,
     DeviceCollector,
     HintedSignal,
+    MockSignalBackend,
+    Signal,
     SignalR,
     SignalRW,
     SoftSignalBackend,
@@ -50,6 +52,29 @@ async def test_signals_equality_raises():
         s1 > 4
 
 
+async def test_signal_connect_fails_with_different_backend_on_connection():
+    sim_signal = Signal(MockSignalBackend(str))
+
+    with pytest.raises(ValueError):
+        await sim_signal.connect(mock=True, backend=MockSignalBackend(int))
+
+    with pytest.raises(ValueError):
+        await sim_signal.connect(mock=True, backend=SoftSignalBackend(str))
+
+    with pytest.raises(ValueError):
+        await sim_signal.connect(mock=False, backend=MockSignalBackend(str))
+
+
+async def test_signal_connect_fails_if_different_backend_but_same_by_value():
+    initial_backend = MockSignalBackend(str)
+    sim_signal = Signal(initial_backend)
+
+    with pytest.raises(ValueError):
+        await sim_signal.connect(mock=True, backend=MockSignalBackend(str))
+
+    await sim_signal.connect(mock=True, backend=initial_backend)
+
+
 async def time_taken_by(coro) -> float:
     start = time.monotonic()
     await coro