Biotite Documentation

Biotite is a fast Python library for computational molecular biology. It provides a uniform interface for various bioinformatics tasks, allowing developers to focus on unique analysis rather than basic functionality.

Key capabilities include:

• Sequence Analysis: Work with nucleotide, protein, and structural alphabets (like 3Di). Includes rapid, modular alignment tools and Matplotlib-based visualization for alignments and feature maps.
• 3D Structure Exploration: Handle large biomolecules and small molecules using a NumPy-like interface. Supports filtering, transforming, and analyzing structures (e.g., surface area calculation, superimposition) and interfaces with formats like PDB, CIF/BinaryCIF, and MOL/SDF.
• Database Access: Query biological databases such as NCBI Entrez, UniProt, PDB, and PubChem using Pythonic logical operators instead of raw REST APIs.
• Software Integration: Seamlessly interface with external tools for multiple sequence alignment and secondary structure annotation. These interfaces handle file creation and command-line execution internally, allowing you to pass and receive Python objects directly.

Biotite is organized into four primary subpackages, each targeting a specific domain of bioinformatics:

• biotite.sequence: Tools for handling sequence information (nucleotides, proteins, etc.), supporting various file formats, sequence manipulations, and modular sequence alignments.
• biotite.structure: Tools for handling 3D biomolecular structures. Structures are represented using NumPy arrays for atom coordinates and annotations (residue names, elements, charges), enabling high-performance operations on single models or MD trajectories. Supports formats like PDB and BinaryCIF.
• biotite.database: Provides a Pythonic interface to search and download data from biological databases via REST APIs.
• biotite.application: Provides seamless interfaces for external software (e.g., Clustal Omega, NCBI BLAST). These interfaces accept and return Biotite sequence and structure objects, handling file I/O and CLI arguments internally.

If the MSA software supports protein alignment and custom substitution matrices (e.g., MUSCLE and MAFFT), you can align non-standard sequence types (e.g., using a custom Alphabet and GeneralSequence).

Internally, Biotite converts these sequences and the SubstitutionMatrix into a format the software understands, performs the alignment, and then maps the results back to your original sequence type. Note that for custom alphabets that do not use characters as symbols, you may need to print alignment.trace instead of the alignment itself.

import numpy as np
import biotite.application.mafft as mafft
import biotite.sequence as seq
import biotite.sequence.align as align

# Define a custom alphabet and sequences
alphabet = seq.Alphabet(("foo", "bar", 42))
sequences = [seq.GeneralSequence(alphabet, symbols) for symbols in [...]]

# Define a custom substitution matrix
matrix = align.SubstitutionMatrix(
    alphabet, alphabet, np.array([
        [ 100, -100, -100],
        [-100,  100, -100],
        [-100, -100,  100]
    ])
)

# Perform alignment
alignment = mafft.MafftApp.align(sequences, matrix=matrix)
print(alignment.trace)

An AnnotatedSequence combines a Sequence with an Annotation. You can obtain it using gb.get_annotated_sequence(file).

Key Behaviors:

• Slicing: Slicing an AnnotatedSequence applies the index to both the Annotation and the Sequence. The sequence_start property shifts to the start of the slice.
• Feature Indexing: You can index an AnnotatedSequence directly with a Feature object to extract the specific sequence corresponding to that feature (handling multiple locations or reverse strands automatically).

Warning: AnnotatedSequence uses base position indices (e.g., starting at 1), whereas standard Sequence objects use array position indices (starting at 0). Therefore, annot_seq[n:m].sequence may differ from annot_seq.sequence[n:m].

import biotite.sequence.io.genbank as gb

annot_seq = gb.get_annotated_sequence(file)

# 1. Slice by range
sub_seq = annot_seq[100:200]

# 2. Slice by Feature object
cds_feature = next(f for f in annot_seq.annotation if f.key == "CDS")
cds_seq = annot_seq[cds_feature]

The biotite.interface.openmm subpackage provides an interface to the OpenMM molecular simulation toolkit. It allows you to expand Biotite's structural capabilities into molecular dynamics.

Conversion Patterns:

• To OpenMM: Use to_<x>() functions to convert Biotite objects to OpenMM objects (e.g., to_topology(), to_system()).
• From OpenMM: Use from_<x>() functions to convert OpenMM objects back to Biotite objects (e.g., from_topology(), from_system(), from_states()).

Note that when converting from OpenMM states to a Biotite AtomArrayStack, you must provide an AtomArray as a template to define the topology (residues, atoms, and bonds), as the states themselves only contain coordinates and box dimensions.

import biotite.interface.openmm as openmm_interface

# Convert AtomArray to OpenMM Topology
topology = openmm_interface.to_topology(molecule)

# Convert OpenMM Topology back to AtomArray template
template = openmm_interface.from_topology(topology)

# Convert OpenMM states to an AtomArrayStack trajectory using a template
trajectory = openmm_interface.from_states(template, states)