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

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
@@ -38,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

@@ -15,6 +15,8 @@ MINIMUM_PANDA_IOC = "0.11.4"
 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,9 @@ 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)
         max_length = 4096
         if first_length > max_length:

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,

ophyd_async/plan_stubs/_ensure_connected.py

@@ -12,6 +12,7 @@ def ensure_connected(
     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

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")
@@ -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,6 +51,7 @@ def setup_ndattributes(
 
 
 def setup_ndstats_sum(detector: Device):
+    """Set up nd stats for a detector."""
     hdf = getattr(detector, "fileio", None)
     if not isinstance(hdf, NDFileHDFIO):
         msg = (

ophyd_async/plan_stubs/_panda.py

@@ -8,6 +8,7 @@ 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)

ophyd_async/plan_stubs/_settings.py

@@ -13,11 +13,12 @@ from ophyd_async.core import (
     Settings,
     SettingsProvider,
     SignalRW,
-    T,
+    walk_config_signals,
     walk_rw_signals,
 )
 from ophyd_async.core._table import Table
 
+from ._utils import T
 from ._wait_for_awaitable import wait_for_awaitable
 
 
@@ -32,8 +33,17 @@ def _get_values_of_signals(
 
 
 @plan
-def get_current_settings(device: Device) -> MsgGenerator[Settings]:
-    signals = walk_rw_signals(device)
+def get_current_settings(
+    device: Device, only_config: bool = False
+) -> MsgGenerator[Settings]:
+    """Get current settings on `Device`.
+
+    If `only_config` is True, get current configuration settings on `Configurable`.
+    """
+    if only_config:
+        signals = yield from wait_for_awaitable(walk_config_signals(device))
+    else:
+        signals = walk_rw_signals(device)
     named_values = yield from _get_values_of_signals(signals)
     signal_values = {signals[name]: value for name, value in named_values.items()}
     return Settings(device, signal_values)
@@ -41,23 +51,43 @@ def get_current_settings(device: Device) -> MsgGenerator[Settings]:
 
 @plan
 def store_settings(
-    provider: SettingsProvider, name: str, device: Device
+    provider: SettingsProvider, name: str, device: Device, only_config: bool = False
 ) -> MsgGenerator[None]:
-    """Walk a Device for SignalRWs and store their values with a provider associated
-    with the given name.
+    """Walk a Device for SignalRWs and store their values.
+
+    If `only_config` is True, store only configuration settings on `Configurable`.
+
+    :param provider: The provider to store the settings with.
+    :param name: The name to store the settings under.
+    :param device: The Device to walk for SignalRWs.
+    :param only_config: If True, store only configuration settings.
     """
-    signals = walk_rw_signals(device)
+    if only_config:
+        signals = yield from wait_for_awaitable(walk_config_signals(device))
+    else:
+        signals = walk_rw_signals(device)
     named_values = yield from _get_values_of_signals(signals)
     yield from wait_for_awaitable(provider.store(name, named_values))
 
 
 @plan
 def retrieve_settings(
-    provider: SettingsProvider, name: str, device: Device
+    provider: SettingsProvider, name: str, device: Device, only_config: bool = False
 ) -> MsgGenerator[Settings]:
-    """Retrieve named Settings for a Device from a provider."""
+    """Retrieve named Settings for a Device from a provider.
+
+    If `only_config` is True, retrieve only configuration settings on `Configurable`.
+
+    :param provider: The provider to retrieve the settings from.
+    :param name: The name of the settings to retrieve.
+    :param device: The Device to retrieve the settings for.
+    :param only_config: If True, retrieve only configuration settings.
+    """
     named_values = yield from wait_for_awaitable(provider.retrieve(name))
-    signals = walk_rw_signals(device)
+    if only_config:
+        signals = yield from wait_for_awaitable(walk_config_signals(device))
+    else:
+        signals = walk_rw_signals(device)
     unknown_names = set(named_values) - set(signals)
     if unknown_names:
         raise NameError(f"Unknown signal names {sorted(unknown_names)}")
@@ -83,15 +113,12 @@ def apply_settings_if_different(
     apply_plan: Callable[[Settings], MsgGenerator[None]],
     current_settings: Settings | None = None,
 ) -> MsgGenerator[None]:
-    """Set every SignalRW in settings to its given value if it is different to the
-    current value.
+    """Set every SignalRW in settings, only if it is different to the current value.
 
-    Parameters
-    ----------
-    apply_plan:
+    :param apply_plan:
         A device specific plan which takes the Settings to apply and applies them to
         the Device. Used to add device specific ordering to setting the signals.
-    current_settings:
+    :param current_settings:
         If given, should be a superset of settings containing the current value of
         the Settings in the Device. If not given it will be created by reading just
         the signals given in settings.

ophyd_async/plan_stubs/_utils.py

@@ -0,0 +1,3 @@
+from typing import TypeVar
+
+T = TypeVar("T")

ophyd_async/plan_stubs/_wait_for_awaitable.py

@@ -3,7 +3,7 @@ from collections.abc import Awaitable
 import bluesky.plan_stubs as bps
 from bluesky.utils import MsgGenerator, plan
 
-from ophyd_async.core import T
+from ._utils import T
 
 
 @plan

ophyd_async/sim/__init__.py

@@ -1,19 +1,29 @@
-from ._pattern_detector import (
-    DATA_PATH,
-    SUM_PATH,
-    PatternDetector,
-    PatternDetectorController,
-    PatternDetectorWriter,
-    PatternGenerator,
+"""Some simulated devices to be used in tutorials and testing."""
+
+from ._blob_detector import SimBlobDetector
+from ._mirror_horizontal import HorizontalMirror, HorizontalMirrorDerived
+from ._mirror_vertical import (
+    TwoJackDerived,
+    TwoJackRaw,
+    TwoJackTransform,
+    VerticalMirror,
 )
-from ._sim_motor import SimMotor
+from ._motor import FlySimMotorInfo, SimMotor
+from ._pattern_generator import PatternGenerator
+from ._point_detector import SimPointDetector
+from ._stage import SimStage
 
 __all__ = [
-    "DATA_PATH",
-    "SUM_PATH",
-    "PatternGenerator",
-    "PatternDetector",
-    "PatternDetectorController",
-    "PatternDetectorWriter",
     "SimMotor",
+    "FlySimMotorInfo",
+    "SimStage",
+    "PatternGenerator",
+    "SimPointDetector",
+    "SimBlobDetector",
+    "VerticalMirror",
+    "HorizontalMirror",
+    "HorizontalMirrorDerived",
+    "TwoJackTransform",
+    "TwoJackDerived",
+    "TwoJackRaw",
 ]