ophyd-async 0.9.0a1__py3-none-any.whl → 0.9.0a2__py3-none-any.whl

ophyd_async/core/_readable.py

@@ -123,29 +123,31 @@ class StandardReadable(
             # we want to combine them when they are Sequences, and ensure they are
             # identical when string values.
             for key, value in new_hint.hints.items():
+                # fail early for unkwon types
                 if isinstance(value, str):
                     if key in hints:
-                        assert (
-                            hints[key] == value  # type: ignore[literal-required]
-                        ), f"Hints key {key} value may not be overridden"
+                        if hints[key] != value:
+                            msg = f"Hints key {key} value may not be overridden"
+                            raise RuntimeError(msg)
                     else:
                         hints[key] = value  # type: ignore[literal-required]
                 elif isinstance(value, Sequence):
                     if key in hints:
                         for new_val in value:
-                            assert (
-                                new_val not in hints[key]  # type: ignore[literal-required]
-                            ), f"Hint {key} {new_val} overrides existing hint"
+                            if new_val in hints[key]:
+                                msg = f"Hint {key} {new_val} overrides existing hint"
+                                raise RuntimeError(msg)
                         hints[key] = (  # type: ignore[literal-required]
                             hints[key] + value  # type: ignore[literal-required]
                         )
                     else:
                         hints[key] = value  # type: ignore[literal-required]
                 else:
-                    raise TypeError(
-                        f"{new_hint.name}: Unknown type for value '{value}' "
+                    msg = (
+                        f"{new_hint.name}: Unknown type for value '{value}'"
                         f" for key '{key}'"
                     )
+                    raise TypeError(msg)
 
         return hints
 
@@ -204,6 +206,11 @@ class StandardReadable(
             `StandardReadableFormat` documentation
         """
 
+        def assert_device_is_signalr(device: Device) -> SignalR:
+            if not isinstance(device, SignalR):
+                raise TypeError(f"{device} is not a SignalR")
+            return device
+
         for device in devices:
             match format:
                 case StandardReadableFormat.CHILD:
@@ -218,24 +225,24 @@ class StandardReadable(
                     if isinstance(device, HasHints):
                         self._has_hints += (device,)
                 case StandardReadableFormat.CONFIG_SIGNAL:
-                    assert isinstance(device, SignalR), f"{device} is not a SignalR"
-                    self._describe_config_funcs += (device.describe,)
-                    self._read_config_funcs += (device.read,)
+                    signalr_device = assert_device_is_signalr(device=device)
+                    self._describe_config_funcs += (signalr_device.describe,)
+                    self._read_config_funcs += (signalr_device.read,)
                 case StandardReadableFormat.HINTED_SIGNAL:
-                    assert isinstance(device, SignalR), f"{device} is not a SignalR"
-                    self._describe_funcs += (device.describe,)
-                    self._read_funcs += (device.read,)
-                    self._stageables += (device,)
-                    self._has_hints += (_HintsFromName(device),)
+                    signalr_device = assert_device_is_signalr(device=device)
+                    self._describe_funcs += (signalr_device.describe,)
+                    self._read_funcs += (signalr_device.read,)
+                    self._stageables += (signalr_device,)
+                    self._has_hints += (_HintsFromName(signalr_device),)
                 case StandardReadableFormat.UNCACHED_SIGNAL:
-                    assert isinstance(device, SignalR), f"{device} is not a SignalR"
-                    self._describe_funcs += (device.describe,)
-                    self._read_funcs += (_UncachedRead(device),)
+                    signalr_device = assert_device_is_signalr(device=device)
+                    self._describe_funcs += (signalr_device.describe,)
+                    self._read_funcs += (_UncachedRead(signalr_device),)
                 case StandardReadableFormat.HINTED_UNCACHED_SIGNAL:
-                    assert isinstance(device, SignalR), f"{device} is not a SignalR"
-                    self._describe_funcs += (device.describe,)
-                    self._read_funcs += (_UncachedRead(device),)
-                    self._has_hints += (_HintsFromName(device),)
+                    signalr_device = assert_device_is_signalr(device=device)
+                    self._describe_funcs += (signalr_device.describe,)
+                    self._read_funcs += (_UncachedRead(signalr_device),)
+                    self._has_hints += (_HintsFromName(signalr_device),)
 
 
 class _UncachedRead:

ophyd_async/core/_settings.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import Callable, Iterator, MutableMapping
+from typing import Any, Generic
+
+from ._device import Device, DeviceT
+from ._signal import SignalRW
+from ._signal_backend import SignalDatatypeT
+
+
+class Settings(MutableMapping[SignalRW[Any], Any], Generic[DeviceT]):
+    def __init__(
+        self, device: DeviceT, settings: MutableMapping[SignalRW, Any] | None = None
+    ):
+        self.device = device
+        self._settings = {}
+        self.update(settings or {})
+
+    def __getitem__(self, key: SignalRW[SignalDatatypeT]) -> SignalDatatypeT:
+        return self._settings[key]
+
+    def _is_in_device(self, device: Device) -> bool:
+        while device.parent and device.parent is not self.device:
+            # While we have a parent that is not the right device
+            # continue searching up the tree
+            device = device.parent
+        return device.parent is self.device
+
+    def __setitem__(
+        self, key: SignalRW[SignalDatatypeT], value: SignalDatatypeT | None
+    ) -> None:
+        # Check the types on entry to dict to make sure we can't accidentally
+        # add a non-signal type
+        if not isinstance(key, SignalRW):
+            raise TypeError(f"Expected SignalRW, got {key}")
+        if not self._is_in_device(key):
+            raise KeyError(f"Signal {key} is not a child of {self.device}")
+        self._settings[key] = value
+
+    def __delitem__(self, key: SignalRW) -> None:
+        del self._settings[key]
+
+    def __iter__(self) -> Iterator[SignalRW]:
+        yield from iter(self._settings)
+
+    def __len__(self) -> int:
+        return len(self._settings)
+
+    def __or__(self, other: MutableMapping[SignalRW, Any]) -> Settings[DeviceT]:
+        """Create a new Settings that is the union of self overridden by other.
+
+        For example::
+
+            settings1 = Settings(device, {device.sig1: 1, device.sig2: 2})
+            settings2 = Settings(device, {device.sig1: 10, device.sig3: 3})
+            settings = settings1 | settings2
+            assert dict(settings) == {
+                device.sig1: 10,
+                device.sig2: 2,
+                device.sig3: 3,
+            }
+        """
+        if isinstance(other, Settings) and not self._is_in_device(other.device):
+            raise ValueError(f"{other.device} is not a child of {self.device}")
+        return Settings(self.device, self._settings | dict(other))
+
+    def partition(
+        self, predicate: Callable[[SignalRW], bool]
+    ) -> tuple[Settings[DeviceT], Settings[DeviceT]]:
+        """Partition into two Settings based on a predicate.
+
+        Parameters
+        ----------
+        predicate
+            Callable that takes each signal, and returns a boolean to say if it
+            should be in the first returned Settings
+
+        Returns
+        -------
+            (where_true, where_false)
+
+        For example::
+
+            settings = Settings(device, {device.special: 1, device.sig: 2})
+            specials, others = settings.partition(lambda sig: "special" in sig.name)
+        """
+        where_true, where_false = Settings(self.device), Settings(self.device)
+        for signal, value in self.items():
+            dest = where_true if predicate(signal) else where_false
+            dest[signal] = value
+        return where_true, where_false
+
+
+class SettingsProvider:
+    @abstractmethod
+    async def store(self, name: str, data: dict[str, Any]):
+        """Store the data, associating it with the given name."""
+        ...
+
+    @abstractmethod
+    async def retrieve(self, name: str) -> dict[str, Any]:
+        """Retrieve the data associated with the given name."""
+        ...

ophyd_async/core/_signal.py

@@ -4,7 +4,7 @@ import asyncio
 import functools
 import time
 from collections.abc import AsyncGenerator, Awaitable, Callable
-from typing import Generic, cast
+from typing import Any, Generic, cast
 
 from bluesky.protocols import (
     Locatable,
@@ -97,30 +97,35 @@ class Signal(Device, Generic[SignalDatatypeT]):
 
 
 class _SignalCache(Generic[SignalDatatypeT]):
-    def __init__(self, backend: SignalBackend[SignalDatatypeT], signal: Signal):
-        self._signal = signal
+    def __init__(self, backend: SignalBackend[SignalDatatypeT], signal: Signal) -> None:
+        self._signal: Signal[Any] = signal
         self._staged = False
         self._listeners: dict[Callback, bool] = {}
         self._valid = asyncio.Event()
         self._reading: Reading[SignalDatatypeT] | None = None
-        self.backend = backend
+        self.backend: SignalBackend[SignalDatatypeT] = backend
         signal.log.debug(f"Making subscription on source {signal.source}")
         backend.set_callback(self._callback)
 
-    def close(self):
+    def close(self) -> None:
         self.backend.set_callback(None)
         self._signal.log.debug(f"Closing subscription on source {self._signal.source}")
 
+    def _ensure_reading(self) -> Reading[SignalDatatypeT]:
+        if not self._reading:
+            msg = "Monitor not working"
+            raise RuntimeError(msg)
+        return self._reading
+
     async def get_reading(self) -> Reading[SignalDatatypeT]:
         await self._valid.wait()
-        assert self._reading is not None, "Monitor not working"
-        return self._reading
+        return self._ensure_reading()
 
     async def get_value(self) -> SignalDatatypeT:
-        reading = await self.get_reading()
+        reading: Reading[SignalDatatypeT] = await self.get_reading()
         return reading["value"]
 
-    def _callback(self, reading: Reading[SignalDatatypeT]):
+    def _callback(self, reading: Reading[SignalDatatypeT]) -> None:
         self._signal.log.debug(
             f"Updated subscription: reading of source {self._signal.source} changed "
             f"from {self._reading} to {reading}"
@@ -134,12 +139,10 @@ class _SignalCache(Generic[SignalDatatypeT]):
         self,
         function: Callback[dict[str, Reading[SignalDatatypeT]] | SignalDatatypeT],
         want_value: bool,
-    ):
-        assert self._reading, "Monitor not working"
-        if want_value:
-            function(self._reading["value"])
-        else:
-            function({self._signal.name: self._reading})
+    ) -> None:
+        function(self._ensure_reading()["value"]) if want_value else function(
+            {self._signal.name: self._ensure_reading()}
+        )
 
     def subscribe(self, function: Callback, want_value: bool) -> None:
         self._listeners[function] = want_value
@@ -150,7 +153,7 @@ class _SignalCache(Generic[SignalDatatypeT]):
         self._listeners.pop(function)
         return self._staged or bool(self._listeners)
 
-    def set_staged(self, staged: bool):
+    def set_staged(self, staged: bool) -> bool:
         self._staged = staged
         return self._staged or bool(self._listeners)
 
@@ -167,7 +170,10 @@ class SignalR(Signal[SignalDatatypeT], AsyncReadable, AsyncStageable, Subscribab
         if cached is None:
             cached = self._cache is not None
         if cached:
-            assert self._cache, f"{self.source} not being monitored"
+            if not self._cache:
+                msg = f"{self.source} not being monitored"
+                raise RuntimeError(msg)
+            # assert self._cache, f"{self.source} not being monitored"
             return self._cache
         else:
             return self._connector.backend
@@ -598,3 +604,35 @@ async def set_and_wait_for_value(
         status_timeout,
         wait_for_set_completion,
     )
+
+
+def walk_rw_signals(device: Device, path_prefix: str = "") -> dict[str, SignalRW[Any]]:
+    """Retrieve all SignalRWs from a device.
+
+    Stores retrieved signals with their dotted attribute paths in a dictionary. Used as
+    part of saving and loading a device.
+
+    Parameters
+    ----------
+    device : Device
+        Ophyd device to retrieve read-write signals from.
+
+    path_prefix : str
+        For internal use, leave blank when calling the method.
+
+    Returns
+    -------
+    SignalRWs : dict
+        A dictionary matching the string attribute path of a SignalRW with the
+        signal itself.
+
+    """
+    signals: dict[str, SignalRW[Any]] = {}
+
+    for attr_name, attr in device.children():
+        dot_path = f"{path_prefix}{attr_name}"
+        if type(attr) is SignalRW:
+            signals[dot_path] = attr
+        attr_signals = walk_rw_signals(attr, path_prefix=dot_path + ".")
+        signals.update(attr_signals)
+    return signals

ophyd_async/core/_signal_backend.py

@@ -10,7 +10,10 @@ from ._table import Table
 from ._utils import Callback, StrictEnum, T
 
 DTypeScalar_co = TypeVar("DTypeScalar_co", covariant=True, bound=np.generic)
-Array1D = np.ndarray[tuple[int], np.dtype[DTypeScalar_co]]
+# To be a 1D array shape should really be tuple[int], but np.array()
+# currently produces tuple[int, ...] even when it has 1D input args
+# https://github.com/numpy/numpy/issues/28077#issuecomment-2566485178
+Array1D = np.ndarray[tuple[int, ...], np.dtype[DTypeScalar_co]]
 Primitive = bool | int | float | str
 # NOTE: if you change this union then update the docs to match
 SignalDatatype = (

ophyd_async/core/_soft_signal_backend.py

@@ -175,7 +175,8 @@ class SoftSignalBackend(SignalBackend[SignalDatatypeT]):
         return self.reading["value"]
 
     def set_callback(self, callback: Callback[Reading[SignalDatatypeT]] | None) -> None:
+        if callback and self.callback:
+            raise RuntimeError("Cannot set a callback when one is already set")
         if callback:
-            assert not self.callback, "Cannot set a callback when one is already set"
             callback(self.reading)
         self.callback = callback

ophyd_async/core/_table.py

@@ -39,6 +39,11 @@ class Table(BaseModel):
     # so it is strictly checked against the BaseModel we are supplied.
     model_config = ConfigDict(extra="allow")
 
+    # Add an init method to match the above model config, otherwise the type
+    # checker will not think we can pass arbitrary kwargs into the base class init
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
     @classmethod
     def __init_subclass__(cls):
         # But forbit extra in subclasses so it gets validated
@@ -78,9 +83,6 @@ class Table(BaseModel):
             }
         )
 
-    def __eq__(self, value: object) -> bool:
-        return super().__eq__(value)
-
     def numpy_dtype(self) -> np.dtype:
         dtype = []
         for k, v in self:
@@ -99,8 +101,10 @@ class Table(BaseModel):
                 v = v[selection]
             if array is None:
                 array = np.empty(v.shape, dtype=self.numpy_dtype())
-            array[k] = v
-        assert array is not None
+            array[k] = v  # type: ignore
+        if array is None:
+            msg = "No arrays found in table"
+            raise ValueError(msg)
         return array
 
     @model_validator(mode="before")
@@ -123,10 +127,12 @@ class Table(BaseModel):
                 # Convert to correct dtype, but only if we don't lose precision
                 # as a result
                 cast_value = np.array(data_value).astype(expected_dtype)
-                assert np.array_equal(data_value, cast_value), (
-                    f"{field_name}: Cannot cast {data_value} to {expected_dtype} "
-                    "without losing precision"
-                )
+                if not np.array_equal(data_value, cast_value):
+                    msg = (
+                        f"{field_name}: Cannot cast {data_value} to {expected_dtype} "
+                        "without losing precision"
+                    )
+                    raise ValueError(msg)
                 data_dict[field_name] = cast_value
         return data_dict
 
@@ -135,7 +141,9 @@ class Table(BaseModel):
         lengths: dict[int, set[str]] = {}
         for field_name, field_value in self:
             lengths.setdefault(len(field_value), set()).add(field_name)
-        assert len(lengths) <= 1, f"Columns should be same length, got {lengths=}"
+        if len(lengths) > 1:
+            msg = f"Columns should be same length, got {lengths=}"
+            raise ValueError(msg)
         return self
 
     def __len__(self) -> int:

ophyd_async/core/_utils.py

@@ -16,6 +16,8 @@ Callback = Callable[[T], None]
 DEFAULT_TIMEOUT = 10.0
 ErrorText = str | Mapping[str, Exception]
 
+logger = logging.getLogger("ophyd_async")
+
 
 class StrictEnumMeta(EnumMeta):
     def __new__(metacls, *args, **kwargs):
@@ -94,7 +96,7 @@ class NotConnected(Exception):
     def format_error_string(self, indent="") -> str:
         if not isinstance(self._errors, dict) and not isinstance(self._errors, str):
             raise RuntimeError(
-                f"Unexpected type `{type(self._errors)}` " "expected `str` or `dict`"
+                f"Unexpected type `{type(self._errors)}` expected `str` or `dict`"
             )
 
         if isinstance(self._errors, str):
@@ -114,7 +116,7 @@ class NotConnected(Exception):
     ) -> NotConnected:
         for name, exception in exceptions.items():
             if not isinstance(exception, NotConnected):
-                logging.exception(
+                logger.exception(
                     f"device `{name}` raised unexpected exception "
                     f"{type(exception).__name__}",
                     exc_info=exception,
@@ -189,7 +191,7 @@ def get_enum_cls(datatype: type | None) -> type[StrictEnum] | None:
     if datatype and issubclass(datatype, Enum):
         if not issubclass(datatype, StrictEnum):
             raise TypeError(
-                f"{datatype} should inherit from .SubsetEnum "
+                f"{datatype} should inherit from ophyd_async.core.SubsetEnum "
                 "or ophyd_async.core.StrictEnum"
             )
         return datatype

ophyd_async/core/_yaml_settings.py

@@ -0,0 +1,64 @@
+import warnings
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+import yaml
+from pydantic import BaseModel
+
+from ._settings import SettingsProvider
+
+
+def ndarray_representer(dumper: yaml.Dumper, array: npt.NDArray[Any]) -> yaml.Node:
+    return dumper.represent_sequence(
+        "tag:yaml.org,2002:seq", array.tolist(), flow_style=True
+    )
+
+
+def pydantic_model_abstraction_representer(
+    dumper: yaml.Dumper, model: BaseModel
+) -> yaml.Node:
+    return dumper.represent_data(model.model_dump(mode="python"))
+
+
+def enum_representer(dumper: yaml.Dumper, enum: Enum) -> yaml.Node:
+    return dumper.represent_data(enum.value)
+
+
+class YamlSettingsProvider(SettingsProvider):
+    def __init__(self, directory: Path | str):
+        self._directory = Path(directory)
+
+    def _file_path(self, name: str) -> Path:
+        return self._directory / (name + ".yaml")
+
+    async def store(self, name: str, data: dict[str, Any]):
+        yaml.add_representer(np.ndarray, ndarray_representer, Dumper=yaml.Dumper)
+        yaml.add_multi_representer(
+            BaseModel,
+            pydantic_model_abstraction_representer,
+            Dumper=yaml.Dumper,
+        )
+        yaml.add_multi_representer(Enum, enum_representer, Dumper=yaml.Dumper)
+        with open(self._file_path(name), "w") as file:
+            yaml.dump(data, file)
+
+    async def retrieve(self, name: str) -> dict[str, Any]:
+        with open(self._file_path(name)) as file:
+            data = yaml.full_load(file)
+        if isinstance(data, list):
+            warnings.warn(
+                DeprecationWarning(
+                    "Found old save file. Re-save your yaml settings file "
+                    f"{self._file_path(name)} using "
+                    "ophyd_async.plan_stubs.store_settings"
+                ),
+                stacklevel=2,
+            )
+            merge = {}
+            for d in data:
+                merge.update(d)
+            return merge
+        return data

ophyd_async/epics/adandor/__init__.py

@@ -0,0 +1,9 @@
+from ._andor import Andor2Detector
+from ._andor_controller import Andor2Controller
+from ._andor_io import Andor2DriverIO
+
+__all__ = [
+    "Andor2Detector",
+    "Andor2Controller",
+    "Andor2DriverIO",
+]

ophyd_async/epics/adandor/_andor.py

@@ -0,0 +1,45 @@
+from collections.abc import Sequence
+
+from ophyd_async.core import PathProvider
+from ophyd_async.core._signal import SignalR
+from ophyd_async.epics import adcore
+
+from ._andor_controller import Andor2Controller
+from ._andor_io import Andor2DriverIO
+
+
+class Andor2Detector(adcore.AreaDetector[Andor2Controller]):
+    """
+    Andor 2 area detector device (CCD detector 56fps with full chip readout).
+    Andor model:DU897_BV.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        path_provider: PathProvider,
+        drv_suffix="cam1:",
+        writer_cls: type[adcore.ADWriter] = adcore.ADHDFWriter,
+        fileio_suffix: str | None = None,
+        name: str = "",
+        config_sigs: Sequence[SignalR] = (),
+        plugins: dict[str, adcore.NDPluginBaseIO] | None = None,
+    ):
+        driver = Andor2DriverIO(prefix + drv_suffix)
+        controller = Andor2Controller(driver)
+
+        writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            dataset_source=driver,
+            fileio_suffix=fileio_suffix,
+            plugins=plugins,
+        )
+
+        super().__init__(
+            controller=controller,
+            writer=writer,
+            plugins=plugins,
+            name=name,
+            config_sigs=config_sigs,
+        )

ophyd_async/epics/adandor/_andor_controller.py

@@ -0,0 +1,49 @@
+import asyncio
+
+from ophyd_async.core import (
+    DetectorTrigger,
+    TriggerInfo,
+)
+from ophyd_async.epics import adcore
+
+from ._andor_io import Andor2DriverIO, Andor2TriggerMode
+
+_MIN_DEAD_TIME = 0.1
+_MAX_NUM_IMAGE = 999_999
+
+
+class Andor2Controller(adcore.ADBaseController[Andor2DriverIO]):
+    def __init__(
+        self,
+        driver: Andor2DriverIO,
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+    ) -> None:
+        super().__init__(driver, good_states=good_states)
+
+    def get_deadtime(self, exposure: float | None) -> float:
+        return _MIN_DEAD_TIME + (exposure or 0)
+
+    async def prepare(self, trigger_info: TriggerInfo):
+        await self.set_exposure_time_and_acquire_period_if_supplied(
+            trigger_info.livetime
+        )
+        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
+            ),
+            self.driver.image_mode.set(adcore.ImageMode.MULTIPLE),
+        )
+
+    def _get_trigger_mode(self, trigger: DetectorTrigger) -> Andor2TriggerMode:
+        supported_trigger_types = {
+            DetectorTrigger.INTERNAL: Andor2TriggerMode.INTERNAL,
+            DetectorTrigger.EDGE_TRIGGER: Andor2TriggerMode.EXT_TRIGGER,
+        }
+        if trigger not in supported_trigger_types:
+            raise ValueError(
+                f"{self.__class__.__name__} only supports the following trigger "
+                f"types: {supported_trigger_types} but was asked to "
+                f"use {trigger}"
+            )
+        return supported_trigger_types[trigger]

ophyd_async/epics/adandor/_andor_io.py

@@ -0,0 +1,36 @@
+from ophyd_async.core import StrictEnum, SubsetEnum
+from ophyd_async.epics.adcore import ADBaseIO
+from ophyd_async.epics.core import (
+    epics_signal_r,
+    epics_signal_rw,
+)
+
+
+class Andor2TriggerMode(StrictEnum):
+    INTERNAL = "Internal"
+    EXT_TRIGGER = "External"
+    EXT_START = "External Start"
+    EXT_EXPOSURE = "External Exposure"
+    EXT_FVP = "External FVP"
+    SOFTWARE = "Software"
+
+
+class Andor2DataType(SubsetEnum):
+    UINT16 = "UInt16"
+    UINT32 = "UInt32"
+    FLOAT32 = "Float32"
+    FLOAT64 = "Float64"
+
+
+class Andor2DriverIO(ADBaseIO):
+    """
+    Epics pv for andor model:DU897_BV as deployed on p99
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        super().__init__(prefix, name=name)
+        self.trigger_mode = epics_signal_rw(Andor2TriggerMode, prefix + "TriggerMode")
+        self.data_type = epics_signal_r(Andor2DataType, prefix + "DataType_RBV")
+        self.andor_accumulate_period = epics_signal_r(
+            float, prefix + "AndorAccumulatePeriod_RBV"
+        )

ophyd_async/epics/adaravis/__init__.py

@@ -1,9 +1,11 @@
 from ._aravis import AravisDetector
 from ._aravis_controller import AravisController
-from ._aravis_io import AravisDriverIO
+from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
 
 __all__ = [
     "AravisDetector",
     "AravisController",
     "AravisDriverIO",
+    "AravisTriggerMode",
+    "AravisTriggerSource",
 ]