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

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

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

ophyd_async/{panda → fastcs/panda}/_hdf_panda.py

@@ -2,17 +2,12 @@ from __future__ import annotations
 
 from typing import Sequence
 
-from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
-    PathProvider,
-    SignalR,
-    StandardDetector,
-)
+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 ._panda_controller import PandaPcapController
-from .writers._hdf_writer import PandaHDFWriter
+from ._block import CommonPandaBlocks
+from ._control import PandaPcapController
+from ._writer import PandaHDFWriter
 
 
 class HDFPanda(CommonPandaBlocks, StandardDetector):
@@ -31,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/{panda → fastcs/panda}/_trigger.py

@@ -4,13 +4,9 @@ from typing import Optional
 from pydantic import BaseModel, Field
 
 from ophyd_async.core import TriggerLogic, wait_for_value
-from ophyd_async.panda import (
-    PcompBlock,
-    PcompDirectionOptions,
-    SeqBlock,
-    SeqTable,
-    TimeUnits,
-)
+
+from ._block import PcompBlock, PcompDirectionOptions, SeqBlock, TimeUnits
+from ._table import SeqTable
 
 
 class SeqTableInfo(BaseModel):

ophyd_async/{panda/writers/_hdf_writer.py → fastcs/panda/_writer.py}

@@ -8,14 +8,15 @@ from p4p.client.thread import Context
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     DetectorWriter,
+    HDFDataset,
+    HDFFile,
     NameProvider,
     PathProvider,
+    observe_value,
     wait_for_value,
 )
-from ophyd_async.core.signal import observe_value
-from ophyd_async.epics.areadetector.writers.general_hdffile import _HDFDataset, _HDFFile
 
-from .._common_blocks import CommonPandaBlocks
+from ._block import DataBlock
 
 
 class PandaHDFWriter(DetectorWriter):
@@ -26,14 +27,14 @@ class PandaHDFWriter(DetectorWriter):
         prefix: str,
         path_provider: PathProvider,
         name_provider: NameProvider,
-        panda_device: CommonPandaBlocks,
+        panda_data_block: DataBlock,
     ) -> None:
-        self.panda_device = panda_device
+        self.panda_data_block = panda_data_block
         self._prefix = prefix
         self._path_provider = path_provider
         self._name_provider = name_provider
-        self._datasets: List[_HDFDataset] = []
-        self._file: Optional[_HDFFile] = None
+        self._datasets: List[HDFDataset] = []
+        self._file: Optional[HDFFile] = None
         self._multiplier = 1
 
     # Triggered on PCAP arm
@@ -41,25 +42,33 @@ class PandaHDFWriter(DetectorWriter):
         """Retrieve and get descriptor of all PandA signals marked for capture"""
 
         # Ensure flushes are immediate
-        await self.panda_device.data.flush_period.set(0)
+        await self.panda_data_block.flush_period.set(0)
 
         self._file = None
-        info = self._path_provider(device_name=self.panda_device.name)
+        info = self._path_provider(device_name=self._name_provider())
+
+        # Set create dir depth first to guarantee that callback when setting
+        # directory path has correct value
+        await self.panda_data_block.create_directory.set(info.create_dir_depth)
+
         # Set the initial values
         await asyncio.gather(
-            self.panda_device.data.hdf_directory.set(
-                str(info.root / info.resource_dir)
-            ),
-            self.panda_device.data.hdf_file_name.set(
+            self.panda_data_block.hdf_directory.set(str(info.directory_path)),
+            self.panda_data_block.hdf_file_name.set(
                 f"{info.filename}.h5",
             ),
-            self.panda_device.data.num_capture.set(0),
-            # TODO: Set create_dir_depth once available
-            # https://github.com/bluesky/ophyd-async/issues/317
+            self.panda_data_block.num_capture.set(0),
         )
 
+        # Make sure that directory exists or has been created.
+        if not await self.panda_data_block.directory_exists.get_value() == 1:
+            raise OSError(
+                f"Directory {info.directory_path} does not exist or "
+                "is not writable by the PandABlocks-ioc!"
+            )
+
         # Wait for it to start, stashing the status that tells us when it finishes
-        await self.panda_device.data.capture.set(True)
+        await self.panda_data_block.capture.set(True)
         if multiplier > 1:
             raise ValueError(
                 "All PandA datasets should be scalar, multiplier should be 1"
@@ -75,7 +84,7 @@ class PandaHDFWriter(DetectorWriter):
         await self._update_datasets()
         describe = {
             ds.data_key: DataKey(
-                source=self.panda_device.data.hdf_directory.source,
+                source=self.panda_data_block.hdf_directory.source,
                 shape=ds.shape,
                 dtype="array" if ds.shape != [1] else "number",
                 dtype_numpy="<f8",  # PandA data should always be written as Float64
@@ -91,9 +100,9 @@ class PandaHDFWriter(DetectorWriter):
         representation of datasets that the panda will write.
         """
 
-        capture_table = await self.panda_device.data.datasets.get_value()
+        capture_table = await self.panda_data_block.datasets.get_value()
         self._datasets = [
-            _HDFDataset(dataset_name, "/" + dataset_name, [1], multiplier=1)
+            HDFDataset(dataset_name, "/" + dataset_name, [1], multiplier=1)
             for dataset_name in capture_table["name"]
         ]
 
@@ -107,18 +116,18 @@ class PandaHDFWriter(DetectorWriter):
 
         matcher.__name__ = f"index_at_least_{index}"
         await wait_for_value(
-            self.panda_device.data.num_captured, matcher, timeout=timeout
+            self.panda_data_block.num_captured, matcher, timeout=timeout
         )
 
     async def get_indices_written(self) -> int:
-        return await self.panda_device.data.num_captured.get_value()
+        return await self.panda_data_block.num_captured.get_value()
 
     async def observe_indices_written(
         self, timeout=DEFAULT_TIMEOUT
     ) -> AsyncGenerator[int, None]:
         """Wait until a specific index is ready to be collected"""
         async for num_captured in observe_value(
-            self.panda_device.data.num_captured, timeout
+            self.panda_data_block.num_captured, timeout
         ):
             yield num_captured // self._multiplier
 
@@ -128,10 +137,9 @@ class PandaHDFWriter(DetectorWriter):
         # TODO: fail if we get dropped frames
         if indices_written:
             if not self._file:
-                self._file = _HDFFile(
-                    self._path_provider(),
-                    Path(await self.panda_device.data.hdf_directory.get_value())
-                    / Path(await self.panda_device.data.hdf_file_name.get_value()),
+                self._file = HDFFile(
+                    Path(await self.panda_data_block.hdf_directory.get_value())
+                    / Path(await self.panda_data_block.hdf_file_name.get_value()),
                     self._datasets,
                 )
                 for doc in self._file.stream_resources():
@@ -141,6 +149,6 @@ class PandaHDFWriter(DetectorWriter):
 
     # Could put this function as default for StandardDetector
     async def close(self):
-        await self.panda_device.data.capture.set(
+        await self.panda_data_block.capture.set(
             False, wait=True, timeout=DEFAULT_TIMEOUT
         )

ophyd_async/plan_stubs/__init__.py

@@ -1,13 +1,16 @@
-from .ensure_connected import ensure_connected
-from .fly import (
+from ._ensure_connected import ensure_connected
+from ._fly import (
     fly_and_collect,
     prepare_static_seq_table_flyer_and_detectors_with_same_trigger,
     time_resolved_fly_and_collect_with_static_seq_table,
 )
+from ._nd_attributes import setup_ndattributes, setup_ndstats_sum
 
 __all__ = [
     "fly_and_collect",
     "prepare_static_seq_table_flyer_and_detectors_with_same_trigger",
     "time_resolved_fly_and_collect_with_static_seq_table",
     "ensure_connected",
+    "setup_ndattributes",
+    "setup_ndstats_sum",
 ]

ophyd_async/plan_stubs/{ensure_connected.py → _ensure_connected.py}

@@ -1,7 +1,6 @@
 import bluesky.plan_stubs as bps
 
-from ophyd_async.core.device import Device
-from ophyd_async.core.utils import DEFAULT_TIMEOUT, wait_for_connection
+from ophyd_async.core import DEFAULT_TIMEOUT, Device, wait_for_connection
 
 
 def ensure_connected(

ophyd_async/plan_stubs/{fly.py → _fly.py}

@@ -3,10 +3,14 @@ from typing import List, Optional
 import bluesky.plan_stubs as bps
 from bluesky.utils import short_uid
 
-from ophyd_async.core.detector import DetectorTrigger, StandardDetector, TriggerInfo
-from ophyd_async.core.flyer import HardwareTriggeredFlyable
-from ophyd_async.core.utils import in_micros
-from ophyd_async.panda import (
+from ophyd_async.core import (
+    DetectorTrigger,
+    StandardDetector,
+    StandardFlyer,
+    TriggerInfo,
+    in_micros,
+)
+from ophyd_async.fastcs.panda import (
     PcompDirectionOptions,
     PcompInfo,
     SeqTable,
@@ -17,7 +21,7 @@ from ophyd_async.panda import (
 
 
 def prepare_static_pcomp_flyer_and_detectors(
-    flyer: HardwareTriggeredFlyable[PcompInfo],
+    flyer: StandardFlyer[PcompInfo],
     detectors: List[StandardDetector],
     pcomp_info: PcompInfo,
     trigger_info: TriggerInfo,
@@ -36,7 +40,7 @@ def prepare_static_pcomp_flyer_and_detectors(
 
 
 def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
-    flyer: HardwareTriggeredFlyable[SeqTableInfo],
+    flyer: StandardFlyer[SeqTableInfo],
     detectors: List[StandardDetector],
     number_of_frames: int,
     exposure: float,
@@ -100,7 +104,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
 
 def fly_and_collect(
     stream_name: str,
-    flyer: HardwareTriggeredFlyable[SeqTableInfo] | HardwareTriggeredFlyable[PcompInfo],
+    flyer: StandardFlyer[SeqTableInfo] | StandardFlyer[PcompInfo],
     detectors: List[StandardDetector],
 ):
     """Kickoff, complete and collect with a flyer and multiple detectors.
@@ -140,7 +144,7 @@ def fly_and_collect(
 
 def fly_and_collect_with_static_pcomp(
     stream_name: str,
-    flyer: HardwareTriggeredFlyable[PcompInfo],
+    flyer: StandardFlyer[PcompInfo],
     detectors: List[StandardDetector],
     number_of_pulses: int,
     pulse_width: int,
@@ -166,7 +170,7 @@ def fly_and_collect_with_static_pcomp(
 
 def time_resolved_fly_and_collect_with_static_seq_table(
     stream_name: str,
-    flyer: HardwareTriggeredFlyable[SeqTableInfo],
+    flyer: StandardFlyer[SeqTableInfo],
     detectors: List[StandardDetector],
     number_of_frames: int,
     exposure: float,

ophyd_async/plan_stubs/_nd_attributes.py

@@ -0,0 +1,63 @@
+from typing import Sequence
+from xml.etree import cElementTree as ET
+
+import bluesky.plan_stubs as bps
+
+from ophyd_async.core._device import Device
+from ophyd_async.epics.adcore._core_io import NDArrayBaseIO
+from ophyd_async.epics.adcore._utils import (
+    NDAttributeDataType,
+    NDAttributeParam,
+    NDAttributePv,
+)
+
+
+def setup_ndattributes(
+    device: NDArrayBaseIO, ndattributes: Sequence[NDAttributePv | NDAttributeParam]
+):
+    xml_text = ET.Element("Attributes")
+
+    for ndattribute in ndattributes:
+        if isinstance(ndattribute, NDAttributeParam):
+            ET.SubElement(
+                xml_text,
+                "Attribute",
+                name=ndattribute.name,
+                type="PARAM",
+                source=ndattribute.param,
+                addr=str(ndattribute.addr),
+                datatype=ndattribute.datatype.value,
+                description=ndattribute.description,
+            )
+        elif isinstance(ndattribute, NDAttributePv):
+            ET.SubElement(
+                xml_text,
+                "Attribute",
+                name=ndattribute.name,
+                type="EPICS_PV",
+                source=ndattribute.signal.source.split("ca://")[-1],
+                dbrtype=ndattribute.dbrtype.value,
+                description=ndattribute.description,
+            )
+        else:
+            raise ValueError(
+                f"Invalid type for ndattributes: {type(ndattribute)}. "
+                "Expected NDAttributePv or NDAttributeParam."
+            )
+    yield from bps.mv(device.nd_attributes_file, xml_text)
+
+
+def setup_ndstats_sum(detector: Device):
+    yield from (
+        setup_ndattributes(
+            detector.hdf,
+            [
+                NDAttributeParam(
+                    name=f"{detector.name}-sum",
+                    param="NDPluginStatsTotal",
+                    datatype=NDAttributeDataType.DOUBLE,
+                    description="Sum of the array",
+                )
+            ],
+        )
+    )

ophyd_async/sim/__init__.py

@@ -1,11 +0,0 @@
-from .pattern_generator import PatternGenerator
-from .sim_pattern_detector_control import SimPatternDetectorControl
-from .sim_pattern_detector_writer import SimPatternDetectorWriter
-from .sim_pattern_generator import SimPatternDetector
-
-__all__ = [
-    "PatternGenerator",
-    "SimPatternDetectorControl",
-    "SimPatternDetectorWriter",
-    "SimPatternDetector",
-]

ophyd_async/sim/demo/__init__.py

@@ -1,3 +1,19 @@
-from .sim_motor import SimMotor
+from ._pattern_detector import (
+    DATA_PATH,
+    SUM_PATH,
+    PatternDetector,
+    PatternDetectorController,
+    PatternDetectorWriter,
+    PatternGenerator,
+)
+from ._sim_motor import SimMotor
 
-__all__ = ["SimMotor"]
+__all__ = [
+    "DATA_PATH",
+    "SUM_PATH",
+    "PatternGenerator",
+    "PatternDetector",
+    "PatternDetectorController",
+    "PatternDetectorWriter",
+    "SimMotor",
+]

ophyd_async/sim/demo/_pattern_detector/__init__.py

@@ -0,0 +1,13 @@
+from ._pattern_detector import PatternDetector
+from ._pattern_detector_controller import PatternDetectorController
+from ._pattern_detector_writer import PatternDetectorWriter
+from ._pattern_generator import DATA_PATH, SUM_PATH, PatternGenerator
+
+__all__ = [
+    "PatternDetector",
+    "PatternDetectorController",
+    "PatternDetectorWriter",
+    "DATA_PATH",
+    "SUM_PATH",
+    "PatternGenerator",
+]

ophyd_async/sim/{sim_pattern_generator.py → demo/_pattern_detector/_pattern_detector.py}

@@ -2,20 +2,20 @@ from pathlib import Path
 from typing import Sequence
 
 from ophyd_async.core import (
+    AsyncReadable,
     FilenameProvider,
     PathProvider,
+    StandardDetector,
     StaticFilenameProvider,
     StaticPathProvider,
 )
-from ophyd_async.core.detector import StandardDetector
-from ophyd_async.protocols import AsyncReadable
-from ophyd_async.sim.pattern_generator import PatternGenerator
 
-from .sim_pattern_detector_control import SimPatternDetectorControl
-from .sim_pattern_detector_writer import SimPatternDetectorWriter
+from ._pattern_detector_controller import PatternDetectorController
+from ._pattern_detector_writer import PatternDetectorWriter
+from ._pattern_generator import PatternGenerator
 
 
-class SimPatternDetector(StandardDetector):
+class PatternDetector(StandardDetector):
     def __init__(
         self,
         path: Path,
@@ -25,12 +25,12 @@ class SimPatternDetector(StandardDetector):
         fp: FilenameProvider = StaticFilenameProvider(name)
         self.path_provider: PathProvider = StaticPathProvider(fp, path)
         self.pattern_generator = PatternGenerator()
-        writer = SimPatternDetectorWriter(
+        writer = PatternDetectorWriter(
             pattern_generator=self.pattern_generator,
             path_provider=self.path_provider,
             name_provider=lambda: self.name,
         )
-        controller = SimPatternDetectorControl(
+        controller = PatternDetectorController(
             pattern_generator=self.pattern_generator,
             path_provider=self.path_provider,
         )

ophyd_async/sim/{sim_pattern_detector_control.py → demo/_pattern_detector/_pattern_detector_controller.py}

@@ -1,13 +1,12 @@
 import asyncio
 from typing import Optional
 
-from ophyd_async.core import PathProvider
-from ophyd_async.core.async_status import AsyncStatus
-from ophyd_async.core.detector import DetectorControl, DetectorTrigger
-from ophyd_async.sim.pattern_generator import PatternGenerator
+from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger, PathProvider
 
+from ._pattern_generator import PatternGenerator
 
-class SimPatternDetectorControl(DetectorControl):
+
+class PatternDetectorController(DetectorControl):
     def __init__(
         self,
         pattern_generator: PatternGenerator,
@@ -15,6 +14,8 @@ class SimPatternDetectorControl(DetectorControl):
         exposure: float = 0.1,
     ) -> None:
         self.pattern_generator: PatternGenerator = pattern_generator
+        if exposure is None:
+            exposure = 0.1
         self.pattern_generator.set_exposure(exposure)
         self.path_provider: PathProvider = path_provider
         self.task: Optional[asyncio.Task] = None
@@ -26,7 +27,8 @@ class SimPatternDetectorControl(DetectorControl):
         trigger: DetectorTrigger = DetectorTrigger.internal,
         exposure: Optional[float] = 0.01,
     ) -> AsyncStatus:
-        assert exposure is not None
+        if exposure is None:
+            exposure = 0.1
         period: float = exposure + self.get_deadtime(exposure)
         task = asyncio.create_task(
             self._coroutine_for_image_writing(exposure, period, num)
@@ -43,7 +45,7 @@ class SimPatternDetectorControl(DetectorControl):
                 pass
             self.task = None
 
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         return 0.001
 
     async def _coroutine_for_image_writing(

ophyd_async/sim/{sim_pattern_detector_writer.py → demo/_pattern_detector/_pattern_detector_writer.py}

@@ -2,12 +2,12 @@ from typing import AsyncGenerator, AsyncIterator, Dict
 
 from bluesky.protocols import DataKey
 
-from ophyd_async.core import NameProvider, PathProvider
-from ophyd_async.core.detector import DetectorWriter
-from ophyd_async.sim.pattern_generator import PatternGenerator
+from ophyd_async.core import DetectorWriter, NameProvider, PathProvider
 
+from ._pattern_generator import PatternGenerator
 
-class SimPatternDetectorWriter(DetectorWriter):
+
+class PatternDetectorWriter(DetectorWriter):
     pattern_generator: PatternGenerator
 
     def __init__(

ophyd_async/sim/{pattern_generator.py → demo/_pattern_detector/_pattern_generator.py}

@@ -5,10 +5,14 @@ import h5py
 import numpy as np
 from bluesky.protocols import DataKey, StreamAsset
 
-from ophyd_async.core import PathProvider
-from ophyd_async.core.signal import observe_value, soft_signal_r_and_setter
-from ophyd_async.core.utils import DEFAULT_TIMEOUT
-from ophyd_async.epics.areadetector.writers.general_hdffile import _HDFDataset, _HDFFile
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    HDFDataset,
+    HDFFile,
+    PathProvider,
+    observe_value,
+    soft_signal_r_and_setter,
+)
 
 # raw data path
 DATA_PATH = "/entry/data/data"
@@ -56,7 +60,7 @@ class PatternGenerator:
             generate_gaussian_blob(width=detector_width, height=detector_height)
             * MAX_UINT8_VALUE
         )
-        self._hdf_stream_provider: Optional[_HDFFile] = None
+        self._hdf_stream_provider: Optional[HDFFile] = None
         self._handle_for_h5_file: Optional[h5py.File] = None
         self.target_path: Optional[Path] = None
 
@@ -135,13 +139,13 @@ class PatternGenerator:
         # cache state to self
         # Add the main data
         self._datasets = [
-            _HDFDataset(
+            HDFDataset(
                 data_key=name,
                 dataset=DATA_PATH,
                 shape=(self.height, self.width),
                 multiplier=multiplier,
             ),
-            _HDFDataset(
+            HDFDataset(
                 f"{name}-sum",
                 dataset=SUM_PATH,
                 shape=(),
@@ -162,8 +166,7 @@ class PatternGenerator:
 
     def _get_new_path(self, path_provider: PathProvider) -> Path:
         info = path_provider(device_name="pattern")
-        filename = info.filename
-        new_path: Path = info.root / info.resource_dir / filename
+        new_path: Path = info.directory_path / info.filename
         return new_path
 
     async def collect_stream_docs(
@@ -183,8 +186,7 @@ class PatternGenerator:
             # until the first frame comes in
             if not self._hdf_stream_provider:
                 assert self.target_path, "open file has not been called"
-                self._hdf_stream_provider = _HDFFile(
-                    self._path_provider(),
+                self._hdf_stream_provider = HDFFile(
                     self.target_path,
                     self._datasets,
                 )

ophyd_async/sim/demo/{sim_motor.py → _sim_motor.py}

@@ -4,15 +4,17 @@ import time
 
 from bluesky.protocols import Movable, Stoppable
 
-from ophyd_async.core import StandardReadable
-from ophyd_async.core.async_status import AsyncStatus, WatchableAsyncStatus
-from ophyd_async.core.signal import (
+from ophyd_async.core import (
+    AsyncStatus,
+    ConfigSignal,
+    HintedSignal,
+    StandardReadable,
+    WatchableAsyncStatus,
+    WatcherUpdate,
     observe_value,
     soft_signal_r_and_setter,
     soft_signal_rw,
 )
-from ophyd_async.core.standard_readable import ConfigSignal, HintedSignal
-from ophyd_async.core.utils import WatcherUpdate
 
 
 class SimMotor(StandardReadable, Movable, Stoppable):