MoleditPy-linux 4.4.1__py3-none-any.whl → 4.5.1__py3-none-any.whl

moleditpy_linux/core/molecular_data.py

@@ -30,6 +30,93 @@ class PointTuple(tuple):
         return float(self[1])
 
 
+def _mdl_radical_code(radical_electrons: int) -> int:
+    """Map a count of unpaired electrons to an MDL radical code."""
+    # MDL encodes 1 = singlet, 2 = doublet, 3 = triplet.
+    if radical_electrons <= 0:
+        return 0
+    return 2 if radical_electrons == 1 else 3
+
+
+def _mdl_property_lines(atom_records: List[Dict[str, Any]]) -> List[str]:
+    """Build the M CHG / M RAD property lines for a V2000 block."""
+    lines = []
+    for tag, key, encode in (
+        ("CHG", "charge", int),
+        ("RAD", "radical", _mdl_radical_code),
+    ):
+        entries = [
+            (idx, encode(rec[key]))
+            for idx, rec in enumerate(atom_records, start=1)
+            if rec[key]
+        ]
+        # The MDL property block allows at most 8 entries per line.
+        for start in range(0, len(entries), 8):
+            chunk = entries[start : start + 8]
+            lines.append(
+                f"M  {tag}{len(chunk):3d}"
+                + "".join(f"{idx:4d}{val:4d}" for idx, val in chunk)
+            )
+    return lines
+
+
+def _to_v2000_block(
+    atom_records: List[Dict[str, Any]], bond_records: List[Dict[str, Any]]
+) -> str:
+    """Render collected atom/bond records as an MDL V2000 MOL block."""
+    lines = ["", "  MoleditPy", ""]
+    lines.append(
+        f"{len(atom_records):3d}{len(bond_records):3d}  0  0  0  0  0  0  0  0999 V2000"
+    )
+    for rec in atom_records:
+        # Charge and radical travel in the M CHG / M RAD blocks below, so every
+        # per-atom field here stays zero.
+        lines.append(
+            f"{rec['x']:10.4f}{rec['y']:10.4f}{0.0:10.4f} {rec['symbol']:<3}"
+            " 0  0  0  0  0  0  0  0  0  0  0  0"
+        )
+    for rec in bond_records:
+        lines.append(
+            f"{rec['a1']:3d}{rec['a2']:3d}{rec['order']:3d}{rec['stereo']:3d}  0  0  0"
+        )
+    lines.extend(_mdl_property_lines(atom_records))
+    lines.append("M  END")
+    return "\n".join(lines) + "\n"
+
+
+def _to_v3000_block(
+    atom_records: List[Dict[str, Any]], bond_records: List[Dict[str, Any]]
+) -> str:
+    """Render collected atom/bond records as an MDL V3000 MOL block."""
+    lines = ["", "  MoleditPy", "", "  0  0  0  0  0  0  0  0  0  0999 V3000"]
+    lines.append("M  V30 BEGIN CTAB")
+    lines.append(f"M  V30 COUNTS {len(atom_records)} {len(bond_records)} 0 0 0")
+    lines.append("M  V30 BEGIN ATOM")
+    for idx, rec in enumerate(atom_records, start=1):
+        extra = ""
+        if rec["charge"]:
+            extra += f" CHG={int(rec['charge'])}"
+        if rec["radical"]:
+            extra += f" RAD={_mdl_radical_code(rec['radical'])}"
+        lines.append(
+            f"M  V30 {idx} {rec['symbol']} "
+            f"{rec['x']:.4f} {rec['y']:.4f} 0.0000 0{extra}"
+        )
+    lines.append("M  V30 END ATOM")
+    lines.append("M  V30 BEGIN BOND")
+    for idx, rec in enumerate(bond_records, start=1):
+        cfg = ""
+        if rec["stereo"] == 1:
+            cfg = " CFG=1"
+        elif rec["stereo"] == 6:
+            cfg = " CFG=3"
+        lines.append(f"M  V30 {idx} {rec['order']} {rec['a1']} {rec['a2']}{cfg}")
+    lines.append("M  V30 END BOND")
+    lines.append("M  V30 END CTAB")
+    lines.append("M  END")
+    return "\n".join(lines) + "\n"
+
+
 class MolecularData:
     """In-memory graph of atoms and bonds, independent of any UI framework."""
 
@@ -348,7 +435,7 @@ class MolecularData:
 
         # Counts line and bond indices must only reflect atoms actually written
         atom_map: Dict[int, int] = {}
-        atom_lines: List[str] = []
+        atom_records: List[Dict[str, Any]] = []
         for old_id, atom in self.atoms.items():
             # Convert scene pixel coordinates to angstroms when emitting MOL block
             pos = atom.get("pos")
@@ -362,37 +449,23 @@ class MolecularData:
             else:
                 continue
 
-            x, y = x_px * ANGSTROM_PER_PIXEL, y_px * ANGSTROM_PER_PIXEL
-            z, symbol = 0.0, atom["symbol"]
-            charge = atom.get("charge", 0)
-
-            chg_code = 0
-            if charge == 3:
-                chg_code = 1
-            elif charge == 2:
-                chg_code = 2
-            elif charge == 1:
-                chg_code = 3
-            elif charge == -1:
-                chg_code = 5
-            elif charge == -2:
-                chg_code = 6
-            elif charge == -3:
-                chg_code = 7
-
-            atom_map[old_id] = len(atom_lines)
-            atom_lines.append(
-                f"{x:10.4f}{y:10.4f}{z:10.4f} {symbol:<3} 0  0  0{chg_code:3d}  0  0  0  0  0  0  0\n"
+            atom_map[old_id] = len(atom_records)
+            atom_records.append(
+                {
+                    "x": x_px * ANGSTROM_PER_PIXEL,
+                    "y": y_px * ANGSTROM_PER_PIXEL,
+                    "symbol": atom["symbol"],
+                    "charge": int(atom.get("charge", 0) or 0),
+                    "radical": int(atom.get("radical", 0) or 0),
+                }
             )
 
-        bond_lines = []
+        bond_records: List[Dict[str, Any]] = []
         for (id1, id2), bond in self.bonds.items():
             if id1 not in atom_map or id2 not in atom_map:
                 continue
-            idx1, idx2 = atom_map[id1] + 1, atom_map[id2] + 1
-            # Bond order may be a float (1.5 = aromatic); V2000 uses code 4.
+            # Bond order may be a float (1.5 = aromatic); MDL uses code 4.
             order_val = float(bond["order"])
-            order = 4 if order_val == 1.5 else int(order_val)
             stereo_code = 0
             bond_stereo = bond.get("stereo", 0)
             if bond_stereo == 1:
@@ -400,16 +473,20 @@ class MolecularData:
             elif bond_stereo == 2:
                 stereo_code = 6
 
-            bond_lines.append(
-                f"{idx1:3d}{idx2:3d}{order:3d}{stereo_code:3d}  0  0  0\n"
+            bond_records.append(
+                {
+                    "a1": atom_map[id1] + 1,
+                    "a2": atom_map[id2] + 1,
+                    "order": 4 if order_val == 1.5 else int(order_val),
+                    "stereo": stereo_code,
+                }
             )
 
-        mol_block = "\n  MoleditPy\n\n"
-        mol_block += f"{len(atom_lines):3d}{len(bond_lines):3d}  0  0  0  0  0  0  0  0999 V2000\n"
-        mol_block += "".join(atom_lines)
-        mol_block += "".join(bond_lines)
-        mol_block += "M  END\n"
-        return mol_block
+        # V2000 packs the counts into three-character fields, so anything past
+        # 999 would run the atom count into the bond count and corrupt the file.
+        if len(atom_records) > 999 or len(bond_records) > 999:
+            return _to_v3000_block(atom_records, bond_records)
+        return _to_v2000_block(atom_records, bond_records)
 
     def to_template_dict(
         self, name: str, version: str = "1.0", application_version: str = ""

moleditpy_linux/main.py

@@ -189,7 +189,7 @@ def setup_logging() -> None:
         log_dir = os.path.join(os.path.expanduser("~"), ".moleditpy")
         try:
             os.makedirs(log_dir, exist_ok=True)
-            log_path = os.path.join(log_dir, "moleditpy_linux.log")
+            log_path = os.path.join(log_dir, "moleditpy.log")
             fh = logging.handlers.RotatingFileHandler(
                 log_path, maxBytes=1_048_576, backupCount=3, encoding="utf-8"
             )
@@ -231,7 +231,7 @@ def main() -> None:
     if sys.platform == "win32":
         # Taskbar grouping ID follows the major version
         major = VERSION.split(".")[0] if VERSION and VERSION != "Unknown" else "0"
-        myappid = f"hyoko.moleditpy_linux.{major}"
+        myappid = f"hyoko.moleditpy.{major}"
         ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
 
     parser = argparse.ArgumentParser(

moleditpy_linux/plugins/plugin_interface.py

@@ -11,7 +11,7 @@ DOI: 10.5281/zenodo.17268532
 """
 
 import logging
-from typing import Any, Callable, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 
 class PluginContext:
@@ -353,6 +353,28 @@ class PluginContext:
         """
         self._manager.register_document_reset_handler(self._plugin_name, callback)
 
+    def register_atom_drag_handler(
+        self,
+        callback: Callable[
+            [str, List[int], Dict[int, Tuple[float, float, float]]], None
+        ],
+    ) -> None:
+        """Register a handler called during 3D atom or group dragging.
+
+        The callback receives:
+            event_type (str): ``"start"``, ``"move"``, or ``"end"``.
+            atom_indices (List[int]): RDKit atom indices being dragged.
+            positions (dict[int, tuple[float, float, float]]):
+                Current 3D positions of the dragged atoms.
+                Empty dict on ``"start"``.
+        """
+        self._manager.register_atom_drag_handler(self._plugin_name, callback)
+
+    @property
+    def is_dragging_atom(self) -> bool:
+        """Return True if an atom or group is currently being dragged in 3D."""
+        return self._manager.is_dragging_atom()  # type: ignore[no-any-return]
+
     def get_setting(self, key: str, default: Any = None) -> Any:
         """
         Get a plugin-specific persistent setting.

moleditpy_linux/plugins/plugin_manager.py

@@ -23,8 +23,9 @@ from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from PyQt6.QtCore import QUrl
 from PyQt6.QtGui import QDesktopServices
-from PyQt6.QtWidgets import QMessageBox
+from PyQt6.QtWidgets import QApplication, QMessageBox
 
+from ..utils.constants import MOVE_DIALOG_TYPES
 from .plugin_interface import PluginContext
 
 
@@ -95,6 +96,7 @@ class PluginManager:
         self.load_handlers: Dict[str, Callable] = {}
         self.custom_3d_styles: Dict[str, Dict[str, Any]] = {}
         self.document_reset_handlers: List[Dict[str, Any]] = []
+        self.atom_drag_handlers: List[Dict[str, Any]] = []
         self.plugin_windows: Dict[
             str, Dict[str, Any]
         ] = {}  # Map of plugin_name -> {window_id -> window}
@@ -247,6 +249,7 @@ class PluginManager:
         self.load_handlers = {}
         self.custom_3d_styles = {}
         self.document_reset_handlers = []
+        self.atom_drag_handlers = []
 
         if not os.path.exists(self.plugin_dir):
             return []
@@ -558,6 +561,10 @@ class PluginManager:
             {"plugin": plugin_name, "callback": callback}
         )
 
+    def register_atom_drag_handler(self, plugin_name: str, callback: Callable) -> None:
+        """Register a handler called during 3D atom/group dragging."""
+        self.atom_drag_handlers.append({"plugin": plugin_name, "callback": callback})
+
     # --- New API Implementation ---
     def show_status_message(self, message: str, timeout: int = 3000) -> None:
         """Display a message in the MainWindow status bar."""
@@ -653,6 +660,48 @@ class PluginManager:
                     exc_info=True,
                 )
 
+    def invoke_atom_drag_handlers(
+        self,
+        event_type: str,
+        atom_indices: List[int],
+        positions: Dict[int, tuple],
+    ) -> None:
+        """Call all registered atom drag handlers."""
+        for handler in self.atom_drag_handlers:
+            try:
+                handler["callback"](event_type, atom_indices, positions)
+            except Exception as e:  # plugins have full app access; catch everything to keep the drag alive
+                logging.warning(
+                    "Error in atom drag handler for %s: %s",
+                    handler["plugin"],
+                    e,
+                    exc_info=True,
+                )
+
+    def is_dragging_atom(self) -> bool:
+        """Return True if an atom or group is currently being dragged in 3D."""
+        mw = self.main_window
+        if mw is None:
+            return False
+        if getattr(mw, "dragged_atom_info", None) is not None:
+            return True
+        return self._is_dragging_group()
+
+    @staticmethod
+    def _is_dragging_group() -> bool:
+        """Return True while a Move Group / Move Selected Atoms gesture is active."""
+        try:
+            for widget in QApplication.topLevelWidgets():
+                if type(widget).__name__ not in MOVE_DIALOG_TYPES:
+                    continue
+                if getattr(widget, "is_dragging_group_vtk", False) or getattr(
+                    widget, "is_rotating_group_vtk", False
+                ):
+                    return True
+        except (AttributeError, RuntimeError, TypeError):
+            logging.debug("Suppressed non-critical error", exc_info=True)
+        return False
+
     def get_plugin_info_safe(self, file_path: str) -> Dict[str, str]:
         """Extracts plugin metadata using AST parsing (safe, no execution)."""
         info = {

moleditpy_linux/ui/angle_dialog.py

@@ -35,6 +35,7 @@ from ..core.mol_geometry import (
     calc_angle_deg,
     get_connected_group,
 )
+from ..utils.suppress_log import suppress_log
 
 if TYPE_CHECKING:
     from .main_window import MainWindow
@@ -468,5 +469,26 @@ class AngleDialog(GeometryBaseDialog):
                 atoms_to_move,
             )
 
+        achieved = calc_angle_deg(positions[idx_a], positions[idx_b], positions[idx_c])
+
         # Write updated positions back using inherited helper
         self._update_molecule_geometry(positions)
+
+        self._warn_if_angle_not_applied(new_angle_deg, achieved)
+
+    def _warn_if_angle_not_applied(self, requested: float, achieved: float) -> None:
+        """Tell the user when the requested angle could not be reached.
+
+        For an angle inside a ring the connected group reached from one arm
+        comes back around and contains all three atoms, so they rotate
+        together and the angle is unchanged. Leaving the old value silently
+        looks like the edit was applied.
+        """
+        if abs(achieved - requested) < 0.5:
+            return
+        with suppress_log(AttributeError, RuntimeError, TypeError):
+            self.main_window.statusBar().showMessage(
+                f"Angle unchanged ({achieved:.2f} deg): the three atoms rotate "
+                "together, which happens for an angle inside a ring.",
+                5000,
+            )

moleditpy_linux/ui/atom_item.py

@@ -63,6 +63,8 @@ class AtomItem(QGraphicsItem):
         self.setFlags(
             QGraphicsItem.GraphicsItemFlag.ItemIsMovable
             | QGraphicsItem.GraphicsItemFlag.ItemIsSelectable
+            # Without this Qt never calls itemChange for moves, so bonds lag.
+            | QGraphicsItem.GraphicsItemFlag.ItemSendsGeometryChanges
         )
         self.setZValue(1)
         self.update_style()

moleditpy_linux/ui/bond_length_dialog.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 import logging
 
 import numpy as np
-from typing import Any, TYPE_CHECKING, Optional, Sequence
+from typing import Any, Dict, TYPE_CHECKING, Optional, Sequence
 
 from PyQt6.QtCore import Qt
 from PyQt6.QtWidgets import (
@@ -32,6 +32,7 @@ from rdkit import Chem
 
 from .geometry_base_dialog import GeometryBaseDialog
 from ..core.mol_geometry import calc_distance, get_connected_group
+from ..utils.suppress_log import suppress_log
 
 if TYPE_CHECKING:
     from .main_window import MainWindow
@@ -359,6 +360,8 @@ class BondLengthDialog(GeometryBaseDialog):
         if current_distance == 0:
             return
 
+        original = {i: np.array(p, dtype=float) for i, p in positions.items()}
+
         direction = direction / current_distance
 
         if self.both_groups_radio.isChecked():
@@ -400,3 +403,46 @@ class BondLengthDialog(GeometryBaseDialog):
 
         # Write updated positions back using inherited helper
         self._update_molecule_geometry(positions)
+
+        self._warn_if_other_bonds_moved(original, positions, idx1, idx2)
+
+    def _warn_if_other_bonds_moved(
+        self,
+        before: Dict[int, Any],
+        after: Dict[int, Any],
+        idx1: int,
+        idx2: int,
+    ) -> None:
+        """Report a neighbouring bond that this edit resized as a side effect.
+
+        A bond inside a ring cannot be resized alone: the group translated
+        along the bond axis wraps back around the ring, so the ring closes at
+        a different length. Stretching a benzene bond to 1.80 A pulls its
+        neighbour to 1.24 A, shorter than a double bond, with nothing on
+        screen to say so.
+        """
+        edited = {idx1, idx2}
+        worst_delta = 0.0
+        worst_label = ""
+        for bond in self.mol.GetBonds():
+            i, j = bond.GetBeginAtomIdx(), bond.GetEndAtomIdx()
+            if {i, j} == edited or i not in before or j not in before:
+                continue
+            delta = calc_distance(after[i], after[j]) - calc_distance(
+                before[i], before[j]
+            )
+            if abs(delta) > abs(worst_delta):
+                worst_delta = delta
+                worst_label = (
+                    f"{self.mol.GetAtomWithIdx(i).GetSymbol()}{i}-"
+                    f"{self.mol.GetAtomWithIdx(j).GetSymbol()}{j}"
+                )
+
+        if abs(worst_delta) < 1e-4:
+            return
+        with suppress_log(AttributeError, RuntimeError, TypeError):
+            self.main_window.statusBar().showMessage(
+                f"Bond {worst_label} also changed by {worst_delta:+.3f} A: a bond "
+                "inside a ring cannot be resized on its own.",
+                5000,
+            )

moleditpy_linux/ui/compute_logic.py

@@ -19,6 +19,7 @@ from PyQt6.QtCore import QThread, QTimer, QPoint
 from PyQt6.QtGui import QAction, QColor
 from PyQt6.QtWidgets import QMenu, QMessageBox, QWidget
 from rdkit import Chem
+from rdkit.Chem import AllChem
 
 from . import OBABEL_AVAILABLE
 
@@ -458,7 +459,31 @@ class ComputeManager:
         # Defer so Qt finishes routing the modal result before restoring focus.
         QTimer.singleShot(0, self.host.init_manager.view_2d.setFocus)
 
+    def _ez_consistent_mol_block(self) -> Optional[str]:
+        """MOL block whose 2D geometry encodes the editor's E/Z labels."""
+        data = self.host.state_manager.data
+        if not any(b.get("stereo", 0) in (3, 4) for b in data.bonds.values()):
+            return None
+        stereo_mol = data.to_rdkit_mol(use_2d_stereo=False)
+        if stereo_mol is None:
+            return None
+        try:
+            # MDL carries double-bond cis/trans only in the 2D coordinates, so a
+            # label that contradicts how the user drew the bond is lost unless
+            # the layout is rebuilt from the stereo. These coordinates only seed
+            # 3D generation; the 2D canvas keeps the user's own layout.
+            planar = Chem.Mol(stereo_mol)
+            planar.RemoveAllConformers()
+            AllChem.Compute2DCoords(planar)
+            return str(Chem.MolToMolBlock(planar, includeStereo=True))
+        except (RuntimeError, ValueError) as e:
+            logging.warning("E/Z-consistent 2D layout failed: %s", e)
+            return None
+
     def _setup_mol_block_for_worker(self, mol: Chem.Mol) -> str:
+        ez_block = self._ez_consistent_mol_block()
+        if ez_block:
+            return ez_block
         mol_block = self.host.state_manager.data.to_mol_block()
         if not mol_block:
             mol_block = Chem.MolToMolBlock(mol, includeStereo=True)