molify 0.2.7__tar.gz → 0.2.8__tar.gz

{molify-0.2.7 → molify-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: molify
-Version: 0.2.7
+Version: 0.2.8
 Summary: Molecular Structure Interface with RDKit, ASE, Packmol and NetworkX
 Project-URL: Repository, https://github.com/zincware/molify
 Project-URL: Releases, https://github.com/zincware/molify/releases

{molify-0.2.7 → molify-0.2.8}/docs/source/index.rst

@@ -124,7 +124,6 @@ For example, molify provides helper functions to generate 3D conformers directly
    # Generate 10 different 3D conformers of water
    water = molify.smiles2conformers("O", numConfs=10)
 
-
 **Molecular System Building**
 
 For many applications, it is useful to solvate molecules or create mixtures.

{molify-0.2.7 → molify-0.2.8}/src/molify/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.7'
-__version_tuple__ = version_tuple = (0, 2, 7)
+__version__ = version = '0.2.8'
+__version_tuple__ = version_tuple = (0, 2, 8)
 
 __commit_id__ = commit_id = None

{molify-0.2.7 → molify-0.2.8}/src/molify/cli.py

@@ -86,13 +86,23 @@ def smiles2atoms(
     seed: Annotated[
         int, typer.Option(help="Random seed for conformer generation.")
     ] = 42,
+    random_coords: Annotated[
+        bool,
+        typer.Option(
+            "--random-coords",
+            help=(
+                "Start the embedding from random coordinates, which long chains"
+                " such as n-alkanes from about C56 on often need."
+            ),
+        ),
+    ] = False,
 ) -> None:
     """Convert a SMILES string into a single 3D structure on standard output.
 
     Example: molify smiles2atoms CCO --format XYZ > etoh.xyz
     """
     try:
-        atoms = _smiles2atoms(smiles, seed=seed)
+        atoms = _smiles2atoms(smiles, seed=seed, useRandomCoords=random_coords)
     except ValueError as err:
         raise typer.BadParameter(str(err), param_hint=["smiles"]) from err
     with io.StringIO() as handle:

{molify-0.2.7 → molify-0.2.8}/src/molify/rdkit2x.py

@@ -1,12 +1,16 @@
 import ase
 import networkx as nx
 from rdkit import Chem
-from rdkit.Chem import AllChem
 
 from molify.constants import EdgeAttr, GraphAttr, NodeAttr
+from molify.utils import embed_conformers
 
 
-def rdkit2ase(mol: Chem.Mol, seed: int = 42) -> ase.Atoms:
+def rdkit2ase(
+    mol: Chem.Mol,
+    seed: int = 42,
+    useRandomCoords: bool = False,  # noqa N803
+) -> ase.Atoms:
     """Convert an RDKit molecule to an ASE Atoms object.
 
     Parameters
@@ -15,6 +19,10 @@ def rdkit2ase(mol: Chem.Mol, seed: int = 42) -> ase.Atoms:
         RDKit molecule to convert
     seed : int, optional
         Random seed for conformer generation (default is 42)
+    useRandomCoords : bool, optional
+        Start the embedding from random coordinates instead of the eigenvectors
+        of the distance matrix (default is False). Long chains, such as
+        n-alkanes from about C56 on, often embed only this way.
 
     Returns
     -------
@@ -26,6 +34,11 @@ def rdkit2ase(mol: Chem.Mol, seed: int = 42) -> ase.Atoms:
         - Formal charges if present
         - SMILES string in atoms.info
 
+    Raises
+    ------
+    ValueError
+        If RDKit fails to embed ``mol``.
+
     Examples
     --------
     >>> from rdkit import Chem
@@ -41,7 +54,7 @@ def rdkit2ase(mol: Chem.Mol, seed: int = 42) -> ase.Atoms:
     smiles = Chem.MolToSmiles(mol)
     mol = Chem.AddHs(mol)
     charges = [atom.GetFormalCharge() for atom in mol.GetAtoms()]
-    AllChem.EmbedMolecule(mol, randomSeed=seed)
+    embed_conformers(mol, smiles, 1, seed, 0, useRandomCoords)
 
     atoms = ase.Atoms(
         positions=mol.GetConformer().GetPositions(),

{molify-0.2.7 → molify-0.2.8}/src/molify/smiles2x.py

@@ -1,9 +1,9 @@
 import ase
 import numpy as np
 from rdkit import Chem
-from rdkit.Chem import rdDistGeom
 
 from molify.constants import GraphAttr
+from molify.utils import embed_conformers
 
 
 def get_pf6() -> ase.Atoms:
@@ -32,7 +32,11 @@ def get_pf6() -> ase.Atoms:
     return atoms
 
 
-def smiles2atoms(smiles: str, seed: int = 42) -> ase.Atoms:
+def smiles2atoms(
+    smiles: str,
+    seed: int = 42,
+    useRandomCoords: bool = False,  # noqa N803
+) -> ase.Atoms:
     """Convert a SMILES string to an ASE Atoms object.
 
     Parameters
@@ -41,6 +45,10 @@ def smiles2atoms(smiles: str, seed: int = 42) -> ase.Atoms:
         The SMILES string to convert.
     seed : int, optional
         Random seed for conformer generation (default is 42).
+    useRandomCoords : bool, optional
+        Start the embedding from random coordinates instead of the eigenvectors
+        of the distance matrix (default is False). Long chains, such as
+        n-alkanes from about C56 on, often embed only this way.
 
     Returns
     -------
@@ -65,7 +73,7 @@ def smiles2atoms(smiles: str, seed: int = 42) -> ase.Atoms:
     >>> isinstance(atoms, ase.Atoms)
     True
     """
-    return smiles2conformers(smiles, 1, seed)[0]
+    return smiles2conformers(smiles, 1, seed, useRandomCoords=useRandomCoords)[0]
 
 
 def smiles2conformers(
@@ -73,6 +81,7 @@ def smiles2conformers(
     numConfs: int,  # noqa N803
     randomSeed: int = 42,  # noqa N803
     maxAttempts: int = 1000,  # noqa N803
+    useRandomCoords: bool = False,  # noqa N803
 ) -> list[ase.Atoms]:
     """Generate multiple molecular conformers from a SMILES string.
 
@@ -86,6 +95,10 @@ def smiles2conformers(
         Random seed for conformer generation (default is 42).
     maxAttempts : int, optional
         Maximum number of embedding attempts (default is 1000).
+    useRandomCoords : bool, optional
+        Start each embedding from random coordinates instead of the
+        eigenvectors of the distance matrix (default is False). Long chains,
+        such as n-alkanes from about C56 on, often embed only this way.
 
     Returns
     -------
@@ -127,17 +140,7 @@ def smiles2conformers(
         return [get_pf6()] * numConfs
 
     mol = Chem.AddHs(mol)
-    conformer_ids = rdDistGeom.EmbedMultipleConfs(
-        mol,
-        numConfs=numConfs,
-        randomSeed=randomSeed,
-        maxAttempts=maxAttempts,
-    )
-    if len(conformer_ids) < numConfs:
-        raise ValueError(
-            f"rdkit embedded {len(conformer_ids)} of {numConfs} conformers"
-            f" of {smiles!r}"
-        )
+    embed_conformers(mol, smiles, numConfs, randomSeed, maxAttempts, useRandomCoords)
 
     images: list[ase.Atoms] = []
     charges = [atom.GetFormalCharge() for atom in mol.GetAtoms()]

{molify-0.2.7 → molify-0.2.8}/src/molify/utils.py

@@ -14,11 +14,60 @@ from ase.data.colors import jmol_colors
 from matplotlib.axes import Axes
 from matplotlib.figure import Figure
 from rdkit import Chem
+from rdkit.Chem import rdDistGeom
 from typing_extensions import deprecated
 
 from molify.constants import GraphAttr
 
 
+def embed_conformers(
+    mol: Chem.Mol,
+    smiles: str,
+    numConfs: int,  # noqa N803
+    randomSeed: int,  # noqa N803
+    maxAttempts: int,  # noqa N803
+    useRandomCoords: bool,  # noqa N803
+) -> None:
+    """Embed conformers into ``mol`` in place.
+
+    Parameters
+    ----------
+    mol : rdkit.Chem.Mol
+        Molecule with explicit hydrogens.
+    smiles : str
+        SMILES string named in the error message.
+    numConfs : int
+        Number of conformers to embed.
+    randomSeed : int
+        Random seed for the embedding.
+    maxAttempts : int
+        Maximum number of embedding attempts per conformer, 0 for RDKit's
+        default.
+    useRandomCoords : bool
+        Start each embedding from random coordinates instead of the
+        eigenvectors of the distance matrix.
+
+    Raises
+    ------
+    ValueError
+        If RDKit embeds fewer than ``numConfs`` conformers.
+    """
+    embedded = len(
+        rdDistGeom.EmbedMultipleConfs(
+            mol,
+            numConfs=numConfs,
+            randomSeed=randomSeed,
+            maxAttempts=maxAttempts,
+            useRandomCoords=useRandomCoords,
+        )
+    )
+    if embedded < numConfs:
+        message = f"rdkit embedded {embedded} of {numConfs} conformers of {smiles!r}"
+        if not useRandomCoords:
+            message += "; random starting coordinates often embed large molecules"
+        raise ValueError(message)
+
+
 def _is_atom_index(value) -> bool:
     return (
         isinstance(value, numbers.Real)

{molify-0.2.7 → molify-0.2.8}/tests/test_cli.py

@@ -76,3 +76,10 @@ def test_smiles2atoms_reports_unparseable_smiles():
     assert (
         "Invalid value for 'smiles': rdkit cannot parse SMILES 'C1CC'" in result.output
     )
+
+
+def test_smiles2atoms_random_coords_embeds_long_chains():
+    result = runner.invoke(app, ["smiles2atoms", "C" * 56, "--random-coords"])
+    assert result.exit_code == 0, result.output
+    atoms = ase.io.read(io.StringIO(result.output), format="extxyz")
+    assert atoms.get_chemical_formula() == "C56H114"

{molify-0.2.7 → molify-0.2.8}/tests/test_rdkit2ase.py

@@ -1,3 +1,5 @@
+import re
+
 import ase
 import numpy as np
 import numpy.testing as npt
@@ -203,3 +205,15 @@ class TestRdkit2NetworkxOriginalIndex:
 
         for node_id, attributes in graph.nodes(data=True):
             assert attributes[NodeAttr.ORIGINAL_INDEX] == node_id
+
+
+def test_rdkit2ase_embeds_long_chains_from_random_coords():
+    atoms = rdkit2ase(Chem.MolFromSmiles("C" * 56), seed=42, useRandomCoords=True)
+    assert atoms.get_chemical_formula() == "C56H114"
+
+
+def test_rdkit2ase_rejects_unembeddable_mol():
+    mol = Chem.MolFromSmiles("[Fe](C)(C)(C)(C)(C)(C)(C)(C)")
+    message = f"rdkit embedded 0 of 1 conformers of {Chem.MolToSmiles(mol)!r}"
+    with pytest.raises(ValueError, match=re.escape(message)):
+        rdkit2ase(mol)

{molify-0.2.7 → molify-0.2.8}/tests/test_smiles2conformers.py

@@ -81,22 +81,46 @@ def test_smiles2conformers_rejects_unparseable_smiles(smiles):
         smiles2conformers(smiles, numConfs=3)
 
 
+RANDOM_COORDS_HINT = "; random starting coordinates often embed large molecules"
+
+
+@pytest.mark.parametrize(
+    ("use_random_coords", "hint"),
+    [(False, RANDOM_COORDS_HINT), (True, "")],
+    ids=["eigenvector-coords", "random-coords"],
+)
 @pytest.mark.parametrize(
     ("convert", "num_confs"),
     [(partial(smiles2conformers, numConfs=3), 3), (smiles2atoms, 1)],
     ids=["smiles2conformers", "smiles2atoms"],
 )
-def test_rejects_unembeddable_smiles(convert, num_confs):
+def test_rejects_unembeddable_smiles(convert, num_confs, use_random_coords, hint):
     smiles = "[Fe](C)(C)(C)(C)(C)(C)(C)(C)"
-    message = f"rdkit embedded 0 of {num_confs} conformers of {smiles!r}"
-    with pytest.raises(ValueError, match=re.escape(message)):
-        convert(smiles)
+    message = f"rdkit embedded 0 of {num_confs} conformers of {smiles!r}{hint}"
+    with pytest.raises(ValueError, match=f"^{re.escape(message)}$"):
+        convert(smiles, useRandomCoords=use_random_coords)
 
 
 def test_smiles2conformers_rejects_partial_embedding():
     smiles = "C1CC2CCC1C2"
     assert len(smiles2conformers(smiles, numConfs=10)) == 10
     with pytest.raises(
-        ValueError, match=r"^rdkit embedded [1-9] of 10 conformers of 'C1CC2CCC1C2'$"
+        ValueError,
+        match=(
+            r"^rdkit embedded [1-9] of 10 conformers of 'C1CC2CCC1C2'"
+            f"{re.escape(RANDOM_COORDS_HINT)}$"
+        ),
     ):
         smiles2conformers(smiles, numConfs=10, maxAttempts=1)
+
+
+@pytest.mark.parametrize("n_carbons", [56, 64])
+def test_smiles2atoms_embeds_long_chains_from_random_coords(n_carbons):
+    atoms = smiles2atoms("C" * n_carbons, seed=42, useRandomCoords=True)
+    assert atoms.get_chemical_formula() == f"C{n_carbons}H{2 * n_carbons + 2}"
+
+
+def test_smiles2conformers_embeds_long_chains_from_random_coords():
+    frames = smiles2conformers("C" * 56, numConfs=2, useRandomCoords=True)
+    assert [atoms.get_chemical_formula() for atoms in frames] == ["C56H114"] * 2
+    assert not np.allclose(frames[0].positions, frames[1].positions)