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

ophyd_async/core/_providers.py

@@ -13,34 +13,24 @@ class PathInfo:
     """
     Information about where and how to write a file.
 
-    The bluesky event model splits the URI for a resource into two segments to aid in
-    different applications mounting filesystems at different mount points.
-    The portion of this path which is relevant only for the writer is the 'root',
-    while the path from an agreed upon mutual mounting is the resource_path.
-    The resource_dir is used with the filename to construct the resource_path.
-
-    :param root: Path of a root directory, relevant only for the file writer
-    :param resource_dir: Directory into which files should be written, relative to root
+    :param directory_path: Directory into which files should be written
     :param filename: Base filename to use generated by FilenameProvider, w/o extension
     :param create_dir_depth: Optional depth of directories to create if they do not
                              exist
     """
 
-    root: Path
-    resource_dir: Path
+    directory_path: Path
     filename: str
     create_dir_depth: int = 0
 
 
 class FilenameProvider(Protocol):
     @abstractmethod
-    def __call__(self) -> str:
+    def __call__(self, device_name: Optional[str] = None) -> str:
         """Get a filename to use for output data, w/o extension"""
 
 
 class PathProvider(Protocol):
-    _filename_provider: FilenameProvider
-
     @abstractmethod
     def __call__(self, device_name: Optional[str] = None) -> PathInfo:
         """Get the current directory to write files into"""
@@ -50,7 +40,7 @@ class StaticFilenameProvider(FilenameProvider):
     def __init__(self, filename: str):
         self._static_filename = filename
 
-    def __call__(self) -> str:
+    def __call__(self, device_name: Optional[str] = None) -> str:
         return self._static_filename
 
 
@@ -63,7 +53,7 @@ class UUIDFilenameProvider(FilenameProvider):
         self._uuid_call_func = uuid_call_func
         self._uuid_call_args = uuid_call_args or []
 
-    def __call__(self) -> str:
+    def __call__(self, device_name: Optional[str] = None) -> str:
         if (
             self._uuid_call_func in [uuid.uuid3, uuid.uuid5]
             and len(self._uuid_call_args) < 2
@@ -92,7 +82,7 @@ class AutoIncrementFilenameProvider(FilenameProvider):
         self._increment = increment
         self._inc_delimeter = inc_delimeter
 
-    def __call__(self):
+    def __call__(self, device_name: Optional[str] = None) -> str:
         if len(str(self._current_value)) > self._max_digits:
             raise ValueError(
                 f"Auto incrementing filename counter \
@@ -112,20 +102,17 @@ class StaticPathProvider(PathProvider):
         self,
         filename_provider: FilenameProvider,
         directory_path: Path,
-        resource_dir: Path = Path("."),
         create_dir_depth: int = 0,
     ) -> None:
         self._filename_provider = filename_provider
         self._directory_path = directory_path
-        self._resource_dir = resource_dir
         self._create_dir_depth = create_dir_depth
 
     def __call__(self, device_name: Optional[str] = None) -> PathInfo:
-        filename = self._filename_provider()
+        filename = self._filename_provider(device_name)
 
         return PathInfo(
-            root=self._directory_path,
-            resource_dir=self._resource_dir,
+            directory_path=self._directory_path,
             filename=filename,
             create_dir_depth=self._create_dir_depth,
         )
@@ -135,7 +122,7 @@ class AutoIncrementingPathProvider(PathProvider):
     def __init__(
         self,
         filename_provider: FilenameProvider,
-        directory_path: Path,
+        base_directory_path: Path,
         create_dir_depth: int = 0,
         max_digits: int = 5,
         starting_value: int = 0,
@@ -145,7 +132,7 @@ class AutoIncrementingPathProvider(PathProvider):
         base_name: str = None,
     ) -> None:
         self._filename_provider = filename_provider
-        self._directory_path = directory_path
+        self._base_directory_path = base_directory_path
         self._create_dir_depth = create_dir_depth
         self._base_name = base_name
         self._starting_value = starting_value
@@ -157,15 +144,17 @@ class AutoIncrementingPathProvider(PathProvider):
         self._inc_delimeter = inc_delimeter
 
     def __call__(self, device_name: Optional[str] = None) -> PathInfo:
-        filename = self._filename_provider()
+        filename = self._filename_provider(device_name)
 
         padded_counter = f"{self._current_value:0{self._max_digits}}"
 
-        resource_dir = str(padded_counter)
+        auto_inc_dir_name = str(padded_counter)
         if self._base_name is not None:
-            resource_dir = f"{self._base_name}{self._inc_delimeter}{padded_counter}"
+            auto_inc_dir_name = (
+                f"{self._base_name}{self._inc_delimeter}{padded_counter}"
+            )
         elif device_name is not None:
-            resource_dir = f"{device_name}{self._inc_delimeter}{padded_counter}"
+            auto_inc_dir_name = f"{device_name}{self._inc_delimeter}{padded_counter}"
 
         self._inc_counter += 1
         if self._inc_counter == self._num_calls_per_inc:
@@ -173,8 +162,7 @@ class AutoIncrementingPathProvider(PathProvider):
             self._current_value += self._increment
 
         return PathInfo(
-            root=self._directory_path,
-            resource_dir=resource_dir,
+            directory_path=self._base_directory_path / auto_inc_dir_name,
             filename=filename,
             create_dir_depth=self._create_dir_depth,
         )
@@ -184,12 +172,12 @@ class YMDPathProvider(PathProvider):
     def __init__(
         self,
         filename_provider: FilenameProvider,
-        directory_path: Path,
+        base_directory_path: Path,
         create_dir_depth: int = -3,  # Default to -3 to create YMD dirs
         device_name_as_base_dir: bool = False,
     ) -> None:
         self._filename_provider = filename_provider
-        self._directory_path = Path(directory_path)
+        self._base_directory_path = Path(base_directory_path)
         self._create_dir_depth = create_dir_depth
         self._device_name_as_base_dir = device_name_as_base_dir
 
@@ -197,22 +185,21 @@ class YMDPathProvider(PathProvider):
         sep = os.path.sep
         current_date = date.today().strftime(f"%Y{sep}%m{sep}%d")
         if device_name is None:
-            resource_dir = current_date
+            ymd_dir_path = current_date
         elif self._device_name_as_base_dir:
-            resource_dir = os.path.join(
+            ymd_dir_path = os.path.join(
                 current_date,
                 device_name,
             )
         else:
-            resource_dir = os.path.join(
+            ymd_dir_path = os.path.join(
                 device_name,
                 current_date,
             )
 
-        filename = self._filename_provider()
+        filename = self._filename_provider(device_name)
         return PathInfo(
-            root=self._directory_path,
-            resource_dir=resource_dir,
+            directory_path=self._base_directory_path / ymd_dir_path,
             filename=filename,
             create_dir_depth=self._create_dir_depth,
         )

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}

@@ -12,6 +12,7 @@ from typing import (
     Optional,
     Tuple,
     Type,
+    TypeVar,
     Union,
 )
 
@@ -25,14 +26,15 @@ from bluesky.protocols import (
     Subscribable,
 )
 
-from ophyd_async.core.mock_signal_backend import MockSignalBackend
-from ophyd_async.protocols import AsyncConfigurable, AsyncReadable, AsyncStageable
+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
 
-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
+S = TypeVar("S")
 
 
 def _add_timeout(func):
@@ -43,15 +45,6 @@ def _add_timeout(func):
     return wrapper
 
 
-def _fail(self, other, *args, **kwargs):
-    if isinstance(other, Signal):
-        raise TypeError(
-            "Can't compare two Signals, did you mean await signal.get_value() instead?"
-        )
-    else:
-        return NotImplemented
-
-
 class Signal(Device, Generic[T]):
     """A Device with the concept of a value, with R, RW, W and X flavours"""
 
@@ -116,12 +109,6 @@ class Signal(Device, Generic[T]):
         """Like ca://PV_PREFIX:SIGNAL, or "" if not set"""
         return self._backend.source(self.name)
 
-    __lt__ = __le__ = __eq__ = __ge__ = __gt__ = __ne__ = _fail
-
-    def __hash__(self):
-        # Restore the default implementation so we can use in a set or dict
-        return hash(id(self))
-
 
 class _SignalCache(Generic[T]):
     def __init__(self, backend: SignalBackend[T], signal: Signal):
@@ -525,7 +512,9 @@ class _ValueChecker(Generic[T]):
 
 
 async def wait_for_value(
-    signal: SignalR[T], match: Union[T, Callable[[T], bool]], timeout: Optional[float]
+    signal: SignalR[T],
+    match: Union[T, Callable[[T], bool]],
+    timeout: Optional[float],
 ):
     """Wait for a signal to have a matching value.
 
@@ -557,6 +546,66 @@ async def wait_for_value(
     await checker.wait_for_value(signal, timeout)
 
 
+async def set_and_wait_for_other_value(
+    set_signal: SignalRW[T],
+    set_value: T,
+    read_signal: SignalR[S],
+    read_value: S,
+    timeout: float = DEFAULT_TIMEOUT,
+    set_timeout: Optional[float] = None,
+) -> AsyncStatus:
+    """Set a signal and monitor another signal until it has the specified value.
+
+    This function sets a set_signal to a specified set_value and waits for
+    a read_signal to have the read_value.
+
+    Parameters
+    ----------
+    signal:
+        The signal to set
+    set_value:
+        The value to set it to
+    read_signal:
+        The signal to monitor
+    read_value:
+        The value to wait for
+    timeout:
+        How long to wait for the signal to have the value
+    set_timeout:
+        How long to wait for the set to complete
+
+    Notes
+    -----
+    Example usage::
+
+        set_and_wait_for_value(device.acquire, 1, device.acquire_rbv, 1)
+    """
+    # Start monitoring before the set to avoid a race condition
+    values_gen = observe_value(read_signal)
+
+    # Get the initial value from the monitor to make sure we've created it
+    current_value = await anext(values_gen)
+
+    status = set_signal.set(set_value, timeout=set_timeout)
+
+    # If the value was the same as before no need to wait for it to change
+    if current_value != read_value:
+
+        async def _wait_for_value():
+            async for value in values_gen:
+                if value == read_value:
+                    break
+
+        try:
+            await asyncio.wait_for(_wait_for_value(), timeout)
+        except asyncio.TimeoutError as e:
+            raise TimeoutError(
+                f"{read_signal.name} didn't match {read_value} in {timeout}s"
+            ) from e
+
+    return status
+
+
 async def set_and_wait_for_value(
     signal: SignalRW[T],
     value: T,
@@ -566,19 +615,14 @@ async def set_and_wait_for_value(
     """Set a signal and monitor it until it has that value.
 
     Useful for busy record, or other Signals with pattern:
-
-    - Set Signal with wait=True and stash the Status
-    - Read the same Signal to check the operation has started
-    - Return the Status so calling code can wait for operation to complete
-
-    This function sets a signal to a specified value, optionally with or without a
-    ca/pv put callback, and waits for the readback value of the signal to match the
-    value it was set to.
+      - Set Signal with wait=True and stash the Status
+      - Read the same Signal to check the operation has started
+      - Return the Status so calling code can wait for operation to complete
 
     Parameters
     ----------
     signal:
-        The signal to set and monitor
+        The signal to set
     value:
         The value to set it to
     timeout:
@@ -592,6 +636,6 @@ async def set_and_wait_for_value(
 
         set_and_wait_for_value(device.acquire, 1)
     """
-    status = signal.set(value, timeout=status_timeout)
-    await wait_for_value(signal, value, timeout=timeout)
-    return status
+    return await set_and_wait_for_other_value(
+        signal, value, signal, value, timeout, status_timeout
+    )

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)

ophyd_async/epics/{areadetector/drivers/aravis_driver.py → adaravis/_aravis_io.py}

@@ -1,8 +1,8 @@
 from enum import Enum
 
 from ophyd_async.core import SubsetEnum
-from ophyd_async.epics.areadetector.drivers import ADBase
-from ophyd_async.epics.signal.signal import epics_signal_rw_rbv
+from ophyd_async.epics import adcore
+from ophyd_async.epics.signal import epics_signal_rw_rbv
 
 
 class AravisTriggerMode(str, Enum):
@@ -22,12 +22,15 @@ class AravisTriggerMode(str, Enum):
 AravisTriggerSource = SubsetEnum["Freerun", "Line1"]
 
 
-class AravisDriver(ADBase):
+class AravisDriverIO(adcore.ADBaseIO):
     # If instantiating a new instance, ensure it is supported in the _deadtimes dict
     """Generic Driver supporting the Manta and Mako drivers.
     Fetches deadtime prior to use in a Streaming scan.
+
     Requires driver firmware up to date:
     - Model_RBV must be of the form "^(Mako|Manta) (model)$"
+
+    This mirrors the interface provided by ADAravis/db/aravisCamera.template.
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:

ophyd_async/epics/adcore/__init__.py

@@ -0,0 +1,47 @@
+from ._core_io import (
+    ADBaseIO,
+    DetectorState,
+    NDArrayBaseIO,
+    NDFileHDFIO,
+    NDPluginStatsIO,
+)
+from ._core_logic import (
+    DEFAULT_GOOD_STATES,
+    ADBaseShapeProvider,
+    set_exposure_time_and_acquire_period_if_supplied,
+    start_acquiring_driver_and_ensure_status,
+)
+from ._hdf_writer import ADHDFWriter
+from ._single_trigger import SingleTriggerDetector
+from ._utils import (
+    ADBaseDataType,
+    FileWriteMode,
+    ImageMode,
+    NDAttributeDataType,
+    NDAttributeParam,
+    NDAttributePv,
+    NDAttributePvDbrType,
+    stop_busy_record,
+)
+
+__all__ = [
+    "ADBaseIO",
+    "DetectorState",
+    "NDArrayBaseIO",
+    "NDFileHDFIO",
+    "NDPluginStatsIO",
+    "DEFAULT_GOOD_STATES",
+    "ADBaseShapeProvider",
+    "set_exposure_time_and_acquire_period_if_supplied",
+    "start_acquiring_driver_and_ensure_status",
+    "ADHDFWriter",
+    "SingleTriggerDetector",
+    "ADBaseDataType",
+    "FileWriteMode",
+    "ImageMode",
+    "NDAttributePv",
+    "NDAttributeParam",
+    "NDAttributeDataType",
+    "stop_busy_record",
+    "NDAttributePvDbrType",
+]