pymmcore-plus 0.13.4__py3-none-any.whl → 0.13.6__py3-none-any.whl

pymmcore_plus/_cli.py

@@ -8,6 +8,7 @@ from contextlib import suppress
 from pathlib import Path
 from typing import Optional, Union, cast
 
+from pymmcore_plus._util import get_device_interface_version
 from pymmcore_plus.core._device import Device
 from pymmcore_plus.core._mmcore_plus import CMMCorePlus
 
@@ -114,9 +115,15 @@ def _list() -> None:
         for parent, items in found.items():
             print(f":file_folder:[bold green] {parent}")
             for item in items:
+                version = ""
+                for _lib in (parent / item).glob("*_dal_*"):
+                    with suppress(Exception):
+                        div = get_device_interface_version(_lib)
+                        version = f" (Dev. Interface {div})"
+                        break
                 bullet = "   [bold yellow]*" if first else "   •"
                 using = " [bold blue](active)" if first else ""
-                print(f"{bullet} [cyan]{item}{using}")
+                print(f"{bullet} [cyan]{item}{version}{using}")
                 first = False
     else:
         print(":x: [bold red]There are no pymmcore-plus Micro-Manager files.")
@@ -157,7 +164,7 @@ def install(
         help="Installation directory.",
     ),
     release: str = typer.Option(
-        "latest", "-r", "--release", help="Release date. e.g. 20210201"
+        "latest-compatible", "-r", "--release", help="Release date. e.g. 20210201"
     ),
     plain_output: bool = typer.Option(
         False,
@@ -289,7 +296,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/_pymmcore.py

@@ -1,12 +1,30 @@
 """Internal module to choose between pymmcore and pymmcore-nano."""
 
+import re
+from typing import NamedTuple
+
 try:
     from pymmcore_nano import *  # noqa F403
     from pymmcore_nano import __version__
 
     BACKEND = "pymmcore-nano"
+    NANO = True
 except ImportError:
     from pymmcore import *  # noqa F403
-    from pymmcore import __version__  # noqa F401
+    from pymmcore import __version__
 
     BACKEND = "pymmcore"
+    NANO = False
+
+
+class VersionInfo(NamedTuple):
+    """Version info for the backend."""
+
+    major: int
+    minor: int
+    micro: int
+    device_interface: int
+    build: int
+
+
+version_info = VersionInfo(*(int(x) for x in re.findall(r"\d+", __version__)))

pymmcore_plus/_util.py

@@ -94,7 +94,7 @@ def find_micromanager(return_first: bool = True) -> str | None | list[str]:
     """
     from ._logger import logger
 
-    # we use a dict here to avoid duplicates
+    # we use a dict here to avoid duplicates, while retaining order
     full_list: dict[str, None] = {}
 
     # environment variable takes precedence
@@ -114,13 +114,42 @@ def find_micromanager(return_first: bool = True) -> str | None | list[str]:
                 return path
             full_list[path] = None
 
+    # then look for mm-device-adapters
+    with suppress(ImportError):
+        import mm_device_adapters
+
+        from . import _pymmcore
+
+        mm_dev_div = mm_device_adapters.__version__.split(".")[0]
+        pymm_div = str(_pymmcore.version_info.device_interface)
+
+        if pymm_div != mm_dev_div:  # pragma: no cover
+            warnings.warn(
+                "mm-device-adapters installed, but its device interface "
+                f"version ({mm_dev_div}) "
+                f"does not match the device interface version of {_pymmcore.BACKEND}"
+                f"({pymm_div}). You may wish to run"
+                f" `pip install --force-reinstall mm-device-adapters=={pymm_div}`. "
+                "mm-device-adapters will be ignored.",
+                stacklevel=2,
+            )
+        else:
+            path = mm_device_adapters.device_adapter_path()
+            if return_first:
+                logger.debug("using MM path from mm-device-adapters: %s", path)
+                return str(path)
+            full_list[path] = None
+
     # then look in user_data_dir
     _folders = (p for p in USER_DATA_MM_PATH.glob("Micro-Manager*") if p.is_dir())
-    user_install = sorted(_folders, reverse=True)
-    if user_install:
-        if return_first:
-            logger.debug("using MM path from user install: %s", user_install[0])
-            return str(user_install[0])
+    if user_install := sorted(_folders, reverse=True):
+        if return_first and (
+            first := next(
+                (x for x in user_install if _mm_path_has_compatible_div(x)), None
+            )
+        ):
+            logger.debug("using MM path from user install: %s", first)
+            return str(first)
         for x in user_install:
             full_list[str(x)] = None
 
@@ -130,9 +159,13 @@ def find_micromanager(return_first: bool = True) -> str | None | list[str]:
         p for p in PYMMCORE_PLUS_PATH.glob(f"**/Micro-Manager*{sfx}") if p.is_dir()
     ]
     if local_install:
-        if return_first:
-            logger.debug("using MM path from local install: %s", local_install[0])
-            return str(local_install[0])
+        if return_first and (
+            first := next(
+                (x for x in local_install if _mm_path_has_compatible_div(x)), None
+            )
+        ):  # pragma: no cover
+            logger.debug("using MM path from local install: %s", first)
+            return str(first)
         for x in local_install:
             full_list[str(x)] = None
 
@@ -153,8 +186,9 @@ def find_micromanager(return_first: bool = True) -> str | None | list[str]:
                 "could not find micromanager directory. Please run 'mmcore install'"
             )
             return None
-        logger.debug("using MM path found in applications: %s", pth)
-        return str(pth)
+        if _mm_path_has_compatible_div(pth):  # pragma: no cover
+            logger.debug("using MM path found in applications: %s", pth)
+            return str(pth)
     if pth is not None:
         full_list[str(pth)] = None
     return list(full_list)
@@ -229,15 +263,15 @@ def _qt_app_is_running() -> bool:
     return False  # pragma: no cover
 
 
-MMCORE_PLUS_SIGNALS_BACKEND = "MMCORE_PLUS_SIGNALS_BACKEND"
+PYMM_SIGNALS_BACKEND = "PYMM_SIGNALS_BACKEND"
 
 
 def signals_backend() -> Literal["qt", "psygnal"]:
     """Return the name of the event backend to use."""
-    env_var = os.environ.get(MMCORE_PLUS_SIGNALS_BACKEND, "auto").lower()
+    env_var = os.environ.get(PYMM_SIGNALS_BACKEND, "auto").lower()
     if env_var not in {"qt", "psygnal", "auto"}:
         warnings.warn(
-            f"{MMCORE_PLUS_SIGNALS_BACKEND} must be one of ['qt', 'psygnal', 'auto']. "
+            f"{PYMM_SIGNALS_BACKEND} must be one of ['qt', 'psygnal', 'auto']. "
             f"not: {env_var!r}. Using 'auto'.",
             stacklevel=1,
         )
@@ -250,7 +284,7 @@ def signals_backend() -> Literal["qt", "psygnal"]:
         if qt_app_running or list(_imported_qt_modules()):
             return "qt"
         warnings.warn(
-            f"{MMCORE_PLUS_SIGNALS_BACKEND} set to 'qt', but no Qt app is running. "
+            f"{PYMM_SIGNALS_BACKEND} set to 'qt', but no Qt app is running. "
             "Falling back to 'psygnal'.",
             stacklevel=1,
         )
@@ -618,3 +652,34 @@ def timestamp() -> str:
     with suppress(Exception):
         now = now.astimezone()
     return now.isoformat()
+
+
+def get_device_interface_version(lib_path: str | Path) -> int:
+    """Return the device interface version from the given library path."""
+    import ctypes
+
+    if sys.platform.startswith("win"):
+        lib = ctypes.WinDLL(lib_path)
+    else:
+        lib = ctypes.CDLL(lib_path)
+
+    try:
+        func = lib.GetDeviceInterfaceVersion
+    except AttributeError:
+        raise RuntimeError(
+            f"Function 'GetDeviceInterfaceVersion' not found in {lib_path}"
+        ) from None
+
+    func.restype = ctypes.c_long
+    func.argtypes = []
+    return func()  # type: ignore[no-any-return]
+
+
+def _mm_path_has_compatible_div(folder: Path | str) -> bool:
+    from . import _pymmcore
+
+    div = _pymmcore.version_info.device_interface
+    for lib_path in Path(folder).glob("*mmgr_dal*"):
+        with suppress(Exception):
+            return get_device_interface_version(lib_path) == div
+    return False  # pragma: no cover

pymmcore_plus/core/_constants.py

@@ -94,6 +94,14 @@ class CFGCommand(str, Enum):
     PixelSizeAffine = pymmcore.g_CFGCommand_PixelSizeAffine
     ParentID = pymmcore.g_CFGCommand_ParentID
     FocusDirection = pymmcore.g_CFGCommand_FocusDirection
+
+    if hasattr(pymmcore, "g_CFGCommand_PixelSizedxdz"):
+        PixelSize_dxdz = pymmcore.g_CFGCommand_PixelSizedxdz
+    if hasattr(pymmcore, "g_CFGCommand_PixelSizedydz"):
+        PixelSize_dydz = pymmcore.g_CFGCommand_PixelSizedydz
+    if hasattr(pymmcore, "g_CFGCommand_PixelSizeOptimalZUm"):
+        PixelSize_OptimalZUm = pymmcore.g_CFGCommand_PixelSizeOptimalZUm
+
     #
     FieldDelimiters = pymmcore.g_FieldDelimiters
 

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/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
 
@@ -207,21 +207,52 @@ class CMMCorePlus(pymmcore.CMMCore):
 
     def __init__(self, mm_path: str | None = None, adapter_paths: Sequence[str] = ()):
         super().__init__()
+        if os.getenv("PYMM_DEBUG_LOG", "0").lower() in ("1", "true"):
+            self.enableDebugLog(True)
+        if os.getenv("PYMM_STDERR_LOG", "0").lower() in ("1", "true"):
+            self.enableStderrLog(True)
+        if buf_size := os.getenv("PYMM_BUFFER_SIZE_MB", ""):
+            try:
+                buf_size_int = int(buf_size)
+                if buf_size_int:
+                    self.setCircularBufferMemoryFootprint(buf_size_int)
+            except (ValueError, TypeError):
+                warnings.warn("PYMM_BUFFER_SIZE_MB must be an integer", stacklevel=2)
 
         # Set the first instance of this class as the global singleton
         global _instance
         if _instance is None:
             _instance = self
 
-        if hasattr("self", "enableFeature"):
-            self.enableFeature("StrictInitializationChecks", True)
+        if hasattr(self, "enableFeature"):
+            strict = True
+            if env_strict := os.getenv("PYMM_STRICT_INIT_CHECKS", "").lower():
+                if env_strict in ("1", "true"):
+                    strict = True
+                elif env_strict in ("0", "false"):
+                    strict = False
+            self.enableFeature("StrictInitializationChecks", strict)
+
+            parallel = True
+            if env_parallel := os.getenv("PYMM_PARALLEL_INIT", "").lower():
+                if env_parallel in ("1", "true"):
+                    parallel = True
+                elif env_parallel in ("0", "false"):
+                    parallel = False
+            self.enableFeature("ParallelDeviceInitialization", parallel)
 
         # TODO: test this on windows ... writing to the same file may be an issue there
         if logfile := current_logfile(logger):
             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]
@@ -348,7 +379,7 @@ class CMMCorePlus(pymmcore.CMMCore):
         """
         try:
             super().loadDevice(label, moduleName, deviceName)
-        except RuntimeError as e:
+        except (RuntimeError, ValueError) as e:
             if exc := self._load_error_with_info(label, moduleName, deviceName, str(e)):
                 raise exc from e
 
@@ -399,15 +430,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 +673,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 +715,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 +731,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 +759,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 +771,7 @@ class CMMCorePlus(pymmcore.CMMCore):
         """
         super().setConfig(groupName, configName)
         self.events.configSet.emit(groupName, configName)
+        self._last_config = (groupName, configName)
 
     # NEW methods
 
@@ -1348,6 +1373,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 +1712,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.
@@ -1982,9 +2026,10 @@ class CMMCorePlus(pymmcore.CMMCore):
         **Why Override?** To also save pixel size configurations.
         """
         super().saveSystemConfiguration(filename)
-        # saveSystemConfiguration does not save the pixel size config so here
-        # we add to the saved file also any pixel size config.
-        self._save_pixel_configurations(filename)
+        if pymmcore.version_info < (11, 5):
+            # saveSystemConfiguration does not save the pixel size config so hereq
+            # we add to the saved file also any pixel size config.
+            self._save_pixel_configurations(filename)
 
     def _save_pixel_configurations(self, filename: str) -> None:
         px_configs = self.getAvailablePixelSizeConfigs()

pymmcore_plus/core/_sequencing.py

@@ -3,10 +3,10 @@ from __future__ import annotations
 from collections import defaultdict
 from collections.abc import Iterable
 from contextlib import suppress
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING, Any, Optional, TypeVar
 
 from pydantic import Field, model_validator
-from useq import AcquireImage, MDAEvent
+from useq import AcquireImage, MDAEvent, MDASequence
 
 from pymmcore_plus.core._constants import DeviceType, Keyword
 
@@ -65,6 +65,9 @@ class SequencedEvent(MDAEvent):
     z_sequence: tuple[float, ...] = Field(default_factory=tuple)
     slm_sequence: tuple[bytes, ...] = Field(default_factory=tuple)
 
+    # re-defining this from MDAEvent to circumvent a strange issue with pydantic 2.11
+    sequence: Optional[MDASequence] = Field(default=None, repr=False)  # noqa: UP007
+
     # all other property sequences
     property_sequences: dict[tuple[str, str], list[str]] = Field(default_factory=dict)
     # static properties should be added to MDAEvent.properties as usual

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/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/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/install.py

@@ -8,8 +8,9 @@ import subprocess
 import sys
 import tempfile
 from contextlib import contextmanager, nullcontext
+from functools import cache
 from pathlib import Path
-from platform import system
+from platform import machine, system
 from typing import TYPE_CHECKING, Callable, Protocol
 from urllib.request import urlopen, urlretrieve
 
@@ -57,7 +58,35 @@ except ImportError:  # pragma: no cover
 
 
 PLATFORM = system()
+MACH = machine()
 BASE_URL = "https://download.micro-manager.org"
+plat = {"Darwin": "Mac", "Windows": "Windows", "Linux": "Linux"}.get(PLATFORM)
+DOWNLOADS_URL = f"{BASE_URL}/nightly/2.0/{plat}/"
+
+
+# Dates of release for each interface version.
+# generally running `mmcore install -r <some_date>` will bring in devices with
+# the NEW interface.
+INTERFACES: dict[int, str] = {
+    73: "20250318",
+    72: "20250318",
+    71: "20221031",
+    70: "20210219",
+    69: "20180712",
+    68: "20171107",
+    67: "20160609",
+    66: "20160608",
+    65: "20150528",
+    64: "20150515",
+    63: "20150505",
+    62: "20150501",
+    61: "20140801",
+    60: "20140618",
+    59: "20140515",
+    58: "20140514",
+    57: "20140125",
+    56: "20140120",
+}
 
 
 def _get_download_name(url: str) -> str:
@@ -141,10 +170,10 @@ def _mac_install(dmg: Path, dest: Path, log_msg: _MsgLogger) -> None:
         os.rename(_tmp / "ImageJ.app", install_path / "ImageJ.app")
 
 
+@cache
 def available_versions() -> dict[str, str]:
     """Return a map of version -> url available for download."""
-    plat = {"Darwin": "Mac", "Windows": "Windows"}[PLATFORM]
-    with urlopen(f"{BASE_URL}/nightly/2.0/{plat}/") as resp:
+    with urlopen(DOWNLOADS_URL) as resp:
         html = resp.read().decode("utf-8")
 
     all_links = re.findall(r"href=\"([^\"]+)\"", html)
@@ -187,7 +216,7 @@ def _download_url(url: str, output_path: Path, show_progress: bool = True) -> No
 
 def install(
     dest: Path | str = USER_DATA_MM_PATH,
-    release: str = "latest",
+    release: str = "latest-compatible",
     log_msg: _MsgLogger = _pretty_print,
 ) -> None:
     """Install Micro-Manager to `dest`.
@@ -199,14 +228,20 @@ def install(
         folder in the user's data directory: `appdirs.user_data_dir()`.
     release : str, optional
         Which release to install, by default "latest". Should be a date in the form
-        YYYYMMDD, or "latest" to install the latest nightly release.
+        YYYYMMDD, "latest" to install the latest nightly release, or "latest-compatible"
+        to install the latest nightly release that is compatible with the
+        device interface version of the current pymmcore version.
     log_msg : _MsgLogger, optional
         Callback to log messages, must have signature:
         `def logger(text: str, color: str = "", emoji: str = ""): ...`
         May ignore color and emoji.
     """
-    if PLATFORM not in ("Darwin", "Windows"):  # pragma: no cover
-        log_msg(f"Unsupported platform: {PLATFORM!r}", "bold red", ":x:")
+    if PLATFORM not in ("Darwin", "Windows") or (
+        PLATFORM == "Darwin" and MACH == "arm64"
+    ):  # pragma: no cover
+        log_msg(
+            f"Unsupported platform/architecture: {PLATFORM}/{MACH}", "bold red", ":x:"
+        )
         log_msg(
             "Consider building from source (mmcore build-dev).",
             "bold yellow",
@@ -214,6 +249,32 @@ def install(
         )
         raise sys.exit(1)
 
+    if release == "latest-compatible":
+        from pymmcore_plus import _pymmcore
+
+        div = _pymmcore.version_info.device_interface
+        # date when the device interface version FOLLOWING the version that this
+        # pymmcore supports was released.
+        next_div_date = INTERFACES.get(div + 1, None)
+
+        # if div is equal to the greatest known interface version, use latest
+        if div == max(INTERFACES.keys()) or next_div_date is None:
+            release = "latest"
+        else:  # pragma: no cover
+            # otherwise, find the date of the release in available_versions() that
+            # is less than the next_div date.
+            available = available_versions()
+            release = max(
+                (date for date in available if date < next_div_date),
+                default="unavailable",
+            )
+            if release == "unavailable":
+                # fallback to latest if no compatible versions found
+                raise ValueError(
+                    "Unable to find a compatible release for device interface"
+                    f"{div} at {DOWNLOADS_URL} "
+                )
+
     if release == "latest":
         plat = {
             "Darwin": "macos/Micro-Manager-x86_64-latest.dmg",

pymmcore_plus/mda/_engine.py

@@ -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.
@@ -238,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)
@@ -413,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)
@@ -430,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())
@@ -594,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/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/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/metadata/functions.py

@@ -289,6 +289,15 @@ def pixel_size_config(core: CMMCorePlus, *, config_name: str) -> PixelSizeConfig
     affine = core.getPixelSizeAffineByID(config_name)
     if affine != (1.0, 0.0, 0.0, 0.0, 1.0, 0.0):
         info["pixel_size_affine"] = affine
+    # added in v11.5
+    if hasattr(core, "getPixelSizedxdz") and (px := core.getPixelSizedxdz(config_name)):
+        info["pixel_size_dxdz"] = px
+    if hasattr(core, "getPixelSizedydz") and (px := core.getPixelSizedydz(config_name)):
+        info["pixel_size_dydz"] = px
+    if hasattr(core, "getPixelSizeOptimalZUm") and (
+        z := core.getPixelSizeOptimalZUm(config_name)
+    ):
+        info["pixel_size_optimal_z_um"] = z
     return info
 
 

pymmcore_plus/metadata/schema.py

@@ -331,11 +331,30 @@ class PixelSizeConfigPreset(ConfigPreset):
         corrected for binning and known magnification devices. The affine transform
         consists of the first two rows of a 3x3 matrix, the third row is always assumed
         to be 0.0 0.0 1.0.
+
+    pixel_size_dxdz : float
+        *Not Required*. The angle between the camera's x axis and the axis (direction)
+        of the z drive for the given pixel size configuration. This angle is
+        dimensionless (i.e. the ratio of the translation in x caused by a translation
+        in z, i.e. dx / dz). If missing, assume 0.0.
+    pixel_size_dydz : float
+        *Not Required*. The angle between the camera's y axis and the axis (direction)
+        of the z drive for the given pixel size configuration. This angle is
+        dimensionless (i.e. the ratio of the translation in y caused by a translation
+        in z, i.e. dy / dz). If missing, assume 0.0.
+    pixel_size_optimal_z_um : float
+        *Not Required*. User-defined optimal Z step size is for this pixel size config.
+        If missing, assume 0.0.
     """
 
     pixel_size_um: float
     pixel_size_affine: NotRequired[AffineTuple]
 
+    # added in MMCore v 11.5
+    pixel_size_dxdz: NotRequired[float]  # default 0.0
+    pixel_size_dydz: NotRequired[float]  # default 0.0
+    pixel_size_optimal_z_um: NotRequired[float]  # default 0.0
+
 
 class ConfigGroup(TypedDict):
     """A group of configuration presets.

pymmcore_plus/model/_config_file.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import warnings
 from typing import TYPE_CHECKING, Any, Callable
 
-from pymmcore_plus import CFGCommand, DeviceType, FocusDirection, Keyword
+from pymmcore_plus import CFGCommand, DeviceType, FocusDirection, Keyword, _pymmcore
 from pymmcore_plus._util import timestamp
 
 from ._config_group import ConfigGroup, ConfigPreset, Setting
@@ -162,6 +162,12 @@ def iter_pixel_size_presets(scope: Microscope) -> Iterable[str]:
         yield _serialize(CFGCommand.PixelSize_um, p.name, p.pixel_size_um)
         if p.affine != DEFAULT_AFFINE:
             yield _serialize(CFGCommand.PixelSizeAffine, p.name, *p.affine)
+        if p.angle_dxdz and (cmd := getattr(CFGCommand, "PixelSizeAngleDxdz", None)):
+            yield _serialize(cmd, p.name, p.angle_dxdz)
+        if p.angle_dydz and (cmd := getattr(CFGCommand, "PixelSizeAngleDydz", None)):
+            yield _serialize(cmd, p.name, p.angle_dydz)
+        if p.optimalz_um and (cmd := getattr(CFGCommand, "PixelSize_OptimalZUm", None)):
+            yield _serialize(cmd, p.name, p.optimalz_um)
 
 
 # Order will determine the order of the sections in the file
@@ -180,10 +186,17 @@ CONFIG_SECTIONS: dict[str, Callable[[Microscope], Iterable[str]]] = {
     "Camera-synchronized devices": lambda _: [],
     "Labels": iter_labels,
     "Configuration presets": iter_config_presets,
-    "Roles": iter_roles,  # MMStudio puts this above Cam-Synched devices, MMCore here.
-    "PixelSize settings": iter_pixel_size_presets,
 }
 
+
+if _pymmcore.version_info >= (11, 5):
+    CONFIG_SECTIONS["PixelSize settings"] = iter_pixel_size_presets
+    CONFIG_SECTIONS["Roles"] = iter_roles
+else:
+    CONFIG_SECTIONS["Roles"] = iter_roles
+    CONFIG_SECTIONS["PixelSize settings"] = iter_pixel_size_presets
+
+
 # ------------------ Deserialization ------------------
 
 # TODO: ... I think the command subclasses are probably overkill here.

pymmcore_plus/model/_device.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING
 
 from pymmcore_plus import CMMCorePlus, DeviceType, FocusDirection, Keyword
 from pymmcore_plus._util import no_stdout
+from pymmcore_plus.core._constants import DeviceInitializationState
 
 from ._core_link import CoreObject
 from ._property import Property
@@ -410,6 +411,11 @@ def get_available_devices(core: CMMCorePlus) -> list[AvailableDevice]:
     for hub in core.getLoadedDevicesOfType(DeviceType.Hub):
         lib_name = core.getDeviceLibrary(hub)
         hub_dev = library_to_hub.get((lib_name, hub))
+        if (
+            core.getDeviceInitializationState(hub)
+            != DeviceInitializationState.InitializedSuccessfully
+        ):
+            continue
         for child in core.getInstalledDevices(hub):
             dev = AvailableDevice(
                 library=lib_name, adapter_name=child, library_hub=hub_dev

pymmcore_plus/model/_pixel_size_config.py

@@ -31,6 +31,9 @@ class PixelSizePreset(ConfigPreset):
 
     pixel_size_um: float = 0.0
     affine: AffineTuple = DEFAULT_AFFINE
+    angle_dxdz: float = 0.0
+    angle_dydz: float = 0.0
+    optimalz_um: float = 0.0
 
     @classmethod
     def from_metadata(cls, meta: PixelSizeConfigPreset) -> Self:  # type: ignore [override]
@@ -38,6 +41,12 @@ class PixelSizePreset(ConfigPreset):
         obj.pixel_size_um = meta["pixel_size_um"]
         if "pixel_size_affine" in meta:
             obj.affine = meta["pixel_size_affine"]
+        if "pixel_size_dxdz" in meta:
+            obj.angle_dxdz = meta["pixel_size_dxdz"]
+        if "pixel_size_dydz" in meta:
+            obj.angle_dydz = meta["pixel_size_dydz"]
+        if "pixel_size_optimal_z_um" in meta:
+            obj.optimalz_um = meta["pixel_size_optimal_z_um"]
         return obj
 
     def __rich_repr__(self, *, defaults: bool = False) -> Iterable[tuple[str, Any]]:

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.4.dist-info → pymmcore_plus-0.13.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymmcore-plus
-Version: 0.13.4
+Version: 0.13.6
 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,7 +30,7 @@ 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.7.0
@@ -40,11 +40,12 @@ Requires-Dist: typer>=0.4.2; extra == 'cli'
 Provides-Extra: dev
 Requires-Dist: ipython; extra == 'dev'
 Requires-Dist: mypy; extra == 'dev'
-Requires-Dist: pdbpp; extra == 'dev'
+Requires-Dist: pdbpp; (sys_platform != 'win32') and extra == 'dev'
 Requires-Dist: pre-commit; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
 Requires-Dist: tensorstore-stubs; extra == 'dev'
 Provides-Extra: docs
+Requires-Dist: mkdocs-autorefs==1.3.1; extra == 'docs'
 Requires-Dist: mkdocs-material; extra == 'docs'
 Requires-Dist: mkdocs-typer==0.0.3; extra == 'docs'
 Requires-Dist: mkdocs>=1.4; extra == 'docs'
@@ -62,8 +63,10 @@ Requires-Dist: pyside2>=5.15; extra == 'pyside2'
 Provides-Extra: pyside6
 Requires-Dist: pyside6<6.8,>=6.4.0; extra == 'pyside6'
 Provides-Extra: test
+Requires-Dist: mm-device-adapters; (sys_platform == 'darwin' and platform_machine == 'x86_64') and extra == 'test'
+Requires-Dist: mm-device-adapters; (sys_platform == 'win32') and extra == 'test'
 Requires-Dist: msgpack; extra == 'test'
-Requires-Dist: msgspec; (python_version < '3.13') and extra == 'test'
+Requires-Dist: msgspec; extra == 'test'
 Requires-Dist: pytest-cov>=4; extra == 'test'
 Requires-Dist: pytest-qt>=4; extra == 'test'
 Requires-Dist: pytest>=7.3.2; extra == 'test'
@@ -99,7 +102,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 +115,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 +142,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 +196,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.4.dist-info → pymmcore_plus-0.13.6.dist-info}/RECORD

@@ -1,25 +1,25 @@
 pymmcore_plus/__init__.py,sha256=9-vK2P2jkJJ2REhCjFDBbJu0wrZM0jvDcf-d2GsjTk0,1415
 pymmcore_plus/_benchmark.py,sha256=YJICxXleFQVbOluJdq4OujnIcTkkuMVzeB8GJ8nUv5I,6011
 pymmcore_plus/_build.py,sha256=RPTAuwCZWGL5IDJj4JZo1DIIouUsIqS3vnbPbG2_bRE,10993
-pymmcore_plus/_cli.py,sha256=FWdIvr6Rh9DVAItFaz9fWx7CbbF8ikOHWICp5h0NHTw,16393
+pymmcore_plus/_cli.py,sha256=ofh7Yac4VqVuWrEYZ9ZpY4jR8FYzzxfjihvs1_gOqpM,16768
 pymmcore_plus/_logger.py,sha256=d7ldqxY0rGWORKdIzNUiFc9BW6cFBx57kHWtXyY1HE0,5416
-pymmcore_plus/_pymmcore.py,sha256=QGlCEEx2pz5JsRLy3nQX3afAvV-_rm6ptWsv05U5hxI,328
-pymmcore_plus/_util.py,sha256=mz5fuyzOhoMARyKYeri8FnR6eHwXsOh45WNZblewS1E,20435
-pymmcore_plus/install.py,sha256=OLKkssJbQ9VSU0Rclkke0fb4Ng1YKb3Ij9rYYbQuusM,8705
+pymmcore_plus/_pymmcore.py,sha256=tcWtTRte9AFQznLGn6CmwLW0W3Rsse8N8NQ5L7JwKCc,630
+pymmcore_plus/_util.py,sha256=oeJiDgt5_EoC8srmGz-QH_yNCgsxJ4k0C43qrAspL2A,22706
+pymmcore_plus/install.py,sha256=U4TbQXbUc12aMtGRF_SkinNOTDCuuzIhME5Oup_4ds0,10768
 pymmcore_plus/mocks.py,sha256=jNUfmffD1OArtIvEmqWsy7GCrtTpssVF03flH8cEYx8,1867
 pymmcore_plus/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pymmcore_plus/seq_tester.py,sha256=PJFQmb-JwGhliwIgje9BOUNcaayDsA-2x278xoumfig,3768
+pymmcore_plus/seq_tester.py,sha256=ielLx2ZUJrOXVCojk64UXTeKDoARxt8QkQjt5AE5Gng,3776
 pymmcore_plus/core/__init__.py,sha256=rYHv5JQVMVDlwYD1wodCc5L9ZbpVld1C_swGx4CRogA,1011
 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=6foxGbek3tgnUHYUtQ7NCqwIIqqGYW1W56HjrhZqsA0,12829
+pymmcore_plus/core/_constants.py,sha256=yS_YVRZQkpvTuQdOPFJdetaFpvXh4CTvd7i0qDIiAuA,13200
 pymmcore_plus/core/_device.py,sha256=Pz9Ekhss2c9IBA3B7WyMU2cCwc19Dp_dGVhMkzqUaIE,7762
-pymmcore_plus/core/_metadata.py,sha256=3vb3d36XgNnUY44dpZ4Ccw0tvn4KCinZ8zrnDllmABI,2645
-pymmcore_plus/core/_mmcore_plus.py,sha256=I5IqUmR-IgdftHO5dkvzA99kAxRZoj-8_tkTaJcfLNQ,91819
+pymmcore_plus/core/_metadata.py,sha256=L8x1gX_zXPz02BUqc7eqJM_Bey2G0RyX30SOBs2aBNc,2755
+pymmcore_plus/core/_mmcore_plus.py,sha256=15_QvUuURNP23rtN_nkWcqVOx6ohwizZyYPEta6O7ww,94187
 pymmcore_plus/core/_property.py,sha256=QsQEzqOAedR24zEJ1Ge4kwScfT_7NOApVcgz6QxBJrI,8265
-pymmcore_plus/core/_sequencing.py,sha256=Vb6hbRsb8RxSPUAlNSVWTM4Yvg7YYf9ZbewK7u_b-QM,16692
-pymmcore_plus/core/events/__init__.py,sha256=Bb1Ga97GzY2z3fAeJkPs1wxbTXa1o_p6nIKof_UCvZs,1093
+pymmcore_plus/core/_sequencing.py,sha256=QmaCoyWzR9lX-3ldZxGYqAiEqOn8gts3X0qmskZXzQo,16887
+pymmcore_plus/core/events/__init__.py,sha256=F8r10LEBLrAV8qfkXScSkpqfExdT2XoOx92OqSturpc,1078
 pymmcore_plus/core/events/_device_signal_view.py,sha256=t-NfBdg3E4rms4vDFxkkR5XtrpLxaBT7mfPwkpIsbVk,1079
 pymmcore_plus/core/events/_norm_slot.py,sha256=8DCBoLHGh7cbB1OB19IJYwL6sFBFmkD8IakfBOvFbw8,2907
 pymmcore_plus/core/events/_prop_event_mixin.py,sha256=FvJJnpEKrOR-_Sp3-NNCwFoUUHwmNKiHruo0Y1vybsY,4042
@@ -30,17 +30,17 @@ pymmcore_plus/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 pymmcore_plus/experimental/unicore/__init__.py,sha256=OcjUZ4tq-NtWDR5R3JFivsRePliQSIQ7Z92k_8Gfz2Q,361
 pymmcore_plus/experimental/unicore/_device_manager.py,sha256=c5DAMsnK06xOy6G7YjHdUughc7xdFtzeo10woO5G_KE,6418
 pymmcore_plus/experimental/unicore/_proxy.py,sha256=Sl_Jiwd4RlcKgmsrEUNZT38YPFGlQonELAg_n3sfbdo,4020
-pymmcore_plus/experimental/unicore/_unicore.py,sha256=HM1rTpFFAtn5nuO9vJGsYGVkyTzeV-EY2KYdAY7EbWM,29027
+pymmcore_plus/experimental/unicore/_unicore.py,sha256=3-HkZbbrQxrUgvEx3A6XEStDH9C3c6NdG_Kb8y1KubY,29029
 pymmcore_plus/experimental/unicore/devices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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/_properties.py,sha256=KuHlSNNpmfj_Q1m1uyfycpE5C63jLg5Mm_D57In2oPo,15389
 pymmcore_plus/experimental/unicore/devices/_stage.py,sha256=Ab4uibYq1cjIBtwcthCxH2FudGq9UMjub-qVeRpApQY,7892
 pymmcore_plus/mda/__init__.py,sha256=7VH-MqOcuK1JNSOG9HhES6Ac-Z-LuT8a0f2xPbGEt7w,344
-pymmcore_plus/mda/_engine.py,sha256=QxUXlDNITCVILfZ2GGoIDe8iSOaMXn6mswhvnsmUzm8,29914
+pymmcore_plus/mda/_engine.py,sha256=U83PnmbaWChxUCEskKqHVy-Xa8KAZAMuvwPSVTAwsKg,31205
 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
-pymmcore_plus/mda/events/__init__.py,sha256=rHTyhQZJ54dz-KtetvN22GvAY2ilR03x8v4H0qUR070,1191
+pymmcore_plus/mda/events/__init__.py,sha256=v7YsVXzd3cTavFs2v3_PEhjqP4CtuRE0nWUoJA3CvYU,1176
 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
@@ -49,23 +49,23 @@ pymmcore_plus/mda/handlers/__init__.py,sha256=TbgpRdcs3BRdCf6uXJlwo_IIbxM6xXaLoc
 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=_Hqfgc2I8n97KPT7quU0p4tqSlomtLbTO-e78bIB6hA,15280
+pymmcore_plus/mda/handlers/_tensorstore_handler.py,sha256=rgLyuTJjV1m5j-O5tLm-BggIblJpdrHa_FB17_S7rug,15282
 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/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
 pymmcore_plus/model/__init__.py,sha256=zKZkkSpNK4ERu-VMdi9gvRrj1aXAjNaYxlYB5PdYSg0,479
-pymmcore_plus/model/_config_file.py,sha256=nCAFh5dA7kYpoWTIwzoG4CHbdLwCYBBDGSOvZosFCFw,13711
+pymmcore_plus/model/_config_file.py,sha256=ks9cR9q7G2a8xx4A8frtJbIL__KVS7j0WPyp0DPtn_g,14281
 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
-pymmcore_plus/model/_device.py,sha256=-0s3NkonDoaMrNy_hn5EDz-c4o33ZiJSQkV_kdBteoo,16115
+pymmcore_plus/model/_device.py,sha256=AX3rO2gbY7AXJyMN3FfI_n2jl2V0IAPuBh7MiDA5SqY,16344
 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/_pixel_size_config.py,sha256=RXk8AAwARe8clsXue0GZfOTb1bxyXIsO0ibcDLHM4_s,3889
 pymmcore_plus/model/_property.py,sha256=NQzNtnEzSCR9ogwx1cfi8X-qbJ_cBSJKdSBAaoKoPQ0,3720
-pymmcore_plus-0.13.4.dist-info/METADATA,sha256=tmhgzAJdqyf1tO_aUNpfIslpMGlqcp49oZ2-kSX7qNs,9594
-pymmcore_plus-0.13.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pymmcore_plus-0.13.4.dist-info/entry_points.txt,sha256=NtFyndrQzBpUNJyil-8e5hMGke2utAf7mkGavTLcLOY,51
-pymmcore_plus-0.13.4.dist-info/licenses/LICENSE,sha256=OHJjRpOPKKRc7FEnpehNWdR5LRBdBhUtIFG-ZI0dCEA,1522
-pymmcore_plus-0.13.4.dist-info/RECORD,,
+pymmcore_plus-0.13.6.dist-info/METADATA,sha256=LPZrzi2nVttLeRhGn-UlURw4NUoOVOG34fUn59_S3Yc,9961
+pymmcore_plus-0.13.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pymmcore_plus-0.13.6.dist-info/entry_points.txt,sha256=NtFyndrQzBpUNJyil-8e5hMGke2utAf7mkGavTLcLOY,51
+pymmcore_plus-0.13.6.dist-info/licenses/LICENSE,sha256=OHJjRpOPKKRc7FEnpehNWdR5LRBdBhUtIFG-ZI0dCEA,1522
+pymmcore_plus-0.13.6.dist-info/RECORD,,