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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.7.2
+Version: 4.8.0
 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.0}/pyproject.toml

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

{moleditpy_linux-4.7.2 → moleditpy_linux-4.8.0}/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.0
 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.0}/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.0}/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.0}/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.0}/src/moleditpy_linux/ui/molecular_scene_handler.py

@@ -448,6 +448,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 +469,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 +499,22 @@ 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)
+            self.template_preview.set_geometry(points, is_aromatic, preview_bonds)
 
             self.template_preview.show()
             if self.views():
@@ -555,6 +571,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 +623,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")

moleditpy_linux-4.8.0/src/moleditpy_linux/ui/preview_molecule.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+MoleditPy — A Python-based molecular editing software
+
+Author: Hiromichi Yokoyama
+License: GPL-3.0 license
+Repo: https://github.com/HiroYokoyama/python_molecular_editor
+DOI: 10.5281/zenodo.17268532
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Sequence, Tuple
+
+from PyQt6.QtCore import QPointF, QRectF
+from PyQt6.QtWidgets import QGraphicsItem, QGraphicsScene
+
+from .atom_item import AtomItem
+from .bond_item import BondItem
+
+
+class PreviewScene(QGraphicsScene):
+    """Scene for preview-only atom/bond items.
+
+    AtomItem and BondItem read their font, colour and spacing through
+    scene().get_setting(), so any scene holding them has to answer it. ``host``
+    is the editor scene, so previews follow the user's 2D settings.
+    """
+
+    def __init__(self, host: Any = None) -> None:
+        super().__init__()
+        self.host: Any = host
+
+    def get_setting(self, key: str, default: Any = None) -> Any:
+        """Forward a settings lookup to the editor scene."""
+        host = self.host
+        if host is None or not hasattr(host, "get_setting"):
+            return default
+        try:
+            return host.get_setting(key, default)
+        except (AttributeError, RuntimeError, TypeError, ValueError):
+            return default
+
+    def views(self) -> List[Any]:
+        """Report the editor's views so zoom-dependent radii match the real items."""
+        host = self.host
+        if host is not None and hasattr(host, "views"):
+            try:
+                return list(host.views())
+            except (AttributeError, RuntimeError, TypeError):
+                return []
+        return list(super().views())
+
+
+def ensure_preview_settings(scene: Any, host: Any = None) -> None:
+    """Give a plain QGraphicsScene the get_setting() the preview items call."""
+    if hasattr(scene, "get_setting"):
+        return
+
+    def get_setting(key: str, default: Any = None) -> Any:
+        if host is None or not hasattr(host, "get_setting"):
+            return default
+        try:
+            # The host outlives the preview normally, but a closed editor would
+            # otherwise raise out of paint()
+            return host.get_setting(key, default)
+        except (AttributeError, RuntimeError, TypeError, ValueError):
+            return default
+
+    scene.get_setting = get_setting
+
+
+def build_preview_items(
+    atoms: Sequence[Dict[str, Any]],
+    bonds: Sequence[Sequence[int]],
+) -> Tuple[List[AtomItem], List[BondItem], Dict[int, Tuple[int, ...]]]:
+    """Build the atom/bond items that draw a template the way the editor draws it.
+
+    ``atoms`` entries need ``pos`` plus the usual ``symbol``/``charge``/``radical``;
+    ``bonds`` are ``(index1, index2[, order[, stereo]])``. The items are returned
+    unparented — the caller decides which scene they belong to — together with the
+    ring each bond belongs to, so a moved preview can recompute its ring centres.
+    """
+    atom_items: List[AtomItem] = []
+    for i, atom_data in enumerate(atoms):
+        item = AtomItem(
+            i,
+            atom_data.get("symbol", "C"),
+            QPointF(atom_data.get("pos", QPointF())),
+            charge=int(atom_data.get("charge", 0) or 0),
+            radical=int(atom_data.get("radical", 0) or 0),
+        )
+        item.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsMovable, False)
+        item.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsSelectable, False)
+        item.setAcceptHoverEvents(False)
+        atom_items.append(item)
+
+    bond_items: List[BondItem] = []
+    seen_pairs: set[Tuple[int, int]] = set()
+    for bond in bonds:
+        if len(bond) < 2:
+            continue
+        i, j = bond[0], bond[1]
+        if not isinstance(i, int) or not isinstance(j, int):
+            continue
+        if not (0 <= i < len(atom_items) and 0 <= j < len(atom_items)) or i == j:
+            continue
+        # A repeated pair would make RDKit reject the whole preview molecule
+        if (min(i, j), max(i, j)) in seen_pairs:
+            continue
+        seen_pairs.add((min(i, j), max(i, j)))
+        order = int(bond[2]) if len(bond) > 2 else 1
+        stereo = int(bond[3]) if len(bond) > 3 else 0
+        atom1, atom2 = atom_items[i], atom_items[j]
+        bond_item = BondItem(atom1, atom2, order, stereo)
+        bond_item.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsSelectable, False)
+        bond_item.setAcceptHoverEvents(False)
+        # create_bond() does this too; without it carbons never turn invisible
+        atom1.bonds.append(bond_item)
+        atom2.bonds.append(bond_item)
+        bond_items.append(bond_item)
+
+    ring_atoms = apply_preview_topology(atom_items, bond_items)
+    for item in atom_items:
+        item.update_style()
+    return atom_items, bond_items, ring_atoms
+
+
+def preview_content_rect(
+    atom_items: Sequence[AtomItem], bond_items: Sequence[BondItem]
+) -> QRectF:
+    """Return the rect the preview actually draws into, without any hit padding."""
+    rect = QRectF()
+    for atom in atom_items:
+        rect = rect.united(atom.visual_rect().translated(atom.pos()))
+    for bond in bond_items:
+        line = bond.get_line_in_local_coords()
+        rect = rect.united(
+            QRectF(line.p1(), line.p2()).normalized().translated(bond.pos())
+        )
+    return rect
+
+
+def apply_preview_topology(
+    atom_items: Sequence[AtomItem], bond_items: Sequence[BondItem]
+) -> Dict[int, Tuple[int, ...]]:
+    """Fill in implicit hydrogens and ring info for the preview.
+
+    Deliberately no sanitization: a preview must draw whatever the template says,
+    so the valence is never checked and an odd one still gets its H count.
+    """
+    try:
+        from rdkit import Chem  # pylint: disable=import-outside-toplevel
+
+        bond_types = {
+            1: Chem.BondType.SINGLE,
+            2: Chem.BondType.DOUBLE,
+            3: Chem.BondType.TRIPLE,
+            4: Chem.BondType.AROMATIC,
+        }
+        mol = Chem.RWMol()
+        for item in atom_items:
+            atom = Chem.Atom(item.symbol)
+            atom.SetFormalCharge(item.charge)
+            atom.SetNumRadicalElectrons(item.radical)
+            mol.AddAtom(atom)
+        index_of = {id(item): i for i, item in enumerate(atom_items)}
+        for bond in bond_items:
+            mol.AddBond(
+                index_of[id(bond.atom1)],
+                index_of[id(bond.atom2)],
+                bond_types.get(bond.order, Chem.BondType.SINGLE),
+            )
+        mol.UpdatePropertyCache(strict=False)
+        Chem.FastFindRings(mol)
+    except (ValueError, RuntimeError, TypeError, AttributeError, ImportError):
+        logging.debug("Preview topology unavailable", exc_info=True)
+        return {}
+
+    for item, atom in zip(atom_items, mol.GetAtoms()):
+        item.implicit_h_count = atom.GetTotalNumHs()
+
+    ring_info = mol.GetRingInfo()
+    ring_atoms: Dict[int, Tuple[int, ...]] = {}
+    best_ring_size: Dict[int, int] = {}
+    for atom_ring, bond_ring in zip(ring_info.AtomRings(), ring_info.BondRings()):
+        positions = [atom_items[idx].pos() for idx in atom_ring]
+        center = (
+            sum(p.x() for p in positions) / len(positions),
+            sum(p.y() for p in positions) / len(positions),
+        )
+        for bond_idx in bond_ring:
+            if bond_idx >= len(bond_items):
+                continue
+            bond = bond_items[bond_idx]
+            bond.is_in_ring = True
+            if best_ring_size.get(bond_idx, len(atom_items) + 1) > len(atom_ring):
+                bond.ring_center = center
+                best_ring_size[bond_idx] = len(atom_ring)
+                ring_atoms[bond_idx] = tuple(atom_ring)
+    return ring_atoms