ophyd-async 0.3.1__tar.gz → 0.3.2__tar.gz

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3.1
+Version: 0.3.2
 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
@@ -41,7 +41,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: networkx>=2.0
-Requires-Dist: numpy
+Requires-Dist: numpy<2.0.0
 Requires-Dist: packaging
 Requires-Dist: pint
 Requires-Dist: bluesky>=1.13.0a3

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/pyproject.toml

@@ -13,7 +13,7 @@ classifiers = [
 description = "Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango"
 dependencies = [
     "networkx>=2.0",
-    "numpy",
+    "numpy<2.0.0",
     "packaging",
     "pint",
     "bluesky>=1.13.0a3",

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/src/ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.1'
-__version_tuple__ = version_tuple = (0, 3, 1)
+__version__ = version = '0.3.2'
+__version_tuple__ = version_tuple = (0, 3, 2)

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/src/ophyd_async/core/signal.py

@@ -31,7 +31,7 @@ from ophyd_async.protocols import AsyncConfigurable, AsyncReadable, AsyncStageab
 from .async_status import AsyncStatus
 from .device import Device
 from .signal_backend import SignalBackend
-from .soft_signal_backend import SoftSignalBackend
+from .soft_signal_backend import SignalMetadata, SoftSignalBackend
 from .utils import DEFAULT_TIMEOUT, CalculatableTimeout, CalculateTimeout, Callback, T
 
 
@@ -272,9 +272,17 @@ def soft_signal_rw(
     datatype: Optional[Type[T]] = None,
     initial_value: Optional[T] = None,
     name: str = "",
+    units: str | None = None,
+    precision: int | None = None,
 ) -> SignalRW[T]:
-    """Creates a read-writable Signal with a SoftSignalBackend"""
-    signal = SignalRW(SoftSignalBackend(datatype, initial_value), name=name)
+    """Creates a read-writable Signal with a SoftSignalBackend.
+    May pass metadata, which are propagated into describe.
+    """
+    metadata = SignalMetadata(units=units, precision=precision)
+    signal = SignalRW(
+        SoftSignalBackend(datatype, initial_value, metadata=metadata),
+        name=name,
+    )
     return signal
 
 
@@ -282,12 +290,16 @@ def soft_signal_r_and_setter(
     datatype: Optional[Type[T]] = None,
     initial_value: Optional[T] = None,
     name: str = "",
+    units: str | None = None,
+    precision: int | None = None,
 ) -> Tuple[SignalR[T], Callable[[T], None]]:
     """Returns a tuple of a read-only Signal and a callable through
-    which the signal can be internally modified within the device. Use
-    soft_signal_rw if you want a device that is externally modifiable
+    which the signal can be internally modified within the device.
+    May pass metadata, which are propagated into describe.
+    Use soft_signal_rw if you want a device that is externally modifiable
     """
-    backend = SoftSignalBackend(datatype, initial_value)
+    metadata = SignalMetadata(units=units, precision=precision)
+    backend = SoftSignalBackend(datatype, initial_value, metadata=metadata)
     signal = SignalR(backend, name=name)
 
     return (signal, backend.set_value)

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/src/ophyd_async/core/soft_signal_backend.py

@@ -5,7 +5,7 @@ import time
 from collections import abc
 from dataclasses import dataclass
 from enum import Enum
-from typing import Dict, Generic, Optional, Type, Union, cast, get_origin
+from typing import Dict, Generic, Optional, Type, TypedDict, Union, cast, get_origin
 
 import numpy as np
 from bluesky.protocols import DataKey, Dtype, Reading
@@ -21,6 +21,11 @@ primitive_dtypes: Dict[type, Dtype] = {
 }
 
 
+class SignalMetadata(TypedDict):
+    units: str | None = None
+    precision: int | None = None
+
+
 class SoftConverter(Generic[T]):
     def value(self, value: T) -> T:
         return value
@@ -35,7 +40,8 @@ class SoftConverter(Generic[T]):
             alarm_severity=-1 if severity > 2 else severity,
         )
 
-    def get_datakey(self, source: str, value) -> DataKey:
+    def get_datakey(self, source: str, value, **metadata) -> DataKey:
+        dk = {"source": source, "shape": [], **metadata}
         dtype = type(value)
         if np.issubdtype(dtype, np.integer):
             dtype = int
@@ -44,8 +50,8 @@ class SoftConverter(Generic[T]):
         assert (
             dtype in primitive_dtypes
         ), f"invalid converter for value of type {type(value)}"
-        dtype_name = primitive_dtypes[dtype]
-        return {"source": source, "dtype": dtype_name, "shape": []}
+        dk["dtype"] = primitive_dtypes[dtype]
+        return dk
 
     def make_initial_value(self, datatype: Optional[Type[T]]) -> T:
         if datatype is None:
@@ -55,8 +61,8 @@ class SoftConverter(Generic[T]):
 
 
 class SoftArrayConverter(SoftConverter):
-    def get_datakey(self, source: str, value) -> DataKey:
-        return {"source": source, "dtype": "array", "shape": [len(value)]}
+    def get_datakey(self, source: str, value, **metadata) -> DataKey:
+        return {"source": source, "dtype": "array", "shape": [len(value)], **metadata}
 
     def make_initial_value(self, datatype: Optional[Type[T]]) -> T:
         if datatype is None:
@@ -78,9 +84,15 @@ class SoftEnumConverter(SoftConverter):
         else:
             return self.enum_class(value)
 
-    def get_datakey(self, source: str, value) -> DataKey:
+    def get_datakey(self, source: str, value, **metadata) -> DataKey:
         choices = [e.value for e in self.enum_class]
-        return {"source": source, "dtype": "string", "shape": [], "choices": choices}  # type: ignore
+        return {
+            "source": source,
+            "dtype": "string",
+            "shape": [],
+            "choices": choices,
+            **metadata,
+        }
 
     def make_initial_value(self, datatype: Optional[Type[T]]) -> T:
         if datatype is None:
@@ -114,9 +126,11 @@ class SoftSignalBackend(SignalBackend[T]):
         self,
         datatype: Optional[Type[T]],
         initial_value: Optional[T] = None,
+        metadata: SignalMetadata = None,
     ) -> None:
         self.datatype = datatype
         self._initial_value = initial_value
+        self._metadata = metadata or {}
         self.converter: SoftConverter = make_converter(datatype)
         if self._initial_value is None:
             self._initial_value = self.converter.make_initial_value(self.datatype)
@@ -155,7 +169,7 @@ class SoftSignalBackend(SignalBackend[T]):
             self.callback(reading, self._value)
 
     async def get_datakey(self, source: str) -> DataKey:
-        return self.converter.get_datakey(source, self._value)
+        return self.converter.get_datakey(source, self._value, **self._metadata)
 
     async def get_reading(self) -> Reading:
         return self.converter.reading(self._value, self._timestamp, self._severity)

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/src/ophyd_async/epics/_backend/_aioca.py

@@ -88,9 +88,11 @@ def _data_key_from_augmented_value(
 
 def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
     def get_limits(limit: str) -> LimitPair:
-        low = getattr(value, f"lower_{limit}_limit", None)
-        high = getattr(value, f"upper_{limit}_limit", None)
-        return LimitPair(low=low, high=high)
+        low = getattr(value, f"lower_{limit}_limit", nan)
+        high = getattr(value, f"upper_{limit}_limit", nan)
+        return LimitPair(
+            low=None if isnan(low) else low, high=None if isnan(high) else high
+        )
 
     return Limits(
         alarm=get_limits("alarm"),

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/src/ophyd_async/panda/_common_blocks.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from enum import Enum
 
 from ophyd_async.core import Device, DeviceVector, SignalR, SignalRW
-from ophyd_async.panda._table import SeqTable
+from ophyd_async.panda._table import DatasetTable, SeqTable
 
 
 class DataBlock(Device):
@@ -14,6 +14,7 @@ class DataBlock(Device):
     num_captured: SignalR[int]
     capture: SignalRW[bool]
     flush_period: SignalRW[float]
+    datasets: SignalR[DatasetTable]
 
 
 class PulseBlock(Device):

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/src/ophyd_async/panda/_hdf_panda.py

@@ -28,9 +28,7 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
         create_children_from_annotations(self)
         controller = PandaPcapController(pcap=self.pcap)
         writer = PandaHDFWriter(
-            prefix=prefix,
             directory_provider=directory_provider,
-            name_provider=lambda: name,
             panda_device=self,
         )
         super().__init__(

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/src/ophyd_async/panda/_table.py

@@ -6,6 +6,16 @@ import numpy as np
 import numpy.typing as npt
 
 
+class PandaHdf5DatasetType(str, Enum):
+    FLOAT_64 = "float64"
+    UINT_32 = "uint32"
+
+
+class DatasetTable(TypedDict):
+    name: npt.NDArray[np.str_]
+    hdf5_type: Sequence[PandaHdf5DatasetType]
+
+
 class SeqTrigger(str, Enum):
     IMMEDIATE = "Immediate"
     BITA_0 = "BITA=0"

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/src/ophyd_async/panda/writers/_hdf_writer.py

@@ -1,8 +1,6 @@
 import asyncio
-from dataclasses import dataclass
-from enum import Enum
 from pathlib import Path
-from typing import Any, AsyncGenerator, AsyncIterator, Dict, List, Optional
+from typing import AsyncGenerator, AsyncIterator, Dict, List, Optional
 
 from bluesky.protocols import DataKey, StreamAsset
 from p4p.client.thread import Context
@@ -10,98 +8,25 @@ from p4p.client.thread import Context
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     DetectorWriter,
-    Device,
     DirectoryProvider,
-    NameProvider,
-    SignalR,
     wait_for_value,
 )
 from ophyd_async.core.signal import observe_value
-from ophyd_async.panda import CommonPandaBlocks
 
+from .._common_blocks import CommonPandaBlocks
 from ._panda_hdf_file import _HDFDataset, _HDFFile
 
 
-class Capture(str, Enum):
-    # Capture signals for the HDF Panda
-    No = "No"
-    Value = "Value"
-    Diff = "Diff"
-    Sum = "Sum"
-    Mean = "Mean"
-    Min = "Min"
-    Max = "Max"
-    MinMax = "Min Max"
-    MinMaxMean = "Min Max Mean"
-
-
-def get_capture_signals(
-    block: Device, path_prefix: Optional[str] = ""
-) -> Dict[str, SignalR]:
-    """Get dict mapping a capture signal's name to the signal itself"""
-    if not path_prefix:
-        path_prefix = ""
-    signals: Dict[str, SignalR[Any]] = {}
-    for attr_name, attr in block.children():
-        # Capture signals end in _capture, but num_capture is a red herring
-        if attr_name == "num_capture":
-            continue
-        dot_path = f"{path_prefix}{attr_name}"
-        if isinstance(attr, SignalR) and attr_name.endswith("_capture"):
-            signals[dot_path] = attr
-        attr_signals = get_capture_signals(attr, path_prefix=dot_path + ".")
-        signals.update(attr_signals)
-    return signals
-
-
-@dataclass
-class CaptureSignalWrapper:
-    signal: SignalR
-    capture_type: Capture
-
-
-# This should return a dictionary which contains a dict, containing the Capture
-# signal object, and the value of that signal
-async def get_signals_marked_for_capture(
-    capture_signals: Dict[str, SignalR],
-) -> Dict[str, CaptureSignalWrapper]:
-    # Read signals to see if they should be captured
-    do_read = [signal.get_value() for signal in capture_signals.values()]
-
-    signal_values = await asyncio.gather(*do_read)
-
-    assert len(signal_values) == len(
-        capture_signals
-    ), "Length of read signals are different to length of signals"
-
-    signals_to_capture: Dict[str, CaptureSignalWrapper] = {}
-    for signal_path, signal_object, signal_value in zip(
-        capture_signals.keys(), capture_signals.values(), signal_values
-    ):
-        signal_path = signal_path.replace("_capture", "")
-        if (signal_value in iter(Capture)) and (signal_value != Capture.No):
-            signals_to_capture[signal_path] = CaptureSignalWrapper(
-                signal_object,
-                signal_value,
-            )
-
-    return signals_to_capture
-
-
 class PandaHDFWriter(DetectorWriter):
     _ctxt: Optional[Context] = None
 
     def __init__(
         self,
-        prefix: str,
         directory_provider: DirectoryProvider,
-        name_provider: NameProvider,
         panda_device: CommonPandaBlocks,
     ) -> None:
         self.panda_device = panda_device
-        self._prefix = prefix
         self._directory_provider = directory_provider
-        self._name_provider = name_provider
         self._datasets: List[_HDFDataset] = []
         self._file: Optional[_HDFFile] = None
         self._multiplier = 1
@@ -110,14 +35,9 @@ class PandaHDFWriter(DetectorWriter):
     async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
         """Retrieve and get descriptor of all PandA signals marked for capture"""
 
-        # Get capture PVs by looking at panda. Gives mapping of dotted attribute path
-        # to Signal object
-        self.capture_signals = get_capture_signals(self.panda_device)
-
         # Ensure flushes are immediate
         await self.panda_device.data.flush_period.set(0)
 
-        to_capture = await get_signals_marked_for_capture(self.capture_signals)
         self._file = None
         info = self._directory_provider()
         # Set the initial values
@@ -133,36 +53,21 @@ class PandaHDFWriter(DetectorWriter):
 
         # Wait for it to start, stashing the status that tells us when it finishes
         await self.panda_device.data.capture.set(True)
-        name = self._name_provider()
         if multiplier > 1:
             raise ValueError(
                 "All PandA datasets should be scalar, multiplier should be 1"
             )
-        self._datasets = []
-        for attribute_path, capture_signal in to_capture.items():
-            split_path = attribute_path.split(".")
-            signal_name = split_path[-1]
-            # Get block names from numbered blocks, eg INENC[1]
-            block_name = (
-                f"{split_path[-3]}{split_path[-2]}"
-                if split_path[-2].isnumeric()
-                else split_path[-2]
-            )
 
-            for suffix in capture_signal.capture_type.split(" "):
-                self._datasets.append(
-                    _HDFDataset(
-                        name,
-                        block_name,
-                        f"{name}-{block_name}-{signal_name}-{suffix}",
-                        f"{block_name}-{signal_name}".upper() + f"-{suffix}",
-                        [1],
-                        multiplier=1,
-                    )
-                )
+        return await self._describe()
 
+    async def _describe(self) -> Dict[str, DataKey]:
+        """
+        Return a describe based on the datasets PV
+        """
+
+        await self._update_datasets()
         describe = {
-            ds.name: DataKey(
+            ds.data_key: DataKey(
                 source=self.panda_device.data.hdf_directory.source,
                 shape=ds.shape,
                 dtype="array" if ds.shape != [1] else "number",
@@ -172,6 +77,18 @@ class PandaHDFWriter(DetectorWriter):
         }
         return describe
 
+    async def _update_datasets(self) -> None:
+        """
+        Load data from the datasets PV on the panda, update internal
+        representation of datasets that the panda will write.
+        """
+
+        capture_table = await self.panda_device.data.datasets.get_value()
+        self._datasets = [
+            _HDFDataset(dataset_name, "/" + dataset_name, [1], multiplier=1)
+            for dataset_name in capture_table["name"]
+        ]
+
     # Next few functions are exactly the same as AD writer. Could move as default
     # StandardDetector behavior
     async def wait_for_index(

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/src/ophyd_async/panda/writers/_panda_hdf_file.py

@@ -9,10 +9,8 @@ from ophyd_async.core import DirectoryInfo
 
 @dataclass
 class _HDFDataset:
-    device_name: str
-    block: str
-    name: str
-    path: str
+    data_key: str
+    internal_path: str
     shape: List[int]
     multiplier: int
 
@@ -29,12 +27,10 @@ class _HDFFile:
             compose_stream_resource(
                 spec="AD_HDF5_SWMR_SLICE",
                 root=str(directory_info.root),
-                data_key=ds.name,
+                data_key=ds.data_key,
                 resource_path=(f"{str(directory_info.root)}/{full_file_name}"),
                 resource_kwargs={
-                    "name": ds.name,
-                    "block": ds.block,
-                    "path": ds.path,
+                    "path": ds.internal_path,
                     "multiplier": ds.multiplier,
                     "timestamps": "/entry/instrument/NDAttributes/NDArrayTimeStamp",
                 },

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/src/ophyd_async.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3.1
+Version: 0.3.2
 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
@@ -41,7 +41,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: networkx>=2.0
-Requires-Dist: numpy
+Requires-Dist: numpy<2.0.0
 Requires-Dist: packaging
 Requires-Dist: pint
 Requires-Dist: bluesky>=1.13.0a3

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/src/ophyd_async.egg-info/requires.txt

@@ -1,5 +1,5 @@
 networkx>=2.0
-numpy
+numpy<2.0.0
 packaging
 pint
 bluesky>=1.13.0a3

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/tests/core/test_mock_signal_backend.py

@@ -326,6 +326,38 @@ async def test_mock_signal_of_soft_signal_backend_receives_intial_value():
     assert await soft_device.my_signal.get_value() == 10
 
 
+async def test_mock_signal_of_soft_signal_backend_receives_metadata():
+    class SomeDevice(Device):
+        def __init__(self, name):
+            self.my_signal = soft_signal_rw(
+                datatype=float, initial_value=1.0, name=name, units="mm", precision=2
+            )
+
+    mocked_device = SomeDevice("mocked_device")
+    await mocked_device.connect(mock=True)
+    soft_device = SomeDevice("soft_device")
+    await soft_device.connect(mock=False)
+
+    assert await mocked_device.my_signal.describe() == {
+        "mocked_device": {
+            "dtype": "number",
+            "shape": [],
+            "source": "mock+soft://mocked_device",
+            "units": "mm",
+            "precision": 2,
+        }
+    }
+    assert await soft_device.my_signal.describe() == {
+        "soft_device": {
+            "dtype": "number",
+            "shape": [],
+            "source": "soft://soft_device",
+            "units": "mm",
+            "precision": 2,
+        }
+    }
+
+
 async def test_writing_to_soft_signals_in_mock():
     class MyDevice(Device):
         def __init__(self, prefix: str, name: str = ""):

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/tests/core/test_soft_signal_backend.py

@@ -9,7 +9,7 @@ import pytest
 from bluesky.protocols import Reading
 
 from ophyd_async.core import Signal, SignalBackend, T
-from ophyd_async.core.soft_signal_backend import SoftSignalBackend
+from ophyd_async.core.soft_signal_backend import SignalMetadata, SoftSignalBackend
 
 
 class MyEnum(str, Enum):
@@ -133,3 +133,39 @@ async def test_soft_signal_descriptor_fails_for_invalid_class():
 
     with pytest.raises(AssertionError):
         await soft_signal._backend.get_datakey("")
+
+
+async def test_soft_signal_descriptor_with_metadata():
+    soft_signal = Signal(
+        SoftSignalBackend(int, 0, metadata=SignalMetadata(units="mm", precision=0))
+    )
+    await soft_signal.connect()
+    datakey = await soft_signal._backend.get_datakey("")
+    assert datakey["units"] == "mm"
+    assert datakey["precision"] == 0
+
+    soft_signal = Signal(SoftSignalBackend(int, metadata=SignalMetadata(units="")))
+    await soft_signal.connect()
+    datakey = await soft_signal._backend.get_datakey("")
+    assert datakey["units"] == ""
+    assert not hasattr(datakey, "precision")
+
+
+async def test_soft_signal_descriptor_with_no_metadata_not_passed():
+    soft_signal = Signal(SoftSignalBackend(int))
+    await soft_signal.connect()
+    datakey = await soft_signal._backend.get_datakey("")
+    assert not hasattr(datakey, "units")
+    assert not hasattr(datakey, "precision")
+
+    soft_signal = Signal(SoftSignalBackend(int, metadata=None))
+    await soft_signal.connect()
+    datakey = await soft_signal._backend.get_datakey("")
+    assert not hasattr(datakey, "units")
+    assert not hasattr(datakey, "precision")
+
+    soft_signal = Signal(SoftSignalBackend(int, metadata={}))
+    await soft_signal.connect()
+    datakey = await soft_signal._backend.get_datakey("")
+    assert not hasattr(datakey, "units")
+    assert not hasattr(datakey, "precision")

{ophyd_async-0.3.1 → ophyd_async-0.3.2}/tests/panda/test_hdf_panda.py

@@ -1,5 +1,6 @@
 from typing import Dict
 
+import numpy as np
 import pytest
 from bluesky import plan_stubs as bps
 from bluesky.run_engine import RunEngine
@@ -9,9 +10,8 @@ from ophyd_async.core.device import Device
 from ophyd_async.core.flyer import HardwareTriggeredFlyable
 from ophyd_async.core.mock_signal_utils import callback_on_mock_put
 from ophyd_async.core.signal import SignalR, assert_emitted
-from ophyd_async.epics.signal.signal import epics_signal_r
 from ophyd_async.panda import HDFPanda, StaticSeqTableTriggerLogic
-from ophyd_async.panda.writers._hdf_writer import Capture
+from ophyd_async.panda._table import DatasetTable, PandaHdf5DatasetType
 from ophyd_async.plan_stubs import (
     prepare_static_seq_table_flyer_and_detectors_with_same_trigger,
 )
@@ -26,25 +26,28 @@ async def mock_hdf_panda(tmp_path):
     mock_hdf_panda = HDFPanda(
         "HDFPANDA:", directory_provider=directory_provider, name="panda"
     )
-    block_a = CaptureBlock(name="block_a")
-    block_b = CaptureBlock(name="block_b")
-    block_a.test_capture = epics_signal_r(
-        Capture, "pva://test_capture_a", name="test_capture_a"
-    )
-    block_b.test_capture = epics_signal_r(
-        Capture, "pva://test_capture_b", name="test_capture_b"
-    )
-
-    setattr(mock_hdf_panda, "block_a", block_a)
-    setattr(mock_hdf_panda, "block_b", block_b)
     await mock_hdf_panda.connect(mock=True)
 
     def link_function(value, **kwargs):
         set_mock_value(mock_hdf_panda.pcap.active, value)
 
     callback_on_mock_put(mock_hdf_panda.pcap.arm, link_function)
-    set_mock_value(block_a.test_capture, Capture.Min)
-    set_mock_value(block_b.test_capture, Capture.Diff)
+
+    set_mock_value(
+        mock_hdf_panda.data.datasets,
+        DatasetTable(
+            name=np.array(
+                [
+                    "x",
+                    "y",
+                ]
+            ),
+            hdf5_type=[
+                PandaHdf5DatasetType.UINT_32,
+                PandaHdf5DatasetType.FLOAT_64,
+            ],
+        ),
+    )
 
     yield mock_hdf_panda
 
@@ -127,10 +130,7 @@ async def test_hdf_panda_hardware_triggered_flyable(
 
     # test descriptor
     data_key_names: Dict[str, str] = docs["descriptor"][0]["object_keys"]["panda"]
-    assert data_key_names == [
-        "panda-block_a-test-Min",
-        "panda-block_b-test-Diff",
-    ]
+    assert data_key_names == ["x", "y"]
     for data_key_name in data_key_names:
         assert (
             docs["descriptor"][0]["data_keys"][data_key_name]["source"]
@@ -138,17 +138,15 @@ async def test_hdf_panda_hardware_triggered_flyable(
         )
 
     # test stream resources
-    for block_letter, stream_resource, data_key_name in zip(
-        ("a", "b"), docs["stream_resource"], data_key_names
+    for dataset_name, stream_resource, data_key_name in zip(
+        ("x", "y"), docs["stream_resource"], data_key_names
     ):
         assert stream_resource["data_key"] == data_key_name
         assert stream_resource["spec"] == "AD_HDF5_SWMR_SLICE"
         assert stream_resource["run_start"] == docs["start"][0]["uid"]
         assert stream_resource["resource_kwargs"] == {
-            "block": f"block_{block_letter}",
+            "path": "/" + dataset_name,
             "multiplier": 1,
-            "name": data_key_name,
-            "path": f"BLOCK_{block_letter.upper()}-TEST-{data_key_name.split('-')[-1]}",
             "timestamps": "/entry/instrument/NDAttributes/NDArrayTimeStamp",
         }