biotite 0.40.0__cp310-cp310-win_amd64.whl → 0.41.0__cp310-cp310-win_amd64.whl

biotite/structure/sequence.py

@@ -0,0 +1,112 @@
+# This source code is part of the Biotite package and is distributed
+# under the 3-Clause BSD License. Please see 'LICENSE.rst' for further
+# information.
+
+"""
+Function for converting a structure into a sequence.
+"""
+
+__name__ = "biotite.structure"
+__author__ = "Patrick Kunzmann"
+__all__ = ["to_sequence"]
+
+import numpy as np
+from .info.misc import one_letter_code
+from .info.groups import amino_acid_names, nucleotide_names
+from .residues import get_residues
+from .chains import get_chain_starts
+from .error import BadStructureError
+from ..sequence.seqtypes import ProteinSequence, NucleotideSequence
+
+
+HETERO_PLACEHOLDER = "."
+
+
+def to_sequence(atoms, allow_hetero=False):
+    """
+    Convert each chain in a structure into a sequence.
+
+    Parameters
+    ----------
+    atoms : AtomArray or AtomArrayStack
+        The structure.
+        May contain multiple chains.
+        Each chain must be either a peptide or a nucleic acid.
+    allow_hetero : bool, optional
+        If true, residues inside a amino acid or nucleotide chain,
+        that have no one-letter code, are replaced by the respective
+        '*any*' symbol (`"X"` or `"N"`, respectively).
+        The same is true for amino acids in nucleotide chains and vice
+        versa.
+        By default, an exception is raised.
+
+    Returns
+    -------
+    sequences : list of Sequence, length=n
+        The sequence for each chain in the structure.
+    chain_start_indices : ndarray, shape=(n,), dtype=int
+        The atom index where each chain starts.
+
+    Notes
+    -----
+    Residues are considered amino acids or nucleotides based on their
+    appearance :func:`info.amino_acid_names()` or
+    :func:`info.nucleotide_names()`, respectively.
+
+    Examples
+    --------
+
+    >>> sequences, chain_starts = to_sequence(atom_array)
+    >>> print(sequences)
+    [ProteinSequence("NLYIQWLKDGGPSSGRPPPS")]
+
+    """
+    sequences = []
+    chain_start_indices = get_chain_starts(atoms, add_exclusive_stop=True)
+    for i in range(len(chain_start_indices)-1):
+        start = chain_start_indices[i]
+        stop = chain_start_indices[i+1]
+        chain = atoms[start:stop]
+        _, residues = get_residues(chain)
+        one_letter_symbols = np.array(
+            [one_letter_code(res) or HETERO_PLACEHOLDER for res in residues]
+        )
+        hetero_mask = one_letter_symbols == HETERO_PLACEHOLDER
+
+        aa_count  = np.count_nonzero(np.isin(residues, amino_acid_names()))
+        nuc_count = np.count_nonzero(np.isin(residues, nucleotide_names()))
+        if aa_count == 0 and nuc_count == 0:
+            raise BadStructureError(
+                f"Chain {chain.chain_id[0]} contains neither amino acids "
+                "nor nucleotides"
+            )
+        elif aa_count > nuc_count:
+            # Chain is a peptide
+            hetero_mask |= ~np.isin(residues, amino_acid_names())
+            if not allow_hetero and np.any(hetero_mask):
+                hetero_indices = np.where(hetero_mask)[0]
+                raise BadStructureError(
+                    f"Hetero residue(s) "
+                    f"{', '.join(residues[hetero_indices])} in peptide"
+                )
+            one_letter_symbols[hetero_mask] = "X"
+            # Replace selenocysteine and pyrrolysine
+            one_letter_symbols[one_letter_symbols == "U"] = "C"
+            one_letter_symbols[one_letter_symbols == "O"] = "K"
+            sequences.append(ProteinSequence("".join(one_letter_symbols)))
+        else:
+            # Chain is a nucleic acid
+            hetero_mask |= ~np.isin(residues, nucleotide_names())
+            if not allow_hetero and np.any(hetero_mask):
+                hetero_indices = np.where(hetero_mask)[0]
+                raise BadStructureError(
+                    f"Hetero residue(s) "
+                    f"{', '.join(residues[hetero_indices])} in nucleic acid"
+                )
+            one_letter_symbols[hetero_mask] = "N"
+            # Replace uracil
+            one_letter_symbols[one_letter_symbols == "U"] = "T"
+            sequences.append(NucleotideSequence("".join(one_letter_symbols)))
+
+    # Remove exclusive stop
+    return sequences, chain_start_indices[:-1]

biotite/structure/superimpose.py

@@ -8,12 +8,19 @@ This module provides functions for structure superimposition.
 
 __name__ = "biotite.structure"
 __author__ = "Patrick Kunzmann, Claude J. Rogers"
-__all__ = ["superimpose", "superimpose_apply", "AffineTransformation"]
+__all__ = ["superimpose", "superimpose_homologs",
+           "superimpose_without_outliers",
+           "AffineTransformation", "superimpose_apply"]
 
 
 import numpy as np
 from .atoms import coord
-from .geometry import centroid
+from .geometry import centroid, distance
+from .filter import filter_amino_acids, filter_nucleotides
+from .sequence import to_sequence
+from ..sequence.alphabet import common_alphabet
+from ..sequence.seqtypes import ProteinSequence
+from ..sequence.align import SubstitutionMatrix, align_optimal, get_codes
 
 
 class AffineTransformation:
@@ -35,11 +42,13 @@ class AffineTransformation:
     ----------
     center_translation, rotation, target_translation : ndarray
         Same as the parameters.
+        The dimensions are always expanded to *(m,3)* or *(m,3,3)*,
+        respectively.
     """
     def __init__(self, center_translation, rotation, target_translation):
-        self.center_translation = center_translation
-        self.rotation = rotation
-        self.target_translation = target_translation
+        self.center_translation = _expand_dims(center_translation, 2)
+        self.rotation = _expand_dims(rotation, 3)
+        self.target_translation = _expand_dims(target_translation, 2)
 
 
     def apply(self, atoms):
@@ -58,10 +67,43 @@ class AffineTransformation:
             with transformations applied.
             Only coordinates are returned, if coordinates were given in
             `atoms`.
+
+        Examples
+        --------
+
+        >>> coord = np.arange(15).reshape(5,3)
+        >>> print(coord)
+        [[ 0  1  2]
+         [ 3  4  5]
+         [ 6  7  8]
+         [ 9 10 11]
+         [12 13 14]]
+        >>> # Rotates 90 degrees around the z-axis
+        >>> transform = AffineTransformation(
+        ...     center_translation=np.array([0,0,0]),
+        ...     rotation=np.array([
+        ...         [0, -1,  0],
+        ...         [1,  0,  0],
+        ...         [0,  0,  1]
+        ...     ]),
+        ...     target_translation=np.array([0,0,0])
+        ... )
+        >>> print(transform.apply(coord))
+        [[ -1.   0.   2.]
+         [ -4.   3.   5.]
+         [ -7.   6.   8.]
+         [-10.   9.  11.]
+         [-13.  12.  14.]]
+
         """
         mobile_coord = coord(atoms)
         original_shape = mobile_coord.shape
         mobile_coord = _reshape_to_3d(mobile_coord)
+        if mobile_coord.shape[0] != self.rotation.shape[0]:
+            raise IndexError(
+                f"Number of transformations is {self.rotation.shape[0]}, "
+                f"but number of structure models is {mobile_coord.shape[0]}"
+            )
 
         superimposed_coord = mobile_coord.copy()
         superimposed_coord += self.center_translation[:, np.newaxis, :]
@@ -77,24 +119,115 @@ class AffineTransformation:
             return superimposed
 
 
+    def as_matrix(self):
+        """
+        Get the translations and rotation as a combined 4x4
+        transformation matrix.
+
+        Multiplying this matrix with coordinates in the form
+        *(x, y, z, 1)* will apply the same transformation as
+        :meth:`apply()` to coordinates in the form *(x, y, z)*.
+
+        Returns
+        -------
+        transformation_matrix : ndarray, shape=(m,4,4), dtype=float
+            The transformation matrix.
+            *m* is the number of models in the transformation.
+
+        Examples
+        --------
+
+        >>> coord = np.arange(15).reshape(5,3)
+        >>> print(coord)
+        [[ 0  1  2]
+         [ 3  4  5]
+         [ 6  7  8]
+         [ 9 10 11]
+         [12 13 14]]
+        >>> # Rotates 90 degrees around the z-axis
+        >>> transform = AffineTransformation(
+        ...     center_translation=np.array([0,0,0]),
+        ...     rotation=np.array([
+        ...         [0, -1,  0],
+        ...         [1,  0,  0],
+        ...         [0,  0,  1]
+        ...     ]),
+        ...     target_translation=np.array([0,0,0])
+        ... )
+        >>> print(transform.apply(coord))
+        [[ -1.   0.   2.]
+         [ -4.   3.   5.]
+         [ -7.   6.   8.]
+         [-10.   9.  11.]
+         [-13.  12.  14.]]
+        >>> # Use a 4x4 matrix for transformation as alternative
+        >>> coord_4 = np.concatenate([coord, np.ones((len(coord), 1))], axis=-1)
+        >>> print(coord_4)
+        [[ 0.  1.  2.  1.]
+         [ 3.  4.  5.  1.]
+         [ 6.  7.  8.  1.]
+         [ 9. 10. 11.  1.]
+         [12. 13. 14.  1.]]
+        >>> print((transform.as_matrix()[0] @ coord_4.T).T)
+        [[ -1.   0.   2.   1.]
+         [ -4.   3.   5.   1.]
+         [ -7.   6.   8.   1.]
+         [-10.   9.  11.   1.]
+         [-13.  12.  14.   1.]]
+
+        """
+        n_models = self.rotation.shape[0]
+        rotation_mat = _3d_identity(n_models, 4)
+        rotation_mat[:, :3, :3] = self.rotation
+        center_translation_mat = _3d_identity(n_models, 4)
+        center_translation_mat[:, :3, 3] = self.center_translation
+        target_translation_mat = _3d_identity(n_models, 4)
+        target_translation_mat[:, :3, 3] = self.target_translation
+        return target_translation_mat @ rotation_mat @ center_translation_mat
+
+
+def _expand_dims(array, n_dims):
+    """
+    Expand the dimensions of an `ndarray` to a certain number of
+    dimensions.
+    """
+    while array.ndim < n_dims:
+        array = array[np.newaxis, ...]
+    return array
+
+
+def _3d_identity(m, n):
+    """
+    Create an array of *m* identity matrices of shape *(n, n)*
+    """
+    matrices = np.zeros((m, n, n), dtype=float)
+    indices = np.arange(n)
+    matrices[:, indices, indices] = 1
+    return matrices
+
+
 def superimpose(fixed, mobile, atom_mask=None):
     """
-    Superimpose structures onto a fixed structure.
+    Superimpose structures onto each other, minimizing the RMSD between
+    them.
+    :footcite:`Kabsch1976, Kabsch1978`.
 
-    The superimposition is performed using the Kabsch algorithm
-    :footcite:`Kabsch1976, Kabsch1978`, so that the RMSD between the
-    superimposed and the fixed structure is minimized.
+    More precisely, the `mobile` structure is rotated and translated onto
+    the `fixed` structure.
 
     Parameters
     ----------
     fixed : AtomArray, shape(n,) or AtomArrayStack, shape(m,n) or ndarray, shape(n,), dtype=float or ndarray, shape(m,n), dtype=float
-        The fixed structure.
+        The fixed structure(s).
         Alternatively coordinates can be given.
     mobile: AtomArray, shape(n,) or AtomArrayStack, shape(m,n) or ndarray, shape(n,), dtype=float or ndarray, shape(m,n), dtype=float
         The structure(s) which is/are superimposed on the `fixed`
         structure.
         Each atom at index *i* in `mobile` must correspond the
         atom at index *i* in `fixed` to obtain correct results.
+        Furthermore, if both `fixed` and `mobile` are
+        :class:`AtomArrayStack` objects, they must have the same
+        number of models.
         Alternatively coordinates can be given.
     atom_mask: ndarray, dtype=bool, optional
         If given, only the atoms covered by this boolean mask will be
@@ -108,15 +241,19 @@ def superimpose(fixed, mobile, atom_mask=None):
     -------
     fitted : AtomArray or AtomArrayStack or ndarray, shape(n,), dtype=float or ndarray, shape(m,n), dtype=float
         A copy of the `mobile` structure(s),
-        superimposed on the fixed structure.
+        superimposed on the fixed structure(s).
         Only coordinates are returned, if coordinates were given in
         `mobile`.
     transformation : AffineTransformation
-        This object contains the affine transformation(s) that were
-        applied on `mobile`.
+        The affine transformation(s) that were applied on `mobile`.
         :meth:`AffineTransformation.apply()` can be used to transform
         another AtomArray in the same way.
 
+    See Also
+    --------
+    superimpose_without_outliers : Superimposition with outlier removal
+    superimpose_homologs : Superimposition of homologous structures
+
     Notes
     -----
     The `transformation` can come in handy, in case you want to
@@ -186,6 +323,258 @@ def superimpose(fixed, mobile, atom_mask=None):
     return transform.apply(mobile), transform
 
 
+def superimpose_without_outliers(fixed, mobile, min_anchors=3,
+                                 max_iterations=10, quantiles=(0.25, 0.75),
+                                 outlier_threshold=1.5):
+    r"""
+    Superimpose structures onto a fixed structure, ignoring
+    conformational outliers.
+
+    This method iteratively superimposes the `mobile` structure onto the
+    `fixed` structure, removes conformational outliers and superimposes
+    the remaining atoms (called *anchors*) again until no outlier
+    remains.
+
+
+    Parameters
+    ----------
+    fixed : AtomArray, shape(n,) or AtomArrayStack, shape(m,n) or ndarray, shape(n,), dtype=float or ndarray, shape(m,n), dtype=float
+        The fixed structure(s).
+        Alternatively coordinates can be given.
+    mobile: AtomArray, shape(n,) or AtomArrayStack, shape(m,n) or ndarray, shape(n,), dtype=float or ndarray, shape(m,n), dtype=float
+        The structure(s) which is/are superimposed on the `fixed`
+        structure.
+        Each atom at index *i* in `mobile` must correspond the
+        atom at index *i* in `fixed` to obtain correct results.
+        Furthermore, if both `fixed` and `mobile` are
+        :class:`AtomArrayStack` objects, they must have the same
+        number of models.
+        Alternatively coordinates can be given.
+    min_anchors : int, optional
+        The outlier removal is stopped, if less than `min_anchors`
+        anchors would be left.
+    max_iterations : int, optional
+        The maximum number of iterations for removing conformational
+        outliers.
+        Setting the value to 1 means that no outlier removal is
+        conducted.
+    quantiles : tuple (float, float), optional
+        The lower and upper quantile for the interpercentile range
+        (IPR).
+        By default the interquartile range is taken.
+    outlier_threshold : float, optional
+        The threshold for considering a conformational outlier.
+        The threshold is given in units of IPR.
+
+    Returns
+    -------
+    fitted : AtomArray or AtomArrayStack
+        A copy of the `mobile` structure(s), superimposed on the fixed
+        structure.
+        Only coordinates are returned, if coordinates were given in
+        `mobile`.
+    transform : AffineTransformation
+        This object contains the affine transformation(s) that were
+        applied on `mobile`.
+        :meth:`AffineTransformation.apply()` can be used to transform
+        another AtomArray in the same way.
+    anchor_indices : ndarray, shape(k,), dtype=int
+        The indices of the anchor atoms.
+        These atoms were used for the superimposition.
+
+    See Also
+    --------
+    superimpose : Superimposition without outlier removal
+    superimpose_homologs : Superimposition of homologous structures
+
+    Notes
+    -----
+    This method runs the following algorithm in iterations:
+
+    1. Superimpose anchor atoms of `mobile` onto `fixed`.
+    2. Calculate the squared distance :math:`d^2` between the
+       superimposed anchors.
+    3. Remove conformational outliers from anchors based on the
+       following criterion:
+
+       .. math:: d^2 > P_\text{upper}(d^2) + \left( P_\text{upper}(d^2) - P_\text{lower}(d^2) \right) \cdot T
+
+       In prose this means that an anchor is considered an outlier, if
+       it is `outlier_threshold` :math:`T` times the interpercentile
+       range (IPR) above the upper percentile.
+       By default, this is 1.5 times the interquartile range, which is
+       the usual threshold to mark outliers in box plots.
+
+    In the beginning, all atoms are considered as anchors.
+
+    Considering all atoms (not only the anchors), this approach does
+    **not** minimize the RMSD, in contrast to :func:`superimpose()`.
+    The purpose of this function is to ignore outliers to decrease the
+    RMSD in the more conserved parts of the structure.
+    """
+    if max_iterations < 1:
+        raise ValueError("Maximum number of iterations must be at least 1")
+
+    # Ensure that the first quantile is smaller than the second one
+    quantiles = sorted(quantiles)
+
+    fixed_coord = coord(fixed)
+    mobile_coord = coord(mobile)
+    # Before refinement, all anchors are included
+    # 'inlier' is the opposite of 'outlier'
+    updated_inlier_mask = np.ones(fixed_coord.shape[-2], dtype=bool)
+
+    for _ in range(max_iterations):
+        # Run superimposition
+        inlier_mask = updated_inlier_mask
+        filtered_fixed_coord = fixed_coord[..., inlier_mask, :]
+        filtered_mobile_coord = mobile_coord[..., inlier_mask, :]
+        superimposed_coord, transform = superimpose(
+            filtered_fixed_coord, filtered_mobile_coord
+        )
+
+        # Find outliers
+        sq_dist = distance(filtered_fixed_coord, superimposed_coord) ** 2
+        if sq_dist.ndim == 2:
+            # If multiple models are superimposed,
+            # use the mean squared distance to determine outliers
+            sq_dist = np.mean(sq_dist, axis=0)
+        lower_quantile, upper_quantile = np.quantile(sq_dist, quantiles)
+        ipr = upper_quantile - lower_quantile
+        updated_inlier_mask = inlier_mask.copy()
+        # Squared distance was only calculated for the existing inliers
+        # -> update the mask only for these atoms
+        updated_inlier_mask[updated_inlier_mask] = (
+            sq_dist <= upper_quantile + outlier_threshold * ipr
+        )
+        if np.all(updated_inlier_mask):
+            # No outliers anymore -> early termination
+            break
+        if np.count_nonzero(updated_inlier_mask) < min_anchors:
+            # Less than min_anchors anchors would be left -> early termination
+            break
+
+    anchor_indices = np.where(inlier_mask)[0]
+    return transform.apply(mobile), transform, anchor_indices
+
+
+def superimpose_homologs(fixed, mobile, substitution_matrix=None,
+                         gap_penalty=-10, min_anchors=3, **kwargs):
+    r"""
+    Superimpose one protein or nucleotide chain onto another one,
+    considering sequence differences and conformational outliers.
+
+    The method finds corresponding residues by sequence alignment and
+    selects their :math:`C_{\alpha}` or :math:`P` atoms as
+    superimposition *anchors*.
+    Then iteratively the anchor atoms are superimposed and outliers are
+    removed.
+
+    Parameters
+    ----------
+    fixed : AtomArray, shape(n,) or AtomArrayStack, shape(m,n)
+        The fixed structure(s).
+        Must comprise a single chain.
+    mobile : AtomArray, shape(n,) or AtomArrayStack, shape(m,n)
+        The structure(s) which is/are superimposed on the `fixed`
+        structure.
+        Must comprise a single chain.
+    substitution_matrix : str or SubstitutionMatrix, optional
+        The (name of the) substitution matrix used for sequence
+        alignment.
+        Must fit the chain type.
+        By default, ``"BLOSUM62"`` and ``"NUC"`` are used respectively.
+        Only aligned residues with a positive score are considered as
+        initial anchors.
+    gap_penalty : int or tuple of int, optional
+        The gap penalty for sequence alignment.
+        A single value indicates a linear penalty, while a tuple
+        indicates an affine penalty.
+    min_anchors : int, optional
+        If less than `min_anchors` anchors are found by sequence
+        alignment, the method ditches the alignment and matches all
+        anchor atoms.
+        If the number of anchor atoms is not equal in `fixed` and
+        `mobile` in this fallback case, an exception is raised.
+        Furthermore, the outlier removal is stopped, if less than
+        `min_anchors` anchors would be left.
+    **kwargs
+        Additional parameters for
+        :func:`superimpose_without_outliers()`.
+
+    Returns
+    -------
+    fitted : AtomArray or AtomArrayStack
+        A copy of the `mobile` structure(s), superimposed on the fixed
+        structure(s).
+    transform : AffineTransformation
+        This object contains the affine transformation(s) that were
+        applied on `mobile`.
+        :meth:`AffineTransformation.apply()` can be used to transform
+        another AtomArray in the same way.
+    fixed_anchor_indices, mobile_anchor_indices : ndarray, shape(k,), dtype=int
+        The indices of the anchor atoms in the fixed and mobile
+        structure, respectively.
+        These atoms were used for the superimposition.
+
+    See Also
+    --------
+    superimpose : Superimposition without outlier removal
+    superimpose_without_outliers : Internally used for outlier removal
+
+    Notes
+    -----
+    As this method relies on sequence alignment, it works only for
+    proteins/nucleic acids with decent sequence homology.
+    """
+    fixed_anchor_indices = _get_backbone_anchor_indices(fixed)
+    mobile_anchor_indices = _get_backbone_anchor_indices(mobile)
+    if (
+        len(fixed_anchor_indices) < min_anchors or
+        len(mobile_anchor_indices) < min_anchors
+    ):
+        raise ValueError(
+            "Structures have too few CA atoms for required number of anchors"
+        )
+
+    anchor_indices = _find_matching_anchors(
+        fixed[..., fixed_anchor_indices],
+        mobile[..., mobile_anchor_indices],
+        substitution_matrix,
+        gap_penalty,
+    )
+    if len(anchor_indices) < min_anchors:
+        # Fallback: Match all backbone anchors
+        if len(fixed_anchor_indices) != len(mobile_anchor_indices):
+            raise ValueError(
+                "Tried fallback due to low anchor number, "
+                "but number of CA atoms does not match"
+            )
+        fixed_anchor_indices = fixed_anchor_indices
+        mobile_anchor_indices = mobile_anchor_indices
+    else:
+        # The anchor indices point to the CA atoms
+        # -> get the corresponding indices for the whole structure
+        fixed_anchor_indices = fixed_anchor_indices[anchor_indices[:, 0]]
+        mobile_anchor_indices = mobile_anchor_indices[anchor_indices[:, 1]]
+
+    _, transform, selected_anchor_indices = superimpose_without_outliers(
+        fixed[..., fixed_anchor_indices],
+        mobile[..., mobile_anchor_indices],
+        min_anchors,
+        **kwargs
+    )
+    fixed_anchor_indices = fixed_anchor_indices[selected_anchor_indices]
+    mobile_anchor_indices = mobile_anchor_indices[selected_anchor_indices]
+
+    return (
+        transform.apply(mobile),
+        transform,
+        fixed_anchor_indices,
+        mobile_anchor_indices,
+    )
+
+
 def superimpose_apply(atoms, transformation):
     """
     Superimpose structures using a given :class:`AffineTransformation`.
@@ -266,3 +655,73 @@ def _multi_matmul(matrices, vectors):
         ),
         axes=(0, 2, 1)
     )
+
+
+def _get_backbone_anchor_indices(atoms):
+    """
+    Select one representative anchor atom for each amino acid and
+    nucleotide and return their indices.
+    """
+    return np.where(
+        ((filter_amino_acids(atoms)) & (atoms.atom_name == "CA")) |
+        ((filter_nucleotides(atoms)) & (atoms.atom_name == "P"))
+    )[0]
+
+
+def _find_matching_anchors(
+    fixed_anchor_atoms,
+    mobile_anchors_atoms,
+    substitution_matrix,
+    gap_penalty,
+):
+    """
+    Find corresponding residues using pairwise sequence alignment.
+    """
+    fixed_seq = _to_sequence(fixed_anchor_atoms)
+    mobile_seq = _to_sequence(mobile_anchors_atoms)
+    common_alph = common_alphabet([fixed_seq.alphabet, mobile_seq.alphabet])
+    if common_alph is None:
+        raise ValueError("Cannot superimpose peptides with nucleic acids")
+
+    if substitution_matrix is None:
+        if isinstance(fixed_seq, ProteinSequence):
+            substitution_matrix = SubstitutionMatrix.std_protein_matrix()
+        else:
+            substitution_matrix = SubstitutionMatrix.std_nucleotide_matrix()
+    elif isinstance(substitution_matrix, str):
+        substitution_matrix = SubstitutionMatrix(
+            common_alph, common_alph, substitution_matrix
+        )
+    score_matrix = substitution_matrix.score_matrix()
+
+    alignment = align_optimal(
+        fixed_seq,
+        mobile_seq,
+        substitution_matrix,
+        gap_penalty,
+        terminal_penalty=False,
+        max_number=1,
+    )[0]
+    alignment_codes = get_codes(alignment)
+    anchor_mask = (
+        # Anchors must be similar amino acids
+        (score_matrix[alignment_codes[0], alignment_codes[1]] > 0)
+        # Cannot anchor gaps
+        & (alignment_codes[0] != -1)
+        & (alignment_codes[1] != -1)
+    )
+    anchors = alignment.trace[anchor_mask]
+    return anchors
+
+
+def _to_sequence(atoms):
+    sequences, _ = to_sequence(atoms, allow_hetero=True)
+    if len(sequences) == 0:
+        raise ValueError(
+            "Structure does not contain any amino acids or nucleotides"
+        )
+    if len(sequences) > 1:
+        raise ValueError(
+            "Structure contains multiple chains, but only one is allowed"
+        )
+    return sequences[0]

{biotite-0.40.0.dist-info → biotite-0.41.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biotite
-Version: 0.40.0
+Version: 0.41.0
 Summary: A comprehensive library for computational molecular biology
 Author: The Biotite contributors
 License: BSD 3-Clause License
@@ -48,7 +48,7 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.rst
 Requires-Dist: requests >=2.12