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

ophyd_async/epics/signal/_p4p.py

@@ -1,198 +1,107 @@
+from __future__ import annotations
+
 import asyncio
 import atexit
-import inspect
 import logging
-import time
-from collections.abc import Sequence
-from dataclasses import dataclass
-from enum import Enum
+from collections.abc import Mapping, Sequence
 from math import isnan, nan
-from typing import Any, get_origin
+from typing import Any, Generic
 
 import numpy as np
 from bluesky.protocols import Reading
-from event_model import DataKey
-from event_model.documents.event_descriptor import Dtype
+from event_model import DataKey, Limits, LimitsRange
 from p4p import Value
 from p4p.client.asyncio import Context, Subscription
 from pydantic import BaseModel
 
 from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
+    Array1D,
+    Callback,
     NotConnected,
-    ReadingValueCallback,
-    RuntimeSubsetEnum,
     SignalBackend,
-    T,
-    get_dtype,
+    SignalDatatype,
+    SignalDatatypeT,
+    SignalMetadata,
+    StrictEnum,
+    Table,
+    get_enum_cls,
     get_unique,
-    is_pydantic_model,
+    make_datakey,
     wait_for_connection,
 )
 
-from ._common import LimitPair, Limits, common_meta, get_supported_values
-
-# https://mdavidsaver.github.io/p4p/values.html
-specifier_to_dtype: dict[str, Dtype] = {
-    "?": "integer",  # bool
-    "b": "integer",  # int8
-    "B": "integer",  # uint8
-    "h": "integer",  # int16
-    "H": "integer",  # uint16
-    "i": "integer",  # int32
-    "I": "integer",  # uint32
-    "l": "integer",  # int64
-    "L": "integer",  # uint64
-    "f": "number",  # float32
-    "d": "number",  # float64
-    "s": "string",
-}
-
-specifier_to_np_dtype: dict[str, str] = {
-    "?": "<i2",  # bool
-    "b": "|i1",  # int8
-    "B": "|u1",  # uint8
-    "h": "<i2",  # int16
-    "H": "<u2",  # uint16
-    "i": "<i4",  # int32
-    "I": "<u4",  # uint32
-    "l": "<i8",  # int64
-    "L": "<u8",  # uint64
-    "f": "<f4",  # float32
-    "d": "<f8",  # float64
-    "s": "|S40",
-}
-
-
-def _data_key_from_value(
-    source: str,
-    value: Value,
-    *,
-    shape: list[int] | None = None,
-    choices: list[str] | None = None,
-    dtype: Dtype | None = None,
-) -> DataKey:
-    """
-    Args:
-        value (Value): Description of the the return type of a DB record
-        shape: Optional override shape when len(shape) > 1
-        choices: Optional list of enum choices to pass as metadata in the datakey
-        dtype: Optional override dtype when AugmentedValue is ambiguous, e.g. booleans
-
-    Returns:
-        DataKey: A rich DataKey describing the DB record
-    """
-    shape = shape or []
-    type_code = value.type().aspy("value")
-
-    dtype = dtype or specifier_to_dtype[type_code]
-
-    try:
-        if isinstance(type_code, tuple):
-            dtype_numpy = ""
-            if type_code[1] == "enum_t":
-                if dtype == "boolean":
-                    dtype_numpy = "<i2"
-                else:
-                    for item in type_code[2]:
-                        if item[0] == "choices":
-                            dtype_numpy = specifier_to_np_dtype[item[1][1]]
-        elif not type_code.startswith("a"):
-            dtype_numpy = specifier_to_np_dtype[type_code]
-        else:
-            # Array type, use typecode of internal element
-            dtype_numpy = specifier_to_np_dtype[type_code[1]]
-    except KeyError:
-        # Case where we can't determine dtype string from value
-        dtype_numpy = ""
-
-    display_data = getattr(value, "display", None)
-
-    d = DataKey(
-        source=source,
-        dtype=dtype,
-        # type ignore until https://github.com/bluesky/event-model/issues/308
-        dtype_numpy=dtype_numpy,  # type: ignore
-        shape=shape,
-    )
-    if display_data is not None:
-        for key in common_meta:
-            attr = getattr(display_data, key, nan)
-            if isinstance(attr, str) or not isnan(attr):
-                d[key] = attr
-
-    if choices is not None:
-        # type ignore until https://github.com/bluesky/event-model/issues/309
-        d["choices"] = choices  # type: ignore
-
-    if limits := _limits_from_value(value):
-        # type ignore until https://github.com/bluesky/event-model/issues/309
-        d["limits"] = limits  # type: ignore
+from ._common import format_datatype, get_supported_values
 
-    return d
 
-
-def _limits_from_value(value: Value) -> Limits:
+def _limits_from_value(value: Any) -> Limits:
     def get_limits(
         substucture_name: str, low_name: str = "limitLow", high_name: str = "limitHigh"
-    ) -> LimitPair:
+    ) -> LimitsRange | None:
         substructure = getattr(value, substucture_name, None)
         low = getattr(substructure, low_name, nan)
         high = getattr(substructure, high_name, nan)
-        return LimitPair(
-            low=None if isnan(low) else low, high=None if isnan(high) else high
-        )
-
-    return Limits(
-        alarm=get_limits("valueAlarm", "lowAlarmLimit", "highAlarmLimit"),
-        control=get_limits("control"),
-        display=get_limits("display"),
-        warning=get_limits("valueAlarm", "lowWarningLimit", "highWarningLimit"),
-    )
-
+        if not (isnan(low) and isnan(high)):
+            return LimitsRange(
+                low=None if isnan(low) else low,
+                high=None if isnan(high) else high,
+            )
 
-class PvaConverter:
-    def write_value(self, value):
-        return value
+    limits = Limits()
+    if limits_range := get_limits("valueAlarm", "lowAlarmLimit", "highAlarmLimit"):
+        limits["alarm"] = limits_range
+    if limits_range := get_limits("control"):
+        limits["control"] = limits_range
+    if limits_range := get_limits("display"):
+        limits["display"] = limits_range
+    if limits_range := get_limits("valueAlarm", "lowWarningLimit", "highWarningLimit"):
+        limits["warning"] = limits_range
+    return limits
+
+
+def _metadata_from_value(datatype: type[SignalDatatype], value: Any) -> SignalMetadata:
+    metadata = SignalMetadata()
+    value_data: Any = getattr(value, "value", None)
+    display_data: Any = getattr(value, "display", None)
+    if hasattr(display_data, "units"):
+        metadata["units"] = display_data.units
+    if hasattr(display_data, "precision") and not isnan(display_data.precision):
+        metadata["precision"] = display_data.precision
+    if limits := _limits_from_value(value):
+        metadata["limits"] = limits
+    # Get choices from display or value
+    if datatype is str or issubclass(datatype, StrictEnum):
+        if hasattr(display_data, "choices"):
+            metadata["choices"] = display_data.choices
+        elif hasattr(value_data, "choices"):
+            metadata["choices"] = value_data.choices
+    return metadata
 
-    def value(self, value):
-        return value["value"]
 
-    def reading(self, value) -> Reading:
-        ts = value["timeStamp"]
-        sv = value["alarm"]["severity"]
-        return {
-            "value": self.value(value),
-            "timestamp": ts["secondsPastEpoch"] + ts["nanoseconds"] * 1e-9,
-            "alarm_severity": -1 if sv > 2 else sv,
-        }
+class PvaConverter(Generic[SignalDatatypeT]):
+    value_fields = ("value",)
+    reading_fields = ("alarm", "timeStamp")
 
-    def get_datakey(self, source: str, value) -> DataKey:
-        return _data_key_from_value(source, value)
+    def __init__(self, datatype: type[SignalDatatypeT]):
+        self.datatype = datatype
 
-    def metadata_fields(self) -> list[str]:
-        """
-        Fields to request from PVA for metadata.
-        """
-        return ["alarm", "timeStamp"]
+    def value(self, value: Any) -> SignalDatatypeT:
+        # for channel access ca_xxx classes, this
+        # invokes __pos__ operator to return an instance of
+        # the builtin base class
+        return value["value"]
 
-    def value_fields(self) -> list[str]:
-        """
-        Fields to request from PVA for the value.
-        """
-        return ["value"]
+    def write_value(self, value: Any) -> Any:
+        # The pva library will do the conversion for us
+        return value
 
 
-class PvaArrayConverter(PvaConverter):
-    def get_datakey(self, source: str, value) -> DataKey:
-        return _data_key_from_value(
-            source, value, dtype="array", shape=[len(value["value"])]
-        )
+class DisconnectedPvaConverter(PvaConverter):
+    def __getattribute__(self, __name: str) -> Any:
+        raise NotImplementedError("No PV has been set as connect() has not been called")
 
 
-class PvaNDArrayConverter(PvaConverter):
-    def metadata_fields(self) -> list[str]:
-        return super().metadata_fields() + ["dimension"]
+class PvaNDArrayConverter(PvaConverter[SignalDatatypeT]):
+    value_fields = ("value", "dimension")
 
     def _get_dimensions(self, value) -> list[int]:
         dimensions: list[Value] = value["dimension"]
@@ -205,243 +114,206 @@ class PvaNDArrayConverter(PvaConverter):
         # last index changing fastest.
         return dims[::-1]
 
-    def value(self, value):
+    def value(self, value: Any) -> SignalDatatypeT:
         dims = self._get_dimensions(value)
         return value["value"].reshape(dims)
 
-    def get_datakey(self, source: str, value) -> DataKey:
-        dims = self._get_dimensions(value)
-        return _data_key_from_value(source, value, dtype="array", shape=dims)
-
-    def write_value(self, value):
+    def write_value(self, value: Any) -> Any:
         # No clear use-case for writing directly to an NDArray, and some
         # complexities around flattening to 1-D - e.g. dimension-order.
         # Don't support this for now.
         raise TypeError("Writing to NDArray not supported")
 
 
-@dataclass
-class PvaEnumConverter(PvaConverter):
-    """To prevent issues when a signal is restarted and returns with different enum
-    values or orders, we put treat an Enum signal as a string, and cache the
-    choices on this class.
-    """
-
-    def __init__(self, choices: dict[str, str]):
-        self.choices = tuple(choices.values())
+class PvaEnumConverter(PvaConverter[str]):
+    def __init__(
+        self, datatype: type[str] = str, supported_values: Mapping[str, str] = {}
+    ):
+        self.supported_values = supported_values
+        super().__init__(datatype)
 
-    def write_value(self, value: Enum | str):
-        if isinstance(value, Enum):
-            return value.value
+    def value(self, value: Any) -> str:
+        str_value = value["value"]["choices"][value["value"]["index"]]
+        if self.supported_values:
+            return self.supported_values[str_value]
         else:
-            return value
-
-    def value(self, value):
-        return self.choices[value["value"]["index"]]
+            return str_value
 
-    def get_datakey(self, source: str, value) -> DataKey:
-        return _data_key_from_value(
-            source, value, choices=list(self.choices), dtype="string"
-        )
 
+class PvaEnumBoolConverter(PvaConverter[bool]):
+    def __init__(self):
+        super().__init__(bool)
 
-class PvaEmumBoolConverter(PvaConverter):
-    def value(self, value):
+    def value(self, value: Any) -> bool:
         return bool(value["value"]["index"])
 
-    def get_datakey(self, source: str, value) -> DataKey:
-        return _data_key_from_value(source, value, dtype="boolean")
-
-
-class PvaTableConverter(PvaConverter):
-    def value(self, value):
-        return value["value"].todict()
 
-    def get_datakey(self, source: str, value) -> DataKey:
-        # This is wrong, but defer until we know how to actually describe a table
-        return _data_key_from_value(source, value, dtype="object")  # type: ignore
+class PvaTableConverter(PvaConverter[Table]):
+    def value(self, value) -> Table:
+        return self.datatype(**value["value"].todict())
 
-
-class PvaPydanticModelConverter(PvaConverter):
-    def __init__(self, datatype: BaseModel):
-        self.datatype = datatype
-
-    def value(self, value: Value):
-        return self.datatype(**value.todict())  # type: ignore
-
-    def write_value(self, value: BaseModel | dict[str, Any]):
-        if isinstance(value, self.datatype):  # type: ignore
-            return value.model_dump(mode="python")  # type: ignore
+    def write_value(self, value: BaseModel | dict[str, Any]) -> Any:
+        if isinstance(value, self.datatype):
+            return value.model_dump(mode="python")
         return value
 
 
-class PvaDictConverter(PvaConverter):
-    def reading(self, value) -> Reading:
-        ts = time.time()
-        value = value.todict()
-        # Alarm severity is vacuously 0 for a table
-        return {"value": value, "timestamp": ts, "alarm_severity": 0}
-
-    def value(self, value: Value):
-        return value.todict()
-
-    def get_datakey(self, source: str, value) -> DataKey:
-        raise NotImplementedError("Describing Dict signals not currently supported")
-
-    def metadata_fields(self) -> list[str]:
-        """
-        Fields to request from PVA for metadata.
-        """
-        return []
-
-    def value_fields(self) -> list[str]:
-        """
-        Fields to request from PVA for the value.
-        """
-        return []
+# https://mdavidsaver.github.io/p4p/values.html
+_datatype_converter_from_typeid: dict[
+    tuple[str, str], tuple[type[SignalDatatype], type[PvaConverter]]
+] = {
+    ("epics:nt/NTScalar:1.0", "?"): (bool, PvaConverter),
+    ("epics:nt/NTScalar:1.0", "b"): (int, PvaConverter),
+    ("epics:nt/NTScalar:1.0", "B"): (int, PvaConverter),
+    ("epics:nt/NTScalar:1.0", "h"): (int, PvaConverter),
+    ("epics:nt/NTScalar:1.0", "H"): (int, PvaConverter),
+    ("epics:nt/NTScalar:1.0", "i"): (int, PvaConverter),
+    ("epics:nt/NTScalar:1.0", "I"): (int, PvaConverter),
+    ("epics:nt/NTScalar:1.0", "l"): (int, PvaConverter),
+    ("epics:nt/NTScalar:1.0", "L"): (int, PvaConverter),
+    ("epics:nt/NTScalar:1.0", "f"): (float, PvaConverter),
+    ("epics:nt/NTScalar:1.0", "d"): (float, PvaConverter),
+    ("epics:nt/NTScalar:1.0", "s"): (str, PvaConverter),
+    ("epics:nt/NTEnum:1.0", "S"): (str, PvaEnumConverter),
+    ("epics:nt/NTScalarArray:1.0", "a?"): (Array1D[np.bool_], PvaConverter),
+    ("epics:nt/NTScalarArray:1.0", "ab"): (Array1D[np.int8], PvaConverter),
+    ("epics:nt/NTScalarArray:1.0", "aB"): (Array1D[np.uint8], PvaConverter),
+    ("epics:nt/NTScalarArray:1.0", "ah"): (Array1D[np.int16], PvaConverter),
+    ("epics:nt/NTScalarArray:1.0", "aH"): (Array1D[np.uint16], PvaConverter),
+    ("epics:nt/NTScalarArray:1.0", "ai"): (Array1D[np.int32], PvaConverter),
+    ("epics:nt/NTScalarArray:1.0", "aI"): (Array1D[np.uint32], PvaConverter),
+    ("epics:nt/NTScalarArray:1.0", "al"): (Array1D[np.int64], PvaConverter),
+    ("epics:nt/NTScalarArray:1.0", "aL"): (Array1D[np.uint64], PvaConverter),
+    ("epics:nt/NTScalarArray:1.0", "af"): (Array1D[np.float32], PvaConverter),
+    ("epics:nt/NTScalarArray:1.0", "ad"): (Array1D[np.float64], PvaConverter),
+    ("epics:nt/NTScalarArray:1.0", "as"): (Sequence[str], PvaConverter),
+    ("epics:nt/NTTable:1.0", "S"): (Table, PvaTableConverter),
+    ("epics:nt/NTNDArray:1.0", "v"): (np.ndarray, PvaNDArrayConverter),
+}
 
 
-class DisconnectedPvaConverter(PvaConverter):
-    def __getattribute__(self, __name: str) -> Any:
-        raise NotImplementedError("No PV has been set as connect() has not been called")
+def _get_specifier(value: Value):
+    typ = value.type("value").aspy()
+    if isinstance(typ, tuple):
+        return typ[0]
+    else:
+        return str(typ)
 
 
 def make_converter(datatype: type | None, values: dict[str, Any]) -> PvaConverter:
     pv = list(values)[0]
     typeid = get_unique({k: v.getID() for k, v in values.items()}, "typeids")
-    typ = get_unique(
-        {k: type(v.get("value")) for k, v in values.items()}, "value types"
+    specifier = get_unique(
+        {k: _get_specifier(v) for k, v in values.items()},
+        "value type specifiers",
     )
-    if "NTScalarArray" in typeid and typ is list:
-        # Waveform of strings, check we wanted this
-        if datatype and datatype != Sequence[str]:
-            raise TypeError(f"{pv} has type [str] not {datatype.__name__}")
-        return PvaArrayConverter()
-    elif "NTScalarArray" in typeid or "NTNDArray" in typeid:
-        pv_dtype = get_unique(
-            {k: v["value"].dtype for k, v in values.items()}, "dtypes"
-        )
-        # This is an array
-        if datatype:
-            # Check we wanted an array of this type
-            dtype = get_dtype(datatype)
-            if not dtype:
-                raise TypeError(f"{pv} has type [{pv_dtype}] not {datatype.__name__}")
-            if dtype != pv_dtype:
-                raise TypeError(f"{pv} has type [{pv_dtype}] not [{dtype}]")
-        if "NTNDArray" in typeid:
-            return PvaNDArrayConverter()
-        else:
-            return PvaArrayConverter()
-    elif "NTEnum" in typeid and datatype is bool:
-        # Wanted a bool, but database represents as an enum
-        pv_choices_len = get_unique(
+    # Infer a datatype and converter from the typeid and specifier
+    inferred_datatype, converter_cls = _datatype_converter_from_typeid[
+        (typeid, specifier)
+    ]
+    # Some override cases
+    if datatype is bool and typeid == "epics:nt/NTEnum:1.0":
+        # Database can't do bools, so are often representated as enums of len 2
+        pv_num_choices = get_unique(
             {k: len(v["value"]["choices"]) for k, v in values.items()},
             "number of choices",
         )
-        if pv_choices_len != 2:
-            raise TypeError(f"{pv} has {pv_choices_len} choices, can't map to bool")
-        return PvaEmumBoolConverter()
-    elif "NTEnum" in typeid:
-        # This is an Enum
+        if pv_num_choices != 2:
+            raise TypeError(f"{pv} has {pv_num_choices} choices, can't map to bool")
+        return PvaEnumBoolConverter()
+    elif typeid == "epics:nt/NTEnum:1.0":
         pv_choices = get_unique(
             {k: tuple(v["value"]["choices"]) for k, v in values.items()}, "choices"
         )
-        return PvaEnumConverter(get_supported_values(pv, datatype, pv_choices))
-    elif "NTScalar" in typeid:
-        if (
-            typ is str
-            and inspect.isclass(datatype)
-            and issubclass(datatype, RuntimeSubsetEnum)
-        ):
+        if enum_cls := get_enum_cls(datatype):
+            # We were given an enum class, so make class from that
             return PvaEnumConverter(
-                get_supported_values(pv, datatype, datatype.choices)  # type: ignore
-            )
-        elif datatype and not issubclass(typ, datatype):
-            # Allow int signals to represent float records when prec is 0
-            is_prec_zero_float = typ is float and (
-                get_unique(
-                    {k: v["display"]["precision"] for k, v in values.items()},
-                    "precision",
-                )
-                == 0
+                supported_values=get_supported_values(pv, enum_cls, pv_choices)
             )
-            if not (datatype is int and is_prec_zero_float):
-                raise TypeError(f"{pv} has type {typ.__name__} not {datatype.__name__}")
-        return PvaConverter()
-    elif "NTTable" in typeid:
-        if is_pydantic_model(datatype):
-            return PvaPydanticModelConverter(datatype)  # type: ignore
-        return PvaTableConverter()
-    elif "structure" in typeid:
-        return PvaDictConverter()
-    else:
-        raise TypeError(f"{pv}: Unsupported typeid {typeid}")
-
-
-class PvaSignalBackend(SignalBackend[T]):
-    _ctxt: Context | None = None
-
-    _ALLOWED_DATATYPES = (
-        bool,
-        int,
-        float,
-        str,
-        Sequence,
-        np.ndarray,
-        Enum,
-        RuntimeSubsetEnum,
-        BaseModel,
-        dict,
+        elif datatype in (None, str):
+            # Still use the Enum converter, but make choices from what it has
+            return PvaEnumConverter()
+    elif (
+        inferred_datatype is float
+        and datatype is int
+        and get_unique(
+            {k: v["display"]["precision"] for k, v in values.items()}, "precision"
+        )
+        == 0
+    ):
+        # Allow int signals to represent float records when prec is 0
+        return PvaConverter(int)
+    elif inferred_datatype is str and (enum_cls := get_enum_cls(datatype)):
+        # Allow strings to be used as enums until QSRV supports this
+        return PvaConverter(str)
+    elif inferred_datatype is Table and datatype and issubclass(datatype, Table):
+        # Use a custom table class
+        return PvaTableConverter(datatype)
+    elif datatype in (None, inferred_datatype):
+        # If datatype matches what we are given then allow it and use inferred converter
+        return converter_cls(inferred_datatype)
+    raise TypeError(
+        f"{pv} with inferred datatype {format_datatype(inferred_datatype)}"
+        f" from {typeid=} {specifier=}"
+        f" cannot be coerced to {format_datatype(datatype)}"
     )
 
-    @classmethod
-    def datatype_allowed(cls, dtype: Any) -> bool:
-        stripped_origin = get_origin(dtype) or dtype
-        if dtype is None:
-            return True
-        return inspect.isclass(stripped_origin) and issubclass(
-            stripped_origin, cls._ALLOWED_DATATYPES
-        )
 
-    def __init__(self, datatype: type[T] | None, read_pv: str, write_pv: str):
-        self.datatype = datatype
-        if not PvaSignalBackend.datatype_allowed(self.datatype):
-            raise TypeError(f"Given datatype {self.datatype} unsupported in PVA.")
+_context: Context | None = None
+
+
+def context() -> Context:
+    global _context
+    if _context is None:
+        _context = Context("pva", nt=False)
+
+        @atexit.register
+        def _del_ctxt():
+            # If we don't do this we get messages like this on close:
+            #   Error in sys.excepthook:
+            #   Original exception was:
+            global _context
+            del _context
 
+    return _context
+
+
+async def pvget_with_timeout(pv: str, timeout: float) -> Any:
+    try:
+        return await asyncio.wait_for(context().get(pv), timeout=timeout)
+    except asyncio.TimeoutError as exc:
+        logging.debug(f"signal pva://{pv} timed out", exc_info=True)
+        raise NotConnected(f"pva://{pv}") from exc
+
+
+def _pva_request_string(fields: Sequence[str]) -> str:
+    """Converts a list of requested fields into a PVA request string which can be
+    passed to p4p.
+    """
+    return f"field({','.join(fields)})"
+
+
+class PvaSignalBackend(SignalBackend[SignalDatatypeT]):
+    def __init__(
+        self,
+        datatype: type[SignalDatatypeT] | None,
+        read_pv: str = "",
+        write_pv: str = "",
+    ):
         self.read_pv = read_pv
         self.write_pv = write_pv
+        self.converter: PvaConverter = DisconnectedPvaConverter(float)
         self.initial_values: dict[str, Any] = {}
-        self.converter: PvaConverter = DisconnectedPvaConverter()
         self.subscription: Subscription | None = None
+        super().__init__(datatype)
 
-    def source(self, name: str):
-        return f"pva://{self.read_pv}"
-
-    @property
-    def ctxt(self) -> Context:
-        if PvaSignalBackend._ctxt is None:
-            PvaSignalBackend._ctxt = Context("pva", nt=False)
+    def source(self, name: str, read: bool):
+        return f"pva://{self.read_pv if read else self.write_pv}"
 
-            @atexit.register
-            def _del_ctxt():
-                # If we don't do this we get messages like this on close:
-                #   Error in sys.excepthook:
-                #   Original exception was:
-                PvaSignalBackend._ctxt = None
-
-        return PvaSignalBackend._ctxt
-
-    async def _store_initial_value(self, pv, timeout: float = DEFAULT_TIMEOUT):
-        try:
-            self.initial_values[pv] = await asyncio.wait_for(
-                self.ctxt.get(pv), timeout=timeout
-            )
-        except asyncio.TimeoutError as exc:
-            logging.debug(f"signal pva://{pv} timed out", exc_info=True)
-            raise NotConnected(f"pva://{pv}") from exc
+    async def _store_initial_value(self, pv: str, timeout: float):
+        self.initial_values[pv] = await pvget_with_timeout(pv, timeout)
 
-    async def connect(self, timeout: float = DEFAULT_TIMEOUT):
+    async def connect(self, timeout: float):
         if self.read_pv != self.write_pv:
             # Different, need to connect both
             await wait_for_connection(
@@ -453,66 +325,61 @@ class PvaSignalBackend(SignalBackend[T]):
             await self._store_initial_value(self.read_pv, timeout=timeout)
         self.converter = make_converter(self.datatype, self.initial_values)
 
-    async def put(self, value: T | None, wait=True, timeout=None):
+    def _make_reading(self, value: Any) -> Reading[SignalDatatypeT]:
+        ts = value["timeStamp"]
+        sv = value["alarm"]["severity"]
+        return {
+            "value": self.converter.value(value),
+            "timestamp": ts["secondsPastEpoch"] + ts["nanoseconds"] * 1e-9,
+            "alarm_severity": -1 if sv > 2 else sv,
+        }
+
+    async def put(self, value: SignalDatatypeT | None, wait: bool):
         if value is None:
             write_value = self.initial_values[self.write_pv]
         else:
             write_value = self.converter.write_value(value)
-        coro = self.ctxt.put(self.write_pv, {"value": write_value}, wait=wait)
-        try:
-            await asyncio.wait_for(coro, timeout)
-        except asyncio.TimeoutError as exc:
-            logging.debug(
-                f"signal pva://{self.write_pv} timed out \
-                          put value: {write_value}",
-                exc_info=True,
-            )
-            raise NotConnected(f"pva://{self.write_pv}") from exc
+        await context().put(self.write_pv, {"value": write_value}, wait=wait)
 
     async def get_datakey(self, source: str) -> DataKey:
-        value = await self.ctxt.get(self.read_pv)
-        return self.converter.get_datakey(source, value)
-
-    def _pva_request_string(self, fields: list[str]) -> str:
-        """
-        Converts a list of requested fields into a PVA request string which can be
-        passed to p4p.
-        """
-        return f"field({','.join(fields)})"
+        value = await context().get(self.read_pv)
+        metadata = _metadata_from_value(self.converter.datatype, value)
+        return make_datakey(
+            self.converter.datatype, self.converter.value(value), source, metadata
+        )
 
     async def get_reading(self) -> Reading:
-        request: str = self._pva_request_string(
-            self.converter.value_fields() + self.converter.metadata_fields()
+        request = _pva_request_string(
+            self.converter.value_fields + self.converter.reading_fields
         )
-        value = await self.ctxt.get(self.read_pv, request=request)
-        return self.converter.reading(value)
+        value = await context().get(self.read_pv, request=request)
+        return self._make_reading(value)
 
-    async def get_value(self) -> T:
-        request: str = self._pva_request_string(self.converter.value_fields())
-        value = await self.ctxt.get(self.read_pv, request=request)
+    async def get_value(self) -> SignalDatatypeT:
+        request = _pva_request_string(self.converter.value_fields)
+        value = await context().get(self.read_pv, request=request)
         return self.converter.value(value)
 
-    async def get_setpoint(self) -> T:
-        value = await self.ctxt.get(self.write_pv, "field(value)")
+    async def get_setpoint(self) -> SignalDatatypeT:
+        request = _pva_request_string(self.converter.value_fields)
+        value = await context().get(self.write_pv, request=request)
         return self.converter.value(value)
 
-    def set_callback(self, callback: ReadingValueCallback[T] | None) -> None:
+    def set_callback(self, callback: Callback[Reading[SignalDatatypeT]] | None) -> None:
         if callback:
             assert (
                 not self.subscription
             ), "Cannot set a callback when one is already set"
 
             async def async_callback(v):
-                callback(self.converter.reading(v), self.converter.value(v))
+                callback(self._make_reading(v))
 
-            request: str = self._pva_request_string(
-                self.converter.value_fields() + self.converter.metadata_fields()
+            request = _pva_request_string(
+                self.converter.value_fields + self.converter.reading_fields
             )
-
-            self.subscription = self.ctxt.monitor(
+            self.subscription = context().monitor(
                 self.read_pv, async_callback, request=request
             )
-        else:
-            if self.subscription:
-                self.subscription.close()
+        elif self.subscription:
+            self.subscription.close()
             self.subscription = None