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

ophyd_async/sim/demo/_pattern_detector/_pattern_detector.py

@@ -1,42 +0,0 @@
-from collections.abc import Sequence
-from pathlib import Path
-
-from ophyd_async.core import (
-    FilenameProvider,
-    PathProvider,
-    SignalR,
-    StandardDetector,
-    StaticFilenameProvider,
-    StaticPathProvider,
-)
-
-from ._pattern_detector_controller import PatternDetectorController
-from ._pattern_detector_writer import PatternDetectorWriter
-from ._pattern_generator import PatternGenerator
-
-
-class PatternDetector(StandardDetector):
-    def __init__(
-        self,
-        path: Path,
-        config_sigs: Sequence[SignalR] = (),
-        name: str = "",
-    ) -> None:
-        fp: FilenameProvider = StaticFilenameProvider(name)
-        self.path_provider: PathProvider = StaticPathProvider(fp, path)
-        self.pattern_generator = PatternGenerator()
-        writer = PatternDetectorWriter(
-            pattern_generator=self.pattern_generator,
-            path_provider=self.path_provider,
-            name_provider=lambda: self.name,
-        )
-        controller = PatternDetectorController(
-            pattern_generator=self.pattern_generator,
-            path_provider=self.path_provider,
-        )
-        super().__init__(
-            controller=controller,
-            writer=writer,
-            config_sigs=config_sigs,
-            name=name,
-        )

ophyd_async/sim/demo/_pattern_detector/_pattern_detector_controller.py

@@ -1,62 +0,0 @@
-import asyncio
-
-from ophyd_async.core import DetectorController, PathProvider, TriggerInfo
-
-from ._pattern_generator import PatternGenerator
-
-
-class PatternDetectorController(DetectorController):
-    def __init__(
-        self,
-        pattern_generator: PatternGenerator,
-        path_provider: PathProvider,
-        exposure: float = 0.1,
-    ) -> None:
-        self.pattern_generator: PatternGenerator = pattern_generator
-        self.pattern_generator.set_exposure(exposure)
-        self.path_provider: PathProvider = path_provider
-        self.task: asyncio.Task | None = None
-        super().__init__()
-
-    async def prepare(self, trigger_info: TriggerInfo):
-        self._trigger_info = trigger_info
-        if self._trigger_info.livetime is None:
-            self._trigger_info.livetime = 0.01
-        self.period: float = self._trigger_info.livetime + self.get_deadtime(
-            trigger_info.livetime
-        )
-
-    async def arm(self):
-        assert self._trigger_info.livetime
-        assert self.period
-        self.task = asyncio.create_task(
-            self._coroutine_for_image_writing(
-                self._trigger_info.livetime,
-                self.period,
-                self._trigger_info.total_number_of_triggers,
-            )
-        )
-
-    async def wait_for_idle(self):
-        if self.task:
-            await self.task
-
-    async def disarm(self):
-        if self.task and not self.task.done():
-            self.task.cancel()
-            try:
-                await self.task
-            except asyncio.CancelledError:
-                pass
-        self.task = None
-
-    def get_deadtime(self, exposure: float | None) -> 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/demo/_pattern_detector/_pattern_detector_writer.py

@@ -1,41 +0,0 @@
-from collections.abc import AsyncGenerator, AsyncIterator
-
-from event_model import DataKey
-
-from ophyd_async.core import DEFAULT_TIMEOUT, DetectorWriter, NameProvider, PathProvider
-
-from ._pattern_generator import PatternGenerator
-
-
-class PatternDetectorWriter(DetectorWriter):
-    pattern_generator: PatternGenerator
-
-    def __init__(
-        self,
-        pattern_generator: PatternGenerator,
-        path_provider: PathProvider,
-        name_provider: NameProvider,
-    ) -> None:
-        self.pattern_generator = pattern_generator
-        self.path_provider = path_provider
-        self.name_provider = name_provider
-
-    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
-        return await self.pattern_generator.open_file(
-            self.path_provider, self.name_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)
-
-    async def observe_indices_written(
-        self, timeout=DEFAULT_TIMEOUT
-    ) -> AsyncGenerator[int, None]:
-        async for index in self.pattern_generator.observe_indices_written(timeout):
-            yield index
-
-    async def get_indices_written(self) -> int:
-        return self.pattern_generator.image_counter

ophyd_async/sim/demo/_pattern_detector/_pattern_generator.py

@@ -1,207 +0,0 @@
-from collections.abc import AsyncGenerator, AsyncIterator
-from pathlib import Path
-
-import h5py
-import numpy as np
-from bluesky.protocols import StreamAsset
-from event_model import DataKey
-
-from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
-    HDFDataset,
-    HDFFile,
-    PathProvider,
-    observe_value,
-    soft_signal_r_and_setter,
-)
-
-# raw data path
-DATA_PATH = "/entry/data/data"
-
-# pixel sum path
-SUM_PATH = "/entry/sum"
-
-MAX_UINT8_VALUE = np.iinfo(np.uint8).max
-
-
-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 PatternGenerator:
-    def __init__(
-        self,
-        saturation_exposure_time: float = 0.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.image_counter: int = 0
-
-        # it automatically initializes to 0
-        self.counter_signal, self._set_counter_signal = soft_signal_r_and_setter(int)
-        self._full_intensity_blob = (
-            generate_gaussian_blob(width=detector_width, height=detector_height)
-            * MAX_UINT8_VALUE
-        )
-        self._hdf_stream_provider: HDFFile | None = None
-        self._handle_for_h5_file: h5py.File | None = None
-        self.target_path: Path | None = None
-
-    def write_data_to_dataset(self, path: str, data_shape: tuple[int, ...], data):
-        """Write data to named dataset, resizing to fit and flushing after."""
-        assert self._handle_for_h5_file, "no file has been opened!"
-        dset = self._handle_for_h5_file[path]
-        assert isinstance(
-            dset, h5py.Dataset
-        ), f"Expected {path} to be dataset, got {dset}"
-        dset.resize((self.image_counter + 1,) + data_shape)
-        dset[self.image_counter] = data
-        dset.flush()
-
-    async def write_image_to_file(self) -> None:
-        # generate the simulated data
-        intensity: float = generate_interesting_pattern(self.x, self.y)
-        detector_data = (
-            self._full_intensity_blob
-            * intensity
-            * self.exposure
-            / self.saturation_exposure_time
-        ).astype(np.uint8)
-
-        # Write the data and sum
-        self.write_data_to_dataset(DATA_PATH, (self.height, self.width), detector_data)
-        self.write_data_to_dataset(SUM_PATH, (), np.sum(detector_data))
-
-        # counter increment is last
-        # as only at this point the new data is visible from the outside
-        self.image_counter += 1
-        self._set_counter_signal(self.image_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, path_provider: PathProvider, name: str, multiplier: int = 1
-    ) -> dict[str, DataKey]:
-        await self.counter_signal.connect()
-
-        self.target_path = self._get_new_path(path_provider)
-        self._path_provider = path_provider
-
-        self._handle_for_h5_file = h5py.File(self.target_path, "w", libver="latest")
-
-        assert self._handle_for_h5_file, "not loaded the file right"
-
-        self._handle_for_h5_file.create_dataset(
-            name=DATA_PATH,
-            shape=(0, self.height, self.width),
-            dtype=np.uint8,
-            maxshape=(None, self.height, self.width),
-        )
-        self._handle_for_h5_file.create_dataset(
-            name=SUM_PATH,
-            shape=(0,),
-            dtype=np.float64,
-            maxshape=(None,),
-        )
-
-        # once datasets written, can switch the model to single writer multiple reader
-        self._handle_for_h5_file.swmr_mode = True
-        self.multiplier = multiplier
-
-        outer_shape = (multiplier,) if multiplier > 1 else ()
-
-        # cache state to self
-        # Add the main data
-        self._datasets = [
-            HDFDataset(
-                data_key=name,
-                dataset=DATA_PATH,
-                shape=(self.height, self.width),
-                multiplier=multiplier,
-            ),
-            HDFDataset(
-                f"{name}-sum",
-                dataset=SUM_PATH,
-                shape=(),
-                multiplier=multiplier,
-            ),
-        ]
-
-        describe = {
-            ds.data_key: DataKey(
-                source="sim://pattern-generator-hdf-file",
-                shape=list(outer_shape) + list(ds.shape),
-                dtype="array" if ds.shape else "number",
-                external="STREAM:",
-            )
-            for ds in self._datasets
-        }
-        return describe
-
-    def _get_new_path(self, path_provider: PathProvider) -> Path:
-        info = path_provider(device_name="pattern")
-        new_path: Path = info.directory_path / info.filename
-        return new_path
-
-    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"
-                self._hdf_stream_provider = HDFFile(
-                    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()
-            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.counter_signal, timeout=timeout):
-            yield num_captured // self.multiplier

ophyd_async/sim/demo/_sim_motor.py

@@ -1,107 +0,0 @@
-import asyncio
-import contextlib
-import time
-
-import numpy as np
-from bluesky.protocols import Movable, Stoppable
-
-from ophyd_async.core import (
-    AsyncStatus,
-    StandardReadable,
-    WatchableAsyncStatus,
-    WatcherUpdate,
-    observe_value,
-    soft_signal_r_and_setter,
-    soft_signal_rw,
-)
-from ophyd_async.core import StandardReadableFormat as Format
-
-
-class SimMotor(StandardReadable, Movable, Stoppable):
-    def __init__(self, name="", instant=True) -> None:
-        """
-        Simulated motor device
-
-        args:
-        - prefix: str: Signal names prefix
-        - name: str: name of device
-        - instant: bool: whether to move instantly, or with a delay
-        """
-        # Define some signals
-        with self.add_children_as_readables(Format.HINTED_SIGNAL):
-            self.user_readback, self._user_readback_set = soft_signal_r_and_setter(
-                float, 0
-            )
-        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
-            self.velocity = soft_signal_rw(float, 0 if instant else 1.0)
-            self.units = soft_signal_rw(str, "mm")
-        self.user_setpoint = soft_signal_rw(float, 0)
-
-        # Whether set() should complete successfully or not
-        self._set_success = True
-        self._move_status: AsyncStatus | None = None
-
-        super().__init__(name=name)
-
-    async def _move(self, old_position: float, new_position: float, move_time: float):
-        start = time.monotonic()
-        # Make an array of relative update times at 10Hz intervals
-        update_times = np.arange(0.1, move_time, 0.1)
-        # With the end position appended
-        update_times = np.concatenate((update_times, [move_time]))
-        # Interpolate the [old, new] position array with those update times
-        new_positions = np.interp(
-            update_times, [0, move_time], [old_position, new_position]
-        )
-        for update_time, new_position in zip(update_times, new_positions, strict=True):
-            # Calculate how long to wait to get there
-            relative_time = time.monotonic() - start
-            await asyncio.sleep(update_time - relative_time)
-            # Update the readback position
-            self._user_readback_set(new_position)
-
-    @WatchableAsyncStatus.wrap
-    async def set(self, value: float):
-        """
-        Asynchronously move the motor to a new position.
-        """
-        new_position = value
-        # Make sure any existing move tasks are stopped
-        await self.stop()
-        old_position, units, velocity = await asyncio.gather(
-            self.user_setpoint.get_value(),
-            self.units.get_value(),
-            self.velocity.get_value(),
-        )
-        # If zero velocity, do instant move
-        if velocity == 0:
-            self._user_readback_set(new_position)
-        else:
-            move_time = abs(new_position - old_position) / velocity
-            self._move_status = AsyncStatus(
-                self._move(old_position, new_position, move_time)
-            )
-            # If stop is called then this will raise a CancelledError, ignore it
-            with contextlib.suppress(asyncio.CancelledError):
-                async for current_position in observe_value(
-                    self.user_readback, done_status=self._move_status
-                ):
-                    yield WatcherUpdate(
-                        current=current_position,
-                        initial=old_position,
-                        target=new_position,
-                        name=self.name,
-                        unit=units,
-                    )
-        if not self._set_success:
-            raise RuntimeError("Motor was stopped")
-
-    async def stop(self, success=True):
-        """
-        Stop the motor if it is moving
-        """
-        self._set_success = success
-        if self._move_status:
-            self._move_status.task.cancel()
-            self._move_status = None
-        await self.user_setpoint.set(await self.user_readback.get_value())

ophyd_async-0.9.0a1.dist-info/RECORD

@@ -1,119 +0,0 @@
-ophyd_async/__init__.py,sha256=tEfgj45lRItQ-_u8SRFPM-mpBh3gWvHXr3emhiJJG_M,225
-ophyd_async/__main__.py,sha256=n_U4O9bgm97OuboUB_9eK7eFiwy8BZSgXJ0OzbE0DqU,481
-ophyd_async/_version.py,sha256=fqly1zb7P_f9515NUzRb7AMheEwRLpJkaVG_Pep_nis,413
-ophyd_async/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/core/__init__.py,sha256=GQCfHqV_nypbNkzzycqq_JxCnIIP1rwBiSB9gBq1EE0,3805
-ophyd_async/core/_detector.py,sha256=Zyrc5dMSmOM4bC_tOXHFfWtXnTtEQGkrAN6kydvUIFw,14307
-ophyd_async/core/_device.py,sha256=oIC-P6Lu6MDAdB_bHPzuT-ox8gTBAcjRNRNEh89IABk,13000
-ophyd_async/core/_device_filler.py,sha256=Nw-DUyuXYpvt4mmCAQaNVA0LFBBaPK84ubZo3bR39Ak,11407
-ophyd_async/core/_device_save_loader.py,sha256=OViN9_LWNOLuajzrHDKYEqd5I47u5npQACdGceKcIGY,8375
-ophyd_async/core/_flyer.py,sha256=us5z6MNGCvIfgPDTmFTxNERSP37g0WVRkRD0Z2JiMgM,1701
-ophyd_async/core/_hdf_dataset.py,sha256=wW_OL8OYLGOsE01ny3hGaapOrxK7BzhWTxKgz8CIXK0,2492
-ophyd_async/core/_log.py,sha256=UbL9AtnHVUg7r9LofzgmuKEtBESy03usCp7ejmDltG4,3679
-ophyd_async/core/_mock_signal_backend.py,sha256=8Upnz6QrSigeDXemjZ-jB4sV2yIPUzid-6GOfTZ-7Io,2805
-ophyd_async/core/_protocol.py,sha256=0pwF_EUu7LZjr-Hg6LKy6B1-5y4gpsU81JsPiNI5g_s,3317
-ophyd_async/core/_providers.py,sha256=ff9ZT5-PZ6rhTTdE-q8w9l_k9DuZqLWLebsKZLeJ0Ds,7112
-ophyd_async/core/_readable.py,sha256=7FxqxhAT1wBQqOEivgnY731zA9QoK1Tt-ZGcH7GBOXM,10623
-ophyd_async/core/_signal.py,sha256=KCIJongFllgRBRJxN1EjsmYR17qTu_wBm-b1OrdhT2w,20558
-ophyd_async/core/_signal_backend.py,sha256=YWPgLSPbfPnWIUDHvP1ArCVK8zKXJxzzbloqQe_ucCI,5040
-ophyd_async/core/_soft_signal_backend.py,sha256=w9zzD4eoD9SsJpORXNSaFOLJrD6biYBbCSVAybLa_7k,5926
-ophyd_async/core/_status.py,sha256=OUKhblRQ4KU5PDsWbpvYduM7G60JMk1NqeV4eqyPtKc,5131
-ophyd_async/core/_table.py,sha256=tNu396gDGjpX1xUBQXgKI7aiDugaBl2McH_kVZPn_kQ,5535
-ophyd_async/core/_utils.py,sha256=bzgxs1KdB35mkONzpDOg3eH6bVMIbJt49qRY0PrFqi4,9870
-ophyd_async/epics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/epics/motor.py,sha256=d5EwfpTmblxuO1H37rzIOTDgNy1OlZmp10FWXOVUQ4o,9076
-ophyd_async/epics/signal.py,sha256=hJCGIIWjRVhjEHkeL1I_oPEaaN7dDFKmm7G7ZmgoTYQ,219
-ophyd_async/epics/adaravis/__init__.py,sha256=u979_9nQTYB0TvDOTXFN4qMrbDP8-xQFfXYMGzLVBo4,207
-ophyd_async/epics/adaravis/_aravis.py,sha256=XBuLQBZYj2tptY39bVzXjl6t-ZpPwqrUOwpR54l-hSo,1952
-ophyd_async/epics/adaravis/_aravis_controller.py,sha256=3zt-BWr-UnM1nguphHhJBNHXgBD6ntzifYXYL2o9VCM,2831
-ophyd_async/epics/adaravis/_aravis_io.py,sha256=_RViDrTDaTutitRbHlJ5VV23X70lvfhyY3DTzgXy6yI,1603
-ophyd_async/epics/adcore/__init__.py,sha256=3wMOyFGaq1X61LqK4iY4pq-m_BjhOgYZD2-mNCAjpzk,1086
-ophyd_async/epics/adcore/_core_io.py,sha256=4yGdsV-uivrJYas07fDFbjNwnqJukB654YneBHGsZJU,6076
-ophyd_async/epics/adcore/_core_logic.py,sha256=2QUWoHc6wJDwFVV81CN0rAOxhgb0SFJNLCeBxKv1Fi4,3632
-ophyd_async/epics/adcore/_hdf_writer.py,sha256=y0K-u3E27a8vJTklvyKrWlzRPNBp1G7DHipUtvUtOWc,7338
-ophyd_async/epics/adcore/_single_trigger.py,sha256=5-s0kgqqrPeNv9gjAB2pNXuxa9oEgwt9KBq58JRta6Y,1208
-ophyd_async/epics/adcore/_utils.py,sha256=qXOT79_CNwtO8BdpHybi4meG3Xq4pqEvWYW-Jjt_elA,3932
-ophyd_async/epics/adkinetix/__init__.py,sha256=cvnwOqbvEENf70eFp6bPGwayP0u14UTIhs3WiZEcF_Q,262
-ophyd_async/epics/adkinetix/_kinetix.py,sha256=JsQVc4d7lRCnVObJlM775hHLfp3rYRSRgOoIyRvrSek,1184
-ophyd_async/epics/adkinetix/_kinetix_controller.py,sha256=R5l7TaPlibeGPY67o18-Ra3i65IVIxRQ_1Zbn8kmi5s,1701
-ophyd_async/epics/adkinetix/_kinetix_io.py,sha256=3zqfmoTCTkhd7kiqD4wiYrnu5EADzzegaCRJFBaZuVk,910
-ophyd_async/epics/adpilatus/__init__.py,sha256=daimScOCCMHR2eb8VbezHOcGOkd6uIRZQiyeTQsaAx4,308
-ophyd_async/epics/adpilatus/_pilatus.py,sha256=hsHYeMbYJiePn3uci-YSUivQRhAaYAgicr3K145HbBA,1751
-ophyd_async/epics/adpilatus/_pilatus_controller.py,sha256=Bef_-2uJe8hTM-VO_xScMCnEB172n7jSmhdUevPtdJY,2676
-ophyd_async/epics/adpilatus/_pilatus_io.py,sha256=Jznmhwidmr_YaUdWXazWFYNQq4wn_sI1dXeo9Zhyf0M,738
-ophyd_async/epics/adsimdetector/__init__.py,sha256=t3crUgTEvVJGI8o6FsfN42k0A-l4v9ZBwXIYtixoE-M,128
-ophyd_async/epics/adsimdetector/_sim.py,sha256=jzsPJdcwdciR2mVPbvg9KhGHWWGNDQwK5TwPcS7_tco,1009
-ophyd_async/epics/adsimdetector/_sim_controller.py,sha256=WXKj5SclfLJ0IywCk81GmFj0ZGMkDnX7jRfatXe1EYo,1677
-ophyd_async/epics/advimba/__init__.py,sha256=l0ElP3Zyff_pzrTRdj9oUO9xigCfmzo3pMVjstlVsJY,320
-ophyd_async/epics/advimba/_vimba.py,sha256=E_RJ0uJQt-RWAY7uFTNkHaOdGYS5sa7ZbRgAe6ngXTA,1125
-ophyd_async/epics/advimba/_vimba_controller.py,sha256=DZNNtYeii1ogFuoW4IV8YYDdNyyt4TwcktMEr4TlJoI,2226
-ophyd_async/epics/advimba/_vimba_io.py,sha256=il-SZSiApx5OUQCYHUGoa0Ywu9pY01DSDvOttU15khQ,1864
-ophyd_async/epics/core/__init__.py,sha256=8NoQxEEc2Ny_L9nrD2fnGSf_2gJr1wCR1LwUeLNcIJo,588
-ophyd_async/epics/core/_aioca.py,sha256=iQWiHWYbMJLa7qeBrCz4_e16Y8A-NYYi6oYNi8oOFVY,11617
-ophyd_async/epics/core/_epics_connector.py,sha256=n1FlQYui8HdobPxaX3VAflrzi2UT7QCe3cFasssmVLw,1789
-ophyd_async/epics/core/_epics_device.py,sha256=kshNiKQhevsL2OZXa-r093L_sQGvGK_0J4PWVLg3Eqw,437
-ophyd_async/epics/core/_p4p.py,sha256=xtN45sJovj_5bo_e6ZUf0A_uIAeMUVgTcYJi-AtzMmw,15518
-ophyd_async/epics/core/_pvi_connector.py,sha256=wi9PiiWtWWE8mlHAfgDd6zKHvXn35E5DaqDvk4k5KD0,3755
-ophyd_async/epics/core/_signal.py,sha256=0_g2dd60tUl1inEY9hUQvWrEka4uvNW8hylrhnB76Q8,4842
-ophyd_async/epics/core/_util.py,sha256=wdwFd6sJoFQo3eGElPzhPaJi3KqLf5Zq_03Hoya7YsE,2079
-ophyd_async/epics/demo/__init__.py,sha256=wCrgemEo-zR4TTvaqCKnQ-AIUHorotV5jhftbq1tXz0,1368
-ophyd_async/epics/demo/_mover.py,sha256=tuAvP8TuyJtHhdSloNol7pBpiBQMcqUtGil52VjpGsE,3666
-ophyd_async/epics/demo/_sensor.py,sha256=VMxsjLV_V3LeLqnSqIsDHVJgpu5SmASV-rlzok_lLws,1040
-ophyd_async/epics/demo/mover.db,sha256=RFz0rxZue689Wh1sWTZwWeFMUrH04ttPq2u5xJH_Fp4,998
-ophyd_async/epics/demo/sensor.db,sha256=AstyG9E0R4KZBz2FZQSrV_QlrfLoU6M2cvYc15Lf548,553
-ophyd_async/epics/eiger/__init__.py,sha256=b3Tt4pVLk23Giyj50R4e94d2MxWDDmNHWhWwNq2jlaw,221
-ophyd_async/epics/eiger/_eiger.py,sha256=hkMsjVwrzDcE1u5BRIQtn8RSR2e0b1JMpDvuIONoNaI,1133
-ophyd_async/epics/eiger/_eiger_controller.py,sha256=ZJGTwSjQam15mtgG4GQ9nPNv_cA-lSLMFgTMkTK79Gg,2343
-ophyd_async/epics/eiger/_eiger_io.py,sha256=qTBT0SebqzlcNXtLQywSoTmAbVC2wl4i0Wn2fbcEISM,1806
-ophyd_async/epics/eiger/_odin_io.py,sha256=3E33ysvMlf8t0bbSVPnzUrvPgUwA7491uoViWpivpf8,4153
-ophyd_async/epics/testing/__init__.py,sha256=terWt7TtNaxk4dCdAGQs-7HM2Z7Vcy34eX6kcngDbi8,498
-ophyd_async/epics/testing/_example_ioc.py,sha256=-GC4mYacZcbLSZMmOj7Kdz08ZrGv9fsYJ4STs3n6ddQ,3481
-ophyd_async/epics/testing/_utils.py,sha256=-D6aKJydhM-n6290DyyKlnwCHFkbQ-j4tu5AD2JjWZ0,2443
-ophyd_async/epics/testing/test_records.db,sha256=25aW0vPe7ScFXI7zE83DfG6StgdrBwCEwDbfK9_hwVw,3198
-ophyd_async/epics/testing/test_records_pva.db,sha256=NyceNGaCZXNYaXjH2VLhvKl8Z-L6dwfE_kYZKqdIcTU,4054
-ophyd_async/fastcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/fastcs/core.py,sha256=MpbRLaPJwmaAuunnIV34oq1AUjT1nfv5ggtgw4I42vY,376
-ophyd_async/fastcs/odin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/fastcs/panda/__init__.py,sha256=_o7n7ckoTM6hTRHpLphpL7r_9sADE59MRNM0gq_ut2o,980
-ophyd_async/fastcs/panda/_block.py,sha256=UZBWos3g4yhxGhX9oB3g_GU7jGGelgoQ2Yt2sm1MPJM,1709
-ophyd_async/fastcs/panda/_control.py,sha256=QIfF5y4nmjhnATeIuBTNTwXfKkNR6D9E7X0RQub0j1k,1021
-ophyd_async/fastcs/panda/_hdf_panda.py,sha256=UnKG8TJugDJGBm8_Grx9EtR07RtEafx1lin-JClujaQ,1172
-ophyd_async/fastcs/panda/_table.py,sha256=5YyAfsl3H7kxH3bDjUKHuH9DyrWQmAn9dv-v0NYzFNo,2289
-ophyd_async/fastcs/panda/_trigger.py,sha256=z9VGb4XPaw3xrOsvTbgpLHbduDbQJB0M4HP3w5YPB_E,3056
-ophyd_async/fastcs/panda/_utils.py,sha256=NdvzdKy0SOG1eCVMQo_nwRXpBo0wyi6lM5Xw3HvssOw,508
-ophyd_async/fastcs/panda/_writer.py,sha256=wDN6uWX1ENofmI3JBXJ7_CGooI7WsZP-JJQrRiSc6sM,6000
-ophyd_async/plan_stubs/__init__.py,sha256=wjpEj_BoBZJ9x2fhUPY6BzWMqyYH96JrBlJvV7frdN4,524
-ophyd_async/plan_stubs/_ensure_connected.py,sha256=uoqfAzghjifdfD_JM860TvMvj9T2Y12nKPvtI5l6zZc,1021
-ophyd_async/plan_stubs/_fly.py,sha256=ZR3oivJuMIQYXTm_QjZaCtnXY21_T8BB3dVqAnp6EHo,6208
-ophyd_async/plan_stubs/_nd_attributes.py,sha256=TVfy3bhnrLFBXZ6b2bREBj0LzEviEGzuGvgWK3I7tII,2198
-ophyd_async/sim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/sim/demo/__init__.py,sha256=JKWFnHqmFuRRMvvU0aBuclke3OdF0iq89yvHEd4J7Bg,371
-ophyd_async/sim/demo/_sim_motor.py,sha256=gfvhW9TSgolAf5iAk30GviuHh680pT_RcxxTviZCzvk,3997
-ophyd_async/sim/demo/_pattern_detector/__init__.py,sha256=o_dSZDIl_CyS3YPSNKpGiQiR9UaC4cNzZ8_ByEN9dIk,402
-ophyd_async/sim/demo/_pattern_detector/_pattern_detector.py,sha256=R-UbcxHLFfCK9tBryKZN5Dit0IjYeJGP-QKV2ssKFoQ,1275
-ophyd_async/sim/demo/_pattern_detector/_pattern_detector_controller.py,sha256=HqlKNgjd_9pjy6pc74xdJ7JtV1Iko6cNxB2aZReJozw,1999
-ophyd_async/sim/demo/_pattern_detector/_pattern_detector_writer.py,sha256=nQOks4EK1Ax0Ib1pkCrmJPF8Jqr7tPusMnby-HGUnP0,1370
-ophyd_async/sim/demo/_pattern_detector/_pattern_generator.py,sha256=gP0Q1-1p_3KOH7mWZc5m-8OUEx_jb7SAdRXcpleRqX4,7096
-ophyd_async/sim/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/tango/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/tango/core/__init__.py,sha256=pBslTNkIt22-g-CDbG9N7pKLQVJqFe6DYXHFFYJZIo8,905
-ophyd_async/tango/core/_base_device.py,sha256=IN1HF1DOf9W9_FhVlzWyuU58gBFu86rYOD1vDZ_a7Wc,4717
-ophyd_async/tango/core/_signal.py,sha256=5ks0dyzCX66cV9R_CnmM949H1RzNQH3Q1XIUhHQCOaI,6421
-ophyd_async/tango/core/_tango_readable.py,sha256=c6xVH56oBp5o3C3y3PuHA5MftvmjKm20BBvrgsTO260,913
-ophyd_async/tango/core/_tango_transport.py,sha256=6yT-UqE7YyH6OxSisUPvwcEqf29i18jHfse6Ag4JtY0,28986
-ophyd_async/tango/demo/__init__.py,sha256=_j-UicTnckuIBp8PnieFMOMnLFGivnaKdmo9o0hYtzc,256
-ophyd_async/tango/demo/_counter.py,sha256=efBqrFj6ejzDh1aggtPXpn1iub1zB4XocRvHqBEiwcs,1105
-ophyd_async/tango/demo/_detector.py,sha256=0wwk7Y-Dl9QF1YsCIU_BxqI6-PQ40qN_0gknrYBkxsY,1292
-ophyd_async/tango/demo/_mover.py,sha256=c5whb380th1eCThs35ftW1bfNRyYRmcofg7xUp6zvV8,2837
-ophyd_async/tango/demo/_tango/__init__.py,sha256=FfONT7vM49nNo3a1Lv-LcMZO9EHv6bv91yY-RnxIib4,85
-ophyd_async/tango/demo/_tango/_servers.py,sha256=MwkkoZWJQm_cgafCBBXeQfwyAiOgU8cE90_uNfcdcGA,2916
-ophyd_async/testing/__init__.py,sha256=O7PFrKkVoPzhyn6f5xv6Jx6-ZahP6iBUAiqdTpalXng,706
-ophyd_async/testing/_assert.py,sha256=dFiy3GC_pJOTbpxvHZ3Mh357j1XtKZcuW74DlkrpJLE,3372
-ophyd_async/testing/_mock_signal_utils.py,sha256=VbnUQhp0QwBK4nTWirwIWRCl9pVudDj9y_qH2LhkCMc,5210
-ophyd_async/testing/_wait_for_pending.py,sha256=YZAR48n-CW0GsPey3zFRzMJ4byDAr3HvMIoawjmTrHw,732
-ophyd_async-0.9.0a1.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.9.0a1.dist-info/METADATA,sha256=94_s1cZumUz1BuiXeodSWxW4AhoIf7Wo4tli2ddQDY0,6753
-ophyd_async-0.9.0a1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-ophyd_async-0.9.0a1.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
-ophyd_async-0.9.0a1.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.9.0a1.dist-info/RECORD,,

ophyd_async-0.9.0a1.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-ophyd-async = ophyd_async.__main__:main