MoleditPy-linux 4.2.3__py3-none-any.whl → 4.3.0__py3-none-any.whl

moleditpy_linux/main.py

@@ -11,20 +11,23 @@ DOI: 10.5281/zenodo.17268532
 """
 
 import ctypes
+import hashlib
 import json
 import logging
 import logging.handlers
 import os
 import sys
 import argparse
-from typing import Any, Optional
+import time
+import traceback
+from typing import Any, Dict, Optional
 
 from .utils.constants import VERSION
 
 # VERSION is resolved above (before Qt) so --version works without launching the app.
 
-from PyQt6.QtCore import QtMsgType, qInstallMessageHandler
-from PyQt6.QtWidgets import QApplication
+from PyQt6.QtCore import QtMsgType, QThread, QTimer, qInstallMessageHandler
+from PyQt6.QtWidgets import QApplication, QMessageBox
 
 from .ui.main_window import MainWindow
 
@@ -49,6 +52,109 @@ def _qt_message_handler(mode: QtMsgType, _context: Any, message: Optional[str])
     logging.log(_QT_LOG_LEVEL.get(mode, logging.WARNING), "Qt: %s", message)
 
 
+class _ErrorDialogHandler(logging.Handler):
+    """Surface ERROR/CRITICAL log records in a dialog, once per unique message.
+
+    The uncaught-exception hook routes through here too (it logs at ERROR with
+    ``exc_info``), so every genuine failure — logged explicitly or bubbling out
+    of Qt — gets one dialog. Warnings/info never reach it (handler level is
+    ERROR). All state is per-instance; the one instance is created and attached
+    in :func:`setup_logging` (only for a real GUI run, never headless).
+
+    Guards: GUI thread + live QApplication only (a worker-thread record, where a
+    QMessageBox is unsafe, stays log-only); a time-windowed dedup so a fast
+    repeating error (e.g. from a QTimer slot) collapses to one dialog while a
+    genuine retry seconds later surfaces again; and ``extra={"no_dialog": True}``
+    to opt a record out. ``emit`` never raises.
+
+    The dialog is shown non-blocking (``show``, not ``exec``): it never spins a
+    nested event loop, so it cannot freeze the app — or a GUI-enabled test run —
+    while it is on screen.
+    """
+
+    # Identical errors within this many seconds share one dialog; a repeat
+    # after it surfaces again.
+    _DEDUP_WINDOW_S = 10.0
+
+    def __init__(self, log_path: Optional[str] = None) -> None:
+        super().__init__(level=logging.ERROR)
+        # signature -> monotonic timestamp of its last shown dialog.
+        self._last_shown: Dict[str, float] = {}
+        # Held so a non-blocking box is not garbage-collected before it closes.
+        self._open_boxes: set = set()
+        self._log_path = log_path
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            if getattr(record, "no_dialog", False):
+                return
+            app = QApplication.instance()
+            if app is None or QThread.currentThread() is not app.thread():
+                return
+            if app.property("moleditpy_shutting_down"):
+                return
+
+            message = record.getMessage()
+            # Source location (as the terminal log shows), then any traceback.
+            detail = f"{record.pathname}:{record.lineno}"
+            if record.exc_info:
+                detail += "\n\n" + "".join(traceback.format_exception(*record.exc_info))
+
+            signature = hashlib.sha1(
+                (message + detail).encode("utf-8", "replace")
+            ).hexdigest()
+            now = time.monotonic()
+            last = self._last_shown.get(signature)
+            if last is not None and now - last < self._DEDUP_WINDOW_S:
+                return
+            self._last_shown[signature] = now
+
+            # Defer so a site's own QMessageBox.critical (raised right after the
+            # log call) is already modal when _show checks activeModalWidget.
+            QTimer.singleShot(0, lambda: self._show(message, detail))
+        except Exception:  # pragma: no cover - logging must never raise
+            self.handleError(record)
+
+    def _details(self) -> str:
+        """Where to find the full error text, honest about file logging."""
+        if self._log_path:
+            return (
+                "Full details are in the terminal output and the log file:\n"
+                f"{self._log_path}"
+            )
+        return (
+            "Full details are in the terminal output. Enable "
+            "Settings ▸ Other ▸ 'Save log to file' to also keep them "
+            "on disk."
+        )
+
+    def _show(self, message: str, detail: str) -> None:
+        """Show one non-blocking error dialog, unless another modal is up.
+
+        Sites (and plugins) log the error and then immediately raise their own
+        ``QMessageBox.critical``; by the time this deferred call fires, that
+        modal is up, so we detect it and stay quiet — surfacing the generic
+        dialog only for errors nobody else reports.
+        """
+        if QApplication.activeModalWidget() is not None:
+            return
+        try:
+            box = QMessageBox()
+            box.setIcon(QMessageBox.Icon.Critical)
+            box.setWindowTitle("MoleditPy — Error")
+            box.setText(message or "An unexpected error occurred.")
+            box.setInformativeText(self._details())
+            if detail:
+                box.setDetailedText(detail)
+            box.setStandardButtons(QMessageBox.StandardButton.Ok)
+            box.setModal(True)
+            self._open_boxes.add(box)
+            box.finished.connect(lambda _result, b=box: self._open_boxes.discard(b))
+            box.show()
+        except Exception:
+            logging.debug("Failed to show error dialog", exc_info=True)
+
+
 def _read_startup_log_settings() -> tuple[bool, bool]:
     """Read log_to_file and log_level_debug from settings.json before Qt starts.
 
@@ -78,6 +184,7 @@ def setup_logging() -> None:
         force=True,
     )
 
+    active_log_path: Optional[str] = None
     if log_to_file:
         log_dir = os.path.join(os.path.expanduser("~"), ".moleditpy")
         try:
@@ -90,11 +197,23 @@ def setup_logging() -> None:
             fh.setFormatter(logging.Formatter(fmt))
             logging.getLogger().addHandler(fh)
             logging.info("File logging enabled: %s", log_path)
+            active_log_path = log_path
         except OSError as e:
             logging.warning("Could not open log file: %s", e)
 
+    # Surface every ERROR/CRITICAL record in a dialog (see _ErrorDialogHandler);
+    # uncaught exceptions flow through here too via handle_exception's log call.
+    # It is a GUI feature, so it is skipped in headless mode (MOLEDITPY_HEADLESS),
+    # where a blocking modal would hang the run.
+    if not os.environ.get("MOLEDITPY_HEADLESS"):
+        logging.getLogger().addHandler(_ErrorDialogHandler(log_path=active_log_path))
+
     def handle_exception(exc_type: Any, exc_value: Any, exc_traceback: Any) -> None:
-        """Log unhandled exceptions using the configured logging system."""
+        """Log unhandled exceptions; the ERROR dialog handler surfaces them.
+
+        The dialog fires only for genuine failures — this log call and explicit
+        logging.error/critical calls — never for warnings/info.
+        """
         if issubclass(exc_type, KeyboardInterrupt):
             sys.__excepthook__(exc_type, exc_value, exc_traceback)
             return

moleditpy_linux/plugins/plugin_manager.py

@@ -113,7 +113,7 @@ class PluginManager:
             try:
                 os.makedirs(self.plugin_dir)
             except OSError as e:
-                logging.error(f"Error creating plugin directory: {e}")
+                logging.warning(f"Error creating plugin directory: {e}")
 
     def open_plugin_folder(self) -> None:
         """Opens the plugin directory in the OS file explorer."""
@@ -381,7 +381,9 @@ class PluginManager:
                         module.initialize(context)
                     except Exception as e:  # plugins have full app access; catch everything to isolate faults
                         status = f"Error (Init): {e}"
-                        logging.exception("Plugin %s initialize error", plugin_name)
+                        logging.warning(
+                            "Plugin %s initialize error", plugin_name, exc_info=True
+                        )
                 elif has_autorun:
                     try:
                         if self.main_window:
@@ -390,7 +392,9 @@ class PluginManager:
                             status = "Skipped (No MW)"
                     except Exception as e:  # plugins have full app access; catch everything to isolate faults
                         status = f"Error (Autorun): {e}"
-                        logging.exception("Plugin %s autorun error", plugin_name)
+                        logging.warning(
+                            "Plugin %s autorun error", plugin_name, exc_info=True
+                        )
                 elif not has_run:
                     status = "No Entry Point"
 
@@ -409,7 +413,9 @@ class PluginManager:
                 )
 
         except Exception as e:  # plugins have full app access; isolate any load failure to prevent crashing discovery
-            logging.exception("Failed to load plugin %s: %s", module_name, e)
+            logging.warning(
+                "Failed to load plugin %s: %s", module_name, e, exc_info=True
+            )
 
     def run_plugin(self, module: Any, main_window: Any) -> None:
         """Executes the plugin's run method (Legacy manual trigger)."""
@@ -620,7 +626,7 @@ class PluginManager:
                             except (RuntimeError, ValueError, TypeError):
                                 continue
         except (RuntimeError, AttributeError) as e:
-            logging.error(f"Error retrieving selected atom indices: {e}")
+            logging.warning(f"Error retrieving selected atom indices: {e}")
 
         return selected_indices
 
@@ -640,8 +646,11 @@ class PluginManager:
             try:
                 handler["callback"]()
             except Exception as e:  # plugins have full app access; catch everything to prevent data loss on document reset
-                logging.exception(
-                    "Error in document reset handler for %s: %s", handler["plugin"], e
+                logging.warning(
+                    "Error in document reset handler for %s: %s",
+                    handler["plugin"],
+                    e,
+                    exc_info=True,
                 )
 
     def get_plugin_info_safe(self, file_path: str) -> Dict[str, str]:

moleditpy_linux/plugins/plugin_manager_window.py

@@ -10,6 +10,7 @@ Repo: https://github.com/HiroYokoyama/python_molecular_editor
 DOI: 10.5281/zenodo.17268532
 """
 
+import logging
 import os
 import shutil
 from typing import Any, Optional
@@ -213,9 +214,7 @@ class PluginManagerWindow(QDialog):
                             f"Removed '{plugin.get('name', 'Unknown')}'.",
                         )
                     except OSError as e:
-                        QMessageBox.critical(
-                            self, "Error", f"Failed to delete plugin: {e}"
-                        )
+                        logging.exception("Failed to delete plugin: %s", e)
             else:
                 QMessageBox.warning(
                     self, "Error", f"Plugin file not found:\n{filepath}"

moleditpy_linux/ui/align_plane_dialog.py

@@ -162,7 +162,7 @@ class AlignPlaneDialog(BasePickingDialog):
             self.update_display()
 
         except (AttributeError, RuntimeError, TypeError, KeyError) as e:
-            logging.exception("Failed to select all atoms")
+            logging.warning("Failed to select all atoms", exc_info=True)
             QMessageBox.warning(self, "Warning", f"Failed to select all atoms: {e}")
 
     def update_display(self) -> None:
@@ -285,5 +285,4 @@ class AlignPlaneDialog(BasePickingDialog):
             self.show_atom_labels()
 
         except (AttributeError, RuntimeError, ValueError, TypeError) as e:
-            logging.exception("Failed to apply align")
-            QMessageBox.critical(self, "Error", f"Failed to apply align: {str(e)}")
+            logging.exception("Failed to apply align: %s", e)

moleditpy_linux/ui/alignment_dialog.py

@@ -276,8 +276,7 @@ class AlignmentDialog(Dialog3DPickingMixin, QDialog):
             )
 
         except (AttributeError, RuntimeError, ValueError, TypeError) as e:
-            logging.exception("Failed to apply alignment")
-            QMessageBox.critical(self, "Error", f"Failed to apply alignment: {str(e)}")
+            logging.exception("Failed to apply alignment: %s", e)
 
     def closeEvent(self, event: Optional[QCloseEvent]) -> None:
         """Clean up when the dialog is closed."""

moleditpy_linux/ui/app_state.py

@@ -223,7 +223,11 @@ class StateManager:
                     self.host.view_3d_manager.draw_molecule_3d(
                         self.host.view_3d_manager.current_mol
                     )
-                    if self.host.view_3d_manager.plotter:
+                    # draw_molecule_3d already preserves the camera; only refit
+                    # on a fresh load, not on undo/redo (which restores state).
+                    if self.host.view_3d_manager.plotter and not getattr(
+                        self.host, "is_restoring_state", False
+                    ):
                         self.host.view_3d_manager.plotter.reset_camera()
 
                     self.host.ui_manager.enable_3d_features(True)
@@ -232,7 +236,7 @@ class StateManager:
                     self.host.clear_3d_view()
                     self.host.ui_manager.enable_3d_features(False)
             except (RuntimeError, ValueError, TypeError) as e:
-                logging.error(f"Could not load 3D model from state data: {e}")
+                logging.warning(f"Could not load 3D model from state data: {e}")
                 self.host.update_status_message(f"Error loading 3D model: {e}", 5000)
                 self.host.set_current_molecule(None)
                 self.host.ui_manager.enable_3d_features(False)
@@ -528,7 +532,9 @@ class StateManager:
                         p_state = callback()
                         plugin_data[name] = p_state
                     except Exception:  # plugins have full app access; catch everything to prevent save corruption
-                        logging.exception("Error saving state for plugin %s", name)
+                        logging.warning(
+                            "Error saving state for plugin %s", name, exc_info=True
+                        )
 
         if plugin_data:
             json_data["plugins"] = plugin_data
@@ -564,7 +570,9 @@ class StateManager:
                         try:
                             load_hand(p_state)
                         except Exception:  # plugins have full app access; catch everything to prevent load corruption
-                            logging.exception("Error loading state for plugin %s", name)
+                            logging.warning(
+                                "Error loading state for plugin %s", name, exc_info=True
+                            )
                     else:
                         # No handler found (plugin disabled or missing)
                         # Preserve data so it's not lost on next save
@@ -671,5 +679,5 @@ class StateManager:
                                 "Suppressed non-critical error", exc_info=True
                             )
             except (RuntimeError, ValueError, TypeError, binascii.Error) as e:
-                logging.error(f"Could not restore 3D molecular data: {e}")
+                logging.warning(f"Could not restore 3D molecular data: {e}")
                 self.host.set_current_molecule(None)

moleditpy_linux/ui/bond_item.py

@@ -96,7 +96,7 @@ class BondItem(QGraphicsItem):
                     view.viewport().update()  # type: ignore[union-attr]
 
         except (AttributeError, RuntimeError, TypeError):
-            logging.exception("Error in BondItem.set_stereo")
+            logging.warning("Error in BondItem.set_stereo", exc_info=True)
             # Continue without crashing
             self.stereo = new_stereo
 
@@ -604,7 +604,7 @@ class BondItem(QGraphicsItem):
                 self.setPos(self.atom1.pos())
             self.update()
         except (AttributeError, RuntimeError):
-            logging.exception("Error updating bond position")
+            logging.warning("Error updating bond position", exc_info=True)
             # Continue without crashing
 
     def hoverEnterEvent(self, event: QGraphicsSceneHoverEvent) -> None:  # type: ignore[override]

moleditpy_linux/ui/compute_logic.py

@@ -390,7 +390,9 @@ class ComputeManager:
         try:
             success = bool(entry["callback"](mol))
         except Exception:  # plugins have full app access; isolate failures
-            logging.exception("Plugin optimization method '%s' failed", label)
+            logging.warning(
+                "Plugin optimization method '%s' failed", label, exc_info=True
+            )
             self._refresh_ui_state()
             self.host.update_status_message(
                 f"Plugin optimization '{label}' failed (see log)."
@@ -431,7 +433,7 @@ class ComputeManager:
         try:
             Chem.SanitizeMol(mol)
         except (ValueError, RuntimeError) as e:
-            logging.error(f"Sanitization failed: {e}")
+            logging.warning(f"Sanitization failed: {e}")
             self.host.statusBar().showMessage("Error: Invalid chemical structure.")  # type: ignore[union-attr]
             return None
         return mol
@@ -587,7 +589,8 @@ class ComputeManager:
             msg = str(message)
 
         self._remove_calculating_text()
-        self._restore_button_ui()
+        # Full restore like the success path, else Export stays disabled on error.
+        self._refresh_ui_state()
 
         if msg == "Halt" or msg == "Halted":
             self.host.statusBar().showMessage("Halted")  # type: ignore[union-attr]

moleditpy_linux/ui/constrained_optimization_dialog.py

@@ -156,7 +156,7 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
                 self.ff_combo.setCurrentText("MMFF94s")
 
         except (AttributeError, RuntimeError, ValueError, TypeError):
-            logging.exception("Could not set default force field")
+            logging.warning("Could not set default force field", exc_info=True)
 
     def init_ui(self) -> None:
         """Build the constrained optimization dialog with constraint table and controls."""
@@ -528,9 +528,7 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
                 add_torsion_constraint = ff.UFFAddTorsionConstraint
 
         except (AttributeError, RuntimeError, ValueError, TypeError) as e:
-            QMessageBox.critical(
-                self, "Error", f"Failed to initialize force field {ff_name}: {e}"
-            )
+            logging.exception("Failed to initialize force field %s: %s", ff_name, e)
             return
 
         # Add constraints
@@ -578,8 +576,7 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
                     )
 
         except (AttributeError, RuntimeError, ValueError, TypeError) as e:
-            QMessageBox.critical(self, "Error", f"Failed to add constraints: {e}")
-            logging.error("Failed to add constraints", exc_info=True)
+            logging.exception("Failed to add constraints: %s", e)
             return
 
         # Execute optimization
@@ -598,7 +595,7 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
             self._opt_thread.start()
 
         except Exception as e:
-            QMessageBox.critical(self, "Error", f"Failed to start optimization: {e}")
+            logging.exception("Failed to start optimization: %s", e)
             self.optimize_button.setEnabled(True)
 
     def _on_optimization_error(self, err_msg: str) -> None:
@@ -673,7 +670,7 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
                 logging.warning("Failed to save constraints post-optimization: %s", e)
 
         except (AttributeError, RuntimeError, ValueError, TypeError) as e:
-            QMessageBox.critical(self, "Error", f"Optimization failed: {e}")
+            logging.exception("Optimization failed: %s", e)
 
     def closeEvent(self, event: Any) -> None:
         """Delegate window close to reject."""

moleditpy_linux/ui/custom_interactor_style.py

@@ -120,7 +120,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                     move_group_dialog = widget
                     break
             except (AttributeError, RuntimeError, TypeError):
-                logging.error("Caught exception in " + __file__, exc_info=True)
+                logging.warning("Caught exception in " + __file__, exc_info=True)
 
         if move_group_dialog and move_group_dialog.group_atoms:
             # Group drag if selected
@@ -401,7 +401,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                     move_group_dialog = widget
                     break
         except (AttributeError, RuntimeError, TypeError):
-            logging.error("Caught exception in " + __file__, exc_info=True)
+            logging.warning("Caught exception in " + __file__, exc_info=True)
         if move_group_dialog and getattr(
             move_group_dialog, "is_dragging_group_vtk", False
         ):
@@ -497,7 +497,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                     move_group_dialog = widget
                     break
         except (AttributeError, RuntimeError, TypeError):
-            logging.error("Caught exception in " + __file__, exc_info=True)
+            logging.warning("Caught exception in " + __file__, exc_info=True)
         # Prevent multi-click issues
         if move_group_dialog:
             if getattr(
@@ -509,7 +509,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                     try:
                         move_group_dialog.on_atom_picked(clicked_atom)
                     except (AttributeError, RuntimeError, TypeError, ValueError) as e:
-                        logging.error(f"Error in toggle: {e}")
+                        logging.warning(f"Error in toggle: {e}")
                 # Reset if multi-clicked without drag
                 move_group_dialog.is_dragging_group_vtk = False
                 move_group_dialog.drag_start_pos_vtk = None
@@ -589,7 +589,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
 
                     QTimer.singleShot(0, _deferred_group_redraw)
                 except (AttributeError, RuntimeError, TypeError, ValueError):
-                    logging.exception("Error finalizing group drag")
+                    logging.warning("Error finalizing group drag", exc_info=True)
             else:
                 # No drag = click only -> toggle
                 clicked_atom = getattr(move_group_dialog, "drag_atom_idx_vtk", None)
@@ -597,7 +597,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                     try:
                         move_group_dialog.on_atom_picked(clicked_atom)
                     except (AttributeError, RuntimeError, TypeError, ValueError):
-                        logging.exception("Error in toggle")
+                        logging.warning("Error in toggle", exc_info=True)
 
         # Background click: deselect Move Group
         if move_group_dialog and not getattr(
@@ -725,7 +725,9 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                                 ),
                             )
                     except (AttributeError, RuntimeError, ValueError, TypeError):
-                        logging.error("Caught exception in " + __file__, exc_info=True)
+                        logging.warning(
+                            "Caught exception in " + __file__, exc_info=True
+                        )
 
                     # Defer the redraw + undo push out of the VTK observer
                     # callback to prevent re-entrant plotter.render() deadlock.
@@ -735,7 +737,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                         try:
                             mw.view_3d_manager.draw_molecule_3d(_atom_mol)
                         except (AttributeError, RuntimeError, ValueError, TypeError):
-                            logging.error(
+                            logging.warning(
                                 "Caught exception in " + __file__, exc_info=True
                             )
                         mw.edit_actions_manager.push_undo_state()
@@ -760,7 +762,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                         try:
                             fn()
                         except (AttributeError, RuntimeError, ValueError, TypeError):
-                            logging.error(
+                            logging.warning(
                                 "Caught exception in " + __file__, exc_info=True
                             )
 
@@ -790,13 +792,13 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                 if hasattr(move_group_dialog, "drag_atom_idx_vtk"):  # Safe
                     delattr(move_group_dialog, "drag_atom_idx_vtk")
         except (AttributeError, RuntimeError, ValueError, TypeError):
-            logging.error("Caught exception in " + __file__, exc_info=True)
+            logging.warning("Caught exception in " + __file__, exc_info=True)
 
         # Update cursor after release
         try:
             mw.view_3d_manager.plotter.setCursor(Qt.CursorShape.ArrowCursor)
         except (AttributeError, RuntimeError, ValueError, TypeError):
-            logging.error("Caught exception in " + __file__, exc_info=True)
+            logging.warning("Caught exception in " + __file__, exc_info=True)
 
         # Restore focus to 2D view
         if mw and mw.init_manager.view_2d:
@@ -820,7 +822,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                     move_group_dialog = widget
                     break
         except (AttributeError, RuntimeError, TypeError):
-            logging.error("Caught exception in " + __file__, exc_info=True)
+            logging.warning("Caught exception in " + __file__, exc_info=True)
         if move_group_dialog and getattr(
             move_group_dialog, "is_rotating_group_vtk", False
         ):
@@ -935,7 +937,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                             move_group_dialog.show_atom_labels()
                             mw.edit_actions_manager.push_undo_state()
                 except (AttributeError, RuntimeError, TypeError, ValueError):
-                    logging.exception("Error finalizing group rotation")
+                    logging.warning("Error finalizing group rotation", exc_info=True)
 
             # Reset state
             move_group_dialog.is_rotating_group_vtk = False

moleditpy_linux/ui/dialog_3d_picking_mixin.py

@@ -100,7 +100,7 @@ class Dialog3DPickingMixin:
                 return False
 
             except (AttributeError, RuntimeError, ValueError, TypeError):
-                logging.exception("Error in eventFilter")
+                logging.warning("Error in eventFilter", exc_info=True)
                 return False
 
         # Add movement tracking for smart selection

moleditpy_linux/ui/dialog_logic.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 
 
 import json
+import logging
 import os
 import sys
 from typing import Any, List, Literal, Optional, cast
@@ -187,9 +188,7 @@ class DialogManager:
             )
 
         except (AttributeError, RuntimeError, ValueError) as e:
-            QMessageBox.critical(
-                self.host, "Error", f"Failed to save template: {str(e)}"
-            )
+            logging.exception("Failed to save template: %s", e)
 
     def _show_modeless_dialog(self, dialog: QDialog) -> None:
         """Show a modeless dialog on top, especially important for macOS."""

moleditpy_linux/ui/edit_actions_logic.py

@@ -986,7 +986,7 @@ class EditActionsManager:
                 ):
                     problem_map[atom_id] = True
         except (AttributeError, RuntimeError, ValueError, TypeError) as e:
-            logging.error(f"Error during chemistry problem detection: {e}")
+            logging.warning(f"Error during chemistry problem detection: {e}")
 
         return problem_map
 

moleditpy_linux/ui/main_window.py

@@ -260,7 +260,7 @@ class MainWindow(QMainWindow):
                 self.state_manager.get_current_state()
             )
         except (RuntimeError, TypeError, ValueError, AttributeError) as e:
-            logging.error(f"save_state_snapshot failed: {e}")
+            logging.warning(f"save_state_snapshot failed: {e}")
 
     def update_window_title(self) -> None:
         """Update main window title to reflect file path and save status."""

moleditpy_linux/ui/main_window_init.py

@@ -144,7 +144,7 @@ class MainInitManager:
             try:
                 self.host.plugin_manager = PluginManager()
             except (AttributeError, RuntimeError, ValueError) as e:
-                logging.error(f"Failed to initialize PluginManager: {e}")
+                logging.warning(f"Failed to initialize PluginManager: {e}")
                 self.host.plugin_manager = None
 
         # Dictionary holding data for plugins that haven't been loaded
@@ -189,7 +189,7 @@ class MainInitManager:
                 for atom in warmup_mol.GetAtoms():
                     atom.GetNumImplicitHs()
         except (AttributeError, RuntimeError, ValueError) as e:
-            logging.error(f"RDKit warm-up failed: {e}")
+            logging.warning(f"RDKit warm-up failed: {e}")
 
         self.host.state_manager.reset_undo_stack()
         self.scene.selectionChanged.connect(  # type: ignore[attr-defined]
@@ -304,9 +304,10 @@ class MainInitManager:
                     self.host.state_manager.update_window_title()
                     return  # Success
                 except Exception:  # plugins have full app access; any failure falls through to the next opener
-                    logging.exception(
+                    logging.warning(
                         "Plugin opener failed for '%s'",
                         opener_info.get("plugin", "Unknown"),
+                        exc_info=True,
                     )
                     continue
 
@@ -404,7 +405,7 @@ class MainInitManager:
                             c.blueF(),
                         ]
         except (AttributeError, RuntimeError, TypeError, ValueError) as e:
-            logging.error(f"Failed to update CPK colors from settings: {e}")
+            logging.warning(f"Failed to update CPK colors from settings: {e}")
 
     def open_settings_dialog(self) -> None:
         """Open the application settings dialog."""
@@ -567,7 +568,7 @@ class MainInitManager:
             self.settings_dirty = False
             self.host.initial_settings = self.settings.copy()
         except (AttributeError, RuntimeError, ValueError) as e:
-            logging.error(f"Error saving settings: {e}")
+            logging.warning(f"Error saving settings: {e}")
 
     # --- UI Initialization Helpers ---
     def _init_main_layout(self) -> None:

moleditpy_linux/ui/mirror_dialog.py

@@ -125,7 +125,7 @@ class MirrorDialog(QDialog):
                     # Calculate new chiral tags from 3D coordinates
                     Chem.AssignAtomChiralTagsFromStructure(self.mol, confId=0)
             except (AttributeError, RuntimeError, ValueError, TypeError):
-                logging.exception("Error updating chiral tags")
+                logging.warning("Error updating chiral tags", exc_info=True)
 
             # Update 3D view (which also draws 3D chiral labels)
             self.main_window.view_3d_manager.draw_molecule_3d(self.mol)
@@ -141,6 +141,4 @@ class MirrorDialog(QDialog):
             )
 
         except (AttributeError, RuntimeError, ValueError, TypeError) as e:
-            QMessageBox.critical(
-                self, "Error", f"Failed to apply mirror transformation: {str(e)}"
-            )
+            logging.exception("Failed to apply mirror transformation: %s", e)