biotite 0.41.1__cp310-cp310-win_amd64.whl → 1.0.0__cp310-cp310-win_amd64.whl

biotite/structure/bonds.pyx

@@ -85,8 +85,8 @@ class BondType(IntEnum):
         Examples
         --------
 
-        >>> print(BondType.AROMATIC_DOUBLE.without_aromaticity())
-        BondType.DOUBLE
+        >>> print(BondType.AROMATIC_DOUBLE.without_aromaticity().name)
+        DOUBLE
         """
         difference = BondType.AROMATIC_SINGLE - BondType.SINGLE
         if self >= BondType.AROMATIC_SINGLE:
@@ -212,21 +212,21 @@ class BondList(Copyable):
     ... )
     >>> for i, j, bond_type in benzene.bonds.as_array():
     ...     print(
-    ...         f"{str(BondType(bond_type))} bond between "
+    ...         f"{BondType(bond_type).name} bond between "
     ...         f"{benzene.atom_name[i]} and {benzene.atom_name[j]}"
     ...     )
-    BondType.AROMATIC_SINGLE bond between C1 and C2
-    BondType.AROMATIC_DOUBLE bond between C2 and C3
-    BondType.AROMATIC_SINGLE bond between C3 and C4
-    BondType.AROMATIC_DOUBLE bond between C4 and C5
-    BondType.AROMATIC_SINGLE bond between C5 and C6
-    BondType.AROMATIC_DOUBLE bond between C1 and C6
-    BondType.SINGLE bond between C1 and H1
-    BondType.SINGLE bond between C2 and H2
-    BondType.SINGLE bond between C3 and H3
-    BondType.SINGLE bond between C4 and H4
-    BondType.SINGLE bond between C5 and H5
-    BondType.SINGLE bond between C6 and H6
+    AROMATIC_SINGLE bond between C1 and C2
+    AROMATIC_DOUBLE bond between C2 and C3
+    AROMATIC_SINGLE bond between C3 and C4
+    AROMATIC_DOUBLE bond between C4 and C5
+    AROMATIC_SINGLE bond between C5 and C6
+    AROMATIC_DOUBLE bond between C1 and C6
+    SINGLE bond between C1 and H1
+    SINGLE bond between C2 and H2
+    SINGLE bond between C3 and H3
+    SINGLE bond between C4 and H4
+    SINGLE bond between C5 and H5
+    SINGLE bond between C6 and H6
 
     Obtain the bonded atoms for the :math:`C_1`:
 
@@ -248,14 +248,14 @@ class BondList(Copyable):
     ... ]
     >>> for i, j, bond_type in half_benzene.bonds.as_array():
     ...     print(
-    ...         f"{str(BondType(bond_type))} bond between "
+    ...         f"{BondType(bond_type).name} bond between "
     ...         f"{half_benzene.atom_name[i]} and {half_benzene.atom_name[j]}"
     ...     )
-    BondType.AROMATIC_DOUBLE bond between C4 and C5
-    BondType.AROMATIC_SINGLE bond between C5 and C6
-    BondType.SINGLE bond between C4 and H4
-    BondType.SINGLE bond between C5 and H5
-    BondType.SINGLE bond between C6 and H6
+    AROMATIC_DOUBLE bond between C4 and C5
+    AROMATIC_SINGLE bond between C5 and C6
+    SINGLE bond between C4 and H4
+    SINGLE bond between C5 and H5
+    SINGLE bond between C6 and H6
     """
 
     def __init__(self, uint32 atom_count, np.ndarray bonds=None):
@@ -449,9 +449,9 @@ class BondList(Copyable):
         >>> bond_list.add_bond(1, 2, BondType.AROMATIC_DOUBLE)
         >>> bond_list.remove_aromaticity()
         >>> for i, j, bond_type in bond_list.as_array():
-        ...     print(i, j, BondType(bond_type))
-        0 1 BondType.SINGLE
-        1 2 BondType.DOUBLE
+        ...     print(i, j, BondType(bond_type).name)
+        0 1 SINGLE
+        1 2 DOUBLE
         """
         bonds = self._bonds
         difference = BondType.AROMATIC_SINGLE - BondType.SINGLE
@@ -1005,14 +1005,13 @@ class BondList(Copyable):
         # maximum and redundant bond calculation
         merged_bond_list._bonds = merged_bonds
         merged_bond_list._max_bonds_per_atom = max(
-            self._max_bonds_per_atom, merged_bond_list._max_bonds_per_atom
+            self._max_bonds_per_atom, bond_list._max_bonds_per_atom
         )
         return merged_bond_list
 
     def __getitem__(self, index):
         ## Variables for both, integer and boolean index arrays
         cdef uint32[:,:] all_bonds_v
-        cdef int32 new_index
         cdef int i
         cdef uint32* index1_ptr
         cdef uint32* index2_ptr
@@ -1020,7 +1019,7 @@ class BondList(Copyable):
         cdef uint8[:] removal_filter_v
 
         ## Variables for integer arrays
-        cdef int32[:] index_v, inverse_index
+        cdef int32[:] inverse_index_v
         cdef int32 new_index1, new_index2
 
         ## Variables for boolean mask
@@ -1035,54 +1034,13 @@ class BondList(Copyable):
             ## Handle single index
             return self.get_bonds(index)
 
-        elif isinstance(index, np.ndarray) \
-            and np.issubdtype(index.dtype, np.integer):
-                ## Handle index array
-                copy = self.copy()
-                all_bonds_v = copy._bonds
-
-                index = _to_positive_index_array(index, self._atom_count)
-                # The inverse index is required to efficiently obtain
-                # the new index of an atom in case of an unsorted index
-                # array
-                inverse_index_v = _invert_index(index, self._atom_count)
-                removal_filter = np.ones(all_bonds_v.shape[0], dtype=np.uint8)
-                removal_filter_v = removal_filter
-                for i in range(all_bonds_v.shape[0]):
-                    # Usage of pointer to increase performance
-                    # as redundant indexing is avoided
-                    index1_ptr = &all_bonds_v[i,0]
-                    index2_ptr = &all_bonds_v[i,1]
-                    new_index1 = inverse_index_v[index1_ptr[0]]
-                    new_index2 = inverse_index_v[index2_ptr[0]]
-                    if new_index1 != -1 and new_index2 != -1:
-                        # Both atoms involved in bond are included
-                        # by index array
-                        # -> assign new atom indices
-                        index1_ptr[0] = <int32>new_index1
-                        index2_ptr[0] = <int32>new_index2
-                    else:
-                        # At least one atom in bond is not included
-                        # -> remove bond
-                        removal_filter_v[i] = False
-
-                copy._bonds = copy._bonds[
-                    removal_filter.astype(bool, copy=False)
-                ]
-                # Again, sort indices per bond
-                # as the correct order is not guaranteed anymore
-                # for unsorted index arrays
-                copy._bonds[:,:2] = np.sort(copy._bonds[:,:2], axis=1)
-                copy._atom_count = len(index)
-                copy._max_bonds_per_atom = copy._get_max_bonds_per_atom()
-                return copy
-
-        else:
-            ## Handle all other arrays as boolean mask
+        elif isinstance(index, np.ndarray) and index.dtype == bool:
+            ## Handle boolean masks
             copy = self.copy()
             all_bonds_v = copy._bonds
+            # Use 'uint8' instead of 'bool' for memory view
+            mask = np.frombuffer(index, dtype=np.uint8)
 
-            mask = _to_bool_mask(index, length=copy._atom_count)
             # Each time an atom is missing in the mask,
             # the offset is increased by one
             offsets = np.cumsum(
@@ -1118,6 +1076,48 @@ class BondList(Copyable):
             copy._max_bonds_per_atom = copy._get_max_bonds_per_atom()
             return copy
 
+        else:
+            ## Convert any other type of index into index array, as it preserves order
+            copy = self.copy()
+            all_bonds_v = copy._bonds
+            index = _to_index_array(index, self._atom_count)
+            index = _to_positive_index_array(index, self._atom_count)
+
+            # The inverse index is required to efficiently obtain
+            # the new index of an atom in case of an unsorted index
+            # array
+            inverse_index_v = _invert_index(index, self._atom_count)
+            removal_filter = np.ones(all_bonds_v.shape[0], dtype=np.uint8)
+            removal_filter_v = removal_filter
+            for i in range(all_bonds_v.shape[0]):
+                # Usage of pointer to increase performance
+                # as redundant indexing is avoided
+                index1_ptr = &all_bonds_v[i,0]
+                index2_ptr = &all_bonds_v[i,1]
+                new_index1 = inverse_index_v[index1_ptr[0]]
+                new_index2 = inverse_index_v[index2_ptr[0]]
+                if new_index1 != -1 and new_index2 != -1:
+                    # Both atoms involved in bond are included
+                    # by index array
+                    # -> assign new atom indices
+                    index1_ptr[0] = <int32>new_index1
+                    index2_ptr[0] = <int32>new_index2
+                else:
+                    # At least one atom in bond is not included
+                    # -> remove bond
+                    removal_filter_v[i] = False
+
+            copy._bonds = copy._bonds[
+                removal_filter.astype(bool, copy=False)
+            ]
+            # Again, sort indices per bond
+            # as the correct order is not guaranteed anymore
+            # for unsorted index arrays
+            copy._bonds[:,:2] = np.sort(copy._bonds[:,:2], axis=1)
+            copy._atom_count = len(index)
+            copy._max_bonds_per_atom = copy._get_max_bonds_per_atom()
+            return copy
+
     def __iter__(self):
         raise TypeError("'BondList' object is not iterable")
 
@@ -1266,6 +1266,18 @@ def _to_positive_index_array(index_array, length):
     return index_array.reshape(orig_shape)
 
 
+def _to_index_array(object index, uint32 length):
+    """
+    Convert an index of arbitrary type into an index array.
+    """
+    if isinstance(index, np.ndarray) and np.issubdtype(index.dtype, np.integer):
+        return index
+    else:
+        # Convert into index array
+        all_indices = np.arange(length, dtype=np.uint32)
+        return all_indices[index]
+
+
 cdef inline bint _in_array(uint32* array, uint32 atom_index, int array_length):
     """
     Test whether a value (`atom_index`) is in a C-array `array`.
@@ -1316,29 +1328,9 @@ def _invert_index(IndexType[:] index_v, uint32 length):
     return inverse_index
 
 
-def _to_bool_mask(object index, uint32 length):
-    """
-    Convert an index of arbitrary type into a boolean mask
-    with given length.
-    """
-    if isinstance(index, np.ndarray) and index.dtype == bool:
-        # Index is already boolean mask -> simply return as uint8
-        if len(index) != length:
-            raise IndexError(
-                f"Boolean mask has length {len(index)}, expected {length}"
-            )
-        # Use 'uint8' instead of 'bool' for memory view
-        return index.astype(np.uint8, copy=False)
-    else:
-        # Use 'uint8' instead of 'bool' for memory view
-        mask = np.zeros(length, dtype=np.uint8)
-        # 1 -> True
-        mask[index] = 1
-        return mask
-
-
 
 
+# fmt: off
 _DEFAULT_DISTANCE_RANGE = {
     # Taken from Allen et al.
     #               min   - 2*std     max   + 2*std
@@ -1385,9 +1377,9 @@ _DEFAULT_DISTANCE_RANGE = {
     ("SE", "SE") : (2.340 - 2*0.024,  2.340 + 2*0.024),
     ("SI", "SE") : (2.359 - 2*0.012,  2.359 + 2*0.012),
 }
+# fmt: on
 
-def connect_via_distances(atoms, dict distance_range=None, atom_mask=None,
-                          bint inter_residue=True,
+def connect_via_distances(atoms, dict distance_range=None, bint inter_residue=True,
                           default_bond_type=BondType.ANY, bint periodic=False):
     """
     connect_via_distances(atoms, distance_range=None, atom_mask=None,
@@ -1419,8 +1411,6 @@ def connect_via_distances(atoms, dict distance_range=None, atom_mask=None,
         Hence, the default bond distances for missing element pairs are
         still taken from the default dictionary.
         The default bond distances are taken from :footcite:`Allen1987`.
-    atom_mask : ndarray, dtype=bool, shape=(n,), optional
-        DEPRECATED: This option has no effect.
     inter_residue : bool, optional
         If true, connections between consecutive amino acids and
         nucleotides are also added.
@@ -1541,7 +1531,7 @@ def connect_via_distances(atoms, dict distance_range=None, atom_mask=None,
 
 
 
-def connect_via_residue_names(atoms, atom_mask=None, bint inter_residue=True,
+def connect_via_residue_names(atoms, bint inter_residue=True,
                               dict custom_bond_dict=None):
     """
     connect_via_residue_names(atoms, atom_mask=None, inter_residue=True)
@@ -1558,8 +1548,6 @@ def connect_via_residue_names(atoms, atom_mask=None, bint inter_residue=True,
     ----------
     atoms : AtomArray, shape=(n,) or AtomArrayStack, shape=(m,n)
         The structure to create the :class:`BondList` for.
-    atom_mask : ndarray, dtype=bool, shape=(n,), optional
-        DEPRECATED: This option has no effect.
     inter_residue : bool, optional
         If true, connections between consecutive amino acids and
         nucleotides are also added.

biotite/structure/box.py

@@ -4,25 +4,33 @@
 
 """
 Functions related to working with the simulation box or unit cell
-of a structure 
+of a structure
 """
 
 __name__ = "biotite.structure"
 __author__ = "Patrick Kunzmann"
-__all__ = ["vectors_from_unitcell", "unitcell_from_vectors", "box_volume",
-           "repeat_box", "repeat_box_coord", "move_inside_box",
-           "remove_pbc", "remove_pbc_from_coord",
-           "coord_to_fraction", "fraction_to_coord", "is_orthogonal"]
+__all__ = [
+    "vectors_from_unitcell",
+    "unitcell_from_vectors",
+    "box_volume",
+    "repeat_box",
+    "repeat_box_coord",
+    "move_inside_box",
+    "remove_pbc",
+    "remove_pbc_from_coord",
+    "coord_to_fraction",
+    "fraction_to_coord",
+    "is_orthogonal",
+]
 
-from collections.abc import Iterable
 from numbers import Integral
 import numpy as np
 import numpy.linalg as linalg
-from .util import vector_dot
-from .atoms import repeat
-from .molecules import get_molecule_masks
-from .chains import get_chain_masks, get_chain_starts
-from .error import BadStructureError
+from biotite.structure.atoms import repeat
+from biotite.structure.chains import get_chain_masks, get_chain_starts
+from biotite.structure.error import BadStructureError
+from biotite.structure.molecules import get_molecule_masks
+from biotite.structure.util import vector_dot
 
 
 def vectors_from_unitcell(len_a, len_b, len_c, alpha, beta, gamma):
@@ -41,7 +49,7 @@ def vectors_from_unitcell(len_a, len_b, len_c, alpha, beta, gamma):
         The angles between the box vectors in radians.
         *alpha* is the angle between *b* and *c*,
         *beta* between *a* and *c*, *gamma* between *a* and *b*
-    
+
     Returns
     -------
     box : ndarray, dtype=float, shape=(3,3)
@@ -49,7 +57,7 @@ def vectors_from_unitcell(len_a, len_b, len_c, alpha, beta, gamma):
         The vector components are in the last dimension.
         The value can be directly used as :attr:`box` attribute in an
         atom array.
-    
+
     See also
     --------
     unitcell_from_vectors
@@ -58,19 +66,15 @@ def vectors_from_unitcell(len_a, len_b, len_c, alpha, beta, gamma):
     b_x = len_b * np.cos(gamma)
     b_y = len_b * np.sin(gamma)
     c_x = len_c * np.cos(beta)
-    c_y = len_c * (np.cos(alpha) - np.cos(beta)*np.cos(gamma)) / np.sin(gamma)
-    c_z = np.sqrt(len_c*len_c - c_x*c_x - c_y*c_y)
-    box = np.array([
-        [a_x,   0,   0],
-        [b_x, b_y,   0],
-        [c_x, c_y, c_z]
-    ], dtype=np.float32)
-    
+    c_y = len_c * (np.cos(alpha) - np.cos(beta) * np.cos(gamma)) / np.sin(gamma)
+    c_z = np.sqrt(len_c * len_c - c_x * c_x - c_y * c_y)
+    box = np.array([[a_x, 0, 0], [b_x, b_y, 0], [c_x, c_y, c_z]], dtype=np.float32)
+
     # Fix numerical errors, as values, that are actually 0,
     # might not be calculated as such
     tol = 1e-4 * (len_a + len_b + len_c)
     box[np.abs(box) < tol] = 0
-    
+
     return box
 
 
@@ -84,7 +88,7 @@ def unitcell_from_vectors(box):
     ----------
     box : ndarray, shape=(3,3)
         The box vectors
-    
+
     Returns
     -------
     len_a, len_b, len_c : float
@@ -103,7 +107,7 @@ def unitcell_from_vectors(box):
     len_b = linalg.norm(b)
     len_c = linalg.norm(c)
     alpha = np.arccos(np.dot(b, c) / (len_b * len_c))
-    beta  = np.arccos(np.dot(a, c) / (len_a * len_c))
+    beta = np.arccos(np.dot(a, c) / (len_a * len_c))
     gamma = np.arccos(np.dot(a, b) / (len_a * len_b))
     return len_a, len_b, len_c, alpha, beta, gamma
 
@@ -116,7 +120,7 @@ def box_volume(box):
     ----------
     box : ndarray, shape=(3,3) or shape=(m,3,3)
         One or multiple boxes to get the volume for.
-    
+
     Returns
     -------
     volume : float or ndarray, shape=(m,)
@@ -159,7 +163,7 @@ def repeat_box(atoms, amount=1):
         Indices to the atoms in the original atom array (stack).
         Equal to
         ``numpy.tile(np.arange(atoms.array_length()), (1 + 2 * amount) ** 3)``.
-    
+
     See also
     --------
     repeat_box_coord
@@ -232,12 +236,12 @@ def repeat_box(atoms, amount=1):
     """
     if atoms.box is None:
         raise BadStructureError("Structure has no box")
-    
+
     repeat_coord, indices = repeat_box_coord(atoms.coord, atoms.box)
     # Unroll repeated coordinates for input to 'repeat()'
     if repeat_coord.ndim == 2:
         repeat_coord = repeat_coord.reshape(-1, atoms.array_length(), 3)
-    else: # ndim == 3
+    else:  # ndim == 3
         repeat_coord = repeat_coord.reshape(
             atoms.stack_depth(), -1, atoms.array_length(), 3
         )
@@ -283,16 +287,15 @@ def repeat_box_coord(coord, box, amount=1):
         raise TypeError("The amount must be an integer")
     # List of numpy arrays for each box repeat
     coords_for_boxes = [coord]
-    for i in range(-amount, amount+1):
-        for j in range(-amount, amount+1):
-            for k in range(-amount, amount+1):
+    for i in range(-amount, amount + 1):
+        for j in range(-amount, amount + 1):
+            for k in range(-amount, amount + 1):
                 # Omit the central box
                 if i != 0 or j != 0 or k != 0:
                     temp_coord = coord.copy()
                     # Shift coordinates to adjacent box/unit cell
                     translation_vec = np.sum(
-                        box * np.array([i,j,k])[:, np.newaxis],
-                        axis=-2
+                        box * np.array([i, j, k])[:, np.newaxis], axis=-2
                     )
                     # 'newaxis' to perform same translation on all
                     # atoms for each model
@@ -300,7 +303,7 @@ def repeat_box_coord(coord, box, amount=1):
                     coords_for_boxes.append(temp_coord)
     return (
         np.concatenate(coords_for_boxes, axis=-2),
-        np.tile(np.arange(coord.shape[-2]), (1 + 2 * amount) ** 3)
+        np.tile(np.arange(coord.shape[-2]), (1 + 2 * amount) ** 3),
     )
 
 
@@ -323,16 +326,16 @@ def move_inside_box(coord, box):
         The box(es) for one or multiple models.
         When `coord` is given for multiple models, :attr:`box` must be
         given for multiple models as well.
-    
+
     Returns
     -------
     moved_coord : ndarray, dtype=float, shape=(n,3) or shape=(m,n,3)
         The moved coordinates.
         Has the same shape is the input `coord`.
-    
+
     Examples
     --------
-    
+
     >>> box = np.array([[10,0,0], [0,10,0], [0,0,10]], dtype=float)
     >>> inside_coord        = [ 1,  2,  3]
     >>> outside_coord       = [ 1, 22, 54]
@@ -363,7 +366,7 @@ def remove_pbc(atoms, selection=None):
     To determine the molecules the structure is required to have an
     associated `BondList`.
     Otherwise segmentation removal is performed on a per-chain basis.
-    
+
     Parameters
     ----------
     atoms : AtomArray, shape=(n,) or AtomArrayStack, shape=(m,n)
@@ -373,13 +376,13 @@ def remove_pbc(atoms, selection=None):
     selection : ndarray, dtype=bool, shape=(n,)
         Specifies which parts of `atoms` are sanitized, i.e the
         segmentation is removed.
-    
+
     Returns
     -------
     sanitized_atoms : AtomArray or AtomArrayStack
         The input structure with removed segmentation over periodic
         boundaries.
-    
+
     See also
     --------
     remove_pbc_from_coord
@@ -392,12 +395,10 @@ def remove_pbc(atoms, selection=None):
     half box size.
     """
     # Avoid circular import
-    from .geometry import centroid
-    
+    from biotite.structure.geometry import centroid
+
     if atoms.box is None:
-        raise BadStructureError(
-            "The 'box' attribute must be set in the structure"
-        )
+        raise BadStructureError("The 'box' attribute must be set in the structure")
     new_atoms = atoms.copy()
 
     if atoms.bonds is not None:
@@ -414,10 +415,8 @@ def remove_pbc(atoms, selection=None):
         )
         # Put center of molecule into box
         center = centroid(new_atoms.coord[..., mask, :])[..., np.newaxis, :]
-        center_in_box = move_inside_box(
-            center, new_atoms.box
-        )
-        new_atoms.coord[..., mask, :] += (center_in_box - center)
+        center_in_box = move_inside_box(center, new_atoms.box)
+        new_atoms.coord[..., mask, :] += center_in_box - center
 
     return new_atoms
 
@@ -433,11 +432,11 @@ def remove_pbc_from_coord(coord, box):
     the displacement coordinates in adjacent array positions.
     Basically, this function performs the reverse action of
     :func:`move_inside_box()`.
-    
+
     Parameters
     ----------
     coord : ndarray, dtype=float, shape=(m,n,3) or shape=(n,3)
-        The coordinates of the potentially segmented structure. 
+        The coordinates of the potentially segmented structure.
     box : ndarray, dtype=float, shape=(m,3,3) or shape=(3,3)
         The simulation box or unit cell that is used as periodic
         boundary.
@@ -447,7 +446,7 @@ def remove_pbc_from_coord(coord, box):
     -------
     sanitized_coord : ndarray, dtype=float, shape=(m,n,3) or shape=(n,3)
         The reassembled coordinates.
-    
+
     See also
     --------
     remove_pbc_from_coord
@@ -463,19 +462,14 @@ def remove_pbc_from_coord(coord, box):
     """
 
     # Import in function to avoid circular import
-    from .geometry import index_displacement
+    from biotite.structure.geometry import index_displacement
+
     # Get the PBC-sanitized displacements of all coordinates
     # to the respective next coordinate
     index_pairs = np.stack(
-        [
-            np.arange(0, coord.shape[-2] - 1), 
-            np.arange(1, coord.shape[-2]    )
-        ],
-        axis=1
-    )
-    neighbour_disp = index_displacement(
-        coord, index_pairs, box=box, periodic=True
+        [np.arange(0, coord.shape[-2] - 1), np.arange(1, coord.shape[-2])], axis=1
     )
+    neighbour_disp = index_displacement(coord, index_pairs, box=box, periodic=True)
     # Get the PBC-sanitized displacements of all but the first
     # coordinates to (0,0,0)
     absolute_disp = np.cumsum(neighbour_disp, axis=-2)
@@ -501,19 +495,19 @@ def coord_to_fraction(coord, box):
         The box(es) for one or multiple models.
         When `coord` is given for multiple models, :attr:`box` must be
         given for multiple models as well.
-    
+
     Returns
     -------
     fraction : ndarray, dtype=float, shape=(n,3) or shape=(m,n,3)
         The fractions of the box vectors.
-    
+
     See also
     --------
     fraction_to_coord
 
     Examples
     --------
-    
+
     >>> box = np.array([[5,0,0], [0,5,0], [0,5,5]], dtype=float)
     >>> coord = np.array(
     ...     [[1,1,1], [10,0,0], [0,0,10], [-5,2,1]],
@@ -548,12 +542,12 @@ def fraction_to_coord(fraction, box):
         The box(es) for one or multiple models.
         When `coord` is given for multiple models, :attr:`box` must be
         given for multiple models as well.
-    
+
     Returns
     -------
     coord : ndarray, dtype=float, shape=(n,3) or shape=(m,n,3)
         The coordinates.
-    
+
     See also
     --------
     coord_to_fraction
@@ -572,12 +566,12 @@ def is_orthogonal(box):
     ----------
     box : ndarray, dtype=float, shape=(3,3) or shape=(m,3,3)
         A single box or multiple boxes.
-    
+
     Returns
     -------
     is_orthgonal : bool or ndarray, shape=(m,), dtype=bool
         True, if the box vectors are orthogonal, false otherwise
-    
+
     Notes
     -----
     Due to possible numerical errors, this function also evaluates two
@@ -587,6 +581,8 @@ def is_orthogonal(box):
     # Fix numerical errors, as values, that are actually 0,
     # might not be calculated as such
     tol = 1e-6
-    return (np.abs(vector_dot(box[..., 0, :], box[..., 1, :])) < tol) & \
-           (np.abs(vector_dot(box[..., 0, :], box[..., 2, :])) < tol) & \
-           (np.abs(vector_dot(box[..., 1, :], box[..., 2, :])) < tol)
+    return (
+        (np.abs(vector_dot(box[..., 0, :], box[..., 1, :])) < tol)
+        & (np.abs(vector_dot(box[..., 0, :], box[..., 2, :])) < tol)
+        & (np.abs(vector_dot(box[..., 1, :], box[..., 2, :])) < tol)
+    )