ophyd-async 0.9.0a1__py3-none-any.whl → 0.10.0a1__py3-none-any.whl

ophyd_async/fastcs/core.py

@@ -1,9 +1,15 @@
+"""FastCS core module for ophyd-async."""
+
 from ophyd_async.core import Device, DeviceConnector
 from ophyd_async.epics.core import PviDeviceConnector
 
 
 def fastcs_connector(device: Device, uri: str, error_hint: str = "") -> DeviceConnector:
+    """Create devices and connections on pvi device `Device`."""
     # TODO: add Tango support based on uri scheme
     connector = PviDeviceConnector(uri, error_hint)
     connector.create_children_from_annotations(device)
     return connector
+
+
+__all__ = ["fastcs_connector"]

ophyd_async/fastcs/odin/__init__.py

@@ -0,0 +1 @@
+__all__ = []

ophyd_async/fastcs/panda/__init__.py

@@ -1,13 +1,14 @@
 from ._block import (
-    BitMux,
     CommonPandaBlocks,
     DataBlock,
+    PandaBitMux,
+    PandaCaptureMode,
+    PandaPcompDirection,
+    PandaTimeUnits,
     PcapBlock,
     PcompBlock,
-    PcompDirection,
     PulseBlock,
     SeqBlock,
-    TimeUnits,
 )
 from ._control import PandaPcapController
 from ._hdf_panda import HDFPanda
@@ -23,19 +24,19 @@ from ._trigger import (
     StaticPcompTriggerLogic,
     StaticSeqTableTriggerLogic,
 )
-from ._utils import phase_sorter
 from ._writer import PandaHDFWriter
 
 __all__ = [
     "CommonPandaBlocks",
     "DataBlock",
-    "BitMux",
+    "PandaBitMux",
+    "PandaCaptureMode",
     "PcapBlock",
     "PcompBlock",
-    "PcompDirection",
+    "PandaPcompDirection",
     "PulseBlock",
     "SeqBlock",
-    "TimeUnits",
+    "PandaTimeUnits",
     "HDFPanda",
     "PandaHDFWriter",
     "PandaPcapController",
@@ -47,5 +48,4 @@ __all__ = [
     "SeqTableInfo",
     "StaticPcompTriggerLogic",
     "StaticSeqTableTriggerLogic",
-    "phase_sorter",
 ]

ophyd_async/fastcs/panda/_block.py

@@ -10,13 +10,17 @@ from ophyd_async.core import (
 from ._table import DatasetTable, SeqTable
 
 
-class CaptureMode(StrictEnum):
+class PandaCaptureMode(StrictEnum):
+    """Capture mode for the `DataBlock` on the PandA."""
+
     FIRST_N = "FIRST_N"
     LAST_N = "LAST_N"
     FOREVER = "FOREVER"
 
 
 class DataBlock(Device):
+    """Data block for the PandA. Used for writing data through the IOC."""
+
     # In future we may decide to make hdf_* optional
     hdf_directory: SignalRW[str]
     hdf_file_name: SignalRW[str]
@@ -24,39 +28,49 @@ class DataBlock(Device):
     num_captured: SignalR[int]
     create_directory: SignalRW[int]
     directory_exists: SignalR[bool]
-    capture_mode: SignalRW[CaptureMode]
+    capture_mode: SignalRW[PandaCaptureMode]
     capture: SignalRW[bool]
     flush_period: SignalRW[float]
     datasets: SignalR[DatasetTable]
 
 
 class PulseBlock(Device):
+    """Used for configuring pulses in the PandA."""
+
     delay: SignalRW[float]
     width: SignalRW[float]
 
 
-class PcompDirection(StrictEnum):
+class PandaPcompDirection(StrictEnum):
+    """Direction options for position compare in the PandA."""
+
     POSITIVE = "Positive"
     NEGATIVE = "Negative"
     EITHER = "Either"
 
 
-class BitMux(SubsetEnum):
+class PandaBitMux(SubsetEnum):
+    """Bit input with configurable delay in the PandA."""
+
     ZERO = "ZERO"
     ONE = "ONE"
 
 
 class PcompBlock(Device):
+    """Position compare block in the PandA."""
+
     active: SignalR[bool]
-    dir: SignalRW[PcompDirection]
-    enable: SignalRW[BitMux]
+    dir: SignalRW[PandaPcompDirection]
+    enable: SignalRW[PandaBitMux]
     pulses: SignalRW[int]
     start: SignalRW[int]
     step: SignalRW[int]
     width: SignalRW[int]
 
 
-class TimeUnits(StrictEnum):
+class PandaTimeUnits(StrictEnum):
+    """Options for units of time in the PandA."""
+
     MIN = "min"
     S = "s"
     MS = "ms"
@@ -64,20 +78,26 @@ class TimeUnits(StrictEnum):
 
 
 class SeqBlock(Device):
+    """Sequencer block in the PandA."""
+
     table: SignalRW[SeqTable]
     active: SignalR[bool]
     repeats: SignalRW[int]
     prescale: SignalRW[float]
-    prescale_units: SignalRW[TimeUnits]
-    enable: SignalRW[BitMux]
+    prescale_units: SignalRW[PandaTimeUnits]
+    enable: SignalRW[PandaBitMux]
 
 
 class PcapBlock(Device):
+    """Position capture block in the PandA."""
+
     active: SignalR[bool]
     arm: SignalRW[bool]
 
 
 class CommonPandaBlocks(Device):
+    """Pandablocks device with blocks which are common and required on introspection."""
+
     pulse: DeviceVector[PulseBlock]
     seq: DeviceVector[SeqBlock]
     pcomp: DeviceVector[PcompBlock]

ophyd_async/fastcs/panda/_control.py

@@ -10,6 +10,8 @@ from ._block import PcapBlock
 
 
 class PandaPcapController(DetectorController):
+    """For controlling a PCAP capture on the PandA."""
+
     def __init__(self, pcap: PcapBlock) -> None:
         self.pcap = pcap
         self._arm_status: AsyncStatus | None = None
@@ -18,10 +20,15 @@ class PandaPcapController(DetectorController):
         return 0.000000008
 
     async def prepare(self, trigger_info: TriggerInfo):
-        assert trigger_info.trigger in (
+        if trigger_info.trigger not in (
             DetectorTrigger.CONSTANT_GATE,
             DetectorTrigger.VARIABLE_GATE,
-        ), "Only constant_gate and variable_gate triggering is supported on the PandA"
+        ):
+            msg = (
+                "Only constant_gate and variable_gate triggering is supported on "
+                "the PandA",
+            )
+            raise TypeError(msg)
 
     async def arm(self):
         self._arm_status = self.pcap.arm.set(True)
@@ -33,3 +40,6 @@ class PandaPcapController(DetectorController):
     async def disarm(self):
         await self.pcap.arm.set(False)
         await wait_for_value(self.pcap.active, False, timeout=1)
+        if self._arm_status and not self._arm_status.done:
+            await self._arm_status
+        self._arm_status = None

ophyd_async/fastcs/panda/_hdf_panda.py

@@ -12,7 +12,11 @@ from ._writer import PandaHDFWriter
 MINIMUM_PANDA_IOC = "0.11.4"
 
 
-class HDFPanda(CommonPandaBlocks, StandardDetector):
+class HDFPanda(
+    CommonPandaBlocks, StandardDetector[PandaPcapController, PandaHDFWriter]
+):
+    """PandA with common blocks for standard HDF writing."""
+
     def __init__(
         self,
         prefix: str,

ophyd_async/fastcs/panda/_table.py

@@ -7,6 +7,8 @@ from ophyd_async.core import Array1D, StrictEnum, Table
 
 
 class PandaHdf5DatasetType(StrictEnum):
+    """Dataset options for HDF capture."""
+
     FLOAT_64 = "float64"
     UINT_32 = "uint32"
 
@@ -17,6 +19,8 @@ class DatasetTable(Table):
 
 
 class SeqTrigger(StrictEnum):
+    """Trigger options for the SeqTable."""
+
     IMMEDIATE = "Immediate"
     BITA_0 = "BITA=0"
     BITA_1 = "BITA=1"
@@ -33,6 +37,8 @@ class SeqTrigger(StrictEnum):
 
 
 class SeqTable(Table):
+    """Data type for the panda seq table."""
+
     repeats: Array1D[np.uint16]
     trigger: Sequence[SeqTrigger]
     position: Array1D[np.int32]
@@ -76,12 +82,12 @@ class SeqTable(Table):
         return SeqTable(**{k: [v] for k, v in locals().items()})  # type: ignore
 
     @model_validator(mode="after")
-    def validate_max_length(self) -> "SeqTable":
-        """
-        Used to check max_length. Unfortunately trying the `max_length` arg in
-        the pydantic field doesn't work
-        """
-
+    def _validate_max_length(self) -> "SeqTable":
+        # Used to check max_length. Unfortunately trying the ``max_length`` arg in
+        # the pydantic field doesn't work.
         first_length = len(self)
-        assert first_length <= 4096, f"Length {first_length} is too long"
+        max_length = 4096
+        if first_length > max_length:
+            msg = f"Length {first_length} is too long"
+            raise ValueError(msg)
         return self

ophyd_async/fastcs/panda/_trigger.py

@@ -4,24 +4,34 @@ from pydantic import BaseModel, Field
 
 from ophyd_async.core import FlyerController, wait_for_value
 
-from ._block import BitMux, PcompBlock, PcompDirection, SeqBlock, TimeUnits
+from ._block import (
+    PandaBitMux,
+    PandaPcompDirection,
+    PandaTimeUnits,
+    PcompBlock,
+    SeqBlock,
+)
 from ._table import SeqTable
 
 
 class SeqTableInfo(BaseModel):
+    """Info for the PandA `SeqTable` for flyscanning."""
+
     sequence_table: SeqTable = Field(strict=True)
     repeats: int = Field(ge=0)
     prescale_as_us: float = Field(default=1, ge=0)  # microseconds
 
 
 class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
+    """For controlling the PandA `SeqTable` when flyscanning."""
+
     def __init__(self, seq: SeqBlock) -> None:
         self.seq = seq
 
     async def prepare(self, value: SeqTableInfo):
         await asyncio.gather(
-            self.seq.prescale_units.set(TimeUnits.US),
-            self.seq.enable.set(BitMux.ZERO),
+            self.seq.prescale_units.set(PandaTimeUnits.US),
+            self.seq.enable.set(PandaBitMux.ZERO),
         )
         await asyncio.gather(
             self.seq.prescale.set(value.prescale_as_us),
@@ -30,18 +40,20 @@ class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
         )
 
     async def kickoff(self) -> None:
-        await self.seq.enable.set(BitMux.ONE)
+        await self.seq.enable.set(PandaBitMux.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(BitMux.ZERO)
+        await self.seq.enable.set(PandaBitMux.ZERO)
         await wait_for_value(self.seq.active, False, timeout=1)
 
 
 class PcompInfo(BaseModel):
+    """Info for the PandA `PcompBlock` for flyscanning."""
+
     start_postion: int = Field(description="start position in counts")
     pulse_width: int = Field(description="width of a single pulse in counts", gt=0)
     rising_edge_step: int = Field(
@@ -54,7 +66,7 @@ class PcompInfo(BaseModel):
         ),
         ge=0,
     )
-    direction: PcompDirection = Field(
+    direction: PandaPcompDirection = Field(
         description=(
             "Specifies which direction the motor counts should be "
             "moving. Pulses won't be sent unless the values are moving in "
@@ -64,11 +76,13 @@ class PcompInfo(BaseModel):
 
 
 class StaticPcompTriggerLogic(FlyerController[PcompInfo]):
+    """For controlling the PandA `PcompBlock` when flyscanning."""
+
     def __init__(self, pcomp: PcompBlock) -> None:
         self.pcomp = pcomp
 
     async def prepare(self, value: PcompInfo):
-        await self.pcomp.enable.set(BitMux.ZERO)
+        await self.pcomp.enable.set(PandaBitMux.ZERO)
         await asyncio.gather(
             self.pcomp.start.set(value.start_postion),
             self.pcomp.width.set(value.pulse_width),
@@ -78,12 +92,12 @@ class StaticPcompTriggerLogic(FlyerController[PcompInfo]):
         )
 
     async def kickoff(self) -> None:
-        await self.pcomp.enable.set(BitMux.ONE)
+        await self.pcomp.enable.set(PandaBitMux.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(BitMux.ZERO)
+        await self.pcomp.enable.set(PandaBitMux.ZERO)
         await wait_for_value(self.pcomp.active, False, timeout=1)

ophyd_async/fastcs/panda/_writer.py

@@ -4,24 +4,23 @@ from pathlib import Path
 
 from bluesky.protocols import StreamAsset
 from event_model import DataKey
-from p4p.client.thread import Context
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     DetectorWriter,
-    HDFDataset,
-    HDFFile,
+    HDFDatasetDescription,
+    HDFDocumentComposer,
     NameProvider,
     PathProvider,
     observe_value,
     wait_for_value,
 )
 
-from ._block import CaptureMode, DataBlock
+from ._block import DataBlock, PandaCaptureMode
 
 
 class PandaHDFWriter(DetectorWriter):
-    _ctxt: Context | None = None
+    """For writing for PandA data from the `DataBlock`."""
 
     def __init__(
         self,
@@ -32,18 +31,17 @@ class PandaHDFWriter(DetectorWriter):
         self.panda_data_block = panda_data_block
         self._path_provider = path_provider
         self._name_provider = name_provider
-        self._datasets: list[HDFDataset] = []
-        self._file: HDFFile | None = None
+        self._datasets: list[HDFDatasetDescription] = []
+        self._composer: HDFDocumentComposer | None = None
         self._multiplier = 1
 
     # Triggered on PCAP arm
     async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
-        """Retrieve and get descriptor of all PandA signals marked for capture"""
-
+        """Retrieve and get descriptor of all PandA signals marked for capture."""
         # Ensure flushes are immediate
         await self.panda_data_block.flush_period.set(0)
 
-        self._file = None
+        self._composer = None
         info = self._path_provider(device_name=self._name_provider())
 
         # Set create dir depth first to guarantee that callback when setting
@@ -56,7 +54,7 @@ class PandaHDFWriter(DetectorWriter):
             self.panda_data_block.hdf_file_name.set(
                 f"{info.filename}.h5",
             ),
-            self.panda_data_block.capture_mode.set(CaptureMode.FOREVER),
+            self.panda_data_block.capture_mode.set(PandaCaptureMode.FOREVER),
         )
 
         # Make sure that directory exists or has been created.
@@ -76,18 +74,15 @@ class PandaHDFWriter(DetectorWriter):
         return await self._describe()
 
     async def _describe(self) -> dict[str, DataKey]:
-        """
-        Return a describe based on the datasets PV
-        """
-
+        """Return a describe based on the datasets PV."""
         await self._update_datasets()
         describe = {
             ds.data_key: DataKey(
                 source=self.panda_data_block.hdf_directory.source,
                 shape=list(ds.shape),
-                dtype="array" if ds.shape != [1] else "number",
+                dtype="number",
                 # PandA data should always be written as Float64
-                dtype_numpy="<f8",
+                dtype_numpy=ds.dtype_numpy,
                 external="STREAM:",
             )
             for ds in self._datasets
@@ -95,17 +90,19 @@ 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.
-        """
-
+        # Load data from the datasets PV on the panda, update internal
+        # representation of datasets that the panda will write.
         capture_table = await self.panda_data_block.datasets.get_value()
         self._datasets = [
             # TODO: Update chunk size to read signal once available in IOC
             # Currently PandA IOC sets chunk size to 1024 points per chunk
-            HDFDataset(
-                dataset_name, "/" + dataset_name, [1], multiplier=1, chunk_shape=(1024,)
+            HDFDatasetDescription(
+                data_key=dataset_name,
+                dataset="/" + dataset_name,
+                shape=(),
+                dtype_numpy="<f8",
+                multiplier=1,
+                chunk_shape=(1024,),
             )
             for dataset_name in capture_table.name
         ]
@@ -135,9 +132,9 @@ class PandaHDFWriter(DetectorWriter):
         return await self.panda_data_block.num_captured.get_value()
 
     async def observe_indices_written(
-        self, timeout=DEFAULT_TIMEOUT
+        self, timeout: float
     ) -> AsyncGenerator[int, None]:
-        """Wait until a specific index is ready to be collected"""
+        """Wait until a specific index is ready to be collected."""
         async for num_captured in observe_value(
             self.panda_data_block.num_captured, timeout
         ):
@@ -148,15 +145,15 @@ class PandaHDFWriter(DetectorWriter):
     ) -> AsyncIterator[StreamAsset]:
         # TODO: fail if we get dropped frames
         if indices_written:
-            if not self._file:
-                self._file = HDFFile(
+            if not self._composer:
+                self._composer = HDFDocumentComposer(
                     Path(await self.panda_data_block.hdf_directory.get_value())
                     / Path(await self.panda_data_block.hdf_file_name.get_value()),
                     self._datasets,
                 )
-                for doc in self._file.stream_resources():
+                for doc in self._composer.stream_resources():
                     yield "stream_resource", doc
-            for doc in self._file.stream_data(indices_written):
+            for doc in self._composer.stream_data(indices_written):
                 yield "stream_datum", doc
 
     # Could put this function as default for StandardDetector

ophyd_async/plan_stubs/__init__.py

@@ -1,3 +1,5 @@
+"""Plan stubs for connecting, setting up and flying devices."""
+
 from ._ensure_connected import ensure_connected
 from ._fly import (
     fly_and_collect,
@@ -5,6 +7,14 @@ from ._fly import (
     time_resolved_fly_and_collect_with_static_seq_table,
 )
 from ._nd_attributes import setup_ndattributes, setup_ndstats_sum
+from ._panda import apply_panda_settings
+from ._settings import (
+    apply_settings,
+    apply_settings_if_different,
+    get_current_settings,
+    retrieve_settings,
+    store_settings,
+)
 
 __all__ = [
     "fly_and_collect",
@@ -13,4 +23,10 @@ __all__ = [
     "ensure_connected",
     "setup_ndattributes",
     "setup_ndstats_sum",
+    "apply_panda_settings",
+    "apply_settings",
+    "apply_settings_if_different",
+    "get_current_settings",
+    "retrieve_settings",
+    "store_settings",
 ]

ophyd_async/plan_stubs/_ensure_connected.py

@@ -1,33 +1,28 @@
-from collections.abc import Awaitable
-
-import bluesky.plan_stubs as bps
+from bluesky.utils import plan
 
 from ophyd_async.core import DEFAULT_TIMEOUT, Device, LazyMock, wait_for_connection
 
+from ._wait_for_awaitable import wait_for_awaitable
+
 
+@plan
 def ensure_connected(
     *devices: Device,
     mock: bool | LazyMock = False,
     timeout: float = DEFAULT_TIMEOUT,
     force_reconnect=False,
 ):
+    """Plan stub to ensure devices are connected with a given timeout."""
     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()
+    coros = {
+        device.name: device.connect(
+            mock=mock, timeout=timeout, force_reconnect=force_reconnect
+        )
+        for device in devices
+    }
+    yield from wait_for_awaitable(wait_for_connection(**coros))

ophyd_async/plan_stubs/_fly.py

@@ -9,7 +9,7 @@ from ophyd_async.core import (
     in_micros,
 )
 from ophyd_async.fastcs.panda import (
-    PcompDirection,
+    PandaPcompDirection,
     PcompInfo,
     SeqTable,
     SeqTableInfo,
@@ -28,7 +28,6 @@ def prepare_static_pcomp_flyer_and_detectors(
     same trigger.
 
     """
-
     for det in detectors:
         yield from bps.prepare(det, trigger_info, wait=False, group="prep")
     yield from bps.prepare(flyer, pcomp_info, wait=False, group="prep")
@@ -58,7 +57,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
     if not detectors:
         raise ValueError("No detectors provided. There must be at least one.")
 
-    deadtime = max(det.controller.get_deadtime(exposure) for det in detectors)
+    deadtime = max(det._controller.get_deadtime(exposure) for det in detectors)  # noqa: SLF001
 
     trigger_info = TriggerInfo(
         number_of_triggers=number_of_frames * repeats,
@@ -147,7 +146,7 @@ def fly_and_collect_with_static_pcomp(
     number_of_pulses: int,
     pulse_width: int,
     rising_edge_step: int,
-    direction: PcompDirection,
+    direction: PandaPcompDirection,
     trigger_info: TriggerInfo,
 ):
     # Set up scan and prepare trigger
@@ -190,7 +189,6 @@ def time_resolved_fly_and_collect_with_static_seq_table(
     stages/unstages the devices, and opens and closes the run.
 
     """
-
     # Set up scan and prepare trigger
     yield from prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
         flyer,

ophyd_async/plan_stubs/_nd_attributes.py

@@ -16,6 +16,7 @@ from ophyd_async.epics.adcore import (
 def setup_ndattributes(
     device: NDArrayBaseIO, ndattributes: Sequence[NDAttributePv | NDAttributeParam]
 ):
+    """Set up attributes on NdArray devices."""
     root = ET.Element("Attributes")
 
     for ndattribute in ndattributes:
@@ -50,11 +51,14 @@ def setup_ndattributes(
 
 
 def setup_ndstats_sum(detector: Device):
-    hdf = getattr(detector, "hdf", None)
-    assert isinstance(hdf, NDFileHDFIO), (
-        f"Expected {detector.name} to have 'hdf' attribute that is an NDFilHDFIO, "
-        f"got {hdf}"
-    )
+    """Set up nd stats for a detector."""
+    hdf = getattr(detector, "fileio", None)
+    if not isinstance(hdf, NDFileHDFIO):
+        msg = (
+            f"Expected {detector.name} to have 'fileio' attribute that is an "
+            f"NDFileHDFIO, got {hdf}"
+        )
+        raise TypeError(msg)
     yield from (
         setup_ndattributes(
             hdf,

ophyd_async/plan_stubs/_panda.py

@@ -0,0 +1,14 @@
+from bluesky.utils import MsgGenerator, plan
+
+from ophyd_async.core import Settings
+from ophyd_async.fastcs import panda
+
+from ._settings import apply_settings
+
+
+@plan
+def apply_panda_settings(settings: Settings[panda.HDFPanda]) -> MsgGenerator[None]:
+    """Apply given settings to a panda device."""
+    units, others = settings.partition(lambda signal: signal.name.endswith("_units"))
+    yield from apply_settings(units)
+    yield from apply_settings(others)