MoleditPy-linux 4.5.0__tar.gz → 4.5.1__tar.gz

{moleditpy_linux-4.5.0 → moleditpy_linux-4.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.5.0
+Version: 4.5.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.5.0 → moleditpy_linux-4.5.1}/pyproject.toml

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

{moleditpy_linux-4.5.0 → moleditpy_linux-4.5.1}/src/MoleditPy_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.5.0
+Version: 4.5.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.5.0 → moleditpy_linux-4.5.1}/src/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-4.5.0 → moleditpy_linux-4.5.1}/src/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-4.5.0 → moleditpy_linux-4.5.1}/src/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-4.5.0 → moleditpy_linux-4.5.1}/src/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-4.5.0 → moleditpy_linux-4.5.1}/src/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)

{moleditpy_linux-4.5.0 → moleditpy_linux-4.5.1}/src/moleditpy_linux/ui/dihedral_dialog.py

@@ -35,6 +35,7 @@ from ..core.mol_geometry import (
     calculate_dihedral,
     get_connected_group,
 )
+from ..utils.suppress_log import suppress_log
 
 if TYPE_CHECKING:
     from .main_window import MainWindow
@@ -469,5 +470,27 @@ class DihedralDialog(GeometryBaseDialog):
                 positions, idx1, idx2, idx3, idx4, new_dihedral_deg, atoms_to_move
             )
 
+        achieved = calculate_dihedral(positions, idx1, idx2, idx3, idx4)
+
         # Write updated positions back using inherited helper
         self._update_molecule_geometry(positions)
+
+        self._warn_if_torsion_not_applied(new_dihedral_deg, achieved)
+
+    def _warn_if_torsion_not_applied(self, requested: float, achieved: float) -> None:
+        """Tell the user when the requested torsion could not be reached.
+
+        A torsion inside a ring cannot rotate: the connected group reached from
+        one side comes back around and contains all four atoms, so they turn
+        together and the angle is unchanged. Silently leaving the old value
+        looks like the edit was applied.
+        """
+        difference = abs(achieved - requested) % 360.0
+        if min(difference, 360.0 - difference) < 0.5:
+            return
+        with suppress_log(AttributeError, RuntimeError, TypeError):
+            self.main_window.statusBar().showMessage(
+                f"Dihedral unchanged ({achieved:.2f}°): the four atoms rotate "
+                "together, which happens for a bond inside a ring.",
+                5000,
+            )

{moleditpy_linux-4.5.0 → moleditpy_linux-4.5.1}/src/moleditpy_linux/ui/edit_actions_logic.py

@@ -583,26 +583,17 @@ class EditActionsManager:
                 if orig_id not in self.host.state_manager.data.atoms:
                     continue
 
-                # Get implicit hydrogens; fallback to total - explicit
-                implicit_h = (
-                    int(rd_atom.GetNumImplicitHs())
-                    if hasattr(rd_atom, "GetNumImplicitHs")
-                    else 0
-                )
-                if implicit_h is None or implicit_h < 0:
+                # Hydrogens still needing an atom of their own. GetTotalNumHs()
+                # excludes H already drawn as atoms but includes the
+                # property-explicit H that sanitization assigns to an aromatic
+                # N-H; subtracting GetNumExplicitHs() here would cancel exactly
+                # that term and leave luminol's two N-H without hydrogens.
+                try:
+                    implicit_h = int(rd_atom.GetTotalNumHs())
+                except (AttributeError, RuntimeError, ValueError, TypeError):
+                    implicit_h = 0
+                if implicit_h < 0:
                     implicit_h = 0
-                if implicit_h == 0:
-                    # Fallback
-                    try:
-                        total_h = int(rd_atom.GetTotalNumHs())
-                        explicit_h = (
-                            int(rd_atom.GetNumExplicitHs())
-                            if hasattr(rd_atom, "GetNumExplicitHs")
-                            else 0
-                        )
-                        implicit_h = max(0, total_h - explicit_h)
-                    except (AttributeError, RuntimeError, ValueError, TypeError):
-                        implicit_h = 0
 
                 if implicit_h <= 0:
                     continue
@@ -954,12 +945,16 @@ class EditActionsManager:
                     continue
                 original_id = atom.GetIntProp("_original_atom_id")
 
-                # Robust retrieval of H counts: prefer implicit, fallback to total or 0
+                # GetTotalNumHs() counts implicit plus property-explicit H but
+                # not H drawn as its own atom, which is exactly what the label
+                # should show. Sanitization files an aromatic N-H (luminol,
+                # pyrrole) under the property, where GetNumImplicitHs() alone
+                # reports 0 and the H silently vanishes from the label.
                 try:
-                    h_count = int(atom.GetNumImplicitHs())
+                    h_count = int(atom.GetTotalNumHs())
                 except (AttributeError, RuntimeError, ValueError, TypeError):
                     try:
-                        h_count = int(atom.GetTotalNumHs())
+                        h_count = int(atom.GetNumImplicitHs())
                     except (AttributeError, RuntimeError, ValueError, TypeError):
                         h_count = 0
 

{moleditpy_linux-4.5.0 → moleditpy_linux-4.5.1}/src/moleditpy_linux/ui/io_logic.py

@@ -152,8 +152,11 @@ class IOManager:
 
     def _mol_from_xyz_lines(self, raw_lines: list[str]) -> Any:
         """Create an RDKit molecule from XYZ text lines."""
-        lines = [ln.strip() for ln in raw_lines if not ln.strip().startswith("#")]
-        while lines and not lines[0]:
+        lines = [ln.strip() for ln in raw_lines]
+        # Only leading comments are metadata. In a headed XYZ the second line is
+        # the title and may itself begin with '#', so discarding every '#' line
+        # would shift the atom rows up one and silently drop the first atom.
+        while lines and (not lines[0] or lines[0].startswith("#")):
             lines.pop(0)
 
         if not lines:
@@ -167,9 +170,11 @@ class IOManager:
             if num_atoms == 0:
                 raise ValueError("XYZ file has zero atoms")
         except ValueError as exc:
-            # Not a standard headed XYZ — treat all lines as atom rows
+            # Not a standard headed XYZ — treat all lines as atom rows. There is
+            # no title line here, so interleaved comments are safe to drop.
             if "zero atoms" in str(exc) or "too few" in str(exc):
                 raise
+            lines = [ln for ln in lines if ln and not ln.startswith("#")]
             num_atoms = len(lines)
             atom_start = 0
 
@@ -442,6 +447,7 @@ class IOManager:
         num_atoms = mol.GetNumAtoms()
         bonds_added = []
 
+        candidates = []
         for i in range(num_atoms):
             for j in range(i + 1, num_atoms):
                 atom_i = mol.GetAtomWithIdx(i)
@@ -456,21 +462,27 @@ class IOManager:
                 expected = radius_i + radius_j
                 tolerance = 1.2 if (symbol_i == "H" or symbol_j == "H") else 1.3
                 if expected * 0.5 <= distance <= expected * tolerance:
-                    if mol.GetBondBetweenAtoms(i, j) is None:
-                        if (
-                            symbol_i == "H" and mol.GetAtomWithIdx(i).GetDegree() >= 1
-                        ) or (
-                            symbol_j == "H" and mol.GetAtomWithIdx(j).GetDegree() >= 1
-                        ):
-                            continue
-                        try:
-                            mol.AddBond(i, j, Chem.BondType.SINGLE)
-                            bonds_added.append((i, j, distance))
-                        except (RuntimeError, ValueError, TypeError):
-                            # Safe defensive fallback catching RuntimeError, ValueError, TypeError
-                            logging.debug(
-                                "Suppressed non-critical error", exc_info=True
-                            )
+                    candidates.append((distance, i, j, symbol_i, symbol_j))
+
+        # Nearest pairs first. The monovalent-H rule below accepts whichever
+        # partner it sees first, so index order would otherwise decide the
+        # connectivity and the same geometry could bond an H differently
+        # depending only on how the file happened to list its atoms.
+        candidates.sort(key=lambda c: c[0])
+
+        for distance, i, j, symbol_i, symbol_j in candidates:
+            if mol.GetBondBetweenAtoms(i, j) is not None:
+                continue
+            if (symbol_i == "H" and mol.GetAtomWithIdx(i).GetDegree() >= 1) or (
+                symbol_j == "H" and mol.GetAtomWithIdx(j).GetDegree() >= 1
+            ):
+                continue
+            try:
+                mol.AddBond(i, j, Chem.BondType.SINGLE)
+                bonds_added.append((i, j, distance))
+            except (RuntimeError, ValueError, TypeError):
+                # Safe defensive fallback catching RuntimeError, ValueError, TypeError
+                logging.debug("Suppressed non-critical error", exc_info=True)
 
         return len(bonds_added)
 
@@ -816,6 +828,7 @@ class IOManager:
                     atom.GetSymbol(),
                     QPointF(scene_x, scene_y),
                     charge=atom.GetFormalCharge(),
+                    radical=atom.GetNumRadicalElectrons(),
                 )
                 rdkit_idx_to_my_id[i] = atom_id
 

{moleditpy_linux-4.5.0 → moleditpy_linux-4.5.1}/src/moleditpy_linux/ui/settings_tabs/settings_other_tab.py

@@ -117,10 +117,10 @@ class SettingsOtherTab(SettingsTabBase):
 
         self.log_to_file_checkbox = QCheckBox()
         self.log_to_file_checkbox.setToolTip(
-            "Save application log to ~/.moleditpy/moleditpy_linux.log (rotated, max 1 MB × 3)."
+            "Save application log to ~/.moleditpy/moleditpy.log (rotated, max 1 MB × 3)."
         )
         form_layout.addRow(
-            "Save log to file (~/.moleditpy/moleditpy_linux.log):", self.log_to_file_checkbox
+            "Save log to file (~/.moleditpy/moleditpy.log):", self.log_to_file_checkbox
         )
 
         self.log_level_debug_checkbox = QCheckBox()

{moleditpy_linux-4.5.0 → moleditpy_linux-4.5.1}/src/moleditpy_linux/ui/string_importers.py

@@ -119,6 +119,7 @@ class StringImporterManager:
                 atom.GetSymbol(),
                 QPointF(scene_x, scene_y),
                 charge=atom.GetFormalCharge(),
+                radical=atom.GetNumRadicalElectrons(),
             )
             rdkit_idx_to_my_id[i] = atom_id
         return rdkit_idx_to_my_id