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

ophyd_async/core/_providers.py

@@ -1,11 +1,15 @@
+import os
+import uuid
 from abc import abstractmethod
+from collections.abc import Callable
 from dataclasses import dataclass
+from datetime import date
 from pathlib import Path
-from typing import Optional, Protocol, Sequence, Union
+from typing import List, Optional, Protocol
 
 
 @dataclass
-class DirectoryInfo:
+class PathInfo:
     """
     Information about where and how to write a file.
 
@@ -17,43 +21,201 @@ class DirectoryInfo:
 
     :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 prefix: Optional filename prefix to add to all files
-    :param suffix: Optional filename suffix to add to all files
+    :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
-    prefix: Optional[str] = ""
-    suffix: Optional[str] = ""
+    filename: str
+    create_dir_depth: int = 0
 
 
-class DirectoryProvider(Protocol):
+class FilenameProvider(Protocol):
     @abstractmethod
-    def __call__(self) -> DirectoryInfo:
+    def __call__(self) -> 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"""
 
 
-class StaticDirectoryProvider(DirectoryProvider):
+class StaticFilenameProvider(FilenameProvider):
+    def __init__(self, filename: str):
+        self._static_filename = filename
+
+    def __call__(self) -> str:
+        return self._static_filename
+
+
+class UUIDFilenameProvider(FilenameProvider):
     def __init__(
         self,
-        directory_path: Union[str, Path],
-        filename_prefix: str = "",
-        filename_suffix: str = "",
-        resource_dir: Optional[Path] = None,
+        uuid_call_func: Callable = uuid.uuid4,
+        uuid_call_args: Optional[List] = None,
+    ):
+        self._uuid_call_func = uuid_call_func
+        self._uuid_call_args = uuid_call_args or []
+
+    def __call__(self) -> str:
+        if (
+            self._uuid_call_func in [uuid.uuid3, uuid.uuid5]
+            and len(self._uuid_call_args) < 2
+        ):
+            raise ValueError(
+                f"To use {self._uuid_call_func} to generate UUID filenames,"
+                " UUID namespace and name must be passed as args!"
+            )
+
+        uuid_str = self._uuid_call_func(*self._uuid_call_args)
+        return f"{uuid_str}"
+
+
+class AutoIncrementFilenameProvider(FilenameProvider):
+    def __init__(
+        self,
+        base_filename: str = "",
+        max_digits: int = 5,
+        starting_value: int = 0,
+        increment: int = 1,
+        inc_delimeter: str = "_",
+    ):
+        self._base_filename = base_filename
+        self._max_digits = max_digits
+        self._current_value = starting_value
+        self._increment = increment
+        self._inc_delimeter = inc_delimeter
+
+    def __call__(self):
+        if len(str(self._current_value)) > self._max_digits:
+            raise ValueError(
+                f"Auto incrementing filename counter \
+                  exceeded maximum of {self._max_digits} digits!"
+            )
+
+        padded_counter = f"{self._current_value:0{self._max_digits}}"
+
+        filename = f"{self._base_filename}{self._inc_delimeter}{padded_counter}"
+
+        self._current_value += self._increment
+        return filename
+
+
+class StaticPathProvider(PathProvider):
+    def __init__(
+        self,
+        filename_provider: FilenameProvider,
+        directory_path: Path,
+        resource_dir: Path = Path("."),
+        create_dir_depth: int = 0,
     ) -> None:
-        if resource_dir is None:
-            resource_dir = Path(".")
-        if isinstance(directory_path, str):
-            directory_path = Path(directory_path)
-        self._directory_info = DirectoryInfo(
-            root=directory_path,
+        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()
+
+        return PathInfo(
+            root=self._directory_path,
+            resource_dir=self._resource_dir,
+            filename=filename,
+            create_dir_depth=self._create_dir_depth,
+        )
+
+
+class AutoIncrementingPathProvider(PathProvider):
+    def __init__(
+        self,
+        filename_provider: FilenameProvider,
+        directory_path: Path,
+        create_dir_depth: int = 0,
+        max_digits: int = 5,
+        starting_value: int = 0,
+        num_calls_per_inc: int = 1,
+        increment: int = 1,
+        inc_delimeter: str = "_",
+        base_name: str = None,
+    ) -> None:
+        self._filename_provider = filename_provider
+        self._directory_path = directory_path
+        self._create_dir_depth = create_dir_depth
+        self._base_name = base_name
+        self._starting_value = starting_value
+        self._current_value = starting_value
+        self._num_calls_per_inc = num_calls_per_inc
+        self._inc_counter = 0
+        self._max_digits = max_digits
+        self._increment = increment
+        self._inc_delimeter = inc_delimeter
+
+    def __call__(self, device_name: Optional[str] = None) -> PathInfo:
+        filename = self._filename_provider()
+
+        padded_counter = f"{self._current_value:0{self._max_digits}}"
+
+        resource_dir = str(padded_counter)
+        if self._base_name is not None:
+            resource_dir = 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}"
+
+        self._inc_counter += 1
+        if self._inc_counter == self._num_calls_per_inc:
+            self._inc_counter = 0
+            self._current_value += self._increment
+
+        return PathInfo(
+            root=self._directory_path,
             resource_dir=resource_dir,
-            prefix=filename_prefix,
-            suffix=filename_suffix,
+            filename=filename,
+            create_dir_depth=self._create_dir_depth,
         )
 
-    def __call__(self) -> DirectoryInfo:
-        return self._directory_info
+
+class YMDPathProvider(PathProvider):
+    def __init__(
+        self,
+        filename_provider: FilenameProvider,
+        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._create_dir_depth = create_dir_depth
+        self._device_name_as_base_dir = device_name_as_base_dir
+
+    def __call__(self, device_name: Optional[str] = None) -> PathInfo:
+        sep = os.path.sep
+        current_date = date.today().strftime(f"%Y{sep}%m{sep}%d")
+        if device_name is None:
+            resource_dir = current_date
+        elif self._device_name_as_base_dir:
+            resource_dir = os.path.join(
+                current_date,
+                device_name,
+            )
+        else:
+            resource_dir = os.path.join(
+                device_name,
+                current_date,
+            )
+
+        filename = self._filename_provider()
+        return PathInfo(
+            root=self._directory_path,
+            resource_dir=resource_dir,
+            filename=filename,
+            create_dir_depth=self._create_dir_depth,
+        )
 
 
 class NameProvider(Protocol):
@@ -64,5 +226,5 @@ class NameProvider(Protocol):
 
 class ShapeProvider(Protocol):
     @abstractmethod
-    async def __call__(self) -> Sequence[int]:
+    async def __call__(self) -> tuple:
         """Get the shape of the data collection"""

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):
@@ -62,7 +61,7 @@ class Signal(Device, Generic[T]):
         name: str = "",
     ) -> None:
         self._timeout = timeout
-        self._initial_backend = self._backend = backend
+        self._backend = backend
         super().__init__(name)
 
     async def connect(
@@ -73,19 +72,43 @@ class Signal(Device, Generic[T]):
         backend: Optional[SignalBackend[T]] = None,
     ):
         if backend:
-            if self._initial_backend and backend is not self._initial_backend:
-                raise ValueError(
-                    "Backend at connection different from initialised one."
-                )
+            if self._backend and backend is not self._backend:
+                raise ValueError("Backend at connection different from previous one.")
+
             self._backend = backend
-        if mock and not isinstance(self._backend, MockSignalBackend):
+        if (
+            self._previous_connect_was_mock is not None
+            and self._previous_connect_was_mock != mock
+        ):
+            raise RuntimeError(
+                f"`connect(mock={mock})` called on a `Signal` where the previous "
+                f"connect was `mock={self._previous_connect_was_mock}`. Changing mock "
+                "value between connects is not permitted."
+            )
+        self._previous_connect_was_mock = mock
+
+        if mock and not issubclass(type(self._backend), MockSignalBackend):
             # Using a soft backend, look to the initial value
             self._backend = MockSignalBackend(initial_backend=self._backend)
 
         if self._backend is None:
             raise RuntimeError("`connect` called on signal without backend")
-        self.log.debug(f"Connecting to {self.source}")
-        await self._backend.connect(timeout=timeout)
+
+        can_use_previous_connection: bool = self._connect_task is not None and not (
+            self._connect_task.done() and self._connect_task.exception()
+        )
+
+        if force_reconnect or not can_use_previous_connection:
+            self.log.debug(f"Connecting to {self.source}")
+            self._connect_task = asyncio.create_task(
+                self._backend.connect(timeout=timeout)
+            )
+        else:
+            self.log.debug(f"Reusing previous connection to {self.source}")
+        assert (
+            self._connect_task
+        ), "this assert is for type analysis and will never fail"
+        await self._connect_task
 
     @property
     def source(self) -> str:

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,
-    TypedDict,
-    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",
@@ -60,6 +51,10 @@ class SoftConverter(Generic[T]):
             dtype in primitive_dtypes
         ), f"invalid converter for value of type {type(value)}"
         dk["dtype"] = primitive_dtypes[dtype]
+        try:
+            dk["dtype_numpy"] = np.dtype(dtype).descr[0][1]
+        except TypeError:
+            dk["dtype_numpy"] = ""
         return dk
 
     def make_initial_value(self, datatype: Optional[Type[T]]) -> T:
@@ -71,7 +66,20 @@ class SoftConverter(Generic[T]):
 
 class SoftArrayConverter(SoftConverter):
     def get_datakey(self, source: str, value, **metadata) -> DataKey:
-        return {"source": source, "dtype": "array", "shape": [len(value)], **metadata}
+        dtype_numpy = ""
+        if isinstance(value, list):
+            if len(value) > 0:
+                dtype_numpy = np.dtype(type(value[0])).descr[0][1]
+        else:
+            dtype_numpy = np.dtype(value.dtype).descr[0][1]
+
+        return {
+            "source": source,
+            "dtype": "array",
+            "dtype_numpy": dtype_numpy,
+            "shape": [len(value)],
+            **metadata,
+        }
 
     def make_initial_value(self, datatype: Optional[Type[T]]) -> T:
         if datatype is None:
@@ -93,15 +101,13 @@ class SoftEnumConverter(SoftConverter):
             self.choices = datatype.choices
 
     def write_value(self, value: Union[Enum, str]) -> str:
-        if isinstance(value, Enum):
-            return value.value
-        else:  # Runtime enum
-            return value
+        return value
 
     def get_datakey(self, source: str, value, **metadata) -> DataKey:
         return {
             "source": source,
             "dtype": "string",
+            "dtype_numpy": "|S40",
             "shape": [],
             "choices": self.choices,
             **metadata,

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}

@@ -2,13 +2,11 @@ from typing import get_args
 
 from bluesky.protocols import HasHints, Hints
 
-from ophyd_async.core import DirectoryProvider, 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.core import PathProvider, StandardDetector
+from ophyd_async.epics import adcore
+
+from ._aravis_controller import AravisController
+from ._aravis_io import AravisDriverIO
 
 
 class AravisDetector(StandardDetector, HasHints):
@@ -19,27 +17,27 @@ class AravisDetector(StandardDetector, HasHints):
     """
 
     _controller: AravisController
-    _writer: HDFWriter
+    _writer: adcore.ADHDFWriter
 
     def __init__(
         self,
         prefix: str,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         drv_suffix="cam1:",
         hdf_suffix="HDF1:",
         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,
-                directory_provider,
+                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)
 
@@ -62,6 +59,7 @@ class AravisController(DetectorControl):
         supported_trigger_types = (
             DetectorTrigger.constant_gate,
             DetectorTrigger.edge_trigger,
+            DetectorTrigger.internal,
         )
         if trigger not in supported_trigger_types:
             raise ValueError(
@@ -75,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,36 @@
+from ._core_io import ADBaseIO, DetectorState, 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,
+    NDAttributesXML,
+    stop_busy_record,
+)
+
+__all__ = [
+    "ADBaseIO",
+    "DetectorState",
+    "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",
+    "NDAttributeDataType",
+    "NDAttributesXML",
+    "stop_busy_record",
+]