molify 0.2.6__tar.gz → 0.2.7__tar.gz

{molify-0.2.6 → molify-0.2.7}/.github/workflows/pytest.yaml

@@ -21,8 +21,8 @@ jobs:
           - "3.12"
           - "3.11"
           - "3.10"
-        os: [ubuntu-latest, ubuntu-24.04-arm, windows-latest, macos-15-intel, macos-latest]
-        # windows-11-arm -> rdkit support missing
+        os: [ubuntu-latest, ubuntu-24.04-arm, windows-latest, macos-latest]
+        # windows-11-arm, macos-15-intel -> rdkit support missing
 
     steps:
       - uses: actions/checkout@v5

{molify-0.2.6 → molify-0.2.7}/.pre-commit-config.yaml

@@ -20,13 +20,13 @@ repos:
       - id: sort-simple-yaml
       - id: trailing-whitespace
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.1
+    rev: v2.4.3
     hooks:
       - id: codespell
         additional_dependencies: ["tomli"]
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.14.14
+    rev: v0.16.10
     hooks:
       # Run the linter.
       - id: ruff

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: molify
-Version: 0.2.6
+Version: 0.2.7
 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
@@ -16,6 +16,7 @@ Requires-Dist: networkx>=3.4.2
 Requires-Dist: packmol>=21.1.2
 Requires-Dist: rdkit>=2024
 Requires-Dist: typer>=0.27.1
+Requires-Dist: typing-extensions>=4.15.0
 Provides-Extra: vesin
 Requires-Dist: vesin>=0.3.7; extra == 'vesin'
 Description-Content-Type: text/markdown

{molify-0.2.6 → molify-0.2.7}/docs/source/packmol_tools.ipynb

@@ -284,6 +284,45 @@
     "print(f\"Density: {actual_density:.1f} kg/m³\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Repeating a Box\n",
+    "\n",
+    "`molify.repeat()` builds a supercell of a periodic box and tiles `info['connectivity']` with it. Every copy carries its own bonds, bonds across the periodic boundary link neighbouring copies, and bond orders are kept. Use it to repeat any structure that carries connectivity."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Atoms: 60 -> 120\n",
+      "Bonds: 50 -> 100\n",
+      "Molecules: 10 -> 20\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Tile the mixture twice along the first cell vector\n",
+    "supercell = molify.repeat(mixture, (2, 1, 1))\n",
+    "\n",
+    "print(f\"Atoms: {len(mixture)} -> {len(supercell)}\")\n",
+    "print(\n",
+    "    f\"Bonds: {len(mixture.info['connectivity'])} \"\n",
+    "    f\"-> {len(supercell.info['connectivity'])}\"\n",
+    ")\n",
+    "print(\n",
+    "    f\"Molecules: {len(list(molify.iter_fragments(mixture)))} \"\n",
+    "    f\"-> {len(list(molify.iter_fragments(supercell)))}\"\n",
+    ")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},

{molify-0.2.6 → molify-0.2.7}/paper/paper.md

@@ -110,10 +110,7 @@ For example, `molify` streamlines the extraction of the CH$_3$ alkyl group from
 ```python
 from molify import get_substructures
 
-frames: list[ase.Atoms] = get_substructures(
-  atoms=box,
-  smiles="[C]([H])([H])[H]"
-)
+frames: list[ase.Atoms] = get_substructures(atoms=box, smiles="[C]([H])([H])[H]")
 ```
 
 # Related software

{molify-0.2.6 → molify-0.2.7}/pyproject.toml

@@ -15,6 +15,7 @@ dependencies = [
     "packmol>=21.1.2",
     "rdkit>=2024",
     "typer>=0.27.1",
+    "typing-extensions>=4.15.0",
 ]
 
 [dependency-groups]

{molify-0.2.6 → molify-0.2.7}/src/molify/__init__.py

@@ -6,6 +6,7 @@ from molify.compress import compress
 from molify.networkx2x import networkx2ase, networkx2rdkit
 from molify.pack import pack
 from molify.rdkit2x import rdkit2ase, rdkit2networkx
+from molify.repeat import repeat
 from molify.smiles2x import smiles2atoms, smiles2conformers
 from molify.substructure import (
     get_substructures,
@@ -27,6 +28,7 @@ __all__ = [
     "pack",
     "smiles2conformers",
     "compress",
+    "repeat",
     "match_substructure",
     "group_matches_by_fragment",
     "get_substructures",

{molify-0.2.6 → molify-0.2.7}/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.6'
-__version_tuple__ = version_tuple = (0, 2, 6)
+__version__ = version = '0.2.7'
+__version_tuple__ = version_tuple = (0, 2, 7)
 
 __commit_id__ = commit_id = None

{molify-0.2.6 → molify-0.2.7}/src/molify/ase2x.py

@@ -1,16 +1,21 @@
 import ase
 import networkx as nx
 import numpy as np
-from ase.neighborlist import natural_cutoffs, neighbor_list
+from ase.data import covalent_radii
+from ase.neighborlist import neighbor_list
 from rdkit import Chem
 
 from molify.constants import EdgeAttr, GraphAttr, NodeAttr
+from molify.utils import read_connectivity
 
 try:
     import vesin
 except ImportError:
     vesin = None
 
+# Li, Na, K, Rb, Cs, Fr
+_NON_BONDING_ATOMIC_NUMBERS = (3, 11, 19, 37, 55, 87)
+
 
 def _create_graph_from_connectivity(
     atoms: ase.Atoms, connectivity, charges
@@ -39,17 +44,30 @@ def _create_graph_from_connectivity(
     return graph
 
 
-def _compute_connectivity_matrix(atoms: ase.Atoms, scale: float, pbc: bool):
-    """Compute connectivity matrix from distance-based cutoffs."""
-    # non-bonding positive charged atoms / ions.
-    non_bonding_atomic_numbers = {3, 11, 19, 37, 55, 87}
+def _compute_bonded_pairs(atoms: ase.Atoms, scale: float, pbc: bool) -> np.ndarray:
+    """Compute bonded atom pairs from distance-based cutoffs.
 
-    atomic_numbers = atoms.get_atomic_numbers()
-    excluded_mask = np.isin(atomic_numbers, list(non_bonding_atomic_numbers))
+    Parameters
+    ----------
+    atoms : ase.Atoms
+        Structure to search for bonds.
+    scale : float
+        Factor applied to the covalent radii.
+    pbc : bool
+        Whether bonds may cross periodic boundaries.
 
-    atom_radii = np.array(natural_cutoffs(atoms, mult=scale))
-    pairwise_cutoffs = atom_radii[:, None] + atom_radii[None, :]
-    max_cutoff = np.max(pairwise_cutoffs)
+    Returns
+    -------
+    numpy.ndarray
+        Shape ``(M, 2)``; unique ``(i, j)`` rows with ``i < j``, sorted
+        lexicographically.
+    """
+    radii = covalent_radii[atoms.numbers] * scale
+    bonding = ~np.isin(atoms.numbers, _NON_BONDING_ATOMIC_NUMBERS)
+    if not bonding.any():
+        return np.empty((0, 2), dtype=np.intp)
+    # Neighbor lists keep d < cutoff; one ulp more keeps pairs at exactly the cutoff.
+    max_cutoff = np.nextafter(2 * radii[bonding].max(), np.inf)
 
     if vesin is not None:
         try:
@@ -66,31 +84,13 @@ def _compute_connectivity_matrix(atoms: ase.Atoms, scale: float, pbc: bool):
             "ijdS", atoms, cutoff=max_cutoff, self_interaction=False
         )
 
-    # If pbc=False, filter out bonds that cross periodic boundaries
+    keep = (i < j) & bonding[i] & bonding[j] & (d <= radii[i] + radii[j])
     if not pbc:
-        non_periodic_mask = np.all(s == 0, axis=1)
-        i = i[non_periodic_mask]
-        j = j[non_periodic_mask]
-        d = d[non_periodic_mask]
+        keep &= ~s.any(axis=1)
+    return np.unique(np.stack([i[keep], j[keep]], axis=1), axis=0)
 
-    d_ij = np.full((len(atoms), len(atoms)), np.inf)
-    d_ij[i, j] = d
-    np.fill_diagonal(d_ij, 0.0)
 
-    # mask out non-bonding atoms
-    d_ij[excluded_mask, :] = np.inf
-    d_ij[:, excluded_mask] = np.inf
-
-    connectivity_matrix = np.zeros((len(atoms), len(atoms)), dtype=int)
-    np.fill_diagonal(d_ij, np.inf)
-    connectivity_matrix[d_ij <= pairwise_cutoffs] = 1
-
-    return connectivity_matrix, non_bonding_atomic_numbers
-
-
-def _add_node_properties(
-    graph: nx.Graph, atoms: ase.Atoms, charges, non_bonding_atomic_numbers
-):
+def _add_node_properties(graph: nx.Graph, atoms: ase.Atoms, charges):
     """Add node properties to the graph."""
     stored_indices = atoms.info.get(NodeAttr.ORIGINAL_INDEX)
 
@@ -100,7 +100,7 @@ def _add_node_properties(
         graph.nodes[i][NodeAttr.ATOMIC_NUMBER] = int(atom.number)
         graph.nodes[i][NodeAttr.ORIGINAL_INDEX] = original_index
         graph.nodes[i][NodeAttr.CHARGE] = float(charges[i])
-        if atom.number in non_bonding_atomic_numbers:
+        if atom.number in _NON_BONDING_ATOMIC_NUMBERS:
             graph.nodes[i][NodeAttr.CHARGE] = 1.0
 
 
@@ -132,6 +132,12 @@ def ase2networkx(
     networkx.Graph
         An undirected NetworkX graph with connectivity information.
 
+    Raises
+    ------
+    ValueError
+        For an invalid bond in ``atoms.info['connectivity']``, see
+        :func:`molify.utils.read_connectivity`.
+
     Notes
     -----
     The graph contains the following information:
@@ -150,7 +156,11 @@ def ase2networkx(
     Connectivity is determined by:
 
     1. Using explicit connectivity if present in atoms.info
-    2. Otherwise using distance-based cutoffs (edges will have bond_order=None)
+    2. Otherwise using distance-based cutoffs: atoms *i* and *j* are bonded
+       when any periodic image of *j* lies within ``scale * (r_i + r_j)`` of
+       *i*, with *r* the covalent radius. Li, Na, K, Rb, Cs and Fr are
+       non-bonding ions. Edges have ``bond_order=None``; memory scales
+       linearly with the number of atoms.
 
     To get bond orders, pass the graph to networkx2rdkit().
 
@@ -169,24 +179,16 @@ def ase2networkx(
     charges = atoms.get_initial_charges()
 
     if GraphAttr.CONNECTIVITY in atoms.info:
-        connectivity = atoms.info[GraphAttr.CONNECTIVITY]
-        # ensure connectivity is list[tuple[int, int, float|None]] and
-        # does not contain np.generic
-        connectivity = [
-            (int(i), int(j), float(bond_order) if bond_order is not None else None)
-            for i, j, bond_order in connectivity
-        ]
+        connectivity = read_connectivity(atoms)
         return _create_graph_from_connectivity(atoms, connectivity, charges)
 
-    connectivity_matrix, non_bonding_atomic_numbers = _compute_connectivity_matrix(
-        atoms, scale, pbc
-    )
+    pairs = _compute_bonded_pairs(atoms, scale, pbc)
 
-    graph = nx.from_numpy_array(connectivity_matrix, edge_attr=None)
-    for u, v in graph.edges():
-        graph.edges[u, v][EdgeAttr.BOND_ORDER] = None
+    graph = nx.Graph()
+    graph.add_nodes_from(range(len(atoms)))
+    graph.add_edges_from(pairs.tolist(), **{EdgeAttr.BOND_ORDER: None})
 
-    _add_node_properties(graph, atoms, charges, non_bonding_atomic_numbers)
+    _add_node_properties(graph, atoms, charges)
 
     graph.graph[GraphAttr.PBC] = atoms.pbc
     graph.graph[GraphAttr.CELL] = atoms.cell

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

@@ -91,7 +91,10 @@ def smiles2atoms(
 
     Example: molify smiles2atoms CCO --format XYZ > etoh.xyz
     """
-    atoms = _smiles2atoms(smiles, seed=seed)
+    try:
+        atoms = _smiles2atoms(smiles, seed=seed)
+    except ValueError as err:
+        raise typer.BadParameter(str(err), param_hint=["smiles"]) from err
     with io.StringIO() as handle:
         ase.io.write(handle, atoms, format=_resolve_format(fmt))
         sys.stdout.write(handle.getvalue())

molify-0.2.7/src/molify/compress.py

@@ -0,0 +1,52 @@
+import ase
+import numpy as np
+from ase.cell import Cell
+
+from molify.constants import GraphAttr
+from molify.utils import calculate_box_dimensions, fragment_indices
+
+
+def compress(
+    atoms: ase.Atoms,
+    density: float,
+    freeze_molecules: bool = False,
+) -> ase.Atoms:
+    """Compress an ASE Atoms object to a target density.
+
+    Parameters
+    ----------
+    atoms : ase.Atoms
+        The Atoms object to compress.
+    density : float
+        The target density in kg/m^3.
+    freeze_molecules : bool
+        If True, freeze the internal degrees of freedom of the molecules
+        during compression, to prevent bond compression.
+
+    Raises
+    ------
+    ValueError
+        With ``freeze_molecules=True``, for a missing ``info['connectivity']``
+        or an invalid bond in it, see :func:`molify.utils.read_connectivity`.
+    """
+    atoms = atoms.copy()
+    new_dimensions = np.array(calculate_box_dimensions([atoms], density))
+
+    if freeze_molecules:
+        if atoms.info.get(GraphAttr.CONNECTIVITY) is None:
+            raise ValueError("No connectivity info found for freeze_molecules=True")
+        fragments = fragment_indices(atoms)
+        new_cell = Cell.new(new_dimensions)
+        t_mat = np.linalg.solve(atoms.get_cell().T, new_cell.T)
+
+        positions = atoms.get_positions()
+        for fragment in fragments:
+            com = atoms[fragment].get_center_of_mass()
+            positions[fragment] += com @ t_mat - com
+
+        atoms.set_positions(positions)
+        atoms.set_cell(new_cell, scale_atoms=False)
+    else:
+        atoms.set_cell(new_dimensions, scale_atoms=True)
+
+    return atoms

{molify-0.2.6 → molify-0.2.7}/src/molify/pack.py

@@ -10,7 +10,7 @@ from ase.io.proteindatabank import write_proteindatabank
 from rdkit import Chem
 
 from molify.constants import GraphAttr
-from molify.utils import calculate_box_dimensions
+from molify.utils import calculate_box_dimensions, read_connectivity
 
 log = logging.getLogger(__name__)
 
@@ -90,13 +90,29 @@ def _write_molecule_files(
             ase.io.write(filepath, atoms)
 
 
+def _combine_bonds(
+    selected_images: list[ase.Atoms],
+) -> list[tuple[int, int, float | None]] | None:
+    """Offset each molecule's bonds into the packed box.
+
+    Returns None when a molecule lacks ``info['connectivity']``.
+    """
+    if not all(GraphAttr.CONNECTIVITY in atoms.info for atoms in selected_images):
+        return None
+    bonds = []
+    offset = 0
+    for atoms in selected_images:
+        for i, j, order in read_connectivity(atoms):
+            bonds.append((i + offset, j + offset, order))
+        offset += len(atoms)
+    return bonds
+
+
 def _extract_atom_arrays(
     selected_images: list[ase.Atoms], packed_atoms: ase.Atoms
 ) -> ase.Atoms:
     """Extracts and adds relevant atom arrays (if present)
 
-    Add bonds from the input structures to the packed structure if available.
-
     Parameters
     ----------
     selected_images : list[ase.Atoms]
@@ -107,7 +123,7 @@ def _extract_atom_arrays(
     Returns
     -------
     ase.Atoms
-        The packed ASE Atoms object with the copied arrays and bonds.
+        The packed ASE Atoms object with the copied arrays.
     """
     array_keys = [
         "occupancy",
@@ -126,14 +142,6 @@ def _extract_atom_arrays(
             )
             packed_atoms.arrays[key] = concatenated_array
 
-    if all(GraphAttr.CONNECTIVITY in atoms.info for atoms in selected_images):
-        bonds = []
-        offset = 0
-        for atoms in selected_images:
-            for bond in atoms.info[GraphAttr.CONNECTIVITY]:
-                bonds.append((bond[0] + offset, bond[1] + offset, bond[2]))
-            offset += len(atoms)
-        packed_atoms.info[GraphAttr.CONNECTIVITY] = bonds
     charges = np.concatenate([atom.get_initial_charges() for atom in selected_images])
     if any(charge != 0 for charge in charges):
         packed_atoms.set_initial_charges(charges)
@@ -189,6 +197,12 @@ def pack(
     ase.Atoms
         An ASE Atoms object representing the packed system.
 
+    Raises
+    ------
+    ValueError
+        For an invalid bond in a molecule's ``info['connectivity']``, see
+        :func:`molify.utils.read_connectivity`.
+
     Example
     -------
     >>> from molify import pack, smiles2conformers
@@ -200,6 +214,7 @@ def pack(
     Atoms(symbols='C10H44O12', pbc=True, cell=[8.4, 8.4, 8.4])
     """
     selected_images = _select_conformers(data, counts, seed)
+    bonds = _combine_bonds(selected_images)
     cell = calculate_box_dimensions(images=selected_images, density=density)
 
     # Adjust cell dimensions according to ratio while keeping volume unchanged
@@ -240,4 +255,6 @@ def pack(
     packed_atoms.cell = cell
     packed_atoms.pbc = True
     packed_atoms = _extract_atom_arrays(selected_images, packed_atoms)
+    if bonds is not None:
+        packed_atoms.info[GraphAttr.CONNECTIVITY] = bonds
     return packed_atoms

molify-0.2.7/src/molify/repeat.py

@@ -0,0 +1,117 @@
+from collections.abc import Sequence
+
+import ase
+import numpy as np
+from ase.geometry import find_mic, minkowski_reduce
+
+from molify.constants import GraphAttr, NodeAttr
+from molify.utils import read_connectivity
+
+
+def _normalize_rep(rep: int | Sequence[int]) -> tuple[int, ...]:
+    try:
+        reps = np.asarray(rep)
+    except ValueError:
+        reps = np.empty(0)
+    if reps.ndim == 0:
+        reps = np.broadcast_to(reps, 3)
+    if reps.shape != (3,) or reps.dtype.kind not in "iu" or (reps < 1).any():
+        raise ValueError(
+            "rep must be a positive integer or a sequence of three positive integers, "
+            f"got {rep!r}"
+        )
+    return tuple(reps.tolist())
+
+
+def _tile_bonds(
+    atoms: ase.Atoms, reps: tuple[int, ...]
+) -> list[tuple[int, int, float | None]]:
+    n_atoms = len(atoms)
+    bonds = read_connectivity(atoms)
+    i = np.array([bond[0] for bond in bonds], dtype=int)
+    j = np.array([bond[1] for bond in bonds], dtype=int)
+    orders = [bond[2] for bond in bonds]
+
+    periodic = atoms.pbc & atoms.cell.any(1)
+    d = atoms.positions[j] - atoms.positions[i]
+    d_mic, lengths = find_mic(d, atoms.cell, periodic)
+    lattice, _ = minkowski_reduce(atoms.cell, periodic)
+    limit = 0.5 * np.linalg.norm(lattice[periodic], axis=1).min(initial=np.inf)
+    too_long = np.flatnonzero(lengths >= limit)
+    if too_long.size:
+        k = too_long[0]
+        raise ValueError(
+            f"bond ({i[k]}, {j[k]}) in atoms.info['connectivity'] is "
+            f"{lengths[k]:.3f} Å long; repeat needs every bond shorter than "
+            f"{limit:.3f} Å, half the shortest periodic lattice vector, so that "
+            "each bond links a unique periodic image"
+        )
+    shift = np.rint(atoms.cell.scaled_positions(d_mic - d)).astype(int)
+
+    images = np.array(list(np.ndindex(*reps)))
+    targets = (images[:, None, :] + shift[None, :, :]) % np.array(reps)
+    target_image = np.ravel_multi_index(np.moveaxis(targets, -1, 0), reps)
+    new_i = np.arange(len(images))[:, None] * n_atoms + i[None, :]
+    new_j = target_image * n_atoms + j[None, :]
+    return [
+        (int(a), int(b), order)
+        for a, b, order in zip(
+            new_i.ravel(), new_j.ravel(), orders * len(images), strict=True
+        )
+    ]
+
+
+def repeat(atoms: ase.Atoms, rep: int | Sequence[int]) -> ase.Atoms:
+    """Repeat a periodic structure together with its connectivity.
+
+    Atom ``k`` of the result is a copy of atom ``k % len(atoms)``, as in
+    :meth:`ase.Atoms.repeat`. Each bond ``(i, j, order)`` links atom ``i`` to
+    the nearest periodic image of atom ``j``. Bond orders are kept.
+
+    Parameters
+    ----------
+    atoms : ase.Atoms
+        Periodic structure whose bonds are each shorter than half the shortest
+        vector of its periodic lattice.
+    rep : int or Sequence[int]
+        Copies along each cell vector: one positive integer for all three, or
+        three positive integers.
+
+    Returns
+    -------
+    ase.Atoms
+        Repeated structure with ``info['connectivity']`` and
+        ``info['original_index']`` tiled and ``info['smiles']`` removed.
+
+    Raises
+    ------
+    ValueError
+        For an invalid ``rep``, an ``info['original_index']`` of the wrong
+        length, an invalid bond in ``info['connectivity']``, or a repeat along
+        an undefined cell vector.
+
+    Examples
+    --------
+    >>> import molify
+    >>> water = molify.smiles2conformers("O", numConfs=1)
+    >>> box = molify.pack([water], counts=[4], density=1000)
+    >>> big = molify.repeat(box, (2, 1, 1))
+    >>> len(big.info["connectivity"]) == 2 * len(box.info["connectivity"])
+    True
+    """
+    reps = _normalize_rep(rep)
+    original_index = atoms.info.get(NodeAttr.ORIGINAL_INDEX)
+    if original_index is not None and len(original_index) != len(atoms):
+        raise ValueError(
+            f"atoms.info['original_index'] holds {len(original_index)} entries "
+            f"for {len(atoms)} atoms; it needs one entry per atom"
+        )
+
+    result = atoms.repeat(reps)
+    result.info.pop(GraphAttr.SMILES, None)
+    if GraphAttr.CONNECTIVITY in atoms.info:
+        result.info[GraphAttr.CONNECTIVITY] = _tile_bonds(atoms, reps)
+    if original_index is not None:
+        tiled = [int(k) for k in original_index] * int(np.prod(reps))
+        result.info[NodeAttr.ORIGINAL_INDEX] = tiled
+    return result

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

@@ -47,6 +47,11 @@ def smiles2atoms(smiles: str, seed: int = 42) -> ase.Atoms:
     ase.Atoms
         The generated Atoms object (first conformer).
 
+    Raises
+    ------
+    ValueError
+        If RDKit fails to parse or embed ``smiles``.
+
     Notes
     -----
     This is a convenience wrapper around smiles2conformers that returns
@@ -87,6 +92,12 @@ def smiles2conformers(
     list[ase.Atoms]
         List of generated conformers as ASE Atoms objects.
 
+    Raises
+    ------
+    ValueError
+        If RDKit fails to parse ``smiles`` or embeds fewer than ``numConfs``
+        conformers.
+
     Notes
     -----
     Special handling is included for PF6- (hexafluorophosphate) which
@@ -110,16 +121,23 @@ def smiles2conformers(
     True
     """
     mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        raise ValueError(f"rdkit cannot parse SMILES {smiles!r}")
     if Chem.MolToSmiles(mol, canonical=True) == "F[P-](F)(F)(F)(F)F":
         return [get_pf6()] * numConfs
 
     mol = Chem.AddHs(mol)
-    rdDistGeom.EmbedMultipleConfs(
+    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}"
+        )
 
     images: list[ase.Atoms] = []
     charges = [atom.GetFormalCharge() for atom in mol.GetAtoms()]

{molify-0.2.6 → molify-0.2.7}/src/molify/substructure.py

@@ -8,7 +8,7 @@ from rdkit.Chem import Draw
 
 from molify.ase2x import ase2rdkit
 from molify.constants import GraphAttr
-from molify.utils import find_connected_components
+from molify.utils import fragment_indices
 
 
 def match_substructure(  # noqa: C901
@@ -289,26 +289,26 @@ def iter_fragments(atoms: ase.Atoms) -> list[ase.Atoms]:
     ase.Atoms
         Each connected component (fragment) in the input structure.
 
+    Raises
+    ------
+    ValueError
+        For an invalid bond in ``atoms.info['connectivity']``, see
+        :func:`molify.utils.read_connectivity`.
+
     Examples
     --------
-    >>> from molify import smiles2atoms
-    >>> from rdkit.Chem import CombineMols
+    >>> from molify import iter_fragments, pack, smiles2conformers
     >>>
-    >>> # Create multi-fragment system
-    >>> ethanol = smiles2atoms("CCO")
-    >>> methanol = smiles2atoms("CO")
-    >>> combined = ethanol + methanol
+    >>> water = smiles2conformers("O", 1)
+    >>> ethanol = smiles2conformers("CCO", 1)
+    >>> box = pack([water, ethanol], [2, 1], density=800)
     >>>
-    >>> # Iterate over fragments
-    >>> fragments = list(iter_fragments(combined))
-    >>> len(fragments)
-    2
+    >>> [fragment.get_chemical_formula() for fragment in iter_fragments(box)]
+    ['H2O', 'H2O', 'C2H6O']
     """
     if GraphAttr.CONNECTIVITY in atoms.info:
-        # connectivity is a list of tuples (i, j, bond_type)
-        connectivity = atoms.info[GraphAttr.CONNECTIVITY]
-        for component in find_connected_components(connectivity):
-            yield atoms[list(component)]
+        for indices in fragment_indices(atoms):
+            yield atoms[indices]
     else:
         for molecule in separate(atoms):
             yield molecule