ophyd-async 0.5.0__py3-none-any.whl → 0.5.2__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.5.0'
-__version_tuple__ = version_tuple = (0, 5, 0)
+__version__ = version = '0.5.2'
+__version_tuple__ = version_tuple = (0, 5, 2)

ophyd_async/core/__init__.py

@@ -33,11 +33,11 @@ from ._protocol import AsyncConfigurable, AsyncReadable, AsyncStageable
 from ._providers import (
     AutoIncrementFilenameProvider,
     AutoIncrementingPathProvider,
+    DatasetDescriber,
     FilenameProvider,
     NameProvider,
     PathInfo,
     PathProvider,
-    ShapeProvider,
     StaticFilenameProvider,
     StaticPathProvider,
     UUIDFilenameProvider,
@@ -55,6 +55,7 @@ from ._signal import (
     assert_reading,
     assert_value,
     observe_value,
+    set_and_wait_for_other_value,
     set_and_wait_for_value,
     soft_signal_r_and_setter,
     soft_signal_rw,
@@ -62,7 +63,7 @@ from ._signal import (
 )
 from ._signal_backend import RuntimeSubsetEnum, SignalBackend, SubsetEnum
 from ._soft_signal_backend import SignalMetadata, SoftSignalBackend
-from ._status import AsyncStatus, WatchableAsyncStatus
+from ._status import AsyncStatus, WatchableAsyncStatus, completed_status
 from ._utils import (
     DEFAULT_TIMEOUT,
     CalculatableTimeout,
@@ -116,7 +117,7 @@ __all__ = [
     "NameProvider",
     "PathInfo",
     "PathProvider",
-    "ShapeProvider",
+    "DatasetDescriber",
     "StaticFilenameProvider",
     "StaticPathProvider",
     "UUIDFilenameProvider",
@@ -135,6 +136,7 @@ __all__ = [
     "assert_value",
     "observe_value",
     "set_and_wait_for_value",
+    "set_and_wait_for_other_value",
     "soft_signal_r_and_setter",
     "soft_signal_rw",
     "wait_for_value",
@@ -156,4 +158,5 @@ __all__ = [
     "get_unique",
     "in_micros",
     "wait_for_connection",
+    "completed_status",
 ]

ophyd_async/core/_detector.py

@@ -55,11 +55,16 @@ class TriggerInfo(BaseModel):
     #: Sort of triggers that will be sent
     trigger: DetectorTrigger = Field()
     #: What is the minimum deadtime between triggers
-    deadtime: float = Field(ge=0)
+    deadtime: float | None = Field(ge=0)
     #: What is the maximum high time of the triggers
-    livetime: float = Field(ge=0)
+    livetime: float | None = Field(ge=0)
     #: What is the maximum timeout on waiting for a frame
     frame_timeout: float | None = Field(None, gt=0)
+    #: How many triggers make up a single StreamDatum index, to allow multiple frames
+    #: from a faster detector to be zipped with a single frame from a slow detector
+    #: e.g. if num=10 and multiplier=5 then the detector will take 10 frames,
+    #: but publish 2 indices, and describe() will show a shape of (5, h, w)
+    multiplier: int = 1
 
 
 class DetectorControl(ABC):
@@ -69,7 +74,7 @@ class DetectorControl(ABC):
     """
 
     @abstractmethod
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         """For a given exposure, how long should the time between exposures be"""
 
     @abstractmethod
@@ -196,10 +201,10 @@ class StandardDetector(
 
     @AsyncStatus.wrap
     async def stage(self) -> None:
-        # Disarm the detector, stop filewriting, and open file for writing.
+        # Disarm the detector, stop filewriting.
         await self._check_config_sigs()
         await asyncio.gather(self.writer.close(), self.controller.disarm())
-        self._describe = await self.writer.open()
+        self._trigger_info = None
 
     async def _check_config_sigs(self):
         """Checks configuration signals are named and connected."""
@@ -212,7 +217,7 @@ class StandardDetector(
                 await signal.get_value()
             except NotImplementedError:
                 raise Exception(
-                    f"config signal {signal._name} must be connected before it is "
+                    f"config signal {signal.name} must be connected before it is "
                     + "passed to the detector"
                 )
 
@@ -236,10 +241,15 @@ class StandardDetector(
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:
-        # set default trigger_info
-        self._trigger_info = TriggerInfo(
-            number=1, trigger=DetectorTrigger.internal, deadtime=0.0, livetime=0.0
-        )
+        if self._trigger_info is None:
+            await self.prepare(
+                TriggerInfo(
+                    number=1,
+                    trigger=DetectorTrigger.internal,
+                    deadtime=None,
+                    livetime=None,
+                )
+            )
         # Arm the detector and wait for it to finish.
         indices_written = await self.writer.get_indices_written()
         written_status = await self.controller.arm(
@@ -250,19 +260,15 @@ class StandardDetector(
         end_observation = indices_written + 1
 
         async for index in self.writer.observe_indices_written(
-            DEFAULT_TIMEOUT + self._trigger_info.livetime + self._trigger_info.deadtime
+            DEFAULT_TIMEOUT
+            + (self._trigger_info.livetime or 0)
+            + (self._trigger_info.deadtime or 0)
         ):
             if index >= end_observation:
                 break
 
-    def prepare(
-        self,
-        value: T,
-    ) -> AsyncStatus:
-        # Just arm detector for the time being
-        return AsyncStatus(self._prepare(value))
-
-    async def _prepare(self, value: T) -> None:
+    @AsyncStatus.wrap
+    async def prepare(self, value: TriggerInfo) -> None:
         """
         Arm detector.
 
@@ -277,22 +283,26 @@ class StandardDetector(
         Args:
             value: TriggerInfo describing how to trigger the detector
         """
-        assert type(value) is TriggerInfo
         self._trigger_info = value
+        if value.trigger != DetectorTrigger.internal:
+            assert (
+                value.deadtime
+            ), "Deadtime must be supplied when in externally triggered mode"
+        if value.deadtime:
+            required = self.controller.get_deadtime(self._trigger_info.livetime)
+            assert required <= value.deadtime, (
+                f"Detector {self.controller} needs at least {required}s deadtime, "
+                f"but trigger logic provides only {value.deadtime}s"
+            )
         self._initial_frame = await self.writer.get_indices_written()
         self._last_frame = self._initial_frame + self._trigger_info.number
-
-        required = self.controller.get_deadtime(self._trigger_info.livetime)
-        assert required <= self._trigger_info.deadtime, (
-            f"Detector {self.controller} needs at least {required}s deadtime, "
-            f"but trigger logic provides only {self._trigger_info.deadtime}s"
-        )
         self._arm_status = await self.controller.arm(
             num=self._trigger_info.number,
             trigger=self._trigger_info.trigger,
             exposure=self._trigger_info.livetime,
         )
         self._fly_start = time.monotonic()
+        self._describe = await self.writer.open(value.multiplier)
 
     @AsyncStatus.wrap
     async def kickoff(self):
@@ -307,8 +317,8 @@ class StandardDetector(
             self._trigger_info.frame_timeout
             or (
                 DEFAULT_TIMEOUT
-                + self._trigger_info.livetime
-                + self._trigger_info.deadtime
+                + (self._trigger_info.livetime or 0)
+                + (self._trigger_info.deadtime or 0)
             )
         ):
             yield WatcherUpdate(

ophyd_async/core/_hdf_dataset.py

@@ -10,8 +10,6 @@ from event_model import (
     StreamResource,
 )
 
-from ._providers import PathInfo
-
 
 @dataclass
 class HDFDataset:
@@ -28,14 +26,12 @@ SLICE_NAME = "AD_HDF5_SWMR_SLICE"
 
 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
     :param datasets: Datasets to write into the file
     """
 
     def __init__(
         self,
-        path_info: PathInfo,
         full_file_name: Path,
         datasets: List[HDFDataset],
         hostname: str = "localhost",
@@ -53,7 +49,7 @@ class HDFFile:
             (
                 "file",
                 self._hostname,
-                str((path_info.root / full_file_name).absolute()),
+                str(full_file_name.absolute()),
                 "",
                 "",
                 None,

ophyd_async/core/_mock_signal_utils.py

@@ -8,11 +8,12 @@ from ._utils import T
 
 
 def _get_mock_signal_backend(signal: Signal) -> MockSignalBackend:
-    assert isinstance(signal._backend, MockSignalBackend), (
+    backend = signal._backend  # noqa:SLF001
+    assert isinstance(backend, MockSignalBackend), (
         "Expected to receive a `MockSignalBackend`, instead "
-        f" received {type(signal._backend)}. "
+        f" received {type(backend)}. "
     )
-    return signal._backend
+    return backend
 
 
 def set_mock_value(signal: Signal[T], value: T):

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,
         )
@@ -224,7 +211,11 @@ class NameProvider(Protocol):
         """Get the name to be used as a data_key in the descriptor document"""
 
 
-class ShapeProvider(Protocol):
+class DatasetDescriber(Protocol):
+    @abstractmethod
+    async def np_datatype(self) -> str:
+        """Represents the numpy datatype"""
+
     @abstractmethod
-    async def __call__(self) -> tuple:
+    async def shape(self) -> tuple[int, ...]:
         """Get the shape of the data collection"""

ophyd_async/core/_signal.py

@@ -12,6 +12,7 @@ from typing import (
     Optional,
     Tuple,
     Type,
+    TypeVar,
     Union,
 )
 
@@ -33,6 +34,8 @@ from ._soft_signal_backend import SignalMetadata, SoftSignalBackend
 from ._status import AsyncStatus
 from ._utils import DEFAULT_TIMEOUT, CalculatableTimeout, CalculateTimeout, Callback, T
 
+S = TypeVar("S")
+
 
 def _add_timeout(func):
     @functools.wraps(func)
@@ -42,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"""
 
@@ -115,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):
@@ -524,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.
 
@@ -556,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: SignalW[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,
@@ -565,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:
@@ -591,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/_status.py

@@ -4,7 +4,16 @@ 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,
+    Optional,
+    Type,
+    TypeVar,
+    cast,
+)
 
 from bluesky.protocols import Status
 
@@ -132,3 +141,10 @@ class WatchableAsyncStatus(AsyncStatusBase, Generic[T]):
             return cls(f(*args, **kwargs))
 
         return cast(Callable[P, WAS], wrap_f)
+
+
+@AsyncStatus.wrap
+async def completed_status(exception: Optional[Exception] = None):
+    if exception:
+        raise exception
+    return None

ophyd_async/epics/adaravis/_aravis.py

@@ -37,7 +37,7 @@ class AravisDetector(StandardDetector, HasHints):
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                adcore.ADBaseShapeProvider(self.drv),
+                adcore.ADBaseDatasetDescriber(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

ophyd_async/epics/adcore/__init__.py

@@ -1,7 +1,13 @@
-from ._core_io import ADBaseIO, DetectorState, NDFileHDFIO, NDPluginStatsIO
+from ._core_io import (
+    ADBaseIO,
+    DetectorState,
+    NDArrayBaseIO,
+    NDFileHDFIO,
+    NDPluginStatsIO,
+)
 from ._core_logic import (
     DEFAULT_GOOD_STATES,
-    ADBaseShapeProvider,
+    ADBaseDatasetDescriber,
     set_exposure_time_and_acquire_period_if_supplied,
     start_acquiring_driver_and_ensure_status,
 )
@@ -12,17 +18,20 @@ from ._utils import (
     FileWriteMode,
     ImageMode,
     NDAttributeDataType,
-    NDAttributesXML,
+    NDAttributeParam,
+    NDAttributePv,
+    NDAttributePvDbrType,
     stop_busy_record,
 )
 
 __all__ = [
     "ADBaseIO",
     "DetectorState",
+    "NDArrayBaseIO",
     "NDFileHDFIO",
     "NDPluginStatsIO",
     "DEFAULT_GOOD_STATES",
-    "ADBaseShapeProvider",
+    "ADBaseDatasetDescriber",
     "set_exposure_time_and_acquire_period_if_supplied",
     "start_acquiring_driver_and_ensure_status",
     "ADHDFWriter",
@@ -30,7 +39,9 @@ __all__ = [
     "ADBaseDataType",
     "FileWriteMode",
     "ImageMode",
+    "NDAttributePv",
+    "NDAttributeParam",
     "NDAttributeDataType",
-    "NDAttributesXML",
     "stop_busy_record",
+    "NDAttributePvDbrType",
 ]