ophyd-async 0.5.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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.dist-info → ophyd_async-0.5.2.dist-info}/METADATA

@@ -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.dist-info → ophyd_async-0.5.2.dist-info}/RECORD

@@ -1,7 +1,7 @@
 ophyd_async/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
 ophyd_async/__main__.py,sha256=G-Zcv_G9zK7Nhx6o5L5w-wyhMxdl_WgyMELu8IMFqAE,328
-ophyd_async/_version.py,sha256=8W5N0WKS0YIWUpfry5TouisDYjsMUIZ7Vc0crGGGQQU,411
-ophyd_async/core/__init__.py,sha256=avd3aVLO3CPq09h0cKon5QMew7RvtbWtmo2rOagFdkA,3745
+ophyd_async/_version.py,sha256=9wH2PDsTkkxdqSU9YziEjDTHYLEcKPSYr6RofNSEaJk,411
+ophyd_async/core/__init__.py,sha256=Ci9J1fxdaUHT45gRQNxzNEqEdbI6xBseSUrFcOIhhlg,3793
 ophyd_async/core/_detector.py,sha256=n5MKTVAzTHVUWH5ZMxcSq7u4qP2nAGemaPyGrPAZQq4,11811
 ophyd_async/core/_device.py,sha256=DDdRujYLCDSuGDB0gqElkzI0qEGb3sMlFP6FgmH2u3A,7554
 ophyd_async/core/_device_save_loader.py,sha256=pTom5EOFa9_5Z3bV37zOnbGx2ujWIOl_D9PVYhpY1FY,8232
@@ -11,38 +11,38 @@ ophyd_async/core/_log.py,sha256=Hsk2Iwx81n3HpxNR30xGTnLJh_lPGd_CGy2MI3OGpWs,3588
 ophyd_async/core/_mock_signal_backend.py,sha256=M_I2LxxJrJmBAbmILjVoAR6E2U8K2UswvHGiHluMqHc,2799
 ophyd_async/core/_mock_signal_utils.py,sha256=LTrmjQTqvP4yY2bsaOmfLNJAegD850_BNZ6Y8uY5XPQ,4717
 ophyd_async/core/_protocol.py,sha256=aRoqet0ThyVK_wrULh4k_StnpeHnNhXc0YffWdRJNZw,3391
-ophyd_async/core/_providers.py,sha256=gCkzLcoXYy2as4CAlLzoA6RzvrYAVIamgRpLsV708ro,7033
+ophyd_async/core/_providers.py,sha256=unFdSAm5Hz4B6s3WSSGRCZo0l9FYMbJwI7DOBIAI_n4,7148
 ophyd_async/core/_readable.py,sha256=WayM35JOJj732-YgvGsjUSlCZwZ_zq1zbAmk-1U0uwU,8998
-ophyd_async/core/_signal.py,sha256=38whsWlm4Wo7r7Beh_i0OJ4iqtJNR5TIGtS7_uZ736Y,19610
+ophyd_async/core/_signal.py,sha256=MzB2KGHogo2mKeSHRkqyAiELv22xnnkPuroXU-RuMWI,19609
 ophyd_async/core/_signal_backend.py,sha256=-Vze8-57W0jpcC4gq4P4rZpXXJvi2qrbu0A8AjqA594,2638
 ophyd_async/core/_soft_signal_backend.py,sha256=Z4LiADd9xKrxhhPOx8q5xq4yrJRdJbfuKeB0o2wBjCk,6653
-ophyd_async/core/_status.py,sha256=mjzoGyaMFCfQLIWNKv_VcuCz9unZ9Gs3nCkaa1dTne8,4334
+ophyd_async/core/_status.py,sha256=lnhy-gt2XV8ZE0EuzrDddHCEYuoquBI5ovTOJxwtSYk,4526
 ophyd_async/core/_utils.py,sha256=3oZcXNqAUHX4ZWMBH5gSuK6cFWEhSkZ9GSDYv0pf8jc,5783
 ophyd_async/epics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/epics/motor.py,sha256=na1WmomnPsFVYTMJwL0ViFjay1UaepeXprKKAJc7pdk,8771
+ophyd_async/epics/motor.py,sha256=x9ysc5tLqJiVYYqyhEd5ornEYQ5aQamg7pB4e5ygwR4,8776
 ophyd_async/epics/adaravis/__init__.py,sha256=u979_9nQTYB0TvDOTXFN4qMrbDP8-xQFfXYMGzLVBo4,207
-ophyd_async/epics/adaravis/_aravis.py,sha256=f2xiKQr1AcX6R-NjaMMgfXBfbHIsYfDGp4-CyHKIT6I,1949
+ophyd_async/epics/adaravis/_aravis.py,sha256=XBuLQBZYj2tptY39bVzXjl6t-ZpPwqrUOwpR54l-hSo,1952
 ophyd_async/epics/adaravis/_aravis_controller.py,sha256=SzyajBNoqvBOUVtNE0t8ghffY2pYP8U99XgQ-4u2pVI,2635
 ophyd_async/epics/adaravis/_aravis_io.py,sha256=GY2thPUJ-6821GvfZTBLoX8g9d-U1YgyoXe3wYRVw-g,1554
-ophyd_async/epics/adcore/__init__.py,sha256=krbCmdOoW2eIbFCztDe1MAlsIyO6vHEcFwkH8DPmy98,1080
+ophyd_async/epics/adcore/__init__.py,sha256=3wMOyFGaq1X61LqK4iY4pq-m_BjhOgYZD2-mNCAjpzk,1086
 ophyd_async/epics/adcore/_core_io.py,sha256=F4TlnWW0ntAekZlr8qxCpKhFyEThSgjYQCOoKOg4DN8,5918
-ophyd_async/epics/adcore/_core_logic.py,sha256=XpM1t2kqof9q_7fkKlFPKP2vT0DoLgc0drj7cTUHsbU,3421
-ophyd_async/epics/adcore/_hdf_writer.py,sha256=YBQRQJN6Ep62SaAz7zW_9pX7IPwsmqiuNxMuLQwV8sA,6870
+ophyd_async/epics/adcore/_core_logic.py,sha256=2iAF64HLRGxg_By-7feGP8eUtujsXYzOhysP0_SuMTM,3577
+ophyd_async/epics/adcore/_hdf_writer.py,sha256=fUvduWqw9aNNwroH5Wutq_8Q8c0Aqb0vMIs2r5ouYjM,6697
 ophyd_async/epics/adcore/_single_trigger.py,sha256=LGhAZV0GoRwRTNFQmgLpkfq73HsiMCu20JKYGOzxt0I,1159
 ophyd_async/epics/adcore/_utils.py,sha256=A5AUQIfdbzLgF7A4V-1TSoPD6Kvgs4sbZBGOV7zb8SY,3909
 ophyd_async/epics/adkinetix/__init__.py,sha256=QEft12PURied6LRzjw-NhUmngjAm1XNA3k-5o5aMXDQ,216
-ophyd_async/epics/adkinetix/_kinetix.py,sha256=Xnt54pqxWArcBIZ8RdLMXfMX0kCDCInJQp48MMx6Gmw,1181
+ophyd_async/epics/adkinetix/_kinetix.py,sha256=JsQVc4d7lRCnVObJlM775hHLfp3rYRSRgOoIyRvrSek,1184
 ophyd_async/epics/adkinetix/_kinetix_controller.py,sha256=jHe6MSfqCOdzw0jQ5L6cYq55I0TD5Bso2ZGOZmv1j3Q,1504
 ophyd_async/epics/adkinetix/_kinetix_io.py,sha256=AbCoYliAobU3I6z3NaswQnExwGTgV458zF3uwkBEQPc,893
 ophyd_async/epics/adpilatus/__init__.py,sha256=daimScOCCMHR2eb8VbezHOcGOkd6uIRZQiyeTQsaAx4,308
-ophyd_async/epics/adpilatus/_pilatus.py,sha256=NEim_ZROa-B0uYXYgLiiAIDzqzl-IjSCqpOrosOvcHk,1748
+ophyd_async/epics/adpilatus/_pilatus.py,sha256=AbWfxEds8ESB73kRXz56FzRPYqy67Ue0m11HRaNUqZY,1751
 ophyd_async/epics/adpilatus/_pilatus_controller.py,sha256=1GfzcnhwLam8fAhf889lPz2rrn9mWDaGO3BIELP3R50,2450
 ophyd_async/epics/adpilatus/_pilatus_io.py,sha256=WB_N2RRpcFCFI6i57PRqjIdpK6hzLpWxn71cWUHUZnc,722
 ophyd_async/epics/adsimdetector/__init__.py,sha256=t3crUgTEvVJGI8o6FsfN42k0A-l4v9ZBwXIYtixoE-M,128
-ophyd_async/epics/adsimdetector/_sim.py,sha256=nk4Xj_j_WeKk1FJov-Zo2W7NHnHcBUDbIzranHUpngI,863
+ophyd_async/epics/adsimdetector/_sim.py,sha256=ijN7K-5prJuzFD3DoNtQ8JujnvCG8_UMwYxMCGSOHCE,866
 ophyd_async/epics/adsimdetector/_sim_controller.py,sha256=v0GrMXg7U1PUvLKW8zmx8zrunk_MfFt7GbckbVlnUys,1494
 ophyd_async/epics/advimba/__init__.py,sha256=GSnFWGPNJsCJZ-Tgyv-L38Smwzp2bWC64U_4uD2TLvs,198
-ophyd_async/epics/advimba/_vimba.py,sha256=qDLP5KcI0PZGgpMVmzkfxfgIt3hoiqpvNlRGrtEZxl4,1122
+ophyd_async/epics/advimba/_vimba.py,sha256=E_RJ0uJQt-RWAY7uFTNkHaOdGYS5sa7ZbRgAe6ngXTA,1125
 ophyd_async/epics/advimba/_vimba_controller.py,sha256=JvQ4M2IdixDI6TXNHSqUs0sX3ncgosecuLmT8bYhU9w,2003
 ophyd_async/epics/advimba/_vimba_io.py,sha256=nf1BdIWey4RR7KuqyZhH6X5yB8Msg0oOtkVLOuwn6Uc,1843
 ophyd_async/epics/demo/__init__.py,sha256=wCrgemEo-zR4TTvaqCKnQ-AIUHorotV5jhftbq1tXz0,1368
@@ -50,6 +50,11 @@ ophyd_async/epics/demo/_mover.py,sha256=7GEmF-mgN0qxiHUE3Tgboh0p9S5AuPBYR-pFeg5Q
 ophyd_async/epics/demo/_sensor.py,sha256=8OyFAsB3EXMzrQreOIg_TGHrseUtI5rxXpfwwUaC76I,1165
 ophyd_async/epics/demo/mover.db,sha256=RFz0rxZue689Wh1sWTZwWeFMUrH04ttPq2u5xJH_Fp4,998
 ophyd_async/epics/demo/sensor.db,sha256=AVtiydrdtwAz2EFurO2Ult9SSRtre3r0akOBbL98LT0,554
+ophyd_async/epics/eiger/__init__.py,sha256=b3Tt4pVLk23Giyj50R4e94d2MxWDDmNHWhWwNq2jlaw,221
+ophyd_async/epics/eiger/_eiger.py,sha256=8sTPz_pBpDyJI_VUGxVb8WtfoTYvsAi3stofaPbcgt4,1155
+ophyd_async/epics/eiger/_eiger_controller.py,sha256=B4CpwWXde71C3BWcSBwlZbt3Fnk9yAT9BZj4J4DeDoU,2139
+ophyd_async/epics/eiger/_eiger_io.py,sha256=MlvLWEZ-n-Lf7y9e_WVoPFdw5YoHVWw_8LxSLajnkk8,1818
+ophyd_async/epics/eiger/_odin_io.py,sha256=NY1O38yIYU0M6hPt1yXqDHxvpnc7PKDpqZasjc7bM_s,4163
 ophyd_async/epics/pvi/__init__.py,sha256=ZvJO69ApL7N9rWT9-hD-JZMC_KsHxgeEqxe-01jNUVw,137
 ophyd_async/epics/pvi/_pvi.py,sha256=PUst4KhX8emkbRunLrJeqTruaOMF3mm1s7YJsBB7HpQ,12099
 ophyd_async/epics/signal/__init__.py,sha256=cJGvTnJxHNzpWyWIYXU4UGMoz3uqZ88UVXNvG-TGngo,441
@@ -82,9 +87,9 @@ ophyd_async/sim/demo/_pattern_detector/_pattern_detector_writer.py,sha256=ayJJ2Y
 ophyd_async/sim/demo/_pattern_detector/_pattern_generator.py,sha256=KRB8y3rwoaemeQx4ewoFO7CCTHtvokWe4zTE0Rg3K0Q,7176
 ophyd_async/sim/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ophyd_async/tango/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async-0.5.1.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.5.1.dist-info/METADATA,sha256=iU7ylsJXDvQ829UX8Q6-2UUUNnu_9wMTP5NirO23HF0,6511
-ophyd_async-0.5.1.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
-ophyd_async-0.5.1.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
-ophyd_async-0.5.1.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.5.1.dist-info/RECORD,,
+ophyd_async-0.5.2.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.5.2.dist-info/METADATA,sha256=WT4LFUgG_L4M56zH19WNULHbqAdJg2_D9AAYGEXTWB8,6511
+ophyd_async-0.5.2.dist-info/WHEEL,sha256=uCRv0ZEik_232NlR4YDw4Pv3Ajt5bKvMH13NUU7hFuI,91
+ophyd_async-0.5.2.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
+ophyd_async-0.5.2.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.5.2.dist-info/RECORD,,

{ophyd_async-0.5.1.dist-info → ophyd_async-0.5.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.0.0)
+Generator: setuptools (74.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any