ophyd-async 0.3.4a1__py3-none-any.whl → 0.4.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.3.4a1'
-__version_tuple__ = version_tuple = (0, 3, 4)
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)

ophyd_async/core/__init__.py

@@ -1,9 +1,15 @@
 from ._providers import (
-    DirectoryInfo,
-    DirectoryProvider,
+    AutoIncrementFilenameProvider,
+    AutoIncrementingPathProvider,
+    FilenameProvider,
     NameProvider,
+    PathInfo,
+    PathProvider,
     ShapeProvider,
-    StaticDirectoryProvider,
+    StaticFilenameProvider,
+    StaticPathProvider,
+    UUIDFilenameProvider,
+    YMDPathProvider,
 )
 from .async_status import AsyncStatus, WatchableAsyncStatus
 from .detector import (
@@ -69,6 +75,8 @@ from .utils import (
 
 __all__ = [
     "AsyncStatus",
+    "AutoIncrementFilenameProvider",
+    "AutoIncrementingPathProvider",
     "CalculatableTimeout",
     "CalculateTimeout",
     "Callback",
@@ -80,16 +88,16 @@ __all__ = [
     "Device",
     "DeviceCollector",
     "DeviceVector",
-    "DirectoryInfo",
-    "DirectoryProvider",
+    "FilenameProvider",
     "HardwareTriggeredFlyable",
     "HintedSignal",
     "MockSignalBackend",
     "NameProvider",
     "NotConnected",
+    "PathInfo",
+    "PathProvider",
     "ReadingValueCallback",
     "RuntimeSubsetEnum",
-    "SubsetEnum",
     "ShapeProvider",
     "Signal",
     "SignalBackend",
@@ -100,14 +108,18 @@ __all__ = [
     "SoftSignalBackend",
     "StandardDetector",
     "StandardReadable",
-    "StaticDirectoryProvider",
+    "StaticFilenameProvider",
+    "StaticPathProvider",
+    "SubsetEnum",
     "T",
     "TriggerInfo",
     "TriggerLogic",
+    "UUIDFilenameProvider",
     "WatchableAsyncStatus",
+    "YMDPathProvider",
+    # Lower-cased imports
     "assert_configuration",
     "assert_emitted",
-    "assert_mock_put_called_with",
     "assert_reading",
     "assert_value",
     "callback_on_mock_put",

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/detector.py

@@ -3,7 +3,6 @@
 import asyncio
 import time
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
 from enum import Enum
 from typing import (
     AsyncGenerator,
@@ -28,6 +27,7 @@ from bluesky.protocols import (
     Triggerable,
     WritesStreamAssets,
 )
+from pydantic import BaseModel, Field
 
 from ophyd_async.protocols import AsyncConfigurable, AsyncReadable
 
@@ -51,20 +51,19 @@ class DetectorTrigger(str, Enum):
     variable_gate = "variable_gate"
 
 
-@dataclass(frozen=True)
-class TriggerInfo:
+class TriggerInfo(BaseModel):
     """Minimal set of information required to setup triggering on a detector"""
 
-    #: Number of triggers that will be sent
-    num: int
+    #: Number of triggers that will be sent, 0 means infinite
+    number: int = Field(gt=0)
     #: Sort of triggers that will be sent
-    trigger: DetectorTrigger
+    trigger: DetectorTrigger = Field()
     #: What is the minimum deadtime between triggers
-    deadtime: float
+    deadtime: float = Field(ge=0)
     #: What is the maximum high time of the triggers
-    livetime: float
+    livetime: float = Field(ge=0)
     #: What is the maximum timeout on waiting for a frame
-    frame_timeout: float | None = None
+    frame_timeout: float | None = Field(None, gt=0)
 
 
 class DetectorControl(ABC):
@@ -243,12 +242,12 @@ class StandardDetector(
     async def trigger(self) -> None:
         # set default trigger_info
         self._trigger_info = TriggerInfo(
-            num=1, trigger=DetectorTrigger.internal, deadtime=0.0, livetime=0.0
+            number=1, trigger=DetectorTrigger.internal, deadtime=0.0, livetime=0.0
         )
         # Arm the detector and wait for it to finish.
         indices_written = await self.writer.get_indices_written()
         written_status = await self.controller.arm(
-            num=self._trigger_info.num,
+            num=self._trigger_info.number,
             trigger=self._trigger_info.trigger,
         )
         await written_status
@@ -285,7 +284,7 @@ class StandardDetector(
         assert type(value) is TriggerInfo
         self._trigger_info = value
         self._initial_frame = await self.writer.get_indices_written()
-        self._last_frame = self._initial_frame + self._trigger_info.num
+        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, (
@@ -293,7 +292,7 @@ class StandardDetector(
             f"but trigger logic provides only {self._trigger_info.deadtime}s"
         )
         self._arm_status = await self.controller.arm(
-            num=self._trigger_info.num,
+            num=self._trigger_info.number,
             trigger=self._trigger_info.trigger,
             exposure=self._trigger_info.livetime,
         )
@@ -320,12 +319,12 @@ class StandardDetector(
                 name=self.name,
                 current=index,
                 initial=self._initial_frame,
-                target=self._trigger_info.num,
+                target=self._trigger_info.number,
                 unit="",
                 precision=0,
                 time_elapsed=time.monotonic() - self._fly_start,
             )
-            if index >= self._trigger_info.num:
+            if index >= self._trigger_info.number:
                 break
 
     async def describe_collect(self) -> Dict[str, DataKey]:

ophyd_async/core/device.py

@@ -33,7 +33,10 @@ class Device(HasName):
     parent: Optional["Device"] = None
     # None if connect hasn't started, a Task if it has
     _connect_task: Optional[asyncio.Task] = None
-    _connect_mock_arg: bool = False
+
+    # Used to check if the previous connect was mocked,
+    # if the next mock value differs then we fail
+    _previous_connect_was_mock = None
 
     def __init__(self, name: str = "") -> None:
         self.set_name(name)
@@ -90,11 +93,21 @@ class Device(HasName):
         timeout:
             Time to wait before failing with a TimeoutError.
         """
+
+        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 `Device` 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 previous connect with same args has started and not errored, can use it
-        can_use_previous_connect = (
-            self._connect_task
-            and not (self._connect_task.done() and self._connect_task.exception())
-            and self._connect_mock_arg == mock
+        can_use_previous_connect = self._connect_task and not (
+            self._connect_task.done() and self._connect_task.exception()
         )
         if force_reconnect or not can_use_previous_connect:
             # Kick off a connection
@@ -105,7 +118,6 @@ class Device(HasName):
                 for name, child_device in self.children()
             }
             self._connect_task = asyncio.create_task(wait_for_connection(**coros))
-            self._connect_mock_arg = mock
 
         assert self._connect_task, "Connect task not created, this shouldn't happen"
         # Wait for it to complete

ophyd_async/core/signal.py

@@ -62,7 +62,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 +73,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/soft_signal_backend.py

@@ -10,7 +10,6 @@ from typing import (
     Optional,
     Tuple,
     Type,
-    TypedDict,
     Union,
     cast,
     get_origin,
@@ -18,6 +17,7 @@ from typing import (
 
 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
@@ -60,6 +60,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 +75,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 +110,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/epics/_backend/_aioca.py

@@ -66,9 +66,12 @@ def _data_key_from_augmented_value(
     scalar = value.element_count == 1
     dtype = dtype or dbr_to_dtype[value.datatype]
 
+    dtype_numpy = np.dtype(dbr.DbrCodeToType[value.datatype].dtype).descr[0][1]
+
     d = DataKey(
         source=source,
         dtype=dtype if scalar else "array",
+        dtype_numpy=dtype_numpy,
         # strictly value.element_count >= len(value)
         shape=[] if scalar else [len(value)],
     )