pymmcore-plus 0.15.4__py3-none-any.whl → 0.16.0__py3-none-any.whl

pymmcore_plus/metadata/_ome.py

@@ -0,0 +1,499 @@
+from __future__ import annotations
+
+import uuid
+from contextlib import suppress
+from datetime import datetime
+from typing import TYPE_CHECKING, NamedTuple
+
+import useq
+from ome_types.model import (
+    OME,
+    Channel,
+    Image,
+    ImageRef,
+    Instrument,
+    Pixels,
+    Pixels_DimensionOrder,
+    PixelType,
+    Plane,
+    Plate,
+    UnitsLength,
+    UnitsTime,
+    Well,
+    WellSample,
+)
+
+from pymmcore_plus.mda._runner import GeneratorMDASequence
+
+if TYPE_CHECKING:
+    from pymmcore_plus.metadata.schema import ImageInfo
+
+    from .schema import FrameMetaV1, SummaryMetaV1
+
+
+__all__ = ["create_ome_metadata"]
+
+
+def create_ome_metadata(
+    summary_metadata: SummaryMetaV1, frame_metadata_list: list[FrameMetaV1]
+) -> OME:
+    """Create OME metadata from metadata saved as json by the core engine.
+
+    Parameters
+    ----------
+    summary_metadata : SummaryMetaV1
+        Summary metadata containing acquisition information.
+    frame_metadata_list : list[FrameMetaV1]
+        List of frame metadata for each acquired image.
+
+    Returns
+    -------
+    OME
+        The OME metadata as an `ome_types.OME` object.
+    """
+    _uuid = f"urn:uuid:{uuid.uuid4()}"
+    ome = OME(uuid=_uuid)
+
+    ome.instruments = instruments = _build_instrument_list(summary_metadata)
+
+    image_infos = summary_metadata.get("image_infos", ())
+    if not frame_metadata_list or not image_infos:
+        return ome
+
+    sequence = _extract_mda_sequence(summary_metadata, frame_metadata_list[0])
+    position_groups = _group_frames_by_position(frame_metadata_list)
+    images = _build_ome_images(
+        dimension_info=_extract_dimension_info(image_infos[0]),
+        sequence=sequence,
+        position_groups=position_groups,
+        acquisition_date=_extract_acquisition_date(summary_metadata),
+    )
+
+    plates = []
+    if (plate_plan := _extract_plate_plan(sequence)) is not None:
+        position_to_image_mapping = _create_position_to_image_mapping(position_groups)
+        plates = [_build_ome_plate(plate_plan, position_to_image_mapping)]
+
+    return OME(
+        uuid=_uuid,
+        images=images,
+        instruments=instruments,
+        plates=plates,
+    )
+
+
+# =============================================================================
+# Data Structures
+# =============================================================================
+
+
+class _DimensionInfo(NamedTuple):
+    pixel_size_um: float
+    dtype: str | None
+    height: int
+    width: int
+
+
+class _PositionKey(NamedTuple):
+    name: str | None
+    p_index: int
+    g_index: int | None = None
+
+    def __str__(self) -> str:
+        p_name = self.name or f"Pos{self.p_index:04d}"
+        if self.g_index is not None:
+            return f"{p_name}_Grid{self.g_index:04d}_{self.p_index}"
+        else:
+            return f"{p_name}_{self.p_index}"
+
+    @property
+    def image_id(self) -> str:
+        if self.g_index is not None:
+            return f"{self.p_index}_{self.g_index}"
+        return f"{self.p_index}"
+
+
+# =============================================================================
+# Metadata Extraction Functions
+# =============================================================================
+
+
+def _extract_dimension_info(
+    image_info: ImageInfo,
+) -> _DimensionInfo:
+    """Extract pixel size (µm), data type, width, and height from image_infos."""
+    return _DimensionInfo(
+        pixel_size_um=image_info.get("pixel_size_um", 1.0),
+        dtype=image_info.get("dtype", None),
+        width=image_info.get("width", 0),
+        height=image_info.get("height", 0),
+    )
+
+
+def _extract_acquisition_date(summary_metadata: SummaryMetaV1) -> datetime | None:
+    """Extract acquisition date from summary metadata."""
+    if (acquisition_time := summary_metadata.get("datetime")) is not None:
+        with suppress(ValueError, AttributeError):
+            return datetime.fromisoformat(acquisition_time.replace("Z", "+00:00"))
+    return None
+
+
+def _extract_mda_sequence(
+    summary_metadata: SummaryMetaV1, single_frame_metadata: FrameMetaV1
+) -> useq.MDASequence | None:
+    """Extract the MDA sequence from summary metadata or frame metadata."""
+    if (sequence_data := summary_metadata.get("mda_sequence")) is not None:
+        return useq.MDASequence.model_validate(sequence_data)
+    if (mda_event := _extract_mda_event(single_frame_metadata)) is not None:
+        return mda_event.sequence
+    return None
+
+
+def _extract_mda_event(frame_metadata: FrameMetaV1) -> useq.MDAEvent | None:
+    """Extract the useq.MDAEvent from frame metadata."""
+    if (mda_event_data := frame_metadata.get("mda_event")) is not None:
+        return useq.MDAEvent.model_validate(mda_event_data)
+    return None  # pragma: no cover
+
+
+def _extract_plate_plan(
+    sequence: useq.MDASequence | None,
+) -> useq.WellPlatePlan | None:
+    """Extract the plate plan from the MDA sequence if it exists."""
+    if sequence is None:  # pragma: no cover
+        return None
+    stage_positions = sequence.stage_positions
+    if isinstance(stage_positions, useq.WellPlatePlan):
+        return stage_positions
+    return None
+
+
+# =============================================================================
+# Frame Grouping and Processing
+# =============================================================================
+
+
+def _group_frames_by_position(
+    frame_metadata_list: list[FrameMetaV1],
+) -> dict[_PositionKey, list[FrameMetaV1]]:
+    """Reorganize frame metadata by stage position index in a dictionary.
+
+    Handles the 'g' axis (grid) by converting it to separate positions,
+    since OME doesn't support the 'g' axis. Each grid position becomes
+    a separate OME Image with names like "Pos0000_Grid0000".
+
+    Returns
+    -------
+    dict[str, list[FrameMetaV1]]
+        mapping of position identifier (e.g. 'Pos0000_Grid0000')
+        to list of `FrameMetaV1`.
+    """
+    frames_by_position: dict[_PositionKey, list[FrameMetaV1]] = {}
+    for frame_metadata in frame_metadata_list:
+        if (mda_event := _extract_mda_event(frame_metadata)) is None:
+            continue  # pragma: no cover
+
+        p_index = mda_event.index.get(useq.Axis.POSITION, 0) or 0
+        g_index = mda_event.index.get(useq.Axis.GRID, None)
+        key = _PositionKey(mda_event.pos_name, p_index, g_index)
+        pos_list = frames_by_position.setdefault(key, [])
+        pos_list.append(frame_metadata)
+    return frames_by_position
+
+
+def _create_position_to_image_mapping(
+    position_groups: dict[_PositionKey, list[FrameMetaV1]],
+) -> dict[int, str]:
+    """Create a mapping from position index to image ID."""
+    position_to_image_mapping: dict[int, str] = {}
+
+    for position_key, position_frames in position_groups.items():
+        if position_frames:
+            mda_event = _extract_mda_event(position_frames[0])
+            if mda_event is not None:
+                position_index = mda_event.index.get("p", 0)
+                position_to_image_mapping[position_index] = position_key.image_id
+    return position_to_image_mapping
+
+
+# =============================================================================
+# Dimension Order and Pixel Information
+# =============================================================================
+
+
+def _determine_dimension_order(
+    sequence: useq.MDASequence | None,
+) -> Pixels_DimensionOrder | None:
+    """Determine the dimension order for pixels."""
+    if sequence is None or isinstance(sequence, GeneratorMDASequence):
+        return Pixels_DimensionOrder.XYTCZ
+    return _extract_dimension_order_from_sequence(sequence)
+
+
+def _extract_dimension_order_from_sequence(
+    sequence: useq.MDASequence,
+) -> Pixels_DimensionOrder:
+    """Extract axis order from a useq.MDASequence.
+
+    Returns
+    -------
+    A Pixels_DimensionOrder representing the dimension order compatible with OME
+    standards
+    (e.g., "XYCZT").
+    """
+    filtered_axes = (axis for axis in sequence.axis_order if axis not in {"p", "g"})
+    dimension_order = "XY" + "".join(filtered_axes).upper()
+
+    if len(dimension_order) != 5:
+        missing_axes = [axis for axis in "XYCZT" if axis not in dimension_order]
+        dimension_order += "".join(missing_axes)
+
+    return Pixels_DimensionOrder(dimension_order)
+
+
+def _extract_pixel_dimensions_and_channels(
+    sequence: useq.MDASequence | None,
+    position_frames: list[FrameMetaV1],
+    image_id: str,
+) -> tuple[tuple[int, int, int], list[Channel]]:
+    """Extract pixel dimensions and channels from sequence or frames."""
+    if sequence is None or isinstance(sequence, GeneratorMDASequence):
+        return _extract_pixel_info_from_frames(position_frames, image_id)
+    return _extract_pixel_info_from_sequence(sequence, image_id)
+
+
+def _extract_pixel_info_from_frames(
+    position_metadata: list[FrameMetaV1],
+    image_id: str,
+) -> tuple[tuple[int, int, int], list[Channel]]:
+    """Extract pixel dimensions and channel information from frame metadata.
+
+    Returns
+    -------
+        A tuple containing the maximum (t, z, c) dimensions, and a list of channels.
+    """
+    max_t, max_z, max_c = 0, 0, 0
+    channels: dict[int, Channel] = {}
+
+    for frame_metadata in position_metadata:
+        mda_event = _extract_mda_event(frame_metadata)
+        if mda_event is None:  # pragma: no cover
+            continue
+
+        t_index = mda_event.index.get("t", 0)
+        z_index = mda_event.index.get("z", 0)
+        c_index = mda_event.index.get("c", 0)
+
+        max_t = max(max_t, t_index)
+        max_z = max(max_z, z_index)
+        max_c = max(max_c, c_index)
+
+        if c_index not in channels and mda_event.channel is not None:
+            channels[c_index] = Channel(
+                id=f"Channel:{image_id}:{c_index}",
+                name=mda_event.channel.config,
+                samples_per_pixel=1,
+            )
+
+    sorted_channels = [channels[i] for i in sorted(channels.keys())]
+    return (max_t + 1, max_z + 1, max_c + 1), sorted_channels
+
+
+def _extract_pixel_info_from_sequence(
+    sequence: useq.MDASequence,
+    image_id: str,
+) -> tuple[tuple[int, int, int], list[Channel]]:
+    """Extract pixel dimensions and channel information from MDA sequence."""
+    max_t = sequence.sizes.get("t", 1)
+    max_z = sequence.sizes.get("z", 1)
+    channels = [
+        Channel(
+            id=f"Channel:{image_id}:{index}",
+            name=channel.config,
+            samples_per_pixel=1,
+        )
+        for index, channel in enumerate(sequence.channels)
+    ]
+    return (max_t, max_z, len(channels)), channels
+
+
+# =============================================================================
+# OME Object Builders
+# =============================================================================
+
+
+def _build_ome_images(
+    dimension_info: _DimensionInfo,
+    sequence: useq.MDASequence | None,
+    position_groups: dict[_PositionKey, list[FrameMetaV1]],
+    acquisition_date: datetime | None,
+) -> list[Image]:
+    """Build OME Images from grouped frame metadata by position."""
+    images = []
+    for position_key, position_frames in position_groups.items():
+        image_id = position_key.image_id
+        position_name = str(position_key)
+
+        dimension_order = _determine_dimension_order(sequence)
+        if not dimension_order:  # pragma: no cover
+            continue
+
+        size_info, channels = _extract_pixel_dimensions_and_channels(
+            sequence, position_frames, image_id
+        )
+        max_t, max_z, max_c = size_info
+
+        pixels = _build_pixels_object(
+            image_id,
+            dimension_order,
+            dimension_info,
+            max_t,
+            max_z,
+            max_c,
+            channels,
+            position_frames,
+        )
+
+        image = Image(
+            acquisition_date=acquisition_date,
+            id=f"Image:{image_id}",
+            name=position_name,
+            pixels=pixels,
+        )
+        images.append(image)
+    return images
+
+
+def _build_pixels_object(
+    image_id: str,
+    dimension_order: Pixels_DimensionOrder,
+    dimension_info: _DimensionInfo,
+    max_t: int,
+    max_z: int,
+    max_c: int,
+    channels: list[Channel],
+    position_frames: list[FrameMetaV1],
+) -> Pixels:
+    """Build a Pixels object with the given parameters."""
+    from ome_types.model import MetadataOnly
+
+    return Pixels(
+        id=f"Pixels:{image_id}",
+        dimension_order=dimension_order,
+        size_x=dimension_info.width,
+        size_y=dimension_info.height,
+        size_z=max(max_z, 1),
+        size_c=max(max_c, 1),
+        size_t=max(max_t, 1),
+        type=PixelType(dimension_info.dtype),
+        physical_size_x=dimension_info.pixel_size_um,
+        physical_size_x_unit=UnitsLength.MICROMETER,
+        physical_size_y=dimension_info.pixel_size_um,
+        physical_size_y_unit=UnitsLength.MICROMETER,
+        channels=channels,
+        metadata_only=MetadataOnly(),
+        planes=_build_plane_list(position_frames),
+    )
+
+
+def _build_plane_list(position_frames: list[FrameMetaV1]) -> list[Plane]:
+    """Build Plane objects for frame metadata at a specific position."""
+    planes = []
+    for frame_metadata in position_frames:
+        mda_event = _extract_mda_event(frame_metadata)
+        if mda_event is None:  # pragma: no cover
+            continue
+
+        event_index = mda_event.index
+        z_index = event_index.get("z", 0)
+        c_index = event_index.get("c", 0)
+        t_index = event_index.get("t", 0)
+
+        runner_time_ms = frame_metadata.get("runner_time_ms", 0.0)
+        delta_t = runner_time_ms / 1000.0 if runner_time_ms > 0 else None
+        exposure_ms = frame_metadata.get("exposure_ms", 0.0)
+
+        plane = Plane(
+            the_z=z_index,
+            the_c=c_index,
+            the_t=t_index,
+            position_x=mda_event.x_pos,
+            position_x_unit=UnitsLength.MICROMETER,
+            position_y=mda_event.y_pos,
+            position_y_unit=UnitsLength.MICROMETER,
+            position_z=mda_event.z_pos,
+            position_z_unit=UnitsLength.MICROMETER,
+            delta_t=delta_t,
+            delta_t_unit=UnitsTime.SECOND,
+            exposure_time=exposure_ms,
+            exposure_time_unit=UnitsTime.MILLISECOND,
+        )
+
+        planes.append(plane)
+    return planes
+
+
+def _build_ome_plate(
+    plate_plan: useq.WellPlatePlan, position_to_image_mapping: dict[int, str]
+) -> Plate:
+    """Create a Plate object from a useq.WellPlatePlan."""
+    wells: list[Well] = []
+
+    # create a mapping from well name to acquisition indices
+    well_acquisition_map: dict[str, list[int]] = {}
+    for acquisition_index, position in enumerate(plate_plan.image_positions):
+        well_name = position.name
+        if well_name is not None:
+            if well_name not in well_acquisition_map:
+                well_acquisition_map[well_name] = []
+            well_acquisition_map[well_name].append(acquisition_index)
+
+    for (row, col), name, pos in zip(
+        plate_plan.selected_well_indices,
+        plate_plan.selected_well_names,
+        plate_plan.selected_well_positions,
+    ):
+        # get all acquisition indices for this well
+        acquisition_indices = well_acquisition_map.get(name, [])
+
+        # create WellSample objects for each acquisition in this well
+        well_samples = []
+        for acq_index in acquisition_indices:
+            # Use the actual image ID from the mapping
+            image_id = position_to_image_mapping.get(acq_index, str(acq_index))
+            well_samples.append(
+                WellSample(
+                    id=f"WellSample:{acq_index}",
+                    position_x=pos.x,
+                    position_y=pos.y,
+                    position_x_unit=UnitsLength.MICROMETER,
+                    position_y_unit=UnitsLength.MICROMETER,
+                    index=acq_index,
+                    image_ref=ImageRef(id=f"Image:{image_id}"),
+                )
+            )
+
+        wells.append(
+            Well(
+                row=row,
+                column=col,
+                well_samples=well_samples,
+            )
+        )
+
+    return Plate(
+        name=plate_plan.plate.name,
+        rows=plate_plan.plate.rows,
+        columns=plate_plan.plate.columns,
+        wells=wells,
+        well_origin_x=plate_plan.a1_center_xy[0],
+        well_origin_x_unit=UnitsLength.MICROMETER,
+        well_origin_y=plate_plan.a1_center_xy[1],
+        well_origin_y_unit=UnitsLength.MICROMETER,
+    )
+
+
+def _build_instrument_list(summary_metadata: SummaryMetaV1) -> list[Instrument]:
+    """Build instrument list from summary metadata."""
+    # TODO
+    return []

{pymmcore_plus-0.15.4.dist-info → pymmcore_plus-0.16.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymmcore-plus
-Version: 0.15.4
+Version: 0.16.0
 Summary: pymmcore superset providing improved APIs, event handling, and a pure python acquisition engine
 Project-URL: Source, https://github.com/pymmcore-plus/pymmcore-plus
 Project-URL: Tracker, https://github.com/pymmcore-plus/pymmcore-plus/issues
@@ -28,9 +28,10 @@ Requires-Python: >=3.9
 Requires-Dist: numpy>=1.25.2
 Requires-Dist: numpy>=1.26.0; python_version >= '3.12'
 Requires-Dist: numpy>=2.1.0; python_version >= '3.13'
+Requires-Dist: ome-types>=0.6.0
 Requires-Dist: platformdirs>=3.0.0
 Requires-Dist: psygnal>=0.10
-Requires-Dist: pymmcore>=11.9.0.73.0
+Requires-Dist: pymmcore>=11.10.0.74.0
 Requires-Dist: rich>=10.2.0
 Requires-Dist: tensorstore!=0.1.72,>=0.1.67
 Requires-Dist: tensorstore!=0.1.72,>=0.1.71; python_version >= '3.13'

{pymmcore_plus-0.15.4.dist-info → pymmcore_plus-0.16.0.dist-info}/RECORD

@@ -1,13 +1,14 @@
-pymmcore_plus/__init__.py,sha256=trTkp3YbM8nahgsl1_N8snC5bs0GY7CX1v1ssVgBh2c,2243
-pymmcore_plus/_accumulator.py,sha256=WUgCrLW0U8_kWXfmhSRrC17ubWZNQNckkGVBiTp72F8,9205
+pymmcore_plus/__init__.py,sha256=Z5CdLIfBVp1Oe-J-uW2VBzjBFas3GPMRea8OSPJYePM,3030
+pymmcore_plus/_accumulator.py,sha256=kQzVAt-lS6DAokJz-nbB7oQBxb23bjT46kCiM_y7rJE,9853
 pymmcore_plus/_benchmark.py,sha256=YJICxXleFQVbOluJdq4OujnIcTkkuMVzeB8GJ8nUv5I,6011
 pymmcore_plus/_build.py,sha256=RPTAuwCZWGL5IDJj4JZo1DIIouUsIqS3vnbPbG2_bRE,10993
-pymmcore_plus/_cli.py,sha256=wmqlG8UGBNiTefRppSnRHwnD3w-5DAhN168lIBujbRA,16831
+pymmcore_plus/_cli.py,sha256=vjF02cLFt0hIJHN5jwhi7KKgqjsFJCE0Wihfg2_x7KQ,17410
+pymmcore_plus/_discovery.py,sha256=rBsf_-H5nQ6MUOD8wPV0c0iOc46nU2RszmUxc7iziVs,12785
 pymmcore_plus/_ipy_completion.py,sha256=K__bKTJZukzz0RhNr3KZ2urpQGxQrW8ySUQtHDoKfLA,17936
-pymmcore_plus/_logger.py,sha256=d7ldqxY0rGWORKdIzNUiFc9BW6cFBx57kHWtXyY1HE0,5416
+pymmcore_plus/_logger.py,sha256=Fzwk8k6zvkhMKajx_vrVjbR-D2o6mKtYivG2Jgyflmc,5421
 pymmcore_plus/_pymmcore.py,sha256=hy0gfEhvQ84o7SFIB2nQp6A1w2L4U7VQrV5_qKsJoLQ,699
-pymmcore_plus/_util.py,sha256=VGcb_nQu6BBWZsQihed0TrCHdTRADKlBo_qSnIbeF0Q,22814
-pymmcore_plus/install.py,sha256=t05GmuxphIVkOr1CuFLAL6NmzL5ELWiXl7aivtQSoOo,10788
+pymmcore_plus/_util.py,sha256=xskovMeMbFDpKcqEv-bADiwm37f-AmPpaPfTPPBjyyo,14278
+pymmcore_plus/install.py,sha256=a7MqkqJFevXgouvLNflypCu7-Y9oe1KKOwImwhyIaO8,16000
 pymmcore_plus/mocks.py,sha256=jNUfmffD1OArtIvEmqWsy7GCrtTpssVF03flH8cEYx8,1867
 pymmcore_plus/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymmcore_plus/seq_tester.py,sha256=ielLx2ZUJrOXVCojk64UXTeKDoARxt8QkQjt5AE5Gng,3776
@@ -16,14 +17,14 @@ pymmcore_plus/core/_adapter.py,sha256=eu2BhGe_dnoQrIsh-u3poxWXsiF2Y8pfbKIGWbUgOk
 pymmcore_plus/core/_config.py,sha256=yWwOnW6f37lLt83MnodNce04az-g8YDjyo7BvMiTc8s,10672
 pymmcore_plus/core/_config_group.py,sha256=R-o4xuPDBPQAC3s-mFsiKwHVKWR38L9qq_aoWdPrAq8,8542
 pymmcore_plus/core/_constants.py,sha256=tpXCn4CdhevGabUwOSvn7klMRoiXiVPmsPlAofL6Ai4,14122
-pymmcore_plus/core/_device.py,sha256=v58TcROSuvxE5ALBjzS474Dx430e0iMA61OuBSnc2rE,33197
+pymmcore_plus/core/_device.py,sha256=x-fZcWu7KGScbxj5CPQomdFMYkvnFWJXGUJuYEfcYNc,33623
 pymmcore_plus/core/_metadata.py,sha256=L8x1gX_zXPz02BUqc7eqJM_Bey2G0RyX30SOBs2aBNc,2755
-pymmcore_plus/core/_mmcore_plus.py,sha256=_5d73MYRG4nOdyJkdL7BvFX8bDmWwbjfN5sCU_vxj8A,102842
-pymmcore_plus/core/_property.py,sha256=QsQEzqOAedR24zEJ1Ge4kwScfT_7NOApVcgz6QxBJrI,8265
+pymmcore_plus/core/_mmcore_plus.py,sha256=3Ij6wWpTm2vcYKwdXY29pRKdrTkTd60va4hZMxAEU7c,103150
+pymmcore_plus/core/_property.py,sha256=fiqxke6Y_3wsXrDTzbGJ4jioj_M-syWPL-7fufUPNow,8514
 pymmcore_plus/core/_sequencing.py,sha256=pOydKOsHjQOlYGp51hrSjHz02s4NoSEzQwTTSh3R4_Q,16887
 pymmcore_plus/core/events/__init__.py,sha256=F8r10LEBLrAV8qfkXScSkpqfExdT2XoOx92OqSturpc,1078
 pymmcore_plus/core/events/_deprecated.py,sha256=H_Sd63ZyV3Hkq8Imozi8OE7FIa_hhSRpEyhjLj4xTB8,2241
-pymmcore_plus/core/events/_device_signal_view.py,sha256=t-NfBdg3E4rms4vDFxkkR5XtrpLxaBT7mfPwkpIsbVk,1079
+pymmcore_plus/core/events/_device_signal_view.py,sha256=NiM7qImggEsOEgfBJtxlr2mUIx5y184PLYIV_vgIo3w,1328
 pymmcore_plus/core/events/_norm_slot.py,sha256=8DCBoLHGh7cbB1OB19IJYwL6sFBFmkD8IakfBOvFbw8,2907
 pymmcore_plus/core/events/_prop_event_mixin.py,sha256=FvJJnpEKrOR-_Sp3-NNCwFoUUHwmNKiHruo0Y1vybsY,4042
 pymmcore_plus/core/events/_protocol.py,sha256=0EpuRrgbnG_abE8raixViU4QcJ59i2RWI7kwKIeZiBs,9072
@@ -31,11 +32,11 @@ pymmcore_plus/core/events/_psygnal.py,sha256=PogTZBA2Xd1PaKHtWpqkSqYOwRd4UM2XSHA
 pymmcore_plus/core/events/_qsignals.py,sha256=aQfLz_E7E3gqE62KWmuyxekQB9N2rUZ9Dbd8c-TgV9U,4052
 pymmcore_plus/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymmcore_plus/experimental/unicore/__init__.py,sha256=2jjw8K3DZ8NSY5mFn4YBTrYp78Zc9EbGIZCiyG7PujQ,682
-pymmcore_plus/experimental/unicore/_device_manager.py,sha256=I0kbIsxxT3tyeeSElK4l4kUd16hbw81fJv3UZCQPW2Q,6423
+pymmcore_plus/experimental/unicore/_device_manager.py,sha256=nhL6YtvmghWRLST8QPNfBIA5A1dfgvxOZE-PARI1_PQ,6820
 pymmcore_plus/experimental/unicore/_proxy.py,sha256=QPFnG9Mw6WCFSui8nUCabJTJL-Xyvyo-fbLM1Q949is,4703
 pymmcore_plus/experimental/unicore/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymmcore_plus/experimental/unicore/core/_sequence_buffer.py,sha256=uyTKacCZNgxmsssBoAt62TvZjtv892YaTojyIDicgRI,12050
-pymmcore_plus/experimental/unicore/core/_unicore.py,sha256=6invaoXaCpvPKqPGa2g5IKXjP5C6hKs0hDuihPs4lfc,72387
+pymmcore_plus/experimental/unicore/core/_unicore.py,sha256=oTvkpFlgRILMBx_fSlABw_E9jHia1OX_00D4Ss9qoDQ,72544
 pymmcore_plus/experimental/unicore/devices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymmcore_plus/experimental/unicore/devices/_camera.py,sha256=Ef0VATVVNldZoYlQv7Qykgw1I6G-jk2usk7qhjJFXJ8,8538
 pymmcore_plus/experimental/unicore/devices/_device_base.py,sha256=rmxzP-Cghn9bOA0m3I2a-7CspJAsp3OwTY6mv3bYzE0,10870
@@ -46,7 +47,7 @@ pymmcore_plus/experimental/unicore/devices/_slm.py,sha256=L2axjzcNQlCSADkuYFwJlZ
 pymmcore_plus/experimental/unicore/devices/_stage.py,sha256=NO96VqeLTdtEWBQ3fPerdQhvGK6Nmu57ZKSq5g9jMiA,7897
 pymmcore_plus/experimental/unicore/devices/_state.py,sha256=EpZAI9jYEQ9hU-H873ow9xY1u0oEXCs5lq6Op8-e-Xs,6091
 pymmcore_plus/mda/__init__.py,sha256=7VH-MqOcuK1JNSOG9HhES6Ac-Z-LuT8a0f2xPbGEt7w,344
-pymmcore_plus/mda/_engine.py,sha256=U83PnmbaWChxUCEskKqHVy-Xa8KAZAMuvwPSVTAwsKg,31205
+pymmcore_plus/mda/_engine.py,sha256=0TmfM-y-fo2TlBTuAeaqZgSDFM3vUKqJxk7T_ze0cyE,38799
 pymmcore_plus/mda/_protocol.py,sha256=10CDJ9H57oX1z0oqK3eShXyQhufHvvu3_8wdaCYpPIg,3254
 pymmcore_plus/mda/_runner.py,sha256=NSOhpll6_WxDLO19FTs19dASJcHcOoVOCy7q_QzX_Ms,18523
 pymmcore_plus/mda/_thread_relay.py,sha256=Ww-9gyvLEzwRhnpL1dpze71wL7IRlhH8K3Q1dmJIxgs,6193
@@ -62,6 +63,7 @@ pymmcore_plus/mda/handlers/_ome_zarr_writer.py,sha256=cKg3kJR7TId6M2qC1nJMLlxkv5
 pymmcore_plus/mda/handlers/_tensorstore_handler.py,sha256=YrKwahypq1yoXP3cOcsJTGF-f4LOLrp4KuNHYzPBK64,15321
 pymmcore_plus/mda/handlers/_util.py,sha256=pZydpKAXtQ_gjq5x1yNK1D0hfS7NUL2nH9ivOBg4abc,1600
 pymmcore_plus/metadata/__init__.py,sha256=0o_v53kwR4U_RLlCnr7GD1G6OdFlVuUByIqXiaaM5uk,699
+pymmcore_plus/metadata/_ome.py,sha256=tSY2SUKA1PNAexyde2fEX1a1owsbU_rsHx64H2ywR4s,16513
 pymmcore_plus/metadata/functions.py,sha256=Nw2zMbJx0c6aJs6I_uaLGz6cop0IIPfRZOR-qx-SQbc,12937
 pymmcore_plus/metadata/schema.py,sha256=NxKujQChIXFT48OirNebankGaHNAD0GcA77tjkG4uGs,18390
 pymmcore_plus/metadata/serialize.py,sha256=hpXJm0tzILELf6OYECMg0sQhuf-h25ob6_DDl-TUUME,3805
@@ -74,8 +76,8 @@ pymmcore_plus/model/_device.py,sha256=AX3rO2gbY7AXJyMN3FfI_n2jl2V0IAPuBh7MiDA5Sq
 pymmcore_plus/model/_microscope.py,sha256=69VV6cuevinOK_LhYEkQygHGesvCZefdn9YNt3mV618,11353
 pymmcore_plus/model/_pixel_size_config.py,sha256=RXk8AAwARe8clsXue0GZfOTb1bxyXIsO0ibcDLHM4_s,3889
 pymmcore_plus/model/_property.py,sha256=NQzNtnEzSCR9ogwx1cfi8X-qbJ_cBSJKdSBAaoKoPQ0,3720
-pymmcore_plus-0.15.4.dist-info/METADATA,sha256=-3XrqRBjgLgw1NqqiSnXjoLYIw0nteZgXIeOYpVl1Pg,8835
-pymmcore_plus-0.15.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pymmcore_plus-0.15.4.dist-info/entry_points.txt,sha256=NtFyndrQzBpUNJyil-8e5hMGke2utAf7mkGavTLcLOY,51
-pymmcore_plus-0.15.4.dist-info/licenses/LICENSE,sha256=OHJjRpOPKKRc7FEnpehNWdR5LRBdBhUtIFG-ZI0dCEA,1522
-pymmcore_plus-0.15.4.dist-info/RECORD,,
+pymmcore_plus-0.16.0.dist-info/METADATA,sha256=ob6RhMldyjqQmKL35L2rBZHCftp_npNd1PKLv6m5bQM,8868
+pymmcore_plus-0.16.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pymmcore_plus-0.16.0.dist-info/entry_points.txt,sha256=NtFyndrQzBpUNJyil-8e5hMGke2utAf7mkGavTLcLOY,51
+pymmcore_plus-0.16.0.dist-info/licenses/LICENSE,sha256=OHJjRpOPKKRc7FEnpehNWdR5LRBdBhUtIFG-ZI0dCEA,1522
+pymmcore_plus-0.16.0.dist-info/RECORD,,