biotite 0.41.2__cp310-cp310-macosx_11_0_arm64.whl → 1.0.1__cp310-cp310-macosx_11_0_arm64.whl

biotite/structure/io/mmtf/encode.pyx

@@ -1,183 +0,0 @@
-# This source code is part of the Biotite package and is distributed
-# under the 3-Clause BSD License. Please see 'LICENSE.rst' for further
-# information.
-
-__name__ = "biotite.structure.io.mmtf"
-__author__ = "Patrick Kunzmann"
-__all__ = ["encode_array"]
-
-cimport cython
-cimport numpy as np
-
-import numpy as np
-
-ctypedef np.int8_t int8
-ctypedef np.int16_t int16
-ctypedef np.int32_t int32
-ctypedef np.uint8_t uint8
-ctypedef np.uint16_t uint16
-ctypedef np.uint32_t uint32
-ctypedef np.uint64_t uint64
-ctypedef np.float32_t float32
-
-
-def encode_array(np.ndarray array, int codec, int param):
-    # Pass-through: 32-bit floating-point number array
-    if   codec == 1:
-        array = array.astype(np.float32, copy=False)
-        return array.astype(">f4").tobytes()
-    # Pass-through: 8-bit signed integer array
-    elif codec == 2:
-        array = array.astype(np.int8, copy=False)
-        return array.astype(">i1").tobytes()
-    # Pass-through: 16-bit signed integer array
-    elif codec == 3:
-        array = array.astype(np.int16, copy=False)
-        return array.astype(">i2").tobytes()
-    # Pass-through: 32-bit signed integer array
-    elif codec == 4:
-        array = array.astype(np.int32, copy=False)
-        return array.astype(">i4").tobytes()
-    # UTF8/ASCII fixed-length string array
-    elif codec == 5:
-        dtype = np.dtype("U" + str(param))
-        array = array.astype(dtype, copy=False)
-        return array.astype(np.dtype("S" + str(param))).tobytes()
-    # Run-length encoded character array
-    elif codec == 6:
-        array = array.astype("U1", copy=False)
-        array = _encode_run_length(np.frombuffer(array, dtype=np.int32))
-        return array.astype(">i4").tobytes()
-    # Run-length encoded 32-bit signed integer array
-    elif codec == 7:
-        array = array.astype(np.int32, copy=False)
-        return _encode_run_length(array).astype(">i4").tobytes()
-    # Delta & run-length encoded 32-bit signed integer array
-    elif codec == 8:
-        array = array.astype(np.int32, copy=False)
-        return _encode_run_length(_encode_delta(array)).astype(">i4").tobytes()
-    # Integer & run-length encoded 32-bit floating-point number array
-    elif codec == 9:
-        array = array.astype(np.float32, copy=False)
-        return _encode_run_length(
-                    _encode_integer(param, array).astype(np.int32)
-                ).astype(">i4").tobytes()
-    # Integer & delta encoded
-    # & two-byte-packed 32-bit floating-point number array
-    elif codec == 10:
-        array = array.astype(np.float32, copy=False)
-        return _encode_packed(
-                    True, _encode_delta(
-                        _encode_integer(param, array).astype(np.int32)
-                    )
-                ).astype(">i2").tobytes()
-    # Integer encoded 32-bit floating-point number array
-    elif codec == 11:
-        array = array.astype(np.float32, copy=False)
-        return _encode_integer(param, array).astype(">i2").tobytes()
-    # Integer & two-byte-packed 32-bit floating-point number array
-    elif codec == 12:
-        array = array.astype(np.float32, copy=False)
-        return _encode_packed(
-                    True, _encode_integer(param, array).astype(np.int32) 
-                ).astype(">i2").tobytes()
-    # Integer & one-byte-packed 32-bit floating-point number array
-    elif codec == 13:
-        array = array.astype(np.float32, copy=False)
-        return _encode_packed(
-                    False, _encode_integer(param, array).astype(np.int32)
-                ).astype(">i1").tobytes()
-    # Two-byte-packed 32-bit signed integer array
-    elif codec == 14:
-        array = array.astype(np.int32, copy=False)
-        return _encode_packed(True, array).astype(">i2").tobytes()
-    # One-byte-packed 32-bit signed integer array
-    elif codec == 15:
-        array = array.astype(np.int32, copy=False)
-        return _encode_packed(False, array).astype(">i1").tobytes()
-    else:
-        raise ValueError(f"Unknown codec with ID {codec}")
-
-
-def _encode_delta(int32[:] array):
-    cdef int32[:] output = np.zeros(array.shape[0], np.int32)
-    output[0] = array[0]
-    cdef int i = 0
-    for i in range(1, array.shape[0]):
-        output[i] = array[i] - array[i-1]
-    return np.asarray(output)
-
-
-def _encode_run_length(int32[:] array):
-    # Pessimistic allocation of output array
-    # -> Run length is 1 for every element
-    cdef int32[:] output = np.zeros(array.shape[0] * 2, dtype=np.int32)
-    cdef int i=0, j=0
-    cdef int val = array[0]
-    cdef int run_length = 0
-    cdef int curr_val
-    for i in range(array.shape[0]):
-        curr_val = array[i]
-        if curr_val == val:
-            run_length += 1
-        else:
-            # New element -> Write element with run-length
-            output[j] = val
-            output[j+1] = run_length
-            j += 2
-            val = curr_val
-            run_length = 1
-    # Write last element
-    output[j] = val
-    output[j+1] = run_length
-    j += 2
-    # Trim to correct size
-    return np.asarray(output)[:j]
-
-
-@cython.cdivision(True)
-def _encode_packed(bint two_byte, int32[:] array):
-    cdef int min_val, max_val
-    cdef int i=0, j=0
-    if two_byte:
-        min_val = np.iinfo(np.int16).min
-        max_val = np.iinfo(np.int16).max
-    else:
-        min_val = np.iinfo(np.int8).min
-        max_val = np.iinfo(np.int8).max
-    # Get length of output array
-    # by summing up required length of each element
-    cdef int number
-    cdef int length = 0
-    for i in range(array.shape[0]):
-        number = array[i]
-        if number < 0:
-            length += number // min_val +1
-        elif number > 0:
-            length += number // max_val +1
-        else:
-            # e = 0
-            length += 1
-    # Fill output
-    cdef int16[:] output = np.zeros(length, dtype=np.int16)
-    cdef int remainder
-    j = 0
-    for i in range(array.shape[0]):
-        remainder = array[i]
-        if remainder < 0:
-            while remainder <= min_val:
-                remainder -= min_val
-                output[j] = min_val
-                j += 1
-        elif remainder > 0:
-            while remainder >= max_val:
-                remainder -= max_val
-                output[j] = max_val
-                j += 1
-        output[j] = remainder
-        j += 1
-    return np.asarray(output)
-
-
-def _encode_integer(int divisor, np.ndarray array):
-    return np.multiply(array, divisor)

biotite/structure/io/mmtf/file.py

@@ -1,233 +0,0 @@
-# This source code is part of the Biotite package and is distributed
-# under the 3-Clause BSD License. Please see 'LICENSE.rst' for further
-# information.
-
-__name__ = "biotite.structure.io.mmtf"
-__author__ = "Patrick Kunzmann"
-__all__ = ["MMTFFile"]
-
-import io
-from collections.abc import MutableMapping
-import struct
-import copy
-import numpy as np
-import msgpack
-import warnings
-from ....file import File, is_binary, is_open_compatible
-from ...error import BadStructureError
-from .decode import decode_array
-from .encode import encode_array
-
-
-class MMTFFile(File, MutableMapping):
-    """
-    This class represents a MMTF file.
-
-    When reading a file, the *MessagePack* unpacker is used to create
-    a dictionary of the file content.
-    This dictionary is accessed by indexing the :class:`MMTFFile`
-    instance directly with the dictionary keys.
-    If the dictionary value is an encoded array, the value automatically
-    decoded.
-    Decoded arrays are always returned as :class:`ndarray` instances.
-
-    DEPRECATED: Use :class:`biotite.structure.io.pdbx.BinaryCIFFile`
-    instead.
-
-    Examples
-    --------
-
-    >>> import os.path
-    >>> mmtf_file = MMTFFile.read(os.path.join(path_to_structures, "1l2y.mmtf"))
-    >>> print(mmtf_file["title"])
-    NMR Structure of Trp-Cage Miniprotein Construct TC5b
-    >>> print(mmtf_file["chainNameList"])
-    ['A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A'
-     'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A' 'A'
-     'A' 'A']
-    """
-
-    def __init__(self):
-        warnings.warn(
-            "'MMTFFile' is deprecated, use 'BinaryCIFFile' instead",
-            DeprecationWarning
-        )
-        super().__init__()
-        self._content = {}
-        self._content["mmtfVersion"] = "1.0.0"
-        self._content["mmtfProducer"] = "UNKNOWN"
-
-    @classmethod
-    def read(self, file):
-        """
-        Read a MMTF file.
-
-        Parameters
-        ----------
-        file : file-like object or str
-            The file to be read.
-            Alternatively a file path can be supplied.
-
-        Returns
-        -------
-        file_object : MMTFFile
-            The parsed file.
-        """
-        mmtf_file = MMTFFile()
-        # File name
-        if is_open_compatible(file):
-            with open(file, "rb") as f:
-                mmtf_file._content = msgpack.unpackb(
-                    f.read(), use_list=True, raw=False
-                )
-        # File object
-        else:
-            if not is_binary(file):
-                raise TypeError("A file opened in 'binary' mode is required")
-            mmtf_file._content = msgpack.unpackb(
-                file.read(), use_list=True, raw=False
-            )
-        return mmtf_file
-
-    def write(self, file):
-        """
-        Write contents into a MMTF file.
-
-        Parameters
-        ----------
-        file : file-like object or str
-            The file to be written to.
-            Alternatively, a file path can be supplied.
-        """
-        packed_bytes = msgpack.packb(
-            self._content, use_bin_type=True, default=_encode_numpy
-        )
-        if is_open_compatible(file):
-            with open(file, "wb") as f:
-                f.write(packed_bytes)
-        else:
-            if not is_binary(file):
-                raise TypeError("A file opened in 'binary' mode is required")
-            file.write(packed_bytes)
-
-    def __copy_fill__(self, clone):
-        super().__copy_fill__(clone)
-        clone._content = copy.deepcopy(self._content)
-
-    def get_codec(self, key):
-        """
-        Obtain the codec ID of an MMTF encoded value.
-
-        Parameters
-        ----------
-        key : str
-            The key for the potentially encoded value.
-
-        Returns
-        -------
-        codec : int or None
-            The codec ID. `None` if the value is not encoded.
-        """
-        data = self._content[key]
-        if isinstance(data, bytes) and data[0] == 0:
-            codec = struct.unpack(">i", data[0:4])[0]
-            return codec
-        else:
-            return None
-
-    def get_length(self, key):
-        """
-        Obtain the length of an MMTF encoded value.
-
-        Parameters
-        ----------
-        key : str
-            The key for the potentially encoded value.
-
-        Returns
-        -------
-        codec : int or None
-            The length of the `bytes` array.
-            `None` if the value is not encoded.
-        """
-        data = self._content[key]
-        if isinstance(data, bytes) and data[0] == 0:
-            length = struct.unpack(">i", data[4:8])[0]
-            return length
-        else:
-            return None
-
-    def get_param(self, key):
-        """
-        Obtain the parameter of an MMTF encoded value.
-
-        Parameters
-        ----------
-        key : str
-            The key for the potentially encoded value.
-
-        Returns
-        -------
-        codec : int or None
-            The parameter of the encoded value.
-            `None` if the value is not encoded.
-        """
-        data = self._content[key]
-        if isinstance(data, bytes) and data[0] == 0:
-            param = struct.unpack(">i", data[8:12])[0]
-            return param
-        else:
-            return None
-
-    def set_array(self, key, array, codec, param=0):
-        length = len(array)
-        raw_bytes = encode_array(array, codec, param)
-        data = struct.pack(">i", codec) \
-             + struct.pack(">i", length) \
-             + struct.pack(">i", param) \
-             + raw_bytes
-        self._content[key] = data
-
-    def __getitem__(self, key):
-        data = self._content[key]
-        if isinstance(data, bytes) and data[0] == 0:
-            # MMTF specific format -> requires decoding
-            codec     = struct.unpack(">i", data[0:4 ])[0]
-            length    = struct.unpack(">i", data[4:8 ])[0]
-            param     = struct.unpack(">i", data[8:12])[0]
-            raw_bytes = data[12:]
-            return decode_array(codec, raw_bytes, param)
-        else:
-            return data
-
-    def __setitem__(self, key, item):
-        if isinstance(item, np.ndarray):
-            raise TypeError("Arrays that need to be encoded must be addeed "
-                            "via 'set_array()'")
-        self._content[key] = item
-
-    def __delitem__(self, key):
-        del self._content[key]
-
-    def __iter__(self):
-        return self._content.__iter__()
-
-    def __len__(self):
-        return len(self._content)
-
-    def __contains__(self, item):
-        return item in self._content
-
-
-def _encode_numpy(item):
-    """
-    Convert NumPy scalar types to native Python types,
-    as *Msgpack* cannot handle NumPy types (e.g. float32).
-
-    The function is given to the Msgpack packer as value for the
-    `default` parameter.
-    """
-    if isinstance(item, np.generic):
-        return item.item()
-    else:
-        raise TypeError(f"can not serialize '{type(item).__name__}' object")

biotite/structure/io/npz/__init__.py

@@ -1,20 +0,0 @@
-# This source code is part of the Biotite package and is distributed
-# under the 3-Clause BSD License. Please see 'LICENSE.rst' for further
-# information.
-
-"""
-This subpackage is used for reading and writing an :class:`AtomArray` or
-:class:`AtomArrayStack` using the internal NPZ file format. This binary
-format is used to store `NumPy` arrays. Since atom arrays and stacks are
-completely built on `NumPy` arrays, this format is preferable for
-Biotite internal usage due to fast I/O operations and preservation
-of all atom annotation arrays.
-
-DEPRECATED: Pickle data directly or use
-:class:`biotite.structure.io.pdbx.BinaryCIFFile` instead.
-"""
-
-__name__ = "biotite.structure.io.npz"
-__author__ = "Patrick Kunzmann"
-
-from .file import *

biotite/structure/io/npz/file.py

@@ -1,152 +0,0 @@
-# This source code is part of the Biotite package and is distributed
-# under the 3-Clause BSD License. Please see 'LICENSE.rst' for further
-# information.
-
-__name__ = "biotite.structure.io.npz"
-__author__ = "Patrick Kunzmann"
-__all__ = ["NpzFile"]
-
-import numpy as np
-from ...atoms import Atom, AtomArray, AtomArrayStack
-from ...bonds import BondList
-from ....file import File, is_binary
-
-
-class NpzFile(File):
-    r"""
-    This class represents a NPZ file, the preferable format for
-    Biotite internal structure storage.
-
-    Internally the this class writes/reads all attribute arrays of an
-    :class:`AtomArray` or :class:`AtomArrayStack` using the *NumPy*
-    :func:`save()`/:func:`load()`
-    method. This format offers the fastest I/O operations and completely
-    preserves the content all atom annotation arrays.
-
-    DEPRECATED: Pickle data directly or use
-    :class:`biotite.structure.io.pdbx.BinaryCIFFile` instead.
-
-    Examples
-    --------
-    Load a \\*.npz file, modify the structure and save the new
-    structure into a new file:
-
-    >>> import os.path
-    >>> file = NpzFile.read(os.path.join(path_to_structures, "1l2y.npz"))
-    >>> array_stack = file.get_structure()
-    >>> array_stack_mod = rotate(array_stack, [1,2,3])
-    >>> file = NpzFile()
-    >>> file.set_structure(array_stack_mod)
-    >>> file.write(os.path.join(path_to_directory, "1l2y_mod.npz"))
-
-    """
-
-    def __init__(self):
-        super().__init__()
-        self._data_dict = None
-
-    def __copy_fill__(self, clone):
-        super().__copy_fill__(clone)
-        if self._data_dict is not None:
-            for key, value in self._data_dict.items():
-                clone._data_dict[key] = np.copy(value)
-
-    @classmethod
-    def read(cls, file):
-        """
-        Read a NPZ file.
-
-        Parameters
-        ----------
-        file : file-like object or str
-            The file to be read.
-            Alternatively a file path can be supplied.
-
-        Returns
-        -------
-        file_object : NPZFile
-            The parsed file.
-        """
-        npz_file = NpzFile()
-        # File name
-        if isinstance(file, str):
-            with open(file, "rb") as f:
-                npz_file._data_dict = dict(np.load(f, allow_pickle=False))
-        # File object
-        else:
-            if not is_binary(file):
-                raise TypeError("A file opened in 'binary' mode is required")
-            npz_file._data_dict = dict(np.load(file, allow_pickle=False))
-        return npz_file
-
-    def write(self, file):
-        """
-        Write a NPZ file.
-
-        Parameters
-        ----------
-        file : file-like object or str
-            The file to be read.
-            Alternatively, a file path can be supplied.
-        """
-        if isinstance(file, str):
-            with open(file, "wb") as f:
-                np.savez(f, **self._data_dict)
-        else:
-            if not is_binary(file):
-                raise TypeError("A file opened in 'binary' mode is required")
-            np.savez(file, **self._data_dict)
-
-    def get_structure(self):
-        """
-        Get an :class:`AtomArray` or :class:`AtomArrayStack` from the
-        file.
-
-        If this method returns an array or stack depends on which type
-        of object was used when the file was written.
-
-        Returns
-        -------
-        array : AtomArray or AtomArrayStack
-            The array or stack contained in this file.
-        """
-        if self._data_dict is None:
-            raise ValueError("The structure of this file "
-                             "has not been loaded or set yet")
-        coord = self._data_dict["coord"]
-        # The type of the structure is determined by the dimensionality
-        # of the 'coord' field
-        if len(coord.shape) == 3:
-            array = AtomArrayStack(coord.shape[0], coord.shape[1])
-        else:
-            array = AtomArray(coord.shape[0])
-
-        for key, value in self._data_dict.items():
-            if key == "coord":
-                array.coord = value
-            elif key == "bonds":
-                array.bonds = BondList(array.array_length(), value)
-            elif key == "box":
-                array.box = value
-            else:
-                array.set_annotation(key, value)
-        return array
-
-    def set_structure(self, array):
-        """
-        Set the :class:`AtomArray` or :class:`AtomArrayStack` for the
-        file.
-
-        Parameters
-        ----------
-        array : AtomArray or AtomArrayStack
-            The array or stack to be saved into this file.
-        """
-        self._data_dict = {}
-        self._data_dict["coord"] = np.copy(array.coord)
-        if array.bonds is not None:
-            self._data_dict["bonds"] = array.bonds.as_array()
-        if array.box is not None:
-            self._data_dict["box"] = np.copy(array.box)
-        for annot in array.get_annotation_categories():
-            self._data_dict[annot] = np.copy(array.get_annotation(annot))