pymmcore-plus 0.15.0__py3-none-any.whl → 0.15.3__py3-none-any.whl

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)
@@ -44,3 +52,24 @@ class CMMCoreSignaler(SignalGroup, _DevicePropertyEventMixin):
     @property
     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),
+            )

pymmcore_plus/core/events/_qsignals.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING, Optional
 
 from qtpy.QtCore import QObject, Signal
 
+from ._deprecated import DeprecatedSignalProxy
 from ._prop_event_mixin import _PropertySignal
 
 if TYPE_CHECKING:
@@ -25,17 +26,23 @@ class QCoreSignaler(QObject):
     SLMExposureChanged = Signal(str, float)
     sLMExposureChanged = SLMExposureChanged  # alias
 
+    # 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()  # on snapImage()
     mdaEngineRegistered = Signal(object, object)  # new engine, old engine
     # when continuousSequenceAcquisition is started
     continuousSequenceAcquisitionStarting = Signal()
     continuousSequenceAcquisitionStarted = Signal()
-    # when SequenceAcquisition is started
-    sequenceAcquisitionStarting = Signal(str, int, float, bool)
-    sequenceAcquisitionStarted = Signal(str, int, float, bool)
-    # when (Continuous)SequenceAcquisition is stopped
-    sequenceAcquisitionStopped = Signal(str)
+
+    if TYPE_CHECKING:
+        # when SequenceAcquisition is started
+        sequenceAcquisitionStarting = Signal(str)
+
     autoShutterSet = Signal(bool)
     configGroupDeleted = Signal(str)
     configDeleted = Signal(str, str)
@@ -77,3 +84,24 @@ class QCoreSignaler(QObject):
         """
         # type ignored: can't use _DevicePropertyEventMixin due to metaclass conflict
         return _PropertySignal(self, device, property)
+
+    if not TYPE_CHECKING:
+        _sequenceAcquisitionStarting = Signal(str)
+        _sequenceAcquisitionStarted = Signal(str)
+
+        # Deprecated signal wrappers for backwards compatibility
+        @property
+        def sequenceAcquisitionStarting(self):
+            return DeprecatedSignalProxy(
+                self._sequenceAcquisitionStarting,
+                current_n_args=1,
+                deprecated_posargs=(-1, 0, False),
+            )
+
+        @property
+        def sequenceAcquisitionStarted(self):
+            return DeprecatedSignalProxy(
+                self._sequenceAcquisitionStarted,
+                current_n_args=1,
+                deprecated_posargs=(-1, 0, False),
+            )

pymmcore_plus/experimental/unicore/__init__.py

@@ -1,16 +1,20 @@
 from .core._unicore import UniMMCore
-from .devices._camera import Camera
-from .devices._device import Device
+from .devices._camera import CameraDevice
+from .devices._device_base import Device
+from .devices._generic_device import GenericDevice
 from .devices._properties import PropertyInfo, pymm_property
+from .devices._shutter import ShutterDevice
 from .devices._slm import SLMDevice
 from .devices._stage import StageDevice, XYStageDevice, XYStepperStageDevice
 from .devices._state import StateDevice
 
 __all__ = [
-    "Camera",
+    "CameraDevice",
     "Device",
+    "GenericDevice",
     "PropertyInfo",
     "SLMDevice",
+    "ShutterDevice",
     "StageDevice",
     "StateDevice",
     "UniMMCore",

pymmcore_plus/experimental/unicore/_device_manager.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, TypeVar, cast
 
 from pymmcore_plus.core._constants import DeviceInitializationState, DeviceType
 
-from .devices._device import Device
+from .devices._device_base import Device
 
 if TYPE_CHECKING:
     from collections.abc import Iterator

pymmcore_plus/experimental/unicore/core/_sequence_buffer.py

@@ -22,6 +22,11 @@ class BufferSlot(NamedTuple):
     nbytes_total: int  # full span in the pool (data + padding)
 
 
+# TODO: version that doesn't use contiguous memory,
+# but rather uses a deuqe of numpy arrays.
+class SequenceStack: ...
+
+
 class SequenceBuffer:
     """A lock-protected circular buffer backed by a single numpy byte array.
 
@@ -55,7 +60,7 @@ class SequenceBuffer:
         self._overflow_occurred: bool = False
 
         self._lock = threading.Lock()  # not re-entrant, but slightly faster than RLock
-        self._pending_slot: tuple[NDArray, int] | None = None  # only 1 outstanding slot
+        self._pending_slot: deque[tuple[NDArray, int]] = deque()
 
     # ---------------------------------------------------------------------
     # Producer API - acquire a slot, fill it, finalize it
@@ -82,10 +87,6 @@ class SequenceBuffer:
         # --- reserve space -------------------------------------------------
 
         with self._lock:
-            if self._pending_slot is not None:
-                msg = "Cannot acquire a new slot before finalizing the pending one."
-                raise RuntimeError(msg)
-
             # Calculate padding needed to align start address to dtype boundary
             align_pad = (-self._head) % dtype_.itemsize
             needed = nbytes_data + align_pad
@@ -112,7 +113,7 @@ class SequenceBuffer:
             arr: NDArray[Any] = np.ndarray(
                 shape, dtype_, buffer=self._pool, offset=start
             )
-            self._pending_slot = (arr, needed)
+            self._pending_slot.append((arr, needed))
             return arr
 
     def finalize_slot(self, metadata: Mapping[str, Any] | None = None) -> None:
@@ -123,12 +124,11 @@ class SequenceBuffer:
         slot's metadata dictionary.
         """
         with self._lock:
-            if (slot := self._pending_slot) is None:
+            if not self._pending_slot:
                 msg = "No pending slot to finalize"
                 raise RuntimeError(msg)
 
-            self._pending_slot = None
-            arr, nbytes_total = slot
+            arr, nbytes_total = self._pending_slot.popleft()
             self._slots.append(BufferSlot(arr, metadata, nbytes_total))
 
     # Convenience: copy-in one-shot insert ------------------------------
@@ -153,7 +153,7 @@ class SequenceBuffer:
     # ------------------------------------------------------------------
 
     def pop_next(
-        self, *, copy: bool = False
+        self, *, out: np.ndarray | None = None
     ) -> tuple[NDArray[Any], Mapping[str, Any]] | None:
         """Remove and return the oldest frame.
 
@@ -165,27 +165,25 @@ class SequenceBuffer:
             if not self._slots:
                 return None
             slot = self._slots.popleft()
-            self._evict_slot(slot)
 
-        if copy:
-            arr = slot.array.copy()
+        if out is not None:
+            out[:] = slot.array
+            arr = out
         else:
-            # even though we're popping, we still return a read-only view since
-            # the caller should be able to modify our _pool directly.
-            arr = slot.array.view()
-            arr.flags.writeable = False
+            arr = slot.array.copy()
+        self._evict_slot(slot)
 
         # return actual metadata, we're done with it.
         return arr, (slot.metadata or {})
 
     def peek_last(
-        self, *, copy: bool = False
+        self, *, out: np.ndarray | None = None
     ) -> tuple[NDArray[Any], Mapping[str, Any]] | None:
         """Return the newest frame without removing it."""
-        return self.peek_nth_from_last(0, copy=copy)
+        return self.peek_nth_from_last(0, out=out)
 
     def peek_nth_from_last(
-        self, n: int, *, copy: bool = False
+        self, n: int, *, out: np.ndarray | None = None
     ) -> tuple[NDArray[Any], dict[str, Any]] | None:
         """Return the n-th most recent frame without removing it.
 
@@ -195,13 +193,11 @@ class SequenceBuffer:
             if n < 0 or n >= len(self._slots):
                 return None
             slot = self._slots[-(n + 1)]
-
-            if copy:
-                arr = slot.array.copy()
+            if out is not None:
+                out[:] = slot.array
+                arr = out
             else:
-                # Return a read-only view to prevent modification of data in the buffer
-                arr = slot.array.view()
-                arr.flags.writeable = False
+                arr = slot.array.copy()
 
             # Return a copy of the metadata to avoid external modification
             return arr, (dict(slot.metadata) if slot.metadata else {})
@@ -213,7 +209,7 @@ class SequenceBuffer:
     def clear(self) -> None:
         with self._lock:
             self._slots.clear()
-            self._pending_slot = None
+            self._pending_slot.clear()
             self._head = self._tail = self._bytes_in_use = 0
             self._overflow_occurred = False
 

pymmcore_plus/experimental/unicore/core/_unicore.py

@@ -25,8 +25,9 @@ from pymmcore_plus.core import Keyword as KW
 from pymmcore_plus.core._constants import PixelType
 from pymmcore_plus.experimental.unicore._device_manager import PyDeviceManager
 from pymmcore_plus.experimental.unicore._proxy import create_core_proxy
-from pymmcore_plus.experimental.unicore.devices._camera import Camera
-from pymmcore_plus.experimental.unicore.devices._device import Device
+from pymmcore_plus.experimental.unicore.devices._camera import CameraDevice
+from pymmcore_plus.experimental.unicore.devices._device_base import Device
+from pymmcore_plus.experimental.unicore.devices._shutter import ShutterDevice
 from pymmcore_plus.experimental.unicore.devices._slm import SLMDevice
 from pymmcore_plus.experimental.unicore.devices._stage import XYStageDevice, _BaseStage
 from pymmcore_plus.experimental.unicore.devices._state import StateDevice
@@ -678,11 +679,11 @@ class UniMMCore(CMMCorePlus):
 
     # --------------------------------------------------------------------- utils
 
-    def _py_camera(self, cameraLabel: str | None = None) -> Camera | None:
+    def _py_camera(self, cameraLabel: str | None = None) -> CameraDevice | None:
         """Return the *Python* Camera for ``label`` (or current), else ``None``."""
         label = cameraLabel or self.getCameraDevice()
         if label in self._pydevices:
-            return self._pydevices.get_device_of_type(label, Camera)
+            return self._pydevices.get_device_of_type(label, CameraDevice)
         return None
 
     def setCameraDevice(self, cameraLabel: DeviceLabel | str) -> None:
@@ -751,7 +752,7 @@ class UniMMCore(CMMCorePlus):
     # ---------------------------------------------------------------- sequence common
 
     def _start_sequence(
-        self, cam: Camera, n_images: int | None, stop_on_overflow: bool
+        self, cam: CameraDevice, n_images: int | None, stop_on_overflow: bool
     ) -> None:
         """Initialise _seq state and call cam.start_sequence."""
         shape, dtype = cam.shape(), np.dtype(cam.dtype())
@@ -786,13 +787,15 @@ class UniMMCore(CMMCorePlus):
             img_number = next(counter)
             elapsed_ms = (perf_counter_ns() - start_time) / 1e6
             received = datetime.now().isoformat(sep=" ")
-            meta_update = {
-                **cam_meta,
-                KW.Metadata_TimeInCore: received,
-                KW.Metadata_ImageNumber: str(img_number),
-                KW.Elapsed_Time_ms: f"{elapsed_ms:.2f}",
-            }
-            self._seq_buffer.finalize_slot({**base_meta, **meta_update})
+            self._seq_buffer.finalize_slot(
+                {
+                    **base_meta,
+                    **cam_meta,
+                    KW.Metadata_TimeInCore: received,
+                    KW.Metadata_ImageNumber: str(img_number),
+                    KW.Elapsed_Time_ms: f"{elapsed_ms:.2f}",
+                }
+            )
 
             # Auto-stop when we've acquired the requested number of images
             if n_images is not None and (img_number + 1) >= n_images:
@@ -808,8 +811,7 @@ class UniMMCore(CMMCorePlus):
 
         self._acquisition_thread = AcquisitionThread(
             image_generator=cam.start_sequence(
-                n_images or 2**63 - 1,
-                get_buffer_with_overflow_handling,
+                n_images, get_buffer_with_overflow_handling
             ),
             finalize=finalize_with_metadata,
             label=camera_label,
@@ -823,6 +825,7 @@ class UniMMCore(CMMCorePlus):
 
     # ------------------------------------------------- startSequenceAcquisition
 
+    # startSequenceAcquisition
     def _do_start_sequence_acquisition(
         self, cameraLabel: str, numImages: int, intervalMs: float, stopOnOverflow: bool
     ) -> None:
@@ -835,6 +838,7 @@ class UniMMCore(CMMCorePlus):
 
     # ------------------------------------------------- continuous acquisition
 
+    # startContinuousSequenceAcquisition
     def _do_start_continuous_sequence_acquisition(self, intervalMs: float = 0) -> None:
         if (cam := self._py_camera()) is None:  # pragma: no cover
             return pymmcore.CMMCore.startContinuousSequenceAcquisition(self, intervalMs)
@@ -879,27 +883,41 @@ class UniMMCore(CMMCorePlus):
 
     # ---------------------------------------------------- getImages
 
-    def getLastImage(self) -> np.ndarray:
+    def getLastImage(self, *, out: np.ndarray | None = None) -> np.ndarray:
         if self._py_camera() is None:
             return super().getLastImage()
-        if not (self._seq_buffer) or (result := self._seq_buffer.peek_last()) is None:
+        if (
+            not (self._seq_buffer)
+            or (result := self._seq_buffer.peek_last(out=out)) is None
+        ):
             raise IndexError("Circular buffer is empty.")
         return result[0]
 
     @overload
     def getLastImageMD(
-        self, channel: int, slice: int, md: pymmcore.Metadata, /
+        self,
+        channel: int,
+        slice: int,
+        md: pymmcore.Metadata,
+        /,
+        *,
+        out: np.ndarray | None = None,
     ) -> np.ndarray: ...
     @overload
-    def getLastImageMD(self, md: pymmcore.Metadata, /) -> np.ndarray: ...
-    def getLastImageMD(self, *args: Any) -> np.ndarray:
+    def getLastImageMD(
+        self, md: pymmcore.Metadata, /, *, out: np.ndarray | None = None
+    ) -> np.ndarray: ...
+    def getLastImageMD(self, *args: Any, out: np.ndarray | None = None) -> np.ndarray:
         if self._py_camera() is None:
             return super().getLastImageMD(*args)
         md_object = args[0] if len(args) == 1 else args[-1]
         if not isinstance(md_object, pymmcore.Metadata):  # pragma: no cover
             raise TypeError("Expected a Metadata object for the last argument.")
 
-        if not (self._seq_buffer) or (result := self._seq_buffer.peek_last()) is None:
+        if (
+            not (self._seq_buffer)
+            or (result := self._seq_buffer.peek_last(out=out)) is None
+        ):
             raise IndexError("Circular buffer is empty.")
 
         img, md = result
@@ -910,13 +928,20 @@ class UniMMCore(CMMCorePlus):
 
         return img
 
-    def getNBeforeLastImageMD(self, n: int, md: pymmcore.Metadata, /) -> np.ndarray:
+    def getNBeforeLastImageMD(
+        self,
+        n: int,
+        md: pymmcore.Metadata,
+        /,
+        *,
+        out: np.ndarray | None = None,
+    ) -> np.ndarray:
         if self._py_camera() is None:
             return super().getNBeforeLastImageMD(n, md)
 
         if (
             not (self._seq_buffer)
-            or (result := self._seq_buffer.peek_nth_from_last(n)) is None
+            or (result := self._seq_buffer.peek_nth_from_last(n, out=out)) is None
         ):
             raise IndexError("Circular buffer is empty or n is out of range.")
 
@@ -1007,7 +1032,7 @@ class UniMMCore(CMMCorePlus):
 
         return self._seq_buffer.size_bytes // bytes_per_frame
 
-    def _predicted_bytes_per_frame(self, cam: Camera) -> int:
+    def _predicted_bytes_per_frame(self, cam: CameraDevice) -> int:
         # Estimate capacity based on camera settings and circular buffer size
         shape, dtype = cam.shape(), np.dtype(cam.dtype())
         return int(np.prod(shape) * dtype.itemsize)
@@ -1593,6 +1618,48 @@ class UniMMCore(CMMCorePlus):
             except KeyError as e:
                 raise RuntimeError(str(e)) from e  # convert to RuntimeError
 
+    # ########################################################################
+    # ------------------------ Shutter Device Methods ------------------------
+    # ########################################################################
+
+    def _py_shutter(self, shutterLabel: str | None = None) -> ShutterDevice | None:
+        """Return the *Python* Shutter device for ``label``, else ``None``."""
+        label = shutterLabel or self.getShutterDevice()
+        if label in self._pydevices:
+            return self._pydevices.get_device_of_type(label, ShutterDevice)
+        return None
+
+    def setShutterDevice(self, shutterLabel: DeviceLabel | str) -> None:
+        label = self._set_current_if_pydevice(KW.CoreShutter, shutterLabel)
+        super().setShutterDevice(label)
+
+    def getShutterDevice(self) -> DeviceLabel | Literal[""]:
+        """Returns the label of the currently selected Shutter device.
+
+        Returns empty string if no Shutter device is selected.
+        """
+        return self._pycore.current(KW.CoreShutter) or super().getShutterDevice()
+
+    @overload
+    def getShutterOpen(self) -> bool: ...
+    @overload
+    def getShutterOpen(self, shutterLabel: DeviceLabel | str) -> bool: ...
+    def getShutterOpen(self, shutterLabel: DeviceLabel | str | None = None) -> bool:
+        shutterLabel = shutterLabel or self.getShutterDevice()
+        if (shutter := self._py_shutter(shutterLabel)) is None:
+            return super().getShutterOpen(shutterLabel)
+
+        with shutter:
+            return shutter.get_open()
+
+    def _do_shutter_open(self, shutterLabel: str, state: bool, /) -> None:
+        """Open or close the shutter."""
+        if (shutter := self._py_shutter(shutterLabel)) is None:  # pragma: no cover
+            return pymmcore.CMMCore.setShutterOpen(self, shutterLabel, state)
+
+        with shutter:
+            shutter.set_open(state)
+
 
 # -------------------------------------------------------------------------------
 

pymmcore_plus/experimental/unicore/devices/_camera.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Callable, ClassVar, Literal
 
 from pymmcore_plus.core._constants import DeviceType, Keyword, PixelFormat
 
-from ._device import Device
+from ._device_base import Device
 
 if TYPE_CHECKING:
     from collections.abc import Iterator, Mapping, Sequence
@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     from numpy.typing import DTypeLike
 
 
-class Camera(Device):
+class CameraDevice(Device):
     # mandatory methods for Camera device adapters
 
     _TYPE: ClassVar[Literal[DeviceType.Camera]] = DeviceType.Camera
@@ -46,7 +46,7 @@ class Camera(Device):
     @abstractmethod
     def start_sequence(
         self,
-        n: int,
+        n: int | None,
         get_buffer: Callable[[Sequence[int], DTypeLike], np.ndarray],
     ) -> Iterator[Mapping]:
         """Start a sequence acquisition.
@@ -60,8 +60,9 @@ class Camera(Device):
 
         Parameters
         ----------
-        n : int
-            The number of images to acquire.
+        n : int | None
+            If an integer, this is the number of images to acquire.
+            If None, the camera should acquire images indefinitely until stopped.
         get_buffer : Callable[[Sequence[int], DTypeLike], np.ndarray]
             A callable that returns a buffer for the camera to fill with image data.
             You should call this with the shape of the image and the dtype
@@ -76,6 +77,10 @@ class Camera(Device):
         """
         # EXAMPLE USAGE:
         # shape, dtype = self.shape(), self.dtype()
+        # if n is None:  # acquire indefinitely until stopped
+        #    while True:
+        #        yield ...
+        #    return
         # for _ in range(n):
         #     image = get_buffer(shape, dtype)
         #     get the image from the camera, and fill the buffer in place

pymmcore_plus/experimental/unicore/devices/_generic_device.py

@@ -0,0 +1,12 @@
+from pymmcore_plus.core._constants import DeviceType
+
+from ._device_base import Device
+
+
+class GenericDevice(Device):
+    """Generic device API, e.g. for devices that don't fit into other categories.
+
+    Generic Devices generally only use the device property interface.
+    """
+
+    _TYPE = DeviceType.GenericDevice

pymmcore_plus/experimental/unicore/devices/_properties.py

@@ -21,7 +21,7 @@ if TYPE_CHECKING:
 
     from typing_extensions import Self, TypeAlias
 
-    from ._device import Device
+    from ._device_base import Device
 
     PropArg: TypeAlias = (
         PropertyType | type | Literal["float", "integer", "string", "boolean"] | None

pymmcore_plus/experimental/unicore/devices/_shutter.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+
+from pymmcore_plus.core._constants import DeviceType
+
+from ._device_base import Device
+
+
+class ShutterDevice(Device):
+    """Shutter device API, e.g. for physical shutters or electronic shutter control.
+
+    Or any 2-state device that can be either open or closed.
+    """
+
+    _TYPE = DeviceType.ShutterDevice
+
+    @abstractmethod
+    def get_open(self) -> bool:
+        """Return True if the shutter is open, False if it is closed."""
+
+    @abstractmethod
+    def set_open(self, open: bool) -> None:
+        """Set the shutter to open or closed.
+
+        Parameters
+        ----------
+        open : bool
+            True to open the shutter, False to close it.
+        """

pymmcore_plus/experimental/unicore/devices/_slm.py

@@ -7,7 +7,7 @@ from numpy.typing import DTypeLike
 
 from pymmcore_plus.core._constants import DeviceType
 
-from ._device import SequenceableDevice
+from ._device_base import SequenceableDevice
 
 
 class SLMDevice(SequenceableDevice[np.ndarray]):

pymmcore_plus/experimental/unicore/devices/_stage.py

@@ -4,7 +4,7 @@ from typing import ClassVar, Literal
 from pymmcore_plus.core import DeviceType
 from pymmcore_plus.core._constants import Keyword
 
-from ._device import SeqT, SequenceableDevice
+from ._device_base import SeqT, SequenceableDevice
 
 __all__ = ["_BaseStage"]
 

pymmcore_plus/experimental/unicore/devices/_state.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, cast
 
 from pymmcore_plus.core._constants import DeviceType, Keyword
 
-from ._device import Device
+from ._device_base import Device
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Mapping

{pymmcore_plus-0.15.0.dist-info → pymmcore_plus-0.15.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymmcore-plus
-Version: 0.15.0
+Version: 0.15.3
 Summary: pymmcore superset providing improved APIs, event handling, and a pure python acquisition engine
 Project-URL: Source, https://github.com/pymmcore-plus/pymmcore-plus
 Project-URL: Tracker, https://github.com/pymmcore-plus/pymmcore-plus/issues
@@ -30,7 +30,7 @@ Requires-Dist: numpy>=1.26.0; python_version >= '3.12'
 Requires-Dist: numpy>=2.1.0; python_version >= '3.13'
 Requires-Dist: platformdirs>=3.0.0
 Requires-Dist: psygnal>=0.10
-Requires-Dist: pymmcore>=11.2.1.71.0
+Requires-Dist: pymmcore>=11.9.0.73.0
 Requires-Dist: rich>=10.2.0
 Requires-Dist: tensorstore!=0.1.72,>=0.1.67
 Requires-Dist: tensorstore!=0.1.72,>=0.1.71; python_version >= '3.13'