ophyd-async 0.5.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

ophyd_async/epics/adcore/_hdf_writer.py

@@ -1,6 +1,7 @@
 import asyncio
 from pathlib import Path
 from typing import AsyncGenerator, AsyncIterator, Dict, List, Optional
+from xml.etree import ElementTree as ET
 
 from bluesky.protocols import DataKey, Hints, StreamAsset
 
@@ -18,8 +19,13 @@ from ophyd_async.core import (
     wait_for_value,
 )
 
-from ._core_io import NDFileHDFIO
-from ._utils import FileWriteMode, convert_ad_dtype_to_np
+from ._core_io import NDArrayBaseIO, NDFileHDFIO
+from ._utils import (
+    FileWriteMode,
+    convert_ad_dtype_to_np,
+    convert_param_dtype_to_np,
+    convert_pv_dtype_to_np,
+)
 
 
 class ADHDFWriter(DetectorWriter):
@@ -29,13 +35,14 @@ class ADHDFWriter(DetectorWriter):
         path_provider: PathProvider,
         name_provider: NameProvider,
         shape_provider: ShapeProvider,
-        **scalar_datasets_paths: str,
+        *plugins: NDArrayBaseIO,
     ) -> None:
         self.hdf = hdf
         self._path_provider = path_provider
         self._name_provider = name_provider
         self._shape_provider = shape_provider
-        self._scalar_datasets_paths = scalar_datasets_paths
+
+        self._plugins = plugins
         self._capture_status: Optional[AsyncStatus] = None
         self._datasets: List[HDFDataset] = []
         self._file: Optional[HDFFile] = None
@@ -44,16 +51,19 @@ class ADHDFWriter(DetectorWriter):
     async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
         self._file = None
         info = self._path_provider(device_name=self.hdf.name)
-        file_path = str(info.root / info.resource_dir)
+
+        # Set the directory creation depth first, since dir creation callback happens
+        # when directory path PV is processed.
+        await self.hdf.create_directory.set(info.create_dir_depth)
+
         await asyncio.gather(
             self.hdf.num_extra_dims.set(0),
             self.hdf.lazy_open.set(True),
             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_path.set(str(info.directory_path)),
             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
@@ -62,7 +72,7 @@ class ADHDFWriter(DetectorWriter):
 
         assert (
             await self.hdf.file_path_exists.get_value()
-        ), f"File path {file_path} for hdf plugin does not exist"
+        ), f"File path {info.directory_path} for hdf plugin does not exist"
 
         # Overwrite num_capture to go forever
         await self.hdf.num_capture.set(0)
@@ -90,16 +100,31 @@ class ADHDFWriter(DetectorWriter):
             )
         ]
         # And all the scalar datasets
-        for ds_name, ds_path in self._scalar_datasets_paths.items():
-            self._datasets.append(
-                HDFDataset(
-                    f"{name}-{ds_name}",
-                    f"/entry/instrument/NDAttributes/{ds_path}",
-                    (),
-                    "",
-                    multiplier,
-                )
-            )
+        for plugin in self._plugins:
+            maybe_xml = await plugin.nd_attributes_file.get_value()
+            # This is the check that ADCore does to see if it is an XML string
+            # rather than a filename to parse
+            if "<Attributes>" in maybe_xml:
+                root = ET.fromstring(maybe_xml)
+                for child in root:
+                    datakey = child.attrib["name"]
+                    if child.attrib.get("type", "EPICS_PV") == "EPICS_PV":
+                        np_datatype = convert_pv_dtype_to_np(
+                            child.attrib.get("dbrtype", "DBR_NATIVE")
+                        )
+                    else:
+                        np_datatype = convert_param_dtype_to_np(
+                            child.attrib.get("datatype", "INT")
+                        )
+                    self._datasets.append(
+                        HDFDataset(
+                            datakey,
+                            f"/entry/instrument/NDAttributes/{datakey}",
+                            (),
+                            np_datatype,
+                            multiplier,
+                        )
+                    )
 
         describe = {
             ds.data_key: DataKey(
@@ -133,7 +158,6 @@ class ADHDFWriter(DetectorWriter):
             if not self._file:
                 path = Path(await self.hdf.full_file_name.get_value())
                 self._file = HDFFile(
-                    self._path_provider(),
                     # See https://github.com/bluesky/ophyd-async/issues/122
                     path,
                     self._datasets,
@@ -149,8 +173,8 @@ class ADHDFWriter(DetectorWriter):
 
     async def close(self):
         # Already done a caput callback in _capture_status, so can't do one here
-        await self.hdf.capture.set(0, wait=False)
-        await wait_for_value(self.hdf.capture, 0, DEFAULT_TIMEOUT)
+        await self.hdf.capture.set(False, wait=False)
+        await wait_for_value(self.hdf.capture, False, DEFAULT_TIMEOUT)
         if self._capture_status:
             # We kicked off an open, so wait for it to return
             await self._capture_status

ophyd_async/epics/adcore/_utils.py

@@ -1,8 +1,9 @@
+from dataclasses import dataclass
 from enum import Enum
 from typing import Optional
-from xml.etree import cElementTree as ET
 
 from ophyd_async.core import DEFAULT_TIMEOUT, SignalRW, T, wait_for_value
+from ophyd_async.core._signal import SignalR
 
 
 class ADBaseDataType(str, Enum):
@@ -34,6 +35,45 @@ def convert_ad_dtype_to_np(ad_dtype: ADBaseDataType) -> str:
     return ad_dtype_to_np_dtype[ad_dtype]
 
 
+def convert_pv_dtype_to_np(datatype: str) -> str:
+    _pvattribute_to_ad_datatype = {
+        "DBR_SHORT": ADBaseDataType.Int16,
+        "DBR_ENUM": ADBaseDataType.Int16,
+        "DBR_INT": ADBaseDataType.Int32,
+        "DBR_LONG": ADBaseDataType.Int32,
+        "DBR_FLOAT": ADBaseDataType.Float32,
+        "DBR_DOUBLE": ADBaseDataType.Float64,
+    }
+    if datatype in ["DBR_STRING", "DBR_CHAR"]:
+        np_datatype = "s40"
+    elif datatype == "DBR_NATIVE":
+        raise ValueError("Don't support DBR_NATIVE yet")
+    else:
+        try:
+            np_datatype = convert_ad_dtype_to_np(_pvattribute_to_ad_datatype[datatype])
+        except KeyError:
+            raise ValueError(f"Invalid dbr type {datatype}")
+    return np_datatype
+
+
+def convert_param_dtype_to_np(datatype: str) -> str:
+    _paramattribute_to_ad_datatype = {
+        "INT": ADBaseDataType.Int32,
+        "INT64": ADBaseDataType.Int64,
+        "DOUBLE": ADBaseDataType.Float64,
+    }
+    if datatype in ["STRING"]:
+        np_datatype = "s40"
+    else:
+        try:
+            np_datatype = convert_ad_dtype_to_np(
+                _paramattribute_to_ad_datatype[datatype]
+            )
+        except KeyError:
+            raise ValueError(f"Invalid datatype {datatype}")
+    return np_datatype
+
+
 class FileWriteMode(str, Enum):
     single = "Single"
     capture = "Capture"
@@ -52,75 +92,34 @@ class NDAttributeDataType(str, Enum):
     STRING = "STRING"
 
 
-class NDAttributesXML:
-    """Helper to make NDAttributesFile XML for areaDetector"""
-
-    _dbr_types = {
-        None: "DBR_NATIVE",
-        NDAttributeDataType.INT: "DBR_LONG",
-        NDAttributeDataType.DOUBLE: "DBR_DOUBLE",
-        NDAttributeDataType.STRING: "DBR_STRING",
-    }
-
-    def __init__(self):
-        self._root = ET.Element("Attributes")
-
-    def add_epics_pv(
-        self,
-        name: str,
-        pv: str,
-        datatype: Optional[NDAttributeDataType] = None,
-        description: str = "",
-    ):
-        """Add a PV to the attribute list
-
-        Args:
-            name: The attribute name
-            pv: The pv to get from
-            datatype: An override datatype, otherwise will use native EPICS type
-            description: A description that appears in the HDF file as an attribute
-        """
-        ET.SubElement(
-            self._root,
-            "Attribute",
-            name=name,
-            type="EPICS_PV",
-            source=pv,
-            datatype=self._dbr_types[datatype],
-            description=description,
-        )
-
-    def add_param(
-        self,
-        name: str,
-        param: str,
-        datatype: NDAttributeDataType,
-        addr: int = 0,
-        description: str = "",
-    ):
-        """Add a driver or plugin parameter to the attribute list
-
-        Args:
-            name: The attribute name
-            param: The parameter string as seen in the INP link of the record
-            datatype: The datatype of the parameter
-            description: A description that appears in the HDF file as an attribute
-        """
-        ET.SubElement(
-            self._root,
-            "Attribute",
-            name=name,
-            type="PARAM",
-            source=param,
-            addr=str(addr),
-            datatype=datatype.value,
-            description=description,
-        )
-
-    def __str__(self) -> str:
-        """Output the XML pretty printed"""
-        ET.indent(self._root, space="    ", level=0)
-        return ET.tostring(self._root, xml_declaration=True, encoding="utf-8").decode()
+class NDAttributePvDbrType(str, Enum):
+    DBR_SHORT = "DBR_SHORT"
+    DBR_ENUM = "DBR_ENUM"
+    DBR_INT = "DBR_INT"
+    DBR_LONG = "DBR_LONG"
+    DBR_FLOAT = "DBR_FLOAT"
+    DBR_DOUBLE = "DBR_DOUBLE"
+    DBR_STRING = "DBR_STRING"
+    DBR_CHAR = "DBR_CHAR"
+
+
+@dataclass
+class NDAttributePv:
+    name: str  # name of attribute stamped on array, also scientifically useful name
+    # when appended to device.name
+    signal: SignalR  # caget the pv given by signal.source and attach to each frame
+    dbrtype: NDAttributePvDbrType
+    description: str = ""  # A description that appears in the HDF file as an attribute
+
+
+@dataclass
+class NDAttributeParam:
+    name: str  # name of attribute stamped on array, also scientifically useful name
+    # when appended to device.name
+    param: str  # The parameter string as seen in the INP link of the record
+    datatype: NDAttributeDataType  # The datatype of the parameter
+    addr: int = 0  # The address as seen in the INP link of the record
+    description: str = ""  # A description that appears in the HDF file as an attribute
 
 
 async def stop_busy_record(

ophyd_async/epics/adkinetix/_kinetix_io.py

@@ -14,6 +14,7 @@ class KinetixReadoutMode(str, Enum):
     sensitivity = 1
     speed = 2
     dynamic_range = 3
+    sub_electron = 4
 
 
 class KinetixDriverIO(adcore.ADBaseIO):
@@ -24,5 +25,7 @@ class KinetixDriverIO(adcore.ADBaseIO):
         self.trigger_mode = epics_signal_rw_rbv(
             KinetixTriggerMode, prefix + "TriggerMode"
         )
-        self.mode = epics_signal_rw_rbv(KinetixReadoutMode, prefix + "ReadoutPortIdx")
+        self.readout_port_idx = epics_signal_rw_rbv(
+            KinetixReadoutMode, prefix + "ReadoutPortIdx"
+        )
         super().__init__(prefix, name)

ophyd_async/epics/adpilatus/_pilatus_controller.py

@@ -54,7 +54,7 @@ class PilatusController(DetectorControl):
         # is actually ready. Should wait for that too or we risk dropping
         # a frame
         await wait_for_value(
-            self._drv.armed_for_triggers,
+            self._drv.armed,
             True,
             timeout=DEFAULT_TIMEOUT,
         )

ophyd_async/epics/adpilatus/_pilatus_io.py

@@ -19,5 +19,5 @@ class PilatusDriverIO(adcore.ADBaseIO):
         self.trigger_mode = epics_signal_rw_rbv(
             PilatusTriggerMode, prefix + "TriggerMode"
         )
-        self.armed_for_triggers = epics_signal_r(bool, prefix + "Armed")
+        self.armed = epics_signal_r(bool, prefix + "Armed")
         super().__init__(prefix, name)

ophyd_async/epics/advimba/_vimba_controller.py

@@ -39,7 +39,7 @@ class VimbaController(DetectorControl):
     ) -> AsyncStatus:
         await asyncio.gather(
             self._drv.trigger_mode.set(TRIGGER_MODE[trigger]),
-            self._drv.expose_mode.set(EXPOSE_OUT_MODE[trigger]),
+            self._drv.exposure_mode.set(EXPOSE_OUT_MODE[trigger]),
             self._drv.num_images.set(num),
             self._drv.image_mode.set(adcore.ImageMode.multiple),
         )
@@ -49,9 +49,9 @@ class VimbaController(DetectorControl):
         ]:
             await self._drv.acquire_time.set(exposure)
         if trigger != DetectorTrigger.internal:
-            self._drv.trig_source.set(VimbaTriggerSource.line1)
+            self._drv.trigger_source.set(VimbaTriggerSource.line1)
         else:
-            self._drv.trig_source.set(VimbaTriggerSource.freerun)
+            self._drv.trigger_source.set(VimbaTriggerSource.freerun)
         return await adcore.start_acquiring_driver_and_ensure_status(self._drv)
 
     async def disarm(self):

ophyd_async/epics/advimba/_vimba_io.py

@@ -50,15 +50,17 @@ class VimbaDriverIO(adcore.ADBaseIO):
 
     def __init__(self, prefix: str, name: str = "") -> None:
         # self.pixel_format = epics_signal_rw_rbv(PixelFormat, prefix + "PixelFormat")
-        self.convert_format = epics_signal_rw_rbv(
+        self.convert_pixel_format = epics_signal_rw_rbv(
             VimbaConvertFormat, prefix + "ConvertPixelFormat"
         )  # Pixel format of data outputted to AD
-        self.trig_source = epics_signal_rw_rbv(
+        self.trigger_source = epics_signal_rw_rbv(
             VimbaTriggerSource, prefix + "TriggerSource"
         )
         self.trigger_mode = epics_signal_rw_rbv(VimbaOnOff, prefix + "TriggerMode")
-        self.overlap = epics_signal_rw_rbv(VimbaOverlap, prefix + "TriggerOverlap")
-        self.expose_mode = epics_signal_rw_rbv(
+        self.trigger_overlap = epics_signal_rw_rbv(
+            VimbaOverlap, prefix + "TriggerOverlap"
+        )
+        self.exposure_mode = epics_signal_rw_rbv(
             VimbaExposeOutMode, prefix + "ExposureMode"
         )
         super().__init__(prefix, name)

ophyd_async/epics/motor.py

@@ -1,7 +1,13 @@
 import asyncio
 from typing import Optional
 
-from bluesky.protocols import Flyable, Movable, Preparable, Stoppable
+from bluesky.protocols import (
+    Flyable,
+    Locatable,
+    Location,
+    Preparable,
+    Stoppable,
+)
 from pydantic import BaseModel, Field
 
 from ophyd_async.core import (
@@ -51,7 +57,7 @@ class FlyMotorInfo(BaseModel):
     timeout: CalculatableTimeout = Field(frozen=True, default=CalculateTimeout)
 
 
-class Motor(StandardReadable, Movable, Stoppable, Flyable, Preparable):
+class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
     """Device that moves a motor record"""
 
     def __init__(self, prefix: str, name="") -> None:
@@ -193,6 +199,13 @@ class Motor(StandardReadable, Movable, Stoppable, Flyable, Preparable):
         await self.velocity.set(abs(max_speed))
         return fly_velocity
 
+    async def locate(self) -> Location[float]:
+        location: Location = {
+            "setpoint": await self.user_setpoint.get_value(),
+            "readback": await self.user_readback.get_value(),
+        }
+        return location
+
     async def _prepare_motor_path(
         self, fly_velocity: float, start_position: float, end_position: float
     ) -> float:

ophyd_async/epics/signal/_aioca.py

@@ -47,7 +47,7 @@ def _data_key_from_augmented_value(
     value: AugmentedValue,
     *,
     choices: Optional[List[str]] = None,
-    dtype: Optional[str] = None,
+    dtype: Optional[Dtype] = None,
 ) -> DataKey:
     """Use the return value of get with FORMAT_CTRL to construct a DataKey
     describing the signal. See docstring of AugmentedValue for expected
@@ -175,7 +175,7 @@ class CaBoolConverter(CaConverter):
         return bool(value)
 
     def get_datakey(self, value: AugmentedValue) -> DataKey:
-        return _data_key_from_augmented_value(value, dtype="bool")
+        return _data_key_from_augmented_value(value, dtype="boolean")
 
 
 class DisconnectedCaConverter(CaConverter):
@@ -229,10 +229,17 @@ def make_converter(
         value = list(values.values())[0]
         # Done the dbr check, so enough to check one of the values
         if datatype and not isinstance(value, datatype):
-            raise TypeError(
-                f"{pv} has type {type(value).__name__.replace('ca_', '')} "
-                + f"not {datatype.__name__}"
+            # Allow int signals to represent float records when prec is 0
+            is_prec_zero_float = (
+                isinstance(value, float)
+                and get_unique({k: v.precision for k, v in values.items()}, "precision")
+                == 0
             )
+            if not (datatype is int and is_prec_zero_float):
+                raise TypeError(
+                    f"{pv} has type {type(value).__name__.replace('ca_', '')} "
+                    + f"not {datatype.__name__}"
+                )
         return CaConverter(pv_dbr, None)
 
 

ophyd_async/epics/signal/_common.py

@@ -55,7 +55,7 @@ def get_supported_values(
                 f"which do not match {datatype}, which has {choices}."
             )
         return {x: datatype(x) if x else "_" for x in pv_choices}
-    elif datatype is None:
+    elif datatype is None or datatype is str:
         return {x: x or "_" for x in pv_choices}
 
     raise TypeError(

ophyd_async/epics/signal/_p4p.py

@@ -64,7 +64,7 @@ def _data_key_from_value(
     *,
     shape: Optional[list[int]] = None,
     choices: Optional[list[str]] = None,
-    dtype: Optional[str] = None,
+    dtype: Optional[Dtype] = None,
 ) -> DataKey:
     """
     Args:
@@ -85,7 +85,7 @@ def _data_key_from_value(
         if isinstance(type_code, tuple):
             dtype_numpy = ""
             if type_code[1] == "enum_t":
-                if dtype == "bool":
+                if dtype == "boolean":
                     dtype_numpy = "<i2"
                 else:
                     for item in type_code[2]:
@@ -241,7 +241,7 @@ class PvaEmumBoolConverter(PvaConverter):
         return bool(value["value"]["index"])
 
     def get_datakey(self, source: str, value) -> DataKey:
-        return _data_key_from_value(source, value, dtype="bool")
+        return _data_key_from_value(source, value, dtype="boolean")
 
 
 class PvaTableConverter(PvaConverter):
@@ -335,14 +335,17 @@ def make_converter(datatype: Optional[Type], values: Dict[str, Any]) -> PvaConve
             return PvaEnumConverter(
                 get_supported_values(pv, datatype, datatype.choices)
             )
-        elif (
-            datatype
-            and not issubclass(typ, datatype)
-            and not (
-                typ is float and datatype is int
-            )  # Allow float -> int since prec can be 0
-        ):
-            raise TypeError(f"{pv} has type {typ.__name__} not {datatype.__name__}")
+        elif datatype and not issubclass(typ, datatype):
+            # Allow int signals to represent float records when prec is 0
+            is_prec_zero_float = typ is float and (
+                get_unique(
+                    {k: v["display"]["precision"] for k, v in values.items()},
+                    "precision",
+                )
+                == 0
+            )
+            if not (datatype is int and is_prec_zero_float):
+                raise TypeError(f"{pv} has type {typ.__name__} not {datatype.__name__}")
         return PvaConverter()
     elif "NTTable" in typeid:
         return PvaTableConverter()

ophyd_async/fastcs/panda/__init__.py

@@ -1,4 +1,4 @@
-from ._common_blocks import (
+from ._block import (
     CommonPandaBlocks,
     DataBlock,
     EnableDisableOptions,
@@ -9,9 +9,8 @@ from ._common_blocks import (
     SeqBlock,
     TimeUnits,
 )
+from ._control import PandaPcapController
 from ._hdf_panda import HDFPanda
-from ._hdf_writer import PandaHDFWriter
-from ._panda_controller import PandaPcapController
 from ._table import (
     DatasetTable,
     PandaHdf5DatasetType,
@@ -28,6 +27,7 @@ from ._trigger import (
     StaticSeqTableTriggerLogic,
 )
 from ._utils import phase_sorter
+from ._writer import PandaHDFWriter
 
 __all__ = [
     "CommonPandaBlocks",

ophyd_async/fastcs/panda/{_common_blocks.py → _block.py}

@@ -13,6 +13,8 @@ class DataBlock(Device):
     hdf_file_name: SignalRW[str]
     num_capture: SignalRW[int]
     num_captured: SignalR[int]
+    create_directory: SignalRW[int]
+    directory_exists: SignalR[bool]
     capture: SignalRW[bool]
     flush_period: SignalRW[float]
     datasets: SignalR[DatasetTable]

ophyd_async/fastcs/panda/{_panda_controller.py → _control.py}

@@ -8,7 +8,7 @@ from ophyd_async.core import (
     wait_for_value,
 )
 
-from ._common_blocks import PcapBlock
+from ._block import PcapBlock
 
 
 class PandaPcapController(DetectorControl):

ophyd_async/fastcs/panda/_hdf_panda.py

@@ -5,9 +5,9 @@ from typing import Sequence
 from ophyd_async.core import DEFAULT_TIMEOUT, PathProvider, SignalR, StandardDetector
 from ophyd_async.epics.pvi import create_children_from_annotations, fill_pvi_entries
 
-from ._common_blocks import CommonPandaBlocks
-from ._hdf_writer import PandaHDFWriter
-from ._panda_controller import PandaPcapController
+from ._block import CommonPandaBlocks
+from ._control import PandaPcapController
+from ._writer import PandaHDFWriter
 
 
 class HDFPanda(CommonPandaBlocks, StandardDetector):
@@ -26,7 +26,7 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
             prefix=prefix,
             path_provider=path_provider,
             name_provider=lambda: name,
-            panda_device=self,
+            panda_data_block=self.data,
         )
         super().__init__(
             controller=controller,

ophyd_async/fastcs/panda/_trigger.py

@@ -5,7 +5,7 @@ from pydantic import BaseModel, Field
 
 from ophyd_async.core import TriggerLogic, wait_for_value
 
-from ._common_blocks import PcompBlock, PcompDirectionOptions, SeqBlock, TimeUnits
+from ._block import PcompBlock, PcompDirectionOptions, SeqBlock, TimeUnits
 from ._table import SeqTable