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

biotite/structure/transform.py

@@ -9,20 +9,25 @@ that can be applied on structures.
 
 __name__ = "biotite.structure"
 __author__ = "Patrick Kunzmann", "Claude J. Rogers"
-__all__ = ["translate", "rotate", "rotate_centered", "rotate_about_axis",
-           "orient_principal_components", "align_vectors"]
+__all__ = [
+    "translate",
+    "rotate",
+    "rotate_centered",
+    "rotate_about_axis",
+    "orient_principal_components",
+    "align_vectors",
+]
 
 import numpy as np
-from .geometry import centroid
-from .error import BadStructureError
-from .atoms import Atom, AtomArray, AtomArrayStack, coord
-from .util import norm_vector, vector_dot, matrix_rotate
+from biotite.structure.atoms import Atom, AtomArray, AtomArrayStack, coord
+from biotite.structure.geometry import centroid
+from biotite.structure.util import matrix_rotate, norm_vector, vector_dot
 
 
 def translate(atoms, vector):
     """
     Translate the given atoms or coordinates by a given vector.
-    
+
     Parameters
     ----------
     atoms : Atom or AtomArray or AtomArrayStack or ndarray, shape=(3,) or shape=(n,3) or shape=(m,n,3)
@@ -30,7 +35,7 @@ def translate(atoms, vector):
         The coordinates can be directly provided as :class:`ndarray`.
     vector: array-like, shape=(3,) or shape=(n,3) or shape=(m,n,3)
         The translation vector :math:`(x, y, z)`.
-    
+
     Returns
     -------
     transformed : Atom or AtomArray or AtomArrayStack or ndarray, shape=(3,) or shape=(n,3) or shape=(m,n,3)
@@ -39,7 +44,7 @@ def translate(atoms, vector):
     """
     positions = coord(atoms).copy()
     vector = np.asarray(vector)
-    
+
     if vector.shape[-1] != 3:
         raise ValueError("Translation vector must contain 3 coordinates")
     positions += vector
@@ -50,10 +55,10 @@ def rotate(atoms, angles):
     """
     Rotate the given atoms or coordinates about the *x*, *y* and *z*
     axes by given angles.
-    
+
     The rotations are centered at the origin and are performed
     sequentially in the order *x*, *y*, *z*.
-    
+
     Parameters
     ----------
     atoms : Atom or AtomArray or AtomArrayStack or ndarray, shape=(3,) or shape=(n,3) or shape=(m,n,3)
@@ -61,13 +66,13 @@ def rotate(atoms, angles):
         The coordinates can be directly provided as :class:`ndarray`.
     angles: array-like, length=3
         The rotation angles in radians around *x*, *y* and *z*.
-    
+
     Returns
     -------
     transformed : Atom or AtomArray or AtomArrayStack or ndarray, shape=(3,) or shape=(n,3) or shape=(m,n,3)
         A copy of the input atoms or coordinates, rotated by the given
         angles.
-        
+
     See Also
     --------
     rotate_centered
@@ -82,27 +87,39 @@ def rotate(atoms, angles):
     >>> print(rotated)
     [1.225e-16 2.000e+00 0.000e+00]
     """
-    from numpy import sin, cos
+    from numpy import cos, sin
 
     # Check if "angles" contains 3 angles for all dimensions
     if len(angles) != 3:
         raise ValueError("Translation vector must be container of length 3")
     # Create rotation matrices for all 3 dimensions
-    rot_x = np.array([[ 1,               0,               0               ],
-                      [ 0,               cos(angles[0]),  -sin(angles[0]) ],
-                      [ 0,               sin(angles[0]),  cos(angles[0])  ]])
-    
-    rot_y = np.array([[ cos(angles[1]),  0,               sin(angles[1])  ],
-                      [ 0,               1,               0               ],
-                      [ -sin(angles[1]), 0,               cos(angles[1])  ]])
-    
-    rot_z = np.array([[ cos(angles[2]),  -sin(angles[2]), 0               ],
-                      [ sin(angles[2]),  cos(angles[2]),  0               ],
-                      [ 0,               0,               1               ]])
-    
+    rot_x = np.array(
+        [
+            [1, 0, 0],
+            [0, cos(angles[0]), -sin(angles[0])],
+            [0, sin(angles[0]), cos(angles[0])],
+        ]
+    )
+
+    rot_y = np.array(
+        [
+            [cos(angles[1]), 0, sin(angles[1])],
+            [0, 1, 0],
+            [-sin(angles[1]), 0, cos(angles[1])],
+        ]
+    )
+
+    rot_z = np.array(
+        [
+            [cos(angles[2]), -sin(angles[2]), 0],
+            [sin(angles[2]), cos(angles[2]), 0],
+            [0, 0, 1],
+        ]
+    )
+
     positions = coord(atoms).copy()
     positions = matrix_rotate(positions, rot_z @ rot_y @ rot_x)
-    
+
     return _put_back(atoms, positions)
 
 
@@ -110,10 +127,10 @@ def rotate_centered(atoms, angles):
     """
     Rotate the given atoms or coordinates about the *x*, *y* and *z*
     axes by given angles.
-    
+
     The rotations are centered at the centroid of the corresponding
     structure and are performed sequentially in the order *x*, *y*, *z*.
-    
+
     Parameters
     ----------
     atoms : Atom or AtomArray or AtomArrayStack or ndarray, shape=(3,) or shape=(n,3) or shape=(m,n,3)
@@ -121,13 +138,13 @@ def rotate_centered(atoms, angles):
         The coordinates can be directly provided as :class:`ndarray`.
     angles: array-like, length=3
         The rotation angles in radians around axes *x*, *y* and *z*.
-    
+
     Returns
     -------
     transformed : Atom or AtomArray or AtomArrayStack or ndarray, shape=(3,) or shape=(n,3) or shape=(m,n,3)
         A copy of the input atoms or coordinates, rotated by the given
         angles.
-        
+
     See Also
     --------
     rotate
@@ -136,7 +153,7 @@ def rotate_centered(atoms, angles):
     if len(coord(atoms).shape) == 1:
         # Single value -> centered rotation does not change coordinates
         return atoms.copy()
-    
+
     # Rotation around centroid requires moving centroid to origin
     center = coord(centroid(atoms))
     # 'centroid()' removes the second last dimesion
@@ -152,7 +169,7 @@ def rotate_about_axis(atoms, axis, angle, support=None):
     """
     Rotate the given atoms or coordinates about a given axis by a given
     angle.
-    
+
     Parameters
     ----------
     atoms : Atom or AtomArray or AtomArrayStack or ndarray, shape=(3,) or shape=(n,3) or shape=(m,n,3)
@@ -167,13 +184,13 @@ def rotate_about_axis(atoms, axis, angle, support=None):
         An optional support vector for the rotation axis, i.e. the
         center of the rotation.
         By default, the center of the rotation is at *(0,0,0)*.
-    
+
     Returns
     -------
     transformed : Atom or AtomArray or AtomArrayStack or ndarray, shape=(3,) or shape=(n,3) or shape=(m,n,3)
         A copy of the input atoms or coordinates, rotated about the
         given axis.
-        
+
     See Also
     --------
     rotate
@@ -194,7 +211,7 @@ def rotate_about_axis(atoms, axis, angle, support=None):
         # Transform coordinates
         # so that the axis support vector is at (0,0,0)
         positions -= np.asarray(support)
-    
+
     # Normalize axis
     axis = np.asarray(axis, dtype=np.float32).copy()
     if np.linalg.norm(axis) == 0:
@@ -205,16 +222,30 @@ def rotate_about_axis(atoms, axis, angle, support=None):
     sin_a = np.sin(angle)
     cos_a = np.cos(angle)
     icos_a = 1 - cos_a
-    x = axis[...,0]
-    y = axis[...,1]
-    z = axis[...,2]
+    x = axis[..., 0]
+    y = axis[..., 1]
+    z = axis[..., 2]
     # Rotation matrix is taken from
     # https://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle
-    rot_matrix = np.array([
-        [ cos_a + icos_a*x**2,  icos_a*x*y - z*sin_a,  icos_a*x*z + y*sin_a],
-        [icos_a*x*y + z*sin_a,   cos_a + icos_a*y**2,  icos_a*y*z - x*sin_a],
-        [icos_a*x*z - y*sin_a,  icos_a*y*z + x*sin_a,   cos_a + icos_a*z**2]
-    ])
+    rot_matrix = np.array(
+        [
+            [
+                cos_a + icos_a * x**2,
+                icos_a * x * y - z * sin_a,
+                icos_a * x * z + y * sin_a,
+            ],
+            [
+                icos_a * x * y + z * sin_a,
+                cos_a + icos_a * y**2,
+                icos_a * y * z - x * sin_a,
+            ],
+            [
+                icos_a * x * z - y * sin_a,
+                icos_a * y * z + x * sin_a,
+                cos_a + icos_a * z**2,
+            ],
+        ]
+    )
 
     # For proper rotation reshape into a maximum of 2 dimensions
     orig_ndim = positions.ndim
@@ -230,7 +261,7 @@ def rotate_about_axis(atoms, axis, angle, support=None):
     if support is not None:
         # Transform coordinates back to original support vector position
         positions += np.asarray(support)
-    
+
     return _put_back(atoms, positions)
 
 
@@ -298,9 +329,7 @@ def orient_principal_components(atoms, order=None):
     else:
         order = np.asarray(order, dtype=int)
         if order.shape != (3,):
-            raise ValueError(
-                f"Expected order to have shape (3,), not {order.shape}"
-            )
+            raise ValueError(f"Expected order to have shape (3,), not {order.shape}")
         if not (np.sort(order) == np.arange(3)).all():
             raise ValueError("Expected order to contain [0, 1, 2].")
 
@@ -333,8 +362,13 @@ def orient_principal_components(atoms, order=None):
     return _put_back(atoms, centered)
 
 
-def align_vectors(atoms, origin_direction, target_direction,
-                  origin_position=None, target_position=None):
+def align_vectors(
+    atoms,
+    origin_direction,
+    target_direction,
+    origin_position=None,
+    target_position=None,
+):
     """
     Apply a transformation to atoms or coordinates, that would transfer
     a origin vector to a target vector.
@@ -345,8 +379,8 @@ def align_vectors(atoms, origin_direction, target_direction,
     This means, that the application of the transformation on the
     origin vector would give the target vector.
     Then the same transformation is applied to the given
-    atoms/coordinates. 
-    
+    atoms/coordinates.
+
     Parameters
     ----------
     atoms : Atom or AtomArray or AtomArrayStack or ndarray, shape=(3,) or shape=(n,3) or shape=(m,n,3)
@@ -359,13 +393,13 @@ def align_vectors(atoms, origin_direction, target_direction,
     origin_position, target_position : array-like, length=3, optional
         Optional support vectors for the origin or target, respectively.
         By default, origin and target start at *(0,0,0)*.
-    
+
     Returns
     -------
     transformed : Atom or AtomArray or AtomArrayStack or ndarray, shape=(3,) or shape=(n,3) or shape=(m,n,3)
         A copy of the input atoms or coordinates with the applied
         transformation.
-        
+
     See Also
     --------
     rotate
@@ -428,12 +462,8 @@ def align_vectors(atoms, origin_direction, target_direction,
         A       2  LEU HD22   H        -6.255    7.544   -2.657
         A       2  LEU HD23   H        -5.592    8.445   -1.281
     """
-    origin_direction = np.asarray(
-        origin_direction, dtype=np.float32
-    ).squeeze()
-    target_direction = np.asarray(
-        target_direction, dtype=np.float32
-    ).squeeze()
+    origin_direction = np.asarray(origin_direction, dtype=np.float32).squeeze()
+    target_direction = np.asarray(target_direction, dtype=np.float32).squeeze()
     # check that original and target direction are vectors of shape (3,)
     if origin_direction.shape != (3,):
         raise ValueError(
@@ -449,9 +479,9 @@ def align_vectors(atoms, origin_direction, target_direction,
         raise ValueError("Length of the origin vector is 0")
     if np.linalg.norm(target_direction) == 0:
         raise ValueError("Length of the target vector is 0")
-    if origin_position is not None: 
+    if origin_position is not None:
         origin_position = np.asarray(origin_position, dtype=np.float32)
-    if target_position is not None: 
+    if target_position is not None:
         target_position = np.asarray(target_position, dtype=np.float32)
 
     positions = coord(atoms).copy()
@@ -459,7 +489,7 @@ def align_vectors(atoms, origin_direction, target_direction,
         # Transform coordinates
         # so that the position of the origin vector is at (0,0,0)
         positions -= origin_position
-    
+
     # Normalize direction vectors
     origin_direction = origin_direction.copy()
     norm_vector(origin_direction)
@@ -468,11 +498,7 @@ def align_vectors(atoms, origin_direction, target_direction,
     # Formula is taken from
     # https://math.stackexchange.com/questions/180418/calculate-rotation-matrix-to-align-vector-a-to-vector-b-in-3d/476311#476311
     vx, vy, vz = np.cross(origin_direction, target_direction)
-    v_c = np.array([
-        [  0, -vz,  vy],
-        [ vz,   0, -vx],
-        [-vy,  vx,   0]
-    ], dtype=float)
+    v_c = np.array([[0, -vz, vy], [vz, 0, -vx], [-vy, vx, 0]], dtype=float)
     cos_a = vector_dot(origin_direction, target_direction)
     if np.all(cos_a == -1):
         raise ValueError(
@@ -480,9 +506,9 @@ def align_vectors(atoms, origin_direction, target_direction,
             "cannot calculate rotation matrix"
         )
     rot_matrix = np.identity(3) + v_c + (v_c @ v_c) / (1 + cos_a)
-    
+
     positions = matrix_rotate(positions, rot_matrix)
-    
+
     if target_position is not None:
         # Transform coordinates to position of the target vector
         positions += target_position
@@ -501,4 +527,4 @@ def _put_back(input_atoms, transformed):
         moved_atoms.coord = transformed
         return moved_atoms
     else:
-        return transformed
+        return transformed

biotite/structure/util.py

@@ -11,31 +11,30 @@ __author__ = "Patrick Kunzmann"
 __all__ = ["vector_dot", "norm_vector", "distance", "matrix_rotate"]
 
 import numpy as np
-from .atoms import Atom, array
 
 
-def vector_dot(v1,v2):
+def vector_dot(v1, v2):
     """
     Calculate vector dot product of two vectors.
-    
+
     Parameters
     ----------
     v1,v2 : ndarray
         The arrays to calculate the product from.
         The vectors are represented by the last axis.
-    
+
     Returns
     -------
     product : float or ndarray
         Scalar product over the last dimension of the arrays.
     """
-    return (v1*v2).sum(axis=-1)
+    return (v1 * v2).sum(axis=-1)
 
 
 def norm_vector(v):
     """
     Normalise a vector.
-    
+
     Parameters
     ----------
     v : ndarray
@@ -47,25 +46,25 @@ def norm_vector(v):
         v /= factor[..., np.newaxis]
     else:
         v /= factor
-        
 
-def distance(v1,v2):
+
+def distance(v1, v2):
     """
     Calculate the distance between two position vectors.
-    
+
     Parameters
     ----------
     v1,v2 : ndarray
         The arrays to calculate the product from.
         The vectors are represented by the last axis.
-    
+
     Returns
     -------
     product : float or ndarray
         Vector distance over the last dimension of the array.
     """
     dif = v1 - v2
-    return np.sqrt((dif*dif).sum(axis=-1))
+    return np.sqrt((dif * dif).sum(axis=-1))
 
 
 def matrix_rotate(v, matrix):
@@ -78,7 +77,7 @@ def matrix_rotate(v, matrix):
         The coordinates to rotate.
     matrix : ndarray
         The rotation matrix.
-    
+
     Returns
     -------
     rotated : ndarray
@@ -95,4 +94,3 @@ def matrix_rotate(v, matrix):
     if orig_ndim > 2:
         v = v.reshape(*orig_shape)
     return v
-

biotite/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.41.2'
-__version_tuple__ = version_tuple = (0, 41, 2)
+__version__ = version = '1.0.1'
+__version_tuple__ = version_tuple = (1, 0, 1)

biotite/visualize.py

@@ -6,25 +6,25 @@ __name__ = "biotite"
 __author__ = "Patrick Kunzmann"
 __all__ = ["colors", "set_font_size_in_coord", "AdaptiveFancyArrow"]
 
-import abc
 from collections import OrderedDict
 import numpy as np
 from numpy.linalg import norm
 
-
 # Biotite themed colors
-colors = OrderedDict([
-    ("brightorange" , "#ffb569ff"),
-    ("lightorange"  , "#ff982dff"),
-    ("orange"       , "#ff8405ff"),
-    ("dimorange"    , "#dc7000ff"),
-    ("darkorange"   , "#b45c00ff"),
-    ("brightgreen"  , "#98e97fff"),
-    ("lightgreen"   , "#6fe04cff"),
-    ("green"        , "#52da2aff"),
-    ("dimgreen"     , "#45bc20ff"),
-    ("darkgreen"    , "#389a1aff"),
-])
+colors = OrderedDict(
+    [
+        ("brightorange", "#ffb569ff"),
+        ("lightorange", "#ff982dff"),
+        ("orange", "#ff8405ff"),
+        ("dimorange", "#dc7000ff"),
+        ("darkorange", "#b45c00ff"),
+        ("brightgreen", "#98e97fff"),
+        ("lightgreen", "#6fe04cff"),
+        ("green", "#52da2aff"),
+        ("dimgreen", "#45bc20ff"),
+        ("darkgreen", "#389a1aff"),
+    ]
+)
 
 
 def set_font_size_in_coord(text, width=None, height=None, mode="unlocked"):
@@ -75,8 +75,8 @@ def set_font_size_in_coord(text, width=None, height=None, mode="unlocked"):
     This behavior is not equal for all initial font sizes (in 'pt'),
     the boundaries for an initial size of 1 'pt' seem to be most exact.
     """
-    from matplotlib.transforms import Bbox, Affine2D
     from matplotlib.patheffects import AbstractPathEffect
+    from matplotlib.transforms import Affine2D, Bbox
 
     class TextScaler(AbstractPathEffect):
         def __init__(self, text, width, height, mode):
@@ -85,11 +85,11 @@ def set_font_size_in_coord(text, width=None, height=None, mode="unlocked"):
             self._width = width
             self._height = height
 
-        def draw_path(self, renderer, gc, tpath, affine, rgbFace=None):
+        def draw_path(self, renderer, gc, tpath, affine, rgbFace=None):  # noqa: N803
             ax = self._text.axes
             try:
                 renderer = ax.get_figure().canvas.get_renderer()
-            except:
+            except Exception:
                 # Use cached renderer for backends, where
                 # `get_renderer()` is not available
                 # Based on the strategy from `Text.get_window_extent()`
@@ -127,25 +127,21 @@ def set_font_size_in_coord(text, width=None, height=None, mode="unlocked"):
 
     if mode in ["unlocked", "minimum", "maximum"]:
         if width is None or height is None:
-            raise TypeError(
-                f"Width and height must be set in '{mode}' mode"
-            )
+            raise TypeError(f"Width and height must be set in '{mode}' mode")
     elif mode == "proportional":
-        if  not (width  is None and height is not None) or \
-            not (height is None and width  is not None):
-                raise TypeError(
-                    f"Either width or height must be set in '{mode}' mode"
-                )
+        if not (width is None and height is not None) or not (
+            height is None and width is not None
+        ):
+            raise TypeError(f"Either width or height must be set in '{mode}' mode")
     else:
-        raise ValueError(
-                f"Unknown mode '{mode}'"
-            )
+        raise ValueError(f"Unknown mode '{mode}'")
     text.set_path_effects([TextScaler(text, width, height, mode)])
 
+
 try:
     # Only create this class when matplotlib is installed
-    from matplotlib.transforms import Bbox
     from matplotlib.patches import FancyArrow
+    from matplotlib.transforms import Bbox
 
     class AdaptiveFancyArrow(FancyArrow):
         """
@@ -177,9 +173,19 @@ try:
             `FancyArrow`.
         """
 
-        def __init__(self, x, y, dx, dy,
-                     tail_width, head_width, head_ratio, draw_head=True,
-                     shape="full", **kwargs):
+        def __init__(
+            self,
+            x,
+            y,
+            dx,
+            dy,
+            tail_width,
+            head_width,
+            head_ratio,
+            draw_head=True,
+            shape="full",
+            **kwargs,
+        ):
             self._x = x
             self._y = y
             self._dx = dx
@@ -193,23 +199,25 @@ try:
             if not draw_head:
                 head_width = tail_width
             super().__init__(
-                x, y, dx, dy,
-                width=tail_width, head_width=head_width,
-                overhang=0, shape=shape,
-                length_includes_head=True, **kwargs
+                x,
+                y,
+                dx,
+                dy,
+                width=tail_width,
+                head_width=head_width,
+                overhang=0,
+                shape=shape,
+                length_includes_head=True,
+                **kwargs,
             )
 
         def draw(self, renderer):
-            arrow_box = Bbox([(0,0), (0,self._head_width)])
+            arrow_box = Bbox([(0, 0), (0, self._head_width)])
             arrow_box_display = self.axes.transData.transform_bbox(arrow_box)
-            head_length_display = np.abs(
-                arrow_box_display.height * self._head_ratio
-            )
+            head_length_display = np.abs(arrow_box_display.height * self._head_ratio)
             arrow_box_display.x1 = arrow_box_display.x0 + head_length_display
             # Transfrom back to data coordinates for plotting
-            arrow_box = self.axes.transData.inverted().transform_bbox(
-                arrow_box_display
-            )
+            arrow_box = self.axes.transData.inverted().transform_bbox(arrow_box_display)
             head_length = arrow_box.width
             arrow_length = norm((self._dx, self._dy))
             if head_length > arrow_length:
@@ -221,11 +229,19 @@ try:
 
             # Renew the arrow's properties
             super().__init__(
-                self._x, self._y, self._dx, self._dy,
-                width=self._tail_width, head_width=self._head_width,
-                overhang=0, shape=self._shape,
-                head_length=head_length, length_includes_head=True,
-                axes=self.axes, transform=self.get_transform(), **self._kwargs
+                self._x,
+                self._y,
+                self._dx,
+                self._dy,
+                width=self._tail_width,
+                head_width=self._head_width,
+                overhang=0,
+                shape=self._shape,
+                head_length=head_length,
+                length_includes_head=True,
+                axes=self.axes,
+                transform=self.get_transform(),
+                **self._kwargs,
             )
             self.set_clip_path(self.axes.patch)
             super().draw(renderer)
@@ -234,18 +250,16 @@ try:
         # Removes warning:
         # unknown document: /tutorials/intermediate/constrainedlayout_guide
         def get_in_layout(self):
-            """
-            """
+            """ """
             return super().get_in_layout()
+
         def set_in_layout(self, in_layout):
-            """
-            """
+            """ """
             return super().set_in_layout(in_layout)
 
 except ImportError:
-
     # Dummy class that propagates a meaningful error,
     # i.e. that Matplotlib is not installed
-    class AdaptiveFancyArrow():
+    class AdaptiveFancyArrow:
         def __init__(*args, **kwargs):
-            raise ModuleNotFoundError(f"No module named 'matplotlib'")
+            raise ModuleNotFoundError("No module named 'matplotlib'")