pymmcore-plus 0.14.0__tar.gz → 0.15.0__tar.gz

{pymmcore_plus-0.14.0 → pymmcore_plus-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymmcore-plus
-Version: 0.14.0
+Version: 0.15.0
 Summary: pymmcore superset providing improved APIs, event handling, and a pure python acquisition engine
 Project-URL: Source, https://github.com/pymmcore-plus/pymmcore-plus
 Project-URL: Tracker, https://github.com/pymmcore-plus/pymmcore-plus/issues

{pymmcore_plus-0.14.0 → pymmcore_plus-0.15.0}/pyproject.toml

@@ -79,15 +79,14 @@ test = [
     "pymmcore >=11.5.0.73",
 ]
 test-codspeed = [{ include-group = "test" }, "pytest-codspeed >=3.2.0"]
-test-qt = ["pytest-qt >=4.4", "qtpy >=2"]
+test-qt = [{ include-group = 'test' }, "pytest-qt >=4.4", "qtpy >=2"]
 PyQt6 = [{ include-group = 'test-qt' }, "pymmcore-plus[PyQt6]"]
 PySide6 = [{ include-group = 'test-qt' }, "pymmcore-plus[PySide6]"]
 PyQt5 = [{ include-group = 'test-qt' }, "pymmcore-plus[PyQt5]"]
 PySide2 = [{ include-group = 'test-qt' }, "pymmcore-plus[PySide2]"]
 dev = [
     # { include-group = "docs" },
-    { include-group = "test" },
-    "PyQt6 >=6.4.2",
+    { include-group = "PyQt6" },
     "ipython>=8.18.1",
     "pdbpp>=0.11.6 ; sys_platform != 'win32'",
     "mypy>=1.14.1",
@@ -158,7 +157,7 @@ ignore = [
 ]
 
 [tool.ruff.lint.per-file-ignores]
-"tests/*.py" = ["D", "SLF"]
+"tests/**/*.py" = ["D", "SLF"]
 "examples/*.py" = ["D"]
 "_cli.py" = ["B008"]
 "docs/*.py" = ["A", "D"]

{pymmcore_plus-0.14.0 → pymmcore_plus-0.15.0}/src/pymmcore_plus/_pymmcore.py

@@ -24,7 +24,9 @@ class VersionInfo(NamedTuple):
     minor: int
     micro: int
     device_interface: int
-    build: int
+    build: int = 0
 
 
-version_info = VersionInfo(*(int(x) for x in re.findall(r"\d+", __version__)))
+# pass no more than 5 parts to VersionInfo
+numbers = re.findall(r"\d+", __version__)[:5]
+version_info = VersionInfo(*(int(i) for i in numbers))

{pymmcore_plus-0.14.0 → pymmcore_plus-0.15.0}/src/pymmcore_plus/core/_constants.py

@@ -13,6 +13,7 @@ import pymmcore_plus._pymmcore as pymmcore
 class Keyword(str, Enum):
     Name = pymmcore.g_Keyword_Name
     Description = pymmcore.g_Keyword_Description
+
     CameraName = pymmcore.g_Keyword_CameraName
     CameraID = pymmcore.g_Keyword_CameraID
     CameraChannelName = pymmcore.g_Keyword_CameraChannelName
@@ -31,6 +32,7 @@ class Keyword(str, Enum):
     Offset = pymmcore.g_Keyword_Offset
     CCDTemperature = pymmcore.g_Keyword_CCDTemperature
     CCDTemperatureSetPoint = pymmcore.g_Keyword_CCDTemperatureSetPoint
+
     State = pymmcore.g_Keyword_State
     Label = pymmcore.g_Keyword_Label
     Position = pymmcore.g_Keyword_Position
@@ -69,12 +71,15 @@ class Keyword(str, Enum):
     HubID = pymmcore.g_Keyword_HubID
 
     # image annotations
-    Meatdata_Exposure = pymmcore.g_Keyword_Meatdata_Exposure
-    Metadata_Score = pymmcore.g_Keyword_Metadata_Score
+    Metadata_CameraLabel = pymmcore.g_Keyword_Metadata_CameraLabel
+    Metadata_Exposure = pymmcore.g_Keyword_Metadata_Exposure
+    Metadata_Height = pymmcore.g_Keyword_Metadata_Height
     Metadata_ImageNumber = pymmcore.g_Keyword_Metadata_ImageNumber
     Metadata_ROI_X = pymmcore.g_Keyword_Metadata_ROI_X
     Metadata_ROI_Y = pymmcore.g_Keyword_Metadata_ROI_Y
+    Metadata_Score = pymmcore.g_Keyword_Metadata_Score
     Metadata_TimeInCore = pymmcore.g_Keyword_Metadata_TimeInCore
+    Metadata_Width = pymmcore.g_Keyword_Metadata_Width
 
     def __str__(self) -> str:
         return str(self.value)
@@ -165,7 +170,9 @@ class PropertyType(IntEnum):
     String = pymmcore.String
     Float = pymmcore.Float
     Integer = pymmcore.Integer
+
     Boolean = auto()  # not supported in pymmcore
+    Enum = auto()  # not supported in pymmcore
 
     def to_python(self) -> type | None:
         return {0: None, 1: str, 2: float, 3: int}[self]
@@ -183,7 +190,16 @@ class PropertyType(IntEnum):
         if value is None:
             return PropertyType.Undef
         if isinstance(value, str):
-            return PropertyType[value.lower().capitalize()]
+            if value.lower() in ("int", "integer"):
+                return PropertyType.Integer
+            if value.lower() in ("float", "double"):
+                return PropertyType.Float
+            if value.lower() in ("bool", "boolean"):
+                return PropertyType.Boolean
+            if value.lower() in ("string", "str"):
+                return PropertyType.String
+            if value.lower() in ("enum", "enumeration"):
+                return PropertyType.Enum
         if isinstance(value, type):
             if value is float:
                 return PropertyType.Float
@@ -193,6 +209,8 @@ class PropertyType(IntEnum):
                 return PropertyType.String
             elif value is bool:
                 return PropertyType.Boolean
+            elif issubclass(value, Enum):
+                return PropertyType.Enum
 
         raise TypeError(
             f"Property type must be a PropertyType enum member, "

{pymmcore_plus-0.14.0 → pymmcore_plus-0.15.0}/src/pymmcore_plus/core/_mmcore_plus.py

@@ -13,9 +13,18 @@ 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, cast, overload
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    NamedTuple,
+    TypeVar,
+    cast,
+    overload,
+)
 
 from psygnal import SignalInstance
+from typing_extensions import deprecated
 
 import pymmcore_plus._pymmcore as pymmcore
 from pymmcore_plus._logger import current_logfile, logger
@@ -42,7 +51,7 @@ from .events import CMMCoreSignaler, PCoreSignaler, _get_auto_core_callback_clas
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator, Sequence
-    from typing import Literal, TypeAlias, TypedDict, Union, Unpack
+    from typing import Literal, Never, TypeAlias, TypedDict, Union, Unpack
 
     import numpy as np
     from pymmcore import DeviceLabel
@@ -274,7 +283,7 @@ class CMMCorePlus(pymmcore.CMMCore):
 
         self._events = _get_auto_core_callback_class()()
         self._callback_relay = MMCallbackRelay(self.events)
-        self.registerCallback(self._callback_relay)
+        super().registerCallback(self._callback_relay)
 
         self._mda_runner = MDARunner()
         self._mda_runner.set_engine(MDAEngine(self))
@@ -287,6 +296,24 @@ class CMMCorePlus(pymmcore.CMMCore):
         self._weak_clean = weakref.WeakMethod(self.unloadAllDevices)
         atexit.register(self._weak_clean)
 
+    @deprecated(
+        "registerCallback is disallowed in pymmcore-plus.  Use .events instead."
+    )
+    def registerCallback(self, *_: Never) -> Never:  # type: ignore[override]
+        """*registerCallback is disallowed in pymmcore-plus!*
+
+        If you want to connect callbacks to events, use the
+        [`CMMCorePlus.events`][pymmcore_plus.CMMCorePlus.events] property instead.
+        """  # noqa
+        raise RuntimeError(
+            dedent("""
+            This method is disallowed in pymmcore-plus.
+
+            If you want to connect callbacks to events, use the
+            `CMMCorePlus.events` property instead.
+            """)
+        )
+
     @property
     def events(self) -> PCoreSignaler:
         """Signaler for core events.
@@ -300,14 +327,20 @@ class CMMCorePlus(pymmcore.CMMCore):
         return self._events
 
     def __repr__(self) -> str:
-        return f"<{type(self).__name__} at {hex(id(self))}>"
+        """Return a string representation of the core object."""
+        ndevices = len(self.getLoadedDevices()) - 1
+        return f"<{type(self).__name__} at {hex(id(self))} with {ndevices} devices>"
 
     def __del__(self) -> None:
         if hasattr(self, "_weak_clean"):
             atexit.unregister(self._weak_clean)
-        self.unloadAllDevices()
-        # clean up logging
-        self.setPrimaryLogFile("")
+        try:
+            super().registerCallback(None)  # type: ignore
+            self.reset()
+            # clean up logging
+            self.setPrimaryLogFile("")
+        except Exception as e:
+            logger.exception("Error during CMMCorePlus.__del__(): %s", e)
 
     # Re-implemented methods from the CMMCore API
 
@@ -691,9 +724,9 @@ class CMMCorePlus(pymmcore.CMMCore):
         """
         md = Metadata()
         if channel is not None and slice is not None:
-            img = super().getLastImageMD(channel, slice, md)
+            img = self.getLastImageMD(channel, slice, md)
         else:
-            img = super().getLastImageMD(md)
+            img = self.getLastImageMD(md)
         return (self.fixImage(img) if fix and not pymmcore.NANO else img, md)
 
     @overload
@@ -735,7 +768,7 @@ class CMMCorePlus(pymmcore.CMMCore):
             Image and metadata
         """
         md = Metadata()
-        img = super().popNextImageMD(channel, slice, md)
+        img = self.popNextImageMD(channel, slice, md)
         return (self.fixImage(img) if fix and not pymmcore.NANO else img, md)
 
     def popNextImage(self, *, fix: bool = True) -> np.ndarray:
@@ -779,7 +812,7 @@ class CMMCorePlus(pymmcore.CMMCore):
             will be reshaped to (w, h, n_components) using `fixImage`.
         """
         md = Metadata()
-        img = super().getNBeforeLastImageMD(n, md)
+        img = self.getNBeforeLastImageMD(n, md)
         return self.fixImage(img) if fix and not pymmcore.NANO else img, md
 
     def setConfig(self, groupName: str, configName: str) -> None:
@@ -1534,7 +1567,7 @@ class CMMCorePlus(pymmcore.CMMCore):
     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:
+    def setXYPosition(self, *args: Any) -> None:
         """Sets the position of the XY stage in microns.
 
         **Why Override?** to store the last commanded stage position internally.
@@ -1543,10 +1576,10 @@ class CMMCorePlus(pymmcore.CMMCore):
             label: str | None = None
             x, y = cast("tuple[float, float]", args)
         elif len(args) == 3:
-            label, x, y = args  # type: ignore
+            label, x, y = args
         else:
             raise ValueError("Invalid number of arguments. Expected 2 or 3.")
-        super().setXYPosition(*args)  # type: ignore
+        super().setXYPosition(*args)
         self._last_xy_position[label] = (x, y)
 
     def getZPosition(self) -> float:
@@ -1592,7 +1625,7 @@ class CMMCorePlus(pymmcore.CMMCore):
         if autoshutter := self.getAutoShutter():
             self.events.propertyChanged.emit(self.getShutterDevice(), "State", True)
         try:
-            super().snapImage()
+            self._do_snap_image()
             self.events.imageSnapped.emit()
         finally:
             if autoshutter:
@@ -1877,15 +1910,12 @@ class CMMCorePlus(pymmcore.CMMCore):
         **Why Override?** To emit a `startContinuousSequenceAcquisition` event.
         """
         self.events.continuousSequenceAcquisitionStarting.emit()
-        super().startContinuousSequenceAcquisition(intervalMs)
+        self._do_start_continuous_sequence_acquisition(intervalMs)
         self.events.continuousSequenceAcquisitionStarted.emit()
 
     @overload
     def startSequenceAcquisition(
-        self,
-        numImages: int,
-        intervalMs: float,
-        stopOnOverflow: bool,
+        self, numImages: int, intervalMs: float, stopOnOverflow: bool, /
     ) -> None: ...
 
     @overload
@@ -1895,9 +1925,10 @@ class CMMCorePlus(pymmcore.CMMCore):
         numImages: int,
         intervalMs: float,
         stopOnOverflow: bool,
+        /,
     ) -> None: ...
 
-    def startSequenceAcquisition(self, *args: Any, **kwargs: Any) -> None:
+    def startSequenceAcquisition(self, *args: Any) -> None:
         """Starts streaming camera sequence acquisition.
 
         This command does not block the calling thread for the duration of the
@@ -1906,18 +1937,16 @@ class CMMCorePlus(pymmcore.CMMCore):
         **Why Override?** To emit a `startSequenceAcquisition` event.
         """
         if len(args) == 3:
-            numImages, intervalMs, stopOnOverflow = args
-            cameraLabel = super().getCameraDevice()
-        else:
-            cameraLabel, numImages, intervalMs, stopOnOverflow = args
+            args = (self.getCameraDevice(), *args)
+        elif len(args) != 4:
+            raise ValueError(
+                "startSequenceAcquisition requires either 3 or 4 arguments, "
+                f"got {len(args)}."
+            )
 
-        self.events.sequenceAcquisitionStarting.emit(
-            cameraLabel, numImages, intervalMs, stopOnOverflow
-        )
-        super().startSequenceAcquisition(*args, **kwargs)
-        self.events.sequenceAcquisitionStarted.emit(
-            cameraLabel, numImages, intervalMs, stopOnOverflow
-        )
+        self.events.sequenceAcquisitionStarting.emit(*args)
+        self._do_start_sequence_acquisition(*args)
+        self.events.sequenceAcquisitionStarted.emit(*args)
 
     def stopSequenceAcquisition(self, cameraLabel: str | None = None) -> None:
         """Stops streaming camera sequence acquisition.
@@ -1926,13 +1955,32 @@ class CMMCorePlus(pymmcore.CMMCore):
 
         **Why Override?** To emit a `stopSequenceAcquisition` event.
         """
-        if cameraLabel is None:
-            super().stopSequenceAcquisition()
-        else:
-            super().stopSequenceAcquisition(cameraLabel)
         cameraLabel = cameraLabel or super().getCameraDevice()
+        self._do_stop_sequence_acquisition(cameraLabel)
         self.events.sequenceAcquisitionStopped.emit(cameraLabel)
 
+    # here for ease of overriding in Unicore ---------------------
+
+    def _do_snap_image(self) -> None:
+        super().snapImage()
+
+    def _do_start_sequence_acquisition(
+        self, cameraLabel: str, numImages: int, intervalMs: float, stopOnOverflow: bool
+    ) -> None:
+        super().startSequenceAcquisition(
+            cameraLabel, numImages, intervalMs, stopOnOverflow
+        )
+
+    def _do_start_continuous_sequence_acquisition(self, intervalMs: float) -> None:
+        """Starts the actual continuous sequence acquisition process."""
+        super().startContinuousSequenceAcquisition(intervalMs)
+
+    def _do_stop_sequence_acquisition(self, cameraLabel: str) -> None:
+        """Stops the actual sequence acquisition process."""
+        super().stopSequenceAcquisition(cameraLabel)
+
+    # end of Unicore helpers ---------------------
+
     def setAutoFocusOffset(self, offset: float) -> None:
         """Applies offset the one-shot focusing device.
 
@@ -2147,21 +2195,29 @@ class CMMCorePlus(pymmcore.CMMCore):
             return list(xs), list(ys), list(ws), list(hs)
 
     @overload
-    def setROI(self, x: int, y: int, width: int, height: int) -> None: ...
+    def setROI(self, x: int, y: int, width: int, height: int, /) -> None: ...
 
     @overload
-    def setROI(self, label: str, x: int, y: int, width: int, height: int) -> None: ...
+    def setROI(
+        self, label: str, x: int, y: int, width: int, height: int, /
+    ) -> None: ...
 
-    def setROI(self, *args: Any, **kwargs: Any) -> None:
+    def setROI(self, *args: Any) -> None:
         """Set the camera Region of Interest (ROI).
 
         **Why Override?** To emit a `roiSet` event.
         """
-        super().setROI(*args, **kwargs)
         if len(args) == 4:
             args = (super().getCameraDevice(), *args)
+        self._do_set_roi(*args)
         self.events.roiSet.emit(*args)
 
+    # here for ease of overriding in Unicore
+
+    def _do_set_roi(self, label: str, x: int, y: int, width: int, height: int) -> None:
+        """Internal method to set the ROI for a specific camera device."""
+        super().setROI(label, x, y, width, height)
+
     def setChannelGroup(self, channelGroup: str) -> None:
         """Specifies the group determining the channel selection.
 

{pymmcore_plus-0.14.0 → pymmcore_plus-0.15.0}/src/pymmcore_plus/core/events/_protocol.py

@@ -1,4 +1,15 @@
-from typing import Any, Callable, Optional, Protocol, Union, runtime_checkable
+from __future__ import annotations
+
+from typing import (
+    Any,
+    Callable,
+    ClassVar,
+    Protocol,
+    overload,
+    runtime_checkable,
+)
+
+from typing_extensions import Self
 
 
 @runtime_checkable
@@ -12,7 +23,7 @@ class PSignalInstance(Protocol):
     def connect(self, slot: Callable) -> Any:
         """Connect slot to this signal."""
 
-    def disconnect(self, slot: Optional[Callable] = None) -> Any:
+    def disconnect(self, slot: Callable | None = None) -> Any:
         """Disconnect slot from this signal.
 
         If `None`, all slots should be disconnected.
@@ -23,14 +34,18 @@ class PSignalInstance(Protocol):
 
 
 @runtime_checkable
-class PSignalDescriptor(Protocol):
+class PSignal(Protocol):
     """Descriptor that returns a signal instance."""
 
-    def __get__(self, instance: Optional[Any], owner: Any) -> PSignalInstance:
+    @overload
+    def __get__(self, instance: None, owner: type, /) -> Self: ...
+    @overload
+    def __get__(self, instance: Any, owner: type | None = None, /) -> Any: ...
+    def __get__(
+        self, instance: Any, owner: type | None = ..., /
+    ) -> PSignalInstance | PSignal:
         """Returns the signal instance for this descriptor."""
-
-
-PSignal = Union[PSignalDescriptor, PSignalInstance]
+        ...
 
 
 @runtime_checkable
@@ -91,102 +106,102 @@ class PCoreSignaler(Protocol):
     """
 
     # native MMCore callback events
-    propertiesChanged: PSignal
+    propertiesChanged: ClassVar[PSignal]
     """Emits with no arguments when properties have changed."""
-    propertyChanged: PSignal
+    propertyChanged: ClassVar[PSignal]
     """Emits `(name: str, : propName: str, propValue: str)` when a specific property has changed."""  # noqa: E501
-    channelGroupChanged: PSignal
+    channelGroupChanged: ClassVar[PSignal]
     """Emits `(newChannelGroupName: str)` when a channel group has changed."""
-    configGroupChanged: PSignal
+    configGroupChanged: ClassVar[PSignal]
     """Emits `(groupName: str, newConfigName: str)` when a config group has changed."""
-    systemConfigurationLoaded: PSignal
+    systemConfigurationLoaded: ClassVar[PSignal]
     """Emits with no arguments when the system configuration has been loaded."""
-    pixelSizeChanged: PSignal
+    pixelSizeChanged: ClassVar[PSignal]
     """Emits `(newPixelSizeUm: float)` when the pixel size has changed."""
-    pixelSizeAffineChanged: PSignal
+    pixelSizeAffineChanged: ClassVar[PSignal]
     """Emits `(float, float, float, float, float, float)` when the pixel size affine has changed."""  # noqa: E501
-    stagePositionChanged: PSignal
+    stagePositionChanged: ClassVar[PSignal]
     """Emits `(name: str, pos: float)` when a stage position has changed."""
-    XYStagePositionChanged: PSignal
+    XYStagePositionChanged: ClassVar[PSignal]
     """Emits `(name: str, xpos: float, ypos: float)` when an XY stage position has changed."""  # noqa: E501
-    xYStagePositionChanged: PSignal  # alias
-    exposureChanged: PSignal
+    xYStagePositionChanged: ClassVar[PSignal]  # alias
+    exposureChanged: ClassVar[PSignal]
     """Emits `(name: str, newExposure: float)` when an exposure has changed."""
-    SLMExposureChanged: PSignal
+    SLMExposureChanged: ClassVar[PSignal]
     """Emits `(name: str, newExposure: float)` when the exposure of the SLM device changes."""  # noqa: E501
-    sLMExposureChanged: PSignal  # alias
+    sLMExposureChanged: ClassVar[PSignal]  # alias
 
     # added for CMMCorePlus
-    configSet: PSignal
+    configSet: ClassVar[PSignal]
     """Emits `(str, str)` when a config has been set.
 
     > :sparkles: This signal is unique to `pymmcore-plus`.
     """
-    imageSnapped: PSignal
+    imageSnapped: ClassVar[PSignal]
     """Emits with no arguments whenever snap is called.
 
     > :sparkles: This signal is unique to `pymmcore-plus`.
     """
-    mdaEngineRegistered: PSignal
+    mdaEngineRegistered: ClassVar[PSignal]
     """Emits `(MDAEngine, MDAEngine)` when an MDAEngine is registered.
 
     > :sparkles: This signal is unique to `pymmcore-plus`.
     """
 
-    continuousSequenceAcquisitionStarting: PSignal
+    continuousSequenceAcquisitionStarting: ClassVar[PSignal]
     """Emits with no arguments *before* continuous sequence acquisition is started.
 
     > :sparkles: This signal is unique to `pymmcore-plus`.
     """
-    continuousSequenceAcquisitionStarted: PSignal
+    continuousSequenceAcquisitionStarted: ClassVar[PSignal]
     """Emits with no arguments *after* continuous sequence acquisition has started.
 
     > :sparkles: This signal is unique to `pymmcore-plus`.
     """
-    sequenceAcquisitionStarting: PSignal
+    sequenceAcquisitionStarting: ClassVar[PSignal]
     """Emits `(str, int, float, bool)` *before* sequence acquisition is started.
 
     (cameraLabel, numImages, intervalMs, stopOnOverflow)
     > :sparkles: This signal is unique to `pymmcore-plus`.
     """
-    sequenceAcquisitionStarted: PSignal
+    sequenceAcquisitionStarted: ClassVar[PSignal]
     """Emits `(str, int, float, bool)` *after* sequence acquisition has started.
 
     (cameraLabel, numImages, intervalMs, stopOnOverflow)
     > :sparkles: This signal is unique to `pymmcore-plus`.
     """
-    sequenceAcquisitionStopped: PSignal
+    sequenceAcquisitionStopped: ClassVar[PSignal]
     """Emits `(str)` when sequence acquisition is stopped.
 
     > :sparkles: This signal is unique to `pymmcore-plus`.
     """
-    autoShutterSet: PSignal
+    autoShutterSet: ClassVar[PSignal]
     """Emits `(bool)` when the auto shutter setting is changed.
 
     """
-    configGroupDeleted: PSignal
+    configGroupDeleted: ClassVar[PSignal]
     """Emits `(str)` when a config group is deleted.
 
     > :sparkles: This signal is unique to `pymmcore-plus`.
     """
-    configDeleted: PSignal
+    configDeleted: ClassVar[PSignal]
     """Emits `(str, str)` when a config is deleted.
 
     > :sparkles: This signal is unique to `pymmcore-plus`.
     """
-    configDefined: PSignal
+    configDefined: ClassVar[PSignal]
     """Emits `(str, str, str, str, str)` when a config is defined.
 
     > :sparkles: This signal is unique to `pymmcore-plus`.
     """
-    roiSet: PSignal
+    roiSet: ClassVar[PSignal]
     """Emits `(str, int, int, int, int)` when an ROI is set.
 
     > :sparkles: This signal is unique to `pymmcore-plus`.
     """
 
     def devicePropertyChanged(
-        self, device: str, property: Optional[str] = None
+        self, device: str, property: str | None = None
     ) -> PSignalInstance:
         """Return object to connect/disconnect to device/property-specific changes.
 

{pymmcore_plus-0.14.0 → pymmcore_plus-0.15.0}/src/pymmcore_plus/core/events/_psygnal.py

@@ -38,9 +38,9 @@ class CMMCoreSignaler(SignalGroup, _DevicePropertyEventMixin):
 
     # aliases for lower casing
     @property
-    def xYStagePositionChanged(self) -> SignalInstance:  # type: ignore
+    def xYStagePositionChanged(self) -> SignalInstance:
         return self.XYStagePositionChanged
 
     @property
-    def sLMExposureChanged(self) -> SignalInstance:  # type: ignore
+    def sLMExposureChanged(self) -> SignalInstance:
         return self.SLMExposureChanged

{pymmcore_plus-0.14.0 → pymmcore_plus-0.15.0}/src/pymmcore_plus/experimental/unicore/__init__.py

@@ -1,12 +1,18 @@
-from ._unicore import UniMMCore
+from .core._unicore import UniMMCore
+from .devices._camera import Camera
 from .devices._device import Device
 from .devices._properties import PropertyInfo, pymm_property
+from .devices._slm import SLMDevice
 from .devices._stage import StageDevice, XYStageDevice, XYStepperStageDevice
+from .devices._state import StateDevice
 
 __all__ = [
+    "Camera",
     "Device",
     "PropertyInfo",
+    "SLMDevice",
     "StageDevice",
+    "StateDevice",
     "UniMMCore",
     "XYStageDevice",
     "XYStepperStageDevice",

{pymmcore_plus-0.14.0 → pymmcore_plus-0.15.0}/src/pymmcore_plus/experimental/unicore/_proxy.py

@@ -106,22 +106,39 @@ def create_proxy(
     ```
     """
     sub_proxies = sub_proxies or {}
+
+    # Get all public attribute names from the protocol (both from dir() and type hints)
     allowed_names = {
         x
         for x in chain(dir(protocol), get_type_hints(protocol))
-        if not x.startswith("_")
+        if not x.startswith("_")  # Exclude private/dunder attributes
     }
+
+    # Create an immutable module to act as our proxy object
     proxy = _ImmutableModule(protocol.__name__)
+
+    # Iterate through each allowed attribute name
     for attr_name in allowed_names:
+        # Get the actual attribute from the source object
         attr = getattr(obj, attr_name)
+
+        # Check if this attribute should be sub-proxied
         if subprotocol := sub_proxies.get(attr_name):
-            # look for nested sub-proxies on attr_name, e.g. `attr_name.sub_attr`
+            # Look for nested sub-proxies on attr_name, e.g. `attr_name.sub_attr`
+            # Filter sub_proxies for keys that start with "attr_name."
             sub = {
-                k.split(".", 1)[1]: v
+                k.split(".", 1)[1]: v  # Remove the "attr_name." prefix
                 for k, v in sub_proxies.items()
                 if k.startswith(f"{attr_name}.")
             }
+            # Recursively create a proxy for this attribute
             attr = create_proxy(attr, subprotocol, sub)
+
+        # Set the attribute on our proxy object
         setattr(proxy, attr_name, attr)
+
+    # Freeze the proxy to prevent further modifications
     proxy.__frozen__ = True
+
+    # Return the proxy cast to the expected protocol type
     return cast("T", proxy)