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

biotite/structure/io/gro/file.py

@@ -6,25 +6,27 @@ __name__ = "biotite.structure.io.gro"
 __author__ = "Daniel Bauer, Patrick Kunzmann"
 __all__ = ["GROFile"]
 
-import numpy as np
-from ...atoms import AtomArray, AtomArrayStack
-from ...box import is_orthogonal
-from ....file import TextFile, InvalidFileError
-from ...repair import infer_elements
-from ...error import BadStructureError
 import copy
 from datetime import datetime
-
-_atom_records = {"res_id"    : (0, 5),
-                 "res_name"  : (5,10),
-                 "atom_name" : (10,15),
-                 "atom_id"   : (15,20),
-                 "coord_x"   : (20, 28),
-                 "coord_y"   : (28, 36),
-                 "coord_z"   : (36, 44),
-                 "v_x"       : (44, 52),
-                 "v_y"       : (52, 60),
-                 "v_z"       : (60, 68)}
+import numpy as np
+from biotite.file import InvalidFileError, TextFile
+from biotite.structure.atoms import AtomArray, AtomArrayStack
+from biotite.structure.box import is_orthogonal
+from biotite.structure.error import BadStructureError
+from biotite.structure.repair import infer_elements
+
+_atom_records = {
+    "res_id": (0, 5),
+    "res_name": (5, 10),
+    "atom_name": (10, 15),
+    "atom_id": (15, 20),
+    "coord_x": (20, 28),
+    "coord_y": (28, 36),
+    "coord_z": (36, 44),
+    "v_x": (44, 52),
+    "v_y": (52, 60),
+    "v_z": (60, 68),
+}
 
 
 class GROFile(TextFile):
@@ -48,6 +50,7 @@ class GROFile(TextFile):
     >>> file.write(os.path.join(path_to_directory, "1l2y_mod.gro"))
 
     """
+
     def get_model_count(self):
         """
         Get the number of models contained in this GRO file.
@@ -63,7 +66,6 @@ class GROFile(TextFile):
                 model_count += 1
         return model_count
 
-
     def get_structure(self, model=None):
         """
         Get an :class:`AtomArray` or :class:`AtomArrayStack` from the
@@ -91,9 +93,7 @@ class GROFile(TextFile):
             """
             Helper function to get the indices of all atoms for a model
             """
-            return np.arange(
-                model_start_i+1, model_start_i+1+model_atom_counts
-            )
+            return np.arange(model_start_i + 1, model_start_i + 1 + model_atom_counts)
 
         def set_box_dimen(box_param):
             """
@@ -114,33 +114,31 @@ class GROFile(TextFile):
                 return None
             if len(box_param) == 3:
                 x, y, z = box_param
-                return np.array([[x,0,0], [0,y,0], [0,0,z]], dtype=float)
+                return np.array([[x, 0, 0], [0, y, 0], [0, 0, z]], dtype=float)
             elif len(box_param) == 9:
                 x1, y2, z3, x2, x3, y1, y3, z1, z2 = box_param
-                return np.array(
-                    [[x1,x2,x3], [y1,y2,y3], [z1,z2,z3]], dtype=float
-                )
+                return np.array([[x1, x2, x3], [y1, y2, y3], [z1, z2, z3]], dtype=float)
             else:
                 raise InvalidFileError(
                     f"Invalid amount of box parameters: {len(box_param)}"
                 )
 
         # Line indices where a new model starts
-        model_start_i = np.array([i for i in range(len(self.lines))
-                                  if _is_int(self.lines[i])],
-                                 dtype=int)
+        model_start_i = np.array(
+            [i for i in range(len(self.lines)) if _is_int(self.lines[i])], dtype=int
+        )
 
         # Number of atoms in each model
-        model_atom_counts = np.array(
-            [int(self.lines[i]) for i in model_start_i]
-        )
+        model_atom_counts = np.array([int(self.lines[i]) for i in model_start_i])
 
         if model is None:
             # Check if all models have the same length
             if np.all(model_atom_counts != model_atom_counts[0]):
-                raise BadStructureError("The models in the file have unequal "
-                                        "amount of atoms, give an explicit "
-                                        "model instead")
+                raise BadStructureError(
+                    "The models in the file have unequal "
+                    "amount of atoms, give an explicit "
+                    "model instead"
+                )
             depth = len(model_start_i)
             length = model_atom_counts[0]
             array = AtomArrayStack(depth, length)
@@ -159,10 +157,10 @@ class GROFile(TextFile):
                     f"the given model {model} does not exist"
                 )
 
-            length = model_atom_counts[model-1]
+            length = model_atom_counts[model - 1]
             array = AtomArray(length)
 
-            annot_i = get_atom_line_i(model_start_i[model-1], length)
+            annot_i = get_atom_line_i(model_start_i[model - 1], length)
 
         # Replace empty strings for elements with guessed types
         # i is index in array, line_i is line index
@@ -179,27 +177,25 @@ class GROFile(TextFile):
             for i, line_i in enumerate(atom_i):
                 line = self.lines[line_i]
                 # gro files use nm instead of A
-                array.coord[i,0] = float(line[20:28])*10
-                array.coord[i,1] = float(line[28:36])*10
-                array.coord[i,2] = float(line[36:44])*10
+                array.coord[i, 0] = float(line[20:28]) * 10
+                array.coord[i, 1] = float(line[28:36]) * 10
+                array.coord[i, 2] = float(line[36:44]) * 10
             # Box is stored in last line (after coordinates)
             box_i = atom_i[-1] + 1
-            box_param = [float(e)*10 for e in self.lines[box_i].split()]
+            box_param = [float(e) * 10 for e in self.lines[box_i].split()]
             array.box = set_box_dimen(box_param)
 
         elif isinstance(array, AtomArrayStack):
             for m in range(len(model_start_i)):
-                atom_i = get_atom_line_i(
-                    model_start_i[m], model_atom_counts[m]
-                )
+                atom_i = get_atom_line_i(model_start_i[m], model_atom_counts[m])
                 for i, line_i in enumerate(atom_i):
                     line = self.lines[line_i]
-                    array.coord[m,i,0] = float(line[20:28])*10
-                    array.coord[m,i,1] = float(line[28:36])*10
-                    array.coord[m,i,2] = float(line[36:44])*10
+                    array.coord[m, i, 0] = float(line[20:28]) * 10
+                    array.coord[m, i, 1] = float(line[28:36]) * 10
+                    array.coord[m, i, 2] = float(line[36:44]) * 10
                 # Box is stored in last line (after coordinates)
                 box_i = atom_i[-1] + 1
-                box_param = [float(e)*10 for e in self.lines[box_i].split()]
+                box_param = [float(e) * 10 for e in self.lines[box_i].split()]
                 box = set_box_dimen(box_param)
                 # Create a box in the stack if not already existing
                 # and the box is not a dummy
@@ -210,7 +206,6 @@ class GROFile(TextFile):
 
         return array
 
-
     def set_structure(self, array):
         """
         Set the :class:`AtomArray` or :class:`AtomArrayStack` for the
@@ -223,6 +218,7 @@ class GROFile(TextFile):
             is given, each array in the stack is saved as separate
             model.
         """
+
         def get_box_dimen(array):
             """
             GRO files have the box dimensions as last line for each
@@ -253,10 +249,15 @@ class GROFile(TextFile):
                 else:
                     box = box / 10
                     box_elements = (
-                        box[0,0], box[1,1], box[2,2],
-                        box[0,1], box[0,2],
-                        box[1,0], box[1,2],
-                        box[2,0], box[2,1],
+                        box[0, 0],
+                        box[1, 1],
+                        box[2, 2],
+                        box[0, 1],
+                        box[0, 2],
+                        box[1, 0],
+                        box[1, 2],
+                        box[2, 0],
+                        box[2, 1],
                     )
                     return " ".join([f"{e:>9.5f}" for e in box_elements])
 
@@ -266,17 +267,11 @@ class GROFile(TextFile):
             atom_id = np.arange(1, array.array_length() + 1)
         # Atom IDs are supported up to 99999,
         # but negative IDs are also possible
-        gro_atom_id = np.where(
-            atom_id > 0,
-            ((atom_id - 1) % 99999) + 1,
-            atom_id
-        )
+        gro_atom_id = np.where(atom_id > 0, ((atom_id - 1) % 99999) + 1, atom_id)
         # Residue IDs are supported up to 9999,
         # but negative IDs are also possible
         gro_res_id = np.where(
-            array.res_id > 0,
-            ((array.res_id - 1) % 99999) + 1,
-            array.res_id
+            array.res_id > 0, ((array.res_id - 1) % 99999) + 1, array.res_id
         )
 
         if isinstance(array, AtomArray):
@@ -290,10 +285,14 @@ class GROFile(TextFile):
             fmt = "{:>5d}{:5s}{:>5s}{:>5d}{:>8.3f}{:>8.3f}{:>8.3f}"
             for i in range(array.array_length()):
                 # gro format is in nm -> multiply coords by 10
-                self.lines[i+2] = fmt.format(
-                    gro_res_id[i], array.res_name[i], array.atom_name[i],
-                    gro_atom_id[i], array.coord[i,0]/10, array.coord[i,1]/10,
-                    array.coord[i,2]/10
+                self.lines[i + 2] = fmt.format(
+                    gro_res_id[i],
+                    array.res_name[i],
+                    array.atom_name[i],
+                    gro_atom_id[i],
+                    array.coord[i, 0] / 10,
+                    array.coord[i, 1] / 10,
+                    array.coord[i, 2] / 10,
                 )
             # Write box lines
             self.lines[-1] = get_box_dimen(array)
@@ -304,10 +303,11 @@ class GROFile(TextFile):
             # Therefore template lines are created
             # which are afterwards applied for each model
             templines = [None] * array.array_length()
-            fmt = '{:>5d}{:5s}{:>5s}{:5d}'
+            fmt = "{:>5d}{:5s}{:>5s}{:5d}"
             for i in range(array.array_length()):
-                templines[i] = fmt.format(gro_res_id[i], array.res_name[i],
-                                           array.atom_name[i], gro_atom_id[i])
+                templines[i] = fmt.format(
+                    gro_res_id[i], array.res_name[i], array.atom_name[i], gro_atom_id[i]
+                )
 
             for i in range(array.stack_depth()):
                 self.lines.append(
@@ -319,10 +319,11 @@ class GROFile(TextFile):
                 modellines = copy.copy(templines)
                 for j, line in enumerate(modellines):
                     # Insert coordinates
-                    line = (line + "{:>8.3f}{:>8.3f}{:>8.3f}".format(
-                                    array.coord[i,j,0]/10,
-                                    array.coord[i,j,1]/10,
-                                    array.coord[i,j,2]/10))
+                    line = line + "{:>8.3f}{:>8.3f}{:>8.3f}".format(
+                        array.coord[i, j, 0] / 10,
+                        array.coord[i, j, 1] / 10,
+                        array.coord[i, j, 2] / 10,
+                    )
                     modellines[j] = line
                 self.lines.extend(modellines)
                 self.lines.append(get_box_dimen(array[i]))
@@ -340,4 +341,4 @@ def _is_int(string):
         int(string)
         return True
     except ValueError:
-        return False
+        return False

biotite/structure/io/mol/__init__.py

@@ -17,4 +17,4 @@ __author__ = "Patrick Kunzmann"
 from .convert import *
 from .header import *
 from .mol import *
-from .sdf import *
+from .sdf import *

biotite/structure/io/mol/convert.py

@@ -6,9 +6,9 @@ __name__ = "biotite.structure.io.mol"
 __author__ = "Patrick Kunzmann"
 __all__ = ["get_structure", "set_structure"]
 
-from .mol import MOLFile
-from .sdf import SDFile, SDRecord
-from ...bonds import BondType
+from biotite.structure.bonds import BondType
+from biotite.structure.io.mol.mol import MOLFile
+from biotite.structure.io.mol.sdf import SDFile, SDRecord
 
 
 def get_structure(mol_file, record_name=None):
@@ -39,8 +39,9 @@ def get_structure(mol_file, record_name=None):
     return record.get_structure()
 
 
-def set_structure(mol_file, atoms, default_bond_type=BondType.ANY,
-                  version=None, record_name=None):
+def set_structure(
+    mol_file, atoms, default_bond_type=BondType.ANY, version=None, record_name=None
+):
     """
     Set the :class:`AtomArray` for the MOL file.
 
@@ -88,9 +89,7 @@ def _get_record(file, record_name):
         else:
             return file[record_name]
     else:
-        raise TypeError(
-            f"Unsupported file type '{type(file).__name__}'"
-        )
+        raise TypeError(f"Unsupported file type '{type(file).__name__}'")
 
 
 def _get_or_create_record(file, record_name):
@@ -110,6 +109,4 @@ def _get_or_create_record(file, record_name):
             file[record_name] = record
         return file[record_name]
     else:
-        raise TypeError(
-            f"Unsupported file type '{type(file).__name__}'"
-        )
+        raise TypeError(f"Unsupported file type '{type(file).__name__}'")

biotite/structure/io/mol/ctab.py

@@ -12,13 +12,13 @@ __author__ = "Patrick Kunzmann"
 __all__ = ["read_structure_from_ctab", "write_structure_to_ctab"]
 
 import itertools
-import warnings
 import shlex
+import warnings
 import numpy as np
-from ....file import InvalidFileError
-from ...error import BadStructureError
-from ...atoms import AtomArray, AtomArrayStack
-from ...bonds import BondList, BondType
+from biotite.file import InvalidFileError
+from biotite.structure.atoms import AtomArray, AtomArrayStack
+from biotite.structure.bonds import BondList, BondType
+from biotite.structure.error import BadStructureError
 
 BOND_TYPE_MAPPING = {
     1: BondType.SINGLE,
@@ -84,8 +84,7 @@ def read_structure_from_ctab(ctab_lines):
             raise InvalidFileError(f"Unknown CTAB version '{unkown_version}'")
 
 
-def write_structure_to_ctab(atoms, default_bond_type=BondType.ANY,
-                            version=None):
+def write_structure_to_ctab(atoms, default_bond_type=BondType.ANY, version=None):
     """
     Convert an :class:`AtomArray` into a
     *MDL* connection table (Ctab).
@@ -124,8 +123,7 @@ def write_structure_to_ctab(atoms, default_bond_type=BondType.ANY,
     """
     if isinstance(atoms, AtomArrayStack):
         raise TypeError(
-            "An 'AtomArrayStack' was given, "
-            "but only a single model can be written"
+            "An 'AtomArrayStack' was given, " "but only a single model can be written"
         )
     if atoms.bonds is None:
         raise BadStructureError("Input AtomArray has no associated BondList")
@@ -134,9 +132,7 @@ def write_structure_to_ctab(atoms, default_bond_type=BondType.ANY,
 
     match version:
         case None:
-            if _is_v2000_compatible(
-                atoms.array_length(), atoms.bonds.get_bond_count()
-            ):
+            if _is_v2000_compatible(atoms.array_length(), atoms.bonds.get_bond_count()):
                 return _write_structure_to_ctab_v2000(atoms, default_bond_type)
             else:
                 return _write_structure_to_ctab_v3000(atoms, default_bond_type)
@@ -160,7 +156,8 @@ def _read_structure_from_ctab_v2000(ctab_lines):
     atom_lines = ctab_lines[1 : 1 + n_atoms]
     bond_lines = ctab_lines[1 + n_atoms : 1 + n_atoms + n_bonds]
     charge_lines = [
-        line for line in ctab_lines[1 + n_atoms + n_bonds:]
+        line
+        for line in ctab_lines[1 + n_atoms + n_bonds :]
         if line.startswith("M  CHG")
     ]
 
@@ -208,10 +205,9 @@ def _read_structure_from_ctab_v2000(ctab_lines):
 
     return atoms
 
+
 def _read_structure_from_ctab_v3000(ctab_lines):
-    v30_lines = [
-        line[6:].strip() for line in ctab_lines if line.startswith("M  V30")
-    ]
+    v30_lines = [line[6:].strip() for line in ctab_lines if line.startswith("M  V30")]
 
     atom_lines = _get_block_v3000(v30_lines, "ATOM")
     if len(atom_lines) == 0:
@@ -262,16 +258,20 @@ def _read_structure_from_ctab_v3000(ctab_lines):
 
     return atoms
 
+
 def _get_version(counts_line):
     return counts_line[33:39].strip()
 
+
 def _is_v2000_compatible(n_atoms, n_bonds):
     # The format uses a maximum of 3 digits for the atom and bond count
     return n_atoms < 1000 and n_bonds < 1000
 
+
 def _get_counts_v2000(counts_line):
     return int(counts_line[0:3]), int(counts_line[3:6])
 
+
 def _get_block_v3000(v30_lines, block_name):
     block_lines = []
     in_block = False
@@ -282,13 +282,12 @@ def _get_block_v3000(v30_lines, block_name):
             if in_block:
                 return block_lines
             else:
-                raise InvalidFileError(
-                    f"Block '{block_name}' ended before it began"
-                )
+                raise InvalidFileError(f"Block '{block_name}' ended before it began")
         elif in_block:
             block_lines.append(line)
     return block_lines
 
+
 def create_property_dict_v3000(property_strings):
     properties = {}
     for prop in property_strings:
@@ -315,7 +314,8 @@ def _write_structure_to_ctab_v2000(atoms, default_bond_type):
         f" {atoms.element[i].capitalize():3}"
         f"{0:>2}"  # Mass difference -> unused
         f"{CHARGE_MAPPING_REV.get(charge[i], 0):>3d}"
-        + f"{0:>3d}" * 10  # More unused fields
+        + f"{0:>3d}"
+        * 10  # More unused fields
         for i in range(atoms.array_length())
     ]
 
@@ -323,7 +323,8 @@ def _write_structure_to_ctab_v2000(atoms, default_bond_type):
     bond_lines = [
         f"{i+1:>3d}{j+1:>3d}"
         f"{BOND_TYPE_MAPPING_REV.get(bond_type, default_bond_value):>3d}"
-        + f"{0:>3d}" * 4
+        + f"{0:>3d}"
+        * 4
         for i, j, bond_type in atoms.bonds.as_array()
     ]
 
@@ -332,8 +333,7 @@ def _write_structure_to_ctab_v2000(atoms, default_bond_type):
     charge_lines = []
     # Each `M  CHG` line can contain up to 8 charges
     for batch in _batched(
-        [(atom_i, c) for atom_i, c in enumerate(charge) if c != 0],
-        N_CHARGES_PER_LINE
+        [(atom_i, c) for atom_i, c in enumerate(charge) if c != 0], N_CHARGES_PER_LINE
     ):
         charge_lines.append(
             f"M  CHG{len(batch):>3d}"
@@ -349,9 +349,7 @@ def _write_structure_to_ctab_v3000(atoms, default_bond_type):
     except AttributeError:
         charges = np.zeros(atoms.array_length(), dtype=int)
 
-    counts_line = (
-        f"COUNTS {atoms.array_length()} {atoms.bonds.get_bond_count()} 0 0 0"
-    )
+    counts_line = f"COUNTS {atoms.array_length()} {atoms.bonds.get_bond_count()} 0 0 0"
 
     atom_lines = [
         f"{i + 1}"
@@ -375,32 +373,35 @@ def _write_structure_to_ctab_v3000(atoms, default_bond_type):
     ]
 
     lines = (
-        ["BEGIN CTAB"] +
-        [counts_line] +
-        ["BEGIN ATOM"] +
-        atom_lines +
-        ["END ATOM"] +
-        ["BEGIN BOND"] +
-        bond_lines +
-        ["END BOND"] +
-        ["END CTAB"]
+        ["BEGIN CTAB"]
+        + [counts_line]
+        + ["BEGIN ATOM"]
+        + atom_lines
+        + ["END ATOM"]
+        + ["BEGIN BOND"]
+        + bond_lines
+        + ["END BOND"]
+        + ["END CTAB"]
     )
     # Mark lines as V3000 CTAB
     lines = ["M  V30 " + line for line in lines]
     return [V2000_COMPATIBILITY_LINE] + lines + ["M  END"]
 
+
 def _to_property(charge):
     if charge == 0:
         return ""
     else:
         return f"CHG={charge}"
 
+
 def _quote(string):
     if " " in string or len(string) == 0:
         return f'"{string}"'
     else:
         return string
 
+
 def _batched(iterable, n):
     """
     Equivalent to :func:`itertools.batched()`.
@@ -411,4 +412,4 @@ def _batched(iterable, n):
     """
     iterator = iter(iterable)
     while batch := tuple(itertools.islice(iterator, n)):
-        yield batch
+        yield batch

biotite/structure/io/mol/header.py

@@ -6,16 +6,15 @@ __name__ = "biotite.structure.io.mol"
 __author__ = "Patrick Kunzmann"
 __all__ = ["Header"]
 
-import warnings
 import datetime
+import warnings
 from dataclasses import dataclass
 
-
 _DATE_FORMAT = "%m%d%y%H%M"
 
 
 @dataclass
-class Header():
+class Header:
     """
     The header for connection tables.
 
@@ -70,20 +69,25 @@ class Header():
             try:
                 time = datetime.datetime.strptime(time_string, _DATE_FORMAT)
             except ValueError:
-                warnings.warn(
-                    f"Invalid time format '{time_string}' in file header"
-                )
+                warnings.warn(f"Invalid time format '{time_string}' in file header")
                 time = None
         dimensions = lines[1][20:22].strip()
         scaling_factors = lines[1][22:34].strip()
-        energy  = lines[1][34:46].strip()
+        energy = lines[1][34:46].strip()
         registry_number = lines[1][46:52].strip()
 
         comments = lines[2].strip()
 
         return Header(
-            mol_name, initials, program, time, dimensions,
-            scaling_factors, energy, registry_number, comments
+            mol_name,
+            initials,
+            program,
+            time,
+            dimensions,
+            scaling_factors,
+            energy,
+            registry_number,
+            comments,
         )
 
     def serialize(self):
@@ -113,4 +117,4 @@ class Header():
         return text
 
     def __str__(self):
-        return self.serialize()
+        return self.serialize()