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

ophyd_async/fastcs/panda/_control.py

@@ -1,38 +1,37 @@
 import asyncio
-from typing import Optional
 
 from ophyd_async.core import (
-    AsyncStatus,
-    DetectorControl,
+    DetectorController,
     DetectorTrigger,
     wait_for_value,
 )
+from ophyd_async.core._detector import TriggerInfo
+from ophyd_async.core._status import AsyncStatus
 
 from ._block import PcapBlock
 
 
-class PandaPcapController(DetectorControl):
+class PandaPcapController(DetectorController):
     def __init__(self, pcap: PcapBlock) -> None:
         self.pcap = pcap
+        self._arm_status: AsyncStatus | None = None
 
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         return 0.000000008
 
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.constant_gate,
-        exposure: Optional[float] = None,
-    ) -> AsyncStatus:
-        assert trigger in (
+    async def prepare(self, trigger_info: TriggerInfo):
+        assert trigger_info.trigger in (
             DetectorTrigger.constant_gate,
-            trigger == DetectorTrigger.variable_gate,
+            DetectorTrigger.variable_gate,
         ), "Only constant_gate and variable_gate triggering is supported on the PandA"
-        await asyncio.gather(self.pcap.arm.set(True))
+
+    async def arm(self):
+        self._arm_status = self.pcap.arm.set(True)
         await wait_for_value(self.pcap.active, True, timeout=1)
-        return AsyncStatus(wait_for_value(self.pcap.active, False, timeout=None))
 
-    async def disarm(self) -> AsyncStatus:
+    async def wait_for_idle(self):
+        pass
+
+    async def disarm(self):
         await asyncio.gather(self.pcap.arm.set(False))
         await wait_for_value(self.pcap.active, False, timeout=1)
-        return AsyncStatus(wait_for_value(self.pcap.active, False, timeout=None))

ophyd_async/fastcs/panda/_hdf_panda.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Sequence
+from collections.abc 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
@@ -36,7 +36,14 @@ class HDFPanda(CommonPandaBlocks, StandardDetector):
         )
 
     async def connect(
-        self, mock: bool = False, timeout: float = DEFAULT_TIMEOUT
-    ) -> None:
+        self,
+        mock: bool = False,
+        timeout: float = DEFAULT_TIMEOUT,
+        force_reconnect: bool = False,
+    ):
+        # TODO: this doesn't support caching
+        # https://github.com/bluesky/ophyd-async/issues/472
         await fill_pvi_entries(self, self._prefix + "PVI", timeout=timeout, mock=mock)
-        await super().connect(mock=mock, timeout=timeout)
+        await super().connect(
+            mock=mock, timeout=timeout, force_reconnect=force_reconnect
+        )

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, 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,73 @@ 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[Sequence[SeqTrigger], Field(default_factory=list)]
+
+
+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":
+        return Table.row(**locals())
+
+    @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,9 +1,8 @@
 import asyncio
-from typing import Optional
 
 from pydantic import BaseModel, Field
 
-from ophyd_async.core import TriggerLogic, wait_for_value
+from ophyd_async.core import FlyerController, wait_for_value
 
 from ._block import PcompBlock, PcompDirectionOptions, SeqBlock, TimeUnits
 from ._table import SeqTable
@@ -15,7 +14,7 @@ class SeqTableInfo(BaseModel):
     prescale_as_us: float = Field(default=1, ge=0)  # microseconds
 
 
-class StaticSeqTableTriggerLogic(TriggerLogic[SeqTableInfo]):
+class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
     def __init__(self, seq: SeqBlock) -> None:
         self.seq = seq
 
@@ -64,7 +63,7 @@ class PcompInfo(BaseModel):
     )
 
 
-class StaticPcompTriggerLogic(TriggerLogic[PcompInfo]):
+class StaticPcompTriggerLogic(FlyerController[PcompInfo]):
     def __init__(self, pcomp: PcompBlock) -> None:
         self.pcomp = pcomp
 
@@ -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 (
@@ -16,11 +17,11 @@ from ophyd_async.core import (
     wait_for_value,
 )
 
-from ._block import DataBlock
+from ._block import CaptureMode, 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
@@ -57,7 +58,7 @@ class PandaHDFWriter(DetectorWriter):
             self.panda_data_block.hdf_file_name.set(
                 f"{info.filename}.h5",
             ),
-            self.panda_data_block.num_capture.set(0),
+            self.panda_data_block.capture_mode.set(CaptureMode.FOREVER),
         )
 
         # Make sure that directory exists or has been created.
@@ -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,13 @@ 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,
 ):
     """Prepare a hardware triggered flyable and one or more detectors.
 
@@ -65,7 +61,7 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
     deadtime = max(det.controller.get_deadtime(exposure) for det in detectors)
 
     trigger_info = TriggerInfo(
-        number=number_of_frames * repeats,
+        number_of_triggers=number_of_frames * repeats,
         trigger=DetectorTrigger.constant_gate,
         deadtime=deadtime,
         livetime=exposure,
@@ -74,24 +70,26 @@ def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
     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 +103,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 +143,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 +169,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)