ophyd-async 0.7.0a1__py3-none-any.whl → 0.8.0a3__py3-none-any.whl

ophyd_async/epics/core/_util.py

@@ -0,0 +1,61 @@
+from collections.abc import Sequence
+from typing import Any, get_args, get_origin
+
+import numpy as np
+
+from ophyd_async.core import (
+    SignalBackend,
+    SignalDatatypeT,
+    SubsetEnum,
+    get_dtype,
+    get_enum_cls,
+)
+
+
+def get_supported_values(
+    pv: str,
+    datatype: type,
+    pv_choices: Sequence[str],
+) -> dict[str, str]:
+    enum_cls = get_enum_cls(datatype)
+    if not enum_cls:
+        raise TypeError(f"{datatype} is not an Enum")
+    choices = [v.value for v in enum_cls]
+    error_msg = f"{pv} has choices {pv_choices}, but {datatype} requested {choices} "
+    if issubclass(enum_cls, SubsetEnum):
+        if not set(choices).issubset(pv_choices):
+            raise TypeError(error_msg + "to be a subset of them.")
+    else:
+        if set(choices) != set(pv_choices):
+            raise TypeError(error_msg + "to be strictly equal to them.")
+
+    # Take order from the pv choices
+    supported_values = {x: x for x in pv_choices}
+    # But override those that we specify via the datatype
+    for v in enum_cls:
+        supported_values[v.value] = v
+    return supported_values
+
+
+def format_datatype(datatype: Any) -> str:
+    if get_origin(datatype) is np.ndarray and get_args(datatype)[0] == tuple[int]:
+        dtype = get_dtype(datatype)
+        return f"Array1D[np.{dtype.name}]"
+    elif get_origin(datatype) is Sequence:
+        return f"Sequence[{get_args(datatype)[0].__name__}]"
+    elif isinstance(datatype, type):
+        return datatype.__name__
+    else:
+        return str(datatype)
+
+
+class EpicsSignalBackend(SignalBackend[SignalDatatypeT]):
+    def __init__(
+        self,
+        datatype: type[SignalDatatypeT] | None,
+        read_pv: str = "",
+        write_pv: str = "",
+    ):
+        self.read_pv = read_pv
+        self.write_pv = write_pv
+        super().__init__(datatype)

ophyd_async/epics/demo/_mover.py

@@ -8,15 +8,14 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     CalculatableTimeout,
-    ConfigSignal,
     Device,
-    HintedSignal,
     StandardReadable,
     WatchableAsyncStatus,
     WatcherUpdate,
     observe_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_x
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
 
 
 class Mover(StandardReadable, Movable, Stoppable):
@@ -24,9 +23,9 @@ class Mover(StandardReadable, Movable, Stoppable):
 
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
-        with self.add_children_as_readables(HintedSignal):
+        with self.add_children_as_readables(Format.HINTED_SIGNAL):
             self.readback = epics_signal_r(float, prefix + "Readback")
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
             self.velocity = epics_signal_rw(float, prefix + "Velocity")
             self.units = epics_signal_r(str, prefix + "Readback.EGU")
         self.setpoint = epics_signal_rw(float, prefix + "Setpoint")

ophyd_async/epics/demo/_sensor.py

@@ -1,10 +1,17 @@
-from enum import Enum
+from typing import Annotated as A
 
-from ophyd_async.core import ConfigSignal, DeviceVector, HintedSignal, StandardReadable
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+from ophyd_async.core import (
+    DeviceVector,
+    SignalR,
+    SignalRW,
+    StandardReadable,
+    StrictEnum,
+)
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
 
 
-class EnergyMode(str, Enum):
+class EnergyMode(StrictEnum):
     """Energy mode for `Sensor`"""
 
     #: Low energy mode
@@ -13,17 +20,11 @@ class EnergyMode(str, Enum):
     high = "High Energy"
 
 
-class Sensor(StandardReadable):
+class Sensor(StandardReadable, EpicsDevice):
     """A demo sensor that produces a scalar value based on X and Y Movers"""
 
-    def __init__(self, prefix: str, name="") -> None:
-        # Define some signals
-        with self.add_children_as_readables(HintedSignal):
-            self.value = epics_signal_r(float, prefix + "Value")
-        with self.add_children_as_readables(ConfigSignal):
-            self.mode = epics_signal_rw(EnergyMode, prefix + "Mode")
-
-        super().__init__(name=name)
+    value: A[SignalR[float], PvSuffix("Value"), Format.HINTED_SIGNAL]
+    mode: A[SignalRW[EnergyMode], PvSuffix("Mode"), Format.CONFIG_SIGNAL]
 
 
 class SensorGroup(StandardReadable):

ophyd_async/epics/eiger/_eiger.py

@@ -1,7 +1,6 @@
 from pydantic import Field
 
-from ophyd_async.core import AsyncStatus, PathProvider, StandardDetector
-from ophyd_async.core._detector import TriggerInfo
+from ophyd_async.core import AsyncStatus, PathProvider, StandardDetector, TriggerInfo
 
 from ._eiger_controller import EigerController
 from ._eiger_io import EigerDriverIO

ophyd_async/epics/eiger/_eiger_controller.py

@@ -4,9 +4,9 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     DetectorController,
     DetectorTrigger,
+    TriggerInfo,
     set_and_wait_for_other_value,
 )
-from ophyd_async.core._detector import TriggerInfo
 
 from ._eiger_io import EigerDriverIO, EigerTriggerMode
 

ophyd_async/epics/eiger/_eiger_io.py

@@ -1,10 +1,8 @@
-from enum import Enum
+from ophyd_async.core import Device, StrictEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv, epics_signal_w
 
-from ophyd_async.core import Device
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw_rbv, epics_signal_w
 
-
-class EigerTriggerMode(str, Enum):
+class EigerTriggerMode(StrictEnum):
     internal = "ints"
     edge = "exts"
     gate = "exte"

ophyd_async/epics/eiger/_odin_io.py

@@ -1,6 +1,5 @@
 import asyncio
 from collections.abc import AsyncGenerator, AsyncIterator
-from enum import Enum
 
 from bluesky.protocols import StreamAsset
 from event_model import DataKey
@@ -12,17 +11,18 @@ from ophyd_async.core import (
     DeviceVector,
     NameProvider,
     PathProvider,
+    StrictEnum,
     observe_value,
     set_and_wait_for_value,
 )
-from ophyd_async.epics.signal import (
+from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,
 )
 
 
-class Writing(str, Enum):
+class Writing(StrictEnum):
     ON = "ON"
     OFF = "OFF"
 
@@ -101,10 +101,10 @@ class OdinWriter(DetectorWriter):
         return {
             "data": DataKey(
                 source=self._drv.file_name.source,
-                shape=data_shape,
+                shape=list(data_shape),
                 dtype="array",
                 # TODO: Use correct type based on eiger https://github.com/bluesky/ophyd-async/issues/529
-                dtype_numpy="<u2",  # type: ignore
+                dtype_numpy="<u2",
                 external="STREAM:",
             )
         }

ophyd_async/epics/motor.py

@@ -14,14 +14,13 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     CalculatableTimeout,
-    ConfigSignal,
-    HintedSignal,
     StandardReadable,
     WatchableAsyncStatus,
     WatcherUpdate,
     observe_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_x
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
 
 
 class MotorLimitsException(Exception):
@@ -61,11 +60,11 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
 
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
             self.motor_egu = epics_signal_r(str, prefix + ".EGU")
             self.velocity = epics_signal_rw(float, prefix + ".VELO")
 
-        with self.add_children_as_readables(HintedSignal):
+        with self.add_children_as_readables(Format.HINTED_SIGNAL):
             self.user_readback = epics_signal_r(float, prefix + ".RBV")
 
         self.user_setpoint = epics_signal_rw(float, prefix + ".VAL")

ophyd_async/epics/signal.py

@@ -0,0 +1,11 @@
+# back compat
+import warnings
+
+from .core import *  # noqa: F403
+
+warnings.warn(
+    DeprecationWarning(
+        "Use `ophyd_async.epics.core` instead of `ophyd_async.epics.signal` and `pvi`"
+    ),
+    stacklevel=2,
+)

ophyd_async/fastcs/core.py

@@ -0,0 +1,9 @@
+from ophyd_async.core import Device, DeviceConnector
+from ophyd_async.epics.core import PviDeviceConnector
+
+
+def fastcs_connector(device: Device, uri: str) -> DeviceConnector:
+    # TODO: add Tango support based on uri scheme
+    connector = PviDeviceConnector(uri)
+    connector.create_children_from_annotations(device)
+    return connector

ophyd_async/fastcs/panda/__init__.py

@@ -1,10 +1,10 @@
 from ._block import (
+    BitMux,
     CommonPandaBlocks,
     DataBlock,
-    EnableDisableOptions,
     PcapBlock,
     PcompBlock,
-    PcompDirectionOptions,
+    PcompDirection,
     PulseBlock,
     SeqBlock,
     TimeUnits,
@@ -29,10 +29,10 @@ from ._writer import PandaHDFWriter
 __all__ = [
     "CommonPandaBlocks",
     "DataBlock",
-    "EnableDisableOptions",
+    "BitMux",
     "PcapBlock",
     "PcompBlock",
-    "PcompDirectionOptions",
+    "PcompDirection",
     "PulseBlock",
     "SeqBlock",
     "TimeUnits",

ophyd_async/fastcs/panda/_block.py

@@ -1,10 +1,19 @@
-from __future__ import annotations
+from ophyd_async.core import (
+    Device,
+    DeviceVector,
+    SignalR,
+    SignalRW,
+    StrictEnum,
+    SubsetEnum,
+)
 
-from enum import Enum
+from ._table import DatasetTable, SeqTable
 
-from ophyd_async.core import Device, DeviceVector, SignalR, SignalRW, SubsetEnum
 
-from ._table import DatasetTable, SeqTable
+class CaptureMode(StrictEnum):
+    FIRST_N = "FIRST_N"
+    LAST_N = "LAST_N"
+    FOREVER = "FOREVER"
 
 
 class DataBlock(Device):
@@ -15,6 +24,7 @@ class DataBlock(Device):
     num_captured: SignalR[int]
     create_directory: SignalRW[int]
     directory_exists: SignalR[bool]
+    capture_mode: SignalRW[CaptureMode]
     capture: SignalRW[bool]
     flush_period: SignalRW[float]
     datasets: SignalR[DatasetTable]
@@ -25,26 +35,28 @@ class PulseBlock(Device):
     width: SignalRW[float]
 
 
-class PcompDirectionOptions(str, Enum):
+class PcompDirection(StrictEnum):
     positive = "Positive"
     negative = "Negative"
     either = "Either"
 
 
-EnableDisableOptions = SubsetEnum["ZERO", "ONE"]
+class BitMux(SubsetEnum):
+    zero = "ZERO"
+    one = "ONE"
 
 
 class PcompBlock(Device):
     active: SignalR[bool]
-    dir: SignalRW[PcompDirectionOptions]
-    enable: SignalRW[EnableDisableOptions]
+    dir: SignalRW[PcompDirection]
+    enable: SignalRW[BitMux]
     pulses: SignalRW[int]
     start: SignalRW[int]
     step: SignalRW[int]
     width: SignalRW[int]
 
 
-class TimeUnits(str, Enum):
+class TimeUnits(StrictEnum):
     min = "min"
     s = "s"
     ms = "ms"
@@ -53,11 +65,11 @@ class TimeUnits(str, Enum):
 
 class SeqBlock(Device):
     table: SignalRW[SeqTable]
-    active: SignalRW[bool]
+    active: SignalR[bool]
     repeats: SignalRW[int]
     prescale: SignalRW[float]
     prescale_units: SignalRW[TimeUnits]
-    enable: SignalRW[EnableDisableOptions]
+    enable: SignalRW[BitMux]
 
 
 class PcapBlock(Device):

ophyd_async/fastcs/panda/_control.py

@@ -1,12 +1,10 @@
-import asyncio
-
 from ophyd_async.core import (
+    AsyncStatus,
     DetectorController,
     DetectorTrigger,
+    TriggerInfo,
     wait_for_value,
 )
-from ophyd_async.core._detector import TriggerInfo
-from ophyd_async.core._status import AsyncStatus
 
 from ._block import PcapBlock
 
@@ -33,5 +31,5 @@ class PandaPcapController(DetectorController):
         pass
 
     async def disarm(self):
-        await asyncio.gather(self.pcap.arm.set(False))
+        await self.pcap.arm.set(False)
         await wait_for_value(self.pcap.active, False, timeout=1)

ophyd_async/fastcs/panda/_hdf_panda.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 
-from ophyd_async.core import DEFAULT_TIMEOUT, PathProvider, SignalR, StandardDetector
-from ophyd_async.epics.pvi import create_children_from_annotations, fill_pvi_entries
+from ophyd_async.core import PathProvider, SignalR, StandardDetector
+from ophyd_async.fastcs.core import fastcs_connector
 
 from ._block import CommonPandaBlocks
 from ._control import PandaPcapController
@@ -18,12 +18,10 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
         config_sigs: Sequence[SignalR] = (),
         name: str = "",
     ):
-        self._prefix = prefix
-
-        create_children_from_annotations(self)
+        # This has to be first so we make self.pcap
+        connector = fastcs_connector(self, prefix)
         controller = PandaPcapController(pcap=self.pcap)
         writer = PandaHDFWriter(
-            prefix=prefix,
             path_provider=path_provider,
             name_provider=lambda: name,
             panda_data_block=self.data,
@@ -33,17 +31,5 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
             writer=writer,
             config_sigs=config_sigs,
             name=name,
-        )
-
-    async def connect(
-        self,
-        mock: bool = False,
-        timeout: float = DEFAULT_TIMEOUT,
-        force_reconnect: bool = False,
-    ):
-        # TODO: this doesn't support caching
-        # https://github.com/bluesky/ophyd-async/issues/472
-        await fill_pvi_entries(self, self._prefix + "PVI", timeout=timeout, mock=mock)
-        await super().connect(
-            mock=mock, timeout=timeout, force_reconnect=force_reconnect
+            connector=connector,
         )

ophyd_async/fastcs/panda/_table.py

@@ -1,27 +1,22 @@
 from collections.abc import Sequence
-from enum import Enum
-from typing import Annotated
 
 import numpy as np
-import numpy.typing as npt
-from pydantic import Field, model_validator
-from pydantic_numpy.helper.annotation import NpArrayPydanticAnnotation
-from typing_extensions import TypedDict
+from pydantic import model_validator
 
-from ophyd_async.core import Table
+from ophyd_async.core import Array1D, StrictEnum, Table
 
 
-class PandaHdf5DatasetType(str, Enum):
+class PandaHdf5DatasetType(StrictEnum):
     FLOAT_64 = "float64"
     UINT_32 = "uint32"
 
 
-class DatasetTable(TypedDict):
-    name: npt.NDArray[np.str_]
+class DatasetTable(Table):
+    name: Sequence[str]
     hdf5_type: Sequence[PandaHdf5DatasetType]
 
 
-class SeqTrigger(str, Enum):
+class SeqTrigger(StrictEnum):
     IMMEDIATE = "Immediate"
     BITA_0 = "BITA=0"
     BITA_1 = "BITA=1"
@@ -37,45 +32,27 @@ class SeqTrigger(str, Enum):
     POSC_LT = "POSC<=POSITION"
 
 
-PydanticNp1DArrayInt32 = Annotated[
-    np.ndarray[tuple[int], np.dtype[np.int32]],
-    NpArrayPydanticAnnotation.factory(
-        data_type=np.int32, dimensions=1, strict_data_typing=False
-    ),
-    Field(default_factory=lambda: np.array([], np.int32)),
-]
-PydanticNp1DArrayBool = Annotated[
-    np.ndarray[tuple[int], np.dtype[np.bool_]],
-    NpArrayPydanticAnnotation.factory(
-        data_type=np.bool_, dimensions=1, strict_data_typing=False
-    ),
-    Field(default_factory=lambda: np.array([], dtype=np.bool_)),
-]
-TriggerStr = Annotated[Sequence[SeqTrigger], Field(default_factory=list)]
-
-
 class SeqTable(Table):
-    repeats: PydanticNp1DArrayInt32
-    trigger: TriggerStr
-    position: PydanticNp1DArrayInt32
-    time1: PydanticNp1DArrayInt32
-    outa1: PydanticNp1DArrayBool
-    outb1: PydanticNp1DArrayBool
-    outc1: PydanticNp1DArrayBool
-    outd1: PydanticNp1DArrayBool
-    oute1: PydanticNp1DArrayBool
-    outf1: PydanticNp1DArrayBool
-    time2: PydanticNp1DArrayInt32
-    outa2: PydanticNp1DArrayBool
-    outb2: PydanticNp1DArrayBool
-    outc2: PydanticNp1DArrayBool
-    outd2: PydanticNp1DArrayBool
-    oute2: PydanticNp1DArrayBool
-    outf2: PydanticNp1DArrayBool
+    repeats: Array1D[np.uint16]
+    trigger: Sequence[SeqTrigger]
+    position: Array1D[np.int32]
+    time1: Array1D[np.uint32]
+    outa1: Array1D[np.bool_]
+    outb1: Array1D[np.bool_]
+    outc1: Array1D[np.bool_]
+    outd1: Array1D[np.bool_]
+    oute1: Array1D[np.bool_]
+    outf1: Array1D[np.bool_]
+    time2: Array1D[np.uint32]
+    outa2: Array1D[np.bool_]
+    outb2: Array1D[np.bool_]
+    outc2: Array1D[np.bool_]
+    outd2: Array1D[np.bool_]
+    oute2: Array1D[np.bool_]
+    outf2: Array1D[np.bool_]
 
-    @classmethod
-    def row(  # type: ignore
-        cls,
+    @staticmethod
+    def row(
         *,
         repeats: int = 1,
         trigger: str = SeqTrigger.IMMEDIATE,
@@ -95,7 +72,8 @@ class SeqTable(Table):
         oute2: bool = False,
         outf2: bool = False,
     ) -> "SeqTable":
-        return Table.row(**locals())
+        # Let pydantic do the conversions for us
+        return SeqTable(**{k: [v] for k, v in locals().items()})  # type: ignore
 
     @model_validator(mode="after")
     def validate_max_length(self) -> "SeqTable":
@@ -104,6 +82,6 @@ class SeqTable(Table):
         the pydantic field doesn't work
         """
 
-        first_length = len(next(iter(self))[1])
-        assert 0 <= first_length < 4096, f"Length {first_length} not in range."
+        first_length = len(self)
+        assert first_length <= 4096, f"Length {first_length} is too long"
         return self

ophyd_async/fastcs/panda/_trigger.py

@@ -4,7 +4,7 @@ from pydantic import BaseModel, Field
 
 from ophyd_async.core import FlyerController, wait_for_value
 
-from ._block import PcompBlock, PcompDirectionOptions, SeqBlock, TimeUnits
+from ._block import BitMux, PcompBlock, PcompDirection, SeqBlock, TimeUnits
 from ._table import SeqTable
 
 
@@ -21,7 +21,7 @@ class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
     async def prepare(self, value: SeqTableInfo):
         await asyncio.gather(
             self.seq.prescale_units.set(TimeUnits.us),
-            self.seq.enable.set("ZERO"),
+            self.seq.enable.set(BitMux.zero),
         )
         await asyncio.gather(
             self.seq.prescale.set(value.prescale_as_us),
@@ -30,14 +30,14 @@ class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
         )
 
     async def kickoff(self) -> None:
-        await self.seq.enable.set("ONE")
+        await self.seq.enable.set(BitMux.one)
         await wait_for_value(self.seq.active, True, timeout=1)
 
     async def complete(self) -> None:
         await wait_for_value(self.seq.active, False, timeout=None)
 
     async def stop(self):
-        await self.seq.enable.set("ZERO")
+        await self.seq.enable.set(BitMux.zero)
         await wait_for_value(self.seq.active, False, timeout=1)
 
 
@@ -54,7 +54,7 @@ class PcompInfo(BaseModel):
         ),
         ge=0,
     )
-    direction: PcompDirectionOptions = Field(
+    direction: PcompDirection = Field(
         description=(
             "Specifies which direction the motor counts should be "
             "moving. Pulses won't be sent unless the values are moving in "
@@ -68,7 +68,7 @@ class StaticPcompTriggerLogic(FlyerController[PcompInfo]):
         self.pcomp = pcomp
 
     async def prepare(self, value: PcompInfo):
-        await self.pcomp.enable.set("ZERO")
+        await self.pcomp.enable.set(BitMux.zero)
         await asyncio.gather(
             self.pcomp.start.set(value.start_postion),
             self.pcomp.width.set(value.pulse_width),
@@ -78,12 +78,12 @@ class StaticPcompTriggerLogic(FlyerController[PcompInfo]):
         )
 
     async def kickoff(self) -> None:
-        await self.pcomp.enable.set("ONE")
+        await self.pcomp.enable.set(BitMux.one)
         await wait_for_value(self.pcomp.active, True, timeout=1)
 
     async def complete(self, timeout: float | None = None) -> None:
         await wait_for_value(self.pcomp.active, False, timeout=timeout)
 
     async def stop(self):
-        await self.pcomp.enable.set("ZERO")
+        await self.pcomp.enable.set(BitMux.zero)
         await wait_for_value(self.pcomp.active, False, timeout=1)

ophyd_async/fastcs/panda/_writer.py

@@ -17,7 +17,7 @@ from ophyd_async.core import (
     wait_for_value,
 )
 
-from ._block import DataBlock
+from ._block import CaptureMode, DataBlock
 
 
 class PandaHDFWriter(DetectorWriter):
@@ -25,13 +25,11 @@ class PandaHDFWriter(DetectorWriter):
 
     def __init__(
         self,
-        prefix: str,
         path_provider: PathProvider,
         name_provider: NameProvider,
         panda_data_block: DataBlock,
     ) -> None:
         self.panda_data_block = panda_data_block
-        self._prefix = prefix
         self._path_provider = path_provider
         self._name_provider = name_provider
         self._datasets: list[HDFDataset] = []
@@ -58,7 +56,7 @@ class PandaHDFWriter(DetectorWriter):
             self.panda_data_block.hdf_file_name.set(
                 f"{info.filename}.h5",
             ),
-            self.panda_data_block.num_capture.set(0),
+            self.panda_data_block.capture_mode.set(CaptureMode.FOREVER),
         )
 
         # Make sure that directory exists or has been created.
@@ -89,8 +87,7 @@ class PandaHDFWriter(DetectorWriter):
                 shape=list(ds.shape),
                 dtype="array" if ds.shape != [1] else "number",
                 # PandA data should always be written as Float64
-                # Ignore type check until https://github.com/bluesky/event-model/issues/308
-                dtype_numpy="<f8",  # type: ignore
+                dtype_numpy="<f8",
                 external="STREAM:",
             )
             for ds in self._datasets
@@ -110,7 +107,7 @@ class PandaHDFWriter(DetectorWriter):
             HDFDataset(
                 dataset_name, "/" + dataset_name, [1], multiplier=1, chunk_shape=(1024,)
             )
-            for dataset_name in capture_table["name"]
+            for dataset_name in capture_table.name
         ]
 
         # Warn user if dataset table is empty in PandA