ophyd-async 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.4.0'
-__version_tuple__ = version_tuple = (0, 4, 0)
+__version__ = version = '0.5.0'
+__version_tuple__ = version_tuple = (0, 5, 0)

ophyd_async/core/__init__.py

@@ -1,26 +1,13 @@
-from ._providers import (
-    AutoIncrementFilenameProvider,
-    AutoIncrementingPathProvider,
-    FilenameProvider,
-    NameProvider,
-    PathInfo,
-    PathProvider,
-    ShapeProvider,
-    StaticFilenameProvider,
-    StaticPathProvider,
-    UUIDFilenameProvider,
-    YMDPathProvider,
-)
-from .async_status import AsyncStatus, WatchableAsyncStatus
-from .detector import (
+from ._detector import (
     DetectorControl,
     DetectorTrigger,
     DetectorWriter,
     StandardDetector,
     TriggerInfo,
 )
-from .device import Device, DeviceCollector, DeviceVector
-from .device_save_loader import (
+from ._device import Device, DeviceCollector, DeviceVector
+from ._device_save_loader import (
+    all_at_once,
     get_signal_values,
     load_device,
     load_from_yaml,
@@ -29,9 +16,11 @@ from .device_save_loader import (
     set_signal_values,
     walk_rw_signals,
 )
-from .flyer import HardwareTriggeredFlyable, TriggerLogic
-from .mock_signal_backend import MockSignalBackend
-from .mock_signal_utils import (
+from ._flyer import StandardFlyer, TriggerLogic
+from ._hdf_dataset import HDFDataset, HDFFile
+from ._log import config_ophyd_async_logging
+from ._mock_signal_backend import MockSignalBackend
+from ._mock_signal_utils import (
     callback_on_mock_put,
     get_mock_put,
     mock_puts_blocked,
@@ -40,7 +29,22 @@ from .mock_signal_utils import (
     set_mock_value,
     set_mock_values,
 )
-from .signal import (
+from ._protocol import AsyncConfigurable, AsyncReadable, AsyncStageable
+from ._providers import (
+    AutoIncrementFilenameProvider,
+    AutoIncrementingPathProvider,
+    FilenameProvider,
+    NameProvider,
+    PathInfo,
+    PathProvider,
+    ShapeProvider,
+    StaticFilenameProvider,
+    StaticPathProvider,
+    UUIDFilenameProvider,
+    YMDPathProvider,
+)
+from ._readable import ConfigSignal, HintedSignal, StandardReadable
+from ._signal import (
     Signal,
     SignalR,
     SignalRW,
@@ -56,93 +60,100 @@ from .signal import (
     soft_signal_rw,
     wait_for_value,
 )
-from .signal_backend import RuntimeSubsetEnum, SignalBackend, SubsetEnum
-from .soft_signal_backend import SoftSignalBackend
-from .standard_readable import ConfigSignal, HintedSignal, StandardReadable
-from .utils import (
+from ._signal_backend import RuntimeSubsetEnum, SignalBackend, SubsetEnum
+from ._soft_signal_backend import SignalMetadata, SoftSignalBackend
+from ._status import AsyncStatus, WatchableAsyncStatus
+from ._utils import (
     DEFAULT_TIMEOUT,
     CalculatableTimeout,
     CalculateTimeout,
-    Callback,
     NotConnected,
     ReadingValueCallback,
     T,
+    WatcherUpdate,
     get_dtype,
     get_unique,
-    merge_gathered_dicts,
+    in_micros,
     wait_for_connection,
 )
 
 __all__ = [
-    "AsyncStatus",
-    "AutoIncrementFilenameProvider",
-    "AutoIncrementingPathProvider",
-    "CalculatableTimeout",
-    "CalculateTimeout",
-    "Callback",
-    "ConfigSignal",
-    "DEFAULT_TIMEOUT",
     "DetectorControl",
     "DetectorTrigger",
     "DetectorWriter",
+    "StandardDetector",
+    "TriggerInfo",
     "Device",
     "DeviceCollector",
     "DeviceVector",
-    "FilenameProvider",
-    "HardwareTriggeredFlyable",
-    "HintedSignal",
+    "all_at_once",
+    "get_signal_values",
+    "load_device",
+    "load_from_yaml",
+    "save_device",
+    "save_to_yaml",
+    "set_signal_values",
+    "walk_rw_signals",
+    "StandardFlyer",
+    "TriggerLogic",
+    "HDFDataset",
+    "HDFFile",
+    "config_ophyd_async_logging",
     "MockSignalBackend",
+    "callback_on_mock_put",
+    "get_mock_put",
+    "mock_puts_blocked",
+    "reset_mock_put_calls",
+    "set_mock_put_proceeds",
+    "set_mock_value",
+    "set_mock_values",
+    "AsyncConfigurable",
+    "AsyncReadable",
+    "AsyncStageable",
+    "AutoIncrementFilenameProvider",
+    "AutoIncrementingPathProvider",
+    "FilenameProvider",
     "NameProvider",
-    "NotConnected",
     "PathInfo",
     "PathProvider",
-    "ReadingValueCallback",
-    "RuntimeSubsetEnum",
     "ShapeProvider",
+    "StaticFilenameProvider",
+    "StaticPathProvider",
+    "UUIDFilenameProvider",
+    "YMDPathProvider",
+    "ConfigSignal",
+    "HintedSignal",
+    "StandardReadable",
     "Signal",
-    "SignalBackend",
     "SignalR",
     "SignalRW",
     "SignalW",
     "SignalX",
-    "SoftSignalBackend",
-    "StandardDetector",
-    "StandardReadable",
-    "StaticFilenameProvider",
-    "StaticPathProvider",
-    "SubsetEnum",
-    "T",
-    "TriggerInfo",
-    "TriggerLogic",
-    "UUIDFilenameProvider",
-    "WatchableAsyncStatus",
-    "YMDPathProvider",
-    # Lower-cased imports
     "assert_configuration",
     "assert_emitted",
     "assert_reading",
     "assert_value",
-    "callback_on_mock_put",
-    "get_dtype",
-    "get_mock_put",
-    "get_signal_values",
-    "get_unique",
-    "load_device",
-    "load_from_yaml",
-    "merge_gathered_dicts",
-    "mock_puts_blocked",
     "observe_value",
-    "reset_mock_put_calls",
-    "save_device",
-    "save_to_yaml",
     "set_and_wait_for_value",
-    "set_mock_put_proceeds",
-    "set_mock_value",
-    "set_mock_values",
-    "set_signal_values",
     "soft_signal_r_and_setter",
     "soft_signal_rw",
-    "wait_for_connection",
     "wait_for_value",
-    "walk_rw_signals",
+    "RuntimeSubsetEnum",
+    "SignalBackend",
+    "SubsetEnum",
+    "SignalMetadata",
+    "SoftSignalBackend",
+    "AsyncStatus",
+    "WatchableAsyncStatus",
+    "DEFAULT_TIMEOUT",
+    "CalculatableTimeout",
+    "CalculateTimeout",
+    "NotConnected",
+    "ReadingValueCallback",
+    "T",
+    "WatcherUpdate",
+    "get_dtype",
+    "get_unique",
+    "in_micros",
+    "wait_for_connection",
 ]

ophyd_async/core/{detector.py → _detector.py}

@@ -13,7 +13,6 @@ from typing import (
     List,
     Optional,
     Sequence,
-    TypeVar,
 )
 
 from bluesky.protocols import (
@@ -29,13 +28,10 @@ from bluesky.protocols import (
 )
 from pydantic import BaseModel, Field
 
-from ophyd_async.protocols import AsyncConfigurable, AsyncReadable
-
-from .async_status import AsyncStatus, WatchableAsyncStatus
-from .device import Device
-from .utils import DEFAULT_TIMEOUT, WatcherUpdate, merge_gathered_dicts
-
-T = TypeVar("T")
+from ._device import Device
+from ._protocol import AsyncConfigurable, AsyncReadable
+from ._status import AsyncStatus, WatchableAsyncStatus
+from ._utils import DEFAULT_TIMEOUT, T, WatcherUpdate, merge_gathered_dicts
 
 
 class DetectorTrigger(str, Enum):

ophyd_async/core/{device.py → _device.py}

@@ -19,7 +19,7 @@ from typing import (
 from bluesky.protocols import HasName
 from bluesky.run_engine import call_in_bluesky_event_loop
 
-from .utils import DEFAULT_TIMEOUT, NotConnected, wait_for_connection
+from ._utils import DEFAULT_TIMEOUT, NotConnected, wait_for_connection
 
 
 class Device(HasName):

ophyd_async/core/{device_save_loader.py → _device_save_loader.py}

@@ -8,8 +8,8 @@ from bluesky.plan_stubs import abs_set, wait
 from bluesky.protocols import Location
 from bluesky.utils import Msg
 
-from .device import Device
-from .signal import SignalRW
+from ._device import Device
+from ._signal import SignalRW
 
 
 def ndarray_representer(dumper: yaml.Dumper, array: npt.NDArray[Any]) -> yaml.Node:
@@ -241,7 +241,7 @@ def save_device(
     Therefore, users should consider the order of device loading and write their
     own sorter algorithms accordingly.
 
-    See :func:`ophyd_async.panda.phase_sorter` for a valid implementation of the
+    See :func:`ophyd_async.fastcs.panda.phase_sorter` for a valid implementation of the
     sorter.
 
     Parameters

ophyd_async/core/{flyer.py → _flyer.py}

@@ -1,14 +1,12 @@
 from abc import ABC, abstractmethod
-from typing import Dict, Generic, Sequence, TypeVar
+from typing import Dict, Generic, Sequence
 
 from bluesky.protocols import DataKey, Flyable, Preparable, Reading, Stageable
 
-from .async_status import AsyncStatus
-from .device import Device
-from .signal import SignalR
-from .utils import merge_gathered_dicts
-
-T = TypeVar("T")
+from ._device import Device
+from ._signal import SignalR
+from ._status import AsyncStatus
+from ._utils import T, merge_gathered_dicts
 
 
 class TriggerLogic(ABC, Generic[T]):
@@ -29,7 +27,7 @@ class TriggerLogic(ABC, Generic[T]):
         """Stop flying and wait everything to be stopped"""
 
 
-class HardwareTriggeredFlyable(
+class StandardFlyer(
     Device,
     Stageable,
     Preparable,

ophyd_async/{epics/areadetector/writers/general_hdffile.py → core/_hdf_dataset.py}

@@ -10,11 +10,11 @@ from event_model import (
     StreamResource,
 )
 
-from ophyd_async.core import PathInfo
+from ._providers import PathInfo
 
 
 @dataclass
-class _HDFDataset:
+class HDFDataset:
     data_key: str
     dataset: str
     shape: Sequence[int] = field(default_factory=tuple)
@@ -26,7 +26,7 @@ class _HDFDataset:
 SLICE_NAME = "AD_HDF5_SWMR_SLICE"
 
 
-class _HDFFile:
+class HDFFile:
     """
     :param directory_info: Contains information about how to construct a StreamResource
     :param full_file_name: Absolute path to the file to be written
@@ -37,7 +37,7 @@ class _HDFFile:
         self,
         path_info: PathInfo,
         full_file_name: Path,
-        datasets: List[_HDFDataset],
+        datasets: List[HDFDataset],
         hostname: str = "localhost",
     ) -> None:
         self._last_emitted = 0

ophyd_async/{log.py → core/_log.py}

@@ -34,9 +34,7 @@ class ColoredFormatterWithDeviceName(colorlog.ColoredFormatter):
 
 
 def _validate_level(level) -> int:
-    """
-    Return an int for level comparison
-    """
+    """Return an int for level comparison."""
     if isinstance(level, int):
         levelno = level
     elif isinstance(level, str):
@@ -80,21 +78,31 @@ def config_ophyd_async_logging(
     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
 

ophyd_async/core/{mock_signal_backend.py → _mock_signal_backend.py}

@@ -5,9 +5,9 @@ from unittest.mock import Mock
 
 from bluesky.protocols import Descriptor, Reading
 
-from ophyd_async.core.signal_backend import SignalBackend
-from ophyd_async.core.soft_signal_backend import SoftSignalBackend
-from ophyd_async.core.utils import DEFAULT_TIMEOUT, ReadingValueCallback, T
+from ._signal_backend import SignalBackend
+from ._soft_signal_backend import SoftSignalBackend
+from ._utils import DEFAULT_TIMEOUT, ReadingValueCallback, T
 
 
 class MockSignalBackend(SignalBackend[T]):

ophyd_async/core/{mock_signal_utils.py → _mock_signal_utils.py}

@@ -2,10 +2,9 @@ from contextlib import asynccontextmanager, contextmanager
 from typing import Any, Callable, Iterable
 from unittest.mock import Mock
 
-from ophyd_async.core.signal import Signal
-from ophyd_async.core.utils import T
-
-from .mock_signal_backend import MockSignalBackend
+from ._mock_signal_backend import MockSignalBackend
+from ._signal import Signal
+from ._utils import T
 
 
 def _get_mock_signal_backend(signal: Signal) -> MockSignalBackend:

ophyd_async/{protocols.py → core/_protocol.py}

@@ -14,7 +14,7 @@ from typing import (
 from bluesky.protocols import DataKey, HasName, Reading
 
 if TYPE_CHECKING:
-    from ophyd_async.core.async_status import AsyncStatus
+    from ._status import AsyncStatus
 
 
 @runtime_checkable

ophyd_async/core/{standard_readable.py → _readable.py}

@@ -1,24 +1,14 @@
 import warnings
 from contextlib import contextmanager
-from typing import (
-    Callable,
-    Dict,
-    Generator,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    Union,
-)
+from typing import Callable, Dict, Generator, Optional, Sequence, Tuple, Type, Union
 
 from bluesky.protocols import DataKey, HasHints, Hints, Reading
 
-from ophyd_async.protocols import AsyncConfigurable, AsyncReadable, AsyncStageable
-
-from .async_status import AsyncStatus
-from .device import Device, DeviceVector
-from .signal import SignalR
-from .utils import merge_gathered_dicts
+from ._device import Device, DeviceVector
+from ._protocol import AsyncConfigurable, AsyncReadable, AsyncStageable
+from ._signal import SignalR
+from ._status import AsyncStatus
+from ._utils import merge_gathered_dicts
 
 ReadableChild = Union[AsyncReadable, AsyncConfigurable, AsyncStageable, HasHints]
 ReadableChildWrapper = Union[

ophyd_async/core/{signal.py → _signal.py}

@@ -25,14 +25,13 @@ from bluesky.protocols import (
     Subscribable,
 )
 
-from ophyd_async.core.mock_signal_backend import MockSignalBackend
-from ophyd_async.protocols import AsyncConfigurable, AsyncReadable, AsyncStageable
-
-from .async_status import AsyncStatus
-from .device import Device
-from .signal_backend import SignalBackend
-from .soft_signal_backend import SignalMetadata, SoftSignalBackend
-from .utils import DEFAULT_TIMEOUT, CalculatableTimeout, CalculateTimeout, Callback, T
+from ._device import Device
+from ._mock_signal_backend import MockSignalBackend
+from ._protocol import AsyncConfigurable, AsyncReadable, AsyncStageable
+from ._signal_backend import SignalBackend
+from ._soft_signal_backend import SignalMetadata, SoftSignalBackend
+from ._status import AsyncStatus
+from ._utils import DEFAULT_TIMEOUT, CalculatableTimeout, CalculateTimeout, Callback, T
 
 
 def _add_timeout(func):

ophyd_async/core/{signal_backend.py → _signal_backend.py}

@@ -1,17 +1,8 @@
 from abc import abstractmethod
-from typing import (
-    TYPE_CHECKING,
-    ClassVar,
-    Generic,
-    Literal,
-    Optional,
-    Tuple,
-    Type,
-)
-
-from bluesky.protocols import DataKey, Reading
-
-from .utils import DEFAULT_TIMEOUT, ReadingValueCallback, T
+from typing import TYPE_CHECKING, ClassVar, Generic, Literal, Optional, Tuple, Type
+
+from ._protocol import DataKey, Reading
+from ._utils import DEFAULT_TIMEOUT, ReadingValueCallback, T
 
 
 class SignalBackend(Generic[T]):

ophyd_async/core/{soft_signal_backend.py → _soft_signal_backend.py}

@@ -4,23 +4,14 @@ import inspect
 import time
 from collections import abc
 from enum import Enum
-from typing import (
-    Dict,
-    Generic,
-    Optional,
-    Tuple,
-    Type,
-    Union,
-    cast,
-    get_origin,
-)
+from typing import Dict, Generic, Optional, Tuple, Type, Union, cast, get_origin
 
 import numpy as np
 from bluesky.protocols import DataKey, Dtype, Reading
 from typing_extensions import TypedDict
 
-from .signal_backend import RuntimeSubsetEnum, SignalBackend
-from .utils import DEFAULT_TIMEOUT, ReadingValueCallback, T, get_dtype
+from ._signal_backend import RuntimeSubsetEnum, SignalBackend
+from ._utils import DEFAULT_TIMEOUT, ReadingValueCallback, T, get_dtype
 
 primitive_dtypes: Dict[type, Dtype] = {
     str: "string",

ophyd_async/core/{async_status.py → _status.py}

@@ -4,20 +4,12 @@ import asyncio
 import functools
 import time
 from dataclasses import asdict, replace
-from typing import (
-    AsyncIterator,
-    Awaitable,
-    Callable,
-    Generic,
-    Type,
-    TypeVar,
-    cast,
-)
+from typing import AsyncIterator, Awaitable, Callable, Generic, Type, TypeVar, cast
 
 from bluesky.protocols import Status
 
-from ..protocols import Watcher
-from .utils import Callback, P, T, WatcherUpdate
+from ._protocol import Watcher
+from ._utils import Callback, P, T, WatcherUpdate
 
 AS = TypeVar("AS", bound="AsyncStatus")
 WAS = TypeVar("WAS", bound="WatchableAsyncStatus")

ophyd_async/epics/adaravis/__init__.py

@@ -0,0 +1,9 @@
+from ._aravis import AravisDetector
+from ._aravis_controller import AravisController
+from ._aravis_io import AravisDriverIO
+
+__all__ = [
+    "AravisDetector",
+    "AravisController",
+    "AravisDriverIO",
+]

ophyd_async/epics/{areadetector/aravis.py → adaravis/_aravis.py}

@@ -3,12 +3,10 @@ from typing import get_args
 from bluesky.protocols import HasHints, Hints
 
 from ophyd_async.core import PathProvider, StandardDetector
-from ophyd_async.epics.areadetector.controllers.aravis_controller import (
-    AravisController,
-)
-from ophyd_async.epics.areadetector.drivers import ADBaseShapeProvider
-from ophyd_async.epics.areadetector.drivers.aravis_driver import AravisDriver
-from ophyd_async.epics.areadetector.writers import HDFWriter, NDFileHDF
+from ophyd_async.epics import adcore
+
+from ._aravis_controller import AravisController
+from ._aravis_io import AravisDriverIO
 
 
 class AravisDetector(StandardDetector, HasHints):
@@ -19,7 +17,7 @@ class AravisDetector(StandardDetector, HasHints):
     """
 
     _controller: AravisController
-    _writer: HDFWriter
+    _writer: adcore.ADHDFWriter
 
     def __init__(
         self,
@@ -30,16 +28,16 @@ class AravisDetector(StandardDetector, HasHints):
         name="",
         gpio_number: AravisController.GPIO_NUMBER = 1,
     ):
-        self.drv = AravisDriver(prefix + drv_suffix)
-        self.hdf = NDFileHDF(prefix + hdf_suffix)
+        self.drv = AravisDriverIO(prefix + drv_suffix)
+        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
 
         super().__init__(
             AravisController(self.drv, gpio_number=gpio_number),
-            HDFWriter(
+            adcore.ADHDFWriter(
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                ADBaseShapeProvider(self.drv),
+                adcore.ADBaseShapeProvider(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

ophyd_async/epics/{areadetector/controllers/aravis_controller.py → adaravis/_aravis_controller.py}

@@ -7,12 +7,9 @@ from ophyd_async.core import (
     DetectorTrigger,
     set_and_wait_for_value,
 )
-from ophyd_async.epics.areadetector.drivers.aravis_driver import (
-    AravisDriver,
-    AravisTriggerMode,
-    AravisTriggerSource,
-)
-from ophyd_async.epics.areadetector.utils import ImageMode, stop_busy_record
+from ophyd_async.epics import adcore
+
+from ._aravis_io import AravisDriverIO, AravisTriggerMode, AravisTriggerSource
 
 # The deadtime of an ADaravis controller varies depending on the exact model of camera.
 # Ideally we would maximize performance by dynamically retrieving the deadtime at
@@ -23,7 +20,7 @@ _HIGHEST_POSSIBLE_DEADTIME = 1961e-6
 class AravisController(DetectorControl):
     GPIO_NUMBER = Literal[1, 2, 3, 4]
 
-    def __init__(self, driver: AravisDriver, gpio_number: GPIO_NUMBER) -> None:
+    def __init__(self, driver: AravisDriverIO, gpio_number: GPIO_NUMBER) -> None:
         self._drv = driver
         self.gpio_number = gpio_number
 
@@ -37,9 +34,9 @@ class AravisController(DetectorControl):
         exposure: Optional[float] = None,
     ) -> AsyncStatus:
         if num == 0:
-            image_mode = ImageMode.continuous
+            image_mode = adcore.ImageMode.continuous
         else:
-            image_mode = ImageMode.multiple
+            image_mode = adcore.ImageMode.multiple
         if exposure is not None:
             await self._drv.acquire_time.set(exposure)
 
@@ -76,4 +73,4 @@ class AravisController(DetectorControl):
             return (AravisTriggerMode.on, f"Line{self.gpio_number}")
 
     async def disarm(self):
-        await stop_busy_record(self._drv.acquire, False, timeout=1)
+        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)