ophyd-async 0.8.0a5__py3-none-any.whl → 0.9.0a1__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

@@ -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/_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

@@ -19,8 +19,8 @@ class PandaPcapController(DetectorController):
 
     async def prepare(self, trigger_info: TriggerInfo):
         assert trigger_info.trigger in (
-            DetectorTrigger.constant_gate,
-            DetectorTrigger.variable_gate,
+            DetectorTrigger.CONSTANT_GATE,
+            DetectorTrigger.VARIABLE_GATE,
         ), "Only constant_gate and variable_gate triggering is supported on the PandA"
 
     async def arm(self):

ophyd_async/fastcs/panda/_hdf_panda.py

@@ -9,6 +9,8 @@ from ._block import CommonPandaBlocks
 from ._control import PandaPcapController
 from ._writer import PandaHDFWriter
 
+MINIMUM_PANDA_IOC = "0.11.4"
+
 
 class HDFPanda(CommonPandaBlocks, StandardDetector):
     def __init__(
@@ -18,8 +20,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/_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/_fly.py

@@ -62,7 +62,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
 
     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/sim/demo/_sim_motor.py

@@ -2,6 +2,7 @@ import asyncio
 import contextlib
 import time
 
+import numpy as np
 from bluesky.protocols import Movable, Stoppable
 
 from ophyd_async.core import (
@@ -44,22 +45,20 @@ class SimMotor(StandardReadable, Movable, Stoppable):
 
     async def _move(self, old_position: float, new_position: float, move_time: float):
         start = time.monotonic()
-        distance = abs(new_position - old_position)
-        while True:
-            time_elapsed = round(time.monotonic() - start, 2)
-
-            # update position based on time elapsed
-            if time_elapsed >= move_time:
-                # successfully reached our target position
-                self._user_readback_set(new_position)
-                break
-            else:
-                current_position = old_position + distance * time_elapsed / move_time
-
-            self._user_readback_set(current_position)
-
-            # 10hz update loop
-            await asyncio.sleep(0.1)
+        # Make an array of relative update times at 10Hz intervals
+        update_times = np.arange(0.1, move_time, 0.1)
+        # With the end position appended
+        update_times = np.concatenate((update_times, [move_time]))
+        # Interpolate the [old, new] position array with those update times
+        new_positions = np.interp(
+            update_times, [0, move_time], [old_position, new_position]
+        )
+        for update_time, new_position in zip(update_times, new_positions, strict=True):
+            # Calculate how long to wait to get there
+            relative_time = time.monotonic() - start
+            await asyncio.sleep(update_time - relative_time)
+            # Update the readback position
+            self._user_readback_set(new_position)
 
     @WatchableAsyncStatus.wrap
     async def set(self, value: float):
@@ -75,22 +74,25 @@ class SimMotor(StandardReadable, Movable, Stoppable):
             self.velocity.get_value(),
         )
         # If zero velocity, do instant move
-        move_time = abs(new_position - old_position) / velocity if velocity else 0
-        self._move_status = AsyncStatus(
-            self._move(old_position, new_position, move_time)
-        )
-        # If stop is called then this will raise a CancelledError, ignore it
-        with contextlib.suppress(asyncio.CancelledError):
-            async for current_position in observe_value(
-                self.user_readback, done_status=self._move_status
-            ):
-                yield WatcherUpdate(
-                    current=current_position,
-                    initial=old_position,
-                    target=new_position,
-                    name=self.name,
-                    unit=units,
-                )
+        if velocity == 0:
+            self._user_readback_set(new_position)
+        else:
+            move_time = abs(new_position - old_position) / velocity
+            self._move_status = AsyncStatus(
+                self._move(old_position, new_position, move_time)
+            )
+            # If stop is called then this will raise a CancelledError, ignore it
+            with contextlib.suppress(asyncio.CancelledError):
+                async for current_position in observe_value(
+                    self.user_readback, done_status=self._move_status
+                ):
+                    yield WatcherUpdate(
+                        current=current_position,
+                        initial=old_position,
+                        target=new_position,
+                        name=self.name,
+                        unit=units,
+                    )
         if not self._set_success:
             raise RuntimeError("Motor was stopped")
 

ophyd_async/tango/__init__.py

@@ -1,43 +0,0 @@
-from .base_devices import (
-    TangoDevice,
-    TangoReadable,
-    tango_polling,
-)
-from .signal import (
-    AttributeProxy,
-    CommandProxy,
-    TangoSignalBackend,
-    ensure_proper_executor,
-    get_dtype_extended,
-    get_python_type,
-    get_tango_trl,
-    get_trl_descriptor,
-    infer_python_type,
-    infer_signal_type,
-    make_backend,
-    tango_signal_r,
-    tango_signal_rw,
-    tango_signal_w,
-    tango_signal_x,
-)
-
-__all__ = [
-    "TangoDevice",
-    "TangoReadable",
-    "tango_polling",
-    "TangoSignalBackend",
-    "get_python_type",
-    "get_dtype_extended",
-    "get_trl_descriptor",
-    "get_tango_trl",
-    "infer_python_type",
-    "infer_signal_type",
-    "make_backend",
-    "AttributeProxy",
-    "CommandProxy",
-    "ensure_proper_executor",
-    "tango_signal_r",
-    "tango_signal_rw",
-    "tango_signal_w",
-    "tango_signal_x",
-]

ophyd_async/tango/{signal → core}/__init__.py

@@ -1,3 +1,4 @@
+from ._base_device import TangoDevice, TangoPolling
 from ._signal import (
     infer_python_type,
     infer_signal_type,
@@ -7,6 +8,7 @@ from ._signal import (
     tango_signal_w,
     tango_signal_x,
 )
+from ._tango_readable import TangoReadable
 from ._tango_transport import (
     AttributeProxy,
     CommandProxy,
@@ -18,7 +20,7 @@ from ._tango_transport import (
     get_trl_descriptor,
 )
 
-__all__ = (
+__all__ = [
     "AttributeProxy",
     "CommandProxy",
     "ensure_proper_executor",
@@ -34,4 +36,7 @@ __all__ = (
     "tango_signal_rw",
     "tango_signal_w",
     "tango_signal_x",
-)
+    "TangoDevice",
+    "TangoReadable",
+    "TangoPolling",
+]

ophyd_async/tango/{base_devices → core}/_base_device.py

@@ -1,17 +1,14 @@
 from __future__ import annotations
 
-from typing import TypeVar
-
-from ophyd_async.core import Device, DeviceConnector, DeviceFiller
-from ophyd_async.core._utils import LazyMock
-from ophyd_async.tango.signal import (
-    TangoSignalBackend,
-    infer_python_type,
-    infer_signal_type,
-)
+from dataclasses import dataclass
+from typing import Any, Generic, TypeVar
+
+from ophyd_async.core import Device, DeviceConnector, DeviceFiller, LazyMock
 from tango import DeviceProxy as DeviceProxy
 from tango.asyncio import DeviceProxy as AsyncDeviceProxy
 
+from ._signal import TangoSignalBackend, infer_python_type, infer_signal_type
+
 T = TypeVar("T")
 
 
@@ -32,63 +29,45 @@ class TangoDevice(Device):
 
     trl: str = ""
     proxy: DeviceProxy | None = None
-    _polling: tuple[bool, float, float | None, float | None] = (False, 0.1, None, 0.1)
-    _signal_polling: dict[str, tuple[bool, float, float, float]] = {}
-    _poll_only_annotated_signals: bool = True
 
     def __init__(
         self,
         trl: str | None = None,
         device_proxy: DeviceProxy | None = None,
+        support_events: bool = False,
         name: str = "",
     ) -> None:
         connector = TangoDeviceConnector(
-            trl=trl,
-            device_proxy=device_proxy,
-            polling=self._polling,
-            signal_polling=self._signal_polling,
+            trl=trl, device_proxy=device_proxy, support_events=support_events
         )
         super().__init__(name=name, connector=connector)
 
 
-def tango_polling(
-    polling: tuple[float, float, float]
-    | dict[str, tuple[float, float, float]]
-    | None = None,
-    signal_polling: dict[str, tuple[float, float, float]] | None = None,
-):
-    """
-    Class decorator to configure polling for Tango devices.
-
-    This decorator allows for the configuration of both device-level and signal-level
-    polling for Tango devices. Polling is useful for device servers that do not support
-    event-driven updates.
-
-    Parameters
-    ----------
-    polling : Optional[Union[Tuple[float, float, float],
-              Dict[str, Tuple[float, float, float]]]], optional
-        Device-level polling configuration as a tuple of three floats representing the
-        polling interval, polling timeout, and polling delay. Alternatively,
-        a dictionary can be provided to specify signal-level polling configurations
-        directly.
-    signal_polling : Optional[Dict[str, Tuple[float, float, float]]], optional
-        Signal-level polling configuration as a dictionary where keys are signal names
-        and values are tuples of three floats representing the polling interval, polling
-        timeout, and polling delay.
-    """
-    if isinstance(polling, dict):
-        signal_polling = polling
-        polling = None
+@dataclass
+class TangoPolling(Generic[T]):
+    ophyd_polling_period: float = 0.1
+    abs_change: T | None = None
+    rel_change: T | None = None
 
-    def decorator(cls):
-        if polling is not None:
-            cls._polling = (True, *polling)
-        if signal_polling is not None:
-            cls._signal_polling = {k: (True, *v) for k, v in signal_polling.items()}
-        return cls
 
-    return decorator
+def fill_backend_with_polling(
+    support_events: bool, backend: TangoSignalBackend, annotations: list[Any]
+):
+    unhandled = []
+    while annotations:
+        annotation = annotations.pop(0)
+        backend.allow_events(support_events)
+        if isinstance(annotation, TangoPolling):
+            backend.set_polling(
+                not support_events,
+                annotation.ophyd_polling_period,
+                annotation.abs_change,
+                annotation.rel_change,
+            )
+        else:
+            unhandled.append(annotation)
+    annotations.extend(unhandled)
+    # These leftover annotations will now be handled by the iterator
 
 
 class TangoDeviceConnector(DeviceConnector):
@@ -96,13 +75,11 @@ class TangoDeviceConnector(DeviceConnector):
         self,
         trl: str | None,
         device_proxy: DeviceProxy | None,
-        polling: tuple[bool, float, float | None, float | None],
-        signal_polling: dict[str, tuple[bool, float, float, float]],
+        support_events: bool,
     ) -> None:
         self.trl = trl
         self.proxy = device_proxy
-        self._polling = polling
-        self._signal_polling = signal_polling
+        self._support_events = support_events
 
     def create_children_from_annotations(self, device: Device):
         if not hasattr(self, "filler"):
@@ -110,11 +87,14 @@ class TangoDeviceConnector(DeviceConnector):
                 device=device,
                 signal_backend_factory=TangoSignalBackend,
                 device_connector_factory=lambda: TangoDeviceConnector(
-                    None, None, (False, 0.1, None, None), {}
+                    None, None, self._support_events
                 ),
             )
             list(self.filler.create_devices_from_annotations(filled=False))
-            list(self.filler.create_signals_from_annotations(filled=False))
+            for backend, annotations in self.filler.create_signals_from_annotations(
+                filled=False
+            ):
+                fill_backend_with_polling(self._support_events, backend, annotations)
             self.filler.check_created()
 
     async def connect_mock(self, device: Device, mock: LazyMock):
@@ -145,12 +125,6 @@ class TangoDeviceConnector(DeviceConnector):
                 backend = self.filler.fill_child_signal(name, signal_type)
                 backend.datatype = await infer_python_type(full_trl, self.proxy)
                 backend.set_trl(full_trl)
-                if polling := self._signal_polling.get(name, ()):
-                    backend.set_polling(*polling)
-                    backend.allow_events(False)
-                elif self._polling[0]:
-                    backend.set_polling(*self._polling)
-                    backend.allow_events(False)
         # Check that all the requested children have been filled
         self.filler.check_filled(f"{self.trl}: {children}")
         # Set the name of the device to name all children

ophyd_async/tango/{signal → core}/_signal.py

@@ -16,7 +16,14 @@ from ophyd_async.core import (
     SignalW,
     SignalX,
 )
-from tango import AttrDataFormat, AttrWriteType, CmdArgType, DeviceProxy, DevState
+from tango import (
+    AttrDataFormat,
+    AttrWriteType,
+    CmdArgType,
+    DeviceProxy,
+    DevState,
+    NonSupportedFeature,  # type: ignore
+)
 from tango.asyncio import DeviceProxy as AsyncDeviceProxy
 
 from ._tango_transport import TangoSignalBackend, get_python_type
@@ -174,8 +181,11 @@ async def infer_signal_type(
     else:
         dev_proxy = proxy
 
-    if tr_name in dev_proxy.get_pipe_list():
-        raise NotImplementedError("Pipes are not supported")
+    try:
+        if tr_name in dev_proxy.get_pipe_list():
+            raise NotImplementedError("Pipes are not supported")
+    except NonSupportedFeature:  # type: ignore
+        pass
 
     if tr_name not in dev_proxy.get_attribute_list():
         if tr_name not in dev_proxy.get_command_list():

ophyd_async/tango/{base_devices → core}/_tango_readable.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
-from ophyd_async.core import (
-    StandardReadable,
-)
-from ophyd_async.tango.base_devices._base_device import TangoDevice
+from ophyd_async.core import StandardReadable
 from tango import DeviceProxy
 
+from ._base_device import TangoDevice
+
 
 class TangoReadable(TangoDevice, StandardReadable):
     """