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

ophyd_async/core/_device_save_loader.py

@@ -1,5 +1,7 @@
+from collections.abc import Callable, Generator, Sequence
 from enum import Enum
-from typing import Any, Callable, Dict, Generator, List, Optional, Sequence
+from pathlib import Path
+from typing import Any
 
 import numpy as np
 import numpy.typing as npt
@@ -7,6 +9,7 @@ import yaml
 from bluesky.plan_stubs import abs_set, wait
 from bluesky.protocols import Location
 from bluesky.utils import Msg
+from pydantic import BaseModel
 
 from ._device import Device
 from ._signal import SignalRW
@@ -18,16 +21,22 @@ def ndarray_representer(dumper: yaml.Dumper, array: npt.NDArray[Any]) -> yaml.No
     )
 
 
+def pydantic_model_abstraction_representer(
+    dumper: yaml.Dumper, model: BaseModel
+) -> yaml.Node:
+    return dumper.represent_data(model.model_dump(mode="python"))
+
+
 class OphydDumper(yaml.Dumper):
     def represent_data(self, data: Any) -> Any:
         if isinstance(data, Enum):
             return self.represent_data(data.value)
-        return super(OphydDumper, self).represent_data(data)
+        return super().represent_data(data)
 
 
 def get_signal_values(
-    signals: Dict[str, SignalRW[Any]], ignore: Optional[List[str]] = None
-) -> Generator[Msg, Sequence[Location[Any]], Dict[str, Any]]:
+    signals: dict[str, SignalRW[Any]], ignore: list[str] | None = None
+) -> Generator[Msg, Sequence[Location[Any]], dict[str, Any]]:
     """Get signal values in bulk.
 
     Used as part of saving the signals of a device to a yaml file.
@@ -59,13 +68,10 @@ def get_signal_values(
     }
     selected_values = yield Msg("locate", *selected_signals.values())
 
-    # TODO: investigate wrong type hints
-    if isinstance(selected_values, dict):
-        selected_values = [selected_values]  # type: ignore
-
     assert selected_values is not None, "No signalRW's were able to be located"
     named_values = {
-        key: value["setpoint"] for key, value in zip(selected_signals, selected_values)
+        key: value["setpoint"]
+        for key, value in zip(selected_signals, selected_values, strict=False)
     }
     # Ignored values place in with value None so we know which ones were ignored
     named_values.update({key: None for key in ignore})
@@ -73,8 +79,8 @@ def get_signal_values(
 
 
 def walk_rw_signals(
-    device: Device, path_prefix: Optional[str] = ""
-) -> Dict[str, SignalRW[Any]]:
+    device: Device, path_prefix: str | None = ""
+) -> dict[str, SignalRW[Any]]:
     """Retrieve all SignalRWs from a device.
 
     Stores retrieved signals with their dotted attribute paths in a dictionary. Used as
@@ -104,7 +110,7 @@ def walk_rw_signals(
     if not path_prefix:
         path_prefix = ""
 
-    signals: Dict[str, SignalRW[Any]] = {}
+    signals: dict[str, SignalRW[Any]] = {}
     for attr_name, attr in device.children():
         dot_path = f"{path_prefix}{attr_name}"
         if type(attr) is SignalRW:
@@ -114,7 +120,7 @@ def walk_rw_signals(
     return signals
 
 
-def save_to_yaml(phases: Sequence[Dict[str, Any]], save_path: str) -> None:
+def save_to_yaml(phases: Sequence[dict[str, Any]], save_path: str | Path) -> None:
     """Plan which serialises a phase or set of phases of SignalRWs to a yaml file.
 
     Parameters
@@ -134,12 +140,17 @@ def save_to_yaml(phases: Sequence[Dict[str, Any]], save_path: str) -> None:
     """
 
     yaml.add_representer(np.ndarray, ndarray_representer, Dumper=yaml.Dumper)
+    yaml.add_multi_representer(
+        BaseModel,
+        pydantic_model_abstraction_representer,
+        Dumper=yaml.Dumper,
+    )
 
     with open(save_path, "w") as file:
         yaml.dump(phases, file, Dumper=OphydDumper, default_flow_style=False)
 
 
-def load_from_yaml(save_path: str) -> Sequence[Dict[str, Any]]:
+def load_from_yaml(save_path: str) -> Sequence[dict[str, Any]]:
     """Plan that returns a list of dicts with saved signal values from a yaml file.
 
     Parameters
@@ -152,12 +163,12 @@ def load_from_yaml(save_path: str) -> Sequence[Dict[str, Any]]:
     :func:`ophyd_async.core.save_to_yaml`
     :func:`ophyd_async.core.set_signal_values`
     """
-    with open(save_path, "r") as file:
+    with open(save_path) as file:
         return yaml.full_load(file)
 
 
 def set_signal_values(
-    signals: Dict[str, SignalRW[Any]], values: Sequence[Dict[str, Any]]
+    signals: dict[str, SignalRW[Any]], values: Sequence[dict[str, Any]]
 ) -> Generator[Msg, None, None]:
     """Maps signals from a yaml file into device signals.
 
@@ -217,7 +228,7 @@ def load_device(device: Device, path: str):
     yield from set_signal_values(signals_to_set, values)
 
 
-def all_at_once(values: Dict[str, Any]) -> Sequence[Dict[str, Any]]:
+def all_at_once(values: dict[str, Any]) -> Sequence[dict[str, Any]]:
     """Sort all the values into a single phase so they are set all at once"""
     return [values]
 
@@ -225,8 +236,8 @@ def all_at_once(values: Dict[str, Any]) -> Sequence[Dict[str, Any]]:
 def save_device(
     device: Device,
     path: str,
-    sorter: Callable[[Dict[str, Any]], Sequence[Dict[str, Any]]] = all_at_once,
-    ignore: Optional[List[str]] = None,
+    sorter: Callable[[dict[str, Any]], Sequence[dict[str, Any]]] = all_at_once,
+    ignore: list[str] | None = None,
 ):
     """Plan that saves the state of all PV's on a device using a sorter.
 

ophyd_async/core/_flyer.py

@@ -1,15 +1,14 @@
 from abc import ABC, abstractmethod
-from typing import Dict, Generic, Sequence
+from typing import Generic
 
-from bluesky.protocols import DataKey, Flyable, Preparable, Reading, Stageable
+from bluesky.protocols import Flyable, Preparable, Stageable
 
 from ._device import Device
-from ._signal import SignalR
 from ._status import AsyncStatus
-from ._utils import T, merge_gathered_dicts
+from ._utils import T
 
 
-class TriggerLogic(ABC, Generic[T]):
+class FlyerController(ABC, Generic[T]):
     @abstractmethod
     async def prepare(self, value: T):
         """Move to the start of the flyscan"""
@@ -36,16 +35,14 @@ class StandardFlyer(
 ):
     def __init__(
         self,
-        trigger_logic: TriggerLogic[T],
-        configuration_signals: Sequence[SignalR] = (),
+        trigger_logic: FlyerController[T],
         name: str = "",
     ):
         self._trigger_logic = trigger_logic
-        self._configuration_signals = tuple(configuration_signals)
         super().__init__(name=name)
 
     @property
-    def trigger_logic(self) -> TriggerLogic[T]:
+    def trigger_logic(self) -> FlyerController[T]:
         return self._trigger_logic
 
     @AsyncStatus.wrap
@@ -71,13 +68,3 @@ class StandardFlyer(
     @AsyncStatus.wrap
     async def complete(self) -> None:
         await self._trigger_logic.complete()
-
-    async def describe_configuration(self) -> Dict[str, DataKey]:
-        return await merge_gathered_dicts(
-            [sig.describe() for sig in self._configuration_signals]
-        )
-
-    async def read_configuration(self) -> Dict[str, Reading]:
-        return await merge_gathered_dicts(
-            [sig.read() for sig in self._configuration_signals]
-        )

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