ophyd-async 0.9.0a1__py3-none-any.whl → 0.10.0a1__py3-none-any.whl

ophyd_async/tango/core/_converters.py

@@ -0,0 +1,81 @@
+from typing import Any, Generic
+
+import numpy as np
+from numpy.typing import NDArray
+
+from ophyd_async.core import (
+    SignalDatatypeT,
+)
+from tango import (
+    DevState,
+)
+
+from ._utils import DevStateEnum
+
+
+class TangoConverter(Generic[SignalDatatypeT]):
+    def write_value(self, value: Any) -> Any:
+        return value
+
+    def value(self, value: Any) -> Any:
+        return value
+
+
+class TangoEnumConverter(TangoConverter):
+    def __init__(self, labels: list[str]):
+        self._labels = labels
+
+    def write_value(self, value: str):
+        if not isinstance(value, str):
+            raise TypeError("TangoEnumConverter expects str value")
+        return self._labels.index(value)
+
+    def value(self, value: int):
+        return self._labels[value]
+
+
+class TangoEnumArrayConverter(TangoConverter):
+    def __init__(self, labels: list[str]):
+        self._labels = labels
+
+    def write_value(self, value: NDArray[np.str_]) -> NDArray[np.integer]:
+        vfunc = np.vectorize(self._labels.index)
+        new_array = vfunc(value)
+        return new_array
+
+    def value(self, value: NDArray[np.integer]) -> NDArray[np.str_]:
+        vfunc = np.vectorize(self._labels.__getitem__)
+        new_array = vfunc(value)
+        return new_array
+
+
+class TangoDevStateConverter(TangoConverter):
+    _labels = [e.value for e in DevStateEnum]
+
+    def write_value(self, value: str) -> DevState:
+        idx = self._labels.index(value)
+        return DevState(idx)
+
+    def value(self, value: DevState) -> str:
+        idx = int(value)
+        return self._labels[idx]
+
+
+class TangoDevStateArrayConverter(TangoConverter):
+    _labels = [e.value for e in DevStateEnum]
+
+    def _write_convert(self, value):
+        return DevState(self._labels.index(value))
+
+    def _convert(self, value):
+        return self._labels[int(value)]
+
+    def write_value(self, value: NDArray[np.str_]) -> NDArray[DevState]:
+        vfunc = np.vectorize(self._write_convert, otypes=[DevState])
+        new_array = vfunc(value)
+        return new_array
+
+    def value(self, value: NDArray[DevState]) -> NDArray[np.str_]:
+        vfunc = np.vectorize(self._convert)
+        new_array = vfunc(value)
+        return new_array

ophyd_async/tango/core/_signal.py

@@ -1,4 +1,4 @@
-"""Tango Signals over Pytango"""
+"""Tango Signals over Pytango."""
 
 from __future__ import annotations
 
@@ -22,31 +22,31 @@ from tango import (
     CmdArgType,
     DeviceProxy,
     DevState,
-    NonSupportedFeature,  # type: ignore
 )
 from tango.asyncio import DeviceProxy as AsyncDeviceProxy
 
 from ._tango_transport import TangoSignalBackend, get_python_type
+from ._utils import get_device_trl_and_attr
+
+logger = logging.getLogger("ophyd_async")
 
 
 def make_backend(
     datatype: type[SignalDatatypeT] | None,
     read_trl: str = "",
     write_trl: str = "",
-    device_proxy: DeviceProxy | None = None,
 ) -> TangoSignalBackend:
-    return TangoSignalBackend(datatype, read_trl, write_trl, device_proxy)
+    return TangoSignalBackend(datatype, read_trl, write_trl)
 
 
 def tango_signal_rw(
     datatype: type[SignalDatatypeT],
     read_trl: str,
     write_trl: str = "",
-    device_proxy: DeviceProxy | None = None,
     timeout: float = DEFAULT_TIMEOUT,
     name: str = "",
 ) -> SignalRW[SignalDatatypeT]:
-    """Create a `SignalRW` backed by 1 or 2 Tango Attribute/Command
+    """Create a `SignalRW` backed by 1 or 2 Tango Attribute/Command.
 
     Parameters
     ----------
@@ -56,25 +56,23 @@ def tango_signal_rw(
         The Attribute/Command to read and monitor
     write_trl:
         If given, use this Attribute/Command to write to, otherwise use read_trl
-    device_proxy:
-        If given, this DeviceProxy will be used
     timeout:
         The timeout for the read and write operations
     name:
         The name of the Signal
+
     """
-    backend = make_backend(datatype, read_trl, write_trl or read_trl, device_proxy)
+    backend = make_backend(datatype, read_trl, write_trl or read_trl)
     return SignalRW(backend, timeout=timeout, name=name)
 
 
 def tango_signal_r(
     datatype: type[SignalDatatypeT],
     read_trl: str,
-    device_proxy: DeviceProxy | None = None,
     timeout: float = DEFAULT_TIMEOUT,
     name: str = "",
 ) -> SignalR[SignalDatatypeT]:
-    """Create a `SignalR` backed by 1 Tango Attribute/Command
+    """Create a `SignalR` backed by 1 Tango Attribute/Command.
 
     Parameters
     ----------
@@ -82,25 +80,23 @@ def tango_signal_r(
         Check that the Attribute/Command is of this type
     read_trl:
         The Attribute/Command to read and monitor
-    device_proxy:
-        If given, this DeviceProxy will be used
     timeout:
         The timeout for the read operation
     name:
         The name of the Signal
+
     """
-    backend = make_backend(datatype, read_trl, read_trl, device_proxy)
+    backend = make_backend(datatype, read_trl, read_trl)
     return SignalR(backend, timeout=timeout, name=name)
 
 
 def tango_signal_w(
     datatype: type[SignalDatatypeT],
     write_trl: str,
-    device_proxy: DeviceProxy | None = None,
     timeout: float = DEFAULT_TIMEOUT,
     name: str = "",
 ) -> SignalW[SignalDatatypeT]:
-    """Create a `SignalW` backed by 1 Tango Attribute/Command
+    """Create a `SignalW` backed by 1 Tango Attribute/Command.
 
     Parameters
     ----------
@@ -108,45 +104,43 @@ def tango_signal_w(
         Check that the Attribute/Command is of this type
     write_trl:
         The Attribute/Command to write to
-    device_proxy:
-        If given, this DeviceProxy will be used
     timeout:
         The timeout for the write operation
     name:
         The name of the Signal
+
     """
-    backend = make_backend(datatype, write_trl, write_trl, device_proxy)
+    backend = make_backend(datatype, write_trl, write_trl)
     return SignalW(backend, timeout=timeout, name=name)
 
 
 def tango_signal_x(
     write_trl: str,
-    device_proxy: DeviceProxy | None = None,
     timeout: float = DEFAULT_TIMEOUT,
     name: str = "",
 ) -> SignalX:
-    """Create a `SignalX` backed by 1 Tango Attribute/Command
+    """Create a `SignalX` backed by 1 Tango Attribute/Command.
 
     Parameters
     ----------
     write_trl:
         The Attribute/Command to write its initial value to on execute
-    device_proxy:
-        If given, this DeviceProxy will be used
     timeout:
         The timeout for the command operation
     name:
         The name of the Signal
+
     """
-    backend = make_backend(None, write_trl, write_trl, device_proxy)
+    backend = make_backend(None, write_trl, write_trl)
     return SignalX(backend, timeout=timeout, name=name)
 
 
 async def infer_python_type(
     trl: str = "", proxy: DeviceProxy | None = None
 ) -> object | npt.NDArray | type[DevState] | IntEnum:
+    """Infers the python type from the TRL."""
     # TODO: work out if this is still needed
-    device_trl, tr_name = trl.rsplit("/", 1)
+    device_trl, tr_name = get_device_trl_and_attr(trl)
     if proxy is None:
         dev_proxy = await AsyncDeviceProxy(device_trl)
     else:
@@ -175,18 +169,12 @@ async def infer_python_type(
 async def infer_signal_type(
     trl, proxy: DeviceProxy | None = None
 ) -> type[Signal] | None:
-    device_trl, tr_name = trl.rsplit("/", 1)
+    device_trl, tr_name = get_device_trl_and_attr(trl)
     if proxy is None:
         dev_proxy = await AsyncDeviceProxy(device_trl)
     else:
         dev_proxy = proxy
 
-    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():
             raise RuntimeError(f"Cannot find {tr_name} in {device_trl}")
@@ -205,7 +193,7 @@ async def infer_signal_type(
         if config.in_type == CmdArgType.DevVoid:
             return SignalX
         elif config.in_type != config.out_type:
-            logging.debug("Commands with different in and out dtypes are not supported")
+            logger.debug("Commands with different in and out dtypes are not supported")
             return None
         else:
             return SignalRW

ophyd_async/tango/core/_tango_readable.py

@@ -1,32 +1,15 @@
 from __future__ import annotations
 
 from ophyd_async.core import StandardReadable
-from tango import DeviceProxy
 
 from ._base_device import TangoDevice
 
 
 class TangoReadable(TangoDevice, StandardReadable):
-    """
-    General class for readable TangoDevices. Extends StandardReadable to provide
-    attributes for Tango devices.
-
-    Usage: to proper signals mount should be awaited:
-    new_device = await TangoDevice(<tango_device>)
-
-    Attributes
-    ----------
-    trl : str
-        Tango resource locator, typically of the device server.
-    proxy : AsyncDeviceProxy
-        AsyncDeviceProxy object for the device. This is created when the
-        device is connected.
-    """
-
     def __init__(
         self,
         trl: str | None = None,
-        device_proxy: DeviceProxy | None = None,
         name: str = "",
+        auto_fill_signals: bool = True,
     ) -> None:
-        TangoDevice.__init__(self, trl, device_proxy=device_proxy, name=name)
+        TangoDevice.__init__(self, trl, name=name, auto_fill_signals=auto_fill_signals)