ophyd-async 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

ophyd_async/epics/testing/test_records_pva.db

@@ -0,0 +1,177 @@
+record(waveform, "$(device)int8a") {
+  field(NELM, "3")
+  field(FTVL, "CHAR")
+  field(INP, {const:[-128, 127]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)uint16a") {
+  field(NELM, "3")
+  field(FTVL, "USHORT")
+  field(INP, {const:[0, 65535]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)uint32a") {
+  field(NELM, "3")
+  field(FTVL, "ULONG")
+  field(INP, {const:[0, 4294967295]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)int64a") {
+  field(NELM, "3")
+  field(FTVL, "INT64")
+  # Can't do 64-bit int with JSON numbers in a const link...
+  field(INP, {const:[-2147483649, 2147483648]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)uint64a") {
+  field(NELM, "3")
+  field(FTVL, "UINT64")
+  field(INP, {const:[0, 4294967297]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)table:labels") {
+    field(FTVL, "STRING")
+    field(NELM, "5")
+    field(INP, {const:["Bool", "Int", "Float", "Str", "Enum"]})
+    field(PINI, "YES")
+    info(Q:group, {
+        "$(device)table": {
+            "+id": "epics:nt/NTTable:1.0",
+            "labels": {
+                "+type": "plain",
+                "+channel": "VAL"
+            }
+        }
+    })
+}
+
+record(waveform, "$(device)table:bool")
+{
+    field(FTVL, "UCHAR")
+    field(NELM, "4096")
+    field(INP, {const:[false, false, true, true]})
+    field(PINI, "YES")
+    info(Q:group, {
+        "$(device)table": {
+            "value.bool": {
+                "+type": "plain",
+                "+channel": "VAL",
+                "+putorder": 1
+            }
+        }
+    })
+}
+
+record(waveform, "$(device)table:int")
+{
+    field(FTVL, "LONG")
+    field(NELM, "4096")
+    field(INP, {const:[1, 8, -9, 32]})
+    field(PINI, "YES")
+    info(Q:group, {
+        "$(device)table": {
+            "value.int": {
+                "+type": "plain",
+                "+channel": "VAL",
+                "+putorder": 2
+            }
+        }
+    })
+}
+
+record(waveform, "$(device)table:float")
+{
+    field(FTVL, "DOUBLE")
+    field(NELM, "4096")
+    field(INP, {const:[1.8, 8.2, -6, 32.9887]})
+    field(PINI, "YES")
+    info(Q:group, {
+        "$(device)table": {
+            "value.float": {
+                "+type": "plain",
+                "+channel": "VAL",
+                "+putorder": 3
+            }
+        }
+    })
+}
+
+record(waveform, "$(device)table:str")
+{
+    field(FTVL, "STRING")
+    field(NELM, "4096")
+    field(INP, {const:["Hello", "World", "Foo", "Bar"]})
+    field(PINI, "YES")
+    info(Q:group, {
+        "$(device)table": {
+            "value.str": {
+                "+type": "plain",
+                "+channel": "VAL",
+                "+putorder": 4
+            }
+        }
+    })
+}
+
+record(waveform, "$(device)table:enum")
+{
+    field(FTVL, "STRING")
+    field(NELM, "4096")
+    field(INP, {const:["Aaa", "Bbb", "Aaa", "Ccc"]})
+    field(PINI, "YES")
+    info(Q:group, {
+        "$(device)table": {
+            "value.enum": {
+                "+type": "plain",
+                "+channel": "VAL",
+                "+putorder": 5,
+                "+trigger": "*",
+            },
+            "": {"+type": "meta", "+channel": "VAL"}
+        }
+    })
+}
+
+record(longout, "$(device)ntndarray:ArraySize0_RBV") {
+    field(VAL, "3")
+    field(PINI, "YES")
+    info(Q:group, {
+        "$(device)ntndarray":{
+            "dimension[0].size":{+channel:"VAL", +type:"plain", +putorder:0}
+        }
+    })
+}
+
+record(longout, "$(device)ntndarray:ArraySize1_RBV") {
+    field(VAL, "2")
+    field(PINI, "YES")
+    info(Q:group, {
+        "$(device)ntndarray":{
+            "dimension[1].size":{+channel:"VAL", +type:"plain", +putorder:0}
+        }
+    })
+}
+
+record(waveform, "$(device)ntndarray:data")
+{
+  field(FTVL, "INT64")
+  field(NELM, "6")
+  field(INP, {const:[0, 0, 0, 0, 0, 0]})
+  field(PINI, "YES")
+  info(Q:group, {
+        "$(device)ntndarray":{
+            +id:"epics:nt/NTNDArray:1.0",
+            "value":{
+                +type:"any",
+                +channel:"VAL",
+                +trigger:"*",
+            },
+            "": {+type:"meta", +channel:"SEVR"}
+        }
+    })
+}

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,13 +1,16 @@
-from __future__ import annotations
-
-from enum import Enum
-
-from ophyd_async.core import Device, DeviceVector, SignalR, SignalRW, SubsetEnum
+from ophyd_async.core import (
+    Device,
+    DeviceVector,
+    SignalR,
+    SignalRW,
+    StrictEnum,
+    SubsetEnum,
+)
 
 from ._table import DatasetTable, SeqTable
 
 
-class CaptureMode(str, Enum):
+class CaptureMode(StrictEnum):
     FIRST_N = "FIRST_N"
     LAST_N = "LAST_N"
     FOREVER = "FOREVER"
@@ -32,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"
@@ -60,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_]
-    hdf5_type: Sequence[PandaHdf5DatasetType]
+class DatasetTable(Table):
+    name: Sequence[str]
+    dtype: 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

@@ -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] = []
@@ -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

ophyd_async/plan_stubs/_ensure_connected.py

@@ -1,26 +1,33 @@
+from collections.abc import Awaitable
+
 import bluesky.plan_stubs as bps
 
-from ophyd_async.core import DEFAULT_TIMEOUT, Device, wait_for_connection
+from ophyd_async.core import DEFAULT_TIMEOUT, Device, LazyMock, wait_for_connection
 
 
 def ensure_connected(
     *devices: Device,
-    mock: bool = False,
+    mock: bool | LazyMock = False,
     timeout: float = DEFAULT_TIMEOUT,
     force_reconnect=False,
 ):
-    (connect_task,) = yield from bps.wait_for(
-        [
-            lambda: wait_for_connection(
-                **{
-                    device.name: device.connect(
-                        mock=mock, timeout=timeout, force_reconnect=force_reconnect
-                    )
-                    for device in devices
-                }
+    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()

ophyd_async/plan_stubs/_fly.py

@@ -9,7 +9,7 @@ from ophyd_async.core import (
     in_micros,
 )
 from ophyd_async.fastcs.panda import (
-    PcompDirectionOptions,
+    PcompDirection,
     PcompInfo,
     SeqTable,
     SeqTableInfo,
@@ -147,7 +147,7 @@ def fly_and_collect_with_static_pcomp(
     number_of_pulses: int,
     pulse_width: int,
     rising_edge_step: int,
-    direction: PcompDirectionOptions,
+    direction: PcompDirection,
     trigger_info: TriggerInfo,
 ):
     # Set up scan and prepare trigger

ophyd_async/plan_stubs/_nd_attributes.py

@@ -16,12 +16,12 @@ from ophyd_async.epics.adcore import (
 def setup_ndattributes(
     device: NDArrayBaseIO, ndattributes: Sequence[NDAttributePv | NDAttributeParam]
 ):
-    xml_text = ET.Element("Attributes")
+    root = ET.Element("Attributes")
 
     for ndattribute in ndattributes:
         if isinstance(ndattribute, NDAttributeParam):
             ET.SubElement(
-                xml_text,
+                root,
                 "Attribute",
                 name=ndattribute.name,
                 type="PARAM",
@@ -32,7 +32,7 @@ def setup_ndattributes(
             )
         elif isinstance(ndattribute, NDAttributePv):
             ET.SubElement(
-                xml_text,
+                root,
                 "Attribute",
                 name=ndattribute.name,
                 type="EPICS_PV",
@@ -45,7 +45,8 @@ def setup_ndattributes(
                 f"Invalid type for ndattributes: {type(ndattribute)}. "
                 "Expected NDAttributePv or NDAttributeParam."
             )
-    yield from bps.mv(device.nd_attributes_file, xml_text)
+    xml_text = ET.tostring(root, encoding="unicode")
+    yield from bps.abs_set(device.nd_attributes_file, xml_text, wait=True)
 
 
 def setup_ndstats_sum(detector: Device):

ophyd_async/sim/demo/_pattern_detector/_pattern_detector_controller.py

@@ -1,7 +1,6 @@
 import asyncio
 
-from ophyd_async.core import DetectorController, PathProvider
-from ophyd_async.core._detector import TriggerInfo
+from ophyd_async.core import DetectorController, PathProvider, TriggerInfo
 
 from ._pattern_generator import PatternGenerator