napari-nninteractive 2.2.0__tar.gz → 2.3.2__tar.gz

{napari_nninteractive-2.2.0/src/napari_nninteractive.egg-info → napari_nninteractive-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: napari-nninteractive
-Version: 2.2.0
+Version: 2.3.2
 Summary: nnInteractive plugin for Napari
 Author: Lars Krämer, Fabian Isensee, Maximilian Rokuss
 Author-email: lars.kraemer@dkfz-heidelberg.de, f.isensee@dkfz-heidelberg.de, maximilian.rokuss@dkfz-heidelberg.de
@@ -231,7 +231,7 @@ Requires-Dist: qtpy
 Requires-Dist: napari-nifti
 Requires-Dist: huggingface_hub
 Requires-Dist: hf_transfer
-Requires-Dist: nnInteractive>=2.3.0
+Requires-Dist: nnInteractive>=2.4.0
 Requires-Dist: napari_toolkit
 Provides-Extra: testing
 Requires-Dist: tox; extra == "testing"
@@ -241,7 +241,7 @@ Requires-Dist: pytest-qt; extra == "testing"
 Requires-Dist: napari; extra == "testing"
 Requires-Dist: pyqt5; extra == "testing"
 Provides-Extra: remote
-Requires-Dist: nnInteractive[client]>=2.2.0; extra == "remote"
+Requires-Dist: nnInteractive[client]>=2.4.0; extra == "remote"
 Dynamic: license-file
 
 <img src="https://github.com/MIC-DKFZ/napari-nninteractive/raw/main/imgs/nnInteractive_header.png"  width="1200">

{napari_nninteractive-2.2.0 → napari_nninteractive-2.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "napari-nninteractive"
-dynamic = ["version"]
+version = "2.3.2"
 description = "nnInteractive plugin for Napari"
 readme = "README.md"
 license = {file = "LICENSE"}
@@ -32,7 +32,7 @@ dependencies = [
     "napari-nifti",
     "huggingface_hub",
     "hf_transfer",
-    "nnInteractive>=2.3.0",
+    "nnInteractive>=2.4.0",
     "napari_toolkit",
 ]
 
@@ -46,7 +46,7 @@ testing = [
     "pyqt5",
 ]
 remote = [
-    "nnInteractive[client]>=2.2.0",
+    "nnInteractive[client]>=2.4.0",
 ]
 
 [project.entry-points."napari.manifest"]
@@ -69,9 +69,6 @@ where = ["src"]
 Homepage = "https://github.com/MIC-DKFZ/napari-nninteractive"
 Code = "https://github.com/MIC-DKFZ/napari-nninteractive"
 
-[tool.setuptools.dynamic]
-version = {attr = "napari_nninteractive.__init__.__version__"}
-
 [tool.black]
 line-length = 100
 target-version = ['py38', 'py39', 'py310']

napari_nninteractive-2.3.2/src/napari_nninteractive/__init__.py

@@ -0,0 +1,12 @@
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _version
+
+from .widget_main import nnInteractiveWidget
+
+try:
+    __version__ = _version("napari-nninteractive")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+
+__all__ = ("nnInteractiveWidget",)

napari_nninteractive-2.3.2/src/napari_nninteractive/_version_check.py

@@ -0,0 +1,78 @@
+"""Non-blocking check for newer releases of the plugin and its backend on PyPI.
+
+The network request runs in a background daemon thread so it never blocks GUI
+startup, and the result is delivered back on the GUI thread via a Qt signal.
+The check is best effort: when PyPI is unreachable (offline, behind a firewall,
+etc.) it simply stays silent instead of nagging the user.
+"""
+
+import json
+import threading
+from importlib.metadata import PackageNotFoundError, version
+from urllib.request import urlopen
+
+from qtpy.QtCore import QObject, Signal
+
+# PyPI project names to check, in display order.
+PACKAGES = ("napari-nninteractive", "nnInteractive")
+
+try:
+    from packaging.version import InvalidVersion
+    from packaging.version import parse as _parse_version
+except ImportError:  # packaging is virtually always present, but degrade gracefully
+    _parse_version = None
+    InvalidVersion = Exception
+
+
+def _installed_version(package: str):
+    """Return the installed version string, or None if the package is missing."""
+    try:
+        return version(package)
+    except PackageNotFoundError:
+        return None
+
+
+def _latest_version(package: str, timeout: float = 5.0) -> str:
+    """Return the latest release version for `package` from the PyPI JSON API."""
+    url = f"https://pypi.org/pypi/{package}/json"
+    with urlopen(url, timeout=timeout) as response:  # noqa: S310 - fixed https URL
+        data = json.load(response)
+    return data["info"]["version"]
+
+
+def _is_outdated(installed: str, latest: str) -> bool:
+    """True if `installed` is an older release than `latest`."""
+    if _parse_version is not None:
+        try:
+            return _parse_version(installed) < _parse_version(latest)
+        except InvalidVersion:
+            return False
+    # Fallback when `packaging` is unavailable: only flag an exact mismatch.
+    return installed != latest
+
+
+class VersionChecker(QObject):
+    """Checks PyPI for newer releases in a background daemon thread.
+
+    Connect to `finished`, then call `start()`. The signal carries a dict mapping
+    each package name to an `(installed, latest)` tuple; either entry may be None
+    (package not installed, or PyPI could not be reached). It is emitted from the
+    worker thread, so Qt delivers it to GUI-thread slots via a queued connection.
+    """
+
+    # Emits {package_name: (installed_or_None, latest_or_None)}
+    finished = Signal(object)
+
+    def start(self) -> None:
+        threading.Thread(target=self._run, name="nni-version-check", daemon=True).start()
+
+    def _run(self) -> None:
+        results = {}
+        for package in PACKAGES:
+            installed = _installed_version(package)
+            try:
+                latest = _latest_version(package)
+            except Exception:  # noqa: BLE001 - offline / PyPI down / bad payload: skip silently
+                latest = None
+            results[package] = (installed, latest)
+        self.finished.emit(results)

{napari_nninteractive-2.2.0 → napari_nninteractive-2.3.2}/src/napari_nninteractive/widget_controls.py

@@ -59,6 +59,12 @@ class LayerControls(BaseGUI):
         self.colormap = ColorMapper(49, seed=0.5, background_value=0)
         self._scribble_brush_size = 5
         self.object_index = 0
+        # Names of the interaction layers that committed an interaction, newest last. Used by
+        # on_undo to remove the visual marker of the most recently undone interaction. The
+        # backend supports single-level undo, so only the top entry is ever undoable; older
+        # entries stay because their interactions are still applied. None means an interaction
+        # without a layer marker (e.g. Initialize with Mask).
+        self._interaction_history = []
 
         self._viewer.layers.selection.events.active.connect(self.on_layer_selected)
 
@@ -69,6 +75,8 @@ class LayerControls(BaseGUI):
         for layer_name in layer_names:
             if layer_name in self._viewer.layers:
                 self._viewer.layers.remove(layer_name)
+        # The interaction markers are gone, so nothing is left to undo for them.
+        self._interaction_history = []
 
     def add_point_layer(self) -> None:
         """Adds a single point layer to the viewer."""
@@ -335,11 +343,12 @@ class LayerControls(BaseGUI):
             self.session_cfg["affine"].scale
         )
 
-        # Decide whether to resume the previous segmentation. We only resume
-        # after a connection loss (flag set by _handle_session_expired) and only
-        # when the surviving label layer belongs to the *same* image layer object
-        # (identity, not merely the same shape, which would be brittle). The
-        # shape check is a cheap guard against a layer that no longer matches.
+        # Decide whether to resume the previous segmentation. We only resume when
+        # the _resume_after_reconnect flag is armed -- set after a connection loss
+        # (_handle_session_expired) -- and only when the surviving label layer
+        # belongs to the *same* image layer object (identity, not merely the same
+        # shape, which would be brittle). The shape check is a cheap guard against
+        # a layer that no longer matches.
         resume = (
             getattr(self, "_resume_after_reconnect", False)
             and self.label_layer_name in self._viewer.layers
@@ -356,10 +365,15 @@ class LayerControls(BaseGUI):
         else:
             # Create the target label array and layer
             self._data_result = np.zeros(self.session_cfg["shape"], dtype=np.uint8)
-            self.object_index = 0
+            # Continue numbering/colors from any objects already segmented for this
+            # image in a previous session instead of restarting at 1.
+            self.object_index = self._next_object_index()
             if self.label_layer_name in self._viewer.layers:
                 self._viewer.layers.remove(self.label_layer_name)
             self.add_label_layer(self._data_result, self.label_layer_name)
+            # Colour the working layer to match where the counter resumes, so the
+            # in-progress object already shows its eventual colour.
+            self._viewer.layers[self.label_layer_name].colormap = self.colormap[self.object_index]
 
         # Pin the resume to this image object so a later reconnect can verify it
         # is the same image before resuming. _resuming is read by the subclass'
@@ -367,6 +381,9 @@ class LayerControls(BaseGUI):
         self._resume_image_layer = image_layer
         self._resuming = resume
 
+        # Fresh image/model pair: nothing from a previous object is undoable.
+        self._interaction_history = []
+
         # Lock the Session
         self._lock_session()
 
@@ -375,15 +392,36 @@ class LayerControls(BaseGUI):
         super().on_reset_interactions()
         self.on_layer_selected()
 
-    def on_next(self) -> None:
+    def _next_object_index(self) -> int:
+        """Continue object numbering from work already present in the viewer for
+        this image, so a new session does not restart at 1 and collide with the
+        names/colors of objects from a previous session. Considers both the
+        per-object ``object N - <name>`` layers and the values of the aggregated
+        ``semantic map - <name>`` layer. Returns 0 when nothing is present.
         """
-        Prepares the next label layer for interactions in the viewer.
-
-        Retrieves the index of the last labeled object, renames the current label layer with
-        this index, unbinds the original data by creating a deep copy, and clears all interaction
-        layers. A new label layer with an updated colormap is then added to the viewer.
+        name = self.session_cfg["name"]
+        # determine_layer_index returns max(N) + 1 over the "object N - <name>"
+        # layers (or 0 when there are none); object_index is that max, one less.
+        highest = (
+            determine_layer_index(
+                [layer.name for layer in self._viewer.layers], "object ", f" - {name}"
+            )
+            - 1
+        )
+        sem_name = f"semantic map - {name}"
+        if sem_name in self._viewer.layers:
+            highest = max(highest, int(self._viewer.layers[sem_name].data.max()))
+        return max(highest, 0)
+
+    def _store_current_object(self) -> None:
+        """Promote the in-progress label layer to a finished object.
+
+        Either as its own ``object N - <name>`` layer or, in instance-aggregation
+        mode, merged into the shared ``semantic map - <name>`` layer. Advances
+        object_index so subsequent objects keep consistent numbering and colours.
+        Shared by ``on_next`` and by the reset paths that offer to keep the
+        in-progress segmentation before tearing down the session.
         """
-        # Rename the current layer and add a new one
         label_layer = self._viewer.layers[self.label_layer_name]
         if not self.instance_aggregation_ckbx.isChecked():
 
@@ -402,7 +440,18 @@ class LayerControls(BaseGUI):
             sem_layer.refresh()
 
         self.object_index += 1
-        label_layer.colormap = self.colormap[self.object_index]
+
+    def on_next(self) -> None:
+        """
+        Prepares the next label layer for interactions in the viewer.
+
+        Retrieves the index of the last labeled object, renames the current label layer with
+        this index, unbinds the original data by creating a deep copy, and clears all interaction
+        layers. A new label layer with an updated colormap is then added to the viewer.
+        """
+        # Store the current object and recolour the working layer for the next one.
+        self._store_current_object()
+        self._viewer.layers[self.label_layer_name].colormap = self.colormap[self.object_index]
 
         self._clear_layers()
         self.prompt_button._uncheck()

{napari_nninteractive-2.2.0 → napari_nninteractive-2.3.2}/src/napari_nninteractive/widget_gui.py

@@ -30,6 +30,8 @@ from qtpy.QtWidgets import (
     QWidget,
 )
 
+from napari_nninteractive._version_check import VersionChecker, _is_outdated
+
 
 class BaseGUI(QWidget):
     """
@@ -66,15 +68,61 @@ class BaseGUI(QWidget):
 
         _ = setup_acknowledgements(_scroll_layout, width=self._width)  # Acknowledgements
 
+        # Update notice, below the logo (filled in asynchronously once PyPI has been queried).
+        self.version_status_label = QLabel("")
+        self.version_status_label.setWordWrap(True)
+        self.version_status_label.setAlignment(Qt.AlignLeft)
+        # Let the user select/copy the update command with the mouse or keyboard.
+        self.version_status_label.setTextInteractionFlags(
+            Qt.TextSelectableByMouse | Qt.TextSelectableByKeyboard
+        )
+        self.version_status_label.setVisible(False)
+        _scroll_layout.addWidget(self.version_status_label)
+
         self._unlock_session()
         self._viewer.bind_key("Ctrl+Q", self._close, overwrite=True)
 
+        # Non-blocking check for newer releases on PyPI. Kept as an attribute so
+        # it outlives __init__; the daemon thread it spawns never blocks startup.
+        self._version_checker = VersionChecker()
+        self._version_checker.finished.connect(self._on_version_check_finished)
+        self._version_checker.start()
+
     # Base Behaviour
     def _close(self):
         """Closes the viewer and quits the application."""
         self._viewer.close()
         quit()
 
+    def _on_version_check_finished(self, results: dict) -> None:
+        """Show an up-to-date / update-available notice from the PyPI check.
+
+        `results` maps each package name to an `(installed, latest)` tuple; either
+        entry may be None (package not installed or PyPI unreachable). When nothing
+        could be compared the label stays hidden rather than showing a false notice.
+        """
+        outdated = [
+            pkg
+            for pkg, (installed, latest) in results.items()
+            if installed and latest and _is_outdated(installed, latest)
+        ]
+        checkable = any(installed and latest for installed, latest in results.values())
+
+        if not checkable:
+            self.version_status_label.setVisible(False)
+            return
+
+        self.version_status_label.setVisible(True)
+        if outdated:
+            self.version_status_label.setText(
+                "Update available. Please run:\n"
+                "pip install -U nnInteractive napari-nninteractive"
+            )
+            self.version_status_label.setStyleSheet("color: #e8830c; font-weight: bold;")  # orange
+        else:
+            self.version_status_label.setText("nnInteractive is up to date")
+            self.version_status_label.setStyleSheet("color: #2e9e2e;")  # green
+
     def _unlock_session(self):
         """Unlocks the session, enabling model and image selection, and initializing controls."""
         self.init_button.setEnabled(True)
@@ -90,6 +138,7 @@ class BaseGUI(QWidget):
         self.run_ckbx.setEnabled(False)
         self.export_button.setEnabled(False)
         self.reset_interaction_button.setEnabled(False)
+        self.undo_button.setEnabled(False)
         self.propagate_ckbx.setEnabled(False)
         self.label_for_init.setEnabled(False)
         self.class_for_init.setEnabled(False)
@@ -127,6 +176,7 @@ class BaseGUI(QWidget):
         self.run_ckbx.setEnabled(True)
         self.export_button.setEnabled(True)
         self.reset_interaction_button.setEnabled(True)
+        self.undo_button.setEnabled(True)
         self.propagate_ckbx.setEnabled(True)
         self.label_for_init.setEnabled(True)
         self.class_for_init.setEnabled(True)
@@ -169,26 +219,51 @@ class BaseGUI(QWidget):
         _boxlayout = QHBoxLayout()
         _local_layout.addLayout(_boxlayout)
         self.model_selection_local = setup_lineedit(
-            _boxlayout, placeholder="Use Local Checkpoint...", function=self.on_model_selected
+            _boxlayout, placeholder="Use Local Checkpoint...", function=self.on_checkpoint_changed
         )
 
         def _reset_local_ckpt_lineedit():
             self.model_selection_local.setText("")
-            self.on_model_selected()
+            self.on_checkpoint_changed()
 
         btn = setup_iconbutton(
             _boxlayout, "", "delete_shape", self._viewer.theme, function=_reset_local_ckpt_lineedit
         )
         btn.setFixedWidth(30)
 
+        # --- Advanced (local) options --- #
+        # These are niche settings, so they live in a collapsible section that is folded
+        # by default. The fold state and the chosen values are persisted via QSettings.
+        advanced_collapsed = self._settings.value("advanced_collapsed", True, type=bool)
+        self.advanced_box, _advanced_layout = setup_vcollapsiblegroupbox(
+            _local_layout, text="Advanced", collapsed=advanced_collapsed
+        )
+
         self.use_torch_compile_ckbx = setup_checkbox(
-            _local_layout,
+            _advanced_layout,
             "use torch.compile",
-            False,
+            self._settings.value("use_torch_compile", False, type=bool),
             tooltips="If checked: enable torch.compile for local inference. The model is compiled "
             "during Initialize, so initialization takes longer, but every prediction afterwards is faster.",
         )
 
+        _storage_layout = QHBoxLayout()
+        _advanced_layout.addLayout(_storage_layout)
+        setup_label(_storage_layout, "interaction storage")
+        self.interactions_storage_combo = setup_combobox(
+            _storage_layout,
+            options=["auto", "blosc2", "tensor"],
+            tooltips="Storage backend for the interaction tensor (local inference only):\n"
+            "• auto: dense tensor for smaller images, blosc2 above ~512x512x512 (default)\n"
+            "• blosc2: much less RAM, slightly slower\n"
+            "• tensor: much more RAM, slightly faster\n"
+            "Pick blosc2 manually if you are short on RAM.",
+        )
+        saved_storage = self._settings.value("interactions_storage", "auto", type=str)
+        _storage_idx = self.interactions_storage_combo.findText(saved_storage)
+        if _storage_idx >= 0:
+            self.interactions_storage_combo.setCurrentIndex(_storage_idx)
+
         # --- Remote container --- #
         self.remote_container = QWidget()
         _remote_layout = QVBoxLayout()
@@ -251,6 +326,26 @@ class BaseGUI(QWidget):
             lambda t: self._settings.setValue("server_url", t)
         )
 
+        # Persist the advanced options (fold state + chosen values) between sessions.
+        self.advanced_box.toggled.connect(
+            lambda expanded: self._settings.setValue("advanced_collapsed", not expanded)
+        )
+        self.use_torch_compile_ckbx.toggled.connect(
+            lambda checked: self._settings.setValue("use_torch_compile", checked)
+        )
+        self.interactions_storage_combo.currentTextChanged.connect(
+            lambda t: self._settings.setValue("interactions_storage", t)
+        )
+
+        # torch.compile and interaction storage are baked into the session at Initialize.
+        # Changing one afterwards would leave the GUI out of sync with the live session, so
+        # uninitialize and force a re-Initialize -- but keep the in-progress segmentation.
+        # Wired after the construction-time restore above, so it never fires during build.
+        self.use_torch_compile_ckbx.toggled.connect(lambda *_: self.on_local_settings_changed())
+        self.interactions_storage_combo.currentTextChanged.connect(
+            lambda *_: self.on_local_settings_changed()
+        )
+
         _group_box.setLayout(_layout)
         return _group_box
 
@@ -284,6 +379,15 @@ class BaseGUI(QWidget):
         self.model_license_label.setWordWrap(True)
         _layout.addWidget(self.model_license_label)
 
+        self.undo_button = setup_iconbutton(
+            _layout,
+            "Undo",
+            "step_left",
+            self._viewer.theme,
+            self.on_undo,
+            tooltips="Undo the last interaction for the current object - press Ctrl+Z",
+            shortcut="Ctrl+Z",
+        )
         self.reset_interaction_button = setup_iconbutton(
             _layout,
             "Reset Object",
@@ -495,10 +599,19 @@ class BaseGUI(QWidget):
     def on_remote_settings_changed(self, *args, **kwargs) -> None:
         """Placeholder for handling changes to remote URL/API key fields."""
 
+    def on_local_settings_changed(self, *args, **kwargs) -> None:
+        """Placeholder for changes to baked-in local options (torch.compile / storage)."""
+
+    def on_checkpoint_changed(self, *args, **kwargs) -> None:
+        """Placeholder for edits to / clearing of the local checkpoint path."""
+
     def on_reset_interactions(self):
         """Reset only the current interaction"""
         self._clear_layers()
 
+    def on_undo(self, *args, **kwargs) -> None:
+        """Placeholder method for undoing the last interaction."""
+
     def on_next(self) -> None:
         """Resets the interactions."""
         print("_reset_interactions")

{napari_nninteractive-2.2.0 → napari_nninteractive-2.3.2}/src/napari_nninteractive/widget_main.py

@@ -45,6 +45,32 @@ class nnInteractiveWidget(LayerControls):
     """
     A widget for the nnInteractive plugin in Napari that manages model inference sessions
     and allows interactive layer-based actions.
+
+    Handling the in-progress object when a session ends
+    ---------------------------------------------------
+    Whenever a live session is torn down we have to decide what happens to the
+    object the user is currently working on (the un-committed "nnInteractive -
+    Label Layer"). The behaviour deliberately splits along *why* the session
+    ended:
+
+    * **User-triggered reinitialization** -- changing the model, the Local/Remote
+      mode, the server URL/key (``on_model_selected``), the local checkpoint
+      (``on_checkpoint_changed``) or a baked-in option such as torch.compile or
+      the interaction storage backend (``on_local_settings_changed``). The new
+      session cannot meaningfully continue the old object, so we *wrap it up*:
+      ``_store_in_progress_segmentation`` commits it as a finished object (exactly
+      like "Next Object") and the user starts fresh on the next Initialize. If
+      they don't want the stored object they can simply delete the layer.
+
+    * **Unintentional loss** -- the remote lease expired or the connection dropped
+      (``_handle_session_expired``). The user did not ask to stop, so we instead
+      *resume*: the label layer is kept and the resume machinery
+      (``_resume_after_reconnect`` / ``_resume_image_layer`` / ``_resuming``,
+      consumed in ``LayerControls.on_init``) seeds the reconnected session with it
+      so refinement continues on the same object.
+
+    In short: deliberate resets bank the work and start over; accidental drops
+    preserve and resume it.
     """
 
     def __init__(self, viewer: Viewer, parent: Optional[QWidget] = None):
@@ -64,6 +90,9 @@ class nnInteractiveWidget(LayerControls):
         self._resume_after_reconnect = False
         self._resume_image_layer = None
         self._resuming = False
+        # Checkpoint-path text the current session was built from. Lets a
+        # re-submitted, unchanged path be a no-op instead of an uninitialize.
+        self._active_checkpoint_text = None
         self._viewer.dims.events.order.connect(self.on_axis_change)
 
         # Belt-and-suspenders lease release on shutdown. closeEvent on this
@@ -163,6 +192,9 @@ class nnInteractiveWidget(LayerControls):
         # Init succeeded; clear the resume state so a normal re-init starts fresh.
         self._resume_after_reconnect = False
         self._resuming = False
+        # Remember the checkpoint text this session was built from, so re-pressing
+        # Enter on an unchanged path keeps the session instead of resetting it.
+        self._active_checkpoint_text = self.model_selection_local.text()
 
         if self._viewer.dims.not_displayed != ():
             self._scribble_brush_size = self.session.preferred_scribble_thickness[
@@ -210,6 +242,7 @@ class nnInteractiveWidget(LayerControls):
             torch_n_threads=os.cpu_count(),
             verbose=False,
             do_autozoom=self.propagate_ckbx.isChecked(),
+            interactions_storage=self.interactions_storage_combo.currentText(),
         )
 
         self.session.initialize_from_trained_model_folder(
@@ -238,32 +271,40 @@ class nnInteractiveWidget(LayerControls):
                 server_url=server_url, api_key=api_key
             )
         except ServerAtCapacityError:
-            self.remote_status_label.setText("server is full, try again later")
-            return None
-        except _SESSION_LOST_ERRORS:
-            # Extremely unlikely at /claim time, but handle for completeness.
-            self.remote_status_label.setText("server rejected the claim; try again")
+            self.remote_status_label.setText("Server full; try again later.")
             return None
+        # Connectivity problems must be handled BEFORE the session-lost case below:
+        # httpx.ConnectError/ConnectTimeout are subclasses of httpx.TransportError, so a
+        # broad TransportError catch would otherwise swallow them and report the wrong cause.
         except httpx.ConnectError:
-            self.remote_status_label.setText(f"cannot reach {server_url}")
+            # DNS failure, connection refused, no route — nothing is listening/reachable.
+            self.remote_status_label.setText("Cannot reach server; check URL/port.")
             return None
         except httpx.ConnectTimeout:
-            self.remote_status_label.setText(f"timed out reaching {server_url}")
+            self.remote_status_label.setText("Connection timed out; check URL/network.")
+            return None
+        except httpx.TimeoutException:
+            # Connected, but the server did not answer the claim in time.
+            self.remote_status_label.setText("Server not responding; try again.")
+            return None
+        except SessionExpiredError:
+            # The connection worked but the server refused/expired the claim itself.
+            self.remote_status_label.setText("Claim rejected; try again.")
             return None
         except httpx.HTTPStatusError as e:
             if e.response.status_code == 401:
-                self.remote_status_label.setText("server rejected the API key")
+                self.remote_status_label.setText("Invalid API key.")
             elif "text/html" in e.response.headers.get("content-type", ""):
-                self.remote_status_label.setText(
-                    "server returned HTML (HTTP proxy?); set NO_PROXY"
-                )
+                self.remote_status_label.setText("Not an nnInteractive server (proxy?).")
             else:
-                self.remote_status_label.setText(
-                    f"server error {e.response.status_code}"
-                )
+                self.remote_status_label.setText(f"Server error {e.response.status_code}.")
+            return None
+        except httpx.TransportError:
+            # Any other network-level failure (proxy, protocol, broken connection).
+            self.remote_status_label.setText("Network error; check connection.")
             return None
         except Exception as e:  # noqa: BLE001
-            self.remote_status_label.setText(f"error: {e}")
+            self.remote_status_label.setText(f"Error: {e}")
             return None
 
         # Honor the current auto-zoom checkbox on the remote session too.
@@ -354,8 +395,35 @@ class nnInteractiveWidget(LayerControls):
         self.remote_container.setVisible(self._remote_mode)
         self.on_model_selected()
 
+    def _store_in_progress_segmentation(self) -> None:
+        """Before a genuine reset (model / mode / server change) drops the session,
+        store the object currently being worked on.
+
+        A genuine reset starts a fresh session, so the in-progress segmentation
+        cannot be resumed (unlike a reconnect or a baked-in option change). Rather
+        than silently discarding it, store it as a finished object - exactly like
+        'Next Object' does. The user can delete the stored object manually if they
+        do not want it. The working layer is then removed: its data has already
+        been copied into the stored object, and removing it prevents the same
+        object being stored twice if the user resets again before re-initializing.
+
+        Does nothing when there is no non-empty in-progress segmentation.
+        """
+        if (
+            self.session_cfg is None
+            or self.label_layer_name not in self._viewer.layers
+            or not np.any(self._viewer.layers[self.label_layer_name].data)
+        ):
+            return
+
+        self._store_current_object()
+        self._viewer.layers.remove(self.label_layer_name)
+
     def on_model_selected(self):
         """Reset the current session completely"""
+        # A genuine reset cannot resume the in-progress object, so store it as a
+        # finished object before the session is gone instead of losing it.
+        self._store_in_progress_segmentation()
         super().on_model_selected()
         self.session = None
         # Genuine reset: the previous model's license no longer applies.
@@ -366,6 +434,50 @@ class nnInteractiveWidget(LayerControls):
         self._resume_after_reconnect = False
         self._resume_image_layer = None
 
+    def _uninitialize_storing_segmentation(self) -> bool:
+        """Drop the live session, first storing the in-progress object as a
+        finished object (like a model/mode change) instead of resuming it on the
+        next Initialize. Returns True if a session was actually torn down, False
+        when nothing was initialized.
+        """
+        if self.session is None:
+            # Nothing initialized yet, so there is nothing to store or tear down;
+            # the new value is simply picked up at the next Initialize.
+            return False
+        self._store_in_progress_segmentation()
+        self.session = None
+        self._clear_layers()
+        self._unlock_session()
+        return True
+
+    def on_local_settings_changed(self, *args, **kwargs):
+        """A baked-in local option (torch.compile / interaction storage) changed.
+
+        The live session was built with the old value, so drop it and force a
+        re-Initialize. The new session cannot resume the in-progress object, so
+        store it as a finished object first instead of discarding it. The model is
+        unchanged, so the displayed license still applies.
+        """
+        self._uninitialize_storing_segmentation()
+
+    def on_checkpoint_changed(self, *args, **kwargs):
+        """The local checkpoint path was edited or cleared (the 'x' button).
+
+        Like a settings change, drop the session and store the in-progress object
+        as a finished object before it is lost. The checkpoint may point at a
+        different model though, so drop the displayed license; on_init repopulates
+        it once the new session is up.
+        """
+        # Re-submitting the same path the live session was built from changes
+        # nothing, so leave the session initialized.
+        if (
+            self.session is not None
+            and self.model_selection_local.text() == self._active_checkpoint_text
+        ):
+            return
+        if self._uninitialize_storing_segmentation():
+            self._update_license_display(None)
+
     def on_image_selected(self):
         """Reset the current sessions interaction but keep the session itself"""
         super().on_image_selected()
@@ -499,8 +611,46 @@ class nnInteractiveWidget(LayerControls):
                     self._handle_session_expired()
                     return
 
+                # Record which layer holds this interaction's marker so on_undo can remove it.
+                self._interaction_history.append(_layer_name)
                 self._viewer.layers[self.label_layer_name].refresh()
 
+    def on_undo(self):
+        """Undo the most recent interaction for the current object.
+
+        Reverts the segmentation via the backend's single-level undo and removes the visual
+        marker of the undone interaction. Only the most recent interaction can be undone; the
+        backend re-arms so the next new interaction becomes undoable again.
+        """
+        if self.session is None:
+            return
+        if not getattr(self.session, "supports_undo", False):
+            show_warning("Undo is not supported by this server. Please update nninteractive-server.")
+            return
+        try:
+            undone = self.session.undo()
+        except _SESSION_LOST_ERRORS:
+            self._handle_session_expired()
+            return
+
+        if not undone:
+            show_warning("Nothing to undo.")
+            return
+
+        # Remove the visual marker of the undone interaction, if we tracked one.
+        if self._interaction_history:
+            layer_name = self._interaction_history.pop()
+            if layer_name is not None and layer_name in self._viewer.layers:
+                layer = self._viewer.layers[layer_name]
+                try:
+                    layer.remove_last()
+                    layer.refresh()
+                except Exception as e:  # noqa: BLE001
+                    print(f"[napari-nninteractive] could not remove last interaction marker: {e!r}")
+
+        if self.label_layer_name in self._viewer.layers:
+            self._viewer.layers[self.label_layer_name].refresh()
+
     def on_load_mask(self):
 
         _layer_data = self._viewer.layers[self.label_for_init.currentText()].data
@@ -520,6 +670,8 @@ class nnInteractiveWidget(LayerControls):
                 except _SESSION_LOST_ERRORS:
                     self._handle_session_expired()
                     return
+                # Undoable via the backend; there is no interaction-layer marker to remove.
+                self._interaction_history.append(None)
                 self._viewer.layers[self.label_layer_name].refresh()
         else:
             warnings.warn("Mask is not valid - probably its empty", UserWarning, stacklevel=1)

{napari_nninteractive-2.2.0 → napari_nninteractive-2.3.2/src/napari_nninteractive.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: napari-nninteractive
-Version: 2.2.0
+Version: 2.3.2
 Summary: nnInteractive plugin for Napari
 Author: Lars Krämer, Fabian Isensee, Maximilian Rokuss
 Author-email: lars.kraemer@dkfz-heidelberg.de, f.isensee@dkfz-heidelberg.de, maximilian.rokuss@dkfz-heidelberg.de
@@ -231,7 +231,7 @@ Requires-Dist: qtpy
 Requires-Dist: napari-nifti
 Requires-Dist: huggingface_hub
 Requires-Dist: hf_transfer
-Requires-Dist: nnInteractive>=2.3.0
+Requires-Dist: nnInteractive>=2.4.0
 Requires-Dist: napari_toolkit
 Provides-Extra: testing
 Requires-Dist: tox; extra == "testing"
@@ -241,7 +241,7 @@ Requires-Dist: pytest-qt; extra == "testing"
 Requires-Dist: napari; extra == "testing"
 Requires-Dist: pyqt5; extra == "testing"
 Provides-Extra: remote
-Requires-Dist: nnInteractive[client]>=2.2.0; extra == "remote"
+Requires-Dist: nnInteractive[client]>=2.4.0; extra == "remote"
 Dynamic: license-file
 
 <img src="https://github.com/MIC-DKFZ/napari-nninteractive/raw/main/imgs/nnInteractive_header.png"  width="1200">

{napari_nninteractive-2.2.0 → napari_nninteractive-2.3.2}/src/napari_nninteractive.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ MANIFEST.in
 README.md
 pyproject.toml
 src/napari_nninteractive/__init__.py
+src/napari_nninteractive/_version_check.py
 src/napari_nninteractive/napari.yaml
 src/napari_nninteractive/widget_controls.py
 src/napari_nninteractive/widget_gui.py

{napari_nninteractive-2.2.0 → napari_nninteractive-2.3.2}/src/napari_nninteractive.egg-info/requires.txt

@@ -4,11 +4,11 @@ qtpy
 napari-nifti
 huggingface_hub
 hf_transfer
-nnInteractive>=2.3.0
+nnInteractive>=2.4.0
 napari_toolkit
 
 [remote]
-nnInteractive[client]>=2.2.0
+nnInteractive[client]>=2.4.0
 
 [testing]
 tox

napari_nninteractive-2.2.0/src/napari_nninteractive/__init__.py

@@ -1,4 +0,0 @@
-__version__ = "2.2.0"
-from .widget_main import nnInteractiveWidget
-
-__all__ = ("nnInteractiveWidget",)