biotite 0.41.2__cp310-cp310-macosx_11_0_arm64.whl → 1.0.0__cp310-cp310-macosx_11_0_arm64.whl

biotite/structure/info/radii.py

@@ -6,9 +6,9 @@ __name__ = "biotite.structure.info"
 __author__ = "Patrick Kunzmann"
 __all__ = ["vdw_radius_protor", "vdw_radius_single"]
 
-from .bonds import bonds_in_residue
-
+from biotite.structure.info.bonds import bonds_in_residue
 
+# fmt: off
 # Contains tuples for the different ProtOr groups:
 # Tuple contains: element, valency, H count
 _PROTOR_RADII = {
@@ -35,28 +35,29 @@ _PROTOR_RADII = {
 _SINGLE_RADII = {
     "H":  1.20,
     "HE": 1.40,
-    
+
     "C":  1.70,
     "N":  1.55,
     "O":  1.52,
     "F":  1.47,
     "NE": 1.54,
-    
+
     "SI": 2.10,
     "P":  1.80,
     "S":  1.80,
     "CL": 1.75,
     "AR": 1.88,
-    
+
     "AS": 1.85,
     "SE": 1.90,
     "BR": 1.85,
     "KR": 2.02,
-    
+
     "TE": 2.06,
     "I":  1.98,
     "XE": 2.16,
 }
+# fmt: on
 
 # A dictionary that caches radii for each residue
 _protor_radii = {}
@@ -82,7 +83,7 @@ def vdw_radius_protor(res_name, atom_name):
         to.
     atom_name : str
         The name of the non-hydrogen atom.
-    
+
     Returns
     -------
     The Van-der-Waals radius of the given atom.
@@ -91,12 +92,12 @@ def vdw_radius_protor(res_name, atom_name):
     See also
     --------
     vdw_radius_single
-    
+
     References
     ----------
-    
+
     .. footbibliography::
-    
+
     Examples
     --------
 
@@ -113,8 +114,7 @@ def vdw_radius_protor(res_name, atom_name):
         # Use cached radii for the residue, if already calculated
         if atom_name not in _protor_radii[res_name]:
             raise KeyError(
-                f"Residue '{res_name}' does not contain an atom named "
-                f"'{atom_name}'"
+                f"Residue '{res_name}' does not contain an atom named " f"'{atom_name}'"
             )
         return _protor_radii[res_name].get(atom_name)
     else:
@@ -124,6 +124,7 @@ def vdw_radius_protor(res_name, atom_name):
         # are cached
         return vdw_radius_protor(res_name, atom_name)
 
+
 def _calculate_protor_radii(res_name):
     """
     Calculate the ProtOr VdW radii for all atoms (atom names) in
@@ -159,8 +160,7 @@ def _calculate_protor_radii(res_name):
                 group[2] += 1
             groups[main_atom] = group
     # Get radii based on ProtOr groups
-    radii = {atom : _PROTOR_RADII.get(tuple(group))
-             for atom, group in groups.items()}
+    radii = {atom: _PROTOR_RADII.get(tuple(group)) for atom, group in groups.items()}
     return radii
 
 
@@ -173,25 +173,25 @@ def vdw_radius_single(element):
     ----------
     element : str
         The chemical element of the atoms.
-    
+
     Returns
     -------
     The Van-der-Waals radius of the atom.
     If the radius is unknown for the element, `None` is returned.
-    
+
     See also
     --------
     vdw_radius_protor
-    
+
     References
     ----------
-    
+
     .. footbibliography::
-    
+
     Examples
     --------
 
     >>> print(vdw_radius_single("C"))
     1.7
     """
-    return _SINGLE_RADII.get(element.upper())
+    return _SINGLE_RADII.get(element.upper())

biotite/structure/info/standardize.py

@@ -8,9 +8,9 @@ __all__ = ["standardize_order"]
 
 import warnings
 import numpy as np
-from .ccd import get_from_ccd
-from ..residues import get_residue_starts
-from ..error import BadStructureError
+from biotite.structure.error import BadStructureError
+from biotite.structure.info.ccd import get_from_ccd
+from biotite.structure.residues import get_residue_starts
 
 
 def standardize_order(atoms):
@@ -116,26 +116,24 @@ def standardize_order(atoms):
     reordered_indices = np.zeros(atoms.array_length(), dtype=int)
 
     starts = get_residue_starts(atoms, add_exclusive_stop=True)
-    for i in range(len(starts)-1):
+    for i in range(len(starts) - 1):
         start = starts[i]
-        stop = starts[i+1]
+        stop = starts[i + 1]
 
         res_name = atoms.res_name[start]
-        standard_atom_names = get_from_ccd(
-            "chem_comp_atom", res_name, "atom_id"
-        )
+        standard_atom_names = get_from_ccd("chem_comp_atom", res_name, "atom_id")
         if standard_atom_names is None:
             # If the residue is not in the CCD, keep the current order
             warnings.warn(
                 f"Residue '{res_name}' is not in the CCD, "
                 f"keeping current atom order"
             )
-            reordered_indices[start : stop] = np.arange(start, stop)
+            reordered_indices[start:stop] = np.arange(start, stop)
             continue
 
-        reordered_indices[start : stop] = _reorder(
-            atoms.atom_name[start : stop], standard_atom_names
-        ) + start
+        reordered_indices[start:stop] = (
+            _reorder(atoms.atom_name[start:stop], standard_atom_names) + start
+        )
 
     return reordered_indices
 
@@ -164,17 +162,13 @@ def _reorder(origin, target):
         Indices for `origin` that that changes the order of `origin`
         to the order of `target`.
     """
-    target_hits, origin_hits = np.where(
-        target[:, np.newaxis] == origin[np.newaxis, :]
-    )
+    target_hits, origin_hits = np.where(target[:, np.newaxis] == origin[np.newaxis, :])
 
     counts = np.bincount(target_hits, minlength=len(target))
     if (counts > 1).any():
         counts = np.bincount(target_hits, minlength=len(target))
         # Identify which atom is duplicate
-        duplicate_i = np.where(
-            counts > 1
-        )[0][0]
+        duplicate_i = np.where(counts > 1)[0][0]
         duplicate_name = target[duplicate_i]
         raise BadStructureError(
             f"Input structure has duplicate atom '{duplicate_name}'"
@@ -185,12 +179,7 @@ def _reorder(origin, target):
         # to the target structure
         # -> Identify which atoms are missing in the target structure
         # and append these to the end of the residue
-        missing_atom_mask = np.bincount(
-            origin_hits, minlength=len(origin)
-        ).astype(bool)
-        return np.concatenate([
-            origin_hits,
-            np.where(~missing_atom_mask)[0]
-        ])
+        missing_atom_mask = np.bincount(origin_hits, minlength=len(origin)).astype(bool)
+        return np.concatenate([origin_hits, np.where(~missing_atom_mask)[0]])
     else:
-        return origin_hits
+        return origin_hits

biotite/structure/integrity.py

@@ -9,53 +9,29 @@ errors in the structure.
 
 __name__ = "biotite.structure"
 __author__ = "Patrick Kunzmann, Daniel Bauer"
-__all__ = ["check_id_continuity", "check_atom_id_continuity",
-           "check_res_id_continuity", "check_backbone_continuity",
-           "check_duplicate_atoms", "check_bond_continuity",
-           "check_linear_continuity"]
+__all__ = [
+    "check_atom_id_continuity",
+    "check_res_id_continuity",
+    "check_backbone_continuity",
+    "check_duplicate_atoms",
+    "check_linear_continuity",
+]
 
 import numpy as np
-import warnings
-from .atoms import AtomArray, AtomArrayStack
-from .filter import (
-    filter_peptide_backbone, filter_phosphate_backbone, filter_linear_bond_continuity)
-from .box import coord_to_fraction
+from biotite.structure.box import coord_to_fraction
+from biotite.structure.filter import (
+    filter_linear_bond_continuity,
+    filter_peptide_backbone,
+    filter_phosphate_backbone,
+)
 
 
 def _check_continuity(array):
     diff = np.diff(array)
-    discontinuity = np.where( ((diff != 0) & (diff != 1)) )
+    discontinuity = np.where(((diff != 0) & (diff != 1)))
     return discontinuity[0] + 1
 
 
-def check_id_continuity(array):
-    """
-    Check if the residue IDs are incremented by more than 1 or
-    decremented, from one atom to the next one.
-
-    An increment by more than 1 is as strong clue for missing residues,
-    a decrement means probably a start of a new chain.
-
-    DEPRECATED: Use :func:`check_res_id_continuity()` instead.
-
-    Parameters
-    ----------
-    array : AtomArray or AtomArrayStack
-        The array to be checked.
-
-    Returns
-    -------
-    discontinuity : ndarray, dtype=int
-        Contains the indices of atoms after a discontinuity
-    """
-    warnings.warn(
-        "'check_id_continuity()' is deprecated, "
-        "use 'check_res_id_continuity()' instead",
-        DeprecationWarning
-    )
-    return check_res_id_continuity(array)
-
-
 def check_atom_id_continuity(array):
     """
     Check if the atom IDs are incremented by more than 1 or
@@ -99,36 +75,6 @@ def check_res_id_continuity(array):
     return _check_continuity(ids)
 
 
-def check_bond_continuity(array, min_len=1.2, max_len=1.8):
-    """
-    Check if the peptide or phosphate backbone atoms have a
-    non-reasonable distance to the next residue.
-
-    A large or very small distance is a very strong clue, that there is
-    no bond between those atoms, therefore the chain is discontinued.
-
-    DEPRECATED: Please use :func:`check_backbone_continuity` for the same functionality.
-
-    Parameters
-    ----------
-    array : AtomArray
-        The array to be checked.
-    min_len, max_len : float, optional
-        The interval in which the atom-atom distance is evaluated as
-        bond.
-
-    Returns
-    -------
-    discontinuity : ndarray, dtype=int
-         Contains the indices of atoms after a discontinuity.
-    """
-    warnings.warn(
-        "Reimplemented into `check_backbone_continuity()`",
-        DeprecationWarning
-    )
-    return check_backbone_continuity(array, min_len, max_len)
-
-
 def check_linear_continuity(array, min_len=1.2, max_len=1.8):
     """
     Check linear (consecutive) bond continuity of atoms in atom array.
@@ -223,8 +169,9 @@ def check_duplicate_atoms(array):
         The first occurence of an atom is not counted as duplicate.
     """
     duplicates = []
-    annots = [array.get_annotation(category) for category
-              in array.get_annotation_categories()]
+    annots = [
+        array.get_annotation(category) for category in array.get_annotation_categories()
+    ]
     for i in range(1, array.array_length()):
         # Start with assumption that all atoms in the array
         # until index i are duplicates of the atom at index i
@@ -233,7 +180,7 @@ def check_duplicate_atoms(array):
             # For each annotation array filter out the atoms until
             # index i that have an unequal annotation
             # to the atom at index i
-            is_duplicate &= (annot[:i] == annot[i])
+            is_duplicate &= annot[:i] == annot[i]
         # After checking all annotation arrays,
         # if there still is any duplicate to the atom at index i,
         # add i the the list of duplicate atom indices

biotite/structure/io/__init__.py

@@ -18,13 +18,12 @@ structure file.
 The recommended format for reading structure files is *BinaryCIF*.
 It has by far the shortest parsing time and file size.
 
-Besides the mentioned structure formats, Gromacs trajectory files can be
-loaded, if `mdtraj` is installed.
+Besides the mentioned structure formats, common trajectory formats can be
+loaded as well.
 """
 
 __name__ = "biotite.structure.io"
 __author__ = "Patrick Kunzmann"
 
-from .ctab import *
 from .general import *
-from .trajfile import *
+from .trajfile import *

biotite/structure/io/dcd/__init__.py

@@ -10,4 +10,4 @@ CDC format used by software like *CHARMM*, *OpenMM* and *NAMD*.
 __name__ = "biotite.structure.io.dcd"
 __author__ = "Patrick Kunzmann"
 
-from .file import *
+from .file import *

biotite/structure/io/dcd/file.py

@@ -6,21 +6,21 @@ __name__ = "biotite.structure.io.dcd"
 __author__ = "Patrick Kunzmann"
 __all__ = ["DCDFile"]
 
+import biotraj
 import numpy as np
-from ..trajfile import TrajectoryFile
-from ...box import vectors_from_unitcell, unitcell_from_vectors
+from biotite.structure.box import unitcell_from_vectors, vectors_from_unitcell
+from biotite.structure.io.trajfile import TrajectoryFile
 
 
 class DCDFile(TrajectoryFile):
     """
     This file class represents a DCD trajectory file.
     """
-    
+
     @classmethod
     def traj_type(cls):
-        import mdtraj.formats as traj
-        return traj.DCDTrajectoryFile
-    
+        return biotraj.DCDTrajectoryFile
+
     @classmethod
     def process_read_values(cls, read_values):
         # .netcdf files use Angstrom
@@ -28,38 +28,40 @@ class DCDFile(TrajectoryFile):
         cell_lengths = read_values[1]
         cell_angles = read_values[2]
         if cell_lengths is None or cell_angles is None:
-             box = None
+            box = None
         else:
             box = np.stack(
-                [vectors_from_unitcell(a, b, c, alpha, beta, gamma)
-                for (a, b, c), (alpha, beta, gamma)
-                in zip(cell_lengths, np.deg2rad(cell_angles))],
-                axis=0
+                [
+                    vectors_from_unitcell(a, b, c, alpha, beta, gamma)
+                    for (a, b, c), (alpha, beta, gamma) in zip(
+                        cell_lengths, np.deg2rad(cell_angles)
+                    )
+                ],
+                axis=0,
             )
         return coord, box, None
-    
+
     @classmethod
     def prepare_write_values(cls, coord, box, time):
-        xyz = coord.astype(np.float32, copy=False) \
-              if coord is not None else None
+        xyz = coord.astype(np.float32, copy=False) if coord is not None else None
         if box is None:
             cell_lengths = None
-            cell_angles  = None
+            cell_angles = None
         else:
             cell_lengths = np.zeros((len(box), 3), dtype=np.float32)
-            cell_angles  = np.zeros((len(box), 3), dtype=np.float32)
+            cell_angles = np.zeros((len(box), 3), dtype=np.float32)
             for i, model_box in enumerate(box):
                 a, b, c, alpha, beta, gamma = unitcell_from_vectors(model_box)
                 cell_lengths[i] = np.array((a, b, c))
                 cell_angles[i] = np.rad2deg((alpha, beta, gamma))
         return {
-            "xyz" : xyz,
-            "cell_lengths" : cell_lengths,
-            "cell_angles" : cell_angles,
+            "xyz": xyz,
+            "cell_lengths": cell_lengths,
+            "cell_angles": cell_angles,
         }
 
     def set_time(self, time):
         if time is not None:
             raise NotImplementedError(
                 "This trajectory file does not support writing simulation time"
-            )
+            )

biotite/structure/io/general.py

@@ -12,9 +12,9 @@ __author__ = "Patrick Kunzmann"
 __all__ = ["load_structure", "save_structure"]
 
 import datetime
-import os.path
 import io
-from ..atoms import AtomArrayStack
+import os.path
+from biotite.structure.atoms import AtomArrayStack
 
 
 def load_structure(file_path, template=None, **kwargs):
@@ -64,73 +64,63 @@ def load_structure(file_path, template=None, **kwargs):
     _, suffix = os.path.splitext(file_path)
     match suffix:
         case ".pdb":
-            from .pdb import PDBFile
+            from biotite.structure.io.pdb import PDBFile
+
             file = PDBFile.read(file_path)
             array = file.get_structure(**kwargs)
             return _as_single_model_if_possible(array)
         case ".pdbqt":
-            from .pdbqt import PDBQTFile
+            from biotite.structure.io.pdbqt import PDBQTFile
+
             file = PDBQTFile.read(file_path)
             array = file.get_structure(**kwargs)
             return _as_single_model_if_possible(array)
         case ".cif" | ".pdbx":
-            from .pdbx import CIFFile, get_structure
+            from biotite.structure.io.pdbx import CIFFile, get_structure
+
             file = CIFFile.read(file_path)
             array = get_structure(file, **kwargs)
             return _as_single_model_if_possible(array)
         case ".bcif":
-            from .pdbx import BinaryCIFFile, get_structure
+            from biotite.structure.io.pdbx import BinaryCIFFile, get_structure
+
             file = BinaryCIFFile.read(file_path)
             array = get_structure(file, **kwargs)
             return _as_single_model_if_possible(array)
         case ".gro":
-            from .gro import GROFile
+            from biotite.structure.io.gro import GROFile
+
             file = GROFile.read(file_path)
             array = file.get_structure(**kwargs)
             return _as_single_model_if_possible(array)
-        case ".mmtf":
-            from .mmtf import MMTFFile, get_structure
-            file = MMTFFile.read(file_path)
-            array = get_structure(file, **kwargs)
-            return _as_single_model_if_possible(array)
-        case ".npz":
-            from .npz import NpzFile
-            file = NpzFile.read(file_path)
-            array = file.get_structure(**kwargs)
-            return _as_single_model_if_possible(array)
         case ".mol":
-            from .mol import MOLFile
+            from biotite.structure.io.mol import MOLFile
+
             file = MOLFile.read(file_path)
             array = file.get_structure(**kwargs)
             # MOL and SDF files only contain a single model
             return array
         case ".sdf" | ".sd":
-            from .mol import SDFile, get_structure
+            from biotite.structure.io.mol import SDFile, get_structure
+
             file = SDFile.read(file_path)
             array = get_structure(file, **kwargs)
             return array
-        case ".trr" | ".xtc" | ".tng" | ".dcd" | ".netcdf":
+        case ".trr" | ".xtc" | ".dcd" | ".netcdf":
             if template is None:
-                raise TypeError(
-                    "Template must be specified for trajectory files"
-                )
+                raise TypeError("Template must be specified for trajectory files")
             # Filter template for atom ids, if an unfiltered template
-            if (
-                "atom_i" in kwargs
-                and template.shape[-1] != len(kwargs["atom_i"])
-            ):
+            if "atom_i" in kwargs and template.shape[-1] != len(kwargs["atom_i"]):
                 template = template[..., kwargs["atom_i"]]
-            from .trr import TRRFile
-            from .xtc import XTCFile
-            from .tng import TNGFile
-            from .dcd import DCDFile
-            from .netcdf import NetCDFFile
+            from biotite.structure.io.dcd import DCDFile
+            from biotite.structure.io.netcdf import NetCDFFile
+            from biotite.structure.io.trr import TRRFile
+            from biotite.structure.io.xtc import XTCFile
+
             if suffix == ".trr":
                 traj_file_cls = TRRFile
             if suffix == ".xtc":
                 traj_file_cls = XTCFile
-            if suffix == ".tng":
-                traj_file_cls = TNGFile
             if suffix == ".dcd":
                 traj_file_cls = DCDFile
             if suffix == ".netcdf":
@@ -169,65 +159,60 @@ def save_structure(file_path, array, **kwargs):
     _, suffix = os.path.splitext(file_path)
     match suffix:
         case ".pdb":
-            from .pdb import PDBFile
+            from biotite.structure.io.pdb import PDBFile
+
             file = PDBFile()
             file.set_structure(array, **kwargs)
             file.write(file_path)
         case ".pdbqt":
-            from .pdbqt import PDBQTFile
+            from biotite.structure.io.pdbqt import PDBQTFile
+
             file = PDBQTFile()
             file.set_structure(array, **kwargs)
             file.write(file_path)
         case ".cif" | ".pdbx":
-            from .pdbx import CIFFile, set_structure
+            from biotite.structure.io.pdbx import CIFFile, set_structure
+
             file = CIFFile()
             set_structure(file, array, **kwargs)
             file.write(file_path)
         case ".bcif":
-            from .pdbx import BinaryCIFFile, set_structure
+            from biotite.structure.io.pdbx import BinaryCIFFile, set_structure
+
             file = BinaryCIFFile()
             set_structure(file, array, **kwargs)
             file.write(file_path)
         case ".gro":
-            from .gro import GROFile
+            from biotite.structure.io.gro import GROFile
+
             file = GROFile()
             file.set_structure(array, **kwargs)
             file.write(file_path)
-        case ".mmtf":
-            from .mmtf import MMTFFile, set_structure
-            file = MMTFFile()
-            set_structure(file, array, **kwargs)
-            file.write(file_path)
-        case ".npz":
-            from .npz import NpzFile
-            file = NpzFile()
-            file.set_structure(array, **kwargs)
-            file.write(file_path)
         case ".mol":
-            from .mol import MOLFile
+            from biotite.structure.io.mol import MOLFile
+
             file = MOLFile()
             file.set_structure(array, **kwargs)
             file.header = _mol_header()
             file.write(file_path)
         case ".sdf" | ".sd":
-            from .mol import SDFile, SDRecord, set_structure
+            from biotite.structure.io.mol import SDFile, SDRecord, set_structure
+
             record = SDRecord()
             record.set_structure(array, **kwargs)
             record.header = _mol_header()
             file = SDFile({"Molecule": record})
             file.write(file_path)
-        case ".trr" | ".xtc" | ".tng" | ".dcd" | ".netcdf":
-            from .trr import TRRFile
-            from .xtc import XTCFile
-            from .tng import TNGFile
-            from .dcd import DCDFile
-            from .netcdf import NetCDFFile
+        case ".trr" | ".xtc" | ".dcd" | ".netcdf":
+            from biotite.structure.io.dcd import DCDFile
+            from biotite.structure.io.netcdf import NetCDFFile
+            from biotite.structure.io.trr import TRRFile
+            from biotite.structure.io.xtc import XTCFile
+
             if suffix == ".trr":
                 traj_file_cls = TRRFile
             if suffix == ".xtc":
                 traj_file_cls = XTCFile
-            if suffix == ".tng":
-                traj_file_cls = TNGFile
             if suffix == ".dcd":
                 traj_file_cls = DCDFile
             if suffix == ".netcdf":
@@ -248,10 +233,11 @@ def _as_single_model_if_possible(atoms):
 
 
 def _mol_header():
-    from .mol import Header
+    from biotite.structure.io.mol import Header
+
     return Header(
         mol_name="Molecule",
         program="Biotite",
         time=datetime.datetime.now(),
         dimensions="3D",
-    )
+    )

biotite/structure/io/gro/__init__.py

@@ -11,4 +11,4 @@ software package.
 __name__ = "biotite.structure.io.gro"
 __author__ = "Daniel Bauer"
 
-from .file import *
+from .file import *