ophyd-async 0.5.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

ophyd_async/core/_hdf_dataset.py

@@ -1,12 +1,13 @@
+from collections.abc import Iterator, Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Iterator, List, Sequence
 from urllib.parse import urlunparse
 
 from event_model import (
     ComposeStreamResource,
     ComposeStreamResourceBundle,
     StreamDatum,
+    StreamRange,
     StreamResource,
 )
 
@@ -19,6 +20,8 @@ class HDFDataset:
     dtype_numpy: str = ""
     multiplier: int = 1
     swmr: bool = False
+    # Represents explicit chunk size written to disk.
+    chunk_shape: tuple[int, ...] = ()
 
 
 SLICE_NAME = "AD_HDF5_SWMR_SLICE"
@@ -33,7 +36,7 @@ class HDFFile:
     def __init__(
         self,
         full_file_name: Path,
-        datasets: List[HDFDataset],
+        datasets: list[HDFDataset],
         hostname: str = "localhost",
     ) -> None:
         self._last_emitted = 0
@@ -56,7 +59,7 @@ class HDFFile:
             )
         )
 
-        self._bundles: List[ComposeStreamResourceBundle] = [
+        self._bundles: list[ComposeStreamResourceBundle] = [
             bundler_composer(
                 mimetype="application/x-hdf5",
                 uri=uri,
@@ -65,6 +68,7 @@ class HDFFile:
                     "dataset": ds.dataset,
                     "swmr": ds.swmr,
                     "multiplier": ds.multiplier,
+                    "chunk_shape": ds.chunk_shape,
                 },
                 uid=None,
                 validate=True,
@@ -79,15 +83,10 @@ class HDFFile:
     def stream_data(self, indices_written: int) -> Iterator[StreamDatum]:
         # Indices are relative to resource
         if indices_written > self._last_emitted:
-            indices = {
+            indices: StreamRange = {
                 "start": self._last_emitted,
                 "stop": indices_written,
             }
             self._last_emitted = indices_written
             for bundle in self._bundles:
                 yield bundle.compose_stream_datum(indices)
-        return None
-
-    def close(self) -> None:
-        for bundle in self._bundles:
-            bundle.close()

ophyd_async/core/_log.py

@@ -29,7 +29,7 @@ class ColoredFormatterWithDeviceName(colorlog.ColoredFormatter):
     def format(self, record):
         message = super().format(record)
         if hasattr(record, "ophyd_async_device_name"):
-            message = f"[{record.ophyd_async_device_name}]{message}"
+            message = f"[{record.ophyd_async_device_name}]{message}"  # type: ignore
         return message
 
 
@@ -39,6 +39,8 @@ def _validate_level(level) -> int:
         levelno = level
     elif isinstance(level, str):
         levelno = logging.getLevelName(level)
+    else:
+        raise TypeError(f"Level {level!r} is not an int or str")
 
     if isinstance(levelno, int):
         return levelno

ophyd_async/core/_mock_signal_backend.py

@@ -1,7 +1,7 @@
 import asyncio
+from collections.abc import Callable
 from functools import cached_property
-from typing import Callable, Optional, Type
-from unittest.mock import Mock
+from unittest.mock import AsyncMock
 
 from bluesky.protocols import Descriptor, Reading
 
@@ -11,10 +11,12 @@ from ._utils import DEFAULT_TIMEOUT, ReadingValueCallback, T
 
 
 class MockSignalBackend(SignalBackend[T]):
+    """Signal backend for testing, created by ``Device.connect(mock=True)``."""
+
     def __init__(
         self,
-        datatype: Optional[Type[T]] = None,
-        initial_backend: Optional[SignalBackend[T]] = None,
+        datatype: type[T] | None = None,
+        initial_backend: SignalBackend[T] | None = None,
     ) -> None:
         if isinstance(initial_backend, MockSignalBackend):
             raise ValueError("Cannot make a MockSignalBackend for a MockSignalBackends")
@@ -46,8 +48,8 @@ class MockSignalBackend(SignalBackend[T]):
         pass
 
     @cached_property
-    def put_mock(self) -> Mock:
-        return Mock(name="put", spec=Callable)
+    def put_mock(self) -> AsyncMock:
+        return AsyncMock(name="put", spec=Callable)
 
     @cached_property
     def put_proceeds(self) -> asyncio.Event:
@@ -55,8 +57,8 @@ class MockSignalBackend(SignalBackend[T]):
         put_proceeds.set()
         return put_proceeds
 
-    async def put(self, value: Optional[T], wait=True, timeout=None):
-        self.put_mock(value, wait=wait, timeout=timeout)
+    async def put(self, value: T | None, wait=True, timeout=None):
+        await self.put_mock(value, wait=wait, timeout=timeout)
         await self.soft_backend.put(value, wait=wait, timeout=timeout)
 
         if wait:
@@ -78,5 +80,5 @@ class MockSignalBackend(SignalBackend[T]):
     async def get_datakey(self, source: str) -> Descriptor:
         return await self.soft_backend.get_datakey(source)
 
-    def set_callback(self, callback: Optional[ReadingValueCallback[T]]) -> None:
+    def set_callback(self, callback: ReadingValueCallback[T] | None) -> None:
         self.soft_backend.set_callback(callback)

ophyd_async/core/_mock_signal_utils.py

@@ -1,6 +1,7 @@
+from collections.abc import Awaitable, Callable, Iterable
 from contextlib import asynccontextmanager, contextmanager
-from typing import Any, Callable, Iterable
-from unittest.mock import Mock
+from typing import Any
+from unittest.mock import AsyncMock
 
 from ._mock_signal_backend import MockSignalBackend
 from ._signal import Signal
@@ -41,7 +42,7 @@ async def mock_puts_blocked(*signals: Signal):
         set_mock_put_proceeds(signal, True)
 
 
-def get_mock_put(signal: Signal) -> Mock:
+def get_mock_put(signal: Signal) -> AsyncMock:
     """Get the mock associated with the put call on the signal."""
     return _get_mock_signal_backend(signal).put_mock
 
@@ -136,12 +137,14 @@ def set_mock_values(
 
 
 @contextmanager
-def _unset_side_effect_cm(put_mock: Mock):
+def _unset_side_effect_cm(put_mock: AsyncMock):
     yield
     put_mock.side_effect = None
 
 
-def callback_on_mock_put(signal: Signal[T], callback: Callable[[T], None]):
+def callback_on_mock_put(
+    signal: Signal[T], callback: Callable[[T], None] | Callable[[T], Awaitable[None]]
+):
     """For setting a callback when a backend is put to.
 
     Can either be used in a context, with the callback being

ophyd_async/core/_protocol.py

@@ -4,14 +4,14 @@ from abc import abstractmethod
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
     Generic,
     Protocol,
     TypeVar,
     runtime_checkable,
 )
 
-from bluesky.protocols import DataKey, HasName, Reading
+from bluesky.protocols import HasName, Reading
+from event_model import DataKey
 
 if TYPE_CHECKING:
     from ._status import AsyncStatus
@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 @runtime_checkable
 class AsyncReadable(HasName, Protocol):
     @abstractmethod
-    async def read(self) -> Dict[str, Reading]:
+    async def read(self) -> dict[str, Reading]:
         """Return an OrderedDict mapping string field name(s) to dictionaries
         of values and timestamps and optional per-point metadata.
 
@@ -36,7 +36,7 @@ class AsyncReadable(HasName, Protocol):
         ...
 
     @abstractmethod
-    async def describe(self) -> Dict[str, DataKey]:
+    async def describe(self) -> dict[str, DataKey]:
         """Return an OrderedDict with exactly the same keys as the ``read``
         method, here mapped to per-scan metadata about each field.
 
@@ -57,16 +57,16 @@ class AsyncReadable(HasName, Protocol):
 
 
 @runtime_checkable
-class AsyncConfigurable(Protocol):
+class AsyncConfigurable(HasName, Protocol):
     @abstractmethod
-    async def read_configuration(self) -> Dict[str, Reading]:
+    async def read_configuration(self) -> dict[str, Reading]:
         """Same API as ``read`` but for slow-changing fields related to configuration.
         e.g., exposure time. These will typically be read only once per run.
         """
         ...
 
     @abstractmethod
-    async def describe_configuration(self) -> Dict[str, DataKey]:
+    async def describe_configuration(self) -> dict[str, DataKey]:
         """Same API as ``describe``, but corresponding to the keys in
         ``read_configuration``.
         """

ophyd_async/core/_providers.py

@@ -5,7 +5,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import date
 from pathlib import Path
-from typing import List, Optional, Protocol
+from typing import Protocol
 
 
 @dataclass
@@ -26,13 +26,13 @@ class PathInfo:
 
 class FilenameProvider(Protocol):
     @abstractmethod
-    def __call__(self, device_name: Optional[str] = None) -> str:
+    def __call__(self, device_name: str | None = None) -> str:
         """Get a filename to use for output data, w/o extension"""
 
 
 class PathProvider(Protocol):
     @abstractmethod
-    def __call__(self, device_name: Optional[str] = None) -> PathInfo:
+    def __call__(self, device_name: str | None = None) -> PathInfo:
         """Get the current directory to write files into"""
 
 
@@ -40,7 +40,7 @@ class StaticFilenameProvider(FilenameProvider):
     def __init__(self, filename: str):
         self._static_filename = filename
 
-    def __call__(self, device_name: Optional[str] = None) -> str:
+    def __call__(self, device_name: str | None = None) -> str:
         return self._static_filename
 
 
@@ -48,12 +48,12 @@ class UUIDFilenameProvider(FilenameProvider):
     def __init__(
         self,
         uuid_call_func: Callable = uuid.uuid4,
-        uuid_call_args: Optional[List] = None,
+        uuid_call_args: list | None = None,
     ):
         self._uuid_call_func = uuid_call_func
         self._uuid_call_args = uuid_call_args or []
 
-    def __call__(self, device_name: Optional[str] = None) -> str:
+    def __call__(self, device_name: str | None = None) -> str:
         if (
             self._uuid_call_func in [uuid.uuid3, uuid.uuid5]
             and len(self._uuid_call_args) < 2
@@ -82,7 +82,7 @@ class AutoIncrementFilenameProvider(FilenameProvider):
         self._increment = increment
         self._inc_delimeter = inc_delimeter
 
-    def __call__(self, device_name: Optional[str] = None) -> str:
+    def __call__(self, device_name: str | None = None) -> str:
         if len(str(self._current_value)) > self._max_digits:
             raise ValueError(
                 f"Auto incrementing filename counter \
@@ -108,7 +108,7 @@ class StaticPathProvider(PathProvider):
         self._directory_path = directory_path
         self._create_dir_depth = create_dir_depth
 
-    def __call__(self, device_name: Optional[str] = None) -> PathInfo:
+    def __call__(self, device_name: str | None = None) -> PathInfo:
         filename = self._filename_provider(device_name)
 
         return PathInfo(
@@ -129,7 +129,7 @@ class AutoIncrementingPathProvider(PathProvider):
         num_calls_per_inc: int = 1,
         increment: int = 1,
         inc_delimeter: str = "_",
-        base_name: str = None,
+        base_name: str | None = None,
     ) -> None:
         self._filename_provider = filename_provider
         self._base_directory_path = base_directory_path
@@ -143,7 +143,7 @@ class AutoIncrementingPathProvider(PathProvider):
         self._increment = increment
         self._inc_delimeter = inc_delimeter
 
-    def __call__(self, device_name: Optional[str] = None) -> PathInfo:
+    def __call__(self, device_name: str | None = None) -> PathInfo:
         filename = self._filename_provider(device_name)
 
         padded_counter = f"{self._current_value:0{self._max_digits}}"
@@ -181,7 +181,7 @@ class YMDPathProvider(PathProvider):
         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:
+    def __call__(self, device_name: str | None = None) -> PathInfo:
         sep = os.path.sep
         current_date = date.today().strftime(f"%Y{sep}%m{sep}%d")
         if device_name is None:

ophyd_async/core/_readable.py

@@ -1,8 +1,9 @@
 import warnings
+from collections.abc import Callable, Generator, Sequence
 from contextlib import contextmanager
-from typing import Callable, Dict, Generator, Optional, Sequence, Tuple, Type, Union
 
-from bluesky.protocols import DataKey, HasHints, Hints, Reading
+from bluesky.protocols import HasHints, Hints, Reading
+from event_model import DataKey
 
 from ._device import Device, DeviceVector
 from ._protocol import AsyncConfigurable, AsyncReadable, AsyncStageable
@@ -10,10 +11,12 @@ from ._signal import SignalR
 from ._status import AsyncStatus
 from ._utils import merge_gathered_dicts
 
-ReadableChild = Union[AsyncReadable, AsyncConfigurable, AsyncStageable, HasHints]
-ReadableChildWrapper = Union[
-    Callable[[ReadableChild], ReadableChild], Type["ConfigSignal"], Type["HintedSignal"]
-]
+ReadableChild = AsyncReadable | AsyncConfigurable | AsyncStageable | HasHints
+ReadableChildWrapper = (
+    Callable[[ReadableChild], ReadableChild]
+    | type["ConfigSignal"]
+    | type["HintedSignal"]
+)
 
 
 class StandardReadable(
@@ -28,10 +31,10 @@ class StandardReadable(
 
     # These must be immutable types to avoid accidental sharing between
     # different instances of the class
-    _readables: Tuple[AsyncReadable, ...] = ()
-    _configurables: Tuple[AsyncConfigurable, ...] = ()
-    _stageables: Tuple[AsyncStageable, ...] = ()
-    _has_hints: Tuple[HasHints, ...] = ()
+    _readables: tuple[AsyncReadable, ...] = ()
+    _configurables: tuple[AsyncConfigurable, ...] = ()
+    _stageables: tuple[AsyncStageable, ...] = ()
+    _has_hints: tuple[HasHints, ...] = ()
 
     def set_readable_signals(
         self,
@@ -53,7 +56,8 @@ class StandardReadable(
             DeprecationWarning(
                 "Migrate to `add_children_as_readables` context manager or "
                 "`add_readables` method"
-            )
+            ),
+            stacklevel=2,
         )
         self.add_readables(read, wrapper=HintedSignal)
         self.add_readables(config, wrapper=ConfigSignal)
@@ -69,20 +73,20 @@ class StandardReadable(
         for sig in self._stageables:
             await sig.unstage().task
 
-    async def describe_configuration(self) -> Dict[str, DataKey]:
+    async def describe_configuration(self) -> dict[str, DataKey]:
         return await merge_gathered_dicts(
             [sig.describe_configuration() for sig in self._configurables]
         )
 
-    async def read_configuration(self) -> Dict[str, Reading]:
+    async def read_configuration(self) -> dict[str, Reading]:
         return await merge_gathered_dicts(
             [sig.read_configuration() for sig in self._configurables]
         )
 
-    async def describe(self) -> Dict[str, DataKey]:
+    async def describe(self) -> dict[str, DataKey]:
         return await merge_gathered_dicts([sig.describe() for sig in self._readables])
 
-    async def read(self) -> Dict[str, Reading]:
+    async def read(self) -> dict[str, Reading]:
         return await merge_gathered_dicts([sig.read() for sig in self._readables])
 
     @property
@@ -123,7 +127,7 @@ class StandardReadable(
     @contextmanager
     def add_children_as_readables(
         self,
-        wrapper: Optional[ReadableChildWrapper] = None,
+        wrapper: ReadableChildWrapper | None = None,
     ) -> Generator[None, None, None]:
         """Context manager to wrap adding Devices
 
@@ -167,8 +171,8 @@ class StandardReadable(
 
     def add_readables(
         self,
-        devices: Sequence[Device],
-        wrapper: Optional[ReadableChildWrapper] = None,
+        devices: Sequence[ReadableChild],
+        wrapper: ReadableChildWrapper | None = None,
     ) -> None:
         """Add the given devices to the lists of known Devices
 
@@ -216,12 +220,16 @@ class ConfigSignal(AsyncConfigurable):
         assert isinstance(signal, SignalR), f"Expected signal, got {signal}"
         self.signal = signal
 
-    async def read_configuration(self) -> Dict[str, Reading]:
+    async def read_configuration(self) -> dict[str, Reading]:
         return await self.signal.read()
 
-    async def describe_configuration(self) -> Dict[str, DataKey]:
+    async def describe_configuration(self) -> dict[str, DataKey]:
         return await self.signal.describe()
 
+    @property
+    def name(self) -> str:
+        return self.signal.name
+
 
 class HintedSignal(HasHints, AsyncReadable):
     def __init__(self, signal: ReadableChild, allow_cache: bool = True) -> None:
@@ -232,10 +240,10 @@ class HintedSignal(HasHints, AsyncReadable):
             self.stage = signal.stage
             self.unstage = signal.unstage
 
-    async def read(self) -> Dict[str, Reading]:
+    async def read(self) -> dict[str, Reading]:
         return await self.signal.read(cached=self.cached)
 
-    async def describe(self) -> Dict[str, DataKey]:
+    async def describe(self) -> dict[str, DataKey]:
         return await self.signal.describe()
 
     @property