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

ophyd_async/sim/pattern_generator.py

@@ -1,31 +1,14 @@
-from dataclasses import dataclass
 from pathlib import Path
-from typing import (
-    Any,
-    AsyncGenerator,
-    AsyncIterator,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-)
+from typing import AsyncGenerator, AsyncIterator, Dict, Optional
 
 import h5py
 import numpy as np
 from bluesky.protocols import DataKey, StreamAsset
-from event_model import (
-    ComposeStreamResource,
-    ComposeStreamResourceBundle,
-    StreamDatum,
-    StreamRange,
-    StreamResource,
-)
-
-from ophyd_async.core import DirectoryInfo, DirectoryProvider
-from ophyd_async.core.mock_signal_backend import MockSignalBackend
-from ophyd_async.core.signal import SignalR, observe_value
+
+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
 
 # raw data path
 DATA_PATH = "/entry/data/data"
@@ -35,35 +18,6 @@ SUM_PATH = "/entry/sum"
 
 MAX_UINT8_VALUE = np.iinfo(np.uint8).max
 
-SLICE_NAME = "AD_HDF5_SWMR_SLICE"
-
-
-@dataclass
-class DatasetConfig:
-    name: str
-    shape: Sequence[int]
-    maxshape: tuple[Any, ...] = (None,)
-    path: Optional[str] = None
-    multiplier: Optional[int] = 1
-    dtype: Optional[Any] = None
-    fillvalue: Optional[int] = None
-
-
-def get_full_file_description(
-    datasets: List[DatasetConfig], outer_shape: tuple[int, ...]
-):
-    full_file_description: Dict[str, DataKey] = {}
-    for d in datasets:
-        source = f"soft://{d.name}"
-        shape = outer_shape + tuple(d.shape)
-        dtype = "number" if d.shape == [1] else "array"
-        descriptor = DataKey(
-            source=source, shape=shape, dtype=dtype, external="STREAM:"
-        )
-        key = d.name.replace("/", "_")
-        full_file_description[key] = descriptor
-    return full_file_description
-
 
 def generate_gaussian_blob(height: int, width: int) -> np.ndarray:
     """Make a Gaussian Blob with float values in range 0..1"""
@@ -81,71 +35,10 @@ def generate_interesting_pattern(x: float, y: float) -> float:
     return z
 
 
-class HdfStreamProvider:
-    def __init__(
-        self,
-        directory_info: DirectoryInfo,
-        full_file_name: Path,
-        datasets: List[DatasetConfig],
-    ) -> None:
-        self._last_emitted = 0
-        self._bundles: List[ComposeStreamResourceBundle] = self._compose_bundles(
-            directory_info, full_file_name, datasets
-        )
-
-    def _compose_bundles(
-        self,
-        directory_info: DirectoryInfo,
-        full_file_name: Path,
-        datasets: List[DatasetConfig],
-    ) -> List[StreamAsset]:
-        path = str(full_file_name.relative_to(directory_info.root))
-        root = str(directory_info.root)
-        bundler_composer = ComposeStreamResource()
-
-        bundles: List[ComposeStreamResourceBundle] = []
-
-        bundles = [
-            bundler_composer(
-                spec=SLICE_NAME,
-                root=root,
-                resource_path=path,
-                data_key=d.name.replace("/", "_"),
-                resource_kwargs={
-                    "path": d.path,
-                    "multiplier": d.multiplier,
-                    "timestamps": "/entry/instrument/NDAttributes/NDArrayTimeStamp",
-                },
-            )
-            for d in datasets
-        ]
-        return bundles
-
-    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:
-            updated_stream_range = StreamRange(
-                start=self._last_emitted,
-                stop=indices_written,
-            )
-            self._last_emitted = indices_written
-            for bundle in self._bundles:
-                yield bundle.compose_stream_datum(indices=updated_stream_range)
-        return None
-
-    def close(self) -> None:
-        for bundle in self._bundles:
-            bundle.close()
-
-
 class PatternGenerator:
     def __init__(
         self,
-        saturation_exposure_time: float = 1,
+        saturation_exposure_time: float = 0.1,
         detector_width: int = 320,
         detector_height: int = 240,
     ) -> None:
@@ -155,17 +48,15 @@ class PatternGenerator:
         self.y = 0.0
         self.height = detector_height
         self.width = detector_width
-        self.written_images_counter: int = 0
+        self.image_counter: int = 0
 
         # it automatically initializes to 0
-        self.signal_backend = MockSignalBackend(int)
-        self.mock_signal = SignalR(self.signal_backend)
-        blob = np.array(
+        self.counter_signal, self._set_counter_signal = soft_signal_r_and_setter(int)
+        self._full_intensity_blob = (
             generate_gaussian_blob(width=detector_width, height=detector_height)
             * MAX_UINT8_VALUE
         )
-        self.STARTING_BLOB = blob
-        self._hdf_stream_provider: Optional[HdfStreamProvider] = None
+        self._hdf_stream_provider: Optional[_HDFFile] = None
         self._handle_for_h5_file: Optional[h5py.File] = None
         self.target_path: Optional[Path] = None
 
@@ -173,31 +64,24 @@ class PatternGenerator:
         assert self._handle_for_h5_file, "no file has been opened!"
         # prepare - resize the fixed hdf5 data structure
         # so that the new image can be written
-        new_layer = self.written_images_counter + 1
-        target_dimensions = (new_layer, self.height, self.width)
+        self._handle_for_h5_file[DATA_PATH].resize(
+            (self.image_counter + 1, self.height, self.width)
+        )
+        self._handle_for_h5_file[SUM_PATH].resize((self.image_counter + 1,))
 
         # generate the simulated data
         intensity: float = generate_interesting_pattern(self.x, self.y)
-        detector_data: np.uint8 = np.uint8(
-            self.STARTING_BLOB
+        detector_data = (
+            self._full_intensity_blob
             * intensity
             * self.exposure
             / self.saturation_exposure_time
-        )
-
-        self._handle_for_h5_file[DATA_PATH].resize(target_dimensions)
-
-        print(f"writing image {new_layer}")
-        assert self._handle_for_h5_file, "no file has been opened!"
-        self._handle_for_h5_file[DATA_PATH].resize(target_dimensions)
-
-        self._handle_for_h5_file[SUM_PATH].resize((new_layer,))
+        ).astype(np.uint8)
 
         # write data to disc (intermediate step)
-        self._handle_for_h5_file[DATA_PATH][self.written_images_counter] = detector_data
-        self._handle_for_h5_file[SUM_PATH][self.written_images_counter] = np.sum(
-            detector_data
-        )
+        self._handle_for_h5_file[DATA_PATH][self.image_counter] = detector_data
+        sum = np.sum(detector_data)
+        self._handle_for_h5_file[SUM_PATH][self.image_counter] = sum
 
         # save metadata - so that it's discoverable
         self._handle_for_h5_file[DATA_PATH].flush()
@@ -205,8 +89,8 @@ class PatternGenerator:
 
         # counter increment is last
         # as only at this point the new data is visible from the outside
-        self.written_images_counter += 1
-        await self.signal_backend.put(self.written_images_counter)
+        self.image_counter += 1
+        self._set_counter_signal(self.image_counter)
 
     def set_exposure(self, value: float) -> None:
         self.exposure = value
@@ -218,63 +102,70 @@ class PatternGenerator:
         self.y = value
 
     async def open_file(
-        self, directory: DirectoryProvider, multiplier: int = 1
+        self, path_provider: PathProvider, name: str, multiplier: int = 1
     ) -> Dict[str, DataKey]:
-        await self.mock_signal.connect()
+        await self.counter_signal.connect()
 
-        self.target_path = self._get_new_path(directory)
+        self.target_path = self._get_new_path(path_provider)
+        self._path_provider = path_provider
 
         self._handle_for_h5_file = h5py.File(self.target_path, "w", libver="latest")
 
         assert self._handle_for_h5_file, "not loaded the file right"
 
-        datasets = self._get_datasets()
-        for d in datasets:
-            self._handle_for_h5_file.create_dataset(
-                name=d.name,
-                shape=d.shape,
-                dtype=d.dtype,
-                maxshape=d.maxshape,
-            )
+        self._handle_for_h5_file.create_dataset(
+            name=DATA_PATH,
+            shape=(0, self.height, self.width),
+            dtype=np.uint8,
+            maxshape=(None, self.height, self.width),
+        )
+        self._handle_for_h5_file.create_dataset(
+            name=SUM_PATH,
+            shape=(0,),
+            dtype=np.float64,
+            maxshape=(None,),
+        )
 
         # once datasets written, can switch the model to single writer multiple reader
         self._handle_for_h5_file.swmr_mode = True
+        self.multiplier = multiplier
 
         outer_shape = (multiplier,) if multiplier > 1 else ()
-        full_file_description = get_full_file_description(datasets, outer_shape)
 
         # cache state to self
-        self._datasets = datasets
-        self.multiplier = multiplier
-        self._directory_provider = directory
-        return full_file_description
+        # Add the main data
+        self._datasets = [
+            _HDFDataset(
+                data_key=name,
+                dataset=DATA_PATH,
+                shape=(self.height, self.width),
+                multiplier=multiplier,
+            ),
+            _HDFDataset(
+                f"{name}-sum",
+                dataset=SUM_PATH,
+                shape=(),
+                multiplier=multiplier,
+            ),
+        ]
+
+        describe = {
+            ds.data_key: DataKey(
+                source="sim://pattern-generator-hdf-file",
+                shape=outer_shape + tuple(ds.shape),
+                dtype="array" if ds.shape else "number",
+                external="STREAM:",
+            )
+            for ds in self._datasets
+        }
+        return describe
 
-    def _get_new_path(self, directory: DirectoryProvider) -> Path:
-        info = directory()
-        filename = f"{info.prefix}pattern{info.suffix}.h5"
+    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
         return new_path
 
-    def _get_datasets(self) -> List[DatasetConfig]:
-        raw_dataset = DatasetConfig(
-            # name=data_name,
-            name=DATA_PATH,
-            dtype=np.uint8,
-            shape=(1, self.height, self.width),
-            maxshape=(None, self.height, self.width),
-        )
-
-        sum_dataset = DatasetConfig(
-            name=SUM_PATH,
-            dtype=np.float64,
-            shape=(1,),
-            maxshape=(None,),
-            fillvalue=-1,
-        )
-
-        datasets: List[DatasetConfig] = [raw_dataset, sum_dataset]
-        return datasets
-
     async def collect_stream_docs(
         self, indices_written: int
     ) -> AsyncIterator[StreamAsset]:
@@ -292,10 +183,8 @@ class PatternGenerator:
             # until the first frame comes in
             if not self._hdf_stream_provider:
                 assert self.target_path, "open file has not been called"
-                datasets = self._get_datasets()
-                self._datasets = datasets
-                self._hdf_stream_provider = HdfStreamProvider(
-                    self._directory_provider(),
+                self._hdf_stream_provider = _HDFFile(
+                    self._path_provider(),
                     self.target_path,
                     self._datasets,
                 )
@@ -314,5 +203,5 @@ class PatternGenerator:
     async def observe_indices_written(
         self, timeout=DEFAULT_TIMEOUT
     ) -> AsyncGenerator[int, None]:
-        async for num_captured in observe_value(self.mock_signal, timeout=timeout):
+        async for num_captured in observe_value(self.counter_signal, timeout=timeout):
             yield num_captured // self.multiplier

ophyd_async/sim/sim_pattern_detector_control.py

@@ -1,7 +1,7 @@
 import asyncio
 from typing import Optional
 
-from ophyd_async.core import DirectoryProvider
+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
@@ -11,12 +11,12 @@ class SimPatternDetectorControl(DetectorControl):
     def __init__(
         self,
         pattern_generator: PatternGenerator,
-        directory_provider: DirectoryProvider,
+        path_provider: PathProvider,
         exposure: float = 0.1,
     ) -> None:
         self.pattern_generator: PatternGenerator = pattern_generator
         self.pattern_generator.set_exposure(exposure)
-        self.directory_provider: DirectoryProvider = directory_provider
+        self.path_provider: PathProvider = path_provider
         self.task: Optional[asyncio.Task] = None
         super().__init__()
 

ophyd_async/sim/sim_pattern_detector_writer.py

@@ -2,7 +2,7 @@ from typing import AsyncGenerator, AsyncIterator, Dict
 
 from bluesky.protocols import DataKey
 
-from ophyd_async.core import DirectoryProvider
+from ophyd_async.core import NameProvider, PathProvider
 from ophyd_async.core.detector import DetectorWriter
 from ophyd_async.sim.pattern_generator import PatternGenerator
 
@@ -11,14 +11,18 @@ class SimPatternDetectorWriter(DetectorWriter):
     pattern_generator: PatternGenerator
 
     def __init__(
-        self, pattern_generator: PatternGenerator, directoryProvider: DirectoryProvider
+        self,
+        pattern_generator: PatternGenerator,
+        path_provider: PathProvider,
+        name_provider: NameProvider,
     ) -> None:
         self.pattern_generator = pattern_generator
-        self.directory_provider = directoryProvider
+        self.path_provider = path_provider
+        self.name_provider = name_provider
 
     async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
         return await self.pattern_generator.open_file(
-            self.directory_provider, multiplier
+            self.path_provider, self.name_provider(), multiplier
         )
 
     async def close(self) -> None:
@@ -31,4 +35,4 @@ class SimPatternDetectorWriter(DetectorWriter):
         return self.pattern_generator.observe_indices_written()
 
     async def get_indices_written(self) -> int:
-        return self.pattern_generator.written_images_counter
+        return self.pattern_generator.image_counter

ophyd_async/sim/sim_pattern_generator.py

@@ -1,7 +1,12 @@
 from pathlib import Path
 from typing import Sequence
 
-from ophyd_async.core import DirectoryProvider, StaticDirectoryProvider
+from ophyd_async.core import (
+    FilenameProvider,
+    PathProvider,
+    StaticFilenameProvider,
+    StaticPathProvider,
+)
 from ophyd_async.core.detector import StandardDetector
 from ophyd_async.protocols import AsyncReadable
 from ophyd_async.sim.pattern_generator import PatternGenerator
@@ -15,17 +20,19 @@ class SimPatternDetector(StandardDetector):
         self,
         path: Path,
         config_sigs: Sequence[AsyncReadable] = [],
-        name: str = "sim_pattern_detector",
+        name: str = "",
     ) -> None:
-        self.directory_provider: DirectoryProvider = StaticDirectoryProvider(path)
+        fp: FilenameProvider = StaticFilenameProvider(name)
+        self.path_provider: PathProvider = StaticPathProvider(fp, path)
         self.pattern_generator = PatternGenerator()
         writer = SimPatternDetectorWriter(
             pattern_generator=self.pattern_generator,
-            directoryProvider=self.directory_provider,
+            path_provider=self.path_provider,
+            name_provider=lambda: self.name,
         )
         controller = SimPatternDetectorControl(
             pattern_generator=self.pattern_generator,
-            directory_provider=self.directory_provider,
+            path_provider=self.path_provider,
         )
         super().__init__(
             controller=controller,

{ophyd_async-0.3.4a1.dist-info → ophyd_async-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3.4a1
+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: dev
@@ -79,10 +81,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.4a1.dist-info → ophyd_async-0.4.0.dist-info}/RECORD

@@ -1,86 +1,84 @@
 ophyd_async/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
 ophyd_async/__main__.py,sha256=G-Zcv_G9zK7Nhx6o5L5w-wyhMxdl_WgyMELu8IMFqAE,328
-ophyd_async/_version.py,sha256=GeD2BgjHboEmcr7_O2gtjDoE83JU6uGSFLE7dAp8RDQ,413
+ophyd_async/_version.py,sha256=j90u3VVU4UrJf1fgMUhaZarHK_Do2XGYXr-vZvOFzVo,411
 ophyd_async/log.py,sha256=DbMjt0bkfUOLHIinZYt0Q0FHZmCXXi5x8y0uFiEmqoQ,3587
 ophyd_async/protocols.py,sha256=EF2W9nfElV-0QNMYrX1zusL1PqDJR3kNsjlalR29j0I,3412
-ophyd_async/core/__init__.py,sha256=xqO9riU_uKqGAOi0ty0cbcI4Oawi_J3XTYLtwNSXGOE,3061
-ophyd_async/core/_providers.py,sha256=LrlTMPHKXWOPVkpAOw-pqBq0kip-c3C9ZZPoFfiaV4M,2212
+ophyd_async/core/__init__.py,sha256=smUUnG2xf5XJMTk_aGKAPg2ZEZTWhABd-p4qCExipqY,3366
+ophyd_async/core/_providers.py,sha256=-HlisysZZcqs6z1yQsWCpof7hQ9QTbg2IYpm4XaErGQ,7454
 ophyd_async/core/async_status.py,sha256=9TOgOXIAuH62RDo5t-Y5GdjrJ76d_6TFlBxYv-5_a88,4367
-ophyd_async/core/detector.py,sha256=NMX8y_yiViHbv3CaJ7LxzXYkH6tCWI3LocpQ3w4lGEQ,11176
-ophyd_async/core/device.py,sha256=280zFnLCoiMZAA-Dh1_AjUSnhxUfKYGgj4H_2S1njOA,7086
+ophyd_async/core/detector.py,sha256=x6zxmDjbh8d6meJc8L2NidxI3Uj5bFPWo_FSaRDDBoM,11271
+ophyd_async/core/device.py,sha256=mb-zxxmr5RftdBO8YPDJayP4ovNWEgW4qh2v1UU7ROg,7553
 ophyd_async/core/device_save_loader.py,sha256=EK7FB5oWiLI_s2KZ1BNDQ2AUKVbFLlimMl0vXfsjcgo,8223
 ophyd_async/core/flyer.py,sha256=bIjzBkrl8HVAlKgsZ_FF0WL69Qvksyzp9ZWmTLl8Yrw,2304
 ophyd_async/core/mock_signal_backend.py,sha256=Ug6jK72wm9vM6EueoUrYgcXtiFzdPUEISRe86LdyYKc,2844
 ophyd_async/core/mock_signal_utils.py,sha256=LE8VxNq3jfaTePnHHpZpKCi1vwKi8EIg-g1jfw-Q5bQ,4726
-ophyd_async/core/signal.py,sha256=hPpMcdq7zx6HOkyQCJrMD5F3uLBEJJTfwL6DsbcTELo,17601
+ophyd_async/core/signal.py,sha256=9zRoHLkSHoa451LmABtpzSvymo0GmC3jAQDQDp0kuMU,18531
 ophyd_async/core/signal_backend.py,sha256=U9J6jzHXRNIrdtGiZBVxXTRtzeejXiXEEIOGRIQhiS8,2678
-ophyd_async/core/soft_signal_backend.py,sha256=6ve1NWuEZFW4oFkAdSfTKFg06fv7rDLgr5IAEr_axeo,6262
+ophyd_async/core/soft_signal_backend.py,sha256=96Zk8ly8Qw6_l4RmB7NW95fbFCsRUTXH2H2JtH46_pY,6688
 ophyd_async/core/standard_readable.py,sha256=fhq_WAZtLYWrw6DvvrFRYRAPOUP2_IcX4qLucoEEeOg,9049
 ophyd_async/core/utils.py,sha256=3oZcXNqAUHX4ZWMBH5gSuK6cFWEhSkZ9GSDYv0pf8jc,5783
 ophyd_async/epics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ophyd_async/epics/_backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ophyd_async/epics/_backend/_aioca.py,sha256=YsKHGaHtYjBte5Tz-AftTENaeV6UGRnonX-1UmAQGqg,11319
-ophyd_async/epics/_backend/_p4p.py,sha256=oCT8MeVWlhmsxZ8YRSrelrY8W3NvfpXcMlfAKL_AUNY,14331
-ophyd_async/epics/_backend/common.py,sha256=ffdcKhtUc8Mmm0AsV0K7cUoOttF6avcN6Kdd4QHjrSw,1833
+ophyd_async/epics/_backend/_aioca.py,sha256=JwMX_8E1kw8GWlIRhXpJ2BExbZG7Ps2OOQWgdqwzo8c,11433
+ophyd_async/epics/_backend/_p4p.py,sha256=RN3skNzG9PKKvIUccqnccVvsfgm4lS1x4g02X5ds00c,15816
+ophyd_async/epics/_backend/common.py,sha256=gxI3c0T_Y-TVnAPabzPF0Y5Xo12xSvtpp5ytAfCxwWA,1863
 ophyd_async/epics/areadetector/__init__.py,sha256=ViKzx-wUxkRyNR33wfpL11QB97o0J47_KMyI2C_NphI,510
-ophyd_async/epics/areadetector/aravis.py,sha256=YklN4V0loqUQBs4swVX304N49JIGPvrNOk8iA5EWofg,2127
-ophyd_async/epics/areadetector/kinetix.py,sha256=7rE2MLnz9DEmeiN9pCekDfpXuZ2DErnMajRp_9eoLZY,1359
-ophyd_async/epics/areadetector/pilatus.py,sha256=hs3v8QUIwTHNg7i1mRSg9SbIIsoUZg90OxJ740gEKpo,2044
+ophyd_async/epics/areadetector/aravis.py,sha256=zRhC0tQTZvBUUcPqJV9EZFJhCL_4ib-O8VcSbPxf9wg,2107
+ophyd_async/epics/areadetector/kinetix.py,sha256=lO-vuE_joIklLL2f0isUZCwVyhFcb4HkXqeCa-gD4kQ,1339
+ophyd_async/epics/areadetector/pilatus.py,sha256=u-c_imklak1GQObqvQ-ziiS3_GEHP5csPlsVfaM_sDU,2024
 ophyd_async/epics/areadetector/single_trigger_det.py,sha256=U92dqhioIfnve3jtCThq9gXBCdEzzqzY4ezk6rZV19g,1182
 ophyd_async/epics/areadetector/utils.py,sha256=p66UbVdKRFj6Sm1Qvm23kmlVyBMMqIvXFxA3x17YnSk,2824
-ophyd_async/epics/areadetector/vimba.py,sha256=IxG8KLzfb84iLtzf6ZoX9JikqZLP49lwkWu33bkDV9Y,1291
+ophyd_async/epics/areadetector/vimba.py,sha256=9KkgXJjJJHc0QQ7E4FAt6n7d6-leUAnEgLVzrIoLE6c,1271
 ophyd_async/epics/areadetector/controllers/__init__.py,sha256=af58ci7X2z2s_FyUwR3IGQrws8q4TKcBw7vFyIS5FoI,217
 ophyd_async/epics/areadetector/controllers/ad_sim_controller.py,sha256=mthZ6WxajMEgUKptq3bnkIctbLhjzTagV66i1auB8cg,1587
-ophyd_async/epics/areadetector/controllers/aravis_controller.py,sha256=CIfnZdq_NobO_UMC2TJoAfUEP9GlzZg5z5bz6Dn1DxY,2669
+ophyd_async/epics/areadetector/controllers/aravis_controller.py,sha256=2C3pGdvzVDBlYsJv4USv-hZ-BpyQUxoZqJTKz0_zPLY,2707
 ophyd_async/epics/areadetector/controllers/kinetix_controller.py,sha256=9QmydX85QOXfQL_UX49M9EQ2b2hUZPVzLxgGQn-A9Oc,1611
 ophyd_async/epics/areadetector/controllers/pilatus_controller.py,sha256=6AiMz2yBA9xig-BrAIAc9CDxwM4Cjfebc4dd7QRutB0,2740
 ophyd_async/epics/areadetector/controllers/vimba_controller.py,sha256=Eh4Hr9rWgq1mKvE93JzgixntjPHxF3_07GTFqiOdZqE,2123
 ophyd_async/epics/areadetector/drivers/__init__.py,sha256=X-KdXw7YWNXpaUCXby2Spqvho2x2n72OavR-3mRlxzk,605
-ophyd_async/epics/areadetector/drivers/ad_base.py,sha256=OMySyCE9dcFRcVLC5Q0wUkri3QtRljIbn4KFdkumI4M,4553
+ophyd_async/epics/areadetector/drivers/ad_base.py,sha256=AB1exQsxL_207Uz88GapYqkWblODqTumaaW2CPLYLV4,4583
 ophyd_async/epics/areadetector/drivers/aravis_driver.py,sha256=K1if0Nv1ZNEvcOha6NVYA9t9VqsBNxKCmbajlysGF2Q,1491
 ophyd_async/epics/areadetector/drivers/kinetix_driver.py,sha256=yIV23BkGBJ4i0VskLiLL7AFbadCCR6Ch1UwUDJ9r2YM,743
 ophyd_async/epics/areadetector/drivers/pilatus_driver.py,sha256=0DBBuiR_FtwzVVdDW0ifdSrdKZtnprWuy87g66o8RlQ,619
 ophyd_async/epics/areadetector/drivers/vimba_driver.py,sha256=J54VtWkOklfbSqZYxGWH1e6Uzm9_Gph_ZbCf9Zax0LU,1713
-ophyd_async/epics/areadetector/writers/__init__.py,sha256=tpPcrYd1hs8WS7C0gmCnR2EBwjE5RzCljI7WwZ2V_LM,191
-ophyd_async/epics/areadetector/writers/_hdfdataset.py,sha256=E0C9VgsPyY35h7k0mvcIhjsIVNavApLxizqNWlM388w,167
-ophyd_async/epics/areadetector/writers/_hdffile.py,sha256=YtUgOKX53m0TaFEGBW671qXqNuuEKxEyLV5Ein1fjvo,1799
-ophyd_async/epics/areadetector/writers/hdf_writer.py,sha256=ZpbVilNVv81OpbCrqaeZUoHLarrjzRWEGe-zI1Wxyyw,5436
-ophyd_async/epics/areadetector/writers/nd_file_hdf.py,sha256=EkiaEh_0U6Iz17jFi2IIsRPsVQTQIJRG8EPNCiAHkkU,1762
-ophyd_async/epics/areadetector/writers/nd_plugin.py,sha256=GUzaeTMdG07Rb1x0WzBBxMEltBhr10jb5dL29tEWXEQ,1547
+ophyd_async/epics/areadetector/writers/__init__.py,sha256=bzUzlEYa3eIKWnT-uVXPiRDdxH1OAzCJCRLJJBF37QA,225
+ophyd_async/epics/areadetector/writers/general_hdffile.py,sha256=aFS_qXC99cUVWPPxgeqgxeF89IinJhtNVQIZ3C5K-C4,2608
+ophyd_async/epics/areadetector/writers/hdf_writer.py,sha256=GzvaXSzRSLjGktGh4ihfkB1Vpv69g8PCMN0h1RqSv08,5940
+ophyd_async/epics/areadetector/writers/nd_file_hdf.py,sha256=fMj_rGV5PX4VlayGzWvyEkFIPM2Mj9w5MEADA3yxSrw,1983
+ophyd_async/epics/areadetector/writers/nd_plugin.py,sha256=OR2-UFypfBW-lLTrVD1_FFbWK-tl863cOxCrH06x7FA,2393
 ophyd_async/epics/demo/__init__.py,sha256=ZcuZ66aIQ58WSydLOSKnk-h_W-aWjhDRZkWQA6f3sig,5790
-ophyd_async/epics/demo/demo_ad_sim_detector.py,sha256=06y65yvaqXvL2rDocjYyLz9kTVzuwV-LeuPhEfExdOA,944
+ophyd_async/epics/demo/demo_ad_sim_detector.py,sha256=x7aD2shaHBvYHP_PTSutXi9Yep8lvOMqeNHxMT7ZGY0,924
 ophyd_async/epics/demo/mover.db,sha256=RFz0rxZue689Wh1sWTZwWeFMUrH04ttPq2u5xJH_Fp4,998
 ophyd_async/epics/demo/sensor.db,sha256=AVtiydrdtwAz2EFurO2Ult9SSRtre3r0akOBbL98LT0,554
 ophyd_async/epics/motion/__init__.py,sha256=tnmVRIwKa9PdN_xonJdAUD04UpEceh-hoD7XI62yDB0,46
-ophyd_async/epics/motion/motor.py,sha256=tqLV4TaW2MIapZsmx4wxnGOdKfkhxKLUPbTHA4YLdYE,3514
+ophyd_async/epics/motion/motor.py,sha256=GrlIgyCK45nfVFw7gRccdt4qy8jXWdcbBzcp6MD3OY4,8466
 ophyd_async/epics/pvi/__init__.py,sha256=TbOQNY4enQWgtr1T7x129vpo2p7FIFlr8cyZqqv5Lk4,158
 ophyd_async/epics/pvi/pvi.py,sha256=Kc3klnA9F82h_p2atFYXe-wFO9OzN5TV69Tc56tD2do,12204
 ophyd_async/epics/signal/__init__.py,sha256=JXKBSGpRL9y3auh27JRxsqDn_rBOXpJjtd4nCuDOX2g,261
 ophyd_async/epics/signal/_epics_transport.py,sha256=DEIL0iYUAWssysVEgWGu1fHSM1l-ATV2kjUgPtDN9LY,858
 ophyd_async/epics/signal/signal.py,sha256=M8ZVG_zLdYJfroCRX-u_w8c3yIhswSRw8e3RkW2szio,3166
-ophyd_async/panda/__init__.py,sha256=FuSnvp-RtdA0X4RcHEF0nTiXymRts2MNdFmF_1_i41w,775
-ophyd_async/panda/_common_blocks.py,sha256=OrA_mSJslxuhjIAD8Liye1-1yTl3DihqFDBXvJGlPFs,1088
-ophyd_async/panda/_hdf_panda.py,sha256=LWWQErG_cxM7zWqKG8c40O55ZpfTu3F70d4jVvRaeMo,1308
+ophyd_async/panda/__init__.py,sha256=RjEow4N-rgEPEZdlsDZElUv-VsLGRX3Awoo4Zij_mIQ,1058
+ophyd_async/panda/_common_blocks.py,sha256=fl8rGfAAslgN7kIzQhbqQkRXVlWvKT6nqiYEE_30Ono,1601
+ophyd_async/panda/_hdf_panda.py,sha256=TU0xa3wLd5zaf_GRBwDFjYirpHAyIRRZ-V8JxHyaLuY,1350
 ophyd_async/panda/_panda_controller.py,sha256=dIqcjmaIHVrki8UXSoDx46kk6I2Lhpe2o3sXNg5f-RQ,1238
-ophyd_async/panda/_table.py,sha256=keCGT66y91feO_MD3a6aMsgx27JuLYWLrAkl0lRXUKY,5854
-ophyd_async/panda/_trigger.py,sha256=tBH8uq_4o1ASG9yofVxq3tjf5v8LPzniDTRL4yjramI,1195
+ophyd_async/panda/_table.py,sha256=atd9wiam0XQH89doqzn0U6J42CFQBKDs9K1_q5GcJR8,6093
+ophyd_async/panda/_trigger.py,sha256=6G30e--M9OGV4TFpGmYOSru6sx5q4KpOJrV6aOsvVN4,3069
 ophyd_async/panda/_utils.py,sha256=VHW5kPVISyEkmse_qQcyisBkkEwMO6GG2Ago-CH1AFA,487
 ophyd_async/panda/writers/__init__.py,sha256=xy7BguVQG4HNIDBfKPjMj0KQo1tptC9LbCpEuMcVGaM,70
-ophyd_async/panda/writers/_hdf_writer.py,sha256=SP71y2-LTKhlNIFxLIddmtjmrg6MDwGvuwQ7X-5OP98,4698
-ophyd_async/panda/writers/_panda_hdf_file.py,sha256=WnGvNWuLe4KljhlmBLM4Y0HKSJCIBNWOwXxioPkGu6Y,1673
+ophyd_async/panda/writers/_hdf_writer.py,sha256=D1cdERT_12nTN19p6sDYD7WqYYOGAmEhJsKArNFH46g,5138
 ophyd_async/plan_stubs/__init__.py,sha256=nO9ELG9J7fYwfVTVRWVorz4kffeszYpwk1ROh6Ha--w,405
-ophyd_async/plan_stubs/ensure_connected.py,sha256=1MkDu8UqVRPHLnW9IXRn-QvKiG8-rCV8T4KDbjf9K6w,557
-ophyd_async/plan_stubs/fly.py,sha256=fQwBeLw57-NeBsroVxKDa8kpuu6fgTWYWimbsatCL28,4999
+ophyd_async/plan_stubs/ensure_connected.py,sha256=iTisEupUXrCTFikoPw9cf-BuwO_tvOmFmbkOUlPkF-E,752
+ophyd_async/plan_stubs/fly.py,sha256=64bJqfvxrQHBUoJeMFY8qLlkvE_8Gw8YTu3Hek_NiLA,6421
 ophyd_async/sim/__init__.py,sha256=ScjH1g7FMo5yPACfJRZE6xGBWCHU4bKDzNQk1tqObnA,366
-ophyd_async/sim/pattern_generator.py,sha256=pvSk2zb82D08j2jiKAMqMAfRohGnYd_rpjUraLrCD6c,10640
-ophyd_async/sim/sim_pattern_detector_control.py,sha256=Ypz8IuRYAY2J243IhVbNyGr_Z-XtpJZ1qxma6NR3TgM,1838
-ophyd_async/sim/sim_pattern_detector_writer.py,sha256=ESpcVyHd1TP7Cojznv2hJAwLinu3XbgAiVKfX12FCII,1237
-ophyd_async/sim/sim_pattern_generator.py,sha256=L4jTnEVUFBRXIWq_UMHqx00YDdbGO2pjo_IuuVwpzXE,1258
+ophyd_async/sim/pattern_generator.py,sha256=5MOkU6JqizxQPZ4Z6kQswHsqZv-vPhsEeo8lUSvSv4Q,7369
+ophyd_async/sim/sim_pattern_detector_control.py,sha256=azkKfPYIAfH8CoCBpkBfqlmOUTTN8GOoCEemRsL0emQ,1808
+ophyd_async/sim/sim_pattern_detector_writer.py,sha256=yH__i1rSHAcFc3mXJPXNQElMCyyCHxpsOdTkEad33sM,1333
+ophyd_async/sim/sim_pattern_generator.py,sha256=pQbXJ5mJQHypg4MTD2FNRs85OJRV9JksYmjl0r9NSSQ,1366
 ophyd_async/sim/demo/__init__.py,sha256=9mxKpslrL89cfSj4g3og8Br3O--pMj3hhWZS-Xu6kyA,56
 ophyd_async/sim/demo/sim_motor.py,sha256=a2p5wnHXjF-V5zOFai7jnszk4kbGmrZRnUqBtkOgEfQ,3733
-ophyd_async-0.3.4a1.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
-ophyd_async-0.3.4a1.dist-info/METADATA,sha256=JNwQkJEsOunynK3sUNPtQMHoTBBf8M7kfrl7HDTJYHM,6294
-ophyd_async-0.3.4a1.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
-ophyd_async-0.3.4a1.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
-ophyd_async-0.3.4a1.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
-ophyd_async-0.3.4a1.dist-info/RECORD,,
+ophyd_async-0.4.0.dist-info/LICENSE,sha256=pU5shZcsvWgz701EbT7yjFZ8rMvZcWgRH54CRt8ld_c,1517
+ophyd_async-0.4.0.dist-info/METADATA,sha256=iXknBXp3IJkO7yB9_P4CRNKksn_h0m_dUKCmnFbJcLE,6491
+ophyd_async-0.4.0.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
+ophyd_async-0.4.0.dist-info/entry_points.txt,sha256=O0YNJTEufO0w9BozXi-JurTy2U1_o0ypeCgJLQ727Jk,58
+ophyd_async-0.4.0.dist-info/top_level.txt,sha256=-hjorMsv5Rmjo3qrgqhjpal1N6kW5vMxZO3lD4iEaXs,12
+ophyd_async-0.4.0.dist-info/RECORD,,

{ophyd_async-0.3.4a1.dist-info → ophyd_async-0.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.1)
+Generator: setuptools (70.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ophyd_async/epics/areadetector/writers/_hdfdataset.py

@@ -1,10 +0,0 @@
-from dataclasses import dataclass
-from typing import Sequence
-
-
-@dataclass
-class _HDFDataset:
-    name: str
-    path: str
-    shape: Sequence[int]
-    multiplier: int