pymmcore-plus 0.9.4__py3-none-any.whl → 0.13.0__py3-none-any.whl

pymmcore_plus/mda/_protocol.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from typing import TYPE_CHECKING, Any, Mapping, Protocol, runtime_checkable
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
 
 if TYPE_CHECKING:
-    from typing import Iterable, Iterator
+    from collections.abc import Iterable, Iterator
 
     from numpy.typing import NDArray
     from useq import MDAEvent, MDASequence
 
-    PImagePayload = tuple[NDArray, MDAEvent, dict]
+    from pymmcore_plus.metadata.schema import FrameMetaV1, SummaryMetaV1
+
+    PImagePayload = tuple[NDArray, MDAEvent, FrameMetaV1]
 
 
 # NOTE: This whole thing could potentially go in useq-schema
@@ -21,7 +23,7 @@ class PMDAEngine(Protocol):
     """Protocol that all MDA engines must implement."""
 
     @abstractmethod
-    def setup_sequence(self, sequence: MDASequence) -> None | Mapping[str, Any]:
+    def setup_sequence(self, sequence: MDASequence) -> SummaryMetaV1 | None:
         """Setup state of system (hardware, etc.) before an MDA is run.
 
         This method is called once at the beginning of a sequence.

pymmcore_plus/mda/_runner.py

@@ -2,17 +2,10 @@ from __future__ import annotations
 
 import time
 import warnings
-from contextlib import nullcontext
+from collections.abc import Iterable, Iterator, Sequence
+from contextlib import AbstractContextManager, nullcontext
 from pathlib import Path
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    ContextManager,
-    Iterable,
-    Iterator,
-    Sequence,
-    Tuple,
-)
+from typing import TYPE_CHECKING, Any
 from unittest.mock import MagicMock
 
 from useq import MDASequence
@@ -39,7 +32,7 @@ MSG = (
 
 
 class GeneratorMDASequence(MDASequence):
-    axis_order: Tuple[str, ...] = ()  # noqa: UP006
+    axis_order: tuple[str, ...] = ()
 
     @property
     def sizes(self) -> dict[str, int]:  # pragma: no cover
@@ -77,7 +70,10 @@ class MDARunner:
 
         self._canceled = False
         self._sequence: MDASequence | None = None
-        self._reset_timer()
+        # timer for the full sequence, reset only once at the beginning of the sequence
+        self._sequence_t0: float = 0.0
+        # event clock, reset whenever `event.reset_event_timer` is True
+        self._t0: float = 0.0
 
     def set_engine(self, engine: PMDAEngine) -> PMDAEngine | None:
         """Set the [`PMDAEngine`][pymmcore_plus.mda.PMDAEngine] to use for the MDA run."""  # noqa: E501
@@ -89,7 +85,7 @@ class MDARunner:
         if self.is_running():  # pragma: no cover
             raise RuntimeError(
                 "Cannot register a new engine when the current engine is running "
-                "an acquistion. Please cancel the current engine's acquistion "
+                "an acquisition. Please cancel the current engine's acquisition "
                 "before registering"
             )
 
@@ -115,7 +111,7 @@ class MDARunner:
         return self._signals
 
     def is_running(self) -> bool:
-        """Return True if an acquistion is currently underway.
+        """Return True if an acquisition is currently underway.
 
         This will return True at any point between the emission of the
         [`sequenceStarted`][pymmcore_plus.mda.PMDASignaler.sequenceStarted] and
@@ -125,19 +121,19 @@ class MDARunner:
         Returns
         -------
         bool
-            Whether an acquistion is underway.
+            Whether an acquisition is underway.
         """
         return self._running
 
     def is_paused(self) -> bool:
-        """Return True if the acquistion is currently paused.
+        """Return True if the acquisition is currently paused.
 
         Use `toggle_pause` to change the paused state.
 
         Returns
         -------
         bool
-            Whether the current acquistion is paused.
+            Whether the current acquisition is paused.
         """
         return self._paused
 
@@ -145,7 +141,7 @@ class MDARunner:
         """Cancel the currently running acquisition.
 
         This is a no-op if no acquisition is currently running.
-        If an acquisition is running then this will cancel the acquistion and
+        If an acquisition is running then this will cancel the acquisition and
         a sequenceCanceled signal, followed by a sequenceFinished signal will
         be emitted.
         """
@@ -157,7 +153,7 @@ class MDARunner:
 
         To get whether the acquisition is currently paused use the
         [`is_paused`][pymmcore_plus.mda.MDARunner.is_paused] method. This method is a
-        no-op if no acquistion is currently underway.
+        no-op if no acquisition is currently underway.
         """
         if self.is_running():
             self._paused = not self._paused
@@ -169,7 +165,7 @@ class MDARunner:
         *,
         output: SingleOutput | Sequence[SingleOutput] | None = None,
     ) -> None:
-        """Run the multi-dimensional acquistion defined by `sequence`.
+        """Run the multi-dimensional acquisition defined by `sequence`.
 
         Most users should not use this directly as it will block further
         execution. Instead, use the
@@ -210,9 +206,21 @@ class MDARunner:
         if error is not None:
             raise error
 
+    def seconds_elapsed(self) -> float:
+        """Return the number of seconds since the start of the acquisition."""
+        return time.perf_counter() - self._sequence_t0
+
+    def event_seconds_elapsed(self) -> float:
+        """Return the number of seconds on the "event clock".
+
+        This is the time since either the start of the acquisition or the last
+        event with `reset_event_timer` set to `True`.
+        """
+        return time.perf_counter() - self._t0
+
     def _outputs_connected(
         self, output: SingleOutput | Sequence[SingleOutput] | None
-    ) -> ContextManager:
+    ) -> AbstractContextManager:
         """Context in which output handlers are connected to the frameReady signal."""
         if output is None:
             return nullcontext()
@@ -266,10 +274,21 @@ class MDARunner:
     def _run(self, engine: PMDAEngine, events: Iterable[MDAEvent]) -> None:
         """Main execution of events, inside the try/except block of `run`."""
         teardown_event = getattr(engine, "teardown_event", lambda e: None)
-        event_iterator = getattr(engine, "event_iterator", iter)
+        if isinstance(events, Iterator):
+            # if an iterator is passed directly, then we use that iterator
+            # instead of the engine's event_iterator.  Directly passing an iterator
+            # is an advanced use case, (for example, `iter(Queue(), None)` for event-
+            # driven acquisition) and we don't want the engine to interfere with it.
+            event_iterator = iter
+        else:
+            event_iterator = getattr(engine, "event_iterator", iter)
         _events: Iterator[MDAEvent] = event_iterator(events)
+        self._reset_event_timer()
+        self._sequence_t0 = self._t0
 
         for event in _events:
+            if event.reset_event_timer:
+                self._reset_event_timer()
             # If cancelled break out of the loop
             if self._wait_until_event(event) or not self._running:
                 break
@@ -278,17 +297,23 @@ class MDARunner:
             logger.info("%s", event)
             engine.setup_event(event)
 
-            output = engine.exec_event(event) or ()  # in case output is None
-
-            for payload in output:
-                img, event, meta = payload
-                if "PerfCounter" in meta:
-                    meta["ElapsedTime-ms"] = (meta["PerfCounter"] - self._t0) * 1000
-                meta["Event"] = event
-                with exceptions_logged():
-                    self._signals.frameReady.emit(img, event, meta)
-
-            teardown_event(event)
+            try:
+                runner_time_ms = self.seconds_elapsed() * 1000
+                # this is a bit of a hack to pass the time into the engine
+                # it is used for intra-event time calculations inside the engine.
+                # we pop it off after the event is executed.
+                event.metadata["runner_t0"] = self._sequence_t0
+                output = engine.exec_event(event) or ()  # in case output is None
+                for payload in output:
+                    img, event, meta = payload
+                    event.metadata.pop("runner_t0", None)
+                    # if the engine calculated its own time, don't overwrite it
+                    if "runner_time_ms" not in meta:
+                        meta["runner_time_ms"] = runner_time_ms
+                    with exceptions_logged():
+                        self._signals.frameReady.emit(img, event, meta)
+            finally:
+                teardown_event(event)
 
     def _prepare_to_run(self, sequence: MDASequence) -> PMDAEngine:
         """Set up for the MDA run.
@@ -307,18 +332,13 @@ class MDARunner:
         self._sequence = sequence
 
         meta = self._engine.setup_sequence(sequence)
-        logger.info("MDA Started: %s", sequence)
-
         self._signals.sequenceStarted.emit(sequence, meta or {})
-        self._reset_timer()
+        logger.info("MDA Started: %s", sequence)
         return self._engine
 
-    def _reset_timer(self) -> None:
+    def _reset_event_timer(self) -> None:
         self._t0 = time.perf_counter()  # reference time, in seconds
 
-    def _time_elapsed(self) -> float:
-        return time.perf_counter() - self._t0
-
     def _check_canceled(self) -> bool:
         """Return True if the cancel method has been called and emit relevant signals.
 
@@ -369,7 +389,7 @@ class MDARunner:
             go_at = event.min_start_time + self._paused_time
             # We need to enter a loop here checking paused and canceled.
             # otherwise you'll potentially wait a long time to cancel
-            remaining_wait_time = go_at - self._time_elapsed()
+            remaining_wait_time = go_at - self.event_seconds_elapsed()
             while remaining_wait_time > 0:
                 self._signals.awaitingEvent.emit(event, remaining_wait_time)
                 while self._paused and not self._canceled:
@@ -380,7 +400,7 @@ class MDARunner:
                 if self._canceled:
                     break
                 time.sleep(min(remaining_wait_time, 0.5))
-                remaining_wait_time = go_at - self._time_elapsed()
+                remaining_wait_time = go_at - self.event_seconds_elapsed()
 
         # check canceled again in case it was canceled
         # during the waiting loop
@@ -402,12 +422,3 @@ class MDARunner:
 
         logger.info("MDA Finished: %s", sequence)
         self._signals.sequenceFinished.emit(sequence)
-
-
-def _assert_handler(handler: Any) -> None:
-    if (
-        not hasattr(handler, "start")
-        or not hasattr(handler, "finish")
-        or not hasattr(handler, "put")
-    ):
-        raise TypeError("Handler must have start, finish, and put methods.")

pymmcore_plus/mda/_thread_relay.py

@@ -11,7 +11,9 @@ from pymmcore_plus._util import listeners_connected
 from .events import _get_auto_MDA_callback_class
 
 if TYPE_CHECKING:
-    from typing import Any, ContextManager, Iterator
+    from collections.abc import Iterator
+    from contextlib import AbstractContextManager
+    from typing import Any
 
     from pymmcore_plus.core.events._protocol import PSignalInstance
     from pymmcore_plus.mda import PMDASignaler
@@ -24,7 +26,7 @@ def mda_listeners_connected(
     name_map: dict[str, str] | None = ...,
     asynchronous: Literal[False],
     wait_on_exit: bool = ...,
-) -> ContextManager[None]: ...
+) -> AbstractContextManager[None]: ...
 
 
 @overload
@@ -34,7 +36,7 @@ def mda_listeners_connected(
     name_map: dict[str, str] | None = ...,
     asynchronous: Literal[True] = ...,
     wait_on_exit: bool = ...,
-) -> ContextManager[MDARelayThread]: ...
+) -> AbstractContextManager[MDARelayThread]: ...
 
 
 @contextmanager

pymmcore_plus/mda/events/__init__.py

@@ -8,12 +8,12 @@ from ._protocol import PMDASignaler
 from ._psygnal import MDASignaler
 
 if TYPE_CHECKING:
-    from ._qsignals import QMDASignaler  # noqa: TCH004
+    from ._qsignals import QMDASignaler  # noqa: TC004
 
 
 __all__ = [
-    "PMDASignaler",
     "MDASignaler",
+    "PMDASignaler",
     "QMDASignaler",
     "_get_auto_MDA_callback_class",
 ]

pymmcore_plus/mda/events/_protocol.py

@@ -8,7 +8,11 @@ class PMDASignaler(Protocol):
     """Declares the protocol for all signals that will be emitted from [`pymmcore_plus.mda.MDARunner`][]."""  # noqa: E501
 
     sequenceStarted: PSignal
-    """Emits `(sequence: MDASequence, metadata: dict)` when an acquisition sequence is started."""  # noqa: E501
+    """Emits `(sequence: MDASequence, metadata: dict)` when an acquisition sequence is started.
+
+    For the default [`MDAEngine`][pymmcore_plus.mda.MDAEngine], the metadata `dict` will
+    be of type [`SummaryMetaV1`][pymmcore_plus.metadata.schema.SummaryMetaV1].
+    """  # noqa: E501
     sequencePauseToggled: PSignal
     """Emits `(paused: bool)` when an acquisition sequence is paused or unpaused."""
     sequenceCanceled: PSignal
@@ -16,7 +20,11 @@ class PMDASignaler(Protocol):
     sequenceFinished: PSignal
     """Emits `(sequence: MDASequence)` when an acquisition sequence is finished."""
     frameReady: PSignal
-    """Emits `(img: np.ndarray, event: MDAEvent, metadata: dict)` after an image is acquired during an acquisition sequence."""  # noqa: E501
+    """Emits `(img: np.ndarray, event: MDAEvent, metadata: dict)` after an image is acquired during an acquisition sequence.
+
+    For the default [`MDAEngine`][pymmcore_plus.mda.MDAEngine], the metadata `dict` will
+    be of type [`FrameMetaV1`][pymmcore_plus.metadata.schema.FrameMetaV1].
+    """  # noqa: E501
     awaitingEvent: PSignal
     """Emits `(event: MDAEvent, remaining_sec: float)` when the runner is waiting to start an event.
 

pymmcore_plus/mda/events/_psygnal.py

@@ -1,9 +1,9 @@
 import numpy as np
-from psygnal import Signal
+from psygnal import Signal, SignalGroup
 from useq import MDAEvent, MDASequence
 
 
-class MDASignaler:
+class MDASignaler(SignalGroup):
     sequenceStarted = Signal(MDASequence, dict)  # at the start of an MDA sequence
     sequencePauseToggled = Signal(bool)  # when MDA is paused/unpaused
     sequenceCanceled = Signal(MDASequence)  # when mda is canceled

pymmcore_plus/mda/handlers/_5d_writer_base.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import json
+import warnings
 from abc import abstractmethod
 from collections import defaultdict
 from typing import TYPE_CHECKING, Generic, Protocol, TypeVar
@@ -8,13 +8,18 @@ from typing import TYPE_CHECKING, Generic, Protocol, TypeVar
 from ._util import position_sizes
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
+
     import numpy as np
     import useq
 
+    from pymmcore_plus.metadata import FrameMetaV1, SummaryMetaV1
+
     class SupportsSetItem(Protocol):
         def __setitem__(self, key: tuple[int, ...], value: np.ndarray) -> None: ...
 
 
+_NULL = object()
 POS_PREFIX = "p"
 T = TypeVar("T", bound="SupportsSetItem")
 
@@ -66,36 +71,73 @@ class _5DWriterBase(Generic[T]):
 
         # storage of individual frame metadata
         # maps position key to list of frame metadata
-        self.frame_metadatas: defaultdict[str, list[dict]] = defaultdict(list)
+        self.frame_metadatas: defaultdict[str, list[FrameMetaV1]] = defaultdict(list)
 
         # set during sequenceStarted and cleared during sequenceFinished
         self.current_sequence: useq.MDASequence | None = None
 
         # list of {dim_name: size} map for each position in the sequence
-        self.position_sizes: list[dict[str, int]] = []
+        self._position_sizes: list[dict[str, int]] = []
+
+        # actual timestamps for each frame
+        self._timestamps: list[float] = []
 
     # The next three methods - `sequenceStarted`, `sequenceFinished`, and `frameReady`
     # are to be connected directly to the MDA's signals, perhaps via listener_connected
 
-    def sequenceStarted(self, seq: useq.MDASequence) -> None:
+    @property
+    def position_sizes(self) -> list[dict[str, int]]:
+        """Return sizes of each dimension for each position in the sequence.
+
+        Will be a list of dicts, where each dict maps dimension names to sizes, and
+        the index in the list corresponds to the stage position index.
+
+        This is the preferred way to access both the dimensions present in each position
+        as well as the sizes of those dimensions.
+
+        The dict is ordered, and the order reflects the order of dimensions in the
+        shape of each position.
+        """
+        return self._position_sizes
+
+    def sequenceStarted(
+        self, seq: useq.MDASequence, meta: SummaryMetaV1 | object = _NULL
+    ) -> None:
         """On sequence started, simply store the sequence."""
+        # this is here for backwards compatibility with experimental viewer widget.
+        if meta is _NULL:  # pragma: no cover
+            warnings.warn(
+                "calling `sequenceStarted` without metadata as the second argument is "
+                "deprecated and will raise an exception in the future. Please propagate"
+                " metadata from the event callback.",
+                UserWarning,
+                stacklevel=2,
+            )
         self.frame_metadatas.clear()
         self.current_sequence = seq
         if seq:
-            self.position_sizes = position_sizes(seq)
+            self._position_sizes = position_sizes(seq)
 
     def sequenceFinished(self, seq: useq.MDASequence) -> None:
         """On sequence finished, clear the current sequence."""
         self.finalize_metadata()
         self.frame_metadatas.clear()
-        self.current_sequence = None
-        self.position_sizes = []
 
-    def frameReady(self, frame: np.ndarray, event: useq.MDAEvent, meta: dict) -> None:
+    def get_position_key(self, position_index: int) -> str:
+        """Get the position key for a specific position index.
+
+        This key will be used for subclasses like Zarr that need a directory structure
+        for each position.  And may also be used to index into `self.position_arrays`.
+        """
+        return f"{POS_PREFIX}{position_index}"
+
+    def frameReady(
+        self, frame: np.ndarray, event: useq.MDAEvent, meta: FrameMetaV1
+    ) -> None:
         """Write frame to the zarr array for the appropriate position."""
         # get the position key to store the array in the group
         p_index = event.index.get("p", 0)
-        key = f"{POS_PREFIX}{p_index}"
+        key = self.get_position_key(p_index)
         pos_sizes = self.position_sizes[p_index]
         if key in self.position_arrays:
             ary = self.position_arrays[key]
@@ -117,6 +159,9 @@ class _5DWriterBase(Generic[T]):
             self.position_arrays[key] = ary = self.new_array(key, frame.dtype, sizes)
 
         index = tuple(event.index[k] for k in pos_sizes)
+        t = event.index.get("t", 0)
+        if t >= len(self._timestamps) and "runner_time_ms" in meta:
+            self._timestamps.append(meta["runner_time_ms"])
         self.write_frame(ary, index, frame)
         self.store_frame_metadata(key, event, meta)
 
@@ -162,7 +207,9 @@ class _5DWriterBase(Generic[T]):
         # WRITE DATA TO DISK
         ary[index] = frame
 
-    def store_frame_metadata(self, key: str, event: useq.MDAEvent, meta: dict) -> None:
+    def store_frame_metadata(
+        self, key: str, event: useq.MDAEvent, meta: FrameMetaV1
+    ) -> None:
         """Called during each frameReady event to store metadata for the frame.
 
         Subclasses may override this method to customize how metadata is stored for each
@@ -181,11 +228,6 @@ class _5DWriterBase(Generic[T]):
         # needn't be re-implemented in subclasses
         # default implementation is to store the metadata in self._frame_metas
         # use finalize_metadata to write to disk at the end of the sequence.
-        if meta:
-            # fix serialization MDAEvent
-            # XXX: There is already an Event object in meta, this overwrites it.
-            event_json = event.json(exclude={"sequence"}, exclude_defaults=True)
-            meta["Event"] = json.loads(event_json)
         self.frame_metadatas[key].append(meta or {})
 
     def finalize_metadata(self) -> None:
@@ -194,3 +236,52 @@ class _5DWriterBase(Generic[T]):
         Subclasses may override this method to flush any accumulated frame metadata to
         disk at the end of the sequence.
         """
+
+    # This syntax is intentionally the same as xarray's isel method.  It's possible
+    # we will use xarray in the future, and this will make it easier to switch.
+    def isel(
+        self,
+        indexers: Mapping[str, int | slice] | None = None,
+        **indexers_kwargs: int | slice,
+    ) -> np.ndarray:
+        """Select data from the array.
+
+        This is a convenience method to select data from the array for a given position
+        key.  It will call the appropriate `__getitem__` method on the array with the
+        given indexers.
+
+        Parameters
+        ----------
+        indexers : Mapping[str, int | slice] | None
+            Mapping of dimension names to indices or slices.  If None, will return the
+            full array.
+        **indexers_kwargs : int | slice
+            Keyword arguments of dimension names to indices or slices.  These will be
+            merged with `indexers`, and allows for a nicer syntax.
+
+        Returns
+        -------
+        np.ndarray
+            The selected data from the array.
+
+        Examples
+        --------
+        >>> data = writer.isel(t=0, z=1, c=0, x=slice(128, 256))
+        """
+        indexers = dict(indexers or {})
+        indexers.update(indexers_kwargs)
+
+        p_index = indexers.get("p", 0)
+        if isinstance(p_index, slice):
+            raise NotImplementedError("Cannot slice over position index")  # TODO
+
+        try:
+            sizes = [*list(self.position_sizes[p_index]), "y", "x"]
+        except IndexError as e:
+            raise IndexError(
+                f"Position index {p_index} out of range for {len(self.position_sizes)}"
+            ) from e
+        data = self.position_arrays[self.get_position_key(p_index)]
+        full = slice(None, None)
+        index = tuple(indexers.get(k, full) for k in sizes)
+        return data[index]  # type: ignore

pymmcore_plus/mda/handlers/__init__.py

@@ -1,5 +1,11 @@
 from ._img_sequence_writer import ImageSequenceWriter
 from ._ome_tiff_writer import OMETiffWriter
 from ._ome_zarr_writer import OMEZarrWriter
+from ._tensorstore_handler import TensorStoreHandler
 
-__all__ = ["ImageSequenceWriter", "OMEZarrWriter", "OMETiffWriter"]
+__all__ = [
+    "ImageSequenceWriter",
+    "OMETiffWriter",
+    "OMEZarrWriter",
+    "TensorStoreHandler",
+]

pymmcore_plus/mda/handlers/_img_sequence_writer.py

@@ -7,10 +7,12 @@ provided.
 
 from __future__ import annotations
 
-import json
+from collections.abc import Mapping, Sequence
 from itertools import count
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Mapping, Sequence, cast
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, cast
+
+from pymmcore_plus.metadata.serialize import json_dumps
 
 from ._util import get_full_sequence_axes
 
@@ -176,11 +178,13 @@ class ImageSequenceWriter:
                 include_frame_count=self._include_frame_count,
             )
             # make directory and write metadata
-            self._seq_meta_file.write_text(seq.json(exclude_unset=True, indent=4))
+            self._seq_meta_file.write_text(
+                seq.model_dump_json(exclude_unset=True, indent=2)
+            )
 
     def sequenceFinished(self, seq: useq.MDASequence) -> None:
         # write final frame metadata to disk
-        self._frame_meta_file.write_text(json.dumps(self._frame_metadata, indent=2))
+        self._frame_meta_file.write_bytes(json_dumps(self._frame_metadata, indent=2))
 
     def frameReady(self, frame: np.ndarray, event: useq.MDAEvent, meta: dict) -> None:
         """Write a frame to disk."""
@@ -199,11 +203,12 @@ class ImageSequenceWriter:
         self._imwrite(str(self._directory / filename), frame, **self._imwrite_kwargs)
 
         # store metadata
-        meta["Event"] = json.loads(event.json(exclude={"sequence"}, exclude_unset=True))
         self._frame_metadata[filename] = meta
         # write metadata to disk every 10 frames
         if frame_idx % 10 == 0:
-            self._frame_meta_file.write_text(json.dumps(self._frame_metadata, indent=2))
+            self._frame_meta_file.write_bytes(
+                json_dumps(self._frame_metadata, indent=2)
+            )
 
     @staticmethod
     def fname_template(

pymmcore_plus/mda/handlers/_ome_tiff_writer.py

@@ -41,13 +41,15 @@ from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
-from ._5d_writer_base import _5DWriterBase
+from ._5d_writer_base import _NULL, _5DWriterBase
 
 if TYPE_CHECKING:
     from pathlib import Path
 
     import useq
 
+    from pymmcore_plus.metadata import SummaryMetaV1
+
 IMAGEJ_AXIS_ORDER = "tzcyxs"
 
 
@@ -81,13 +83,15 @@ class OMETiffWriter(_5DWriterBase[np.memmap]):
 
         super().__init__()
 
-    def sequenceStarted(self, seq: useq.MDASequence) -> None:
-        super().sequenceStarted(seq)
+    def sequenceStarted(
+        self, seq: useq.MDASequence, meta: SummaryMetaV1 | object = _NULL
+    ) -> None:
+        super().sequenceStarted(seq, meta)
         # Non-OME (ImageJ) hyperstack axes MUST be in TZCYXS order
         # so we reorder the ordered position_sizes dicts.  This will ensure
         # that the array indices created from event.index are in the correct order.
         if not self._is_ome:
-            self.position_sizes = [
+            self._position_sizes = [
                 {k: x[k] for k in IMAGEJ_AXIS_ORDER if k.lower() in x}
                 for x in self.position_sizes
             ]