MoleditPy-linux 4.11.5__tar.gz → 4.12.1__tar.gz

{moleditpy_linux-4.11.5 → moleditpy_linux-4.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.11.5
+Version: 4.12.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.11.5 → moleditpy_linux-4.12.1}/pyproject.toml

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

{moleditpy_linux-4.11.5 → moleditpy_linux-4.12.1}/src/MoleditPy_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.11.5
+Version: 4.12.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.11.5 → moleditpy_linux-4.12.1}/src/moleditpy_linux/core/molecular_data.py

@@ -12,6 +12,7 @@ DOI: 10.5281/zenodo.17268532
 
 from __future__ import annotations
 import logging
+import math
 from typing import Any, Dict, List, Optional, Tuple, Union
 from rdkit import Chem
 from rdkit.Chem import rdCIPLabeler
@@ -150,6 +151,245 @@ def align_ez_to_cip(mol: Chem.Mol, wanted: Dict[int, str]) -> None:
                 bond.SetStereo(flipped[bond.GetStereo()])
 
 
+_WEDGE_Z = {Chem.BondDir.BEGINWEDGE: 1.0, Chem.BondDir.BEGINDASH: -1.0}
+
+# How far past a straight line the two bonds without a wedge may open and
+# still count as a T-shape rather than a fan the wedge sits inside.
+_T_SHAPE_TOLERANCE_DEG = 5.0
+
+
+def _tag_from_points(
+    mol: Chem.Mol,
+    center: int,
+    points: Dict[int, Tuple[float, float, float]],
+    virtual: Optional[Tuple[float, float, float]] = None,
+) -> Chem.ChiralType:
+    """Chiral tag of *center* with its neighbors at *points* (center-relative).
+
+    *virtual* is the position of an implicit H or lone pair. The center is
+    placed at the centroid of the four positions, inside the tetrahedron, so
+    any three neighbor vectors are independent.
+    """
+    corners = list(points.values()) + ([virtual] if virtual is not None else [])
+    centroid = tuple(sum(p[k] for p in corners) / len(corners) for k in range(3))
+    probe = Chem.Mol(mol)
+    conf = Chem.Conformer(probe.GetNumAtoms())
+    conf.Set3D(True)
+    for idx, pos in points.items():
+        conf.SetAtomPosition(idx, pos)
+    conf.SetAtomPosition(center, centroid)
+    probe.RemoveAllConformers()
+    conf_id = probe.AddConformer(conf, assignId=True)
+    Chem.AssignAtomChiralTagsFromStructure(probe, confId=conf_id)
+    return probe.GetAtomWithIdx(center).GetChiralTag()
+
+
+def _largest_gap_deg(directions: List[Tuple[float, float]]) -> float:
+    """Largest angle between angularly adjacent 2D directions, in degrees."""
+    angles = sorted(math.degrees(math.atan2(dy, dx)) % 360.0 for dx, dy in directions)
+    gaps = [b - a for a, b in zip(angles, angles[1:])]
+    gaps.append(360.0 - angles[-1] + angles[0])
+    return max(gaps)
+
+
+def wedge_reading(mol: Chem.Mol, center: int) -> Optional[Chem.ChiralType]:
+    """Chiral tag the wedges/hashes starting at *center* specify, or None.
+
+    Reads the drawing the way a chemist does: plain bonds in the paper plane,
+    a wedge toward the viewer, a hash away. With three drawn neighbors the
+    implicit H (or lone pair) points opposite the wedges. With four, each
+    stereo bond is read in turn as the one out of the plane; the reading
+    counts only when they all agree.
+
+    None means the drawing does not decide: no stereo bond starts here, a
+    wedge and a hash cancel on a three-neighbor center, the wedge sits inside
+    a fan of under 180 degrees, or the stereo bonds of a four-neighbor center
+    contradict each other (a wedge and a hash on opposite bonds).
+    """
+    atom = mol.GetAtomWithIdx(center)
+    if atom.GetDegree() not in (3, 4) or mol.GetNumConformers() == 0:
+        return None
+    conf = mol.GetConformer()
+    origin = conf.GetAtomPosition(center)
+    directions: Dict[int, Tuple[float, float]] = {}
+    lift: Dict[int, float] = {}
+    for bond in atom.GetBonds():
+        nbr = bond.GetOtherAtomIdx(center)
+        pos = conf.GetAtomPosition(nbr)
+        dx, dy = pos.x - origin.x, pos.y - origin.y
+        length = math.hypot(dx, dy)
+        if length < 1e-6:
+            return None
+        directions[nbr] = (dx / length, dy / length)
+        lift[nbr] = (
+            _WEDGE_Z.get(bond.GetBondDir(), 0.0)
+            if bond.GetBeginAtomIdx() == center
+            else 0.0
+        )
+    stereo_nbrs = [nbr for nbr, z in lift.items() if z]
+    if not stereo_nbrs:
+        return None
+    flat = {nbr: (dx, dy, 0.0) for nbr, (dx, dy) in directions.items()}
+
+    if len(directions) == 3:
+        net = sum(lift.values())
+        if not net:
+            return None
+        if _largest_gap_deg(list(directions.values())) > 180.0 + _T_SHAPE_TOLERANCE_DEG:
+            return None
+        return _tag_from_points(mol, center, flat, (0.0, 0.0, -math.copysign(1.0, net)))
+
+    readings = set()
+    for nbr in stereo_nbrs:
+        points = dict(flat)
+        points[nbr] = (0.0, 0.0, lift[nbr])
+        readings.add(_tag_from_points(mol, center, points))
+    return readings.pop() if len(readings) == 1 else None
+
+
+def _bond_states(mol: Chem.Mol, indices: List[int]) -> List[Tuple[int, int, Any]]:
+    """Begin, end and direction of the bonds at *indices*."""
+    return [
+        (
+            mol.GetBondWithIdx(i).GetBeginAtomIdx(),
+            mol.GetBondWithIdx(i).GetEndAtomIdx(),
+            mol.GetBondWithIdx(i).GetBondDir(),
+        )
+        for i in indices
+    ]
+
+
+def _rdkit_tags(mol: Chem.Mol) -> List[Chem.ChiralType]:
+    """Chiral tag RDKit's wedge perception gives each atom of *mol*."""
+    probe = Chem.Mol(mol)
+    for atom in probe.GetAtoms():
+        atom.SetChiralTag(Chem.ChiralType.CHI_UNSPECIFIED)
+    Chem.AssignChiralTypesFromBondDirs(probe)
+    return [atom.GetChiralTag() for atom in probe.GetAtoms()]
+
+
+def _clear_own_wedges(mol: Chem.Mol, centers: Dict[int, Chem.ChiralType]) -> None:
+    """Remove the wedges/hashes that start at *centers*."""
+    for center in centers:
+        for bond in mol.GetAtomWithIdx(center).GetBonds():
+            if bond.GetBeginAtomIdx() == center and bond.GetBondDir() in _WEDGE_Z:
+                bond.SetBondDir(Chem.BondDir.NONE)
+
+
+def _rdkit_rewedge(mol: Chem.Mol, fixes: Dict[int, Chem.ChiralType]) -> None:
+    """Let RDKit wedge each fixed center for its wanted tag (may reverse bonds)."""
+    _clear_own_wedges(mol, fixes)
+    for center, tag in fixes.items():
+        mol.GetAtomWithIdx(center).SetChiralTag(tag)
+    Chem.WedgeMolBonds(mol, mol.GetConformer())
+    for center in fixes:
+        mol.GetAtomWithIdx(center).SetChiralTag(Chem.ChiralType.CHI_UNSPECIFIED)
+
+
+def _pick_wedges(mol: Chem.Mol, fixes: Dict[int, Chem.ChiralType]) -> None:
+    """Wedge or hash one free bond per fixed center so it reads its wanted tag.
+
+    A candidate counts only when RDKit and wedge_reading() agree on it.
+    """
+    for center, tag in fixes.items():
+        for bond in mol.GetAtomWithIdx(center).GetBonds():
+            if (
+                bond.GetBeginAtomIdx() != center
+                or bond.GetBondDir() != Chem.BondDir.NONE
+                or bond.GetBondType() != Chem.BondType.SINGLE
+            ):
+                continue
+            for direction in _WEDGE_Z:
+                bond.SetBondDir(direction)
+                if (
+                    _rdkit_tags(mol)[center] == tag
+                    and wedge_reading(mol, center) == tag
+                ):
+                    break
+                bond.SetBondDir(Chem.BondDir.NONE)
+            else:
+                continue
+            break
+
+
+def resolve_wedge_chirality(mol: Chem.Mol) -> None:
+    """Re-wedge stereocenters whose drawn wedges RDKit reads differently.
+
+    RDKit's wedge perception is unstable on some unambiguous drawings: with
+    the two plain bonds of a three-neighbor center drawn in a straight line
+    (a T-shape, which the editor's angle snapping produces), it reports
+    "ambiguous stereochemistry" or inverts the center, while the same drawing
+    bent by a few degrees reads correctly. Where wedge_reading() gives a
+    definite answer that RDKit's perception does not reproduce, the wedges at
+    that center are replaced by ones RDKit picks for the intended
+    configuration on the same coordinates (or, where RDKit declines, a wedge
+    or hash on a free bond of the center that both readings agree on), so
+    every later reader (MOL block, 3D embedding, stereo check) gets the drawn
+    isomer. Nothing is changed unless every other stereocenter and every
+    bond away from the fixed centers stays exactly as drawn.
+    """
+    if mol.GetNumConformers() == 0:
+        return
+    centers = sorted(
+        {b.GetBeginAtomIdx() for b in mol.GetBonds() if b.GetBondDir() in _WEDGE_Z}
+    )
+    if not centers:
+        return
+    try:
+        read = _rdkit_tags(mol)
+        fixes: Dict[int, Chem.ChiralType] = {}
+        for center in centers:
+            wanted = wedge_reading(mol, center)
+            if wanted is not None and wanted != read[center]:
+                fixes[center] = wanted
+        if not fixes:
+            return
+
+        # Bonds the re-wedge must not touch: everything away from the fixed
+        # centers, and any wedge/hash an adjacent center draws onto a bond it
+        # shares with a fixed center.
+        protected = [
+            b.GetIdx()
+            for b in mol.GetBonds()
+            if b.GetBeginAtomIdx() not in fixes
+            and (b.GetEndAtomIdx() not in fixes or b.GetBondDir() in _WEDGE_Z)
+        ]
+        before = _bond_states(mol, protected)
+        expected = [fixes.get(i, tag) for i, tag in enumerate(read)]
+
+        def holds(trial: Chem.Mol) -> bool:
+            """Fixed centers read right; every other center and bond is as drawn."""
+            return (
+                _bond_states(trial, protected) == before
+                and _rdkit_tags(trial) == expected
+            )
+
+        # WedgeMolBonds may reverse bonds, which cannot be undone, so try it
+        # on a copy and touch the real molecule only once it holds.
+        trial = Chem.Mol(mol)
+        _rdkit_rewedge(trial, fixes)
+        if holds(trial):
+            _rdkit_rewedge(mol, fixes)
+            return
+        # WedgeMolBonds declines some centers, e.g. a T-shape whose one
+        # unambiguous bond already carries a neighbor's hash. Try each free
+        # bond of the center instead; this never reverses a bond.
+        trial = Chem.Mol(mol)
+        _clear_own_wedges(trial, fixes)
+        _pick_wedges(trial, fixes)
+        if holds(trial):
+            for center in fixes:
+                for bond in mol.GetAtomWithIdx(center).GetBonds():
+                    if bond.GetBeginAtomIdx() == center:
+                        bond.SetBondDir(
+                            trial.GetBondWithIdx(bond.GetIdx()).GetBondDir()
+                        )
+            return
+        logging.debug("Re-wedging stereocenters %s did not hold", sorted(fixes))
+    except (RuntimeError, ValueError) as e:
+        logging.warning("Resolving wedge stereochemistry failed: %s", e)
+
+
 class MolecularData:
     """In-memory graph of atoms and bonds, independent of any UI framework."""
 
@@ -449,6 +689,8 @@ class MolecularData:
                     ).get("type") not in (1, 2):
                         adjacent.SetBondDir(Chem.BondDir.NONE)
 
+        resolve_wedge_chirality(final_mol)
+
         # The labels are CIP E/Z; the neighbors picked above are not always
         # the CIP-higher ones.
         align_ez_to_cip(final_mol, ez_wanted)

{moleditpy_linux-4.11.5 → moleditpy_linux-4.12.1}/src/moleditpy_linux/core/stereo_check.py

@@ -113,6 +113,75 @@ def find_chirality_mismatches(
     ]
 
 
+def ambiguous_wedge_centers(data: MolecularData) -> List[int]:
+    """Atom IDs of stereocenters whose wedges/hashes specify no configuration.
+
+    These are drawings RDKit rejects as ambiguous (for example a wedge and a
+    hash on opposite bonds), so the 3D structure gets an arbitrary
+    configuration there. Atoms that are not stereocenters are not reported.
+    """
+    if not any(bond.get("stereo") in (1, 2) for bond in data.bonds.values()):
+        return []
+    mol = data.to_rdkit_mol(use_2d_stereo=False)
+    if mol is None:
+        return []
+    probe = Chem.Mol(mol)
+    Chem.AssignChiralTypesFromBondDirs(probe)
+    centers = {
+        bond.GetBeginAtomIdx()
+        for bond in mol.GetBonds()
+        if bond.GetBondDir() in (Chem.BondDir.BEGINWEDGE, Chem.BondDir.BEGINDASH)
+    }
+    found: List[int] = []
+    for idx in sorted(centers):
+        atom = probe.GetAtomWithIdx(idx)
+        if atom.GetChiralTag() != Chem.ChiralType.CHI_UNSPECIFIED:
+            continue
+        # A stereocenter keeps an arbitrary tag through perception.
+        trial = Chem.Mol(mol)
+        trial.GetAtomWithIdx(idx).SetChiralTag(Chem.ChiralType.CHI_TETRAHEDRAL_CW)
+        Chem.AssignStereochemistry(trial, cleanIt=True, force=True)
+        trial_atom = trial.GetAtomWithIdx(idx)
+        if trial_atom.GetChiralTag() != Chem.ChiralType.CHI_UNSPECIFIED and (
+            trial_atom.HasProp("_original_atom_id")
+        ):
+            found.append(trial_atom.GetIntProp("_original_atom_id"))
+    return found
+
+
+def find_ambiguous_centers(
+    data: MolecularData, mol_3d: Chem.Mol
+) -> List[ChiralityMismatch]:
+    """Ambiguously wedged stereocenters, with ``drawn`` set to "ambiguous".
+
+    ``actual`` is the configuration the 3D structure happened to get.
+    """
+    try:
+        atom_ids = ambiguous_wedge_centers(data)
+        if not atom_ids:
+            return []
+        actual = actual_chirality(mol_3d)
+    except (RuntimeError, ValueError) as e:
+        logging.warning("Ambiguous wedge check failed: %s", e)
+        return []
+    index_of = {
+        atom.GetIntProp("_original_atom_id"): atom.GetIdx()
+        for atom in mol_3d.GetAtoms()
+        if atom.HasProp("_original_atom_id")
+    }
+    return [
+        ChiralityMismatch(
+            atom_id=atom_id,
+            symbol=str(data.atoms[atom_id]["symbol"]),
+            rdkit_index=index_of.get(atom_id),
+            drawn="ambiguous",
+            actual=actual.get(atom_id),
+        )
+        for atom_id in atom_ids
+        if atom_id in data.atoms
+    ]
+
+
 def _bond_cip_by_atom_ids(
     mol: Chem.Mol,
 ) -> Dict[FrozenSet[int], Tuple[int, str]]:

{moleditpy_linux-4.11.5 → moleditpy_linux-4.12.1}/src/moleditpy_linux/ui/chirality_warning_dialog.py

@@ -88,16 +88,47 @@ class ChiralityWarningDialog(QDialog):
             )
         return rows
 
+    def _summary_text(self, row_count: int, total: int) -> str:
+        """Rich-text summary: wrong elements, then ambiguously drawn centers."""
+        ambiguous = sum(1 for m in self.mismatches if m.drawn == "ambiguous")
+        wrong = row_count - ambiguous
+        parts = []
+        if wrong:
+            parts.append(
+                f"<b>The 3D structure is wrong.</b><br>"
+                f"{wrong} of {total} stereo element(s) drawn in 2D (R/S centers, "
+                f"E/Z double bonds) have a different configuration in 3D."
+            )
+        if ambiguous:
+            parts.append(
+                f"<b>{ambiguous} stereocenter(s) are drawn ambiguously</b> "
+                f"(for example a wedge and a hash on opposite bonds), so the "
+                f"wedges do not specify a configuration and the 3D one shown is "
+                f"arbitrary. Redraw them with one wedge or hash, or with the "
+                f"wedge and hash on adjacent bonds."
+            )
+        return "<br><br>".join(parts)
+
+    def _hint_text(self, row_count: int) -> str:
+        """What to do next; flipping applies only to wrong, not ambiguous, rows."""
+        ambiguous = sum(1 for m in self.mismatches if m.drawn == "ambiguous")
+        labels = (
+            "While this window is open, the 3D view shows chiral and E/Z labels: "
+            "listed ones in red, the others in the usual color."
+        )
+        if row_count == ambiguous:
+            return labels
+        flip = "Please flip the wrong ones manually in the 3D structure."
+        if not ambiguous:
+            flip = "Please flip these manually in the 3D structure."
+        return f"{flip} {labels}"
+
     def _build_ui(self, total: int) -> None:
         """Lay out the summary, the per-item table and the close button."""
         layout = QVBoxLayout(self)
 
         rows = self._rows()
-        summary = QLabel(
-            f"<b>The 3D structure is wrong.</b><br>"
-            f"{len(rows)} of {total} stereo element(s) drawn in 2D (R/S centers, "
-            f"E/Z double bonds) have a different configuration in 3D."
-        )
+        summary = QLabel(self._summary_text(len(rows), total))
         summary.setWordWrap(True)
         layout.addWidget(summary)
 
@@ -115,11 +146,7 @@ class ChiralityWarningDialog(QDialog):
             header.setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
         layout.addWidget(table)
 
-        hint = QLabel(
-            "Please flip these manually in the 3D structure. While this window "
-            "is open, the 3D view shows chiral and E/Z labels: wrong ones in "
-            "red, correct ones in the usual color."
-        )
+        hint = QLabel(self._hint_text(len(rows)))
         hint.setWordWrap(True)
         layout.addWidget(hint)
 

{moleditpy_linux-4.11.5 → moleditpy_linux-4.12.1}/src/moleditpy_linux/ui/compute_logic.py

@@ -41,6 +41,7 @@ from ..core.mol_geometry import (
 from ..core.stereo_check import (
     drawn_chirality,
     drawn_ez,
+    find_ambiguous_centers,
     find_chirality_mismatches,
     find_ez_mismatches,
 )
@@ -703,6 +704,7 @@ class ComputeManager:
             return
 
         mismatches = find_chirality_mismatches(data, mol)
+        mismatches += find_ambiguous_centers(data, mol)
         ez_mismatches = find_ez_mismatches(data, mol)
         if not mismatches and not ez_mismatches:
             return
@@ -718,7 +720,8 @@ class ComputeManager:
         count = len(mismatches) + len(ez_mismatches)
         if report_status:
             self.host.update_status_message(
-                f"Warning: {count} stereo element(s) differ from the 2D drawing."
+                f"Warning: {count} stereo element(s) differ from the 2D drawing "
+                "or are drawn ambiguously."
             )
 
     def on_calculation_error(self, message: Union[str, Tuple[int, str]]) -> None:

{moleditpy_linux-4.11.5 → moleditpy_linux-4.12.1}/src/moleditpy_linux/ui/view_3d_logic.py

@@ -1798,13 +1798,22 @@ class View3DManager:
 
     def fit_to_view(self) -> None:
         """Fit all items in the scene into the view"""
-        if not self.host.init_manager.scene.items():
+        try:
+            old_ta = self.host.init_manager.view_2d.transformationAnchor()
+            old_ra = self.host.init_manager.view_2d.resizeAnchor()
+            items = self.host.init_manager.scene.items()
+        except (AttributeError, RuntimeError, TypeError) as e:
+            # Deferred calls (QTimer.singleShot after a load) can land after
+            # the window is torn down; a deleted view cannot be fitted or reset.
+            logging.debug("fit_to_view skipped, 2D view unavailable: %s", e)
+            return
+        if not items:
             self.reset_zoom()
             return
 
         # Calculate total bounding rect of visible items
         visible_items_rect = QRectF()
-        for item in self.host.init_manager.scene.items():
+        for item in items:
             if item.isVisible() and not isinstance(item, TemplatePreviewItem):
                 if visible_items_rect.isEmpty():
                     visible_items_rect = item.sceneBoundingRect()
@@ -1826,12 +1835,6 @@ class View3DManager:
         padded = QRectF(cx - w / 2.0, cy - h / 2.0, w, h)
 
         # Temporarily set anchor to center before calling fitInView
-        try:
-            old_ta = self.host.init_manager.view_2d.transformationAnchor()
-            old_ra = self.host.init_manager.view_2d.resizeAnchor()
-        except (AttributeError, RuntimeError, TypeError):
-            old_ta = old_ra = None
-
         try:
             self.host.init_manager.view_2d.setTransformationAnchor(
                 QGraphicsView.ViewportAnchor.AnchorViewCenter
@@ -1932,13 +1935,18 @@ class View3DManager:
                         tp.ItalicOff()
                         tp.ShadowOff()
 
-                # Add orientation marker widget
-                self.axes_widget = vtk.vtkOrientationMarkerWidget()
-                self.axes_widget.SetOrientationMarker(axes)
-                self.axes_widget.SetInteractor(self.plotter.interactor)  # type: ignore[union-attr]
-                self.axes_widget.SetViewport(0.0, 0.0, 0.2, 0.2)
-                self.axes_widget.SetEnabled(True)
-                self.axes_widget.InteractiveOff()
+                # plotter.interactor is the Qt widget, which VTK rejects;
+                # iren.interactor is the underlying vtkRenderWindowInteractor.
+                # Publish the widget only once fully set up, so a failure here
+                # never leaves an interactor-less widget for the next call to
+                # SetEnabled(False) on.
+                axes_widget = vtk.vtkOrientationMarkerWidget()
+                axes_widget.SetOrientationMarker(axes)
+                axes_widget.SetInteractor(self.plotter.iren.interactor)  # type: ignore[union-attr]
+                axes_widget.SetViewport(0.0, 0.0, 0.2, 0.2)
+                axes_widget.SetEnabled(True)
+                axes_widget.InteractiveOff()
+                self.axes_widget = axes_widget
             else:
                 self.plotter.hide_axes()  # type: ignore[call-arg, union-attr]