ophyd-async 0.12.3__py3-none-any.whl → 0.13.1__py3-none-any.whl

ophyd_async/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.12.3'
-__version_tuple__ = version_tuple = (0, 12, 3)
+__version__ = version = '0.13.1'
+__version_tuple__ = version_tuple = (0, 13, 1)
+
+__commit_id__ = commit_id = None

ophyd_async/core/__init__.py

@@ -16,6 +16,12 @@ from ._detector import (
 )
 from ._device import Device, DeviceConnector, DeviceVector, init_devices
 from ._device_filler import DeviceFiller
+from ._enums import (
+    EnabledDisabled,
+    EnableDisable,
+    InOut,
+    OnOff,
+)
 from ._flyer import FlyerController, FlyMotorInfo, StandardFlyer
 from ._hdf_dataset import HDFDatasetDescription, HDFDocumentComposer
 from ._log import config_ophyd_async_logging
@@ -209,4 +215,9 @@ __all__ = [
     # Back compat - delete before 1.0
     "ConfigSignal",
     "HintedSignal",
+    # Standard enums
+    "EnabledDisabled",
+    "EnableDisable",
+    "InOut",
+    "OnOff",
 ]

ophyd_async/core/_detector.py

@@ -84,7 +84,7 @@ class TriggerInfo(ConfinedModel):
     A exposures_per_event > 1 can be useful to have exposures from a faster detector
     able to be zipped with a single exposure from a slower detector. E.g. if
     number_of_events=10 and exposures_per_event=5 then the detector will take
-    10 exposures, but publish 2 StreamDatum indices, and describe() will show a
+    50 exposures, but publish 10 StreamDatum indices, and describe() will show a
     shape of (5, h, w) for each.
     Default is 1.
     """
@@ -104,7 +104,11 @@ class DetectorController(ABC):
 
     @abstractmethod
     def get_deadtime(self, exposure: float | None) -> float:
-        """For a given exposure, how long should the time between exposures be."""
+        """Get state-independent deadtime.
+
+        For a given exposure, what is the safest minimum time between exposures that
+        can be determined without reading signals.
+        """
 
     @abstractmethod
     async def prepare(self, trigger_info: TriggerInfo) -> None:
@@ -313,14 +317,7 @@ class StandardDetector(
         if value.trigger != DetectorTrigger.INTERNAL and not value.deadtime:
             msg = "Deadtime must be supplied when in externally triggered mode"
             raise ValueError(msg)
-        required_deadtime = self._controller.get_deadtime(value.livetime)
-        if value.deadtime and required_deadtime > value.deadtime:
-            msg = (
-                f"Detector {self._controller} needs at least {required_deadtime}s "
-                f"deadtime, but trigger logic provides only {value.deadtime}s"
-            )
-            raise ValueError(msg)
-        elif not value.deadtime:
+        if not value.deadtime:
             value.deadtime = self._controller.get_deadtime(value.livetime)
         self._trigger_info = value
         self._number_of_events_iter = iter(

ophyd_async/core/_enums.py

@@ -0,0 +1,21 @@
+from ._utils import StrictEnum
+
+
+class OnOff(StrictEnum):
+    ON = "On"
+    OFF = "Off"
+
+
+class EnableDisable(StrictEnum):
+    ENABLE = "Enable"
+    DISABLE = "Disable"
+
+
+class EnabledDisabled(StrictEnum):
+    ENABLED = "Enabled"
+    DISABLED = "Disabled"
+
+
+class InOut(StrictEnum):
+    IN = "In"
+    OUT = "Out"

ophyd_async/core/_signal.py

@@ -39,8 +39,8 @@ from ._utils import (
 async def _wait_for(coro: Awaitable[T], timeout: float | None, source: str) -> T:
     try:
         return await asyncio.wait_for(coro, timeout)
-    except asyncio.TimeoutError as e:
-        raise asyncio.TimeoutError(source) from e
+    except TimeoutError as e:
+        raise TimeoutError(source) from e
 
 
 def _add_timeout(func):
@@ -492,7 +492,7 @@ async def observe_signals_value(
         last_item = ()
         while True:
             if overall_deadline and time.monotonic() >= overall_deadline:
-                raise asyncio.TimeoutError(
+                raise TimeoutError(
                     f"observe_value was still observing signals "
                     f"{[signal.source for signal in signals]} after "
                     f"timeout {done_timeout}s"
@@ -500,8 +500,8 @@ async def observe_signals_value(
             iteration_timeout = _get_iteration_timeout(timeout, overall_deadline)
             try:
                 item = await asyncio.wait_for(q.get(), iteration_timeout)
-            except asyncio.TimeoutError as exc:
-                raise asyncio.TimeoutError(
+            except TimeoutError as exc:
+                raise TimeoutError(
                     f"Timeout Error while waiting {iteration_timeout}s to update "
                     f"{[signal.source for signal in signals]}. "
                     f"Last observed signal and value were {last_item}"
@@ -536,8 +536,8 @@ class _ValueChecker(Generic[SignalDatatypeT]):
     ):
         try:
             await asyncio.wait_for(self._wait_for_value(signal), timeout)
-        except asyncio.TimeoutError as e:
-            raise asyncio.TimeoutError(
+        except TimeoutError as e:
+            raise TimeoutError(
                 f"{signal.name} didn't match {self._matcher_name} in {timeout}s, "
                 f"last value {self._last_value!r}"
             ) from e
@@ -635,8 +635,8 @@ async def set_and_wait_for_other_value(
             await asyncio.wait_for(_wait_for_value(), timeout)
             if wait_for_set_completion:
                 await status
-        except asyncio.TimeoutError as e:
-            raise asyncio.TimeoutError(
+        except TimeoutError as e:
+            raise TimeoutError(
                 f"{match_signal.name} value didn't match value from"
                 f" {matcher.__name__}() in {timeout}s"
             ) from e

ophyd_async/core/_utils.py

@@ -4,7 +4,7 @@ import asyncio
 import logging
 from collections.abc import Awaitable, Callable, Iterable, Mapping, Sequence
 from dataclasses import dataclass
-from enum import Enum, EnumMeta
+from enum import Enum, EnumMeta, StrEnum
 from typing import (
     Any,
     Generic,
@@ -59,15 +59,15 @@ class AnyStringUppercaseNameEnumMeta(UppercaseNameEnumMeta):
         return super().__call__(value, *args, **kwargs)
 
 
-class StrictEnum(str, Enum, metaclass=UppercaseNameEnumMeta):
+class StrictEnum(StrEnum, metaclass=UppercaseNameEnumMeta):
     """All members should exist in the Backend, and there will be no extras."""
 
 
-class SubsetEnum(str, Enum, metaclass=AnyStringUppercaseNameEnumMeta):
+class SubsetEnum(StrEnum, metaclass=AnyStringUppercaseNameEnumMeta):
     """All members should exist in the Backend, but there may be extras."""
 
 
-class SupersetEnum(str, Enum, metaclass=UppercaseNameEnumMeta):
+class SupersetEnum(StrEnum, metaclass=UppercaseNameEnumMeta):
     """Some members should exist in the Backend, and there should be no extras."""
 
 
@@ -243,6 +243,7 @@ def get_enum_cls(datatype: type | None) -> type[EnumTypes] | None:
     """
     if get_origin(datatype) is Sequence:
         datatype = get_args(datatype)[0]
+    datatype = get_origin_class(datatype)
     if datatype and issubclass(datatype, Enum):
         if not issubclass(datatype, EnumTypes):
             raise TypeError(

ophyd_async/epics/adandor/_andor.py

@@ -1,7 +1,6 @@
 from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider
-from ophyd_async.core._signal import SignalR
+from ophyd_async.core import PathProvider, SignalR
 from ophyd_async.epics import adcore
 
 from ._andor_controller import Andor2Controller

ophyd_async/epics/adaravis/__init__.py

@@ -5,12 +5,11 @@ https://github.com/areaDetector/ADAravis
 
 from ._aravis import AravisDetector
 from ._aravis_controller import AravisController
-from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
+from ._aravis_io import AravisDriverIO, AravisTriggerSource
 
 __all__ = [
     "AravisDetector",
     "AravisController",
     "AravisDriverIO",
-    "AravisTriggerMode",
     "AravisTriggerSource",
 ]

ophyd_async/epics/adaravis/_aravis_controller.py

@@ -1,9 +1,9 @@
 import asyncio
 
-from ophyd_async.core import DetectorTrigger, TriggerInfo
+from ophyd_async.core import DetectorTrigger, OnOff, TriggerInfo
 from ophyd_async.epics import adcore
 
-from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
+from ._aravis_io import AravisDriverIO, AravisTriggerSource
 
 # The deadtime of an ADaravis controller varies depending on the exact model of camera.
 # Ideally we would maximize performance by dynamically retrieving the deadtime at
@@ -23,14 +23,14 @@ class AravisController(adcore.ADBaseController[AravisDriverIO]):
 
         if trigger_info.trigger is DetectorTrigger.INTERNAL:
             # Set trigger mode off to ignore the trigger source
-            await self.driver.trigger_mode.set(AravisTriggerMode.OFF)
+            await self.driver.trigger_mode.set(OnOff.OFF)
         elif trigger_info.trigger in {
             DetectorTrigger.CONSTANT_GATE,
             DetectorTrigger.EDGE_TRIGGER,
         }:
             # Trigger on the rising edge of Line1
             # trigger mode must be set first and on it's own!
-            await self.driver.trigger_mode.set(AravisTriggerMode.ON)
+            await self.driver.trigger_mode.set(OnOff.ON)
             await self.driver.trigger_source.set(AravisTriggerSource.LINE1)
         else:
             raise ValueError(f"ADAravis does not support {trigger_info.trigger}")

ophyd_async/epics/adaravis/_aravis_io.py

@@ -1,20 +1,10 @@
 from typing import Annotated as A
 
-from ophyd_async.core import SignalRW, StrictEnum, SubsetEnum
+from ophyd_async.core import OnOff, SignalRW, SubsetEnum
 from ophyd_async.epics import adcore
 from ophyd_async.epics.core import PvSuffix
 
 
-class AravisTriggerMode(StrictEnum):
-    """GigEVision GenICAM standard TriggerMode."""
-
-    ON = "On"
-    """Use TriggerSource to trigger each frame"""
-
-    OFF = "Off"
-    """Just trigger as fast as you can"""
-
-
 class AravisTriggerSource(SubsetEnum):
     """Which trigger source to use when TriggerMode=On."""
 
@@ -27,5 +17,5 @@ class AravisDriverIO(adcore.ADBaseIO):
     This mirrors the interface provided by ADAravis/db/aravisCamera.template.
     """
 
-    trigger_mode: A[SignalRW[AravisTriggerMode], PvSuffix.rbv("TriggerMode")]
+    trigger_mode: A[SignalRW[OnOff], PvSuffix.rbv("TriggerMode")]
     trigger_source: A[SignalRW[AravisTriggerSource], PvSuffix.rbv("TriggerSource")]

ophyd_async/epics/adcore/__init__.py

@@ -7,7 +7,6 @@ from ._core_detector import AreaDetector, ContAcqAreaDetector
 from ._core_io import (
     ADBaseDatasetDescriber,
     ADBaseIO,
-    ADCallbacks,
     ADCompression,
     ADState,
     NDArrayBaseIO,
@@ -18,6 +17,7 @@ from ._core_io import (
     NDPluginBaseIO,
     NDPluginCBIO,
     NDPluginStatsIO,
+    NDROIStatIO,
 )
 from ._core_logic import DEFAULT_GOOD_STATES, ADBaseContAcqController, ADBaseController
 from ._core_writer import ADWriter
@@ -33,11 +33,11 @@ from ._utils import (
     NDAttributeParam,
     NDAttributePv,
     NDAttributePvDbrType,
+    ndattributes_to_xml,
 )
 
 __all__ = [
     "ADBaseIO",
-    "ADCallbacks",
     "ADCompression",
     "ADBaseContAcqController",
     "AreaDetector",
@@ -49,6 +49,7 @@ __all__ = [
     "NDFileHDFIO",
     "NDPluginBaseIO",
     "NDPluginStatsIO",
+    "NDROIStatIO",
     "DEFAULT_GOOD_STATES",
     "ADBaseDatasetDescriber",
     "ADBaseController",
@@ -66,4 +67,5 @@ __all__ = [
     "NDAttributePvDbrType",
     "NDCBFlushOnSoftTrgMode",
     "NDPluginCBIO",
+    "ndattributes_to_xml",
 ]

ophyd_async/epics/adcore/_core_detector.py

@@ -1,7 +1,6 @@
 from collections.abc import Sequence
 
-from ophyd_async.core import SignalR, StandardDetector
-from ophyd_async.core._providers import PathProvider
+from ophyd_async.core import PathProvider, SignalR, StandardDetector
 
 from ._core_io import ADBaseIO, NDPluginBaseIO, NDPluginCBIO
 from ._core_logic import ADBaseContAcqController, ADBaseControllerT

ophyd_async/epics/adcore/_core_io.py

@@ -1,17 +1,19 @@
 import asyncio
 from typing import Annotated as A
 
-from ophyd_async.core import DatasetDescriber, SignalR, SignalRW, StrictEnum
+from ophyd_async.core import (
+    DatasetDescriber,
+    DeviceVector,
+    EnableDisable,
+    SignalR,
+    SignalRW,
+    StrictEnum,
+)
 from ophyd_async.epics.core import EpicsDevice, PvSuffix
 
 from ._utils import ADBaseDataType, ADFileWriteMode, ADImageMode, convert_ad_dtype_to_np
 
 
-class ADCallbacks(StrictEnum):
-    ENABLE = "Enable"
-    DISABLE = "Disable"
-
-
 class NDArrayBaseIO(EpicsDevice):
     """Class responsible for passing detector data from drivers to pluglins.
 
@@ -53,7 +55,7 @@ class NDPluginBaseIO(NDArrayBaseIO):
     """
 
     nd_array_port: A[SignalRW[str], PvSuffix.rbv("NDArrayPort")]
-    enable_callbacks: A[SignalRW[ADCallbacks], PvSuffix.rbv("EnableCallbacks")]
+    enable_callbacks: A[SignalRW[EnableDisable], PvSuffix.rbv("EnableCallbacks")]
     nd_array_address: A[SignalRW[int], PvSuffix.rbv("NDArrayAddress")]
     array_size0: A[SignalR[int], PvSuffix("ArraySize0_RBV")]
     array_size1: A[SignalR[int], PvSuffix("ArraySize1_RBV")]
@@ -87,6 +89,56 @@ class NDPluginStatsIO(NDPluginBaseIO):
     hist_max: A[SignalRW[float], PvSuffix.rbv("HistMax")]
 
 
+class NDROIStatIO(NDPluginBaseIO):
+    """Plugin for calculating basic statistics for multiple ROIs.
+
+    Each ROI is implemented as an instance of NDROIStatNIO,
+    and the collection of ROIs is held as a DeviceVector.
+
+    See HTML docs at https://areadetector.github.io/areaDetector/ADCore/NDPluginROIStat.html
+    """
+
+    def __init__(self, prefix, num_channels=8, with_pvi=False, name=""):
+        self.channels = DeviceVector(
+            {i: NDROIStatNIO(f"{prefix}{i}:") for i in range(1, num_channels + 1)}
+        )
+        super().__init__(prefix, with_pvi, name)
+
+
+class NDROIStatNIO(EpicsDevice):
+    """Defines the parameters for a single ROI used for statistics calculation.
+
+    Each instance represents a single ROI, with attributes for its position
+    (min_x, min_y) and size (size_x, size_y), as well as a name and use status.
+
+    See definition in ADApp/pluginSrc/NDPluginROIStat.h in https://github.com/areaDetector/ADCore.
+
+    Attributes:
+        name: The name of the ROI.
+        use: Flag indicating whether the ROI is used.
+        min_x: The start X-coordinate of the ROI.
+        min_y: The start Y-coordinate of the ROI.
+        size_x: The width of the ROI.
+        size_y: The height of the ROI.
+        min_value: Minimum count value in the ROI.
+        max_value: Maximum count value in the ROI.
+        mean_value: Mean counts value in the ROI.
+        total: Total counts in the ROI.
+    """
+
+    name_: A[SignalRW[str], PvSuffix("Name")]
+    use: A[SignalRW[bool], PvSuffix.rbv("Use")]
+    min_x: A[SignalRW[int], PvSuffix.rbv("MinX")]
+    min_y: A[SignalRW[int], PvSuffix.rbv("MinY")]
+    size_x: A[SignalRW[int], PvSuffix.rbv("SizeX")]
+    size_y: A[SignalRW[int], PvSuffix.rbv("SizeY")]
+    # stats
+    min_value: A[SignalR[float], PvSuffix("MinValue_RBV")]
+    max_value: A[SignalR[float], PvSuffix("MaxValue_RBV")]
+    mean_value: A[SignalR[float], PvSuffix("MeanValue_RBV")]
+    total: A[SignalR[float], PvSuffix("Total_RBV")]
+
+
 class ADState(StrictEnum):
     """Default set of states of an AreaDetector driver.
 
@@ -177,7 +229,7 @@ class NDFileHDFIO(NDFilePluginIO):
     swmr_mode: A[SignalRW[bool], PvSuffix.rbv("SWMRMode")]
     flush_now: A[SignalRW[bool], PvSuffix("FlushNow")]
     xml_file_name: A[SignalRW[str], PvSuffix.rbv("XMLFileName")]
-    num_frames_chunks: A[SignalR[int], PvSuffix("NumFramesChunks_RBV")]
+    num_frames_chunks: A[SignalRW[int], PvSuffix.rbv("NumFramesChunks")]
     chunk_size_auto: A[SignalRW[bool], PvSuffix.rbv("ChunkSizeAuto")]
     lazy_open: A[SignalRW[bool], PvSuffix.rbv("LazyOpen")]
 

ophyd_async/epics/adcore/_core_logic.py

@@ -6,6 +6,7 @@ from ophyd_async.core import (
     AsyncStatus,
     DetectorController,
     DetectorTrigger,
+    EnableDisable,
     TriggerInfo,
     observe_value,
     set_and_wait_for_value,
@@ -14,7 +15,6 @@ from ophyd_async.epics.core import stop_busy_record
 
 from ._core_io import (
     ADBaseIO,
-    ADCallbacks,
     ADState,
     NDCBFlushOnSoftTrgMode,
     NDPluginCBIO,
@@ -130,7 +130,7 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
                 ):
                     if state in self.good_states:
                         return
-            except asyncio.TimeoutError as exc:
+            except TimeoutError as exc:
                 if state is not None:
                     raise ValueError(
                         f"Final detector state {state.value} not in valid end "
@@ -138,7 +138,7 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
                     ) from exc
                 else:
                     # No updates from the detector, something else is wrong
-                    raise asyncio.TimeoutError(
+                    raise TimeoutError(
                         "Could not monitor detector state: "
                         + self.driver.detector_state.source
                     ) from exc
@@ -199,7 +199,7 @@ class ADBaseContAcqController(ADBaseController[ADBaseIO]):
 
         # Configure the CB plugin to collect the correct number of triggers
         await asyncio.gather(
-            self.cb_plugin.enable_callbacks.set(ADCallbacks.ENABLE),
+            self.cb_plugin.enable_callbacks.set(EnableDisable.ENABLE),
             self.cb_plugin.pre_count.set(0),
             self.cb_plugin.post_count.set(trigger_info.total_number_of_exposures),
             self.cb_plugin.preset_trigger_count.set(1),

ophyd_async/epics/adcore/_core_writer.py

@@ -11,20 +11,23 @@ from event_model import (  # type: ignore
 )
 from pydantic import PositiveInt
 
-from ophyd_async.core._detector import DetectorWriter
-from ophyd_async.core._providers import DatasetDescriber, PathInfo, PathProvider
-from ophyd_async.core._signal import (
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    DatasetDescriber,
+    DetectorWriter,
+    EnableDisable,
+    PathInfo,
+    PathProvider,
+    error_if_none,
     observe_value,
     set_and_wait_for_value,
 )
-from ophyd_async.core._status import AsyncStatus
-from ophyd_async.core._utils import DEFAULT_TIMEOUT, error_if_none
 from ophyd_async.epics.core import stop_busy_record
 
 # from ophyd_async.epics.adcore._core_logic import ADBaseDatasetDescriber
 from ._core_io import (
     ADBaseDatasetDescriber,
-    ADCallbacks,
     NDArrayBaseIO,
     NDFileIO,
     NDFilePluginIO,
@@ -89,7 +92,7 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         )
 
         if isinstance(self.fileio, NDFilePluginIO):
-            await self.fileio.enable_callbacks.set(ADCallbacks.ENABLE)
+            await self.fileio.enable_callbacks.set(EnableDisable.ENABLE)
 
         # Set the directory creation depth first, since dir creation callback happens
         # when directory path PV is processed.

ophyd_async/epics/adcore/_hdf_writer.py

@@ -75,8 +75,13 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
         # Used by the base class
         self._exposures_per_event = exposures_per_event
 
-        # Determine number of frames that will be saved per HDF chunk
+        # Determine number of frames that will be saved per HDF chunk.
+        # On a fresh IOC startup, this is set to zero until the first capture,
+        # so if it is zero, set it to 1.
         frames_per_chunk = await self.fileio.num_frames_chunks.get_value()
+        if frames_per_chunk == 0:
+            frames_per_chunk = 1
+            await self.fileio.num_frames_chunks.set(frames_per_chunk)
 
         if not _is_fully_described(detector_shape):
             # Questions:
@@ -99,12 +104,6 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
             )
         ]
 
-        self._composer = HDFDocumentComposer(
-            # See https://github.com/bluesky/ophyd-async/issues/122
-            f"{self._path_info.directory_uri}{self._path_info.filename}{self._file_extension}",
-            self._datasets,
-        )
-
         # And all the scalar datasets
         for plugin in self._plugins.values():
             maybe_xml = await plugin.nd_attributes_file.get_value()
@@ -136,6 +135,12 @@ class ADHDFWriter(ADWriter[NDFileHDFIO]):
                         )
                     )
 
+        self._composer = HDFDocumentComposer(
+            # See https://github.com/bluesky/ophyd-async/issues/122
+            f"{self._path_info.directory_uri}{self._path_info.filename}{self._file_extension}",
+            self._datasets,
+        )
+
         describe = {
             ds.data_key: DataKey(
                 source=self.fileio.full_file_name.source,

ophyd_async/epics/adcore/_utils.py

@@ -1,4 +1,6 @@
+from collections.abc import Sequence
 from dataclasses import dataclass
+from xml.etree import ElementTree as ET
 
 from ophyd_async.core import (
     SignalR,
@@ -130,3 +132,39 @@ class NDAttributeParam:
     datatype: NDAttributeDataType  # The datatype of the parameter
     addr: int = 0  # The address as seen in the INP link of the record
     description: str = ""  # A description that appears in the HDF file as an attribute
+
+
+def ndattributes_to_xml(
+    ndattributes: Sequence[NDAttributeParam | NDAttributePv],
+) -> str:
+    """Convert a set of NDAttribute params to XML."""
+    root = ET.Element("Attributes")
+    for ndattribute in ndattributes:
+        if isinstance(ndattribute, NDAttributeParam):
+            ET.SubElement(
+                root,
+                "Attribute",
+                name=ndattribute.name,
+                type="PARAM",
+                source=ndattribute.param,
+                addr=str(ndattribute.addr),
+                datatype=ndattribute.datatype.value,
+                description=ndattribute.description,
+            )
+        elif isinstance(ndattribute, NDAttributePv):
+            ET.SubElement(
+                root,
+                "Attribute",
+                name=ndattribute.name,
+                type="EPICS_PV",
+                source=ndattribute.signal.source.split("ca://")[-1],
+                dbrtype=ndattribute.dbrtype.value,
+                description=ndattribute.description,
+            )
+        else:
+            raise ValueError(
+                f"Invalid type for ndattributes: {type(ndattribute)}. "
+                "Expected NDAttributePv or NDAttributeParam."
+            )
+    xml_text = ET.tostring(root, encoding="unicode")
+    return xml_text

ophyd_async/epics/adkinetix/_kinetix_io.py

@@ -16,10 +16,10 @@ class KinetixTriggerMode(StrictEnum):
 class KinetixReadoutMode(StrictEnum):
     """Readout mode for ADKinetix detector."""
 
-    SENSITIVITY = 1
-    SPEED = 2
-    DYNAMIC_RANGE = 3
-    SUB_ELECTRON = 4
+    SENSITIVITY = "1"
+    SPEED = "2"
+    DYNAMIC_RANGE = "3"
+    SUB_ELECTRON = "4"
 
 
 class KinetixDriverIO(adcore.ADBaseIO):

ophyd_async/epics/adpilatus/_pilatus.py

@@ -1,11 +1,7 @@
 from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider
-from ophyd_async.core._signal import SignalR
-from ophyd_async.epics.adcore._core_detector import AreaDetector
-from ophyd_async.epics.adcore._core_io import NDPluginBaseIO
-from ophyd_async.epics.adcore._core_writer import ADWriter
-from ophyd_async.epics.adcore._hdf_writer import ADHDFWriter
+from ophyd_async.core import PathProvider, SignalR
+from ophyd_async.epics.adcore import ADHDFWriter, ADWriter, AreaDetector, NDPluginBaseIO
 
 from ._pilatus_controller import PilatusController, PilatusReadoutTime
 from ._pilatus_io import PilatusDriverIO

ophyd_async/epics/advimba/__init__.py

@@ -4,7 +4,6 @@ from ._vimba_io import (
     VimbaConvertFormat,
     VimbaDriverIO,
     VimbaExposeOutMode,
-    VimbaOnOff,
     VimbaOverlap,
     VimbaTriggerSource,
 )
@@ -14,7 +13,6 @@ __all__ = [
     "VimbaController",
     "VimbaDriverIO",
     "VimbaExposeOutMode",
-    "VimbaOnOff",
     "VimbaTriggerSource",
     "VimbaOverlap",
     "VimbaConvertFormat",