feat(gui)squashed: allow alignment overwiriting with warning

Squashed commit of the following:

commit 08d66df
Author: Dusten Hubbard <dusten@utexas.edu>
Date:   Fri Jul 31 08:15:32 2026 -0500

    feat(alignments): import alignments from another series, and confirm overwrites

    Alignments > Import alignments offered .txt and SWiFT only. Taking an
    alignment from another series was reachable only through Series > Import >
    from series, the whole-series merge dialog, so a user looking for an
    alignment import did not find it. Add a "From another series (.jser)..."
    source that opens a one-tab dialog over the same Series.importTransforms
    call, and put it first in the submenu.

    Importing an alignment under a name the series already uses was rejected
    outright, which meant an alignment could not be updated in place. Allow it
    for alignments and confirm first, naming the alignments that would be
    replaced. Palettes and brightness/contrast profiles keep the rejection.

    Also renames the Alignments import submenu's attr_name from importmenu to
    importalignmentsmenu. Series > Import already claims importmenu, and
    populateMenuBar setattr()s by that key, so the two submenus were writing
    over each other on the main window.

    Adds tests/ with 24 tests over the menu row, the collision decision, the
    prompt wording, and the handler's exit paths, plus a test extra and a
    testpaths pin so collection does not reach packaging/smoke_test.py.

Author: quasiTriestino

PyReconstruct/modules/gui/dialog/__init__.py

@@ -18,6 +18,6 @@
 from .shortcuts import ShortcutsDialog
 from .backup_comment import BackupCommentDialog
 from .table_columns import TableColumnsDialog
-from .import_series import ImportSeriesDialog
+from .import_series import ImportSeriesDialog, ImportAlignmentsDialog
 from .malformed_contours import MalformedContoursDialog
-from .copy_to_sections import CopyToSectionsDialog, format_copy_result
+from .copy_to_sections import CopyToSectionsDialog, format_copy_result

PyReconstruct/modules/gui/dialog/import_series.py

@@ -23,7 +23,7 @@
 
 from .helper import BrowseWidget, MultiInput, BorderedWidget, RadioButtonGroup, resizeLineEdit
 from .quick_dialog import getLayout
-from PyReconstruct.modules.gui.utils import notify
+from PyReconstruct.modules.gui.utils import notify, notifyConfirm
 from PyReconstruct.modules.datatypes import Series
 
 
@@ -143,9 +143,10 @@ def __init__(self, parent : QWidget, series : Series, other : Series):
             "alignments",
             MultiImportAs(
                 self, 
-                other.alignments, 
-                series.alignments, 
-                "alignment"
+                other.alignments,
+                series.alignments,
+                "alignment",
+                allow_overwrite=True,
             )
         ))
 
@@ -229,6 +230,71 @@ def exec(self):
             return None, False
 
 
+class ImportAlignmentsDialog(QDialog):
+    """Import alignments, and nothing else, from another series.
+
+    The same alignments are reachable through ImportSeriesDialog's Alignments
+    tab, which is the whole-series merge: seven tabs, six of them about
+    something else. A user who only wants a colleague's alignment has to find it
+    in there, so Alignments > Import alignments offers this one-tab version too.
+    Both run the same MultiImportAs widget and therefore the same overwrite
+    prompt.
+    """
+
+    def __init__(self, parent : QWidget, series : Series, other : Series):
+        """Create the import-alignments dialog.
+
+            Params:
+                parent (QWidget): the parent widget
+                series (Series): the current series obj
+                other (Series): the series importing from
+        """
+        super().__init__(parent)
+        self.setWindowTitle("Import Alignments")
+
+        vlayout = QVBoxLayout()
+        vlayout.setSpacing(10)
+
+        vlayout.addWidget(QLabel(
+            f"Import alignments from {os.path.basename(other.jser_fp)}:",
+            self,
+        ))
+
+        self.import_widget = MultiImportAs(
+            self,
+            other.alignments,
+            series.alignments,
+            "alignment",
+            allow_overwrite=True,
+            default_to_source=True,
+        )
+        vlayout.addWidget(self.import_widget)
+
+        QBtn = QDialogButtonBox.Ok | QDialogButtonBox.Cancel
+        buttonbox = QDialogButtonBox(QBtn)
+        buttonbox.accepted.connect(self.accept)
+        buttonbox.rejected.connect(self.reject)
+        vlayout.addWidget(buttonbox)
+
+        self.setLayout(vlayout)
+        self.response = None
+
+    def accept(self):
+        """Run when user clicks OK."""
+        response, confirmed = self.import_widget.getResponse()
+        if not confirmed:
+            return  # stay open: the widget already said why
+        self.response = response
+        super().accept()
+
+    def exec(self):
+        """Run the dialog."""
+        confirmed = super().exec()
+        if confirmed:
+            return self.response, True
+        return None, False
+
+
 class ImportTracesWidget(QWidget):
 
     def __init__(self, parent, series : Series, other : Series):
@@ -494,17 +560,53 @@ def getResponse(self):
             return None, False
 
 
+def collidingImportNames(entries, existing) -> list:
+    """Return the target names in entries that already exist, in order.
+
+    Kept as a plain function (no Qt) because it is the whole decision behind the
+    overwrite prompt: warn only about names that really are already taken, and
+    name them. Duplicates are collapsed so a two-row import onto one existing
+    name reads as one collision.
+
+        Params:
+            entries (list): (source name, target name) pairs
+            existing (iterable): the names the series already uses
+        Returns:
+            (list): the colliding target names, first-seen order, deduped
+    """
+    taken = set(existing)
+    collisions = []
+    for _source, target in entries:
+        if target in taken and target not in collisions:
+            collisions.append(target)
+    return collisions
+
+
 class ImportAs(QWidget):
 
-    def __init__(self, parent=None, combo_items=[]):
-        """Create the import __ as __ widget."""
+    def __init__(self, parent=None, combo_items=[], default_to_source=False):
+        """Create the import __ as __ widget.
+
+            Params:
+                parent (QWidget): the parent widget
+                combo_items (list): the names available to import
+                default_to_source (bool): True if the target name should
+                    prefill with (and follow) the selected source name
+        """
         super().__init__(parent)
 
         # set up the inputs
         self.input_1 = QComboBox(self)
         self.input_1.addItems(combo_items)
         self.input_2 = QLineEdit("", self)
 
+        if default_to_source:
+            # importing an alignment under its own name is the common case, so
+            # prefill it and keep following the combo until the user types
+            self.input_2.setText(self.input_1.currentText())
+            self.input_1.currentTextChanged.connect(self._followSource)
+            self.input_2.textEdited.connect(self._stopFollowingSource)
+
         # set up the layout
         hlayout = QHBoxLayout()
         hlayout.addWidget(QLabel("Import", self))
@@ -513,7 +615,18 @@ def __init__(self, parent=None, combo_items=[]):
         hlayout.addWidget(self.input_2)
 
         self.setLayout(hlayout)
-    
+
+    def _followSource(self, text):
+        """Mirror the selected source name into the target field."""
+        self.input_2.setText(text)
+
+    def _stopFollowingSource(self, _text):
+        """Stop mirroring once the user has typed a name of their own."""
+        try:
+            self.input_1.currentTextChanged.disconnect(self._followSource)
+        except RuntimeError:
+            pass
+
     def getResponse(self):
         """Get the user response."""
         return (
@@ -524,19 +637,42 @@ def getResponse(self):
 
 class MultiImportAs(QWidget):
 
-    def __init__(self, parent : QWidget, other_items, self_items, name : str):
-        """Create the multi line edit widget."""
+    def __init__(
+        self,
+        parent : QWidget,
+        other_items,
+        self_items,
+        name : str,
+        allow_overwrite : bool = False,
+        default_to_source : bool = False,
+    ):
+        """Create the multi line edit widget.
+
+            Params:
+                parent (QWidget): the parent widget
+                other_items (iterable): names available in the other series
+                self_items (iterable): names already in the current series
+                name (str): what one item is called, for messages
+                allow_overwrite (bool): True if a name that already exists may
+                    be replaced after the user confirms it. False rejects the
+                    name outright, which is the behavior for palettes and
+                    brightness/contrast profiles.
+                default_to_source (bool): True if each row's target name should
+                    prefill from its source name
+        """
         super().__init__(parent)
 
         vbl = QVBoxLayout()
         self.input_layout = QVBoxLayout()
         self.other_items = other_items
         self.self_items = self_items
         self.name = name
+        self.allow_overwrite = allow_overwrite
+        self.default_to_source = default_to_source
 
         # create the inputs
         self.inputs = []
-        w = ImportAs(self, self.other_items)
+        w = ImportAs(self, self.other_items, self.default_to_source)
         self.input_layout.addWidget(w)
         self.inputs.append(w)
         vbl.addLayout(self.input_layout)
@@ -556,7 +692,7 @@ def __init__(self, parent : QWidget, other_items, self_items, name : str):
 
     def add(self):
         """Add a line edit row to the field."""
-        w = ImportAs(self, self.other_items)
+        w = ImportAs(self, self.other_items, self.default_to_source)
         self.input_layout.addWidget(w)
         self.inputs.append(w)
 
@@ -587,16 +723,37 @@ def accept(self):
             if not new_name:
                 notify("Please enter a valid name.")
                 return False
-            if new_name in self.self_items:
+            if new_name in self.self_items and not self.allow_overwrite:
                 notify(f"{self.name.capitalize()} name already exists in current series.")
                 return False
             if new_name in new_names:
                 notify(f"Cannot import multiple {self.name}s as the same name.")
                 return False
             new_names.add(new_name)
-        
+
+        collisions = collidingImportNames(entries, self.self_items)
+        if collisions and not self.confirmOverwrite(collisions):
+            return False
+
         return True
-    
+
+    def confirmOverwrite(self, collisions : list) -> bool:
+        """Ask before replacing names that already exist in this series.
+
+        Only reached when allow_overwrite is set and a target name really is
+        taken, so the prompt never fires on an import that adds new names.
+        """
+        listed = "\n".join(f"    {name}" for name in collisions)
+        plural = "s" if len(collisions) > 1 else ""
+        return notifyConfirm(
+            f"This series already has the following {self.name}{plural}:\n\n"
+            f"{listed}\n\n"
+            f"Importing under {'these names' if plural else 'this name'} will "
+            f"replace the existing {self.name}{plural} on every section.\n\n"
+            "Continue?",
+            yn=True,
+        )
+
     def getResponse(self):
         """Get the user response"""
         if self.accept():

PyReconstruct/modules/gui/main/main_imports.py

@@ -56,6 +56,7 @@
     ShortcutsDialog,
     BackupCommentDialog,
     ImportSeriesDialog,
+    ImportAlignmentsDialog,
 )
 
 from PyReconstruct.modules.gui.popup import (

PyReconstruct/modules/gui/main/main_window.py

@@ -873,6 +873,58 @@ def seriesModified(self, modified=True):
         if self.field:
             self.checkActions()
 
+    def importAlignmentsFromSeries(self, jser_fp : str = None):
+        """Import alignments from another series.
+
+        Same import that ImportSeriesDialog's Alignments tab performs, reached
+        from Alignments > Import alignments so that all three alignment sources
+        (.jser, .txt, SWiFT) sit together.
+
+            Params:
+                jser_fp (str): the filepath for the series to import from
+        """
+        if jser_fp is None:
+            jser_fp = FileDialog.get(
+                "file",
+                self,
+                "Select Series",
+                filter="*.jser"
+            )
+        if not jser_fp: return
+
+        self.saveAllData()
+
+        o_series = Series.openJser(jser_fp)
+
+        try:
+            if not checkMag(self.series, o_series):
+                return
+
+            import_as, confirmed = ImportAlignmentsDialog(
+                self, self.series, o_series
+            ).exec()
+            if not confirmed or not import_as:
+                return
+
+            self.series.importTransforms(
+                o_series,
+                import_as,
+                self.field.series_states
+            )
+        finally:
+            o_series.close()
+
+        # the alignment submenus list the series' alignments by name
+        self.createContextMenus()
+
+        # reload the section
+        self.field.reload()
+
+        # refresh the data and lists
+        self.field.table_manager.recreateTables()
+
+        notify("Alignments imported successfully.")
+
     def importTransforms(self, tforms_fp : str = None):
         """Import transforms from a text file.
         

PyReconstruct/modules/gui/main/menubar.py

@@ -275,12 +275,18 @@ def return_alignments_menu(self):
             ("changealignment_act", "Modify alignments", self.series, self.modifyAlignments),
             None,
             {
-                "attr_name": "importmenu",
+                "attr_name": "importalignmentsmenu",
                 "text": "Import alignments",
                 "opts":
                 [
-                    ("importtransforms_act", ".txt file", "", self.importTransforms),
-                    ("import_swift_transforms_act", "SWiFT project", "", self.importSwiftTransforms),
+                    ## "From another series" is first because it is the common
+                    ## case (taking a colleague's alignment) and because it was
+                    ## previously only reachable through Series > Import > from
+                    ## series, where a user looking for an alignment import does
+                    ## not think to look.
+                    ("import_jser_alignments_act", "From another series (.jser)...", "", self.importAlignmentsFromSeries),
+                    ("importtransforms_act", "From .txt file...", "", self.importTransforms),
+                    ("import_swift_transforms_act", "From SWiFT project...", "", self.importSwiftTransforms),
                 ]
             },
             None,

pyproject.toml

@@ -43,6 +43,14 @@ dependencies = [
     "packaging",
 ]
 
+[project.optional-dependencies]
+# Test-only, not shipped to end users. The suite drives the widgets through
+# PySide6 directly (a module-scoped QApplication fixture), so pytest is the
+# only addition.
+test = [
+    "pytest>=8",
+]
+
 [project.urls]
 Homepage = "https://github.com/SynapseWeb/PyReconstruct"
 
@@ -55,6 +63,13 @@ include = ["PyReconstruct*"]
 [tool.setuptools.package-data]
 PyReconstruct = ["assets/**/*", "assets/welcome_series/.welcome/*"]
 
+[tool.pytest.ini_options]
+# Collection is pinned to tests/ because packaging/smoke_test.py matches
+# pytest's default *_test.py pattern while being a standalone script: its module
+# body builds a QApplication and renders a VTK scene, which is not something a
+# collection pass should do.
+testpaths = ["tests"]
+
 [tool.setuptools_scm]
 # Tag-derived version. Writes PyReconstruct/_version.py at build time so the
 # frozen app can read its version without git or installed package metadata.