ophyd-async 0.10.0a1__tar.gz → 0.10.0a3__tar.gz

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.10.0a1
+Version: 0.10.0a3
 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

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a3}/src/ophyd_async/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.10.0a1'
-__version_tuple__ = version_tuple = (0, 10, 0)
+__version__ = version = '0.10.0a3'
+__version_tuple__ = version_tuple = (0, 10, 0, 'a3')

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a3}/src/ophyd_async/core/__init__.py

@@ -26,7 +26,6 @@ from ._providers import (
     AutoIncrementingPathProvider,
     DatasetDescriber,
     FilenameProvider,
-    NameProvider,
     PathInfo,
     PathProvider,
     StaticFilenameProvider,
@@ -160,7 +159,6 @@ __all__ = [
     "AutoIncrementFilenameProvider",
     "UUIDFilenameProvider",
     # Datatset
-    "NameProvider",
     "DatasetDescriber",
     "HDFDatasetDescription",
     "HDFDocumentComposer",

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a3}/src/ophyd_async/core/_derived_signal.py

@@ -1,5 +1,5 @@
 from collections.abc import Awaitable, Callable
-from typing import Any, Generic, get_type_hints
+from typing import Any, Generic, get_type_hints, is_typeddict
 
 from ._derived_signal_backend import (
     DerivedSignalBackend,
@@ -46,13 +46,13 @@ class DerivedSignalFactory(Generic[TransformT]):
                     f"got {list(raw_and_transform_devices)}"
                 )
                 raise TypeError(msg)
-        set_derived_datatype = (
-            _get_first_arg_datatype(set_derived) if set_derived else None
+        self._set_derived_takes_dict = (
+            is_typeddict(_get_first_arg_datatype(set_derived)) if set_derived else False
         )
         self._transformer = SignalTransformer(
             transform_cls,
             set_derived,
-            set_derived_datatype,
+            self._set_derived_takes_dict,
             **raw_and_transform_devices,
         )
 
@@ -75,7 +75,7 @@ class DerivedSignalFactory(Generic[TransformT]):
                 f"{signal_cls.__name__}s"
             )
             raise ValueError(msg)
-        if issubclass(signal_cls, SignalRW):
+        if issubclass(signal_cls, SignalRW) and self._set_derived_takes_dict:
             self._transformer.raw_locatables  # noqa: B018
         backend = DerivedSignalBackend(
             datatype, name, self._transformer, units, precision
@@ -173,7 +173,7 @@ def _make_factory(
 
         # Update the signature for raw_to_derived to match what we are passed as this
         # will be checked in DerivedSignalFactory
-        DerivedTransform.raw_to_derived.__annotations__ = raw_to_derived.__annotations__
+        DerivedTransform.raw_to_derived.__annotations__ = get_type_hints(raw_to_derived)
 
         return DerivedSignalFactory(
             DerivedTransform, set_derived=set_derived, **(raw_devices or {})

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a3}/src/ophyd_async/core/_derived_signal_backend.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 from collections.abc import Awaitable, Callable, Mapping
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, Generic, TypeVar, is_typeddict
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
 
 from bluesky.protocols import Location, Reading, Subscribable
 from event_model import DataKey
@@ -76,12 +76,12 @@ class SignalTransformer(Generic[TransformT]):
         self,
         transform_cls: type[TransformT],
         set_derived: Callable[..., Awaitable[None]] | None,
-        set_derived_datatype: type | None,
+        set_derived_takes_dict: bool,
         **raw_and_transform_devices,
     ):
         self._transform_cls = transform_cls
         self._set_derived = set_derived
-        self._need_dict = is_typeddict(set_derived_datatype)
+        self._set_derived_takes_dict = set_derived_takes_dict
         self._transform_devices = {
             k: raw_and_transform_devices.pop(k) for k in transform_cls.model_fields
         }
@@ -229,7 +229,7 @@ class SignalTransformer(Generic[TransformT]):
         if self._set_derived is None:
             msg = "Cannot put as no set_derived method given"
             raise RuntimeError(msg)
-        if self._need_dict:
+        if self._set_derived_takes_dict:
             # Need to get the other derived values and update the one that's changing
             derived = await self.get_locations()
             setpoints = {k: v["setpoint"] for k, v in derived.items()}

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a3}/src/ophyd_async/core/_detector.py

@@ -23,7 +23,7 @@ from bluesky.protocols import (
     WritesStreamAssets,
 )
 from event_model import DataKey
-from pydantic import BaseModel, Field, NonNegativeInt, computed_field
+from pydantic import BaseModel, Field, NonNegativeInt, PositiveInt, computed_field
 
 from ._device import Device, DeviceConnector
 from ._protocol import AsyncConfigurable, AsyncReadable
@@ -51,49 +51,52 @@ class DetectorTrigger(Enum):
 class TriggerInfo(BaseModel):
     """Minimal set of information required to setup triggering on a detector."""
 
-    number_of_triggers: NonNegativeInt | list[NonNegativeInt] = Field(default=1)
-    """Number of triggers that will be sent, (0 means infinite).
+    number_of_events: NonNegativeInt | list[NonNegativeInt] = Field(default=1)
+    """Number of events that will be processed, (0 means infinite).
 
     Can be:
     - A single integer or
-    - A list of integers for multiple triggers
+    - A list of integers for multiple events
 
-    Example for tomography: ``TriggerInfo(number=[2,3,100,3])``.
-    This would trigger:
+    Example for tomography: ``TriggerInfo(number_of_events=[2,3,100,3])``.
+    This would process:
 
-    - 2 times for dark field images
-    - 3 times for initial flat field images
-    - 100 times for projections
-    - 3 times for final flat field images
+    - 2 events for dark field images
+    - 3 events for initial flat field images
+    - 100 events for projections
+    - 3 events for final flat field images
     """
 
     trigger: DetectorTrigger = Field(default=DetectorTrigger.INTERNAL)
     """Sort of triggers that will be sent"""
 
     deadtime: float = Field(default=0.0, ge=0)
-    """What is the minimum deadtime between triggers"""
+    """What is the minimum deadtime between exposures"""
 
     livetime: float | None = Field(default=None, ge=0)
-    """What is the maximum high time of the triggers"""
-
-    frame_timeout: float | None = Field(default=None, gt=0)
-    """What is the maximum timeout on waiting for a frame"""
-
-    multiplier: int = 1
-    """How many triggers make up a single StreamDatum index, to allow multiple frames
-    from a faster detector to be zipped with a single frame from a slow detector
-    e.g. if num=10 and multiplier=5 then the detector will take 10 frames,
-    but publish 2 indices, and describe() will show a shape of (5, h, w)
+    """What is the maximum high time of the exposures"""
+
+    exposure_timeout: float | None = Field(default=None, gt=0)
+    """What is the maximum timeout on waiting for an exposure"""
+
+    exposures_per_event: PositiveInt = 1
+    """The number of exposures that are grouped into a single StreamDatum index.
+    A exposures_per_event > 1 can be useful to have exposures from a faster detector
+    able to be zipped with a single exposure from a slower detector. E.g. if
+    number_of_events=10 and exposures_per_event=5 then the detector will take
+    10 exposures, but publish 2 StreamDatum indices, and describe() will show a
+    shape of (5, h, w) for each.
+    Default is 1.
     """
 
     @computed_field
     @cached_property
-    def total_number_of_triggers(self) -> int:
+    def total_number_of_exposures(self) -> int:
         return (
-            sum(self.number_of_triggers)
-            if isinstance(self.number_of_triggers, list)
-            else self.number_of_triggers
-        )
+            sum(self.number_of_events)
+            if isinstance(self.number_of_events, list)
+            else self.number_of_events
+        ) * self.exposures_per_event
 
 
 class DetectorController(ABC):
@@ -127,16 +130,17 @@ class DetectorWriter(ABC):
     """Logic for making detector write data to somewhere persistent (e.g. HDF5 file)."""
 
     @abstractmethod
-    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
+    async def open(
+        self, name: str, exposures_per_event: PositiveInt = 1
+    ) -> dict[str, DataKey]:
         """Open writer and wait for it to be ready for data.
 
-        :param multiplier:
+        :param exposures_per_event:
             Each StreamDatum index corresponds to this many written exposures
         :return: Output for ``describe()``
         """
 
-    @property
-    def hints(self) -> Hints:
+    def get_hints(self, name: str) -> Hints:
         """The hints to be used for the detector."""
         return {}
 
@@ -153,7 +157,9 @@ class DetectorWriter(ABC):
         """Yield the index of each frame (or equivalent data point) as it is written."""
 
     @abstractmethod
-    def collect_stream_docs(self, indices_written: int) -> AsyncIterator[StreamAsset]:
+    def collect_stream_docs(
+        self, name: str, indices_written: int
+    ) -> AsyncIterator[StreamAsset]:
         """Create Stream docs up to given number written."""
 
     @abstractmethod
@@ -215,11 +221,11 @@ class StandardDetector(
         self._watchers: list[Callable] = []
         self._fly_status: WatchableAsyncStatus | None = None
         self._fly_start: float | None = None
-        self._frames_to_complete: int = 0
-        # Represents the total number of frames that will have been completed at the
+        self._events_to_complete: int = 0
+        # Represents the total number of exposures that will have been completed at the
         # end of the next `complete`.
-        self._completable_frames: int = 0
-        self._number_of_triggers_iter: Iterator[int] | None = None
+        self._completable_exposures: int = 0
+        self._number_of_events_iter: Iterator[int] | None = None
         self._initial_frame: int = 0
         super().__init__(name, connector=connector)
 
@@ -269,15 +275,19 @@ class StandardDetector(
         if self._trigger_info is None:
             await self.prepare(
                 TriggerInfo(
-                    number_of_triggers=1,
+                    number_of_events=1,
                     trigger=DetectorTrigger.INTERNAL,
                 )
             )
-
         trigger_info = _ensure_trigger_info_exists(self._trigger_info)
         if trigger_info.trigger is not DetectorTrigger.INTERNAL:
             msg = "The trigger method can only be called with INTERNAL triggering"
             raise ValueError(msg)
+        if trigger_info.number_of_events != 1:
+            raise ValueError(
+                "Triggering is not supported for multiple events, the detector was "
+                f"prepared with number_of_events={trigger_info.number_of_events}."
+            )
 
         # Arm the detector and wait for it to finish.
         indices_written = await self._writer.get_indices_written()
@@ -312,13 +322,15 @@ class StandardDetector(
             raise ValueError(msg)
         elif not value.deadtime:
             value.deadtime = self._controller.get_deadtime(value.livetime)
-        self._number_of_triggers_iter = iter(
-            value.number_of_triggers
-            if isinstance(value.number_of_triggers, list)
-            else [value.number_of_triggers]
+        self._trigger_info = value
+        self._number_of_events_iter = iter(
+            value.number_of_events
+            if isinstance(value.number_of_events, list)
+            else [value.number_of_events]
         )
         self._describe, _ = await asyncio.gather(
-            self._writer.open(value.multiplier), self._controller.prepare(value)
+            self._writer.open(self.name, value.exposures_per_event),
+            self._controller.prepare(value),
         )
         self._initial_frame = await self._writer.get_indices_written()
         if value.trigger != DetectorTrigger.INTERNAL:
@@ -327,25 +339,27 @@ class StandardDetector(
 
     @AsyncStatus.wrap
     async def kickoff(self):
-        if self._trigger_info is None or self._number_of_triggers_iter is None:
+        if self._trigger_info is None or self._number_of_events_iter is None:
             raise RuntimeError("Prepare must be called before kickoff!")
         if self._trigger_info.trigger == DetectorTrigger.INTERNAL:
             await self._controller.arm()
         self._fly_start = time.monotonic()
         try:
-            self._frames_to_complete = next(self._number_of_triggers_iter)
-            self._completable_frames += self._frames_to_complete
+            self._events_to_complete = next(self._number_of_events_iter)
+            self._completable_exposures += (
+                self._events_to_complete * self._trigger_info.exposures_per_event
+            )
         except StopIteration as err:
             raise RuntimeError(
                 f"Kickoff called more than the configured number of "
-                f"{self._trigger_info.total_number_of_triggers} iteration(s)!"
+                f"{self._trigger_info.total_number_of_exposures} iteration(s)!"
             ) from err
 
     @WatchableAsyncStatus.wrap
     async def complete(self):
         trigger_info = _ensure_trigger_info_exists(self._trigger_info)
         indices_written = self._writer.observe_indices_written(
-            trigger_info.frame_timeout
+            trigger_info.exposure_timeout
             or (
                 DEFAULT_TIMEOUT
                 + (trigger_info.livetime or 0)
@@ -358,21 +372,21 @@ class StandardDetector(
                     name=self.name,
                     current=index,
                     initial=self._initial_frame,
-                    target=self._frames_to_complete,
+                    target=self._events_to_complete,
                     unit="",
                     precision=0,
                     time_elapsed=time.monotonic() - self._fly_start
                     if self._fly_start
                     else None,
                 )
-                if index >= self._frames_to_complete:
+                if index >= self._events_to_complete:
                     break
         finally:
             await indices_written.aclose()
-            if self._completable_frames >= trigger_info.total_number_of_triggers:
-                self._completable_frames = 0
-                self._frames_to_complete = 0
-                self._number_of_triggers_iter = None
+            if self._completable_exposures >= trigger_info.total_number_of_exposures:
+                self._completable_exposures = 0
+                self._events_to_complete = 0
+                self._number_of_events_iter = None
                 await self._controller.wait_for_idle()
 
     async def describe_collect(self) -> dict[str, DataKey]:
@@ -386,7 +400,7 @@ class StandardDetector(
         # retrieved for step scans.
         if index is None:
             index = await self._writer.get_indices_written()
-        async for doc in self._writer.collect_stream_docs(index):
+        async for doc in self._writer.collect_stream_docs(self.name, index):
             yield doc
 
     async def get_index(self) -> int:
@@ -394,4 +408,4 @@ class StandardDetector(
 
     @property
     def hints(self) -> Hints:
-        return self._writer.hints
+        return self._writer.get_hints(self.name)

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a3}/src/ophyd_async/core/_device.py

@@ -346,10 +346,10 @@ class DeviceProcessor:
 
 
 def init_devices(
-    set_name=True,
+    set_name: bool = True,
     child_name_separator: str = "-",
-    connect=True,
-    mock=False,
+    connect: bool = True,
+    mock: bool = False,
     timeout: float = 10.0,
 ):
     """Auto initialize top level Device instances: to be used as a context manager.

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a3}/src/ophyd_async/core/_hdf_dataset.py

@@ -2,7 +2,7 @@ from collections.abc import Iterator
 from pathlib import Path
 from urllib.parse import urlunparse
 
-from event_model import (
+from event_model import (  # type: ignore
     ComposeStreamResource,
     ComposeStreamResourceBundle,
     StreamDatum,
@@ -34,9 +34,6 @@ class HDFDatasetDescription(BaseModel):
     chunk_shape: tuple[int, ...]
     """The explicit chunk size written to disk"""
 
-    multiplier: int = 1
-    """Won't be used soon."""
-
 
 SLICE_NAME = "AD_HDF5_SWMR_SLICE"
 
@@ -74,7 +71,6 @@ class HDFDocumentComposer:
                 data_key=ds.data_key,
                 parameters={
                     "dataset": ds.dataset,
-                    "multiplier": ds.multiplier,
                     "chunk_shape": ds.chunk_shape,
                 },
                 uid=None,

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a3}/src/ophyd_async/core/_providers.py

@@ -220,14 +220,6 @@ class YMDPathProvider(PathProvider):
         )
 
 
-class NameProvider(Protocol):
-    """Base class for callable classes providing data keys."""
-
-    @abstractmethod
-    def __call__(self) -> str:
-        """Get the name to be used as a data_key in the descriptor document."""
-
-
 class DatasetDescriber(Protocol):
     """For describing datasets in file writing."""
 

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a3}/src/ophyd_async/core/_readable.py

@@ -179,8 +179,20 @@ class StandardReadable(
 
         yield
 
-        # Set symmetric difference operator gives all newly added keys
+        # Set symmetric difference operator gives all newly added keys.
         new_dict = dict(self.children())
+        for key, value in new_dict.items():
+            # Check if key already exists in dict_copy and if the value has changed.
+            if key in dict_copy and value != dict_copy[key]:
+                error_msg = (
+                    f"Duplicate readable device found: '{key}' in {value.parent}. "
+                    "Derived class must not redefine a readable. "
+                    "See: https://github.com/bluesky/ophyd-async/issues/848. "
+                    "If this functionality is required, please raise an issue: "
+                    "https://github.com/bluesky/ophyd-async"
+                )
+                raise KeyError(error_msg)
+
         new_keys = dict_copy.keys() ^ new_dict.keys()
         new_values = [new_dict[key] for key in new_keys]
 

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a3}/src/ophyd_async/core/_table.py

@@ -93,18 +93,19 @@ class Table(BaseModel):
 
     def __add__(self, right: TableSubclass) -> TableSubclass:
         """Concatenate the arrays in field values."""
-        if type(right) is not type(self):
+        cls = type(right)
+        if type(self) is not cls:
             raise RuntimeError(
                 f"{right} is not a `Table`, or is not the same "
                 f"type of `Table` as {self}."
             )
 
-        return type(right)(
+        return cls(
             **{
                 field_name: _concat(
                     getattr(self, field_name), getattr(right, field_name)
                 )
-                for field_name in self.model_fields
+                for field_name in cls.model_fields
             }
         )
 

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a3}/src/ophyd_async/epics/adandor/_andor_controller.py

@@ -32,7 +32,7 @@ class Andor2Controller(adcore.ADBaseController[Andor2DriverIO]):
         await asyncio.gather(
             self.driver.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
             self.driver.num_images.set(
-                trigger_info.total_number_of_triggers or _MAX_NUM_IMAGE
+                trigger_info.total_number_of_exposures or _MAX_NUM_IMAGE
             ),
             self.driver.image_mode.set(adcore.ADImageMode.MULTIPLE),
         )

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a3}/src/ophyd_async/epics/adaravis/_aravis_controller.py

@@ -35,11 +35,11 @@ class AravisController(adcore.ADBaseController[AravisDriverIO]):
         else:
             raise ValueError(f"ADAravis does not support {trigger_info.trigger}")
 
-        if trigger_info.total_number_of_triggers == 0:
+        if trigger_info.total_number_of_exposures == 0:
             image_mode = adcore.ADImageMode.CONTINUOUS
         else:
             image_mode = adcore.ADImageMode.MULTIPLE
         await asyncio.gather(
-            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.num_images.set(trigger_info.total_number_of_exposures),
             self.driver.image_mode.set(image_mode),
         )

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a3}/src/ophyd_async/epics/adcore/_core_logic.py

@@ -33,7 +33,7 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
         driver: ADBaseIOT,
         good_states: frozenset[ADState] = DEFAULT_GOOD_STATES,
     ) -> None:
-        self.driver = driver
+        self.driver: ADBaseIOT = driver
         self.good_states = good_states
         self.frame_timeout = DEFAULT_TIMEOUT
         self._arm_status: AsyncStatus | None = None
@@ -49,7 +49,7 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
             DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
         )
         await asyncio.gather(
-            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.num_images.set(trigger_info.total_number_of_exposures),
             self.driver.image_mode.set(ADImageMode.MULTIPLE),
         )
 
@@ -176,7 +176,7 @@ class ADBaseContAcqController(ADBaseController[ADBaseIO]):
         await asyncio.gather(
             self.cb_plugin.enable_callbacks.set(ADCallbacks.ENABLE),
             self.cb_plugin.pre_count.set(0),
-            self.cb_plugin.post_count.set(trigger_info.total_number_of_triggers),
+            self.cb_plugin.post_count.set(trigger_info.total_number_of_exposures),
             self.cb_plugin.preset_trigger_count.set(1),
             self.cb_plugin.flush_on_soft_trg.set(NDCBFlushOnSoftTrgMode.ON_NEW_IMAGE),
         )

{ophyd_async-0.10.0a1 → ophyd_async-0.10.0a3}/src/ophyd_async/epics/adcore/_core_writer.py

@@ -5,14 +5,15 @@ from typing import Generic, TypeVar, get_args
 from urllib.parse import urlunparse
 
 from bluesky.protocols import Hints, StreamAsset
-from event_model import (
+from event_model import (  # type: ignore
     ComposeStreamResource,
     DataKey,
     StreamRange,
 )
+from pydantic import PositiveInt
 
 from ophyd_async.core._detector import DetectorWriter
-from ophyd_async.core._providers import DatasetDescriber, NameProvider, PathProvider
+from ophyd_async.core._providers import DatasetDescriber, PathProvider
 from ophyd_async.core._signal import (
     observe_value,
     set_and_wait_for_value,
@@ -44,7 +45,6 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         self,
         fileio: NDFileIOT,
         path_provider: PathProvider,
-        name_provider: NameProvider,
         dataset_describer: DatasetDescriber,
         file_extension: str = "",
         mimetype: str = "",
@@ -53,7 +53,6 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         self._plugins = plugins or {}
         self.fileio = fileio
         self._path_provider = path_provider
-        self._name_provider = name_provider
         self._dataset_describer = dataset_describer
         self._file_extension = file_extension
         self._mimetype = mimetype
@@ -61,7 +60,6 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         self._emitted_resource = None
 
         self._capture_status: AsyncStatus | None = None
-        self._multiplier = 1
         self._filename_template = "%s%s_%6.6d"
 
     @classmethod
@@ -81,18 +79,11 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
         fileio = fileio_cls(prefix + (fileio_suffix or cls.default_suffix))
         dataset_describer = ADBaseDatasetDescriber(dataset_source or fileio)
 
-        def name_provider() -> str:
-            if fileio.parent == "Not attached to a detector":
-                raise RuntimeError("Initializing writer without parent detector!")
-            return fileio.parent.name
-
-        writer = cls(
-            fileio, path_provider, name_provider, dataset_describer, plugins=plugins
-        )
+        writer = cls(fileio, path_provider, dataset_describer, plugins=plugins)
         return writer
 
-    async def begin_capture(self) -> None:
-        info = self._path_provider(device_name=self._name_provider())
+    async def begin_capture(self, name: str) -> None:
+        info = self._path_provider(device_name=name)
 
         await self.fileio.enable_callbacks.set(ADCallbacks.ENABLE)
 
@@ -125,19 +116,21 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
             self.fileio.capture, True, wait_for_set_completion=False
         )
 
-    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
+    async def open(
+        self, name: str, exposures_per_event: PositiveInt = 1
+    ) -> dict[str, DataKey]:
         self._emitted_resource = None
         self._last_emitted = 0
-        self._multiplier = multiplier
+        self._exposures_per_event = exposures_per_event
         frame_shape = await self._dataset_describer.shape()
         dtype_numpy = await self._dataset_describer.np_datatype()
 
-        await self.begin_capture()
+        await self.begin_capture(name)
 
         describe = {
-            self._name_provider(): DataKey(
+            name: DataKey(
                 source=self.fileio.full_file_name.source,
-                shape=list(frame_shape),
+                shape=[exposures_per_event, *frame_shape],
                 dtype="array",
                 dtype_numpy=dtype_numpy,
                 external="STREAM:",
@@ -150,14 +143,14 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
     ) -> AsyncGenerator[int, None]:
         """Wait until a specific index is ready to be collected."""
         async for num_captured in observe_value(self.fileio.num_captured, timeout):
-            yield num_captured // self._multiplier
+            yield num_captured // self._exposures_per_event
 
     async def get_indices_written(self) -> int:
         num_captured = await self.fileio.num_captured.get_value()
-        return num_captured // self._multiplier
+        return num_captured // self._exposures_per_event
 
     async def collect_stream_docs(
-        self, indices_written: int
+        self, name: str, indices_written: int
     ) -> AsyncIterator[StreamAsset]:
         if indices_written:
             if not self._emitted_resource:
@@ -183,13 +176,14 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
                 self._emitted_resource = bundler_composer(
                     mimetype=self._mimetype,
                     uri=uri,
-                    data_key=self._name_provider(),
+                    # TODO no reference to detector's name
+                    data_key=name,
                     parameters={
-                        # Assume that we always write 1 frame per file/chunk
+                        # Assume that we always write 1 frame per file/chunk, this
+                        # may change to self._exposures_per_event in the future
                         "chunk_shape": (1, *frame_shape),
                         # Include file template for reconstruction in consolidator
                         "template": file_template,
-                        "multiplier": self._multiplier,
                     },
                     uid=None,
                     validate=True,
@@ -218,6 +212,5 @@ class ADWriter(DetectorWriter, Generic[NDFileIOT]):
             await self._capture_status
         self._capture_status = None
 
-    @property
-    def hints(self) -> Hints:
-        return {"fields": [self._name_provider()]}
+    def get_hints(self, name: str) -> Hints:
+        return {"fields": [name]}