ophyd-async 0.5.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

ophyd_async/epics/eiger/_eiger.py

@@ -38,6 +38,6 @@ class EigerDetector(StandardDetector):
         )
 
     @AsyncStatus.wrap
-    async def prepare(self, value: EigerTriggerInfo) -> None:
+    async def prepare(self, value: EigerTriggerInfo) -> None:  # type: ignore
         await self._controller.set_energy(value.energy_ev)
         await super().prepare(value)

ophyd_async/epics/eiger/_eiger_controller.py

@@ -1,13 +1,12 @@
 import asyncio
-from typing import Optional
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
-    AsyncStatus,
     DetectorControl,
     DetectorTrigger,
     set_and_wait_for_other_value,
 )
+from ophyd_async.core._detector import TriggerInfo
 
 from ._eiger_io import EigerDriverIO, EigerTriggerMode
 
@@ -26,7 +25,7 @@ class EigerController(DetectorControl):
     ) -> None:
         self._drv = driver
 
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         # See https://media.dectris.com/filer_public/30/14/3014704e-5f3b-43ba-8ccf-8ef720e60d2a/240202_usermanual_eiger2.pdf
         return 0.0001
 
@@ -37,30 +36,31 @@ class EigerController(DetectorControl):
         if abs(current_energy - energy) > tolerance:
             await self._drv.photon_energy.set(energy)
 
-    @AsyncStatus.wrap
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.internal,
-        exposure: Optional[float] = None,
-    ):
+    async def prepare(self, trigger_info: TriggerInfo):
         coros = [
-            self._drv.trigger_mode.set(EIGER_TRIGGER_MODE_MAP[trigger].value),
-            self._drv.num_images.set(num),
+            self._drv.trigger_mode.set(
+                EIGER_TRIGGER_MODE_MAP[trigger_info.trigger].value
+            ),
+            self._drv.num_images.set(trigger_info.number),
         ]
-        if exposure is not None:
+        if trigger_info.livetime is not None:
             coros.extend(
                 [
-                    self._drv.acquire_time.set(exposure),
-                    self._drv.acquire_period.set(exposure),
+                    self._drv.acquire_time.set(trigger_info.livetime),
+                    self._drv.acquire_period.set(trigger_info.livetime),
                 ]
             )
         await asyncio.gather(*coros)
 
+    async def arm(self):
         # TODO: Detector state should be an enum see https://github.com/DiamondLightSource/eiger-fastcs/issues/43
-        await set_and_wait_for_other_value(
+        self._arm_status = set_and_wait_for_other_value(
             self._drv.arm, 1, self._drv.state, "ready", timeout=DEFAULT_TIMEOUT
         )
 
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
+
     async def disarm(self):
         await self._drv.disarm.set(1)

ophyd_async/epics/eiger/_odin_io.py

@@ -1,9 +1,9 @@
 import asyncio
+from collections.abc import AsyncGenerator, AsyncIterator
 from enum import Enum
-from typing import AsyncGenerator, AsyncIterator, Dict
 
 from bluesky.protocols import StreamAsset
-from event_model.documents.event_descriptor import DataKey
+from event_model import DataKey
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
@@ -77,7 +77,7 @@ class OdinWriter(DetectorWriter):
         self._name_provider = name_provider
         super().__init__()
 
-    async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
+    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
         info = self._path_provider(device_name=self._name_provider())
 
         await asyncio.gather(
@@ -93,7 +93,7 @@ class OdinWriter(DetectorWriter):
 
         return await self._describe()
 
-    async def _describe(self) -> Dict[str, DataKey]:
+    async def _describe(self) -> dict[str, DataKey]:
         data_shape = await asyncio.gather(
             self._drv.image_height.get_value(), self._drv.image_width.get_value()
         )
@@ -103,7 +103,8 @@ class OdinWriter(DetectorWriter):
                 source=self._drv.file_name.source,
                 shape=data_shape,
                 dtype="array",
-                dtype_numpy="<u2",  # TODO: Use correct type based on eiger https://github.com/bluesky/ophyd-async/issues/529
+                # TODO: Use correct type based on eiger https://github.com/bluesky/ophyd-async/issues/529
+                dtype_numpy="<u2",  # type: ignore
                 external="STREAM:",
             )
         }

ophyd_async/epics/motor.py

@@ -1,5 +1,4 @@
 import asyncio
-from typing import Optional
 
 from bluesky.protocols import (
     Flyable,
@@ -11,10 +10,10 @@ from bluesky.protocols import (
 from pydantic import BaseModel, Field
 
 from ophyd_async.core import (
+    CALCULATE_TIMEOUT,
     DEFAULT_TIMEOUT,
     AsyncStatus,
     CalculatableTimeout,
-    CalculateTimeout,
     ConfigSignal,
     HintedSignal,
     StandardReadable,
@@ -54,7 +53,7 @@ class FlyMotorInfo(BaseModel):
 
     #: Maximum time for the complete motor move, including run up and run down.
     #: Defaults to `time_for_move` + run up and run down times + 10s.
-    timeout: CalculatableTimeout = Field(frozen=True, default=CalculateTimeout)
+    timeout: CalculatableTimeout = Field(frozen=True, default=CALCULATE_TIMEOUT)
 
 
 class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
@@ -83,13 +82,13 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         self._set_success = True
 
         # end_position of a fly move, with run_up_distance added on.
-        self._fly_completed_position: Optional[float] = None
+        self._fly_completed_position: float | None = None
 
         # Set on kickoff(), complete when motor reaches self._fly_completed_position
-        self._fly_status: Optional[WatchableAsyncStatus] = None
+        self._fly_status: WatchableAsyncStatus | None = None
 
         # Set during prepare
-        self._fly_timeout: Optional[CalculatableTimeout] = CalculateTimeout
+        self._fly_timeout: CalculatableTimeout | None = CALCULATE_TIMEOUT
 
         super().__init__(name=name)
 
@@ -138,9 +137,8 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         return self._fly_status
 
     @WatchableAsyncStatus.wrap
-    async def set(
-        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
-    ):
+    async def set(self, value: float, timeout: CalculatableTimeout = CALCULATE_TIMEOUT):
+        new_position = value
         self._set_success = True
         (
             old_position,
@@ -155,7 +153,7 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
             self.velocity.get_value(),
             self.acceleration_time.get_value(),
         )
-        if timeout is CalculateTimeout:
+        if timeout is CALCULATE_TIMEOUT:
             assert velocity > 0, "Motor has zero velocity"
             timeout = (
                 abs(new_position - old_position) / velocity

ophyd_async/epics/pvi/_pvi.py

@@ -1,15 +1,11 @@
 import re
+import types
+from collections.abc import Callable
 from dataclasses import dataclass
 from inspect import isclass
 from typing import (
     Any,
-    Callable,
-    Dict,
-    FrozenSet,
     Literal,
-    Optional,
-    Tuple,
-    Type,
     Union,
     get_args,
     get_origin,
@@ -32,23 +28,24 @@ from ophyd_async.epics.signal import (
     epics_signal_x,
 )
 
-Access = FrozenSet[
-    Union[Literal["r"], Literal["w"], Literal["rw"], Literal["x"], Literal["d"]]
+Access = frozenset[
+    Literal["r"] | Literal["w"] | Literal["rw"] | Literal["x"] | Literal["d"]
 ]
 
 
-def _strip_number_from_string(string: str) -> Tuple[str, Optional[int]]:
+def _strip_number_from_string(string: str) -> tuple[str, int | None]:
     match = re.match(r"(.*?)(\d*)$", string)
     assert match
 
     name = match.group(1)
     number = match.group(2) or None
-    if number:
-        number = int(number)
-    return name, number
+    if number is None:
+        return name, None
+    else:
+        return name, int(number)
 
 
-def _split_subscript(tp: T) -> Union[Tuple[Any, Tuple[Any]], Tuple[T, None]]:
+def _split_subscript(tp: T) -> tuple[Any, tuple[Any]] | tuple[T, None]:
     """Split a subscripted type into the its origin and args.
 
     If `tp` is not a subscripted type, then just return the type and None as args.
@@ -60,8 +57,8 @@ def _split_subscript(tp: T) -> Union[Tuple[Any, Tuple[Any]], Tuple[T, None]]:
     return tp, None
 
 
-def _strip_union(field: Union[Union[T], T]) -> Tuple[T, bool]:
-    if get_origin(field) is Union:
+def _strip_union(field: T | T) -> tuple[T, bool]:
+    if get_origin(field) in [Union, types.UnionType]:
         args = get_args(field)
         is_optional = type(None) in args
         for arg in args:
@@ -70,7 +67,7 @@ def _strip_union(field: Union[Union[T], T]) -> Tuple[T, bool]:
     return field, False
 
 
-def _strip_device_vector(field: Union[Type[Device]]) -> Tuple[bool, Type[Device]]:
+def _strip_device_vector(field: type[Device]) -> tuple[bool, type[Device]]:
     if get_origin(field) is DeviceVector:
         return True, get_args(field)[0]
     return False, field
@@ -83,13 +80,13 @@ class _PVIEntry:
     This could either be a signal or a sub-table.
     """
 
-    sub_entries: Dict[str, Union[Dict[int, "_PVIEntry"], "_PVIEntry"]]
-    pvi_pv: Optional[str] = None
-    device: Optional[Device] = None
-    common_device_type: Optional[Type[Device]] = None
+    sub_entries: dict[str, Union[dict[int, "_PVIEntry"], "_PVIEntry"]]
+    pvi_pv: str | None = None
+    device: Device | None = None
+    common_device_type: type[Device] | None = None
 
 
-def _verify_common_blocks(entry: _PVIEntry, common_device: Type[Device]):
+def _verify_common_blocks(entry: _PVIEntry, common_device: type[Device]):
     if not entry.sub_entries:
         return
     common_sub_devices = get_type_hints(common_device)
@@ -107,12 +104,12 @@ def _verify_common_blocks(entry: _PVIEntry, common_device: Type[Device]):
                 _verify_common_blocks(sub_sub_entry, sub_device)  # type: ignore
         else:
             _verify_common_blocks(
-                entry.sub_entries[sub_name],
+                entry.sub_entries[sub_name],  # type: ignore
                 sub_device,  # type: ignore
             )
 
 
-_pvi_mapping: Dict[FrozenSet[str], Callable[..., Signal]] = {
+_pvi_mapping: dict[frozenset[str], Callable[..., Signal]] = {
     frozenset({"r", "w"}): lambda dtype, read_pv, write_pv: epics_signal_rw(
         dtype, "pva://" + read_pv, "pva://" + write_pv
     ),
@@ -129,8 +126,8 @@ _pvi_mapping: Dict[FrozenSet[str], Callable[..., Signal]] = {
 
 def _parse_type(
     is_pvi_table: bool,
-    number_suffix: Optional[int],
-    common_device_type: Optional[Type[Device]],
+    number_suffix: int | None,
+    common_device_type: type[Device] | None,
 ):
     if common_device_type:
         # pre-defined type
@@ -159,7 +156,7 @@ def _parse_type(
     return is_device_vector, is_signal, signal_dtype, device_cls
 
 
-def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
+def _mock_common_blocks(device: Device, stripped_type: type | None = None):
     device_t = stripped_type or type(device)
     sub_devices = (
         (field, field_type)
@@ -173,11 +170,10 @@ def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
         device_cls, device_args = _split_subscript(device_cls)
         assert issubclass(device_cls, Device)
 
-        is_signal = issubclass(device_cls, Signal)
         signal_dtype = device_args[0] if device_args is not None else None
 
         if is_device_vector:
-            if is_signal:
+            if issubclass(device_cls, Signal):
                 sub_device_1 = device_cls(SoftSignalBackend(signal_dtype))
                 sub_device_2 = device_cls(SoftSignalBackend(signal_dtype))
                 sub_device = DeviceVector({1: sub_device_1, 2: sub_device_2})
@@ -198,7 +194,7 @@ def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
             for value in sub_device.values():
                 value.parent = sub_device
         else:
-            if is_signal:
+            if issubclass(device_cls, Signal):
                 sub_device = device_cls(SoftSignalBackend(signal_dtype))
             else:
                 sub_device = getattr(device, device_name, device_cls())
@@ -271,7 +267,8 @@ def _set_device_attributes(entry: _PVIEntry):
                 # Set the device vector entry to have the device vector as a parent
                 device_vector_sub_entry.device.parent = sub_device  # type: ignore
         else:
-            sub_device = sub_entry.device  # type: ignore
+            sub_device = sub_entry.device
+            assert sub_device, f"Device of {sub_entry} is None"
             if sub_entry.pvi_pv:
                 _set_device_attributes(sub_entry)
 
@@ -308,8 +305,8 @@ async def fill_pvi_entries(
 
 def create_children_from_annotations(
     device: Device,
-    included_optional_fields: Tuple[str, ...] = (),
-    device_vectors: Optional[Dict[str, int]] = None,
+    included_optional_fields: tuple[str, ...] = (),
+    device_vectors: dict[str, int] | None = None,
 ):
     """For intializing blocks at __init__ of ``device``."""
     for name, device_type in get_type_hints(type(device)).items():
@@ -328,7 +325,7 @@ def create_children_from_annotations(
 
         if is_device_vector:
             n_device_vector = DeviceVector(
-                {i: device_type() for i in range(1, device_vectors[name] + 1)}
+                {i: device_type() for i in range(1, device_vectors[name] + 1)}  # type: ignore
             )
             setattr(device, name, n_device_vector)
             for sub_device in n_device_vector.values():

ophyd_async/epics/signal/_aioca.py

@@ -1,9 +1,11 @@
+import inspect
 import logging
 import sys
+from collections.abc import Sequence
 from dataclasses import dataclass
 from enum import Enum
 from math import isnan, nan
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import Any, get_origin
 
 import numpy as np
 from aioca import (
@@ -17,13 +19,16 @@ from aioca import (
     caput,
 )
 from aioca.types import AugmentedValue, Dbr, Format
-from bluesky.protocols import DataKey, Dtype, Reading
+from bluesky.protocols import Reading
 from epicscorelibs.ca import dbr
+from event_model import DataKey
+from event_model.documents.event_descriptor import Dtype
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     NotConnected,
     ReadingValueCallback,
+    RuntimeSubsetEnum,
     SignalBackend,
     T,
     get_dtype,
@@ -33,7 +38,7 @@ from ophyd_async.core import (
 
 from ._common import LimitPair, Limits, common_meta, get_supported_values
 
-dbr_to_dtype: Dict[Dbr, Dtype] = {
+dbr_to_dtype: dict[Dbr, Dtype] = {
     dbr.DBR_STRING: "string",
     dbr.DBR_SHORT: "integer",
     dbr.DBR_FLOAT: "number",
@@ -46,8 +51,8 @@ dbr_to_dtype: Dict[Dbr, Dtype] = {
 def _data_key_from_augmented_value(
     value: AugmentedValue,
     *,
-    choices: Optional[List[str]] = None,
-    dtype: Optional[Dtype] = None,
+    choices: list[str] | None = None,
+    dtype: Dtype | None = None,
 ) -> DataKey:
     """Use the return value of get with FORMAT_CTRL to construct a DataKey
     describing the signal. See docstring of AugmentedValue for expected
@@ -65,14 +70,15 @@ def _data_key_from_augmented_value(
     assert value.ok, f"Error reading {source}: {value}"
 
     scalar = value.element_count == 1
-    dtype = dtype or dbr_to_dtype[value.datatype]
+    dtype = dtype or dbr_to_dtype[value.datatype]  # type: ignore
 
     dtype_numpy = np.dtype(dbr.DbrCodeToType[value.datatype].dtype).descr[0][1]
 
     d = DataKey(
         source=source,
         dtype=dtype if scalar else "array",
-        dtype_numpy=dtype_numpy,
+        # Ignore until https://github.com/bluesky/event-model/issues/308
+        dtype_numpy=dtype_numpy,  # type: ignore
         # strictly value.element_count >= len(value)
         shape=[] if scalar else [len(value)],
     )
@@ -82,10 +88,10 @@ def _data_key_from_augmented_value(
             d[key] = attr
 
     if choices is not None:
-        d["choices"] = choices
+        d["choices"] = choices  # type: ignore
 
     if limits := _limits_from_augmented_value(value):
-        d["limits"] = limits
+        d["limits"] = limits  # type: ignore
 
     return d
 
@@ -108,8 +114,8 @@ def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
 
 @dataclass
 class CaConverter:
-    read_dbr: Optional[Dbr]
-    write_dbr: Optional[Dbr]
+    read_dbr: Dbr | None
+    write_dbr: Dbr | None
 
     def write_value(self, value) -> Any:
         return value
@@ -118,9 +124,9 @@ class CaConverter:
         # for channel access ca_xxx classes, this
         # invokes __pos__ operator to return an instance of
         # the builtin base class
-        return +value
+        return +value  # type: ignore
 
-    def reading(self, value: AugmentedValue):
+    def reading(self, value: AugmentedValue) -> Reading:
         return {
             "value": self.value(value),
             "timestamp": value.timestamp,
@@ -155,14 +161,14 @@ class CaEnumConverter(CaConverter):
 
     choices: dict[str, str]
 
-    def write_value(self, value: Union[Enum, str]):
+    def write_value(self, value: Enum | str):
         if isinstance(value, Enum):
             return value.value
         else:
             return value
 
     def value(self, value: AugmentedValue):
-        return self.choices[value]
+        return self.choices[value]  # type: ignore
 
     def get_datakey(self, value: AugmentedValue) -> DataKey:
         # Sometimes DBR_TYPE returns as String, must pass choices still
@@ -184,7 +190,7 @@ class DisconnectedCaConverter(CaConverter):
 
 
 def make_converter(
-    datatype: Optional[Type], values: Dict[str, AugmentedValue]
+    datatype: type | None, values: dict[str, AugmentedValue]
 ) -> CaConverter:
     pv = list(values)[0]
     pv_dbr = get_unique({k: v.datatype for k, v in values.items()}, "datatypes")
@@ -200,7 +206,7 @@ def make_converter(
                 raise TypeError(f"{pv} has type [str] not {datatype.__name__}")
         return CaArrayConverter(pv_dbr, None)
     elif is_array:
-        pv_dtype = get_unique({k: v.dtype for k, v in values.items()}, "dtypes")
+        pv_dtype = get_unique({k: v.dtype for k, v in values.items()}, "dtypes")  # type: ignore
         # This is an array
         if datatype:
             # Check we wanted an array of this type
@@ -209,9 +215,10 @@ def make_converter(
                 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}]")
-        return CaArrayConverter(pv_dbr, None)
+        return CaArrayConverter(pv_dbr, None)  # type: ignore
     elif pv_dbr == dbr.DBR_ENUM and datatype is bool:
-        # Database can't do bools, so are often representated as enums, CA can do int
+        # Database can't do bools, so are often representated as enums,
+        # CA can do int
         pv_choices_len = get_unique(
             {k: len(v.enums) for k, v in values.items()}, "number of choices"
         )
@@ -240,7 +247,7 @@ def make_converter(
                     f"{pv} has type {type(value).__name__.replace('ca_', '')} "
                     + f"not {datatype.__name__}"
                 )
-        return CaConverter(pv_dbr, None)
+    return CaConverter(pv_dbr, None)  # type: ignore
 
 
 _tried_pyepics = False
@@ -256,13 +263,36 @@ def _use_pyepics_context_if_imported():
 
 
 class CaSignalBackend(SignalBackend[T]):
-    def __init__(self, datatype: Optional[Type[T]], read_pv: str, write_pv: str):
+    _ALLOWED_DATATYPES = (
+        bool,
+        int,
+        float,
+        str,
+        Sequence,
+        Enum,
+        RuntimeSubsetEnum,
+        np.ndarray,
+    )
+
+    @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 CaSignalBackend.datatype_allowed(self.datatype):
+            raise TypeError(f"Given datatype {self.datatype} unsupported in CA.")
         self.read_pv = read_pv
         self.write_pv = write_pv
-        self.initial_values: Dict[str, AugmentedValue] = {}
+        self.initial_values: dict[str, AugmentedValue] = {}
         self.converter: CaConverter = DisconnectedCaConverter(None, None)
-        self.subscription: Optional[Subscription] = None
+        self.subscription: Subscription | None = None
 
     def source(self, name: str):
         return f"ca://{self.read_pv}"
@@ -289,7 +319,7 @@ class CaSignalBackend(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: Optional[T], wait=True, timeout=None):
+    async def put(self, value: T | None, wait=True, timeout=None):
         if value is None:
             write_value = self.initial_values[self.write_pv]
         else:
@@ -331,7 +361,7 @@ class CaSignalBackend(SignalBackend[T]):
         )
         return self.converter.value(value)
 
-    def set_callback(self, callback: Optional[ReadingValueCallback[T]]) -> None:
+    def set_callback(self, callback: ReadingValueCallback[T] | None) -> None:
         if callback:
             assert (
                 not self.subscription

ophyd_async/epics/signal/_common.py

@@ -1,6 +1,5 @@
 import inspect
 from enum import Enum
-from typing import Dict, Optional, Tuple, Type
 
 from typing_extensions import TypedDict
 
@@ -16,9 +15,6 @@ class LimitPair(TypedDict):
     high: float | None
     low: float | None
 
-    def __bool__(self) -> bool:
-        return self.low is None and self.high is None
-
 
 class Limits(TypedDict):
     alarm: LimitPair
@@ -26,15 +22,12 @@ class Limits(TypedDict):
     display: LimitPair
     warning: LimitPair
 
-    def __bool__(self) -> bool:
-        return any(self.alarm, self.control, self.display, self.warning)
-
 
 def get_supported_values(
     pv: str,
-    datatype: Optional[Type[str]],
-    pv_choices: Tuple[str, ...],
-) -> Dict[str, str]:
+    datatype: type[str] | None,
+    pv_choices: tuple[str, ...],
+) -> dict[str, str]:
     if inspect.isclass(datatype) and issubclass(datatype, RuntimeSubsetEnum):
         if not set(datatype.choices).issubset(set(pv_choices)):
             raise TypeError(

ophyd_async/epics/signal/_epics_transport.py

@@ -4,22 +4,25 @@ from __future__ import annotations
 
 from enum import Enum
 
+
+def _make_unavailable_class(error: Exception) -> type:
+    class TransportNotAvailable:
+        def __init__(*args, **kwargs):
+            raise NotImplementedError("Transport not available") from error
+
+    return TransportNotAvailable
+
+
 try:
     from ._aioca import CaSignalBackend
 except ImportError as ca_error:
-
-    class CaSignalBackend:  # type: ignore
-        def __init__(*args, ca_error=ca_error, **kwargs):
-            raise NotImplementedError("CA support not available") from ca_error
+    CaSignalBackend = _make_unavailable_class(ca_error)
 
 
 try:
     from ._p4p import PvaSignalBackend
 except ImportError as pva_error:
-
-    class PvaSignalBackend:  # type: ignore
-        def __init__(*args, pva_error=pva_error, **kwargs):
-            raise NotImplementedError("PVA support not available") from pva_error
+    PvaSignalBackend = _make_unavailable_class(pva_error)
 
 
 class _EpicsTransport(Enum):