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

biotite/structure/io/pdbqt/convert.py

@@ -18,7 +18,7 @@ def get_structure(pdbqt_file, model=None):
     PDBQT file.
 
     EXPERIMENTAL: Future API changes are probable.
-    
+
     Parameters
     ----------
     pdbqt_file : PDBQTFile
@@ -32,7 +32,7 @@ def get_structure(pdbqt_file, model=None):
         If this parameter is omitted, an :class:`AtomArrayStack`
         containing all models will be returned, even if the
         structure contains only one model.
-    
+
     Returns
     -------
     array : AtomArray or AtomArrayStack
@@ -41,13 +41,20 @@ def get_structure(pdbqt_file, model=None):
     return pdbqt_file.get_structure(model)
 
 
-def set_structure(pdbqt_file, atoms, charges=None, atom_types=None,
-                  rotatable_bonds=None, root=None, include_torsdof=True):
+def set_structure(
+    pdbqt_file,
+    atoms,
+    charges=None,
+    atom_types=None,
+    rotatable_bonds=None,
+    root=None,
+    include_torsdof=True,
+):
     """
     Write an :class:`AtomArray` into a PDBQT file.
 
     EXPERIMENTAL: Future API changes are probable.
-    
+
     Parameters
     ----------
     pdbqt_file : PDBQTFile
@@ -71,7 +78,7 @@ def set_structure(pdbqt_file, atoms, charges=None, atom_types=None,
               be written.
             - ``'rigid'`` - The molecule is handled as rigid ligand:
               Only a ``ROOT`` line will be written.
-            - ``'all'`` - The molecule is handled as flexible 
+            - ``'all'`` - The molecule is handled as flexible
               ligand:
               A ``ROOT`` line will be written and all rotatable
               bonds are included using ``BRANCH`` and ``ENDBRANCH``
@@ -81,7 +88,7 @@ def set_structure(pdbqt_file, atoms, charges=None, atom_types=None,
               A ``ROOT`` line will be written and all bonds in the
               given :class:`BondList` are considered flexible via
               ``BRANCH`` and ``ENDBRANCH`` lines.
-        
+
     root : int, optional
         Specifies the index of the atom following the ``ROOT`` line.
         Setting the root atom is useful for specifying the *anchor*
@@ -93,7 +100,7 @@ def set_structure(pdbqt_file, atoms, charges=None, atom_types=None,
         By default, a ``TORSDOF`` (torsional degrees of freedom)
         record is written at the end of the file.
         By setting this parameter to false, the record is omitted.
-    
+
     Returns
     -------
     mask : ndarray, shape=(n,), dtype=bool
@@ -102,6 +109,5 @@ def set_structure(pdbqt_file, atoms, charges=None, atom_types=None,
         hydrogen.
     """
     return pdbqt_file.set_structure(
-        atoms, charges, atom_types, rotatable_bonds, root,
-        include_torsdof
-    )
+        atoms, charges, atom_types, rotatable_bonds, root, include_torsdof
+    )

biotite/structure/io/pdbqt/file.py

@@ -8,17 +8,33 @@ __all__ = ["PDBQTFile"]
 
 import warnings
 import numpy as np
-from ....file import TextFile, InvalidFileError
-from ...error import BadStructureError
-from ...atoms import AtomArray, AtomArrayStack
-from ...charges import partial_charges
-from ...bonds import BondList, BondType, find_connected, find_rotatable_bonds
-
+from biotite.file import InvalidFileError, TextFile
+from biotite.structure.atoms import AtomArray, AtomArrayStack
+from biotite.structure.bonds import (
+    BondList,
+    BondType,
+    find_connected,
+    find_rotatable_bonds,
+)
+from biotite.structure.charges import partial_charges
+from biotite.structure.error import BadStructureError
 
 PARAMETRIZED_ELEMENTS = [
-    "H", "C", "N", "O", "P", "S",
-    "F", "Cl", "Br", "I",
-    "Mg", "Ca", "Mn", "Fe", "Zn"
+    "H",
+    "C",
+    "N",
+    "O",
+    "P",
+    "S",
+    "F",
+    "Cl",
+    "Br",
+    "I",
+    "Mg",
+    "Ca",
+    "Mn",
+    "Fe",
+    "Zn",
 ]
 
 
@@ -116,13 +132,15 @@ class PDBQTFile(TextFile):
             ``'REMARKS'``.
         """
         # Line indices where a new model starts
-        model_start_i = np.array([i for i in range(len(self.lines))
-                                  if self.lines[i].startswith(("MODEL"))],
-                                 dtype=int)
+        model_start_i = np.array(
+            [i for i in range(len(self.lines)) if self.lines[i].startswith(("MODEL"))],
+            dtype=int,
+        )
         # Line indices with ATOM or HETATM records
-        remark_line_i = np.array([i for i in range(len(self.lines)) if
-                                  self.lines[i].startswith("REMARK")],
-                                 dtype=int)
+        remark_line_i = np.array(
+            [i for i in range(len(self.lines)) if self.lines[i].startswith("REMARK")],
+            dtype=int,
+        )
         # Structures containing only one model may omit MODEL record
         # In these cases model starting index is set to 0
         if len(model_start_i) == 0:
@@ -131,11 +149,10 @@ class PDBQTFile(TextFile):
         if model is None:
             # Add exclusive end of file
             model_start_i = np.concatenate((model_start_i, [len(self.lines)]))
-            model_i = 0
             remarks = []
             for i in range(len(model_start_i) - 1):
                 start = model_start_i[i]
-                stop  = model_start_i[i+1]
+                stop = model_start_i[i + 1]
                 model_remark_line_i = remark_line_i[
                     (remark_line_i >= start) & (remark_line_i < stop)
                 ]
@@ -152,10 +169,11 @@ class PDBQTFile(TextFile):
             model = last_model + model + 1 if model < 0 else model
 
             if model < last_model:
-                line_filter = ( ( remark_line_i >= model_start_i[model-1] ) &
-                                ( remark_line_i <  model_start_i[model  ] ) )
+                line_filter = (remark_line_i >= model_start_i[model - 1]) & (
+                    remark_line_i < model_start_i[model]
+                )
             elif model == last_model:
-                line_filter = (remark_line_i >= model_start_i[model-1])
+                line_filter = remark_line_i >= model_start_i[model - 1]
             else:
                 raise ValueError(
                     f"The file has {last_model} models, "
@@ -166,7 +184,6 @@ class PDBQTFile(TextFile):
             # Do not include 'REMARK ' itself -> begin from pos 8
             return "\n".join([self.lines[i][7:] for i in remark_line_i])
 
-
     def get_structure(self, model=None):
         """
         Get an :class:`AtomArray` or :class:`AtomArrayStack` from the
@@ -190,13 +207,19 @@ class PDBQTFile(TextFile):
             The return type depends on the `model` parameter.
         """
         # Line indices where a new model starts
-        model_start_i = np.array([i for i in range(len(self.lines))
-                                  if self.lines[i].startswith(("MODEL"))],
-                                 dtype=int)
+        model_start_i = np.array(
+            [i for i in range(len(self.lines)) if self.lines[i].startswith(("MODEL"))],
+            dtype=int,
+        )
         # Line indices with ATOM or HETATM records
-        atom_line_i = np.array([i for i in range(len(self.lines)) if
-                                self.lines[i].startswith(("ATOM", "HETATM"))],
-                               dtype=int)
+        atom_line_i = np.array(
+            [
+                i
+                for i in range(len(self.lines))
+                if self.lines[i].startswith(("ATOM", "HETATM"))
+            ],
+            dtype=int,
+        )
         # Structures containing only one model may omit MODEL record
         # In these cases model starting index is set to 0
         if len(model_start_i) == 0:
@@ -224,10 +247,11 @@ class PDBQTFile(TextFile):
             model = last_model + model + 1 if model < 0 else model
 
             if model < last_model:
-                line_filter = ( ( atom_line_i >= model_start_i[model-1] ) &
-                                ( atom_line_i <  model_start_i[model  ] ) )
+                line_filter = (atom_line_i >= model_start_i[model - 1]) & (
+                    atom_line_i < model_start_i[model]
+                )
             elif model == last_model:
-                line_filter = (atom_line_i >= model_start_i[model-1])
+                line_filter = atom_line_i >= model_start_i[model - 1]
             else:
                 raise ValueError(
                     f"The file has {last_model} models, "
@@ -237,16 +261,16 @@ class PDBQTFile(TextFile):
             array = AtomArray(len(coord_i))
 
         # Save atom IDs for later sorting into the original atom order
-        atom_id  = np.zeros(array.array_length(), int)
+        atom_id = np.zeros(array.array_length(), int)
 
         # Create 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)
 
         # Fill annotation array
         # i is index in array, line_i is line index
@@ -258,7 +282,7 @@ class PDBQTFile(TextFile):
             res_id[i] = int(line[22:26])
             ins_code[i] = line[26].strip()
             res_name[i] = line[17:20].strip()
-            hetero[i] = (False if line[0:4] == "ATOM" else True)
+            hetero[i] = False if line[0:4] == "ATOM" else True
             atom_name[i] = line[12:16].strip()
             element[i] = line[76:78].strip()
 
@@ -275,21 +299,21 @@ class PDBQTFile(TextFile):
         if isinstance(array, AtomArray):
             for i, line_i in enumerate(coord_i):
                 line = self.lines[line_i]
-                array.coord[i,0] = float(line[30:38])
-                array.coord[i,1] = float(line[38:46])
-                array.coord[i,2] = float(line[46:54])
+                array.coord[i, 0] = float(line[30:38])
+                array.coord[i, 1] = float(line[38:46])
+                array.coord[i, 2] = float(line[46:54])
 
         elif isinstance(array, AtomArrayStack):
             m = 0
             i = 0
             for line_i in atom_line_i:
-                if m < len(model_start_i)-1 and line_i > model_start_i[m+1]:
+                if m < len(model_start_i) - 1 and line_i > model_start_i[m + 1]:
                     m += 1
                     i = 0
                 line = self.lines[line_i]
-                array.coord[m,i,0] = float(line[30:38])
-                array.coord[m,i,1] = float(line[38:46])
-                array.coord[m,i,2] = float(line[46:54])
+                array.coord[m, i, 0] = float(line[30:38])
+                array.coord[m, i, 1] = float(line[38:46])
+                array.coord[m, i, 2] = float(line[46:54])
                 i += 1
 
         # Sort into the original atom order
@@ -297,9 +321,15 @@ class PDBQTFile(TextFile):
 
         return array
 
-
-    def set_structure(self, atoms, charges=None, atom_types=None,
-                      rotatable_bonds=None, root=None, include_torsdof=True):
+    def set_structure(
+        self,
+        atoms,
+        charges=None,
+        atom_types=None,
+        rotatable_bonds=None,
+        root=None,
+        include_torsdof=True,
+    ):
         """
         Write an :class:`AtomArray` into the PDBQT file.
 
@@ -394,12 +424,8 @@ class PDBQTFile(TextFile):
             use_root = True
         else:
             if rotatable_bonds.ndim != 2 or rotatable_bonds.shape[1] != 2:
-                raise ValueError(
-                    "An (nx2) array is expected for rotatable bonds"
-                )
-            rotatable_bonds = BondList(
-                len(mask), np.asarray(rotatable_bonds)
-            )[mask]
+                raise ValueError("An (nx2) array is expected for rotatable bonds")
+            rotatable_bonds = BondList(len(mask), np.asarray(rotatable_bonds))[mask]
             use_root = True
 
         if root is None:
@@ -426,35 +452,51 @@ class PDBQTFile(TextFile):
         # for simple branch determination in '_write_atoms()'
         atoms.bonds.remove_bonds(rotatable_bonds)
 
-        hetero = ["ATOM" if e == False else "HETATM" for e in atoms.hetero]
+        hetero = ["HETATM" if e else "ATOM" for e in atoms.hetero]
         if "atom_id" in atoms.get_annotation_categories():
             atom_id = atoms.atom_id
         else:
-            atom_id = np.arange(1, atoms.array_length()+1)
+            atom_id = np.arange(1, atoms.array_length() + 1)
         occupancy = np.ones(atoms.array_length())
         b_factor = np.zeros(atoms.array_length())
 
         # Convert rotatable bonds into array for easier handling
         # The bond type is irrelevant from this point on
-        rotatable_bonds = rotatable_bonds.as_array()[:,:2]
+        rotatable_bonds = rotatable_bonds.as_array()[:, :2]
 
         self.lines = []
         self._write_atoms(
-            atoms, charges, types,
-            atom_id, hetero, occupancy, b_factor,
-            root_index, rotatable_bonds,
-            np.zeros(len(rotatable_bonds), dtype=bool), use_root
+            atoms,
+            charges,
+            types,
+            atom_id,
+            hetero,
+            occupancy,
+            b_factor,
+            root_index,
+            rotatable_bonds,
+            np.zeros(len(rotatable_bonds), dtype=bool),
+            use_root,
         )
         if include_torsdof:
             self.lines.append(f"TORSDOF {len(rotatable_bonds)}")
 
         return mask
 
-
-    def _write_atoms(self, atoms, charges, types,
-                     atom_id, hetero, occupancy, b_factor,
-                     root_atom, rotatable_bonds, visited_rotatable_bonds,
-                     is_root):
+    def _write_atoms(
+        self,
+        atoms,
+        charges,
+        types,
+        atom_id,
+        hetero,
+        occupancy,
+        b_factor,
+        root_atom,
+        rotatable_bonds,
+        visited_rotatable_bonds,
+        is_root,
+    ):
         if len(rotatable_bonds) != 0:
             # Get the indices to atoms of this branch, i.e. a group of
             # atoms that are connected by non-rotatable bonds
@@ -465,9 +507,7 @@ class PDBQTFile(TextFile):
             # the rotatable bond should always be listed first
             # -> Remove root atom and insert it at the beginning
             this_branch_indices = np.insert(
-                this_branch_indices[this_branch_indices != root_atom],
-                0,
-                root_atom
+                this_branch_indices[this_branch_indices != root_atom], 0, root_atom
             )
         else:
             # No rotatable bonds
@@ -525,18 +565,24 @@ class PDBQTFile(TextFile):
                 f"BRANCH {atom_id[this_br_i]:>3d} {atom_id[new_br_i]:>3d}"
             )
             self._write_atoms(
-                atoms, charges, types,
-                atom_id, hetero, occupancy, b_factor,
+                atoms,
+                charges,
+                types,
+                atom_id,
+                hetero,
+                occupancy,
+                b_factor,
                 # The root atom of the branch
-                #is the other atom of the rotatable bond
-                new_br_i, rotatable_bonds, visited_rotatable_bonds,
-                False
+                # is the other atom of the rotatable bond
+                new_br_i,
+                rotatable_bonds,
+                visited_rotatable_bonds,
+                False,
             )
             self.lines.append(
                 f"ENDBRANCH {atom_id[this_br_i]:>3d} {atom_id[new_br_i]:>3d}"
             )
 
-
     def _get_model_length(self, model_start_i, atom_line_i):
         """
         Determine length of models and check that all models
@@ -546,8 +592,11 @@ class PDBQTFile(TextFile):
         length = None
         for model_i in range(len(model_start_i)):
             model_start = model_start_i[model_i]
-            model_stop = model_start_i[model_i+1] if model_i+1 < n_models \
-                            else len(self.lines)
+            model_stop = (
+                model_start_i[model_i + 1]
+                if model_i + 1 < n_models
+                else len(self.lines)
+            )
             model_length = np.count_nonzero(
                 (atom_line_i >= model_start) & (atom_line_i < model_stop)
             )
@@ -613,8 +662,7 @@ def convert_atoms(atoms, charges):
                 )
         elif element == "C":
             if np.isin(
-                all_bond_types[i],
-                [BondType.AROMATIC_SINGLE, BondType.AROMATIC_DOUBLE]
+                all_bond_types[i], [BondType.AROMATIC_SINGLE, BondType.AROMATIC_DOUBLE]
             ).any():
                 # Aromatic carbon
                 atom_types[i] = "A"
@@ -637,4 +685,4 @@ def convert_atoms(atoms, charges):
             atom_types[i] = "H"
 
     mask = ~hydrogen_removal_mask
-    return atoms[mask], charges[mask], atom_types[mask], mask
+    return atoms[mask], charges[mask], atom_types[mask], mask

biotite/structure/io/pdbx/__init__.py

@@ -15,9 +15,8 @@ from/to these files.
 __name__ = "biotite.structure.io.pdbx"
 __author__ = "Patrick Kunzmann"
 
-from .convert import *
 from .bcif import *
 from .cif import *
 from .component import *
+from .convert import *
 from .encoding import *
-from .legacy import *

biotite/structure/io/pdbx/bcif.py

@@ -4,16 +4,29 @@
 
 __name__ = "biotite.structure.io.pdbx"
 __author__ = "Patrick Kunzmann"
-__all__ = ["BinaryCIFFile", "BinaryCIFBlock", "BinaryCIFCategory",
-           "BinaryCIFColumn", "BinaryCIFData"]
+__all__ = [
+    "BinaryCIFFile",
+    "BinaryCIFBlock",
+    "BinaryCIFCategory",
+    "BinaryCIFColumn",
+    "BinaryCIFData",
+]
 
 from collections.abc import Sequence
-import numpy as np
 import msgpack
-from .component import _Component, _HierarchicalContainer, MaskValue
-from .encoding import decode_stepwise, encode_stepwise, deserialize_encoding, \
-                      create_uncompressed_encoding
-from ....file import File, is_binary, is_open_compatible, SerializationError
+import numpy as np
+from biotite.file import File, SerializationError, is_binary, is_open_compatible
+from biotite.structure.io.pdbx.component import (
+    MaskValue,
+    _Component,
+    _HierarchicalContainer,
+)
+from biotite.structure.io.pdbx.encoding import (
+    create_uncompressed_encoding,
+    decode_stepwise,
+    deserialize_encoding,
+    encode_stepwise,
+)
 
 
 class BinaryCIFData(_Component):
@@ -74,10 +87,7 @@ class BinaryCIFData(_Component):
     """
 
     def __init__(self, array, encoding=None):
-        if (
-            not isinstance(array, (Sequence, np.ndarray))
-            or isinstance(array, str)
-        ):
+        if not isinstance(array, (Sequence, np.ndarray)) or isinstance(array, str):
             array = [array]
         array = np.asarray(array)
         if np.issubdtype(array.dtype, np.object_):
@@ -107,19 +117,13 @@ class BinaryCIFData(_Component):
 
     @staticmethod
     def deserialize(content):
-        encoding = [
-            deserialize_encoding(enc) for enc in content["encoding"]
-        ]
-        return BinaryCIFData(
-            decode_stepwise(content["data"], encoding), encoding
-        )
+        encoding = [deserialize_encoding(enc) for enc in content["encoding"]]
+        return BinaryCIFData(decode_stepwise(content["data"], encoding), encoding)
 
     def serialize(self):
         serialized_data = encode_stepwise(self._array, self._encoding)
         if not isinstance(serialized_data, bytes):
-            raise SerializationError(
-                "Final encoding must return 'bytes'"
-            )
+            raise SerializationError("Final encoding must return 'bytes'")
         serialized_encoding = [enc.serialize() for enc in self._encoding]
         return {"data": serialized_data, "encoding": serialized_encoding}
 
@@ -190,8 +194,7 @@ class BinaryCIFColumn(_Component):
                 mask = BinaryCIFData(mask)
             if len(data) != len(mask):
                 raise IndexError(
-                    f"Data has length {len(data)}, "
-                    f"but mask has length {len(mask)}"
+                    f"Data has length {len(data)}, " f"but mask has length {len(mask)}"
                 )
         self._data = data
         self._mask = mask
@@ -290,9 +293,7 @@ class BinaryCIFColumn(_Component):
                 array = np.full(len(self._data), masked_value, dtype=dtype)
 
             present_mask = self._mask.array == MaskValue.PRESENT
-            array[present_mask] = (
-                self._data.array[present_mask].astype(dtype)
-            )
+            array[present_mask] = self._data.array[present_mask].astype(dtype)
             return array
 
     @staticmethod
@@ -300,13 +301,14 @@ class BinaryCIFColumn(_Component):
         return BinaryCIFColumn(
             BinaryCIFData.deserialize(content["data"]),
             BinaryCIFData.deserialize(content["mask"])
-            if content["mask"] is not None else None
+            if content["mask"] is not None
+            else None,
         )
 
     def serialize(self):
         return {
             "data": self._data.serialize(),
-            "mask": self._mask.serialize() if self._mask is not None else None
+            "mask": self._mask.serialize() if self._mask is not None else None,
         }
 
     def __len__(self):
@@ -392,10 +394,8 @@ class BinaryCIFCategory(_HierarchicalContainer):
     @staticmethod
     def deserialize(content):
         return BinaryCIFCategory(
-            BinaryCIFCategory._deserialize_elements(
-                content["columns"], "name"
-            ),
-            content["rowCount"]
+            BinaryCIFCategory._deserialize_elements(content["columns"], "name"),
+            content["rowCount"],
         )
 
     def serialize(self):
@@ -470,9 +470,7 @@ class BinaryCIFBlock(_HierarchicalContainer):
     @staticmethod
     def deserialize(content):
         return BinaryCIFBlock(
-            BinaryCIFBlock._deserialize_elements(
-                content["categories"], "name"
-            )
+            BinaryCIFBlock._deserialize_elements(content["categories"], "name")
         )
 
     def serialize(self):
@@ -559,16 +557,14 @@ class BinaryCIFFile(File, _HierarchicalContainer):
     @staticmethod
     def deserialize(content):
         return BinaryCIFFile(
-            BinaryCIFFile._deserialize_elements(
-                content["dataBlocks"], "header"
-            )
+            BinaryCIFFile._deserialize_elements(content["dataBlocks"], "header")
         )
 
     def serialize(self):
         return {"dataBlocks": self._serialize_elements("header")}
 
     @classmethod
-    def read(self, file):
+    def read(cls, file):
         """
         Read a *BinaryCIF* file.
 
@@ -587,18 +583,14 @@ class BinaryCIFFile(File, _HierarchicalContainer):
         if is_open_compatible(file):
             with open(file, "rb") as f:
                 return BinaryCIFFile.deserialize(
-                    msgpack.unpackb(
-                        f.read(), use_list=True, raw=False
-                    )
+                    msgpack.unpackb(f.read(), use_list=True, raw=False)
                 )
         # File object
         else:
             if not is_binary(file):
                 raise TypeError("A file opened in 'binary' mode is required")
             return BinaryCIFFile.deserialize(
-                msgpack.unpackb(
-                    file.read(), use_list=True, raw=False
-                )
+                msgpack.unpackb(file.read(), use_list=True, raw=False)
             )
 
     def write(self, file):