ophyd-async 0.8.0a3__py3-none-any.whl → 0.8.0a5__py3-none-any.whl

ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.8.0a3'
+__version__ = version = '0.8.0a5'
 __version_tuple__ = version_tuple = (0, 8, 0)

ophyd_async/core/__init__.py

@@ -83,6 +83,7 @@ from ._utils import (
     DEFAULT_TIMEOUT,
     CalculatableTimeout,
     Callback,
+    LazyMock,
     NotConnected,
     Reference,
     StrictEnum,
@@ -176,6 +177,7 @@ __all__ = [
     "DEFAULT_TIMEOUT",
     "CalculatableTimeout",
     "Callback",
+    "LazyMock",
     "CALCULATE_TIMEOUT",
     "NotConnected",
     "Reference",

ophyd_async/core/_device.py

@@ -3,17 +3,15 @@ from __future__ import annotations
 import asyncio
 import sys
 from collections.abc import Coroutine, Iterator, Mapping, MutableMapping
+from functools import cached_property
 from logging import LoggerAdapter, getLogger
 from typing import Any, TypeVar
-from unittest.mock import Mock
 
 from bluesky.protocols import HasName
 from bluesky.run_engine import call_in_bluesky_event_loop, in_bluesky_event_loop
 
 from ._protocol import Connectable
-from ._utils import DEFAULT_TIMEOUT, NotConnected, wait_for_connection
-
-_device_mocks: dict[Device, Mock] = {}
+from ._utils import DEFAULT_TIMEOUT, LazyMock, NotConnected, wait_for_connection
 
 
 class DeviceConnector:
@@ -37,25 +35,29 @@ class DeviceConnector:
         during ``__init__``.
         """
 
-    async def connect(
-        self,
-        device: Device,
-        mock: bool | Mock,
-        timeout: float,
-        force_reconnect: bool,
-    ):
+    async def connect_mock(self, device: Device, mock: LazyMock):
+        # Connect serially, no errors to gather up as in mock mode
+        exceptions: dict[str, Exception] = {}
+        for name, child_device in device.children():
+            try:
+                await child_device.connect(mock=mock.child(name))
+            except Exception as e:
+                exceptions[name] = e
+        if exceptions:
+            raise NotConnected.with_other_exceptions_logged(exceptions)
+
+    async def connect_real(self, device: Device, timeout: float, force_reconnect: bool):
         """Used during ``Device.connect``.
 
         This is called when a previous connect has not been done, or has been
         done in a different mock more. It should connect the Device and all its
         children.
         """
-        coros = {}
-        for name, child_device in device.children():
-            child_mock = getattr(mock, name) if mock else mock  # Mock() or False
-            coros[name] = child_device.connect(
-                mock=child_mock, timeout=timeout, force_reconnect=force_reconnect
-            )
+        # Connect in parallel, gathering up NotConnected errors
+        coros = {
+            name: child_device.connect(timeout=timeout, force_reconnect=force_reconnect)
+            for name, child_device in device.children()
+        }
         await wait_for_connection(**coros)
 
 
@@ -67,9 +69,8 @@ class Device(HasName, Connectable):
     parent: Device | None = None
     # None if connect hasn't started, a Task if it has
     _connect_task: asyncio.Task | None = None
-    # If not None, then this is the mock arg of the previous connect
-    # to let us know if we can reuse an existing connection
-    _connect_mock_arg: bool | None = None
+    # The mock if we have connected in mock mode
+    _mock: LazyMock | None = None
 
     def __init__(
         self, name: str = "", connector: DeviceConnector | None = None
@@ -83,10 +84,18 @@ class Device(HasName, Connectable):
         """Return the name of the Device"""
         return self._name
 
+    @cached_property
+    def _child_devices(self) -> dict[str, Device]:
+        return {}
+
     def children(self) -> Iterator[tuple[str, Device]]:
-        for attr_name, attr in self.__dict__.items():
-            if attr_name != "parent" and isinstance(attr, Device):
-                yield attr_name, attr
+        yield from self._child_devices.items()
+
+    @cached_property
+    def log(self) -> LoggerAdapter:
+        return LoggerAdapter(
+            getLogger("ophyd_async.devices"), {"ophyd_async_device_name": self.name}
+        )
 
     def set_name(self, name: str):
         """Set ``self.name=name`` and each ``self.child.name=name+"-child"``.
@@ -97,28 +106,33 @@ class Device(HasName, Connectable):
             New name to set
         """
         self._name = name
-        # Ensure self.log is recreated after a name change
-        self.log = LoggerAdapter(
-            getLogger("ophyd_async.devices"), {"ophyd_async_device_name": self.name}
-        )
+        # Ensure logger is recreated after a name change
+        if "log" in self.__dict__:
+            del self.log
         for child_name, child in self.children():
             child_name = f"{self.name}-{child_name.strip('_')}" if self.name else ""
             child.set_name(child_name)
 
     def __setattr__(self, name: str, value: Any) -> None:
+        # Bear in mind that this function is called *a lot*, so
+        # we need to make sure nothing expensive happens in it...
         if name == "parent":
             if self.parent not in (value, None):
                 raise TypeError(
                     f"Cannot set the parent of {self} to be {value}: "
                     f"it is already a child of {self.parent}"
                 )
-        elif isinstance(value, Device):
+        # ...hence not doing an isinstance check for attributes we
+        # know not to be Devices
+        elif name not in _not_device_attrs and isinstance(value, Device):
             value.parent = self
-        return super().__setattr__(name, value)
+            self._child_devices[name] = value
+        # ...and avoiding the super call as we know it resolves to `object`
+        return object.__setattr__(self, name, value)
 
     async def connect(
         self,
-        mock: bool | Mock = False,
+        mock: bool | LazyMock = False,
         timeout: float = DEFAULT_TIMEOUT,
         force_reconnect: bool = False,
     ) -> None:
@@ -133,26 +147,39 @@ class Device(HasName, Connectable):
         timeout:
             Time to wait before failing with a TimeoutError.
         """
-        uses_mock = bool(mock)
-        can_use_previous_connect = (
-            uses_mock is self._connect_mock_arg
-            and self._connect_task
-            and not (self._connect_task.done() and self._connect_task.exception())
-        )
-        if mock is True:
-            mock = Mock()  # create a new Mock if one not provided
-        if force_reconnect or not can_use_previous_connect:
-            self._connect_mock_arg = uses_mock
-            if self._connect_mock_arg:
-                _device_mocks[self] = mock
-            coro = self._connector.connect(
-                device=self, mock=mock, timeout=timeout, force_reconnect=force_reconnect
+        if mock:
+            # Always connect in mock mode serially
+            if isinstance(mock, LazyMock):
+                # Use the provided mock
+                self._mock = mock
+            elif not self._mock:
+                # Make one
+                self._mock = LazyMock()
+            await self._connector.connect_mock(self, self._mock)
+        else:
+            # Try to cache the connect in real mode
+            can_use_previous_connect = (
+                self._mock is None
+                and self._connect_task
+                and not (self._connect_task.done() and self._connect_task.exception())
             )
-            self._connect_task = asyncio.create_task(coro)
+            if force_reconnect or not can_use_previous_connect:
+                self._mock = None
+                coro = self._connector.connect_real(self, timeout, force_reconnect)
+                self._connect_task = asyncio.create_task(coro)
+            assert self._connect_task, "Connect task not created, this shouldn't happen"
+            # Wait for it to complete
+            await self._connect_task
+
 
-        assert self._connect_task, "Connect task not created, this shouldn't happen"
-        # Wait for it to complete
-        await self._connect_task
+_not_device_attrs = {
+    "_name",
+    "_children",
+    "_connector",
+    "_timeout",
+    "_mock",
+    "_connect_task",
+}
 
 
 DeviceT = TypeVar("DeviceT", bound=Device)
@@ -172,7 +199,8 @@ class DeviceVector(MutableMapping[int, DeviceT], Device):
         children: Mapping[int, DeviceT],
         name: str = "",
     ) -> None:
-        self._children = dict(children)
+        self._children: dict[int, DeviceT] = {}
+        self.update(children)
         super().__init__(name=name)
 
     def __setattr__(self, name: str, child: Any) -> None:

ophyd_async/core/_mock_signal_backend.py

@@ -1,13 +1,13 @@
 import asyncio
 from collections.abc import Callable
 from functools import cached_property
-from unittest.mock import AsyncMock, Mock
+from unittest.mock import AsyncMock
 
 from bluesky.protocols import Descriptor, Reading
 
 from ._signal_backend import SignalBackend, SignalDatatypeT
 from ._soft_signal_backend import SoftSignalBackend
-from ._utils import Callback
+from ._utils import Callback, LazyMock
 
 
 class MockSignalBackend(SignalBackend[SignalDatatypeT]):
@@ -16,7 +16,7 @@ class MockSignalBackend(SignalBackend[SignalDatatypeT]):
     def __init__(
         self,
         initial_backend: SignalBackend[SignalDatatypeT],
-        mock: Mock,
+        mock: LazyMock,
     ) -> None:
         if isinstance(initial_backend, MockSignalBackend):
             raise ValueError("Cannot make a MockSignalBackend for a MockSignalBackend")
@@ -34,11 +34,14 @@ class MockSignalBackend(SignalBackend[SignalDatatypeT]):
 
         # use existing Mock if provided
         self.mock = mock
-        self.put_mock = AsyncMock(name="put", spec=Callable)
-        self.mock.attach_mock(self.put_mock, "put")
-
         super().__init__(datatype=self.initial_backend.datatype)
 
+    @cached_property
+    def put_mock(self) -> AsyncMock:
+        put_mock = AsyncMock(name="put", spec=Callable)
+        self.mock().attach_mock(put_mock, "put")
+        return put_mock
+
     def set_value(self, value: SignalDatatypeT):
         self.soft_backend.set_value(value)
 
@@ -46,7 +49,7 @@ class MockSignalBackend(SignalBackend[SignalDatatypeT]):
         return f"mock+{self.initial_backend.source(name, read)}"
 
     async def connect(self, timeout: float) -> None:
-        pass
+        raise RuntimeError("It is not possible to connect a MockSignalBackend")
 
     @cached_property
     def put_proceeds(self) -> asyncio.Event:

ophyd_async/core/_mock_signal_utils.py

@@ -2,17 +2,26 @@ from collections.abc import Awaitable, Callable, Iterable
 from contextlib import asynccontextmanager, contextmanager
 from unittest.mock import AsyncMock, Mock
 
-from ._device import Device, _device_mocks
+from ._device import Device
 from ._mock_signal_backend import MockSignalBackend
-from ._signal import Signal, SignalR, _mock_signal_backends
+from ._signal import Signal, SignalConnector, SignalR
 from ._soft_signal_backend import SignalDatatypeT
+from ._utils import LazyMock
+
+
+def get_mock(device: Device | Signal) -> Mock:
+    mock = device._mock  # noqa: SLF001
+    assert isinstance(mock, LazyMock), f"Device {device} not connected in mock mode"
+    return mock()
 
 
 def _get_mock_signal_backend(signal: Signal) -> MockSignalBackend:
-    assert (
-        signal in _mock_signal_backends
+    connector = signal._connector  # noqa: SLF001
+    assert isinstance(connector, SignalConnector), f"Expected Signal, got {signal}"
+    assert isinstance(
+        connector.backend, MockSignalBackend
     ), f"Signal {signal} not connected in mock mode"
-    return _mock_signal_backends[signal]
+    return connector.backend
 
 
 def set_mock_value(signal: Signal[SignalDatatypeT], value: SignalDatatypeT):
@@ -45,12 +54,6 @@ def get_mock_put(signal: Signal) -> AsyncMock:
     return _get_mock_signal_backend(signal).put_mock
 
 
-def get_mock(device: Device | Signal) -> Mock:
-    if isinstance(device, Signal):
-        return _get_mock_signal_backend(device).mock
-    return _device_mocks[device]
-
-
 def reset_mock_put_calls(signal: Signal):
     backend = _get_mock_signal_backend(signal)
     backend.put_mock.reset_mock()

ophyd_async/core/_signal.py

@@ -4,7 +4,6 @@ import asyncio
 import functools
 from collections.abc import AsyncGenerator, Awaitable, Callable, Mapping
 from typing import Any, Generic, cast
-from unittest.mock import Mock
 
 from bluesky.protocols import (
     Locatable,
@@ -30,9 +29,14 @@ from ._signal_backend import (
 )
 from ._soft_signal_backend import SoftSignalBackend
 from ._status import AsyncStatus
-from ._utils import CALCULATE_TIMEOUT, DEFAULT_TIMEOUT, CalculatableTimeout, Callback, T
-
-_mock_signal_backends: dict[Device, MockSignalBackend] = {}
+from ._utils import (
+    CALCULATE_TIMEOUT,
+    DEFAULT_TIMEOUT,
+    CalculatableTimeout,
+    Callback,
+    LazyMock,
+    T,
+)
 
 
 async def _wait_for(coro: Awaitable[T], timeout: float | None, source: str) -> T:
@@ -54,26 +58,28 @@ class SignalConnector(DeviceConnector):
     def __init__(self, backend: SignalBackend):
         self.backend = self._init_backend = backend
 
-    async def connect(
-        self,
-        device: Device,
-        mock: bool | Mock,
-        timeout: float,
-        force_reconnect: bool,
-    ):
-        if mock:
-            self.backend = MockSignalBackend(self._init_backend, mock)
-            _mock_signal_backends[device] = self.backend
-        else:
-            self.backend = self._init_backend
+    async def connect_mock(self, device: Device, mock: LazyMock):
+        self.backend = MockSignalBackend(self._init_backend, mock)
+
+    async def connect_real(self, device: Device, timeout: float, force_reconnect: bool):
+        self.backend = self._init_backend
         device.log.debug(f"Connecting to {self.backend.source(device.name, read=True)}")
         await self.backend.connect(timeout)
 
 
+class _ChildrenNotAllowed(dict[str, Device]):
+    def __setitem__(self, key: str, value: Device) -> None:
+        raise AttributeError(
+            f"Cannot add Device or Signal child {key}={value} of Signal, "
+            "make a subclass of Device instead"
+        )
+
+
 class Signal(Device, Generic[SignalDatatypeT]):
     """A Device with the concept of a value, with R, RW, W and X flavours"""
 
     _connector: SignalConnector
+    _child_devices = _ChildrenNotAllowed()  # type: ignore
 
     def __init__(
         self,
@@ -89,14 +95,6 @@ class Signal(Device, Generic[SignalDatatypeT]):
         """Like ca://PV_PREFIX:SIGNAL, or "" if not set"""
         return self._connector.backend.source(self.name, read=True)
 
-    def __setattr__(self, name: str, value: Any) -> None:
-        if name != "parent" and isinstance(value, Device):
-            raise AttributeError(
-                f"Cannot add Device or Signal {value} as a child of Signal {self}, "
-                "make a subclass of Device instead"
-            )
-        return super().__setattr__(name, value)
-
 
 class _SignalCache(Generic[SignalDatatypeT]):
     def __init__(self, backend: SignalBackend[SignalDatatypeT], signal: Signal):
@@ -451,12 +449,6 @@ async def observe_value(
     """
 
     q: asyncio.Queue[SignalDatatypeT | Status] = asyncio.Queue()
-    if timeout is None:
-        get_value = q.get
-    else:
-
-        async def get_value():
-            return await asyncio.wait_for(q.get(), timeout)
 
     if done_status is not None:
         done_status.add_callback(q.put_nowait)
@@ -464,7 +456,10 @@ async def observe_value(
     signal.subscribe_value(q.put_nowait)
     try:
         while True:
-            item = await get_value()
+            # yield here in case something else is filling the queue
+            # like in test_observe_value_times_out_with_no_external_task()
+            await asyncio.sleep(0)
+            item = await asyncio.wait_for(q.get(), timeout)
             if done_status and item is done_status:
                 if exc := done_status.exception():
                     raise exc

ophyd_async/core/_soft_signal_backend.py

@@ -4,7 +4,8 @@ import time
 from abc import abstractmethod
 from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import Any, Generic, get_origin
+from functools import lru_cache
+from typing import Any, Generic, get_args, get_origin
 
 import numpy as np
 from bluesky.protocols import Reading
@@ -57,7 +58,7 @@ class SequenceEnumSoftConverter(SoftConverter[Sequence[EnumT]]):
 
 @dataclass
 class NDArraySoftConverter(SoftConverter[Array1D]):
-    datatype: np.dtype
+    datatype: np.dtype | None = None
 
     def write_value(self, value: Any) -> Array1D:
         return np.array(() if value is None else value, dtype=self.datatype)
@@ -90,13 +91,18 @@ class TableSoftConverter(SoftConverter[TableT]):
             raise TypeError(f"Cannot convert {value} to {self.datatype}")
 
 
+@lru_cache
 def make_converter(datatype: type[SignalDatatype]) -> SoftConverter:
     enum_cls = get_enum_cls(datatype)
     if datatype == Sequence[str]:
         return SequenceStrSoftConverter()
     elif get_origin(datatype) == Sequence and enum_cls:
         return SequenceEnumSoftConverter(enum_cls)
+    elif datatype is np.ndarray:
+        return NDArraySoftConverter()
     elif get_origin(datatype) == np.ndarray:
+        if datatype not in get_args(SignalDatatype):
+            raise TypeError(f"Expected Array1D[dtype], got {datatype}")
         return NDArraySoftConverter(get_dtype(datatype))
     elif enum_cls:
         return EnumSoftConverter(enum_cls)

ophyd_async/core/_utils.py

@@ -2,18 +2,11 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from collections.abc import Awaitable, Callable, Iterable, Sequence
+from collections.abc import Awaitable, Callable, Iterable, Mapping, Sequence
 from dataclasses import dataclass
 from enum import Enum, EnumMeta
-from typing import (
-    Any,
-    Generic,
-    Literal,
-    ParamSpec,
-    TypeVar,
-    get_args,
-    get_origin,
-)
+from typing import Any, Generic, Literal, ParamSpec, TypeVar, get_args, get_origin
+from unittest.mock import Mock
 
 import numpy as np
 
@@ -21,7 +14,7 @@ T = TypeVar("T")
 P = ParamSpec("P")
 Callback = Callable[[T], None]
 DEFAULT_TIMEOUT = 10.0
-ErrorText = str | dict[str, Exception]
+ErrorText = str | Mapping[str, Exception]
 
 
 class StrictEnum(str, Enum):
@@ -69,6 +62,13 @@ class NotConnected(Exception):
 
         self._errors = errors
 
+    @property
+    def sub_errors(self) -> Mapping[str, Exception]:
+        if isinstance(self._errors, dict):
+            return self._errors.copy()
+        else:
+            return {}
+
     def _format_sub_errors(self, name: str, error: Exception, indent="") -> str:
         if isinstance(error, NotConnected):
             error_txt = ":" + error.format_error_string(indent + self._indent_width)
@@ -99,6 +99,19 @@ class NotConnected(Exception):
     def __str__(self) -> str:
         return self.format_error_string(indent="")
 
+    @classmethod
+    def with_other_exceptions_logged(
+        cls, exceptions: Mapping[str, Exception]
+    ) -> NotConnected:
+        for name, exception in exceptions.items():
+            if not isinstance(exception, NotConnected):
+                logging.exception(
+                    f"device `{name}` raised unexpected exception "
+                    f"{type(exception).__name__}",
+                    exc_info=exception,
+                )
+        return NotConnected(exceptions)
+
 
 @dataclass(frozen=True)
 class WatcherUpdate(Generic[T]):
@@ -120,21 +133,23 @@ async def wait_for_connection(**coros: Awaitable[None]):
 
     Expected kwargs should be a mapping of names to coroutine tasks to execute.
     """
-    results = await asyncio.gather(*coros.values(), return_exceptions=True)
-    exceptions = {}
-
-    for name, result in zip(coros, results, strict=False):
-        if isinstance(result, Exception):
-            exceptions[name] = result
-            if not isinstance(result, NotConnected):
-                logging.exception(
-                    f"device `{name}` raised unexpected exception "
-                    f"{type(result).__name__}",
-                    exc_info=result,
-                )
+    exceptions: dict[str, Exception] = {}
+    if len(coros) == 1:
+        # Single device optimization
+        name, coro = coros.popitem()
+        try:
+            await coro
+        except Exception as e:
+            exceptions[name] = e
+    else:
+        # Use gather to connect in parallel
+        results = await asyncio.gather(*coros.values(), return_exceptions=True)
+        for name, result in zip(coros, results, strict=False):
+            if isinstance(result, Exception):
+                exceptions[name] = result
 
     if exceptions:
-        raise NotConnected(exceptions)
+        raise NotConnected.with_other_exceptions_logged(exceptions)
 
 
 def get_dtype(datatype: type) -> np.dtype:
@@ -252,3 +267,38 @@ class Reference(Generic[T]):
 
     def __call__(self) -> T:
         return self._obj
+
+
+class LazyMock:
+    """A lazily created Mock to be used when connecting in mock mode.
+
+    Creating Mocks is reasonably expensive when each Device (and Signal)
+    requires its own, and the tree is only used when ``Signal.set()`` is
+    called. This class allows a tree of lazily connected Mocks to be
+    constructed so that when the leaf is created, so are its parents.
+    Any calls to the child are then accessible from the parent mock.
+
+    >>> parent = LazyMock()
+    >>> child = parent.child("child")
+    >>> child_mock = child()
+    >>> child_mock()  # doctest: +ELLIPSIS
+    <Mock name='mock.child()' id='...'>
+    >>> parent_mock = parent()
+    >>> parent_mock.mock_calls
+    [call.child()]
+    """
+
+    def __init__(self, name: str = "", parent: LazyMock | None = None) -> None:
+        self.parent = parent
+        self.name = name
+        self._mock: Mock | None = None
+
+    def child(self, name: str) -> LazyMock:
+        return LazyMock(name, self)
+
+    def __call__(self) -> Mock:
+        if self._mock is None:
+            self._mock = Mock(spec=object)
+            if self.parent is not None:
+                self.parent().attach_mock(self._mock, self.name)
+        return self._mock

ophyd_async/epics/adcore/_single_trigger.py

@@ -19,7 +19,8 @@ class SingleTriggerDetector(StandardReadable, Triggerable):
         **plugins: NDPluginBaseIO,
     ) -> None:
         self.drv = drv
-        self.__dict__.update(plugins)
+        for k, v in plugins.items():
+            setattr(self, k, v)
 
         self.add_readables(
             [self.drv.array_counter, *read_uncached],

ophyd_async/epics/core/_aioca.py

@@ -115,7 +115,7 @@ class CaLongStrConverter(CaConverter[str]):
     def __init__(self):
         super().__init__(str, dbr.DBR_CHAR_STR, dbr.DBR_CHAR_STR)
 
-    def write_value_and_dbr(self, value: Any) -> Any:
+    def write_value(self, value: Any) -> Any:
         # Add a null in here as this is what the commandline caput does
         # TODO: this should be in the server so check if it can be pushed to asyn
         return value + "\0"

ophyd_async/epics/core/_p4p.py

@@ -188,6 +188,7 @@ _datatype_converter_from_typeid: dict[
     ("epics:nt/NTScalarArray:1.0", "as"): (Sequence[str], PvaConverter),
     ("epics:nt/NTTable:1.0", "S"): (Table, PvaTableConverter),
     ("epics:nt/NTNDArray:1.0", "v"): (np.ndarray, PvaNDArrayConverter),
+    ("epics:nt/NTNDArray:1.0", "U"): (np.ndarray, PvaNDArrayConverter),
 }
 
 

ophyd_async/epics/core/_pvi_connector.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from unittest.mock import Mock
-
 from ophyd_async.core import (
     Device,
     DeviceConnector,
@@ -11,6 +9,7 @@ from ophyd_async.core import (
     SignalRW,
     SignalX,
 )
+from ophyd_async.core._utils import LazyMock
 
 from ._epics_connector import fill_backend_with_prefix
 from ._signal import PvaSignalBackend, pvget_with_timeout
@@ -64,29 +63,29 @@ class PviDeviceConnector(DeviceConnector):
             backend.read_pv = read_pv
             backend.write_pv = write_pv
 
-    async def connect(
-        self, device: Device, mock: bool | Mock, timeout: float, force_reconnect: bool
+    async def connect_mock(self, device: Device, mock: LazyMock):
+        self.filler.create_device_vector_entries_to_mock(2)
+        # Set the name of the device to name all children
+        device.set_name(device.name)
+        return await super().connect_mock(device, mock)
+
+    async def connect_real(
+        self, device: Device, timeout: float, force_reconnect: bool
     ) -> None:
-        if mock:
-            # Make 2 entries for each DeviceVector
-            self.filler.create_device_vector_entries_to_mock(2)
-        else:
-            pvi_structure = await pvget_with_timeout(self.pvi_pv, timeout)
-            entries: dict[str, Entry | list[Entry | None]] = pvi_structure[
-                "value"
-            ].todict()
-            # Fill based on what PVI gives us
-            for name, entry in entries.items():
-                if isinstance(entry, dict):
-                    # This is a child
-                    self._fill_child(name, entry)
-                else:
-                    # This is a DeviceVector of children
-                    for i, e in enumerate(entry):
-                        if e:
-                            self._fill_child(name, e, i)
-            # Check that all the requested children have been filled
-            self.filler.check_filled(f"{self.pvi_pv}: {entries}")
+        pvi_structure = await pvget_with_timeout(self.pvi_pv, timeout)
+        entries: dict[str, Entry | list[Entry | None]] = pvi_structure["value"].todict()
+        # Fill based on what PVI gives us
+        for name, entry in entries.items():
+            if isinstance(entry, dict):
+                # This is a child
+                self._fill_child(name, entry)
+            else:
+                # This is a DeviceVector of children
+                for i, e in enumerate(entry):
+                    if e:
+                        self._fill_child(name, e, i)
+        # Check that all the requested children have been filled
+        self.filler.check_filled(f"{self.pvi_pv}: {entries}")
         # Set the name of the device to name all children
         device.set_name(device.name)
-        return await super().connect(device, mock, timeout, force_reconnect)
+        return await super().connect_real(device, timeout, force_reconnect)

ophyd_async/fastcs/panda/_table.py

@@ -13,7 +13,7 @@ class PandaHdf5DatasetType(StrictEnum):
 
 class DatasetTable(Table):
     name: Sequence[str]
-    hdf5_type: Sequence[PandaHdf5DatasetType]
+    dtype: Sequence[PandaHdf5DatasetType]
 
 
 class SeqTrigger(StrictEnum):

ophyd_async/plan_stubs/_ensure_connected.py

@@ -1,28 +1,33 @@
-from unittest.mock import Mock
+from collections.abc import Awaitable
 
 import bluesky.plan_stubs as bps
 
-from ophyd_async.core import DEFAULT_TIMEOUT, Device, wait_for_connection
+from ophyd_async.core import DEFAULT_TIMEOUT, Device, LazyMock, wait_for_connection
 
 
 def ensure_connected(
     *devices: Device,
-    mock: bool | Mock = False,
+    mock: bool | LazyMock = False,
     timeout: float = DEFAULT_TIMEOUT,
     force_reconnect=False,
 ):
-    (connect_task,) = yield from bps.wait_for(
-        [
-            lambda: wait_for_connection(
-                **{
-                    device.name: device.connect(
-                        mock=mock, timeout=timeout, force_reconnect=force_reconnect
-                    )
-                    for device in devices
-                }
+    device_names = [device.name for device in devices]
+    non_unique = {
+        device: device.name for device in devices if device_names.count(device.name) > 1
+    }
+    if non_unique:
+        raise ValueError(f"Devices do not have unique names {non_unique}")
+
+    def connect_devices() -> Awaitable[None]:
+        coros = {
+            device.name: device.connect(
+                mock=mock, timeout=timeout, force_reconnect=force_reconnect
             )
-        ]
-    )
+            for device in devices
+        }
+        return wait_for_connection(**coros)
+
+    (connect_task,) = yield from bps.wait_for([connect_devices])
 
     if connect_task and connect_task.exception() is not None:
         raise connect_task.exception()

ophyd_async/tango/base_devices/_base_device.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 from typing import TypeVar
-from unittest.mock import Mock
 
 from ophyd_async.core import Device, DeviceConnector, DeviceFiller
+from ophyd_async.core._utils import LazyMock
 from ophyd_async.tango.signal import (
     TangoSignalBackend,
     infer_python_type,
@@ -117,41 +117,42 @@ class TangoDeviceConnector(DeviceConnector):
             list(self.filler.create_signals_from_annotations(filled=False))
             self.filler.check_created()
 
-    async def connect(
-        self, device: Device, mock: bool | Mock, timeout: float, force_reconnect: bool
-    ) -> None:
-        if mock:
-            # Make 2 entries for each DeviceVector
-            self.filler.create_device_vector_entries_to_mock(2)
+    async def connect_mock(self, device: Device, mock: LazyMock):
+        # Make 2 entries for each DeviceVector
+        self.filler.create_device_vector_entries_to_mock(2)
+        # Set the name of the device to name all children
+        device.set_name(device.name)
+        return await super().connect_mock(device, mock)
+
+    async def connect_real(self, device: Device, timeout: float, force_reconnect: bool):
+        if self.trl and self.proxy is None:
+            self.proxy = await AsyncDeviceProxy(self.trl)
+        elif self.proxy and not self.trl:
+            self.trl = self.proxy.name()
         else:
-            if self.trl and self.proxy is None:
-                self.proxy = await AsyncDeviceProxy(self.trl)
-            elif self.proxy and not self.trl:
-                self.trl = self.proxy.name()
-            else:
-                raise TypeError("Neither proxy nor trl supplied")
-
-            children = sorted(
-                set()
-                .union(self.proxy.get_attribute_list())
-                .union(self.proxy.get_command_list())
-            )
-            for name in children:
-                # TODO: strip attribute name
-                full_trl = f"{self.trl}/{name}"
-                signal_type = await infer_signal_type(full_trl, self.proxy)
-                if signal_type:
-                    backend = self.filler.fill_child_signal(name, signal_type)
-                    backend.datatype = await infer_python_type(full_trl, self.proxy)
-                    backend.set_trl(full_trl)
-                    if polling := self._signal_polling.get(name, ()):
-                        backend.set_polling(*polling)
-                        backend.allow_events(False)
-                    elif self._polling[0]:
-                        backend.set_polling(*self._polling)
-                        backend.allow_events(False)
-            # Check that all the requested children have been filled
-            self.filler.check_filled(f"{self.trl}: {children}")
+            raise TypeError("Neither proxy nor trl supplied")
+
+        children = sorted(
+            set()
+            .union(self.proxy.get_attribute_list())
+            .union(self.proxy.get_command_list())
+        )
+        for name in children:
+            # TODO: strip attribute name
+            full_trl = f"{self.trl}/{name}"
+            signal_type = await infer_signal_type(full_trl, self.proxy)
+            if signal_type:
+                backend = self.filler.fill_child_signal(name, signal_type)
+                backend.datatype = await infer_python_type(full_trl, self.proxy)
+                backend.set_trl(full_trl)
+                if polling := self._signal_polling.get(name, ()):
+                    backend.set_polling(*polling)
+                    backend.allow_events(False)
+                elif self._polling[0]:
+                    backend.set_polling(*self._polling)
+                    backend.allow_events(False)
+        # Check that all the requested children have been filled
+        self.filler.check_filled(f"{self.trl}: {children}")
         # Set the name of the device to name all children
         device.set_name(device.name)
-        return await super().connect(device, mock, timeout, force_reconnect)
+        return await super().connect_real(device, timeout, force_reconnect)

{ophyd_async-0.8.0a3.dist-info → ophyd_async-0.8.0a5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.8.0a3
+Version: 0.8.0a5
 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

{ophyd_async-0.8.0a3.dist-info → ophyd_async-0.8.0a5.dist-info}/RECORD

@@ -1,26 +1,26 @@
 ophyd_async/__init__.py,sha256=tEfgj45lRItQ-_u8SRFPM-mpBh3gWvHXr3emhiJJG_M,225
 ophyd_async/__main__.py,sha256=n_U4O9bgm97OuboUB_9eK7eFiwy8BZSgXJ0OzbE0DqU,481
-ophyd_async/_version.py,sha256=7HtuNUHmvgApFDFxIXlpPtAL7GP25idINU4Fd3AJSWE,413
+ophyd_async/_version.py,sha256=SQdFsQ53whTNOERBL9cmDWrar7r4kVAXQthVKIJB7mU,413
 ophyd_async/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/core/__init__.py,sha256=0UUwdcqeXFVxGDBLIbZkA5cZx4rbqdud6n4rCfcrpIY,4253
+ophyd_async/core/__init__.py,sha256=JBKq2w50jBjxg_2KRL1jXnIzETaj8dPOD47_prgtotU,4283
 ophyd_async/core/_detector.py,sha256=bKLekM2J3GzLXsKwe8qXQjNP_sAVsa8EtwFEWD-8MeA,14307
-ophyd_async/core/_device.py,sha256=AJvqPRfN4LOSVptPC9hyyabH2gBUFMLMNpugWsP501E,11019
+ophyd_async/core/_device.py,sha256=ygXxDKiTO43qDnLeLzrKKyABwlrfGvSVii7PHyCIjHg,12074
 ophyd_async/core/_device_filler.py,sha256=Nw-DUyuXYpvt4mmCAQaNVA0LFBBaPK84ubZo3bR39Ak,11407
 ophyd_async/core/_device_save_loader.py,sha256=OViN9_LWNOLuajzrHDKYEqd5I47u5npQACdGceKcIGY,8375
 ophyd_async/core/_flyer.py,sha256=us5z6MNGCvIfgPDTmFTxNERSP37g0WVRkRD0Z2JiMgM,1701
 ophyd_async/core/_hdf_dataset.py,sha256=wW_OL8OYLGOsE01ny3hGaapOrxK7BzhWTxKgz8CIXK0,2492
 ophyd_async/core/_log.py,sha256=UbL9AtnHVUg7r9LofzgmuKEtBESy03usCp7ejmDltG4,3679
-ophyd_async/core/_mock_signal_backend.py,sha256=E8YMLJJyAt8UAwX-5PMQCuAuHuVVs5ko7vJtY5qR9P8,2656
-ophyd_async/core/_mock_signal_utils.py,sha256=i7CCFeB6JkTpdAe32Jtap2nrvFL-gbz_3zrnlK7Lbow,5139
+ophyd_async/core/_mock_signal_backend.py,sha256=8Upnz6QrSigeDXemjZ-jB4sV2yIPUzid-6GOfTZ-7Io,2805
+ophyd_async/core/_mock_signal_utils.py,sha256=YeKjStClwp1etlmHMx1tb_VV1GjeFPg83Hkq7-YPkpg,5306
 ophyd_async/core/_protocol.py,sha256=MuYRqSfakdry9RllX7G9UTzp4lw3eDjtkdGPpnbNb34,4040
 ophyd_async/core/_providers.py,sha256=ff9ZT5-PZ6rhTTdE-q8w9l_k9DuZqLWLebsKZLeJ0Ds,7112
 ophyd_async/core/_readable.py,sha256=7FxqxhAT1wBQqOEivgnY731zA9QoK1Tt-ZGcH7GBOXM,10623
-ophyd_async/core/_signal.py,sha256=4Umj1EXgz89ZO1Ej-b5TEkmr72pdw3Jbyk-nIsYIYpo,20011
+ophyd_async/core/_signal.py,sha256=IpOyYu1IqpX8sFs9_CLUd1LuFWgAqEaFZgA12BG5tfM,19897
 ophyd_async/core/_signal_backend.py,sha256=YWPgLSPbfPnWIUDHvP1ArCVK8zKXJxzzbloqQe_ucCI,5040
-ophyd_async/core/_soft_signal_backend.py,sha256=VBemKbSM397zhtjm6zLKozhJ8cY3XhDu42OagBc_d64,5663
+ophyd_async/core/_soft_signal_backend.py,sha256=w9zzD4eoD9SsJpORXNSaFOLJrD6biYBbCSVAybLa_7k,5926
 ophyd_async/core/_status.py,sha256=OUKhblRQ4KU5PDsWbpvYduM7G60JMk1NqeV4eqyPtKc,5131
 ophyd_async/core/_table.py,sha256=ZToBVmAPDmhrVDgjx0f8SErxVdKhvGdGwQ-fXxGCtN8,5386
-ophyd_async/core/_utils.py,sha256=agOw4xTv2NFPfywDUkY_NYT2GNXI6p7GGs08z0H51jk,7548
+ophyd_async/core/_utils.py,sha256=wzzGL7yPAMuPueGOG1cpTgh0vho5YxI86m8SSX7Z9hw,9494
 ophyd_async/epics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ophyd_async/epics/motor.py,sha256=pujJXV_vslvo3AxsVySTAEoFuduuv5Hp6sz8aRvIbeQ,8792
 ophyd_async/epics/signal.py,sha256=hJCGIIWjRVhjEHkeL1I_oPEaaN7dDFKmm7G7ZmgoTYQ,219
@@ -32,7 +32,7 @@ ophyd_async/epics/adcore/__init__.py,sha256=3wMOyFGaq1X61LqK4iY4pq-m_BjhOgYZD2-m
 ophyd_async/epics/adcore/_core_io.py,sha256=ZQjRLdpFMVS9kwEm5LAh60pxiy7XWyYtc2TzEvCEVYM,6076
 ophyd_async/epics/adcore/_core_logic.py,sha256=JjrSmKErRFSv1C98or1Upwi01k3NWDRMi2fPHVWMmWw,3561
 ophyd_async/epics/adcore/_hdf_writer.py,sha256=eWT9SH7uegf9rpCWRmVCZTsOxF1drPaOAMmoXm99mVk,7215
-ophyd_async/epics/adcore/_single_trigger.py,sha256=tu1kZ1zsqgL0PM3ibmnxabNUA3gXaluQ6JW5C093tYc,1177
+ophyd_async/epics/adcore/_single_trigger.py,sha256=7SzmadatWk4zXIweRIhVX5odc__ZZKuGicL7vlW0JbY,1208
 ophyd_async/epics/adcore/_utils.py,sha256=MZBKeSPIRzyo6f84MpzPp28KwOLa9qgrkMIFc618wOE,3932
 ophyd_async/epics/adkinetix/__init__.py,sha256=cvnwOqbvEENf70eFp6bPGwayP0u14UTIhs3WiZEcF_Q,262
 ophyd_async/epics/adkinetix/_kinetix.py,sha256=JsQVc4d7lRCnVObJlM775hHLfp3rYRSRgOoIyRvrSek,1184
@@ -50,11 +50,11 @@ ophyd_async/epics/advimba/_vimba.py,sha256=E_RJ0uJQt-RWAY7uFTNkHaOdGYS5sa7ZbRgAe
 ophyd_async/epics/advimba/_vimba_controller.py,sha256=Ej7irxTab9cfjmqz4G4Zxv3CjhJw_eRmIb3E62YWh6g,2226
 ophyd_async/epics/advimba/_vimba_io.py,sha256=F3KUzMN-GMe637za-iRVGGTt8v9F1a79fRcl3MCkfXA,1864
 ophyd_async/epics/core/__init__.py,sha256=8NoQxEEc2Ny_L9nrD2fnGSf_2gJr1wCR1LwUeLNcIJo,588
-ophyd_async/epics/core/_aioca.py,sha256=318lw_dGWnckgyQ1f4K8QeX_KVOD4idzWX8sx2jbnyk,11625
+ophyd_async/epics/core/_aioca.py,sha256=iQWiHWYbMJLa7qeBrCz4_e16Y8A-NYYi6oYNi8oOFVY,11617
 ophyd_async/epics/core/_epics_connector.py,sha256=n1FlQYui8HdobPxaX3VAflrzi2UT7QCe3cFasssmVLw,1789
 ophyd_async/epics/core/_epics_device.py,sha256=kshNiKQhevsL2OZXa-r093L_sQGvGK_0J4PWVLg3Eqw,437
-ophyd_async/epics/core/_p4p.py,sha256=Ap_WVWCa4Eb44i50bxjy8qS-n8AUKTaLbFNq5eZZk0w,14619
-ophyd_async/epics/core/_pvi_connector.py,sha256=D4IM_SiNkUEe01DsstTX-s2XEgT3X-jspGmZePSCYZE,3577
+ophyd_async/epics/core/_p4p.py,sha256=S6zXXApRF0454aOcxUI_cd7Y7tXiOnss_ODhjjk0PMo,14691
+ophyd_async/epics/core/_pvi_connector.py,sha256=Rjc8g3Rdny_O-4JxhoCpD4L7XWIRq-lnGHXKpsIUrSU,3621
 ophyd_async/epics/core/_signal.py,sha256=jHdMXV1-0bd7PC8XV32Sso1xgubZVDhWFNsWV-UuamQ,4642
 ophyd_async/epics/core/_util.py,sha256=6CCWDfp54WeBIJdGjg_YBVZTKoNjponWyykMmLPrj7U,1820
 ophyd_async/epics/demo/__init__.py,sha256=wCrgemEo-zR4TTvaqCKnQ-AIUHorotV5jhftbq1tXz0,1368
@@ -74,12 +74,12 @@ ophyd_async/fastcs/panda/__init__.py,sha256=_o7n7ckoTM6hTRHpLphpL7r_9sADE59MRNM0
 ophyd_async/fastcs/panda/_block.py,sha256=STQo6NJAqIVfxyMf-2pxINPyr9_nKtXSdicp92a25xo,1709
 ophyd_async/fastcs/panda/_control.py,sha256=61vcJMjYQiUGAM5J0SfkfthFs7U28m9Pe9mgmGGf0-w,1021
 ophyd_async/fastcs/panda/_hdf_panda.py,sha256=WdgWgdrU2yT4keH70VG-ZBVOmT-IpKVyukEuKk7QnJs,1049
-ophyd_async/fastcs/panda/_table.py,sha256=8XkfpdZETflzoZE4qB5Y5ySi8JFxxZulDszVccgY_w4,2293
+ophyd_async/fastcs/panda/_table.py,sha256=5YyAfsl3H7kxH3bDjUKHuH9DyrWQmAn9dv-v0NYzFNo,2289
 ophyd_async/fastcs/panda/_trigger.py,sha256=forImtdnDnaZ0KKhqSxCqwHWXq13SJ4mn9wdM4yqNLY,3056
 ophyd_async/fastcs/panda/_utils.py,sha256=NdvzdKy0SOG1eCVMQo_nwRXpBo0wyi6lM5Xw3HvssOw,508
 ophyd_async/fastcs/panda/_writer.py,sha256=wDN6uWX1ENofmI3JBXJ7_CGooI7WsZP-JJQrRiSc6sM,6000
 ophyd_async/plan_stubs/__init__.py,sha256=wjpEj_BoBZJ9x2fhUPY6BzWMqyYH96JrBlJvV7frdN4,524
-ophyd_async/plan_stubs/_ensure_connected.py,sha256=MIn-aWKiaGI0k7ac-_Ca40uouoGsyRX1gAHY-A-ifGI,750
+ophyd_async/plan_stubs/_ensure_connected.py,sha256=uoqfAzghjifdfD_JM860TvMvj9T2Y12nKPvtI5l6zZc,1021
 ophyd_async/plan_stubs/_fly.py,sha256=WxghBAHsF-8xFrILCm44jeHIu9udLhm-tj4JXd9kZjY,6208
 ophyd_async/plan_stubs/_nd_attributes.py,sha256=TVfy3bhnrLFBXZ6b2bREBj0LzEviEGzuGvgWK3I7tII,2198
 ophyd_async/sim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -93,7 +93,7 @@ ophyd_async/sim/demo/_pattern_detector/_pattern_generator.py,sha256=gP0Q1-1p_3KO
 ophyd_async/sim/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ophyd_async/tango/__init__.py,sha256=2XxSpJWvvAlCs0GLPv6sEnUUD40fWq9OzKuiBEZ_MEs,861
 ophyd_async/tango/base_devices/__init__.py,sha256=fbn1-rfK8MCErpSmjAJuQioDikbjOobd4sDvAB9Xupw,157
-ophyd_async/tango/base_devices/_base_device.py,sha256=5Jt3UXIK1wNlKGnlGcKthigHBoLQ-MX7tzq4J3QY-_8,5968
+ophyd_async/tango/base_devices/_base_device.py,sha256=3GIkU1bUyunA9uTBsEtANmlJBo4WCgQmAWYbCRcjoXM,6016
 ophyd_async/tango/base_devices/_tango_readable.py,sha256=J-XeR2fmQU5RTdsNhRvzNPJD8xZRVJ6-qXt09vfpVtI,951
 ophyd_async/tango/demo/__init__.py,sha256=_j-UicTnckuIBp8PnieFMOMnLFGivnaKdmo9o0hYtzc,256
 ophyd_async/tango/demo/_counter.py,sha256=neKkuepWfpBxMOPnnHJ79SHgwepymG4gTDVacuHE6fA,1134
@@ -104,9 +104,9 @@ ophyd_async/tango/demo/_tango/_servers.py,sha256=MwkkoZWJQm_cgafCBBXeQfwyAiOgU8c
 ophyd_async/tango/signal/__init__.py,sha256=-_wBvhSPb58h_XSeGVaJ6gMFOY8TQNsVYfZxQuxGB1c,750
 ophyd_async/tango/signal/_signal.py,sha256=72iOxCt6HkyaYPgE402h5fd1KryyVUarR0exV2A3UbU,6277
 ophyd_async/tango/signal/_tango_transport.py,sha256=DVTdLu8C19k-QzYaKUzFK2WMbaSd6dIO77k99ugD8U4,28990
-ophyd_async-0.8.0a3.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.8.0a3.dist-info/METADATA,sha256=tAf70XFrRZAkgiqGePl9EqzyGRpYsKEh3Jz2-_3qj5w,6708
-ophyd_async-0.8.0a3.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-ophyd_async-0.8.0a3.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
-ophyd_async-0.8.0a3.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.8.0a3.dist-info/RECORD,,
+ophyd_async-0.8.0a5.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.8.0a5.dist-info/METADATA,sha256=0uu4GmEt1a33pHw4Oa5BhF22ns92xsqC_0wNmg3nkM0,6708
+ophyd_async-0.8.0a5.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+ophyd_async-0.8.0a5.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
+ophyd_async-0.8.0a5.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.8.0a5.dist-info/RECORD,,

{ophyd_async-0.8.0a3.dist-info → ophyd_async-0.8.0a5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (75.5.0)
 Root-Is-Purelib: true
 Tag: py3-none-any