ophyd-async 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

ophyd_async/epics/demo/_mover.py

@@ -0,0 +1,97 @@
+import asyncio
+
+import numpy as np
+from bluesky.protocols import Movable, Stoppable
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    CalculatableTimeout,
+    CalculateTimeout,
+    ConfigSignal,
+    Device,
+    HintedSignal,
+    StandardReadable,
+    WatchableAsyncStatus,
+    WatcherUpdate,
+    observe_value,
+)
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_x
+
+
+class Mover(StandardReadable, Movable, Stoppable):
+    """A demo movable that moves based on velocity"""
+
+    def __init__(self, prefix: str, name="") -> None:
+        # Define some signals
+        with self.add_children_as_readables(HintedSignal):
+            self.readback = epics_signal_r(float, prefix + "Readback")
+        with self.add_children_as_readables(ConfigSignal):
+            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")
+        self.precision = epics_signal_r(int, prefix + "Readback.PREC")
+        # Signals that collide with standard methods should have a trailing underscore
+        self.stop_ = epics_signal_x(prefix + "Stop.PROC")
+        # Whether set() should complete successfully or not
+        self._set_success = True
+
+        super().__init__(name=name)
+
+    def set_name(self, name: str):
+        super().set_name(name)
+        # Readback should be named the same as its parent in read()
+        self.readback.set_name(name)
+
+    @WatchableAsyncStatus.wrap
+    async def set(
+        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
+    ):
+        self._set_success = True
+        old_position, units, precision, velocity = await asyncio.gather(
+            self.setpoint.get_value(),
+            self.units.get_value(),
+            self.precision.get_value(),
+            self.velocity.get_value(),
+        )
+        if timeout is CalculateTimeout:
+            assert velocity > 0, "Mover has zero velocity"
+            timeout = abs(new_position - old_position) / velocity + DEFAULT_TIMEOUT
+        # Make an Event that will be set on completion, and a Status that will
+        # error if not done in time
+        done = asyncio.Event()
+        done_status = AsyncStatus(asyncio.wait_for(done.wait(), timeout))
+        # Wait for the value to set, but don't wait for put completion callback
+        await self.setpoint.set(new_position, wait=False)
+        async for current_position in observe_value(
+            self.readback, done_status=done_status
+        ):
+            yield WatcherUpdate(
+                current=current_position,
+                initial=old_position,
+                target=new_position,
+                name=self.name,
+                unit=units,
+                precision=precision,
+            )
+            if np.isclose(current_position, new_position):
+                done.set()
+                break
+        if not self._set_success:
+            raise RuntimeError("Motor was stopped")
+
+    async def stop(self, success=True):
+        self._set_success = success
+        status = self.stop_.trigger()
+        await status
+
+
+class SampleStage(Device):
+    """A demo sample stage with X and Y movables"""
+
+    def __init__(self, prefix: str, name="") -> None:
+        # Define some child Devices
+        self.x = Mover(prefix + "X:")
+        self.y = Mover(prefix + "Y:")
+        # Set name of device and child devices
+        super().__init__(name=name)

ophyd_async/epics/demo/_sensor.py

@@ -0,0 +1,36 @@
+from enum import Enum
+
+from ophyd_async.core import ConfigSignal, DeviceVector, HintedSignal, StandardReadable
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+
+
+class EnergyMode(str, Enum):
+    """Energy mode for `Sensor`"""
+
+    #: Low energy mode
+    low = "Low Energy"
+    #: High energy mode
+    high = "High Energy"
+
+
+class Sensor(StandardReadable):
+    """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)
+
+
+class SensorGroup(StandardReadable):
+    def __init__(self, prefix: str, name: str = "", sensor_count: int = 3) -> None:
+        with self.add_children_as_readables():
+            self.sensors = DeviceVector(
+                {i: Sensor(f"{prefix}{i}:") for i in range(1, sensor_count + 1)}
+            )
+
+        super().__init__(name)

ophyd_async/epics/{motion/motor.py → motor.py}

@@ -1,25 +1,28 @@
 import asyncio
 from typing import Optional
 
-from bluesky.protocols import Flyable, Movable, Preparable, Stoppable
+from bluesky.protocols import (
+    Flyable,
+    Locatable,
+    Location,
+    Preparable,
+    Stoppable,
+)
 from pydantic import BaseModel, Field
 
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    CalculatableTimeout,
+    CalculateTimeout,
     ConfigSignal,
     HintedSignal,
     StandardReadable,
     WatchableAsyncStatus,
-)
-from ophyd_async.core.async_status import AsyncStatus
-from ophyd_async.core.signal import observe_value
-from ophyd_async.core.utils import (
-    DEFAULT_TIMEOUT,
-    CalculatableTimeout,
-    CalculateTimeout,
     WatcherUpdate,
+    observe_value,
 )
-
-from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_x
 
 
 class MotorLimitsException(Exception):
@@ -54,7 +57,7 @@ class FlyMotorInfo(BaseModel):
     timeout: CalculatableTimeout = Field(frozen=True, default=CalculateTimeout)
 
 
-class Motor(StandardReadable, Movable, Stoppable, Flyable, Preparable):
+class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
     """Device that moves a motor record"""
 
     def __init__(self, prefix: str, name="") -> None:
@@ -116,6 +119,7 @@ class Motor(StandardReadable, Movable, Stoppable, Flyable, Preparable):
         )
 
         await self.set(fly_prepared_position)
+        await self.velocity.set(fly_velocity)
 
     @AsyncStatus.wrap
     async def kickoff(self):
@@ -182,7 +186,7 @@ class Motor(StandardReadable, Movable, Stoppable, Flyable, Preparable):
     async def _prepare_velocity(
         self, start_position: float, end_position: float, time_for_move: float
     ) -> float:
-        fly_velocity = (start_position - end_position) / time_for_move
+        fly_velocity = (end_position - start_position) / time_for_move
         max_speed, egu = await asyncio.gather(
             self.max_velocity.get_value(), self.motor_egu.get_value()
         )
@@ -191,15 +195,25 @@ class Motor(StandardReadable, Movable, Stoppable, Flyable, Preparable):
                 f"Motor speed of {abs(fly_velocity)} {egu}/s was requested for a motor "
                 f" with max speed of {max_speed} {egu}/s"
             )
-        await self.velocity.set(abs(fly_velocity))
+        # move to prepare position at maximum velocity
+        await self.velocity.set(abs(max_speed))
         return fly_velocity
 
+    async def locate(self) -> Location[float]:
+        location: Location = {
+            "setpoint": await self.user_setpoint.get_value(),
+            "readback": await self.user_readback.get_value(),
+        }
+        return location
+
     async def _prepare_motor_path(
         self, fly_velocity: float, start_position: float, end_position: float
     ) -> float:
         # Distance required for motor to accelerate from stationary to fly_velocity, and
         # distance required for motor to decelerate from fly_velocity to stationary
-        run_up_distance = (await self.acceleration_time.get_value()) * fly_velocity
+        run_up_distance = (
+            (await self.acceleration_time.get_value()) * fly_velocity * 0.5
+        )
 
         self._fly_completed_position = end_position + run_up_distance
 

ophyd_async/epics/pvi/__init__.py

@@ -1,3 +1,3 @@
-from .pvi import PVIEntry, create_children_from_annotations, fill_pvi_entries
+from ._pvi import create_children_from_annotations, fill_pvi_entries
 
-__all__ = ["PVIEntry", "fill_pvi_entries", "create_children_from_annotations"]
+__all__ = ["fill_pvi_entries", "create_children_from_annotations"]

ophyd_async/epics/pvi/{pvi.py → _pvi.py}

@@ -10,25 +10,28 @@ from typing import (
     Optional,
     Tuple,
     Type,
-    TypeVar,
     Union,
     get_args,
     get_origin,
     get_type_hints,
 )
 
-from ophyd_async.core import Device, DeviceVector, SoftSignalBackend
-from ophyd_async.core.signal import Signal
-from ophyd_async.core.utils import DEFAULT_TIMEOUT
-from ophyd_async.epics._backend._p4p import PvaSignalBackend
-from ophyd_async.epics.signal.signal import (
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    Device,
+    DeviceVector,
+    Signal,
+    SoftSignalBackend,
+    T,
+)
+from ophyd_async.epics.signal import (
+    PvaSignalBackend,
     epics_signal_r,
     epics_signal_rw,
     epics_signal_w,
     epics_signal_x,
 )
 
-T = TypeVar("T")
 Access = FrozenSet[
     Union[Literal["r"], Literal["w"], Literal["rw"], Literal["x"], Literal["d"]]
 ]
@@ -74,19 +77,19 @@ def _strip_device_vector(field: Union[Type[Device]]) -> Tuple[bool, Type[Device]
 
 
 @dataclass
-class PVIEntry:
+class _PVIEntry:
     """
     A dataclass to represent a single entry in the PVI table.
     This could either be a signal or a sub-table.
     """
 
-    sub_entries: Dict[str, Union[Dict[int, "PVIEntry"], "PVIEntry"]]
+    sub_entries: Dict[str, Union[Dict[int, "_PVIEntry"], "_PVIEntry"]]
     pvi_pv: Optional[str] = None
     device: Optional[Device] = None
     common_device_type: Optional[Type[Device]] = None
 
 
-def _verify_common_blocks(entry: PVIEntry, common_device: Type[Device]):
+def _verify_common_blocks(entry: _PVIEntry, common_device: Type[Device]):
     if not entry.sub_entries:
         return
     common_sub_devices = get_type_hints(common_device)
@@ -205,7 +208,7 @@ def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
         sub_device.parent = device
 
 
-async def _get_pvi_entries(entry: PVIEntry, timeout=DEFAULT_TIMEOUT):
+async def _get_pvi_entries(entry: _PVIEntry, timeout=DEFAULT_TIMEOUT):
     if not entry.pvi_pv or not entry.pvi_pv.endswith(":PVI"):
         raise RuntimeError("Top level entry must be a pvi table")
 
@@ -235,7 +238,7 @@ async def _get_pvi_entries(entry: PVIEntry, timeout=DEFAULT_TIMEOUT):
         else:
             device = getattr(entry.device, sub_name, device_type())
 
-        sub_entry = PVIEntry(
+        sub_entry = _PVIEntry(
             device=device, common_device_type=device_type, sub_entries={}
         )
 
@@ -257,7 +260,7 @@ async def _get_pvi_entries(entry: PVIEntry, timeout=DEFAULT_TIMEOUT):
         _verify_common_blocks(entry, entry.common_device_type)
 
 
-def _set_device_attributes(entry: PVIEntry):
+def _set_device_attributes(entry: _PVIEntry):
     for sub_name, sub_entry in entry.sub_entries.items():
         if isinstance(sub_entry, dict):
             sub_device = DeviceVector()  # type: ignore
@@ -289,7 +292,7 @@ async def fill_pvi_entries(
         _mock_common_blocks(device)
     else:
         # check the pvi table for devices and fill the device with them
-        root_entry = PVIEntry(
+        root_entry = _PVIEntry(
             pvi_pv=root_pv,
             device=device,
             common_device_type=type(device),

ophyd_async/epics/signal/__init__.py

@@ -1,4 +1,6 @@
-from .signal import (
+from ._common import LimitPair, Limits, get_supported_values
+from ._p4p import PvaSignalBackend
+from ._signal import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,
@@ -7,6 +9,10 @@ from .signal import (
 )
 
 __all__ = [
+    "get_supported_values",
+    "LimitPair",
+    "Limits",
+    "PvaSignalBackend",
     "epics_signal_r",
     "epics_signal_rw",
     "epics_signal_rw_rbv",

ophyd_async/epics/{_backend → signal}/_aioca.py

@@ -21,6 +21,8 @@ from bluesky.protocols import DataKey, Dtype, Reading
 from epicscorelibs.ca import dbr
 
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    NotConnected,
     ReadingValueCallback,
     SignalBackend,
     T,
@@ -28,9 +30,8 @@ from ophyd_async.core import (
     get_unique,
     wait_for_connection,
 )
-from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
 
-from .common import LimitPair, Limits, common_meta, get_supported_values
+from ._common import LimitPair, Limits, common_meta, get_supported_values
 
 dbr_to_dtype: Dict[Dbr, Dtype] = {
     dbr.DBR_STRING: "string",
@@ -46,7 +47,7 @@ def _data_key_from_augmented_value(
     value: AugmentedValue,
     *,
     choices: Optional[List[str]] = None,
-    dtype: Optional[str] = None,
+    dtype: Optional[Dtype] = None,
 ) -> DataKey:
     """Use the return value of get with FORMAT_CTRL to construct a DataKey
     describing the signal. See docstring of AugmentedValue for expected
@@ -174,7 +175,7 @@ class CaBoolConverter(CaConverter):
         return bool(value)
 
     def get_datakey(self, value: AugmentedValue) -> DataKey:
-        return _data_key_from_augmented_value(value, dtype="bool")
+        return _data_key_from_augmented_value(value, dtype="boolean")
 
 
 class DisconnectedCaConverter(CaConverter):
@@ -228,10 +229,17 @@ def make_converter(
         value = list(values.values())[0]
         # Done the dbr check, so enough to check one of the values
         if datatype and not isinstance(value, datatype):
-            raise TypeError(
-                f"{pv} has type {type(value).__name__.replace('ca_', '')} "
-                + f"not {datatype.__name__}"
+            # Allow int signals to represent float records when prec is 0
+            is_prec_zero_float = (
+                isinstance(value, float)
+                and get_unique({k: v.precision for k, v in values.items()}, "precision")
+                == 0
             )
+            if not (datatype is int and is_prec_zero_float):
+                raise TypeError(
+                    f"{pv} has type {type(value).__name__.replace('ca_', '')} "
+                    + f"not {datatype.__name__}"
+                )
         return CaConverter(pv_dbr, None)
 
 

ophyd_async/epics/{_backend/common.py → signal/_common.py}

@@ -4,7 +4,7 @@ from typing import Dict, Optional, Tuple, Type
 
 from typing_extensions import TypedDict
 
-from ophyd_async.core.signal_backend import RuntimeSubsetEnum
+from ophyd_async.core import RuntimeSubsetEnum
 
 common_meta = {
     "units",
@@ -55,7 +55,7 @@ def get_supported_values(
                 f"which do not match {datatype}, which has {choices}."
             )
         return {x: datatype(x) if x else "_" for x in pv_choices}
-    elif datatype is None:
+    elif datatype is None or datatype is str:
         return {x: x or "_" for x in pv_choices}
 
     raise TypeError(

ophyd_async/epics/signal/_epics_transport.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from enum import Enum
 
 try:
-    from .._backend._aioca import CaSignalBackend
+    from ._aioca import CaSignalBackend
 except ImportError as ca_error:
 
     class CaSignalBackend:  # type: ignore
@@ -14,7 +14,7 @@ except ImportError as ca_error:
 
 
 try:
-    from .._backend._p4p import PvaSignalBackend
+    from ._p4p import PvaSignalBackend
 except ImportError as pva_error:
 
     class PvaSignalBackend:  # type: ignore
@@ -22,7 +22,7 @@ except ImportError as pva_error:
             raise NotImplementedError("PVA support not available") from pva_error
 
 
-class EpicsTransport(Enum):
+class _EpicsTransport(Enum):
     """The sorts of transport EPICS support"""
 
     #: Use Channel Access (using aioca library)

ophyd_async/epics/{_backend → signal}/_p4p.py

@@ -13,17 +13,18 @@ from p4p import Value
 from p4p.client.asyncio import Context, Subscription
 
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    NotConnected,
     ReadingValueCallback,
+    RuntimeSubsetEnum,
     SignalBackend,
     T,
     get_dtype,
     get_unique,
     wait_for_connection,
 )
-from ophyd_async.core.signal_backend import RuntimeSubsetEnum
-from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
 
-from .common import LimitPair, Limits, common_meta, get_supported_values
+from ._common import LimitPair, Limits, common_meta, get_supported_values
 
 # https://mdavidsaver.github.io/p4p/values.html
 specifier_to_dtype: Dict[str, Dtype] = {
@@ -63,7 +64,7 @@ def _data_key_from_value(
     *,
     shape: Optional[list[int]] = None,
     choices: Optional[list[str]] = None,
-    dtype: Optional[str] = None,
+    dtype: Optional[Dtype] = None,
 ) -> DataKey:
     """
     Args:
@@ -84,7 +85,7 @@ def _data_key_from_value(
         if isinstance(type_code, tuple):
             dtype_numpy = ""
             if type_code[1] == "enum_t":
-                if dtype == "bool":
+                if dtype == "boolean":
                     dtype_numpy = "<i2"
                 else:
                     for item in type_code[2]:
@@ -240,7 +241,7 @@ class PvaEmumBoolConverter(PvaConverter):
         return bool(value["value"]["index"])
 
     def get_datakey(self, source: str, value) -> DataKey:
-        return _data_key_from_value(source, value, dtype="bool")
+        return _data_key_from_value(source, value, dtype="boolean")
 
 
 class PvaTableConverter(PvaConverter):
@@ -334,14 +335,17 @@ def make_converter(datatype: Optional[Type], values: Dict[str, Any]) -> PvaConve
             return PvaEnumConverter(
                 get_supported_values(pv, datatype, datatype.choices)
             )
-        elif (
-            datatype
-            and not issubclass(typ, datatype)
-            and not (
-                typ is float and datatype is int
-            )  # Allow float -> int since prec can be 0
-        ):
-            raise TypeError(f"{pv} has type {typ.__name__} not {datatype.__name__}")
+        elif datatype and not issubclass(typ, datatype):
+            # Allow int signals to represent float records when prec is 0
+            is_prec_zero_float = typ is float and (
+                get_unique(
+                    {k: v["display"]["precision"] for k, v in values.items()},
+                    "precision",
+                )
+                == 0
+            )
+            if not (datatype is int and is_prec_zero_float):
+                raise TypeError(f"{pv} has type {typ.__name__} not {datatype.__name__}")
         return PvaConverter()
     elif "NTTable" in typeid:
         return PvaTableConverter()

ophyd_async/epics/signal/{signal.py → _signal.py}

@@ -14,26 +14,27 @@ from ophyd_async.core import (
     get_unique,
 )
 
-from ._epics_transport import EpicsTransport
+from ._epics_transport import _EpicsTransport
 
-_default_epics_transport = EpicsTransport.ca
+_default_epics_transport = _EpicsTransport.ca
 
 
-def _transport_pv(pv: str) -> Tuple[EpicsTransport, str]:
+def _transport_pv(pv: str) -> Tuple[_EpicsTransport, str]:
     split = pv.split("://", 1)
     if len(split) > 1:
         # We got something like pva://mydevice, so use specified comms mode
         transport_str, pv = split
-        transport = EpicsTransport[transport_str]
+        transport = _EpicsTransport[transport_str]
     else:
         # No comms mode specified, use the default
         transport = _default_epics_transport
     return transport, pv
 
 
-def _make_backend(
+def _epics_signal_backend(
     datatype: Optional[Type[T]], read_pv: str, write_pv: str
 ) -> SignalBackend[T]:
+    """Create an epics signal backend."""
     r_transport, r_pv = _transport_pv(read_pv)
     w_transport, w_pv = _transport_pv(write_pv)
     transport = get_unique({read_pv: r_transport, write_pv: w_transport}, "transports")
@@ -54,7 +55,7 @@ def epics_signal_rw(
     write_pv:
         If given, use this PV to write to, otherwise use read_pv
     """
-    backend = _make_backend(datatype, read_pv, write_pv or read_pv)
+    backend = _epics_signal_backend(datatype, read_pv, write_pv or read_pv)
     return SignalRW(backend, name=name)
 
 
@@ -85,7 +86,7 @@ def epics_signal_r(datatype: Type[T], read_pv: str, name: str = "") -> SignalR[T
     read_pv:
         The PV to read and monitor
     """
-    backend = _make_backend(datatype, read_pv, read_pv)
+    backend = _epics_signal_backend(datatype, read_pv, read_pv)
     return SignalR(backend, name=name)
 
 
@@ -99,7 +100,7 @@ def epics_signal_w(datatype: Type[T], write_pv: str, name: str = "") -> SignalW[
     write_pv:
         The PV to write to
     """
-    backend = _make_backend(datatype, write_pv, write_pv)
+    backend = _epics_signal_backend(datatype, write_pv, write_pv)
     return SignalW(backend, name=name)
 
 
@@ -111,5 +112,5 @@ def epics_signal_x(write_pv: str, name: str = "") -> SignalX:
     write_pv:
         The PV to write its initial value to on trigger
     """
-    backend: SignalBackend = _make_backend(None, write_pv, write_pv)
+    backend: SignalBackend = _epics_signal_backend(None, write_pv, write_pv)
     return SignalX(backend, name=name)

ophyd_async/{panda → fastcs/panda}/__init__.py

@@ -1,4 +1,4 @@
-from ._common_blocks import (
+from ._block import (
     CommonPandaBlocks,
     DataBlock,
     EnableDisableOptions,
@@ -9,9 +9,11 @@ from ._common_blocks import (
     SeqBlock,
     TimeUnits,
 )
+from ._control import PandaPcapController
 from ._hdf_panda import HDFPanda
-from ._panda_controller import PandaPcapController
 from ._table import (
+    DatasetTable,
+    PandaHdf5DatasetType,
     SeqTable,
     SeqTableRow,
     SeqTrigger,
@@ -25,28 +27,31 @@ from ._trigger import (
     StaticSeqTableTriggerLogic,
 )
 from ._utils import phase_sorter
+from ._writer import PandaHDFWriter
 
 __all__ = [
     "CommonPandaBlocks",
-    "HDFPanda",
-    "PcompBlock",
-    "PcompInfo",
-    "PcompDirectionOptions",
+    "DataBlock",
     "EnableDisableOptions",
     "PcapBlock",
+    "PcompBlock",
+    "PcompDirectionOptions",
     "PulseBlock",
-    "seq_table_from_arrays",
-    "seq_table_from_rows",
     "SeqBlock",
-    "SeqTableInfo",
+    "TimeUnits",
+    "HDFPanda",
+    "PandaHDFWriter",
+    "PandaPcapController",
+    "DatasetTable",
+    "PandaHdf5DatasetType",
     "SeqTable",
     "SeqTableRow",
     "SeqTrigger",
-    "phase_sorter",
-    "PandaPcapController",
-    "TimeUnits",
-    "DataBlock",
-    "CommonPandABlocks",
-    "StaticSeqTableTriggerLogic",
+    "seq_table_from_arrays",
+    "seq_table_from_rows",
+    "PcompInfo",
+    "SeqTableInfo",
     "StaticPcompTriggerLogic",
+    "StaticSeqTableTriggerLogic",
+    "phase_sorter",
 ]

ophyd_async/{panda/_common_blocks.py → fastcs/panda/_block.py}

@@ -2,9 +2,9 @@ from __future__ import annotations
 
 from enum import Enum
 
-from ophyd_async.core import Device, DeviceVector, SignalR, SignalRW
-from ophyd_async.core.signal_backend import SubsetEnum
-from ophyd_async.panda._table import DatasetTable, SeqTable
+from ophyd_async.core import Device, DeviceVector, SignalR, SignalRW, SubsetEnum
+
+from ._table import DatasetTable, SeqTable
 
 
 class DataBlock(Device):
@@ -13,6 +13,8 @@ class DataBlock(Device):
     hdf_file_name: SignalRW[str]
     num_capture: SignalRW[int]
     num_captured: SignalR[int]
+    create_directory: SignalRW[int]
+    directory_exists: SignalR[bool]
     capture: SignalRW[bool]
     flush_period: SignalRW[float]
     datasets: SignalR[DatasetTable]