pymmcore-plus 0.13.1__py3-none-any.whl → 0.13.2__py3-none-any.whl

pymmcore_plus/core/_constants.py

@@ -209,10 +209,15 @@ class PortType(IntEnum):
     HIDPort = pymmcore.HIDPort
 
 
+# NB:
+# do *not* use `pymmcore.FocusDirection...` enums here.
+# the MMCore API does not use the device enums (which is what pymmcore exposes)
+# but instead translates MM::FocusDirectionTowardSample into a different number:
+# https://github.com/micro-manager/mmCoreAndDevices/tree/MMCore/MMCore.cpp#L2063-L2074
 class FocusDirection(IntEnum):
-    Unknown = pymmcore.FocusDirectionUnknown
-    TowardSample = pymmcore.FocusDirectionTowardSample
-    AwayFromSample = pymmcore.FocusDirectionAwayFromSample
+    Unknown = 0
+    TowardSample = 1
+    AwayFromSample = -1
     # aliases
     FocusDirectionUnknown = Unknown
     FocusDirectionTowardSample = TowardSample

pymmcore_plus/mda/__init__.py

@@ -1,6 +1,6 @@
 from ._engine import MDAEngine
 from ._protocol import PMDAEngine
-from ._runner import MDARunner
+from ._runner import MDARunner, SupportsFrameReady
 from ._thread_relay import mda_listeners_connected
 from .events import PMDASignaler
 
@@ -9,5 +9,6 @@ __all__ = [
     "MDARunner",
     "PMDAEngine",
     "PMDASignaler",
+    "SupportsFrameReady",
     "mda_listeners_connected",
 ]

pymmcore_plus/mda/_runner.py

@@ -5,8 +5,9 @@ import warnings
 from collections.abc import Iterable, Iterator, Sequence
 from contextlib import AbstractContextManager, nullcontext
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 from unittest.mock import MagicMock
+from weakref import WeakSet
 
 from useq import MDASequence
 
@@ -17,13 +18,40 @@ from ._thread_relay import mda_listeners_connected
 from .events import PMDASignaler, _get_auto_MDA_callback_class
 
 if TYPE_CHECKING:
-    from typing import TypeAlias
+    from typing import Protocol, TypeAlias
 
+    import numpy as np
     from useq import MDAEvent
 
+    from pymmcore_plus.metadata.schema import FrameMetaV1
+
     from ._engine import MDAEngine
 
-    SingleOutput: TypeAlias = Path | str | object
+    class FrameReady0(Protocol):
+        """Data handler with a no-argument `frameReady` method."""
+
+        def frameReady(self) -> Any: ...
+
+    class FrameReady1(Protocol):
+        """Data handler with a `frameReady` method that takes `(image,)` ."""
+
+        def frameReady(self, img: np.ndarray, /) -> Any: ...
+
+    class FrameReady2(Protocol):
+        """Data handler with a `frameReady` method that takes `(image, event)`."""
+
+        def frameReady(self, img: np.ndarray, event: MDAEvent, /) -> Any: ...
+
+    class FrameReady3(Protocol):
+        """Data handler with a `frameReady` method that takes `(image, event, meta)`."""
+
+        def frameReady(
+            self, img: np.ndarray, event: MDAEvent, meta: FrameMetaV1, /
+        ) -> Any: ...
+
+
+SupportsFrameReady: TypeAlias = "FrameReady0 | FrameReady1 | FrameReady2 | FrameReady3"
+SingleOutput: TypeAlias = "Path | str | SupportsFrameReady"
 
 MSG = (
     "This sequence is a placeholder for a generator of events with unknown "
@@ -67,7 +95,7 @@ class MDARunner:
         self._paused = False
         self._paused_time: float = 0
         self._pause_interval: float = 0.1  # sec to wait between checking pause state
-
+        self._handlers: WeakSet[SupportsFrameReady] = WeakSet()
         self._canceled = False
         self._sequence: MDASequence | None = None
         # timer for the full sequence, reset only once at the beginning of the sequence
@@ -189,6 +217,10 @@ class MDARunner:
             - A handler object that implements the `DataHandler` protocol, currently
                 meaning it has a `frameReady` method.  See `mda_listeners_connected`
                 for more details.
+
+            During the course of the sequence, the `get_output_handlers` method can be
+            used to get the currently connected output handlers (including those that
+            were created automatically based on file paths).
         """
         error = None
         sequence = events if isinstance(events, MDASequence) else GeneratorMDASequence()
@@ -206,6 +238,31 @@ class MDARunner:
         if error is not None:
             raise error
 
+    def get_output_handlers(self) -> tuple[SupportsFrameReady, ...]:
+        """Return the data handlers that are currently connected.
+
+        Output handlers are connected by passing them to the `output` parameter of the
+        `run` method; the run method accepts objects with a `frameReady` method *or*
+        strings representing paths.  If a string is passed, a handler will be created
+        internally.
+
+        This method returns a tuple of currently connected handlers, including those
+        that were explicitly passed to `run()`, as well as those that were created based
+        on file paths.  Internally, handlers are held by weak references, so if you want
+        the handler to persist, you must keep a reference to it.  The only guaranteed
+        API that the handler will have is the `frameReady` method, but it could be any
+        user-defined object that implements that method.
+
+        Handlers are cleared each time `run()` is called, (but not at the end
+        of the sequence).
+
+        Returns
+        -------
+        tuple[SupportsFrameReady, ...]
+            Tuple of objects that (minimally) support the `frameReady` method.
+        """
+        return tuple(self._handlers)
+
     def seconds_elapsed(self) -> float:
         """Return the number of seconds since the start of the acquisition."""
         return time.perf_counter() - self._sequence_t0
@@ -228,48 +285,31 @@ class MDARunner:
         if isinstance(output, (str, Path)) or not isinstance(output, Sequence):
             output = [output]
 
-        # convert all items to handler objects
-        handlers: list[Any] = []
+        # convert all items to handler objects, preserving order
+        _handlers: list[SupportsFrameReady] = []
         for item in output:
             if isinstance(item, (str, Path)):
-                handlers.append(self._handler_for_path(item))
+                _handlers.append(self._handler_for_path(item))
             else:
-                # TODO: better check for valid handler protocol
-                # quick hack for now.
-                if not hasattr(item, "frameReady"):
+                if not callable(getattr(item, "frameReady", None)):
                     raise TypeError(
-                        "Output handlers must have a frameReady method. "
+                        "Output handlers must have a callable frameReady method. "
                         f"Got {item} with type {type(item)}."
                     )
-                handlers.append(item)
+                _handlers.append(item)
 
-        return mda_listeners_connected(*handlers, mda_events=self._signals)
+        self._handlers.clear()
+        self._handlers.update(_handlers)
+        return mda_listeners_connected(*_handlers, mda_events=self._signals)
 
-    def _handler_for_path(self, path: str | Path) -> object:
+    def _handler_for_path(self, path: str | Path) -> SupportsFrameReady:
         """Convert a string or Path into a handler object.
 
         This method picks from the built-in handlers based on the extension of the path.
         """
-        path = str(Path(path).expanduser().resolve())
-        if path.endswith(".zarr"):
-            from pymmcore_plus.mda.handlers import OMEZarrWriter
-
-            return OMEZarrWriter(path)
-
-        if path.endswith((".tiff", ".tif")):
-            from pymmcore_plus.mda.handlers import OMETiffWriter
-
-            return OMETiffWriter(path)
-
-        # FIXME: ugly hack for the moment to represent a non-existent directory
-        # there are many features that ImageSequenceWriter supports, and it's unclear
-        # how to infer them all from a single string.
-        if not (Path(path).suffix or Path(path).exists()):
-            from pymmcore_plus.mda.handlers import ImageSequenceWriter
-
-            return ImageSequenceWriter(path)
+        from pymmcore_plus.mda.handlers import handler_for_path
 
-        raise ValueError(f"Could not infer a writer handler for path: '{path}'")
+        return cast("SupportsFrameReady", handler_for_path(path))
 
     def _run(self, engine: PMDAEngine, events: Iterable[MDAEvent]) -> None:
         """Main execution of events, inside the try/except block of `run`."""

pymmcore_plus/mda/handlers/__init__.py

@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+from pathlib import Path
+
 from ._img_sequence_writer import ImageSequenceWriter
 from ._ome_tiff_writer import OMETiffWriter
 from ._ome_zarr_writer import OMEZarrWriter
@@ -8,4 +12,29 @@ __all__ = [
     "OMETiffWriter",
     "OMEZarrWriter",
     "TensorStoreHandler",
+    "handler_for_path",
 ]
+
+
+def handler_for_path(path: str | Path) -> object:
+    """Convert a string or Path into a handler object.
+
+    This method picks from the built-in handlers based on the extension of the path.
+    """
+    if str(path).rstrip("/").rstrip(":").lower() == "memory":
+        return TensorStoreHandler(kvstore="memory://")
+
+    path = str(Path(path).expanduser().resolve())
+    if path.endswith(".zarr"):
+        return OMEZarrWriter(path)
+
+    if path.endswith((".tiff", ".tif")):
+        return OMETiffWriter(path)
+
+    # FIXME: ugly hack for the moment to represent a non-existent directory
+    # there are many features that ImageSequenceWriter supports, and it's unclear
+    # how to infer them all from a single string.
+    if not (Path(path).suffix or Path(path).exists()):
+        return ImageSequenceWriter(path)
+
+    raise ValueError(f"Could not infer a writer handler for path: '{path}'")

pymmcore_plus/mda/handlers/_img_sequence_writer.py

@@ -22,6 +22,8 @@ if TYPE_CHECKING:
     import useq
     from typing_extensions import TypeAlias  # py310
 
+    from pymmcore_plus.metadata.schema import FrameMetaV1
+
     ImgWriter: TypeAlias = Callable[[str, npt.NDArray], Any]
 
 FRAME_KEY = "frame"
@@ -118,7 +120,7 @@ class ImageSequenceWriter:
             shutil.rmtree(self._directory)
 
         # ongoing dict of frame meta... stored for easy rewrite without reading
-        self._frame_metadata: dict[str, dict] = {}
+        self._frame_metadata: dict[str, FrameMetaV1] = {}
         self._frame_meta_file = self._directory.joinpath(self.FRAME_META_PATH)
         self._seq_meta_file = self._directory.joinpath(self.SEQ_META_PATH)
 
@@ -186,7 +188,9 @@ class ImageSequenceWriter:
         # write final frame metadata to disk
         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:
+    def frameReady(
+        self, frame: np.ndarray, event: useq.MDAEvent, meta: FrameMetaV1, /
+    ) -> None:
         """Write a frame to disk."""
         frame_idx = next(self._counter)
         if self._name_template:

pymmcore_plus/mda/handlers/_tensorstore_handler.py

@@ -111,6 +111,8 @@ class TensorStoreHandler:
         self.delete_existing = delete_existing
         self.spec = spec
 
+        self._current_sequence: useq.MDASequence | None = None
+
         # storage of individual frame metadata
         # maps position key to list of frame metadata
         self.frame_metadatas: list[tuple[useq.MDAEvent, FrameMetaV1]] = []
@@ -176,13 +178,25 @@ class TensorStoreHandler:
 
         return cls(path=path, **kwargs)
 
-    def sequenceStarted(self, seq: useq.MDASequence, meta: SummaryMetaV1) -> None:
-        """On sequence started, simply store the sequence."""
+    def reset(self, sequence: useq.MDASequence) -> None:
+        """Reset state to prepare for new `sequence`."""
         self._frame_index = 0
         self._store = None
         self._futures.clear()
         self.frame_metadatas.clear()
-        self.current_sequence = seq
+        self._current_sequence = sequence
+
+    @property
+    def current_sequence(self) -> useq.MDASequence | None:
+        """Return current sequence, or none.
+
+        Use `.reset()` to initialize the handler for a new sequence.
+        """
+        return self._current_sequence
+
+    def sequenceStarted(self, seq: useq.MDASequence, meta: SummaryMetaV1) -> None:
+        """On sequence started, simply store the sequence."""
+        self.reset(seq)
 
     def sequenceFinished(self, seq: useq.MDASequence) -> None:
         """On sequence finished, clear the current sequence."""
@@ -199,7 +213,7 @@ class TensorStoreHandler:
             self.finalize_metadata()
 
     def frameReady(
-        self, frame: np.ndarray, event: useq.MDAEvent, meta: FrameMetaV1
+        self, frame: np.ndarray, event: useq.MDAEvent, meta: FrameMetaV1, /
     ) -> None:
         """Write frame to the zarr array for the appropriate position."""
         if self._store is None:

pymmcore_plus/model/_config_file.py

@@ -209,18 +209,28 @@ def run_command(line: str, scope: Microscope) -> None:
         return
 
     exec_cmd, expected_n_args = COMMAND_EXECUTORS[command]
+    should_raise = command in SHOULD_RAISE
 
     if (nargs := len(args) + 1) not in expected_n_args:
         exp_str = " or ".join(map(str, expected_n_args))
-        raise ValueError(
+        msg = (
             f"Invalid configuration line encountered for command {cmd_name}. "
             f"Expected {exp_str} arguments, got {nargs}: {line!r}"
         )
+        if should_raise:
+            raise ValueError(msg)
+        else:
+            warnings.warn(msg, RuntimeWarning, stacklevel=2)
+            return
 
     try:
         exec_cmd(scope, args)
     except Exception as exc:
-        raise ValueError(f"Error executing command {line!r}: {exc}") from exc
+        if should_raise:
+            raise ValueError(f"Error executing command {line!r}: {exc}") from exc
+        warnings.warn(
+            f"Failed to execute command {line!r}: {exc}", RuntimeWarning, stacklevel=2
+        )
 
 
 def _exec_Device(scope: Microscope, args: Sequence[str]) -> None:
@@ -352,3 +362,6 @@ COMMAND_EXECUTORS: dict[CFGCommand, tuple[Executor, set[int]]] = {
     CFGCommand.ParentID: (_exec_ParentID, {3}),
     CFGCommand.FocusDirection: (_exec_FocusDirection, {3}),
 }
+
+# Commands that should raise when fail
+SHOULD_RAISE = {CFGCommand.Device, CFGCommand.Property}

{pymmcore_plus-0.13.1.dist-info → pymmcore_plus-0.13.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymmcore-plus
-Version: 0.13.1
+Version: 0.13.2
 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

{pymmcore_plus-0.13.1.dist-info → pymmcore_plus-0.13.2.dist-info}/RECORD

@@ -13,7 +13,7 @@ pymmcore_plus/core/__init__.py,sha256=rYHv5JQVMVDlwYD1wodCc5L9ZbpVld1C_swGx4CRog
 pymmcore_plus/core/_adapter.py,sha256=eu2BhGe_dnoQrIsh-u3poxWXsiF2Y8pfbKIGWbUgOk8,2857
 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=ugXgCKVHt9E2s8outgA1cVgoB2Ea9Io4mcgxu5o_UAA,12617
+pymmcore_plus/core/_constants.py,sha256=6foxGbek3tgnUHYUtQ7NCqwIIqqGYW1W56HjrhZqsA0,12829
 pymmcore_plus/core/_device.py,sha256=Pz9Ekhss2c9IBA3B7WyMU2cCwc19Dp_dGVhMkzqUaIE,7762
 pymmcore_plus/core/_metadata.py,sha256=3vb3d36XgNnUY44dpZ4Ccw0tvn4KCinZ8zrnDllmABI,2645
 pymmcore_plus/core/_mmcore_plus.py,sha256=8tjNxpSRfDLmYbNllLgJ2RVbKLpeUsOMb0hw-MPR9BI,91621
@@ -35,28 +35,28 @@ pymmcore_plus/experimental/unicore/devices/__init__.py,sha256=47DEQpj8HBSa-_TImW
 pymmcore_plus/experimental/unicore/devices/_device.py,sha256=PfX4BSpVMPXyNCNWkZ0Xy1-72ZZdME5zm7NgtCRu8ts,9751
 pymmcore_plus/experimental/unicore/devices/_properties.py,sha256=yqVyoXb3VSbHahN2mXOIgeKOS7pUQeiJIZ_Y2d55dTI,15387
 pymmcore_plus/experimental/unicore/devices/_stage.py,sha256=Ab4uibYq1cjIBtwcthCxH2FudGq9UMjub-qVeRpApQY,7892
-pymmcore_plus/mda/__init__.py,sha256=RXI4ubqV71lLTFVrj62UpGzXVwOOQfJSiXR0k5tRXdk,298
+pymmcore_plus/mda/__init__.py,sha256=7VH-MqOcuK1JNSOG9HhES6Ac-Z-LuT8a0f2xPbGEt7w,344
 pymmcore_plus/mda/_engine.py,sha256=m-GsTMCIX2CgyUZb32Cyp52fh3WcUW--evk_yLANu-E,29534
 pymmcore_plus/mda/_protocol.py,sha256=10CDJ9H57oX1z0oqK3eShXyQhufHvvu3_8wdaCYpPIg,3254
-pymmcore_plus/mda/_runner.py,sha256=IeZ34e4rcjRoPayCYJo_xn33yB4kPFltt23ntHE9TVI,16679
+pymmcore_plus/mda/_runner.py,sha256=NSOhpll6_WxDLO19FTs19dASJcHcOoVOCy7q_QzX_Ms,18523
 pymmcore_plus/mda/_thread_relay.py,sha256=Ww-9gyvLEzwRhnpL1dpze71wL7IRlhH8K3Q1dmJIxgs,6193
 pymmcore_plus/mda/events/__init__.py,sha256=rHTyhQZJ54dz-KtetvN22GvAY2ilR03x8v4H0qUR070,1191
 pymmcore_plus/mda/events/_protocol.py,sha256=9Q7LjYOgEWQGS8gHMV97UXM9bhoVW2OeyoPyNsQbwzw,1659
 pymmcore_plus/mda/events/_psygnal.py,sha256=TdN1mFGpTPXmEs9iwFKSC1svv87PDZkT2JZvl0tEGrQ,640
 pymmcore_plus/mda/events/_qsignals.py,sha256=tULQg-e_NX197DxJXaWHn1zLJ-4tzc9QyOAnsobEDtA,554
 pymmcore_plus/mda/handlers/_5d_writer_base.py,sha256=c9cA0n8DOBoZcy9asue5eV7jW8hFVC0XEewroFgDNHA,11925
-pymmcore_plus/mda/handlers/__init__.py,sha256=LdO3jf47fb4gXmbP9I8f5xC9Mrfd_-shf86OAaN9LdA,305
-pymmcore_plus/mda/handlers/_img_sequence_writer.py,sha256=fAj6CB90RXYJ2jJIRDFxZgQb-TfwuRPWGCPFopCijRI,11549
+pymmcore_plus/mda/handlers/__init__.py,sha256=TbgpRdcs3BRdCf6uXJlwo_IIbxM6xXaLocKK1pyhU2Q,1286
+pymmcore_plus/mda/handlers/_img_sequence_writer.py,sha256=XUJovvdWViTkn2VZr4XcovNIuBNZF4J4cCHIdwAs1WE,11639
 pymmcore_plus/mda/handlers/_ome_tiff_writer.py,sha256=pqqdl3KQd0tH5Gp4rHVgYqqh2Y8iwoKRXTjwq1JLy1E,6239
 pymmcore_plus/mda/handlers/_ome_zarr_writer.py,sha256=cKg3kJR7TId6M2qC1nJMLlxkv5vlfA5XEAlTIr9kt_E,12275
-pymmcore_plus/mda/handlers/_tensorstore_handler.py,sha256=_xaUkDEYoTO29u4iHPQK8ygcCy8CSCXYi1xu5QF8B8E,14829
+pymmcore_plus/mda/handlers/_tensorstore_handler.py,sha256=_Hqfgc2I8n97KPT7quU0p4tqSlomtLbTO-e78bIB6hA,15280
 pymmcore_plus/mda/handlers/_util.py,sha256=pZydpKAXtQ_gjq5x1yNK1D0hfS7NUL2nH9ivOBg4abc,1600
 pymmcore_plus/metadata/__init__.py,sha256=0o_v53kwR4U_RLlCnr7GD1G6OdFlVuUByIqXiaaM5uk,699
 pymmcore_plus/metadata/functions.py,sha256=EjwB-6UO8c8AUriawhbE7x6ZAR1vJAxc72iYqyes5PQ,12506
 pymmcore_plus/metadata/schema.py,sha256=j7nMwjCBXaAC0zKA2OsF201dsOB_3b2ggjqIa7EiVPQ,17368
 pymmcore_plus/metadata/serialize.py,sha256=hpXJm0tzILELf6OYECMg0sQhuf-h25ob6_DDl-TUUME,3805
 pymmcore_plus/model/__init__.py,sha256=zKZkkSpNK4ERu-VMdi9gvRrj1aXAjNaYxlYB5PdYSg0,479
-pymmcore_plus/model/_config_file.py,sha256=Cw3bF1DLQUbMXVz59ZEUjfSaXcw8Lz6StIagReIKB-k,13280
+pymmcore_plus/model/_config_file.py,sha256=nCAFh5dA7kYpoWTIwzoG4CHbdLwCYBBDGSOvZosFCFw,13711
 pymmcore_plus/model/_config_group.py,sha256=vL_-EWH-Nsb8xTgFqpYIFaJzBk_RDBFchBnQ61DMSvI,3407
 pymmcore_plus/model/_core_device.py,sha256=viwMgrCTZn1XYIyjC8w4xj1XAmoowZmCb93isGbG8BE,2722
 pymmcore_plus/model/_core_link.py,sha256=dsbT0gncfa3TAORSaWUrZR9rcI_nOLX9e5BTmyo-UYo,2737
@@ -64,8 +64,8 @@ pymmcore_plus/model/_device.py,sha256=-0s3NkonDoaMrNy_hn5EDz-c4o33ZiJSQkV_kdBteo
 pymmcore_plus/model/_microscope.py,sha256=69VV6cuevinOK_LhYEkQygHGesvCZefdn9YNt3mV618,11353
 pymmcore_plus/model/_pixel_size_config.py,sha256=smoOmT54nSkg52RaSQzTFG0YwyMR_SEq_lkS-JyJW9U,3514
 pymmcore_plus/model/_property.py,sha256=NQzNtnEzSCR9ogwx1cfi8X-qbJ_cBSJKdSBAaoKoPQ0,3720
-pymmcore_plus-0.13.1.dist-info/METADATA,sha256=TJaJKDATvzOOeJtqyDBP9Xsp1RZwLZQNM0TUdRvriEA,9594
-pymmcore_plus-0.13.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pymmcore_plus-0.13.1.dist-info/entry_points.txt,sha256=NtFyndrQzBpUNJyil-8e5hMGke2utAf7mkGavTLcLOY,51
-pymmcore_plus-0.13.1.dist-info/licenses/LICENSE,sha256=OHJjRpOPKKRc7FEnpehNWdR5LRBdBhUtIFG-ZI0dCEA,1522
-pymmcore_plus-0.13.1.dist-info/RECORD,,
+pymmcore_plus-0.13.2.dist-info/METADATA,sha256=4z6G5lpau1oQJUFSejzKr88yNTWOzStR50mRZvaN6IU,9594
+pymmcore_plus-0.13.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pymmcore_plus-0.13.2.dist-info/entry_points.txt,sha256=NtFyndrQzBpUNJyil-8e5hMGke2utAf7mkGavTLcLOY,51
+pymmcore_plus-0.13.2.dist-info/licenses/LICENSE,sha256=OHJjRpOPKKRc7FEnpehNWdR5LRBdBhUtIFG-ZI0dCEA,1522
+pymmcore_plus-0.13.2.dist-info/RECORD,,