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

biotite/sequence/sequence.py

@@ -25,7 +25,7 @@ _size_uint32 = np.iinfo(np.uint32).max +1
 class Sequence(Copyable, metaclass=abc.ABCMeta):
     """
     The abstract base class for all sequence types.
-    
+
     A :class:`Sequence` can be seen as a succession of symbols, that are
     elements in the allowed set of symbols, the :class:`Alphabet`.
     Internally, a :class:`Sequence` object uses a *NumPy*
@@ -36,35 +36,35 @@ class Sequence(Copyable, metaclass=abc.ABCMeta):
     :class:`Sequence`, into an integer. These integer values are called
     symbol code, the encoding of an entire sequence of symbols is
     called sequence code.
-    
-    The size of the symbol code type in the array is determined by the 
+
+    The size of the symbol code type in the array is determined by the
     size of the :class:`Alphabet`:
     If the :class:`Alphabet` contains 256 symbols or less, one byte is
     used per array element; if the :class:`Alphabet` contains
     between 257 and 65536 symbols, two bytes are used, and so on.
-    
+
     Two :class:`Sequence` objects are equal if they are instances of the
     same class, have the same :class:`Alphabet` and have equal sequence
     codes.
     Comparison with a string or list of symbols evaluates always to
     false.
-    
+
     A :class:`Sequence` can be indexed by any 1-D index a
     :class:`ndarray` accepts.
     If the index is a single integer, the decoded symbol at that
     position is returned, otherwise a subsequence is returned.
-    
+
     Individual symbols of the sequence can also be exchanged in indexed
     form: If the an integer is used as index, the item is treated as a
     symbol. Any other index (slice, index list, boolean mask) expects
     multiple symbols, either as list of symbols, as :class:`ndarray`
     containing a sequence code or another :class:`Sequence` instance.
     Concatenation of two sequences is achieved with the '+' operator.
-    
+
     Each subclass of :class:`Sequence` needs to overwrite the abstract
     method :func:`get_alphabet()`, which specifies the alphabet the
     :class:`Sequence` uses.
-    
+
     Parameters
     ----------
     sequence : iterable object, optional
@@ -72,7 +72,7 @@ class Sequence(Copyable, metaclass=abc.ABCMeta):
         For alphabets containing single letter strings, this parameter
         may also be a :class`str` object.
         By default the sequence is empty.
-    
+
     Attributes
     ----------
     code : ndarray
@@ -85,12 +85,12 @@ class Sequence(Copyable, metaclass=abc.ABCMeta):
     alphabet : Alphabet
         The alphabet of this sequence. Cannot be set.
         Equal to `get_alphabet()`.
-    
+
     Examples
     --------
     Creating a DNA sequence from string and print the symbols and the
     code:
-    
+
     >>> dna_seq = NucleotideSequence("ACGTA")
     >>> print(dna_seq)
     ACGTA
@@ -100,18 +100,18 @@ class Sequence(Copyable, metaclass=abc.ABCMeta):
     ['A' 'C' 'G' 'T' 'A']
     >>> print(list(dna_seq))
     ['A', 'C', 'G', 'T', 'A']
-    
+
     Sequence indexing:
-        
+
     >>> print(dna_seq[1:3])
     CG
     >>> print(dna_seq[[0,2,4]])
     AGA
     >>> print(dna_seq[np.array([False,False,True,True,True])])
     GTA
-    
+
     Sequence manipulation:
-        
+
     >>> dna_copy = dna_seq.copy()
     >>> dna_copy[2] = "C"
     >>> print(dna_copy)
@@ -134,28 +134,28 @@ class Sequence(Copyable, metaclass=abc.ABCMeta):
     >>> dna_seq_rev = dna_seq.reverse()
     >>> print(dna_seq_rev)
     ATGCA
-    
+
     Concatenate the two sequences:
-        
+
     >>> dna_seq_concat = dna_seq + dna_seq_rev
     >>> print(dna_seq_concat)
     ACGTAATGCA
-        
+
     """
-    
+
     def __init__(self, sequence=()):
         self.symbols = sequence
 
     def copy(self, new_seq_code=None):
         """
         Copy the object.
-        
+
         Parameters
         ----------
         new_seq_code : ndarray, optional
             If this parameter is set, the sequence code is set to this
             value, rather than the original sequence code.
-        
+
         Returns
         -------
         copy
@@ -171,51 +171,51 @@ class Sequence(Copyable, metaclass=abc.ABCMeta):
             clone.code = new_seq_code
         self.__copy_fill__(clone)
         return clone
-    
+
     @property
     def symbols(self):
         return self.get_alphabet().decode_multiple(self.code)
-    
+
     @symbols.setter
     def symbols(self, value):
         alph = self.get_alphabet()
         dtype = Sequence.dtype(len(alph))
         self._seq_code = alph.encode_multiple(value, dtype)
-    
+
     @property
     def code(self):
         return self._seq_code
-    
+
     @code.setter
     def code(self, value):
         dtype = Sequence.dtype(len(self.get_alphabet()))
         if not isinstance(value, np.ndarray):
             raise TypeError("Sequence code must be an integer ndarray")
         self._seq_code = value.astype(dtype, copy=False)
-    
+
     @property
     def alphabet(self):
         return self.get_alphabet()
-    
+
     @abc.abstractmethod
     def get_alphabet(self):
         """
         Get the :class:`Alphabet` of the :class:`Sequence`.
-        
+
         This method must be overwritten, when subclassing
         :class:`Sequence`.
-        
+
         Returns
         -------
         alphabet : Alphabet
             :class:`Sequence` alphabet.
         """
         pass
-    
+
     def reverse(self, copy=True):
         """
         Reverse the :class:`Sequence`.
-        
+
         Parameters
         ----------
         copy : bool, optional
@@ -225,15 +225,15 @@ class Sequence(Copyable, metaclass=abc.ABCMeta):
             In this case, manipulations on the returned sequence would
             also affect this object.
             Otherwise, the sequence code is copied.
-        
+
         Returns
         -------
         reversed : Sequence
             The reversed :class:`Sequence`.
-            
+
         Examples
         --------
-            
+
         >>> dna_seq = NucleotideSequence("ACGTA")
         >>> dna_seq_rev = dna_seq.reverse()
         >>> print(dna_seq_rev)
@@ -243,33 +243,33 @@ class Sequence(Copyable, metaclass=abc.ABCMeta):
         if copy:
             reversed_code = np.copy(reversed_code)
         return self.copy(reversed_code)
-    
+
     def is_valid(self):
         """
         Check, if the sequence contains a valid sequence code.
-        
+
         A sequence code is valid, if at each sequence position the
         code is smaller than the size of the alphabet.
-        
+
         Invalid code means that the code cannot be decoded into
         symbols. Furthermore invalid code can lead to serious
         errors in alignments, since the substitution matrix
         is indexed with an invalid index.
-        
+
         Returns
         -------
         valid : bool
             True, if the sequence is valid, false otherwise.
         """
         return (self.code < len(self.get_alphabet())).all()
-    
+
     def get_symbol_frequency(self):
         """
         Get the number of occurences of each symbol in the sequence.
-        
+
         If a symbol does not occur in the sequence, but it is in the
         alphabet, its number of occurences is 0.
-        
+
         Returns
         -------
         frequency : dict
@@ -284,7 +284,7 @@ class Sequence(Copyable, metaclass=abc.ABCMeta):
             symbol: count for symbol, count
             in zip(self.get_alphabet().get_symbols(), counts)
         }
-    
+
     def __getitem__(self, index):
         alph = self.get_alphabet()
         sub_seq = self._seq_code.__getitem__(index)
@@ -292,7 +292,7 @@ class Sequence(Copyable, metaclass=abc.ABCMeta):
             return self.copy(sub_seq)
         else:
             return alph.decode(sub_seq)
-    
+
     def __setitem__(self, index, item):
         alph = self.get_alphabet()
         if isinstance(index, numbers.Integral):
@@ -308,32 +308,34 @@ class Sequence(Copyable, metaclass=abc.ABCMeta):
                 # Default: item is iterable object of symbols
                 code = alph.encode_multiple(item)
         self._seq_code.__setitem__(index, code)
-    
+
     def __len__(self):
         return len(self._seq_code)
-    
+
     def __iter__(self):
         alph = self.get_alphabet()
         i = 0
         while i < len(self):
             yield alph.decode(self._seq_code[i])
             i += 1
-    
+
     def __eq__(self, item):
         if not isinstance(item, type(self)):
             return False
         if self.get_alphabet() != item.get_alphabet():
             return False
         return np.array_equal(self._seq_code, item._seq_code)
-    
+
     def __str__(self):
         alph = self.get_alphabet()
         if isinstance(alph, LetterAlphabet):
             return alph.decode_multiple(self._seq_code, as_bytes=True)\
                    .tobytes().decode("ASCII")
         else:
-            return "".join(alph.decode_multiple(self._seq_code))
-    
+            return ", ".join(
+                [str(e) for e in alph.decode_multiple(self._seq_code)]
+            )
+
     def __add__(self, sequence):
         if self.get_alphabet().extends(sequence.get_alphabet()):
             new_code = np.concatenate((self._seq_code, sequence._seq_code))
@@ -356,7 +358,7 @@ class Sequence(Copyable, metaclass=abc.ABCMeta):
         ----------
         alpahabet_size : int
             The size of the alphabet.
-        
+
         Returns
         -------
         dtype

biotite/structure/atoms.py

@@ -498,14 +498,14 @@ class Atom(Copyable):
 
     def __repr__(self):
         """Represent Atom as a string for debugging."""
-        annot = 'chain_id="' + self._annot["chain_id"] + '"'
-        annot = annot + ', res_id=' + str(self._annot["res_id"])
-        annot = annot + ', ins_code="' + self._annot["ins_code"] + '"'
-        annot = annot + ', res_name="' + self._annot["res_name"] + '"'
-        annot = annot + ', hetero=' + str(self._annot["hetero"])
-        annot = annot + ', atom_name="' + self._annot["atom_name"] + '"'
-        annot = annot + ', element="' + self._annot["element"] + '"'
-        return f'Atom(np.{np.array_repr(self.coord)}, {annot})'
+        # print out key-value pairs and format strings in quotation marks
+        annot_parts = [
+            f'{key}="{value}"' if isinstance(value, str) else f'{key}={value}'
+            for key, value in self._annot.items()
+        ]
+
+        annot = ', '.join(annot_parts)
+        return f'Atom(np.{np.array_repr(self.coord)}, {annot})'    
 
     @property
     def shape(self):

biotite/structure/bonds.pyx

@@ -1012,7 +1012,6 @@ class BondList(Copyable):
     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,27 +1328,6 @@ 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
-
-
 
 
 _DEFAULT_DISTANCE_RANGE = {

biotite/structure/info/ccd.py

@@ -24,12 +24,20 @@ _residue_index = {}
 
 def get_ccd():
     """
-    Get the PDB *Chemical Component Dictionary* (CCD).
+    Get the internal subset of the PDB
+    *Chemical Component Dictionary* (CCD).
+    :footcite:`Westbrook2015`
 
     Returns
     -------
     ccd : BinaryCIFFile
         The CCD.
+
+    References
+    ----------
+
+    .. footbibliography::
+
     """
     # Avoid circular import
     from ..io.pdbx.bcif import BinaryCIFFile
@@ -44,7 +52,8 @@ def get_ccd():
 def get_from_ccd(category_name, comp_id, column_name=None):
     """
     Get the rows for the given residue in the given category from the
-    PDB *Chemical Component Dictionary* (CCD).
+    internal subset of the PDB *Chemical Component Dictionary* (CCD).
+    :footcite:`Westbrook2015`
 
     Parameters
     ----------
@@ -62,6 +71,12 @@ def get_from_ccd(category_name, comp_id, column_name=None):
     value : ndarray or dict or None
         The array of the given column or all columns as dictionary.
         ``None`` if the `comp_id` is not found in the category.
+
+    References
+    ----------
+
+    .. footbibliography::
+
     """
     global _residue_index
     ccd = get_ccd()

biotite/structure/info/groups.py

@@ -19,7 +19,8 @@ group_lists = {}
 def amino_acid_names():
     """
     Get a tuple of amino acid three-letter codes according to the
-    PDB *Chemical Component Dictionary* :footcite:`Westbrook2015`.
+    PDB *Chemical Component Dictionary*.
+    :footcite:`Westbrook2015`
 
     Returns
     -------
@@ -27,13 +28,11 @@ def amino_acid_names():
         A list of three-letter-codes containing residues that are
         peptide monomers.
 
-    Notes
-    -----
-
     References
     ----------
 
     .. footbibliography::
+
     """
     return _get_group_members("amino_acids")
 
@@ -41,7 +40,8 @@ def amino_acid_names():
 def nucleotide_names():
     """
     Get a tuple of nucleotide three-letter codes according to the
-    PDB *Chemical Component Dictionary* :footcite:`Westbrook2015`.
+    PDB *Chemical Component Dictionary*.
+    :footcite:`Westbrook2015`
 
     Returns
     -------
@@ -49,13 +49,11 @@ def nucleotide_names():
         A list of three-letter-codes containing residues that are
         DNA/RNA monomers.
 
-    Notes
-    -----
-
     References
     ----------
 
     .. footbibliography::
+
     """
     return _get_group_members("nucleotides")
 
@@ -63,7 +61,8 @@ def nucleotide_names():
 def carbohydrate_names():
     """
     Get a tuple of carbohydrate three-letter codes according to the
-    PDB *Chemical Component Dictionary* :footcite:`Westbrook2015`.
+    PDB *Chemical Component Dictionary*.
+    :footcite:`Westbrook2015`
 
     Returns
     -------
@@ -71,13 +70,11 @@ def carbohydrate_names():
         A list of three-letter-codes containing residues that are
         saccharide monomers.
 
-    Notes
-    -----
-
     References
     ----------
 
     .. footbibliography::
+
     """
     return _get_group_members("carbohydrates")
 

biotite/structure/io/pdbx/bcif.py

@@ -389,14 +389,6 @@ class BinaryCIFCategory(_HierarchicalContainer):
     def supercomponent_class():
         return BinaryCIFBlock
 
-    def filter(self, index):
-        return BinaryCIFCategory(
-            {key: column.filter(index) for key, column in self.items()},
-            # Create placeholder array just to check how many elements
-            # remain after filtering
-            len(np.empty(self.row_count, dtype=bool)[index]),
-        )
-
     @staticmethod
     def deserialize(content):
         return BinaryCIFCategory(

biotite/version.py

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