biotite 1.1.0__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

biotite/sequence/__init__.py

@@ -0,0 +1,84 @@
+# 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.
+
+"""
+A subpackage for handling sequences.
+
+A :class:`Sequence` can be seen as a succession of symbols.
+The set of symbols, that can occur in a sequence, is defined by an
+:class:`Alphabet`.
+For example, an unambiguous DNA sequence has an :class:`Alphabet`, that
+includes the 4 letters (strings) ``'A'``, ``'C'``, ``'G'`` and ``'T'``.
+But furthermore, an :class:`Alphabet` can also contain any immutable and
+hashable Python object like :class:`int`, :class:`tuple`, etc.
+If a :class:`Sequence` is created with at least a symbol,
+that is not in the given :class:`Alphabet`, an :class:`AlphabetError` is
+raised.
+
+Internally, a :class:`Sequence` is saved as a *NumPy* :class:`ndarray`
+of integer values, where each integer represents a symbol in the
+:class:`Alphabet`.
+For example, ``'A'``, ``'C'``, ``'G'`` and ``'T'`` would be encoded into
+0, 1, 2 and 3, respectively.
+These integer values are called *symbol code*, the encoding of an entire
+sequence of symbols is called *sequence code*.
+
+.. figure:: /static/assets/figures/symbol_encoding.png
+    :alt: Symbol encoding in Biotite
+    :scale: 50%
+
+    Taken from
+    `Kunzmann & Hamacher 2018 <https://doi.org/10.1186/s12859-018-2367-z>`_
+    licensed under `CC BY 4.0 <https://creativecommons.org/licenses/by/4.0/>`_.
+
+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, between 257 and 65536 symbols, two bytes are used,
+and so on.
+
+This approach has multiple advantages:
+
+    - Wider spectrum of what kind of objects can be represented by
+      :class:`Sequence` objects
+    - Efficient memory usage and faster calculations due to
+      alphabet-tailored *symbol code* type size
+    - C-acceleration due to usage of :class:`ndarray` objects
+    - Most functions applied on :class:`Sequence` objects are
+      indifferent to the actual type of sequence.
+    - Symbol codes are directly indices for substitution matrices in
+      alignments
+    - *k-mers* can be computed fast
+
+The abstract :class:`Sequence` superclass cannot be instantiated
+directly, as it does not define an :class:`Alphabet` by itself.
+Instead usually the concrete subclasses :class:`NucleotideSequence`
+(for DNA and RNA sequences) and :class:`ProteinSequence`
+(for amino acid sequences) are used.
+These classes have defined alphabets and provide additional sequence
+type specific methods.
+The class :class:`GeneralSequence` allows the usage of a custom
+:class:`Alphabet` without the need to subclass :class:`Sequence`.
+
+Additionally, this subpackage provides support for sequence features,
+as used in e.g. GenBank or GFF files.
+A :class:`Feature` stores its key name, its qualifiers and locations.
+An :class:`Annotation` is a group of multiple :class:`Feature` objects
+and offers convenient location based indexing.
+An :class:`AnnotatedSequence` combines an :class:`Annotation` and a
+:class:`Sequence`.
+
+Sequence profiles can be created with the :class:`SequenceProfile` class.
+"""
+
+__name__ = "biotite.sequence"
+__author__ = "Patrick Kunzmann"
+
+from .alphabet import *
+from .annotation import *
+from .codon import *
+from .profile import *
+from .search import *
+from .seqtypes import *
+from .sequence import *

biotite/sequence/align/__init__.py

@@ -0,0 +1,203 @@
+# 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 provides functionality for sequence alignments.
+
+The two central classes involved are :class:`SubstitutionMatrix` and
+:class:`Alignment`:
+
+Every function that performs an alignment requires a
+:class:`SubstitutionMatrix` that provides similarity scores for each
+symbol combination of two alphabets (usually both alphabets are equal).
+The alphabets in the :class:`SubstitutionMatrix` must match or extend
+the alphabets of the sequences to be aligned.
+
+An alignment cannot be directly represented as list of :class:`Sequence`
+objects, since a gap indicates the absence of any symbol.
+Instead, the aligning functions return one or more :class:`Alignment`
+instances.
+These objects contain the original sequences and a trace, that describe
+which positions (indices) in the sequences are aligned.
+Optionally they also contain the similarity score.
+
+The aligning functions :func:`align_optimal()` and
+:func:`align_multiple()` cover most use cases for pairwise and multiple
+sequence alignments respectively.
+
+However, *Biotite* provides also a modular system to build performant
+heuristic alignment search methods, e.g. for finding homologies in a sequence
+database or map reads to a genome.
+The table below summarizes those provided functionalities.
+The typical stages in alignment search, where those functionalities are used,
+are arranged from top to bottom.
+
+.. grid::
+    :gutter: 0
+    :class-container: sd-text-center
+
+    .. grid-item::
+        :padding: 2
+        :outline:
+        :columns: 3
+
+        **Entire k-mer set**
+
+    .. grid-item::
+        :padding: 2
+        :outline:
+        :columns: 9
+
+        .. grid::
+            :margin: 0
+
+            .. grid-item::
+                :padding: 2
+                :columns: 12
+
+                **k-mer subset selection**
+
+            .. grid-item::
+                :padding: 2
+                :columns: 4
+
+                Minimizers
+
+                :class:`MinimizerSelector`
+
+            .. grid-item::
+                :padding: 2
+                :columns: 4
+
+                Syncmers
+
+                :class:`SyncmerSelector`
+
+                :class:`CachedSyncmerSelector`
+
+            .. grid-item::
+                :padding: 2
+                :columns: 4
+
+                Mincode
+
+                :class:`MincodeSelector`
+
+
+    .. grid-item::
+        :padding: 2
+        :outline:
+        :columns: 12
+
+        .. grid::
+            :margin: 0
+
+            .. grid-item::
+                :padding: 2
+                :columns: 12
+
+                **k-mer indexing and matching**
+
+            .. grid-item::
+                :padding: 2
+                :columns: 6
+
+                Perfect hashing
+
+                :class:`KmerTable`
+
+            .. grid-item::
+                :padding: 2
+                :columns: 6
+
+                Space-efficient hashing
+
+                :class:`BucketKmerTable`
+
+                :func:`bucket_number()`
+
+
+    .. grid-item::
+        :padding: 2
+        :outline:
+        :columns: 12
+
+        .. grid::
+            :margin: 0
+
+            .. grid-item::
+                :padding: 2
+                :columns: 12
+
+                **Ungapped seed extension**
+
+                :class:`align_local_ungapped()`
+
+
+    .. grid-item::
+        :padding: 2
+        :outline:
+        :columns: 12
+
+        .. grid::
+            :margin: 0
+
+            .. grid-item::
+                :padding: 2
+                :columns: 12
+
+                **Gapped alignment**
+
+            .. grid-item::
+                :padding: 2
+                :columns: 6
+
+                Banded local/semiglobal alignment
+
+                :class:`align_banded()`
+
+            .. grid-item::
+                :padding: 2
+                :columns: 6
+
+                Local alignment (*X-drop*)
+
+                :class:`align_local_gapped()`
+
+    .. grid-item::
+        :padding: 2
+        :outline:
+        :columns: 12
+
+        .. grid::
+            :margin: 0
+
+            .. grid-item::
+                :padding: 2
+                :columns: 12
+
+                **Significance evaluation**
+
+                :class:`EValueEstimator`
+
+"""
+
+__name__ = "biotite.sequence.align"
+__author__ = "Patrick Kunzmann"
+
+from .alignment import *
+from .banded import *
+from .buckets import *
+from .cigar import *
+from .kmeralphabet import *
+from .kmersimilarity import *
+from .kmertable import *
+from .localgapped import *
+from .localungapped import *
+from .matrix import *
+from .multiple import *
+from .pairwise import *
+from .permutation import *
+from .selector import *
+from .statistics import *