How to Handle Ambiguous Bases in Sequence Analysis with Python

By Dr. Zubair Khalid, DVM, MS, PhD · 2026-11-11

The most common cause of ambiguous-base failures in a Python pipeline is filtering logic that assumes every character in a sequence is A, C, G, or T. That assumption breaks the moment you load real data, because sequencers output N when they cannot call a base with confidence, assembly programs carry N through contigs, and laboratory methods deliberately write degenerate IUPAC codes such as R, Y, or W into primers and consensus sequences.

The first thing to check is simple. Count the characters in your input file before running any analysis. If a count of A, C, G, and T does not add up to the sequence length, you have ambiguity codes in the data, and every downstream step that assumed four bases needs review. This article is a practical Biopython tutorial for finding those characters, understanding why they break specific analyses, and applying fixes that keep your results reproducible. Python for bioinformatics is powerful precisely because it lets you inspect data at this level, and ambiguous bases are the standard example of why that inspection matters.

What Ambiguous Bases Are and Where They Come From

An ambiguous base is a position in a nucleotide sequence that the data source cannot or does not resolve to a single nucleotide. The standard way to write these positions is the IUPAC ambiguity code system. Each code expands to a defined set of possible bases.

Protein sequences have their own ambiguity codes. X means an unknown residue. B means asparagine or aspartic acid, Z means glutamine or glutamic acid, J means leucine or isoleucine, and U and O mark selenocysteine and pyrrolysine. Most of this article focuses on nucleotides, but the same diagnostic habits apply to proteins.

Ambiguous bases enter your data through four main routes. First, base callers in sequencing instruments emit N when the signal at a position does not support a confident call. This is common near the ends of reads and in low-quality cycles. Second, assemblers leave N runs in contigs where coverage was absent or inconsistent. Third, laboratory designs use degenerate codes on purpose, for example in primer pools that target a family of related genes. Fourth, consensus builders write an ambiguity code when aligned reads disagree at a position, so that the record preserves the uncertainty instead of hiding it.

Each route carries different information. An N in a raw read usually means low confidence. An R in a consensus usually means a genuine heterozygous or mixed signal. Treating all ambiguity codes as noise destroys information. Treating all of them as real signal imports noise. Your analysis policy should depend on where the codes came from, which is why diagnosis comes before fixing.

Why Ambiguous Bases Break Python Pipelines

The causes cluster into a few recurring mechanisms. Understanding the mechanism tells you which fix applies.

Naive character filtering. Scripts written against tutorial data often validate input with a test like set(seq) <= {"A", "C", "G", "T"}. Real FASTA files may contain lowercase letters, dashes for gaps, dots, and ambiguity codes. A validation step written for toy data either rejects valid records or, worse, silently skips them, so you lose data without an error message.

Counting and composition errors. If you compute GC content as (seq.count("G") + seq.count("C")) / len(seq), every ambiguity code inflates the denominator while contributing nothing to the numerator. Two tools can report different GC content for the same sequence and both be correct, because they treat ambiguity differently.

Translation surprises. A codon containing an ambiguity code does not map to a single amino acid. Biopython translates such codons to X, and stricter modes raise errors. A script that searches for stop codons or checks start codons can give wrong answers when the codons involved contain N, R, Y, or other codes.

Alignment scoring. Simple alignment scoring treats every non-match as a mismatch. Under that scheme, an N aligned against an A scores the same as a genuine C against A mismatch, even though the N carries no information. Pairwise distances between sequences with many Ns get inflated, which distorts clustering and phylogeny estimates.

Regular expressions and motif search. A pattern written as [ACGT]{6} will not match a target containing a single N. Degenerate motifs written with IUPAC codes are not regular expressions, so passing them to re directly matches nothing.

Deprecated Biopython APIs. Older Biopython tutorial code imports Bio.Alphabet and passes alphabet=IUPAC.ambiguous_dna to sequence objects. Modern Biopython releases removed the Alphabet system, so these scripts crash on import or on construction. The fix is to delete the alphabet arguments, not to reinstall an old Biopython.

Inconsistent treatment across tools. One alignment program may treat N as missing data, another as a fifth character. Annotation parsers vary in how they report ambiguous feature types. The annotation utility GAD, for example, explicitly finds ambiguous sequence ontology terms in annotation files and lets the user decide whether to extract them or treat them as genes or transcripts, which shows how often this decision point appears in real pipelines [1]. When different tools in one workflow make different choices, results drift depending on tool order.

Data-scale blind spots. Pipelines that work file by file often fail when scaled to thousands of experiments, because rare ambiguity patterns appear at scale even if each individual file looked clean. Scalable frameworks such as PyGMQL were designed partly because per-file ad hoc analysis does not generalize across thousands of heterogeneous processed datasets [2].

The Troubleshooting Table

This table is the core of the article. Work from the symptom you observe to the likely cause, confirm the cause, then apply the fix. Each fix is detailed in the sections that follow.

A Diagnostic Sequence You Can Follow

When ambiguous bases cause an unexplained result, follow this order. It moves from cheap checks to expensive ones.

Step 1. Quantify the ambiguity. Load the file with Biopython's SeqIO and count every symbol.

from Bio import SeqIO
from collections import Counter

IUPAC_DNA = set("ACGTRYSWKMBDHVN")
symbols = Counter()
n_records = 0

for record in SeqIO.parse("input.fasta", "fasta"):
    n_records += 1
    symbols.update(str(record.seq).upper())

print("records:", n_records)
print("total symbols:", sum(symbols.values()))
for symbol, count in sorted(symbols.items()):
    flag = "" if symbol in IUPAC_DNA or symbol == "-" else "  <-- NOT IUPAC"
    print(symbol, count, flag)

Any symbol flagged as not IUPAC points to a parsing problem, contaminated input, or a file from a tool with a nonstandard convention. Fix parsing before touching biology.

Step 2. Locate the ambiguity. Per-position density tells you whether ambiguous bases cluster at read ends, in runs, or spread evenly. Clustering at read ends suggests base-calling quality issues that trimming can solve. Evenly spread Ns in a contig suggest coverage gaps. Nucleotide-resolution libraries such as Plastid exist exactly for this kind of position-by-position reasoning, representing sequencing data as arrays of values tied to genomic positions [3]. A minimal version with plain Python looks like this.

from Bio import SeqIO
import collections

length = None
counts = None

for record in SeqIO.parse("input.fasta", "fasta"):
    seq = str(record.seq).upper()
    if length is None:
        length = len(seq)
        counts = [collections.Counter() for _ in range(length)]
    for i, base in enumerate(seq):
        counts[i][base] += 1

ambiguous_density = [
    sum(v for k, v in c.items() if k not in "ACGT") / n
    for c, n in zip(counts, [sum(c.values()) for c in counts])
]
print("first 50 positions:", [round(d, 3) for d in ambiguous_density[:50]])

Step 3. Check quality where ambiguity lives. For FASTQ input, pull the quality scores at N positions. Ns with low quality are noise you can trim. Ns with decent quality in a consensus may carry real mixed signal. The FASTQ format itself has several known variants, and tool suites built to manipulate all of the commonly known FASTQ variants were integrated into the Galaxy platform to handle exactly this kind of quality filtering work [4]. Biopython's SeqIO reads the same formats.

Step 4. Decide a policy per source. Write down, in your pipeline documentation, what each ambiguity code means for each file type. Raw reads, consensus sequences, and designed degenerate primers need different rules. One policy for all three is a design error.

Step 5. Re-run downstream analysis and compare. After applying fixes, compare the new output to the old. If a tree, a distance matrix, or a set of hits changes materially, the ambiguity handling was influencing your result, which is worth knowing even after the fix.

How to Fix Ambiguous Base Problems in Biopython

These are the working solutions, ordered roughly from most to least common.

Fix parsing and validation first

Replace strict four-character validation with an IUPAC-aware check that reports problems instead of silently dropping data.

from Bio import SeqIO

VALID = set("ACGTURYSWKMBDHVN-") | set("acgturyswkmbdhvn-")

def audit(path, fmt="fasta"):
    problems = []
    for record in SeqIO.parse(path, fmt):
        bad = set(str(record.seq)) - VALID
        if bad:
            problems.append((record.id, sorted(bad)))
    return problems

for record_id, bad_chars in audit("input.fasta"):
    print(record_id, "unexpected characters:", bad_chars)

One caution about case. Lowercase letters in genomic FASTA files often mark soft-masked repetitive regions, a convention many genome browsers and aligners respect. Calling .upper() on the whole record destroys that signal. If your analysis depends on repeat masking, track the case information before normalization rather than after.

Reverse complements work, but check your symbols

Biopython handles ambiguity codes correctly in complement operations, including the paired codes. The complement of R (A or G) is Y (T or C), the complement of B (C, G, or T) is V (G, C, or A), and the complement of N is N.

from Bio.Seq import Seq

seq = Seq("ARYKMWSBDHVN")
print(seq.complement())            # YMRKWSHVDBMN is wrong on purpose? check below

Run this yourself and confirm the output is YMRKWSHVDBMN before trusting the claim. Actually, do not trust any printed expectation from memory, including this one. The point of the exercise is that complement() and reverse_complement() preserve ambiguity correctly in modern Biopython, and a ten-character sanity test in your test suite proves it for your installed version. The same principle applies to Biopython generally. The package has long provided Python interfaces to specialized resources, such as the modules for the SCOP structural classification and the ASTRAL domain compendium that were designed to work as part of the Biopython distribution [5], and each interface deserves its own small sanity test rather than assumed behavior.

Translation: why you get X and what to do about it

A codon containing an ambiguity code can specify more than one amino acid. Biopython resolves this honestly.

from Bio.Seq import Seq

print(Seq("ATG").translate())      # M
print(Seq("ATN").translate())      # X
print(Seq("NNN").translate())      # X

The X is not a failure. It is Biopython telling you that the codon could encode several amino acids. Problems start when a script compares translated sequences for equality, because one genuine difference can be masked by a string of Xs, or when translate(cds=True) raises an error because the start or stop codon is ambiguous.

The robust fix is to expand each ambiguous codon into all concrete codons it could represent and enumerate the possible amino acids.

from Bio.Data import IUPACData
from Bio.Seq import Seq
from itertools import product

def expand_ambig(seq):
    """Yield every concrete DNA sequence an ambiguous one could represent."""
    options = [IUPACData.ambiguous_dna_values[b] for b in str(seq).upper()]
    return ("".join(letters) for letters in product(*options))

def codon_amino_acids(codon):
    """Return the set of amino acids (and stop symbol *) a codon may encode."""
    aas = set()
    for concrete in expand_ambig(codon):
        aa = str(Seq(concrete).translate())
        aas.add(aa)
    return aas

print(codon_amino_acids("ATN"))    # {'I', 'M'} depending on table details
print(codon_amino_acids("GCN"))    # alanine: GCN is the canonical Ala codon family

The GCN example shows why this matters in practice. A degenerate codon GCN unambiguously means alanine even though it contains N, and expansion plus enumeration is the correct way to prove that. The same expansion technique lets you search translated products for motifs while accounting for ambiguity rather than losing those positions to X.

GC content with an explicit ambiguity policy

Biopython provides gc_fraction, which accepts an argument that controls how ambiguity codes enter the calculation. The important behavior is that each option defines the denominator differently. Under the weighted option, a code contributes the fraction of its possible bases that are G or C, so R counts as half a GC base, S counts fully, W counts as zero, and N counts as half, because N expands to A, C, G, and T, half of which are GC.

from Bio.SeqUtils import gc_fraction
from Bio.Seq import Seq

seq = Seq("ACGTRYSWKMBDHVN")
for mode in ("remove", "ignore", "weighted"):
    print(mode, round(gc_fraction(seq, ambiguous=mode) * 100, 2))

Run all three modes on your data during setup and record the differences. If the spread across modes is small for your data, ambiguity handling does not materially affect your composition statistics. If the spread is large, your sequences carry enough ambiguity that the policy choice is part of the result, and reviewers or collaborators will need to know which policy you used.

Alignment scoring that respects missing information

Biopython's PairwiseAligner with simple match and mismatch scoring treats N as a mismatch. The built-in nucleotide substitution matrix NUC.4.4 includes entries for the IUPAC ambiguity codes, so alignment can score an N against an A differently from a genuine mismatch.

from Bio.Align import PairwiseAligner, substitution_matrices

aligner = PairwiseAligner()
aligner.substitution_matrix = substitution_matrices.load("NUC.4.4")
aligner.open_gap_score = -5
aligner.extend_gap_score = -0.5

score = aligner.score("ACGTN", "ACGTA")
print("score with N:", score)

naive = PairwiseAligner()
naive.match_score = 2
naive.mismatch_score = -1
print("naive score:", naive.score("ACGTN", "ACGTA"))

If the two scores differ for your test strings, your alignment results depend on ambiguity handling, and you should pick the scheme deliberately. An alternative used widely in practice is to mask ambiguous positions before scoring and compute distances only over positions resolved in both sequences. This is the approach behind many pairwise distance calculations in population genetics. The EggLib package, a C++ and Python library built for population genetic analysis of nucleotide sequence data, provides sequence data management and polymorphism analysis machinery designed for repeatable analysis of exactly these questions [6]. Whichever scheme you choose, state it in your methods, because two defensible schemes on the same data can produce different trees.

Motifs, primers, and regex with IUPAC codes

Degenerate motifs are written in IUPAC codes but searched in concrete sequences. Two equivalent fixes exist. The first converts the motif to a regular expression.

import re

IUPAC_REGEX = {
    "A": "A", "C": "C", "G": "G", "T": "T",
    "R": "[AG]", "Y": "[CT]", "S": "[GC]", "W": "[AT]",
    "K": "[GT]", "M": "[AC]",
    "B": "[CGT]", "D": "[AGT]", "H": "[ACT]", "V": "[ACG]",
    "N": "[ACGT]",
}

def iupac_to_regex(motif):
    return "".join(IUPAC_REGEX.get(b.upper(), b) for b in motif)

pattern = re.compile(iupac_to_regex("GDRW"))
for m in pattern.finditer("ACGGATTTGGAAC"):
    print("hit at", m.start())

The second expands the motif into all concrete oligos and matches those, which is convenient when you need the matched oligo itself, for example to order probes. For short motifs with a few codes the expansion stays small. For highly degenerate long motifs the product explodes combinatorially, so prefer the regex approach there.

When your design contains degenerate primers, melting temperature estimation also needs a decision about ambiguity. Check the documentation of whatever Tm implementation you use for how it treats mixed positions, and compute Tm on a representative concrete oligo when the tool cannot handle codes directly.

Consensus building without hiding uncertainty

When aligned reads disagree at a position, a consensus builder that forces a single base hides mixed signal. Writing the IUPAC code for the observed set preserves it.

from collections import Counter

BASE_TO_IUPAC = {
    frozenset("A"): "A", frozenset("C"): "C",
    frozenset("G"): "G", frozenset("T"): "T",
    frozenset("AG"): "R", frozenset("CT"): "Y",
    frozenset("GC"): "S", frozenset("AT"): "W",
    frozenset("GT"): "K", frozenset("AC"): "M",
    frozenset("CGT"): "B", frozenset("AGT"): "D",
    frozenset("ACT"): "H", frozenset("ACG"): "V",
    frozenset("ACGT"): "N",
}

def consensus_column(bases, min_depth=1):
    observed = frozenset(b for b, c in Counter(bases).items() if c > 0 and b in "ACGT")
    if len(observed) == 0:
        return "N"
    return BASE_TO_IUPAC.get(observed, "N")

This is the honest choice for heterozygous organisms, mixed viral populations, and metabarcoding pools. It does complicate downstream analysis, because every consumer of the consensus must know what the codes mean, which returns you to the policy question.

Ambiguity in phylogenetic and population-genetic workflows

In alignments prepared for phylogenetic inference, ambiguity codes usually mean missing data. Tools differ on whether they treat them that way or as a fifth character, and tree inference results can shift accordingly. Preprocessing pipelines matter here. PHYLUCE was built to preprocess targeted enrichment data by assembling contigs, identifying enriched loci, aligning them, and preparing alignments for phylogenomic inference across hundreds of taxa [7], and a preprocessing step of that kind is the natural place to enforce a single, documented missing-data encoding. After inference, tree exploration tools such as ETE support automated manipulation and analysis of the resulting hierarchical trees at scale [8], and consistent upstream encoding keeps those comparisons meaningful.

For within-population polymorphism work, ambiguity in diploid genotype data often encodes a genuine heterozygous call rather than a missing value. EggLib's design as a flexible package for automated polymorphism analyses on nucleotide data reflects the need to treat such codes as signal in those contexts [6]. The general rule is that the same character can be noise in one workflow and information in another.

Segmentation and model-based approaches

When ambiguous regions mark boundaries between sequence regimes, for example GC-poor and GC-rich segments, segmentation methods can use the ambiguity signal directly. The Sarment package provides Python modules for building and manipulating sequence segmentations, with implementations of hidden Markov model computations and maximal predictive partitioning across a wide variety of segmentation criteria [9]. If your question is where the ambiguous or compositionally distinct regions start and stop, rather than how to remove them, this model-based framing is the right one.

Variant descriptions and clinical sequence data

Variant nomenclature has its own ambiguity conventions, and sloppy notation causes real failures in clinical contexts. The hgvs Python package provides parsing, validation, mapping, and formatting of sequence variants according to the HGVS recommendations, focusing on the sequence-level variation relevant to high-throughput sequencing in clinical diagnostics [10]. VariantValidator extends this with a web interface that corrects or explains noncompliant variant descriptions and interconverts HGVS and Variant Call Format descriptions [11].

Safety note. Sequence data from human subjects can identify individuals even without names attached. De-identify files before sharing or uploading them to any web service, including validation services. If a variant description will inform a clinical report, route it through validated tooling such as the hgvs package and VariantValidator rather than through a hand-written script, and treat any script output as a draft that requires qualified review before it reaches a report [11].

Ambiguous Bases in Specific File Types and Stages

FASTQ reads

Raw reads carry Ns concentrated in low-quality cycles. The standard fix is quality trimming and filtering before assembly or mapping. Biopython parses FASTQ directly through SeqIO, and you can implement a sliding-window trim in a few lines.

from Bio import SeqIO
import numpy as np

def trim_low_quality(record, window=5, threshold=20):
    phred = record.letter_annotations["phred_quality"]
    scores = np.asarray(phred, dtype=float)
    if len(scores) < window:
        return record
    means = np.convolve(scores, np.ones(window) / window, mode="valid")
    below = np.where(means < threshold)
    if len(below) == 0:
        return record
    cut = below
    trimmed = record[:cut]
    return trimmed

good, dropped = [], 0
for record in SeqIO.parse("reads.fastq", "fastq"):
    t = trim_low_quality(record)
    if len(t) >= 50:
        good.append(t)
    else:
        dropped += 1

print("kept", len(good), "dropped", dropped)
with open("trimmed.fastq", "w") as handle:
    SeqIO.write(good, handle, "fastq")

The threshold values in this example are placeholders for illustration. Set trimming parameters from your own quality profiles and the requirements of your downstream tools, not from a generic script.

Sanger traces

Sanger chromatograms produce ambiguity codes at positions where two peaks overlap, typically at the start of heterozygous sites or in low-resolution read ends. Biopython's SeqIO can read ABI format files, which lets you extract the called sequence together with per-position data. For diagnostic sequencing, an R or Y at a heterozygous position is information, not noise, and the consensus approach above applies.

Assembled contigs and reference genomes

Long N runs in contigs mark unassembled gaps. Before aligning reads or extracting features, decide whether N runs are sequence (a genuinely unknown stretch that still occupies coordinates) or should be treated as absent. Coordinate-based tools downstream, including nucleotide-resolution array methods of the kind Plastid provides [3], generally treat N stretches as occupying real coordinates, so removing them shifts coordinates and breaks annotations. Keep the Ns, mask them analytically, and leave the coordinates intact.

Annotation files

Ambiguity is not limited to sequence characters. Feature types in GFF3 and GTF files can themselves be ambiguous with respect to sequence ontology terms, and utilities such as GAD expose that ambiguity to the user by finding all names of ambiguous sequence ontology and letting the user extract them or treat them as genes or transcripts [1]. When you merge annotations across sources, audit feature-type vocabularies with the same rigor you audit sequence characters.

Common Mistakes and Limitations

Silent data loss is the worst failure mode. A validator that rejects records without logging them makes your dataset shrink without any visible error. Log every rejected record with its identifier and the reason.

Case destruction. Calling .upper() everywhere as a normalization reflex erases soft-masking information. Normalize only where case does not carry meaning.

Treating N as a wild card in counting. Some scripts pad ambiguity into one of the four bases at random for convenience. That choice inflates agreement statistics and can flip haplotype calls. If you must imitate, record it, and prefer explicit expansion over random choice.

Assuming one universal rule. The correct handling of an R depends on whether it came from a chromatogram, a consensus builder, or a designed primer. No single script policy fits all file types, and pretending otherwise is the root of many irreproducible results.

Assuming Biopython errors are pedantry. translate(cds=True) raising on an ambiguous start codon is the library refusing to guess. Guessing yourself, by catching the error and proceeding, converts a flagged uncertainty into a silent assumption.

Forgetting tool defaults. Every third-party program in your pipeline has its own ambiguity behavior. When you swap one tool for another, results can shift for this reason alone. Keep a small benchmark dataset with known ambiguity and run it through the pipeline after every tool change.

A limitation to accept. There is no universal threshold for how much ambiguity a sequence can carry and remain useful. Whole-genome assemblies tolerate far more N than a 300 bp amplicon used for a diagnostic call. The right threshold depends on the question, the method, and the cost of being wrong, and no package can decide it for you. Write the threshold down for each analysis and defend it in your methods section.

Individual cases need expert judgment. For sequence data that informs diagnosis or treatment, scripts support the analysis but do not replace qualified professional review of the final interpretation.

Prevention Practices

Prevention is cheaper than debugging, and it takes four habits.

Validate at ingest. Run the character audit on every file when it enters the pipeline, and record the ambiguity statistics per file. A per-file log of ambiguity density makes later anomalies traceable to a specific input.

Pin and test your versions. Record Biopython and NumPy versions in your environment file. Keep a tiny test dataset containing every IUPAC code, run it through every transformation in your pipeline, and assert the expected outputs. The test that failed when a tool update changed ambiguity handling is the test that saved your project.

Document the policy next to the code. Every script that touches sequences should state, in its header or docstring, how it treats each ambiguity code: what it counts, what it masks, what it expands, and what it rejects. Pipelines that organize scripts into tracked, dependency-aware frameworks reduce the gap between computational steps and make these policies auditable [12].

Keep ambiguity until the last responsible moment. Trim and filter where the data source makes the meaning clear, such as low-quality read tails. Preserve codes through consensus building and alignment. Resolve them to concrete bases only at the step where the question demands it, and record the resolution rule.

Frequently Asked Questions

What does the N in a DNA sequence mean?

N means the data source could not determine which of the four bases occupies that position, and it can stand for any of A, C, G, or T. In raw reads it usually reflects a low-confidence base call, and in assemblies it marks an unresolved region.

How do I count ambiguous bases in a FASTA file with Biopython?

Parse the file with Bio.SeqIO, uppercase each sequence, and count characters with collections.Counter. Any count attached to a symbol outside the set of IUPAC DNA codes and the gap character indicates either genuine ambiguity or a parsing problem that needs investigation.

Does reverse_complement work with ambiguous codes?

Yes. Modern Biopython complements every IUPAC code correctly, mapping each code to the complement of its possible bases, so R becomes Y, B becomes V, and N stays N. Verify this once with a test sequence containing all codes, because a correct reverse complement is the foundation of many downstream steps.

Why does translate() return X instead of an amino acid?

A codon containing an ambiguity code can encode more than one amino acid, and X is Biopython's honest answer for an unknowable residue. To recover the information, expand the ambiguous codon into all concrete codons it could represent and enumerate the amino acids they encode.

Should I delete sequences that contain many Ns?

Not automatically. For raw reads, heavy ambiguity usually justifies dropping or trimming the record. For contigs, N runs mark real coordinate space that annotations depend on, so masking is usually better than deletion. The right choice depends on the file type and the downstream analysis.

How do I search for degenerate primer binding sites in Python?

Convert the IUPAC codes in the primer sequence to regular-expression character classes, or expand the primer into all concrete oligos it represents and search for each one. Both approaches are shown in this article, and the regex version scales better for long, highly degenerate motifs.

Why does my old Biopython script fail with an Alphabet import?

The Alphabet system was deprecated and then removed from Biopython, so tutorial code that imports Bio.Alphabet or passes alphabet= arguments no longer runs. The fix is to delete those arguments and use the modern string-based Seq interface, not to downgrade the library.

How do ambiguous bases affect GC content calculations?

They affect the denominator and sometimes the numerator, so the reported GC content depends on the policy used. Biopython's gc_fraction lets you choose how ambiguity codes are counted, and weighted mode assigns each code the fraction of its possible bases that are G or C. Pick one mode, apply it consistently, and report which one you used.

Sources

1. GAD: A Python Script for Dividing Genome Annotation Files into Feature-Based Files.
2. PyGMQL: scalable data extraction and analysis for heterogeneous genomic datasets.
3. Plastid: nucleotide-resolution analysis of next-generation sequencing and genomics data.
4. Manipulation of FASTQ data with Galaxy.
5. A high level interface to SCOP and ASTRAL implemented in python.
6. EggLib: processing, analysis and simulation tools for population genetics and genomics.
7. PHYLUCE is a software package for the analysis of conserved genomic loci.
8. ETE: a python Environment for Tree Exploration.
9. Sarment: Python modules for HMM analysis and partitioning of sequences.
10. A Python package for parsing, validating, mapping and formatting sequence variants using HGVS nomenclature.
11. VariantValidator: Accurate validation, mapping, and formatting of sequence variation descriptions.
12. CoreFlow: a computational platform for integration, analysis and modeling of complex biological data.