MoleditPy-linux 4.1.1__tar.gz → 4.1.3__tar.gz

{moleditpy_linux-4.1.1 → moleditpy_linux-4.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.1.1
+Version: 4.1.3
 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.1.1 → moleditpy_linux-4.1.3}/pyproject.toml

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

{moleditpy_linux-4.1.1 → moleditpy_linux-4.1.3}/src/MoleditPy_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.1.1
+Version: 4.1.3
 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.1.1 → moleditpy_linux-4.1.3}/src/moleditpy_linux/__init__.py

@@ -8,8 +8,6 @@ Author: Hiromichi Yokoyama
 License: GPL-3.0 license
 Repo: https://github.com/HiroYokoyama/python_molecular_editor
 DOI: 10.5281/zenodo.17268532
-
-Top-level package for moleditpy_linux.
 """
 
 import importlib.util  # noqa: F401

{moleditpy_linux-4.1.1 → moleditpy_linux-4.1.3}/src/moleditpy_linux/plugins/plugin_interface.py

@@ -190,11 +190,9 @@ class PluginContext:
         Get or set the current molecule (RDKit Mol object). Shortcut for current_molecule.
         """
         mw = self.get_main_window()
-        return (
-            mw.view_3d_manager.current_mol
-            if mw and hasattr(mw, "view_3d_manager")
-            else None
-        )
+        if mw and hasattr(mw, "view_3d_manager"):
+            return mw.view_3d_manager.current_mol
+        return None
 
     @current_mol.setter
     def current_mol(self, mol: Any) -> None:
@@ -499,6 +497,17 @@ class PluginContext:
         if mw and hasattr(mw, "string_importer_manager"):
             mw.string_importer_manager.load_from_smiles(smiles)
 
+    def show_xyz_data(
+        self, xyz_text: str, source_name: str = "XYZ data"
+    ) -> Optional[Any]:
+        """Display XYZ text in the 3D viewer and return the loaded RDKit Mol."""
+        mw = self.get_main_window()
+        if mw and hasattr(mw, "io_manager"):
+            show = getattr(mw.io_manager, "show_xyz_data", None)
+            if show is not None:
+                return show(xyz_text, source_name=source_name)
+        return None
+
     def to_xyz_block(self) -> Optional[str]:
         """Return the current 3D structure as an XYZ block (only element x y z lines)."""
         mol = self.current_mol

{moleditpy_linux-4.1.1 → moleditpy_linux-4.1.3}/src/moleditpy_linux/plugins/plugin_manager.py

@@ -588,7 +588,8 @@ class PluginManager:
                         selected_atom_ids.add(item.atom_id)
 
                 # Now map these editor IDs to RDKit indices
-                mol = getattr(self.main_window, "current_mol", None)
+                v3d = getattr(self.main_window, "view_3d_manager", None)
+                mol = v3d.current_mol if v3d else None
                 if mol and selected_atom_ids:
                     for i in range(mol.GetNumAtoms()):
                         atom = mol.GetAtomWithIdx(i)

{moleditpy_linux-4.1.1 → moleditpy_linux-4.1.3}/src/moleditpy_linux/ui/io_logic.py

@@ -34,7 +34,7 @@ from PyQt6.QtWidgets import (
 from rdkit import Chem
 from rdkit.Chem import AllChem, rdGeometry, rdMolTransforms, Descriptors
 
-from ..utils.constants import COVALENT_RADII, VERSION
+from ..utils.constants import COVALENT_RADII, DUMMY_XYZ_SYMBOLS, VERSION
 
 
 class IOManager:
@@ -84,139 +84,210 @@ class IOManager:
         lines[3] = self.fix_mol_counts_line(lines[3])
         return "\n".join(lines)
 
-    def load_xyz_file(self, file_path: str) -> Optional[Any]:
-        """Load XYZ file and create RDKit Mol with charge prompt and bond determination."""
-        if not self.host.state_manager.check_unsaved_changes():
-            return None
-
+    def _normalize_xyz_symbol(self, raw_symbol: str) -> Tuple[str, bool]:
+        """Return the RDKit symbol for an XYZ atom and whether it is a dummy."""
+        stripped = raw_symbol.strip()
+        if ":" in stripped:
+            return "*", True
+        if stripped.upper() in DUMMY_XYZ_SYMBOLS:
+            return "*", True
+        symbol = stripped.capitalize()
+        try:
+            atomic_num = Chem.GetPeriodicTable().GetAtomicNumber(symbol)
+        except (RuntimeError, ValueError, TypeError):
+            return "*", True
+        if atomic_num <= 0:
+            return "*", True
+        return symbol, False
+
+    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.pop(0)
+
+        if not lines:
+            raise ValueError("XYZ file format error: too few lines")
+
+        atom_start = 2
         try:
-            with open(file_path, "r", encoding="utf-8") as f:
-                raw_lines = f.readlines()
-
-            lines = [ln.strip() for ln in raw_lines if not ln.strip().startswith("#")]
-            while lines and not lines[0]:
-                lines.pop(0)
-
             if len(lines) < 2:
                 raise ValueError("XYZ file format error: too few lines")
-
             num_atoms = int(lines[0])
             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
+            if "zero atoms" in str(exc) or "too few" in str(exc):
+                raise
+            num_atoms = len(lines)
+            atom_start = 0
+
+        atoms_data = []
+        has_dummy_atoms = False
+        atom_lines = lines[atom_start : atom_start + num_atoms]
+        if len(atom_lines) < num_atoms:
+            raise ValueError("XYZ file format error: fewer atom rows than expected")
+
+        for i, line in enumerate(atom_lines):
+            parts = line.split()
+            if len(parts) < 4:
+                raise ValueError(f"Invalid atom data at line {atom_start + i + 1}")
+            raw_symbol = parts[0]
+            symbol, is_dummy = self._normalize_xyz_symbol(raw_symbol)
+            has_dummy_atoms = has_dummy_atoms or is_dummy
+            atoms_data.append(
+                (symbol, float(parts[1]), float(parts[2]), float(parts[3]))
+            )
 
-            atoms_data = []
-            for i, line in enumerate(lines[2 : 2 + num_atoms]):
-                parts = line.split()
-                if len(parts) < 4:
-                    raise ValueError(f"Invalid atom data at line {i + 3}")
-                symbol = parts[0].capitalize()
-                try:
-                    Chem.Atom(symbol)
-                except (RuntimeError, ValueError):
-                    settings = self.host.init_manager.settings
-                    if settings.get("skip_chemistry_checks", False):
-                        symbol = "C"
-                    else:
-                        raise ValueError(f"Unrecognized element symbol: {parts[0]}")
-                atoms_data.append(
-                    (symbol, float(parts[1]), float(parts[2]), float(parts[3]))
-                )
-
-            if not atoms_data:
-                raise ValueError("No valid atoms found in XYZ file")
+        if not atoms_data:
+            raise ValueError("No valid atoms found in XYZ file")
 
-            mol = Chem.RWMol()
-            conf = Chem.Conformer(len(atoms_data))
-            for i, (symbol, x, y, z) in enumerate(atoms_data):
-                atom = Chem.Atom(symbol)
-                atom.SetIntProp("xyz_unique_id", i)
-                mol.AddAtom(atom)
-                conf.SetAtomPosition(i, rdGeometry.Point3D(x, y, z))
-            mol.AddConformer(conf)
+        mol = Chem.RWMol()
+        conf = Chem.Conformer(len(atoms_data))
+        for i, (symbol, x, y, z) in enumerate(atoms_data):
+            atom = Chem.Atom(symbol)
+            atom.SetIntProp("xyz_unique_id", i)
+            if atom.GetAtomicNum() == 0:
+                atom.SetProp("xyz_original_symbol", atom_lines[i].split()[0])
+            mol.AddAtom(atom)
+            conf.SetAtomPosition(i, rdGeometry.Point3D(x, y, z))
+        mol.AddConformer(conf)
 
-            settings = self.host.init_manager.settings
-            skip_checks = bool(settings.get("skip_chemistry_checks", False))
+        settings = self.host.init_manager.settings
+        skip_checks = bool(settings.get("skip_chemistry_checks", False))
 
-            def _set_prop(m: Chem.Mol, key: str, val: Any) -> None:
+        def _set_prop(m: Chem.Mol, key: str, val: Any) -> None:
+            try:
+                if isinstance(val, int):
+                    m.SetIntProp(key, val)
+                elif isinstance(val, float):
+                    m.SetDoubleProp(key, val)
+            except (RuntimeError, TypeError, ValueError):
+                # Safe defensive fallback catching RuntimeError, TypeError, ValueError
+                pass
+
+        def _process(charge_val: int, use_rd_determine: bool = True) -> Any:
+            if use_rd_determine:
                 try:
-                    if isinstance(val, int):
-                        m.SetIntProp(key, val)
-                    elif isinstance(val, float):
-                        m.SetDoubleProp(key, val)
-                except (RuntimeError, TypeError, ValueError):
-                    # Safe defensive fallback catching RuntimeError, TypeError, ValueError
-                    pass
-
-            def _process(charge_val: int, use_rd_determine: bool = True) -> Any:
-                if use_rd_determine:
-                    try:
-                        from rdkit.Chem import rdDetermineBonds
+                    from rdkit.Chem import rdDetermineBonds
 
-                        mol_copy = Chem.RWMol(mol)
-                        rdDetermineBonds.DetermineBonds(mol_copy, charge=charge_val)
-                        candidate = mol_copy.GetMol()
-                        _set_prop(candidate, "_xyz_charge", charge_val)
-                        return candidate
-                    except (RuntimeError, ValueError, TypeError) as e:
-                        raise e
-                else:
-                    self.estimate_bonds_from_distances(mol)
-                    candidate = mol.GetMol()
+                    mol_copy = Chem.RWMol(mol)
+                    rdDetermineBonds.DetermineBonds(mol_copy, charge=charge_val)
+                    candidate = mol_copy.GetMol()
                     _set_prop(candidate, "_xyz_charge", charge_val)
                     return candidate
-
-            if skip_checks:
-                final_mol = _process(0, use_rd_determine=False)
-                _set_prop(final_mol, "_xyz_skip_checks", 1)
+                except (RuntimeError, ValueError, TypeError):
+                    raise
             else:
-                final_mol = None
-                settings = self.host.init_manager.settings
-                # First try with charge 0 (per user's 'first try with 0 then ask' requirement)
-                # but only if "Always ask" is not explicitly enabled in settings.
-                if not settings.get("always_ask_charge", False):
-                    try:
-                        final_mol = _process(0, use_rd_determine=True)
-                    except (RuntimeError, ValueError, TypeError):
-                        final_mol = None
-
-                # If still no final_mol (because always_ask is True, or charge 0 failed)
-                if final_mol is None:
-                    while True:
-                        prompt_fn = getattr(self, "prompt_for_charge", None)
-                        if callable(prompt_fn):
-                            result = prompt_fn()
-                            if isinstance(result, tuple) and len(result) == 3:
-                                charge_val, ok, skip_flag = result
-                            else:
-                                charge_val, ok, skip_flag = 0, True, False
+                self.estimate_bonds_from_distances(mol)
+                candidate = mol.GetMol()
+                _set_prop(candidate, "_xyz_charge", charge_val)
+                return candidate
+
+        if skip_checks or has_dummy_atoms:
+            final_mol = _process(0, use_rd_determine=False)
+            _set_prop(final_mol, "_xyz_skip_checks", 1)
+        else:
+            final_mol = None
+            # First try with charge 0 (per user's 'first try with 0 then ask' requirement)
+            # but only if "Always ask" is not explicitly enabled in settings.
+            if not settings.get("always_ask_charge", False):
+                try:
+                    final_mol = _process(0, use_rd_determine=True)
+                except (RuntimeError, ValueError, TypeError):
+                    final_mol = None
+
+            # If still no final_mol (because always_ask is True, or charge 0 failed)
+            if final_mol is None:
+                while True:
+                    prompt_fn = getattr(self, "prompt_for_charge", None)
+                    if callable(prompt_fn):
+                        result = prompt_fn()
+                        if isinstance(result, tuple) and len(result) == 3:
+                            charge_val, ok, skip_flag = result
                         else:
                             charge_val, ok, skip_flag = 0, True, False
+                    else:
+                        charge_val, ok, skip_flag = 0, True, False
+
+                    if not ok:
+                        return None
+                    if skip_flag:
+                        final_mol = _process(0, use_rd_determine=False)
+                        _set_prop(final_mol, "_xyz_skip_checks", 1)
+                        break
+                    try:
+                        final_mol = _process(charge_val, use_rd_determine=True)
+                        break
+                    except (RuntimeError, ValueError, TypeError) as e:
+                        if self.host.statusBar():
+                            self.host.statusBar().showMessage(
+                                f"Chemistry failed for charge {charge_val}: {e}. Try a different charge or skip."
+                            )
+                        if not callable(prompt_fn):
+                            raise e
 
-                        if not ok:
-                            return None
-                        if skip_flag:
-                            final_mol = _process(0, use_rd_determine=False)
-                            _set_prop(final_mol, "_xyz_skip_checks", 1)
-                            break
-                        try:
-                            final_mol = _process(charge_val, use_rd_determine=True)
-                            break
-                        except (RuntimeError, ValueError, TypeError) as e:
-                            if self.host.statusBar():
-                                self.host.statusBar().showMessage(
-                                    f"Chemistry failed for charge {charge_val}: {e}. Try a different charge or skip."
-                                )
-                            if not callable(prompt_fn):
-                                raise e
-
-                if final_mol:
-                    final_mol.xyz_atom_data = atoms_data
-            return final_mol
+        if final_mol:
+            final_mol.xyz_atom_data = atoms_data
+        return final_mol
+
+    def load_xyz_file(self, file_path: str) -> Optional[Any]:
+        """Load XYZ file and create RDKit Mol with charge prompt and bond determination."""
+        if not self.host.state_manager.check_unsaved_changes():
+            return None
 
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                return self._mol_from_xyz_lines(f.readlines())
         except (RuntimeError, TypeError, ValueError, UnicodeDecodeError) as e:
             self.host.statusBar().showMessage(f"Error parsing XYZ file: {e}")
             return None
 
+    def load_xyz_block(self, xyz_text: str) -> Optional[Any]:
+        """Load XYZ text and create an RDKit Mol without opening a file dialog."""
+        try:
+            return self._mol_from_xyz_lines(xyz_text.splitlines())
+        except (RuntimeError, TypeError, ValueError, UnicodeDecodeError) as e:
+            self.host.statusBar().showMessage(f"Error parsing XYZ data: {e}")
+            return None
+
+    def show_xyz_data(
+        self, xyz_text: str, source_name: str = "XYZ data"
+    ) -> Optional[Any]:
+        """Load XYZ text, set it as the current molecule, and draw it in 3D."""
+        try:
+            mol = self.load_xyz_block(xyz_text)
+            if mol is None:
+                return None
+
+            self.host.edit_actions_manager.clear_all(skip_check=True)
+            self.host.set_current_molecule(mol)
+            self.host.set_atom_id_to_rdkit_idx_map({})
+
+            skip_flag = False
+            if mol.HasProp("_xyz_skip_checks"):
+                skip_flag = bool(mol.GetIntProp("_xyz_skip_checks"))
+            self.host.is_xyz_derived = skip_flag or (mol.GetNumBonds() == 0)
+
+            self.host.view_3d_manager.draw_molecule_3d(mol)
+            self.host.ui_manager.enter_3d_viewer_mode()
+            self.host.ui_manager.enable_3d_features(True)
+            self.host.view_3d_manager.update_atom_id_menu_text()
+            self.host.view_3d_manager.update_atom_id_menu_state()
+
+            if self.host.statusBar():
+                self.host.statusBar().showMessage(
+                    f"3D Viewer Mode: Loaded {source_name}"
+                )
+            self.host.set_has_unsaved_changes(False)
+            self.host.state_manager.update_window_title()
+            return mol
+        except (RuntimeError, TypeError, ValueError, AttributeError) as e:
+            if self.host.statusBar():
+                self.host.statusBar().showMessage(f"XYZ display failed: {e}")
+            return None
+
     def prompt_for_charge(self) -> Tuple[Optional[int], bool, bool]:
         """Show dialog to prompt user for molecular charge when loading XYZ files."""
         dialog = QDialog(self.host)
@@ -261,6 +332,8 @@ class IOManager:
             for j in range(i + 1, num_atoms):
                 atom_i = mol.GetAtomWithIdx(i)
                 atom_j = mol.GetAtomWithIdx(j)
+                if atom_i.GetAtomicNum() == 0 or atom_j.GetAtomicNum() == 0:
+                    continue
                 distance = rdMolTransforms.GetBondLength(conf, i, j)
                 symbol_i = atom_i.GetSymbol()
                 symbol_j = atom_j.GetSymbol()

{moleditpy_linux-4.1.1 → moleditpy_linux-4.1.3}/src/moleditpy_linux/ui/main_window.py

@@ -19,6 +19,7 @@ if TYPE_CHECKING:
     from rdkit import Chem
 
 # PyQt6 Modules
+import copy
 from PyQt6.QtCore import pyqtSignal
 from PyQt6.QtWidgets import QMainWindow, QMessageBox
 
@@ -254,8 +255,6 @@ class MainWindow(QMainWindow):
 
     def save_state_snapshot(self) -> None:
         """Create a deep copy snapshot of the current state for undo/redo comparison."""
-        import copy
-
         try:
             self.state_manager.saved_state = copy.deepcopy(
                 self.state_manager.get_current_state()

{moleditpy_linux-4.1.1 → moleditpy_linux-4.1.3}/src/moleditpy_linux/ui/move_selected_atoms_dialog.py

@@ -56,6 +56,8 @@ class MoveSelectedAtomsDialog(BasePickingDialog):
         self.mouse_moved_during_drag: bool = False
         self._consume_next_left_release: bool = False
         self.highlight_actor: Optional[pv.Actor] = None
+        self.original_style: Optional[Any] = None
+        self.rubber_band_style: Optional[Any] = None
 
         self.widgets: dict[str, Any] = {}
 
@@ -211,6 +213,13 @@ class MoveSelectedAtomsDialog(BasePickingDialog):
     def _init_buttons_ui(self, layout: QVBoxLayout) -> None:
         """Initialize bottom buttons."""
         button_layout = QHBoxLayout()
+
+        box_select_btn = QPushButton("Box Selection: OFF")
+        box_select_btn.setCheckable(True)
+        box_select_btn.clicked.connect(self.toggle_box_selection)
+        self.widgets["box_select_btn"] = box_select_btn
+        button_layout.addWidget(box_select_btn)
+
         clear_btn = QPushButton("Clear Selection")
         clear_btn.clicked.connect(self.clear_selection)
         self.widgets["clear_button"] = clear_btn
@@ -238,6 +247,24 @@ class MoveSelectedAtomsDialog(BasePickingDialog):
 
         e_type = event.type()
 
+        btn = self.widgets.get("box_select_btn")
+        box_selection_on = btn is not None and btn.isChecked()
+
+        if e_type == QEvent.Type.MouseButtonPress:
+            self._click_press_pos = getattr(event, "pos", lambda: None)()
+        elif e_type == QEvent.Type.MouseButtonRelease:
+            if hasattr(self, "_click_press_pos") and self._click_press_pos is not None:
+                pos = getattr(event, "pos", lambda: None)()
+                if pos:
+                    diff = pos - self._click_press_pos
+                    if diff.manhattanLength() < 3:
+                        if box_selection_on:
+                            self.clear_selection()
+            self._click_press_pos = None
+
+        if box_selection_on:
+            return False
+
         if e_type == QEvent.Type.MouseButtonDblClick:
             # Ignore double clicks and reset state
             self.is_dragging_group = False
@@ -645,3 +672,78 @@ class MoveSelectedAtomsDialog(BasePickingDialog):
         self.update_display()
         self.is_dragging_group = False
         self.drag_start_pos = None
+
+    def toggle_box_selection(self, checked: bool) -> None:
+        """Toggle Box Selection mode using PyVista's rectangle picker."""
+        plotter = self.main_window.view_3d_manager.plotter
+        if plotter is None or plotter.interactor is None:
+            return
+
+        btn = self.widgets["box_select_btn"]
+        if checked:
+            btn.setText("Box Selection: ON")
+            # Save original style if not saved
+            if self.original_style is None:
+                self.original_style = plotter.interactor.GetInteractorStyle()
+
+            # Using PyVista's built-in picking which reliably draws the box correctly
+            plotter.enable_rectangle_picking(
+                callback=self.on_rectangle_picked,
+                show_message=False,
+                start=True,
+                color="red",
+            )
+        else:
+            btn.setText("Box Selection: OFF")
+            plotter.disable_picking()
+            # Restore original style
+            if self.original_style is not None:
+                plotter.interactor.SetInteractorStyle(self.original_style)
+                self.rubber_band_style = None
+
+    def on_rectangle_picked(self, selection: Any) -> None:
+        """Handle PyVista rectangle picking callback."""
+        if not hasattr(selection, "viewport"):
+            return
+
+        x0, y0, x1, y1 = selection.viewport
+        x_min = min(x0, x1)
+        x_max = max(x0, x1)
+        y_min = min(y0, y1)
+        y_max = max(y0, y1)
+
+        # If the drag box is small, treat it as a single click to clear selection
+        if abs(x_max - x_min) < 15 and abs(y_max - y_min) < 15:
+            self.clear_selection()
+            return
+
+        plotter = self.main_window.view_3d_manager.plotter
+        if plotter is None:
+            return
+        renderer = plotter.renderer
+
+        positions = self.main_window.view_3d_manager.atom_positions_3d
+        if positions is not None:
+            added = False
+            for atom_idx, pos in enumerate(positions):
+                renderer.SetWorldPoint(float(pos[0]), float(pos[1]), float(pos[2]), 1.0)
+                renderer.WorldToDisplay()
+                display = renderer.GetDisplayPoint()
+
+                if x_min <= display[0] <= x_max and y_min <= display[1] <= y_max:
+                    if atom_idx not in self.selected_atoms:
+                        self.selected_atoms.add(atom_idx)
+                        added = True
+
+            if added:
+                self.show_atom_labels()
+                self.update_display()
+
+    def reject(self) -> None:
+        """Clean up when dialog closes."""
+        # Ensure we restore the interactor style if it was left in Box Selection mode
+        btn = self.widgets.get("box_select_btn")
+        if btn and btn.isChecked():
+            btn.setChecked(False)
+            self.toggle_box_selection(False)
+        super().reject()

{moleditpy_linux-4.1.1 → moleditpy_linux-4.1.3}/src/moleditpy_linux/ui/view_3d_logic.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 """
-MoleditPy  EA Python-based molecular editing software
+MoleditPy — A Python-based molecular editing software
 
 Author: Hiromichi Yokoyama
 License: GPL-3.0 license

moleditpy_linux-4.1.3/src/moleditpy_linux/utils/__init__.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+MoleditPy — A Python-based molecular editing software
+
+Author: Hiromichi Yokoyama
+License: GPL-3.0 license
+Repo: https://github.com/HiroYokoyama/python_molecular_editor
+DOI: 10.5281/zenodo.17268532
+"""

{moleditpy_linux-4.1.1 → moleditpy_linux-4.1.3}/src/moleditpy_linux/utils/constants.py

@@ -55,6 +55,11 @@ BOND_OFFSET = 3.5
 DEFAULT_BOND_LENGTH = 75  # Standard bond length used in templates
 CLIPBOARD_MIME_TYPE = "application/x-moleditpy-fragment"
 
+# XYZ dummy/pseudo-atom labels that map to RDKit wildcard atom (*)
+DUMMY_XYZ_SYMBOLS: frozenset[str] = frozenset(
+    {"*", "-", "X", "DA", "DU", "DUM", "DUMMY", "Q", "BQ", "LP"}
+)
+
 # Physical bond length (approximate) used to convert scene pixels to angstroms.
 # DEFAULT_BOND_LENGTH is the length in pixels used in the editor UI for a typical bond.
 # Many molecular file formats expect coordinates in angstroms; use ~1.5 Å as a typical single-bond length.