MoleditPy-linux 4.11.2__tar.gz → 4.11.4__tar.gz

{moleditpy_linux-4.11.2 → moleditpy_linux-4.11.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.11.2
+Version: 4.11.4
 Summary: A cross-platform, simple, and intuitive molecular structure editor built in Python. It allows 2D molecular drawing and 3D structure visualization. It supports exporting structure files for input to DFT calculation software.
 Author-email: HiroYokoyama <titech.yoko.hiro@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{moleditpy_linux-4.11.2 → moleditpy_linux-4.11.4}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "MoleditPy-linux"
 
-version = "4.11.2"
+version = "4.11.4"
 
 license = {file = "LICENSE"}
 

{moleditpy_linux-4.11.2 → moleditpy_linux-4.11.4}/src/MoleditPy_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.11.2
+Version: 4.11.4
 Summary: A cross-platform, simple, and intuitive molecular structure editor built in Python. It allows 2D molecular drawing and 3D structure visualization. It supports exporting structure files for input to DFT calculation software.
 Author-email: HiroYokoyama <titech.yoko.hiro@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{moleditpy_linux-4.11.2 → moleditpy_linux-4.11.4}/src/moleditpy_linux/core/molecular_data.py

@@ -438,13 +438,16 @@ class MolecularData:
                     bond.SetStereo(Chem.BondStereo.STEREOE)
                 ez_wanted[bond_idx] = "Z" if stereo_type == 3 else "E"
 
-                # Clear BondDir (wedge/dash) of adjacent single bonds assigned via coordinates to avoid label conflicts
-                b1 = final_mol.GetBondBetweenAtoms(begin_atom_idx, neigh1_idx)
-                b2 = final_mol.GetBondBetweenAtoms(end_atom_idx, neigh2_idx)
-                if b1 is not None:
-                    b1.SetBondDir(Chem.BondDir.NONE)
-                if b2 is not None:
-                    b2.SetBondDir(Chem.BondDir.NONE)
+                # Preserve explicit wedge/dash labels, including those applied later.
+                for center_idx, neighbor_idx in (
+                    (begin_atom_idx, neigh1_idx),
+                    (end_atom_idx, neigh2_idx),
+                ):
+                    adjacent = final_mol.GetBondBetweenAtoms(center_idx, neighbor_idx)
+                    if adjacent is not None and bond_stereo_info.get(
+                        adjacent.GetIdx(), {}
+                    ).get("type") not in (1, 2):
+                        adjacent.SetBondDir(Chem.BondDir.NONE)
 
         # The labels are CIP E/Z; the neighbors picked above are not always
         # the CIP-higher ones.

{moleditpy_linux-4.11.2 → moleditpy_linux-4.11.4}/src/moleditpy_linux/plugins/plugin_manager.py

@@ -16,8 +16,10 @@ import hashlib
 import importlib.util
 import json
 import logging
+import ntpath
 import os
 import shutil
+import stat
 import sys
 import zipfile
 from typing import Any, Callable, Dict, List, Optional, Tuple
@@ -164,6 +166,88 @@ class PluginManager:
         self.ensure_plugin_dir()
         QDesktopServices.openUrl(QUrl.fromLocalFile(self.plugin_dir))
 
+    @staticmethod
+    def _safe_install_path(root: str, name: str) -> str:
+        """Resolve a portable relative path strictly within an install directory."""
+        normalized = name.replace("\\", "/").rstrip("/")
+        parts = normalized.split("/")
+        reserved = {"CON", "PRN", "AUX", "NUL"} | {
+            f"{prefix}{number}" for prefix in ("COM", "LPT") for number in range(1, 10)
+        }
+        if (
+            not normalized
+            or normalized.startswith("/")
+            or ntpath.splitdrive(normalized)[0]
+            or any(
+                part in ("", ".", "..")
+                or part.endswith((".", " "))
+                or any(char in part for char in '<>:"|?*\0')
+                or part.split(".")[0].upper() in reserved
+                for part in parts
+            )
+        ):
+            raise ValueError(f"Unsafe plugin path: {name!r}")
+        destination = os.path.abspath(os.path.join(root, *parts))
+        resolved_root = os.path.normcase(os.path.realpath(root))
+        resolved_destination = os.path.normcase(os.path.realpath(destination))
+        if (
+            resolved_destination == resolved_root
+            or os.path.commonpath([resolved_root, resolved_destination])
+            != resolved_root
+        ):
+            raise ValueError(f"Plugin path escapes install directory: {name!r}")
+        return destination
+
+    def _install_zip(self, file_path: str, filename: str) -> str:
+        """Validate every archive member before removing or writing plugin files."""
+        with zipfile.ZipFile(file_path, "r") as archive:
+            members = []
+            for member in archive.infolist():
+                self._safe_install_path(self.plugin_dir, member.orig_filename)
+                if stat.S_ISLNK(member.external_attr >> 16):
+                    raise ValueError(
+                        "Plugin ZIP archives cannot contain symbolic links"
+                    )
+                members.append((member, member.filename.replace("\\", "/")))
+            if not members:
+                raise ValueError("Plugin ZIP archive is empty")
+
+            roots = {name.split("/")[0] for _, name in members}
+            nested = (
+                len(roots) == 1
+                and any("/" in name for _, name in members)
+                and next(iter(roots)) != "__init__.py"
+            )
+            folder = next(iter(roots)) if nested else os.path.splitext(filename)[0]
+            destination = self._safe_install_path(self.plugin_dir, folder)
+            relative_members = [
+                (member, name.partition("/")[2] if nested else name)
+                for member, name in members
+            ]
+            # Validate against the package boundary as well as the plugin root.
+            for _, name in relative_members:
+                if name:
+                    self._safe_install_path(destination, name)
+
+            if os.path.exists(destination):
+                if os.path.isdir(destination):
+                    shutil.rmtree(destination)
+                else:
+                    os.remove(destination)
+            os.makedirs(destination)
+            for member, name in relative_members:
+                if not name:
+                    continue
+                target = self._safe_install_path(destination, name)
+                if name.endswith("/"):
+                    os.makedirs(target, exist_ok=True)
+                else:
+                    os.makedirs(os.path.dirname(target), exist_ok=True)
+                    with archive.open(member) as source, open(target, "wb") as output:
+                        shutil.copyfileobj(source, output)
+            kind = "ZIP" if nested else "Flat ZIP"
+            return f"Installed package {folder} (from {kind})"
+
     def install_plugin(self, file_path: str) -> Tuple[bool, str]:
         """Copies a plugin file to the plugin directory. Supports .py and .zip."""
         self.ensure_plugin_dir()
@@ -174,7 +258,7 @@ class PluginManager:
 
             if os.path.isdir(file_path):
                 # Copy entire directory
-                dest_path = os.path.join(self.plugin_dir, filename)
+                dest_path = self._safe_install_path(self.plugin_dir, filename)
                 if os.path.exists(dest_path):
                     # Option 1: Overwrite (remove then copy) - safer for clean install
                     if os.path.isdir(dest_path):
@@ -190,63 +274,10 @@ class PluginManager:
                 )
                 msg = f"Installed package {filename}"
             elif filename.lower().endswith(".zip"):
-                # Extract ZIP contents
-                with zipfile.ZipFile(file_path, "r") as zf:
-                    # Smart Extraction: Check if ZIP has a single top-level folder
-                    # Fix for paths with backslashes on Windows if zip was created on Windows
-                    roots = set()
-                    root_is_dir = False
-                    for name in zf.namelist():
-                        # Normalize path separators to forward slash for consistent check
-                        name = name.replace("\\", "/")
-                        parts = name.split("/")
-                        if parts[0]:
-                            roots.add(parts[0])
-                            # Sub-entries prove the root is a folder
-                            if len(parts) > 1:
-                                root_is_dir = True
-
-                    is_nested = len(roots) == 1 and root_is_dir
-
-                    if is_nested:
-                        # Case A: ZIP contains a single folder (e.g. MyPlugin/init.py)
-                        top_folder = list(roots)[0]
-
-                        # A root named __init__.py always needs a wrapper folder
-                        if top_folder == "__init__.py":
-                            is_nested = False
-
-                    if is_nested:
-                        # Case A (Confirmed): Extract directly
-                        dest_path = os.path.join(self.plugin_dir, top_folder)
-
-                        # Clean Install: Remove existing folder to prevent stale files
-                        if os.path.exists(dest_path):
-                            if os.path.isdir(dest_path):
-                                shutil.rmtree(dest_path)
-                            else:
-                                os.remove(dest_path)
-
-                        zf.extractall(self.plugin_dir)
-                        msg = f"Installed package {top_folder} (from ZIP)"
-                    else:
-                        # Case B: ZIP is flat (e.g. file1.py, file2.py or just __init__.py)
-                        # Extract into a new folder named after the ZIP file
-                        folder_name = os.path.splitext(filename)[0]
-                        dest_path = os.path.join(self.plugin_dir, folder_name)
-
-                        if os.path.exists(dest_path):
-                            if os.path.isdir(dest_path):
-                                shutil.rmtree(dest_path)
-                            else:
-                                os.remove(dest_path)
-
-                        os.makedirs(dest_path)
-                        zf.extractall(dest_path)
-                        msg = f"Installed package {folder_name} (from Flat ZIP)"
+                msg = self._install_zip(file_path, filename)
             else:
                 # Standard file copy
-                dest_path = os.path.join(self.plugin_dir, filename)
+                dest_path = self._safe_install_path(self.plugin_dir, filename)
                 if os.path.exists(dest_path):
                     if os.path.isdir(dest_path):
                         shutil.rmtree(dest_path)
@@ -265,7 +296,9 @@ class PluginManager:
             OSError,
             ImportError,
             SyntaxError,
+            zipfile.BadZipFile,
         ) as e:
+            logging.warning("Plugin installation failed: %s", e, exc_info=True)
             return False, str(e)
 
     def discover_plugins(self, parent: Any = None) -> List[Dict[str, Any]]:

{moleditpy_linux-4.11.2 → moleditpy_linux-4.11.4}/src/moleditpy_linux/ui/base_picking_dialog.py

@@ -62,10 +62,21 @@ class BasePickingDialog(Dialog3DPickingMixin, QDialog):
         Dialog3DPickingMixin.__init__(self)
         self.mol = mol
         self.main_window = main_window
+        self._invalidated = False
+        self._geometry_refresh_timer = QTimer(self)
+        self._geometry_refresh_timer.setSingleShot(True)
+        self._geometry_refresh_timer.timeout.connect(self._refresh_geometry_display)
         self._molecule_modified = (
             False  # Track if any modifications were made during this session
         )
 
+    def invalidate_molecule(self) -> None:
+        """Close a dialog bound to a replaced molecule without recording an edit."""
+        self._invalidated = True
+        self._molecule_modified = False
+        self.setEnabled(False)
+        self.reject()
+
     def keyPressEvent(self, event: Optional[QKeyEvent]) -> None:
         """Standard keyboard handler: Enter/Return triggers 'Apply'."""
         if event is None:
@@ -80,18 +91,21 @@ class BasePickingDialog(Dialog3DPickingMixin, QDialog):
 
     def closeEvent(self, event: Optional[QCloseEvent]) -> None:
         """Cleanup on window close."""
+        self._geometry_refresh_timer.stop()
         self.clear_atom_labels()
         self.disable_picking()
         super().closeEvent(event)
 
     def reject(self) -> None:
         """Cleanup on cancel."""
+        self._geometry_refresh_timer.stop()
         self.clear_atom_labels()
         self.disable_picking()
         super().reject()
 
     def accept(self) -> None:
         """Cleanup on OK."""
+        self._geometry_refresh_timer.stop()
         self.clear_atom_labels()
         self.disable_picking()
         super().accept()
@@ -103,6 +117,8 @@ class BasePickingDialog(Dialog3DPickingMixin, QDialog):
         Update the molecule's conformer and the 3D position cache, then redraw.
         :param positions: A numpy array or dictionary of all atom positions.
         """
+        if self._invalidated:
+            return
         conf = self.mol.GetConformer()
         num_atoms = conf.GetNumAtoms()
 
@@ -138,24 +154,30 @@ class BasePickingDialog(Dialog3DPickingMixin, QDialog):
         self._molecule_modified = True
 
         # 4. Refresh display (deferred to ensure stability)
+        self._geometry_refresh_timer.start(200)
+
+        # 5. Refresh chiral/cis-trans labels if applicable
+        self.main_window.view_3d_manager.update_chiral_labels()
+
+    def _refresh_geometry_display(self) -> None:
+        """Refresh labels and rendering while this dialog still owns its molecule."""
+        if self._invalidated:
+            return
         is_dragging = getattr(self, "_slider_dragging", False)
 
         if is_dragging and hasattr(self, "show_atom_labels"):
-            QTimer.singleShot(200, self.show_atom_labels)
+            self.show_atom_labels()
         elif hasattr(self, "update_display"):
-            QTimer.singleShot(200, self.update_display)
-
-        if (
-            hasattr(self.main_window.view_3d_manager, "plotter")
-            and self.main_window.view_3d_manager.plotter
-        ):
-            QTimer.singleShot(200, self.main_window.view_3d_manager.plotter.render)
+            self.update_display()
 
-        # 5. Refresh chiral/cis-trans labels if applicable
-        self.main_window.view_3d_manager.update_chiral_labels()
+        plotter = self.main_window.view_3d_manager.plotter
+        if plotter is not None:
+            plotter.render()
 
     def _push_undo(self) -> None:
         """Centralized undo logic to push current state to the undo stack."""
+        if self._invalidated:
+            return
         self.main_window.edit_actions_manager.push_undo_state()
         self._molecule_modified = False
 

{moleditpy_linux-4.11.2 → moleditpy_linux-4.11.4}/src/moleditpy_linux/ui/calculation_worker.py

@@ -1016,7 +1016,8 @@ class CalculationWorker(QObject):
                         t = 3.0 if s == Chem.BondStereo.STEREOZ else 5.0
                         bm[satoms[0]][satoms[1]] = bm[satoms[1]][satoms[0]] = t
                 DoTriangleSmoothing(bm)
-                conf_id = rdDistGeom.EmbedMolecule(mol, bm, params)
+                params.SetBoundsMat(bm)
+                conf_id = rdDistGeom.EmbedMolecule(mol, params)
 
         if conf_id == -1:
             return False

{moleditpy_linux-4.11.2 → moleditpy_linux-4.11.4}/src/moleditpy_linux/ui/compute_logic.py

@@ -58,6 +58,7 @@ class ComputeManager:
         """Initialize ComputeManager with reference to host window."""
         self._calculating_text_actor: Any = None
         self.original_atom_properties: Dict[int, int] = {}
+        self._worker_atom_properties: Dict[int, Dict[int, int]] = {}
         self.host = host
         self.last_successful_optimization_method: Optional[str] = None
         self._active_calc_threads: List[QThread] = []
@@ -270,6 +271,7 @@ class ComputeManager:
         self.next_conversion_id = run_id + 1
         self.active_worker_ids.add(run_id)
         self._conversion_run_ids.add(run_id)
+        self._worker_atom_properties[run_id] = self.original_atom_properties.copy()
 
         # The worker only runs built-in force fields. If the selected method is a
         # plugin optimizer, pre-optimize with MMFF (RDKit) in the worker (which
@@ -336,6 +338,7 @@ class ComputeManager:
             self.halt_ids.update(wids_to_halt)
         self.active_worker_ids.clear()
         self._pending_plugin_opt.clear()
+        self._worker_atom_properties.clear()
         getattr(self, "_conversion_run_ids", set()).clear()
 
         self._restore_button_ui()
@@ -394,6 +397,11 @@ class ComputeManager:
         run_id = int(getattr(self, "next_conversion_id", 1))
         self.next_conversion_id = run_id + 1
         options["worker_id"] = run_id
+        self._worker_atom_properties[run_id] = {
+            atom.GetIdx(): atom.GetIntProp("_original_atom_id")
+            for atom in self.host.view_3d_manager.current_mol.GetAtoms()
+            if atom.HasProp("_original_atom_id")
+        }
 
         self.active_worker_ids.add(run_id)
 
@@ -601,9 +609,14 @@ class ComputeManager:
         self.host.set_current_molecule(mol)
         self.host.is_xyz_derived = False
 
-        # Restore properties
+        # MOL blocks omit custom atom properties; restore the submitting molecule's IDs.
+        atom_properties = (
+            self._worker_atom_properties.pop(worker_id, {})
+            if worker_id is not None
+            else self.original_atom_properties
+        )
         if mol:
-            for i, orig_id in self.original_atom_properties.items():
+            for i, orig_id in atom_properties.items():
                 if i < mol.GetNumAtoms():
                     mol.GetAtomWithIdx(i).SetIntProp("_original_atom_id", orig_id)
 
@@ -713,11 +726,10 @@ class ComputeManager:
         # Accept either a string or (worker_id, message) tuple from the worker signal
         if isinstance(message, tuple) and len(message) == 2:
             worker_id, msg = message
+            self._worker_atom_properties.pop(worker_id, None)
             getattr(self, "_conversion_run_ids", set()).discard(worker_id)
             if worker_id not in self.active_worker_ids:
-                # Still cleanup overlay/buttons even if stale
-                self._remove_calculating_text()
-                self._restore_button_ui()
+                # A stale worker must not reset the current calculation's UI.
                 # If it was a halt or error from a stale worker, show with ID
                 if msg == "Halt" or msg == "Halted":
                     self.host.statusBar().showMessage(  # type: ignore[union-attr]

{moleditpy_linux-4.11.2 → moleditpy_linux-4.11.4}/src/moleditpy_linux/ui/constrained_optimization_dialog.py

@@ -11,9 +11,10 @@ DOI: 10.5281/zenodo.17268532
 """
 
 import logging
-from typing import Any
+from typing import Any, Optional
 
-from PyQt6.QtCore import Qt, QThread, pyqtSignal
+import numpy as np
+from PyQt6.QtCore import Qt, QThread, pyqtSignal, pyqtSlot
 from PyQt6.QtWidgets import (
     QAbstractItemView,
     QComboBox,
@@ -28,6 +29,7 @@ from PyQt6.QtWidgets import (
     QTableWidgetItem,
     QVBoxLayout,
 )
+from rdkit import Chem
 from rdkit.Chem import rdForceFieldHelpers, rdMolTransforms
 
 from .dialog_3d_picking_mixin import Dialog3DPickingMixin
@@ -40,18 +42,32 @@ class ConstrainedOptimizationThread(QThread):
     optimization_finished = pyqtSignal()
     error_occurred = pyqtSignal(str)
 
-    def __init__(self, ff: Any, max_iters: int = 20000, parent: Any = None) -> None:
+    def __init__(
+        self,
+        ff: Any,
+        max_iters: int = 20000,
+        parent: Any = None,
+        mol: Optional[Chem.Mol] = None,
+    ) -> None:
         """Initialize constrained optimization worker thread."""
         super().__init__(parent)
         self.ff = ff
         self.max_iters = max_iters
+        # Keep the private conformer backing the force field alive during minimization.
+        self.mol = mol
 
     def run(self) -> None:
         """Execute force-field minimization and emit finished or error signal."""
         try:
-            self.ff.Minimize(maxIts=self.max_iters)
-            self.optimization_finished.emit()
+            for offset in range(0, self.max_iters, 200):
+                if self.isInterruptionRequested():
+                    return
+                if self.ff.Minimize(maxIts=min(200, self.max_iters - offset)) == 0:
+                    break
+            if not self.isInterruptionRequested():
+                self.optimization_finished.emit()
         except Exception as e:
+            logging.exception("Constrained minimization failed")
             self.error_occurred.emit(str(e))
 
 
@@ -62,14 +78,17 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
         """Initialize constrained force field optimization dialog."""
         QDialog.__init__(self, parent)
         Dialog3DPickingMixin.__init__(self)
-        self.mol = mol
+        self.mol: Chem.Mol = mol
         self.main_window = main_window
         self.selected_atoms: list[int] = []  # Using a list because order matters
         self.constraints: list[Any] = []  # (type, atoms_indices, value)
         self.constraint_labels: list[Any] = []  # 3D label actors
-        self._opt_thread: Any = None
+        self._opt_thread: Optional[ConstrainedOptimizationThread] = None
         # Closed dialogs must discard late optimization-thread results
         self._closed = False
+        self._invalidated = False
+        self._optimization_baseline: Optional[np.ndarray] = None
+        self._optimization_method = ""
         self.init_ui()
         self.enable_picking()
 
@@ -500,12 +519,19 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
 
     def apply_optimization(self) -> None:
         """Run force-field minimization with the configured constraints."""
+        if self._closed:
+            return
+        if self._opt_thread is not None:
+            if self._opt_thread.isRunning():
+                return
+            self._opt_thread = None
         if not self.mol or self.mol.GetNumConformers() == 0:
             QMessageBox.warning(self, "Error", "No valid 3D molecule found.")
             return
 
         ff_name = self.ff_combo.currentText()
-        conf = self.mol.GetConformer()
+        optimization_mol = Chem.Mol(self.mol)
+        self._optimization_baseline = self.mol.GetConformer().GetPositions().copy()
 
         try:
             ignore_interfrag = not self.main_window.init_manager.settings.get(
@@ -513,10 +539,10 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
             )
             if ff_name.startswith("MMFF"):
                 props = rdForceFieldHelpers.MMFFGetMoleculeProperties(
-                    self.mol, mmffVariant=ff_name
+                    optimization_mol, mmffVariant=ff_name
                 )
                 ff = rdForceFieldHelpers.MMFFGetMoleculeForceField(
-                    self.mol,
+                    optimization_mol,
                     props,
                     confId=0,
                     ignoreInterfragInteractions=ignore_interfrag,
@@ -526,7 +552,9 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
                 add_torsion_constraint = ff.MMFFAddTorsionConstraint
             else:  # UFF
                 ff = rdForceFieldHelpers.UFFGetMoleculeForceField(
-                    self.mol, confId=0, ignoreInterfragInteractions=ignore_interfrag
+                    optimization_mol,
+                    confId=0,
+                    ignoreInterfragInteractions=ignore_interfrag,
                 )
                 add_dist_constraint = ff.UFFAddDistanceConstraint
                 add_angle_constraint = ff.UFFAddAngleConstraint
@@ -592,17 +620,38 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
 
             self.optimize_button.setEnabled(False)
 
-            self._opt_thread = ConstrainedOptimizationThread(ff, 20000, self)
-            self._opt_thread.optimization_finished.connect(
-                lambda: self._on_optimization_finished(ff_name, conf)
+            self._opt_thread = ConstrainedOptimizationThread(
+                ff, 20000, mol=optimization_mol
             )
+            self._optimization_method = ff_name
+            self._opt_thread.optimization_finished.connect(self._on_worker_result)
             self._opt_thread.error_occurred.connect(self._on_optimization_error)
+            self._opt_thread.finished.connect(self._on_worker_finished)
+            self.main_window.edit_3d_manager.register_optimization_thread(
+                self._opt_thread
+            )
             self._opt_thread.start()
 
         except Exception as e:
             logging.exception("Failed to start optimization: %s", e)
             self.optimize_button.setEnabled(True)
 
+    @pyqtSlot()
+    def _on_worker_result(self) -> None:
+        """Receive a private conformer on the GUI thread while the dialog exists."""
+        thread = self._opt_thread
+        if thread is None or self.sender() is not thread or thread.mol is None:
+            return
+        self._on_optimization_finished(
+            self._optimization_method, thread.mol.GetConformer()
+        )
+
+    @pyqtSlot()
+    def _on_worker_finished(self) -> None:
+        """Drop the completed worker reference before its owner deletes it."""
+        if self.sender() is self._opt_thread:
+            self._opt_thread = None
+
     def _on_optimization_error(self, err_msg: str) -> None:
         """Handle optimization thread failure callback."""
         if self._closed:
@@ -622,7 +671,24 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
             logging.info("Discarding constrained optimization result after close.")
             return
         self.optimize_button.setEnabled(True)
+        current_mol = self.main_window.view_3d_manager.current_mol
+        if current_mol is None or current_mol is not self.mol:
+            logging.info("Discarding constrained optimization for a replaced molecule.")
+            return
+        if self._optimization_baseline is not None and not np.array_equal(
+            self.mol.GetConformer().GetPositions(), self._optimization_baseline
+        ):
+            status_bar = self.main_window.statusBar()
+            if status_bar is not None:
+                status_bar.showMessage(
+                    "Optimization discarded: molecule geometry changed while running."
+                )
+            return
         try:
+            live_conf = self.mol.GetConformer()
+            for i in range(self.mol.GetNumAtoms()):
+                pos = conf.GetAtomPosition(i)
+                live_conf.SetAtomPosition(i, (float(pos.x), float(pos.y), float(pos.z)))
             # Apply optimized coordinates to the main window's numpy array
             cache = self.main_window.view_3d_manager.atom_positions_3d
             for i in range(self.mol.GetNumAtoms()):
@@ -670,6 +736,8 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
             self.main_window.view_3d_manager.draw_molecule_3d(self.mol)
             self.main_window.view_3d_manager.update_chiral_labels()
             self.main_window.edit_actions_manager.push_undo_state()
+            self.main_window.state_manager.has_unsaved_changes = True
+            self.main_window.state_manager.update_window_title()
             status_bar = self.main_window.statusBar()
             if status_bar is not None:
                 status_bar.showMessage("Constrained optimization finished.")
@@ -687,6 +755,12 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
         except (AttributeError, RuntimeError, ValueError, TypeError) as e:
             logging.exception("Optimization failed: %s", e)
 
+    def invalidate_molecule(self) -> None:
+        """Discard pending work and constraints when the document is replaced."""
+        self._invalidated = True
+        self.setEnabled(False)
+        self.reject()
+
     def closeEvent(self, event: Any) -> None:
         """Delegate window close to reject."""
         self.reject()
@@ -695,9 +769,14 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
     def reject(self) -> None:
         """Clear labels, disable picking, and save constraints before closing."""
         self._closed = True
+        if self._opt_thread is not None:
+            self._opt_thread.requestInterruption()
         self.clear_constraint_labels()
         self.clear_selection_labels()
         self.disable_picking()
+        if self._invalidated:
+            super().reject()
+            return
 
         # Save constraints list to MainWindow when closing the dialog
         try: