ophyd-async 0.13.4__py3-none-any.whl → 0.13.6__py3-none-any.whl

ophyd_async/tango/core/_tango_transport.py

@@ -3,15 +3,24 @@ import functools
 import logging
 import time
 from abc import abstractmethod
-from collections.abc import Callable, Coroutine
-from enum import Enum
-from typing import Any, ParamSpec, TypeVar, cast
+from collections.abc import Callable, Coroutine, Sequence
+from typing import (
+    Any,
+    ParamSpec,
+    TypeVar,
+    cast,
+    get_args,
+    get_origin,
+)
 
 import numpy as np
+import numpy.typing as npt
 from bluesky.protocols import Reading
-from event_model import DataKey
+from event_model import DataKey, Limits, LimitsRange
+from event_model.documents.event_descriptor import RdsRange
 from tango import (
     AttrDataFormat,
+    AttributeInfo,
     AttributeInfoEx,
     CmdArgType,
     CommandInfo,
@@ -19,6 +28,7 @@ from tango import (
     DeviceProxy,
     DevState,
     EventType,
+    GreenMode,
 )
 from tango.asyncio import DeviceProxy as AsyncDeviceProxy
 from tango.asyncio_executor import (
@@ -26,19 +36,23 @@ from tango.asyncio_executor import (
     get_global_executor,
     set_global_executor,
 )
-from tango.utils import is_array, is_binary, is_bool, is_float, is_int, is_str
+from tango.utils import is_binary, is_bool, is_float, is_int, is_str
 
 from ophyd_async.core import (
+    Array1D,
     AsyncStatus,
     Callback,
-    NotConnected,
+    NotConnectedError,
     SignalBackend,
     SignalDatatypeT,
+    SignalMetadata,
     StrictEnum,
+    Table,
     get_dtype,
-    get_unique,
+    make_datakey,
     wait_for_connection,
 )
+from ophyd_async.tango.testing import TestConfig
 
 from ._converters import (
     TangoConverter,
@@ -47,7 +61,7 @@ from ._converters import (
     TangoEnumArrayConverter,
     TangoEnumConverter,
 )
-from ._utils import DevStateEnum, get_device_trl_and_attr
+from ._utils import DevStateEnum, get_device_trl_and_attr, try_to_cast_as_float
 
 logger = logging.getLogger("ophyd_async")
 
@@ -73,28 +87,85 @@ def ensure_proper_executor(
     return wrapper
 
 
-def get_python_type(tango_type: CmdArgType) -> tuple[bool, object, str]:
+class TangoLongStringTable(Table):
+    long: Array1D[np.int32]
+    string: Sequence[str]
+
+
+class TangoDoubleStringTable(Table):
+    double: Array1D[np.float64]
+    string: Sequence[str]
+
+
+def get_python_type(config: AttributeInfoEx | CommandInfo | TestConfig) -> object:
     """For converting between recieved tango types and python primatives."""
-    array = is_array(tango_type)
+    tango_type = None
+    tango_format = None
+    if isinstance(config, AttributeInfoEx | AttributeInfo):
+        tango_type = config.data_type
+        tango_format = config.data_format
+    elif isinstance(config, CommandInfo):
+        read_character = get_command_character(config)
+        if read_character == CommandProxyReadCharacter.READ:
+            tango_type = config.out_type
+        else:
+            tango_type = config.in_type
+    elif isinstance(config, TestConfig):
+        tango_type = config.data_type
+        tango_format = config.data_format
+    else:
+        raise TypeError("Unrecognized Tango resource configuration")
+    if tango_format not in [
+        AttrDataFormat.SCALAR,
+        AttrDataFormat.SPECTRUM,
+        AttrDataFormat.IMAGE,
+        None,
+    ]:
+        raise TypeError("Unknown TangoFormat")
+
+    if tango_type is CmdArgType.DevVarLongStringArray:
+        return TangoLongStringTable
+    if tango_type is CmdArgType.DevVarDoubleStringArray:
+        return TangoDoubleStringTable
+
+    def _get_type(cls: type) -> object:
+        if tango_format == AttrDataFormat.SCALAR:
+            return cls
+        elif tango_format == AttrDataFormat.SPECTRUM:
+            if cls is str or issubclass(cls, StrictEnum):
+                return Sequence[cls]
+            return Array1D[cls]
+        elif tango_format == AttrDataFormat.IMAGE:
+            if cls is str or issubclass(cls, StrictEnum):
+                return Sequence[Sequence[str]]
+            return npt.NDArray[cls]
+        else:
+            return cls
+
     if is_int(tango_type, True):
-        return array, int, "integer"
-    if is_float(tango_type, True):
-        return array, float, "number"
-    if is_bool(tango_type, True):
-        return array, bool, "integer"
-    if is_str(tango_type, True):
-        return array, str, "string"
-    if is_binary(tango_type, True):
-        return array, list[str], "string"
-    if tango_type == CmdArgType.DevEnum:
-        return array, Enum, "string"
-    if tango_type == CmdArgType.DevState:
-        return array, CmdArgType.DevState, "string"
-    if tango_type == CmdArgType.DevUChar:
-        return array, int, "integer"
-    if tango_type == CmdArgType.DevVoid:
-        return array, None, "string"
-    raise TypeError("Unknown TangoType")
+        return _get_type(int)
+    elif is_float(tango_type, True):
+        return _get_type(float)
+    elif is_bool(tango_type, True):
+        return _get_type(bool)
+    elif is_str(tango_type, True):
+        return _get_type(str)
+    elif is_binary(tango_type, True):
+        return _get_type(str)
+    elif tango_type == CmdArgType.DevEnum:
+        if hasattr(config, "enum_labels"):
+            enum_dict = {label: str(label) for label in config.enum_labels}
+            return _get_type(StrictEnum("TangoEnum", enum_dict))
+        else:
+            return _get_type(int)
+    elif tango_type == CmdArgType.DevState:
+        return _get_type(DevStateEnum)
+    elif tango_type == CmdArgType.DevUChar:
+        return _get_type(int)
+    elif tango_type == CmdArgType.DevVoid:
+        return None
+    else:
+        raise TypeError(f"Unknown TangoType: {tango_type}")
 
 
 class TangoProxy:
@@ -202,49 +273,26 @@ class AttributeProxy(TangoProxy):
     async def put(  # type: ignore
         self, value: object | None, wait: bool = True, timeout: float | None = None
     ) -> AsyncStatus | None:
+        if wait is False:
+            raise RuntimeWarning(
+                "wait=False is not supported in Tango."
+                "Simply don't await the status object."
+            )
         # TODO: remove the timeout from this as it is handled at the signal level
         value = self._converter.write_value(value)
-        if wait:
-            try:
-
-                async def _write():
-                    return await self._proxy.write_attribute(self._name, value)
-
-                task = asyncio.create_task(_write())
-                await asyncio.wait_for(task, timeout)
-            except TimeoutError as te:
-                raise TimeoutError(f"{self._name} attr put failed: Timeout") from te
-            except DevFailed as de:
-                raise RuntimeError(
-                    f"{self._name} device failure: {de.args[0].desc}"
-                ) from de
-
-        else:
-            rid = await self._proxy.write_attribute_asynch(self._name, value)
+        try:
 
-            async def wait_for_reply(rd: int, to: float | None):
-                start_time = time.time()
-                while True:
-                    try:
-                        # I have to typehint proxy as tango.DeviceProxy because
-                        # tango.asyncio.DeviceProxy cannot be used as a typehint.
-                        # This means pyright will not be able to see that
-                        # write_attribute_reply is awaitable.
-                        await self._proxy.write_attribute_reply(rd)  # type: ignore
-                        break
-                    except DevFailed as exc:
-                        if exc.args[0].reason == "API_AsynReplyNotArrived":
-                            await asyncio.sleep(A_BIT)
-                            if to and (time.time() - start_time > to):
-                                raise TimeoutError(
-                                    f"{self._name} attr put failed: Timeout"
-                                ) from exc
-                        else:
-                            raise RuntimeError(
-                                f"{self._name} device failure: {exc.args[0].desc}"
-                            ) from exc
+            async def _write():
+                return await self._proxy.write_attribute(self._name, value)
 
-            return AsyncStatus(wait_for_reply(rid, timeout))
+            task = asyncio.create_task(_write())
+            await asyncio.wait_for(task, timeout)
+        except TimeoutError as te:
+            raise TimeoutError(f"{self._name} attr put failed: Timeout") from te
+        except DevFailed as de:
+            raise RuntimeError(
+                f"{self._name} device failure: {de.args[0].desc}"
+            ) from de
 
     @ensure_proper_executor
     async def get_config(self) -> AttributeInfoEx:  # type: ignore
@@ -264,6 +312,17 @@ class AttributeProxy(TangoProxy):
     def has_subscription(self) -> bool:
         return bool(self._callback)
 
+    @ensure_proper_executor
+    async def _subscribe_to_event(self):
+        if not self._eid:
+            self._eid = await self._proxy.subscribe_event(
+                self._name,
+                EventType.CHANGE_EVENT,
+                self._event_processor,
+                stateless=True,
+                green_mode=GreenMode.Asyncio,
+            )
+
     def subscribe_callback(self, callback: Callback | None):
         # If the attribute supports events, then we can subscribe to them
         # If the callback is not a callable, then we raise an error
@@ -272,14 +331,7 @@ class AttributeProxy(TangoProxy):
 
         self._callback = callback
         if self.support_events:
-            """add user callback to CHANGE event subscription"""
-            if not self._eid:
-                self._eid = self._proxy.subscribe_event(
-                    self._name,
-                    EventType.CHANGE_EVENT,
-                    self._event_processor,
-                    green_mode=False,
-                )
+            asyncio.create_task(self._subscribe_to_event())
         elif self._allow_polling:
             """start polling if no events supported"""
             if self._callback is not None:
@@ -303,8 +355,12 @@ class AttributeProxy(TangoProxy):
 
     def unsubscribe_callback(self):
         if self._eid:
-            self._proxy.unsubscribe_event(self._eid, green_mode=False)
-            self._eid = None
+            try:
+                self._proxy.unsubscribe_event(self._eid, green_mode=False)
+            except Exception as exc:
+                logger.warning(f"Could not unsubscribe from event: {exc}")
+            finally:
+                self._eid = None
         if self._poll_task:
             self._poll_task.cancel()
             self._poll_task = None
@@ -316,7 +372,8 @@ class AttributeProxy(TangoProxy):
                     pass
         self._callback = None
 
-    def _event_processor(self, event):
+    @ensure_proper_executor
+    async def _event_processor(self, event):
         if not event.err:
             reading = Reading(
                 value=self._converter.value(event.attr_value.value),
@@ -339,8 +396,8 @@ class AttributeProxy(TangoProxy):
             # Initial reading
             if self._callback is not None:
                 self._callback(last_reading)
-        except Exception as e:
-            raise RuntimeError(f"Could not poll the attribute: {e}") from e
+        except Exception as exc:
+            raise RuntimeError(f"Could not poll the attribute: {exc}") from exc
 
         try:
             # If the value is a number, we can check for changes
@@ -396,8 +453,8 @@ class AttributeProxy(TangoProxy):
                                 else:
                                     break
                         last_reading = reading.copy()
-        except Exception as e:
-            raise RuntimeError(f"Could not poll the attribute: {e}") from e
+        except Exception as exc:
+            raise RuntimeError(f"Could not poll the attribute: {exc}") from exc
 
     def set_polling(
         self,
@@ -413,10 +470,46 @@ class AttributeProxy(TangoProxy):
         self._rel_change = rel_change
 
 
+class CommandProxyReadCharacter(StrictEnum):
+    """Enum to carry the read/write character of the CommandProxy."""
+
+    READ = "READ"
+    WRITE = "WRITE"
+    READ_WRITE = "READ_WRITE"
+    EXECUTE = "EXECUTE"
+
+
+def get_command_character(config: CommandInfo) -> CommandProxyReadCharacter:
+    """Return the command character for the given command config."""
+    in_type = config.in_type
+    out_type = config.out_type
+    if in_type == CmdArgType.DevVoid and out_type != CmdArgType.DevVoid:
+        read_character = CommandProxyReadCharacter.READ
+    elif in_type != CmdArgType.DevVoid and out_type == CmdArgType.DevVoid:
+        read_character = CommandProxyReadCharacter.WRITE
+    elif in_type == CmdArgType.DevVoid and out_type == CmdArgType.DevVoid:
+        read_character = CommandProxyReadCharacter.EXECUTE
+    else:
+        read_character = CommandProxyReadCharacter.READ_WRITE
+    return read_character
+
+
 class CommandProxy(TangoProxy):
     """Tango proxy for commands."""
 
-    _last_reading: Reading = Reading(value=None, timestamp=0, alarm_severity=0)
+    _last_reading: Reading
+    _last_w_value: Any
+    _config: CommandInfo
+    _read_character: CommandProxyReadCharacter
+    device_proxy: DeviceProxy
+    name: str
+
+    def __init__(self, device_proxy: DeviceProxy, name: str):
+        super().__init__(device_proxy, name)
+        self._last_reading = Reading(value=None, timestamp=0, alarm_severity=0)
+        self.device_proxy = device_proxy
+        self.name = name
+        self._last_w_value = None
 
     def subscribe_callback(self, callback: Callback | None) -> None:
         raise NotImplementedError("Cannot subscribe to commands")
@@ -425,78 +518,59 @@ class CommandProxy(TangoProxy):
         raise NotImplementedError("Cannot unsubscribe from commands")
 
     async def get(self) -> object:
-        return self._last_reading["value"]
+        if self._read_character == CommandProxyReadCharacter.READ_WRITE:
+            return self._last_reading["value"]
+        elif self._read_character == CommandProxyReadCharacter.READ:
+            await self.put(value=None, wait=True, timeout=None)
+            return self._last_reading["value"]
 
     async def get_w_value(self) -> object:
-        return self._last_reading["value"]
+        return self._last_w_value
 
     async def connect(self) -> None:
-        pass
+        self._config = await self.device_proxy.get_command_config(self.name)
+        self._read_character = get_command_character(self._config)
 
     @ensure_proper_executor
     async def put(  # type: ignore
         self, value: object | None, wait: bool = True, timeout: float | None = None
     ) -> AsyncStatus | None:
+        if wait is False:
+            raise RuntimeError(
+                "wait=False is not supported in Tango."
+                " Simply don't await the status object."
+            )
         value = self._converter.write_value(value)
-        if wait:
-            try:
-
-                async def _put():
-                    return await self._proxy.command_inout(self._name, value)
-
-                task = asyncio.create_task(_put())
-                val = await asyncio.wait_for(task, timeout)
-                self._last_reading = Reading(
-                    value=self._converter.value(val),
-                    timestamp=time.time(),
-                    alarm_severity=0,
-                )
-            except TimeoutError as te:
-                raise TimeoutError(f"{self._name} command failed: Timeout") from te
-            except DevFailed as de:
-                raise RuntimeError(
-                    f"{self._name} device failure: {de.args[0].desc}"
-                ) from de
-
-        else:
-            rid = self._proxy.command_inout_asynch(self._name, value)
+        try:
 
-            async def wait_for_reply(rd: int, to: float | None):
-                start_time = time.time()
-                while True:
-                    try:
-                        reply_value = self._converter.value(
-                            self._proxy.command_inout_reply(rd)
-                        )
-                        self._last_reading = Reading(
-                            value=reply_value, timestamp=time.time(), alarm_severity=0
-                        )
-                        break
-                    except DevFailed as de_exc:
-                        if de_exc.args[0].reason == "API_AsynReplyNotArrived":
-                            await asyncio.sleep(A_BIT)
-                            if to and time.time() - start_time > to:
-                                raise TimeoutError(
-                                    "Timeout while waiting for command reply"
-                                ) from de_exc
-                        else:
-                            raise RuntimeError(
-                                f"{self._name} device failure: {de_exc.args[0].desc}"
-                            ) from de_exc
+            async def _put():
+                return await self._proxy.command_inout(self._name, value)
 
-            return AsyncStatus(wait_for_reply(rid, timeout))
+            task = asyncio.create_task(_put())
+            val = await asyncio.wait_for(task, timeout)
+            self._last_w_value = value
+            self._last_reading = Reading(
+                value=self._converter.value(val),
+                timestamp=time.time(),
+                alarm_severity=0,
+            )
+        except TimeoutError as te:
+            raise TimeoutError(f"{self._name} command failed: Timeout") from te
+        except DevFailed as de:
+            raise RuntimeError(
+                f"{self._name} device failure: {de.args[0].desc}"
+            ) from de
 
     @ensure_proper_executor
     async def get_config(self) -> CommandInfo:  # type: ignore
         return await self._proxy.get_command_config(self._name)
 
     async def get_reading(self) -> Reading:
-        reading = Reading(
-            value=self._last_reading["value"],
-            timestamp=self._last_reading["timestamp"],
-            alarm_severity=self._last_reading.get("alarm_severity", 0),
-        )
-        return reading
+        if self._read_character == CommandProxyReadCharacter.READ:
+            await self.put(value=None, wait=True, timeout=None)
+            return self._last_reading
+        else:
+            return self._last_reading
 
     def set_polling(
         self,
@@ -518,101 +592,79 @@ def get_dtype_extended(datatype) -> object | None:
     return dtype
 
 
-def get_trl_descriptor(
-    datatype: type | None,
+def get_source_metadata(
     tango_resource: str,
-    tr_configs: dict[str, AttributeInfoEx | CommandInfo],
-) -> DataKey:
-    """Create a descriptor from a tango resource locator."""
-    tr_dtype = {}
-    for tr_name, config in tr_configs.items():
+    tr_configs: dict[str, AttributeInfoEx],
+) -> SignalMetadata:
+    metadata = {}
+    for _, config in tr_configs.items():
         if isinstance(config, AttributeInfoEx):
-            _, dtype, descr = get_python_type(config.data_type)
-            tr_dtype[tr_name] = config.data_format, dtype, descr
-        elif isinstance(config, CommandInfo):
-            if (
-                config.in_type != CmdArgType.DevVoid
-                and config.out_type != CmdArgType.DevVoid
-                and config.in_type != config.out_type
-            ):
-                raise RuntimeError(
-                    "Commands with different in and out dtypes are not supported"
-                )
-            array, dtype, descr = get_python_type(
-                config.in_type
-                if config.in_type != CmdArgType.DevVoid
-                else config.out_type
+            alarm_info = config.alarms
+            _limits = Limits(
+                control=LimitsRange(
+                    low=try_to_cast_as_float(config.min_value),
+                    high=try_to_cast_as_float(config.max_value),
+                ),
+                warning=LimitsRange(
+                    low=try_to_cast_as_float(alarm_info.min_warning),
+                    high=try_to_cast_as_float(alarm_info.max_warning),
+                ),
+                alarm=LimitsRange(
+                    low=try_to_cast_as_float(alarm_info.min_alarm),
+                    high=try_to_cast_as_float(alarm_info.max_alarm),
+                ),
             )
-            tr_dtype[tr_name] = (
-                AttrDataFormat.SPECTRUM if array else AttrDataFormat.SCALAR,
-                dtype,
-                descr,
+
+            delta_t, delta_val = map(
+                try_to_cast_as_float, (alarm_info.delta_t, alarm_info.delta_val)
             )
-        else:
-            raise RuntimeError(f"Unknown config type: {type(config)}")
-    tr_format, tr_dtype, tr_dtype_desc = get_unique(tr_dtype, "typeids")
-
-    # tango commands are limited in functionality:
-    # they do not have info about shape and Enum labels
-    trl_config = list(tr_configs.values())[0]
-    max_x: int = (
-        trl_config.max_dim_x
-        if hasattr(trl_config, "max_dim_x")
-        else np.iinfo(np.int32).max
-    )
-    max_y: int = (
-        trl_config.max_dim_y
-        if hasattr(trl_config, "max_dim_y")
-        else np.iinfo(np.int32).max
-    )
-    # is_attr = hasattr(trl_config, "enum_labels")
-    # trl_choices = list(trl_config.enum_labels) if is_attr else []
-
-    if tr_format in [AttrDataFormat.SPECTRUM, AttrDataFormat.IMAGE]:
-        # This is an array
-        if datatype:
-            # Check we wanted an array of this type
-            dtype = get_dtype_extended(datatype)
-            if not dtype:
-                raise TypeError(
-                    f"{tango_resource} has type [{tr_dtype}] not {datatype.__name__}"
+            if isinstance(delta_t, float) and isinstance(delta_val, float):
+                limits_rds = RdsRange(
+                    time_difference=delta_t,
+                    value_difference=delta_val,
+                )
+                _limits["rds"] = limits_rds
+            # if only one of the two is set
+            elif isinstance(delta_t, float) ^ isinstance(delta_val, float):
+                logger.warning(
+                    f"Both delta_t and delta_val should be set for {tango_resource} "
+                    f"but only one is set. "
+                    f"delta_t: {alarm_info.delta_t}, delta_val: {alarm_info.delta_val}"
                 )
-            if dtype != tr_dtype:
-                raise TypeError(f"{tango_resource} has type [{tr_dtype}] not [{dtype}]")
 
-        if tr_format == AttrDataFormat.SPECTRUM:
-            return DataKey(source=tango_resource, dtype="array", shape=[max_x])
-        elif tr_format == AttrDataFormat.IMAGE:
-            return DataKey(source=tango_resource, dtype="array", shape=[max_y, max_x])
+            _choices = list(config.enum_labels) if config.enum_labels else []
 
-    else:
-        if tr_dtype in (Enum, CmdArgType.DevState):
-            # if tr_dtype == CmdArgType.DevState:
-            #     trl_choices = list(DevState.names.keys())
+            tr_dtype = get_python_type(config)
 
-            if datatype:
-                if not issubclass(datatype, Enum | DevState):
-                    raise TypeError(
-                        f"{tango_resource} has type Enum not {datatype.__name__}"
-                    )
-                # if tr_dtype == Enum and is_attr:
-                #     if isinstance(datatype, DevState):
-                #         choices = tuple(v.name for v in datatype)
-                #         if set(choices) != set(trl_choices):
-                #             raise TypeError(
-                #                 f"{tango_resource} has choices {trl_choices} "
-                #                 f"not {choices}"
-                #             )
-            return DataKey(source=tango_resource, dtype="string", shape=[])
-        else:
-            if datatype and not issubclass(tr_dtype, datatype):
-                raise TypeError(
-                    f"{tango_resource} has type {tr_dtype.__name__} "
-                    f"not {datatype.__name__}"
-                )
-            return DataKey(source=tango_resource, dtype=tr_dtype_desc, shape=[])
+            if tr_dtype == CmdArgType.DevState:
+                _choices = list(DevState.names.keys())
 
-    raise RuntimeError(f"Error getting descriptor for {tango_resource}")
+            _precision = None
+            if config.format:
+                try:
+                    _precision = int(config.format.split(".")[1].split("f")[0])
+                except (ValueError, IndexError) as exc:
+                    # If parsing config.format fails, _precision remains None.
+                    logger.warning(
+                        "Failed to parse precision from config.format: %s. Error: %s",
+                        config.format,
+                        exc,
+                    )
+            no_limits = Limits(
+                control=LimitsRange(high=None, low=None),
+                warning=LimitsRange(high=None, low=None),
+                alarm=LimitsRange(high=None, low=None),
+            )
+            if _limits:
+                if _limits != no_limits:
+                    metadata["limits"] = _limits
+            if _choices:
+                metadata["choices"] = _choices
+            if _precision:
+                metadata["precision"] = _precision
+            if config.unit:
+                metadata["units"] = config.unit
+    return SignalMetadata(**metadata)
 
 
 async def get_tango_trl(
@@ -625,7 +677,6 @@ async def get_tango_trl(
     trl_name = trl_name.lower()
     if device_proxy is None:
         device_proxy = await AsyncDeviceProxy(device_trl, timeout=timeout)
-
     # all attributes can be always accessible with low register
     if isinstance(device_proxy, DeviceProxy):
         all_attrs = [
@@ -703,7 +754,6 @@ class TangoSignalBackend(SignalBackend[SignalDatatypeT]):
             write_trl: self.device_proxy,
         }
         self.trl_configs: dict[str, AttributeInfoEx] = {}
-        self.descriptor: DataKey = {}  # type: ignore
         self._polling: tuple[bool, float, float | None, float | None] = (
             False,
             0.1,
@@ -730,20 +780,131 @@ class TangoSignalBackend(SignalBackend[SignalDatatypeT]):
     def source(self, name: str, read: bool) -> str:
         return self.read_trl if read else self.write_trl
 
+    def _type_match_ndarray(self, signal_type: type[SignalDatatypeT], tr_dtype: object):
+        tango_resource = self.source(name="", read=True)
+
+        def extract_dtype_param(dtype_arg):
+            if hasattr(dtype_arg, "__origin__") and dtype_arg.__origin__ is np.dtype:
+                inner = get_args(dtype_arg)
+                return inner[0] if inner else object
+            return dtype_arg
+
+        signal_dtype = extract_dtype_param(get_args(signal_type)[-1])
+        tr_dtype_arg = extract_dtype_param(get_args(tr_dtype)[-1])
+
+        try:
+            sdt = np.dtype(signal_dtype)
+            tdt = np.dtype(tr_dtype_arg)
+        except TypeError as exc:
+            raise TypeError(
+                f"Could not interpret array dtypes: {signal_dtype!r},"
+                f" {tr_dtype_arg!r} ({exc})"
+            ) from exc
+
+        if sdt != tdt:
+            raise TypeError(
+                f"{tango_resource} has type {tr_dtype!r}, expected {self.datatype!r}"
+            )
+
+    def _type_match_array(
+        self,
+        signal_type: type[SignalDatatypeT] | None,
+        tr_dtype: object,
+        tango_resource: str,
+    ):
+        # Always get a fresh resource string for the error context
+        tango_resource = self.source(name="", read=True)
+        if get_origin(signal_type) is Sequence and get_origin(tr_dtype) is Sequence:
+            sig_elem_type = get_args(signal_type)[0]
+            tr_elem_type = get_args(tr_dtype)[0]
+            self._type_match_scalar(sig_elem_type, tr_elem_type, tango_resource)
+            return
+        elif (
+            get_origin(signal_type) is np.ndarray and get_origin(tr_dtype) is np.ndarray
+        ):
+            if signal_type is None:
+                raise TypeError(
+                    f"{tango_resource} has type {tr_dtype!r}, expected a non-None"
+                    f" signal_type"
+                )
+            self._type_match_ndarray(signal_type, tr_dtype)
+            return
+        else:
+            raise TypeError(
+                tango_resource, "has type", str(signal_type), "which is not recognized"
+            )
+
+    def _type_match_scalar(
+        self,
+        signal_type: type[SignalDatatypeT] | None,
+        tr_dtype: object,
+        tango_resource: str,
+    ):
+        if signal_type is tr_dtype:
+            return
+        if isinstance(signal_type, type) and issubclass(signal_type, StrictEnum):
+            return
+        raise TypeError(
+            f"{tango_resource} has type {tr_dtype!r}, expected {self.datatype!r}"
+        )
+
+    def _verify_datatype_matches(self, config: AttributeInfoEx | CommandInfo):
+        """Verify that the datatype of the config matches the datatype of the signal."""
+        tr_dtype = get_python_type(config)
+        tango_resource = self.source(name="", read=True)
+        signal_type = self.datatype
+        if isinstance(config, AttributeInfoEx | AttributeInfo):
+            tr_format = config.data_format
+            if tr_format in [AttrDataFormat.SPECTRUM, AttrDataFormat.IMAGE]:
+                self._type_match_array(signal_type, tr_dtype, tango_resource)
+            elif tr_format is AttrDataFormat.SCALAR:
+                self._type_match_scalar(signal_type, tr_dtype, tango_resource)
+        elif isinstance(config, CommandInfo):
+            if (
+                config.in_type != CmdArgType.DevVoid
+                and config.out_type != CmdArgType.DevVoid
+                and config.in_type != config.out_type
+            ):
+                raise RuntimeError(
+                    "Commands with different in and out dtypes are not supported"
+                )
+            if get_origin(tr_dtype) in [Sequence, np.ndarray]:
+                self._type_match_array(signal_type, tr_dtype, tango_resource)
+            else:
+                self._type_match_scalar(signal_type, tr_dtype, tango_resource)
+        else:
+            raise TypeError(
+                f"Unrecognized resource configuration: {config} "
+                f"for source {tango_resource}"
+            )
+
     async def _connect_and_store_config(self, trl: str, timeout: float) -> None:
         if not trl:
             raise RuntimeError(f"trl not set for {self}")
         try:
             self.proxies[trl] = await get_tango_trl(trl, self.proxies[trl], timeout)
             if self.proxies[trl] is None:
-                raise NotConnected(f"Not connected to {trl}")
+                raise NotConnectedError(f"Not connected to {trl}")
             # Pyright does not believe that self.proxies[trl] is not None despite
             # the check above
             await self.proxies[trl].connect()  # type: ignore
-            self.trl_configs[trl] = await self.proxies[trl].get_config()  # type: ignore
+            config = await self.proxies[trl].get_config()  # type: ignore
+            self.trl_configs[trl] = config
+
+            # Perform signal verification
+            self._verify_datatype_matches(config)
+
+            if isinstance(config, AttributeInfoEx):
+                if (
+                    config.data_type == CmdArgType.DevString
+                    and config.data_format == AttrDataFormat.IMAGE
+                ):
+                    raise TypeError(
+                        "DevString IMAGE attributes are not supported by ophyd-async."
+                    )
             self.proxies[trl].support_events = self.support_events  # type: ignore
         except TimeoutError as ce:
-            raise NotConnected(f"tango://{trl}") from ce
+            raise NotConnectedError(f"tango://{trl}") from ce
 
     async def connect(self, timeout: float) -> None:
         if not self.read_trl:
@@ -760,47 +921,54 @@ class TangoSignalBackend(SignalBackend[SignalDatatypeT]):
         self.proxies[self.read_trl].set_polling(*self._polling)  # type: ignore
         self.converter = make_converter(self.trl_configs[self.read_trl], self.datatype)
         self.proxies[self.read_trl].set_converter(self.converter)  # type: ignore
-        self.descriptor = get_trl_descriptor(
-            self.datatype, self.read_trl, self.trl_configs
-        )
 
     async def put(self, value: SignalDatatypeT | None, wait=True, timeout=None) -> None:
         if self.proxies[self.write_trl] is None:
-            raise NotConnected(f"Not connected to {self.write_trl}")
+            raise NotConnectedError(f"Not connected to {self.write_trl}")
         self.status = None
         put_status = await self.proxies[self.write_trl].put(value, wait, timeout)  # type: ignore
         self.status = put_status
 
     async def get_datakey(self, source: str) -> DataKey:
-        return self.descriptor
+        try:
+            value: Any = await self.proxies[source].get()  # type: ignore
+        except AttributeError as ae:
+            raise NotConnectedError(f"Not connected to {source}") from ae
+        md = get_source_metadata(source, self.trl_configs)
+        return make_datakey(
+            self.datatype,  # type: ignore
+            value,
+            source,
+            metadata=md,
+        )
 
     async def get_reading(self) -> Reading[SignalDatatypeT]:
         if self.proxies[self.read_trl] is None:
-            raise NotConnected(f"Not connected to {self.read_trl}")
+            raise NotConnectedError(f"Not connected to {self.read_trl}")
         reading = await self.proxies[self.read_trl].get_reading()  # type: ignore
         return reading
 
     async def get_value(self) -> SignalDatatypeT:
         if self.proxies[self.read_trl] is None:
-            raise NotConnected(f"Not connected to {self.read_trl}")
+            raise NotConnectedError(f"Not connected to {self.read_trl}")
         proxy = self.proxies[self.read_trl]
         if proxy is None:
-            raise NotConnected(f"Not connected to {self.read_trl}")
+            raise NotConnectedError(f"Not connected to {self.read_trl}")
         value = await proxy.get()
         return cast(SignalDatatypeT, value)
 
     async def get_setpoint(self) -> SignalDatatypeT:
         if self.proxies[self.write_trl] is None:
-            raise NotConnected(f"Not connected to {self.write_trl}")
+            raise NotConnectedError(f"Not connected to {self.write_trl}")
         proxy = self.proxies[self.write_trl]
         if proxy is None:
-            raise NotConnected(f"Not connected to {self.write_trl}")
+            raise NotConnectedError(f"Not connected to {self.write_trl}")
         w_value = await proxy.get_w_value()
         return cast(SignalDatatypeT, w_value)
 
     def set_callback(self, callback: Callback | None) -> None:
         if self.proxies[self.read_trl] is None:
-            raise NotConnected(f"Not connected to {self.read_trl}")
+            raise NotConnectedError(f"Not connected to {self.read_trl}")
         if self.support_events is False and self._polling[0] is False:
             raise RuntimeError(
                 f"Cannot set event for {self.read_trl}. "