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

ophyd_async/epics/eiger/_eiger_io.py

@@ -0,0 +1,42 @@
+from enum import Enum
+
+from ophyd_async.core import Device
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw_rbv, epics_signal_w
+
+
+class EigerTriggerMode(str, Enum):
+    internal = "ints"
+    edge = "exts"
+    gate = "exte"
+
+
+class EigerDriverIO(Device):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.bit_depth = epics_signal_r(int, f"{prefix}BitDepthReadout")
+        self.stale_parameters = epics_signal_r(bool, f"{prefix}StaleParameters")
+        self.state = epics_signal_r(str, f"{prefix}DetectorState")
+        self.roi_mode = epics_signal_rw_rbv(str, f"{prefix}RoiMode")
+
+        self.acquire_time = epics_signal_rw_rbv(float, f"{prefix}CountTime")
+        self.acquire_period = epics_signal_rw_rbv(float, f"{prefix}FrameTime")
+
+        self.num_images = epics_signal_rw_rbv(int, f"{prefix}Nimages")
+        self.num_triggers = epics_signal_rw_rbv(int, f"{prefix}Ntrigger")
+
+        # TODO: Should be EigerTriggerMode enum, see https://github.com/DiamondLightSource/eiger-fastcs/issues/43
+        self.trigger_mode = epics_signal_rw_rbv(str, f"{prefix}TriggerMode")
+
+        self.arm = epics_signal_w(int, f"{prefix}Arm")
+        self.disarm = epics_signal_w(int, f"{prefix}Disarm")
+        self.abort = epics_signal_w(int, f"{prefix}Abort")
+
+        self.beam_centre_x = epics_signal_rw_rbv(float, f"{prefix}BeamCenterX")
+        self.beam_centre_y = epics_signal_rw_rbv(float, f"{prefix}BeamCenterY")
+
+        self.det_distance = epics_signal_rw_rbv(float, f"{prefix}DetectorDistance")
+        self.omega_start = epics_signal_rw_rbv(float, f"{prefix}OmegaStart")
+        self.omega_increment = epics_signal_rw_rbv(float, f"{prefix}OmegaIncrement")
+
+        self.photon_energy = epics_signal_rw_rbv(float, f"{prefix}PhotonEnergy")
+
+        super().__init__(name)

ophyd_async/epics/eiger/_odin_io.py

@@ -0,0 +1,125 @@
+import asyncio
+from enum import Enum
+from typing import AsyncGenerator, AsyncIterator, Dict
+
+from bluesky.protocols import StreamAsset
+from event_model.documents.event_descriptor import DataKey
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    DetectorWriter,
+    Device,
+    DeviceVector,
+    NameProvider,
+    PathProvider,
+    observe_value,
+    set_and_wait_for_value,
+)
+from ophyd_async.epics.signal import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_rw_rbv,
+)
+
+
+class Writing(str, Enum):
+    ON = "ON"
+    OFF = "OFF"
+
+
+class OdinNode(Device):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.writing = epics_signal_r(Writing, f"{prefix}HDF:Writing")
+        self.connected = epics_signal_r(bool, f"{prefix}Connected")
+
+        super().__init__(name)
+
+
+class Odin(Device):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.nodes = DeviceVector({i: OdinNode(f"{prefix}FP{i}:") for i in range(4)})
+
+        self.capture = epics_signal_rw(
+            Writing, f"{prefix}Writing", f"{prefix}ConfigHdfWrite"
+        )
+        self.num_captured = epics_signal_r(int, f"{prefix}FramesWritten")
+        self.num_to_capture = epics_signal_rw_rbv(int, f"{prefix}ConfigHdfFrames")
+
+        self.start_timeout = epics_signal_rw_rbv(int, f"{prefix}TimeoutTimerPeriod")
+
+        self.image_height = epics_signal_rw_rbv(int, f"{prefix}DatasetDataDims0")
+        self.image_width = epics_signal_rw_rbv(int, f"{prefix}DatasetDataDims1")
+
+        self.num_row_chunks = epics_signal_rw_rbv(int, f"{prefix}DatasetDataChunks1")
+        self.num_col_chunks = epics_signal_rw_rbv(int, f"{prefix}DatasetDataChunks2")
+
+        self.file_path = epics_signal_rw_rbv(str, f"{prefix}ConfigHdfFilePath")
+        self.file_name = epics_signal_rw_rbv(str, f"{prefix}ConfigHdfFilePrefix")
+
+        self.acquisition_id = epics_signal_rw_rbv(
+            str, f"{prefix}ConfigHdfAcquisitionId"
+        )
+
+        self.data_type = epics_signal_rw_rbv(str, f"{prefix}DatasetDataDatatype")
+
+        super().__init__(name)
+
+
+class OdinWriter(DetectorWriter):
+    def __init__(
+        self,
+        path_provider: PathProvider,
+        name_provider: NameProvider,
+        odin_driver: Odin,
+    ) -> None:
+        self._drv = odin_driver
+        self._path_provider = path_provider
+        self._name_provider = name_provider
+        super().__init__()
+
+    async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
+        info = self._path_provider(device_name=self._name_provider())
+
+        await asyncio.gather(
+            self._drv.file_path.set(str(info.directory_path)),
+            self._drv.file_name.set(info.filename),
+            self._drv.data_type.set(
+                "uint16"
+            ),  # TODO: Get from eiger https://github.com/bluesky/ophyd-async/issues/529
+            self._drv.num_to_capture.set(0),
+        )
+
+        await self._drv.capture.set(Writing.ON)
+
+        return await self._describe()
+
+    async def _describe(self) -> Dict[str, DataKey]:
+        data_shape = await asyncio.gather(
+            self._drv.image_height.get_value(), self._drv.image_width.get_value()
+        )
+
+        return {
+            "data": DataKey(
+                source=self._drv.file_name.source,
+                shape=data_shape,
+                dtype="array",
+                dtype_numpy="<u2",  # TODO: Use correct type based on eiger https://github.com/bluesky/ophyd-async/issues/529
+                external="STREAM:",
+            )
+        }
+
+    async def observe_indices_written(
+        self, timeout=DEFAULT_TIMEOUT
+    ) -> AsyncGenerator[int, None]:
+        async for num_captured in observe_value(self._drv.num_captured, timeout):
+            yield num_captured
+
+    async def get_indices_written(self) -> int:
+        return await self._drv.num_captured.get_value()
+
+    def collect_stream_docs(self, indices_written: int) -> AsyncIterator[StreamAsset]:
+        # TODO: Correctly return stream https://github.com/bluesky/ophyd-async/issues/530
+        raise NotImplementedError()
+
+    async def close(self) -> None:
+        await set_and_wait_for_value(self._drv.capture, Writing.OFF)

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:
@@ -113,7 +119,7 @@ class Motor(StandardReadable, Movable, Stoppable, Flyable, Preparable):
         )
 
         await self.set(fly_prepared_position)
-        await self.velocity.set(fly_velocity)
+        await self.velocity.set(abs(fly_velocity))
 
     @AsyncStatus.wrap
     async def kickoff(self):
@@ -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
 
 

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

@@ -16,7 +16,7 @@ from ophyd_async.core import (
     wait_for_value,
 )
 
-from ._common_blocks import CommonPandaBlocks
+from ._block import DataBlock
 
 
 class PandaHDFWriter(DetectorWriter):
@@ -27,9 +27,9 @@ 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
@@ -42,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"
@@ -76,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
@@ -92,7 +100,7 @@ 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)
             for dataset_name in capture_table["name"]
@@ -108,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
 
@@ -130,9 +138,8 @@ class PandaHDFWriter(DetectorWriter):
         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()),
+                    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():
@@ -142,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

@@ -4,10 +4,13 @@ from ._fly import (
     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/_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/demo/_pattern_detector/_pattern_detector_controller.py

@@ -14,6 +14,8 @@ class PatternDetectorController(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
@@ -25,7 +27,8 @@ class PatternDetectorController(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)
@@ -42,7 +45,7 @@ class PatternDetectorController(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/demo/_pattern_detector/_pattern_generator.py

@@ -166,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(
@@ -188,7 +187,6 @@ class PatternGenerator:
             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.target_path,
                     self._datasets,
                 )