ophyd-async 0.8.0a5__py3-none-any.whl → 0.9.0__py3-none-any.whl

ophyd_async/epics/testing/test_records.db

@@ -0,0 +1,174 @@
+record(bo, "$(device)bool") {
+  field(ZNAM, "No")
+  field(ONAM, "Yes")
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
+record(bo, "$(device)bool_unnamed") {
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
+record(longout, "$(device)int") {
+  field(LLSV, "MAJOR") # LOLO is alarm
+  field(LSV, "MINOR") # LOW is warning
+  field(HSV, "MINOR") # HIGH is warning
+  field(HHSV, "MAJOR") # HIHI is alarm
+  field(HOPR, "100")
+  field(HIHI, "98")
+  field(HIGH, "96")
+  field(DRVH, "90")
+  field(DRVL, "10")
+  field(LOW, "5")
+  field(LOLO, "2")
+  field(LOPR, "0")
+  field(VAL, "42")
+  field(PINI, "YES")
+}
+
+record(longout, "$(device)partialint") {
+  field(LLSV, "MAJOR") # LOLO is alarm
+  field(HHSV, "MAJOR") # HIHI is alarm
+  field(HOPR, "100")
+  field(HIHI, "98")
+  field(DRVH, "90")
+  field(DRVL, "10")
+  field(LOLO, "2")
+  field(LOPR, "0")
+  field(VAL, "42")
+  field(PINI, "YES")
+}
+
+record(longout, "$(device)lessint") {
+  field(HSV, "MINOR") # LOW is warning
+  field(LSV, "MINOR") # HIGH is warning
+  field(HOPR, "100")
+  field(HIGH, "98")
+  field(LOW, "2")
+  field(LOPR, "0")
+  field(VAL, "42")
+  field(PINI, "YES")
+}
+
+record(ao, "$(device)float") {
+  field(PREC, "1")
+  field(EGU, "mm")
+  field(VAL, "3.141")
+  field(PINI, "YES")
+}
+
+record(ao, "$(device)float_prec_0") {
+  field(PREC, "0")
+  field(EGU, "mm")
+  field(VAL, "3")
+  field(PINI, "YES")
+}
+
+record(ao, "$(device)float_prec_1") {
+  field(PREC, "1")
+  field(EGU, "mm")
+  field(VAL, "3")
+  field(PINI, "YES")
+}
+
+record(stringout, "$(device)str") {
+  field(VAL, "hello")
+  field(PINI, "YES")
+}
+
+record(mbbo, "$(device)enum") {
+  field(ZRST, "Aaa")
+  field(ZRVL, "5")
+  field(ONST, "Bbb")
+  field(ONVL, "6")
+  field(TWST, "Ccc")
+  field(TWVL, "7")
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
+record(mbbo, "$(device)enum2") {
+  field(ZRST, "Aaa")
+  field(ONST, "Bbb")
+  field(TWST, "Ccc")
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
+record(mbbo, "$(device)subset_enum") {
+  field(ZRST, "Aaa")
+  field(ONST, "Bbb")
+  field(TWST, "Ccc")
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
+record(mbbo, "$(device)enum_str_fallback") {
+  field(ZRST, "Aaa")
+  field(ONST, "Bbb")
+  field(TWST, "Ccc")
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)uint8a") {
+  field(NELM, "3")
+  field(FTVL, "UCHAR")
+  field(INP, {const:[0, 255]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)int16a") {
+  field(NELM, "3")
+  field(FTVL, "SHORT")
+  field(INP, {const:[-32768, 32767]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)int32a") {
+  field(NELM, "3")
+  field(FTVL, "LONG")
+  field(INP, {const:[-2147483648, 2147483647]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)float32a") {
+  field(NELM, "3")
+  field(FTVL, "FLOAT")
+  field(INP, {const:[0.000002, -123.123]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)float64a") {
+  field(NELM, "3")
+  field(FTVL, "DOUBLE")
+  field(INP, {const:[0.1, -12345678.123]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)stra") {
+  field(NELM, "3")
+  field(FTVL, "STRING")
+  field(INP, {const:["five", "six", "seven"]})
+  field(PINI, "YES")
+}
+
+record(waveform, "$(device)longstr") {
+  field(NELM, "80")
+  field(FTVL, "CHAR")
+  field(INP, {const:"a string that is just longer than forty characters"})
+  field(PINI, "YES")
+}
+
+record(lsi, "$(device)longstr2") {
+  field(SIZV, "80")
+  field(INP, {const:"a string that is just longer than forty characters"})
+  field(PINI, "YES")
+}
+
+record(calc, "$(device)ticking") {
+  field(INPA, "$(device)ticking")
+  field(CALC, "A+1")
+  field(SCAN, ".1 second")
+}

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

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

ophyd_async/fastcs/panda/__init__.py

@@ -23,7 +23,6 @@ from ._trigger import (
     StaticPcompTriggerLogic,
     StaticSeqTableTriggerLogic,
 )
-from ._utils import phase_sorter
 from ._writer import PandaHDFWriter
 
 __all__ = [
@@ -47,5 +46,4 @@ __all__ = [
     "SeqTableInfo",
     "StaticPcompTriggerLogic",
     "StaticSeqTableTriggerLogic",
-    "phase_sorter",
 ]

ophyd_async/fastcs/panda/_block.py

@@ -36,14 +36,14 @@ class PulseBlock(Device):
 
 
 class PcompDirection(StrictEnum):
-    positive = "Positive"
-    negative = "Negative"
-    either = "Either"
+    POSITIVE = "Positive"
+    NEGATIVE = "Negative"
+    EITHER = "Either"
 
 
 class BitMux(SubsetEnum):
-    zero = "ZERO"
-    one = "ONE"
+    ZERO = "ZERO"
+    ONE = "ONE"
 
 
 class PcompBlock(Device):
@@ -57,10 +57,10 @@ class PcompBlock(Device):
 
 
 class TimeUnits(StrictEnum):
-    min = "min"
-    s = "s"
-    ms = "ms"
-    us = "us"
+    MIN = "min"
+    S = "s"
+    MS = "ms"
+    US = "us"
 
 
 class SeqBlock(Device):

ophyd_async/fastcs/panda/_control.py

@@ -18,10 +18,15 @@ class PandaPcapController(DetectorController):
         return 0.000000008
 
     async def prepare(self, trigger_info: TriggerInfo):
-        assert trigger_info.trigger in (
-            DetectorTrigger.constant_gate,
-            DetectorTrigger.variable_gate,
-        ), "Only constant_gate and variable_gate triggering is supported on the PandA"
+        if trigger_info.trigger not in (
+            DetectorTrigger.CONSTANT_GATE,
+            DetectorTrigger.VARIABLE_GATE,
+        ):
+            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)

ophyd_async/fastcs/panda/_hdf_panda.py

@@ -9,8 +9,12 @@ from ._block import CommonPandaBlocks
 from ._control import PandaPcapController
 from ._writer import PandaHDFWriter
 
+MINIMUM_PANDA_IOC = "0.11.4"
 
-class HDFPanda(CommonPandaBlocks, StandardDetector):
+
+class HDFPanda(
+    CommonPandaBlocks, StandardDetector[PandaPcapController, PandaHDFWriter]
+):
     def __init__(
         self,
         prefix: str,
@@ -18,8 +22,9 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
         config_sigs: Sequence[SignalR] = (),
         name: str = "",
     ):
+        error_hint = f"Is PandABlocks-ioc at least version {MINIMUM_PANDA_IOC}?"
         # This has to be first so we make self.pcap
-        connector = fastcs_connector(self, prefix)
+        connector = fastcs_connector(self, prefix, error_hint)
         controller = PandaPcapController(pcap=self.pcap)
         writer = PandaHDFWriter(
             path_provider=path_provider,

ophyd_async/fastcs/panda/_table.py

@@ -83,5 +83,8 @@ class SeqTable(Table):
         """
 
         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

@@ -20,8 +20,8 @@ class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
 
     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(TimeUnits.US),
+            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(BitMux.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(BitMux.zero)
+        await self.seq.enable.set(BitMux.ZERO)
         await wait_for_value(self.seq.active, False, timeout=1)
 
 
@@ -68,7 +68,7 @@ class StaticPcompTriggerLogic(FlyerController[PcompInfo]):
         self.pcomp = pcomp
 
     async def prepare(self, value: PcompInfo):
-        await self.pcomp.enable.set(BitMux.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(BitMux.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(BitMux.zero)
+        await self.pcomp.enable.set(BitMux.ZERO)
         await wait_for_value(self.pcomp.active, False, timeout=1)

ophyd_async/plan_stubs/__init__.py

@@ -5,6 +5,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 +21,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,10 +1,11 @@
-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,
@@ -17,17 +18,10 @@ def ensure_connected(
     }
     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

@@ -58,11 +58,11 @@ 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,
-        trigger=DetectorTrigger.constant_gate,
+        trigger=DetectorTrigger.CONSTANT_GATE,
         deadtime=deadtime,
         livetime=exposure,
         frame_timeout=frame_timeout,

ophyd_async/plan_stubs/_nd_attributes.py

@@ -50,11 +50,13 @@ 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}"
-    )
+    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,13 @@
+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]:
+    units, others = settings.partition(lambda signal: signal.name.endswith("_units"))
+    yield from apply_settings(units)
+    yield from apply_settings(others)