MoleditPy-linux 4.8.0__tar.gz → 4.8.2__tar.gz

{moleditpy_linux-4.8.0 → moleditpy_linux-4.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.8.0
+Version: 4.8.2
 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,9 +709,9 @@ 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)
-![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)
+[![Overall Coverage](https://img.shields.io/badge/coverage->80%25-green)](https://github.com/HiroYokoyama/python_molecular_editor/blob/main/tests/coverage_report.md)
+[![GUI Status](https://img.shields.io/badge/GUI-Manually_Verified-blue)](https://github.com/HiroYokoyama/python_molecular_editor/blob/main/tests/MANUAL_CHECKLIST.md)
+[![Pylint Score](https://img.shields.io/badge/pylint->9%2F10-brightgreen)](https://github.com/HiroYokoyama/python_molecular_editor/blob/main/tests/pylint-score.txt)
 [![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)
 [![PyPI Downloads](https://static.pepy.tech/personalized-badge/moleditpy?period=monthly&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=monthly+downloads)](https://pepy.tech/projects/moleditpy)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/HiroYokoyama/python_molecular_editor)

{moleditpy_linux-4.8.0 → moleditpy_linux-4.8.2}/README.md

@@ -6,9 +6,9 @@
 [![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)
-![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)
+[![Overall Coverage](https://img.shields.io/badge/coverage->80%25-green)](https://github.com/HiroYokoyama/python_molecular_editor/blob/main/tests/coverage_report.md)
+[![GUI Status](https://img.shields.io/badge/GUI-Manually_Verified-blue)](https://github.com/HiroYokoyama/python_molecular_editor/blob/main/tests/MANUAL_CHECKLIST.md)
+[![Pylint Score](https://img.shields.io/badge/pylint->9%2F10-brightgreen)](https://github.com/HiroYokoyama/python_molecular_editor/blob/main/tests/pylint-score.txt)
 [![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)
 [![PyPI Downloads](https://static.pepy.tech/personalized-badge/moleditpy?period=monthly&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=monthly+downloads)](https://pepy.tech/projects/moleditpy)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/HiroYokoyama/python_molecular_editor)

{moleditpy_linux-4.8.0 → moleditpy_linux-4.8.2}/pyproject.toml

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

{moleditpy_linux-4.8.0 → moleditpy_linux-4.8.2}/src/MoleditPy_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.8.0
+Version: 4.8.2
 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,9 +709,9 @@ 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)
-![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)
+[![Overall Coverage](https://img.shields.io/badge/coverage->80%25-green)](https://github.com/HiroYokoyama/python_molecular_editor/blob/main/tests/coverage_report.md)
+[![GUI Status](https://img.shields.io/badge/GUI-Manually_Verified-blue)](https://github.com/HiroYokoyama/python_molecular_editor/blob/main/tests/MANUAL_CHECKLIST.md)
+[![Pylint Score](https://img.shields.io/badge/pylint->9%2F10-brightgreen)](https://github.com/HiroYokoyama/python_molecular_editor/blob/main/tests/pylint-score.txt)
 [![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)
 [![PyPI Downloads](https://static.pepy.tech/personalized-badge/moleditpy?period=monthly&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=monthly+downloads)](https://pepy.tech/projects/moleditpy)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/HiroYokoyama/python_molecular_editor)

{moleditpy_linux-4.8.0 → moleditpy_linux-4.8.2}/src/moleditpy_linux/plugins/plugin_interface.py

@@ -31,6 +31,7 @@ class PluginContext:
         text: Optional[str] = None,
         icon: Optional[str] = None,
         shortcut: Optional[str] = None,
+        pin: Optional[str] = None,
     ) -> None:
         """
         Register a menu action.
@@ -41,9 +42,16 @@ class PluginContext:
             text: Label for the action (defaults to last part of path if None).
             icon: Path to icon or icon name (optional).
             shortcut: Keyboard shortcut (optional).
+            pin: Placement request. ``"header"`` puts a direct "Plugin/<entry>"
+                registration next to "Plugin Manager..." above the first
+                divider, for plugins that manage the plugin system itself.
+                Anything else is ignored, so unknown values stay forward
+                compatible. Added in 4.8.1 — passing it to an older MoleditPy
+                raises TypeError, so guard the call if your plugin supports
+                both (see PLUGIN_DEVELOPMENT_MANUAL_V4.md).
         """
         self._manager.register_menu_action(
-            self._plugin_name, path, callback, text, icon, shortcut
+            self._plugin_name, path, callback, text, icon, shortcut, pin
         )
 
     def register_menu_action(
@@ -72,6 +80,7 @@ class PluginContext:
         text: Optional[str] = None,
         icon: Optional[str] = None,
         shortcut: Optional[str] = None,
+        pin: Optional[str] = None,
     ) -> None:
         """
         Register an action nested inside the Plugin menu.
@@ -87,9 +96,10 @@ class PluginContext:
             text: Label override (defaults to last part of path).
             icon: Path to icon (optional).
             shortcut: Keyboard shortcut (optional).
+            pin: Placement request; see add_menu_action.
         """
         full_path = f"Plugin/{path.lstrip('/')}"
-        self.add_menu_action(full_path, callback, text, icon, shortcut)
+        self.add_menu_action(full_path, callback, text, icon, shortcut, pin)
 
     def add_toolbar_action(
         self,

{moleditpy_linux-4.8.0 → moleditpy_linux-4.8.2}/src/moleditpy_linux/plugins/plugin_manager.py

@@ -358,7 +358,13 @@ class PluginManager:
                 plugin_desc = getattr(
                     module, "PLUGIN_DESCRIPTION", getattr(module, "__doc__", "")
                 )
-                plugin_category = getattr(module, "PLUGIN_CATEGORY", category)
+                # The folder the user filed the plugin under wins: that
+                # placement is a deliberate, user-controlled ordering. A
+                # plugin's own PLUGIN_CATEGORY only applies when the file sits
+                # at the plugins root, where there is no folder to honour.
+                plugin_category = category or str(
+                    getattr(module, "PLUGIN_CATEGORY", "") or ""
+                )
 
                 # Additional cleanup for docstring (strip whitespace)
                 if plugin_desc is None:
@@ -445,8 +451,13 @@ class PluginManager:
         text: str,
         icon: str,
         shortcut: str,
+        pin: Optional[str] = None,
     ) -> None:
-        """Register a plugin menu action with its path, callback, and display metadata."""
+        """Register a plugin menu action with its path, callback, and display metadata.
+
+        ``pin`` is optional so a V3-era caller reaching this method directly
+        keeps working.
+        """
         self.menu_actions.append(
             {
                 "plugin": plugin_name,
@@ -455,6 +466,7 @@ class PluginManager:
                 "text": text,
                 "icon": icon,
                 "shortcut": shortcut,
+                "pin": pin,
             }
         )
 

{moleditpy_linux-4.8.0 → moleditpy_linux-4.8.2}/src/moleditpy_linux/ui/calculation_worker.py

@@ -26,6 +26,8 @@ from rdkit import Chem
 from rdkit.Chem import AllChem, rdGeometry
 from rdkit.DistanceGeometry import DoTriangleSmoothing
 
+from ..utils.constants import DEFAULT_BOND_LENGTH_ANGSTROM
+
 from .. import OBABEL_AVAILABLE
 
 # Only import pybel on demand
@@ -367,6 +369,50 @@ def _apply_explicit_stereo(
                     bond.SetStereo(stereo_type)
 
 
+# Typical X-H distances used when placing hydrogens the 2D sketch never had.
+_DIRECT_XH_LENGTHS = {6: 1.09, 7: 1.01, 8: 0.97, 15: 1.42, 16: 1.34}
+_DIRECT_XH_DEFAULT = 1.10
+# Out-of-plane tilt applied to added H and to wedge/hash bonds.
+_DIRECT_H_TILT = math.radians(20.0)
+_DIRECT_WEDGE_TILT = math.radians(35.0)
+
+
+def _rescale_2d_layout(
+    coords: list, mol: Chem.Mol, _safe_status: Callable[[str], None]
+) -> list:
+    """Scale parsed 2D coordinates so the median bond is a chemically sane length."""
+    lengths = []
+    for bond in mol.GetBonds():
+        i, j = bond.GetBeginAtomIdx(), bond.GetEndAtomIdx()
+        if i < len(coords) and j < len(coords):
+            d = math.hypot(coords[i][0] - coords[j][0], coords[i][1] - coords[j][1])
+            if d > 1e-6:
+                lengths.append(d)
+    if not lengths:
+        return coords
+
+    median = float(np.median(lengths))
+    if median < 1e-6 or abs(median - DEFAULT_BOND_LENGTH_ANGSTROM) < 0.05:
+        return coords
+
+    scale = DEFAULT_BOND_LENGTH_ANGSTROM / median
+    _safe_status(f"Rescaling 2D layout (x{scale:.3f})...")
+    return [(x * scale, y * scale, z * scale) for x, y, z in coords]
+
+
+def _center_conformer(conf: Chem.Conformer) -> None:
+    """Move the conformer's centroid to the origin."""
+    n = conf.GetNumAtoms()
+    if n == 0:
+        return
+    pos = np.array(
+        [[p.x, p.y, p.z] for p in (conf.GetAtomPosition(i) for i in range(n))],
+        dtype=float,
+    )
+    for i, (x, y, z) in enumerate(pos - pos.mean(axis=0)):
+        conf.SetAtomPosition(i, rdGeometry.Point3D(float(x), float(y), float(z)))
+
+
 def _perform_direct_conversion(
     mol_block: str,
     mol: Chem.Mol,
@@ -446,6 +492,8 @@ def _perform_direct_conversion(
     if not parsed_coords:
         raise ValueError("Failed to parse coordinates for direct conversion.")
 
+    parsed_coords = _rescale_2d_layout(parsed_coords, mol, _safe_status)
+
     num_existing = len(parsed_coords)
     conf = Chem.Conformer(mol.GetNumAtoms())
     for i in range(mol.GetNumAtoms()):
@@ -480,28 +528,45 @@ def _perform_direct_conversion(
                                 vecs[0][0],
                                 math.hypot(-vecs[0][1], vecs[0][0]),
                             )
-                        angle = sum(
+                        n_placed = sum(
                             1
                             for n in mol.GetAtomWithIdx(parent_idx).GetNeighbors()
                             if n.GetIdx() < i and n.GetAtomicNum() == 1
-                        ) * (math.pi / 6.0)
+                        )
+                        angle = n_placed * (math.pi / 6.0)
                         rx, ry = (
                             (fx / fn) * math.cos(angle) - (fy / fn) * math.sin(angle),
                             (fx / fn) * math.sin(angle) + (fy / fn) * math.cos(angle),
                         )
+                        bond_len = _DIRECT_XH_LENGTHS.get(
+                            mol.GetAtomWithIdx(parent_idx).GetAtomicNum(),
+                            _DIRECT_XH_DEFAULT,
+                        )
+                        in_plane = bond_len * math.cos(_DIRECT_H_TILT)
+                        # Alternate the pucker so a CH2's two hydrogens straddle
+                        # the plane instead of stacking on the same side.
+                        dz = bond_len * math.sin(_DIRECT_H_TILT)
+                        if n_placed % 2:
+                            dz = -dz
                         conf.SetAtomPosition(
                             i,
                             rdGeometry.Point3D(
-                                float(parent_pos.x) + rx, float(parent_pos.y) + ry, 0.3
+                                float(parent_pos.x) + rx * in_plane,
+                                float(parent_pos.y) + ry * in_plane,
+                                float(parent_pos.z) + dz,
                             ),
                         )
                     else:
+                        bond_len = _DIRECT_XH_LENGTHS.get(
+                            mol.GetAtomWithIdx(parent_idx).GetAtomicNum(),
+                            _DIRECT_XH_DEFAULT,
+                        )
                         conf.SetAtomPosition(
                             i,
                             rdGeometry.Point3D(
-                                float(parent_pos.x) + 0.5,
-                                float(parent_pos.y) + 0.5,
-                                0.3,
+                                float(parent_pos.x) + bond_len,
+                                float(parent_pos.y),
+                                float(parent_pos.z),
                             ),
                         )
                 else:
@@ -511,16 +576,28 @@ def _perform_direct_conversion(
     with suppress_log(AttributeError, RuntimeError, TypeError, IndexError):
         for b, e, flag in stereo_dirs:
             if b < num_existing and e < num_existing:
-                pos = conf.GetAtomPosition(e)
+                start, pos = conf.GetAtomPosition(b), conf.GetAtomPosition(e)
+                vx, vy = float(pos.x) - float(start.x), float(pos.y) - float(start.y)
+                length = math.hypot(vx, vy)
+                if length < 1e-6:
+                    continue
+                # Rotate the bond out of plane so it keeps its length; adding a
+                # flat +/-1.5 A of z stretched every wedge bond instead.
+                sign = 1.0 if flag == 1 else -1.0
+                scale = math.cos(_DIRECT_WEDGE_TILT)
                 conf.SetAtomPosition(
                     e,
                     rdGeometry.Point3D(
-                        float(pos.x),
-                        float(pos.y),
-                        float(pos.z) + (1.5 if flag == 1 else -1.5),
+                        float(start.x) + vx * scale,
+                        float(start.y) + vy * scale,
+                        float(start.z) + sign * length * math.sin(_DIRECT_WEDGE_TILT),
                     ),
                 )
 
+    # The sketch sits wherever it was drawn on the canvas, which can be hundreds
+    # of angstroms from the origin; centre it before handing it to the 3D view.
+    _center_conformer(conf)
+
     mol.RemoveAllConformers()
     mol.AddConformer(conf, assignId=True)
 

{moleditpy_linux-4.8.0 → moleditpy_linux-4.8.2}/src/moleditpy_linux/ui/edit_actions_logic.py

@@ -883,9 +883,11 @@ class EditActionsManager:
         self.host.set_current_file_path(None)
         self.host.state_manager.update_window_title()
 
-        # Reset 2D zoom
+        # Reset 2D zoom to the launch default (75%), not the bare identity
+        # transform -- resetTransform() left the view at 100%, so Clear All
+        # came back zoomed in compared to a freshly started session.
         if self.host.init_manager.view_2d:
-            self.host.init_manager.view_2d.resetTransform()
+            self.host.view_3d_manager.reset_zoom()
 
         # Update scene and view
         self.host.init_manager.scene.update()

{moleditpy_linux-4.8.0 → moleditpy_linux-4.8.2}/src/moleditpy_linux/ui/molecular_scene_handler.py

@@ -24,6 +24,7 @@ from .bond_item import BondItem
 
 from ..utils.sip_isdeleted_safe import sip_isdeleted_safe
 
+from ..core.mol_geometry import is_problematic_valence
 from ..utils.constants import DEFAULT_BOND_LENGTH, SUM_TOLERANCE
 
 
@@ -197,6 +198,106 @@ class TemplateMixin:
 
         return not atom1_has_other_double and not atom2_has_other_double
 
+    @staticmethod
+    def _bond_load(atom: Optional[AtomItem]) -> float:
+        """Total bond order already attached to *atom*."""
+        if atom is None:
+            return 0.0
+        return sum(b.order for b in atom.bonds)
+
+    def _plan_template_bonds(
+        self,
+        bonds: List[Tuple[int, int, int]],
+        vertex_atoms: List[Optional[AtomItem]],
+    ) -> Tuple[List[Tuple[int, int, int]], List[Tuple[int, int]]]:
+        """Decide the order every template bond ends up with once placed.
+
+        Two things constrain the template's own alternation:
+
+        * a bond that already exists is kept, unless the benzene policy allows
+          re-ordering it *and* both atoms have room for the extra order;
+        * a Kekule ring always carries a double next to its fused bond, so
+          fusing onto a single bond whose atoms each already hold a double --
+          every peripheral single bond of naphthalene -- would hand one of them
+          a fifth bond. Those bonds are lowered instead, which leaves the new
+          carbons as methylene: a real molecule rather than a hypervalent one.
+
+        Existing bonds are settled first so that an allowed upgrade is in the
+        atom's load before the new bonds hanging off it are fitted, and loads
+        are carried across the ring so several new bonds on one atom count
+        together.
+
+        Returns the planned orders and the vertex pairs the editor already
+        draws unchanged -- the ghost skips those, since painting a second copy
+        over a real double bond reads as a triple.
+        """
+        is_benzene_template = len(bonds) == 6 and any(o == 2 for _, _, o in bonds)
+        loads = {i: self._bond_load(atom) for i, atom in enumerate(vertex_atoms)}
+
+        def vertex(index: int) -> Optional[AtomItem]:
+            return vertex_atoms[index] if index < len(vertex_atoms) else None
+
+        def fits(index: int, extra: float) -> bool:
+            atom = vertex(index)
+            if atom is None or extra <= 0:
+                return True
+            return not is_problematic_valence(
+                getattr(atom, "symbol", "C"),
+                loads.get(index, 0.0) + extra,
+                int(getattr(atom, "charge", 0) or 0),
+            )
+
+        planned: Dict[int, int] = {}
+        unchanged: List[Tuple[int, int]] = []
+
+        # Every new bond needs at least a single, so an upgrade has to leave
+        # room for the ones still to come as well as for itself
+        incoming: Dict[int, int] = {}
+        for i, j, _order in bonds:
+            atom_i, atom_j = vertex(i), vertex(j)
+            if atom_i and atom_j and self.find_bond_between(atom_i, atom_j):
+                continue
+            incoming[i] = incoming.get(i, 0) + 1
+            incoming[j] = incoming.get(j, 0) + 1
+
+        # Pass 1 -- bonds that are already drawn
+        for position, (i, j, order) in enumerate(bonds):
+            atom_i, atom_j = vertex(i), vertex(j)
+            exist_b = (
+                self.find_bond_between(atom_i, atom_j) if atom_i and atom_j else None
+            )
+            if exist_b is None:
+                continue
+            current = int(getattr(exist_b, "order", order))
+            extra = order - current
+            if (
+                is_benzene_template
+                and self._should_overwrite_benzene_bond(exist_b)
+                and fits(i, extra + incoming.get(i, 0))
+                and fits(j, extra + incoming.get(j, 0))
+            ):
+                loads[i] = loads.get(i, 0.0) + extra
+                loads[j] = loads.get(j, 0.0) + extra
+                planned[position] = order
+            else:
+                planned[position] = current
+                unchanged.append((i, j))
+
+        # Pass 2 -- bonds the placement will create
+        for position, (i, j, order) in enumerate(bonds):
+            if position in planned:
+                continue
+            while order > 1 and not (fits(i, order) and fits(j, order)):
+                order -= 1
+            loads[i] = loads.get(i, 0.0) + order
+            loads[j] = loads.get(j, 0.0) + order
+            planned[position] = order
+
+        return (
+            [(i, j, planned[position]) for position, (i, j, _) in enumerate(bonds)],
+            unchanged,
+        )
+
     def add_molecule_fragment(
         self,
         points: List[Union[QPointF, Tuple[float, float]]],
@@ -214,8 +315,6 @@ class TemplateMixin:
         num_points = len(points)
         atom_items: List[Optional[AtomItem]] = [None] * num_points
 
-        is_benzene_template = num_points == 6 and any(o == 2 for _, _, o in bonds_info)
-
         def coords(p: Any) -> Any:
             if hasattr(p, "x") and hasattr(p, "y"):
                 return (p.x(), p.y())
@@ -317,6 +416,12 @@ class TemplateMixin:
                 new_tb.append((i_idx, j_idx, new_order))
             template_bonds_to_use = new_tb
 
+        # Atoms exist but carry no template bonds yet, so their loads are the
+        # ones the fusion has to fit into.
+        template_bonds_to_use, _unchanged = self._plan_template_bonds(
+            list(template_bonds_to_use), atom_items
+        )
+
         # --- 5) Bond Creation/Update ---
         for id1_idx, id2_idx, order in template_bonds_to_use:
             if id1_idx < len(atom_items) and id2_idx < len(atom_items):
@@ -331,22 +436,15 @@ class TemplateMixin:
                 exist_b = self.find_bond_between(a_item, b_item)
 
                 if exist_b:
-                    # Keep existing bonds by default unless it's a safe benzene overwrite
-                    should_overwrite = (
-                        is_benzene_template
-                        and self._should_overwrite_benzene_bond(exist_b)
-                    )
-
-                    if should_overwrite:
-                        # Update bond order if conditions met
-                        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:
-                        # Keep existing bond if conditions not met
+                    # _plan_template_bonds already applied the keep-or-overwrite
+                    # policy, so an unchanged order means keep this bond
+                    if order == exist_b.order:
                         continue
+                    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
                     self.create_bond(a_item, b_item, bond_order=order, bond_stereo=0)
@@ -514,7 +612,12 @@ class TemplateMixin:
                     for m, (i, j, _) in enumerate(bonds_info)
                 ]
 
-            self.template_preview.set_geometry(points, is_aromatic, preview_bonds)
+            preview_bonds, editor_drawn = self._plan_template_bonds(
+                preview_bonds, vertex_atoms
+            )
+            self.template_preview.set_geometry(
+                points, is_aromatic, preview_bonds, editor_drawn
+            )
 
             self.template_preview.show()
             if self.views():

{moleditpy_linux-4.8.0 → moleditpy_linux-4.8.2}/src/moleditpy_linux/ui/plugin_menu_manager.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 
 import logging
 import os
-from typing import Any, Callable, Dict, List, TYPE_CHECKING
+from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING
 
 from PyQt6.QtGui import QAction, QIcon, QKeySequence
 from PyQt6.QtWidgets import QFileDialog, QMenu, QMessageBox
@@ -38,8 +38,18 @@ class PluginMenuManager:
     # so the rebuild pass can find and remove exactly those on the next reload.
     _PLUGIN_ACTION_TAG = "plugin_managed"
 
+    # Title of the menu that hosts "Plugin/<path>" registrations.
+    _PLUGIN_MENU_TITLE = "Plugin"
+
+    # Value of add_menu_action(pin=...) requesting the header slot: placed with
+    # "Plugin Manager..." above the first divider, for plugins that manage the
+    # plugin system itself rather than acting on a molecule.
+    _PIN_HEADER = "header"
+
     def __init__(self, init_manager: MainInitManager) -> None:
         self._im = init_manager
+        # Built once and re-added on every reset; see _reset_plugin_menu.
+        self._manage_action: Optional[QAction] = None
 
     def _make_safe_callback(self, callback: Callable, plugin_name: str) -> Callable:
         """Wrap a plugin callback so exceptions don't propagate into Qt's signal machinery."""
@@ -99,12 +109,8 @@ class PluginMenuManager:
         if not self._im.host.plugin_manager:
             return
 
-        self._clear_all_plugin_actions(plugin_menu)
-
-        manage_action = QAction("Plugin Manager...", self._im.host)
-        manage_action.triggered.connect(lambda: self._show_plugin_manager(plugin_menu))
-        plugin_menu.addAction(manage_action)
-        plugin_menu.addSeparator()
+        self._clear_all_plugin_actions()
+        self._reset_plugin_menu(plugin_menu)
 
         plugins = self._im.host.plugin_manager.discover_plugins(self._im.host)
 
@@ -117,6 +123,33 @@ class PluginMenuManager:
         self.integrate_plugin_analysis_tools()
         self.integrate_plugin_optimization_methods()
 
+    def _reset_plugin_menu(self, plugin_menu: QMenu) -> None:
+        """Empty the Plugin menu and re-add its fixed header.
+
+        Menu entries are parented to the host, not to the menu, so ``clear()``
+        only detaches them — without retiring the outgoing ones every rebuild
+        strands another set on the main window for the life of the process.
+
+        The manager entry is kept and re-added rather than rebuilt: a rebuild
+        can start from inside its own ``triggered`` handler (Plugin Manager ▸
+        Reload), and that handler is still on the stack, so this is the one
+        action that must not be deleted here.
+        """
+        manage_action = self._manage_action
+        self._retire_menu_tree(plugin_menu, manage_action)
+        plugin_menu.clear()
+
+        if manage_action is None:
+            # Bound to the menu it was first built for, which in the app is
+            # always MainInitManager.plugin_menu.
+            manage_action = QAction("Plugin Manager...", self._im.host)
+            manage_action.triggered.connect(
+                lambda: self._show_plugin_manager(plugin_menu)
+            )
+            self._manage_action = manage_action
+        plugin_menu.addAction(manage_action)
+        plugin_menu.addSeparator()
+
     def rebuild_plugin_menus(self) -> None:
         """Fully rebuild all plugin-managed UI after an install/uninstall.
 
@@ -124,43 +157,35 @@ class PluginMenuManager:
         ``PluginManager.discover_plugins`` has already been called and the
         registries are fresh.  It cleans the existing tagged actions and
         re-populates every integration point: menus, toolbars, export,
-        file-openers, analysis tools, and 3D styles.
-        """
+        file-openers, analysis tools, legacy run() entries, and 3D styles.
 
-        def _clean_menu(menu: QMenu) -> None:
-            for action in list(menu.actions()):
-                submenu = action.menu()
-                if submenu is not None:
-                    _clean_menu(submenu)
-                    if not any(not a.isSeparator() for a in submenu.actions()):
-                        menu.removeAction(action)
-                elif action.data() == self._PLUGIN_ACTION_TAG:
-                    self._remove_action(menu, action)
+        The Plugin menu is emptied and rebuilt rather than topped up, so a
+        reload lands the context-injected entries above the folder-derived ones
+        exactly as a fresh launch does. Appending to the surviving (untagged)
+        folder entries instead used to flip the two groups on every reload.
+        """
 
         try:
             for menu in self._get_plugin_target_menus():
-                _clean_menu(menu)
+                self._strip_plugin_actions(menu)
         except Exception:
             logging.warning("Plugin rebuild: menu cleanup error", exc_info=True)
 
-        # Drop tagged (plugin-created) top-level menus the clean pass emptied
-        try:
-            menu_bar = self._im.host.menuBar()
-            for top_action in list(menu_bar.actions()):
-                if top_action.data() != self._PLUGIN_ACTION_TAG:
-                    continue
-                submenu = top_action.menu()
-                if submenu is None or not any(
-                    not a.isSeparator() for a in submenu.actions()
-                ):
-                    menu_bar.removeAction(top_action)
-        except Exception:
-            logging.warning("Plugin rebuild: menubar cleanup error", exc_info=True)
+        self._clear_plugin_menubar_entries()
 
-        self._im.plugin_menubar_separator_added = False
+        plugin_menu = getattr(self._im, "plugin_menu", None)
+        if plugin_menu is not None:
+            self._reset_plugin_menu(plugin_menu)
+
+        def _rebuild_legacy_actions() -> None:
+            if plugin_menu is not None:
+                self._add_legacy_plugin_actions(
+                    plugin_menu, self._im.host.plugin_manager.plugins
+                )
 
         for method, label in [
             (self.add_registered_plugin_actions, "menu actions"),
+            (_rebuild_legacy_actions, "legacy plugin actions"),
             (self.add_plugin_toolbar_actions, "toolbar actions"),
             (self.integrate_plugin_export_actions, "export actions"),
             (self.integrate_plugin_file_openers, "file openers"),
@@ -173,6 +198,129 @@ class PluginMenuManager:
             except Exception:
                 logging.warning("Plugin rebuild: %s error", label, exc_info=True)
 
+    def _retire_menu_tree(self, menu: QMenu, keep: Optional[QAction]) -> None:
+        """Destroy a menu subtree that ``clear()`` would only detach.
+
+        ``clear()`` deletes the actions a menu owns, but plugin entries are
+        parented to the host and submenus are child widgets of the menu, so
+        both outlive it — a submenu's menuAction going away does not take the
+        QMenu with it. Retiring the tree explicitly keeps a reload from
+        stranding another copy of every folder submenu and its entries.
+
+        *keep* is spared: it is the manager entry, which may be the handler
+        the current rebuild was started from.
+        """
+        for action in menu.actions():
+            submenu = action.menu()
+            if submenu is not None:
+                self._retire_menu_tree(submenu, keep)
+                submenu.deleteLater()
+            elif action is not keep:
+                action.deleteLater()
+
+    def _strip_plugin_actions(self, menu: QMenu) -> None:
+        """Remove every tagged action from *menu* and its submenus.
+
+        Recurses before removing, so a plugin-created submenu is emptied
+        first and only then dropped — and destroyed with it. Detaching a
+        submenu without destroying it leaves the QMenu alive as a child of
+        its former parent, and the next populate pass, no longer finding it
+        among the parent's actions, builds another: one stranded menu per
+        rebuild for the life of the process.
+
+        Native submenus that happen to be empty are not ours to remove, hence
+        the tag check.
+        """
+        for action in list(menu.actions()):
+            submenu = action.menu()
+            if submenu is not None:
+                self._strip_plugin_actions(submenu)
+                if action.data() == self._PLUGIN_ACTION_TAG and not any(
+                    not a.isSeparator() for a in submenu.actions()
+                ):
+                    menu.removeAction(action)
+                    submenu.deleteLater()
+            elif action.data() == self._PLUGIN_ACTION_TAG:
+                self._remove_action(menu, action)
+
+    def _clear_plugin_menubar_entries(self) -> None:
+        """Drop emptied plugin-created top-level menus and the menubar divider.
+
+        Both clear paths need this. ``_get_plugin_target_menus`` walks *into*
+        the menus on the bar but never the bar itself, so without this pass an
+        uninstalled plugin's own top-level menu survives as an empty stub and
+        the divider in front of it is never reclaimed. Resetting the flag lets
+        the following populate pass re-add that divider.
+        """
+        try:
+            menu_bar = self._im.host.menuBar()
+            for top_action in list(menu_bar.actions()):
+                if top_action.data() != self._PLUGIN_ACTION_TAG:
+                    continue
+                submenu = top_action.menu()
+                if submenu is None or not any(
+                    not a.isSeparator() for a in submenu.actions()
+                ):
+                    menu_bar.removeAction(top_action)
+        except Exception:
+            logging.warning("Plugin menubar cleanup error", exc_info=True)
+
+        self._im.plugin_menubar_separator_added = False
+
+    def _ensure_plugin_separator(self, menu: QMenu) -> None:
+        """Add a tagged divider before the first plugin entry appended to *menu*.
+
+        The divider must land where the plugin content actually starts. For a
+        nested path like ``Tools/Sub/Item`` that is the *parent* menu, just
+        before ``Sub`` is created -- checking the freshly made (and therefore
+        empty) leaf instead placed no divider at all, and the next sibling
+        entry then saw an untagged submenu as the last action and inserted the
+        divider after the plugin submenu, splitting the plugin group instead of
+        separating it from the native entries.
+        """
+        actions = menu.actions()
+        if (
+            actions
+            and not actions[-1].isSeparator()
+            and actions[-1].data() != self._PLUGIN_ACTION_TAG
+        ):
+            sep = menu.addSeparator()
+            if sep is not None:
+                sep.setData(self._PLUGIN_ACTION_TAG)
+
+    @classmethod
+    def _wants_header_slot(
+        cls, top_level_title: str, parts: List[str], action_def: Dict[str, Any]
+    ) -> bool:
+        """Return True for an entry that asked to sit beside the Plugin Manager.
+
+        A plugin that manages the plugin system itself — the Plugin Installer —
+        reads as part of the menu's header pair rather than as one more
+        installed plugin, and says so with ``pin="header"``. The app therefore
+        needs to know no plugin by name.
+        """
+        return (
+            top_level_title == cls._PLUGIN_MENU_TITLE
+            and len(parts) == 2
+            and action_def.get("pin") == cls._PIN_HEADER
+        )
+
+    @staticmethod
+    def _trim_trailing_separator(menu: QMenu) -> None:
+        """Drop a divider left dangling at the end of *menu*."""
+        actions = menu.actions()
+        if actions and actions[-1].isSeparator():
+            menu.removeAction(actions[-1])
+
+    @staticmethod
+    def _add_beside_plugin_manager(menu: QMenu, action: QAction) -> None:
+        """Add *action* to the menu's header group, above the first divider."""
+        anchor = next((a for a in menu.actions() if a.isSeparator()), None)
+        if anchor is None:
+            menu.addAction(action)
+        else:
+            menu.insertAction(anchor, action)
+
     def add_registered_plugin_actions(self) -> None:
         """Add menu actions explicitly registered by V3/V4 plugins."""
         if not self._im.host.plugin_manager.menu_actions:
@@ -211,25 +359,31 @@ class PluginMenuManager:
                     ),
                     None,
                 )
-                current_menu = sub if sub else current_menu.addMenu(part)
-
-            actions = current_menu.actions()
-            if (
-                actions
-                and not actions[-1].isSeparator()
-                and actions[-1].data() != self._PLUGIN_ACTION_TAG
-            ):
-                sep = current_menu.addSeparator()
-                sep.setData(self._PLUGIN_ACTION_TAG)
+                if sub is not None:
+                    # Descending into an existing submenu appends nothing to
+                    # the parent, so no divider is due here.
+                    current_menu = sub
+                    continue
+                self._ensure_plugin_separator(current_menu)
+                current_menu = current_menu.addMenu(part)
+                current_menu.menuAction().setData(self._PLUGIN_ACTION_TAG)
+
+            label = text or parts[-1]
+            pinned = self._wants_header_slot(top_level_title, parts, action_def)
+            if not pinned:
+                self._ensure_plugin_separator(current_menu)
 
-            action = QAction(text or parts[-1], self._im.host)
+            action = QAction(label, self._im.host)
             action.triggered.connect(
                 self._make_safe_callback(callback, action_def.get("plugin", "Plugin"))
             )
             if action_def.get("shortcut"):
                 action.setShortcut(QKeySequence(action_def["shortcut"]))
             action.setData(self._PLUGIN_ACTION_TAG)
-            current_menu.addAction(action)
+            if pinned:
+                self._add_beside_plugin_manager(current_menu, action)
+            else:
+                current_menu.addAction(action)
 
     def add_plugin_toolbar_actions(self) -> None:
         """Populate the plugin toolbar from registered toolbar actions."""
@@ -271,21 +425,17 @@ class PluginMenuManager:
         dlg.exec()
         self.update_plugin_menu(plugin_menu)
 
-    def _clear_all_plugin_actions(self, plugin_menu: QMenu) -> None:
-        """Remove all tagged plugin actions from every menu and the export button."""
-
-        def clear_menu(menu: Any) -> None:
-            if not menu:
-                return
-            for act in list(menu.actions()):
-                if act.data() == self._PLUGIN_ACTION_TAG:
-                    self._remove_action(menu, act)
-                elif act.menu():
-                    clear_menu(act.menu())
+    def _clear_all_plugin_actions(self) -> None:
+        """Remove all tagged plugin actions from every menu and the export button.
 
-        plugin_menu.clear()
+        The Plugin menu itself is not emptied here — ``_reset_plugin_menu``
+        owns that, so both the update and the rebuild path clear it the same
+        way.
+        """
         for menu in self._get_plugin_target_menus():
-            clear_menu(menu)
+            if menu:
+                self._strip_plugin_actions(menu)
+        self._clear_plugin_menubar_entries()
 
     def update_style_menu_with_plugins(self) -> None:
         """Append custom 3D styles registered by plugins to the style menu."""
@@ -329,15 +479,36 @@ class PluginMenuManager:
         root = []
         for p in plugins:
             if hasattr(p["module"], "run"):
-                cat = p.get("category", p.get("rel_folder", "")).strip()
+                cat = str(p.get("category") or "").strip()
                 if cat:
                     categorized.setdefault(cat, []).append(p)
                 else:
                     root.append(p)
 
+        # This is the last step of Plugin-menu construction on both the update
+        # and the rebuild path, so it also drops the header divider when there
+        # turns out to be nothing under it -- an install of only the Plugin
+        # Installer would otherwise end on a dangling divider.
+        if not categorized and not root:
+            self._trim_trailing_separator(plugin_menu)
+            return
+
+        # Divide the folder-derived entries below from the context-injected
+        # ones ("Plugin/XXX" paths) that add_registered_plugin_actions already
+        # placed above: two different organizing schemes should not read as one
+        # list. Deferred until we know there is content, so an app with only
+        # context-injected plugins gets no dangling trailing divider.
+        existing = plugin_menu.actions()
+        if existing and not existing[-1].isSeparator():
+            plugin_menu.addSeparator()
+
         for cat in sorted(categorized.keys()):
             current_parent: Any = plugin_menu
-            for part in cat.split(os.sep):
+            # A folder category arrives with os.sep; a root plugin's own
+            # PLUGIN_CATEGORY is hand-written and usually uses "/".
+            for part in cat.replace("/", os.sep).split(os.sep):
+                if not part:
+                    continue
                 sub = next(
                     (
                         a.menu()

{moleditpy_linux-4.8.0 → moleditpy_linux-4.8.2}/src/moleditpy_linux/ui/template_preview_item.py

@@ -54,6 +54,7 @@ class TemplatePreviewItem(QGraphicsItem):
         self.ghost_atoms: List[AtomItem] = []
         self.ghost_bonds: List[BondItem] = []
         self.existing_indices: Set[int] = set()
+        self.editor_drawn_bonds: Set[frozenset] = set()
         self.existing_h_counts: Dict[int, int] = {}
         self.replaced_label_path = QPainterPath()
         self.mark_first_atom = False
@@ -66,11 +67,13 @@ class TemplatePreviewItem(QGraphicsItem):
         points: list[QPointF],
         is_aromatic: bool = False,
         bonds_info: Optional[list[Any]] = None,
+        editor_drawn_bonds: Optional[list[Any]] = None,
     ) -> None:
         """Set polygon points for a standard ring template preview.
 
         ``bonds_info`` carries the orders the placement will use; without it the
-        ring falls back to a plain alternation.
+        ring falls back to a plain alternation. ``editor_drawn_bonds`` lists the
+        vertex pairs the editor already draws, which the ghost must leave alone.
         """
         self.prepareGeometryChange()
         self.is_chain = False
@@ -83,6 +86,10 @@ class TemplatePreviewItem(QGraphicsItem):
                 for i in range(n)
             ]
         self._rebuild_ghost(points, bonds_info, [{"symbol": "C"} for _ in points])
+        # After the rebuild, which clears whatever the last preview recorded
+        self.editor_drawn_bonds = {
+            frozenset(pair) for pair in (editor_drawn_bonds or ())
+        }
         self.update()
 
     def set_chain_geometry(
@@ -130,6 +137,7 @@ class TemplatePreviewItem(QGraphicsItem):
         """Drop the ghost molecule and everything derived from the editor scene."""
         self._clear_ghost_items()
         self.existing_indices = set()
+        self.editor_drawn_bonds = set()
         self.existing_h_counts = {}
         self.replaced_label_path = QPainterPath()
 
@@ -140,6 +148,9 @@ class TemplatePreviewItem(QGraphicsItem):
         atoms_data: list[dict[str, Any]],
     ) -> None:
         """Rebuild the preview as real atom/bond items so it renders like the result."""
+        # Every preview kind lands here, so this is the one place that can keep
+        # a user template from inheriting the pairs a fused ring recorded
+        self.editor_drawn_bonds = set()
         self.ghost_scene.host = self.scene()
         if not points:
             self._clear_ghost()
@@ -362,6 +373,11 @@ class TemplatePreviewItem(QGraphicsItem):
         painter.save()
         painter.setOpacity(GHOST_OPACITY)
         for bond in self.ghost_bonds:
+            pair = frozenset((bond.atom1.atom_id, bond.atom2.atom_id))
+            if pair in self.editor_drawn_bonds:
+                # Placement leaves this bond alone and the editor already draws
+                # it; a ghost copy on top of a real double bond reads as a triple
+                continue
             painter.save()
             painter.translate(bond.pos())
             bond.paint(painter, option)  # type: ignore[arg-type]