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

ophyd_async/sim/demo/_sim_motor.py

@@ -6,8 +6,6 @@ from bluesky.protocols import Movable, Stoppable
 
 from ophyd_async.core import (
     AsyncStatus,
-    ConfigSignal,
-    HintedSignal,
     StandardReadable,
     WatchableAsyncStatus,
     WatcherUpdate,
@@ -15,6 +13,7 @@ from ophyd_async.core import (
     soft_signal_r_and_setter,
     soft_signal_rw,
 )
+from ophyd_async.core import StandardReadableFormat as Format
 
 
 class SimMotor(StandardReadable, Movable, Stoppable):
@@ -28,11 +27,11 @@ class SimMotor(StandardReadable, Movable, Stoppable):
         - instant: bool: whether to move instantly, or with a delay
         """
         # Define some signals
-        with self.add_children_as_readables(HintedSignal):
+        with self.add_children_as_readables(Format.HINTED_SIGNAL):
             self.user_readback, self._user_readback_set = soft_signal_r_and_setter(
                 float, 0
             )
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
             self.velocity = soft_signal_rw(float, 0 if instant else 1.0)
             self.units = soft_signal_rw(str, "mm")
         self.user_setpoint = soft_signal_rw(float, 0)

ophyd_async/tango/__init__.py

@@ -1,45 +0,0 @@
-from .base_devices import (
-    TangoDevice,
-    TangoReadable,
-    tango_polling,
-)
-from .signal import (
-    AttributeProxy,
-    CommandProxy,
-    TangoSignalBackend,
-    __tango_signal_auto,
-    ensure_proper_executor,
-    get_dtype_extended,
-    get_python_type,
-    get_tango_trl,
-    get_trl_descriptor,
-    infer_python_type,
-    infer_signal_character,
-    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_character",
-    "make_backend",
-    "AttributeProxy",
-    "CommandProxy",
-    "ensure_proper_executor",
-    "__tango_signal_auto",
-    "tango_signal_r",
-    "tango_signal_rw",
-    "tango_signal_w",
-    "tango_signal_x",
-]

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

@@ -1,13 +1,14 @@
+from ._base_device import TangoDevice, TangoPolling
 from ._signal import (
-    __tango_signal_auto,
     infer_python_type,
-    infer_signal_character,
+    infer_signal_type,
     make_backend,
     tango_signal_r,
     tango_signal_rw,
     tango_signal_w,
     tango_signal_x,
 )
+from ._tango_readable import TangoReadable
 from ._tango_transport import (
     AttributeProxy,
     CommandProxy,
@@ -19,7 +20,7 @@ from ._tango_transport import (
     get_trl_descriptor,
 )
 
-__all__ = (
+__all__ = [
     "AttributeProxy",
     "CommandProxy",
     "ensure_proper_executor",
@@ -29,11 +30,13 @@ __all__ = (
     "get_trl_descriptor",
     "get_tango_trl",
     "infer_python_type",
-    "infer_signal_character",
+    "infer_signal_type",
     "make_backend",
     "tango_signal_r",
     "tango_signal_rw",
     "tango_signal_w",
     "tango_signal_x",
-    "__tango_signal_auto",
-)
+    "TangoDevice",
+    "TangoReadable",
+    "TangoPolling",
+]

ophyd_async/tango/core/_base_device.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+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")
+
+
+class TangoDevice(Device):
+    """
+    General class for TangoDevices. Extends Device to provide attributes for Tango
+    devices.
+
+    Parameters
+    ----------
+    trl: str
+        Tango resource locator, typically of the device server.
+    device_proxy: Optional[Union[AsyncDeviceProxy, SyncDeviceProxy]]
+        Asynchronous or synchronous DeviceProxy object for the device. If not provided,
+        an asynchronous DeviceProxy object will be created using the trl and awaited
+        when the device is connected.
+    """
+
+    trl: str = ""
+    proxy: DeviceProxy | None = None
+
+    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, support_events=support_events
+        )
+        super().__init__(name=name, connector=connector)
+
+
+@dataclass
+class TangoPolling(Generic[T]):
+    ophyd_polling_period: float = 0.1
+    abs_change: T | None = None
+    rel_change: T | None = None
+
+
+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):
+    def __init__(
+        self,
+        trl: str | None,
+        device_proxy: DeviceProxy | None,
+        support_events: bool,
+    ) -> None:
+        self.trl = trl
+        self.proxy = device_proxy
+        self._support_events = support_events
+
+    def create_children_from_annotations(self, device: Device):
+        if not hasattr(self, "filler"):
+            self.filler = DeviceFiller(
+                device=device,
+                signal_backend_factory=TangoSignalBackend,
+                device_connector_factory=lambda: TangoDeviceConnector(
+                    None, None, self._support_events
+                ),
+            )
+            list(self.filler.create_devices_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):
+        # Make 2 entries for each DeviceVector
+        self.filler.create_device_vector_entries_to_mock(2)
+        # Set the name of the device to name all children
+        device.set_name(device.name)
+        return await super().connect_mock(device, mock)
+
+    async def connect_real(self, device: Device, timeout: float, force_reconnect: bool):
+        if self.trl and self.proxy is None:
+            self.proxy = await AsyncDeviceProxy(self.trl)
+        elif self.proxy and not self.trl:
+            self.trl = self.proxy.name()
+        else:
+            raise TypeError("Neither proxy nor trl supplied")
+
+        children = sorted(
+            set()
+            .union(self.proxy.get_attribute_list())
+            .union(self.proxy.get_command_list())
+        )
+        for name in children:
+            # TODO: strip attribute name
+            full_trl = f"{self.trl}/{name}"
+            signal_type = await infer_signal_type(full_trl, self.proxy)
+            if signal_type:
+                backend = self.filler.fill_child_signal(name, signal_type)
+                backend.datatype = await infer_python_type(full_trl, self.proxy)
+                backend.set_trl(full_trl)
+        # 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
+        device.set_name(device.name)
+        return await super().connect_real(device, timeout, force_reconnect)

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

@@ -2,21 +2,35 @@
 
 from __future__ import annotations
 
+import logging
 from enum import Enum, IntEnum
 
 import numpy.typing as npt
 
-from ophyd_async.core import DEFAULT_TIMEOUT, SignalR, SignalRW, SignalW, SignalX, T
-from ophyd_async.tango.signal._tango_transport import (
-    TangoSignalBackend,
-    get_python_type,
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    Signal,
+    SignalDatatypeT,
+    SignalR,
+    SignalRW,
+    SignalW,
+    SignalX,
+)
+from tango import (
+    AttrDataFormat,
+    AttrWriteType,
+    CmdArgType,
+    DeviceProxy,
+    DevState,
+    NonSupportedFeature,  # type: ignore
 )
-from tango import AttrDataFormat, AttrWriteType, CmdArgType, DeviceProxy, DevState
 from tango.asyncio import DeviceProxy as AsyncDeviceProxy
 
+from ._tango_transport import TangoSignalBackend, get_python_type
+
 
 def make_backend(
-    datatype: type[T] | None,
+    datatype: type[SignalDatatypeT] | None,
     read_trl: str = "",
     write_trl: str = "",
     device_proxy: DeviceProxy | None = None,
@@ -25,13 +39,13 @@ def make_backend(
 
 
 def tango_signal_rw(
-    datatype: type[T],
+    datatype: type[SignalDatatypeT],
     read_trl: str,
     write_trl: str = "",
     device_proxy: DeviceProxy | None = None,
     timeout: float = DEFAULT_TIMEOUT,
     name: str = "",
-) -> SignalRW[T]:
+) -> SignalRW[SignalDatatypeT]:
     """Create a `SignalRW` backed by 1 or 2 Tango Attribute/Command
 
     Parameters
@@ -54,12 +68,12 @@ def tango_signal_rw(
 
 
 def tango_signal_r(
-    datatype: type[T],
+    datatype: type[SignalDatatypeT],
     read_trl: str,
     device_proxy: DeviceProxy | None = None,
     timeout: float = DEFAULT_TIMEOUT,
     name: str = "",
-) -> SignalR[T]:
+) -> SignalR[SignalDatatypeT]:
     """Create a `SignalR` backed by 1 Tango Attribute/Command
 
     Parameters
@@ -80,12 +94,12 @@ def tango_signal_r(
 
 
 def tango_signal_w(
-    datatype: type[T],
+    datatype: type[SignalDatatypeT],
     write_trl: str,
     device_proxy: DeviceProxy | None = None,
     timeout: float = DEFAULT_TIMEOUT,
     name: str = "",
-) -> SignalW[T]:
+) -> SignalW[SignalDatatypeT]:
     """Create a `SignalW` backed by 1 Tango Attribute/Command
 
     Parameters
@@ -128,39 +142,10 @@ def tango_signal_x(
     return SignalX(backend, timeout=timeout, name=name)
 
 
-async def __tango_signal_auto(
-    datatype: type[T] | None = None,
-    *,
-    trl: str,
-    device_proxy: DeviceProxy | None,
-    timeout: float = DEFAULT_TIMEOUT,
-    name: str = "",
-) -> SignalW | SignalX | SignalR | SignalRW | None:
-    try:
-        signal_character = await infer_signal_character(trl, device_proxy)
-    except RuntimeError as e:
-        if "Commands with different in and out dtypes" in str(e):
-            return None
-        else:
-            raise e
-
-    if datatype is None:
-        datatype = await infer_python_type(trl, device_proxy)
-
-    backend = make_backend(datatype, trl, trl, device_proxy)
-    if signal_character == "RW":
-        return SignalRW(backend=backend, timeout=timeout, name=name)
-    if signal_character == "R":
-        return SignalR(backend=backend, timeout=timeout, name=name)
-    if signal_character == "W":
-        return SignalW(backend=backend, timeout=timeout, name=name)
-    if signal_character == "X":
-        return SignalX(backend=backend, timeout=timeout, name=name)
-
-
 async def infer_python_type(
     trl: str = "", proxy: DeviceProxy | None = None
 ) -> object | npt.NDArray | type[DevState] | IntEnum:
+    # TODO: work out if this is still needed
     device_trl, tr_name = trl.rsplit("/", 1)
     if proxy is None:
         dev_proxy = await AsyncDeviceProxy(device_trl)
@@ -187,15 +172,20 @@ async def infer_python_type(
     return npt.NDArray[py_type] if isarray else py_type
 
 
-async def infer_signal_character(trl, proxy: DeviceProxy | None = None) -> str:
+async def infer_signal_type(
+    trl, proxy: DeviceProxy | None = None
+) -> type[Signal] | None:
     device_trl, tr_name = trl.rsplit("/", 1)
     if proxy is None:
         dev_proxy = await AsyncDeviceProxy(device_trl)
     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():
@@ -204,20 +194,19 @@ async def infer_signal_character(trl, proxy: DeviceProxy | None = None) -> str:
     if tr_name in dev_proxy.get_attribute_list():
         config = await dev_proxy.get_attribute_config(tr_name)
         if config.writable in [AttrWriteType.READ_WRITE, AttrWriteType.READ_WITH_WRITE]:
-            return "RW"
+            return SignalRW
         elif config.writable == AttrWriteType.READ:
-            return "R"
+            return SignalR
         else:
-            return "W"
+            return SignalW
 
     if tr_name in dev_proxy.get_command_list():
         config = await dev_proxy.get_command_config(tr_name)
         if config.in_type == CmdArgType.DevVoid:
-            return "X"
+            return SignalX
         elif config.in_type != config.out_type:
-            raise RuntimeError(
-                "Commands with different in and out dtypes are not" " supported"
-            )
+            logging.debug("Commands with different in and out dtypes are not supported")
+            return None
         else:
-            return "RW"
+            return SignalRW
     raise RuntimeError(f"Unable to infer signal character for {trl}")

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):
     """