ophyd-async 0.8.0a4__tar.gz → 0.8.0a5__tar.gz

{ophyd_async-0.8.0a4 → ophyd_async-0.8.0a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.8.0a4
+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.0a4 → ophyd_async-0.8.0a5}/src/ophyd_async/_version.py

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

{ophyd_async-0.8.0a4 → ophyd_async-0.8.0a5}/src/ophyd_async/core/_device.py

@@ -37,8 +37,14 @@ class DeviceConnector:
 
     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():
-            await child_device.connect(mock=mock.child(name))
+            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``.
@@ -193,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-0.8.0a4 → ophyd_async-0.8.0a5}/src/ophyd_async/core/_signal.py

@@ -449,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)
@@ -462,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-0.8.0a4 → ophyd_async-0.8.0a5}/src/ophyd_async/core/_soft_signal_backend.py

@@ -5,7 +5,7 @@ from abc import abstractmethod
 from collections.abc import Sequence
 from dataclasses import dataclass
 from functools import lru_cache
-from typing import Any, Generic, get_origin
+from typing import Any, Generic, get_args, get_origin
 
 import numpy as np
 from bluesky.protocols import Reading
@@ -58,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)
@@ -98,7 +98,11 @@ def make_converter(datatype: type[SignalDatatype]) -> SoftConverter:
         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-0.8.0a4 → ophyd_async-0.8.0a5}/src/ophyd_async/core/_utils.py

@@ -2,18 +2,10 @@ 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
@@ -22,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):
@@ -70,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)
@@ -100,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]):
@@ -137,14 +149,7 @@ async def wait_for_connection(**coros: Awaitable[None]):
                 exceptions[name] = result
 
     if exceptions:
-        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,
-                )
-        raise NotConnected(exceptions)
+        raise NotConnected.with_other_exceptions_logged(exceptions)
 
 
 def get_dtype(datatype: type) -> np.dtype:

{ophyd_async-0.8.0a4 → ophyd_async-0.8.0a5}/src/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-0.8.0a4 → ophyd_async-0.8.0a5}/src/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-0.8.0a4 → ophyd_async-0.8.0a5}/src/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-0.8.0a5/src/ophyd_async/plan_stubs/_ensure_connected.py

@@ -0,0 +1,33 @@
+from collections.abc import Awaitable
+
+import bluesky.plan_stubs as bps
+
+from ophyd_async.core import DEFAULT_TIMEOUT, Device, LazyMock, wait_for_connection
+
+
+def ensure_connected(
+    *devices: Device,
+    mock: bool | LazyMock = False,
+    timeout: float = DEFAULT_TIMEOUT,
+    force_reconnect=False,
+):
+    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-0.8.0a4 → ophyd_async-0.8.0a5}/src/ophyd_async.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.8.0a4
+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.0a4 → ophyd_async-0.8.0a5}/src/ophyd_async.egg-info/SOURCES.txt

@@ -185,6 +185,7 @@ tests/core/test_device_save_loader.py
 tests/core/test_flyer.py
 tests/core/test_log.py
 tests/core/test_mock_signal_backend.py
+tests/core/test_observe.py
 tests/core/test_protocol.py
 tests/core/test_providers.py
 tests/core/test_readable.py

{ophyd_async-0.8.0a4 → ophyd_async-0.8.0a5}/tests/core/test_device.py

@@ -117,10 +117,15 @@ async def test_device_with_device_collector():
         parent = DummyDeviceGroup("parent")
 
     assert parent.name == "parent"
+    assert parent.parent is None
     assert parent.child1.name == "parent-child1"
+    assert parent.child1.parent == parent
     assert parent._child2.name == "parent-child2"
+    assert parent._child2.parent == parent
     assert parent.dict_with_children.name == "parent-dict_with_children"
+    assert parent.dict_with_children.parent == parent
     assert parent.dict_with_children[123].name == "parent-dict_with_children-123"
+    assert parent.dict_with_children[123].parent == parent.dict_with_children
     assert parent.child1.connected
     assert parent.dict_with_children[123].connected
 

{ophyd_async-0.8.0a4 → ophyd_async-0.8.0a5}/tests/core/test_device_save_loader.py

@@ -4,7 +4,6 @@ from typing import Any
 from unittest.mock import patch
 
 import numpy as np
-import numpy.typing as npt
 import pytest
 import yaml
 from bluesky.run_engine import RunEngine
@@ -71,17 +70,16 @@ class DummyDeviceGroupAllTypes(Device):
         self.pv_str: SignalRW = epics_signal_rw(str, "PV2")
         self.pv_enum_str: SignalRW = epics_signal_rw(MyEnum, "PV3")
         self.pv_enum: SignalRW = epics_signal_rw(MyEnum, "PV4")
-        self.pv_array_int8 = epics_signal_rw(npt.NDArray[np.int8], "PV5")
-        self.pv_array_uint8 = epics_signal_rw(npt.NDArray[np.uint8], "PV6")
-        self.pv_array_int16 = epics_signal_rw(npt.NDArray[np.int16], "PV7")
-        self.pv_array_uint16 = epics_signal_rw(npt.NDArray[np.uint16], "PV8")
-        self.pv_array_int32 = epics_signal_rw(npt.NDArray[np.int32], "PV9")
-        self.pv_array_uint32 = epics_signal_rw(npt.NDArray[np.uint32], "PV10")
-        self.pv_array_int64 = epics_signal_rw(npt.NDArray[np.int64], "PV11")
-        self.pv_array_uint64 = epics_signal_rw(npt.NDArray[np.uint64], "PV12")
-        self.pv_array_float32 = epics_signal_rw(npt.NDArray[np.float32], "PV13")
-        self.pv_array_float64 = epics_signal_rw(npt.NDArray[np.float64], "PV14")
-        self.pv_array_npstr = epics_signal_rw(npt.NDArray[np.str_], "PV15")
+        self.pv_array_int8 = epics_signal_rw(Array1D[np.int8], "PV5")
+        self.pv_array_uint8 = epics_signal_rw(Array1D[np.uint8], "PV6")
+        self.pv_array_int16 = epics_signal_rw(Array1D[np.int16], "PV7")
+        self.pv_array_uint16 = epics_signal_rw(Array1D[np.uint16], "PV8")
+        self.pv_array_int32 = epics_signal_rw(Array1D[np.int32], "PV9")
+        self.pv_array_uint32 = epics_signal_rw(Array1D[np.uint32], "PV10")
+        self.pv_array_int64 = epics_signal_rw(Array1D[np.int64], "PV11")
+        self.pv_array_uint64 = epics_signal_rw(Array1D[np.uint64], "PV12")
+        self.pv_array_float32 = epics_signal_rw(Array1D[np.float32], "PV13")
+        self.pv_array_float64 = epics_signal_rw(Array1D[np.float64], "PV14")
         self.pv_array_str = epics_signal_rw(Sequence[str], "PV16")
         self.pv_protocol_device_abstraction = epics_signal_rw(Table, "pva://PV17")
         super().__init__(name)
@@ -168,9 +166,6 @@ async def test_save_device_all_types(
         )
 
         await pv.set(data)
-    await device_all_types.pv_array_npstr.set(
-        np.array(["one", "two", "three"], dtype=np.str_),
-    )
     await device_all_types.pv_array_str.set(
         ["one", "two", "three"],
     )

ophyd_async-0.8.0a5/tests/core/test_observe.py

@@ -0,0 +1,90 @@
+import asyncio
+import time
+
+import pytest
+
+from ophyd_async.core import AsyncStatus, observe_value, soft_signal_r_and_setter
+
+
+async def test_observe_value_working_correctly():
+    sig, setter = soft_signal_r_and_setter(float)
+
+    async def tick():
+        for i in range(2):
+            await asyncio.sleep(0.01)
+            setter(i + 1)
+
+    recv = []
+    status = AsyncStatus(tick())
+    async for val in observe_value(sig, done_status=status):
+        recv.append(val)
+    assert recv == [0, 1, 2]
+    await status
+
+
+async def test_observe_value_times_out():
+    sig, setter = soft_signal_r_and_setter(float)
+
+    async def tick():
+        for i in range(5):
+            await asyncio.sleep(0.1)
+            setter(i + 1)
+
+    recv = []
+
+    async def watch():
+        async for val in observe_value(sig):
+            recv.append(val)
+
+    t = asyncio.create_task(tick())
+    start = time.time()
+    try:
+        with pytest.raises(asyncio.TimeoutError):
+            await asyncio.wait_for(watch(), timeout=0.2)
+        assert recv == [0, 1]
+        assert time.time() - start == pytest.approx(0.2, abs=0.05)
+    finally:
+        t.cancel()
+
+
+async def test_observe_value_times_out_with_busy_sleep():
+    sig, setter = soft_signal_r_and_setter(float)
+
+    async def tick():
+        for i in range(5):
+            await asyncio.sleep(0.1)
+            setter(i + 1)
+
+    recv = []
+
+    async def watch():
+        async for val in observe_value(sig):
+            time.sleep(0.15)
+            recv.append(val)
+
+    t = asyncio.create_task(tick())
+    start = time.time()
+    try:
+        with pytest.raises(asyncio.TimeoutError):
+            await asyncio.wait_for(watch(), timeout=0.2)
+        assert recv == [0, 1]
+        assert time.time() - start == pytest.approx(0.3, abs=0.05)
+    finally:
+        t.cancel()
+
+
+async def test_observe_value_times_out_with_no_external_task():
+    sig, setter = soft_signal_r_and_setter(float)
+
+    recv = []
+
+    async def watch():
+        async for val in observe_value(sig):
+            recv.append(val)
+            setter(val + 1)
+
+    start = time.time()
+    with pytest.raises(asyncio.TimeoutError):
+        await asyncio.wait_for(watch(), timeout=0.1)
+    assert recv
+    assert time.time() - start == pytest.approx(0.1, abs=0.05)

{ophyd_async-0.8.0a4 → ophyd_async-0.8.0a5}/tests/core/test_signal.py

@@ -5,6 +5,8 @@ import time
 from asyncio import Event
 from unittest.mock import ANY, Mock
 
+import numpy as np
+import numpy.typing as npt
 import pytest
 from bluesky.protocols import Reading
 
@@ -299,21 +301,35 @@ async def test_subscription_logs(caplog):
     assert "Closing subscription on source" in caplog.text
 
 
-async def test_signal_unknown_datatype():
-    class SomeClass:
-        def __init__(self):
-            self.some_attribute = "some_attribute"
+class SomeClass:
+    def __init__(self):
+        self.some_attribute = "some_attribute"
 
-        def some_function(self):
-            pass
+    def some_function(self):
+        pass
 
-    err_str = (
-        "Can't make converter for <class "
-        "'test_signal.test_signal_unknown_datatype.<locals>.SomeClass'>"
-    )
+
+@pytest.mark.parametrize(
+    "datatype,err",
+    [
+        (SomeClass, "Can't make converter for %s"),
+        (object, "Can't make converter for %s"),
+        (dict, "Can't make converter for %s"),
+        (npt.NDArray[np.float64], "Expected Array1D[dtype], got %s"),
+    ],
+)
+async def test_signal_unknown_datatype(datatype, err):
+    err_str = re.escape(err % datatype)
     with pytest.raises(TypeError, match=err_str):
-        await epics_signal_rw(SomeClass, "pva://mock_signal").connect(mock=True)
+        await epics_signal_rw(datatype, "pva://mock_signal").connect(mock=True)
     with pytest.raises(TypeError, match=err_str):
-        await epics_signal_rw(SomeClass, "ca://mock_signal").connect(mock=True)
+        await epics_signal_rw(datatype, "ca://mock_signal").connect(mock=True)
     with pytest.raises(TypeError, match=err_str):
-        soft_signal_rw(SomeClass)
+        soft_signal_rw(datatype)
+
+
+async def test_soft_signal_ndarray_can_change_dtype():
+    sig = soft_signal_rw(np.ndarray)
+    for dtype in (np.int32, np.float64):
+        await sig.set(np.arange(4, dtype=dtype))
+        assert (await sig.get_value()).dtype == dtype

{ophyd_async-0.8.0a4 → ophyd_async-0.8.0a5}/tests/core/test_soft_signal_backend.py

@@ -5,11 +5,11 @@ from collections.abc import Callable, Sequence
 from typing import Any
 
 import numpy as np
-import numpy.typing as npt
 import pytest
 from bluesky.protocols import Reading
 
 from ophyd_async.core import (
+    Array1D,
     SignalBackend,
     SoftSignalBackend,
     StrictEnum,
@@ -81,20 +81,17 @@ default_int_type = (
         (float, 0.0, 43.5, number_d, "<f8"),
         (str, "", "goodbye", string_d, "|S40"),
         (MyEnum, MyEnum.a, MyEnum.c, enum_d, "|S40"),
-        (npt.NDArray[np.int8], [], [-8, 3, 44], waveform_d, "|i1"),
-        (npt.NDArray[np.uint8], [], [218], waveform_d, "|u1"),
-        (npt.NDArray[np.int16], [], [-855], waveform_d, "<i2"),
-        (npt.NDArray[np.uint16], [], [5666], waveform_d, "<u2"),
-        (npt.NDArray[np.int32], [], [-2], waveform_d, "<i4"),
-        (npt.NDArray[np.uint32], [], [1022233], waveform_d, "<u4"),
-        (npt.NDArray[np.int64], [], [-3], waveform_d, "<i8"),
-        (npt.NDArray[np.uint64], [], [995444], waveform_d, "<u8"),
-        (npt.NDArray[np.float32], [], [1.0], waveform_d, "<f4"),
-        (npt.NDArray[np.float64], [], [0.2], waveform_d, "<f8"),
+        (Array1D[np.int8], [], [-8, 3, 44], waveform_d, "|i1"),
+        (Array1D[np.uint8], [], [218], waveform_d, "|u1"),
+        (Array1D[np.int16], [], [-855], waveform_d, "<i2"),
+        (Array1D[np.uint16], [], [5666], waveform_d, "<u2"),
+        (Array1D[np.int32], [], [-2], waveform_d, "<i4"),
+        (Array1D[np.uint32], [], [1022233], waveform_d, "<u4"),
+        (Array1D[np.int64], [], [-3], waveform_d, "<i8"),
+        (Array1D[np.uint64], [], [995444], waveform_d, "<u8"),
+        (Array1D[np.float32], [], [1.0], waveform_d, "<f4"),
+        (Array1D[np.float64], [], [0.2], waveform_d, "<f8"),
         (Sequence[str], [], ["nine", "ten"], waveform_d, "|S40"),
-        # Can't do long strings until https://github.com/epics-base/pva2pva/issues/17
-        # (str, "longstr", ls1, ls2, string_d),
-        # (str, "longstr2.VAL$", ls1, ls2, string_d),
     ],
 )
 async def test_soft_signal_backend_get_put_monitor(
@@ -135,7 +132,7 @@ async def test_soft_signal_backend_enum_value_equivalence():
 
 
 async def test_soft_signal_backend_with_numpy_typing():
-    soft_backend = SoftSignalBackend(npt.NDArray[np.float64])
+    soft_backend = SoftSignalBackend(Array1D[np.float64])
     await soft_backend.connect(timeout=1)
     array = await soft_backend.get_value()
     assert array.shape == (0,)

{ophyd_async-0.8.0a4 → ophyd_async-0.8.0a5}/tests/core/test_utils.py

@@ -173,6 +173,38 @@ async def test_error_handling_value_errors(caplog):
         assert f"signal {protocol}://A_NON_EXISTENT_SIGNAL timed out" in messages
 
 
+class BadDatatypeDevice(Device):
+    def __init__(self, name: str = "") -> None:
+        self.sig = epics_signal_rw(object, "", "")
+        super().__init__(name)
+
+
+async def test_error_handling_device_collector_mock():
+    with pytest.raises(NotConnected) as e:
+        async with DeviceCollector(mock=True):
+            device = BadDatatypeDevice()
+            device2 = BadDatatypeDevice()
+    expected_output = NotConnected(
+        {
+            "device": NotConnected(
+                {"sig": TypeError(f"Can't make converter for {object}")}
+            ),
+            "device2": NotConnected(
+                {"sig": TypeError(f"Can't make converter for {object}")}
+            ),
+        }
+    )
+    assert str(expected_output) == str(e.value)
+
+
+def test_introspecting_sub_errors():
+    sub_error1 = NotConnected("bad")
+    assert sub_error1.sub_errors == {}
+    sub_error2 = ValueError("very bad")
+    error = NotConnected({"child1": sub_error1, "child2": sub_error2})
+    assert error.sub_errors == {"child1": sub_error1, "child2": sub_error2}
+
+
 async def test_error_handling_device_collector(caplog):
     caplog.set_level(10)
     with pytest.raises(NotConnected) as e:

{ophyd_async-0.8.0a4 → ophyd_async-0.8.0a5}/tests/fastcs/panda/test_hdf_panda.py

@@ -47,7 +47,7 @@ async def mock_hdf_panda(tmp_path):
         mock_hdf_panda.data.datasets,
         DatasetTable(
             name=["x", "y"],
-            hdf5_type=[PandaHdf5DatasetType.UINT_32, PandaHdf5DatasetType.FLOAT_64],
+            dtype=[PandaHdf5DatasetType.UINT_32, PandaHdf5DatasetType.FLOAT_64],
         ),
     )
 

{ophyd_async-0.8.0a4 → ophyd_async-0.8.0a5}/tests/fastcs/panda/test_writer.py

@@ -27,11 +27,11 @@ from ophyd_async.fastcs.panda import (
 TABLES = [
     DatasetTable(
         name=[],
-        hdf5_type=[],
+        dtype=[],
     ),
     DatasetTable(
         name=["x"],
-        hdf5_type=[PandaHdf5DatasetType.UINT_32],
+        dtype=[PandaHdf5DatasetType.UINT_32],
     ),
     DatasetTable(
         name=[
@@ -40,7 +40,7 @@ TABLES = [
             "y_min",
             "y_max",
         ],
-        hdf5_type=[
+        dtype=[
             PandaHdf5DatasetType.UINT_32,
             PandaHdf5DatasetType.FLOAT_64,
             PandaHdf5DatasetType.FLOAT_64,
@@ -82,7 +82,7 @@ async def mock_panda(panda_t):
         mock_panda.data.datasets,
         DatasetTable(
             name=[],
-            hdf5_type=[],
+            dtype=[],
         ),
     )
 

{ophyd_async-0.8.0a4 → ophyd_async-0.8.0a5}/tests/plan_stubs/test_ensure_connected.py

@@ -1,3 +1,5 @@
+import re
+
 import pytest
 
 from ophyd_async.core import Device, NotConnected, soft_signal_rw
@@ -36,3 +38,15 @@ def test_ensure_connected(RE):
         assert device2.signal._mock is not None
 
     RE(connect_with_mocking())
+
+
+def test_ensure_connected_fails_for_non_unique_device_names(RE):
+    d1 = Device("dupe")
+    d2 = Device("dupe")
+    d3 = Device("ok")
+    non_unique = {d1: "dupe", d2: "dupe"}
+    with pytest.raises(
+        ValueError,
+        match=re.escape(f"Devices do not have unique names {non_unique}"),
+    ):
+        RE(ensure_connected(d1, d2, d3))

{ophyd_async-0.8.0a4 → ophyd_async-0.8.0a5}/tests/test_data/test_yaml_save.yml

@@ -24,7 +24,6 @@
   pv_array_int32: [-2147483648, 2147483647, 0, 1, 2, 3, 4]
   pv_array_int64: [-9223372036854775808, 9223372036854775807, 0, 1, 2, 3, 4]
   pv_array_int8: [-128, 127, 0, 1, 2, 3, 4]
-  pv_array_npstr: [one, two, three]
   pv_array_str:
     - one
     - two

ophyd_async-0.8.0a4/src/ophyd_async/plan_stubs/_ensure_connected.py

@@ -1,26 +0,0 @@
-import bluesky.plan_stubs as bps
-
-from ophyd_async.core import DEFAULT_TIMEOUT, Device, LazyMock, wait_for_connection
-
-
-def ensure_connected(
-    *devices: Device,
-    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
-                }
-            )
-        ]
-    )
-
-    if connect_task and connect_task.exception() is not None:
-        raise connect_task.exception()