pymmcore-plus 0.13.5__py3-none-any.whl → 0.13.7__py3-none-any.whl

pymmcore_plus/_cli.py

@@ -1,4 +1,5 @@
 # do NOT use __future__.annotations here. It breaks typer.
+import contextlib
 import os
 import shutil
 import subprocess
@@ -8,6 +9,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 +116,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.")
@@ -136,12 +144,13 @@ def mmstudio() -> None:  # pragma: no cover
         if mm
         else None
     )
-    if not app:  # pragma: no cover
+    if not mm or not app:  # pragma: no cover
         print(f":x: [bold red]No MMStudio application found in {mm!r}")
         print("[magenta]run `mmcore install` to install a version of Micro-Manager")
         raise typer.Exit(1)
     cmd = ["open", "-a", str(app)] if PLATFORM == "Darwin" else [str(app)]
-    raise typer.Exit(subprocess.run(cmd).returncode)
+    with contextlib.chdir(mm):
+        raise typer.Exit(subprocess.run(cmd).returncode)
 
 
 @app.command()
@@ -157,7 +166,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,

pymmcore_plus/_pymmcore.py

@@ -1,5 +1,8 @@
 """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__
@@ -8,7 +11,20 @@ try:
     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
 
@@ -148,13 +181,17 @@ def find_micromanager(return_first: bool = True) -> str | None | list[str]:
     app_path = applications[sys.platform]
     pth = next(app_path.glob("[m,M]icro-[m,M]anager*"), None)
     if return_first:
-        if pth is None:
-            logger.error(
-                "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 pth and _mm_path_has_compatible_div(pth):  # pragma: no cover
+            logger.debug("using MM path found in applications: %s", pth)
+            return str(pth)
+        from . import _pymmcore
+
+        div = _pymmcore.version_info.device_interface
+        logger.error(
+            f"could not find micromanager directory for device interface {div}. "
+            "Please run 'mmcore install'"
+        )
+        return None
     if pth is not None:
         full_list[str(pth)] = None
     return list(full_list)
@@ -229,15 +266,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 +287,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 +655,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(str(lib_path))
+    else:
+        lib = ctypes.CDLL(str(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/_mmcore_plus.py

@@ -207,14 +207,39 @@ 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):
@@ -354,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
 
@@ -2001,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/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/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-0.13.5.dist-info → pymmcore_plus-0.13.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymmcore-plus
-Version: 0.13.5
+Version: 0.13.7
 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
@@ -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'
@@ -63,7 +64,7 @@ Provides-Extra: pyside6
 Requires-Dist: pyside6<6.8,>=6.4.0; extra == 'pyside6'
 Provides-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'

{pymmcore_plus-0.13.5.dist-info → pymmcore_plus-0.13.7.dist-info}/RECORD

@@ -1,11 +1,11 @@
 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=vysJhdBua23NFSILU0CSMs84hjKVbQl4ttUnk5ouMsk,16395
+pymmcore_plus/_cli.py,sha256=wmqlG8UGBNiTefRppSnRHwnD3w-5DAhN168lIBujbRA,16831
 pymmcore_plus/_logger.py,sha256=d7ldqxY0rGWORKdIzNUiFc9BW6cFBx57kHWtXyY1HE0,5416
-pymmcore_plus/_pymmcore.py,sha256=HzV-vW7QT0BhkIh7aWwQKwAtmt27iNnHGzXXzg3_6n0,361
-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=VGcb_nQu6BBWZsQihed0TrCHdTRADKlBo_qSnIbeF0Q,22814
+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=ielLx2ZUJrOXVCojk64UXTeKDoARxt8QkQjt5AE5Gng,3776
@@ -13,12 +13,12 @@ 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=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=L8x1gX_zXPz02BUqc7eqJM_Bey2G0RyX30SOBs2aBNc,2755
-pymmcore_plus/core/_mmcore_plus.py,sha256=XEdoYyMPfk4zJxXqSzVaq7J5_qtngNYP7ebf_blaOQY,92887
+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/_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
@@ -52,20 +52,20 @@ pymmcore_plus/mda/handlers/_ome_zarr_writer.py,sha256=cKg3kJR7TId6M2qC1nJMLlxkv5
 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.5.dist-info/METADATA,sha256=HKYfO-wVXV-thoxMJNDaIejT08X5m81K915GzyCEH4c,9710
-pymmcore_plus-0.13.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pymmcore_plus-0.13.5.dist-info/entry_points.txt,sha256=NtFyndrQzBpUNJyil-8e5hMGke2utAf7mkGavTLcLOY,51
-pymmcore_plus-0.13.5.dist-info/licenses/LICENSE,sha256=OHJjRpOPKKRc7FEnpehNWdR5LRBdBhUtIFG-ZI0dCEA,1522
-pymmcore_plus-0.13.5.dist-info/RECORD,,
+pymmcore_plus-0.13.7.dist-info/METADATA,sha256=Xf0FN1PVDxE4QgDL3JaKGuGutrKAnTOm1nfb0OUdFDU,9765
+pymmcore_plus-0.13.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pymmcore_plus-0.13.7.dist-info/entry_points.txt,sha256=NtFyndrQzBpUNJyil-8e5hMGke2utAf7mkGavTLcLOY,51
+pymmcore_plus-0.13.7.dist-info/licenses/LICENSE,sha256=OHJjRpOPKKRc7FEnpehNWdR5LRBdBhUtIFG-ZI0dCEA,1522
+pymmcore_plus-0.13.7.dist-info/RECORD,,