biotite 0.41.2__cp311-cp311-win_amd64.whl → 1.0.0__cp311-cp311-win_amd64.whl

biotite/structure/chains.py

@@ -9,22 +9,38 @@ atom level.
 
 __name__ = "biotite.structure"
 __author__ = "Patrick Kunzmann"
-__all__ = ["get_chain_starts", "apply_chain_wise", "spread_chain_wise",
-           "get_chain_masks", "get_chain_starts_for", "get_chain_positions",
-           "chain_iter", "get_chains", "get_chain_count", "chain_iter"]
+__all__ = [
+    "get_chain_starts",
+    "apply_chain_wise",
+    "spread_chain_wise",
+    "get_chain_masks",
+    "get_chain_starts_for",
+    "get_chain_positions",
+    "chain_iter",
+    "get_chains",
+    "get_chain_count",
+    "chain_iter",
+]
 
 import numpy as np
-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_chain_starts(array, add_exclusive_stop=False):
     """
     Get the indices in an atom array, which indicates the beginning of
     a new chain.
-    
+
     A new chain starts, when the chain ID changes or when the residue ID
     decreases.
-    
+
     Parameters
     ----------
     array : AtomArray or AtomArrayStack
@@ -33,17 +49,17 @@ def get_chain_starts(array, add_exclusive_stop=False):
         If true, the exclusive stop of the input atom array, i.e.
         ``array.array_length()``, is added to the returned array of
         start indices as last element.
-        
+
     Returns
     -------
     starts : ndarray, dtype=int
         The start indices of new chains in `array`.
-    
+
     Notes
     -----
     This method is internally used by all other chain-related
     functions.
-    
+
     See also
     --------
     get_residue_starts
@@ -51,13 +67,13 @@ def get_chain_starts(array, add_exclusive_stop=False):
     diff = np.diff(array.res_id)
     res_id_decrement = diff < 0
     # This mask is 'true' at indices where the value changes
-    chain_id_changes = (array.chain_id[1:] != array.chain_id[:-1])
-    
+    chain_id_changes = array.chain_id[1:] != array.chain_id[:-1]
+
     # Convert mask to indices
     # Add 1, to shift the indices from the end of a chain
     # to the start of a new chain
     chain_starts = np.where(res_id_decrement | chain_id_changes)[0] + 1
-    
+
     # The first chain is not included yet -> Insert '[0]'
     if add_exclusive_stop:
         return np.concatenate(([0], chain_starts, [array.array_length()]))
@@ -69,7 +85,7 @@ def apply_chain_wise(array, data, function, axis=None):
     """
     Apply a function to intervals of data, where each interval
     corresponds to one chain.
-    
+
     The function takes an atom array (stack) and an data array
     (`ndarray`) of the same length. The function iterates through the
     chain IDs of the atom array (stack) and identifies intervals of
@@ -77,8 +93,8 @@ def apply_chain_wise(array, data, function, axis=None):
     partitioned into the same intervals, and each interval (also an
     :class:`ndarray`) is put as parameter into `function`. Each return value is
     stored as element in the resulting :class:`ndarray`, therefore each element
-    corresponds to one chain. 
-    
+    corresponds to one chain.
+
     Parameters
     ----------
     array : AtomArray or AtomArrayStack
@@ -92,14 +108,14 @@ def apply_chain_wise(array, data, function, axis=None):
         must return a value with the same shape and data type.
     axis : int, optional
         This value is given to the `axis` parameter of `function`.
-        
+
     Returns
     -------
     processed_data : ndarray
         Chain-wise evaluation of `data` by `function`. The size of the
         first dimension of this array is equal to the amount of
         chains.
-        
+
     See also
     --------
     apply_residue_wise
@@ -114,11 +130,11 @@ def spread_chain_wise(array, input_data):
 
     Each value in the chain-wise input is assigned to all atoms of
     this chain:
-    
+
     ``output_data[i] = input_data[j]``,
     *i* is incremented from atom to atom,
     *j* is incremented every chain change.
-    
+
     Parameters
     ----------
     array : AtomArray or AtomArrayStack
@@ -126,13 +142,13 @@ def spread_chain_wise(array, input_data):
     input_data : ndarray
         The data to be spread. The length of axis=0 must be equal to
         the amount of different chain IDs in `array`.
-        
+
     Returns
     -------
     output_data : ndarray
         Chain-wise spread `input_data`. Length is the same as
         `array_length()` of `array`.
-        
+
     See also
     --------
     spread_residue_wise
@@ -154,14 +170,14 @@ def get_chain_masks(array, indices):
         These indices indicate the atoms to get the corresponding
         chains for.
         Negative indices are not allowed.
-    
+
     Returns
     -------
     chains_masks : ndarray, dtype=bool, shape=(k,n)
         Multiple boolean masks, one for each given index in `indices`.
         Each array masks the atoms that belong to the same chain as
         the atom at the given index.
-    
+
     See also
     --------
     get_residue_masks
@@ -183,13 +199,13 @@ def get_chain_starts_for(array, indices):
         These indices point to the atoms to get the corresponding
         chain starts for.
         Negative indices are not allowed.
-    
+
     Returns
     -------
     start_indices : ndarray, dtype=int, shape=(k,)
         The indices that point to the chain starts for the input
         `indices`.
-    
+
     See also
     --------
     get_residue_starts_for
@@ -214,12 +230,12 @@ def get_chain_positions(array, indices):
         These indices point to the atoms to get the corresponding
         chain positions for.
         Negative indices are not allowed.
-    
+
     Returns
     -------
     start_indices : ndarray, dtype=int, shape=(k,)
         The indices that point to the position of the chains.
-    
+
     See also
     --------
     get_residue_positions
@@ -231,20 +247,20 @@ def get_chain_positions(array, indices):
 def get_chains(array):
     """
     Get the chain IDs of an atom array (stack).
-    
+
     The chains are listed in the same order they occur in the array
     (stack).
-    
+
     Parameters
     ----------
     array : AtomArray or AtomArrayStack
         The atom array (stack), where the chains are determined.
-        
+
     Returns
     -------
     ids : ndarray, dtype=str
         List of chain IDs.
-        
+
     See also
     --------
     get_residues
@@ -255,20 +271,20 @@ def get_chains(array):
 def get_chain_count(array):
     """
     Get the amount of chains in an atom array (stack).
-    
+
     The count is determined from the `chain_id` annotation.
     Each time the chain ID changes, the count is incremented.
-    
+
     Parameters
     ----------
     array : AtomArray or AtomArrayStack
         The atom array (stack), where the chains are counted.
-        
+
     Returns
     -------
     count : int
         Amount of chains.
-    
+
     See also
     --------
     get_residue_count
@@ -279,20 +295,20 @@ def get_chain_count(array):
 def chain_iter(array):
     """
     Iterate over all chains in an atom array (stack).
-    
+
     Parameters
     ----------
     array : AtomArray or AtomArrayStack
         The atom array (stack) to iterate over.
-        
+
     Yields
     ------
     chain : AtomArray or AtomArrayStack
         A single chain of the input `array`.
-    
+
     See also
     --------
     residue_iter
     """
     starts = get_chain_starts(array, add_exclusive_stop=True)
-    return segment_iter(array, starts)
+    return segment_iter(array, starts)

biotite/structure/compare.py

@@ -12,21 +12,21 @@ __author__ = "Patrick Kunzmann"
 __all__ = ["rmsd", "rmspd", "rmsf", "average"]
 
 import numpy as np
-from .atoms import Atom, AtomArray, AtomArrayStack, coord
-from .geometry import index_distance
-from .util import vector_dot
+from biotite.structure.atoms import AtomArrayStack, coord
+from biotite.structure.geometry import index_distance
+from biotite.structure.util import vector_dot
 
 
 def rmsd(reference, subject):
     r"""
     Calculate the RMSD between two structures.
-    
+
     The *root-mean-square-deviation* (RMSD) indicates the overall
     deviation of each model of a structure to a reference structure.
     It is defined as:
-    
+
     .. math:: RMSD = \sqrt{ \frac{1}{n} \sum\limits_{i=1}^n (x_i - x_{ref,i})^2}
-    
+
     Parameters
     ----------
     reference : AtomArray or ndarray, dtype=float, shape=(n,3)
@@ -37,7 +37,7 @@ def rmsd(reference, subject):
         Structure(s) to be compared with `reference`.
         Alternatively, coordinates can be provided directly as
         :class:`ndarray`.
-    
+
     Returns
     -------
     rmsd : float or ndarray, dtype=float, shape=(m,)
@@ -45,7 +45,7 @@ def rmsd(reference, subject):
         If subject is an :class:`AtomArray` a float is returned.
         If subject is an :class:`AtomArrayStack` a :class:`ndarray`
         containing the RMSD for each model is returned.
-    
+
     See Also
     --------
     rmsf
@@ -71,16 +71,17 @@ def rmsd(reference, subject):
     """
     return np.sqrt(np.mean(_sq_euclidian(reference, subject), axis=-1))
 
+
 def rmspd(reference, subject, periodic=False, box=None):
     r"""
-    Calculate the RMSD of atom pair distances for given structures 
+    Calculate the RMSD of atom pair distances for given structures
     relative to those found in a reference structure.
 
-    Unlike the standard RMSD, the *root-mean-square-pairwise-deviation* 
-    (RMSPD) is a fit-free method to determine deviations between 
+    Unlike the standard RMSD, the *root-mean-square-pairwise-deviation*
+    (RMSPD) is a fit-free method to determine deviations between
     a structure and a preset reference.
 
-    .. math:: RMSPD = \sqrt{ \frac{1}{n^2} \sum\limits_{i=1}^n \sum\limits_{j \neq i}^n (d_{ij} - d_{ref,ij})^2}  
+    .. math:: RMSPD = \sqrt{ \frac{1}{n^2} \sum\limits_{i=1}^n \sum\limits_{j \neq i}^n (d_{ij} - d_{ref,ij})^2}
 
     Parameters
     ----------
@@ -102,7 +103,7 @@ def rmspd(reference, subject, periodic=False, box=None):
     box : ndarray, shape=(3,3) or shape=(m,3,3), optional
         If this parameter is set, the given box is used instead of the
         `box` attribute of `atoms`.
-    
+
     Returns
     -------
     rmspd : float or ndarray, dtype=float, shape=(m,)
@@ -110,7 +111,7 @@ def rmspd(reference, subject, periodic=False, box=None):
         If subject is an :class:`AtomArray` a float is returned.
         If subject is an :class:`AtomArrayStack` a :class:`ndarray`
         containing the RMSD for each model is returned.
-    
+
     Warnings
     --------
     Internally, this function uses :func:`index_distance()`.
@@ -119,7 +120,7 @@ def rmspd(reference, subject, periodic=False, box=None):
     prior to the computation of RMSPDs with `periodic` set to false
     to ensure correct results.
     (e.g. with :func:`remove_pbc()`).
-    
+
     See also
     --------
     index_distance
@@ -134,9 +135,10 @@ def rmspd(reference, subject, periodic=False, box=None):
     refdist = index_distance(reference, pairs, periodic=periodic, box=box)
     subjdist = index_distance(subject, pairs, periodic=periodic, box=box)
 
-    rmspd = np.sqrt(np.sum((subjdist - refdist)**2, axis = -1))/reflen
+    rmspd = np.sqrt(np.sum((subjdist - refdist) ** 2, axis=-1)) / reflen
     return rmspd
 
+
 def rmsf(reference, subject):
     r"""
     Calculate the RMSF between two structures.
@@ -146,9 +148,9 @@ def rmsf(reference, subject):
     models.
     Usually the reference structure, is the average over all models.
     The RMSF is defined as:
-    
+
     .. math:: RMSF(i) = \sqrt{ \frac{1}{T} \sum\limits_{t=1}^T (x_i(t) - x_{ref,i}(t))^2}
-    
+
     Parameters
     ----------
     reference : AtomArray or ndarray, dtype=float, shape=(n,3)
@@ -161,14 +163,14 @@ def rmsf(reference, subject):
         :class:`AtomArrayStack`.
         Alternatively, coordinates can be provided directly as
         :class:`ndarray`.
-    
+
     Returns
     -------
     rmsf : ndarray, dtype=float, shape=(n,)
         RMSF between subject and reference structure.
         Each element gives the RMSF for the atom at the respective
         index.
-    
+
     See Also
     --------
     rmsd
@@ -198,41 +200,39 @@ def rmsf(reference, subject):
 def average(atoms):
     """
     Calculate an average structure.
-    
+
     The average structure has the average coordinates
     of the input models.
-    
+
     Parameters
     ----------
     atoms : AtomArrayStack or ndarray, dtype=float, shape=(m,n,3)
         The structure models to be averaged.
         Alternatively, coordinates can be provided directly as
         :class:`ndarray`.
-    
+
     Returns
     -------
     average : AtomArray or ndarray, dtype=float, shape=(n,3)
         Structure with averaged atom coordinates.
         If `atoms` is a :class:`ndarray` and :class:`ndarray` is also
         returned.
-    
+
     See Also
     --------
     rmsd, rmsf
-    
+
     Notes
     -----
     The calculated average structure is not suitable for visualization
     or geometric calculations, since bond lengths and angles will
     deviate from meaningful values.
     This method is rather useful to provide a reference structure for
-    calculation of e.g. the RMSD or RMSF. 
+    calculation of e.g. the RMSD or RMSF.
     """
     coords = coord(atoms)
     if coords.ndim != 3:
-        raise TypeError(
-            "Expected an AtomArrayStack or an ndarray with shape (m,n,3)"
-        )
+        raise TypeError("Expected an AtomArrayStack or an ndarray with shape (m,n,3)")
     mean_coords = np.mean(coords, axis=0)
     if isinstance(atoms, AtomArrayStack):
         mean_array = atoms[0].copy()
@@ -246,7 +246,7 @@ def _sq_euclidian(reference, subject):
     """
     Calculate squared euclidian distance between atoms in two
     structures.
-    
+
     Parameters
     ----------
     reference : AtomArray or ndarray, dtype=float, shape=(n,3)
@@ -254,7 +254,7 @@ def _sq_euclidian(reference, subject):
     subject : AtomArray or AtomArrayStack or ndarray, dtype=float, shape=(n,3) or shape=(m,n,3)
         Structure(s) whose atoms squared euclidian distance to
         `reference` is measured.
-    
+
     Returns
     -------
     ndarray, dtype=float, shape=(n,) or shape=(m,n)
@@ -271,4 +271,4 @@ def _sq_euclidian(reference, subject):
             "Expected an AtomArray or an ndarray with shape (n,3) as reference"
         )
     dif = subject_coord - reference_coord
-    return vector_dot(dif, dif)
+    return vector_dot(dif, dif)

biotite/structure/density.py

@@ -11,11 +11,10 @@ __author__ = "Daniel Bauer"
 __all__ = ["density"]
 
 import numpy as np
-from .atoms import coord
+from biotite.structure.atoms import coord
 
 
-def density(atoms, selection=None, delta=1.0, bins=None,
-            density=False, weights=None):
+def density(atoms, selection=None, delta=1.0, bins=None, density=False, weights=None):
     r"""
     Compute the density of the selected atoms.
 
@@ -51,13 +50,13 @@ def density(atoms, selection=None, delta=1.0, bins=None,
         Otherwise, returns the probability density function of each bin.
         See :func:`numpy.histogramdd()` for further details.
     weights: ndarray, shape=(n,) or shape=(m,n), optional
-        An array of values to weight the contribution of *n* atoms in 
+        An array of values to weight the contribution of *n* atoms in
         *m* models.
         If the shape is *(n,)*, the weights will be interpreted as
         *per atom*.
         A shape of *(m,n)* allows to additionally weight atoms on a
         *per model* basis.
-    
+
     Returns
     -------
     H : ndarray, dtype=float
@@ -69,12 +68,12 @@ def density(atoms, selection=None, delta=1.0, bins=None,
         A list containing the 3 arrays describing the bin edges.
     """
     coords = coord(atoms)
-    
+
     is_stack = coords.ndim == 3
 
     # Define the grid for coordinate binning based on coordinates of
     # supplied atoms
-    # This makes the binning independent of a supplied box vector and 
+    # This makes the binning independent of a supplied box vector and
     # fluctuating box dimensions are not a problem
     # However, this means that the user has to make sure the region of
     # interest is in the center of the box, i.e. by centering the
@@ -84,19 +83,17 @@ def density(atoms, selection=None, delta=1.0, bins=None,
             axis = (0, 1)
         else:
             axis = 0
-        grid_min, grid_max = np.min(
-            coords, axis=axis), np.max(coords, axis=axis
-        )
+        grid_min, grid_max = np.min(coords, axis=axis), np.max(coords, axis=axis)
         bins = [
-            np.arange(grid_min[0], grid_max[0]+delta, delta),
-            np.arange(grid_min[1], grid_max[1]+delta, delta),
-            np.arange(grid_min[2], grid_max[2]+delta, delta),
+            np.arange(grid_min[0], grid_max[0] + delta, delta),
+            np.arange(grid_min[1], grid_max[1] + delta, delta),
+            np.arange(grid_min[2], grid_max[2] + delta, delta),
         ]
 
     if selection is None:
         selected_coords = coords
     else:
-        selected_coords = coords[...,selection, :]
+        selected_coords = coords[..., selection, :]
 
     # Reshape the coords into Nx3
     coords = selected_coords.reshape((np.prod(selected_coords.shape[:-1]), 3))
@@ -106,9 +103,7 @@ def density(atoms, selection=None, delta=1.0, bins=None,
         if is_stack and len(weights.shape) < 2:
             weights = np.tile(weights, len(selected_coords))
         weights = weights.reshape(coords.shape[0])
-    
+
     # Calculate the histogram
-    hist = np.histogramdd(
-        coords, bins=bins, density=density, weights=weights
-    )
+    hist = np.histogramdd(coords, bins=bins, density=density, weights=weights)
     return hist

biotite/structure/dotbracket.py

@@ -9,13 +9,12 @@ dot-bracket-notation.
 
 __name__ = "biotite.structure"
 __author__ = "Tom David Müller"
-__all__ = ["dot_bracket_from_structure", "dot_bracket",
-           "base_pairs_from_dot_bracket"]
+__all__ = ["dot_bracket_from_structure", "dot_bracket", "base_pairs_from_dot_bracket"]
 
 import numpy as np
-from .basepairs import base_pairs
-from .pseudoknots import pseudoknots
-from .residues import get_residue_count, get_residue_positions
+from biotite.structure.basepairs import base_pairs
+from biotite.structure.pseudoknots import pseudoknots
+from biotite.structure.residues import get_residue_count, get_residue_positions
 
 _OPENING_BRACKETS = "([{<ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 _OPENING_BRACKETS_BYTES = _OPENING_BRACKETS.encode()
@@ -24,7 +23,8 @@ _CLOSING_BRACKETS_BYTES = _CLOSING_BRACKETS.encode()
 
 
 def dot_bracket_from_structure(
-    nucleic_acid_strand, scores=None, max_pseudoknot_order=None):
+    nucleic_acid_strand, scores=None, max_pseudoknot_order=None
+):
     """
     Represent a nucleic-acid-strand in dot-bracket-letter-notation
     (DBL-notation). :footcite:`Antczak2018`
@@ -53,16 +53,18 @@ def dot_bracket_from_structure(
 
     References
     ----------
-    
+
     .. footbibliography::
     """
     basepairs = base_pairs(nucleic_acid_strand)
     if len(basepairs) == 0:
-        return ['']
+        return [""]
     basepairs = get_residue_positions(nucleic_acid_strand, basepairs)
     length = get_residue_count(nucleic_acid_strand)
-    return dot_bracket(basepairs, length, scores=scores,
-                       max_pseudoknot_order=max_pseudoknot_order)
+    return dot_bracket(
+        basepairs, length, scores=scores, max_pseudoknot_order=max_pseudoknot_order
+    )
+
 
 def dot_bracket(basepairs, length, scores=None, max_pseudoknot_order=None):
     """
@@ -115,21 +117,20 @@ def dot_bracket(basepairs, length, scores=None, max_pseudoknot_order=None):
 
     References
     ----------
-    
+
     .. footbibliography::
     """
     # Make sure the lower residue is on the left for each row
     basepairs = np.sort(basepairs, axis=1)
 
     # Get pseudoknot order
-    pseudoknot_order = pseudoknots(basepairs, scores=scores,
-                                   max_pseudoknot_order=max_pseudoknot_order)
+    pseudoknot_order = pseudoknots(
+        basepairs, scores=scores, max_pseudoknot_order=max_pseudoknot_order
+    )
 
     # Each optimal pseudoknot order solution is represented in
     # dot-bracket-notation
-    notations = [
-        bytearray((b"."*length)) for _ in range(len(pseudoknot_order))
-    ]
+    notations = [bytearray((b"." * length)) for _ in range(len(pseudoknot_order))]
     for s, solution in enumerate(pseudoknot_order):
         for basepair, order in zip(basepairs, solution):
             if order == -1:
@@ -138,6 +139,7 @@ def dot_bracket(basepairs, length, scores=None, max_pseudoknot_order=None):
             notations[s][basepair[1]] = _CLOSING_BRACKETS_BYTES[order]
     return [notation.decode() for notation in notations]
 
+
 def base_pairs_from_dot_bracket(dot_bracket_notation):
     """
     Extract the base pairs from a nucleic-acid-strand in
@@ -172,7 +174,7 @@ def base_pairs_from_dot_bracket(dot_bracket_notation):
 
     References
     ----------
-    
+
     .. footbibliography::
     """
     basepairs = []
@@ -180,7 +182,6 @@ def base_pairs_from_dot_bracket(dot_bracket_notation):
 
     # Iterate through input string and extract base pairs
     for pos, symbol in enumerate(dot_bracket_notation):
-
         if symbol in _OPENING_BRACKETS:
             # Add opening residues to list (separate list for each
             # bracket type)
@@ -197,9 +198,7 @@ def base_pairs_from_dot_bracket(dot_bracket_notation):
 
         else:
             if symbol != ".":
-                raise ValueError(
-                    f"'{symbol}' is an invalid character for DBL-notation"
-                )
+                raise ValueError(f"'{symbol}' is an invalid character for DBL-notation")
 
     for not_closed in opened_brackets:
         if not_closed != []:
@@ -208,7 +207,6 @@ def base_pairs_from_dot_bracket(dot_bracket_notation):
                 "closing bracket"
             )
 
-
     # Sort the base pair indices in ascending order
     basepairs = np.array(basepairs)
     if len(basepairs) > 0: