ophyd-async 0.3a2__py3-none-any.whl → 0.3a4__py3-none-any.whl

ophyd_async/epics/motion/motor.py

@@ -4,7 +4,7 @@ from typing import Callable, List, Optional
 
 from bluesky.protocols import Movable, Stoppable
 
-from ophyd_async.core import AsyncStatus, StandardReadable
+from ophyd_async.core import AsyncStatus, ConfigSignal, HintedSignal, StandardReadable
 
 from ..signal.signal import epics_signal_r, epics_signal_rw, epics_signal_x
 
@@ -14,26 +14,25 @@ class Motor(StandardReadable, Movable, Stoppable):
 
     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.user_readback = epics_signal_r(float, prefix + ".RBV")
-        self.velocity = epics_signal_rw(float, prefix + ".VELO")
         self.max_velocity = epics_signal_r(float, prefix + ".VMAX")
         self.acceleration_time = epics_signal_rw(float, prefix + ".ACCL")
-        self.motor_egu = epics_signal_r(str, prefix + ".EGU")
         self.precision = epics_signal_r(int, prefix + ".PREC")
         self.deadband = epics_signal_r(float, prefix + ".RDBD")
-        self.motor_done_move = epics_signal_r(float, prefix + ".DMOV")
-        self.low_limit_travel = epics_signal_rw(int, prefix + ".LLM")
-        self.high_limit_travel = epics_signal_rw(int, prefix + ".HLM")
+        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
-        # Set name and signals for read() and read_configuration()
-        self.set_readable_signals(
-            read=[self.user_readback],
-            config=[self.velocity, self.motor_egu],
-        )
         super().__init__(name=name)
 
     def set_name(self, name: str):
@@ -41,7 +40,11 @@ class Motor(StandardReadable, Movable, Stoppable):
         # Readback should be named the same as its parent in read()
         self.user_readback.set_name(name)
 
-    async def _move(self, new_position: float, watchers: List[Callable] = []):
+    async def _move(
+        self, new_position: float, watchers: Optional[List[Callable]] = None
+    ):
+        if watchers is None:
+            watchers = []
         self._set_success = True
         start = time.monotonic()
         old_position, units, precision = await asyncio.gather(

ophyd_async/epics/pvi/pvi.py

@@ -17,7 +17,7 @@ from typing import (
     get_type_hints,
 )
 
-from ophyd_async.core import Device, DeviceVector, SimSignalBackend
+from ophyd_async.core import Device, DeviceVector, SoftSignalBackend
 from ophyd_async.core.signal import Signal
 from ophyd_async.core.utils import DEFAULT_TIMEOUT
 from ophyd_async.epics._backend._p4p import PvaSignalBackend
@@ -156,7 +156,7 @@ def _parse_type(
     return is_device_vector, is_signal, signal_dtype, device_cls
 
 
-def _sim_common_blocks(device: Device, stripped_type: Optional[Type] = None):
+def _mock_common_blocks(device: Device, stripped_type: Optional[Type] = None):
     device_t = stripped_type or type(device)
     sub_devices = (
         (field, field_type)
@@ -175,23 +175,23 @@ def _sim_common_blocks(device: Device, stripped_type: Optional[Type] = None):
 
         if is_device_vector:
             if is_signal:
-                sub_device_1 = device_cls(SimSignalBackend(signal_dtype))
-                sub_device_2 = device_cls(SimSignalBackend(signal_dtype))
+                sub_device_1 = device_cls(SoftSignalBackend(signal_dtype))
+                sub_device_2 = device_cls(SoftSignalBackend(signal_dtype))
                 sub_device = DeviceVector({1: sub_device_1, 2: sub_device_2})
             else:
                 sub_device = DeviceVector({1: device_cls(), 2: device_cls()})
 
                 for sub_device_in_vector in sub_device.values():
-                    _sim_common_blocks(sub_device_in_vector, stripped_type=device_cls)
+                    _mock_common_blocks(sub_device_in_vector, stripped_type=device_cls)
 
             for value in sub_device.values():
                 value.parent = sub_device
         else:
             if is_signal:
-                sub_device = device_cls(SimSignalBackend(signal_dtype))
+                sub_device = device_cls(SoftSignalBackend(signal_dtype))
             else:
                 sub_device = getattr(device, device_name, device_cls())
-                _sim_common_blocks(sub_device, stripped_type=device_cls)
+                _mock_common_blocks(sub_device, stripped_type=device_cls)
 
         setattr(device, device_name, sub_device)
         sub_device.parent = device
@@ -269,16 +269,16 @@ def _set_device_attributes(entry: PVIEntry):
 
 
 async def fill_pvi_entries(
-    device: Device, root_pv: str, timeout=DEFAULT_TIMEOUT, sim=False
+    device: Device, root_pv: str, timeout=DEFAULT_TIMEOUT, mock=False
 ):
     """
     Fills a ``device`` with signals from a the ``root_pvi:PVI`` table.
 
     If the device names match with parent devices of ``device`` then types are used.
     """
-    if sim:
-        # set up sim signals for the common annotations
-        _sim_common_blocks(device)
+    if mock:
+        # set up mock signals for the common annotations
+        _mock_common_blocks(device)
     else:
         # check the pvi table for devices and fill the device with them
         root_entry = PVIEntry(

ophyd_async/epics/signal/signal.py

@@ -79,7 +79,7 @@ def epics_signal_r(datatype: Type[T], read_pv: str, name: str = "") -> SignalR[T
     """Create a `SignalR` backed by 1 EPICS PV
 
     Parameters
-    ---------
+    ----------
     datatype
         Check that the PV is of this type
     read_pv:

ophyd_async/log.py

@@ -0,0 +1,130 @@
+import logging
+import sys
+
+import colorlog
+
+__all__ = (
+    "config_ophyd_async_logging",
+    "logger",
+    "set_handler",
+)
+
+DEFAULT_FORMAT = (
+    "%(log_color)s[%(levelname)1.1s %(asctime)s.%(msecs)03d "
+    "%(module)s:%(lineno)d] %(message)s"
+)
+
+DEFAULT_DATE_FORMAT = "%y%m%d %H:%M:%S"
+
+DEFAULT_LOG_COLORS = {
+    "DEBUG": "cyan",
+    "INFO": "green",
+    "WARNING": "yellow",
+    "ERROR": "red",
+    "CRITICAL": "red,bg_white",
+}
+
+
+class ColoredFormatterWithDeviceName(colorlog.ColoredFormatter):
+    def format(self, record):
+        message = super().format(record)
+        if hasattr(record, "ophyd_async_device_name"):
+            message = f"[{record.ophyd_async_device_name}]{message}"
+        return message
+
+
+def _validate_level(level) -> int:
+    """
+    Return an int for level comparison
+    """
+    if isinstance(level, int):
+        levelno = level
+    elif isinstance(level, str):
+        levelno = logging.getLevelName(level)
+
+    if isinstance(levelno, int):
+        return levelno
+    else:
+        raise ValueError(
+            "Your level is illegal, please use "
+            "'CRITICAL', 'FATAL', 'ERROR', 'WARNING', 'INFO', or 'DEBUG'."
+        )
+
+
+logger = logging.getLogger("ophyd_async")
+
+current_handler = None  # overwritten below
+
+
+def config_ophyd_async_logging(
+    file=sys.stdout,
+    fmt=DEFAULT_FORMAT,
+    datefmt=DEFAULT_DATE_FORMAT,
+    color=True,
+    level="WARNING",
+):
+    """
+    Set a new handler on the ``logging.getLogger('ophyd_async')`` logger.
+    If this is called more than once, the handler from the previous invocation
+    is removed (if still present) and replaced.
+
+    Parameters
+    ----------
+    file : object with ``write`` method or filename string
+        Default is ``sys.stdout``.
+    fmt : Overall logging format
+    datefmt : string
+        Date format. Default is ``'%H:%M:%S'``.
+    color : boolean
+        Use ANSI color codes. True by default.
+    level : str or int
+        Python logging level, given as string or corresponding integer.
+        Default is 'WARNING'.
+    Returns
+    -------
+    handler : logging.Handler
+        The handler, which has already been added to the 'ophyd_async' logger.
+    Examples
+    --------
+    Log to a file.
+        config_ophyd_async_logging(file='/tmp/what_is_happening.txt')
+    Include the date along with the time. (The log messages will always include
+    microseconds, which are configured separately, not as part of 'datefmt'.)
+        config_ophyd_async_logging(datefmt="%Y-%m-%d %H:%M:%S")
+    Turn off ANSI color codes.
+        config_ophyd_async_logging(color=False)
+    Increase verbosity: show level DEBUG or higher.
+        config_ophyd_async_logging(level='DEBUG')
+    """
+    global current_handler
+
+    if isinstance(file, str):
+        handler = logging.FileHandler(file)
+        formatter = ColoredFormatterWithDeviceName(
+            fmt=fmt, datefmt=datefmt, no_color=True
+        )
+    else:
+        handler = colorlog.StreamHandler(file)
+        formatter = ColoredFormatterWithDeviceName(
+            fmt=fmt, datefmt=datefmt, log_colors=DEFAULT_LOG_COLORS, no_color=color
+        )
+
+    levelno = _validate_level(level)
+    handler.setFormatter(formatter)
+    handler.setLevel(levelno)
+
+    if current_handler in logger.handlers:
+        logger.removeHandler(current_handler)
+    logger.addHandler(handler)
+
+    current_handler = handler
+
+    if logger.getEffectiveLevel() > levelno:
+        logger.setLevel(levelno)
+    try:
+        return handler
+    finally:
+        handler.close()
+
+
+set_handler = config_ophyd_async_logging  # for back-compat

ophyd_async/panda/_hdf_panda.py

@@ -42,7 +42,7 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
         )
 
     async def connect(
-        self, sim: bool = False, timeout: float = DEFAULT_TIMEOUT
+        self, mock: bool = False, timeout: float = DEFAULT_TIMEOUT
     ) -> None:
-        await fill_pvi_entries(self, self._prefix + "PVI", timeout=timeout, sim=sim)
-        await super().connect(sim=sim, timeout=timeout)
+        await fill_pvi_entries(self, self._prefix + "PVI", timeout=timeout, mock=mock)
+        await super().connect(mock=mock, timeout=timeout)

ophyd_async/panda/writers/_hdf_writer.py

@@ -4,7 +4,7 @@ from enum import Enum
 from pathlib import Path
 from typing import Any, AsyncGenerator, AsyncIterator, Dict, List, Optional
 
-from bluesky.protocols import Descriptor, StreamAsset
+from bluesky.protocols import DataKey, StreamAsset
 from p4p.client.thread import Context
 
 from ophyd_async.core import (
@@ -107,7 +107,7 @@ class PandaHDFWriter(DetectorWriter):
         self._multiplier = 1
 
     # Triggered on PCAP arm
-    async def open(self, multiplier: int = 1) -> Dict[str, Descriptor]:
+    async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
         """Retrieve and get descriptor of all PandA signals marked for capture"""
 
         # Get capture PVs by looking at panda. Gives mapping of dotted attribute path
@@ -162,7 +162,7 @@ class PandaHDFWriter(DetectorWriter):
                 )
 
         describe = {
-            ds.name: Descriptor(
+            ds.name: DataKey(
                 source=self.panda_device.data.hdf_directory.source,
                 shape=ds.shape,
                 dtype="array" if ds.shape != [1] else "number",

ophyd_async/protocols.py

@@ -1,7 +1,9 @@
 from abc import abstractmethod
 from typing import Dict, Protocol, runtime_checkable
 
-from bluesky.protocols import Descriptor, HasName, Reading
+from bluesky.protocols import DataKey, HasName, Reading
+
+from ophyd_async.core.async_status import AsyncStatus
 
 
 @runtime_checkable
@@ -23,7 +25,7 @@ class AsyncReadable(HasName, Protocol):
         ...
 
     @abstractmethod
-    async def describe(self) -> Dict[str, Descriptor]:
+    async def describe(self) -> Dict[str, DataKey]:
         """Return an OrderedDict with exactly the same keys as the ``read``
         method, here mapped to per-scan metadata about each field.
 
@@ -53,7 +55,7 @@ class AsyncConfigurable(Protocol):
         ...
 
     @abstractmethod
-    async def describe_configuration(self) -> Dict[str, Descriptor]:
+    async def describe_configuration(self) -> Dict[str, DataKey]:
         """Same API as ``describe``, but corresponding to the keys in
         ``read_configuration``.
         """
@@ -71,3 +73,24 @@ class AsyncPausable(Protocol):
     async def resume(self) -> None:
         """Perform device-specific work when the RunEngine resumes after a pause."""
         ...
+
+
+@runtime_checkable
+class AsyncStageable(Protocol):
+    @abstractmethod
+    def stage(self) -> AsyncStatus:
+        """An optional hook for "setting up" the device for acquisition.
+
+        It should return a ``Status`` that is marked done when the device is
+        done staging.
+        """
+        ...
+
+    @abstractmethod
+    def unstage(self) -> AsyncStatus:
+        """A hook for "cleaning up" the device after acquisition.
+
+        It should return a ``Status`` that is marked done when the device is finished
+        unstaging.
+        """
+        ...

ophyd_async/sim/demo/sim_motor.py

@@ -6,7 +6,8 @@ from bluesky.protocols import Movable, Stoppable
 
 from ophyd_async.core import StandardReadable
 from ophyd_async.core.async_status import AsyncStatus
-from ophyd_async.core.signal import soft_signal_r_and_backend, soft_signal_rw
+from ophyd_async.core.signal import soft_signal_r_and_setter, soft_signal_rw
+from ophyd_async.core.standard_readable import ConfigSignal, HintedSignal
 
 
 class SimMotor(StandardReadable, Movable, Stoppable):
@@ -19,20 +20,21 @@ class SimMotor(StandardReadable, Movable, Stoppable):
         - name: str: name of device
         - instant: bool: whether to move instantly, or with a delay
         """
+        with self.add_children_as_readables(HintedSignal):
+            self.user_readback, self._user_readback_set = soft_signal_r_and_setter(
+                float, 0
+            )
+
+        with self.add_children_as_readables(ConfigSignal):
+            self.velocity = soft_signal_rw(float, 1.0)
+            self.egu = soft_signal_rw(float, "mm")
+
         self._instant = instant
         self._move_task: Optional[asyncio.Task] = None
 
         # Define some signals
         self.user_setpoint = soft_signal_rw(float, 0)
-        self.user_readback, self._user_readback = soft_signal_r_and_backend(float, 0)
-        self.velocity = soft_signal_rw(float, 1.0)
-        self.egu = soft_signal_rw(float, "mm")
-
-        # Set name and signals for read() and read_configuration()
-        self.set_readable_signals(
-            read=[self.user_readback],
-            config=[self.velocity, self.egu],
-        )
+
         super().__init__(name=name)
 
         # Whether set() should complete successfully or not
@@ -82,7 +84,7 @@ class SimMotor(StandardReadable, Movable, Stoppable):
                 # update position based on time elapsed
                 if time_elapsed >= travel_time:
                     # successfully reached our target position
-                    await self._user_readback.put(new_position)
+                    self._user_readback_set(new_position)
                     self._set_success = True
                     break
                 else:
@@ -90,7 +92,7 @@ class SimMotor(StandardReadable, Movable, Stoppable):
                         old_position + distance * time_elapsed / travel_time
                     )
 
-                await self._user_readback.put(current_position)
+                self._user_readback_set(current_position)
 
                 # notify watchers of the new position
                 for watcher in watchers:

ophyd_async/sim/pattern_generator.py

@@ -13,7 +13,7 @@ from typing import (
 
 import h5py
 import numpy as np
-from bluesky.protocols import Descriptor, StreamAsset
+from bluesky.protocols import DataKey, StreamAsset
 from event_model import (
     ComposeStreamResource,
     ComposeStreamResourceBundle,
@@ -23,8 +23,8 @@ from event_model import (
 )
 
 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.sim_signal_backend import SimSignalBackend
 from ophyd_async.core.utils import DEFAULT_TIMEOUT
 
 # raw data path
@@ -52,12 +52,12 @@ class DatasetConfig:
 def get_full_file_description(
     datasets: List[DatasetConfig], outer_shape: tuple[int, ...]
 ):
-    full_file_description: Dict[str, Descriptor] = {}
+    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 = Descriptor(
+        descriptor = DataKey(
             source=source, shape=shape, dtype=dtype, external="STREAM:"
         )
         key = d.name.replace("/", "_")
@@ -158,8 +158,8 @@ class PatternGenerator:
         self.written_images_counter: int = 0
 
         # it automatically initializes to 0
-        self.signal_backend = SimSignalBackend(int)
-        self.sim_signal = SignalR(self.signal_backend)
+        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
@@ -219,8 +219,8 @@ class PatternGenerator:
 
     async def open_file(
         self, directory: DirectoryProvider, multiplier: int = 1
-    ) -> Dict[str, Descriptor]:
-        await self.sim_signal.connect()
+    ) -> Dict[str, DataKey]:
+        await self.mock_signal.connect()
 
         self.target_path = self._get_new_path(directory)
 
@@ -314,5 +314,5 @@ class PatternGenerator:
     async def observe_indices_written(
         self, timeout=DEFAULT_TIMEOUT
     ) -> AsyncGenerator[int, None]:
-        async for num_captured in observe_value(self.sim_signal, timeout=timeout):
+        async for num_captured in observe_value(self.mock_signal, timeout=timeout):
             yield num_captured // self.multiplier

ophyd_async/sim/sim_pattern_detector_writer.py

@@ -1,6 +1,6 @@
 from typing import AsyncGenerator, AsyncIterator, Dict
 
-from bluesky.protocols import Descriptor
+from bluesky.protocols import DataKey
 
 from ophyd_async.core import DirectoryProvider
 from ophyd_async.core.detector import DetectorWriter
@@ -16,7 +16,7 @@ class SimPatternDetectorWriter(DetectorWriter):
         self.pattern_generator = pattern_generator
         self.directory_provider = directoryProvider
 
-    async def open(self, multiplier: int = 1) -> Dict[str, Descriptor]:
+    async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
         return await self.pattern_generator.open_file(
             self.directory_provider, multiplier
         )

ophyd_async/sim/sim_pattern_generator.py

@@ -3,7 +3,7 @@ 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.protocols import AsyncReadable
 from ophyd_async.sim.pattern_generator import PatternGenerator
 
 from .sim_pattern_detector_control import SimPatternDetectorControl
@@ -14,7 +14,7 @@ class SimPatternDetector(StandardDetector):
     def __init__(
         self,
         path: Path,
-        config_sigs: Sequence[SignalR] = [],
+        config_sigs: Sequence[AsyncReadable] = [],
         name: str = "sim_pattern_detector",
         writer_timeout: float = 1,
     ) -> None:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3a2
+Version: 0.3a4
 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
@@ -48,6 +48,7 @@ Requires-Dist: bluesky >=1.13.0a3
 Requires-Dist: event-model <1.21.0
 Requires-Dist: p4p
 Requires-Dist: pyyaml
+Requires-Dist: colorlog
 Provides-Extra: ca
 Requires-Dist: aioca >=1.6 ; extra == 'ca'
 Provides-Extra: dev
@@ -70,7 +71,7 @@ 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 ==6.6.2 ; extra == 'dev'
+Requires-Dist: pyside6 ==6.7.0 ; extra == 'dev'
 Requires-Dist: pytest ; extra == 'dev'
 Requires-Dist: pytest-asyncio ; extra == 'dev'
 Requires-Dist: pytest-cov ; extra == 'dev'
@@ -79,6 +80,7 @@ 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: sphinxcontrib-mermaid ; extra == 'dev'
 Requires-Dist: sphinx-copybutton ; extra == 'dev'
 Requires-Dist: sphinx-design ; extra == 'dev'
 Requires-Dist: tox-direct ; extra == 'dev'
@@ -92,7 +94,7 @@ Requires-Dist: p4p ; extra == 'pva'
 [![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)
 
-# ophyd_async
+# ophyd-async
 
 Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 
@@ -102,6 +104,21 @@ Asynchronous Bluesky hardware abstraction code, compatible with control systems
 | Documentation |      <https://bluesky.github.io/ophyd-async>      |
 |   Releases    | <https://github.com/bluesky/ophyd-async/releases> |
 
+Ophyd-async is a 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.
+
+Both ophyd and ophyd-async are typically used with the [Bluesky Run Engine][] for experiment orchestration and data acquisition.
+
+While [EPICS][] is the most common control system layer that ophyd-async can interface with, support for other control systems like [Tango][] will be supported in the future. The focus of ophyd-async is:
+
+* 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
+
+[Bluesky Run Engine]: http://blueskyproject.io/bluesky
+[EPICS]: http://www.aps.anl.gov/epics/
+[Tango]: https://www.tango-controls.org/
+
 <!-- README only content. Anything below this line won't be included in index.md -->
 
 See https://bluesky.github.io/ophyd-async for more detailed documentation.

ophyd_async-0.3a4.dist-info/RECORD

@@ -0,0 +1,85 @@
+ophyd_async/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
+ophyd_async/__main__.py,sha256=G-Zcv_G9zK7Nhx6o5L5w-wyhMxdl_WgyMELu8IMFqAE,328
+ophyd_async/_version.py,sha256=KnUL22nu-ueGx6I5b6OJXJXe49pxXyZLEJ7g8y71WnM,408
+ophyd_async/log.py,sha256=DbMjt0bkfUOLHIinZYt0Q0FHZmCXXi5x8y0uFiEmqoQ,3587
+ophyd_async/protocols.py,sha256=48jqS78KAMvy6LmenL21ARoTAD8oOL9YdVmIlI0E0VA,2890
+ophyd_async/core/__init__.py,sha256=h1jha-uq0_QfQx2ZD8wit5a58doHfNebyK1mxHMKTUI,2843
+ophyd_async/core/_providers.py,sha256=LrlTMPHKXWOPVkpAOw-pqBq0kip-c3C9ZZPoFfiaV4M,2212
+ophyd_async/core/async_status.py,sha256=7cf5vfOaP6qZ8GW7sl--IZOi8CaLfPM5ULa8H1K3aeA,2803
+ophyd_async/core/detector.py,sha256=OkdaaJnj2v8DKF4k7VsTo8ReAvIzyFjBqbqdiYf7FBE,11179
+ophyd_async/core/device.py,sha256=xoxz0Iz4vovOWwpUzecDFLtLyJb_aLVi2EBnwxMyeMQ,6209
+ophyd_async/core/device_save_loader.py,sha256=RXA3dPUPihAR2ZGDStlGiA-TAsr_xqL0snsCjMsMnfA,9138
+ophyd_async/core/flyer.py,sha256=LfO3EQTW2zMeNqZh8TLXvE92E30Duds2RXskRYAdJ_4,2299
+ophyd_async/core/mock_signal_backend.py,sha256=MZQr1oGv2ssnAK9WxItthiZogCh8rw4BL2N4YoHCgww,3041
+ophyd_async/core/mock_signal_utils.py,sha256=weaH1PnjyzIxo2FmhLwx4o5i-X71srvvvsHsN3C4XqY,4267
+ophyd_async/core/signal.py,sha256=zjfS_QuPNx9bm8K4tpZYrxqba5A1CHAlRPYg1kokrAQ,14674
+ophyd_async/core/signal_backend.py,sha256=qDdWz8X4CWStuYknxcj4G76BLq4TzrAIyZO1NOEq9ao,1519
+ophyd_async/core/soft_signal_backend.py,sha256=56zvcEi4c8n1yYbafTbp7X0VhSkhoehm3L8RBhu2fik,5596
+ophyd_async/core/standard_readable.py,sha256=uVG3vs3s7-Kzg5dRCtT4I2mhZPqwVGYy2dxNmaOpDVU,8980
+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=cpPNZmRMi7FnAh2-3ec5uklLVFOqsmEmpI1nh5Ud1Ls,8794
+ophyd_async/epics/_backend/_p4p.py,sha256=lIKx7kQ2o8h3M4wPwrq8JBo8xuDnasJxpDH2ATVBY78,12257
+ophyd_async/epics/_backend/common.py,sha256=16mAuxDwA3eZFjUW8DHMabaW3CtEI0Qe8DLpP2xlW7Y,814
+ophyd_async/epics/areadetector/__init__.py,sha256=ViKzx-wUxkRyNR33wfpL11QB97o0J47_KMyI2C_NphI,510
+ophyd_async/epics/areadetector/aravis.py,sha256=ujO82hYZ5D5GIaBhz0JNC2G5uVSgowY8xxsY2tunzi4,2277
+ophyd_async/epics/areadetector/kinetix.py,sha256=7rE2MLnz9DEmeiN9pCekDfpXuZ2DErnMajRp_9eoLZY,1359
+ophyd_async/epics/areadetector/pilatus.py,sha256=ki-BOBCEIiUD2wAtmujBIB1eX-nbXB4yMLJK_Q3opRM,1398
+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=vRiSexnFzijG8eEwowMAFIe730xFNMmgjjbXQVi4zrc,2394
+ophyd_async/epics/areadetector/controllers/kinetix_controller.py,sha256=9QmydX85QOXfQL_UX49M9EQ2b2hUZPVzLxgGQn-A9Oc,1611
+ophyd_async/epics/areadetector/controllers/pilatus_controller.py,sha256=cd1CKkaXlwkpQ0I1VL7nN0U8R4VweTsa08WhvHYI4nY,2243
+ophyd_async/epics/areadetector/controllers/vimba_controller.py,sha256=Eh4Hr9rWgq1mKvE93JzgixntjPHxF3_07GTFqiOdZqE,2123
+ophyd_async/epics/areadetector/drivers/__init__.py,sha256=-Ib0Lz4fFQQmB7K0uFxMDvAerkLxadMQERH7lNAvrs4,495
+ophyd_async/epics/areadetector/drivers/ad_base.py,sha256=cE7I-IsfQz3UR9yqghy4czAxHeHERTTKe080GB9sCFQ,3847
+ophyd_async/epics/areadetector/drivers/aravis_driver.py,sha256=2KbfcsAN2lYXWDc773KS0tE37Fw5gs7IATbDBOyLD-8,5704
+ophyd_async/epics/areadetector/drivers/kinetix_driver.py,sha256=yIV23BkGBJ4i0VskLiLL7AFbadCCR6Ch1UwUDJ9r2YM,743
+ophyd_async/epics/areadetector/drivers/pilatus_driver.py,sha256=0DsUu9vAPXDa2v8_V0f_kPjBtLu3y4_EkmFfFjYO4Gk,553
+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=e7EbusP3Ell-2npdLtDWcZ_kDIRidUwHeqcbeMx4mlU,5427
+ophyd_async/epics/areadetector/writers/nd_file_hdf.py,sha256=whKDkvKnU1qiDym4xQq4Fd1jHEhtDu552xhhGSnB--w,1910
+ophyd_async/epics/areadetector/writers/nd_plugin.py,sha256=sG4XZAS_k065g88n9U3IJGtYI4PPHfyJMcVqh9hVAa4,979
+ophyd_async/epics/demo/__init__.py,sha256=D-jYrorqa5C3gLzIi2Hkn8f8uaE9wb5S-WX3YYuHV48,6052
+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=9sWF2oawtKLL1JZIT8FZc8WtKhrZVKfmwgyQv0x48B4,3826
+ophyd_async/epics/pvi/__init__.py,sha256=TbOQNY4enQWgtr1T7x129vpo2p7FIFlr8cyZqqv5Lk4,158
+ophyd_async/epics/pvi/pvi.py,sha256=5Hd9BkULbVv9mCmEn3LFafs2oz77xqlGHn-X48nJ-4o,11331
+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=M8ZVG_zLdYJfroCRX-u_w8c3yIhswSRw8e3RkW2szio,3166
+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=QjfZyYos0ZBlIqBiZ5UbyEd_wuh_cGzwV8QE9jvLiIY,1419
+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=_KlawqQHuWXLCvhGg1N6S4dQ8LhM88NbHsbXryxPvPA,7617
+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=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=fbcwWxTPYKLK33OzIY15vGylnonOO8HIudz1y_56GZU,1336
+ophyd_async/sim/demo/__init__.py,sha256=9mxKpslrL89cfSj4g3og8Br3O--pMj3hhWZS-Xu6kyA,56
+ophyd_async/sim/demo/sim_motor.py,sha256=knpfyrqeNr7HnlV54TQGUr3pLnDyg84vfj_4vKB9UYc,4065
+ophyd_async-0.3a4.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.3a4.dist-info/METADATA,sha256=wPoVN6LuWFSMlFzEaAriOPfJD-XncaJHVzpao8HUBlg,6284
+ophyd_async-0.3a4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+ophyd_async-0.3a4.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
+ophyd_async-0.3a4.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.3a4.dist-info/RECORD,,