ophyd-async 0.3.4__tar.gz → 0.4.0__tar.gz

{ophyd_async-0.3.4 → ophyd_async-0.4.0}/.github/workflows/_release.yml

@@ -23,7 +23,7 @@ jobs:
       - name: Create GitHub Release
         # We pin to the SHA, not the tag, for security reasons.
         # https://docs.github.com/en/actions/learn-github-actions/security-hardening-for-github-actions#using-third-party-actions
-        uses: softprops/action-gh-release@69320dbe05506a9a39fc8ae11030b214ec2d1f87 # v2.0.5
+        uses: softprops/action-gh-release@a74c6b72af54cfa997e81df42d94703d6313a2d0 # v2.0.6
         with:
           prerelease: ${{ contains(github.ref_name, 'a') || contains(github.ref_name, 'b') || contains(github.ref_name, 'rc') }}
           files: "*"

{ophyd_async-0.3.4 → ophyd_async-0.4.0}/.github/workflows/_test.yml

@@ -49,7 +49,6 @@ jobs:
         with:
           python-version: ${{ inputs.python-version }}
           pip-install: ".[dev]"
-
       - name: Run tests
         run: tox -e tests
 

{ophyd_async-0.3.4 → ophyd_async-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3.4
+Version: 0.4.0
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License
@@ -45,10 +45,12 @@ Requires-Dist: numpy<2.0.0
 Requires-Dist: packaging
 Requires-Dist: pint
 Requires-Dist: bluesky>=1.13.0a3
-Requires-Dist: event-model<1.21.0
+Requires-Dist: event_model
 Requires-Dist: p4p
 Requires-Dist: pyyaml
 Requires-Dist: colorlog
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pydantic-numpy
 Provides-Extra: ca
 Requires-Dist: aioca>=1.6; extra == "ca"
 Provides-Extra: pva
@@ -81,10 +83,13 @@ Requires-Dist: pytest-faulthandler; extra == "dev"
 Requires-Dist: pytest-rerunfailures; extra == "dev"
 Requires-Dist: pytest-timeout; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
+Requires-Dist: sphinx<7.4.0; extra == "dev"
 Requires-Dist: sphinx-autobuild; extra == "dev"
+Requires-Dist: autodoc-pydantic; extra == "dev"
 Requires-Dist: sphinxcontrib-mermaid; extra == "dev"
 Requires-Dist: sphinx-copybutton; extra == "dev"
 Requires-Dist: sphinx-design; extra == "dev"
+Requires-Dist: super_state_machine; extra == "dev"
 Requires-Dist: tox-direct; extra == "dev"
 Requires-Dist: types-mock; extra == "dev"
 Requires-Dist: types-pyyaml; extra == "dev"

{ophyd_async-0.3.4 → ophyd_async-0.4.0}/docs/conf.py

@@ -34,6 +34,8 @@ else:
 extensions = [
     # for diagrams
     "sphinxcontrib.mermaid",
+    # Used for BaseModel autodoc
+    "sphinxcontrib.autodoc_pydantic",
     # Use this for generating API docs
     "sphinx.ext.autodoc",
     "sphinx.ext.doctest",
@@ -239,5 +241,9 @@ autodoc_docstring_signature = True
 # numpydoc config
 numpydoc_show_class_members = False
 
+# pydantic models
+autodoc_pydantic_model_show_json = True
+autodoc_pydantic_model_show_config_summary = False
+
 # Where to put Ipython savefigs
 ipython_savefig_dir = "../build/savefig"

{ophyd_async-0.3.4 → ophyd_async-0.4.0}/pyproject.toml

@@ -17,10 +17,12 @@ dependencies = [
     "packaging",
     "pint",
     "bluesky>=1.13.0a3",
-    "event-model<1.21.0",
+    "event_model",
     "p4p",
     "pyyaml",
     "colorlog",
+    "pydantic>=2.0",
+    "pydantic-numpy",
 ]
 dynamic = ["version"]
 license.file = "LICENSE"
@@ -58,10 +60,13 @@ dev = [
     "pytest-rerunfailures",
     "pytest-timeout",
     "ruff",
+    "sphinx<7.4.0",              # https://github.com/bluesky/ophyd-async/issues/459
     "sphinx-autobuild",
+    "autodoc-pydantic",
     "sphinxcontrib-mermaid",
     "sphinx-copybutton",
     "sphinx-design",
+    "super_state_machine",
     "tox-direct",
     "types-mock",
     "types-pyyaml",
@@ -127,7 +132,7 @@ allowlist_externals =
 commands =
     tests: pytest --cov=ophyd_async --cov-report term --cov-report xml:cov.xml {posargs}
     type-checking: ruff check src tests {posargs}
-    pre-commit: pre-commit run --all-files {posargs}
+    pre-commit: pre-commit run --all-files --show-diff-on-failure {posargs}
     docs: sphinx-{posargs:build -EW --keep-going} -T docs build/html
 """
 

{ophyd_async-0.3.4 → ophyd_async-0.4.0}/src/ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.4'
-__version_tuple__ = version_tuple = (0, 3, 4)
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)

{ophyd_async-0.3.4 → ophyd_async-0.4.0}/src/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-0.4.0/src/ophyd_async/core/_providers.py

@@ -0,0 +1,230 @@
+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 List, Optional, Protocol
+
+
+@dataclass
+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 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
+    filename: str
+    create_dir_depth: int = 0
+
+
+class FilenameProvider(Protocol):
+    @abstractmethod
+    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 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,
+        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:
+        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,
+            filename=filename,
+            create_dir_depth=self._create_dir_depth,
+        )
+
+
+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):
+    @abstractmethod
+    def __call__(self) -> str:
+        """Get the name to be used as a data_key in the descriptor document"""
+
+
+class ShapeProvider(Protocol):
+    @abstractmethod
+    async def __call__(self) -> tuple:
+        """Get the shape of the data collection"""

{ophyd_async-0.3.4 → ophyd_async-0.4.0}/src/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-0.3.4 → ophyd_async-0.4.0}/src/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-0.3.4 → ophyd_async-0.4.0}/src/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-0.3.4 → ophyd_async-0.4.0}/src/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:
@@ -99,6 +116,7 @@ class SoftEnumConverter(SoftConverter):
         return {
             "source": source,
             "dtype": "string",
+            "dtype_numpy": "|S40",
             "shape": [],
             "choices": self.choices,
             **metadata,

{ophyd_async-0.3.4 → ophyd_async-0.4.0}/src/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)],
     )