ophyd-async 0.8.0a5__py3-none-any.whl → 0.9.0a1__py3-none-any.whl

ophyd_async/core/_table.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from typing import Annotated, Any, TypeVar, get_origin
 
 import numpy as np
@@ -19,6 +19,13 @@ def _concat(value1, value2):
         return value1 + value2
 
 
+def _make_default_factory(dtype: np.dtype) -> Callable[[], np.ndarray]:
+    def numpy_array_default_factory() -> np.ndarray:
+        return np.array([], dtype)
+
+    return numpy_array_default_factory
+
+
 class Table(BaseModel):
     """An abstraction of a Table of str to numpy array."""
 
@@ -45,9 +52,7 @@ class Table(BaseModel):
                     NpArrayPydanticAnnotation.factory(
                         data_type=dtype.type, dimensions=1, strict_data_typing=False
                     ),
-                    Field(
-                        default_factory=lambda dtype=dtype: np.array([], dtype=dtype)
-                    ),
+                    Field(default_factory=_make_default_factory(dtype)),
                 ]
             elif get_origin(anno) is Sequence:
                 new_anno = Annotated[anno, Field(default_factory=list)]

ophyd_async/core/_utils.py

@@ -17,11 +17,20 @@ DEFAULT_TIMEOUT = 10.0
 ErrorText = str | Mapping[str, Exception]
 
 
-class StrictEnum(str, Enum):
+class StrictEnumMeta(EnumMeta):
+    def __new__(metacls, *args, **kwargs):
+        ret = super().__new__(metacls, *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(EnumMeta):
+class SubsetEnumMeta(StrictEnumMeta):
     def __call__(self, value, *args, **kwargs):  # type: ignore
         if isinstance(value, str) and not isinstance(value, self):
             return value

ophyd_async/epics/adaravis/_aravis_controller.py

@@ -31,9 +31,9 @@ class AravisController(DetectorController):
 
     async def prepare(self, trigger_info: TriggerInfo):
         if trigger_info.total_number_of_triggers == 0:
-            image_mode = adcore.ImageMode.continuous
+            image_mode = adcore.ImageMode.CONTINUOUS
         else:
-            image_mode = adcore.ImageMode.multiple
+            image_mode = adcore.ImageMode.MULTIPLE
         if (exposure := trigger_info.livetime) is not None:
             await self._drv.acquire_time.set(exposure)
 
@@ -58,9 +58,9 @@ class AravisController(DetectorController):
         self, trigger: DetectorTrigger
     ) -> tuple[AravisTriggerMode, AravisTriggerSource]:
         supported_trigger_types = (
-            DetectorTrigger.constant_gate,
-            DetectorTrigger.edge_trigger,
-            DetectorTrigger.internal,
+            DetectorTrigger.CONSTANT_GATE,
+            DetectorTrigger.EDGE_TRIGGER,
+            DetectorTrigger.INTERNAL,
         )
         if trigger not in supported_trigger_types:
             raise ValueError(
@@ -68,10 +68,10 @@ class AravisController(DetectorController):
                 f"types: {supported_trigger_types} but was asked to "
                 f"use {trigger}"
             )
-        if trigger == DetectorTrigger.internal:
-            return AravisTriggerMode.off, AravisTriggerSource.freerun
+        if trigger == DetectorTrigger.INTERNAL:
+            return AravisTriggerMode.OFF, AravisTriggerSource.FREERUN
         else:
-            return (AravisTriggerMode.on, f"Line{self.gpio_number}")  # type: ignore
+            return (AravisTriggerMode.ON, f"Line{self.gpio_number}")  # type: ignore
 
     async def disarm(self):
         await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/adaravis/_aravis_io.py

@@ -6,8 +6,8 @@ from ophyd_async.epics.core import epics_signal_rw_rbv
 class AravisTriggerMode(StrictEnum):
     """GigEVision GenICAM standard: on=externally triggered"""
 
-    on = "On"
-    off = "Off"
+    ON = "On"
+    OFF = "Off"
 
 
 """A minimal set of TriggerSources that must be supported by the underlying record.
@@ -20,8 +20,8 @@ class AravisTriggerMode(StrictEnum):
 
 
 class AravisTriggerSource(SubsetEnum):
-    freerun = "Freerun"
-    line1 = "Line1"
+    FREERUN = "Freerun"
+    LINE1 = "Line1"
 
 
 class AravisDriverIO(adcore.ADBaseIO):

ophyd_async/epics/adcore/_core_io.py

@@ -9,8 +9,8 @@ from ._utils import ADBaseDataType, FileWriteMode, ImageMode
 
 
 class Callback(StrictEnum):
-    Enable = "Enable"
-    Disable = "Disable"
+    ENABLE = "Enable"
+    DISABLE = "Disable"
 
 
 class NDArrayBaseIO(Device):
@@ -72,17 +72,17 @@ class DetectorState(StrictEnum):
     See definition in ADApp/ADSrc/ADDriver.h in https://github.com/areaDetector/ADCore
     """
 
-    Idle = "Idle"
-    Acquire = "Acquire"
-    Readout = "Readout"
-    Correct = "Correct"
-    Saving = "Saving"
-    Aborting = "Aborting"
-    Error = "Error"
-    Waiting = "Waiting"
-    Initializing = "Initializing"
-    Disconnected = "Disconnected"
-    Aborted = "Aborted"
+    IDLE = "Idle"
+    ACQUIRE = "Acquire"
+    READOUT = "Readout"
+    CORRECT = "Correct"
+    SAVING = "Saving"
+    ABORTING = "Aborting"
+    ERROR = "Error"
+    WAITING = "Waiting"
+    INITIALIZING = "Initializing"
+    DISCONNECTED = "Disconnected"
+    ABORTED = "Aborted"
 
 
 class ADBaseIO(NDArrayBaseIO):
@@ -99,14 +99,14 @@ class ADBaseIO(NDArrayBaseIO):
 
 
 class Compression(StrictEnum):
-    none = "None"
-    nbit = "N-bit"
-    szip = "szip"
-    zlib = "zlib"
-    blosc = "Blosc"
-    bslz4 = "BSLZ4"
-    lz4 = "LZ4"
-    jpeg = "JPEG"
+    NONE = "None"
+    NBIT = "N-bit"
+    SZIP = "szip"
+    ZLIB = "zlib"
+    BLOSC = "Blosc"
+    BSLZ4 = "BSLZ4"
+    LZ4 = "LZ4"
+    JPEG = "JPEG"
 
 
 class NDFileHDFIO(NDPluginBaseIO):

ophyd_async/epics/adcore/_core_logic.py

@@ -14,7 +14,7 @@ from ._core_io import ADBaseIO, DetectorState
 # Default set of states that we should consider "good" i.e. the acquisition
 #  is complete and went well
 DEFAULT_GOOD_STATES: frozenset[DetectorState] = frozenset(
-    [DetectorState.Idle, DetectorState.Aborted]
+    [DetectorState.IDLE, DetectorState.ABORTED]
 )
 
 
@@ -91,7 +91,9 @@ async def start_acquiring_driver_and_ensure_status(
         subsequent raising (if applicable) due to detector state.
     """
 
-    status = await set_and_wait_for_value(driver.acquire, True, timeout=timeout)
+    status = await set_and_wait_for_value(
+        driver.acquire, True, timeout=timeout, wait_for_set_completion=False
+    )
 
     async def complete_acquisition() -> None:
         """NOTE: possible race condition here between the callback from
@@ -100,7 +102,8 @@ async def start_acquiring_driver_and_ensure_status(
         state = await driver.detector_state.get_value()
         if state not in good_states:
             raise ValueError(
-                f"Final detector state {state} not in valid end states: {good_states}"
+                f"Final detector state {state.value} not in valid end "
+                f"states: {good_states}"
             )
 
     return AsyncStatus(complete_acquisition())

ophyd_async/epics/adcore/_hdf_writer.py

@@ -20,7 +20,7 @@ from ophyd_async.core import (
     wait_for_value,
 )
 
-from ._core_io import NDArrayBaseIO, NDFileHDFIO
+from ._core_io import Callback, NDArrayBaseIO, NDFileHDFIO
 from ._utils import (
     FileWriteMode,
     convert_param_dtype_to_np,
@@ -67,10 +67,11 @@ class ADHDFWriter(DetectorWriter):
             self.hdf.file_path.set(str(info.directory_path)),
             self.hdf.file_name.set(info.filename),
             self.hdf.file_template.set("%s/%s.h5"),
-            self.hdf.file_write_mode.set(FileWriteMode.stream),
+            self.hdf.file_write_mode.set(FileWriteMode.STREAM),
             # Never use custom xml layout file but use the one defined
             # in the source code file NDFileHDF5LayoutXML.cpp
             self.hdf.xml_file_name.set(""),
+            self.hdf.enable_callbacks.set(Callback.ENABLE),
         )
 
         assert (
@@ -80,7 +81,9 @@ class ADHDFWriter(DetectorWriter):
         # Overwrite num_capture to go forever
         await self.hdf.num_capture.set(0)
         # Wait for it to start, stashing the status that tells us when it finishes
-        self._capture_status = await set_and_wait_for_value(self.hdf.capture, True)
+        self._capture_status = await set_and_wait_for_value(
+            self.hdf.capture, True, wait_for_set_completion=False
+        )
         name = self._name_provider()
         detector_shape = await self._dataset_describer.shape()
         np_dtype = await self._dataset_describer.np_datatype()

ophyd_async/epics/adcore/_single_trigger.py

@@ -34,7 +34,7 @@ class SingleTriggerDetector(StandardReadable, Triggerable):
     @AsyncStatus.wrap
     async def stage(self) -> None:
         await asyncio.gather(
-            self.drv.image_mode.set(ImageMode.single),
+            self.drv.image_mode.set(ImageMode.SINGLE),
             self.drv.wait_for_plugins.set(True),
         )
         await super().stage()

ophyd_async/epics/adcore/_utils.py

@@ -11,42 +11,42 @@ from ophyd_async.core import (
 
 
 class ADBaseDataType(StrictEnum):
-    Int8 = "Int8"
-    UInt8 = "UInt8"
-    Int16 = "Int16"
-    UInt16 = "UInt16"
-    Int32 = "Int32"
-    UInt32 = "UInt32"
-    Int64 = "Int64"
-    UInt64 = "UInt64"
-    Float32 = "Float32"
-    Float64 = "Float64"
+    INT8 = "Int8"
+    UINT8 = "UInt8"
+    INT16 = "Int16"
+    UINT16 = "UInt16"
+    INT32 = "Int32"
+    UINT32 = "UInt32"
+    INT64 = "Int64"
+    UINT64 = "UInt64"
+    FLOAT32 = "Float32"
+    FLOAT64 = "Float64"
 
 
 def convert_ad_dtype_to_np(ad_dtype: ADBaseDataType) -> str:
     ad_dtype_to_np_dtype = {
-        ADBaseDataType.Int8: "|i1",
-        ADBaseDataType.UInt8: "|u1",
-        ADBaseDataType.Int16: "<i2",
-        ADBaseDataType.UInt16: "<u2",
-        ADBaseDataType.Int32: "<i4",
-        ADBaseDataType.UInt32: "<u4",
-        ADBaseDataType.Int64: "<i8",
-        ADBaseDataType.UInt64: "<u8",
-        ADBaseDataType.Float32: "<f4",
-        ADBaseDataType.Float64: "<f8",
+        ADBaseDataType.INT8: "|i1",
+        ADBaseDataType.UINT8: "|u1",
+        ADBaseDataType.INT16: "<i2",
+        ADBaseDataType.UINT16: "<u2",
+        ADBaseDataType.INT32: "<i4",
+        ADBaseDataType.UINT32: "<u4",
+        ADBaseDataType.INT64: "<i8",
+        ADBaseDataType.UINT64: "<u8",
+        ADBaseDataType.FLOAT32: "<f4",
+        ADBaseDataType.FLOAT64: "<f8",
     }
     return ad_dtype_to_np_dtype[ad_dtype]
 
 
 def convert_pv_dtype_to_np(datatype: str) -> str:
     _pvattribute_to_ad_datatype = {
-        "DBR_SHORT": ADBaseDataType.Int16,
-        "DBR_ENUM": ADBaseDataType.Int16,
-        "DBR_INT": ADBaseDataType.Int32,
-        "DBR_LONG": ADBaseDataType.Int32,
-        "DBR_FLOAT": ADBaseDataType.Float32,
-        "DBR_DOUBLE": ADBaseDataType.Float64,
+        "DBR_SHORT": ADBaseDataType.INT16,
+        "DBR_ENUM": ADBaseDataType.INT16,
+        "DBR_INT": ADBaseDataType.INT32,
+        "DBR_LONG": ADBaseDataType.INT32,
+        "DBR_FLOAT": ADBaseDataType.FLOAT32,
+        "DBR_DOUBLE": ADBaseDataType.FLOAT64,
     }
     if datatype in ["DBR_STRING", "DBR_CHAR"]:
         np_datatype = "s40"
@@ -62,9 +62,9 @@ def convert_pv_dtype_to_np(datatype: str) -> str:
 
 def convert_param_dtype_to_np(datatype: str) -> str:
     _paramattribute_to_ad_datatype = {
-        "INT": ADBaseDataType.Int32,
-        "INT64": ADBaseDataType.Int64,
-        "DOUBLE": ADBaseDataType.Float64,
+        "INT": ADBaseDataType.INT32,
+        "INT64": ADBaseDataType.INT64,
+        "DOUBLE": ADBaseDataType.FLOAT64,
     }
     if datatype in ["STRING"]:
         np_datatype = "s40"
@@ -79,15 +79,15 @@ def convert_param_dtype_to_np(datatype: str) -> str:
 
 
 class FileWriteMode(StrictEnum):
-    single = "Single"
-    capture = "Capture"
-    stream = "Stream"
+    SINGLE = "Single"
+    CAPTURE = "Capture"
+    STREAM = "Stream"
 
 
 class ImageMode(StrictEnum):
-    single = "Single"
-    multiple = "Multiple"
-    continuous = "Continuous"
+    SINGLE = "Single"
+    MULTIPLE = "Multiple"
+    CONTINUOUS = "Continuous"
 
 
 class NDAttributeDataType(StrictEnum):

ophyd_async/epics/adkinetix/_kinetix_controller.py

@@ -11,10 +11,10 @@ from ophyd_async.epics import adcore
 from ._kinetix_io import KinetixDriverIO, KinetixTriggerMode
 
 KINETIX_TRIGGER_MODE_MAP = {
-    DetectorTrigger.internal: KinetixTriggerMode.internal,
-    DetectorTrigger.constant_gate: KinetixTriggerMode.gate,
-    DetectorTrigger.variable_gate: KinetixTriggerMode.gate,
-    DetectorTrigger.edge_trigger: KinetixTriggerMode.edge,
+    DetectorTrigger.INTERNAL: KinetixTriggerMode.INTERNAL,
+    DetectorTrigger.CONSTANT_GATE: KinetixTriggerMode.GATE,
+    DetectorTrigger.VARIABLE_GATE: KinetixTriggerMode.GATE,
+    DetectorTrigger.EDGE_TRIGGER: KinetixTriggerMode.EDGE,
 }
 
 
@@ -33,11 +33,11 @@ class KinetixController(DetectorController):
         await asyncio.gather(
             self._drv.trigger_mode.set(KINETIX_TRIGGER_MODE_MAP[trigger_info.trigger]),
             self._drv.num_images.set(trigger_info.total_number_of_triggers),
-            self._drv.image_mode.set(adcore.ImageMode.multiple),
+            self._drv.image_mode.set(adcore.ImageMode.MULTIPLE),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [
-            DetectorTrigger.variable_gate,
-            DetectorTrigger.constant_gate,
+            DetectorTrigger.VARIABLE_GATE,
+            DetectorTrigger.CONSTANT_GATE,
         ]:
             await self._drv.acquire_time.set(trigger_info.livetime)
 

ophyd_async/epics/adkinetix/_kinetix_io.py

@@ -4,16 +4,16 @@ from ophyd_async.epics.core import epics_signal_rw_rbv
 
 
 class KinetixTriggerMode(StrictEnum):
-    internal = "Internal"
-    edge = "Rising Edge"
-    gate = "Exp. Gate"
+    INTERNAL = "Internal"
+    EDGE = "Rising Edge"
+    GATE = "Exp. Gate"
 
 
 class KinetixReadoutMode(StrictEnum):
-    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

@@ -17,10 +17,10 @@ class PilatusReadoutTime(float, Enum):
     """Pilatus readout time per model in ms"""
 
     # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
-    pilatus2 = 2.28e-3
+    PILATUS2 = 2.28e-3
 
     # Cite: https://media.dectris.com/user-manual-pilatus3-2020.pdf
-    pilatus3 = 0.95e-3
+    PILATUS3 = 0.95e-3
 
 
 class PilatusDetector(StandardDetector):
@@ -33,7 +33,7 @@ class PilatusDetector(StandardDetector):
         self,
         prefix: str,
         path_provider: PathProvider,
-        readout_time: PilatusReadoutTime = PilatusReadoutTime.pilatus3,
+        readout_time: PilatusReadoutTime = PilatusReadoutTime.PILATUS3,
         drv_suffix: str = "cam1:",
         hdf_suffix: str = "HDF1:",
         name: str = "",

ophyd_async/epics/adpilatus/_pilatus_controller.py

@@ -15,9 +15,9 @@ from ._pilatus_io import PilatusDriverIO, PilatusTriggerMode
 
 class PilatusController(DetectorController):
     _supported_trigger_types = {
-        DetectorTrigger.internal: PilatusTriggerMode.internal,
-        DetectorTrigger.constant_gate: PilatusTriggerMode.ext_enable,
-        DetectorTrigger.variable_gate: PilatusTriggerMode.ext_enable,
+        DetectorTrigger.INTERNAL: PilatusTriggerMode.INTERNAL,
+        DetectorTrigger.CONSTANT_GATE: PilatusTriggerMode.EXT_ENABLE,
+        DetectorTrigger.VARIABLE_GATE: PilatusTriggerMode.EXT_ENABLE,
     }
 
     def __init__(
@@ -44,7 +44,7 @@ class PilatusController(DetectorController):
                 if trigger_info.total_number_of_triggers == 0
                 else trigger_info.total_number_of_triggers
             ),
-            self._drv.image_mode.set(adcore.ImageMode.multiple),
+            self._drv.image_mode.set(adcore.ImageMode.MULTIPLE),
         )
 
     async def arm(self):

ophyd_async/epics/adpilatus/_pilatus_io.py

@@ -4,11 +4,11 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv
 
 
 class PilatusTriggerMode(StrictEnum):
-    internal = "Internal"
-    ext_enable = "Ext. Enable"
-    ext_trigger = "Ext. Trigger"
-    mult_trigger = "Mult. Trigger"
-    alignment = "Alignment"
+    INTERNAL = "Internal"
+    EXT_ENABLE = "Ext. Enable"
+    EXT_TRIGGER = "Ext. Trigger"
+    MULT_TRIGGER = "Mult. Trigger"
+    ALIGNMENT = "Alignment"
 
 
 class PilatusDriverIO(adcore.ADBaseIO):

ophyd_async/epics/adsimdetector/_sim_controller.py

@@ -26,14 +26,14 @@ class SimController(DetectorController):
 
     async def prepare(self, trigger_info: TriggerInfo):
         assert (
-            trigger_info.trigger == DetectorTrigger.internal
+            trigger_info.trigger == DetectorTrigger.INTERNAL
         ), "fly scanning (i.e. external triggering) is not supported for this device"
         self.frame_timeout = (
             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.image_mode.set(adcore.ImageMode.multiple),
+            self.driver.image_mode.set(adcore.ImageMode.MULTIPLE),
         )
 
     async def arm(self):

ophyd_async/epics/advimba/_vimba_controller.py

@@ -11,17 +11,17 @@ from ophyd_async.epics import adcore
 from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaOnOff, VimbaTriggerSource
 
 TRIGGER_MODE = {
-    DetectorTrigger.internal: VimbaOnOff.off,
-    DetectorTrigger.constant_gate: VimbaOnOff.on,
-    DetectorTrigger.variable_gate: VimbaOnOff.on,
-    DetectorTrigger.edge_trigger: VimbaOnOff.on,
+    DetectorTrigger.INTERNAL: VimbaOnOff.OFF,
+    DetectorTrigger.CONSTANT_GATE: VimbaOnOff.ON,
+    DetectorTrigger.VARIABLE_GATE: VimbaOnOff.ON,
+    DetectorTrigger.EDGE_TRIGGER: VimbaOnOff.ON,
 }
 
 EXPOSE_OUT_MODE = {
-    DetectorTrigger.internal: VimbaExposeOutMode.timed,
-    DetectorTrigger.constant_gate: VimbaExposeOutMode.trigger_width,
-    DetectorTrigger.variable_gate: VimbaExposeOutMode.trigger_width,
-    DetectorTrigger.edge_trigger: VimbaExposeOutMode.timed,
+    DetectorTrigger.INTERNAL: VimbaExposeOutMode.TIMED,
+    DetectorTrigger.CONSTANT_GATE: VimbaExposeOutMode.TRIGGER_WIDTH,
+    DetectorTrigger.VARIABLE_GATE: VimbaExposeOutMode.TRIGGER_WIDTH,
+    DetectorTrigger.EDGE_TRIGGER: VimbaExposeOutMode.TIMED,
 }
 
 
@@ -41,17 +41,17 @@ class VimbaController(DetectorController):
             self._drv.trigger_mode.set(TRIGGER_MODE[trigger_info.trigger]),
             self._drv.exposure_mode.set(EXPOSE_OUT_MODE[trigger_info.trigger]),
             self._drv.num_images.set(trigger_info.total_number_of_triggers),
-            self._drv.image_mode.set(adcore.ImageMode.multiple),
+            self._drv.image_mode.set(adcore.ImageMode.MULTIPLE),
         )
         if trigger_info.livetime is not None and trigger_info.trigger not in [
-            DetectorTrigger.variable_gate,
-            DetectorTrigger.constant_gate,
+            DetectorTrigger.VARIABLE_GATE,
+            DetectorTrigger.CONSTANT_GATE,
         ]:
             await self._drv.acquire_time.set(trigger_info.livetime)
-        if trigger_info.trigger != DetectorTrigger.internal:
-            self._drv.trigger_source.set(VimbaTriggerSource.line1)
+        if trigger_info.trigger != DetectorTrigger.INTERNAL:
+            self._drv.trigger_source.set(VimbaTriggerSource.LINE1)
         else:
-            self._drv.trigger_source.set(VimbaTriggerSource.freerun)
+            self._drv.trigger_source.set(VimbaTriggerSource.FREERUN)
 
     async def arm(self):
         self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(

ophyd_async/epics/advimba/_vimba_io.py

@@ -4,44 +4,44 @@ from ophyd_async.epics.core import epics_signal_rw_rbv
 
 
 class VimbaPixelFormat(StrictEnum):
-    internal = "Mono8"
-    ext_enable = "Mono12"
-    ext_trigger = "Ext. Trigger"
-    mult_trigger = "Mult. Trigger"
-    alignment = "Alignment"
+    INTERNAL = "Mono8"
+    EXT_ENABLE = "Mono12"
+    EXT_TRIGGER = "Ext. Trigger"
+    MULT_TRIGGER = "Mult. Trigger"
+    ALIGNMENT = "Alignment"
 
 
 class VimbaConvertFormat(StrictEnum):
-    none = "None"
-    mono8 = "Mono8"
-    mono16 = "Mono16"
-    rgb8 = "RGB8"
-    rgb16 = "RGB16"
+    NONE = "None"
+    MONO8 = "Mono8"
+    MONO16 = "Mono16"
+    RGB8 = "RGB8"
+    RGB16 = "RGB16"
 
 
 class VimbaTriggerSource(StrictEnum):
-    freerun = "Freerun"
-    line1 = "Line1"
-    line2 = "Line2"
-    fixed_rate = "FixedRate"
-    software = "Software"
-    action0 = "Action0"
-    action1 = "Action1"
+    FREERUN = "Freerun"
+    LINE1 = "Line1"
+    LINE2 = "Line2"
+    FIXED_RATE = "FixedRate"
+    SOFTWARE = "Software"
+    ACTION0 = "Action0"
+    ACTION1 = "Action1"
 
 
 class VimbaOverlap(StrictEnum):
-    off = "Off"
-    prev_frame = "PreviousFrame"
+    OFF = "Off"
+    PREV_FRAME = "PreviousFrame"
 
 
 class VimbaOnOff(StrictEnum):
-    on = "On"
-    off = "Off"
+    ON = "On"
+    OFF = "Off"
 
 
 class VimbaExposeOutMode(StrictEnum):
-    timed = "Timed"  # Use ExposureTime PV
-    trigger_width = "TriggerWidth"  # Expose for length of high signal
+    TIMED = "Timed"  # Use ExposureTime PV
+    TRIGGER_WIDTH = "TriggerWidth"  # Expose for length of high signal
 
 
 class VimbaDriverIO(adcore.ADBaseIO):

ophyd_async/epics/core/_p4p.py

@@ -94,6 +94,22 @@ class PvaConverter(Generic[SignalDatatypeT]):
         return value
 
 
+class PvaLongStringConverter(PvaConverter[str]):
+    def __init__(self):
+        super().__init__(str)
+
+    def value(self, value: Any) -> Any:
+        # Value here is a null terminated array of ascii codes.
+        # We strip out the null terminator, and convert each code
+        # to the corresponding char, joining into a string
+        return value["value"].tobytes().rstrip(b"\0").decode()
+
+    def write_value(self, value: Any) -> Any:
+        # Inverse of reading - convert each character into it's ascii code,
+        # put into a list, and add null terminator.
+        return np.frombuffer(str(value).encode() + b"\0", dtype=np.int8)
+
+
 class DisconnectedPvaConverter(PvaConverter):
     def __getattribute__(self, __name: str) -> Any:
         raise NotImplementedError("No PV has been set as connect() has not been called")
@@ -252,6 +268,9 @@ def make_converter(datatype: type | None, values: dict[str, Any]) -> PvaConverte
     elif datatype in (None, inferred_datatype):
         # If datatype matches what we are given then allow it and use inferred converter
         return converter_cls(inferred_datatype)
+    # Allow waveforms with FTVL=CHAR to be treated as str when requested
+    elif datatype is str and inferred_datatype == Array1D[np.int8]:
+        return PvaLongStringConverter()
     raise TypeError(
         f"{pv} with inferred datatype {format_datatype(inferred_datatype)}"
         f" from {typeid=} {specifier=}"