MoleditPy-linux 4.11.3__tar.gz → 4.11.5__tar.gz

{moleditpy_linux-4.11.3 → moleditpy_linux-4.11.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.11.3
+Version: 4.11.5
 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.3 → moleditpy_linux-4.11.5}/pyproject.toml

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

{moleditpy_linux-4.11.3 → moleditpy_linux-4.11.5}/src/MoleditPy_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.11.3
+Version: 4.11.5
 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.3 → moleditpy_linux-4.11.5}/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.3 → moleditpy_linux-4.11.5}/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.3 → moleditpy_linux-4.11.5}/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:

{moleditpy_linux-4.11.3 → moleditpy_linux-4.11.5}/src/moleditpy_linux/ui/edit_3d_logic.py

@@ -20,7 +20,7 @@ from typing import Any, Dict, List, Optional
 
 import numpy as np
 import pyvista as pv
-from PyQt6.QtCore import QPointF
+from PyQt6.QtCore import QPointF, QThread, QTimer
 from PyQt6.QtGui import QColor, QFont
 from PyQt6.QtWidgets import QGraphicsTextItem
 
@@ -53,6 +53,38 @@ class Edit3DManager:
         self.is_3d_edit_mode = False
         self.dragged_atom_info = None
         self.constraints_3d: list[Any] = []
+        self._optimization_threads: set[QThread] = set()
+        self._close_after_optimization = False
+
+    def register_optimization_thread(self, thread: QThread) -> None:
+        """Own minimization workers independently of their modeless dialogs."""
+        thread.setParent(self.host)
+        self._optimization_threads.add(thread)
+        thread.finished.connect(lambda: self._release_optimization_thread(thread))
+
+    def _release_optimization_thread(self, thread: QThread) -> None:
+        """Delete completed workers and resume a deferred application close."""
+        self._optimization_threads.discard(thread)
+        thread.deleteLater()
+        if self._close_after_optimization and not self._optimization_threads:
+            self._close_after_optimization = False
+            QTimer.singleShot(0, self.host.close)
+
+    def prepare_optimization_shutdown(self) -> bool:
+        """Cancel workers and defer window destruction while minimization exits."""
+        running = [
+            thread for thread in self._optimization_threads if thread.isRunning()
+        ]
+        if not running:
+            return True
+        self._close_after_optimization = True
+        self.close_all_3d_edit_dialogs()
+        for thread in running:
+            thread.requestInterruption()
+        self.host.update_status_message(
+            "Canceling constrained optimization before closing..."
+        )
+        return False
 
     def _label_kwargs(self, kind: str) -> Dict[str, Any]:
         """add_point_labels style arguments for one label kind, from settings."""
@@ -93,6 +125,13 @@ class Edit3DManager:
         else:
             self.host.statusBar().showMessage("Measurement mode disabled.")
 
+    def invalidate_molecule_dialogs(self) -> None:
+        """Discard molecule-bound dialog sessions before replacing the document."""
+        for dialog in self.active_3d_dialogs.copy():
+            if not sip_isdeleted_safe(dialog):
+                dialog.invalidate_molecule()
+        self.active_3d_dialogs.clear()
+
     def close_all_3d_edit_dialogs(self) -> None:
         """Close all active 3D edit dialogs."""
         dialogs_to_close = self.active_3d_dialogs.copy()

{moleditpy_linux-4.11.3 → moleditpy_linux-4.11.5}/src/moleditpy_linux/ui/geometry_base_dialog.py

@@ -118,6 +118,8 @@ class GeometryBaseDialog(BasePickingDialog):
     def on_slider_released(self) -> None:
         """Finalize a slider drag operation."""
         self._slider_dragging = False
+        if self._invalidated:
+            return
         # Snapshot is usually kept until selection changes to preserve turn direction,
         # but subclasses can override this behavior if needed.
         self.main_window.view_3d_manager.draw_molecule_3d(self.mol)

{moleditpy_linux-4.11.3 → moleditpy_linux-4.11.5}/src/moleditpy_linux/ui/io_logic.py

@@ -445,9 +445,6 @@ class IOManager:
 
     def load_xyz_file(self, file_path: str) -> Optional[Any]:
         """Load XYZ file and create RDKit Mol with charge prompt and bond determination."""
-        if not self.host.state_manager.check_unsaved_changes():
-            return None
-
         try:
             return self._mol_from_xyz_lines(self._read_text_lines_flexible(file_path))
         except (RuntimeError, TypeError, ValueError, UnicodeDecodeError) as e:
@@ -466,6 +463,8 @@ class IOManager:
         self, xyz_text: str, source_name: str = "XYZ data"
     ) -> Optional[Any]:
         """Load XYZ text, set it as the current molecule, and draw it in 3D."""
+        if not self.host.state_manager.check_unsaved_changes():
+            return None
         try:
             mol = self.load_xyz_block(xyz_text)
             if mol is None:
@@ -490,6 +489,7 @@ class IOManager:
                 self.host.statusBar().showMessage(
                     f"3D Viewer Mode: Loaded {source_name}"
                 )
+            self.host.edit_actions_manager.reset_history()
             self.host.set_has_unsaved_changes(False)
             self.host.state_manager.update_window_title()
             return mol
@@ -1055,6 +1055,8 @@ class IOManager:
 
     def load_xyz_for_3d_viewing(self, file_path: Optional[str] = None) -> None:
         """Load XYZ file and display in 3D viewer."""
+        if not self.host.state_manager.check_unsaved_changes():
+            return
         if not file_path:
             default_dir = (
                 os.path.dirname(self.host.init_manager.current_file_path)
@@ -1113,6 +1115,7 @@ class IOManager:
                     )
                 self.host.statusBar().showMessage(message)
             self.host.set_current_file_path(file_path)
+            self.host.edit_actions_manager.reset_history()
             self.host.set_has_unsaved_changes(False)
             self.host.state_manager.update_window_title()
         except (OSError, IOError, ValueError, RuntimeError, AttributeError) as e:
@@ -1160,6 +1163,7 @@ class IOManager:
             self.host.view_3d_manager.update_atom_id_menu_state()
             self.host.update_status_message(f"Loaded {file_path} in 3D viewer")
             self.host.set_current_file_path(file_path)
+            self.host.edit_actions_manager.reset_history()
             self.host.set_has_unsaved_changes(False)
             self.host.state_manager.update_window_title()
         except SdfSelectionCancelled:

{moleditpy_linux-4.11.3 → moleditpy_linux-4.11.5}/src/moleditpy_linux/ui/main_window.py

@@ -133,6 +133,8 @@ class MainWindow(QMainWindow):
 
     def set_current_molecule(self, mol: Optional[Chem.Mol]) -> None:
         """Set the current 3D molecule and trigger rendering updates."""
+        if mol is not self.view_3d_manager.current_mol:
+            self.edit_3d_manager.invalidate_molecule_dialogs()
         self.view_3d_manager.current_mol = mol
 
     def set_3d_atom_positions(self, positions: Any) -> None:
@@ -141,7 +143,7 @@ class MainWindow(QMainWindow):
 
     def clear_3d_view(self) -> None:
         """Clear 3D molecule state and plotter rendering."""
-        self.view_3d_manager.current_mol = None
+        self.set_current_molecule(None)
         if self.view_3d_manager.plotter:
             self.view_3d_manager.plotter.clear()
 
@@ -292,7 +294,7 @@ class MainWindow(QMainWindow):
     @current_mol.setter
     def current_mol(self, value: Any) -> None:
         """Proxy for current 3D molecule (read/write)."""
-        self.view_3d_manager.current_mol = value
+        self.set_current_molecule(value)
 
     @property
     def plotter(self) -> Optional[CustomQtInteractor]:

{moleditpy_linux-4.11.3 → moleditpy_linux-4.11.5}/src/moleditpy_linux/ui/mirror_dialog.py

@@ -37,6 +37,7 @@ class MirrorDialog(QDialog):
         super().__init__(parent)
         self.mol = mol
         self.main_window = main_window
+        self._invalidated = False
         self.plane_group: Optional[QButtonGroup] = None
         self.xy_radio: Optional[QRadioButton] = None
         self.xz_radio: Optional[QRadioButton] = None
@@ -87,8 +88,16 @@ class MirrorDialog(QDialog):
 
         layout.addLayout(button_layout)
 
+    def invalidate_molecule(self) -> None:
+        """Close the mirror tool when its molecule is replaced."""
+        self._invalidated = True
+        self.setEnabled(False)
+        self.reject()
+
     def apply_mirror(self) -> None:
         """Apply mirror transformation across the selected plane."""
+        if self._invalidated:
+            return
         if not self.mol or self.mol.GetNumConformers() == 0:
             QMessageBox.warning(self, "Error", "No 3D coordinates available.")
             return

{moleditpy_linux-4.11.3 → moleditpy_linux-4.11.5}/src/moleditpy_linux/ui/molecular_scene_handler.py

@@ -445,10 +445,10 @@ class TemplateMixin:
                     # policy, so an unchanged order means keep this bond
                     if order == exist_b.order:
                         continue
+                    key = (id1, id2) if (id1, id2) in self.data.bonds else (id2, id1)
+                    self.data.bonds[key].update(order=order, stereo=0)
                     exist_b.order = order
                     exist_b.stereo = 0
-                    self.data.bonds[(id1, id2)]["order"] = order
-                    self.data.bonds[(id1, id2)]["stereo"] = 0
                     exist_b.update()
                 else:
                     # Create new bond

{moleditpy_linux-4.11.3 → moleditpy_linux-4.11.5}/src/moleditpy_linux/ui/molecule_scene.py

@@ -12,7 +12,8 @@ DOI: 10.5281/zenodo.17268532
 
 from __future__ import annotations
 import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+import copy
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
 
 from PyQt6.QtCore import QEvent, QLineF, Qt, QPointF
 from PyQt6.QtGui import QPen
@@ -216,6 +217,7 @@ class MoleculeScene(
         self, raw_atoms: Dict[int, Any], raw_bonds: Dict[Tuple[int, int], Any]
     ) -> None:
         """Restore scene items from undo/redo state (dict-of-dicts format)."""
+        self.data.adjacency_list = {atom_id: [] for atom_id in raw_atoms}
         for atom_id, data in raw_atoms.items():
             raw_pos = tuple(data["pos"])
             pos_q = QPointF(raw_pos[0], raw_pos[1])
@@ -245,6 +247,8 @@ class MoleculeScene(
                     "order": data.get("order", 1),
                     "stereo": data.get("stereo", 0),
                 }
+                self.data.adjacency_list[id1].append(id2)
+                self.data.adjacency_list[id2].append(id1)
                 self.bond_items[key_tuple] = bond_item
                 atom1_item.bonds.append(bond_item)
                 atom2_item.bonds.append(bond_item)
@@ -258,6 +262,7 @@ class MoleculeScene(
         self, atoms_2d: List[Dict[str, Any]], bonds_2d: List[Dict[str, Any]]
     ) -> None:
         """Restore scene items from PMEPRJ JSON (list-of-dicts format)."""
+        self.data.adjacency_list = {atom["id"]: [] for atom in atoms_2d}
         for atom_data in atoms_2d:
             atom_id = atom_data["id"]
             symbol = atom_data["symbol"]
@@ -290,6 +295,8 @@ class MoleculeScene(
                     "order": bond_order,
                     "stereo": stereo,
                 }
+                self.data.adjacency_list[atom1_id].append(atom2_id)
+                self.data.adjacency_list[atom2_id].append(atom1_id)
                 self.bond_items[(atom1_id, atom2_id)] = bond_item
                 self.addItem(bond_item)
 
@@ -297,6 +304,58 @@ class MoleculeScene(
             atom_item.update_style()
         self.update_all_items()
 
+    def add_molecule_fragment(
+        self,
+        points: List[Union[QPointF, Tuple[float, float]]],
+        bonds_info: List[Tuple[int, int, int]],
+        existing_items: Optional[List[AtomItem]] = None,
+        symbol: str = "C",
+    ) -> List[Optional[AtomItem]]:
+        """Insert a template, restoring model and scene if a Qt/model write fails."""
+        atoms = copy.deepcopy(self.data.atoms)
+        bonds = copy.deepcopy(self.data.bonds)
+        next_atom_id = self.data.next_atom_id
+        selected_ids = {i for i, item in self.atom_items.items() if item.isSelected()}
+        try:
+            return TemplateMixin.add_molecule_fragment(
+                self, points, bonds_info, existing_items, symbol
+            )
+        except (RuntimeError, ValueError, TypeError, KeyError, IndexError):
+            logging.exception("Template insertion failed; restoring the previous scene")
+            self.clear()
+            self.data.atoms.clear()
+            self.data.bonds.clear()
+            self.data.next_atom_id = next_atom_id
+            self.reinitialize_items()
+            self.restore_atoms_and_bonds(atoms, bonds)
+            for atom_id in selected_ids:
+                self.atom_items[atom_id].setSelected(True)
+            raise
+
+    def clear(self) -> None:
+        """Release item and interaction references before Qt deletes the scene."""
+        self.atom_items.clear()
+        self.bond_items.clear()
+        self._deleted_items.clear()
+        self.initial_positions_in_event.clear()
+        self.template_context.clear()
+        self.template_preview = None
+        self.template_preview_points = []
+        self.start_atom = None
+        self.temp_line = None
+        self.hovered_item = None
+        self.start_pos = None
+        self.press_pos = None
+        self.chain_start_atom = None
+        self.chain_end_atom = None
+        self.chain_anchor = None
+        self.chain_points = []
+        self.chain_active = False
+        self.data_changed_in_event = False
+        self.mouse_moved_since_press = False
+        self.was_selected_on_press = False
+        super().clear()
+
     def reinitialize_items(self) -> None:
         """Reset transient scene state including template preview and deleted-item list."""
         self.template_preview = TemplatePreviewItem()

{moleditpy_linux-4.11.3 → moleditpy_linux-4.11.5}/src/moleditpy_linux/ui/ui_manager.py

@@ -219,6 +219,8 @@ class UIManager(QObject):
         Handle application close logic.
         Returns True if close should proceed, False if it should be cancelled.
         """
+        if not self.host.edit_3d_manager.prepare_optimization_shutdown():
+            return False
         # 1. Persist settings
         try:
             modified = self.host.init_manager.settings_dirty or (