ophyd-async 0.5.1__tar.gz → 0.5.2__tar.gz

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.5.1
+Version: 0.5.2
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/docs/examples/foo_detector.py

@@ -69,7 +69,7 @@ class FooDetector(StandardDetector, HasHints):
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                adcore.ADBaseShapeProvider(self.drv),
+                adcore.ADBaseDatasetDescriber(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/pyproject.toml

@@ -139,7 +139,7 @@ commands =
 
 
 [tool.ruff]
-src = ["src", "tests"]
+src = ["src", "tests", "system_tests"]
 line-length = 88
 lint.select = [
     "C4",   # flake8-comprehensions - https://beta.ruff.rs/docs/rules/#flake8-comprehensions-c4

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.1'
-__version_tuple__ = version_tuple = (0, 5, 1)
+__version__ = version = '0.5.2'
+__version_tuple__ = version_tuple = (0, 5, 2)

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async/core/__init__.py

@@ -33,11 +33,11 @@ from ._protocol import AsyncConfigurable, AsyncReadable, AsyncStageable
 from ._providers import (
     AutoIncrementFilenameProvider,
     AutoIncrementingPathProvider,
+    DatasetDescriber,
     FilenameProvider,
     NameProvider,
     PathInfo,
     PathProvider,
-    ShapeProvider,
     StaticFilenameProvider,
     StaticPathProvider,
     UUIDFilenameProvider,
@@ -63,7 +63,7 @@ from ._signal import (
 )
 from ._signal_backend import RuntimeSubsetEnum, SignalBackend, SubsetEnum
 from ._soft_signal_backend import SignalMetadata, SoftSignalBackend
-from ._status import AsyncStatus, WatchableAsyncStatus
+from ._status import AsyncStatus, WatchableAsyncStatus, completed_status
 from ._utils import (
     DEFAULT_TIMEOUT,
     CalculatableTimeout,
@@ -117,7 +117,7 @@ __all__ = [
     "NameProvider",
     "PathInfo",
     "PathProvider",
-    "ShapeProvider",
+    "DatasetDescriber",
     "StaticFilenameProvider",
     "StaticPathProvider",
     "UUIDFilenameProvider",
@@ -158,4 +158,5 @@ __all__ = [
     "get_unique",
     "in_micros",
     "wait_for_connection",
+    "completed_status",
 ]

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async/core/_providers.py

@@ -211,7 +211,11 @@ class NameProvider(Protocol):
         """Get the name to be used as a data_key in the descriptor document"""
 
 
-class ShapeProvider(Protocol):
+class DatasetDescriber(Protocol):
     @abstractmethod
-    async def __call__(self) -> tuple:
+    async def np_datatype(self) -> str:
+        """Represents the numpy datatype"""
+
+    @abstractmethod
+    async def shape(self) -> tuple[int, ...]:
         """Get the shape of the data collection"""

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async/core/_signal.py

@@ -547,7 +547,7 @@ async def wait_for_value(
 
 
 async def set_and_wait_for_other_value(
-    set_signal: SignalRW[T],
+    set_signal: SignalW[T],
     set_value: T,
     read_signal: SignalR[S],
     read_value: S,

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async/core/_status.py

@@ -4,7 +4,16 @@ import asyncio
 import functools
 import time
 from dataclasses import asdict, replace
-from typing import AsyncIterator, Awaitable, Callable, Generic, Type, TypeVar, cast
+from typing import (
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Generic,
+    Optional,
+    Type,
+    TypeVar,
+    cast,
+)
 
 from bluesky.protocols import Status
 
@@ -132,3 +141,10 @@ class WatchableAsyncStatus(AsyncStatusBase, Generic[T]):
             return cls(f(*args, **kwargs))
 
         return cast(Callable[P, WAS], wrap_f)
+
+
+@AsyncStatus.wrap
+async def completed_status(exception: Optional[Exception] = None):
+    if exception:
+        raise exception
+    return None

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async/epics/adaravis/_aravis.py

@@ -37,7 +37,7 @@ class AravisDetector(StandardDetector, HasHints):
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                adcore.ADBaseShapeProvider(self.drv),
+                adcore.ADBaseDatasetDescriber(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async/epics/adcore/__init__.py

@@ -7,7 +7,7 @@ from ._core_io import (
 )
 from ._core_logic import (
     DEFAULT_GOOD_STATES,
-    ADBaseShapeProvider,
+    ADBaseDatasetDescriber,
     set_exposure_time_and_acquire_period_if_supplied,
     start_acquiring_driver_and_ensure_status,
 )
@@ -31,7 +31,7 @@ __all__ = [
     "NDFileHDFIO",
     "NDPluginStatsIO",
     "DEFAULT_GOOD_STATES",
-    "ADBaseShapeProvider",
+    "ADBaseDatasetDescriber",
     "set_exposure_time_and_acquire_period_if_supplied",
     "start_acquiring_driver_and_ensure_status",
     "ADHDFWriter",

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async/epics/adcore/_core_logic.py

@@ -4,10 +4,11 @@ from typing import FrozenSet, Set
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
+    DatasetDescriber,
     DetectorControl,
-    ShapeProvider,
     set_and_wait_for_value,
 )
+from ophyd_async.epics.adcore._utils import convert_ad_dtype_to_np
 
 from ._core_io import ADBaseIO, DetectorState
 
@@ -18,15 +19,17 @@ DEFAULT_GOOD_STATES: FrozenSet[DetectorState] = frozenset(
 )
 
 
-class ADBaseShapeProvider(ShapeProvider):
+class ADBaseDatasetDescriber(DatasetDescriber):
     def __init__(self, driver: ADBaseIO) -> None:
         self._driver = driver
 
-    async def __call__(self) -> tuple:
+    async def np_datatype(self) -> str:
+        return convert_ad_dtype_to_np(await self._driver.data_type.get_value())
+
+    async def shape(self) -> tuple[int, int]:
         shape = await asyncio.gather(
             self._driver.array_size_y.get_value(),
             self._driver.array_size_x.get_value(),
-            self._driver.data_type.get_value(),
         )
         return shape
 

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async/epics/adcore/_hdf_writer.py

@@ -8,12 +8,12 @@ from bluesky.protocols import DataKey, Hints, StreamAsset
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
+    DatasetDescriber,
     DetectorWriter,
     HDFDataset,
     HDFFile,
     NameProvider,
     PathProvider,
-    ShapeProvider,
     observe_value,
     set_and_wait_for_value,
     wait_for_value,
@@ -22,7 +22,6 @@ from ophyd_async.core import (
 from ._core_io import NDArrayBaseIO, NDFileHDFIO
 from ._utils import (
     FileWriteMode,
-    convert_ad_dtype_to_np,
     convert_param_dtype_to_np,
     convert_pv_dtype_to_np,
 )
@@ -34,13 +33,13 @@ class ADHDFWriter(DetectorWriter):
         hdf: NDFileHDFIO,
         path_provider: PathProvider,
         name_provider: NameProvider,
-        shape_provider: ShapeProvider,
+        dataset_describer: DatasetDescriber,
         *plugins: NDArrayBaseIO,
     ) -> None:
         self.hdf = hdf
         self._path_provider = path_provider
         self._name_provider = name_provider
-        self._shape_provider = shape_provider
+        self._dataset_describer = dataset_describer
 
         self._plugins = plugins
         self._capture_status: Optional[AsyncStatus] = None
@@ -79,23 +78,18 @@ class ADHDFWriter(DetectorWriter):
         # 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)
         name = self._name_provider()
-        detector_shape = tuple(await self._shape_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 ()
-        frame_shape = detector_shape[:-1] if len(detector_shape) > 0 else []
-        dtype_numpy = (
-            convert_ad_dtype_to_np(detector_shape[-1])
-            if len(detector_shape) > 0
-            else ""
-        )
 
         # Add the main data
         self._datasets = [
             HDFDataset(
                 data_key=name,
                 dataset="/entry/data/data",
-                shape=frame_shape,
-                dtype_numpy=dtype_numpy,
+                shape=detector_shape,
+                dtype_numpy=np_dtype,
                 multiplier=multiplier,
             )
         ]

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async/epics/adkinetix/_kinetix.py

@@ -33,7 +33,7 @@ class KinetixDetector(StandardDetector, HasHints):
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                adcore.ADBaseShapeProvider(self.drv),
+                adcore.ADBaseDatasetDescriber(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async/epics/adpilatus/_pilatus.py

@@ -47,7 +47,7 @@ class PilatusDetector(StandardDetector):
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                adcore.ADBaseShapeProvider(self.drv),
+                adcore.ADBaseDatasetDescriber(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async/epics/adsimdetector/_sim.py

@@ -27,7 +27,7 @@ class SimDetector(StandardDetector):
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                adcore.ADBaseShapeProvider(self.drv),
+                adcore.ADBaseDatasetDescriber(self.drv),
             ),
             config_sigs=config_sigs,
             name=name,

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async/epics/advimba/_vimba.py

@@ -32,7 +32,7 @@ class VimbaDetector(StandardDetector, HasHints):
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                adcore.ADBaseShapeProvider(self.drv),
+                adcore.ADBaseDatasetDescriber(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

ophyd_async-0.5.2/src/ophyd_async/epics/eiger/__init__.py

@@ -0,0 +1,5 @@
+from ._eiger import EigerDetector, EigerTriggerInfo
+from ._eiger_controller import EigerController
+from ._eiger_io import EigerDriverIO
+
+__all__ = ["EigerDetector", "EigerController", "EigerDriverIO", "EigerTriggerInfo"]

ophyd_async-0.5.2/src/ophyd_async/epics/eiger/_eiger.py

@@ -0,0 +1,43 @@
+from pydantic import Field
+
+from ophyd_async.core import AsyncStatus, PathProvider, StandardDetector
+from ophyd_async.core._detector import TriggerInfo
+
+from ._eiger_controller import EigerController
+from ._eiger_io import EigerDriverIO
+from ._odin_io import Odin, OdinWriter
+
+
+class EigerTriggerInfo(TriggerInfo):
+    energy_ev: float = Field(gt=0)
+
+
+class EigerDetector(StandardDetector):
+    """
+    Ophyd-async implementation of an Eiger Detector.
+    """
+
+    _controller: EigerController
+    _writer: Odin
+
+    def __init__(
+        self,
+        prefix: str,
+        path_provider: PathProvider,
+        drv_suffix="-EA-EIGER-01:",
+        hdf_suffix="-EA-ODIN-01:",
+        name="",
+    ):
+        self.drv = EigerDriverIO(prefix + drv_suffix)
+        self.odin = Odin(prefix + hdf_suffix + "FP:")
+
+        super().__init__(
+            EigerController(self.drv),
+            OdinWriter(path_provider, lambda: self.name, self.odin),
+            name=name,
+        )
+
+    @AsyncStatus.wrap
+    async def prepare(self, value: EigerTriggerInfo) -> None:
+        await self._controller.set_energy(value.energy_ev)
+        await super().prepare(value)

ophyd_async-0.5.2/src/ophyd_async/epics/eiger/_eiger_controller.py

@@ -0,0 +1,66 @@
+import asyncio
+from typing import Optional
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    DetectorControl,
+    DetectorTrigger,
+    set_and_wait_for_other_value,
+)
+
+from ._eiger_io import EigerDriverIO, EigerTriggerMode
+
+EIGER_TRIGGER_MODE_MAP = {
+    DetectorTrigger.internal: EigerTriggerMode.internal,
+    DetectorTrigger.constant_gate: EigerTriggerMode.gate,
+    DetectorTrigger.variable_gate: EigerTriggerMode.gate,
+    DetectorTrigger.edge_trigger: EigerTriggerMode.edge,
+}
+
+
+class EigerController(DetectorControl):
+    def __init__(
+        self,
+        driver: EigerDriverIO,
+    ) -> None:
+        self._drv = driver
+
+    def get_deadtime(self, exposure: float) -> float:
+        # See https://media.dectris.com/filer_public/30/14/3014704e-5f3b-43ba-8ccf-8ef720e60d2a/240202_usermanual_eiger2.pdf
+        return 0.0001
+
+    async def set_energy(self, energy: float, tolerance: float = 0.1):
+        """Changing photon energy takes some time so only do so if the current energy is
+        outside the tolerance."""
+        current_energy = await self._drv.photon_energy.get_value()
+        if abs(current_energy - energy) > tolerance:
+            await self._drv.photon_energy.set(energy)
+
+    @AsyncStatus.wrap
+    async def arm(
+        self,
+        num: int,
+        trigger: DetectorTrigger = DetectorTrigger.internal,
+        exposure: Optional[float] = None,
+    ):
+        coros = [
+            self._drv.trigger_mode.set(EIGER_TRIGGER_MODE_MAP[trigger].value),
+            self._drv.num_images.set(num),
+        ]
+        if exposure is not None:
+            coros.extend(
+                [
+                    self._drv.acquire_time.set(exposure),
+                    self._drv.acquire_period.set(exposure),
+                ]
+            )
+        await asyncio.gather(*coros)
+
+        # TODO: Detector state should be an enum see https://github.com/DiamondLightSource/eiger-fastcs/issues/43
+        await set_and_wait_for_other_value(
+            self._drv.arm, 1, self._drv.state, "ready", timeout=DEFAULT_TIMEOUT
+        )
+
+    async def disarm(self):
+        await self._drv.disarm.set(1)

ophyd_async-0.5.2/src/ophyd_async/epics/eiger/_eiger_io.py

@@ -0,0 +1,42 @@
+from enum import Enum
+
+from ophyd_async.core import Device
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw_rbv, epics_signal_w
+
+
+class EigerTriggerMode(str, Enum):
+    internal = "ints"
+    edge = "exts"
+    gate = "exte"
+
+
+class EigerDriverIO(Device):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.bit_depth = epics_signal_r(int, f"{prefix}BitDepthReadout")
+        self.stale_parameters = epics_signal_r(bool, f"{prefix}StaleParameters")
+        self.state = epics_signal_r(str, f"{prefix}DetectorState")
+        self.roi_mode = epics_signal_rw_rbv(str, f"{prefix}RoiMode")
+
+        self.acquire_time = epics_signal_rw_rbv(float, f"{prefix}CountTime")
+        self.acquire_period = epics_signal_rw_rbv(float, f"{prefix}FrameTime")
+
+        self.num_images = epics_signal_rw_rbv(int, f"{prefix}Nimages")
+        self.num_triggers = epics_signal_rw_rbv(int, f"{prefix}Ntrigger")
+
+        # TODO: Should be EigerTriggerMode enum, see https://github.com/DiamondLightSource/eiger-fastcs/issues/43
+        self.trigger_mode = epics_signal_rw_rbv(str, f"{prefix}TriggerMode")
+
+        self.arm = epics_signal_w(int, f"{prefix}Arm")
+        self.disarm = epics_signal_w(int, f"{prefix}Disarm")
+        self.abort = epics_signal_w(int, f"{prefix}Abort")
+
+        self.beam_centre_x = epics_signal_rw_rbv(float, f"{prefix}BeamCenterX")
+        self.beam_centre_y = epics_signal_rw_rbv(float, f"{prefix}BeamCenterY")
+
+        self.det_distance = epics_signal_rw_rbv(float, f"{prefix}DetectorDistance")
+        self.omega_start = epics_signal_rw_rbv(float, f"{prefix}OmegaStart")
+        self.omega_increment = epics_signal_rw_rbv(float, f"{prefix}OmegaIncrement")
+
+        self.photon_energy = epics_signal_rw_rbv(float, f"{prefix}PhotonEnergy")
+
+        super().__init__(name)

ophyd_async-0.5.2/src/ophyd_async/epics/eiger/_odin_io.py

@@ -0,0 +1,125 @@
+import asyncio
+from enum import Enum
+from typing import AsyncGenerator, AsyncIterator, Dict
+
+from bluesky.protocols import StreamAsset
+from event_model.documents.event_descriptor import DataKey
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    DetectorWriter,
+    Device,
+    DeviceVector,
+    NameProvider,
+    PathProvider,
+    observe_value,
+    set_and_wait_for_value,
+)
+from ophyd_async.epics.signal import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_rw_rbv,
+)
+
+
+class Writing(str, Enum):
+    ON = "ON"
+    OFF = "OFF"
+
+
+class OdinNode(Device):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.writing = epics_signal_r(Writing, f"{prefix}HDF:Writing")
+        self.connected = epics_signal_r(bool, f"{prefix}Connected")
+
+        super().__init__(name)
+
+
+class Odin(Device):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.nodes = DeviceVector({i: OdinNode(f"{prefix}FP{i}:") for i in range(4)})
+
+        self.capture = epics_signal_rw(
+            Writing, f"{prefix}Writing", f"{prefix}ConfigHdfWrite"
+        )
+        self.num_captured = epics_signal_r(int, f"{prefix}FramesWritten")
+        self.num_to_capture = epics_signal_rw_rbv(int, f"{prefix}ConfigHdfFrames")
+
+        self.start_timeout = epics_signal_rw_rbv(int, f"{prefix}TimeoutTimerPeriod")
+
+        self.image_height = epics_signal_rw_rbv(int, f"{prefix}DatasetDataDims0")
+        self.image_width = epics_signal_rw_rbv(int, f"{prefix}DatasetDataDims1")
+
+        self.num_row_chunks = epics_signal_rw_rbv(int, f"{prefix}DatasetDataChunks1")
+        self.num_col_chunks = epics_signal_rw_rbv(int, f"{prefix}DatasetDataChunks2")
+
+        self.file_path = epics_signal_rw_rbv(str, f"{prefix}ConfigHdfFilePath")
+        self.file_name = epics_signal_rw_rbv(str, f"{prefix}ConfigHdfFilePrefix")
+
+        self.acquisition_id = epics_signal_rw_rbv(
+            str, f"{prefix}ConfigHdfAcquisitionId"
+        )
+
+        self.data_type = epics_signal_rw_rbv(str, f"{prefix}DatasetDataDatatype")
+
+        super().__init__(name)
+
+
+class OdinWriter(DetectorWriter):
+    def __init__(
+        self,
+        path_provider: PathProvider,
+        name_provider: NameProvider,
+        odin_driver: Odin,
+    ) -> None:
+        self._drv = odin_driver
+        self._path_provider = path_provider
+        self._name_provider = name_provider
+        super().__init__()
+
+    async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
+        info = self._path_provider(device_name=self._name_provider())
+
+        await asyncio.gather(
+            self._drv.file_path.set(str(info.directory_path)),
+            self._drv.file_name.set(info.filename),
+            self._drv.data_type.set(
+                "uint16"
+            ),  # TODO: Get from eiger https://github.com/bluesky/ophyd-async/issues/529
+            self._drv.num_to_capture.set(0),
+        )
+
+        await self._drv.capture.set(Writing.ON)
+
+        return await self._describe()
+
+    async def _describe(self) -> Dict[str, DataKey]:
+        data_shape = await asyncio.gather(
+            self._drv.image_height.get_value(), self._drv.image_width.get_value()
+        )
+
+        return {
+            "data": DataKey(
+                source=self._drv.file_name.source,
+                shape=data_shape,
+                dtype="array",
+                dtype_numpy="<u2",  # TODO: Use correct type based on eiger https://github.com/bluesky/ophyd-async/issues/529
+                external="STREAM:",
+            )
+        }
+
+    async def observe_indices_written(
+        self, timeout=DEFAULT_TIMEOUT
+    ) -> AsyncGenerator[int, None]:
+        async for num_captured in observe_value(self._drv.num_captured, timeout):
+            yield num_captured
+
+    async def get_indices_written(self) -> int:
+        return await self._drv.num_captured.get_value()
+
+    def collect_stream_docs(self, indices_written: int) -> AsyncIterator[StreamAsset]:
+        # TODO: Correctly return stream https://github.com/bluesky/ophyd-async/issues/530
+        raise NotImplementedError()
+
+    async def close(self) -> None:
+        await set_and_wait_for_value(self._drv.capture, Writing.OFF)

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async/epics/motor.py

@@ -119,7 +119,7 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         )
 
         await self.set(fly_prepared_position)
-        await self.velocity.set(fly_velocity)
+        await self.velocity.set(abs(fly_velocity))
 
     @AsyncStatus.wrap
     async def kickoff(self):

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.5.1
+Version: 0.5.2
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License

{ophyd_async-0.5.1 → ophyd_async-0.5.2}/src/ophyd_async.egg-info/SOURCES.txt

@@ -117,6 +117,11 @@ src/ophyd_async/epics/demo/_mover.py
 src/ophyd_async/epics/demo/_sensor.py
 src/ophyd_async/epics/demo/mover.db
 src/ophyd_async/epics/demo/sensor.db
+src/ophyd_async/epics/eiger/__init__.py
+src/ophyd_async/epics/eiger/_eiger.py
+src/ophyd_async/epics/eiger/_eiger_controller.py
+src/ophyd_async/epics/eiger/_eiger_io.py
+src/ophyd_async/epics/eiger/_odin_io.py
 src/ophyd_async/epics/pvi/__init__.py
 src/ophyd_async/epics/pvi/_pvi.py
 src/ophyd_async/epics/signal/__init__.py
@@ -149,6 +154,9 @@ src/ophyd_async/sim/demo/_pattern_detector/_pattern_detector_writer.py
 src/ophyd_async/sim/demo/_pattern_detector/_pattern_generator.py
 src/ophyd_async/sim/testing/__init__.py
 src/ophyd_async/tango/__init__.py
+system_tests/epics/eiger/README.md
+system_tests/epics/eiger/start_iocs_and_run_tests.sh
+system_tests/epics/eiger/test_eiger_system.py
 tests/conftest.py
 tests/test_cli.py
 tests/core/test_device.py
@@ -180,6 +188,9 @@ tests/epics/adsimdetector/test_adsim_controller.py
 tests/epics/adsimdetector/test_sim.py
 tests/epics/advimba/test_vimba.py
 tests/epics/demo/test_demo.py
+tests/epics/eiger/test_eiger_controller.py
+tests/epics/eiger/test_eiger_detector.py
+tests/epics/eiger/test_odin_io.py
 tests/epics/pvi/test_pvi.py
 tests/epics/signal/test_common.py
 tests/epics/signal/test_records.db

ophyd_async-0.5.2/system_tests/epics/eiger/README.md

@@ -0,0 +1,8 @@
+This system test runs against the eiger tickit sim. To run it:
+
+0. Ensure you have disabled SELinux (https://dev-portal.diamond.ac.uk/guide/containers/tutorials/podman/#enable-use-of-vscode-features)
+1. Run `podman run --rm -it -v /dev/shm:/dev/shm -v /tmp:/tmp --net=host ghcr.io/diamondlightsource/eiger-detector-runtime:1.16.0beta5` this will bring up the simulator itself.
+2. In a separate terminal load a python environment with `ophyd-async` in it
+3. `cd system_tests/epics/eiger` and `./start_iocs_and_run_tests.sh`
+
+

ophyd_async-0.5.2/system_tests/epics/eiger/start_iocs_and_run_tests.sh

@@ -0,0 +1,25 @@
+
+host=$(hostname | tr -cd '[:digit:]')
+export eiger_ioc=EIGER-$host
+export odin_ioc=ODIN-$host
+
+mkdir /tmp/opi
+
+if command -v docker &> /dev/null; then
+    DOCKER_COMMAND=docker
+else
+    DOCKER_COMMAND=podman
+fi
+
+echo "Using $DOCKER_COMMAND" 
+
+$DOCKER_COMMAND run --rm --name=$eiger_ioc -dt --net=host -v /tmp/opi/:/epics/opi ghcr.io/diamondlightsource/eiger-fastcs:0.1.0beta5 ioc $eiger_ioc
+
+$DOCKER_COMMAND run --rm --name=$odin_ioc -dt --net=host -v /tmp/opi/:/epics/opi ghcr.io/diamondlightsource/odin-fastcs:0.2.0beta2 ioc $odin_ioc
+
+sleep 1
+
+pytest .
+
+podman kill $eiger_ioc
+podman kill $odin_ioc