biotite 0.41.1__cp310-cp310-win_amd64.whl → 1.0.0__cp310-cp310-win_amd64.whl

biotite/structure/repair.py

@@ -8,80 +8,14 @@ This module contains functionalities for repairing malformed structures.
 
 __name__ = "biotite.structure"
 __author__ = "Patrick Kunzmann, Daniel Bauer"
-__all__ = ["renumber_atom_ids", "renumber_res_ids",
-           "create_continuous_res_ids", "infer_elements", "create_atom_names"]
+__all__ = ["create_continuous_res_ids", "infer_elements", "create_atom_names"]
 
-from collections import Counter
 import warnings
+from collections import Counter
 import numpy as np
-from .atoms import AtomArray, AtomArrayStack
-from .residues import get_residue_starts
-from .chains import get_chain_starts
-
-
-def renumber_atom_ids(array, start=None):
-    """
-    Renumber the atom IDs of the given array.
-
-    DEPRECATED.
-
-    Parameters
-    ----------
-    array : AtomArray or AtomArrayStack
-        The array to be checked.
-    start : int, optional
-        The starting index for renumbering.
-        The first ID in the array is taken by default.
-
-    Returns
-    -------
-    array : AtomArray or AtomArrayStack
-        The renumbered array.
-    """
-    warnings.warn(
-      "'renumber_atom_ids()' is deprecated",
-        DeprecationWarning
-    )
-    if "atom_id" not in array.get_annotation_categories():
-        raise ValueError("The atom array must have the 'atom_id' annotation")
-    if start is None:
-        start = array.atom_id[0]
-    array = array.copy()
-    array.atom_id = np.arange(start, array.shape[-1]+1)
-    return array
-
-
-def renumber_res_ids(array, start=None):
-    """
-    Renumber the residue IDs of the given array, so that are continuous.
-
-    DEPRECATED: Use :func:`create_continuous_res_ids()`instead.
-
-    Parameters
-    ----------
-    array : AtomArray or AtomArrayStack
-        The array to be checked.
-    start : int, optional
-        The starting index for renumbering.
-        The first ID in the array is taken by default.
-
-    Returns
-    -------
-    array : AtomArray or AtomArrayStack
-        The renumbered array.
-    """
-    warnings.warn(
-      "'renumber_res_ids()' is deprecated, use 'create_continuous_res_ids()'",
-        DeprecationWarning
-    )
-    if start is None:
-        start = array.res_id[0]
-    diff = np.diff(array.res_id)
-    diff[diff != 0] = 1
-    new_res_ids =  np.concatenate(([start], diff)).cumsum()
-    array = array.copy()
-    array.res_id = new_res_ids
-    return array
+from biotite.structure.atoms import AtomArray, AtomArrayStack
+from biotite.structure.chains import get_chain_starts
+from biotite.structure.residues import get_residue_starts
 
 
 def create_continuous_res_ids(atoms, restart_each_chain=True):
@@ -217,18 +151,131 @@ def create_atom_names(atoms):
     return atom_names
 
 
-_elements = [elem.upper() for elem in
-["H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne", "Na", "Mg",
-"Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca", "Sc", "Ti", "V", "Cr", "Mn", "Fe",
-"Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr", "Rb", "Sr", "Y",
-"Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn", "Sb", "Te",
-"I", "Xe", "Cs", "Ba", "La", "Ce", "Pr", "Nd", "Pm", "Sm", "Eu", "Gd", "Tb",
-"Dy", "Ho", "Er", "Tm", "Yb", "Lu", "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt",
-"Au", "Hg", "Tl", "Pb", "Bi", "Po", "At", "Rn", "Fr", "Ra", "Ac", "Th", "Pa",
-"U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm", "Md", "No", "Lr", "Rf",
-"Db", "Sg", "Bh", "Hs", "Mt", "Ds", "Rg", "Cn", "Nh", "Fl", "Mc", "Lv", "Ts",
-"Og"]
+_elements = [
+    elem.upper()
+    for elem in [
+        "H",
+        "He",
+        "Li",
+        "Be",
+        "B",
+        "C",
+        "N",
+        "O",
+        "F",
+        "Ne",
+        "Na",
+        "Mg",
+        "Al",
+        "Si",
+        "P",
+        "S",
+        "Cl",
+        "Ar",
+        "K",
+        "Ca",
+        "Sc",
+        "Ti",
+        "V",
+        "Cr",
+        "Mn",
+        "Fe",
+        "Co",
+        "Ni",
+        "Cu",
+        "Zn",
+        "Ga",
+        "Ge",
+        "As",
+        "Se",
+        "Br",
+        "Kr",
+        "Rb",
+        "Sr",
+        "Y",
+        "Zr",
+        "Nb",
+        "Mo",
+        "Tc",
+        "Ru",
+        "Rh",
+        "Pd",
+        "Ag",
+        "Cd",
+        "In",
+        "Sn",
+        "Sb",
+        "Te",
+        "I",
+        "Xe",
+        "Cs",
+        "Ba",
+        "La",
+        "Ce",
+        "Pr",
+        "Nd",
+        "Pm",
+        "Sm",
+        "Eu",
+        "Gd",
+        "Tb",
+        "Dy",
+        "Ho",
+        "Er",
+        "Tm",
+        "Yb",
+        "Lu",
+        "Hf",
+        "Ta",
+        "W",
+        "Re",
+        "Os",
+        "Ir",
+        "Pt",
+        "Au",
+        "Hg",
+        "Tl",
+        "Pb",
+        "Bi",
+        "Po",
+        "At",
+        "Rn",
+        "Fr",
+        "Ra",
+        "Ac",
+        "Th",
+        "Pa",
+        "U",
+        "Np",
+        "Pu",
+        "Am",
+        "Cm",
+        "Bk",
+        "Cf",
+        "Es",
+        "Fm",
+        "Md",
+        "No",
+        "Lr",
+        "Rf",
+        "Db",
+        "Sg",
+        "Bh",
+        "Hs",
+        "Mt",
+        "Ds",
+        "Rg",
+        "Cn",
+        "Nh",
+        "Fl",
+        "Mc",
+        "Lv",
+        "Ts",
+        "Og",
+    ]
 ]
+
+
 def _guess_element(atom_name):
     # remove digits (1H -> H)
     elem = "".join([i for i in atom_name if not i.isdigit()])
@@ -237,9 +284,13 @@ def _guess_element(atom_name):
         return ""
 
     # Some often used elements for biomolecules
-    if elem.startswith("C") or elem.startswith("N") or \
-        elem.startswith("O") or elem.startswith("S") or \
-        elem.startswith("H"):
+    if (
+        elem.startswith("C")
+        or elem.startswith("N")
+        or elem.startswith("O")
+        or elem.startswith("S")
+        or elem.startswith("H")
+    ):
         return elem[0]
 
     # Exactly match element abbreviations
@@ -250,4 +301,4 @@ def _guess_element(atom_name):
             return _elements[_elements.index(elem[0])]
         except ValueError:
             warnings.warn(f"Could not infer element for '{atom_name}'")
-            return ""
+            return ""

biotite/structure/residues.py

@@ -9,14 +9,27 @@ atom level.
 
 __name__ = "biotite.structure"
 __author__ = "Patrick Kunzmann"
-__all__ = ["get_residue_starts", "apply_residue_wise", "spread_residue_wise",
-           "get_residue_masks", "get_residue_starts_for",
-           "get_residue_positions", "get_residues", "get_residue_count",
-           "residue_iter"]
+__all__ = [
+    "get_residue_starts",
+    "apply_residue_wise",
+    "spread_residue_wise",
+    "get_residue_masks",
+    "get_residue_starts_for",
+    "get_residue_positions",
+    "get_residues",
+    "get_residue_count",
+    "residue_iter",
+]
 
 import numpy as np
-from .atoms import AtomArray, AtomArrayStack
-from .resutil import *
+from biotite.structure.segments import (
+    apply_segment_wise,
+    get_segment_masks,
+    get_segment_positions,
+    get_segment_starts_for,
+    segment_iter,
+    spread_segment_wise,
+)
 
 
 def get_residue_starts(array, add_exclusive_stop=False):
@@ -57,23 +70,20 @@ def get_residue_starts(array, add_exclusive_stop=False):
      278 292 304]
     """
     # These mask are 'true' at indices where the value changes
-    chain_id_changes = (array.chain_id[1:] != array.chain_id[:-1])
-    res_id_changes   = (array.res_id[1:]   != array.res_id[:-1]  )
-    ins_code_changes = (array.ins_code[1:] != array.ins_code[:-1])
-    res_name_changes = (array.res_name[1:] != array.res_name[:-1])
+    chain_id_changes = array.chain_id[1:] != array.chain_id[:-1]
+    res_id_changes = array.res_id[1:] != array.res_id[:-1]
+    ins_code_changes = array.ins_code[1:] != array.ins_code[:-1]
+    res_name_changes = array.res_name[1:] != array.res_name[:-1]
 
     # If any of these annotation arrays change, a new residue starts
     residue_change_mask = (
-        chain_id_changes |
-        res_id_changes |
-        ins_code_changes |
-        res_name_changes
+        chain_id_changes | res_id_changes | ins_code_changes | res_name_changes
     )
 
     # Convert mask to indices
     # Add 1, to shift the indices from the end of a residue
     # to the start of a new residue
-    residue_starts = np.where(residue_change_mask)[0] +1
+    residue_starts = np.where(residue_change_mask)[0] + 1
 
     # The first residue is not included yet -> Insert '[0]'
     if add_exclusive_stop:
@@ -197,7 +207,7 @@ def spread_residue_wise(array, input_data):
     Spread secondary structure annotation to every atom of a 20 residue
     peptide (with 304 atoms).
 
-        >>> sse = annotate_sse(atom_array, "A")
+        >>> sse = annotate_sse(atom_array)
         >>> print(len(sse))
         20
         >>> print(sse)

biotite/structure/{resutil.py → segments.py}

@@ -4,8 +4,14 @@
 
 __name__ = "biotite.structure"
 __author__ = "Patrick Kunzmann"
-__all__ = ["apply_segment_wise", "spread_segment_wise", "get_segment_masks",
-           "get_segment_starts_for", "get_segment_positions", "segment_iter"]
+__all__ = [
+    "apply_segment_wise",
+    "spread_segment_wise",
+    "get_segment_masks",
+    "get_segment_starts_for",
+    "get_segment_positions",
+    "segment_iter",
+]
 
 import numpy as np
 
@@ -24,9 +30,9 @@ def apply_segment_wise(starts, data, function, axis):
     """
     # The result array
     processed_data = None
-    for i in range(len(starts)-1):
-        segment = data[starts[i]:starts[i+1]]
-        if axis == None:
+    for i in range(len(starts) - 1):
+        segment = data[starts[i] : starts[i + 1]]
+        if axis is None:
             value = function(segment)
         else:
             value = function(segment, axis=axis)
@@ -39,13 +45,11 @@ def apply_segment_wise(starts, data, function, axis):
                 # is length of segment of size 1 -> length of all IDs
                 # (equal to atom array length)
                 processed_data = np.zeros(
-                    (len(starts)-1,) + value.shape, dtype=value.dtype
+                    (len(starts) - 1,) + value.shape, dtype=value.dtype
                 )
             else:
                 # Scalar value -> one dimensional result array
-                processed_data = np.zeros(
-                    len(starts)-1, dtype=type(value)
-                )
+                processed_data = np.zeros(len(starts) - 1, dtype=type(value))
         # Write values into result arrays
         processed_data[i] = value
     return processed_data
@@ -64,7 +68,7 @@ def spread_segment_wise(starts, input_data):
         atom array.
     """
     output_data = np.zeros(starts[-1], dtype=input_data.dtype)
-    for i in range(len(starts)-1):
+    for i in range(len(starts) - 1):
         start = starts[i]
         stop = starts[i + 1]
         output_data[start:stop] = input_data[i]
@@ -92,14 +96,13 @@ def get_segment_masks(starts, indices):
     if (indices >= length).any():
         index = np.min(np.where(indices >= length)[0])
         raise ValueError(
-            f"Index {index} is out of range for "
-            f"an atom array with length {length}"
+            f"Index {index} is out of range for " f"an atom array with length {length}"
         )
-    
+
     insertion_points = np.searchsorted(starts, indices, side="right") - 1
     for i, point in enumerate(insertion_points):
-        masks[i, starts[point] : starts[point+1]] = True
-    
+        masks[i, starts[point] : starts[point + 1]] = True
+
     return masks
 
 
@@ -125,10 +128,9 @@ def get_segment_starts_for(starts, indices):
     if (indices >= length).any():
         index = np.min(np.where(indices >= length)[0])
         raise ValueError(
-            f"Index {index} is out of range for "
-            f"an atom array with length {length}"
+            f"Index {index} is out of range for " f"an atom array with length {length}"
         )
-    
+
     insertion_points = np.searchsorted(starts, indices, side="right") - 1
     return starts[insertion_points]
 
@@ -155,10 +157,9 @@ def get_segment_positions(starts, indices):
     if (indices >= length).any():
         index = np.min(np.where(indices >= length)[0])
         raise ValueError(
-            f"Index {index} is out of range for "
-            f"an atom array with length {length}"
+            f"Index {index} is out of range for " f"an atom array with length {length}"
         )
-    
+
     return np.searchsorted(starts, indices, side="right") - 1
 
 
@@ -174,5 +175,5 @@ def segment_iter(array, starts):
         Includes exclusive stop, i.e. the length of the corresponding
         atom array.
     """
-    for i in range(len(starts)-1):
-        yield array[..., starts[i] : starts[i+1]]
+    for i in range(len(starts) - 1):
+        yield array[..., starts[i] : starts[i + 1]]

biotite/structure/sequence.py

@@ -11,13 +11,12 @@ __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
-
+from biotite.sequence.seqtypes import NucleotideSequence, ProteinSequence
+from biotite.structure.chains import get_chain_starts
+from biotite.structure.error import BadStructureError
+from biotite.structure.info.groups import amino_acid_names, nucleotide_names
+from biotite.structure.info.misc import one_letter_code
+from biotite.structure.residues import get_residues
 
 HETERO_PLACEHOLDER = "."
 
@@ -63,9 +62,9 @@ def to_sequence(atoms, allow_hetero=False):
     """
     sequences = []
     chain_start_indices = get_chain_starts(atoms, add_exclusive_stop=True)
-    for i in range(len(chain_start_indices)-1):
+    for i in range(len(chain_start_indices) - 1):
         start = chain_start_indices[i]
-        stop = chain_start_indices[i+1]
+        stop = chain_start_indices[i + 1]
         chain = atoms[start:stop]
         _, residues = get_residues(chain)
         one_letter_symbols = np.array(
@@ -73,7 +72,7 @@ def to_sequence(atoms, allow_hetero=False):
         )
         hetero_mask = one_letter_symbols == HETERO_PLACEHOLDER
 
-        aa_count  = np.count_nonzero(np.isin(residues, amino_acid_names()))
+        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(
@@ -109,4 +108,4 @@ def to_sequence(atoms, allow_hetero=False):
             sequences.append(NucleotideSequence("".join(one_letter_symbols)))
 
     # Remove exclusive stop
-    return sequences, chain_start_indices[:-1]
+    return sequences, chain_start_indices[:-1]