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

ophyd_async/epics/core/_aioca.py

@@ -1,6 +1,8 @@
 import logging
 import sys
+import typing
 from collections.abc import Sequence
+from functools import cache
 from math import isnan, nan
 from typing import Any, Generic, cast
 
@@ -35,16 +37,19 @@ from ophyd_async.core import (
 
 from ._util import EpicsSignalBackend, format_datatype, get_supported_values
 
+logger = logging.getLogger("ophyd_async")
+
 
 def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
     def get_limits(limit: str) -> LimitsRange | None:
         low = getattr(value, f"lower_{limit}_limit", nan)
         high = getattr(value, f"upper_{limit}_limit", nan)
-        if not (isnan(low) and isnan(high)):
+        if not (isnan(low) and isnan(high)) and not high == low == 0:
             return LimitsRange(
                 low=None if isnan(low) else low,
                 high=None if isnan(high) else high,
             )
+        return None
 
     limits = Limits()
     if limits_range := get_limits("alarm"):
@@ -59,14 +64,20 @@ def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
 
 
 def _metadata_from_augmented_value(
-    value: AugmentedValue, metadata: SignalMetadata
+    datatype: type[SignalDatatypeT] | None,
+    value: AugmentedValue,
+    metadata: SignalMetadata,
 ) -> SignalMetadata:
     metadata = metadata.copy()
-    if hasattr(value, "units"):
+    if hasattr(value, "units") and datatype not in (str, bool):
         metadata["units"] = value.units
-    if hasattr(value, "precision") and not isnan(value.precision):
+    if (
+        hasattr(value, "precision")
+        and not isnan(value.precision)
+        and datatype is not int
+    ):
         metadata["precision"] = value.precision
-    if limits := _limits_from_augmented_value(value):
+    if (limits := _limits_from_augmented_value(value)) and datatype is not bool:
         metadata["limits"] = limits
     return metadata
 
@@ -100,6 +111,11 @@ class DisconnectedCaConverter(CaConverter):
         raise NotImplementedError("No PV has been set as connect() has not been called")
 
 
+class CaIntConverter(CaConverter[int]):
+    def value(self, value: AugmentedValue) -> int:
+        return int(value)  # type: ignore
+
+
 class CaArrayConverter(CaConverter[np.ndarray]):
     def value(self, value: AugmentedValue) -> np.ndarray:
         # A less expensive conversion
@@ -168,6 +184,9 @@ def make_converter(
         Dbr, get_unique({k: v.datatype for k, v in values.items()}, "datatypes")
     )
     is_array = bool([v for v in values.values() if v.element_count > 1])
+    # Make the datatype canonical for the inference below
+    if datatype == typing.Sequence[str]:
+        datatype = Sequence[str]
     # Infer a datatype and converter from the dbr
     inferred_datatype, converter_cls = _datatype_converter_from_dbr[(pv_dbr, is_array)]
     # Some override cases
@@ -202,7 +221,7 @@ def make_converter(
         and get_unique({k: v.precision for k, v in values.items()}, "precision") == 0
     ):
         # Allow int signals to represent float records when prec is 0
-        return CaConverter(int, pv_dbr)
+        return CaIntConverter(int, pv_dbr)
     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, pv_dbr)
@@ -214,19 +233,18 @@ def make_converter(
     )
 
 
-_tried_pyepics = False
-
-
+# Cached call to avoid repeated initialization attempts
+@cache
 def _use_pyepics_context_if_imported():
-    global _tried_pyepics
-    if not _tried_pyepics:
-        ca = sys.modules.get("epics.ca", None)
-        if ca:
-            ca.use_initial_context()
-        _tried_pyepics = True
+    """Sets up the pyepics context if the module is imported."""
+    ca = sys.modules.get("epics.ca", None)
+    if ca:
+        ca.use_initial_context()
 
 
 class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
+    """Backend for a signal to interact with PVs over channel access."""
+
     def __init__(
         self,
         datatype: type[SignalDatatypeT] | None,
@@ -247,7 +265,7 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
                 pv, format=FORMAT_CTRL, timeout=timeout
             )
         except CANothing as exc:
-            logging.debug(f"signal ca://{pv} timed out")
+            logger.debug(f"signal ca://{pv} timed out")
             raise NotConnected(f"ca://{pv}") from exc
 
     async def connect(self, timeout: float):
@@ -280,17 +298,33 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
             write_value = self.initial_values[self.write_pv]
         else:
             write_value = self.converter.write_value(value)
-        await caput(
-            self.write_pv,
-            write_value,
-            datatype=self.converter.write_dbr,
-            wait=wait,
-            timeout=None,
-        )
+        try:
+            await caput(
+                self.write_pv,
+                write_value,
+                datatype=self.converter.write_dbr,
+                wait=wait,
+                timeout=None,
+            )
+        except CANothing as exc:
+            # If we ran into a write error, check to see if there is a list
+            # of valid choices, and if the value we tried to write is in that list.
+            valid_choices = self.converter.metadata.get("choices")
+            if valid_choices:
+                if value not in valid_choices:
+                    msg = (
+                        f"{value} is not a valid choice for {self.write_pv}, "
+                        f"valid choices: {self.converter.metadata.get('choices')}"
+                    )
+                    raise ValueError(msg) from exc
+                raise
+            raise
 
     async def get_datakey(self, source: str) -> DataKey:
         value = await self._caget(self.read_pv, FORMAT_CTRL)
-        metadata = _metadata_from_augmented_value(value, self.converter.metadata)
+        metadata = _metadata_from_augmented_value(
+            self.datatype, value, self.converter.metadata
+        )
         return make_datakey(
             self.converter.datatype, self.converter.value(value), source, metadata
         )
@@ -308,16 +342,18 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
         return self.converter.value(value)
 
     def set_callback(self, callback: Callback[Reading[SignalDatatypeT]] | None) -> None:
+        if callback and self.subscription:
+            msg = "Cannot set a callback when one is already set"
+            raise RuntimeError(msg)
+
+        if self.subscription:
+            self.subscription.close()
+            self.subscription = None
+
         if callback:
-            assert (
-                not self.subscription
-            ), "Cannot set a callback when one is already set"
             self.subscription = camonitor(
                 self.read_pv,
                 lambda v: callback(self._make_reading(v)),
                 datatype=self.converter.read_dbr,
                 format=FORMAT_TIME,
             )
-        elif self.subscription:
-            self.subscription.close()
-            self.subscription = None

ophyd_async/epics/core/_epics_connector.py

@@ -10,6 +10,8 @@ from ._signal import EpicsSignalBackend, get_signal_backend_type, split_protocol
 
 @dataclass
 class PvSuffix:
+    """Define the PV suffix to be appended to the device prefix."""
+
     read_suffix: str
     write_suffix: str | None = None
 
@@ -36,6 +38,8 @@ def fill_backend_with_prefix(
 
 
 class EpicsDeviceConnector(DeviceConnector):
+    """Used for connecting signals to static EPICS pvs."""
+
     def __init__(self, prefix: str) -> None:
         self.prefix = prefix
 

ophyd_async/epics/core/_epics_device.py

@@ -5,6 +5,8 @@ from ._pvi_connector import PviDeviceConnector
 
 
 class EpicsDevice(Device):
+    """Baseclass to allow child signals to be created declaratively."""
+
     def __init__(self, prefix: str, with_pvi: bool = False, name: str = ""):
         if with_pvi:
             connector = PviDeviceConnector(prefix)

ophyd_async/epics/core/_p4p.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import atexit
 import logging
+import typing
 from collections.abc import Mapping, Sequence
 from math import isnan, nan
 from typing import Any, Generic
@@ -31,6 +32,8 @@ from ophyd_async.core import (
 
 from ._util import EpicsSignalBackend, format_datatype, get_supported_values
 
+logger = logging.getLogger("ophyd_async")
+
 
 def _limits_from_value(value: Any) -> Limits:
     def get_limits(
@@ -39,11 +42,12 @@ def _limits_from_value(value: Any) -> Limits:
         substructure = getattr(value, substucture_name, None)
         low = getattr(substructure, low_name, nan)
         high = getattr(substructure, high_name, nan)
-        if not (isnan(low) and isnan(high)):
+        if not (isnan(low) and isnan(high)) and not low == high == 0:
             return LimitsRange(
                 low=None if isnan(low) else low,
                 high=None if isnan(high) else high,
             )
+        return None
 
     limits = Limits()
     if limits_range := get_limits("valueAlarm", "lowAlarmLimit", "highAlarmLimit"):
@@ -60,12 +64,22 @@ def _limits_from_value(value: Any) -> Limits:
 def _metadata_from_value(datatype: type[SignalDatatype], value: Any) -> SignalMetadata:
     metadata = SignalMetadata()
     value_data: Any = getattr(value, "value", None)
+    specifier = _get_specifier(value)
     display_data: Any = getattr(value, "display", None)
-    if hasattr(display_data, "units"):
+    if (
+        hasattr(display_data, "units")
+        and specifier[-1] in _number_specifiers
+        and datatype is not str
+    ):
         metadata["units"] = display_data.units
-    if hasattr(display_data, "precision") and not isnan(display_data.precision):
+    if (
+        hasattr(display_data, "precision")
+        and not isnan(display_data.precision)
+        and specifier[-1] in _float_specifiers
+        and datatype is not int
+    ):
         metadata["precision"] = display_data.precision
-    if limits := _limits_from_value(value):
+    if (limits := _limits_from_value(value)) and specifier[-1] in _number_specifiers:
         metadata["limits"] = limits
     # Get choices from display or value
     if datatype is str or issubclass(datatype, StrictEnum):
@@ -84,9 +98,7 @@ class PvaConverter(Generic[SignalDatatypeT]):
         self.datatype = datatype
 
     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
+        # Normally the value will be of the correct python type
         return value["value"]
 
     def write_value(self, value: Any) -> Any:
@@ -94,6 +106,15 @@ class PvaConverter(Generic[SignalDatatypeT]):
         return value
 
 
+class PvaIntConverter(PvaConverter[int]):
+    def __init__(self):
+        super().__init__(int)
+
+    def value(self, value: Any) -> int:
+        # Convert to an int
+        return int(value["value"])
+
+
 class PvaLongStringConverter(PvaConverter[str]):
     def __init__(self):
         super().__init__(str)
@@ -174,6 +195,9 @@ class PvaTableConverter(PvaConverter[Table]):
 
 
 # https://mdavidsaver.github.io/p4p/values.html
+_float_specifiers = {"f", "d"}
+_int_specifiers = {"b", "B", "h", "H", "i", "I", "l", "L"}
+_number_specifiers = _float_specifiers.union(_int_specifiers)
 _datatype_converter_from_typeid: dict[
     tuple[str, str], tuple[type[SignalDatatype], type[PvaConverter]]
 ] = {
@@ -208,7 +232,7 @@ _datatype_converter_from_typeid: dict[
 }
 
 
-def _get_specifier(value: Value):
+def _get_specifier(value: Value) -> str:
     typ = value.type("value").aspy()
     if isinstance(typ, tuple):
         return typ[0]
@@ -223,6 +247,9 @@ def make_converter(datatype: type | None, values: dict[str, Any]) -> PvaConverte
         {k: _get_specifier(v) for k, v in values.items()},
         "value type specifiers",
     )
+    # Make the datatype canonical for the inference below
+    if datatype == typing.Sequence[str]:
+        datatype = Sequence[str]
     # Infer a datatype and converter from the typeid and specifier
     inferred_datatype, converter_cls = _datatype_converter_from_typeid[
         (typeid, specifier)
@@ -258,7 +285,7 @@ def make_converter(datatype: type | None, values: dict[str, Any]) -> PvaConverte
         == 0
     ):
         # Allow int signals to represent float records when prec is 0
-        return PvaConverter(int)
+        return PvaIntConverter()
     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)
@@ -301,18 +328,21 @@ 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)
+        logger.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.
+    """Convert a list of requested fields into a PVA request string.
+
+    This can be passed to p4p.
     """
     return f"field({','.join(fields)})"
 
 
 class PvaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
+    """Backend for a signal to interact with PVs over pva."""
+
     def __init__(
         self,
         datatype: type[SignalDatatypeT] | None,
@@ -383,10 +413,15 @@ class PvaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
         return self.converter.value(value)
 
     def set_callback(self, callback: Callback[Reading[SignalDatatypeT]] | None) -> None:
+        if callback and self.subscription:
+            msg = "Cannot set a callback when one is already set"
+            raise RuntimeError(msg)
+
+        if self.subscription:
+            self.subscription.close()
+            self.subscription = None
+
         if callback:
-            assert (
-                not self.subscription
-            ), "Cannot set a callback when one is already set"
 
             async def async_callback(v):
                 callback(self._make_reading(v))
@@ -397,6 +432,3 @@ class PvaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
             self.subscription = context().monitor(
                 self.read_pv, async_callback, request=request
             )
-        elif self.subscription:
-            self.subscription.close()
-            self.subscription = None

ophyd_async/epics/core/_pvi_connector.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import Literal, cast
+
 from ophyd_async.core import (
     Device,
     DeviceConnector,
@@ -7,6 +9,7 @@ from ophyd_async.core import (
     Signal,
     SignalR,
     SignalRW,
+    SignalW,
     SignalX,
 )
 from ophyd_async.core._utils import LazyMock
@@ -16,6 +19,27 @@ from ._signal import PvaSignalBackend, pvget_with_timeout
 
 Entry = dict[str, str]
 
+OldPVIVector = list[Entry | None]
+# The older PVI structure has vectors of the form
+# structure[] ttlout
+#     (none)
+#     structure
+#         string d PANDABLOCKS_IOC:TTLOUT1:PVI
+#     structure
+#         string d PANDABLOCKS_IOC:TTLOUT2:PVI
+#     structure
+#         string d PANDABLOCKS_IOC:TTLOUT3:PVI
+
+
+FastCSPVIVector = dict[Literal["d"], Entry]
+# The newer pva FastCS PVI structure has vectors of the form
+# structure ttlout
+#     structure d
+#         string v1 FASTCS_PANDA:Ttlout1:PVI
+#         string v2 FASTCS_PANDA:Ttlout2:PVI
+#         string v3 FASTCS_PANDA:Ttlout3:PVI
+#         string v4 FASTCS_PANDA:Ttlout4:PVI
+
 
 def _get_signal_details(entry: Entry) -> tuple[type[Signal], str, str]:
     match entry:
@@ -23,6 +47,8 @@ def _get_signal_details(entry: Entry) -> tuple[type[Signal], str, str]:
             return SignalR, read_pv, read_pv
         case {"r": read_pv, "w": write_pv}:
             return SignalRW, read_pv, write_pv
+        case {"w": write_pv}:
+            return SignalW, write_pv, write_pv
         case {"rw": read_write_pv}:
             return SignalRW, read_write_pv, read_write_pv
         case {"x": execute_pv}:
@@ -31,7 +57,26 @@ def _get_signal_details(entry: Entry) -> tuple[type[Signal], str, str]:
             raise TypeError(f"Can't process entry {entry}")
 
 
+def _is_device_vector_entry(entry: Entry | OldPVIVector | FastCSPVIVector) -> bool:
+    return isinstance(entry, list) or (
+        entry.keys() == {"d"} and isinstance(entry["d"], dict)
+    )
+
+
 class PviDeviceConnector(DeviceConnector):
+    """Connect to PVI structure served over PVA.
+
+    At init, fill in all the type hinted signals. At connection check their
+    types and fill in any extra signals.
+
+    :param prefix:
+        The PV prefix of the device, "PVI" will be appended to it to get the PVI
+        PV.
+    :param error_hint:
+        If given, this will be appended to the error message if any of they type
+        hinted Signals are not present.
+    """
+
     def __init__(self, prefix: str = "", error_hint: str = "") -> None:
         # TODO: what happens if we get a leading "pva://" here?
         self.prefix = prefix
@@ -70,21 +115,33 @@ class PviDeviceConnector(DeviceConnector):
         device.set_name(device.name)
         return await super().connect_mock(device, mock)
 
+    def _fill_vector_child(self, name: str, entry: OldPVIVector | FastCSPVIVector):
+        if isinstance(entry, list):
+            for i, e in enumerate(entry):
+                if e:
+                    self._fill_child(name, e, i)
+        else:
+            for i_string, e in entry["d"].items():
+                self._fill_child(name, {"d": e}, int(i_string.lstrip("v")))
+
     async def connect_real(
         self, device: Device, timeout: float, force_reconnect: bool
     ) -> None:
         pvi_structure = await pvget_with_timeout(self.pvi_pv, timeout)
-        entries: dict[str, Entry | list[Entry | None]] = pvi_structure["value"].todict()
+
+        entries: dict[str, Entry | OldPVIVector | FastCSPVIVector] = pvi_structure[
+            "value"
+        ].todict()
         # Fill based on what PVI gives us
         for name, entry in entries.items():
-            if isinstance(entry, dict):
-                # This is a child
-                self._fill_child(name, entry)
+            if _is_device_vector_entry(entry):
+                self._fill_vector_child(
+                    name, cast(OldPVIVector | FastCSPVIVector, entry)
+                )
             else:
-                # This is a DeviceVector of children
-                for i, e in enumerate(entry):
-                    if e:
-                        self._fill_child(name, e, i)
+                # This is a child
+                self._fill_child(name, cast(Entry, entry))
+
         # Check that all the requested children have been filled
         suffix = f"\n{self.error_hint}" if self.error_hint else ""
         self.filler.check_filled(f"{self.pvi_pv}: {entries}{suffix}")

ophyd_async/epics/core/_signal.py

@@ -1,10 +1,11 @@
-"""EPICS Signals over CA or PVA"""
+"""EPICS Signals over CA or PVA."""
 
 from __future__ import annotations
 
 from enum import Enum
 
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
     SignalBackend,
     SignalDatatypeT,
     SignalR,
@@ -73,6 +74,7 @@ def get_signal_backend_type(protocol: EpicsProtocol) -> type[EpicsSignalBackend]
             return CaSignalBackend
         case EpicsProtocol.PVA:
             return PvaSignalBackend
+    raise TypeError(f"Unsupported protocol: {protocol}")
 
 
 def _epics_signal_backend(
@@ -91,20 +93,18 @@ def epics_signal_rw(
     read_pv: str,
     write_pv: str | None = None,
     name: str = "",
+    timeout: float = DEFAULT_TIMEOUT,
 ) -> SignalRW[SignalDatatypeT]:
-    """Create a `SignalRW` backed by 1 or 2 EPICS PVs
-
-    Parameters
-    ----------
-    datatype:
-        Check that the PV is of this type
-    read_pv:
-        The PV to read and monitor
-    write_pv:
-        If given, use this PV to write to, otherwise use read_pv
+    """Create a `SignalRW` backed by 1 or 2 EPICS PVs.
+
+    :param datatype: Check that the PV is of this type
+    :param read_pv: The PV to read and monitor
+    :param write_pv: If given, use this PV to write to, otherwise use read_pv
+    :param name: The name of the signal (defaults to empty string)
+    :param timeout: A timeout to be used when reading (not connecting) this signal
     """
     backend = _epics_signal_backend(datatype, read_pv, write_pv or read_pv)
-    return SignalRW(backend, name=name)
+    return SignalRW(backend, name=name, timeout=timeout)
 
 
 def epics_signal_rw_rbv(
@@ -112,67 +112,67 @@ def epics_signal_rw_rbv(
     write_pv: str,
     read_suffix: str = "_RBV",
     name: str = "",
+    timeout: float = DEFAULT_TIMEOUT,
 ) -> SignalRW[SignalDatatypeT]:
-    """Create a `SignalRW` backed by 1 or 2 EPICS PVs, with a suffix on the readback pv
-
-    Parameters
-    ----------
-    datatype:
-        Check that the PV is of this type
-    write_pv:
-        The PV to write to
-    read_suffix:
-        Append this suffix to the write pv to create the readback pv
-    """
+    """Create a `SignalRW` backed by 1 or 2 EPICS PVs, with a suffix on the readback pv.
 
+    :param datatype: Check that the PV is of this type
+    :param write_pv: The PV to write to
+    :param read_suffix: Append this suffix to the write pv to create the readback pv
+    :param name: The name of the signal (defaults to empty string)
+    :param timeout: A timeout to be used when reading (not connecting) this signal
+    """
     base_pv, field = get_pv_basename_and_field(write_pv)
     if field is not None:
         read_pv = f"{base_pv}{read_suffix}.{field}"
     else:
         read_pv = f"{write_pv}{read_suffix}"
 
-    return epics_signal_rw(datatype, read_pv, write_pv, name)
+    return epics_signal_rw(datatype, read_pv, write_pv, name, timeout=timeout)
 
 
 def epics_signal_r(
-    datatype: type[SignalDatatypeT], read_pv: str, name: str = ""
+    datatype: type[SignalDatatypeT],
+    read_pv: str,
+    name: str = "",
+    timeout: float = DEFAULT_TIMEOUT,
 ) -> SignalR[SignalDatatypeT]:
-    """Create a `SignalR` backed by 1 EPICS PV
-
-    Parameters
-    ----------
-    datatype
-        Check that the PV is of this type
-    read_pv:
-        The PV to read and monitor
+    """Create a `SignalR` backed by 1 EPICS PV.
+
+    :param datatype: Check that the PV is of this type
+    :param read_pv: The PV to read from
+    :param name: The name of the signal (defaults to empty string)
+    :param timeout: A timeout to be used when reading (not connecting) this signal
     """
     backend = _epics_signal_backend(datatype, read_pv, read_pv)
-    return SignalR(backend, name=name)
+    return SignalR(backend, name=name, timeout=timeout)
 
 
 def epics_signal_w(
-    datatype: type[SignalDatatypeT], write_pv: str, name: str = ""
+    datatype: type[SignalDatatypeT],
+    write_pv: str,
+    name: str = "",
+    timeout: float = DEFAULT_TIMEOUT,
 ) -> SignalW[SignalDatatypeT]:
-    """Create a `SignalW` backed by 1 EPICS PVs
-
-    Parameters
-    ----------
-    datatype:
-        Check that the PV is of this type
-    write_pv:
-        The PV to write to
+    """Create a `SignalW` backed by 1 EPICS PVs.
+
+    :param datatype: Check that the PV is of this type
+    :param write_pv: The PV to write to
+    :param name: The name of the signal (defaults to empty string)
+    :param timeout: A timeout to be used when reading (not connecting) this signal
     """
     backend = _epics_signal_backend(datatype, write_pv, write_pv)
-    return SignalW(backend, name=name)
+    return SignalW(backend, name=name, timeout=timeout)
 
 
-def epics_signal_x(write_pv: str, name: str = "") -> SignalX:
-    """Create a `SignalX` backed by 1 EPICS PVs
+def epics_signal_x(
+    write_pv: str, name: str = "", timeout: float = DEFAULT_TIMEOUT
+) -> SignalX:
+    """Create a `SignalX` backed by 1 EPICS PVs.
 
-    Parameters
-    ----------
-    write_pv:
-        The PV to write its initial value to on trigger
+    :param write_pv: The PV to write its initial value to on trigger
+    :param name: The name of the signal
+    :param timeout: A timeout to be used when reading (not connecting) this signal
     """
     backend = _epics_signal_backend(None, write_pv, write_pv)
-    return SignalX(backend, name=name)
+    return SignalX(backend, name=name, timeout=timeout)