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

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

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

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

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

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

@@ -390,6 +390,85 @@ def resolve_wedge_chirality(mol: Chem.Mol) -> None:
         logging.warning("Resolving wedge stereochemistry failed: %s", e)
 
 
+RS_LABELS = ("R", "S")
+
+
+def rs_entry(atom: Dict[str, Any]) -> Dict[str, str]:
+    """{"rs": label} when *atom* carries a valid R/S label, else {}.
+
+    Spread into serialized atom records so an unlabelled atom is written
+    exactly as before the label existed.
+    """
+    label = atom.get("rs")
+    return {"rs": label} if label in RS_LABELS else {}
+
+
+def _tag_for_label(
+    mol: Chem.Mol, center: int, label: str, tags: List[Chem.ChiralType]
+) -> Optional[Chem.ChiralType]:
+    """Chiral tag that gives *center* CIP *label*, or None if it has no R/S.
+
+    The other centers keep *tags* (their drawn configuration), since a
+    center's CIP label can depend on them.
+    """
+    cw, ccw = Chem.ChiralType.CHI_TETRAHEDRAL_CW, Chem.ChiralType.CHI_TETRAHEDRAL_CCW
+    probe = Chem.Mol(mol)
+    for atom, other in zip(probe.GetAtoms(), tags):
+        atom.SetChiralTag(other)
+    probe.GetAtomWithIdx(center).SetChiralTag(cw)
+    Chem.AssignStereochemistry(probe, cleanIt=True, force=True)
+    if probe.GetAtomWithIdx(center).GetChiralTag() != cw:
+        return None  # perception dropped it: not a stereocenter
+    rdCIPLabeler.AssignCIPLabels(probe)
+    atom = probe.GetAtomWithIdx(center)
+    code = atom.GetProp("_CIPCode") if atom.HasProp("_CIPCode") else None
+    if code not in RS_LABELS:
+        return None  # no CIP label, or pseudo-asymmetric (r/s)
+    # The mirror tag gives the mirror label.
+    return cw if code == label else ccw
+
+
+def apply_rs_labels(mol: Chem.Mol, wanted: Dict[int, str]) -> None:
+    """Re-wedge each labelled center of *mol* so it reads as its R/S label.
+
+    *wanted* maps atom index to "R" or "S". A label is the user's explicit
+    choice, so it overrides whatever the wedges and hashes at that center
+    say; it is written back as wedges because that is what every later
+    reader (MOL block, 3D embedding, stereo check) takes chirality from.
+    Labels on atoms that are not stereocenters are ignored, and other
+    centers keep their drawn configuration.
+    """
+    if not wanted or mol.GetNumConformers() == 0:
+        return
+    try:
+        read = _rdkit_tags(mol)
+        fixes: Dict[int, Chem.ChiralType] = {}
+        for center, label in wanted.items():
+            tag = _tag_for_label(mol, center, label, read)
+            if tag is None:
+                logging.debug("R/S label on atom %d ignored: no stereocenter", center)
+            elif tag != read[center]:
+                fixes[center] = tag
+        if not fixes:
+            return
+        expected = [fixes.get(i, tag) for i, tag in enumerate(read)]
+        for rewedge in (_rdkit_rewedge, _clear_and_pick_wedges):
+            trial = Chem.Mol(mol)
+            rewedge(trial, fixes)
+            if _rdkit_tags(trial) == expected:
+                rewedge(mol, fixes)
+                return
+        logging.warning("Could not draw R/S labels on atoms %s", sorted(fixes))
+    except (RuntimeError, ValueError) as e:
+        logging.warning("Applying R/S labels failed: %s", e)
+
+
+def _clear_and_pick_wedges(mol: Chem.Mol, fixes: Dict[int, Chem.ChiralType]) -> None:
+    """Drop the wedges at *fixes* and pick one free bond per center afresh."""
+    _clear_own_wedges(mol, fixes)
+    _pick_wedges(mol, fixes)
+
+
 class MolecularData:
     """In-memory graph of atoms and bonds, independent of any UI framework."""
 
@@ -511,10 +590,14 @@ class MolecularData:
                 self.adjacency_list[id2].remove(id1)
             self.bonds.pop(key_to_remove, None)
 
-    def to_rdkit_mol(self, use_2d_stereo: bool = True) -> Optional[Chem.Mol]:
+    def to_rdkit_mol(
+        self, use_2d_stereo: bool = True, use_rs_labels: bool = True
+    ) -> Optional[Chem.Mol]:
         """
         use_2d_stereo: True estimates E/Z from 2D coordinates (as before). False prioritizes E/Z labels.
         Call with use_2d_stereo=False for 3D conversion.
+        use_rs_labels: True re-wedges atoms carrying an R/S label ("rs") so the
+        label wins over their drawn wedges; False reads the drawing alone.
         """
         if not self.atoms:
             return None
@@ -691,6 +774,17 @@ class MolecularData:
 
         resolve_wedge_chirality(final_mol)
 
+        # R/S labels are the user's explicit choice and override the wedges.
+        if use_rs_labels:
+            apply_rs_labels(
+                final_mol,
+                {
+                    atom_id_to_idx_map[atom_id]: data["rs"]
+                    for atom_id, data in self.atoms.items()
+                    if data.get("rs") in RS_LABELS and atom_id in atom_id_to_idx_map
+                },
+            )
+
         # 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.12.1 → moleditpy_linux-4.13.0}/src/moleditpy_linux/core/stereo_check.py

@@ -14,12 +14,12 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass
-from typing import Dict, FrozenSet, List, Optional, Tuple
+from typing import Any, Dict, FrozenSet, List, Optional, Tuple
 
 from rdkit import Chem
 from rdkit.Chem import rdCIPLabeler
 
-from .molecular_data import MolecularData
+from .molecular_data import RS_LABELS, MolecularData
 
 
 @dataclass(frozen=True)
@@ -55,12 +55,20 @@ def _cip_labels_by_atom_id(mol: Chem.Mol) -> Dict[int, str]:
     return labels
 
 
-def drawn_chirality(data: MolecularData) -> Dict[int, str]:
-    """CIP labels of the stereocenters the 2D drawing specifies with wedges."""
-    # Nothing is specified without a wedge or hash; skip CIP labelling.
-    if not any(bond.get("stereo") in (1, 2) for bond in data.bonds.values()):
+def drawn_chirality(data: MolecularData, use_rs_labels: bool = True) -> Dict[int, str]:
+    """CIP labels of the stereocenters the 2D drawing specifies.
+
+    These come from the wedges and hashes and, unless *use_rs_labels* is
+    False, the atoms' R/S labels, which override the wedges at their center.
+    """
+    # Nothing is specified without a wedge, hash or label; skip CIP labelling.
+    has_wedge = any(bond.get("stereo") in (1, 2) for bond in data.bonds.values())
+    has_label = use_rs_labels and any(
+        atom.get("rs") in RS_LABELS for atom in data.atoms.values()
+    )
+    if not has_wedge and not has_label:
         return {}
-    mol = data.to_rdkit_mol(use_2d_stereo=False)
+    mol = data.to_rdkit_mol(use_2d_stereo=False, use_rs_labels=use_rs_labels)
     if mol is None:
         return {}
     Chem.AssignChiralTypesFromBondDirs(mol)
@@ -68,6 +76,125 @@ def drawn_chirality(data: MolecularData) -> Dict[int, str]:
     return _cip_labels_by_atom_id(mol)
 
 
+@dataclass(frozen=True)
+class WedgeForLabel:
+    """How to draw a bond so that the stereocenter at its narrow end reads as R/S."""
+
+    key: Tuple[int, int]  # (stereocenter, other end): data.bonds key, narrow end first
+    stereo: int  # 1 = wedge, 2 = hash
+    cleared: Tuple[Tuple[int, int], ...]  # other wedges at the center to make plain
+
+
+def wedge_for_label(
+    data: MolecularData,
+    bond_key: Tuple[int, int],
+    label: str,
+    centers: Optional[List[int]] = None,
+) -> Optional[WedgeForLabel]:
+    """Wedge or hash on *bond_key* that makes one of its ends CIP *label*.
+
+    *centers* is the order in which the bond's ends are tried (default: the
+    key order). Each end is tried first with the other wedges kept; if they
+    make *label* unreachable, then with this center's other wedges and hashes
+    made plain, so the requested label wins. Returns None when neither end
+    can be *label* (not a stereocenter). *data* is left unchanged.
+    """
+    if bond_key not in data.bonds or label not in RS_LABELS:
+        return None
+    ends = list(centers) if centers else list(bond_key)
+    original = list(data.bonds.items())
+    template = dict(data.bonds[bond_key], order=1)
+    trial_bonds = {k: dict(v) for k, v in original if k != bond_key}
+    try:
+        for center in ends:
+            if center not in bond_key:
+                continue
+            other = bond_key[1] if center == bond_key[0] else bond_key[0]
+            own = tuple(
+                k
+                for k, v in trial_bonds.items()
+                if k[0] == center and v.get("stereo") in (1, 2)
+            )
+            for cleared in ((), own) if own else ((),):
+                stereo = _stereo_reading_as(
+                    data, trial_bonds, (center, other), template, cleared, label
+                )
+                if stereo is not None:
+                    return WedgeForLabel((center, other), stereo, cleared)
+        return None
+    except (RuntimeError, ValueError, TypeError) as e:
+        logging.warning("R/S wedge search failed: %s", e)
+        return None
+    finally:
+        data.bonds.clear()
+        data.bonds.update(original)
+
+
+def _stereo_reading_as(
+    data: MolecularData,
+    base: Dict[Tuple[int, int], Dict[str, Any]],
+    key: Tuple[int, int],
+    template: Dict[str, Any],
+    cleared: Tuple[Tuple[int, int], ...],
+    label: str,
+) -> Optional[int]:
+    """Wedge (1) or hash (2) on *key* that makes its narrow end read *label*.
+
+    Tried on *data* rebuilt from *base* with the *cleared* bonds made plain;
+    the caller restores *data*.
+    """
+    for stereo in (1, 2):
+        data.bonds.clear()
+        for k, v in base.items():
+            data.bonds[k] = dict(v, stereo=0) if k in cleared else dict(v)
+        data.bonds[key] = dict(template, stereo=stereo)
+        if drawn_chirality(data, use_rs_labels=False).get(key[0]) == label:
+            return stereo
+    return None
+
+
+def align_wedges_to_label(
+    data: MolecularData, center: int, label: str
+) -> Dict[Tuple[int, int], int]:
+    """Stereo changes that make the wedges at *center* draw R/S *label*.
+
+    Only the wedges and hashes starting at *center* are touched, and only when
+    there are some: a center drawn without them keeps its plain bonds (its
+    label alone carries the configuration). If the drawing already reads as
+    *label*, nothing changes. Otherwise every stereo bond at the center is
+    swapped (wedge <-> hash), which mirrors it; if that still does not read
+    as *label* (an ambiguous drawing), one of them is redrawn and the rest
+    made plain. Returns {data.bonds key: new stereo}; empty when nothing
+    needs to change or no drawing gives *label*.
+    """
+    own = [
+        key
+        for key, bond in data.bonds.items()
+        if key[0] == center and bond.get("stereo") in (1, 2)
+    ]
+    if not own or label not in RS_LABELS:
+        return {}
+    if drawn_chirality(data, use_rs_labels=False).get(center) == label:
+        return {}
+    original = {key: data.bonds[key]["stereo"] for key in own}
+    swapped = {key: 3 - stereo for key, stereo in original.items()}
+    try:
+        for key, stereo in swapped.items():
+            data.bonds[key]["stereo"] = stereo
+        if drawn_chirality(data, use_rs_labels=False).get(center) == label:
+            return swapped
+    finally:
+        for key, stereo in original.items():
+            data.bonds[key]["stereo"] = stereo
+    for key in own:
+        found = wedge_for_label(data, key, label, centers=[center])
+        if found is not None:
+            changes = dict.fromkeys(found.cleared, 0)
+            changes[key] = found.stereo
+            return changes
+    return {}
+
+
 def actual_chirality(mol_3d: Chem.Mol) -> Dict[int, str]:
     """CIP labels of the stereocenters in a 3D structure, read from coordinates."""
     if mol_3d.GetNumConformers() == 0:

{moleditpy_linux-4.12.1 → moleditpy_linux-4.13.0}/src/moleditpy_linux/ui/app_state.py

@@ -33,7 +33,7 @@ from PyQt6.QtCore import QDateTime, Qt
 from PyQt6.QtWidgets import QMessageBox
 
 from ..utils.constants import VERSION
-from ..core.molecular_data import MolecularData
+from ..core.molecular_data import MolecularData, rs_entry
 
 
 from typing import TYPE_CHECKING
@@ -90,6 +90,7 @@ class StateManager:
                 "pos": data["pos"],  # Already a tuple (x, y)
                 "charge": data.get("charge", 0),
                 "radical": data.get("radical", 0),
+                **rs_entry(data),
             }
             for atom_id, data in self.data.atoms.items()
         }
@@ -332,7 +333,7 @@ class StateManager:
 
         if self.data:
             try:
-                mol = self.data.to_rdkit_mol()
+                mol = self.data.to_rdkit_mol(use_rs_labels=False)
                 if mol:
                     mol_with_hs = Chem.AddHs(mol)
                     mol_formula = rdMolDescriptors.CalcMolFormula(mol)
@@ -370,6 +371,7 @@ class StateManager:
                     "y": pos[1],
                     "charge": data.get("charge", 0),
                     "radical": data.get("radical", 0),
+                    **rs_entry(data),
                 }
                 atoms_2d.append(atom_data)
 

{moleditpy_linux-4.12.1 → moleditpy_linux-4.13.0}/src/moleditpy_linux/ui/atom_item.py

@@ -22,6 +22,7 @@ from PyQt6.QtGui import (
     QFontMetricsF,
     QPainter,
     QPainterPath,
+    QPainterPathStroker,
     QPen,
 )
 from PyQt6.QtWidgets import (
@@ -34,6 +35,7 @@ from PyQt6.QtWidgets import (
 from ..utils.constants import (
     ATOM_RADIUS,
     CPK_COLORS,
+    EZ_LABEL_TEXT_OUTLINE,
     FONT_FAMILY,
     FONT_WEIGHT_BOLD,
 )
@@ -86,6 +88,8 @@ class AtomItem(QGraphicsItem):
         self.radical: int = radical
         self.bonds: List[BondItem] = []
         self.chiral_label: Optional[str] = None
+        # User-set R/S label ("R"/"S"); mirrors data.atoms[atom_id]["rs"].
+        self.rs_label: Optional[str] = None
 
         self.setPos(pos)
         self.implicit_h_count: int = 0
@@ -250,9 +254,91 @@ class AtomItem(QGraphicsItem):
     def boundingRect(self) -> QRectF:
         """Return the drawn rect plus the hit shape, which Qt requires it to cover."""
         hit_r = self.hit_radius()
-        return self.visual_rect().united(
+        rect = self.visual_rect().united(
             QRectF(-hit_r, -hit_r, hit_r * 2.0, hit_r * 2.0)
         )
+        rs_rect = self._rs_label_rect()
+        if rs_rect is not None:
+            rect = rect.united(rs_rect.adjusted(-2, -2, 2, 2))
+        return rect
+
+    def _rs_label_font(self) -> QFont:
+        """Italic font of the R/S label, sized from the atom label font."""
+        base = self._label_font()
+        font = QFont(
+            base.family(), max(8, int(base.pointSize() * 0.7)), FONT_WEIGHT_BOLD
+        )
+        font.setItalic(True)
+        return font
+
+    def _rs_label_rect(self) -> Optional[QRectF]:
+        """Where the "(R)"/"(S)" label goes: beside the atom, away from its bonds."""
+        if self.rs_label not in ("R", "S"):
+            return None
+        rect = QFontMetricsF(self._rs_label_font()).boundingRect(f"({self.rs_label})")
+        dx = dy = 0.0
+        for bond in self.bonds:
+            try:
+                partner = bond.atom2 if bond.atom1 is self else bond.atom1
+                if partner is None or sip_isdeleted_safe(partner):
+                    continue
+                vec = partner.pos() - self.pos()
+                length = (vec.x() ** 2 + vec.y() ** 2) ** 0.5
+                if length > 1e-6:
+                    dx += vec.x() / length
+                    dy += vec.y() / length
+            except (AttributeError, RuntimeError, TypeError):
+                continue
+        length = (dx**2 + dy**2) ** 0.5
+        # Opposite the bonds; upper right when they balance out or there are none.
+        ux, uy = (-dx / length, -dy / length) if length > 0.3 else (0.71, -0.71)
+        distance = 14.0 + max(rect.width(), rect.height()) / 2.0
+        rect.moveCenter(QPointF(ux * distance, uy * distance))
+        return rect
+
+    def _relayout_rs_labels(self) -> None:
+        """Re-place the R/S labels a move of this atom shifts.
+
+        A label sits opposite its atom's bonds, so moving this atom moves its
+        own label and those of its labelled neighbors.
+        """
+        if self.rs_label is not None:
+            self.prepareGeometryChange()
+        for bond in self.bonds:
+            partner = bond.atom2 if bond.atom1 is self else bond.atom1
+            if partner is None or sip_isdeleted_safe(partner):
+                continue
+            if getattr(partner, "rs_label", None) is not None:
+                partner.prepareGeometryChange()
+
+    def _paint_rs_label(self, painter: QPainter) -> None:
+        """Draw the user-set R/S label, outlined like the E/Z label."""
+        rect = self._rs_label_rect()
+        if rect is None:
+            return
+        painter.save()
+        font = self._rs_label_font()
+        text = f"({self.rs_label})"
+        path = QPainterPath()
+        fm = QFontMetricsF(font)
+        path.addText(QPointF(rect.left(), rect.top() + fm.ascent()), font, text)
+        outline_color = QColor(255, 255, 255)
+        scene: Any = self.scene()
+        try:
+            if scene is not None:
+                outline_color = scene.backgroundBrush().color()
+        except (AttributeError, RuntimeError, TypeError):
+            logging.debug("R/S label outline color fallback", exc_info=True)
+        stroker = QPainterPathStroker()
+        stroker.setWidth(EZ_LABEL_TEXT_OUTLINE)
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(outline_color)
+        painter.drawPath(stroker.createStroke(path))
+        text_color = QColor("gray")
+        painter.setBrush(text_color)
+        painter.setPen(text_color)
+        painter.drawPath(path)
+        painter.restore()
 
     def get_bg_ellipse_path(self) -> QPainterPath:
         """Return the elliptical background path used for bond endpoint clipping."""
@@ -381,6 +467,9 @@ class AtomItem(QGraphicsItem):
                         QPointF(text_rect.center().x() + 5, radical_pos_y), 3, 3
                     )
 
+        # Drawn even on a skeletal carbon, which has no symbol of its own.
+        self._paint_rs_label(painter)
+
         # --- Selection highlights etc. ---
         if self.has_problem:
             painter.setBrush(Qt.BrushStyle.NoBrush)
@@ -405,6 +494,7 @@ class AtomItem(QGraphicsItem):
                 for bond in self.bonds:
                     if bond.scene():
                         bond.update_position()
+                self._relayout_rs_labels()
         elif change == QGraphicsItem.GraphicsItemChange.ItemSceneHasChanged:
             if self.scene() is not None:
                 self.update_style()

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

@@ -817,7 +817,7 @@ class ComputeManager:
     def update_aromatic_rings(self) -> None:
         """Update aromatic ring visualization."""
         try:
-            mol = self.host.state_manager.data.to_rdkit_mol()
+            mol = self.host.state_manager.data.to_rdkit_mol(use_rs_labels=False)
             if not mol:
                 return
             Chem.SanitizeMol(mol)

{moleditpy_linux-4.12.1 → moleditpy_linux-4.13.0}/src/moleditpy_linux/ui/edit_actions_logic.py

@@ -44,7 +44,7 @@ from rdkit import Chem
 from .atom_item import AtomItem
 from .bond_item import BondItem
 from ..utils.constants import CLIPBOARD_MIME_TYPE, UNDO_STACK_MAX_DEPTH
-from ..core.molecular_data import MolecularData
+from ..core.molecular_data import RS_LABELS, MolecularData, rs_entry
 from ..utils.sip_isdeleted_safe import sip_isdeleted_safe
 
 
@@ -159,6 +159,7 @@ class EditActionsManager:
                     v["pos"].y() if hasattr(v["pos"], "y") else v["pos"][1],
                     v.get("charge", 0),
                     v.get("radical", 0),
+                    v.get("rs"),
                 )
                 for k, v in self.host.state_manager.data.atoms.items()
             },
@@ -196,6 +197,7 @@ class EditActionsManager:
                         v["pos"].y() if hasattr(v["pos"], "y") else v["pos"][1],
                         v.get("charge", 0),
                         v.get("radical", 0),
+                        v.get("rs"),
                     )
                     for k, v in last_atoms.items()
                 },
@@ -322,6 +324,9 @@ class EditActionsManager:
                         "rel_pos": atom.pos() - center,
                         "charge": atom.charge,
                         "radical": atom.radical,
+                        **rs_entry(
+                            self.host.state_manager.data.atoms.get(atom.atom_id, {})
+                        ),
                     }
                 )
 
@@ -350,6 +355,7 @@ class EditActionsManager:
                         "rel_pos": [a["rel_pos"].x(), a["rel_pos"].y()],
                         "charge": a["charge"],
                         "radical": a["radical"],
+                        **rs_entry(a),
                     }
                     for a in fragment_atoms
                 ],
@@ -441,12 +447,15 @@ class EditActionsManager:
                     raise TypeError(
                         "Clipboard atom charge and radical must be integers"
                     )
+                if atom_data.get("rs") not in (None, *RS_LABELS):
+                    raise ValueError("Clipboard atom R/S label must be R or S")
                 validated_atoms.append(
                     {
                         "symbol": symbol,
                         "rel_pos": (rel_x, rel_y),
                         "charge": charge,
                         "radical": radical,
+                        **rs_entry(atom_data),
                     }
                 )
 
@@ -500,6 +509,10 @@ class EditActionsManager:
                     radical=atom_data.get("radical", 0),
                 )
                 new_item = self.host.init_manager.scene.atom_items[new_id]
+                if atom_data.get("rs"):
+                    self.host.init_manager.scene.set_atom_rs_label(
+                        new_item, atom_data["rs"]
+                    )
                 new_atoms.append(new_item)
                 new_item.setSelected(True)
 
@@ -1208,7 +1221,7 @@ class EditActionsManager:
 
             mol = None
             try:
-                mol = self.host.state_manager.data.to_rdkit_mol()
+                mol = self.host.state_manager.data.to_rdkit_mol(use_rs_labels=False)
             except (AttributeError, RuntimeError, ValueError, TypeError) as e:
                 logging.debug(f"to_rdkit_mol failed during H-update: {e}")
                 mol = None

{moleditpy_linux-4.12.1 → moleditpy_linux-4.13.0}/src/moleditpy_linux/ui/main_window_init.py

@@ -848,6 +848,7 @@ class MainInitManager:
             ("Triple Bond", "bond_3_0", "3", "triple"),
             ("Wedge Bond", "bond_1_1", "W", "wedge"),
             ("Dash Bond", "bond_1_2", "D", "dash"),
+            ("Toggle R/S", "rs_label", "R", "rs_toggle"),
             ("Toggle E/Z", "bond_2_5", "E/Z", "ez_toggle"),
         ]
 
@@ -1032,17 +1033,28 @@ class MainInitManager:
             offset = QPointF(v.dx(), v.dy()) * 2.0
             painter.drawLine(linez.translated(offset))
             painter.drawLine(linez.translated(-offset))
-            font = painter.font()
-            font.setPointSize(10)
-            font.setBold(True)
-            painter.setFont(font)
-            painter.drawText(
-                QRectF(0, 0, size, size * 0.6), Qt.AlignmentFlag.AlignCenter, "Z⇌E"
-            )
+            self._draw_icon_caption(painter, size, "Z⇌E")
+        elif bond_type == "rs_toggle":
+            p1z, p2z = QPointF(6, size * 0.75), QPointF(size - 6, size * 0.75)
+            normal = QLineF(p1z, p2z).unitVector().normalVector()
+            offset = QPointF(normal.dx(), normal.dy()) * 3.0
+            painter.drawPolygon(QPolygonF([p1z, p2z + offset, p2z - offset]))
+            self._draw_icon_caption(painter, size, "R⇌S")
 
         painter.end()
         return QIcon(pixmap)
 
+    @staticmethod
+    def _draw_icon_caption(painter: QPainter, size: int, text: str) -> None:
+        """Bold caption across the top of a toolbar icon (e.g. "Z⇌E")."""
+        font = painter.font()
+        font.setPointSize(10)
+        font.setBold(True)
+        painter.setFont(font)
+        painter.drawText(
+            QRectF(0, 0, size, size * 0.6), Qt.AlignmentFlag.AlignCenter, text
+        )
+
     def _create_chain_icon(self, size: int = 32) -> QIcon:
         """Generate the -(-)n- repeat-unit icon for the alkyl chain tool."""
         fg = self._get_icon_foreground_color()

{moleditpy_linux-4.12.1 → moleditpy_linux-4.13.0}/src/moleditpy_linux/ui/molecular_scene_handler.py

@@ -25,6 +25,8 @@ from .bond_item import BondItem
 from ..utils.sip_isdeleted_safe import sip_isdeleted_safe
 
 from ..core.mol_geometry import is_problematic_valence
+from ..core.molecular_data import RS_LABELS
+from ..core.stereo_check import align_wedges_to_label, drawn_chirality
 from ..utils.constants import DEFAULT_BOND_LENGTH, SUM_TOLERANCE
 
 
@@ -893,6 +895,7 @@ class KeyboardMixin:
     # Provided by the composed MoleculeScene at runtime
     _calculate_polygon_from_edge: Any
     add_molecule_fragment: Any
+    apply_rs_label: Any
     atom_items: Any
     clear: Any
     create_atom: Any
@@ -1201,6 +1204,20 @@ class KeyboardMixin:
                     event.accept()
                     return
 
+            # --- 0c. R/S label (R cycles the hovered atom: R -> S -> none) ---
+            if (
+                key == Qt.Key.Key_R
+                and modifiers == Qt.KeyboardModifier.NoModifier
+                and isinstance(item_at_cursor, AtomItem)
+            ):
+                if self.apply_rs_label(
+                    item_at_cursor, next_rs_label(item_at_cursor.rs_label)
+                ):
+                    self.update_all_items()
+                    self.window.edit_actions_manager.push_undo_state()
+                event.accept()
+                return
+
             # --- 1. Atom operations (change symbol) ---
             if isinstance(item_at_cursor, AtomItem):
                 new_symbol = None
@@ -1851,3 +1868,79 @@ class SceneQueryMixin:
             )
             self.window.statusBar().showMessage(f"Error: {e}", 5000)
             self.update_all_items()
+
+    def set_atom_rs_label(self, atom_item: Any, label: Optional[str]) -> None:
+        """Store R/S *label* (None clears it) on the atom's data and item."""
+        record = self.data.atoms.get(atom_item.atom_id)
+        if record is None:
+            return
+        if label in RS_LABELS:
+            record["rs"] = label
+        else:
+            record.pop("rs", None)
+            label = None
+        atom_item.prepareGeometryChange()
+        atom_item.rs_label = label
+        atom_item.update()
+
+    def apply_rs_label(self, atom_item: Any, label: Optional[str]) -> bool:
+        """Give *atom_item* R/S *label* (None clears it); True if anything changed.
+
+        A label overrides the wedges at its center. Where the center already
+        has wedges or hashes, they are redrawn to agree with the label; a
+        center without them keeps its plain bonds. An atom that cannot be R/S
+        (not a stereocenter) is left alone with a status-bar note.
+        """
+        if atom_item is None or atom_item.atom_id not in self.data.atoms:
+            return False
+        if getattr(atom_item, "rs_label", None) == label:
+            return False
+        atom_id = atom_item.atom_id
+        if label is None:
+            self.set_atom_rs_label(atom_item, None)
+            return True
+        record = self.data.atoms[atom_id]
+        previous = record.get("rs")
+        record["rs"] = label
+        try:
+            reachable = drawn_chirality(self.data).get(atom_id) == label
+        finally:
+            if previous is None:
+                record.pop("rs", None)
+            else:
+                record["rs"] = previous
+        if not reachable:
+            self.window.statusBar().showMessage(
+                f"{atom_item.symbol}{atom_id} is not a stereocenter; no R/S label set.",
+                4000,
+            )
+            return False
+        bond_changes = align_wedges_to_label(self.data, atom_id, label)
+        self.set_atom_rs_label(atom_item, label)
+        for key, stereo in bond_changes.items():
+            self._set_bond_stereo_by_key(key, stereo)
+        return True
+
+    def _set_bond_stereo_by_key(self, key: Tuple[int, int], stereo: int) -> None:
+        """Set a bond's stereo in data and scene, keeping plain-bond keys sorted."""
+        bond_data = self.data.bonds.get(key)
+        bond_item = self.bond_items.get(key)
+        if bond_data is None:
+            return
+        bond_data["stereo"] = stereo
+        new_key = key
+        if stereo == 0 and key[0] > key[1]:
+            new_key = (key[1], key[0])
+            self.data.bonds[new_key] = self.data.bonds.pop(key)
+        if bond_item is None:
+            return
+        if new_key != key:
+            self.rekey_bond_item(bond_item, new_key)
+            bond_item.atom1, bond_item.atom2 = bond_item.atom2, bond_item.atom1
+            bond_item.update_position()
+        bond_item.set_stereo(stereo)
+
+
+def next_rs_label(current: Optional[str]) -> Optional[str]:
+    """The R/S tool's click cycle: none -> R -> S -> none."""
+    return {None: "R", "R": "S"}.get(current)

{moleditpy_linux-4.12.1 → moleditpy_linux-4.13.0}/src/moleditpy_linux/ui/molecule_scene.py

@@ -25,6 +25,8 @@ from PyQt6.QtWidgets import (
     QGraphicsSceneMouseEvent,
 )
 
+from ..core.molecular_data import rs_entry
+
 if TYPE_CHECKING:
     from ..core.molecular_data import MolecularData
     from .main_window import MainWindow
@@ -36,7 +38,12 @@ from .template_preview_item import TemplatePreviewItem
 
 from ..utils.sip_isdeleted_safe import sip_isdeleted_safe
 
-from .molecular_scene_handler import TemplateMixin, KeyboardMixin, SceneQueryMixin
+from .molecular_scene_handler import (
+    KeyboardMixin,
+    SceneQueryMixin,
+    TemplateMixin,
+    next_rs_label,
+)
 from .chain_mixin import ChainMixin
 
 
@@ -126,7 +133,7 @@ class MoleculeScene(
             return
 
         # 1. Generate RDKit molecule for topology analysis
-        mol = self.data.to_rdkit_mol(use_2d_stereo=False)
+        mol = self.data.to_rdkit_mol(use_2d_stereo=False, use_rs_labels=False)
         if not mol:
             # Fallback: reset all ring info if molecule generation fails
             for bond_item in self.bond_items.values():
@@ -231,7 +238,9 @@ class MoleculeScene(
                 "pos": raw_pos,
                 "charge": charge,
                 "radical": radical,
+                **rs_entry(data),
             }
+            atom_item.rs_label = self.data.atoms[atom_id].get("rs")
             self.atom_items[atom_id] = atom_item
             self.addItem(atom_item)
 
@@ -276,7 +285,9 @@ class MoleculeScene(
                 "pos": raw_pos,
                 "charge": charge,
                 "radical": radical,
+                **rs_entry(atom_data),
             }
+            atom_item.rs_label = self.data.atoms[atom_id].get("rs")
             self.atom_items[atom_id] = atom_item
             self.addItem(atom_item)
 
@@ -439,7 +450,9 @@ class MoleculeScene(
             if (
                 len(selected_items) > 1
                 and item in selected_items
-                and not self.mode.startswith(("template", "charge", "radical"))
+                and not self.mode.startswith(
+                    ("template", "charge", "radical", "rs_label")
+                )
             ):
                 # Delete the entire rectangular selection
                 data_changed = self.delete_items(set(selected_items))
@@ -484,6 +497,9 @@ class MoleculeScene(
                     self.data.atoms[item.atom_id]["radical"] = 0
                     item.update_style()
                     data_changed = True
+                # Clear the R/S label if in R/S mode
+                elif self.mode == "rs_label" and item.rs_label is not None:
+                    data_changed = self.apply_rs_label(item, None)
                 # Set charge to 0 if in charge mode
                 elif self.mode in ["charge_plus", "charge_minus"] and item.charge != 0:
                     item.prepareGeometryChange()
@@ -492,11 +508,15 @@ class MoleculeScene(
                     item.update_style()
                     data_changed = True
                 # Delete atom in modes other than those above (excluding template, charge, radical)
-                elif not self.mode.startswith(("template", "charge", "radical")):
+                elif not self.mode.startswith(
+                    ("template", "charge", "radical", "rs_label")
+                ):
                     data_changed = self.delete_items({item})
             elif isinstance(item, BondItem):
                 # Delete bond in modes other than template, charge, radical
-                if not self.mode.startswith(("template", "charge", "radical")):
+                if not self.mode.startswith(
+                    ("template", "charge", "radical", "rs_label")
+                ):
                     data_changed = self.delete_items({item})
 
             if data_changed:
@@ -692,6 +712,19 @@ class MoleculeScene(
             self.press_pos = None
             self.window.edit_actions_manager.push_undo_state()
             return
+        elif (
+            self.mode == "rs_label" and is_click and isinstance(released_item, AtomItem)
+        ):
+            changed = self.apply_rs_label(
+                released_item, next_rs_label(released_item.rs_label)
+            )
+            self.start_atom = None
+            self.start_pos = None
+            self.press_pos = None
+            if changed:
+                self.update_all_items()
+                self.window.edit_actions_manager.push_undo_state()
+            return
         elif (
             (self.mode == "charge_plus" or self.mode == "charge_minus")
             and is_click
@@ -922,6 +955,13 @@ class MoleculeScene(
         """Handle double click events."""
         item = self.itemAt(event.scenePos(), self.views()[0].transform())
 
+        if self.mode == "rs_label" and isinstance(item, AtomItem):
+            # The second click of a double-click advances the cycle once more.
+            if self.apply_rs_label(item, next_rs_label(item.rs_label)):
+                self.update_all_items()
+                self.window.edit_actions_manager.push_undo_state()
+            event.accept()
+            return
         if self.mode in ["charge_plus", "charge_minus", "radical"] and isinstance(
             item, AtomItem
         ):

{moleditpy_linux-4.12.1 → moleditpy_linux-4.13.0}/src/moleditpy_linux/ui/ui_manager.py

@@ -85,7 +85,7 @@ class UIManager(QObject):
             self.host.init_manager.view_2d.setCursor(Qt.CursorShape.ArrowCursor)
         elif mode_str.startswith(("atom", "bond", "template", "chain")):
             self.host.init_manager.view_2d.setCursor(Qt.CursorShape.CrossCursor)
-        elif mode_str.startswith(("charge", "radical")):
+        elif mode_str.startswith(("charge", "radical", "rs_label")):
             self.host.init_manager.view_2d.setCursor(Qt.CursorShape.CrossCursor)
         else:
             self.host.init_manager.view_2d.setCursor(Qt.CursorShape.ArrowCursor)
@@ -139,6 +139,11 @@ class UIManager(QObject):
         elif mode_str == "radical":
             self.host.update_status_message("Mode: Toggle Radical (Click on Atom)")
             self.host.init_manager.view_2d.setDragMode(QGraphicsView.DragMode.NoDrag)
+        elif mode_str == "rs_label":
+            self.host.update_status_message(
+                "Mode: Toggle R/S (Click on a stereocenter: R -> S -> none)"
+            )
+            self.host.init_manager.view_2d.setDragMode(QGraphicsView.DragMode.NoDrag)
 
         else:  # Select mode
             self.host.update_status_message("Mode: Select")

{moleditpy_linux-4.12.1 → moleditpy_linux-4.13.0}/src/moleditpy_linux/ui/zoomable_view.py

@@ -127,7 +127,7 @@ class ZoomableView(QGraphicsView):
                 self.setCursor(Qt.CursorShape.ArrowCursor)
             elif current_mode.startswith(("atom", "bond", "template", "chain")):
                 self.setCursor(Qt.CursorShape.CrossCursor)
-            elif current_mode.startswith(("charge", "radical")):
+            elif current_mode.startswith(("charge", "radical", "rs_label")):
                 self.setCursor(Qt.CursorShape.CrossCursor)
             else:
                 self.setCursor(Qt.CursorShape.ArrowCursor)