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

biotite/structure/io/general.py

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

biotite/structure/io/gro/__init__.py

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

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__}'")