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

ophyd_async/epics/_backend/_p4p.py

@@ -1,5 +1,6 @@
 import asyncio
 import atexit
+import inspect
 import logging
 import time
 from dataclasses import dataclass
@@ -19,6 +20,7 @@ from ophyd_async.core import (
     get_unique,
     wait_for_connection,
 )
+from ophyd_async.core.signal_backend import RuntimeSubsetEnum
 from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
 
 from .common import LimitPair, Limits, common_meta, get_supported_values
@@ -39,6 +41,21 @@ specifier_to_dtype: Dict[str, Dtype] = {
     "s": "string",
 }
 
+specifier_to_np_dtype: Dict[str, str] = {
+    "?": "<i2",  # bool
+    "b": "|i1",  # int8
+    "B": "|u1",  # uint8
+    "h": "<i2",  # int16
+    "H": "<u2",  # uint16
+    "i": "<i4",  # int32
+    "I": "<u4",  # uint32
+    "l": "<i8",  # int64
+    "L": "<u8",  # uint64
+    "f": "<f4",  # float32
+    "d": "<f8",  # float64
+    "s": "|S40",
+}
+
 
 def _data_key_from_value(
     source: str,
@@ -59,12 +76,35 @@ def _data_key_from_value(
         DataKey: A rich DataKey describing the DB record
     """
     shape = shape or []
-    dtype = dtype or specifier_to_dtype[value.type().aspy("value")]
+    type_code = value.type().aspy("value")
+
+    dtype = dtype or specifier_to_dtype[type_code]
+
+    try:
+        if isinstance(type_code, tuple):
+            dtype_numpy = ""
+            if type_code[1] == "enum_t":
+                if dtype == "bool":
+                    dtype_numpy = "<i2"
+                else:
+                    for item in type_code[2]:
+                        if item[0] == "choices":
+                            dtype_numpy = specifier_to_np_dtype[item[1][1]]
+        elif not type_code.startswith("a"):
+            dtype_numpy = specifier_to_np_dtype[type_code]
+        else:
+            # Array type, use typecode of internal element
+            dtype_numpy = specifier_to_np_dtype[type_code[1]]
+    except KeyError:
+        # Case where we can't determine dtype string from value
+        dtype_numpy = ""
+
     display_data = getattr(value, "display", None)
 
     d = DataKey(
         source=source,
         dtype=dtype,
+        dtype_numpy=dtype_numpy,
         shape=shape,
     )
     if display_data is not None:
@@ -249,7 +289,7 @@ def make_converter(datatype: Optional[Type], values: Dict[str, Any]) -> PvaConve
     typ = get_unique(
         {k: type(v.get("value")) for k, v in values.items()}, "value types"
     )
-    if "NTScalarArray" in typeid and typ == list:
+    if "NTScalarArray" in typeid and typ is list:
         # Waveform of strings, check we wanted this
         if datatype and datatype != Sequence[str]:
             raise TypeError(f"{pv} has type [str] not {datatype.__name__}")
@@ -287,6 +327,14 @@ def make_converter(datatype: Optional[Type], values: Dict[str, Any]) -> PvaConve
         return PvaEnumConverter(get_supported_values(pv, datatype, pv_choices))
     elif "NTScalar" in typeid:
         if (
+            typ is str
+            and inspect.isclass(datatype)
+            and issubclass(datatype, RuntimeSubsetEnum)
+        ):
+            return PvaEnumConverter(
+                get_supported_values(pv, datatype, datatype.choices)
+            )
+        elif (
             datatype
             and not issubclass(typ, datatype)
             and not (

ophyd_async/epics/_backend/common.py

@@ -1,6 +1,8 @@
 import inspect
 from enum import Enum
-from typing import Dict, Optional, Tuple, Type, TypedDict
+from typing import Dict, Optional, Tuple, Type
+
+from typing_extensions import TypedDict
 
 from ophyd_async.core.signal_backend import RuntimeSubsetEnum
 

ophyd_async/epics/areadetector/aravis.py

@@ -2,7 +2,7 @@ from typing import get_args
 
 from bluesky.protocols import HasHints, Hints
 
-from ophyd_async.core import DirectoryProvider, StandardDetector
+from ophyd_async.core import PathProvider, StandardDetector
 from ophyd_async.epics.areadetector.controllers.aravis_controller import (
     AravisController,
 )
@@ -24,7 +24,7 @@ class AravisDetector(StandardDetector, HasHints):
     def __init__(
         self,
         prefix: str,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         drv_suffix="cam1:",
         hdf_suffix="HDF1:",
         name="",
@@ -37,7 +37,7 @@ class AravisDetector(StandardDetector, HasHints):
             AravisController(self.drv, gpio_number=gpio_number),
             HDFWriter(
                 self.hdf,
-                directory_provider,
+                path_provider,
                 lambda: self.name,
                 ADBaseShapeProvider(self.drv),
             ),

ophyd_async/epics/areadetector/controllers/aravis_controller.py

@@ -62,6 +62,7 @@ class AravisController(DetectorControl):
         supported_trigger_types = (
             DetectorTrigger.constant_gate,
             DetectorTrigger.edge_trigger,
+            DetectorTrigger.internal,
         )
         if trigger not in supported_trigger_types:
             raise ValueError(

ophyd_async/epics/areadetector/drivers/ad_base.py

@@ -1,6 +1,6 @@
 import asyncio
 from enum import Enum
-from typing import FrozenSet, Sequence, Set
+from typing import FrozenSet, Set
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
@@ -131,9 +131,10 @@ class ADBaseShapeProvider(ShapeProvider):
     def __init__(self, driver: ADBase) -> None:
         self._driver = driver
 
-    async def __call__(self) -> Sequence[int]:
+    async def __call__(self) -> tuple:
         shape = await asyncio.gather(
             self._driver.array_size_y.get_value(),
             self._driver.array_size_x.get_value(),
+            self._driver.data_type.get_value(),
         )
         return shape

ophyd_async/epics/areadetector/kinetix.py

@@ -1,6 +1,6 @@
 from bluesky.protocols import HasHints, Hints
 
-from ophyd_async.core import DirectoryProvider, StandardDetector
+from ophyd_async.core import PathProvider, StandardDetector
 from ophyd_async.epics.areadetector.controllers.kinetix_controller import (
     KinetixController,
 )
@@ -21,7 +21,7 @@ class KinetixDetector(StandardDetector, HasHints):
     def __init__(
         self,
         prefix: str,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         drv_suffix="cam1:",
         hdf_suffix="HDF1:",
         name="",
@@ -33,7 +33,7 @@ class KinetixDetector(StandardDetector, HasHints):
             KinetixController(self.drv),
             HDFWriter(
                 self.hdf,
-                directory_provider,
+                path_provider,
                 lambda: self.name,
                 ADBaseShapeProvider(self.drv),
             ),

ophyd_async/epics/areadetector/pilatus.py

@@ -2,7 +2,7 @@ from enum import Enum
 
 from bluesky.protocols import Hints
 
-from ophyd_async.core import DirectoryProvider
+from ophyd_async.core import PathProvider
 from ophyd_async.core.detector import StandardDetector
 from ophyd_async.epics.areadetector.controllers.pilatus_controller import (
     PilatusController,
@@ -36,7 +36,7 @@ class PilatusDetector(StandardDetector):
     def __init__(
         self,
         prefix: str,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         readout_time: PilatusReadoutTime = PilatusReadoutTime.pilatus3,
         drv_suffix: str = "cam1:",
         hdf_suffix: str = "HDF1:",
@@ -49,7 +49,7 @@ class PilatusDetector(StandardDetector):
             PilatusController(self.drv, readout_time=readout_time.value),
             HDFWriter(
                 self.hdf,
-                directory_provider,
+                path_provider,
                 lambda: self.name,
                 ADBaseShapeProvider(self.drv),
             ),

ophyd_async/epics/areadetector/vimba.py

@@ -1,6 +1,6 @@
 from bluesky.protocols import HasHints, Hints
 
-from ophyd_async.core import DirectoryProvider, StandardDetector
+from ophyd_async.core import PathProvider, StandardDetector
 from ophyd_async.epics.areadetector.controllers.vimba_controller import VimbaController
 from ophyd_async.epics.areadetector.drivers import ADBaseShapeProvider
 from ophyd_async.epics.areadetector.drivers.vimba_driver import VimbaDriver
@@ -18,7 +18,7 @@ class VimbaDetector(StandardDetector, HasHints):
     def __init__(
         self,
         prefix: str,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         drv_suffix="cam1:",
         hdf_suffix="HDF1:",
         name="",
@@ -30,7 +30,7 @@ class VimbaDetector(StandardDetector, HasHints):
             VimbaController(self.drv),
             HDFWriter(
                 self.hdf,
-                directory_provider,
+                path_provider,
                 lambda: self.name,
                 ADBaseShapeProvider(self.drv),
             ),

ophyd_async/epics/areadetector/writers/__init__.py

@@ -1,5 +1,5 @@
 from .hdf_writer import HDFWriter
 from .nd_file_hdf import NDFileHDF
-from .nd_plugin import NDPluginBase, NDPluginStats
+from .nd_plugin import ADBaseDataType, NDPluginBase, NDPluginStats
 
-__all__ = ["HDFWriter", "NDFileHDF", "NDPluginBase", "NDPluginStats"]
+__all__ = ["HDFWriter", "NDFileHDF", "NDPluginBase", "NDPluginStats", "ADBaseDataType"]

ophyd_async/epics/areadetector/writers/general_hdffile.py

@@ -0,0 +1,97 @@
+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,
+    StreamResource,
+)
+
+from ophyd_async.core import PathInfo
+
+
+@dataclass
+class _HDFDataset:
+    data_key: str
+    dataset: str
+    shape: Sequence[int] = field(default_factory=tuple)
+    dtype_numpy: str = ""
+    multiplier: int = 1
+    swmr: bool = False
+
+
+SLICE_NAME = "AD_HDF5_SWMR_SLICE"
+
+
+class _HDFFile:
+    """
+    :param directory_info: Contains information about how to construct a StreamResource
+    :param full_file_name: Absolute path to the file to be written
+    :param datasets: Datasets to write into the file
+    """
+
+    def __init__(
+        self,
+        path_info: PathInfo,
+        full_file_name: Path,
+        datasets: List[_HDFDataset],
+        hostname: str = "localhost",
+    ) -> None:
+        self._last_emitted = 0
+        self._hostname = hostname
+
+        if len(datasets) == 0:
+            self._bundles = []
+            return None
+
+        bundler_composer = ComposeStreamResource()
+
+        uri = urlunparse(
+            (
+                "file",
+                self._hostname,
+                str((path_info.root / full_file_name).absolute()),
+                "",
+                "",
+                None,
+            )
+        )
+
+        self._bundles: List[ComposeStreamResourceBundle] = [
+            bundler_composer(
+                mimetype="application/x-hdf5",
+                uri=uri,
+                data_key=ds.data_key,
+                parameters={
+                    "dataset": ds.dataset,
+                    "swmr": ds.swmr,
+                    "multiplier": ds.multiplier,
+                },
+                uid=None,
+                validate=True,
+            )
+            for ds in datasets
+        ]
+
+    def stream_resources(self) -> Iterator[StreamResource]:
+        for bundle in self._bundles:
+            yield bundle.stream_resource_doc
+
+    def stream_data(self, indices_written: int) -> Iterator[StreamDatum]:
+        # Indices are relative to resource
+        if indices_written > self._last_emitted:
+            indices = {
+                "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/epics/areadetector/writers/hdf_writer.py

@@ -8,30 +8,30 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     DetectorWriter,
-    DirectoryProvider,
     NameProvider,
+    PathProvider,
     ShapeProvider,
     set_and_wait_for_value,
     wait_for_value,
 )
 from ophyd_async.core.signal import observe_value
 
-from ._hdfdataset import _HDFDataset
-from ._hdffile import _HDFFile
+from .general_hdffile import _HDFDataset, _HDFFile
 from .nd_file_hdf import FileWriteMode, NDFileHDF
+from .nd_plugin import convert_ad_dtype_to_np
 
 
 class HDFWriter(DetectorWriter):
     def __init__(
         self,
         hdf: NDFileHDF,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         name_provider: NameProvider,
         shape_provider: ShapeProvider,
         **scalar_datasets_paths: str,
     ) -> None:
         self.hdf = hdf
-        self._directory_provider = directory_provider
+        self._path_provider = path_provider
         self._name_provider = name_provider
         self._shape_provider = shape_provider
         self._scalar_datasets_paths = scalar_datasets_paths
@@ -42,7 +42,7 @@ class HDFWriter(DetectorWriter):
 
     async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
         self._file = None
-        info = self._directory_provider()
+        info = self._path_provider(device_name=self.hdf.name)
         file_path = str(info.root / info.resource_dir)
         await asyncio.gather(
             self.hdf.num_extra_dims.set(0),
@@ -50,8 +50,9 @@ class HDFWriter(DetectorWriter):
             self.hdf.swmr_mode.set(True),
             # See https://github.com/bluesky/ophyd-async/issues/122
             self.hdf.file_path.set(file_path),
-            self.hdf.file_name.set(f"{info.prefix}{self.hdf.name}{info.suffix}"),
+            self.hdf.file_name.set(info.filename),
             self.hdf.file_template.set("%s/%s.h5"),
+            self.hdf.create_dir_depth.set(info.create_dir_depth),
             self.hdf.file_write_mode.set(FileWriteMode.stream),
             # Never use custom xml layout file but use the one defined
             # in the source code file NDFileHDF5LayoutXML.cpp
@@ -70,9 +71,22 @@ class HDFWriter(DetectorWriter):
         detector_shape = tuple(await self._shape_provider())
         self._multiplier = multiplier
         outer_shape = (multiplier,) if multiplier > 1 else ()
+        frame_shape = detector_shape[:-1] if len(detector_shape) > 0 else []
+        dtype_numpy = (
+            convert_ad_dtype_to_np(detector_shape[-1])
+            if len(detector_shape) > 0
+            else ""
+        )
+
         # Add the main data
         self._datasets = [
-            _HDFDataset(name, "/entry/data/data", detector_shape, multiplier)
+            _HDFDataset(
+                data_key=name,
+                dataset="/entry/data/data",
+                shape=frame_shape,
+                dtype_numpy=dtype_numpy,
+                multiplier=multiplier,
+            )
         ]
         # And all the scalar datasets
         for ds_name, ds_path in self._scalar_datasets_paths.items():
@@ -81,14 +95,17 @@ class HDFWriter(DetectorWriter):
                     f"{name}-{ds_name}",
                     f"/entry/instrument/NDAttributes/{ds_path}",
                     (),
+                    "",
                     multiplier,
                 )
             )
+
         describe = {
-            ds.name: DataKey(
+            ds.data_key: DataKey(
                 source=self.hdf.full_file_name.source,
                 shape=outer_shape + tuple(ds.shape),
                 dtype="array" if ds.shape else "number",
+                dtype_numpy=ds.dtype_numpy,
                 external="STREAM:",
             )
             for ds in self._datasets
@@ -115,7 +132,7 @@ class HDFWriter(DetectorWriter):
             if not self._file:
                 path = Path(await self.hdf.full_file_name.get_value())
                 self._file = _HDFFile(
-                    self._directory_provider(),
+                    self._path_provider(),
                     # See https://github.com/bluesky/ophyd-async/issues/122
                     path,
                     self._datasets,

ophyd_async/epics/areadetector/writers/nd_file_hdf.py

@@ -37,4 +37,7 @@ class NDFileHDF(NDPluginBase):
         self.capture = epics_signal_rw_rbv(bool, prefix + "Capture")
         self.flush_now = epics_signal_rw(bool, prefix + "FlushNow")
         self.xml_file_name = epics_signal_rw_rbv(str, prefix + "XMLFileName")
+        self.array_size0 = epics_signal_r(int, prefix + "ArraySize0")
+        self.array_size1 = epics_signal_r(int, prefix + "ArraySize1")
+        self.create_dir_depth = epics_signal_rw(int, prefix + "CreateDirectory")
         super().__init__(prefix, name)

ophyd_async/epics/areadetector/writers/nd_plugin.py

@@ -10,6 +10,35 @@ class Callback(str, Enum):
     Disable = "Disable"
 
 
+class ADBaseDataType(str, Enum):
+    Int8 = "Int8"
+    UInt8 = "UInt8"
+    Int16 = "Int16"
+    UInt16 = "UInt16"
+    Int32 = "Int32"
+    UInt32 = "UInt32"
+    Int64 = "Int64"
+    UInt64 = "UInt64"
+    Float32 = "Float32"
+    Float64 = "Float64"
+
+
+def convert_ad_dtype_to_np(ad_dtype: ADBaseDataType) -> str:
+    ad_dtype_to_np_dtype = {
+        ADBaseDataType.Int8: "|i1",
+        ADBaseDataType.UInt8: "|u1",
+        ADBaseDataType.Int16: "<i2",
+        ADBaseDataType.UInt16: "<u2",
+        ADBaseDataType.Int32: "<i4",
+        ADBaseDataType.UInt32: "<u4",
+        ADBaseDataType.Int64: "<i8",
+        ADBaseDataType.UInt64: "<u8",
+        ADBaseDataType.Float32: "<f4",
+        ADBaseDataType.Float64: "<f8",
+    }
+    return ad_dtype_to_np_dtype[ad_dtype]
+
+
 class NDArrayBase(Device):
     def __init__(self, prefix: str, name: str = "") -> None:
         self.unique_id = epics_signal_r(int, prefix + "UniqueId_RBV")
@@ -17,6 +46,7 @@ class NDArrayBase(Device):
         self.acquire = epics_signal_rw_rbv(bool, prefix + "Acquire")
         self.array_size_x = epics_signal_r(int, prefix + "ArraySizeX_RBV")
         self.array_size_y = epics_signal_r(int, prefix + "ArraySizeY_RBV")
+        self.data_type = epics_signal_r(ADBaseDataType, prefix + "NDDataType_RBV")
         self.array_counter = epics_signal_rw_rbv(int, prefix + "ArrayCounter")
         # There is no _RBV for this one
         self.wait_for_plugins = epics_signal_rw(bool, prefix + "WaitForPlugins")

ophyd_async/epics/demo/demo_ad_sim_detector.py

@@ -1,6 +1,6 @@
 from typing import Sequence
 
-from ophyd_async.core import DirectoryProvider, SignalR, StandardDetector
+from ophyd_async.core import PathProvider, SignalR, StandardDetector
 
 from ..areadetector.controllers import ADSimController
 from ..areadetector.drivers import ADBase, ADBaseShapeProvider
@@ -15,7 +15,7 @@ class DemoADSimDetector(StandardDetector):
         self,
         drv: ADBase,
         hdf: NDFileHDF,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         name: str = "",
         config_sigs: Sequence[SignalR] = (),
     ):
@@ -26,7 +26,7 @@ class DemoADSimDetector(StandardDetector):
             ADSimController(self.drv),
             HDFWriter(
                 self.hdf,
-                directory_provider,
+                path_provider,
                 lambda: self.name,
                 ADBaseShapeProvider(self.drv),
             ),