MoleditPy-linux 4.7.2__tar.gz → 4.8.1__tar.gz

{moleditpy_linux-4.7.2 → moleditpy_linux-4.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.7.2
+Version: 4.8.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

{moleditpy_linux-4.7.2 → moleditpy_linux-4.8.1}/pyproject.toml

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

{moleditpy_linux-4.7.2 → moleditpy_linux-4.8.1}/src/MoleditPy_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.7.2
+Version: 4.8.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

{moleditpy_linux-4.7.2 → moleditpy_linux-4.8.1}/src/MoleditPy_linux.egg-info/SOURCES.txt

@@ -58,6 +58,7 @@ 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/preview_molecule.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-4.7.2 → moleditpy_linux-4.8.1}/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.7.2 → moleditpy_linux-4.8.1}/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.7.2 → moleditpy_linux-4.8.1}/src/moleditpy_linux/ui/about_dialog.py

@@ -100,15 +100,16 @@ class AboutDialog(QDialog):
         layout.addLayout(button_layout)
 
     def image_clicked(self, event: QMouseEvent) -> None:
-        """Easter egg: Clear all and load bipyrimidine from SMILES"""
+        """Clear all, load bipyrimidine from SMILES, and build it in 3D."""
         # Clear the current scene
         self.main_window.edit_actions_manager.clear_all()
 
         bipyrimidine_smiles = "C1=CN=C(N=C1)C2=NC=CC=N2"
         self.main_window.string_importer_manager.load_from_smiles(bipyrimidine_smiles)
 
-        # Close the dialog
+        # Close the dialog first: the conversion puts up its own
         self.accept()
+        self.main_window.compute_manager.trigger_conversion()
 
     def image_mouse_press_event(self, event: QMouseEvent) -> None:
         """Handle mouse press on the image: trigger easter egg only for right-click."""
@@ -118,6 +119,7 @@ class AboutDialog(QDialog):
             else:
                 event.ignore()
         except (AttributeError, RuntimeError, ValueError, TypeError):
+            logging.warning("Image click handling failed", exc_info=True)
             try:
                 event.ignore()
             except (AttributeError, RuntimeError, ValueError, TypeError) as e:

{moleditpy_linux-4.7.2 → moleditpy_linux-4.8.1}/src/moleditpy_linux/ui/dialog_logic.py

@@ -114,29 +114,11 @@ class DialogManager:
             _template_dialog.activateWindow()
             return
 
-        # Create new dialog
+        # Create new dialog. Picking a template arms it right away, and closing
+        # the dialog cleans the mode up, so there is nothing to do on finish.
         self.host.template_dialog = UserTemplateDialog(self.host, self.host)
         self.host.template_dialog.show()
 
-        # Activate if a template is selected after dialog is closed
-        def on_dialog_finished() -> None:
-            if self.host.template_dialog.selected_template:
-                template_name = self.host.template_dialog.selected_template.get(
-                    "name", "user_template"
-                )
-                mode_name = f"template_user_{template_name}"
-
-                # Store template data for the scene to use
-                self.host.set_scene_user_template_data(
-                    self.host.template_dialog.selected_template
-                )
-                self.host.ui_manager.set_mode(mode_name)
-
-                # Update status
-                self.host.update_status_message(f"Template mode: {template_name}")
-
-        self.host.template_dialog.finished.connect(on_dialog_finished)
-
     def save_2d_as_template(self) -> None:
         """Save current 2D structure as a template"""
         if not self.host.state_manager.data.atoms:

{moleditpy_linux-4.7.2 → moleditpy_linux-4.8.1}/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.7.2 → moleditpy_linux-4.8.1}/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)
@@ -448,6 +546,7 @@ class TemplateMixin:
             self.template_context["bonds_info"] = bonds_info
 
             # Snap individual preview vertices to nearby atoms to reflect template fusing visually
+            vertex_atoms: List[Optional[AtomItem]] = [None] * len(points)
             if self.get_setting("template_fusing_enabled_2d", True) and not alt_pressed:
                 fuse_dist = self.get_setting("template_fusing_distance_2d", 7.0)
                 mapped_atoms = set(self.template_context.get("items", []))
@@ -468,6 +567,7 @@ class TemplateMixin:
                         if best_idx != -1 and best_d <= click_map_threshold:
                             points[best_idx] = ex_pos
                             used_indices.add(best_idx)
+                            vertex_atoms[best_idx] = ex_item
                     except (AttributeError, TypeError, IndexError):
                         # Safe defensive fallback catching AttributeError, TypeError, IndexError
                         logging.debug("Suppressed non-critical error", exc_info=True)
@@ -497,8 +597,27 @@ class TemplateMixin:
                         if nearby and best_d <= fuse_dist:
                             points[i] = nearby.pos()
                             mapped_atoms.add(nearby)
+                            vertex_atoms[i] = nearby
+
+            # add_molecule_fragment rotates a fused aromatic ring to match the
+            # bonds already there; the preview shows the same alternation. It
+            # rotates the placement copy itself, so template_context keeps the
+            # unrotated orders.
+            preview_bonds = bonds_info
+            if is_aromatic and n == 6:
+                rotation = self._calculate_6ring_rotation(n, bonds_info, vertex_atoms)
+                orders = [order for (_, _, order) in bonds_info]
+                preview_bonds = [
+                    (i, j, orders[(m + rotation) % n])
+                    for m, (i, j, _) in enumerate(bonds_info)
+                ]
 
-            self.template_preview.set_geometry(points, is_aromatic)
+            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():
@@ -555,6 +674,44 @@ class TemplateMixin:
             points.append(current_p)
         return points
 
+    def _apply_template_atom_to_existing(
+        self, atom_item: Any, atom_data: Dict[str, Any]
+    ) -> None:
+        """Overwrite an existing atom with a user template atom's element/charge/radical."""
+        symbol = atom_data.get("symbol", "C")
+        # A hand-written template may carry nulls here
+        charge = int(atom_data.get("charge") or 0)
+        radical = int(atom_data.get("radical") or 0)
+
+        if (
+            atom_item.symbol == symbol
+            and atom_item.charge == charge
+            and atom_item.radical == radical
+        ):
+            return
+
+        try:
+            atom_item.prepareGeometryChange()
+            atom_item.symbol = symbol
+            atom_item.charge = charge
+            atom_item.radical = radical
+
+            record = self.data.atoms.get(atom_item.atom_id)
+            if record is not None:
+                record["symbol"] = symbol
+                record["charge"] = charge
+                record["radical"] = radical
+
+            # A bonded carbon is drawn as a bare vertex; the new element needs a label
+            atom_item.update_style()
+            for bond in atom_item.bonds:
+                bond.update()
+                other = bond.atom1 if bond.atom2 is atom_item else bond.atom2
+                if other is not None:
+                    other.update_style()
+        except (AttributeError, RuntimeError, KeyError, TypeError) as e:
+            logging.warning(f"Error applying template atom to existing atom: {e}")
+
     def add_user_template_fragment(self, context: Dict[str, Any]) -> None:
         """Place user template fragment"""
         points = context.get("points", [])
@@ -569,9 +726,10 @@ class TemplateMixin:
         atom_id_map = {}  # template id -> scene atom id
 
         for i, (pos, atom_data) in enumerate(zip(points, atoms_data)):
-            # Skip first atom if attaching to existing atom
+            # Reuse the clicked atom for the template's first atom, overwriting its element
             if i == 0 and attachment_atom:
                 atom_id_map[atom_data["id"]] = attachment_atom.atom_id
+                self._apply_template_atom_to_existing(attachment_atom, atom_data)
                 continue
 
             symbol = atom_data.get("symbol", "C")