ophyd-async 0.10.0a2__py3-none-any.whl → 0.10.0a4__py3-none-any.whl

ophyd_async/core/_utils.py

@@ -5,7 +5,15 @@ import logging
 from collections.abc import Awaitable, Callable, Iterable, Mapping, Sequence
 from dataclasses import dataclass
 from enum import Enum, EnumMeta
-from typing import Any, Generic, Literal, ParamSpec, TypeVar, get_args, get_origin
+from typing import (
+    Any,
+    Generic,
+    Literal,
+    ParamSpec,
+    TypeVar,
+    get_args,
+    get_origin,
+)
 from unittest.mock import Mock
 
 import numpy as np
@@ -19,20 +27,16 @@ DEFAULT_TIMEOUT = 10.0
 logger = logging.getLogger("ophyd_async")
 
 
-class StrictEnumMeta(EnumMeta):
-    def __new__(metacls, *args, **kwargs):
-        ret = super().__new__(metacls, *args, **kwargs)
+class UppercaseNameEnumMeta(EnumMeta):
+    def __new__(cls, *args, **kwargs):
+        ret = super().__new__(cls, *args, **kwargs)
         lowercase_names = [x.name for x in ret if not x.name.isupper()]  # type: ignore
         if lowercase_names:
             raise TypeError(f"Names {lowercase_names} should be uppercase")
         return ret
 
 
-class StrictEnum(str, Enum, metaclass=StrictEnumMeta):
-    """All members should exist in the Backend, and there will be no extras."""
-
-
-class SubsetEnumMeta(StrictEnumMeta):
+class AnyStringUppercaseNameEnumMeta(UppercaseNameEnumMeta):
     def __call__(self, value, *args, **kwargs):  # type: ignore
         """Return given value if it is a string and not a member of the enum.
 
@@ -54,10 +58,21 @@ class SubsetEnumMeta(StrictEnumMeta):
         return super().__call__(value, *args, **kwargs)
 
 
-class SubsetEnum(StrictEnum, metaclass=SubsetEnumMeta):
+class StrictEnum(str, Enum, metaclass=UppercaseNameEnumMeta):
+    """All members should exist in the Backend, and there will be no extras."""
+
+
+class SubsetEnum(str, Enum, metaclass=AnyStringUppercaseNameEnumMeta):
     """All members should exist in the Backend, but there may be extras."""
 
 
+class SupersetEnum(str, Enum, metaclass=UppercaseNameEnumMeta):
+    """Some members should exist in the Backend, and there should be no extras."""
+
+
+EnumTypes = StrictEnum | SubsetEnum | SupersetEnum
+
+
 CALCULATE_TIMEOUT = "CALCULATE_TIMEOUT"
 """Sentinel used to implement ``myfunc(timeout=CalculateTimeout)``
 
@@ -207,10 +222,11 @@ def get_dtype(datatype: type) -> np.dtype:
     return np.dtype(get_args(get_args(datatype)[1])[0])
 
 
-def get_enum_cls(datatype: type | None) -> type[StrictEnum] | None:
+def get_enum_cls(datatype: type | None) -> type[EnumTypes] | None:
     """Get the enum class from a datatype.
 
-    :raises TypeError: if type is not a [](#StrictEnum) or [](#SubsetEnum) subclass
+    :raises TypeError: if type is not a [](#StrictEnum) or [](#SubsetEnum)
+    or [](#SupersetEnum) subclass
     ```python
     >>> from ophyd_async.core import StrictEnum
     >>> from collections.abc import Sequence
@@ -227,10 +243,11 @@ def get_enum_cls(datatype: type | None) -> type[StrictEnum] | None:
     if get_origin(datatype) is Sequence:
         datatype = get_args(datatype)[0]
     if datatype and issubclass(datatype, Enum):
-        if not issubclass(datatype, StrictEnum):
+        if not issubclass(datatype, EnumTypes):
             raise TypeError(
                 f"{datatype} should inherit from ophyd_async.core.SubsetEnum "
-                "or ophyd_async.core.StrictEnum"
+                "or ophyd_async.core.StrictEnum "
+                "or ophyd_async.core.SupersetEnum."
             )
         return datatype
     return None

ophyd_async/epics/adandor/_andor_controller.py

@@ -32,7 +32,7 @@ class Andor2Controller(adcore.ADBaseController[Andor2DriverIO]):
         await asyncio.gather(
             self.driver.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
             self.driver.num_images.set(
-                trigger_info.total_number_of_triggers or _MAX_NUM_IMAGE
+                trigger_info.total_number_of_exposures or _MAX_NUM_IMAGE
             ),
             self.driver.image_mode.set(adcore.ADImageMode.MULTIPLE),
         )

ophyd_async/epics/adaravis/_aravis_controller.py

@@ -35,11 +35,11 @@ class AravisController(adcore.ADBaseController[AravisDriverIO]):
         else:
             raise ValueError(f"ADAravis does not support {trigger_info.trigger}")
 
-        if trigger_info.total_number_of_triggers == 0:
+        if trigger_info.total_number_of_exposures == 0:
             image_mode = adcore.ADImageMode.CONTINUOUS
         else:
             image_mode = adcore.ADImageMode.MULTIPLE
         await asyncio.gather(
-            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.num_images.set(trigger_info.total_number_of_exposures),
             self.driver.image_mode.set(image_mode),
         )

ophyd_async/epics/adcore/_core_detector.py

@@ -22,8 +22,8 @@ class AreaDetector(StandardDetector[ADBaseControllerT, ADWriter]):
         self.fileio = writer.fileio
 
         if plugins is not None:
-            for name, plugin in plugins.items():
-                setattr(self, name, plugin)
+            for plugin_name, plugin in plugins.items():
+                setattr(self, plugin_name, plugin)
 
         super().__init__(
             controller,

ophyd_async/epics/adcore/_core_io.py

@@ -70,14 +70,14 @@ class NDPluginStatsIO(NDPluginBaseIO):
     # Basic statistics
     compute_statistics: A[SignalRW[bool], PvSuffix.rbv("ComputeStatistics")]
     bgd_width: A[SignalRW[int], PvSuffix.rbv("BgdWidth")]
-    total_array: A[SignalRW[float], PvSuffix.rbv("TotalArray")]
+    total: A[SignalR[float], PvSuffix.rbv("Total")]
     # Centroid statistics
     compute_centroid: A[SignalRW[bool], PvSuffix.rbv("ComputeCentroid")]
     centroid_threshold: A[SignalRW[float], PvSuffix.rbv("CentroidThreshold")]
     # X and Y Profiles
     compute_profiles: A[SignalRW[bool], PvSuffix.rbv("ComputeProfiles")]
-    profile_size_x: A[SignalRW[int], PvSuffix.rbv("ProfileSizeX")]
-    profile_size_y: A[SignalRW[int], PvSuffix.rbv("ProfileSizeY")]
+    profile_size_x: A[SignalR[int], PvSuffix.rbv("ProfileSizeX")]
+    profile_size_y: A[SignalR[int], PvSuffix.rbv("ProfileSizeY")]
     cursor_x: A[SignalRW[int], PvSuffix.rbv("CursorX")]
     cursor_y: A[SignalRW[int], PvSuffix.rbv("CursorY")]
     # Array Histogram

ophyd_async/epics/adcore/_core_logic.py

@@ -33,7 +33,7 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
         driver: ADBaseIOT,
         good_states: frozenset[ADState] = DEFAULT_GOOD_STATES,
     ) -> None:
-        self.driver = driver
+        self.driver: ADBaseIOT = driver
         self.good_states = good_states
         self.frame_timeout = DEFAULT_TIMEOUT
         self._arm_status: AsyncStatus | None = None
@@ -49,7 +49,7 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
             DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
         )
         await asyncio.gather(
-            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.num_images.set(trigger_info.total_number_of_exposures),
             self.driver.image_mode.set(ADImageMode.MULTIPLE),
         )
 
@@ -176,7 +176,7 @@ class ADBaseContAcqController(ADBaseController[ADBaseIO]):
         await asyncio.gather(
             self.cb_plugin.enable_callbacks.set(ADCallbacks.ENABLE),
             self.cb_plugin.pre_count.set(0),
-            self.cb_plugin.post_count.set(trigger_info.total_number_of_triggers),
+            self.cb_plugin.post_count.set(trigger_info.total_number_of_exposures),
             self.cb_plugin.preset_trigger_count.set(1),
             self.cb_plugin.flush_on_soft_trg.set(NDCBFlushOnSoftTrgMode.ON_NEW_IMAGE),
         )

ophyd_async/epics/adcore/_core_writer.py

@@ -5,14 +5,15 @@ from typing import Generic, TypeVar, get_args
 from urllib.parse import urlunparse
 
 from bluesky.protocols import Hints, StreamAsset
-from event_model import (
+from event_model import (  # type: ignore
     ComposeStreamResource,
     DataKey,
     StreamRange,
 )
+from pydantic import PositiveInt
 
 from ophyd_async.core._detector import DetectorWriter
-from ophyd_async.core._providers import DatasetDescriber, NameProvider, PathProvider
+from ophyd_async.core._providers import DatasetDescriber, PathProvider
 from ophyd_async.core._signal import (
     observe_value,
     set_and_wait_for_value,
@@ -44,7 +45,6 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         self,
         fileio: NDFileIOT,
         path_provider: PathProvider,
-        name_provider: NameProvider,
         dataset_describer: DatasetDescriber,
         file_extension: str = "",
         mimetype: str = "",
@@ -53,7 +53,6 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         self._plugins = plugins or {}
         self.fileio = fileio
         self._path_provider = path_provider
-        self._name_provider = name_provider
         self._dataset_describer = dataset_describer
         self._file_extension = file_extension
         self._mimetype = mimetype
@@ -61,7 +60,6 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         self._emitted_resource = None
 
         self._capture_status: AsyncStatus | None = None
-        self._multiplier = 1
         self._filename_template = "%s%s_%6.6d"
 
     @classmethod
@@ -81,18 +79,11 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         fileio = fileio_cls(prefix + (fileio_suffix or cls.default_suffix))
         dataset_describer = ADBaseDatasetDescriber(dataset_source or fileio)
 
-        def name_provider() -> str:
-            if fileio.parent == "Not attached to a detector":
-                raise RuntimeError("Initializing writer without parent detector!")
-            return fileio.parent.name
-
-        writer = cls(
-            fileio, path_provider, name_provider, dataset_describer, plugins=plugins
-        )
+        writer = cls(fileio, path_provider, dataset_describer, plugins=plugins)
         return writer
 
-    async def begin_capture(self) -> None:
-        info = self._path_provider(device_name=self._name_provider())
+    async def begin_capture(self, name: str) -> None:
+        info = self._path_provider(device_name=name)
 
         await self.fileio.enable_callbacks.set(ADCallbacks.ENABLE)
 
@@ -125,19 +116,21 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
             self.fileio.capture, True, wait_for_set_completion=False
         )
 
-    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
+    async def open(
+        self, name: str, exposures_per_event: PositiveInt = 1
+    ) -> dict[str, DataKey]:
         self._emitted_resource = None
         self._last_emitted = 0
-        self._multiplier = multiplier
+        self._exposures_per_event = exposures_per_event
         frame_shape = await self._dataset_describer.shape()
         dtype_numpy = await self._dataset_describer.np_datatype()
 
-        await self.begin_capture()
+        await self.begin_capture(name)
 
         describe = {
-            self._name_provider(): DataKey(
+            name: DataKey(
                 source=self.fileio.full_file_name.source,
-                shape=list(frame_shape),
+                shape=[exposures_per_event, *frame_shape],
                 dtype="array",
                 dtype_numpy=dtype_numpy,
                 external="STREAM:",
@@ -150,14 +143,14 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
     ) -> AsyncGenerator[int, None]:
         """Wait until a specific index is ready to be collected."""
         async for num_captured in observe_value(self.fileio.num_captured, timeout):
-            yield num_captured // self._multiplier
+            yield num_captured // self._exposures_per_event
 
     async def get_indices_written(self) -> int:
         num_captured = await self.fileio.num_captured.get_value()
-        return num_captured // self._multiplier
+        return num_captured // self._exposures_per_event
 
     async def collect_stream_docs(
-        self, indices_written: int
+        self, name: str, indices_written: int
     ) -> AsyncIterator[StreamAsset]:
         if indices_written:
             if not self._emitted_resource:
@@ -183,13 +176,14 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
                 self._emitted_resource = bundler_composer(
                     mimetype=self._mimetype,
                     uri=uri,
-                    data_key=self._name_provider(),
+                    # TODO no reference to detector's name
+                    data_key=name,
                     parameters={
-                        # Assume that we always write 1 frame per file/chunk
+                        # Assume that we always write 1 frame per file/chunk, this
+                        # may change to self._exposures_per_event in the future
                         "chunk_shape": (1, *frame_shape),
                         # Include file template for reconstruction in consolidator
                         "template": file_template,
-                        "multiplier": self._multiplier,
                     },
                     uid=None,
                     validate=True,
@@ -218,6 +212,5 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
             await self._capture_status
         self._capture_status = None
 
-    @property
-    def hints(self) -> Hints:
-        return {"fields": [self._name_provider()]}
+    def get_hints(self, name: str) -> Hints:
+        return {"fields": [name]}

ophyd_async/epics/adcore/_hdf_writer.py

@@ -5,12 +5,12 @@ from xml.etree import ElementTree as ET
 
 from bluesky.protocols import StreamAsset
 from event_model import DataKey
+from pydantic import PositiveInt
 
 from ophyd_async.core import (
     DatasetDescriber,
     HDFDatasetDescription,
     HDFDocumentComposer,
-    NameProvider,
     PathProvider,
 )
 
@@ -31,14 +31,12 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         self,
         fileio: NDFileHDFIO,
         path_provider: PathProvider,
-        name_provider: NameProvider,
         dataset_describer: DatasetDescriber,
         plugins: dict[str, NDPluginBaseIO] | None = None,
     ) -> None:
         super().__init__(
             fileio,
             path_provider,
-            name_provider,
             dataset_describer,
             plugins=plugins,
             file_extension=".h5",
@@ -48,7 +46,9 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         self._composer: HDFDocumentComposer | None = None
         self._filename_template = "%s%s"
 
-    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
+    async def open(
+        self, name: str, exposures_per_event: PositiveInt = 1
+    ) -> dict[str, DataKey]:
         self._composer = None
 
         # Setting HDF writer specific signals
@@ -64,13 +64,13 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         )
 
         # Set common AD file plugin params, begin capturing
-        await self.begin_capture()
+        await self.begin_capture(name)
 
-        name = self._name_provider()
         detector_shape = await self._dataset_describer.shape()
         np_dtype = await self._dataset_describer.np_datatype()
-        self._multiplier = multiplier
-        outer_shape = (multiplier,) if multiplier > 1 else ()
+
+        # Used by the base class
+        self._exposures_per_event = exposures_per_event
 
         # Determine number of frames that will be saved per HDF chunk
         frames_per_chunk = await self.fileio.num_frames_chunks.get_value()
@@ -80,9 +80,8 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
             HDFDatasetDescription(
                 data_key=name,
                 dataset="/entry/data/data",
-                shape=detector_shape,
+                shape=(exposures_per_event, *detector_shape),
                 dtype_numpy=np_dtype,
-                multiplier=multiplier,
                 chunk_shape=(frames_per_chunk, *detector_shape),
             )
         ]
@@ -107,20 +106,23 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
                         HDFDatasetDescription(
                             data_key=data_key,
                             dataset=f"/entry/instrument/NDAttributes/{data_key}",
-                            shape=(),
+                            shape=(exposures_per_event,)
+                            if exposures_per_event > 1
+                            else (),
                             dtype_numpy=np_datatype,
                             # NDAttributes appear to always be configured with
                             # this chunk size
                             chunk_shape=(16384,),
-                            multiplier=multiplier,
                         )
                     )
 
         describe = {
             ds.data_key: DataKey(
                 source=self.fileio.full_file_name.source,
-                shape=list(outer_shape + tuple(ds.shape)),
-                dtype="array" if ds.shape else "number",
+                shape=list(ds.shape),
+                dtype="array"
+                if exposures_per_event > 1 or len(ds.shape) > 1
+                else "number",
                 dtype_numpy=ds.dtype_numpy,
                 external="STREAM:",
             )
@@ -129,7 +131,7 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         return describe
 
     async def collect_stream_docs(
-        self, indices_written: int
+        self, name: str, indices_written: int
     ) -> AsyncIterator[StreamAsset]:
         # TODO: fail if we get dropped frames
         await self.fileio.flush_now.set(True)

ophyd_async/epics/adcore/_jpeg_writer.py

@@ -1,4 +1,4 @@
-from ophyd_async.core import DatasetDescriber, NameProvider, PathProvider
+from ophyd_async.core import DatasetDescriber, PathProvider
 
 from ._core_io import NDFileIO, NDPluginBaseIO
 from ._core_writer import ADWriter
@@ -11,14 +11,12 @@ class ADJPEGWriter(ADWriter[NDFileIO]):
         self,
         fileio: NDFileIO,
         path_provider: PathProvider,
-        name_provider: NameProvider,
         dataset_describer: DatasetDescriber,
         plugins: dict[str, NDPluginBaseIO] | None = None,
     ) -> None:
         super().__init__(
             fileio,
             path_provider,
-            name_provider,
             dataset_describer,
             plugins=plugins,
             file_extension=".jpg",

ophyd_async/epics/adcore/_tiff_writer.py

@@ -1,4 +1,4 @@
-from ophyd_async.core import DatasetDescriber, NameProvider, PathProvider
+from ophyd_async.core import DatasetDescriber, PathProvider
 
 from ._core_io import NDFileIO, NDPluginBaseIO
 from ._core_writer import ADWriter
@@ -11,14 +11,12 @@ class ADTIFFWriter(ADWriter[NDFileIO]):
         self,
         fileio: NDFileIO,
         path_provider: PathProvider,
-        name_provider: NameProvider,
         dataset_describer: DatasetDescriber,
         plugins: dict[str, NDPluginBaseIO] | None = None,
     ) -> None:
         super().__init__(
             fileio,
             path_provider,
-            name_provider,
             dataset_describer,
             plugins=plugins,
             file_extension=".tiff",

ophyd_async/epics/adcore/_utils.py

@@ -7,11 +7,12 @@ from ophyd_async.core import (
     SignalRW,
     StrictEnum,
     SubsetEnum,
+    SupersetEnum,
     wait_for_value,
 )
 
 
-class ADBaseDataType(StrictEnum):
+class ADBaseDataType(SupersetEnum):
     INT8 = "Int8"
     UINT8 = "UInt8"
     INT16 = "Int16"
@@ -22,6 +23,9 @@ class ADBaseDataType(StrictEnum):
     UINT64 = "UInt64"
     FLOAT32 = "Float32"
     FLOAT64 = "Float64"
+    # Driver database override will blank the enum string if it doesn't
+    # support a datatype
+    UNDEFINED = ""
 
 
 def convert_ad_dtype_to_np(ad_dtype: ADBaseDataType) -> str:
@@ -37,7 +41,12 @@ def convert_ad_dtype_to_np(ad_dtype: ADBaseDataType) -> str:
         ADBaseDataType.FLOAT32: "<f4",
         ADBaseDataType.FLOAT64: "<f8",
     }
-    return ad_dtype_to_np_dtype[ad_dtype]
+    np_type = ad_dtype_to_np_dtype.get(ad_dtype)
+    if np_type is None:
+        raise ValueError(
+            "Areadetector driver has a blank DataType, this is not supported"
+        )
+    return np_type
 
 
 def convert_pv_dtype_to_np(datatype: str) -> str:

ophyd_async/epics/adkinetix/_kinetix_controller.py

@@ -34,7 +34,7 @@ class KinetixController(adcore.ADBaseController[KinetixDriverIO]):
             self.driver.trigger_mode.set(
                 KINETIX_TRIGGER_MODE_MAP[trigger_info.trigger]
             ),
-            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.num_images.set(trigger_info.total_number_of_exposures),
             self.driver.image_mode.set(adcore.ADImageMode.MULTIPLE),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [

ophyd_async/epics/adpilatus/_pilatus.py

@@ -27,7 +27,7 @@ class PilatusDetector(AreaDetector[PilatusController]):
         config_sigs: Sequence[SignalR] = (),
     ):
         driver = PilatusDriverIO(prefix + drv_suffix)
-        controller = PilatusController(driver)
+        controller = PilatusController(driver, readout_time=readout_time)
 
         writer = writer_cls.with_io(
             prefix,

ophyd_async/epics/adpilatus/_pilatus_controller.py

@@ -29,6 +29,7 @@ class PilatusController(adcore.ADBaseController[PilatusDriverIO]):
         DetectorTrigger.INTERNAL: PilatusTriggerMode.INTERNAL,
         DetectorTrigger.CONSTANT_GATE: PilatusTriggerMode.EXT_ENABLE,
         DetectorTrigger.VARIABLE_GATE: PilatusTriggerMode.EXT_ENABLE,
+        DetectorTrigger.EDGE_TRIGGER: PilatusTriggerMode.EXT_TRIGGER,
     }
 
     def __init__(
@@ -49,11 +50,13 @@ class PilatusController(adcore.ADBaseController[PilatusDriverIO]):
                 trigger_info.livetime
             )
         await asyncio.gather(
-            self.driver.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
+            self.driver.trigger_mode.set(
+                self._supported_trigger_types[trigger_info.trigger]
+            ),
             self.driver.num_images.set(
                 999_999
-                if trigger_info.total_number_of_triggers == 0
-                else trigger_info.total_number_of_triggers
+                if trigger_info.total_number_of_exposures == 0
+                else trigger_info.total_number_of_exposures
             ),
             self.driver.image_mode.set(adcore.ADImageMode.MULTIPLE),
         )
@@ -70,13 +73,3 @@ class PilatusController(adcore.ADBaseController[PilatusDriverIO]):
             True,
             timeout=DEFAULT_TIMEOUT,
         )
-
-    @classmethod
-    def _get_trigger_mode(cls, trigger: DetectorTrigger) -> PilatusTriggerMode:
-        if trigger not in cls._supported_trigger_types.keys():
-            raise ValueError(
-                f"{cls.__name__} only supports the following trigger "
-                f"types: {cls._supported_trigger_types.keys()} but was asked to "
-                f"use {trigger}"
-            )
-        return cls._supported_trigger_types[trigger]

ophyd_async/epics/adpilatus/_pilatus_io.py

@@ -21,4 +21,4 @@ class PilatusDriverIO(adcore.ADBaseIO):
     """This mirrors the interface provided by ADPilatus/db/pilatus.template."""
     """See HTML docs at https://areadetector.github.io/areaDetector/ADPilatus/pilatusDoc.html"""
     trigger_mode: A[SignalRW[PilatusTriggerMode], PvSuffix.rbv("TriggerMode")]
-    armed: A[SignalR[bool], PvSuffix.rbv("Armed_RBV")]
+    armed: A[SignalR[bool], PvSuffix("Armed")]

ophyd_async/epics/advimba/_vimba_controller.py

@@ -40,7 +40,7 @@ class VimbaController(adcore.ADBaseController[VimbaDriverIO]):
         await asyncio.gather(
             self.driver.trigger_mode.set(TRIGGER_MODE[trigger_info.trigger]),
             self.driver.exposure_mode.set(EXPOSE_OUT_MODE[trigger_info.trigger]),
-            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.num_images.set(trigger_info.total_number_of_exposures),
             self.driver.image_mode.set(adcore.ADImageMode.MULTIPLE),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [

ophyd_async/epics/core/_aioca.py

@@ -1,7 +1,7 @@
 import logging
 import sys
 import typing
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from functools import cache
 from math import isnan, nan
 from typing import Any, Generic, cast
@@ -146,7 +146,7 @@ class CaBoolConverter(CaConverter[bool]):
 
 
 class CaEnumConverter(CaConverter[str]):
-    def __init__(self, supported_values: dict[str, str]):
+    def __init__(self, supported_values: Mapping[str, str]):
         self.supported_values = supported_values
         super().__init__(
             str, dbr.DBR_STRING, metadata=SignalMetadata(choices=list(supported_values))

ophyd_async/epics/core/_p4p.py

@@ -383,7 +383,7 @@ class PvaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
 
     async def put(self, value: SignalDatatypeT | None, wait: bool):
         if value is None:
-            write_value = self.initial_values[self.write_pv]
+            write_value = self.initial_values[self.write_pv]["value"]
         else:
             write_value = self.converter.write_value(value)
         await context().put(self.write_pv, {"value": write_value}, wait=wait)

ophyd_async/epics/core/_pvi_connector.py

@@ -43,10 +43,10 @@ FastCSPVIVector = dict[Literal["d"], Entry]
 
 def _get_signal_details(entry: Entry) -> tuple[type[Signal], str, str]:
     match entry:
-        case {"r": read_pv}:
-            return SignalR, read_pv, read_pv
         case {"r": read_pv, "w": write_pv}:
             return SignalRW, read_pv, write_pv
+        case {"r": read_pv}:
+            return SignalR, read_pv, read_pv
         case {"w": write_pv}:
             return SignalW, write_pv, write_pv
         case {"rw": read_write_pv}:
@@ -77,6 +77,8 @@ class PviDeviceConnector(DeviceConnector):
         hinted Signals are not present.
     """
 
+    mock_device_vector_len: int = 2
+
     def __init__(self, prefix: str = "", error_hint: str = "") -> None:
         # TODO: what happens if we get a leading "pva://" here?
         self.prefix = prefix
@@ -110,7 +112,7 @@ class PviDeviceConnector(DeviceConnector):
             backend.write_pv = write_pv
 
     async def connect_mock(self, device: Device, mock: LazyMock):
-        self.filler.create_device_vector_entries_to_mock(2)
+        self.filler.create_device_vector_entries_to_mock(self.mock_device_vector_len)
         # Set the name of the device to name all children
         device.set_name(device.name)
         return await super().connect_mock(device, mock)