pymmcore-plus 0.14.0__py3-none-any.whl → 0.15.2__py3-none-any.whl

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)
+            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,8 +1625,8 @@ class CMMCorePlus(pymmcore.CMMCore):
         if autoshutter := self.getAutoShutter():
             self.events.propertyChanged.emit(self.getShutterDevice(), "State", True)
         try:
-            super().snapImage()
-            self.events.imageSnapped.emit()
+            self._do_snap_image()
+            self.events.imageSnapped.emit(self.getCameraDevice())
         finally:
             if autoshutter:
                 self.events.propertyChanged.emit(
@@ -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.
 
@@ -1989,26 +2037,27 @@ class CMMCorePlus(pymmcore.CMMCore):
         self.events.autoShutterSet.emit(state)
 
     @overload
-    def setShutterOpen(self, state: bool) -> None: ...
-
+    def setShutterOpen(self, state: bool, /) -> None: ...
     @overload
-    def setShutterOpen(self, shutterLabel: str, state: bool) -> None: ...
-
-    def setShutterOpen(self, *args: Any, **kwargs: Any) -> None:
+    def setShutterOpen(self, shutterLabel: str, state: bool, /) -> None: ...
+    def setShutterOpen(self, *args: Any) -> None:
         """Open or close the currently selected or `shutterLabel` shutter.
 
         **Why Override?** To emit a `propertyChanged` event.
         """
-        super().setShutterOpen(*args, **kwargs)
-        shutterLabel, state = kwargs.get("shutterLabel"), kwargs.get("state")
         if len(args) == 2:
             shutterLabel, state = args
         elif len(args) == 1:
             shutterLabel = super().getShutterDevice()
             state = args[0]
+        self._do_shutter_open(shutterLabel, state)
         state = str(int(bool(state)))
         self.events.propertyChanged.emit(shutterLabel, "State", state)
 
+    def _do_shutter_open(self, shutterLabel: str, state: bool, /) -> None:
+        """Open or close the shutter."""
+        super().setShutterOpen(shutterLabel, state)
+
     @overload
     def deleteConfig(self, groupName: str, configName: str) -> None: ...
 
@@ -2147,21 +2196,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.
 
@@ -2328,8 +2385,9 @@ class CMMCorePlus(pymmcore.CMMCore):
         try:
             before = [self.getProperty(device, p) for p in properties]
         except Exception as e:
-            logger.error(
-                "Error getting properties %s on %s: %s. Cannot ensure signal emission",
+            logger.warning(
+                "Error getting properties %s on %s: %s. "
+                "Cannot ensure propertyChanged signal emission",
                 properties,
                 device,
                 e,
@@ -2506,12 +2564,9 @@ class _MMCallbackRelay(pymmcore.MMEventCallback):
         return reemit
 
 
+MMCORE_SIGNAL_NAMES = {n for n in dir(pymmcore.MMEventCallback) if n.startswith("on")}
 MMCallbackRelay = type(
     "MMCallbackRelay",
     (_MMCallbackRelay,),
-    {
-        n: _MMCallbackRelay.make_reemitter(n)
-        for n in dir(pymmcore.MMEventCallback)
-        if n.startswith("on")
-    },
+    {n: _MMCallbackRelay.make_reemitter(n) for n in MMCORE_SIGNAL_NAMES},
 )

pymmcore_plus/core/_sequencing.py

@@ -66,7 +66,7 @@ class SequencedEvent(MDAEvent):
     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
+    sequence: Optional[MDASequence] = Field(default=None, repr=False)  # noqa: UP045
 
     # all other property sequences
     property_sequences: dict[tuple[str, str], list[str]] = Field(default_factory=dict)

pymmcore_plus/core/events/_deprecated.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import inspect
+import warnings
+from typing import TYPE_CHECKING, Any, Callable
+
+if TYPE_CHECKING:
+    from ._protocol import PSignalInstance
+
+
+class DeprecatedSignalProxy:
+    def __init__(
+        self,
+        signal: PSignalInstance,
+        current_n_args: int,
+        deprecated_posargs: tuple[Any, ...],
+    ) -> None:
+        self._signal = signal
+        self._current_n_args = current_n_args
+        self._deprecated_posargs = deprecated_posargs
+        self._shims: dict[Callable, Callable] = {}
+
+    def connect(self, slot: Callable) -> Any:
+        """Connect slot to this signal."""
+        min_pos_args = sum(
+            1
+            for p in inspect.signature(slot).parameters.values()
+            if p.kind
+            in {
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.POSITIONAL_ONLY,
+            }
+            and p.default is inspect.Parameter.empty
+        )
+
+        num_extra_pos_args = min_pos_args - self._current_n_args
+        if num_extra_pos_args > 0:
+            extra_args = self._deprecated_posargs[:num_extra_pos_args]
+            warnings.warn(
+                f"Callback {slot.__name__!r} requires {min_pos_args} positional "
+                f"arguments, but this signal only supports {self._current_n_args}. "
+                "Fake arguments will be added, but this will be an exception in the "
+                "future. Please update your callback.",
+                FutureWarning,
+                stacklevel=2,
+            )
+
+            def _shim(*args: Any) -> Any:
+                slot(*args[: self._current_n_args], *extra_args)
+
+            self._shims[slot] = _shim
+            self._signal.connect(_shim)
+        else:
+            self._signal.connect(slot)
+
+    def disconnect(self, slot: Callable | None = None) -> Any:
+        """Disconnect slot from this signal.
+
+        If `None`, all slots should be disconnected.
+        """
+        if slot in self._shims:
+            slot = self._shims.pop(slot)
+        return self._signal.disconnect(slot)
+
+    def emit(self, *args: Any) -> Any:
+        """Emits the signal with the given arguments."""
+        return self._signal.emit(*args[: self._current_n_args])

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,112 @@ class PCoreSignaler(Protocol):
     """
 
     # native MMCore callback events
-    propertiesChanged: PSignal
+    propertiesChanged: ClassVar[PSignal]
     """Emits with no arguments when properties have changed."""
-    propertyChanged: PSignal
-    """Emits `(name: str, : propName: str, propValue: str)` when a specific property has changed."""  # noqa: E501
-    channelGroupChanged: PSignal
+    propertyChanged: ClassVar[PSignal]
+    """Emits `(name: str, propName: str, propValue: str)` when a specific property has changed."""  # noqa: E501
+    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
-    """Emits `(str, int, float, bool)` *before* sequence acquisition is started.
+    sequenceAcquisitionStarting: ClassVar[PSignal]
+    """Emits `(str,)` *before* sequence acquisition is started.
+
+    !!! critical "Breaking Change"
+        In `pymmcore-plus` version 0.16.0, the `sequenceAcquisitionStarting` signal
+        was *reduced* from `(str, int, float, bool)` to `(str,)` to match the signature
+        emitted by the C++ MMCore library.
 
-    (cameraLabel, numImages, intervalMs, stopOnOverflow)
+    `(cameraLabel,)`
     > :sparkles: This signal is unique to `pymmcore-plus`.
     """
-    sequenceAcquisitionStarted: PSignal
-    """Emits `(str, int, float, bool)` *after* sequence acquisition has started.
+    sequenceAcquisitionStarted: ClassVar[PSignal]
+    """Emits `(str)` *after* sequence acquisition has started.
+
+    !!! critical "Breaking Change"
+        In `pymmcore-plus` version 0.16.0, the `sequenceAcquisitionStarted` signal
+        was *reduced* from `(str, int, float, bool)` to `(str,)` to match the signature
+        emitted by the C++ MMCore library.
 
-    (cameraLabel, numImages, intervalMs, stopOnOverflow)
+    (cameraLabel,)
     > :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/core/events/_psygnal.py

@@ -1,7 +1,10 @@
+from typing import TYPE_CHECKING
+
 from psygnal import Signal, SignalGroup, SignalInstance
 
 from pymmcore_plus.mda import MDAEngine
 
+from ._deprecated import DeprecatedSignalProxy
 from ._prop_event_mixin import _DevicePropertyEventMixin
 
 
@@ -22,14 +25,19 @@ class CMMCoreSignaler(SignalGroup, _DevicePropertyEventMixin):
     exposureChanged = Signal(str, float)
     SLMExposureChanged = Signal(str, float)
 
+    # https://github.com/micro-manager/mmCoreAndDevices/pull/659
+    imageSnapped = Signal(str)  # on snapImage()
+    # when (Continuous)SequenceAcquisition is stopped
+    sequenceAcquisitionStopped = Signal(str)
+    if TYPE_CHECKING:  # see deprecated impl below
+        sequenceAcquisitionStarted = Signal(str)
+
     # added for CMMCorePlus
-    imageSnapped = Signal()  # whenever snapImage is called
     mdaEngineRegistered = Signal(MDAEngine, MDAEngine)
     continuousSequenceAcquisitionStarting = Signal()
     continuousSequenceAcquisitionStarted = Signal()
-    sequenceAcquisitionStarting = Signal(str, int, float, bool)
-    sequenceAcquisitionStarted = Signal(str, int, float, bool)
-    sequenceAcquisitionStopped = Signal(str)
+    if TYPE_CHECKING:
+        sequenceAcquisitionStarting = Signal(str)
     autoShutterSet = Signal(bool)
     configGroupDeleted = Signal(str)
     configDeleted = Signal(str, str)
@@ -38,9 +46,30 @@ 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
+
+    if not TYPE_CHECKING:
+        _sequenceAcquisitionStarting = Signal(str)
+        _sequenceAcquisitionStarted = Signal(str)
+
+        # Deprecated signal wrappers for backwards compatibility
+        @property
+        def sequenceAcquisitionStarting(self) -> SignalInstance:
+            return DeprecatedSignalProxy(
+                self._sequenceAcquisitionStarting,
+                current_n_args=1,
+                deprecated_posargs=(-1, 0, False),
+            )
+
+        @property
+        def sequenceAcquisitionStarted(self) -> SignalInstance:
+            return DeprecatedSignalProxy(
+                self._sequenceAcquisitionStarted,
+                current_n_args=1,
+                deprecated_posargs=(-1, 0, False),
+            )