ophyd-async 0.8.0a4__py3-none-any.whl → 0.8.0a6__py3-none-any.whl

ophyd_async/epics/testing/test_records.db

@@ -0,0 +1,152 @@
+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(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")
+}

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/panda/_table.py

@@ -13,7 +13,7 @@ class PandaHdf5DatasetType(StrictEnum):
 
 class DatasetTable(Table):
     name: Sequence[str]
-    hdf5_type: Sequence[PandaHdf5DatasetType]
+    dtype: Sequence[PandaHdf5DatasetType]
 
 
 class SeqTrigger(StrictEnum):

ophyd_async/plan_stubs/_ensure_connected.py

@@ -1,3 +1,5 @@
+from collections.abc import Awaitable
+
 import bluesky.plan_stubs as bps
 
 from ophyd_async.core import DEFAULT_TIMEOUT, Device, LazyMock, wait_for_connection
@@ -9,18 +11,23 @@ def ensure_connected(
     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/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):
     """

ophyd_async/tango/demo/_counter.py

@@ -2,18 +2,17 @@ from typing import Annotated as A
 
 from ophyd_async.core import DEFAULT_TIMEOUT, AsyncStatus, SignalR, SignalRW, SignalX
 from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.tango import TangoReadable, tango_polling
+from ophyd_async.tango.core import TangoPolling, TangoReadable
 
 
-# Enable device level polling, useful for servers that do not support events
-# Polling for individual signal can be enabled with a dict
-@tango_polling({"counts": (1.0, 0.1, 0.1), "sample_time": (0.1, 0.1, 0.1)})
 class TangoCounter(TangoReadable):
     # Enter the name and type of the signals you want to use
-    # If type is None or Signal, the type will be inferred from the Tango device
-    counts: A[SignalR[int], Format.HINTED_SIGNAL]
-    sample_time: A[SignalRW[float], Format.CONFIG_SIGNAL]
+    # If the server doesn't support events, the TangoPolling annotation gives
+    # the parameters for ophyd to poll instead
+    counts: A[SignalR[int], Format.HINTED_SIGNAL, TangoPolling(1.0, 0.1, 0.1)]
+    sample_time: A[SignalRW[float], Format.CONFIG_SIGNAL, TangoPolling(0.1, 0.1, 0.1)]
     start: SignalX
+    # If a tango name clashes with a bluesky verb, add a trailing underscore
     reset_: SignalX
 
     @AsyncStatus.wrap