biotite 0.41.2__cp312-cp312-win_amd64.whl → 1.0.0__cp312-cp312-win_amd64.whl

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 *

biotite/structure/io/pdb/convert.py

@@ -9,8 +9,14 @@ subpackages.
 
 __name__ = "biotite.structure.io.pdb"
 __author__ = "Patrick Kunzmann"
-__all__ = ["get_model_count", "get_structure", "set_structure",
-           "list_assemblies", "get_assembly", "get_symmetry_mates"]
+__all__ = [
+    "get_model_count",
+    "get_structure",
+    "set_structure",
+    "list_assemblies",
+    "get_assembly",
+    "get_symmetry_mates",
+]
 
 
 def get_model_count(pdb_file):
@@ -30,8 +36,9 @@ def get_model_count(pdb_file):
     return pdb_file.get_model_count()
 
 
-def get_structure(pdb_file, model=None, altloc="first", extra_fields=[],
-                  include_bonds=False):
+def get_structure(
+    pdb_file, model=None, altloc="first", extra_fields=[], include_bonds=False
+):
     """
     Create an :class:`AtomArray` or :class:`AtomArrayStack` from a
     :class:`PDBFile`.
@@ -39,7 +46,7 @@ def get_structure(pdb_file, model=None, altloc="first", extra_fields=[],
     This function is a thin wrapper around the :class:`PDBFile` method
     :func:`get_structure()` for the sake of consistency with other
     ``structure.io`` subpackages.
-    
+
     Parameters
     ----------
     pdb_file : PDBFile
@@ -77,12 +84,12 @@ def get_structure(pdb_file, model=None, altloc="first", extra_fields=[],
         (e.g. especially inter-residue bonds),
         have :attr:`BondType.ANY`, since the PDB format itself does
         not support bond orders.
-        
+
     Returns
     -------
     array : AtomArray or AtomArrayStack
         The return type depends on the `model` parameter.
-    
+
     """
     return pdb_file.get_structure(model, altloc, extra_fields, include_bonds)
 
@@ -95,11 +102,11 @@ def set_structure(pdb_file, array, hybrid36=False):
     This function is a thin wrapper around the :class:`PDBFile` method
     :func:`set_structure()` for the sake of consistency with other
     ``structure.io`` subpackages.
-    
+
     This will save the coordinates, the mandatory annotation categories
     and the optional annotation categories
     'atom_id', 'b_factor', 'occupancy' and 'charge'.
-    
+
     Parameters
     ----------
     pdb_file : PDBFile
@@ -137,7 +144,7 @@ def list_assemblies(pdb_file):
     -------
     assemblies : list of str
         A list that contains the available assembly IDs.
-    
+
     Examples
     --------
     >>> import os.path
@@ -148,8 +155,14 @@ def list_assemblies(pdb_file):
     return pdb_file.list_assemblies()
 
 
-def get_assembly(pdb_file, assembly_id=None, model=None, altloc="first",
-                 extra_fields=[], include_bonds=False):
+def get_assembly(
+    pdb_file,
+    assembly_id=None,
+    model=None,
+    altloc="first",
+    extra_fields=[],
+    include_bonds=False,
+):
     """
     Build the given biological assembly.
 
@@ -205,7 +218,7 @@ def get_assembly(pdb_file, assembly_id=None, model=None, altloc="first",
     assembly : AtomArray or AtomArrayStack
         The assembly.
         The return type depends on the `model` parameter.
-    
+
     Examples
     --------
 
@@ -218,8 +231,9 @@ def get_assembly(pdb_file, assembly_id=None, model=None, altloc="first",
     )
 
 
-def get_symmetry_mates(pdb_file, model=None, altloc="first",
-                        extra_fields=[], include_bonds=False):
+def get_symmetry_mates(
+    pdb_file, 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
@@ -274,13 +288,13 @@ def get_symmetry_mates(pdb_file, model=None, altloc="first",
     symmetry_mates : AtomArray or AtomArrayStack
         All atoms within a single unit cell.
         The return type depends on the `model` parameter.
-    
+
     Notes
     -----
     To expand the structure beyond a single unit cell, use
     :func:`repeat_box()` with the return value as its
     input.
-    
+
     Examples
     --------
 
@@ -288,6 +302,4 @@ def get_symmetry_mates(pdb_file, model=None, altloc="first",
     >>> file = PDBFile.read(os.path.join(path_to_structures, "1aki.pdb"))
     >>> atoms_in_unit_cell = get_symmetry_mates(file, model=1)
     """
-    return pdb_file.get_symmetry_mates(
-        model, altloc, extra_fields, include_bonds
-    )
+    return pdb_file.get_symmetry_mates(model, altloc, extra_fields, include_bonds)