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

biotite/structure/io/pdb/file.py

@@ -8,20 +8,23 @@ __all__ = ["PDBFile"]
 
 import warnings
 import numpy as np
-from ...atoms import AtomArray, AtomArrayStack, repeat
-from ...bonds import BondList, connect_via_residue_names
-from ...box import vectors_from_unitcell, unitcell_from_vectors
-from ....file import TextFile, InvalidFileError
-from ...repair import infer_elements
-from ...error import BadStructureError
-from ...filter import (
+from biotite.file import InvalidFileError, TextFile
+from biotite.structure.atoms import AtomArray, AtomArrayStack, repeat
+from biotite.structure.bonds import BondList, connect_via_residue_names
+from biotite.structure.box import unitcell_from_vectors, vectors_from_unitcell
+from biotite.structure.error import BadStructureError
+from biotite.structure.filter import (
     filter_first_altloc,
     filter_highest_occupancy_altloc,
     filter_solvent,
 )
-from ...util import matrix_rotate
-from .hybrid36 import encode_hybrid36, decode_hybrid36, max_hybrid36_number
-
+from biotite.structure.io.pdb.hybrid36 import (
+    decode_hybrid36,
+    encode_hybrid36,
+    max_hybrid36_number,
+)
+from biotite.structure.repair import infer_elements
+from biotite.structure.util import matrix_rotate
 
 _PDB_MAX_ATOMS = 99999
 _PDB_MAX_RESIDUES = 9999
@@ -82,6 +85,7 @@ class PDBFile(TextFile):
     >>> file.set_structure(array_stack_mod)
     >>> file.write(os.path.join(path_to_directory, "1l2y_mod.pdb"))
     """
+
     @classmethod
     def read(cls, file):
         file = super().read(file)
@@ -91,7 +95,6 @@ class PDBFile(TextFile):
         file._index_models_and_atoms()
         return file
 
-
     def get_remark(self, number):
         r"""
         Get the lines containing the *REMARK* records with the given
@@ -140,7 +143,8 @@ class PDBFile(TextFile):
         remark_string = f"REMARK {number:>3d}"
         # Find lines and omit ``REMARK XXX `` part
         remark_lines = [
-            line[CONTENT_START_COLUMN:] for line in self.lines
+            line[CONTENT_START_COLUMN:]
+            for line in self.lines
             if line.startswith(remark_string)
         ]
         if len(remark_lines) == 0:
@@ -149,7 +153,6 @@ class PDBFile(TextFile):
         remark_lines = remark_lines[1:]
         return remark_lines
 
-
     def get_model_count(self):
         """
         Get the number of models contained in the PDB file.
@@ -161,7 +164,6 @@ class PDBFile(TextFile):
         """
         return len(self._model_start_i)
 
-
     def get_coord(self, model=None):
         """
         Get only the coordinates from the PDB file.
@@ -239,21 +241,21 @@ class PDBFile(TextFile):
         if model is None:
             coord = np.zeros(
                 (len(self._model_start_i), self._get_model_length(), 3),
-                dtype=np.float32
+                dtype=np.float32,
             )
             m = 0
             i = 0
             for line_i in self._atom_line_i:
                 if (
-                    m < len(self._model_start_i)-1
-                    and line_i > self._model_start_i[m+1]
+                    m < len(self._model_start_i) - 1
+                    and line_i > self._model_start_i[m + 1]
                 ):
                     m += 1
                     i = 0
                 line = self.lines[line_i]
-                coord[m,i,0] = float(line[_coord_x])
-                coord[m,i,1] = float(line[_coord_y])
-                coord[m,i,2] = float(line[_coord_z])
+                coord[m, i, 0] = float(line[_coord_x])
+                coord[m, i, 1] = float(line[_coord_y])
+                coord[m, i, 2] = float(line[_coord_z])
                 i += 1
             return coord
 
@@ -262,12 +264,11 @@ class PDBFile(TextFile):
             coord = np.zeros((len(coord_i), 3), dtype=np.float32)
             for i, line_i in enumerate(coord_i):
                 line = self.lines[line_i]
-                coord[i,0] = float(line[_coord_x])
-                coord[i,1] = float(line[_coord_y])
-                coord[i,2] = float(line[_coord_z])
+                coord[i, 0] = float(line[_coord_x])
+                coord[i, 1] = float(line[_coord_y])
+                coord[i, 2] = float(line[_coord_z])
             return coord
 
-
     def get_b_factor(self, model=None):
         """
         Get only the B-factors from the PDB file.
@@ -300,20 +301,19 @@ class PDBFile(TextFile):
         """
         if model is None:
             b_factor = np.zeros(
-                (len(self._model_start_i), self._get_model_length()),
-                dtype=np.float32
+                (len(self._model_start_i), self._get_model_length()), dtype=np.float32
             )
             m = 0
             i = 0
             for line_i in self._atom_line_i:
                 if (
-                    m < len(self._model_start_i)-1
-                    and line_i > self._model_start_i[m+1]
+                    m < len(self._model_start_i) - 1
+                    and line_i > self._model_start_i[m + 1]
                 ):
                     m += 1
                     i = 0
                 line = self.lines[line_i]
-                b_factor[m,i] = float(line[_temp_f])
+                b_factor[m, i] = float(line[_temp_f])
                 i += 1
             return b_factor
 
@@ -325,9 +325,9 @@ class PDBFile(TextFile):
                 b_factor[i] = float(line[_temp_f])
             return b_factor
 
-
-    def get_structure(self, model=None, altloc="first", extra_fields=[],
-                      include_bonds=False):
+    def get_structure(
+        self, model=None, altloc="first", extra_fields=[], include_bonds=False
+    ):
         """
         Get an :class:`AtomArray` or :class:`AtomArrayStack` from the PDB file.
 
@@ -391,17 +391,17 @@ class PDBFile(TextFile):
             array = AtomArray(len(coord_i))
 
         # Create mandatory and optional annotation arrays
-        chain_id  = np.zeros(array.array_length(), array.chain_id.dtype)
-        res_id    = np.zeros(array.array_length(), array.res_id.dtype)
-        ins_code  = np.zeros(array.array_length(), array.ins_code.dtype)
-        res_name  = np.zeros(array.array_length(), array.res_name.dtype)
-        hetero    = np.zeros(array.array_length(), array.hetero.dtype)
+        chain_id = np.zeros(array.array_length(), array.chain_id.dtype)
+        res_id = np.zeros(array.array_length(), array.res_id.dtype)
+        ins_code = np.zeros(array.array_length(), array.ins_code.dtype)
+        res_name = np.zeros(array.array_length(), array.res_name.dtype)
+        hetero = np.zeros(array.array_length(), array.hetero.dtype)
         atom_name = np.zeros(array.array_length(), array.atom_name.dtype)
-        element   = np.zeros(array.array_length(), array.element.dtype)
+        element = np.zeros(array.array_length(), array.element.dtype)
         atom_id_raw = np.zeros(array.array_length(), "U5")
-        charge_raw  = np.zeros(array.array_length(), "U2")
+        charge_raw = np.zeros(array.array_length(), "U2")
         occupancy = np.zeros(array.array_length(), float)
-        b_factor  = np.zeros(array.array_length(), float)
+        b_factor = np.zeros(array.array_length(), float)
         altloc_id = np.zeros(array.array_length(), dtype="U1")
 
         # Fill annotation array
@@ -425,13 +425,11 @@ class PDBFile(TextFile):
             occupancy[i] = float(line[_occupancy].strip())
             b_factor[i] = float(line[_temp_f].strip())
 
-        if include_bonds or \
-            (extra_fields is not None and "atom_id" in extra_fields):
-                # The atom IDs are only required in these two cases
-                atom_id = np.array(
-                    [decode_hybrid36(raw_id.item()) for raw_id in atom_id_raw],
-                    dtype=int
-                )
+        if include_bonds or (extra_fields is not None and "atom_id" in extra_fields):
+            # The atom IDs are only required in these two cases
+            atom_id = np.array(
+                [decode_hybrid36(raw_id.item()) for raw_id in atom_id_raw], dtype=int
+            )
         else:
             atom_id = None
 
@@ -444,16 +442,16 @@ class PDBFile(TextFile):
         array.atom_name = atom_name
         array.element = element
 
-        for field in (extra_fields if extra_fields is not None else []):
+        for field in extra_fields if extra_fields is not None else []:
             if field == "atom_id":
                 # Copy is necessary to avoid double masking in
                 # later altloc ID filtering
                 array.set_annotation("atom_id", atom_id.copy())
             elif field == "charge":
                 charge = np.array(charge_raw)
-                array.set_annotation("charge", np.where(
-                    charge == "  ", "0", charge
-                ).astype(int))
+                array.set_annotation(
+                    "charge", np.where(charge == "  ", "0", charge).astype(int)
+                )
             elif field == "occupancy":
                 array.set_annotation("occupancy", occupancy)
             elif field == "b_factor":
@@ -485,7 +483,10 @@ class PDBFile(TextFile):
             m = 0
             i = 0
             for line_i in self._atom_line_i:
-                if m < len(self._model_start_i)-1 and line_i > self._model_start_i[m+1]:
+                if (
+                    m < len(self._model_start_i) - 1
+                    and line_i > self._model_start_i[m + 1]
+                ):
                     m += 1
                     i = 0
                 line = self.lines[line_i]
@@ -506,9 +507,7 @@ class PDBFile(TextFile):
                     alpha = np.deg2rad(float(line[_alpha]))
                     beta = np.deg2rad(float(line[_beta]))
                     gamma = np.deg2rad(float(line[_gamma]))
-                    box = vectors_from_unitcell(
-                        len_a, len_b, len_c, alpha, beta, gamma
-                    )
+                    box = vectors_from_unitcell(len_a, len_b, len_c, alpha, beta, gamma)
                 except ValueError:
                     # File contains invalid 'CRYST1' record
                     warnings.warn(
@@ -526,9 +525,7 @@ class PDBFile(TextFile):
 
         # Filter altloc IDs
         if altloc == "occupancy":
-            filter = filter_highest_occupancy_altloc(
-                array, altloc_id, occupancy
-            )
+            filter = filter_highest_occupancy_altloc(array, altloc_id, occupancy)
             array = array[..., filter]
             atom_id = atom_id[filter] if atom_id is not None else None
         elif altloc == "first":
@@ -548,7 +545,6 @@ class PDBFile(TextFile):
 
         return array
 
-
     def set_structure(self, array, hybrid36=False):
         """
         Set the :class:`AtomArray` or :class:`AtomArrayStack` for the
@@ -596,39 +592,42 @@ class PDBFile(TextFile):
             occupancy = np.char.array(np.full(natoms, "  1.00", dtype="U6"))
         if "charge" in annot_categories:
             charge = np.char.array(
-                [str(np.abs(charge)) + "+" if charge > 0 else
-                 (str(np.abs(charge)) + "-" if charge < 0 else "")
-                 for charge in array.get_annotation("charge")]
+                [
+                    str(np.abs(charge)) + "+"
+                    if charge > 0
+                    else (str(np.abs(charge)) + "-" if charge < 0 else "")
+                    for charge in array.get_annotation("charge")
+                ]
             )
         else:
             charge = np.char.array(np.full(natoms, "  ", dtype="U2"))
 
         if hybrid36:
-            pdb_atom_id = np.char.array(
-                [encode_hybrid36(i, 5) for i in atom_id]
-            )
-            pdb_res_id = np.char.array(
-                [encode_hybrid36(i, 4) for i in array.res_id]
-            )
+            pdb_atom_id = np.char.array([encode_hybrid36(i, 5) for i in atom_id])
+            pdb_res_id = np.char.array([encode_hybrid36(i, 4) for i in array.res_id])
         else:
             # Atom IDs are supported up to 99999,
             # but negative IDs are also possible
-            pdb_atom_id = np.char.array(np.where(
-                atom_id > 0,
-                ((atom_id - 1) % _PDB_MAX_ATOMS) + 1,
-                atom_id
-            ).astype(str))
+            pdb_atom_id = np.char.array(
+                np.where(
+                    atom_id > 0, ((atom_id - 1) % _PDB_MAX_ATOMS) + 1, atom_id
+                ).astype(str)
+            )
             # Residue IDs are supported up to 9999,
             # but negative IDs are also possible
-            pdb_res_id = np.char.array(np.where(
-                array.res_id > 0,
-                ((array.res_id - 1) % _PDB_MAX_RESIDUES) + 1,
-                array.res_id
-            ).astype(str))
+            pdb_res_id = np.char.array(
+                np.where(
+                    array.res_id > 0,
+                    ((array.res_id - 1) % _PDB_MAX_RESIDUES) + 1,
+                    array.res_id,
+                ).astype(str)
+            )
 
         names = np.char.array(
-            [f" {atm}" if len(elem) == 1 and len(atm) < 4 else atm
-             for atm, elem in zip(array.atom_name, array.element)]
+            [
+                f" {atm}" if len(elem) == 1 and len(atm) < 4 else atm
+                for atm, elem in zip(array.atom_name, array.element)
+            ]
         )
         res_names = np.char.array(array.res_name)
         chain_ids = np.char.array(array.chain_id)
@@ -637,17 +636,20 @@ class PDBFile(TextFile):
         elements = np.char.array(array.element)
 
         first_half = (
-            record.ljust(6) +
-            pdb_atom_id.rjust(5) +
-            spaces +
-            names.ljust(4) +
-            spaces + res_names.rjust(3) + spaces + chain_ids +
-            pdb_res_id.rjust(4) + ins_codes.rjust(1)
+            record.ljust(6)
+            + pdb_atom_id.rjust(5)
+            + spaces
+            + names.ljust(4)
+            + spaces
+            + res_names.rjust(3)
+            + spaces
+            + chain_ids
+            + pdb_res_id.rjust(4)
+            + ins_codes.rjust(1)
         )
 
         second_half = (
-            occupancy + b_factor + 10 * spaces +
-            elements.rjust(2) + charge.rjust(2)
+            occupancy + b_factor + 10 * spaces + elements.rjust(2) + charge.rjust(2)
         )
 
         coords = array.coord
@@ -674,9 +676,10 @@ class PDBFile(TextFile):
                 self.lines.append(f"MODEL     {model_num:4}")
             # Bundle non-coordinate data to simplify iteration
             self.lines.extend(
-                [f"{start:27}   {x:>8.3f}{y:>8.3f}{z:>8.3f}{end:26}"
-                 for start, (x, y, z), end in
-                 zip(first_half, coord_i, second_half)]
+                [
+                    f"{start:27}   {x:>8.3f}{y:>8.3f}{z:>8.3f}{end:26}"
+                    for start, (x, y, z), end in zip(first_half, coord_i, second_half)
+                ]
             )
             if is_stack:
                 self.lines.append("ENDMDL")
@@ -688,18 +691,15 @@ class PDBFile(TextFile):
             hetero_indices = np.where(array.hetero & ~filter_solvent(array))[0]
             bond_array = array.bonds.as_array()
             bond_array = bond_array[
-                np.isin(bond_array[:,0], hetero_indices) |
-                np.isin(bond_array[:,1], hetero_indices) |
-                (array.res_id  [bond_array[:,0]] != array.res_id  [bond_array[:,1]]) |
-                (array.chain_id[bond_array[:,0]] != array.chain_id[bond_array[:,1]])
+                np.isin(bond_array[:, 0], hetero_indices)
+                | np.isin(bond_array[:, 1], hetero_indices)
+                | (array.res_id[bond_array[:, 0]] != array.res_id[bond_array[:, 1]])
+                | (array.chain_id[bond_array[:, 0]] != array.chain_id[bond_array[:, 1]])
             ]
-            self._set_bonds(
-                BondList(array.array_length(), bond_array), pdb_atom_id
-            )
+            self._set_bonds(BondList(array.array_length(), bond_array), pdb_atom_id)
 
         self._index_models_and_atoms()
 
-
     def list_assemblies(self):
         """
         List the biological assemblies that are available for the
@@ -727,14 +727,16 @@ class PDBFile(TextFile):
             raise InvalidFileError(
                 "File does not contain assembly information (REMARK 300)"
             )
-        return [
-            assembly_id.strip()
-            for assembly_id in remark_lines[0][12:].split(",")
-        ]
-
-
-    def get_assembly(self, assembly_id=None, model=None, altloc="first",
-                     extra_fields=[], include_bonds=False):
+        return [assembly_id.strip() for assembly_id in remark_lines[0][12:].split(",")]
+
+    def get_assembly(
+        self,
+        assembly_id=None,
+        model=None,
+        altloc="first",
+        extra_fields=[],
+        include_bonds=False,
+    ):
         """
         Build the given biological assembly.
 
@@ -829,18 +831,16 @@ class PDBFile(TextFile):
         if assembly_start_i is None:
             if assembly_id is None:
                 raise InvalidFileError(
-                    "File does not contain transformation "
-                    "expressions for assemblies"
+                    "File does not contain transformation " "expressions for assemblies"
                 )
             else:
-                raise KeyError(
-                    f"The assembly ID '{assembly_id}' is not found"
-                )
-        assembly_lines = remark_lines[assembly_start_i : assembly_stop_i]
+                raise KeyError(f"The assembly ID '{assembly_id}' is not found")
+        assembly_lines = remark_lines[assembly_start_i:assembly_stop_i]
 
         # Get transformations for a set of chains
         chain_set_start_indices = [
-            i for i, line in enumerate(assembly_lines)
+            i
+            for i, line in enumerate(assembly_lines)
             if line.startswith("APPLY THE FOLLOWING TO CHAINS")
         ]
         # Add exclusive stop at end of records
@@ -848,17 +848,17 @@ class PDBFile(TextFile):
         assembly = None
         for i in range(len(chain_set_start_indices) - 1):
             start = chain_set_start_indices[i]
-            stop = chain_set_start_indices[i+1]
+            stop = chain_set_start_indices[i + 1]
             # Read affected chain IDs from the following line(s)
             affected_chain_ids = []
             transform_start = None
-            for j, line in enumerate(assembly_lines[start : stop]):
-                if line.startswith("APPLY THE FOLLOWING TO CHAINS:") or \
-                   line.startswith("                   AND CHAINS:"):
-                        affected_chain_ids += [
-                            chain_id.strip()
-                            for chain_id in line[30:].split(",")
-                        ]
+            for j, line in enumerate(assembly_lines[start:stop]):
+                if line.startswith("APPLY THE FOLLOWING TO CHAINS:") or line.startswith(
+                    "                   AND CHAINS:"
+                ):
+                    affected_chain_ids += [
+                        chain_id.strip() for chain_id in line[30:].split(",")
+                    ]
                 else:
                     # Chain specification has finished
                     # BIOMT lines start directly after chain specification
@@ -866,11 +866,9 @@ class PDBFile(TextFile):
                     break
             # Parse transformations from BIOMT lines
             if transform_start is None:
-                raise InvalidFileError(
-                    "No 'BIOMT' records found for chosen assembly"
-                )
+                raise InvalidFileError("No 'BIOMT' records found for chosen assembly")
             rotations, translations = _parse_transformations(
-                assembly_lines[transform_start : stop]
+                assembly_lines[transform_start:stop]
             )
             # Filter affected chains
             sub_structure = structure[
@@ -888,9 +886,9 @@ class PDBFile(TextFile):
 
         return assembly
 
-
-    def get_symmetry_mates(self, model=None, altloc="first",
-                           extra_fields=[], include_bonds=False):
+    def get_symmetry_mates(
+        self, model=None, altloc="first", extra_fields=[], include_bonds=False
+    ):
         """
         Build a structure model containing all symmetric copies
         of the structure within a single unit cell, given by the space
@@ -971,27 +969,15 @@ class PDBFile(TextFile):
                 "File does not contain crystallographic symmetry "
                 "information (REMARK 350)"
             )
-        transform_lines = [
-            line for line in remark_lines if line.startswith("  SMTRY")
-        ]
-        rotations, translations = _parse_transformations(
-            transform_lines
-        )
-        return _apply_transformations(
-            structure, rotations, translations
-        )
-
-
-
+        transform_lines = [line for line in remark_lines if line.startswith("  SMTRY")]
+        rotations, translations = _parse_transformations(transform_lines)
+        return _apply_transformations(structure, rotations, translations)
 
     def _index_models_and_atoms(self):
         # Line indices where a new model starts
         self._model_start_i = np.array(
-            [
-                i for i in range(len(self.lines))
-                if self.lines[i].startswith(("MODEL"))
-            ],
-            dtype=int
+            [i for i in range(len(self.lines)) if self.lines[i].startswith(("MODEL"))],
+            dtype=int,
         )
         if len(self._model_start_i) == 0:
             # It could be an empty file or a file with a single model,
@@ -1005,13 +991,13 @@ class PDBFile(TextFile):
         # Line indices with ATOM or HETATM records
         self._atom_line_i = np.array(
             [
-                i for i in range(len(self.lines))
+                i
+                for i in range(len(self.lines))
                 if self.lines[i].startswith(("ATOM", "HETATM"))
             ],
-            dtype=int
+            dtype=int,
         )
 
-
     def _get_atom_record_indices_for_model(self, model):
         last_model = len(self._model_start_i)
         if model == 0:
@@ -1020,12 +1006,11 @@ class PDBFile(TextFile):
         model = last_model + model + 1 if model < 0 else model
 
         if model < last_model:
-            line_filter = (
-                (self._atom_line_i >= self._model_start_i[model-1]) &
-                (self._atom_line_i <  self._model_start_i[model  ])
+            line_filter = (self._atom_line_i >= self._model_start_i[model - 1]) & (
+                self._atom_line_i < self._model_start_i[model]
             )
         elif model == last_model:
-            line_filter = (self._atom_line_i >= self._model_start_i[model-1])
+            line_filter = self._atom_line_i >= self._model_start_i[model - 1]
         else:
             raise ValueError(
                 f"The file has {last_model} models, "
@@ -1033,7 +1018,6 @@ class PDBFile(TextFile):
             )
         return self._atom_line_i[line_filter]
 
-
     def _get_model_length(self):
         """
         Determine length of models and check that all models
@@ -1043,11 +1027,13 @@ class PDBFile(TextFile):
         length = None
         for model_i in range(len(self._model_start_i)):
             model_start = self._model_start_i[model_i]
-            model_stop = self._model_start_i[model_i+1] \
-                         if model_i+1 < n_models else len(self.lines)
+            model_stop = (
+                self._model_start_i[model_i + 1]
+                if model_i + 1 < n_models
+                else len(self.lines)
+            )
             model_length = np.count_nonzero(
-                (self._atom_line_i >= model_start) &
-                (self._atom_line_i < model_stop)
+                (self._atom_line_i >= model_start) & (self._atom_line_i < model_stop)
             )
             if length is None:
                 length = model_length
@@ -1058,26 +1044,22 @@ class PDBFile(TextFile):
                 )
         return length
 
-
     def _get_bonds(self, atom_ids):
-        conect_lines = [line for line in self.lines
-                        if line.startswith("CONECT")]
+        conect_lines = [line for line in self.lines if line.startswith("CONECT")]
 
         # Mapping from atom ids to indices in an AtomArray
-        atom_id_to_index = np.zeros(atom_ids[-1]+1, dtype=int)
+        atom_id_to_index = np.zeros(atom_ids[-1] + 1, dtype=int)
         try:
             for i, id in enumerate(atom_ids):
                 atom_id_to_index[id] = i
         except IndexError as e:
-            raise InvalidFileError(
-                "Atom IDs are not strictly increasing"
-            ) from e
+            raise InvalidFileError("Atom IDs are not strictly increasing") from e
 
         bonds = []
         for line in conect_lines:
-            center_id = atom_id_to_index[decode_hybrid36(line[6 : 11])]
+            center_id = atom_id_to_index[decode_hybrid36(line[6:11])]
             for i in range(11, 31, 5):
-                id_string = line[i : i+5]
+                id_string = line[i : i + 5]
                 try:
                     id = atom_id_to_index[decode_hybrid36(id_string)]
                 except ValueError:
@@ -1089,7 +1071,6 @@ class PDBFile(TextFile):
         # is equal to the length of the AtomArray
         return BondList(len(atom_ids), np.array(bonds, dtype=np.uint32))
 
-
     def _set_bonds(self, bond_list, atom_ids):
         # Bond type is unused since PDB does not support bond orders
         bonds, _ = bond_list.get_all_bonds()
@@ -1136,9 +1117,7 @@ def _parse_transformations(lines):
         # transformation index) are not used
         transformations = [float(e) for e in line.split()[2:]]
         if len(transformations) != 4:
-            raise InvalidFileError(
-                "Invalid number of transformation vector elements"
-            )
+            raise InvalidFileError("Invalid number of transformation vector elements")
         rotations[transformation_i, component_i, :] = transformations[:3]
         translations[transformation_i, component_i] = transformations[3]
 
@@ -1237,4 +1216,4 @@ def _number_of_integer_digits(values):
     n_digits = 0
     n_digits = max(n_digits, len(str(np.min(values))))
     n_digits = max(n_digits, len(str(np.max(values))))
-    return n_digits
+    return n_digits

biotite/structure/io/pdbqt/__init__.py

@@ -11,5 +11,5 @@ software series.
 __name__ = "biotite.structure.io.pdbqt"
 __author__ = "Patrick Kunzmann"
 
+from .convert import *
 from .file import *
-from .convert import *