pymmcore-plus 0.13.3__tar.gz → 0.13.5__tar.gz

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymmcore-plus
-Version: 0.13.3
+Version: 0.13.5
 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
@@ -30,10 +30,10 @@ Requires-Dist: platformdirs>=3.0.0
 Requires-Dist: psygnal>=0.7
 Requires-Dist: pymmcore>=10.7.0.71.0
 Requires-Dist: rich>=10.2.0
-Requires-Dist: tensorstore; python_version < '3.13'
+Requires-Dist: tensorstore<=0.1.71
 Requires-Dist: typer>=0.4.2
 Requires-Dist: typing-extensions
-Requires-Dist: useq-schema>=0.6.2
+Requires-Dist: useq-schema>=0.7.0
 Provides-Extra: cli
 Requires-Dist: rich>=10.2.0; extra == 'cli'
 Requires-Dist: typer>=0.4.2; extra == 'cli'
@@ -99,7 +99,7 @@ environments**.
   [CMMCorePlus
   documentation](https://pymmcore-plus.github.io/pymmcore-plus/api/cmmcoreplus/)
   for details.
-- `pymmcore-plus` includes an [acquisition engine](https://pymmcore-plus.github.io/pymmcore-plus/guides/mda_engine/) 
+- `pymmcore-plus` includes an [acquisition engine](https://pymmcore-plus.github.io/pymmcore-plus/guides/mda_engine/)
   that drives micro-manager for conventional multi-dimensional experiments. It accepts an
   [MDASequence](https://pymmcore-plus.github.io/useq-schema/schema/sequence/)
   from [useq-schema](https://pymmcore-plus.github.io/useq-schema/) for
@@ -112,7 +112,7 @@ environments**.
 
 ## Documentation
 
-https://pymmcore-plus.github.io/pymmcore-plus/
+<https://pymmcore-plus.github.io/pymmcore-plus/>
 
 ## Why not just use `pymmcore` directly?
 
@@ -139,20 +139,22 @@ python users are accustomed to. This library:
 
 ## How does this relate to `Pycro-Manager`?
 
-[Pycro-Manager](https://github.com/micro-manager/pycro-manager) is an impressive
-library written by Henry Pinkard designed to make it easier to work with and
-control the Java Micro-manager application using python. As such, it requires
-Java to be installed and running in the background (either via the micro-manager
-GUI application directly, or via a headless process). The python half
-communicates with the Java half using ZeroMQ messaging.
+[Pycro-Manager](https://github.com/micro-manager/pycro-manager) is designed to
+make it easier to work with and control the Java Micro-manager application
+(MMStudio) using python. As such, it requires Java to be installed and for
+MMStudio to be running a server in another process. The python half communicates
+with the Java half using ZeroMQ messaging.
 
 **In brief**: while `Pycro-Manager` provides a python API to control the Java
 Micro-manager application (which in turn controls the C++ core), `pymmcore-plus`
 provides a python API to control the C++ core directly, without the need for
-Java in the loop.  Each has its own advantages and disadvantages!  With
-pycro-manager you immediately get the entire existing micro-manager ecosystem
-and GUI application. With pymmcore-plus you don't need to install Java, and you
-have direct access to the memory buffers used by the C++ core.
+Java in the loop. Each has its own advantages and disadvantages! With
+pycro-manager you retain the entire existing micro-manager ecosystem
+and GUI application. With pymmcore-plus, the entire thing is python: you
+don't need to install Java, and you have direct access to the memory buffers
+used by the C++ core.  Work on recreating the gui application in python
+being done in [`pymmcore-widgets`](https://github.com/pymmcore-plus/pymmcore-widgets)
+and [`pymmcore-gui`](https://github.com/pymmcore-plus/pymmcore-gui).
 
 ## Quickstart
 
@@ -191,7 +193,7 @@ mmcore install
 
 (you can also download these manually from [micro-manager.org](https://micro-manager.org/Micro-Manager_Nightly_Builds))
 
-_See [installation documentation ](https://pymmcore-plus.github.io/pymmcore-plus/install/) for more details._
+_See [installation documentation](https://pymmcore-plus.github.io/pymmcore-plus/install/) for more details._
 
 ### Usage
 

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/README.md

@@ -22,7 +22,7 @@ environments**.
   [CMMCorePlus
   documentation](https://pymmcore-plus.github.io/pymmcore-plus/api/cmmcoreplus/)
   for details.
-- `pymmcore-plus` includes an [acquisition engine](https://pymmcore-plus.github.io/pymmcore-plus/guides/mda_engine/) 
+- `pymmcore-plus` includes an [acquisition engine](https://pymmcore-plus.github.io/pymmcore-plus/guides/mda_engine/)
   that drives micro-manager for conventional multi-dimensional experiments. It accepts an
   [MDASequence](https://pymmcore-plus.github.io/useq-schema/schema/sequence/)
   from [useq-schema](https://pymmcore-plus.github.io/useq-schema/) for
@@ -35,7 +35,7 @@ environments**.
 
 ## Documentation
 
-https://pymmcore-plus.github.io/pymmcore-plus/
+<https://pymmcore-plus.github.io/pymmcore-plus/>
 
 ## Why not just use `pymmcore` directly?
 
@@ -62,20 +62,22 @@ python users are accustomed to. This library:
 
 ## How does this relate to `Pycro-Manager`?
 
-[Pycro-Manager](https://github.com/micro-manager/pycro-manager) is an impressive
-library written by Henry Pinkard designed to make it easier to work with and
-control the Java Micro-manager application using python. As such, it requires
-Java to be installed and running in the background (either via the micro-manager
-GUI application directly, or via a headless process). The python half
-communicates with the Java half using ZeroMQ messaging.
+[Pycro-Manager](https://github.com/micro-manager/pycro-manager) is designed to
+make it easier to work with and control the Java Micro-manager application
+(MMStudio) using python. As such, it requires Java to be installed and for
+MMStudio to be running a server in another process. The python half communicates
+with the Java half using ZeroMQ messaging.
 
 **In brief**: while `Pycro-Manager` provides a python API to control the Java
 Micro-manager application (which in turn controls the C++ core), `pymmcore-plus`
 provides a python API to control the C++ core directly, without the need for
-Java in the loop.  Each has its own advantages and disadvantages!  With
-pycro-manager you immediately get the entire existing micro-manager ecosystem
-and GUI application. With pymmcore-plus you don't need to install Java, and you
-have direct access to the memory buffers used by the C++ core.
+Java in the loop. Each has its own advantages and disadvantages! With
+pycro-manager you retain the entire existing micro-manager ecosystem
+and GUI application. With pymmcore-plus, the entire thing is python: you
+don't need to install Java, and you have direct access to the memory buffers
+used by the C++ core.  Work on recreating the gui application in python
+being done in [`pymmcore-widgets`](https://github.com/pymmcore-plus/pymmcore-widgets)
+and [`pymmcore-gui`](https://github.com/pymmcore-plus/pymmcore-gui).
 
 ## Quickstart
 
@@ -114,7 +116,7 @@ mmcore install
 
 (you can also download these manually from [micro-manager.org](https://micro-manager.org/Micro-Manager_Nightly_Builds))
 
-_See [installation documentation ](https://pymmcore-plus.github.io/pymmcore-plus/install/) for more details._
+_See [installation documentation](https://pymmcore-plus.github.io/pymmcore-plus/install/) for more details._
 
 ### Usage
 

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/pyproject.toml

@@ -39,9 +39,10 @@ dependencies = [
     "numpy >=1.17.3",
     "psygnal >=0.7",
     "pymmcore >=10.7.0.71.0",
-    "typing-extensions",                    # not actually required at runtime
-    "useq-schema >=0.6.2",
-    "tensorstore; python_version < '3.13'",
+    "typing-extensions",      # not actually required at runtime
+    "useq-schema >=0.7.0",
+    # until https://github.com/google/tensorstore/issues/217 is resolved
+    "tensorstore <= 0.1.71",
     # cli requirements included by default for now
     "typer >=0.4.2",
     "rich >=10.2.0",

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/src/pymmcore_plus/_cli.py

@@ -289,7 +289,7 @@ def run(
         mda.setdefault("channels", []).append(_c)
     if channel_group is not None:
         for c in mda.get("channels", []):
-            cast(dict, c)["group"] = channel_group
+            cast("dict", c)["group"] = channel_group
 
     # this will raise if anything has gone wrong.
     _mda = MDASequence(**mda)

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/src/pymmcore_plus/_pymmcore.py

@@ -5,8 +5,10 @@ try:
     from pymmcore_nano import __version__
 
     BACKEND = "pymmcore-nano"
+    NANO = True
 except ImportError:
     from pymmcore import *  # noqa F403
     from pymmcore import __version__  # noqa F401
 
     BACKEND = "pymmcore"
+    NANO = False

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/src/pymmcore_plus/core/_metadata.py

@@ -20,8 +20,7 @@ class Metadata(pymmcore.Metadata):
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__()
         if args and isinstance(args[0], Mapping):
-            for k, v in args[0].items():
-                self[k] = v
+            kwargs = {**args[0], **kwargs}
         for k, v in kwargs.items():
             self[k] = v
 
@@ -76,15 +75,19 @@ class Metadata(pymmcore.Metadata):
         return json.dumps(dict(self))
 
     def keys(self) -> KeysView[str]:
-        return cast(KeysView, metadata_keys(self))
+        return cast("KeysView", metadata_keys(self))
 
     def items(self) -> ItemsView[str, str]:
-        return cast(ItemsView, metadata_items(self))
+        return cast("ItemsView", metadata_items(self))
 
     def values(self) -> ValuesView[str]:
-        return cast(ValuesView, metadata_values(self))
+        return cast("ValuesView", metadata_values(self))
 
 
 metadata_keys = new_class("metadata_keys", (KeysView,), {})
 metadata_items = new_class("metadata_items", (ItemsView,), {})
 metadata_values = new_class("metadata_values", (ValuesView,), {})
+
+# Register the new classes with the `collections.abc` module
+# so that isistance() works as expected.
+Mapping.register(Metadata)

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/src/pymmcore_plus/core/_mmcore_plus.py

@@ -13,7 +13,7 @@ from pathlib import Path
 from re import Pattern
 from textwrap import dedent
 from threading import Thread
-from typing import TYPE_CHECKING, Any, Callable, NamedTuple, TypeVar, overload
+from typing import TYPE_CHECKING, Any, Callable, NamedTuple, TypeVar, cast, overload
 
 from psygnal import SignalInstance
 
@@ -221,7 +221,13 @@ class CMMCorePlus(pymmcore.CMMCore):
             self.setPrimaryLogFile(str(logfile))
             logger.debug("Initialized core %s", self)
 
-        self._last_config: str | None = None  # last loaded config file
+        # some internal state, remembering the last arguments passed to various
+        # functions.  These are subject to change: do not depend on externally
+        self._last_sys_config: str | None = None  # last loaded config file
+        self._last_config: tuple[str, str] = ("", "")
+        # last position set by setXYPosition, None means currentXYStageDevice
+        self._last_xy_position: dict[str | None, tuple[float, float]] = {}
+
         self._mm_path = mm_path or find_micromanager()
         if not adapter_paths and self._mm_path:
             adapter_paths = [self._mm_path]
@@ -399,15 +405,15 @@ class CMMCorePlus(pymmcore.CMMCore):
             fpath = Path(self._mm_path) / fileName
         if not fpath.exists():
             raise FileNotFoundError(f"Path does not exist: {fpath}")
-        self._last_config = str(fpath.resolve())
-        super().loadSystemConfiguration(self._last_config)
+        self._last_sys_config = str(fpath.resolve())
+        super().loadSystemConfiguration(self._last_sys_config)
 
     def systemConfigurationFile(self) -> str | None:
         """Return the path to the last loaded system configuration file, or `None`.
 
         :sparkles: *This method is new in `CMMCorePlus`.*
         """
-        return self._last_config
+        return self._last_sys_config
 
     def unloadAllDevices(self) -> None:
         """Unload all devices from the core and reset all configuration data.
@@ -642,10 +648,7 @@ class CMMCorePlus(pymmcore.CMMCore):
             img = super().getLastImageMD(channel, slice, md)
         else:
             img = super().getLastImageMD(md)
-        return (
-            self.fixImage(img) if fix and pymmcore.BACKEND == "pymmcore" else img,
-            md,
-        )
+        return (self.fixImage(img) if fix and not pymmcore.NANO else img, md)
 
     @overload
     def popNextImageAndMD(
@@ -687,11 +690,7 @@ class CMMCorePlus(pymmcore.CMMCore):
         """
         md = Metadata()
         img = super().popNextImageMD(channel, slice, md)
-        md = Metadata(md)
-        return (
-            self.fixImage(img) if fix and pymmcore.BACKEND == "pymmcore" else img,
-            md,
-        )
+        return (self.fixImage(img) if fix and not pymmcore.NANO else img, md)
 
     def popNextImage(self, *, fix: bool = True) -> np.ndarray:
         """Gets and removes the next image from the circular buffer.
@@ -707,7 +706,7 @@ class CMMCorePlus(pymmcore.CMMCore):
             will be reshaped to (w, h, n_components) using `fixImage`.
         """
         img: np.ndarray = super().popNextImage()
-        return self.fixImage(img) if fix and pymmcore.BACKEND == "pymmcore" else img
+        return self.fixImage(img) if fix and not pymmcore.NANO else img
 
     def getNBeforeLastImageAndMD(
         self, n: int, *, fix: bool = True
@@ -735,7 +734,7 @@ class CMMCorePlus(pymmcore.CMMCore):
         """
         md = Metadata()
         img = super().getNBeforeLastImageMD(n, md)
-        return self.fixImage(img) if fix and pymmcore.BACKEND == "pymmcore" else img, md
+        return self.fixImage(img) if fix and not pymmcore.NANO else img, md
 
     def setConfig(self, groupName: str, configName: str) -> None:
         """Applies a configuration to a group.
@@ -747,6 +746,7 @@ class CMMCorePlus(pymmcore.CMMCore):
         """
         super().setConfig(groupName, configName)
         self.events.configSet.emit(groupName, configName)
+        self._last_config = (groupName, configName)
 
     # NEW methods
 
@@ -1348,6 +1348,25 @@ class CMMCorePlus(pymmcore.CMMCore):
         self.waitForDevice(self.getXYStageDevice())
         self.waitForDevice(self.getFocusDevice())
 
+    @overload
+    def setXYPosition(self, x: float, y: float, /) -> None: ...
+    @overload
+    def setXYPosition(self, xyStageLabel: str, x: float, y: float, /) -> None: ...
+    def setXYPosition(self, *args: str | float) -> None:
+        """Sets the position of the XY stage in microns.
+
+        **Why Override?** to store the last commanded stage position internally.
+        """
+        if len(args) == 2:
+            label: str | None = None
+            x, y = cast("tuple[float, float]", args)
+        elif len(args) == 3:
+            label, x, y = args  # type: ignore
+        else:
+            raise ValueError("Invalid number of arguments. Expected 2 or 3.")
+        super().setXYPosition(*args)  # type: ignore
+        self._last_xy_position[label] = (x, y)
+
     def getZPosition(self) -> float:
         """Obtains the current position of the Z axis of the Z stage in microns.
 
@@ -1668,7 +1687,7 @@ class CMMCorePlus(pymmcore.CMMCore):
             if numChannel is not None
             else super().getImage()
         )
-        return self.fixImage(img) if fix and pymmcore.BACKEND == "pymmcore" else img
+        return self.fixImage(img) if fix and not pymmcore.NANO else img
 
     def startContinuousSequenceAcquisition(self, intervalMs: float = 0) -> None:
         """Start a ContinuousSequenceAcquisition.

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/src/pymmcore_plus/core/events/__init__.py

@@ -6,7 +6,7 @@ from ._protocol import PCoreSignaler
 from ._psygnal import CMMCoreSignaler
 
 if TYPE_CHECKING:
-    from ._qsignals import QCoreSignaler  # noqa: TC004
+    from ._qsignals import QCoreSignaler
 
 
 __all__ = [

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/src/pymmcore_plus/experimental/unicore/_unicore.py

@@ -654,7 +654,7 @@ def _ensure_label(
     if len(args) < min_args:
         # we didn't get the label
         return getter(), args
-    return cast(str, args[0]), args[1:]
+    return cast("str", args[0]), args[1:]
 
 
 class PropertyStateCache(MutableMapping[tuple[str, str], Any]):

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/src/pymmcore_plus/experimental/unicore/devices/_properties.py

@@ -173,7 +173,7 @@ class PropertyController(Generic[TDev, TProp]):
                     f"of property {self.property.name!r}: {self.property.limits}."
                 ) from e
             min_, max_ = self.property.limits
-            if not min_ <= cast(float, value) <= max_:
+            if not min_ <= cast("float", value) <= max_:
                 raise ValueError(
                     f"Value {value!r} is not within the allowed range of property "
                     f"{self.property.name!r}: {self.property.limits}."

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/src/pymmcore_plus/mda/_engine.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Literal, NamedTuple, cast
 
 import numpy as np
 import useq
-from useq import HardwareAutofocus, MDAEvent, MDASequence
+from useq import AcquireImage, HardwareAutofocus, MDAEvent, MDASequence
 
 from pymmcore_plus._logger import logger
 from pymmcore_plus._util import retry
@@ -72,6 +72,10 @@ class MDAEngine(PMDAEngine):
     def __init__(self, mmc: CMMCorePlus, use_hardware_sequencing: bool = True) -> None:
         self._mmc = mmc
         self.use_hardware_sequencing: bool = use_hardware_sequencing
+        # if True, always set XY position, even if the commanded position is the same
+        # as the last commanded position (this does *not* query the stage for the
+        # current position).
+        self.force_set_xy_position: bool = True
 
         # whether to include position metadata when fetching on-frame metadata
         # omitted by default when performing triggered acquisition because it's slow.
@@ -92,6 +96,9 @@ class MDAEngine(PMDAEngine):
         # Note: getAutoShutter() is True when no config is loaded at all
         self._autoshutter_was_set: bool = self._mmc.getAutoShutter()
 
+        self._last_config: tuple[str, str] = ("", "")
+        self._last_xy_pos: tuple[float | None, float | None] = (None, None)
+
         # -----
         # The following values are stored during setup_sequence simply to speed up
         # retrieval of metadata during each frame.
@@ -195,6 +202,13 @@ class MDAEngine(PMDAEngine):
                 )
             return
 
+        # don't try to execute any other action types. Mostly, this is just
+        # CustomAction, which is a user-defined action that the engine doesn't know how
+        # to handle.  But may include other actions in the future, and this ensures
+        # backwards compatibility.
+        if not isinstance(action, (AcquireImage, type(None))):
+            return
+
         # if the autofocus was engaged at the start of the sequence AND autofocus action
         # did not fail, re-engage it. NOTE: we need to do that AFTER the runner calls
         # `setup_event`, so we can't do it inside the exec_event autofocus action above.
@@ -231,18 +245,15 @@ class MDAEngine(PMDAEngine):
         if event.keep_shutter_open:
             ...
 
-        if event.x_pos is not None or event.y_pos is not None:
-            self._set_event_position(event)
+        self._set_event_xy_position(event)
+
         if event.z_pos is not None:
             self._set_event_z(event)
         if event.slm_image is not None:
             self._set_event_slm_image(event)
-        if event.channel is not None:
-            try:
-                # possible speedup by setting manually.
-                self._mmc.setConfig(event.channel.group, event.channel.config)
-            except Exception as e:
-                logger.warning("Failed to set channel. %s", e)
+
+        self._set_event_channel(event)
+
         if event.exposure is not None:
             try:
                 self._mmc.setExposure(event.exposure)
@@ -406,11 +417,7 @@ class MDAEngine(PMDAEngine):
         # the call below, we won't be able to query `core.getCurrentConfig()`
         # not sure that's necessary; and this is here for tests to pass for now,
         # but this could be removed.
-        if event.channel is not None:
-            try:
-                core.setConfig(event.channel.group, event.channel.config)
-            except Exception as e:
-                logger.warning("Failed to set channel. %s", e)
+        self._set_event_channel(event)
 
         if event.slm_image:
             self._set_event_slm_image(event)
@@ -423,8 +430,8 @@ class MDAEngine(PMDAEngine):
         # start sequences or set non-sequenced values
         if event.x_sequence:
             core.startXYStageSequence(core.getXYStageDevice())
-        elif event.x_pos is not None or event.y_pos is not None:
-            self._set_event_position(event)
+        else:
+            self._set_event_xy_position(event)
 
         if event.z_sequence:
             core.startStageSequence(core.getFocusDevice())
@@ -587,15 +594,51 @@ class MDAEngine(PMDAEngine):
 
         return _perform_full_focus(self._mmc.getZPosition())
 
-    def _set_event_position(self, event: MDAEvent) -> None:
+    def _set_event_xy_position(self, event: MDAEvent) -> None:
+        event_x, event_y = event.x_pos, event.y_pos
+        # If neither coordinate is provided, do nothing.
+        if event_x is None and event_y is None:
+            return
+
         # skip if no XY stage device is found
         if not self._mmc.getXYStageDevice():
             logger.warning("No XY stage device found. Cannot set XY position.")
             return
 
-        x = event.x_pos if event.x_pos is not None else self._mmc.getXPosition()
-        y = event.y_pos if event.y_pos is not None else self._mmc.getYPosition()
-        self._mmc.setXYPosition(x, y)
+        # Retrieve the last commanded XY position.
+        last_x, last_y = self._mmc._last_xy_position.get(None) or (None, None)  # noqa: SLF001
+        if (
+            not self.force_set_xy_position
+            and (event_x is None or event_x == last_x)
+            and (event_y is None or event_y == last_y)
+        ):
+            return
+
+        if event_x is None or event_y is None:
+            cur_x, cur_y = self._mmc.getXYPosition()
+            event_x = cur_x if event_x is None else event_x
+            event_y = cur_y if event_y is None else event_y
+
+        try:
+            self._mmc.setXYPosition(event_x, event_y)
+        except Exception as e:
+            logger.warning("Failed to set XY position. %s", e)
+
+    def _set_event_channel(self, event: MDAEvent) -> None:
+        if (ch := event.channel) is None:
+            return
+
+        # comparison with _last_config is a fast/rough check ... which may miss subtle
+        # differences if device properties have been individually set in the meantime.
+        # could also compare to the system state, with:
+        # data = self._mmc.getConfigData(ch.group, ch.config)
+        # if self._mmc.getSystemStateCache().isConfigurationIncluded(data):
+        #     ...
+        if (ch.group, ch.config) != self._mmc._last_config:  # noqa: SLF001
+            try:
+                self._mmc.setConfig(ch.group, ch.config)
+            except Exception as e:
+                logger.warning("Failed to set channel. %s", e)
 
     def _set_event_z(self, event: MDAEvent) -> None:
         # skip if no Z stage device is found

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/src/pymmcore_plus/mda/events/__init__.py

@@ -8,7 +8,7 @@ from ._protocol import PMDASignaler
 from ._psygnal import MDASignaler
 
 if TYPE_CHECKING:
-    from ._qsignals import QMDASignaler  # noqa: TC004
+    from ._qsignals import QMDASignaler
 
 
 __all__ = [

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/src/pymmcore_plus/mda/handlers/_tensorstore_handler.py

@@ -302,7 +302,7 @@ class TensorStoreHandler:
 
         # HACK
         if self.ts_driver == "zarr":
-            meta = cast(dict, spec.setdefault("metadata", {}))
+            meta = cast("dict", spec.setdefault("metadata", {}))
             if "dimension_separator" not in meta:
                 meta["dimension_separator"] = "/"
         return spec

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/src/pymmcore_plus/seq_tester.py

@@ -88,8 +88,8 @@ class Setting:
 
     @classmethod
     def _from_list(cls, val: list) -> Self:
-        (dev, prop), (typ, val) = val
-        return cls(dev, prop, typ, val)
+        (dev, prop), (type_, val) = val
+        return cls(dev, prop, type_, val)
 
 
 @dataclass
@@ -100,8 +100,8 @@ class SettingEvent(Setting):
 
     @classmethod
     def _from_list(cls, val: list) -> Self:
-        (dev, prop), (typ, val), count = val
-        return cls(dev, prop, typ, val, count)
+        (dev, prop), (type_, val), count = val
+        return cls(dev, prop, type_, val, count)
 
 
 @dataclass

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/tests/test_cli.py

@@ -208,7 +208,7 @@ def test_run_mda(tmp_path: Path, with_file: bool, args: dict[str, dict | str]) -
             # otherwise it updates the existing
             else:
                 _data = seq.model_dump() if hasattr(seq, "model_dump") else seq.dict()
-                sub_field = cast(dict, _data[field_name])
+                sub_field = cast("dict", _data[field_name])
                 sub_field.update(**val)
                 newval = getattr(MDASequence(**{field_name: sub_field}), field_name)
                 seq = seq.replace(**{field_name: newval})

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/tests/test_core.py

@@ -1,5 +1,6 @@
 import os
 import re
+from collections.abc import Mapping
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable
 from unittest.mock import MagicMock, call, patch
@@ -339,18 +340,28 @@ def test_new_metadata():
     assert isinstance(md, pymmcore.Metadata)
 
 
-def test_md_(core: CMMCorePlus) -> None:
+def test_get_image_and_meta(core: CMMCorePlus) -> None:
     core.startContinuousSequenceAcquisition(10)
     core.stopSequenceAcquisition()
 
     image, md = core.getNBeforeLastImageAndMD(0)
-    assert isinstance(image, np.ndarray) and isinstance(md, Metadata)
+    assert isinstance(image, np.ndarray)
+    assert isinstance(md, Metadata)
+    assert "TimeReceivedByCore" in md
 
     image, md = core.getLastImageAndMD()
-    assert isinstance(image, np.ndarray) and isinstance(md, Metadata)
+    assert isinstance(image, np.ndarray)
+    assert isinstance(md, Metadata)
+    assert "TimeReceivedByCore" in md
 
     image, md = core.popNextImageAndMD()
-    assert isinstance(image, np.ndarray) and isinstance(md, Metadata)
+    assert isinstance(image, np.ndarray)
+    assert isinstance(md, Metadata)
+    assert "TimeReceivedByCore" in md
+
+    assert Metadata(md) == md
+    assert isinstance(md, Mapping)
+    assert issubclass(Metadata, Mapping)
 
 
 def test_configuration(core: CMMCorePlus) -> None:

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/tests/test_mda.py

@@ -490,3 +490,9 @@ def test_get_handlers(core: CMMCorePlus) -> None:
     # but they should have been available during start and finish events
     assert on_start_names == ["TensorStoreHandler"]
     assert on_finish_names == ["TensorStoreHandler"]
+
+
+def test_custom_action(core: CMMCorePlus) -> None:
+    """Make sure we can handle custom actions gracefully"""
+
+    core.mda.run([MDAEvent(action=useq.CustomAction())])

{pymmcore_plus-0.13.3 → pymmcore_plus-0.13.5}/tests/test_sequencing.py

@@ -42,6 +42,7 @@ def test_sequenced_mda(core: CMMCorePlus) -> None:
     engine = MDAEngine(mmc=core_mock)
 
     engine.use_hardware_sequencing = False
+    engine.force_set_xy_position = False
     assert len(list(engine.event_iterator(mda))) == NLOOPS * 2 * 2
 
     engine.use_hardware_sequencing = True
@@ -66,7 +67,7 @@ def test_sequenced_mda(core: CMMCorePlus) -> None:
     expected_exposure = [call(5), call(10)] * 2
     assert core_mock.setExposure.call_args_list == expected_exposure
 
-    expected_pos = [call(0, 0), call(0, 0), call(1, 1), call(1, 1)]
+    expected_pos = [call(0, 0), call(1, 1)]
     assert core_mock.setXYPosition.call_args_list == expected_pos