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

ophyd_async/fastcs/panda/_table.py

@@ -1,11 +1,14 @@
-from dataclasses import dataclass
+from collections.abc import Sequence
 from enum import Enum
-from typing import Optional, Sequence, Type, TypeVar
+from typing import Annotated
 
 import numpy as np
 import numpy.typing as npt
-import pydantic_numpy.typing as pnd
-from typing_extensions import NotRequired, TypedDict
+from pydantic import Field, field_validator, model_validator
+from pydantic_numpy.helper.annotation import NpArrayPydanticAnnotation
+from typing_extensions import TypedDict
+
+from ophyd_async.core import Table
 
 
 class PandaHdf5DatasetType(str, Enum):
@@ -34,137 +37,107 @@ class SeqTrigger(str, Enum):
     POSC_LT = "POSC<=POSITION"
 
 
-@dataclass
-class SeqTableRow:
-    repeats: int = 1
-    trigger: SeqTrigger = SeqTrigger.IMMEDIATE
-    position: int = 0
-    time1: int = 0
-    outa1: bool = False
-    outb1: bool = False
-    outc1: bool = False
-    outd1: bool = False
-    oute1: bool = False
-    outf1: bool = False
-    time2: int = 0
-    outa2: bool = False
-    outb2: bool = False
-    outc2: bool = False
-    outd2: bool = False
-    oute2: bool = False
-    outf2: bool = False
-
-
-class SeqTable(TypedDict):
-    repeats: NotRequired[pnd.Np1DArrayUint16]
-    trigger: NotRequired[Sequence[SeqTrigger]]
-    position: NotRequired[pnd.Np1DArrayInt32]
-    time1: NotRequired[pnd.Np1DArrayUint32]
-    outa1: NotRequired[pnd.Np1DArrayBool]
-    outb1: NotRequired[pnd.Np1DArrayBool]
-    outc1: NotRequired[pnd.Np1DArrayBool]
-    outd1: NotRequired[pnd.Np1DArrayBool]
-    oute1: NotRequired[pnd.Np1DArrayBool]
-    outf1: NotRequired[pnd.Np1DArrayBool]
-    time2: NotRequired[pnd.Np1DArrayUint32]
-    outa2: NotRequired[pnd.Np1DArrayBool]
-    outb2: NotRequired[pnd.Np1DArrayBool]
-    outc2: NotRequired[pnd.Np1DArrayBool]
-    outd2: NotRequired[pnd.Np1DArrayBool]
-    oute2: NotRequired[pnd.Np1DArrayBool]
-    outf2: NotRequired[pnd.Np1DArrayBool]
-
-
-def seq_table_from_rows(*rows: SeqTableRow):
-    """
-    Constructs a sequence table from a series of rows.
-    """
-    return seq_table_from_arrays(
-        repeats=np.array([row.repeats for row in rows], dtype=np.uint16),
-        trigger=[row.trigger for row in rows],
-        position=np.array([row.position for row in rows], dtype=np.int32),
-        time1=np.array([row.time1 for row in rows], dtype=np.uint32),
-        outa1=np.array([row.outa1 for row in rows], dtype=np.bool_),
-        outb1=np.array([row.outb1 for row in rows], dtype=np.bool_),
-        outc1=np.array([row.outc1 for row in rows], dtype=np.bool_),
-        outd1=np.array([row.outd1 for row in rows], dtype=np.bool_),
-        oute1=np.array([row.oute1 for row in rows], dtype=np.bool_),
-        outf1=np.array([row.outf1 for row in rows], dtype=np.bool_),
-        time2=np.array([row.time2 for row in rows], dtype=np.uint32),
-        outa2=np.array([row.outa2 for row in rows], dtype=np.bool_),
-        outb2=np.array([row.outb2 for row in rows], dtype=np.bool_),
-        outc2=np.array([row.outc2 for row in rows], dtype=np.bool_),
-        outd2=np.array([row.outd2 for row in rows], dtype=np.bool_),
-        oute2=np.array([row.oute2 for row in rows], dtype=np.bool_),
-        outf2=np.array([row.outf2 for row in rows], dtype=np.bool_),
-    )
-
-
-T = TypeVar("T", bound=np.generic)
-
-
-def seq_table_from_arrays(
-    *,
-    repeats: Optional[npt.NDArray[np.uint16]] = None,
-    trigger: Optional[Sequence[SeqTrigger]] = None,
-    position: Optional[npt.NDArray[np.int32]] = None,
-    time1: Optional[npt.NDArray[np.uint32]] = None,
-    outa1: Optional[npt.NDArray[np.bool_]] = None,
-    outb1: Optional[npt.NDArray[np.bool_]] = None,
-    outc1: Optional[npt.NDArray[np.bool_]] = None,
-    outd1: Optional[npt.NDArray[np.bool_]] = None,
-    oute1: Optional[npt.NDArray[np.bool_]] = None,
-    outf1: Optional[npt.NDArray[np.bool_]] = None,
-    time2: npt.NDArray[np.uint32],
-    outa2: Optional[npt.NDArray[np.bool_]] = None,
-    outb2: Optional[npt.NDArray[np.bool_]] = None,
-    outc2: Optional[npt.NDArray[np.bool_]] = None,
-    outd2: Optional[npt.NDArray[np.bool_]] = None,
-    oute2: Optional[npt.NDArray[np.bool_]] = None,
-    outf2: Optional[npt.NDArray[np.bool_]] = None,
-) -> SeqTable:
-    """
-    Constructs a sequence table from a series of columns as arrays.
-    time2 is the only required argument and must not be None.
-    All other provided arguments must be of equal length to time2.
-    If any other argument is not given, or else given as None or empty,
-    an array of length len(time2) filled with the following is defaulted:
-    repeats: 1
-    trigger: SeqTrigger.IMMEDIATE
-    all others: 0/False as appropriate
-    """
-    assert time2 is not None, "time2 must be provided"
-    length = len(time2)
-    assert 0 < length < 4096, f"Length {length} not in range"
-
-    def or_default(
-        value: Optional[npt.NDArray[T]], dtype: Type[T], default_value: int = 0
-    ) -> npt.NDArray[T]:
-        if value is None or len(value) == 0:
-            return np.full(length, default_value, dtype=dtype)
-        return value
-
-    table = SeqTable(
-        repeats=or_default(repeats, np.uint16, 1),
-        trigger=trigger or [SeqTrigger.IMMEDIATE] * length,
-        position=or_default(position, np.int32),
-        time1=or_default(time1, np.uint32),
-        outa1=or_default(outa1, np.bool_),
-        outb1=or_default(outb1, np.bool_),
-        outc1=or_default(outc1, np.bool_),
-        outd1=or_default(outd1, np.bool_),
-        oute1=or_default(oute1, np.bool_),
-        outf1=or_default(outf1, np.bool_),
-        time2=time2,
-        outa2=or_default(outa2, np.bool_),
-        outb2=or_default(outb2, np.bool_),
-        outc2=or_default(outc2, np.bool_),
-        outd2=or_default(outd2, np.bool_),
-        oute2=or_default(oute2, np.bool_),
-        outf2=or_default(outf2, np.bool_),
-    )
-    for k, v in table.items():
-        size = len(v)  # type: ignore
-        if size != length:
-            raise ValueError(f"{k}: has length {size} not {length}")
-    return table
+PydanticNp1DArrayInt32 = Annotated[
+    np.ndarray[tuple[int], np.dtype[np.int32]],
+    NpArrayPydanticAnnotation.factory(
+        data_type=np.int32, dimensions=1, strict_data_typing=False
+    ),
+    Field(default_factory=lambda: np.array([], np.int32)),
+]
+PydanticNp1DArrayBool = Annotated[
+    np.ndarray[tuple[int], np.dtype[np.bool_]],
+    NpArrayPydanticAnnotation.factory(
+        data_type=np.bool_, dimensions=1, strict_data_typing=False
+    ),
+    Field(default_factory=lambda: np.array([], dtype=np.bool_)),
+]
+TriggerStr = Annotated[
+    np.ndarray[tuple[int], np.dtype[np.unicode_]],
+    NpArrayPydanticAnnotation.factory(
+        data_type=np.unicode_, dimensions=1, strict_data_typing=False
+    ),
+    Field(default_factory=lambda: np.array([], dtype=np.dtype("<U32"))),
+]
+
+
+class SeqTable(Table):
+    repeats: PydanticNp1DArrayInt32
+    trigger: TriggerStr
+    position: PydanticNp1DArrayInt32
+    time1: PydanticNp1DArrayInt32
+    outa1: PydanticNp1DArrayBool
+    outb1: PydanticNp1DArrayBool
+    outc1: PydanticNp1DArrayBool
+    outd1: PydanticNp1DArrayBool
+    oute1: PydanticNp1DArrayBool
+    outf1: PydanticNp1DArrayBool
+    time2: PydanticNp1DArrayInt32
+    outa2: PydanticNp1DArrayBool
+    outb2: PydanticNp1DArrayBool
+    outc2: PydanticNp1DArrayBool
+    outd2: PydanticNp1DArrayBool
+    oute2: PydanticNp1DArrayBool
+    outf2: PydanticNp1DArrayBool
+
+    @classmethod
+    def row(  # type: ignore
+        cls,
+        *,
+        repeats: int = 1,
+        trigger: str = SeqTrigger.IMMEDIATE,
+        position: int = 0,
+        time1: int = 0,
+        outa1: bool = False,
+        outb1: bool = False,
+        outc1: bool = False,
+        outd1: bool = False,
+        oute1: bool = False,
+        outf1: bool = False,
+        time2: int = 0,
+        outa2: bool = False,
+        outb2: bool = False,
+        outc2: bool = False,
+        outd2: bool = False,
+        oute2: bool = False,
+        outf2: bool = False,
+    ) -> "SeqTable":
+        if isinstance(trigger, SeqTrigger):
+            trigger = trigger.value
+        return super().row(**locals())
+
+    @field_validator("trigger", mode="before")
+    @classmethod
+    def trigger_to_np_array(cls, trigger_column):
+        """
+        The user can provide a list of SeqTrigger enum elements instead of a numpy str.
+        """
+        if isinstance(trigger_column, Sequence) and all(
+            isinstance(trigger, SeqTrigger) for trigger in trigger_column
+        ):
+            trigger_column = np.array(
+                [trigger.value for trigger in trigger_column], dtype=np.dtype("<U32")
+            )
+        elif isinstance(trigger_column, Sequence) or isinstance(
+            trigger_column, np.ndarray
+        ):
+            for trigger in trigger_column:
+                SeqTrigger(
+                    trigger
+                )  # To check all the given strings are actually `SeqTrigger`s
+        else:
+            raise ValueError(
+                "Expected a numpy array or a sequence of `SeqTrigger`, got "
+                f"{type(trigger_column)}."
+            )
+        return trigger_column
+
+    @model_validator(mode="after")
+    def validate_max_length(self) -> "SeqTable":
+        """
+        Used to check max_length. Unfortunately trying the `max_length` arg in
+        the pydantic field doesn't work
+        """
+
+        first_length = len(next(iter(self))[1])
+        assert 0 <= first_length < 4096, f"Length {first_length} not in range."
+        return self

ophyd_async/fastcs/panda/_trigger.py

@@ -1,5 +1,4 @@
 import asyncio
-from typing import Optional
 
 from pydantic import BaseModel, Field
 
@@ -82,7 +81,7 @@ class StaticPcompTriggerLogic(TriggerLogic[PcompInfo]):
         await self.pcomp.enable.set("ONE")
         await wait_for_value(self.pcomp.active, True, timeout=1)
 
-    async def complete(self, timeout: Optional[float] = None) -> None:
+    async def complete(self, timeout: float | None = None) -> None:
         await wait_for_value(self.pcomp.active, False, timeout=timeout)
 
     async def stop(self):

ophyd_async/fastcs/panda/_utils.py

@@ -1,7 +1,8 @@
-from typing import Any, Dict, Sequence
+from collections.abc import Sequence
+from typing import Any
 
 
-def phase_sorter(panda_signal_values: Dict[str, Any]) -> Sequence[Dict[str, Any]]:
+def phase_sorter(panda_signal_values: dict[str, Any]) -> Sequence[dict[str, Any]]:
     # Panda has two load phases. If the signal name ends in the string "UNITS",
     # it needs to be loaded first so put in first phase
     phase_1, phase_2 = {}, {}

ophyd_async/fastcs/panda/_writer.py

@@ -1,8 +1,9 @@
 import asyncio
+from collections.abc import AsyncGenerator, AsyncIterator
 from pathlib import Path
-from typing import AsyncGenerator, AsyncIterator, Dict, List, Optional
 
-from bluesky.protocols import DataKey, StreamAsset
+from bluesky.protocols import StreamAsset
+from event_model import DataKey
 from p4p.client.thread import Context
 
 from ophyd_async.core import (
@@ -20,7 +21,7 @@ from ._block import DataBlock
 
 
 class PandaHDFWriter(DetectorWriter):
-    _ctxt: Optional[Context] = None
+    _ctxt: Context | None = None
 
     def __init__(
         self,
@@ -33,12 +34,12 @@ class PandaHDFWriter(DetectorWriter):
         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: HDFFile | None = None
         self._multiplier = 1
 
     # Triggered on PCAP arm
-    async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
+    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
         """Retrieve and get descriptor of all PandA signals marked for capture"""
 
         # Ensure flushes are immediate
@@ -76,7 +77,7 @@ class PandaHDFWriter(DetectorWriter):
 
         return await self._describe()
 
-    async def _describe(self) -> Dict[str, DataKey]:
+    async def _describe(self) -> dict[str, DataKey]:
         """
         Return a describe based on the datasets PV
         """
@@ -85,9 +86,11 @@ class PandaHDFWriter(DetectorWriter):
         describe = {
             ds.data_key: DataKey(
                 source=self.panda_data_block.hdf_directory.source,
-                shape=ds.shape,
+                shape=list(ds.shape),
                 dtype="array" if ds.shape != [1] else "number",
-                dtype_numpy="<f8",  # PandA data should always be written as Float64
+                # PandA data should always be written as Float64
+                # Ignore type check until https://github.com/bluesky/event-model/issues/308
+                dtype_numpy="<f8",  # type: ignore
                 external="STREAM:",
             )
             for ds in self._datasets
@@ -102,15 +105,27 @@ class PandaHDFWriter(DetectorWriter):
 
         capture_table = await self.panda_data_block.datasets.get_value()
         self._datasets = [
-            HDFDataset(dataset_name, "/" + dataset_name, [1], multiplier=1)
+            # TODO: Update chunk size to read signal once available in IOC
+            # Currently PandA IOC sets chunk size to 1024 points per chunk
+            HDFDataset(
+                dataset_name, "/" + dataset_name, [1], multiplier=1, chunk_shape=(1024,)
+            )
             for dataset_name in capture_table["name"]
         ]
 
+        # Warn user if dataset table is empty in PandA
+        # i.e. no stream resources will be generated
+        if len(self._datasets) == 0:
+            self.panda_data_block.log.warning(
+                f"PandA {self._name_provider()} DATASETS table is empty! "
+                "No stream resource docs will be generated. "
+                "Make sure captured positions have their corresponding "
+                "*:DATASET PV set to a scientifically relevant name."
+            )
+
     # Next few functions are exactly the same as AD writer. Could move as default
     # StandardDetector behavior
-    async def wait_for_index(
-        self, index: int, timeout: Optional[float] = DEFAULT_TIMEOUT
-    ):
+    async def wait_for_index(self, index: int, timeout: float | None = DEFAULT_TIMEOUT):
         def matcher(value: int) -> bool:
             return value >= index
 

ophyd_async/plan_stubs/_fly.py

@@ -1,5 +1,3 @@
-from typing import List, Optional
-
 import bluesky.plan_stubs as bps
 from bluesky.utils import short_uid
 
@@ -15,14 +13,12 @@ from ophyd_async.fastcs.panda import (
     PcompInfo,
     SeqTable,
     SeqTableInfo,
-    SeqTableRow,
-    seq_table_from_rows,
 )
 
 
 def prepare_static_pcomp_flyer_and_detectors(
     flyer: StandardFlyer[PcompInfo],
-    detectors: List[StandardDetector],
+    detectors: list[StandardDetector],
     pcomp_info: PcompInfo,
     trigger_info: TriggerInfo,
 ):
@@ -41,13 +37,14 @@ def prepare_static_pcomp_flyer_and_detectors(
 
 def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
     flyer: StandardFlyer[SeqTableInfo],
-    detectors: List[StandardDetector],
+    detectors: list[StandardDetector],
     number_of_frames: int,
     exposure: float,
     shutter_time: float,
     repeats: int = 1,
     period: float = 0.0,
-    frame_timeout: Optional[float] = None,
+    frame_timeout: float | None = None,
+    iteration: int = 1,
 ):
     """Prepare a hardware triggered flyable and one or more detectors.
 
@@ -70,28 +67,31 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
         deadtime=deadtime,
         livetime=exposure,
         frame_timeout=frame_timeout,
+        iteration=iteration,
     )
     trigger_time = number_of_frames * (exposure + deadtime)
     pre_delay = max(period - 2 * shutter_time - trigger_time, 0)
 
-    table: SeqTable = seq_table_from_rows(
+    table = (
         # Wait for pre-delay then open shutter
-        SeqTableRow(
+        SeqTable.row(
             time1=in_micros(pre_delay),
             time2=in_micros(shutter_time),
             outa2=True,
-        ),
+        )
+        +
         # Keeping shutter open, do N triggers
-        SeqTableRow(
+        SeqTable.row(
             repeats=number_of_frames,
             time1=in_micros(exposure),
             outa1=True,
             outb1=True,
             time2=in_micros(deadtime),
             outa2=True,
-        ),
+        )
+        +
         # Add the shutter close
-        SeqTableRow(time2=in_micros(shutter_time)),
+        SeqTable.row(time2=in_micros(shutter_time))
     )
 
     table_info = SeqTableInfo(sequence_table=table, repeats=repeats)
@@ -105,7 +105,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
 def fly_and_collect(
     stream_name: str,
     flyer: StandardFlyer[SeqTableInfo] | StandardFlyer[PcompInfo],
-    detectors: List[StandardDetector],
+    detectors: list[StandardDetector],
 ):
     """Kickoff, complete and collect with a flyer and multiple detectors.
 
@@ -145,7 +145,7 @@ def fly_and_collect(
 def fly_and_collect_with_static_pcomp(
     stream_name: str,
     flyer: StandardFlyer[PcompInfo],
-    detectors: List[StandardDetector],
+    detectors: list[StandardDetector],
     number_of_pulses: int,
     pulse_width: int,
     rising_edge_step: int,
@@ -171,7 +171,7 @@ def fly_and_collect_with_static_pcomp(
 def time_resolved_fly_and_collect_with_static_seq_table(
     stream_name: str,
     flyer: StandardFlyer[SeqTableInfo],
-    detectors: List[StandardDetector],
+    detectors: list[StandardDetector],
     number_of_frames: int,
     exposure: float,
     shutter_time: float,

ophyd_async/plan_stubs/_nd_attributes.py

@@ -1,14 +1,15 @@
-from typing import Sequence
-from xml.etree import cElementTree as ET
+from collections.abc import Sequence
+from xml.etree import ElementTree 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 (
+from ophyd_async.core import Device
+from ophyd_async.epics.adcore import (
+    NDArrayBaseIO,
     NDAttributeDataType,
     NDAttributeParam,
     NDAttributePv,
+    NDFileHDFIO,
 )
 
 
@@ -48,9 +49,14 @@ def setup_ndattributes(
 
 
 def setup_ndstats_sum(detector: Device):
+    hdf = getattr(detector, "hdf", None)
+    assert isinstance(hdf, NDFileHDFIO), (
+        f"Expected {detector.name} to have 'hdf' attribute that is an NDFilHDFIO, "
+        f"got {hdf}"
+    )
     yield from (
         setup_ndattributes(
-            detector.hdf,
+            hdf,
             [
                 NDAttributeParam(
                     name=f"{detector.name}-sum",

ophyd_async/sim/demo/_pattern_detector/_pattern_detector.py

@@ -1,10 +1,10 @@
+from collections.abc import Sequence
 from pathlib import Path
-from typing import Sequence
 
 from ophyd_async.core import (
-    AsyncReadable,
     FilenameProvider,
     PathProvider,
+    SignalR,
     StandardDetector,
     StaticFilenameProvider,
     StaticPathProvider,
@@ -19,7 +19,7 @@ class PatternDetector(StandardDetector):
     def __init__(
         self,
         path: Path,
-        config_sigs: Sequence[AsyncReadable] = [],
+        config_sigs: Sequence[SignalR] = (),
         name: str = "",
     ) -> None:
         fp: FilenameProvider = StaticFilenameProvider(name)

ophyd_async/sim/demo/_pattern_detector/_pattern_detector_controller.py

@@ -1,7 +1,7 @@
 import asyncio
-from typing import Optional
 
-from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger, PathProvider
+from ophyd_async.core import DetectorControl, PathProvider
+from ophyd_async.core._detector import TriggerInfo
 
 from ._pattern_generator import PatternGenerator
 
@@ -14,36 +14,40 @@ 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
+        self.task: asyncio.Task | None = None
         super().__init__()
 
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.internal,
-        exposure: Optional[float] = 0.01,
-    ) -> AsyncStatus:
-        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)
+    async def prepare(self, trigger_info: TriggerInfo):
+        self._trigger_info = trigger_info
+        if self._trigger_info.livetime is None:
+            self._trigger_info.livetime = 0.01
+        self.period: float = self._trigger_info.livetime + self.get_deadtime(
+            trigger_info.livetime
         )
-        self.task = task
-        return AsyncStatus(task)
 
-    async def disarm(self):
+    async def arm(self):
+        assert self._trigger_info.livetime
+        assert self.period
+        self.task = asyncio.create_task(
+            self._coroutine_for_image_writing(
+                self._trigger_info.livetime, self.period, self._trigger_info.number
+            )
+        )
+
+    async def wait_for_idle(self):
         if self.task:
+            await self.task
+
+    async def disarm(self):
+        if self.task and not self.task.done():
             self.task.cancel()
             try:
                 await self.task
             except asyncio.CancelledError:
                 pass
-            self.task = None
+        self.task = None
 
     def get_deadtime(self, exposure: float | None) -> float:
         return 0.001

ophyd_async/sim/demo/_pattern_detector/_pattern_detector_writer.py

@@ -1,8 +1,8 @@
-from typing import AsyncGenerator, AsyncIterator, Dict
+from collections.abc import AsyncGenerator, AsyncIterator
 
-from bluesky.protocols import DataKey
+from event_model import DataKey
 
-from ophyd_async.core import DetectorWriter, NameProvider, PathProvider
+from ophyd_async.core import DEFAULT_TIMEOUT, DetectorWriter, NameProvider, PathProvider
 
 from ._pattern_generator import PatternGenerator
 
@@ -20,7 +20,7 @@ class PatternDetectorWriter(DetectorWriter):
         self.path_provider = path_provider
         self.name_provider = name_provider
 
-    async def open(self, multiplier: int = 1) -> Dict[str, DataKey]:
+    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
         return await self.pattern_generator.open_file(
             self.path_provider, self.name_provider(), multiplier
         )
@@ -31,8 +31,11 @@ class PatternDetectorWriter(DetectorWriter):
     def collect_stream_docs(self, indices_written: int) -> AsyncIterator:
         return self.pattern_generator.collect_stream_docs(indices_written)
 
-    def observe_indices_written(self, timeout=...) -> AsyncGenerator[int, None]:
-        return self.pattern_generator.observe_indices_written()
+    async def observe_indices_written(
+        self, timeout=DEFAULT_TIMEOUT
+    ) -> AsyncGenerator[int, None]:
+        async for index in self.pattern_generator.observe_indices_written(timeout):
+            yield index
 
     async def get_indices_written(self) -> int:
         return self.pattern_generator.image_counter