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

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

@@ -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 → pymmcore_plus-0.13.7}/pyproject.toml

@@ -58,7 +58,7 @@ PySide6 = ["PySide6 >=6.4.0,<6.8"]
 PyQt5 = ["PyQt5 >=5.15.4"]
 PyQt6 = ["PyQt6 >=6.4.2,<6.8"]
 test = [
-    "msgspec; python_version < '3.13'",
+    "msgspec",
     "msgpack",
     "pytest-cov >=4",
     "pytest-qt >=4",
@@ -70,11 +70,19 @@ test = [
     "zarr >=2.2,<3",
     "xarray",
 ]
-dev = ["ipython", "mypy", "pdbpp", "pre-commit", "ruff", "tensorstore-stubs"]
+dev = [
+    "ipython",
+    "mypy",
+    "pdbpp; sys_platform != 'win32'",
+    "pre-commit",
+    "ruff",
+    "tensorstore-stubs",
+]
 docs = [
     "mkdocs >=1.4",
     "mkdocs-material",
     "mkdocstrings ==0.22.0",
+    "mkdocs-autorefs ==1.3.1",
     "mkdocstrings-python ==1.1.2",
     "mkdocs-typer ==0.0.3",
     # "griffe @ git+https://github.com/tlambert03/griffe@recursion"
@@ -194,4 +202,4 @@ ignore = [
 ]
 
 [tool.typos.default]
-extend-ignore-identifiers-re = ["(?i)nd2?.*", "(?i)ome", "anager"]
+extend-ignore-identifiers-re = ["(?i)nd2?.*", "(?i)ome", "anager", "ba"]

{pymmcore_plus-0.13.5 → pymmcore_plus-0.13.7}/src/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-0.13.7/src/pymmcore_plus/_pymmcore.py

@@ -0,0 +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__
+
+    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-0.13.5 → pymmcore_plus-0.13.7}/src/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-0.13.5 → pymmcore_plus-0.13.7}/src/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-0.13.5 → pymmcore_plus-0.13.7}/src/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-0.13.5 → pymmcore_plus-0.13.7}/src/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-0.13.5 → pymmcore_plus-0.13.7}/src/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-0.13.5 → pymmcore_plus-0.13.7}/src/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-0.13.5 → pymmcore_plus-0.13.7}/src/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-0.13.5 → pymmcore_plus-0.13.7}/src/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-0.13.5 → pymmcore_plus-0.13.7}/src/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-0.13.5 → pymmcore_plus-0.13.7}/src/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 → pymmcore_plus-0.13.7}/tests/test_cli.py

@@ -29,6 +29,12 @@ from pymmcore_plus import CMMCorePlus, __version__, _cli, _logger, _util, instal
 runner = CliRunner()
 subrun = subprocess.run
 
+skipif_no_drivers_available = pytest.mark.skipif(
+    platform.system() == "Linux"
+    or (platform.system() == "Darwin" and platform.machine() == "arm64"),
+    reason="Drivers not available on Linux or macOS ARM64",
+)
+
 
 def _mock_urlretrieve(url: str, filename: str, reporthook=None) -> None:
     """fake urlretrieve that writes a fake file."""
@@ -68,7 +74,7 @@ def _mock_run(dest: Path) -> Callable:
     return runner
 
 
-@pytest.mark.skipif(platform.system() == "Linux", reason="Not supported on Linux")
+@skipif_no_drivers_available
 def test_install_app(tmp_path: Path) -> None:
     patch_download = patch.object(install, "urlretrieve", _mock_urlretrieve)
     patch_run = patch.object(subprocess, "run", _mock_run(tmp_path))
@@ -79,7 +85,7 @@ def test_install_app(tmp_path: Path) -> None:
     assert result.exit_code == 0
 
 
-@pytest.mark.skipif(platform.system() == "Linux", reason="Not supported on Linux")
+@skipif_no_drivers_available
 def test_basic_install(tmp_path: Path) -> None:
     patch_download = patch.object(install, "urlretrieve", _mock_urlretrieve)
     patch_run = patch.object(subprocess, "run", _mock_run(tmp_path))
@@ -91,7 +97,7 @@ def test_basic_install(tmp_path: Path) -> None:
     assert mock.call_args_list[-1][0][0].startswith("Installed")
 
 
-@pytest.mark.skipif(platform.system() == "Linux", reason="Not supported on Linux")
+@skipif_no_drivers_available
 def test_available_versions() -> None:
     """installing with an erroneous version should fail and show available versions."""
     result = runner.invoke(app, ["install", "-r", "xxxx"])

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

@@ -607,3 +607,44 @@ def test_snap_rgb(core: CMMCorePlus) -> None:
         dtype="uint8",
     )
     np.testing.assert_equal(img[::64, -1], expect)
+
+
+def test_env_vars(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    core = CMMCorePlus()
+    assert not core.debugLogEnabled()
+    assert not core.stderrLogEnabled()
+    assert core.getCircularBufferMemoryFootprint() != 64
+    assert core.isFeatureEnabled("ParallelDeviceInitialization")
+    assert core.isFeatureEnabled("StrictInitializationChecks")
+
+    with monkeypatch.context() as m:
+        m.setenv("PYMM_DEBUG_LOG", "1")
+        core = CMMCorePlus()
+        assert core.debugLogEnabled()
+
+    with monkeypatch.context() as m:
+        m.setenv("PYMM_STDERR_LOG", "1")
+        core = CMMCorePlus()
+        assert core.stderrLogEnabled()
+
+    with monkeypatch.context() as m:
+        m.setenv("PYMM_BUFFER_SIZE_MB", "64")
+        core = CMMCorePlus()
+        assert core.getCircularBufferMemoryFootprint() == 64
+
+    with monkeypatch.context() as m:
+        m.setenv("PYMM_STRICT_INIT_CHECKS", "0")
+        core = CMMCorePlus()
+        assert not core.isFeatureEnabled("StrictInitializationChecks")
+
+    with monkeypatch.context() as m:
+        # test with an invalid value
+        m.setenv("PYMM_PARALLEL_INIT", "0")
+        core = CMMCorePlus()
+        assert not core.isFeatureEnabled("ParallelDeviceInitialization")
+
+    with monkeypatch.context() as m:
+        m.setenv("MICROMANAGER_PATH", str(tmp_path))
+        core = CMMCorePlus()
+        paths = core.getDeviceAdapterSearchPaths()
+        assert str(tmp_path) in paths

{pymmcore_plus-0.13.5 → pymmcore_plus-0.13.7}/tests/test_events.py

@@ -7,7 +7,7 @@ from unittest.mock import Mock, call
 import pytest
 
 from pymmcore_plus import CMMCorePlus, Keyword
-from pymmcore_plus._util import MMCORE_PLUS_SIGNALS_BACKEND
+from pymmcore_plus._util import PYMM_SIGNALS_BACKEND
 from pymmcore_plus.core.events import CMMCoreSignaler, PCoreSignaler
 
 Signalers = [CMMCoreSignaler]
@@ -38,7 +38,7 @@ def test_signal_backend_selection(
 
         _ = QApplication.instance() or QApplication([])
 
-    monkeypatch.setenv(MMCORE_PLUS_SIGNALS_BACKEND, env_var)
+    monkeypatch.setenv(PYMM_SIGNALS_BACKEND, env_var)
     ctx = (
         pytest.warns(UserWarning)
         if (env_var == "nonsense" or (env_var == "qt" and QCoreSignaler is None))

{pymmcore_plus-0.13.5 → pymmcore_plus-0.13.7}/tests/test_model.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 from pathlib import Path
 
 import pytest
@@ -56,7 +57,7 @@ def test_model_from_summary_metadata(tmp_path: Path) -> None:
 
 def non_empty_lines(path: Path) -> list[str]:
     return [
-        ln
+        ln.replace("1.0", "1").replace("0.0", "0")  # normalize floats
         for line in path.read_text().splitlines()
         if (ln := line.strip()) and not ln.startswith("#")
     ]
@@ -95,16 +96,19 @@ def _assert_cfg_matches_core_save(
     model.save(model_out)
     core.saveSystemConfiguration(str(core_out))
 
-    # MMCore DOES write out default affine transforms... MMStudio doesn't and we don't
-    core_lines = [
-        x for x in non_empty_lines(core_out) if "1.0,0.0,0.0,0.0,1.0,0.0" not in x
-    ]
-    # MMCore doesn't write out AutoShutter prefs
+    # MMCore DOES write out default affine transforms and angles...
+    # MMStudio doesn't and we don't
+    pattern = re.compile(
+        r"(PixelSizeAffine,.+,1(?:\.0)?,0(?:\.0)?,0(?:\.0)?,0(?:\.0)?,1(?:\.0)?,0(?:\.0)?"
+        r"|PixelSizeAngle_dxdz,.+,0|"
+        r"PixelSizeAngle_dydz,.+,0|PixelSizeOptimalZ_Um,.+,0)"
+    )
+    core_lines = [x for x in non_empty_lines(core_out) if not pattern.match(x)]
+    # MMCore doesn't write out AutoShutter prefs, but we do
     model_lines = [
         x
         for x in non_empty_lines(model_out)
-        if not x.startswith("Property,Core,AutoShutter")
-        and "1.0,0.0,0.0,0.0,1.0,0.0" not in x
+        if not x.startswith("Property,Core,AutoShutter") and "1,0,0,0,1,0" not in x
     ]
     assert core_lines == model_lines
 

{pymmcore_plus-0.13.5 → pymmcore_plus-0.13.7}/tests/unicore/test_unicore.py

@@ -5,7 +5,7 @@ from unittest.mock import MagicMock
 
 import pytest
 
-from pymmcore_plus import DeviceInitializationState, DeviceType, PropertyType
+from pymmcore_plus import DeviceInitializationState, DeviceType, PropertyType, _pymmcore
 from pymmcore_plus.experimental.unicore import Device, UniMMCore, pymm_property
 
 DOC = """Example generic device."""
@@ -153,7 +153,12 @@ def test_device_load_from_module():
 
     # If we gave a proper library name, but a bad device name...
     # it should raise the usual error
-    with pytest.raises(RuntimeError, match="Failed to load device"):
+    msg = (
+        "failed to instantiate device"
+        if _pymmcore.version_info >= (11, 5)
+        else "Failed to load device"
+    )
+    with pytest.raises(RuntimeError, match=msg):
         core.loadDevice("newdev", "DemoCamera", "NoSuchDevice")
 
     # Then we fallback to checking python modules

{pymmcore_plus-0.13.5 → pymmcore_plus-0.13.7}/tests/unicore/test_xy_stage.py

@@ -52,6 +52,7 @@ def test_unicore_xy_stage():
     # print status of C-side XY stage device
     assert core.getXYStageDevice() == "XY"
     core.setXYPosition(100, 200)
+    core.waitForDevice("XY")
     x, y = core.getXYPosition()
     assert (round(x), round(y)) == (100, 200)
 
@@ -75,6 +76,7 @@ def test_unicore_xy_stage():
     # can still set and query the C-side device directly
     core.waitForDevice("XY")
     core.setXYPosition("XY", 1.5, 3.7)
+    core.waitForDevice("XY")
     x, y = core.getXYPosition("XY")
     assert (round(x, 1), round(y, 1)) == (1.5, 3.7)
     assert core.getXYPosition(XYDEV) == NEW_POS

pymmcore_plus-0.13.5/src/pymmcore_plus/_pymmcore.py

@@ -1,14 +0,0 @@
-"""Internal module to choose between pymmcore and pymmcore-nano."""
-
-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
-
-    BACKEND = "pymmcore"
-    NANO = False