MoleditPy-linux 3.6.6__tar.gz → 4.0.1__tar.gz

{moleditpy_linux-3.6.6 → moleditpy_linux-4.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 3.6.6
+Version: 4.0.1
 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
@@ -709,8 +709,7 @@ Dynamic: license-file
 [![Python Versions](https://img.shields.io/pypi/pyversions/MoleditPy.svg)](https://pypi.org/project/MoleditPy/)
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 [![Build Status](https://github.com/HiroYokoyama/python_molecular_editor/actions/workflows/tests.yml/badge.svg)](https://github.com/HiroYokoyama/python_molecular_editor/actions)
-![Core Logic Coverage](https://img.shields.io/badge/core_logic_coverage->80%25-green)
-![Overall Coverage](https://img.shields.io/badge/coverage->75%25-green)
+![Overall Coverage](https://img.shields.io/badge/coverage->80%25-green)
 ![GUI Status](https://img.shields.io/badge/GUI-Manually_Verified-blue)
 ![Pylint Score](https://img.shields.io/badge/pylint->9%2F10-brightgreen)
 [![PyPI Downloads](https://static.pepy.tech/personalized-badge/moleditpy?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/moleditpy)
@@ -850,6 +849,8 @@ If you use this software in your work, please cite it as follows:
 Yokoyama, H. (2026). MoleditPy — A Python-based molecular editing software. Zenodo. https://doi.org/10.5281/zenodo.17268532
 ```
 
+Additionally, please cite the plugins you used.
+
 -----
 
 <div id="japanese"></div>
@@ -981,3 +982,5 @@ moleditpy
 ```
 Yokoyama, H. (2026). MoleditPy — A Python-based molecular editing software. Zenodo. https://doi.org/10.5281/zenodo.17268532
 ```
+
+また、使用したプラグインの引用もお願いいたします。

{moleditpy_linux-3.6.6 → moleditpy_linux-4.0.1}/README.md

@@ -6,8 +6,7 @@
 [![Python Versions](https://img.shields.io/pypi/pyversions/MoleditPy.svg)](https://pypi.org/project/MoleditPy/)
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 [![Build Status](https://github.com/HiroYokoyama/python_molecular_editor/actions/workflows/tests.yml/badge.svg)](https://github.com/HiroYokoyama/python_molecular_editor/actions)
-![Core Logic Coverage](https://img.shields.io/badge/core_logic_coverage->80%25-green)
-![Overall Coverage](https://img.shields.io/badge/coverage->75%25-green)
+![Overall Coverage](https://img.shields.io/badge/coverage->80%25-green)
 ![GUI Status](https://img.shields.io/badge/GUI-Manually_Verified-blue)
 ![Pylint Score](https://img.shields.io/badge/pylint->9%2F10-brightgreen)
 [![PyPI Downloads](https://static.pepy.tech/personalized-badge/moleditpy?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/moleditpy)
@@ -147,6 +146,8 @@ If you use this software in your work, please cite it as follows:
 Yokoyama, H. (2026). MoleditPy — A Python-based molecular editing software. Zenodo. https://doi.org/10.5281/zenodo.17268532
 ```
 
+Additionally, please cite the plugins you used.
+
 -----
 
 <div id="japanese"></div>
@@ -278,3 +279,5 @@ moleditpy
 ```
 Yokoyama, H. (2026). MoleditPy — A Python-based molecular editing software. Zenodo. https://doi.org/10.5281/zenodo.17268532
 ```
+
+また、使用したプラグインの引用もお願いいたします。

{moleditpy_linux-3.6.6 → moleditpy_linux-4.0.1}/pyproject.toml

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

{moleditpy_linux-3.6.6 → moleditpy_linux-4.0.1}/src/MoleditPy_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 3.6.6
+Version: 4.0.1
 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
@@ -709,8 +709,7 @@ Dynamic: license-file
 [![Python Versions](https://img.shields.io/pypi/pyversions/MoleditPy.svg)](https://pypi.org/project/MoleditPy/)
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 [![Build Status](https://github.com/HiroYokoyama/python_molecular_editor/actions/workflows/tests.yml/badge.svg)](https://github.com/HiroYokoyama/python_molecular_editor/actions)
-![Core Logic Coverage](https://img.shields.io/badge/core_logic_coverage->80%25-green)
-![Overall Coverage](https://img.shields.io/badge/coverage->75%25-green)
+![Overall Coverage](https://img.shields.io/badge/coverage->80%25-green)
 ![GUI Status](https://img.shields.io/badge/GUI-Manually_Verified-blue)
 ![Pylint Score](https://img.shields.io/badge/pylint->9%2F10-brightgreen)
 [![PyPI Downloads](https://static.pepy.tech/personalized-badge/moleditpy?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/moleditpy)
@@ -850,6 +849,8 @@ If you use this software in your work, please cite it as follows:
 Yokoyama, H. (2026). MoleditPy — A Python-based molecular editing software. Zenodo. https://doi.org/10.5281/zenodo.17268532
 ```
 
+Additionally, please cite the plugins you used.
+
 -----
 
 <div id="japanese"></div>
@@ -981,3 +982,5 @@ moleditpy
 ```
 Yokoyama, H. (2026). MoleditPy — A Python-based molecular editing software. Zenodo. https://doi.org/10.5281/zenodo.17268532
 ```
+
+また、使用したプラグインの引用もお願いいたします。

{moleditpy_linux-3.6.6 → moleditpy_linux-4.0.1}/src/MoleditPy_linux.egg-info/SOURCES.txt

@@ -56,6 +56,7 @@ src/moleditpy_linux/ui/move_group_dialog.py
 src/moleditpy_linux/ui/move_selected_atoms_dialog.py
 src/moleditpy_linux/ui/periodic_table_dialog.py
 src/moleditpy_linux/ui/planarize_dialog.py
+src/moleditpy_linux/ui/plugin_menu_manager.py
 src/moleditpy_linux/ui/settings_dialog.py
 src/moleditpy_linux/ui/string_importers.py
 src/moleditpy_linux/ui/template_preview_item.py

{moleditpy_linux-3.6.6 → moleditpy_linux-4.0.1}/src/moleditpy_linux/__init__.py

@@ -12,7 +12,7 @@ DOI: 10.5281/zenodo.17268532
 Top-level package for moleditpy_linux.
 """
 
-import importlib.util
+import importlib.util  # noqa: F401
 from .utils.constants import VERSION as __version__  # noqa: F401
 
 try:

{moleditpy_linux-3.6.6 → moleditpy_linux-4.0.1}/src/moleditpy_linux/core/molecular_data.py

@@ -15,10 +15,7 @@ import logging
 from typing import Any, Dict, List, Optional, Tuple, Union
 from rdkit import Chem
 
-try:
-    from ..utils.constants import ANGSTROM_PER_PIXEL
-except ImportError:
-    from moleditpy_linux.utils.constants import ANGSTROM_PER_PIXEL
+from ..utils.constants import ANGSTROM_PER_PIXEL
 
 
 class PointTuple(tuple):
@@ -35,12 +32,12 @@ class MolecularData:
     atoms: Dict[int, Dict[str, Any]]
     bonds: Dict[Tuple[int, int], Dict[str, Any]]
     adjacency_list: Dict[int, List[int]]
-    _next_atom_id: int
+    next_atom_id: int
 
     def __init__(self) -> None:
         self.atoms = {}
         self.bonds = {}
-        self._next_atom_id = 0
+        self.next_atom_id = 0
         self.adjacency_list = {}
 
     def add_atom(
@@ -50,7 +47,7 @@ class MolecularData:
         charge: int = 0,
         radical: int = 0,
     ) -> int:
-        atom_id = self._next_atom_id
+        atom_id = self.next_atom_id
         # Internalize position as raw floats to decouple from UI types (QPointF)
         if hasattr(pos, "x") and hasattr(pos, "y"):
             raw_pos = PointTuple((float(pos.x()), float(pos.y())))
@@ -60,12 +57,11 @@ class MolecularData:
         self.atoms[atom_id] = {
             "symbol": symbol,
             "pos": raw_pos,
-            "item": None,
             "charge": charge,
             "radical": radical,
         }
         self.adjacency_list[atom_id] = []
-        self._next_atom_id += 1
+        self.next_atom_id += 1
         return atom_id
 
     def set_atom_pos(self, atom_id: int, pos: Union[Any, Tuple[float, float]]) -> None:
@@ -87,7 +83,7 @@ class MolecularData:
             if id1 > id2:
                 id1, id2 = id2, id1
 
-        bond_data = {"order": order, "stereo": stereo, "item": None}
+        bond_data = {"order": order, "stereo": stereo}
 
         # Check if it's a new bond, considering reverse direction keys.
         is_new_bond = (id1, id2) not in self.bonds and (id2, id1) not in self.bonds
@@ -321,94 +317,6 @@ class MolecularData:
             Chem.AssignStereochemistry(final_mol, cleanIt=False, force=False)
         return final_mol
 
-    def update_ring_info_2d(self) -> None:
-        """Update is_in_ring and ring_center for all BondItems based on 2D topology."""
-        if not self.atoms or not self.bonds:
-            return
-
-        # 1. Generate RDKit molecule for topology analysis
-        mol = self.to_rdkit_mol(use_2d_stereo=False)
-        if not mol:
-            # Fallback: reset all ring info if molecule generation fails
-            for bond_data in self.bonds.values():
-                bond_item = bond_data.get("item")
-                if bond_item:
-                    bond_item.is_in_ring = False
-                    bond_item.ring_center = None
-            return
-
-        # 2. Extract ring information
-        ring_info = mol.GetRingInfo()
-        atom_rings = ring_info.AtomRings()
-        bond_rings = ring_info.BondRings()
-
-        # 3. Create mapping from RDKit atom index to editor atom item
-        rdkit_idx_to_item = {}
-        for atom in mol.GetAtoms():
-            if atom.HasProp("_original_atom_id"):
-                orig_id = atom.GetIntProp("_original_atom_id")
-                if orig_id in self.atoms:
-                    rdkit_idx_to_item[atom.GetIdx()] = self.atoms[orig_id]["item"]
-
-        # 4. Map RDKit bond index to editor bond item
-        rdkit_bond_idx_to_item = {}
-        for bidx, rdkit_bond in enumerate(mol.GetBonds()):
-            a1_idx = rdkit_bond.GetBeginAtomIdx()
-            a2_idx = rdkit_bond.GetEndAtomIdx()
-            if a1_idx in rdkit_idx_to_item and a2_idx in rdkit_idx_to_item:
-                # Find corresponding editor bond item
-                # This is slightly expensive but done once per update
-                item1 = rdkit_idx_to_item[a1_idx]
-                item2 = rdkit_idx_to_item[a2_idx]
-                id1, id2 = item1.atom_id, item2.atom_id
-                key = (id1, id2) if (id1, id2) in self.bonds else (id2, id1)
-                if key in self.bonds:
-                    rdkit_bond_idx_to_item[bidx] = self.bonds[key].get("item")
-
-        # 5. Initialize/Reset all bond items and track best ring size
-        bond_to_best_size: Dict[
-            int, int
-        ] = {}  # bond_item_id -> smallest_ring_size_found
-        for bond_data in self.bonds.values():
-            bond_item = bond_data.get("item")
-            if bond_item:
-                bond_item.is_in_ring = False
-                bond_item.ring_center = None
-
-        # 6. Apply ring information
-        for a_ring, b_ring in zip(atom_rings, bond_rings):
-            ring_size = len(a_ring)
-            # Calculate ring center (geometric mean of atom positions)
-            positions = []
-            for aidx in a_ring:
-                item = rdkit_idx_to_item.get(aidx)
-                if item and hasattr(item, "pos"):
-                    pos = item.pos()
-                    if pos is not None:
-                        positions.append(pos)
-
-            if not positions:
-                continue
-
-            center_x = sum(p.x() for p in positions) / len(positions)
-            center_y = sum(p.y() for p in positions) / len(positions)
-            ring_center = (center_x, center_y)  # Use tuple (x, y) instead of QPointF
-
-            # Update all bonds in this ring
-            for bidx in b_ring:
-                bond_item = rdkit_bond_idx_to_item.get(bidx)
-                if bond_item:
-                    bond_item.is_in_ring = True
-                    # Explicitly prioritize smaller rings for double bond shift logic.
-                    # This ensures the double bond is drawn inside the smaller ring in fused systems.
-                    item_id = id(bond_item)
-                    if (
-                        item_id not in bond_to_best_size
-                        or ring_size < bond_to_best_size[item_id]
-                    ):
-                        bond_item.ring_center = ring_center
-                        bond_to_best_size[item_id] = ring_size
-
     def to_mol_block(self) -> Optional[str]:
         mol = self.to_rdkit_mol()
         if mol:

{moleditpy_linux-3.6.6 → moleditpy_linux-4.0.1}/src/moleditpy_linux/main.py

@@ -17,23 +17,13 @@ import logging
 import os
 from typing import Any
 
-try:
-    from .utils.constants import VERSION
-except ImportError:
-    # Add the parent directory (src) to sys.path so 'moleditpy_linux.*' imports work
-    src_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-    if src_dir not in sys.path:
-        sys.path.insert(0, src_dir)
-    from moleditpy_linux.utils.constants import VERSION
+from .utils.constants import VERSION
 
 # VERSION is resolved above (before Qt) so --version works without launching the app.
 
 from PyQt6.QtWidgets import QApplication
 
-try:
-    from .ui.main_window import MainWindow
-except ImportError:
-    from moleditpy_linux.ui.main_window import MainWindow
+from .ui.main_window import MainWindow
 
 
 def setup_logging() -> None:
@@ -103,7 +93,7 @@ def main() -> None:
             from .plugins.plugin_manager import PluginManager
 
         pm = PluginManager()
-        sha256 = pm._compute_sha256(plugin_path)
+        sha256 = pm.compute_sha256(plugin_path)
 
         # Extract metadata
         metadata_file = plugin_path
@@ -155,7 +145,9 @@ def main() -> None:
             from PyQt6.QtCore import QTimer
 
             QTimer.singleShot(100, lambda: window.setWindowIcon(window.windowIcon()))
-        except Exception:
+        except (
+            Exception
+        ):  # [COSMETIC] Icon refresh is best-effort; Qt timing errors are non-fatal.
             pass
 
     sys.exit(app.exec())

{moleditpy_linux-3.6.6 → moleditpy_linux-4.0.1}/src/moleditpy_linux/plugins/plugin_interface.py

@@ -164,6 +164,24 @@ class PluginContext:
         """
         self._manager.show_status_message(message, timeout)
 
+    def rebuild_menus(self) -> None:
+        """Rebuild plugin-managed menus and toolbars to apply changes immediately (Public API)."""
+        if hasattr(self._manager, "rebuild_plugin_menus"):
+            self._manager.rebuild_plugin_menus()
+
+    def enter_3d_viewer_mode(self) -> None:
+        """Switch the application UI layout to 3D viewer mode (Public API)."""
+        mw = self.get_main_window()
+        if mw is not None and hasattr(mw, "ui_manager"):
+            if hasattr(mw.ui_manager, "enter_3d_viewer_mode"):
+                mw.ui_manager.enter_3d_viewer_mode()
+            elif hasattr(mw.ui_manager, "enter_3d_viewer_ui_mode"):
+                mw.ui_manager.enter_3d_viewer_ui_mode()
+
+    def enter_3d_mode(self) -> None:
+        """Switch UI layout to 3D viewer mode. Alias for enter_3d_viewer_mode."""
+        self.enter_3d_viewer_mode()
+
     @property
     def current_mol(self) -> Any:
         """
@@ -310,8 +328,12 @@ class PluginContext:
 
     def register_3d_context_menu(self, callback: Callable, label: str) -> None:
         """Deprecated: This method does nothing. Kept for backward compatibility."""
-        print(
-            f"Warning: Plugin '{self._plugin_name}' uses deprecated 'register_3d_context_menu'. This API has been removed."
+        import warnings
+
+        warnings.warn(
+            f"Plugin '{self._plugin_name}' uses deprecated 'register_3d_context_menu'. This API has been removed.",
+            category=DeprecationWarning,
+            stacklevel=2,
         )
 
     def register_3d_style(
@@ -371,6 +393,133 @@ class PluginContext:
             if hasattr(mw.init_manager, "settings_dirty"):
                 mw.init_manager.settings_dirty = True
 
+    def mark_project_modified(self) -> None:
+        """Mark the current project as having unsaved changes and update the window title."""
+        mw = self.get_main_window()
+        if mw and hasattr(mw, "state_manager"):
+            try:
+                mw.state_manager.has_unsaved_changes = True
+                if hasattr(mw.state_manager, "update_window_title"):
+                    mw.state_manager.update_window_title()
+            except Exception:
+                pass
+
+    def refresh_ui(self) -> None:
+        """Refresh all UI state after modifying the molecule.
+
+        Calls update_realtime_info, update_undo_redo_actions, and update_window_title
+        in one shot. Call this at the end of any edit that changes atom/bond data.
+        """
+        mw = self.get_main_window()
+        if mw is None:
+            return
+        if hasattr(mw, "state_manager"):
+            if hasattr(mw.state_manager, "update_realtime_info"):
+                mw.state_manager.update_realtime_info()
+            if hasattr(mw.state_manager, "update_window_title"):
+                mw.state_manager.update_window_title()
+        if hasattr(mw, "edit_actions_manager") and hasattr(
+            mw.edit_actions_manager, "update_undo_redo_actions"
+        ):
+            mw.edit_actions_manager.update_undo_redo_actions()
+
+    def fit_3d_view(self) -> None:
+        """Zoom and re-center the 3D viewport to fit the current molecule."""
+        mw = self.get_main_window()
+        if mw and hasattr(mw, "view_3d_manager"):
+            fit = getattr(mw.view_3d_manager, "fit_to_view", None)
+            if fit is not None:
+                fit()
+
+    def clear_canvas(self, push_to_undo: bool = True) -> None:
+        """Clear the 2D editor canvas.
+
+        Args:
+            push_to_undo: Whether to push the cleared state onto the undo stack
+                          before clearing (default True).
+        """
+        mw = self.get_main_window()
+        if mw and hasattr(mw, "edit_actions_manager"):
+            clear = getattr(mw.edit_actions_manager, "clear_2d_editor", None)
+            if clear is not None:
+                clear(push_to_undo=push_to_undo)
+
+    def set_3d_features_enabled(self, enabled: bool) -> None:
+        """Enable or disable the 3D visualization panel and related UI actions.
+
+        Args:
+            enabled: True to enable 3D features, False to disable.
+        """
+        mw = self.get_main_window()
+        if mw and hasattr(mw, "ui_manager"):
+            enable = getattr(mw.ui_manager, "enable_3d_features", None)
+            if enable is not None:
+                enable(enabled)
+
+    def set_analysis_enabled(self, enabled: bool) -> None:
+        """Enable or disable the Analysis action in the main menu.
+
+        Args:
+            enabled: True to enable, False to disable.
+        """
+        mw = self.get_main_window()
+        if mw and hasattr(mw, "init_manager"):
+            action = getattr(mw.init_manager, "analysis_action", None)
+            if action is not None:
+                action.setEnabled(enabled)
+
+    def check_chemistry_problems(self) -> None:
+        """Trigger a chemistry validation pass and update problem flags on atoms."""
+        mw = self.get_main_window()
+        if mw and hasattr(mw, "compute_manager"):
+            check = getattr(
+                mw.compute_manager, "check_chemistry_problems_fallback", None
+            )
+            if check is not None:
+                check()
+
+    def refresh_2d_scene(self) -> None:
+        """Force a full redraw of the 2D canvas.
+
+        Recalculates ring geometry, then repaints every atom and bond item.
+        Use this after directly manipulating scene items (e.g. via scene.create_atom)
+        without going through context.current_molecule.
+        For a lightweight Qt repaint only, use context.scene.update() instead.
+        """
+        mw = self.get_main_window()
+        if mw and hasattr(mw, "init_manager"):
+            scene = getattr(mw.init_manager, "scene", None)
+            if scene is not None and hasattr(scene, "update_all_items"):
+                scene.update_all_items()
+
+    def load_from_smiles(self, smiles: str) -> None:
+        """Add a molecule from a SMILES string to the 2D editor."""
+        mw = self.get_main_window()
+        if mw and hasattr(mw, "string_importer_manager"):
+            mw.string_importer_manager.load_from_smiles(smiles)
+
+    def to_xyz_block(self) -> Optional[str]:
+        """Return the current 3D structure as an XYZ block (only element x y z lines)."""
+        mol = self.current_mol
+        if not mol:
+            return None
+
+        try:
+            conf = mol.GetConformer()
+            num_atoms = mol.GetNumAtoms()
+            xyz_lines = []
+
+            for i in range(num_atoms):
+                pos = conf.GetAtomPosition(i)
+                symbol = mol.GetAtomWithIdx(i).GetSymbol()
+                xyz_lines.append(
+                    f"  {symbol:<5}{pos.x:>15.8f}{pos.y:>15.8f}{pos.z:>15.8f}"
+                )
+
+            return "\n".join(xyz_lines)
+        except Exception:
+            return None
+
 
 class Plugin3DController:
     """Helper to manipulate the 3D scene."""

{moleditpy_linux-3.6.6 → moleditpy_linux-4.0.1}/src/moleditpy_linux/plugins/plugin_manager.py

@@ -25,15 +25,11 @@ from PyQt6.QtCore import QUrl
 from PyQt6.QtGui import QDesktopServices
 from PyQt6.QtWidgets import QMessageBox
 
-try:
-    from .plugin_interface import PluginContext
-except ImportError:
-    # Fallback if running as script
-    from moleditpy_linux.plugins.plugin_interface import PluginContext
+from .plugin_interface import PluginContext
 
 
 class PluginManager:
-    def _compute_sha256(self, path: str) -> str:
+    def compute_sha256(self, path: str) -> str:
         """Computes SHA-256 for a file or a directory (concatenated hashes of all files)."""
         if os.path.isfile(path):
             return self._sha256_for_file(path)
@@ -66,7 +62,10 @@ class PluginManager:
                     hasher.update(rel_path.encode("utf-8", errors="replace"))
                     hasher.update(b"\0")
                     with open(file_path, "rb") as f:
-                        for chunk in iter(lambda: f.read(8192), b""):
+                        while True:
+                            chunk = f.read(8192)
+                            if not chunk:
+                                break
                             hasher.update(chunk)
                     hasher.update(b"\0")
             return hasher.hexdigest()
@@ -363,35 +362,18 @@ class PluginManager:
                     # Pass category to context if needed, currently not storing it in context directly but could be useful
                     try:
                         module.initialize(context)
-                    except (
-                        AttributeError,
-                        RuntimeError,
-                        ValueError,
-                        OSError,
-                        ImportError,
-                        SyntaxError,
-                    ) as e:
-                        # [BROAD EXCEPTION] Plugins have root power; catch all potential failures during init.
+                    except Exception as e:  # plugins have full app access; catch everything to isolate faults
                         status = f"Error (Init): {e}"
-                        # Initialization errors are stored in plugin status for display in Plugin Dialog
-                        logging.error(f"Plugin {plugin_name} initialize error: {e}")
+                        logging.exception("Plugin %s initialize error", plugin_name)
                 elif has_autorun:
                     try:
                         if self.main_window:
                             module.autorun(self.main_window)
                         else:
                             status = "Skipped (No MW)"
-                    except (
-                        AttributeError,
-                        RuntimeError,
-                        ValueError,
-                        OSError,
-                        ImportError,
-                        SyntaxError,
-                    ) as e:
+                    except Exception as e:  # plugins have full app access; catch everything to isolate faults
                         status = f"Error (Autorun): {e}"
-                        # Autorun errors are stored in plugin status
-                        print(f"Plugin {plugin_name} autorun error: {e}")
+                        logging.exception("Plugin %s autorun error", plugin_name)
                 elif not has_run:
                     status = "No Entry Point"
 
@@ -409,36 +391,25 @@ class PluginManager:
                     }
                 )
 
-        except (
-            AttributeError,
-            RuntimeError,
-            ValueError,
-            OSError,
-            ImportError,
-            SyntaxError,
-        ) as e:
-            # [BROAD EXCEPTION] Loading failures are caught to prevent a single buggy plugin from
-            # crashing the entire discovery process.
-            logging.error(f"Failed to load plugin {module_name}: {e}")
+        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)
 
     def run_plugin(self, module: Any, main_window: Any) -> None:
         """Executes the plugin's run method (Legacy manual trigger)."""
         try:
             module.run(main_window)
-        except (
-            AttributeError,
-            RuntimeError,
-            ValueError,
-            OSError,
-            ImportError,
-            SyntaxError,
-        ) as e:
+        except Exception as e:  # plugins have full app access; catch everything so the error dialog can show the cause
             QMessageBox.critical(
                 main_window,
                 "Plugin Error",
                 f"Error running plugin '{getattr(module, 'PLUGIN_NAME', 'Unknown')}':\n{e}",
             )
 
+    def rebuild_plugin_menus(self) -> None:
+        """Rebuild all plugin menus and toolbars."""
+        if self.main_window and hasattr(self.main_window, "plugin_menu_manager"):
+            self.main_window.plugin_menu_manager.rebuild_plugin_menus()
+
     # --- Registration Callbacks ---
     def register_menu_action(
         self,
@@ -614,9 +585,11 @@ class PluginManager:
                                     selected_indices.append(i)
                             except (RuntimeError, ValueError, TypeError):
                                 continue
-        except ImportError:
+        except (
+            ImportError
+        ):  # [OPTIONAL DEP] importlib.metadata unavailable (<3.8); silently skip.
             pass
-        except Exception as e:
+        except (RuntimeError, AttributeError) as e:
             logging.error(f"Error retrieving selected atom indices: {e}")
 
         return selected_indices
@@ -636,17 +609,9 @@ class PluginManager:
         for handler in self.document_reset_handlers:
             try:
                 handler["callback"]()
-            except (
-                AttributeError,
-                RuntimeError,
-                ValueError,
-                OSError,
-                ImportError,
-                SyntaxError,
-            ) as e:
-                # [BROAD EXCEPTION] Document reset handlers are user plugins; catch all to prevent data loss.
-                logging.error(
-                    f"Error in document reset handler for {handler['plugin']}: {e}"
+            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
                 )
 
     def get_plugin_info_safe(self, file_path: str) -> Dict[str, str]:
@@ -675,10 +640,6 @@ class PluginManager:
                         if node.value:  # AnnAssign might presumably not have value? (though usually does for module globals)
                             if isinstance(node.value, ast.Constant):  # Py3.8+
                                 val = node.value.value
-                            elif hasattr(ast, "Str") and isinstance(
-                                node.value, getattr(ast, "Str", type(None))
-                            ):  # Py3.7 and below
-                                val = node.value.s
                             elif isinstance(node.value, ast.Tuple):
                                 # Handle version tuples e.g. (1, 0, 0)
                                 try:
@@ -687,18 +648,13 @@ class PluginManager:
                                     for elt in node.value.elts:
                                         if isinstance(elt, ast.Constant):
                                             elts.append(elt.value)
-                                        elif hasattr(ast, "Num") and isinstance(
-                                            elt, getattr(ast, "Num", type(None))
-                                        ):
-                                            elts.append(elt.n)
                                     val = ".".join(map(str, elts))
                                 except (
                                     AttributeError,
                                     RuntimeError,
                                     ValueError,
                                     TypeError,
-                                ):
-                                    # Fallback for complex AST structures during metadata extraction
+                                ):  # [AST PARSE] Complex/unexpected AST node shapes during metadata extraction; skip gracefully.
                                     pass
 
                         if val is not None: