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

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()

biotite/structure/io/mol/mol.py

@@ -6,11 +6,13 @@ __name__ = "biotite.structure.io.mol"
 __author__ = "Patrick Kunzmann"
 __all__ = ["MOLFile"]
 
-from ....file import TextFile, InvalidFileError
-from .ctab import read_structure_from_ctab, write_structure_to_ctab
-from .header import Header
-from ...bonds import BondType
-
+from biotite.file import InvalidFileError, TextFile
+from biotite.structure.bonds import BondType
+from biotite.structure.io.mol.ctab import (
+    read_structure_from_ctab,
+    write_structure_to_ctab,
+)
+from biotite.structure.io.mol.header import Header
 
 # Number of header lines
 N_HEADER = 3
@@ -80,66 +82,23 @@ class MOLFile(TextFile):
         self.lines = [""] * N_HEADER
         self._header = None
 
-
     @classmethod
     def read(cls, file):
         mol_file = super().read(file)
         mol_file._header = None
         return mol_file
 
-
     @property
     def header(self):
         if self._header is None:
             self._header = Header.deserialize("\n".join(self.lines[0:3]) + "\n")
         return self._header
 
-
     @header.setter
     def header(self, header):
         self._header = header
         self.lines[0:3] = self._header.serialize().splitlines()
 
-
-    def get_header(self):
-        """
-        Get the header from the MOL file.
-
-        DEPRECATED: Use the :attr:`header` property instead.
-
-        Returns
-        -------
-        header_attributes
-            See :class:`Header`.
-        """
-        header = self.header
-        return (
-            header.mol_name,
-            header.initials,
-            header.program,
-            header.time,
-            header.dimensions,
-            header.scaling_factors,
-            header.energy,
-            header.registry_number,
-            header.comments
-        )
-
-
-    def set_header(self, *args, **kwargs):
-        """
-        Set the header for the MOL file.
-
-        DEPRECATED: Use the :attr:`header` property instead.
-
-        Parameters
-        ----------
-        **args, **kwars
-            See :class:`Header`.
-        """
-        self.header = Header(*args, **kwargs)
-
-
     def get_structure(self):
         """
         Get an :class:`AtomArray` from the MOL file.
@@ -157,9 +116,7 @@ class MOLFile(TextFile):
             raise InvalidFileError("File does not contain structure data")
         return read_structure_from_ctab(ctab_lines)
 
-
-    def set_structure(self, atoms, default_bond_type=BondType.ANY,
-                      version=None):
+    def set_structure(self, atoms, default_bond_type=BondType.ANY, version=None):
         """
         Set the :class:`AtomArray` for the file.
 
@@ -185,9 +142,8 @@ class MOLFile(TextFile):
         )
 
 
-
 def _get_ctab_lines(lines):
     for i, line in enumerate(lines):
         if line.startswith("M  END"):
-            return lines[N_HEADER:i+1]
+            return lines[N_HEADER : i + 1]
     return lines[N_HEADER:]

biotite/structure/io/mol/sdf.py

@@ -8,16 +8,24 @@ __all__ = ["SDFile", "SDRecord", "Metadata"]
 
 import re
 import warnings
+from collections.abc import Mapping, MutableMapping
 from dataclasses import dataclass
-from collections.abc import MutableMapping, Mapping
 import numpy as np
-from ....file import File, InvalidFileError, is_open_compatible, is_text, \
-                     DeserializationError, SerializationError
-from .ctab import read_structure_from_ctab, write_structure_to_ctab
-from .header import Header
-from ...atoms import AtomArray
-from ...bonds import BondList, BondType
-
+from biotite.file import (
+    DeserializationError,
+    File,
+    InvalidFileError,
+    SerializationError,
+    is_open_compatible,
+    is_text,
+)
+from biotite.structure.atoms import AtomArray
+from biotite.structure.bonds import BondList, BondType
+from biotite.structure.io.mol.ctab import (
+    read_structure_from_ctab,
+    write_structure_to_ctab,
+)
+from biotite.structure.io.mol.header import Header
 
 _N_HEADER = 3
 # Number of header lines
@@ -96,6 +104,7 @@ class Metadata(MutableMapping):
         number, name, registry_internal, registry_external
             The same as the parameters.
         """
+
         # The characters that can be given as input to `name`
         # First character must be alphanumeric,
         # following characters may include underscores and periods
@@ -103,7 +112,7 @@ class Metadata(MutableMapping):
         # they are still used in practice and therefore allowed here
         _NAME_INPUT_REGEX = re.compile(r"^[a-zA-Z0-9][\w.]*$")
         # These regexes are used to parse the key from a line
-        _COMPONENT_REGEX =  {
+        _COMPONENT_REGEX = {
             "number": re.compile(r"^DT(\d+)$"),
             "name": re.compile(r"^<([a-zA-Z0-9][\w.]*)>$"),
             "registry_internal": re.compile(r"^(\d+)$"),
@@ -162,9 +171,7 @@ class Metadata(MutableMapping):
                     break
                 else:
                     # There is no matching pattern
-                    raise DeserializationError(
-                        f"Invalid key component '{component}'"
-                    )
+                    raise DeserializationError(f"Invalid key component '{component}'")
             return Metadata.Key(**parsed_component_dict)
 
         def serialize(self):
@@ -190,7 +197,6 @@ class Metadata(MutableMapping):
         def __str__(self):
             return self.serialize()
 
-
     def __init__(self, metadata=None):
         if metadata is None:
             metadata = {}
@@ -222,9 +228,7 @@ class Metadata(MutableMapping):
                 current_value = None
             else:
                 if current_key is None:
-                    raise DeserializationError(
-                        "Value found before metadata key"
-                    )
+                    raise DeserializationError("Value found before metadata key")
                 if current_value is None:
                     current_value = line
                 else:
@@ -388,7 +392,7 @@ class SDRecord:
         if isinstance(self._header, str):
             try:
                 self._header = Header.deserialize(self._header)
-            except:
+            except Exception:
                 raise DeserializationError("Failed to deserialize header")
         return self._header
 
@@ -406,7 +410,7 @@ class SDRecord:
         if isinstance(self._metadata, str):
             try:
                 self._metadata = Metadata.deserialize(self._metadata)
-            except:
+            except Exception:
                 raise DeserializationError("Failed to deserialize metadata")
         return self._metadata
 
@@ -483,8 +487,7 @@ class SDRecord:
             raise InvalidFileError("File does not contain structure data")
         return read_structure_from_ctab(ctab_lines)
 
-    def set_structure(self, atoms, default_bond_type=BondType.ANY,
-                      version=None):
+    def set_structure(self, atoms, default_bond_type=BondType.ANY, version=None):
         """
         Set the structural data in the SD record.
 
@@ -505,9 +508,9 @@ class SDRecord:
             By default, ``"V2000"`` is used, unless the number of atoms
             or bonds exceeds 999, in which case ``"V3000"`` is used.
         """
-        self._ctab = _join_with_terminal_newline(write_structure_to_ctab(
-            atoms, default_bond_type, version
-        ))
+        self._ctab = _join_with_terminal_newline(
+            write_structure_to_ctab(atoms, default_bond_type, version)
+        )
 
     def __eq__(self, other):
         if not isinstance(other, type(self)):
@@ -736,28 +739,29 @@ class SDFile(File, MutableMapping):
             The content to be deserialized.
         """
         lines = text.splitlines()
-        record_ends = np.array([
-            i for i, line in enumerate(lines)
-            if line.startswith(_RECORD_DELIMITER)
-        ], dtype=int)
+        record_ends = np.array(
+            [i for i, line in enumerate(lines) if line.startswith(_RECORD_DELIMITER)],
+            dtype=int,
+        )
         if len(record_ends) == 0:
             warnings.warn(
                 "Final record delimiter missing, "
                 "maybe this is a MOL file instead of a SD file"
             )
-            record_ends = np.array([len(lines)-1], dtype=int)
+            record_ends = np.array([len(lines) - 1], dtype=int)
         # The first record starts at the first line and the last
         # delimiter is at the end of the file
         # Records in the middle start directly after the delimiter
         record_starts = np.concatenate(([0], record_ends[:-1] + 1), dtype=int)
         record_names = [lines[start].strip() for start in record_starts]
-        return SDFile({
-            # Do not include the delimiter
-            # -> stop at end (instead of end + 1)
-            name: _join_with_terminal_newline(lines[start : end])
-            for name, start, end
-            in zip(record_names, record_starts, record_ends)
-        })
+        return SDFile(
+            {
+                # Do not include the delimiter
+                # -> stop at end (instead of end + 1)
+                name: _join_with_terminal_newline(lines[start:end])
+                for name, start, end in zip(record_names, record_starts, record_ends)
+            }
+        )
 
     def serialize(self):
         """
@@ -776,7 +780,7 @@ class SDFile(File, MutableMapping):
             else:
                 try:
                     text_blocks.append(record.serialize())
-                except:
+                except Exception:
                     raise SerializationError(
                         f"Failed to serialize record '{record_name}'"
                     )
@@ -835,19 +839,15 @@ class SDFile(File, MutableMapping):
             # -> must be deserialized first
             try:
                 record = SDRecord.deserialize(record)
-            except:
-                raise DeserializationError(
-                    f"Failed to deserialize record '{key}'"
-                )
+            except Exception:
+                raise DeserializationError(f"Failed to deserialize record '{key}'")
             # Update with deserialized object
             self._records[key] = record
         return record
 
     def __setitem__(self, key, record):
         if not isinstance(record, SDRecord):
-            raise TypeError(
-                f"Expected 'SDRecord', but got '{type(record).__name__}'"
-            )
+            raise TypeError(f"Expected 'SDRecord', but got '{type(record).__name__}'")
         # The molecule name in the header is unique across the file
         record.header.mol_name = key
         self._records[key] = record
@@ -895,22 +895,19 @@ def _to_metadata_key(key):
         return Metadata.Key(name=key)
     else:
         raise TypeError(
-            "Expected 'Metadata.Key' or str, "
-            f"but got '{type(key).__name__}'"
+            "Expected 'Metadata.Key' or str, " f"but got '{type(key).__name__}'"
         )
 
 
 def _add_key_value_pair(metadata, key, value):
     if key is not None:
         if value is None:
-            raise DeserializationError(
-                f"No value found for metadata key {key}"
-            )
+            raise DeserializationError(f"No value found for metadata key {key}")
         metadata[key] = value
 
 
 def _get_ctab_stop(lines):
     for i in range(_N_HEADER, len(lines)):
         if lines[i].startswith("M  END"):
-            return i+1
-    return len(lines)
+            return i + 1
+    return len(lines)

biotite/structure/io/netcdf/__init__.py

@@ -10,4 +10,4 @@ This subpackage is used for reading and writing trajectories in the
 __name__ = "biotite.structure.io.netcdf"
 __author__ = "Patrick Kunzmann"
 
-from .file import *
+from .file import *

biotite/structure/io/netcdf/file.py

@@ -6,21 +6,21 @@ __name__ = "biotite.structure.io.netcdf"
 __author__ = "Patrick Kunzmann"
 __all__ = ["NetCDFFile"]
 
+import biotraj
 import numpy as np
-from ..trajfile import TrajectoryFile
-from ...box import vectors_from_unitcell, unitcell_from_vectors
+from biotite.structure.box import unitcell_from_vectors, vectors_from_unitcell
+from biotite.structure.io.trajfile import TrajectoryFile
 
 
 class NetCDFFile(TrajectoryFile):
     """
     This file class represents a NetCDF trajectory file.
     """
-    
+
     @classmethod
     def traj_type(cls):
-        import mdtraj.formats as traj
-        return traj.NetCDFTrajectoryFile
-    
+        return biotraj.NetCDFTrajectoryFile
+
     @classmethod
     def process_read_values(cls, read_values):
         # .dcd files use Angstrom
@@ -29,35 +29,36 @@ class NetCDFFile(TrajectoryFile):
         cell_lengths = read_values[2]
         cell_angles = read_values[3]
         if cell_lengths is None or cell_angles is None:
-             box = None
+            box = None
         else:
             box = np.stack(
-                [vectors_from_unitcell(a, b, c, alpha, beta, gamma)
-                for (a, b, c), (alpha, beta, gamma)
-                in zip(cell_lengths, np.deg2rad(cell_angles))],
-                axis=0
+                [
+                    vectors_from_unitcell(a, b, c, alpha, beta, gamma)
+                    for (a, b, c), (alpha, beta, gamma) in zip(
+                        cell_lengths, np.deg2rad(cell_angles)
+                    )
+                ],
+                axis=0,
             )
         return coord, box, time
-    
+
     @classmethod
     def prepare_write_values(cls, coord, box, time):
-        coord = coord.astype(np.float32, copy=False) \
-              if coord is not None else None
-        time = time.astype(np.float32, copy=False) \
-               if time is not None else None
+        coord = coord.astype(np.float32, copy=False) if coord is not None else None
+        time = time.astype(np.float32, copy=False) if time is not None else None
         if box is None:
             cell_lengths = None
-            cell_angles  = None
+            cell_angles = None
         else:
             cell_lengths = np.zeros((len(box), 3), dtype=np.float32)
-            cell_angles  = np.zeros((len(box), 3), dtype=np.float32)
+            cell_angles = np.zeros((len(box), 3), dtype=np.float32)
             for i, model_box in enumerate(box):
                 a, b, c, alpha, beta, gamma = unitcell_from_vectors(model_box)
                 cell_lengths[i] = np.array((a, b, c))
                 cell_angles[i] = np.rad2deg((alpha, beta, gamma))
         return {
-            "coordinates" : coord,
-            "time" : time,
-            "cell_lengths" : cell_lengths,
-            "cell_angles" : cell_angles,
-        }
+            "coordinates": coord,
+            "time": time,
+            "cell_lengths": cell_lengths,
+            "cell_angles": cell_angles,
+        }

biotite/structure/io/pdb/__init__.py

@@ -16,5 +16,5 @@ In all other cases, usage of the :mod:`pdbx` subpackage is encouraged.
 __name__ = "biotite.structure.io.pdb"
 __author__ = "Patrick Kunzmann"
 
+from .convert import *
 from .file import *
-from .convert import *