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

ophyd_async/tango/demo/_mover.py

@@ -1,4 +1,5 @@
 import asyncio
+from typing import Annotated as A
 
 from bluesky.protocols import Movable, Stoppable
 
@@ -16,18 +17,18 @@ from ophyd_async.core import (
     wait_for_value,
 )
 from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.tango import TangoReadable, tango_polling
+from ophyd_async.tango.core import TangoPolling, TangoReadable
 from tango import DevState
 
 
-# Enable device level polling, useful for servers that do not support events
-@tango_polling((0.1, 0.1, 0.1))
 class TangoMover(TangoReadable, Movable, Stoppable):
     # 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
-    position: SignalRW[float]
-    velocity: SignalRW[float]
-    state: SignalR[DevState]
+    # If the server doesn't support events, the TangoPolling annotation gives
+    # the parameters for ophyd to poll instead
+    position: A[SignalRW[float], TangoPolling(0.1, 0.1, 0.1)]
+    velocity: A[SignalRW[float], TangoPolling(0.1, 0.1, 0.1)]
+    state: A[SignalR[DevState], TangoPolling(0.1)]
+    # If a tango name clashes with a bluesky verb, add a trailing underscore
     stop_: SignalX
 
     def __init__(self, trl: str | None = "", name=""):

{ophyd_async-0.8.0a5.dist-info → ophyd_async-0.8.0a6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.8.0a5
+Version: 0.8.0a6
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License
@@ -40,62 +40,62 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: networkx >=2.0
+Requires-Dist: networkx>=2.0
 Requires-Dist: numpy
 Requires-Dist: packaging
 Requires-Dist: pint
-Requires-Dist: bluesky >=1.13
-Requires-Dist: event-model >=1.22.1
-Requires-Dist: p4p >=4.2.0a3
+Requires-Dist: bluesky>=1.13
+Requires-Dist: event-model>=1.22.1
+Requires-Dist: p4p>=4.2.0a3
 Requires-Dist: pyyaml
 Requires-Dist: colorlog
-Requires-Dist: pydantic >=2.0
+Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-numpy
 Provides-Extra: ca
-Requires-Dist: aioca >=1.6 ; extra == 'ca'
-Provides-Extra: dev
-Requires-Dist: ophyd-async[pva] ; extra == 'dev'
-Requires-Dist: ophyd-async[sim] ; extra == 'dev'
-Requires-Dist: ophyd-async[ca] ; extra == 'dev'
-Requires-Dist: ophyd-async[tango] ; extra == 'dev'
-Requires-Dist: inflection ; extra == 'dev'
-Requires-Dist: ipython ; extra == 'dev'
-Requires-Dist: ipywidgets ; extra == 'dev'
-Requires-Dist: matplotlib ; extra == 'dev'
-Requires-Dist: myst-parser ; extra == 'dev'
-Requires-Dist: numpydoc ; extra == 'dev'
-Requires-Dist: ophyd ; extra == 'dev'
-Requires-Dist: pickleshare ; extra == 'dev'
-Requires-Dist: pipdeptree ; extra == 'dev'
-Requires-Dist: pre-commit ; extra == 'dev'
-Requires-Dist: pydata-sphinx-theme >=0.12 ; extra == 'dev'
-Requires-Dist: pyepics >=3.4.2 ; extra == 'dev'
-Requires-Dist: pyright ; extra == 'dev'
-Requires-Dist: pyside6 ==6.7.0 ; extra == 'dev'
-Requires-Dist: pytest ; extra == 'dev'
-Requires-Dist: pytest-asyncio ; extra == 'dev'
-Requires-Dist: pytest-cov ; extra == 'dev'
-Requires-Dist: pytest-faulthandler ; extra == 'dev'
-Requires-Dist: pytest-forked ; extra == 'dev'
-Requires-Dist: pytest-rerunfailures ; extra == 'dev'
-Requires-Dist: pytest-timeout ; extra == 'dev'
-Requires-Dist: ruff ; extra == 'dev'
-Requires-Dist: sphinx <7.4.0 ; extra == 'dev'
-Requires-Dist: sphinx-autobuild ; extra == 'dev'
-Requires-Dist: autodoc-pydantic ; extra == 'dev'
-Requires-Dist: sphinxcontrib-mermaid ; extra == 'dev'
-Requires-Dist: sphinx-copybutton ; extra == 'dev'
-Requires-Dist: sphinx-design ; extra == 'dev'
-Requires-Dist: super-state-machine ; extra == 'dev'
-Requires-Dist: tox-direct ; extra == 'dev'
-Requires-Dist: types-mock ; extra == 'dev'
-Requires-Dist: types-pyyaml ; extra == 'dev'
+Requires-Dist: aioca>=1.6; extra == "ca"
 Provides-Extra: pva
-Requires-Dist: p4p ; extra == 'pva'
+Requires-Dist: p4p; extra == "pva"
 Provides-Extra: sim
-Requires-Dist: h5py ; extra == 'sim'
+Requires-Dist: h5py; extra == "sim"
 Provides-Extra: tango
-Requires-Dist: pytango >=10.0.0 ; extra == 'tango'
+Requires-Dist: pytango>=10.0.0; extra == "tango"
+Provides-Extra: dev
+Requires-Dist: ophyd_async[pva]; extra == "dev"
+Requires-Dist: ophyd_async[sim]; extra == "dev"
+Requires-Dist: ophyd_async[ca]; extra == "dev"
+Requires-Dist: ophyd_async[tango]; extra == "dev"
+Requires-Dist: inflection; extra == "dev"
+Requires-Dist: ipython; extra == "dev"
+Requires-Dist: ipywidgets; extra == "dev"
+Requires-Dist: matplotlib; extra == "dev"
+Requires-Dist: myst-parser; extra == "dev"
+Requires-Dist: numpydoc; extra == "dev"
+Requires-Dist: ophyd; extra == "dev"
+Requires-Dist: pickleshare; extra == "dev"
+Requires-Dist: pipdeptree; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pydata-sphinx-theme>=0.12; extra == "dev"
+Requires-Dist: pyepics>=3.4.2; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+Requires-Dist: pyside6==6.7.0; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-faulthandler; extra == "dev"
+Requires-Dist: pytest-forked; extra == "dev"
+Requires-Dist: pytest-rerunfailures; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: sphinx<7.4.0; extra == "dev"
+Requires-Dist: sphinx-autobuild; extra == "dev"
+Requires-Dist: autodoc-pydantic; extra == "dev"
+Requires-Dist: sphinxcontrib-mermaid; extra == "dev"
+Requires-Dist: sphinx-copybutton; extra == "dev"
+Requires-Dist: sphinx-design; extra == "dev"
+Requires-Dist: super_state_machine; extra == "dev"
+Requires-Dist: tox-direct; extra == "dev"
+Requires-Dist: types-mock; extra == "dev"
+Requires-Dist: types-pyyaml; extra == "dev"
 
 [![CI](https://github.com/bluesky/ophyd-async/actions/workflows/ci.yml/badge.svg)](https://github.com/bluesky/ophyd-async/actions/workflows/ci.yml)
 [![Coverage](https://codecov.io/gh/bluesky/ophyd-async/branch/main/graph/badge.svg)](https://codecov.io/gh/bluesky/ophyd-async)