ophyd-async 0.3.4a1__py3-none-any.whl → 0.5.0__py3-none-any.whl

ophyd_async/epics/motion/motor.py

@@ -1,97 +0,0 @@
-import asyncio
-
-from bluesky.protocols import Movable, Stoppable
-
-from ophyd_async.core import (
-    ConfigSignal,
-    HintedSignal,
-    StandardReadable,
-    WatchableAsyncStatus,
-)
-from ophyd_async.core.signal import observe_value
-from ophyd_async.core.utils import (
-    DEFAULT_TIMEOUT,
-    CalculatableTimeout,
-    CalculateTimeout,
-    WatcherUpdate,
-)
-
-from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
-
-
-class Motor(StandardReadable, Movable, Stoppable):
-    """Device that moves a motor record"""
-
-    def __init__(self, prefix: str, name="") -> None:
-        # Define some signals
-        with self.add_children_as_readables(ConfigSignal):
-            self.motor_egu = epics_signal_r(str, prefix + ".EGU")
-            self.velocity = epics_signal_rw(float, prefix + ".VELO")
-
-        with self.add_children_as_readables(HintedSignal):
-            self.user_readback = epics_signal_r(float, prefix + ".RBV")
-
-        self.user_setpoint = epics_signal_rw(float, prefix + ".VAL")
-        self.max_velocity = epics_signal_r(float, prefix + ".VMAX")
-        self.acceleration_time = epics_signal_rw(float, prefix + ".ACCL")
-        self.precision = epics_signal_r(int, prefix + ".PREC")
-        self.deadband = epics_signal_r(float, prefix + ".RDBD")
-        self.motor_done_move = epics_signal_r(int, prefix + ".DMOV")
-        self.low_limit_travel = epics_signal_rw(float, prefix + ".LLM")
-        self.high_limit_travel = epics_signal_rw(float, prefix + ".HLM")
-
-        self.motor_stop = epics_signal_x(prefix + ".STOP")
-        # Whether set() should complete successfully or not
-        self._set_success = True
-        super().__init__(name=name)
-
-    def set_name(self, name: str):
-        super().set_name(name)
-        # Readback should be named the same as its parent in read()
-        self.user_readback.set_name(name)
-
-    @WatchableAsyncStatus.wrap
-    async def set(
-        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
-    ):
-        self._set_success = True
-        (
-            old_position,
-            units,
-            precision,
-            velocity,
-            acceleration_time,
-        ) = await asyncio.gather(
-            self.user_setpoint.get_value(),
-            self.motor_egu.get_value(),
-            self.precision.get_value(),
-            self.velocity.get_value(),
-            self.acceleration_time.get_value(),
-        )
-        if timeout is CalculateTimeout:
-            assert velocity > 0, "Motor has zero velocity"
-            timeout = (
-                abs(new_position - old_position) / velocity
-                + 2 * acceleration_time
-                + DEFAULT_TIMEOUT
-            )
-        move_status = self.user_setpoint.set(new_position, wait=True, timeout=timeout)
-        async for current_position in observe_value(
-            self.user_readback, done_status=move_status
-        ):
-            yield WatcherUpdate(
-                current=current_position,
-                initial=old_position,
-                target=new_position,
-                name=self.name,
-                unit=units,
-                precision=precision,
-            )
-        if not self._set_success:
-            raise RuntimeError("Motor was stopped")
-
-    async def stop(self, success=False):
-        self._set_success = success
-        # Put with completion will never complete as we are waiting for completion on
-        # the move above, so need to pass wait=False
-        await self.motor_stop.trigger(wait=False)

ophyd_async/panda/_trigger.py

@@ -1,39 +0,0 @@
-import asyncio
-from dataclasses import dataclass
-
-from ophyd_async.core import TriggerLogic, wait_for_value
-from ophyd_async.panda import SeqBlock, SeqTable, TimeUnits
-
-
-@dataclass
-class SeqTableInfo:
-    sequence_table: SeqTable
-    repeats: int
-    prescale_as_us: float = 1  # microseconds
-
-
-class StaticSeqTableTriggerLogic(TriggerLogic[SeqTableInfo]):
-    def __init__(self, seq: SeqBlock) -> None:
-        self.seq = seq
-
-    async def prepare(self, value: SeqTableInfo):
-        await asyncio.gather(
-            self.seq.prescale_units.set(TimeUnits.us),
-            self.seq.enable.set("ZERO"),
-        )
-        await asyncio.gather(
-            self.seq.prescale.set(value.prescale_as_us),
-            self.seq.repeats.set(value.repeats),
-            self.seq.table.set(value.sequence_table),
-        )
-
-    async def kickoff(self) -> None:
-        await self.seq.enable.set("ONE")
-        await wait_for_value(self.seq.active, True, timeout=1)
-
-    async def complete(self) -> None:
-        await wait_for_value(self.seq.active, False, timeout=None)
-
-    async def stop(self):
-        await self.seq.enable.set("ZERO")
-        await wait_for_value(self.seq.active, False, timeout=1)

ophyd_async/panda/writers/__init__.py

@@ -1,3 +0,0 @@
-from ._hdf_writer import PandaHDFWriter
-
-__all__ = ["PandaHDFWriter"]

ophyd_async/panda/writers/_panda_hdf_file.py

@@ -1,54 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Iterator, List
-
-from event_model import StreamDatum, StreamResource, compose_stream_resource
-
-from ophyd_async.core import DirectoryInfo
-
-
-@dataclass
-class _HDFDataset:
-    data_key: str
-    internal_path: str
-    shape: List[int]
-    multiplier: int
-
-
-class _HDFFile:
-    def __init__(
-        self,
-        directory_info: DirectoryInfo,
-        full_file_name: Path,
-        datasets: List[_HDFDataset],
-    ) -> None:
-        self._last_emitted = 0
-        self._bundles = [
-            compose_stream_resource(
-                spec="AD_HDF5_SWMR_SLICE",
-                root=str(directory_info.root),
-                data_key=ds.data_key,
-                resource_path=(f"{str(directory_info.root)}/{full_file_name}"),
-                resource_kwargs={
-                    "path": ds.internal_path,
-                    "multiplier": ds.multiplier,
-                    "timestamps": "/entry/instrument/NDAttributes/NDArrayTimeStamp",
-                },
-            )
-            for ds in datasets
-        ]
-
-    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:
-            indices = {
-                "start": self._last_emitted,
-                "stop": indices_written,
-            }
-            self._last_emitted = indices_written
-            for bundle in self._bundles:
-                yield bundle.compose_stream_datum(indices)

ophyd_async/plan_stubs/ensure_connected.py

@@ -1,22 +0,0 @@
-import bluesky.plan_stubs as bps
-
-from ophyd_async.core.device import Device
-from ophyd_async.core.utils import DEFAULT_TIMEOUT, wait_for_connection
-
-
-def ensure_connected(
-    *devices: Device,
-    mock: bool = False,
-    timeout: float = DEFAULT_TIMEOUT,
-    force_reconnect=False,
-):
-    yield from bps.wait_for(
-        [
-            lambda: wait_for_connection(
-                **{
-                    device.name: device.connect(mock, timeout, force_reconnect)
-                    for device in devices
-                }
-            )
-        ]
-    )

ophyd_async/sim/pattern_generator.py

@@ -1,318 +0,0 @@
-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 DataKey, StreamAsset
-from event_model import (
-    ComposeStreamResource,
-    ComposeStreamResourceBundle,
-    StreamDatum,
-    StreamRange,
-    StreamResource,
-)
-
-from ophyd_async.core import DirectoryInfo, DirectoryProvider
-from ophyd_async.core.mock_signal_backend import MockSignalBackend
-from ophyd_async.core.signal import SignalR, observe_value
-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, DataKey] = {}
-    for d in datasets:
-        source = f"soft://{d.name}"
-        shape = outer_shape + tuple(d.shape)
-        dtype = "number" if d.shape == [1] else "array"
-        descriptor = DataKey(
-            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 = MockSignalBackend(int)
-        self.mock_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, DataKey]:
-        await self.mock_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.mock_signal, timeout=timeout):
-            yield num_captured // self.multiplier

ophyd_async/sim/sim_pattern_generator.py

@@ -1,35 +0,0 @@
-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.protocols import AsyncReadable
-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[AsyncReadable] = [],
-        name: str = "sim_pattern_detector",
-    ) -> 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,
-        )

ophyd_async-0.3.4a1.dist-info/RECORD

@@ -1,86 +0,0 @@
-ophyd_async/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
-ophyd_async/__main__.py,sha256=G-Zcv_G9zK7Nhx6o5L5w-wyhMxdl_WgyMELu8IMFqAE,328
-ophyd_async/_version.py,sha256=GeD2BgjHboEmcr7_O2gtjDoE83JU6uGSFLE7dAp8RDQ,413
-ophyd_async/log.py,sha256=DbMjt0bkfUOLHIinZYt0Q0FHZmCXXi5x8y0uFiEmqoQ,3587
-ophyd_async/protocols.py,sha256=EF2W9nfElV-0QNMYrX1zusL1PqDJR3kNsjlalR29j0I,3412
-ophyd_async/core/__init__.py,sha256=xqO9riU_uKqGAOi0ty0cbcI4Oawi_J3XTYLtwNSXGOE,3061
-ophyd_async/core/_providers.py,sha256=LrlTMPHKXWOPVkpAOw-pqBq0kip-c3C9ZZPoFfiaV4M,2212
-ophyd_async/core/async_status.py,sha256=9TOgOXIAuH62RDo5t-Y5GdjrJ76d_6TFlBxYv-5_a88,4367
-ophyd_async/core/detector.py,sha256=NMX8y_yiViHbv3CaJ7LxzXYkH6tCWI3LocpQ3w4lGEQ,11176
-ophyd_async/core/device.py,sha256=280zFnLCoiMZAA-Dh1_AjUSnhxUfKYGgj4H_2S1njOA,7086
-ophyd_async/core/device_save_loader.py,sha256=EK7FB5oWiLI_s2KZ1BNDQ2AUKVbFLlimMl0vXfsjcgo,8223
-ophyd_async/core/flyer.py,sha256=bIjzBkrl8HVAlKgsZ_FF0WL69Qvksyzp9ZWmTLl8Yrw,2304
-ophyd_async/core/mock_signal_backend.py,sha256=Ug6jK72wm9vM6EueoUrYgcXtiFzdPUEISRe86LdyYKc,2844
-ophyd_async/core/mock_signal_utils.py,sha256=LE8VxNq3jfaTePnHHpZpKCi1vwKi8EIg-g1jfw-Q5bQ,4726
-ophyd_async/core/signal.py,sha256=hPpMcdq7zx6HOkyQCJrMD5F3uLBEJJTfwL6DsbcTELo,17601
-ophyd_async/core/signal_backend.py,sha256=U9J6jzHXRNIrdtGiZBVxXTRtzeejXiXEEIOGRIQhiS8,2678
-ophyd_async/core/soft_signal_backend.py,sha256=6ve1NWuEZFW4oFkAdSfTKFg06fv7rDLgr5IAEr_axeo,6262
-ophyd_async/core/standard_readable.py,sha256=fhq_WAZtLYWrw6DvvrFRYRAPOUP2_IcX4qLucoEEeOg,9049
-ophyd_async/core/utils.py,sha256=3oZcXNqAUHX4ZWMBH5gSuK6cFWEhSkZ9GSDYv0pf8jc,5783
-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=YsKHGaHtYjBte5Tz-AftTENaeV6UGRnonX-1UmAQGqg,11319
-ophyd_async/epics/_backend/_p4p.py,sha256=oCT8MeVWlhmsxZ8YRSrelrY8W3NvfpXcMlfAKL_AUNY,14331
-ophyd_async/epics/_backend/common.py,sha256=ffdcKhtUc8Mmm0AsV0K7cUoOttF6avcN6Kdd4QHjrSw,1833
-ophyd_async/epics/areadetector/__init__.py,sha256=ViKzx-wUxkRyNR33wfpL11QB97o0J47_KMyI2C_NphI,510
-ophyd_async/epics/areadetector/aravis.py,sha256=YklN4V0loqUQBs4swVX304N49JIGPvrNOk8iA5EWofg,2127
-ophyd_async/epics/areadetector/kinetix.py,sha256=7rE2MLnz9DEmeiN9pCekDfpXuZ2DErnMajRp_9eoLZY,1359
-ophyd_async/epics/areadetector/pilatus.py,sha256=hs3v8QUIwTHNg7i1mRSg9SbIIsoUZg90OxJ740gEKpo,2044
-ophyd_async/epics/areadetector/single_trigger_det.py,sha256=U92dqhioIfnve3jtCThq9gXBCdEzzqzY4ezk6rZV19g,1182
-ophyd_async/epics/areadetector/utils.py,sha256=p66UbVdKRFj6Sm1Qvm23kmlVyBMMqIvXFxA3x17YnSk,2824
-ophyd_async/epics/areadetector/vimba.py,sha256=IxG8KLzfb84iLtzf6ZoX9JikqZLP49lwkWu33bkDV9Y,1291
-ophyd_async/epics/areadetector/controllers/__init__.py,sha256=af58ci7X2z2s_FyUwR3IGQrws8q4TKcBw7vFyIS5FoI,217
-ophyd_async/epics/areadetector/controllers/ad_sim_controller.py,sha256=mthZ6WxajMEgUKptq3bnkIctbLhjzTagV66i1auB8cg,1587
-ophyd_async/epics/areadetector/controllers/aravis_controller.py,sha256=CIfnZdq_NobO_UMC2TJoAfUEP9GlzZg5z5bz6Dn1DxY,2669
-ophyd_async/epics/areadetector/controllers/kinetix_controller.py,sha256=9QmydX85QOXfQL_UX49M9EQ2b2hUZPVzLxgGQn-A9Oc,1611
-ophyd_async/epics/areadetector/controllers/pilatus_controller.py,sha256=6AiMz2yBA9xig-BrAIAc9CDxwM4Cjfebc4dd7QRutB0,2740
-ophyd_async/epics/areadetector/controllers/vimba_controller.py,sha256=Eh4Hr9rWgq1mKvE93JzgixntjPHxF3_07GTFqiOdZqE,2123
-ophyd_async/epics/areadetector/drivers/__init__.py,sha256=X-KdXw7YWNXpaUCXby2Spqvho2x2n72OavR-3mRlxzk,605
-ophyd_async/epics/areadetector/drivers/ad_base.py,sha256=OMySyCE9dcFRcVLC5Q0wUkri3QtRljIbn4KFdkumI4M,4553
-ophyd_async/epics/areadetector/drivers/aravis_driver.py,sha256=K1if0Nv1ZNEvcOha6NVYA9t9VqsBNxKCmbajlysGF2Q,1491
-ophyd_async/epics/areadetector/drivers/kinetix_driver.py,sha256=yIV23BkGBJ4i0VskLiLL7AFbadCCR6Ch1UwUDJ9r2YM,743
-ophyd_async/epics/areadetector/drivers/pilatus_driver.py,sha256=0DBBuiR_FtwzVVdDW0ifdSrdKZtnprWuy87g66o8RlQ,619
-ophyd_async/epics/areadetector/drivers/vimba_driver.py,sha256=J54VtWkOklfbSqZYxGWH1e6Uzm9_Gph_ZbCf9Zax0LU,1713
-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=ZpbVilNVv81OpbCrqaeZUoHLarrjzRWEGe-zI1Wxyyw,5436
-ophyd_async/epics/areadetector/writers/nd_file_hdf.py,sha256=EkiaEh_0U6Iz17jFi2IIsRPsVQTQIJRG8EPNCiAHkkU,1762
-ophyd_async/epics/areadetector/writers/nd_plugin.py,sha256=GUzaeTMdG07Rb1x0WzBBxMEltBhr10jb5dL29tEWXEQ,1547
-ophyd_async/epics/demo/__init__.py,sha256=ZcuZ66aIQ58WSydLOSKnk-h_W-aWjhDRZkWQA6f3sig,5790
-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=tqLV4TaW2MIapZsmx4wxnGOdKfkhxKLUPbTHA4YLdYE,3514
-ophyd_async/epics/pvi/__init__.py,sha256=TbOQNY4enQWgtr1T7x129vpo2p7FIFlr8cyZqqv5Lk4,158
-ophyd_async/epics/pvi/pvi.py,sha256=Kc3klnA9F82h_p2atFYXe-wFO9OzN5TV69Tc56tD2do,12204
-ophyd_async/epics/signal/__init__.py,sha256=JXKBSGpRL9y3auh27JRxsqDn_rBOXpJjtd4nCuDOX2g,261
-ophyd_async/epics/signal/_epics_transport.py,sha256=DEIL0iYUAWssysVEgWGu1fHSM1l-ATV2kjUgPtDN9LY,858
-ophyd_async/epics/signal/signal.py,sha256=M8ZVG_zLdYJfroCRX-u_w8c3yIhswSRw8e3RkW2szio,3166
-ophyd_async/panda/__init__.py,sha256=FuSnvp-RtdA0X4RcHEF0nTiXymRts2MNdFmF_1_i41w,775
-ophyd_async/panda/_common_blocks.py,sha256=OrA_mSJslxuhjIAD8Liye1-1yTl3DihqFDBXvJGlPFs,1088
-ophyd_async/panda/_hdf_panda.py,sha256=LWWQErG_cxM7zWqKG8c40O55ZpfTu3F70d4jVvRaeMo,1308
-ophyd_async/panda/_panda_controller.py,sha256=dIqcjmaIHVrki8UXSoDx46kk6I2Lhpe2o3sXNg5f-RQ,1238
-ophyd_async/panda/_table.py,sha256=keCGT66y91feO_MD3a6aMsgx27JuLYWLrAkl0lRXUKY,5854
-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=SP71y2-LTKhlNIFxLIddmtjmrg6MDwGvuwQ7X-5OP98,4698
-ophyd_async/panda/writers/_panda_hdf_file.py,sha256=WnGvNWuLe4KljhlmBLM4Y0HKSJCIBNWOwXxioPkGu6Y,1673
-ophyd_async/plan_stubs/__init__.py,sha256=nO9ELG9J7fYwfVTVRWVorz4kffeszYpwk1ROh6Ha--w,405
-ophyd_async/plan_stubs/ensure_connected.py,sha256=1MkDu8UqVRPHLnW9IXRn-QvKiG8-rCV8T4KDbjf9K6w,557
-ophyd_async/plan_stubs/fly.py,sha256=fQwBeLw57-NeBsroVxKDa8kpuu6fgTWYWimbsatCL28,4999
-ophyd_async/sim/__init__.py,sha256=ScjH1g7FMo5yPACfJRZE6xGBWCHU4bKDzNQk1tqObnA,366
-ophyd_async/sim/pattern_generator.py,sha256=pvSk2zb82D08j2jiKAMqMAfRohGnYd_rpjUraLrCD6c,10640
-ophyd_async/sim/sim_pattern_detector_control.py,sha256=Ypz8IuRYAY2J243IhVbNyGr_Z-XtpJZ1qxma6NR3TgM,1838
-ophyd_async/sim/sim_pattern_detector_writer.py,sha256=ESpcVyHd1TP7Cojznv2hJAwLinu3XbgAiVKfX12FCII,1237
-ophyd_async/sim/sim_pattern_generator.py,sha256=L4jTnEVUFBRXIWq_UMHqx00YDdbGO2pjo_IuuVwpzXE,1258
-ophyd_async/sim/demo/__init__.py,sha256=9mxKpslrL89cfSj4g3og8Br3O--pMj3hhWZS-Xu6kyA,56
-ophyd_async/sim/demo/sim_motor.py,sha256=a2p5wnHXjF-V5zOFai7jnszk4kbGmrZRnUqBtkOgEfQ,3733
-ophyd_async-0.3.4a1.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.3.4a1.dist-info/METADATA,sha256=JNwQkJEsOunynK3sUNPtQMHoTBBf8M7kfrl7HDTJYHM,6294
-ophyd_async-0.3.4a1.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
-ophyd_async-0.3.4a1.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
-ophyd_async-0.3.4a1.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.3.4a1.dist-info/RECORD,,