ophyd-async 0.2.0__py3-none-any.whl → 0.3a2__py3-none-any.whl

ophyd_async/sim/pattern_generator.py

@@ -0,0 +1,318 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import (
+    Any,
+    AsyncGenerator,
+    AsyncIterator,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+)
+
+import h5py
+import numpy as np
+from bluesky.protocols import Descriptor, StreamAsset
+from event_model import (
+    ComposeStreamResource,
+    ComposeStreamResourceBundle,
+    StreamDatum,
+    StreamRange,
+    StreamResource,
+)
+
+from ophyd_async.core import DirectoryInfo, DirectoryProvider
+from ophyd_async.core.signal import SignalR, observe_value
+from ophyd_async.core.sim_signal_backend import SimSignalBackend
+from ophyd_async.core.utils import DEFAULT_TIMEOUT
+
+# raw data path
+DATA_PATH = "/entry/data/data"
+
+# pixel sum path
+SUM_PATH = "/entry/sum"
+
+MAX_UINT8_VALUE = np.iinfo(np.uint8).max
+
+SLICE_NAME = "AD_HDF5_SWMR_SLICE"
+
+
+@dataclass
+class DatasetConfig:
+    name: str
+    shape: Sequence[int]
+    maxshape: tuple[Any, ...] = (None,)
+    path: Optional[str] = None
+    multiplier: Optional[int] = 1
+    dtype: Optional[Any] = None
+    fillvalue: Optional[int] = None
+
+
+def get_full_file_description(
+    datasets: List[DatasetConfig], outer_shape: tuple[int, ...]
+):
+    full_file_description: Dict[str, Descriptor] = {}
+    for d in datasets:
+        source = f"soft://{d.name}"
+        shape = outer_shape + tuple(d.shape)
+        dtype = "number" if d.shape == [1] else "array"
+        descriptor = Descriptor(
+            source=source, shape=shape, dtype=dtype, external="STREAM:"
+        )
+        key = d.name.replace("/", "_")
+        full_file_description[key] = descriptor
+    return full_file_description
+
+
+def generate_gaussian_blob(height: int, width: int) -> np.ndarray:
+    """Make a Gaussian Blob with float values in range 0..1"""
+    x, y = np.meshgrid(np.linspace(-1, 1, width), np.linspace(-1, 1, height))
+    d = np.sqrt(x * x + y * y)
+    blob = np.exp(-(d**2))
+    return blob
+
+
+def generate_interesting_pattern(x: float, y: float) -> float:
+    """This function is interesting in x and y in range -10..10, returning
+    a float value in range 0..1
+    """
+    z = 0.5 + (np.sin(x) ** 10 + np.cos(10 + y * x) * np.cos(x)) / 2
+    return z
+
+
+class HdfStreamProvider:
+    def __init__(
+        self,
+        directory_info: DirectoryInfo,
+        full_file_name: Path,
+        datasets: List[DatasetConfig],
+    ) -> None:
+        self._last_emitted = 0
+        self._bundles: List[ComposeStreamResourceBundle] = self._compose_bundles(
+            directory_info, full_file_name, datasets
+        )
+
+    def _compose_bundles(
+        self,
+        directory_info: DirectoryInfo,
+        full_file_name: Path,
+        datasets: List[DatasetConfig],
+    ) -> List[StreamAsset]:
+        path = str(full_file_name.relative_to(directory_info.root))
+        root = str(directory_info.root)
+        bundler_composer = ComposeStreamResource()
+
+        bundles: List[ComposeStreamResourceBundle] = []
+
+        bundles = [
+            bundler_composer(
+                spec=SLICE_NAME,
+                root=root,
+                resource_path=path,
+                data_key=d.name.replace("/", "_"),
+                resource_kwargs={
+                    "path": d.path,
+                    "multiplier": d.multiplier,
+                    "timestamps": "/entry/instrument/NDAttributes/NDArrayTimeStamp",
+                },
+            )
+            for d in datasets
+        ]
+        return bundles
+
+    def stream_resources(self) -> Iterator[StreamResource]:
+        for bundle in self._bundles:
+            yield bundle.stream_resource_doc
+
+    def stream_data(self, indices_written: int) -> Iterator[StreamDatum]:
+        # Indices are relative to resource
+        if indices_written > self._last_emitted:
+            updated_stream_range = StreamRange(
+                start=self._last_emitted,
+                stop=indices_written,
+            )
+            self._last_emitted = indices_written
+            for bundle in self._bundles:
+                yield bundle.compose_stream_datum(indices=updated_stream_range)
+        return None
+
+    def close(self) -> None:
+        for bundle in self._bundles:
+            bundle.close()
+
+
+class PatternGenerator:
+    def __init__(
+        self,
+        saturation_exposure_time: float = 1,
+        detector_width: int = 320,
+        detector_height: int = 240,
+    ) -> None:
+        self.saturation_exposure_time = saturation_exposure_time
+        self.exposure = saturation_exposure_time
+        self.x = 0.0
+        self.y = 0.0
+        self.height = detector_height
+        self.width = detector_width
+        self.written_images_counter: int = 0
+
+        # it automatically initializes to 0
+        self.signal_backend = SimSignalBackend(int)
+        self.sim_signal = SignalR(self.signal_backend)
+        blob = np.array(
+            generate_gaussian_blob(width=detector_width, height=detector_height)
+            * MAX_UINT8_VALUE
+        )
+        self.STARTING_BLOB = blob
+        self._hdf_stream_provider: Optional[HdfStreamProvider] = None
+        self._handle_for_h5_file: Optional[h5py.File] = None
+        self.target_path: Optional[Path] = None
+
+    async def write_image_to_file(self) -> None:
+        assert self._handle_for_h5_file, "no file has been opened!"
+        # prepare - resize the fixed hdf5 data structure
+        # so that the new image can be written
+        new_layer = self.written_images_counter + 1
+        target_dimensions = (new_layer, self.height, self.width)
+
+        # generate the simulated data
+        intensity: float = generate_interesting_pattern(self.x, self.y)
+        detector_data: np.uint8 = np.uint8(
+            self.STARTING_BLOB
+            * intensity
+            * self.exposure
+            / self.saturation_exposure_time
+        )
+
+        self._handle_for_h5_file[DATA_PATH].resize(target_dimensions)
+
+        print(f"writing image {new_layer}")
+        assert self._handle_for_h5_file, "no file has been opened!"
+        self._handle_for_h5_file[DATA_PATH].resize(target_dimensions)
+
+        self._handle_for_h5_file[SUM_PATH].resize((new_layer,))
+
+        # write data to disc (intermediate step)
+        self._handle_for_h5_file[DATA_PATH][self.written_images_counter] = detector_data
+        self._handle_for_h5_file[SUM_PATH][self.written_images_counter] = np.sum(
+            detector_data
+        )
+
+        # save metadata - so that it's discoverable
+        self._handle_for_h5_file[DATA_PATH].flush()
+        self._handle_for_h5_file[SUM_PATH].flush()
+
+        # counter increment is last
+        # as only at this point the new data is visible from the outside
+        self.written_images_counter += 1
+        await self.signal_backend.put(self.written_images_counter)
+
+    def set_exposure(self, value: float) -> None:
+        self.exposure = value
+
+    def set_x(self, value: float) -> None:
+        self.x = value
+
+    def set_y(self, value: float) -> None:
+        self.y = value
+
+    async def open_file(
+        self, directory: DirectoryProvider, multiplier: int = 1
+    ) -> Dict[str, Descriptor]:
+        await self.sim_signal.connect()
+
+        self.target_path = self._get_new_path(directory)
+
+        self._handle_for_h5_file = h5py.File(self.target_path, "w", libver="latest")
+
+        assert self._handle_for_h5_file, "not loaded the file right"
+
+        datasets = self._get_datasets()
+        for d in datasets:
+            self._handle_for_h5_file.create_dataset(
+                name=d.name,
+                shape=d.shape,
+                dtype=d.dtype,
+                maxshape=d.maxshape,
+            )
+
+        # once datasets written, can switch the model to single writer multiple reader
+        self._handle_for_h5_file.swmr_mode = True
+
+        outer_shape = (multiplier,) if multiplier > 1 else ()
+        full_file_description = get_full_file_description(datasets, outer_shape)
+
+        # cache state to self
+        self._datasets = datasets
+        self.multiplier = multiplier
+        self._directory_provider = directory
+        return full_file_description
+
+    def _get_new_path(self, directory: DirectoryProvider) -> Path:
+        info = directory()
+        filename = f"{info.prefix}pattern{info.suffix}.h5"
+        new_path: Path = info.root / info.resource_dir / filename
+        return new_path
+
+    def _get_datasets(self) -> List[DatasetConfig]:
+        raw_dataset = DatasetConfig(
+            # name=data_name,
+            name=DATA_PATH,
+            dtype=np.uint8,
+            shape=(1, self.height, self.width),
+            maxshape=(None, self.height, self.width),
+        )
+
+        sum_dataset = DatasetConfig(
+            name=SUM_PATH,
+            dtype=np.float64,
+            shape=(1,),
+            maxshape=(None,),
+            fillvalue=-1,
+        )
+
+        datasets: List[DatasetConfig] = [raw_dataset, sum_dataset]
+        return datasets
+
+    async def collect_stream_docs(
+        self, indices_written: int
+    ) -> AsyncIterator[StreamAsset]:
+        """
+        stream resource says "here is a dataset",
+        stream datum says "here are N frames in that stream resource",
+        you get one stream resource and many stream datums per scan
+        """
+        if self._handle_for_h5_file:
+            self._handle_for_h5_file.flush()
+        # when already something was written to the file
+        if indices_written:
+            # if no frames arrived yet, there's no file to speak of
+            # cannot get the full filename the HDF writer will write
+            # until the first frame comes in
+            if not self._hdf_stream_provider:
+                assert self.target_path, "open file has not been called"
+                datasets = self._get_datasets()
+                self._datasets = datasets
+                self._hdf_stream_provider = HdfStreamProvider(
+                    self._directory_provider(),
+                    self.target_path,
+                    self._datasets,
+                )
+                for doc in self._hdf_stream_provider.stream_resources():
+                    yield "stream_resource", doc
+            if self._hdf_stream_provider:
+                for doc in self._hdf_stream_provider.stream_data(indices_written):
+                    yield "stream_datum", doc
+
+    def close(self) -> None:
+        if self._handle_for_h5_file:
+            self._handle_for_h5_file.close()
+            print("file closed")
+            self._handle_for_h5_file = None
+
+    async def observe_indices_written(
+        self, timeout=DEFAULT_TIMEOUT
+    ) -> AsyncGenerator[int, None]:
+        async for num_captured in observe_value(self.sim_signal, timeout=timeout):
+            yield num_captured // self.multiplier

ophyd_async/sim/sim_pattern_detector_control.py

@@ -0,0 +1,55 @@
+import asyncio
+from typing import Optional
+
+from ophyd_async.core import DirectoryProvider
+from ophyd_async.core.async_status import AsyncStatus
+from ophyd_async.core.detector import DetectorControl, DetectorTrigger
+from ophyd_async.sim.pattern_generator import PatternGenerator
+
+
+class SimPatternDetectorControl(DetectorControl):
+    def __init__(
+        self,
+        pattern_generator: PatternGenerator,
+        directory_provider: DirectoryProvider,
+        exposure: float = 0.1,
+    ) -> None:
+        self.pattern_generator: PatternGenerator = pattern_generator
+        self.pattern_generator.set_exposure(exposure)
+        self.directory_provider: DirectoryProvider = directory_provider
+        self.task: Optional[asyncio.Task] = None
+        super().__init__()
+
+    async def arm(
+        self,
+        num: int,
+        trigger: DetectorTrigger = DetectorTrigger.internal,
+        exposure: Optional[float] = 0.01,
+    ) -> AsyncStatus:
+        assert exposure is not None
+        period: float = exposure + self.get_deadtime(exposure)
+        task = asyncio.create_task(
+            self._coroutine_for_image_writing(exposure, period, num)
+        )
+        self.task = task
+        return AsyncStatus(task)
+
+    async def disarm(self):
+        if self.task:
+            self.task.cancel()
+            try:
+                await self.task
+            except asyncio.CancelledError:
+                pass
+            self.task = None
+
+    def get_deadtime(self, exposure: float) -> float:
+        return 0.001
+
+    async def _coroutine_for_image_writing(
+        self, exposure: float, period: float, frames_number: int
+    ):
+        for _ in range(frames_number):
+            self.pattern_generator.set_exposure(exposure)
+            await asyncio.sleep(period)
+            await self.pattern_generator.write_image_to_file()

ophyd_async/sim/sim_pattern_detector_writer.py

@@ -0,0 +1,34 @@
+from typing import AsyncGenerator, AsyncIterator, Dict
+
+from bluesky.protocols import Descriptor
+
+from ophyd_async.core import DirectoryProvider
+from ophyd_async.core.detector import DetectorWriter
+from ophyd_async.sim.pattern_generator import PatternGenerator
+
+
+class SimPatternDetectorWriter(DetectorWriter):
+    pattern_generator: PatternGenerator
+
+    def __init__(
+        self, pattern_generator: PatternGenerator, directoryProvider: DirectoryProvider
+    ) -> None:
+        self.pattern_generator = pattern_generator
+        self.directory_provider = directoryProvider
+
+    async def open(self, multiplier: int = 1) -> Dict[str, Descriptor]:
+        return await self.pattern_generator.open_file(
+            self.directory_provider, multiplier
+        )
+
+    async def close(self) -> None:
+        self.pattern_generator.close()
+
+    def collect_stream_docs(self, indices_written: int) -> AsyncIterator:
+        return self.pattern_generator.collect_stream_docs(indices_written)
+
+    def observe_indices_written(self, timeout=...) -> AsyncGenerator[int, None]:
+        return self.pattern_generator.observe_indices_written()
+
+    async def get_indices_written(self) -> int:
+        return self.pattern_generator.written_images_counter

ophyd_async/sim/sim_pattern_generator.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+from typing import Sequence
+
+from ophyd_async.core import DirectoryProvider, StaticDirectoryProvider
+from ophyd_async.core.detector import StandardDetector
+from ophyd_async.core.signal import SignalR
+from ophyd_async.sim.pattern_generator import PatternGenerator
+
+from .sim_pattern_detector_control import SimPatternDetectorControl
+from .sim_pattern_detector_writer import SimPatternDetectorWriter
+
+
+class SimPatternDetector(StandardDetector):
+    def __init__(
+        self,
+        path: Path,
+        config_sigs: Sequence[SignalR] = [],
+        name: str = "sim_pattern_detector",
+        writer_timeout: float = 1,
+    ) -> None:
+        self.directory_provider: DirectoryProvider = StaticDirectoryProvider(path)
+        self.pattern_generator = PatternGenerator()
+        writer = SimPatternDetectorWriter(
+            pattern_generator=self.pattern_generator,
+            directoryProvider=self.directory_provider,
+        )
+        controller = SimPatternDetectorControl(
+            pattern_generator=self.pattern_generator,
+            directory_provider=self.directory_provider,
+        )
+        super().__init__(
+            controller=controller,
+            writer=writer,
+            config_sigs=config_sigs,
+            name=name,
+            writer_timeout=writer_timeout,
+        )

{ophyd_async-0.2.0.dist-info → ophyd_async-0.3a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.2.0
+Version: 0.3a2
 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
@@ -35,21 +35,19 @@ License: BSD 3-Clause License
 Project-URL: GitHub, https://github.com/bluesky/ophyd-async
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.9
-Description-Content-Type: text/x-rst
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: networkx >=2.0
 Requires-Dist: numpy
 Requires-Dist: packaging
 Requires-Dist: pint
-Requires-Dist: bluesky
-Requires-Dist: event-model
+Requires-Dist: bluesky >=1.13.0a3
+Requires-Dist: event-model <1.21.0
 Requires-Dist: p4p
 Requires-Dist: pyyaml
-Requires-Dist: typing-extensions ; python_version < "3.8"
 Provides-Extra: ca
 Requires-Dist: aioca >=1.6 ; extra == 'ca'
 Provides-Extra: dev
@@ -64,7 +62,6 @@ Requires-Dist: inflection ; extra == 'dev'
 Requires-Dist: ipython ; extra == 'dev'
 Requires-Dist: ipywidgets ; extra == 'dev'
 Requires-Dist: matplotlib ; extra == 'dev'
-Requires-Dist: mypy ; extra == 'dev'
 Requires-Dist: myst-parser ; extra == 'dev'
 Requires-Dist: numpydoc ; extra == 'dev'
 Requires-Dist: ophyd ; extra == 'dev'
@@ -73,13 +70,14 @@ Requires-Dist: pipdeptree ; extra == 'dev'
 Requires-Dist: pre-commit ; extra == 'dev'
 Requires-Dist: pydata-sphinx-theme >=0.12 ; extra == 'dev'
 Requires-Dist: pyepics >=3.4.2 ; extra == 'dev'
-Requires-Dist: pyside6 ; extra == 'dev'
+Requires-Dist: pyside6 ==6.6.2 ; extra == 'dev'
 Requires-Dist: pytest ; extra == 'dev'
 Requires-Dist: pytest-asyncio ; extra == 'dev'
 Requires-Dist: pytest-cov ; extra == 'dev'
 Requires-Dist: pytest-faulthandler ; extra == 'dev'
 Requires-Dist: pytest-rerunfailures ; extra == 'dev'
 Requires-Dist: pytest-timeout ; extra == 'dev'
+Requires-Dist: ruff ; extra == 'dev'
 Requires-Dist: sphinx-autobuild ; extra == 'dev'
 Requires-Dist: sphinx-copybutton ; extra == 'dev'
 Requires-Dist: sphinx-design ; extra == 'dev'
@@ -89,75 +87,21 @@ Requires-Dist: types-pyyaml ; extra == 'dev'
 Provides-Extra: pva
 Requires-Dist: p4p ; extra == 'pva'
 
-Ophyd Async
-===========
+[![CI](https://github.com/bluesky/ophyd-async/actions/workflows/ci.yml/badge.svg)](https://github.com/bluesky/ophyd-async/actions/workflows/ci.yml)
+[![Coverage](https://codecov.io/gh/bluesky/ophyd-async/branch/main/graph/badge.svg)](https://codecov.io/gh/bluesky/ophyd-async)
+[![PyPI](https://img.shields.io/pypi/v/ophyd-async.svg)](https://pypi.org/project/ophyd-async)
+[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
 
-|code_ci| |docs_ci| |coverage| |pypi_version| |license|
+# ophyd_async
 
-Asynchronous device abstraction framework, building on `Ophyd`_.
+Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 
-============== ==============================================================
-PyPI           ``pip install ophyd-async``
-Source code    https://github.com/bluesky/ophyd-async
-Documentation  https://blueskyproject.io/ophyd-async
-============== ==============================================================
+|    Source     |     <https://github.com/bluesky/ophyd-async>      |
+| :-----------: | :-----------------------------------------------: |
+|     PyPI      |             `pip install ophyd-async`             |
+| Documentation |      <https://bluesky.github.io/ophyd-async>      |
+|   Releases    | <https://github.com/bluesky/ophyd-async/releases> |
 
-Python library for asynchronously interfacing with hardware, intended to 
-be used as an abstraction layer that enables experiment orchestration and data 
-acquisition code to operate above the specifics of particular devices and control
-systems.
+<!-- README only content. Anything below this line won't be included in index.md -->
 
-Both ophyd and ophyd-async are typically used with the `Bluesky Run Engine`_ for 
-experiment orchestration and data acquisition. However, these libraries are
-able to be used in a stand-alone fashion. For an example of how a facility defines
-and uses ophyd-async devices, see `dls-dodal`_, which is currently using a
-mixture of ophyd and ophyd-async devices.
-
-While `EPICS`_ is the most common control system layer that ophyd-async can
-interface with, other control systems like `Tango`_ are used by some facilities
-also. In addition to the abstractions provided by ophyd, ophyd-async allows:
-
-* Asynchronous signal access, opening the possibility for hardware-triggered
-  scanning (also known as fly-scanning)
-* Simpler instantiation of devices (groupings of signals) with less reliance
-  upon complex class hierarchies
-
-NOTE: ophyd-async is included on a provisional basis until the v1.0 release.
-
-See the tutorials for usage examples.
-
-.. |code_ci| image:: https://github.com/bluesky/ophyd-async/actions/workflows/code.yml/badge.svg?branch=main
-    :target: https://github.com/bluesky/ophyd-async/actions/workflows/code.yml
-    :alt: Code CI
-
-.. |docs_ci| image:: https://github.com/bluesky/ophyd-async/actions/workflows/docs.yml/badge.svg?branch=main
-    :target: https://github.com/bluesky/ophyd-async/actions/workflows/docs.yml
-    :alt: Docs CI
-
-.. |coverage| image:: https://codecov.io/gh/bluesky/ophyd-async/branch/master/graph/badge.svg
-    :target: https://codecov.io/gh/bluesky/ophyd-async
-    :alt: Test Coverage
-
-.. |pypi_version| image:: https://img.shields.io/pypi/v/ophyd-async.svg
-    :target: https://pypi.org/project/ophyd-async
-    :alt: Latest PyPI version
-
-.. |license| image:: https://img.shields.io/badge/License-BSD%203--Clause-blue.svg
-    :target: https://opensource.org/licenses/BSD-3-Clause
-    :alt: BSD 3-Clause License
-
-.. _Bluesky Run Engine: http://blueskyproject.io/bluesky
-
-.. _Ophyd: http://blueskyproject.io/ophyd
-
-.. _dls-dodal: https://github.com/DiamondLightSource/dodal
-
-.. _EPICS: http://www.aps.anl.gov/epics/
-
-.. _Tango: https://www.tango-controls.org/
-
-..
-    Anything below this line is used when viewing README.rst and will be replaced
-    when included in index.rst
-
-See https://blueskyproject.io/ophyd-async for more detailed documentation.
+See https://bluesky.github.io/ophyd-async for more detailed documentation.

ophyd_async-0.3a2.dist-info/RECORD

@@ -0,0 +1,76 @@
+ophyd_async/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
+ophyd_async/__main__.py,sha256=G-Zcv_G9zK7Nhx6o5L5w-wyhMxdl_WgyMELu8IMFqAE,328
+ophyd_async/_version.py,sha256=qiI6_8XDVi-QTRXglHkCWQmocyDKhwu0_7zIjyy3JmQ,408
+ophyd_async/protocols.py,sha256=8kQms6exvlMRqK0DESv4LyhhweUf7bskUj0ODWBLra8,2283
+ophyd_async/core/__init__.py,sha256=pzR-cIfjKTOoL8BFkvhwwflMIYzCOpeXU1xkppC1V7c,2252
+ophyd_async/core/_providers.py,sha256=LrlTMPHKXWOPVkpAOw-pqBq0kip-c3C9ZZPoFfiaV4M,2212
+ophyd_async/core/async_status.py,sha256=-sfIf7VhwAP25kSVwKZjAIYOTROpfnh2jgkDw5_afSU,2801
+ophyd_async/core/detector.py,sha256=bc_9rXDaRiD2tciSZtP57h64r8wOCG4ZcWnmnJORRlI,11220
+ophyd_async/core/device.py,sha256=Bm8u1wEN6PuJgCgis_msVRvfrO1_RumxAIMPag8k-cI,5813
+ophyd_async/core/device_save_loader.py,sha256=RXA3dPUPihAR2ZGDStlGiA-TAsr_xqL0snsCjMsMnfA,9138
+ophyd_async/core/flyer.py,sha256=rTAcFIyfGJwzwP-oI-V6nPNQiZazKDHn278wC9-sZgQ,2305
+ophyd_async/core/signal.py,sha256=ZNHP9yh81l3kOpyQvnXuASVBlU8SJiKEQczKvJXXCxI,12549
+ophyd_async/core/signal_backend.py,sha256=z0bwzM9IYp-hOZGlxy0u8JHfMGlULP17p14l2eVuk6A,1528
+ophyd_async/core/sim_signal_backend.py,sha256=HK6-_jAvH3Uc8ijnVgLtjl1SsGWyiEH7ptkyUQPv_E4,6071
+ophyd_async/core/standard_readable.py,sha256=ZoArn8sk31Kz389_CDe_Z70L9L6qjT5uVqYi5ywj2oM,2614
+ophyd_async/core/utils.py,sha256=AVF5e42CVG_GaLoHJSI82iC4KAO60fb9fEJMISHBCNM,5043
+ophyd_async/epics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/epics/_backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ophyd_async/epics/_backend/_aioca.py,sha256=TZiV5r7CvEbM40t3TrTG4mVJBZGI_NDIaQlhfUHm0us,8789
+ophyd_async/epics/_backend/_p4p.py,sha256=NtGncTdiou9HPt0fLPhPjRDcvUsUJ_6em9bhcQew-C8,12061
+ophyd_async/epics/_backend/common.py,sha256=o0heeQEM7aP-QYCicwOEtNHs5c5OD6raR-5cTs9yRX0,840
+ophyd_async/epics/areadetector/__init__.py,sha256=T5coX2Osb59uzQFlpHykp_spV-SBRQZYWdAIpDDsYQc,442
+ophyd_async/epics/areadetector/aravis.py,sha256=cCugTlUs0b7mtzKTyxtWCRXO27tYA7zycPVPMhgkMyU,2335
+ophyd_async/epics/areadetector/pilatus.py,sha256=gEJVUphr5gj8TwSYcc07ZakWk9tRIKKZRnPva5LZVBE,1537
+ophyd_async/epics/areadetector/single_trigger_det.py,sha256=q5mG-OUVagIjvXLb28lsrGj4eUSoH2pNW2rT4rQR8fA,1206
+ophyd_async/epics/areadetector/utils.py,sha256=dez54oElIkGMnhSM9qghToUB1opSqjdWTV2vhHCgRMA,3133
+ophyd_async/epics/areadetector/controllers/__init__.py,sha256=UG2-M5d2ykp2T8isQJCbAsGZF1aH0BtC_OPlzzPTjnA,149
+ophyd_async/epics/areadetector/controllers/ad_sim_controller.py,sha256=mthZ6WxajMEgUKptq3bnkIctbLhjzTagV66i1auB8cg,1587
+ophyd_async/epics/areadetector/controllers/aravis_controller.py,sha256=vRiSexnFzijG8eEwowMAFIe730xFNMmgjjbXQVi4zrc,2394
+ophyd_async/epics/areadetector/controllers/pilatus_controller.py,sha256=cd1CKkaXlwkpQ0I1VL7nN0U8R4VweTsa08WhvHYI4nY,2243
+ophyd_async/epics/areadetector/drivers/__init__.py,sha256=AOpIEYfoBhG9Nc4-SId99v4PpyEh4_RBXfNaqiXlwUI,315
+ophyd_async/epics/areadetector/drivers/ad_base.py,sha256=ikfyNcZwJa5ah52DckjrBzkMMT_eDY1smM4XWfb6A6E,3689
+ophyd_async/epics/areadetector/drivers/aravis_driver.py,sha256=Z96xXKfGJbLYehyy0wmP3mCW5lVRmdypmX-9U8cYbD8,5607
+ophyd_async/epics/areadetector/drivers/pilatus_driver.py,sha256=fc3vNHqop9oLg-fvaU-diQNEV5U1qzA9vX2T8Hwy_E8,478
+ophyd_async/epics/areadetector/writers/__init__.py,sha256=tpPcrYd1hs8WS7C0gmCnR2EBwjE5RzCljI7WwZ2V_LM,191
+ophyd_async/epics/areadetector/writers/_hdfdataset.py,sha256=E0C9VgsPyY35h7k0mvcIhjsIVNavApLxizqNWlM388w,167
+ophyd_async/epics/areadetector/writers/_hdffile.py,sha256=YtUgOKX53m0TaFEGBW671qXqNuuEKxEyLV5Ein1fjvo,1799
+ophyd_async/epics/areadetector/writers/hdf_writer.py,sha256=oons06X8OAw3fh3IggvvQazjIgWpZAQ9jo_PBdtYewM,5259
+ophyd_async/epics/areadetector/writers/nd_file_hdf.py,sha256=rutCstILCGGwhP5pH_2lWM2QUcZ88-uxx5dTZIJUMWQ,1562
+ophyd_async/epics/areadetector/writers/nd_plugin.py,sha256=l0yBBEazviyFsWJv_4_sfGn_YM_Iyd0_SlMdAmUlXDU,871
+ophyd_async/epics/demo/__init__.py,sha256=XSoP6xZVuQtxcDe6ZBIUy76iEgOywJgR4Z-ASEyyc90,6237
+ophyd_async/epics/demo/demo_ad_sim_detector.py,sha256=06y65yvaqXvL2rDocjYyLz9kTVzuwV-LeuPhEfExdOA,944
+ophyd_async/epics/demo/mover.db,sha256=RFz0rxZue689Wh1sWTZwWeFMUrH04ttPq2u5xJH_Fp4,998
+ophyd_async/epics/demo/sensor.db,sha256=AVtiydrdtwAz2EFurO2Ult9SSRtre3r0akOBbL98LT0,554
+ophyd_async/epics/motion/__init__.py,sha256=tnmVRIwKa9PdN_xonJdAUD04UpEceh-hoD7XI62yDB0,46
+ophyd_async/epics/motion/motor.py,sha256=PBnkPuoCU1u1HD8IGEOM9GF2d1kwd0Hi7V9tr2rahZY,3786
+ophyd_async/epics/pvi/__init__.py,sha256=TbOQNY4enQWgtr1T7x129vpo2p7FIFlr8cyZqqv5Lk4,158
+ophyd_async/epics/pvi/pvi.py,sha256=hpn7GeO0xk_-UDoy42LIsi0adER9IZO3HPP2iu6Nmu4,11320
+ophyd_async/epics/signal/__init__.py,sha256=wb93RTqvSbGKVFQj8OHykbVLGLmwKHU72oi5xYu2UaY,188
+ophyd_async/epics/signal/_epics_transport.py,sha256=DEIL0iYUAWssysVEgWGu1fHSM1l-ATV2kjUgPtDN9LY,858
+ophyd_async/epics/signal/signal.py,sha256=J3Kush7lK0lGj9dZG6qfNPFGNDsv4s-Ggv__1O9qaqA,3165
+ophyd_async/panda/__init__.py,sha256=ZaD1nRgGKAGFGdpP1WWF-FnX3wcGuYqqq0QRZbaSBYQ,692
+ophyd_async/panda/_common_blocks.py,sha256=n0PPc1rar43oDSIA-yNubTc8fR5YCW1tyjQU58whsg0,1038
+ophyd_async/panda/_hdf_panda.py,sha256=zZxIdNIXHwjlZA-HTezQNfcCh98P2Pst6Pcld92rPLM,1414
+ophyd_async/panda/_panda_controller.py,sha256=dIqcjmaIHVrki8UXSoDx46kk6I2Lhpe2o3sXNg5f-RQ,1238
+ophyd_async/panda/_table.py,sha256=dLoRP4zYNOkD_s0Vkp2wVYAwkjVG8nNdf8-FaXOTfPo,5655
+ophyd_async/panda/_trigger.py,sha256=tBH8uq_4o1ASG9yofVxq3tjf5v8LPzniDTRL4yjramI,1195
+ophyd_async/panda/_utils.py,sha256=VHW5kPVISyEkmse_qQcyisBkkEwMO6GG2Ago-CH1AFA,487
+ophyd_async/panda/writers/__init__.py,sha256=xy7BguVQG4HNIDBfKPjMj0KQo1tptC9LbCpEuMcVGaM,70
+ophyd_async/panda/writers/_hdf_writer.py,sha256=tmIMWKQhURZu3PnmJyEn0xd94CWijpErXo_oJTSfefA,7626
+ophyd_async/panda/writers/_panda_hdf_file.py,sha256=42iHaTax4JjOBpNC7d4nkNL9SM14OTnFPTIcXv2jg-4,1759
+ophyd_async/planstubs/__init__.py,sha256=G9B80_d87lnOThUsGbAYPqzMw9xDelq2TbS7dkB692o,188
+ophyd_async/planstubs/prepare_trigger_and_dets.py,sha256=0c4XDAxVkSanyDKtaMda0VgPEbk2jM0geVzAx707DhI,1772
+ophyd_async/sim/__init__.py,sha256=ScjH1g7FMo5yPACfJRZE6xGBWCHU4bKDzNQk1tqObnA,366
+ophyd_async/sim/pattern_generator.py,sha256=R9iC4ofkcM6KI1cLFDdgyggBccXrGmb5_MNIIlPVgQc,10646
+ophyd_async/sim/sim_pattern_detector_control.py,sha256=Ypz8IuRYAY2J243IhVbNyGr_Z-XtpJZ1qxma6NR3TgM,1838
+ophyd_async/sim/sim_pattern_detector_writer.py,sha256=X7AUYKL19Z0CLAI_wzQvJMo5CUYlebT_7-q7CgZ9FsA,1243
+ophyd_async/sim/sim_pattern_generator.py,sha256=w5oc5QaFpAxzM0S5irvcOqsyASgN0rZQRzMjbZ5r8cE,1326
+ophyd_async/sim/demo/__init__.py,sha256=9mxKpslrL89cfSj4g3og8Br3O--pMj3hhWZS-Xu6kyA,56
+ophyd_async/sim/demo/sim_motor.py,sha256=Nt8mD_RY4pl80wQOQ3g0KIfNep4_9teJh4ioYgIsLj8,4036
+ophyd_async-0.3a2.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.3a2.dist-info/METADATA,sha256=_ZQVR2K-Bjx7gL7Z6kmlFbOjeEGG8ttArDfMshOri9g,5249
+ophyd_async-0.3a2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+ophyd_async-0.3a2.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
+ophyd_async-0.3a2.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.3a2.dist-info/RECORD,,

{ophyd_async-0.2.0.dist-info → ophyd_async-0.3a2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.3)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any