ophyd-async 0.3a3__py3-none-any.whl → 0.3a4__py3-none-any.whl

ophyd_async/core/{sim_signal_backend.py → soft_signal_backend.py}

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
-import asyncio
 import inspect
 import time
 from collections import abc
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Dict, Generic, Optional, Type, Union, cast, get_origin
+from typing import Dict, Generic, Optional, Type, Union, cast, get_origin
 
 import numpy as np
 from bluesky.protocols import DataKey, Dtype, Reading
@@ -22,7 +21,7 @@ primitive_dtypes: Dict[type, Dtype] = {
 }
 
 
-class SimConverter(Generic[T]):
+class SoftConverter(Generic[T]):
     def value(self, value: T) -> T:
         return value
 
@@ -55,7 +54,7 @@ class SimConverter(Generic[T]):
         return datatype()
 
 
-class SimArrayConverter(SimConverter):
+class SoftArrayConverter(SoftConverter):
     def get_datakey(self, source: str, value) -> DataKey:
         return {"source": source, "dtype": "array", "shape": [len(value)]}
 
@@ -70,7 +69,7 @@ class SimArrayConverter(SimConverter):
 
 
 @dataclass
-class SimEnumConverter(SimConverter):
+class SoftEnumConverter(SoftConverter):
     enum_class: Type[Enum]
 
     def write_value(self, value: Union[Enum, str]) -> Enum:
@@ -90,26 +89,21 @@ class SimEnumConverter(SimConverter):
         return cast(T, list(datatype.__members__.values())[0])  # type: ignore
 
 
-class DisconnectedSimConverter(SimConverter):
-    def __getattribute__(self, __name: str) -> Any:
-        raise NotImplementedError("No PV has been set as connect() has not been called")
-
-
 def make_converter(datatype):
     is_array = get_dtype(datatype) is not None
     is_sequence = get_origin(datatype) == abc.Sequence
     is_enum = issubclass(datatype, Enum) if inspect.isclass(datatype) else False
 
     if is_array or is_sequence:
-        return SimArrayConverter()
+        return SoftArrayConverter()
     if is_enum:
-        return SimEnumConverter(datatype)
+        return SoftEnumConverter(datatype)
 
-    return SimConverter()
+    return SoftConverter()
 
 
-class SimSignalBackend(SignalBackend[T]):
-    """An simulated backend to a Signal, created with ``Signal.connect(sim=True)``"""
+class SoftSignalBackend(SignalBackend[T]):
+    """An backend to a soft Signal, for test signals see ``MockSignalBackend``."""
 
     _value: T
     _initial_value: Optional[T]
@@ -122,25 +116,23 @@ class SimSignalBackend(SignalBackend[T]):
         initial_value: Optional[T] = None,
     ) -> None:
         self.datatype = datatype
-        self.converter: SimConverter = DisconnectedSimConverter()
         self._initial_value = initial_value
-        self.put_proceeds = asyncio.Event()
-        self.put_proceeds.set()
-        self.callback: Optional[ReadingValueCallback[T]] = None
-
-    def source(self, name: str) -> str:
-        return f"soft://{name}"
-
-    async def connect(self, timeout: float = DEFAULT_TIMEOUT) -> None:
-        self.converter = make_converter(self.datatype)
+        self.converter: SoftConverter = make_converter(datatype)
         if self._initial_value is None:
             self._initial_value = self.converter.make_initial_value(self.datatype)
         else:
-            # convert potentially unconverted initial value passed to init method
             self._initial_value = self.converter.write_value(self._initial_value)
+
+        self.callback: Optional[ReadingValueCallback[T]] = None
         self._severity = 0
+        self.set_value(self._initial_value)
 
-        await self.put(None)
+    def source(self, name: str) -> str:
+        return f"soft://{name}"
+
+    async def connect(self, timeout: float = DEFAULT_TIMEOUT) -> None:
+        """Connection isn't required for soft signals."""
+        pass
 
     async def put(self, value: Optional[T], wait=True, timeout=None):
         write_value = (
@@ -148,13 +140,11 @@ class SimSignalBackend(SignalBackend[T]):
             if value is not None
             else self._initial_value
         )
-        self._set_value(write_value)
 
-        if wait:
-            await asyncio.wait_for(self.put_proceeds.wait(), timeout)
+        self.set_value(write_value)
 
-    def _set_value(self, value: T):
-        """Method to bypass asynchronous logic, designed to only be used in tests."""
+    def set_value(self, value: T):
+        """Method to bypass asynchronous logic."""
         self._value = value
         self._timestamp = time.monotonic()
         reading: Reading = self.converter.reading(
@@ -174,7 +164,7 @@ class SimSignalBackend(SignalBackend[T]):
         return self.converter.value(self._value)
 
     async def get_setpoint(self) -> T:
-        """For a simulated backend, the setpoint and readback values are the same."""
+        """For a soft signal, the setpoint and readback values are the same."""
         return await self.get_value()
 
     def set_callback(self, callback: Optional[ReadingValueCallback[T]]) -> None:

ophyd_async/epics/_backend/_aioca.py

@@ -28,7 +28,7 @@ from ophyd_async.core import (
 )
 from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
 
-from .common import get_supported_enum_class
+from .common import get_supported_values
 
 dbr_to_dtype: Dict[Dbr, Dtype] = {
     dbr.DBR_STRING: "string",
@@ -79,7 +79,7 @@ class CaArrayConverter(CaConverter):
 
 @dataclass
 class CaEnumConverter(CaConverter):
-    enum_class: Type[Enum]
+    choices: dict[str, str]
 
     def write_value(self, value: Union[Enum, str]):
         if isinstance(value, Enum):
@@ -88,11 +88,15 @@ class CaEnumConverter(CaConverter):
             return value
 
     def value(self, value: AugmentedValue):
-        return self.enum_class(value)
+        return self.choices[value]
 
     def get_datakey(self, source: str, value: AugmentedValue) -> DataKey:
-        choices = [e.value for e in self.enum_class]
-        return {"source": source, "dtype": "string", "shape": [], "choices": choices}
+        return {
+            "source": source,
+            "dtype": "string",
+            "shape": [],
+            "choices": list(self.choices),
+        }
 
 
 class DisconnectedCaConverter(CaConverter):
@@ -138,8 +142,8 @@ def make_converter(
         pv_choices = get_unique(
             {k: tuple(v.enums) for k, v in values.items()}, "choices"
         )
-        enum_class = get_supported_enum_class(pv, datatype, pv_choices)
-        return CaEnumConverter(dbr.DBR_STRING, None, enum_class)
+        supported_values = get_supported_values(pv, datatype, pv_choices)
+        return CaEnumConverter(dbr.DBR_STRING, None, supported_values)
     else:
         value = list(values.values())[0]
         # Done the dbr check, so enough to check one of the values

ophyd_async/epics/_backend/_p4p.py

@@ -20,7 +20,7 @@ from ophyd_async.core import (
 )
 from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
 
-from .common import get_supported_enum_class
+from .common import get_supported_values
 
 # https://mdavidsaver.github.io/p4p/values.html
 specifier_to_dtype: Dict[str, Dtype] = {
@@ -109,7 +109,8 @@ class PvaNDArrayConverter(PvaConverter):
 
 @dataclass
 class PvaEnumConverter(PvaConverter):
-    enum_class: Type[Enum]
+    def __init__(self, choices: dict[str, str]):
+        self.choices = tuple(choices.values())
 
     def write_value(self, value: Union[Enum, str]):
         if isinstance(value, Enum):
@@ -118,11 +119,15 @@ class PvaEnumConverter(PvaConverter):
             return value
 
     def value(self, value):
-        return list(self.enum_class)[value["value"]["index"]]
+        return self.choices[value["value"]["index"]]
 
     def get_datakey(self, source: str, value) -> DataKey:
-        choices = [e.value for e in self.enum_class]
-        return {"source": source, "dtype": "string", "shape": [], "choices": choices}
+        return {
+            "source": source,
+            "dtype": "string",
+            "shape": [],
+            "choices": list(self.choices),
+        }
 
 
 class PvaEnumBoolConverter(PvaConverter):
@@ -214,7 +219,7 @@ def make_converter(datatype: Optional[Type], values: Dict[str, Any]) -> PvaConve
         pv_choices = get_unique(
             {k: tuple(v["value"]["choices"]) for k, v in values.items()}, "choices"
         )
-        return PvaEnumConverter(get_supported_enum_class(pv, datatype, pv_choices))
+        return PvaEnumConverter(get_supported_values(pv, datatype, pv_choices))
     elif "NTScalar" in typeid:
         if (
             datatype
@@ -244,7 +249,6 @@ class PvaSignalBackend(SignalBackend[T]):
         self.converter: PvaConverter = DisconnectedPvaConverter()
         self.subscription: Optional[Subscription] = None
 
-    @property
     def source(self, name: str):
         return f"pva://{self.read_pv}"
 

ophyd_async/epics/_backend/common.py

@@ -1,25 +1,25 @@
 from enum import Enum
-from typing import Any, Optional, Tuple, Type
+from typing import Dict, Optional, Tuple, Type
 
 
-def get_supported_enum_class(
+def get_supported_values(
     pv: str,
-    datatype: Optional[Type[Enum]],
-    pv_choices: Tuple[Any, ...],
-) -> Type[Enum]:
+    datatype: Optional[Type[str]],
+    pv_choices: Tuple[str, ...],
+) -> Dict[str, str]:
     if not datatype:
-        return Enum("GeneratedChoices", {x or "_": x for x in pv_choices}, type=str)  # type: ignore
+        return {x: x or "_" for x in pv_choices}
 
-    if not issubclass(datatype, Enum):
-        raise TypeError(f"{pv} has type Enum not {datatype.__name__}")
     if not issubclass(datatype, str):
-        raise TypeError(f"{pv} has type Enum but doesn't inherit from String")
-    choices = tuple(v.value for v in datatype)
-    if set(choices) != set(pv_choices):
-        raise TypeError(
-            (
-                f"{pv} has choices {pv_choices}, "
-                f"which do not match {datatype}, which has {choices}"
+        raise TypeError(f"{pv} is type Enum but doesn't inherit from String")
+    if issubclass(datatype, Enum):
+        choices = tuple(v.value for v in datatype)
+        if set(choices) != set(pv_choices):
+            raise TypeError(
+                (
+                    f"{pv} has choices {pv_choices}, "
+                    f"which do not match {datatype}, which has {choices}"
+                )
             )
-        )
-    return datatype
+        return {x: datatype(x) for x in pv_choices}
+    return {x: x for x in pv_choices}

ophyd_async/epics/areadetector/__init__.py

@@ -7,8 +7,6 @@ from .utils import (
     ImageMode,
     NDAttributeDataType,
     NDAttributesXML,
-    ad_r,
-    ad_rw,
 )
 from .vimba import VimbaDetector
 
@@ -19,8 +17,6 @@ __all__ = [
     "SingleTriggerDet",
     "FileWriteMode",
     "ImageMode",
-    "ad_r",
-    "ad_rw",
     "NDAttributeDataType",
     "NDAttributesXML",
     "PilatusDetector",

ophyd_async/epics/areadetector/drivers/ad_base.py

@@ -9,8 +9,8 @@ from ophyd_async.core import (
     set_and_wait_for_value,
 )
 
-from ...signal.signal import epics_signal_rw
-from ..utils import ImageMode, ad_r, ad_rw
+from ...signal.signal import epics_signal_r, epics_signal_rw, epics_signal_rw_rbv
+from ..utils import ImageMode
 from ..writers.nd_plugin import NDArrayBase
 
 
@@ -43,14 +43,16 @@ DEFAULT_GOOD_STATES: FrozenSet[DetectorState] = frozenset(
 class ADBase(NDArrayBase):
     def __init__(self, prefix: str, name: str = "") -> None:
         # Define some signals
-        self.acquire = ad_rw(bool, prefix + "Acquire")
-        self.acquire_time = ad_rw(float, prefix + "AcquireTime")
-        self.num_images = ad_rw(int, prefix + "NumImages")
-        self.image_mode = ad_rw(ImageMode, prefix + "ImageMode")
-        self.array_counter = ad_rw(int, prefix + "ArrayCounter")
-        self.array_size_x = ad_r(int, prefix + "ArraySizeX")
-        self.array_size_y = ad_r(int, prefix + "ArraySizeY")
-        self.detector_state = ad_r(DetectorState, prefix + "DetectorState")
+        self.acquire = epics_signal_rw_rbv(bool, prefix + "Acquire")
+        self.acquire_time = epics_signal_rw_rbv(float, prefix + "AcquireTime")
+        self.num_images = epics_signal_rw_rbv(int, prefix + "NumImages")
+        self.image_mode = epics_signal_rw_rbv(ImageMode, prefix + "ImageMode")
+        self.array_counter = epics_signal_rw_rbv(int, prefix + "ArrayCounter")
+        self.array_size_x = epics_signal_r(int, prefix + "ArraySizeX_RBV")
+        self.array_size_y = epics_signal_r(int, prefix + "ArraySizeY_RBV")
+        self.detector_state = epics_signal_r(
+            DetectorState, prefix + "DetectorState_RBV"
+        )
         # There is no _RBV for this one
         self.wait_for_plugins = epics_signal_rw(bool, prefix + "WaitForPlugins")
         super().__init__(prefix, name=name)

ophyd_async/epics/areadetector/drivers/aravis_driver.py

@@ -2,7 +2,7 @@ from enum import Enum
 from typing import Callable, Dict, Literal, Optional, Tuple
 
 from ophyd_async.epics.areadetector.drivers import ADBase
-from ophyd_async.epics.areadetector.utils import ad_r, ad_rw
+from ophyd_async.epics.signal.signal import epics_signal_r, epics_signal_rw_rbv
 
 
 class AravisTriggerMode(str, Enum):
@@ -138,10 +138,12 @@ class AravisDriver(ADBase):
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.trigger_mode = ad_rw(AravisTriggerMode, prefix + "TriggerMode")
-        self.trigger_source = ad_rw(str, prefix + "TriggerSource")
-        self.model = ad_r(str, prefix + "Model")
-        self.pixel_format = ad_rw(str, prefix + "PixelFormat")
+        self.trigger_mode = epics_signal_rw_rbv(
+            AravisTriggerMode, prefix + "TriggerMode"
+        )
+        self.trigger_source = epics_signal_rw_rbv(str, prefix + "TriggerSource")
+        self.model = epics_signal_r(str, prefix + "Model_RBV")
+        self.pixel_format = epics_signal_rw_rbv(str, prefix + "PixelFormat")
         self.dead_time: Optional[float] = None
         super().__init__(prefix, name=name)
 

ophyd_async/epics/areadetector/drivers/kinetix_driver.py

@@ -1,6 +1,7 @@
 from enum import Enum
 
-from ..utils import ad_rw
+from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
+
 from .ad_base import ADBase
 
 
@@ -18,7 +19,9 @@ class KinetixReadoutMode(str, Enum):
 
 class KinetixDriver(ADBase):
     def __init__(self, prefix: str, name: str = "") -> None:
-        # self.pixel_format = ad_rw(PixelFormat, prefix + "PixelFormat")
-        self.trigger_mode = ad_rw(KinetixTriggerMode, prefix + "TriggerMode")
-        self.mode = ad_rw(KinetixReadoutMode, prefix + "ReadoutPortIdx")
+        # self.pixel_format = epics_signal_rw_rbv(PixelFormat, prefix + "PixelFormat")
+        self.trigger_mode = epics_signal_rw_rbv(
+            KinetixTriggerMode, prefix + "TriggerMode"
+        )
+        self.mode = epics_signal_rw_rbv(KinetixReadoutMode, prefix + "ReadoutPortIdx")
         super().__init__(prefix, name)

ophyd_async/epics/areadetector/drivers/pilatus_driver.py

@@ -1,6 +1,7 @@
 from enum import Enum
 
-from ..utils import ad_rw
+from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
+
 from .ad_base import ADBase
 
 
@@ -14,5 +15,7 @@ class PilatusTriggerMode(str, Enum):
 
 class PilatusDriver(ADBase):
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.trigger_mode = ad_rw(PilatusTriggerMode, prefix + "TriggerMode")
+        self.trigger_mode = epics_signal_rw_rbv(
+            PilatusTriggerMode, prefix + "TriggerMode"
+        )
         super().__init__(prefix, name)

ophyd_async/epics/areadetector/drivers/vimba_driver.py

@@ -1,6 +1,7 @@
 from enum import Enum
 
-from ..utils import ad_rw
+from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
+
 from .ad_base import ADBase
 
 
@@ -47,12 +48,16 @@ class VimbaExposeOutMode(str, Enum):
 
 class VimbaDriver(ADBase):
     def __init__(self, prefix: str, name: str = "") -> None:
-        # self.pixel_format = ad_rw(PixelFormat, prefix + "PixelFormat")
-        self.convert_format = ad_rw(
+        # self.pixel_format = epics_signal_rw_rbv(PixelFormat, prefix + "PixelFormat")
+        self.convert_format = epics_signal_rw_rbv(
             VimbaConvertFormat, prefix + "ConvertPixelFormat"
         )  # Pixel format of data outputted to AD
-        self.trig_source = ad_rw(VimbaTriggerSource, prefix + "TriggerSource")
-        self.trigger_mode = ad_rw(VimbaOnOff, prefix + "TriggerMode")
-        self.overlap = ad_rw(VimbaOverlap, prefix + "TriggerOverlap")
-        self.expose_mode = ad_rw(VimbaExposeOutMode, prefix + "ExposureMode")
+        self.trig_source = epics_signal_rw_rbv(
+            VimbaTriggerSource, prefix + "TriggerSource"
+        )
+        self.trigger_mode = epics_signal_rw_rbv(VimbaOnOff, prefix + "TriggerMode")
+        self.overlap = epics_signal_rw_rbv(VimbaOverlap, prefix + "TriggerOverlap")
+        self.expose_mode = epics_signal_rw_rbv(
+            VimbaExposeOutMode, prefix + "ExposureMode"
+        )
         super().__init__(prefix, name)

ophyd_async/epics/areadetector/utils.py

@@ -1,18 +1,8 @@
 from enum import Enum
-from typing import Optional, Type
+from typing import Optional
 from xml.etree import cElementTree as ET
 
-from ophyd_async.core import DEFAULT_TIMEOUT, SignalR, SignalRW, T, wait_for_value
-
-from ..signal.signal import epics_signal_r, epics_signal_rw
-
-
-def ad_rw(datatype: Type[T], prefix: str) -> SignalRW[T]:
-    return epics_signal_rw(datatype, prefix + "_RBV", prefix)
-
-
-def ad_r(datatype: Type[T], prefix: str) -> SignalR[T]:
-    return epics_signal_r(datatype, prefix + "_RBV")
+from ophyd_async.core import DEFAULT_TIMEOUT, SignalRW, T, wait_for_value
 
 
 class FileWriteMode(str, Enum):

ophyd_async/epics/areadetector/writers/nd_file_hdf.py

@@ -1,7 +1,7 @@
 from enum import Enum
 
-from ...signal.signal import epics_signal_rw
-from ..utils import FileWriteMode, ad_r, ad_rw
+from ...signal.signal import epics_signal_r, epics_signal_rw, epics_signal_rw_rbv
+from ..utils import FileWriteMode
 from .nd_plugin import NDPluginBase
 
 
@@ -19,22 +19,24 @@ class Compression(str, Enum):
 class NDFileHDF(NDPluginBase):
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
-        self.position_mode = ad_rw(bool, prefix + "PositionMode")
-        self.compression = ad_rw(Compression, prefix + "Compression")
-        self.num_extra_dims = ad_rw(int, prefix + "NumExtraDims")
-        self.file_path = ad_rw(str, prefix + "FilePath")
-        self.file_name = ad_rw(str, prefix + "FileName")
-        self.file_path_exists = ad_r(bool, prefix + "FilePathExists")
-        self.file_template = ad_rw(str, prefix + "FileTemplate")
-        self.full_file_name = ad_r(str, prefix + "FullFileName")
-        self.file_write_mode = ad_rw(FileWriteMode, prefix + "FileWriteMode")
-        self.num_capture = ad_rw(int, prefix + "NumCapture")
-        self.num_captured = ad_r(int, prefix + "NumCaptured")
-        self.swmr_mode = ad_rw(bool, prefix + "SWMRMode")
-        self.lazy_open = ad_rw(bool, prefix + "LazyOpen")
-        self.capture = ad_rw(bool, prefix + "Capture")
+        self.position_mode = epics_signal_rw_rbv(bool, prefix + "PositionMode")
+        self.compression = epics_signal_rw_rbv(Compression, prefix + "Compression")
+        self.num_extra_dims = epics_signal_rw_rbv(int, prefix + "NumExtraDims")
+        self.file_path = epics_signal_rw_rbv(str, prefix + "FilePath")
+        self.file_name = epics_signal_rw_rbv(str, prefix + "FileName")
+        self.file_path_exists = epics_signal_r(bool, prefix + "FilePathExists_RBV")
+        self.file_template = epics_signal_rw_rbv(str, prefix + "FileTemplate")
+        self.full_file_name = epics_signal_r(str, prefix + "FullFileName_RBV")
+        self.file_write_mode = epics_signal_rw_rbv(
+            FileWriteMode, prefix + "FileWriteMode"
+        )
+        self.num_capture = epics_signal_rw_rbv(int, prefix + "NumCapture")
+        self.num_captured = epics_signal_r(int, prefix + "NumCaptured_RBV")
+        self.swmr_mode = epics_signal_rw_rbv(bool, prefix + "SWMRMode")
+        self.lazy_open = epics_signal_rw_rbv(bool, prefix + "LazyOpen")
+        self.capture = epics_signal_rw_rbv(bool, prefix + "Capture")
         self.flush_now = epics_signal_rw(bool, prefix + "FlushNow")
-        self.array_size0 = ad_r(int, prefix + "ArraySize0")
-        self.array_size1 = ad_r(int, prefix + "ArraySize1")
-        self.xml_file_name = ad_rw(str, prefix + "XMLFileName")
+        self.array_size0 = epics_signal_r(int, prefix + "ArraySize0_RBV")
+        self.array_size1 = epics_signal_r(int, prefix + "ArraySize1_RBV")
+        self.xml_file_name = epics_signal_rw_rbv(str, prefix + "XMLFileName")
         super().__init__(prefix, name)

ophyd_async/epics/areadetector/writers/nd_plugin.py

@@ -2,8 +2,7 @@ from enum import Enum
 
 from ophyd_async.core import Device
 from ophyd_async.epics.signal import epics_signal_rw
-
-from ..utils import ad_r, ad_rw
+from ophyd_async.epics.signal.signal import epics_signal_r, epics_signal_rw_rbv
 
 
 class Callback(str, Enum):
@@ -13,16 +12,16 @@ class Callback(str, Enum):
 
 class NDArrayBase(Device):
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.unique_id = ad_r(int, prefix + "UniqueId")
+        self.unique_id = epics_signal_r(int, prefix + "UniqueId_RBV")
         self.nd_attributes_file = epics_signal_rw(str, prefix + "NDAttributesFile")
-        super().__init__(name)
+        super().__init__(name=name)
 
 
 class NDPluginBase(NDArrayBase):
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.nd_array_port = ad_rw(str, prefix + "NDArrayPort")
-        self.enable_callback = ad_rw(Callback, prefix + "EnableCallbacks")
-        self.nd_array_address = ad_rw(int, prefix + "NDArrayAddress")
+        self.nd_array_port = epics_signal_rw_rbv(str, prefix + "NDArrayPort")
+        self.enable_callback = epics_signal_rw_rbv(Callback, prefix + "EnableCallbacks")
+        self.nd_array_address = epics_signal_rw_rbv(int, prefix + "NDArrayAddress")
         super().__init__(prefix, name)
 
 

ophyd_async/epics/motion/motor.py

@@ -40,7 +40,11 @@ class Motor(StandardReadable, Movable, Stoppable):
         # Readback should be named the same as its parent in read()
         self.user_readback.set_name(name)
 
-    async def _move(self, new_position: float, watchers: List[Callable] = []):
+    async def _move(
+        self, new_position: float, watchers: Optional[List[Callable]] = None
+    ):
+        if watchers is None:
+            watchers = []
         self._set_success = True
         start = time.monotonic()
         old_position, units, precision = await asyncio.gather(

ophyd_async/epics/pvi/pvi.py

@@ -17,7 +17,7 @@ from typing import (
     get_type_hints,
 )
 
-from ophyd_async.core import Device, DeviceVector, SimSignalBackend
+from ophyd_async.core import Device, DeviceVector, SoftSignalBackend
 from ophyd_async.core.signal import Signal
 from ophyd_async.core.utils import DEFAULT_TIMEOUT
 from ophyd_async.epics._backend._p4p import PvaSignalBackend
@@ -156,7 +156,7 @@ def _parse_type(
     return is_device_vector, is_signal, signal_dtype, device_cls
 
 
-def _sim_common_blocks(device: Device, stripped_type: Optional[Type] = None):
+def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
     device_t = stripped_type or type(device)
     sub_devices = (
         (field, field_type)
@@ -175,23 +175,23 @@ def _sim_common_blocks(device: Device, stripped_type: Optional[Type] = None):
 
         if is_device_vector:
             if is_signal:
-                sub_device_1 = device_cls(SimSignalBackend(signal_dtype))
-                sub_device_2 = device_cls(SimSignalBackend(signal_dtype))
+                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})
             else:
                 sub_device = DeviceVector({1: device_cls(), 2: device_cls()})
 
                 for sub_device_in_vector in sub_device.values():
-                    _sim_common_blocks(sub_device_in_vector, stripped_type=device_cls)
+                    _mock_common_blocks(sub_device_in_vector, stripped_type=device_cls)
 
             for value in sub_device.values():
                 value.parent = sub_device
         else:
             if is_signal:
-                sub_device = device_cls(SimSignalBackend(signal_dtype))
+                sub_device = device_cls(SoftSignalBackend(signal_dtype))
             else:
                 sub_device = getattr(device, device_name, device_cls())
-                _sim_common_blocks(sub_device, stripped_type=device_cls)
+                _mock_common_blocks(sub_device, stripped_type=device_cls)
 
         setattr(device, device_name, sub_device)
         sub_device.parent = device
@@ -269,16 +269,16 @@ def _set_device_attributes(entry: PVIEntry):
 
 
 async def fill_pvi_entries(
-    device: Device, root_pv: str, timeout=DEFAULT_TIMEOUT, sim=False
+    device: Device, root_pv: str, timeout=DEFAULT_TIMEOUT, mock=False
 ):
     """
     Fills a ``device`` with signals from a the ``root_pvi:PVI`` table.
 
     If the device names match with parent devices of ``device`` then types are used.
     """
-    if sim:
-        # set up sim signals for the common annotations
-        _sim_common_blocks(device)
+    if mock:
+        # set up mock signals for the common annotations
+        _mock_common_blocks(device)
     else:
         # check the pvi table for devices and fill the device with them
         root_entry = PVIEntry(

ophyd_async/panda/_hdf_panda.py

@@ -42,7 +42,7 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
         )
 
     async def connect(
-        self, sim: bool = False, timeout: float = DEFAULT_TIMEOUT
+        self, mock: bool = False, timeout: float = DEFAULT_TIMEOUT
     ) -> None:
-        await fill_pvi_entries(self, self._prefix + "PVI", timeout=timeout, sim=sim)
-        await super().connect(sim=sim, timeout=timeout)
+        await fill_pvi_entries(self, self._prefix + "PVI", timeout=timeout, mock=mock)
+        await super().connect(mock=mock, timeout=timeout)