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

biotite/structure/hbond.py

@@ -11,16 +11,23 @@ __author__ = "Daniel Bauer, Patrick Kunzmann"
 __all__ = ["hbond", "hbond_frequency"]
 
 import warnings
-from .geometry import distance, angle
 import numpy as np
-from .atoms import AtomArrayStack, stack
-from .celllist import CellList
-
-
-def hbond(atoms, selection1=None, selection2=None, selection1_type='both',
-          cutoff_dist=2.5, cutoff_angle=120,
-          donor_elements=('O', 'N', 'S'), acceptor_elements=('O', 'N', 'S'),
-          periodic=False):
+from biotite.structure.atoms import AtomArrayStack, stack
+from biotite.structure.celllist import CellList
+from biotite.structure.geometry import angle, distance
+
+
+def hbond(
+    atoms,
+    selection1=None,
+    selection2=None,
+    selection1_type="both",
+    cutoff_dist=2.5,
+    cutoff_angle=120,
+    donor_elements=("O", "N", "S"),
+    acceptor_elements=("O", "N", "S"),
+    periodic=False,
+):
     r"""
     Find hydrogen bonds in a structure using the Baker-Hubbard
     algorithm. :footcite:`Baker1984`
@@ -31,7 +38,7 @@ def hbond(atoms, selection1=None, selection2=None, selection1_type='both',
     and :math:`d_{H,A} \le 2.5 \mathring{A}`.
     Consequently, the given structure must contain hydrogen atoms.
     Otherwise, no hydrogen bonds will be found.
-    
+
     Parameters
     ----------
     atoms : AtomArray or AtomArrayStack
@@ -60,7 +67,7 @@ def hbond(atoms, selection1=None, selection2=None, selection1_type='both',
         boundary conditions.
         The `box` attribute of `atoms` is required in this case.
         (Default: False).
-        
+
     Returns
     -------
     triplets : ndarray, dtype=int, shape=(n,3)
@@ -74,7 +81,7 @@ def hbond(atoms, selection1=None, selection2=None, selection1_type='both',
         *m x n* matrix that shows if an interaction with index *n* in
         `triplets` is present in the model *m* of the input `atoms`.
         Only returned if `atoms` is an :class:`AtomArrayStack`.
-    
+
     Notes
     -----
     The result of this function may include false positives:
@@ -84,19 +91,19 @@ def hbond(atoms, selection1=None, selection2=None, selection1_type='both',
     For example, a nitrogen atom with positive charge could be
     considered as acceptor atom by this method, although this does
     make sense from a chemical perspective.
-        
+
     Examples
     --------
     Calculate the total number of hydrogen bonds found in each model:
-    
+
     >>> triplets, mask = hbond(atom_array_stack)
     >>> hbonds_per_model = np.count_nonzero(mask, axis=1)
     >>> print(hbonds_per_model)
     [14 14 14 12 11 12  9 13  9 14 13 13 14 11 11 12 11 14 14 13 14 13 15 17
      14 12 15 12 12 13 13 13 12 12 11 14 10 11]
-    
+
     Get hydrogen bond donors of third model:
-    
+
     >>> # Third model -> index 2
     >>> triplets = triplets[mask[2,:]]
     >>> # First column contains donors
@@ -137,12 +144,12 @@ def hbond(atoms, selection1=None, selection2=None, selection1_type='both',
         single_model = True
     else:
         single_model = False
-    
+
     if periodic:
         box = atoms.box
     else:
         box = None
-    
+
     # Mask for donor/acceptor elements
     donor_element_mask = np.isin(atoms.element, donor_elements)
     acceptor_element_mask = np.isin(atoms.element, acceptor_elements)
@@ -152,69 +159,81 @@ def hbond(atoms, selection1=None, selection2=None, selection1_type='both',
     if selection2 is None:
         selection2 = np.ones(atoms.array_length(), dtype=bool)
 
-    if selection1_type == 'both':
+    if selection1_type == "both":
         # The two selections are separated into three selections:
         # the original ones without the overlaping part
         # and one containing the overlap
-        # This prevents redundant triplets and unnecessary computation 
+        # This prevents redundant triplets and unnecessary computation
         overlap_selection = selection1 & selection2
         # Original selections without overlaping part
         exclusive_selection1 = selection1 & (~overlap_selection)
         exclusive_selection2 = selection2 & (~overlap_selection)
-        
+
         # Put selections to list for cleaner iteration
-        selections = [
-            exclusive_selection1, exclusive_selection2, overlap_selection
-        ]
+        selections = [exclusive_selection1, exclusive_selection2, overlap_selection]
         selection_combinations = [
-            #(0,0),   is not included, would be same selection
+            # (0,0),   is not included, would be same selection
             #         as donor and acceptor simultaneously
-            (0,1),
-            (0,2),
-            (1,0),
-            #(1,1),   # same reason above
-            (1,2),
-            (2,0),
-            (2,1),
-            (2,2)     # overlaping part, combination is necessary
+            (0, 1),
+            (0, 2),
+            (1, 0),
+            # (1,1),   # same reason above
+            (1, 2),
+            (2, 0),
+            (2, 1),
+            (2, 2),  # overlaping part, combination is necessary
         ]
-        
+
         all_comb_triplets = []
         all_comb_mask = []
         for selection_index1, selection_index2 in selection_combinations:
             donor_mask = selections[selection_index1]
             acceptor_mask = selections[selection_index2]
-            if  np.count_nonzero(donor_mask) != 0 and \
-                np.count_nonzero(acceptor_mask) != 0:
-                    # Calculate triplets and mask
-                    triplets, mask = _hbond(
-                        atoms, donor_mask, acceptor_mask,
-                        donor_element_mask, acceptor_element_mask,
-                        cutoff_dist, cutoff_angle,
-                        box
-                    )
-                    all_comb_triplets.append(triplets)
-                    all_comb_mask.append(mask)
+            if (
+                np.count_nonzero(donor_mask) != 0
+                and np.count_nonzero(acceptor_mask) != 0
+            ):
+                # Calculate triplets and mask
+                triplets, mask = _hbond(
+                    atoms,
+                    donor_mask,
+                    acceptor_mask,
+                    donor_element_mask,
+                    acceptor_element_mask,
+                    cutoff_dist,
+                    cutoff_angle,
+                    box,
+                )
+                all_comb_triplets.append(triplets)
+                all_comb_mask.append(mask)
         # Merge results from all combinations
         triplets = np.concatenate(all_comb_triplets, axis=0)
         mask = np.concatenate(all_comb_mask, axis=1)
 
-    elif selection1_type == 'donor':
+    elif selection1_type == "donor":
         triplets, mask = _hbond(
-            atoms, selection1, selection2,
-            donor_element_mask, acceptor_element_mask,
-            cutoff_dist, cutoff_angle,
-            box
+            atoms,
+            selection1,
+            selection2,
+            donor_element_mask,
+            acceptor_element_mask,
+            cutoff_dist,
+            cutoff_angle,
+            box,
         )
-    
-    elif selection1_type == 'acceptor':
+
+    elif selection1_type == "acceptor":
         triplets, mask = _hbond(
-            atoms, selection2, selection1,
-            donor_element_mask, acceptor_element_mask,
-            cutoff_dist, cutoff_angle,
-            box
+            atoms,
+            selection2,
+            selection1,
+            donor_element_mask,
+            acceptor_element_mask,
+            cutoff_dist,
+            cutoff_angle,
+            box,
         )
-    
+
     else:
         raise ValueError(f"Unkown selection type '{selection1_type}'")
 
@@ -228,12 +247,18 @@ def hbond(atoms, selection1=None, selection2=None, selection1_type='both',
         return triplets, mask
 
 
-def _hbond(atoms, donor_mask, acceptor_mask,
-           donor_element_mask, acceptor_element_mask,
-           cutoff_dist, cutoff_angle, box):
-    
+def _hbond(
+    atoms,
+    donor_mask,
+    acceptor_mask,
+    donor_element_mask,
+    acceptor_element_mask,
+    cutoff_dist,
+    cutoff_angle,
+    box,
+):
     # Filter donor/acceptor elements
-    donor_mask    &= donor_element_mask
+    donor_mask &= donor_element_mask
     acceptor_mask &= acceptor_element_mask
 
     first_model_box = box[0] if box is not None else None
@@ -254,47 +279,43 @@ def _hbond(atoms, donor_mask, acceptor_mask,
     if len(donor_h_i) == 0 or len(acceptor_i) == 0:
         # Return empty triplets and mask
         return (
-            np.zeros((0,3), dtype=int),
-            np.zeros((atoms.stack_depth(),0), dtype=bool)
+            np.zeros((0, 3), dtype=int),
+            np.zeros((atoms.stack_depth(), 0), dtype=bool),
         )
-    
+
     # Narrow the amount of possible acceptor to donor-H connections
     # down via the distance cutoff parameter using a cell list
     # Save in acceptor-to-hydrogen matrix
     # (true when distance smaller than cutoff)
     coord = atoms.coord
-    possible_bonds = np.zeros(
-        (len(acceptor_i), len(donor_h_i)),
-        dtype=bool
-    )
+    possible_bonds = np.zeros((len(acceptor_i), len(donor_h_i)), dtype=bool)
     periodic = False if box is None else True
     for model_i in range(atoms.stack_depth()):
         donor_h_coord = coord[model_i, donor_h_mask]
         acceptor_coord = coord[model_i, acceptor_mask]
         box_for_model = box[model_i] if box is not None else None
         cell_list = CellList(
-            donor_h_coord, cell_size=cutoff_dist,
-            periodic=periodic, box=box_for_model
-        )
-        possible_bonds |= cell_list.get_atoms_in_cells(
-            acceptor_coord, as_mask=True
+            donor_h_coord, cell_size=cutoff_dist, periodic=periodic, box=box_for_model
         )
+        possible_bonds |= cell_list.get_atoms_in_cells(acceptor_coord, as_mask=True)
     possible_bonds_i = np.where(possible_bonds)
     # Narrow down
     acceptor_i = acceptor_i[possible_bonds_i[0]]
     donor_h_i = donor_h_i[possible_bonds_i[1]]
-    
+
     # Build D-H..A triplets
     donor_i = associated_donor_indices[donor_h_i]
     triplets = np.stack((donor_i, donor_h_i, acceptor_i), axis=1)
     # Remove entries where donor and acceptor are the same
     triplets = triplets[donor_i != acceptor_i]
-    
+
     hbond_mask = _is_hbond(
-        coord[:, triplets[:,0]],  # donors
-        coord[:, triplets[:,1]],  # donor hydrogens
-        coord[:, triplets[:,2]],  # acceptors
-        box, cutoff_dist=cutoff_dist, cutoff_angle=cutoff_angle
+        coord[:, triplets[:, 0]],  # donors
+        coord[:, triplets[:, 1]],  # donor hydrogens
+        coord[:, triplets[:, 2]],  # acceptors
+        box,
+        cutoff_dist=cutoff_dist,
+        cutoff_angle=cutoff_angle,
     )
 
     # Reduce output to contain only triplets counted at least once
@@ -311,14 +332,14 @@ def _get_bonded_h(array, donor_mask, bonds):
     all donors in atoms[donor_mask].
     A `BondsList` is used for detecting bonded hydrogen atoms.
     """
-    hydrogen_mask = (array.element == "H")
-    
+    hydrogen_mask = array.element == "H"
+
     donor_hydrogen_mask = np.zeros(len(array), dtype=bool)
     associated_donor_indices = np.full(len(array), -1, dtype=int)
 
     all_bond_indices, _ = bonds.get_all_bonds()
     donor_indices = np.where(donor_mask)[0]
-    
+
     for donor_i in donor_indices:
         bonded_indices = all_bond_indices[donor_i]
         # Remove padding values
@@ -327,7 +348,7 @@ def _get_bonded_h(array, donor_mask, bonds):
         bonded_indices = bonded_indices[hydrogen_mask[bonded_indices]]
         donor_hydrogen_mask[bonded_indices] = True
         associated_donor_indices[bonded_indices] = donor_i
-    
+
     return donor_hydrogen_mask, associated_donor_indices
 
 
@@ -342,22 +363,20 @@ def _get_bonded_h_via_distance(array, donor_mask, box):
 
     coord = array.coord
     res_id = array.res_id
-    hydrogen_mask = (array.element == "H")
-    
+    hydrogen_mask = array.element == "H"
+
     donor_hydrogen_mask = np.zeros(len(array), dtype=bool)
     associated_donor_indices = np.full(len(array), -1, dtype=int)
 
     donor_indices = np.where(donor_mask)[0]
     for donor_i in donor_indices:
         candidate_mask = hydrogen_mask & (res_id == res_id[donor_i])
-        distances = distance(
-            coord[donor_i], coord[candidate_mask], box=box
-        )
+        distances = distance(coord[donor_i], coord[candidate_mask], box=box)
         donor_h_indices = np.where(candidate_mask)[0][distances <= CUTOFF]
         for i in donor_h_indices:
             associated_donor_indices[i] = donor_i
             donor_hydrogen_mask[i] = True
-    
+
     return donor_hydrogen_mask, associated_donor_indices
 
 
@@ -378,12 +397,12 @@ def hbond_frequency(mask):
 
     The frequency is the amount of models, where the respective bond
     exists divided by the total amount of models.
-    
+
     Parameters
     ----------
     mask: ndarray, dtype=bool, shape=(m,n)
         Input mask obtained from `hbond` function.
-    
+
     Returns
     -------
     ndarray, dtype=Float
@@ -406,4 +425,4 @@ def hbond_frequency(mask):
      0.132 0.053 0.026 0.158 0.026 0.868 0.211 0.026 0.921 0.316 0.079 0.237
      0.105 0.421 0.079 0.026 1.000 0.053 0.132 0.026 0.184]
     """
-    return mask.sum(axis=0)/len(mask)
+    return mask.sum(axis=0) / len(mask)

biotite/structure/info/__init__.py

@@ -14,8 +14,6 @@ of the
 __name__ = "biotite.structure.info"
 __author__ = "Patrick Kunzmann, Tom David Müller"
 
-from .groups import *
-
 from .atoms import *
 from .bonds import *
 from .groups import *

biotite/structure/info/atoms.py

@@ -6,15 +6,16 @@ __name__ = "biotite.structure.info"
 __author__ = "Patrick Kunzmann"
 __all__ = ["residue"]
 
-from .ccd import get_ccd
+from biotite.structure.info.ccd import get_ccd
 
-
-non_hetero_residues = set([
-    "ALA","ARG","ASN","ASP","CYS","GLN","GLU","GLY","HIS",
-    "ILE","LEU","LYS","MET","PHE","PRO","PYL","SER","THR",
-    "TRP","TYR","VAL", "SEC",
+# fmt: off
+NON_HETERO_RESIDUES = set([
+    "ALA", "ARG", "ASN", "ASP", "CYS", "GLN", "GLU", "GLY", "HIS",
+    "ILE", "LEU", "LYS", "MET", "PHE", "PRO", "PYL", "SER", "THR",
+    "TRP", "TYR", "VAL", "SEC",
     "A", "DA", "G", "DG", "C", "DC", "U", "DT",
 ])
+# fmt: on
 
 
 def residue(res_name):
@@ -70,13 +71,11 @@ def residue(res_name):
      ['OXT' 'HXT']]
     """
     # Avoid circular import
-    from ..io.pdbx import get_component
+    from biotite.structure.io.pdbx import get_component
 
     try:
         component = get_component(get_ccd(), res_name=res_name)
     except KeyError:
-        raise KeyError(
-            f"No atom information found for residue '{res_name}' in CCD"
-        )
-    component.hetero[:] = res_name not in non_hetero_residues
+        raise KeyError(f"No atom information found for residue '{res_name}' in CCD")
+    component.hetero[:] = res_name not in NON_HETERO_RESIDUES
     return component

biotite/structure/info/bonds.py

@@ -6,18 +6,17 @@ __name__ = "biotite.structure.info"
 __author__ = "Patrick Kunzmann"
 __all__ = ["bond_type", "bonds_in_residue"]
 
-from ..bonds import BondType
-from .ccd import get_from_ccd
-
+from biotite.structure.bonds import BondType
+from biotite.structure.info.ccd import get_from_ccd
 
 BOND_TYPES = {
-    ("SING", "N") : BondType.SINGLE,
-    ("DOUB", "N") : BondType.DOUBLE,
-    ("TRIP", "N") : BondType.TRIPLE,
-    ("QUAD", "N") : BondType.QUADRUPLE,
-    ("SING", "Y") : BondType.AROMATIC_SINGLE,
-    ("DOUB", "Y") : BondType.AROMATIC_DOUBLE,
-    ("TRIP", "Y") : BondType.AROMATIC_TRIPLE,
+    ("SING", "N"): BondType.SINGLE,
+    ("DOUB", "N"): BondType.DOUBLE,
+    ("TRIP", "N"): BondType.TRIPLE,
+    ("QUAD", "N"): BondType.QUADRUPLE,
+    ("SING", "Y"): BondType.AROMATIC_SINGLE,
+    ("DOUB", "Y"): BondType.AROMATIC_DOUBLE,
+    ("TRIP", "Y"): BondType.AROMATIC_TRIPLE,
 }
 
 _intra_bonds = {}
@@ -48,13 +47,13 @@ def bond_type(res_name, atom_name1, atom_name2):
     Examples
     --------
 
-    >>> print(bond_type("PHE", "CA", "CB"))
-    BondType.SINGLE
-    >>> print(bond_type("PHE", "CG", "CD1"))
-    BondType.AROMATIC_DOUBLE
-    >>> print(bond_type("PHE", "CA", "CG"))
+    >>> print(repr(bond_type("PHE", "CA", "CB")))
+    <BondType.SINGLE: 1>
+    >>> print(repr(bond_type("PHE", "CG", "CD1")))
+    <BondType.AROMATIC_DOUBLE: 6>
+    >>> print(repr(bond_type("PHE", "CA", "CG")))
     None
-    >>> print(bond_type("PHE", "FOO", "BAR"))
+    >>> print(repr(bond_type("PHE", "FOO", "BAR")))
     None
     """
     bonds_for_residue = bonds_in_residue(res_name)
@@ -62,8 +61,7 @@ def bond_type(res_name, atom_name1, atom_name2):
         return None
     # Try both atom orders
     bond_type_int = bonds_for_residue.get(
-        (atom_name1, atom_name2),
-        bonds_for_residue.get((atom_name2, atom_name1))
+        (atom_name1, atom_name2), bonds_for_residue.get((atom_name2, atom_name1))
     )
     if bond_type_int is not None:
         return BondType(bond_type_int)
@@ -101,30 +99,30 @@ def bonds_in_residue(res_name):
     >>> bonds = bonds_in_residue("PHE")
     >>> for atoms, bond_type_int in sorted(bonds.items()):
     ...     atom1, atom2 = sorted(atoms)
-    ...     print(f"{atom1:3} + {atom2:3} -> {str(BondType(bond_type_int))}")
-    C   + O   -> BondType.DOUBLE
-    C   + OXT -> BondType.SINGLE
-    C   + CA  -> BondType.SINGLE
-    CA  + CB  -> BondType.SINGLE
-    CA  + HA  -> BondType.SINGLE
-    CB  + CG  -> BondType.SINGLE
-    CB  + HB2 -> BondType.SINGLE
-    CB  + HB3 -> BondType.SINGLE
-    CD1 + CE1 -> BondType.AROMATIC_SINGLE
-    CD1 + HD1 -> BondType.SINGLE
-    CD2 + CE2 -> BondType.AROMATIC_DOUBLE
-    CD2 + HD2 -> BondType.SINGLE
-    CE1 + CZ  -> BondType.AROMATIC_DOUBLE
-    CE1 + HE1 -> BondType.SINGLE
-    CE2 + CZ  -> BondType.AROMATIC_SINGLE
-    CE2 + HE2 -> BondType.SINGLE
-    CD1 + CG  -> BondType.AROMATIC_DOUBLE
-    CD2 + CG  -> BondType.AROMATIC_SINGLE
-    CZ  + HZ  -> BondType.SINGLE
-    CA  + N   -> BondType.SINGLE
-    H   + N   -> BondType.SINGLE
-    H2  + N   -> BondType.SINGLE
-    HXT + OXT -> BondType.SINGLE
+    ...     print(f"{atom1:3} + {atom2:3} -> {BondType(bond_type_int).name}")
+    C   + O   -> DOUBLE
+    C   + OXT -> SINGLE
+    C   + CA  -> SINGLE
+    CA  + CB  -> SINGLE
+    CA  + HA  -> SINGLE
+    CB  + CG  -> SINGLE
+    CB  + HB2 -> SINGLE
+    CB  + HB3 -> SINGLE
+    CD1 + CE1 -> AROMATIC_SINGLE
+    CD1 + HD1 -> SINGLE
+    CD2 + CE2 -> AROMATIC_DOUBLE
+    CD2 + HD2 -> SINGLE
+    CE1 + CZ  -> AROMATIC_DOUBLE
+    CE1 + HE1 -> SINGLE
+    CE2 + CZ  -> AROMATIC_SINGLE
+    CE2 + HE2 -> SINGLE
+    CD1 + CG  -> AROMATIC_DOUBLE
+    CD2 + CG  -> AROMATIC_SINGLE
+    CZ  + HZ  -> SINGLE
+    CA  + N   -> SINGLE
+    H   + N   -> SINGLE
+    H2  + N   -> SINGLE
+    HXT + OXT -> SINGLE
     """
     global _intra_bonds
     if res_name not in _intra_bonds:
@@ -137,7 +135,7 @@ def bonds_in_residue(res_name):
                 chem_comp_bond_dict["atom_id_1"],
                 chem_comp_bond_dict["atom_id_2"],
                 chem_comp_bond_dict["value_order"],
-                chem_comp_bond_dict["pdbx_aromatic_flag"]
+                chem_comp_bond_dict["pdbx_aromatic_flag"],
             ):
                 bond_type = BOND_TYPES[order, aromatic_flag]
                 bonds_for_residue[atom1.item(), atom2.item()] = bond_type

biotite/structure/info/ccd.py

@@ -9,7 +9,6 @@ __all__ = ["get_ccd", "get_from_ccd"]
 from pathlib import Path
 import numpy as np
 
-
 CCD_DIR = Path(__file__).parent / "ccd"
 INDEX_COLUMN_NAME = {
     "chem_comp": "id",
@@ -40,7 +39,7 @@ def get_ccd():
 
     """
     # Avoid circular import
-    from ..io.pdbx.bcif import BinaryCIFFile
+    from biotite.structure.io.pdbx.bcif import BinaryCIFFile
 
     global _ccd_block
     if _ccd_block is None:
@@ -104,7 +103,7 @@ def _index_residues(id_column):
     # The final start is the exclusive stop of last residue
     residue_starts = np.concatenate(([0], residue_starts, [len(id_column)]))
     index = {}
-    for i in range(len(residue_starts)-1):
+    for i in range(len(residue_starts) - 1):
         comp_id = id_column[residue_starts[i]].item()
-        index[comp_id] = (residue_starts[i], residue_starts[i+1])
-    return index
+        index[comp_id] = (residue_starts[i], residue_starts[i + 1])
+    return index

biotite/structure/info/groups.py

@@ -7,8 +7,6 @@ __author__ = "Tom David Müller, Patrick Kunzmann"
 __all__ = ["amino_acid_names", "nucleotide_names", "carbohydrate_names"]
 
 from pathlib import Path
-import copy
-
 
 CCD_DIR = Path(__file__).parent / "ccd"
 
@@ -84,4 +82,4 @@ def _get_group_members(group_name):
     if group_name not in group_lists:
         with open(CCD_DIR / f"{group_name}.txt", "r") as file:
             group_lists[group_name] = tuple(file.read().split())
-    return group_lists[group_name]
+    return group_lists[group_name]

biotite/structure/info/masses.py

@@ -8,9 +8,8 @@ __all__ = ["mass"]
 
 import json
 from pathlib import Path
-from ..atoms import Atom, AtomArray, AtomArrayStack
-from .ccd import get_from_ccd
-
+from biotite.structure.atoms import Atom, AtomArray, AtomArrayStack
+from biotite.structure.info.ccd import get_from_ccd
 
 # Masses are taken from http://www.sbcs.qmul.ac.uk/iupac/AtWt/ (2018/03/01)
 ATOM_MASSES_FILE = Path(__file__).parent / "atom_masses.json"
@@ -109,15 +108,11 @@ def mass(item, is_residue=None):
     elif isinstance(item, Atom):
         result_mass = mass(item.element, is_residue=False)
     elif isinstance(item, AtomArray) or isinstance(item, AtomArrayStack):
-        result_mass = sum(
-            (mass(element, is_residue=False) for element in item.element)
-        )
+        result_mass = sum((mass(element, is_residue=False) for element in item.element))
 
     else:
-        raise TypeError(
-            f"Cannot calculate mass for {type(item).__name__} objects"
-        )
+        raise TypeError(f"Cannot calculate mass for {type(item).__name__} objects")
 
     if result_mass is None:
         raise KeyError(f"{item} is not known")
-    return result_mass
+    return result_mass

biotite/structure/info/misc.py

@@ -6,7 +6,7 @@ __name__ = "biotite.structure.info"
 __author__ = "Patrick Kunzmann"
 __all__ = ["all_residues", "full_name", "link_type", "one_letter_code"]
 
-from .ccd import get_ccd, get_from_ccd
+from biotite.structure.info.ccd import get_ccd, get_from_ccd
 
 
 def all_residues():