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

biotite/sequence/alphabet.py

@@ -4,14 +4,18 @@
 
 __name__ = "biotite.sequence"
 __author__ = "Patrick Kunzmann"
-__all__ = ["Alphabet", "LetterAlphabet", "AlphabetMapper", "AlphabetError",
-           "common_alphabet"]
+__all__ = [
+    "Alphabet",
+    "LetterAlphabet",
+    "AlphabetMapper",
+    "AlphabetError",
+    "common_alphabet",
+]
 
-import copy
-from numbers import Integral
 import string
+from numbers import Integral
 import numpy as np
-from .codec import encode_chars, decode_to_chars, map_sequence_code
+from biotite.sequence.codec import decode_to_chars, encode_chars, map_sequence_code
 
 
 class Alphabet(object):
@@ -100,14 +104,14 @@ class Alphabet(object):
     def __init__(self, symbols):
         if len(symbols) == 0:
             raise ValueError("Symbol list is empty")
-        self._symbols = copy.deepcopy(list(symbols))
+        self._symbols = tuple(symbols)
         self._symbol_dict = {}
         for i, symbol in enumerate(symbols):
             self._symbol_dict[symbol] = i
 
     def __repr__(self):
         """Represent Alphabet as a string for debugging."""
-        return f'Alphabet({self._symbols})'
+        return f"Alphabet({self._symbols})"
 
     def get_symbols(self):
         """
@@ -115,10 +119,10 @@ class Alphabet(object):
 
         Returns
         -------
-        symbols : list
-            Copy of the internal list of symbols.
+        symbols : tuple
+            The symbols.
         """
-        return copy.deepcopy(self._symbols)
+        return self._symbols
 
     def extends(self, alphabet):
         """
@@ -139,8 +143,7 @@ class Alphabet(object):
         elif len(alphabet) > len(self):
             return False
         else:
-            return alphabet.get_symbols() \
-                == self.get_symbols()[:len(alphabet)]
+            return alphabet.get_symbols() == self.get_symbols()[: len(alphabet)]
 
     def encode(self, symbol):
         """
@@ -164,9 +167,7 @@ class Alphabet(object):
         try:
             return self._symbol_dict[symbol]
         except KeyError:
-            raise AlphabetError(
-                f"Symbol {repr(symbol)} is not in the alphabet"
-            )
+            raise AlphabetError(f"Symbol {repr(symbol)} is not in the alphabet")
 
     def decode(self, code):
         """
@@ -238,12 +239,11 @@ class Alphabet(object):
             have length 1 and are printable.
         """
         for symbol in self:
-            if not isinstance(symbol, (str, bytes)) \
-                or len(symbol) > 1:
-                    return False
+            if not isinstance(symbol, (str, bytes)) or len(symbol) > 1:
+                return False
             if isinstance(symbol, str):
                 symbol = symbol.encode("ASCII")
-            if symbol not in LetterAlphabet.PRINATBLES:
+            if symbol not in LetterAlphabet.PRINTABLES:
                 return False
         return True
 
@@ -260,7 +260,11 @@ class Alphabet(object):
         return symbol in self.get_symbols()
 
     def __hash__(self):
-        return hash(tuple(self._symbols))
+        symbols = self.get_symbols()
+        if isinstance(symbols, tuple):
+            return hash(symbols)
+        else:
+            return hash(tuple(symbols))
 
     def __eq__(self, item):
         if item is self:
@@ -292,8 +296,9 @@ class LetterAlphabet(Alphabet):
         in this list.
     """
 
-    PRINATBLES = (string.digits + string.ascii_letters + string.punctuation) \
-                 .encode("ASCII")
+    PRINTABLES = (string.digits + string.ascii_letters + string.punctuation).encode(
+        "ASCII"
+    )
 
     def __init__(self, symbols):
         if len(symbols) == 0:
@@ -304,7 +309,7 @@ class LetterAlphabet(Alphabet):
                 raise ValueError(f"Symbol '{symbol}' is not a single letter")
             if isinstance(symbol, str):
                 symbol = symbol.encode("ASCII")
-            if symbol not in LetterAlphabet.PRINATBLES:
+            if symbol not in LetterAlphabet.PRINTABLES:
                 raise ValueError(
                     f"Symbol {repr(symbol)} is not printable or whitespace"
                 )
@@ -312,47 +317,33 @@ class LetterAlphabet(Alphabet):
         # Direct 'astype' conversion is not allowed by numpy
         # -> frombuffer()
         self._symbols = np.frombuffer(
-            np.array(self._symbols, dtype="|S1"),
-            dtype=np.ubyte
+            np.array(self._symbols, dtype="|S1"), dtype=np.ubyte
         )
 
     def __repr__(self):
         """Represent LetterAlphabet as a string for debugging."""
-        return f'LetterAlphabet({self.get_symbols()})'
+        return f"LetterAlphabet({self.get_symbols()})"
 
     def extends(self, alphabet):
         if alphabet is self:
             return True
-        elif type(alphabet) == LetterAlphabet:
+        elif isinstance(alphabet, LetterAlphabet):
             if len(alphabet._symbols) > len(self._symbols):
                 return False
-            return np.all(
-                alphabet._symbols == self._symbols[:len(alphabet._symbols)]
-            )
+            return np.all(alphabet._symbols == self._symbols[: len(alphabet._symbols)])
         else:
             return super().extends(alphabet)
 
     def get_symbols(self):
-        """
-        Get the symbols in the alphabet.
-
-        Returns
-        -------
-        symbols : list
-            Copy of the internal list of symbols.
-        """
-        return [symbol.decode("ASCII") for symbol
-                in self._symbols_as_bytes()]
+        return tuple([symbol.decode("ASCII") for symbol in self._symbols_as_bytes()])
 
     def encode(self, symbol):
         if not isinstance(symbol, (str, bytes)) or len(symbol) > 1:
             raise AlphabetError(f"Symbol '{symbol}' is not a single letter")
         indices = np.where(self._symbols == ord(symbol))[0]
         if len(indices) == 0:
-            raise AlphabetError(
-                f"Symbol {repr(symbol)} is not in the alphabet"
-            )
-        return indices[0]
+            raise AlphabetError(f"Symbol {repr(symbol)} is not in the alphabet")
+        return indices[0].item()
 
     def decode(self, code, as_bytes=False):
         if code < 0 or code >= len(self._symbols):
@@ -382,13 +373,10 @@ class LetterAlphabet(Alphabet):
         elif isinstance(symbols, bytes):
             symbols = np.frombuffer(symbols, dtype=np.ubyte)
         elif isinstance(symbols, np.ndarray):
-            symbols = np.frombuffer(
-                symbols.astype(dtype="|S1"), dtype=np.ubyte
-            )
+            symbols = np.frombuffer(symbols.astype(dtype="|S1"), dtype=np.ubyte)
         else:
             symbols = np.frombuffer(
-                np.array(list(symbols), dtype="|S1"),
-                dtype=np.ubyte
+                np.array(list(symbols), dtype="|S1"), dtype=np.ubyte
             )
         return encode_chars(alphabet=self._symbols, symbols=symbols)
 
@@ -435,7 +423,6 @@ class LetterAlphabet(Alphabet):
         return np.frombuffer(self._symbols, dtype="|S1")
 
 
-
 class AlphabetMapper(object):
     """
     This class is used for symbol code conversion from a source
@@ -486,8 +473,7 @@ class AlphabetMapper(object):
         else:
             self._necessary_mapping = True
             self._mapper = np.zeros(
-                len(source_alphabet),
-                dtype=AlphabetMapper._dtype(len(target_alphabet))
+                len(source_alphabet), dtype=AlphabetMapper._dtype(len(target_alphabet))
             )
             for old_code in range(len(source_alphabet)):
                 symbol = source_alphabet.decode(old_code)
@@ -500,26 +486,25 @@ class AlphabetMapper(object):
                 return self._mapper[code]
             else:
                 return code
-        if not isinstance(code, np.ndarray) \
-           or code.dtype not in (np.uint8, np.uint16, np.uint32, np.uint64):
-                code = np.array(code, dtype=np.uint64)
+        if not isinstance(code, np.ndarray) or code.dtype not in (
+            np.uint8,
+            np.uint16,
+            np.uint32,
+            np.uint64,
+        ):
+            code = np.array(code, dtype=np.uint64)
         if self._necessary_mapping:
             mapped_code = np.empty(len(code), dtype=self._mapper.dtype)
-            map_sequence_code(
-                self._mapper,
-                code,
-                mapped_code
-            )
+            map_sequence_code(self._mapper, code, mapped_code)
             return mapped_code
         else:
             return code
 
-
     @staticmethod
     def _dtype(alphabet_size):
-        _size_uint8  = np.iinfo(np.uint8 ).max +1
-        _size_uint16 = np.iinfo(np.uint16).max +1
-        _size_uint32 = np.iinfo(np.uint32).max +1
+        _size_uint8 = np.iinfo(np.uint8).max + 1
+        _size_uint16 = np.iinfo(np.uint16).max + 1
+        _size_uint32 = np.iinfo(np.uint32).max + 1
         if alphabet_size <= _size_uint8:
             return np.uint8
         elif alphabet_size <= _size_uint16:
@@ -535,6 +520,7 @@ class AlphabetError(Exception):
     This exception is raised, when a code or a symbol is not in an
     :class:`Alphabet`.
     """
+
     pass
 
 
@@ -563,4 +549,4 @@ def common_alphabet(alphabets):
                 common_alphabet = alphabet
             else:
                 return None
-    return common_alphabet
+    return common_alphabet

biotite/sequence/annotation.py

@@ -6,17 +6,15 @@ __name__ = "biotite.sequence"
 __author__ = "Patrick Kunzmann"
 __all__ = ["Location", "Feature", "Annotation", "AnnotatedSequence"]
 
-import numbers
 import copy
+import numbers
 import sys
-from enum import Flag, Enum, auto
+from enum import Enum, Flag, auto
 import numpy as np
-from .sequence import Sequence
-from ..copyable import Copyable
-from .seqtypes import NucleotideSequence
+from biotite.copyable import Copyable
 
 
-class Location():
+class Location:
     """
     A :class:`Location` defines at which base(s)/residue(s) a feature is
     located.
@@ -63,24 +61,25 @@ class Location():
            - **BETWEEN** - The position is between to consecutive
              bases/residues.
         """
-        NONE         = 0
-        MISS_LEFT    = auto()
-        MISS_RIGHT   = auto()
-        BEYOND_LEFT  = auto()
+
+        NONE = 0
+        MISS_LEFT = auto()
+        MISS_RIGHT = auto()
+        BEYOND_LEFT = auto()
         BEYOND_RIGHT = auto()
-        UNK_LOC      = auto()
-        BETWEEN      = auto()
+        UNK_LOC = auto()
+        BETWEEN = auto()
 
     class Strand(Enum):
         """
         This enum type describes the strand of the feature location.
         This is not relevant for protein sequence features.
         """
+
         FORWARD = auto()
         REVERSE = auto()
 
-    def __init__(self, first, last, strand=Strand.FORWARD,
-                 defect=Defect.NONE):
+    def __init__(self, first, last, strand=Strand.FORWARD, defect=Defect.NONE):
         if first > last:
             raise ValueError(
                 "The first position cannot be higher than the last position"
@@ -92,8 +91,10 @@ class Location():
 
     def __repr__(self):
         """Represent Location as a string for debugging."""
-        return f'Location({self._first}, {self._last}, strand={"Location." + str(self._strand)}, ' \
-               f'defect={"Location." + str(self._defect)})'
+        return (
+            f'Location({self._first}, {self._last}, strand={"Location." + str(self._strand)}, '
+            f'defect={"Location." + str(self._defect)})'
+        )
 
     @property
     def first(self):
@@ -122,10 +123,12 @@ class Location():
     def __eq__(self, item):
         if not isinstance(item, Location):
             return False
-        return (    self.first  == item.first
-                and self.last   == item.last
-                and self.strand == item.strand
-                and self.defect == item.defect)
+        return (
+            self.first == item.first
+            and self.last == item.last
+            and self.strand == item.strand
+            and self.defect == item.defect
+        )
 
     def __hash__(self):
         return hash((self._first, self._last, self._strand, self._defect))
@@ -208,9 +211,11 @@ class Feature(Copyable):
     def __eq__(self, item):
         if not isinstance(item, Feature):
             return False
-        return (    self._key  == item._key
-                and self._locs == item._locs
-                and self._qual == item._qual)
+        return (
+            self._key == item._key
+            and self._locs == item._locs
+            and self._qual == item._qual
+        )
 
     def __lt__(self, item):
         if not isinstance(item, Feature):
@@ -223,7 +228,7 @@ class Feature(Copyable):
             return True
         elif first > it_first:
             return False
-        else: # First is equal
+        else:  # First is equal
             return last > it_last
 
     def __gt__(self, item):
@@ -237,7 +242,7 @@ class Feature(Copyable):
             return True
         elif first < it_first:
             return False
-        else: # First is equal
+        else:  # First is equal
             return last < it_last
 
     @property
@@ -253,7 +258,7 @@ class Feature(Copyable):
         return copy.copy(self._qual)
 
     def __hash__(self):
-        return hash(( self._key, self._locs, frozenset(self._qual.items()) ))
+        return hash((self._key, self._locs, frozenset(self._qual.items())))
 
 
 class Annotation(Copyable):
@@ -337,7 +342,7 @@ class Annotation(Copyable):
     ...     gene = f.qual["gene"]
     ...     loc_str = "".join([f"{loc}    {loc.defect}" for loc in f.locs])
     ...     print(gene, loc_str)
-    test5 40-149 >    Defect.MISS_RIGHT|MISS_LEFT
+    test5 40-149 >    Defect.MISS_LEFT|MISS_RIGHT
     test2 40-50 >    Defect.MISS_LEFT
     test3 100-130 >    Defect.NONE
     """
@@ -350,7 +355,9 @@ class Annotation(Copyable):
 
     def __repr__(self):
         """Represent Annotation as a string for debugging."""
-        return f'Annotation([{", ".join([feat.__repr__() for feat in self._features])}])'
+        return (
+            f'Annotation([{", ".join([feat.__repr__() for feat in self._features])}])'
+        )
 
     def __copy_create__(self):
         return Annotation(self._features)
@@ -403,7 +410,7 @@ class Annotation(Copyable):
                 if loc.last > last:
                     last = loc.last
         # Exclusive stop -> +1
-        return first, last+1
+        return first, last + 1
 
     def del_feature(self, feature):
         """
@@ -475,9 +482,7 @@ class Annotation(Copyable):
                         if loc.last > i_last:
                             defect |= Location.Defect.MISS_RIGHT
                             last = i_last
-                        locs_in_scope.append(Location(
-                            first, last, loc.strand, defect
-                        ))
+                        locs_in_scope.append(Location(first, last, loc.strand, defect))
                 if len(locs_in_scope) > 0:
                     # The feature is present in the new annotation
                     # if any of the original locations is in the new
@@ -488,15 +493,12 @@ class Annotation(Copyable):
                     sub_annot.add_feature(new_feature)
             return sub_annot
         else:
-            raise TypeError(
-                f"'{type(index).__name__}' instances are invalid indices"
-            )
+            raise TypeError(f"'{type(index).__name__}' instances are invalid indices")
 
     def __delitem__(self, item):
         if not isinstance(item, Feature):
             raise TypeError(
-                f"Only 'Feature' objects are supported, "
-                f"not {type(item).__name__}"
+                f"Only 'Feature' objects are supported, " f"not {type(item).__name__}"
             )
         self.del_feature(item)
 
@@ -626,8 +628,10 @@ class AnnotatedSequence(Copyable):
 
     def __repr__(self):
         """Represent AnnotatedSequence as a string for debugging."""
-        return f'AnnotatedSequence({self._annotation.__repr__()}, {self._sequence.__repr__()}, ' \
-               f'sequence_start={self._seqstart})'
+        return (
+            f"AnnotatedSequence({self._annotation.__repr__()}, {self._sequence.__repr__()}, "
+            f"sequence_start={self._seqstart})"
+        )
 
     @property
     def sequence_start(self):
@@ -643,7 +647,8 @@ class AnnotatedSequence(Copyable):
 
     def __copy_create__(self):
         return AnnotatedSequence(
-            self._annotation.copy(), self._sequence.copy, self._seqstart)
+            self._annotation.copy(), self._sequence.copy, self._seqstart
+        )
 
     def reverse_complement(self, sequence_start=1):
         """
@@ -676,10 +681,12 @@ class AnnotatedSequence(Copyable):
                 # (seq_len-1) -> last sequence index
                 # (loc.last-self._seqstart) -> location to index
                 # ... + rev_seqstart -> index to location
-                rev_loc_first \
-                    = (seq_len-1) - (loc.last-self._seqstart) + rev_seqstart
-                rev_loc_last \
-                    = (seq_len-1) - (loc.first-self._seqstart) + rev_seqstart
+                rev_loc_first = (
+                    (seq_len - 1) - (loc.last - self._seqstart) + rev_seqstart
+                )
+                rev_loc_last = (
+                    (seq_len - 1) - (loc.first - self._seqstart) + rev_seqstart
+                )
 
                 if loc.strand == Location.Strand.FORWARD:
                     rev_loc_strand = Location.Strand.REVERSE
@@ -700,17 +707,14 @@ class AnnotatedSequence(Copyable):
                 if loc.defect & Location.Defect.BETWEEN:
                     rev_loc_defect |= Location.Defect.BETWEEN
 
-                rev_locs.append(Location(
-                        rev_loc_first, rev_loc_last,
-                        rev_loc_strand, rev_loc_defect
-                ))
-            rev_features.append(Feature(
-                feature.key, rev_locs, feature.qual
-            ))
+                rev_locs.append(
+                    Location(
+                        rev_loc_first, rev_loc_last, rev_loc_strand, rev_loc_defect
+                    )
+                )
+            rev_features.append(Feature(feature.key, rev_locs, feature.qual))
 
-        return AnnotatedSequence(
-            Annotation(rev_features), rev_sequence, rev_seqstart
-        )
+        return AnnotatedSequence(Annotation(rev_features), rev_sequence, rev_seqstart)
 
     def __getitem__(self, index):
         if isinstance(index, Feature):
@@ -730,24 +734,20 @@ class AnnotatedSequence(Copyable):
                     pass
                 elif strand is None:
                     strand = loc.strand
-                else: # loc.strand != strand
+                else:  # loc.strand != strand
                     raise ValueError(
                         "All locations of the feature must have the same "
                         "strand direction"
                     )
             if strand == Location.Strand.FORWARD:
-                sorted_locs = sorted(
-                    locs, key=lambda loc: loc.first
-                )
+                sorted_locs = sorted(locs, key=lambda loc: loc.first)
             else:
-                sorted_locs = sorted(
-                    locs, key=lambda loc: loc.last, reverse=True
-                )
+                sorted_locs = sorted(locs, key=lambda loc: loc.last, reverse=True)
             # Merge the sequences corresponding to the ordered locations
             for loc in sorted_locs:
                 slice_start = loc.first - self._seqstart
                 # +1 due to exclusive stop
-                slice_stop = loc.last - self._seqstart +1
+                slice_stop = loc.last - self._seqstart + 1
                 add_seq = self._sequence[slice_start:slice_stop]
                 if loc.strand == Location.Strand.REVERSE:
                     add_seq = add_seq.reverse().complement()
@@ -775,17 +775,17 @@ class AnnotatedSequence(Copyable):
                 rel_seq_start = self._seqstart
             else:
                 rel_seq_start = index.start
-            return AnnotatedSequence(self._annotation[index],
-                                     self._sequence[seq_start:seq_stop],
-                                     rel_seq_start)
+            return AnnotatedSequence(
+                self._annotation[index],
+                self._sequence[seq_start:seq_stop],
+                rel_seq_start,
+            )
 
         elif isinstance(index, numbers.Integral):
             return self._sequence[index - self._seqstart]
 
         else:
-            raise TypeError(
-                f"'{type(index).__name__}' instances are invalid indices"
-            )
+            raise TypeError(f"'{type(index).__name__}' instances are invalid indices")
 
     def __setitem__(self, index, item):
         if isinstance(index, Feature):
@@ -796,10 +796,11 @@ class AnnotatedSequence(Copyable):
             for loc in index.locs:
                 slice_start = loc.first - self._seqstart
                 # +1 due to exclusive stop
-                slice_stop = loc.last - self._seqstart +1
+                slice_stop = loc.last - self._seqstart + 1
                 interval_size = slice_stop - slice_start
-                self._sequence[slice_start:slice_stop] \
-                    = sub_seq[sub_seq_i : sub_seq_i + interval_size]
+                self._sequence[slice_start:slice_stop] = sub_seq[
+                    sub_seq_i : sub_seq_i + interval_size
+                ]
                 sub_seq_i += interval_size
         elif isinstance(index, slice):
             # Sequence start correction
@@ -817,13 +818,13 @@ class AnnotatedSequence(Copyable):
             # Item is a symbol
             self._sequence[index - self._seqstart] = item
         else:
-            raise TypeError(
-                f"'{type(index).__name__}' instances are invalid indices"
-            )
+            raise TypeError(f"'{type(index).__name__}' instances are invalid indices")
 
     def __eq__(self, item):
         if not isinstance(item, AnnotatedSequence):
             return False
-        return (    self.annotation == item.annotation
-                and self.sequence   == item.sequence
-                and self._seqstart  == item._seqstart)
+        return (
+            self.annotation == item.annotation
+            and self.sequence == item.sequence
+            and self._seqstart == item._seqstart
+        )