--- /dev/null
+#TODO - Remove this work around once we drop python 2.3 support
+try:
+ set = set
+except NameError:
+ from sets import Set as set
+
+from Bio import Alphabet
+from Bio.Alphabet import IUPAC
+from Bio.Data import IUPACData
+
+unambiguous_dna_by_name = {}
+unambiguous_dna_by_id = {}
+unambiguous_rna_by_name = {}
+unambiguous_rna_by_id = {}
+generic_by_name = {} # unambiguous DNA or RNA
+generic_by_id = {} # unambiguous DNA or RNA
+ambiguous_generic_by_name = {} # ambiguous DNA or RNA
+ambiguous_generic_by_id = {} # ambiguous DNA or RNA
+
+# standard IUPAC unambiguous codons
+standard_dna_table = None
+standard_rna_table = None
+
+# In the future, the back_table could return a statistically
+# appropriate distribution of codons, so do not cache the results of
+# back_table lookups!
+
+class TranslationError(Exception):
+ pass
+
+class CodonTable:
+ nucleotide_alphabet = Alphabet.generic_nucleotide
+ protein_alphabet = Alphabet.generic_protein
+
+ forward_table = {} # only includes codons which actually code
+ back_table = {} # for back translations
+ start_codons = []
+ stop_codons = []
+ # Not always called from derived classes!
+ def __init__(self, nucleotide_alphabet = nucleotide_alphabet,
+ protein_alphabet = protein_alphabet,
+ forward_table = forward_table, back_table = back_table,
+ start_codons = start_codons, stop_codons = stop_codons):
+ self.nucleotide_alphabet = nucleotide_alphabet
+ self.protein_alphabet = protein_alphabet
+ self.forward_table = forward_table
+ self.back_table = back_table
+ self.start_codons = start_codons
+ self.stop_codons = stop_codons
+
+ def __str__(self) :
+ """Returns a simple text representation of the codon table
+
+ e.g.
+ >>> import Bio.Data.CodonTable
+ >>> print Bio.Data.CodonTable.standard_dna_table
+ >>> print Bio.Data.CodonTable.generic_by_id[1]"""
+
+ if self.id :
+ answer = "Table %i" % self.id
+ else :
+ answer = "Table ID unknown"
+ if self.names :
+ answer += " " + ", ".join(filter(None, self.names))
+
+ #Use the main four letters (and the conventional ordering)
+ #even for ambiguous tables
+ letters = self.nucleotide_alphabet.letters
+ if isinstance(self.nucleotide_alphabet, Alphabet.DNAAlphabet) \
+ or (letters is not None and "T" in letters) :
+ letters = "TCAG"
+ else :
+ #Should be either RNA or generic nucleotides,
+ #e.g. Bio.Data.CodonTable.generic_by_id[1]
+ letters = "UCAG"
+
+ #Build the table...
+ answer=answer + "\n\n |" + "|".join( \
+ [" %s " % c2 for c2 in letters] \
+ ) + "|"
+ answer=answer + "\n--+" \
+ + "+".join(["---------" for c2 in letters]) + "+--"
+ for c1 in letters :
+ for c3 in letters :
+ line = c1 + " |"
+ for c2 in letters :
+ codon = c1+c2+c3
+ line = line + " %s" % codon
+ if codon in self.stop_codons :
+ line = line + " Stop|"
+ else :
+ try :
+ amino = self.forward_table[codon]
+ except KeyError :
+ amino = "?"
+ except TranslationError :
+ amino = "?"
+ if codon in self.start_codons :
+ line = line + " %s(s)|" % amino
+ else :
+ line = line + " %s |" % amino
+ line = line + " " + c3
+ answer = answer + "\n"+ line
+ answer=answer + "\n--+" \
+ + "+".join(["---------" for c2 in letters]) + "+--"
+ return answer
+
+def make_back_table(table, default_stop_codon):
+ # ONLY RETURNS A SINGLE CODON
+ # Do the sort so changes in the hash implementation won't affect
+ # the result when one amino acid is coded by more than one codon.
+ back_table = {}
+ keys = table.keys() ; keys.sort()
+ for key in keys:
+ back_table[table[key]] = key
+ back_table[None] = default_stop_codon
+ return back_table
+
+
+class NCBICodonTable(CodonTable):
+ nucleotide_alphabet = Alphabet.generic_nucleotide
+ protein_alphabet = IUPAC.protein
+
+ def __init__(self, id, names, table, start_codons, stop_codons):
+ self.id = id
+ self.names = names
+ self.forward_table = table
+ self.back_table = make_back_table(table, stop_codons[0])
+ self.start_codons = start_codons
+ self.stop_codons = stop_codons
+
+
+class NCBICodonTableDNA(NCBICodonTable):
+ nucleotide_alphabet = IUPAC.unambiguous_dna
+
+class NCBICodonTableRNA(NCBICodonTable):
+ nucleotide_alphabet = IUPAC.unambiguous_rna
+
+
+
+def register_ncbi_table(name, alt_name, id,
+ table, start_codons, stop_codons):
+ names = name.split("; ")
+
+ dna = NCBICodonTableDNA(id, names + [alt_name], table, start_codons,
+ stop_codons)
+ # replace all T's with U's for the RNA tables
+ rna_table = {}
+ generic_table = {}
+ for codon, val in table.items():
+ generic_table[codon] = val
+ codon = codon.replace("T", "U")
+ generic_table[codon] = val
+ rna_table[codon] = val
+ rna_start_codons = []
+ generic_start_codons = []
+ for codon in start_codons:
+ generic_start_codons.append(codon)
+ codon = codon.replace("T", "U")
+ generic_start_codons.append(codon)
+ rna_start_codons.append(codon)
+ rna_stop_codons = []
+ generic_stop_codons = []
+ for codon in stop_codons:
+ generic_stop_codons.append(codon)
+ codon = codon.replace("T", "U")
+ generic_stop_codons.append(codon)
+ rna_stop_codons.append(codon)
+
+ generic = NCBICodonTable(id, names + [alt_name], generic_table,
+ generic_start_codons, generic_stop_codons)
+ rna = NCBICodonTableRNA(id, names + [alt_name], rna_table,
+ rna_start_codons, rna_stop_codons)
+
+ if id == 1:
+ global standard_dna_table, standard_rna_table
+ standard_dna_table = dna
+ standard_rna_table = rna
+
+ unambiguous_dna_by_id[id] = dna
+ unambiguous_rna_by_id[id] = rna
+ generic_by_id[id] = generic
+
+ if alt_name is not None:
+ names.append(alt_name)
+
+ for name in names:
+ unambiguous_dna_by_name[name] = dna
+ unambiguous_rna_by_name[name] = rna
+ generic_by_name[name] = generic
+
+### These tables created from the data file
+### ftp://ncbi.nlm.nih.gov/entrez/misc/data/gc.prt
+### using the following:
+##import re
+##for line in open("gc.prt").readlines():
+## if line[:2] == " {":
+## names = []
+## id = None
+## aa = None
+## start = None
+## bases = []
+## elif line[:6] == " name":
+## names.append(re.search('"([^"]*)"', line).group(1))
+## elif line[:8] == " name":
+## names.append(re.search('"(.*)$', line).group(1))
+## elif line == ' Mitochondrial; Mycoplasma; Spiroplasma" ,\n':
+## names[-1] = names[-1] + " Mitochondrial; Mycoplasma; Spiroplasma"
+## elif line[:4] == " id":
+## id = int(re.search('(\d+)', line).group(1))
+## elif line[:10] == " ncbieaa ":
+## aa = line[12:12+64]
+## elif line[:10] == " sncbieaa":
+## start = line[12:12+64]
+## elif line[:9] == " -- Base":
+## bases.append(line[12:12+64])
+## elif line[:2] == " }":
+## assert names != [] and id is not None and aa is not None
+## assert start is not None and bases != []
+## if len(names) == 1:
+## names.append(None)
+## print "register_ncbi_table(name = %s," % repr(names[0])
+## print " alt_name = %s, id = %d", % \
+## (repr(names[1]), id)
+## print " table = {"
+## s = " "
+## for i in range(64):
+## if aa[i] != "*":
+## t = " '%s%s%s': '%s'," % (bases[0][i], bases[1][i],
+## bases[2][i], aa[i])
+## if len(s) + len(t) > 75:
+## print s
+## s = " " + t
+## else:
+## s = s + t
+## print s, "},"
+
+## s = " stop_codons = ["
+## for i in range(64):
+## if aa[i] == "*":
+## t = " '%s%s%s'," % (bases[0][i], bases[1][i], bases[2][i])
+## if len(s) + len(t) > 75:
+## print s
+## s = " " + t
+## else:
+## s = s + t
+## print s, "],"
+
+## s = " start_codons = ["
+## for i in range(64):
+## if start[i] == "M":
+## t = " '%s%s%s'," % (bases[0][i], bases[1][i], bases[2][i])
+## if len(s) + len(t) > 75:
+## print s
+## s = " " + t
+## else:
+## s = s + t
+## print s, "]"
+## print " )"
+## elif line[:2] == "--" or line == "\n" or line == "}\n" or \
+## line == 'Genetic-code-table ::= {\n':
+## pass
+## else:
+## raise Exception("Unparsed: " + repr(line))
+
+register_ncbi_table(name = 'Standard',
+ alt_name = 'SGC0', id = 1,
+ table = {
+ 'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L', 'TCT': 'S',
+ 'TCC': 'S', 'TCA': 'S', 'TCG': 'S', 'TAT': 'Y', 'TAC': 'Y',
+ 'TGT': 'C', 'TGC': 'C', 'TGG': 'W', 'CTT': 'L', 'CTC': 'L',
+ 'CTA': 'L', 'CTG': 'L', 'CCT': 'P', 'CCC': 'P', 'CCA': 'P',
+ 'CCG': 'P', 'CAT': 'H', 'CAC': 'H', 'CAA': 'Q', 'CAG': 'Q',
+ 'CGT': 'R', 'CGC': 'R', 'CGA': 'R', 'CGG': 'R', 'ATT': 'I',
+ 'ATC': 'I', 'ATA': 'I', 'ATG': 'M', 'ACT': 'T', 'ACC': 'T',
+ 'ACA': 'T', 'ACG': 'T', 'AAT': 'N', 'AAC': 'N', 'AAA': 'K',
+ 'AAG': 'K', 'AGT': 'S', 'AGC': 'S', 'AGA': 'R', 'AGG': 'R',
+ 'GTT': 'V', 'GTC': 'V', 'GTA': 'V', 'GTG': 'V', 'GCT': 'A',
+ 'GCC': 'A', 'GCA': 'A', 'GCG': 'A', 'GAT': 'D', 'GAC': 'D',
+ 'GAA': 'E', 'GAG': 'E', 'GGT': 'G', 'GGC': 'G', 'GGA': 'G',
+ 'GGG': 'G', },
+ stop_codons = [ 'TAA', 'TAG', 'TGA', ],
+ start_codons = [ 'TTG', 'CTG', 'ATG', ]
+ )
+register_ncbi_table(name = 'Vertebrate Mitochondrial',
+ alt_name = 'SGC1', id = 2,
+ table = {
+ 'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L', 'TCT': 'S',
+ 'TCC': 'S', 'TCA': 'S', 'TCG': 'S', 'TAT': 'Y', 'TAC': 'Y',
+ 'TGT': 'C', 'TGC': 'C', 'TGA': 'W', 'TGG': 'W', 'CTT': 'L',
+ 'CTC': 'L', 'CTA': 'L', 'CTG': 'L', 'CCT': 'P', 'CCC': 'P',
+ 'CCA': 'P', 'CCG': 'P', 'CAT': 'H', 'CAC': 'H', 'CAA': 'Q',
+ 'CAG': 'Q', 'CGT': 'R', 'CGC': 'R', 'CGA': 'R', 'CGG': 'R',
+ 'ATT': 'I', 'ATC': 'I', 'ATA': 'M', 'ATG': 'M', 'ACT': 'T',
+ 'ACC': 'T', 'ACA': 'T', 'ACG': 'T', 'AAT': 'N', 'AAC': 'N',
+ 'AAA': 'K', 'AAG': 'K', 'AGT': 'S', 'AGC': 'S', 'GTT': 'V',
+ 'GTC': 'V', 'GTA': 'V', 'GTG': 'V', 'GCT': 'A', 'GCC': 'A',
+ 'GCA': 'A', 'GCG': 'A', 'GAT': 'D', 'GAC': 'D', 'GAA': 'E',
+ 'GAG': 'E', 'GGT': 'G', 'GGC': 'G', 'GGA': 'G', 'GGG': 'G', },
+ stop_codons = [ 'TAA', 'TAG', 'AGA', 'AGG', ],
+ start_codons = [ 'ATT', 'ATC', 'ATA', 'ATG', 'GTG', ]
+ )
+register_ncbi_table(name = 'Yeast Mitochondrial',
+ alt_name = 'SGC2', id = 3,
+ table = {
+ 'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L', 'TCT': 'S',
+ 'TCC': 'S', 'TCA': 'S', 'TCG': 'S', 'TAT': 'Y', 'TAC': 'Y',
+ 'TGT': 'C', 'TGC': 'C', 'TGA': 'W', 'TGG': 'W', 'CTT': 'T',
+ 'CTC': 'T', 'CTA': 'T', 'CTG': 'T', 'CCT': 'P', 'CCC': 'P',
+ 'CCA': 'P', 'CCG': 'P', 'CAT': 'H', 'CAC': 'H', 'CAA': 'Q',
+ 'CAG': 'Q', 'CGT': 'R', 'CGC': 'R', 'CGA': 'R', 'CGG': 'R',
+ 'ATT': 'I', 'ATC': 'I', 'ATA': 'M', 'ATG': 'M', 'ACT': 'T',
+ 'ACC': 'T', 'ACA': 'T', 'ACG': 'T', 'AAT': 'N', 'AAC': 'N',
+ 'AAA': 'K', 'AAG': 'K', 'AGT': 'S', 'AGC': 'S', 'AGA': 'R',
+ 'AGG': 'R', 'GTT': 'V', 'GTC': 'V', 'GTA': 'V', 'GTG': 'V',
+ 'GCT': 'A', 'GCC': 'A', 'GCA': 'A', 'GCG': 'A', 'GAT': 'D',
+ 'GAC': 'D', 'GAA': 'E', 'GAG': 'E', 'GGT': 'G', 'GGC': 'G',
+ 'GGA': 'G', 'GGG': 'G', },
+ stop_codons = [ 'TAA', 'TAG', ],
+ start_codons = [ 'ATG', ]
+ )
+register_ncbi_table(name = 'Mold Mitochondrial; Protozoan Mitochondrial; Coelenterate Mitochondrial; Mycoplasma; Spiroplasma',
+ alt_name = 'SGC3', id = 4,
+ table = {
+ 'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L', 'TCT': 'S',
+ 'TCC': 'S', 'TCA': 'S', 'TCG': 'S', 'TAT': 'Y', 'TAC': 'Y',
+ 'TGT': 'C', 'TGC': 'C', 'TGA': 'W', 'TGG': 'W', 'CTT': 'L',
+ 'CTC': 'L', 'CTA': 'L', 'CTG': 'L', 'CCT': 'P', 'CCC': 'P',
+ 'CCA': 'P', 'CCG': 'P', 'CAT': 'H', 'CAC': 'H', 'CAA': 'Q',
+ 'CAG': 'Q', 'CGT': 'R', 'CGC': 'R', 'CGA': 'R', 'CGG': 'R',
+ 'ATT': 'I', 'ATC': 'I', 'ATA': 'I', 'ATG': 'M', 'ACT': 'T',
+ 'ACC': 'T', 'ACA': 'T', 'ACG': 'T', 'AAT': 'N', 'AAC': 'N',
+ 'AAA': 'K', 'AAG': 'K', 'AGT': 'S', 'AGC': 'S', 'AGA': 'R',
+ 'AGG': 'R', 'GTT': 'V', 'GTC': 'V', 'GTA': 'V', 'GTG': 'V',
+ 'GCT': 'A', 'GCC': 'A', 'GCA': 'A', 'GCG': 'A', 'GAT': 'D',
+ 'GAC': 'D', 'GAA': 'E', 'GAG': 'E', 'GGT': 'G', 'GGC': 'G',
+ 'GGA': 'G', 'GGG': 'G', },
+ stop_codons = [ 'TAA', 'TAG', ],
+ start_codons = [ 'TTA', 'TTG', 'CTG', 'ATT', 'ATC',
+ 'ATA', 'ATG', 'GTG', ]
+ )
+register_ncbi_table(name = 'Invertebrate Mitochondrial',
+ alt_name = 'SGC4', id = 5,
+ table = {
+ 'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L', 'TCT': 'S',
+ 'TCC': 'S', 'TCA': 'S', 'TCG': 'S', 'TAT': 'Y', 'TAC': 'Y',
+ 'TGT': 'C', 'TGC': 'C', 'TGA': 'W', 'TGG': 'W', 'CTT': 'L',
+ 'CTC': 'L', 'CTA': 'L', 'CTG': 'L', 'CCT': 'P', 'CCC': 'P',
+ 'CCA': 'P', 'CCG': 'P', 'CAT': 'H', 'CAC': 'H', 'CAA': 'Q',
+ 'CAG': 'Q', 'CGT': 'R', 'CGC': 'R', 'CGA': 'R', 'CGG': 'R',
+ 'ATT': 'I', 'ATC': 'I', 'ATA': 'M', 'ATG': 'M', 'ACT': 'T',
+ 'ACC': 'T', 'ACA': 'T', 'ACG': 'T', 'AAT': 'N', 'AAC': 'N',
+ 'AAA': 'K', 'AAG': 'K', 'AGT': 'S', 'AGC': 'S', 'AGA': 'S',
+ 'AGG': 'S', 'GTT': 'V', 'GTC': 'V', 'GTA': 'V', 'GTG': 'V',
+ 'GCT': 'A', 'GCC': 'A', 'GCA': 'A', 'GCG': 'A', 'GAT': 'D',
+ 'GAC': 'D', 'GAA': 'E', 'GAG': 'E', 'GGT': 'G', 'GGC': 'G',
+ 'GGA': 'G', 'GGG': 'G', },
+ stop_codons = [ 'TAA', 'TAG', ],
+ start_codons = [ 'TTG', 'ATT', 'ATC', 'ATA', 'ATG',
+ 'GTG', ]
+ )
+register_ncbi_table(name = 'Ciliate Nuclear; Dasycladacean Nuclear; Hexamita Nuclear',
+ alt_name = 'SGC5', id = 6,
+ table = {
+ 'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L', 'TCT': 'S',
+ 'TCC': 'S', 'TCA': 'S', 'TCG': 'S', 'TAT': 'Y', 'TAC': 'Y',
+ 'TAA': 'Q', 'TAG': 'Q', 'TGT': 'C', 'TGC': 'C', 'TGG': 'W',
+ 'CTT': 'L', 'CTC': 'L', 'CTA': 'L', 'CTG': 'L', 'CCT': 'P',
+ 'CCC': 'P', 'CCA': 'P', 'CCG': 'P', 'CAT': 'H', 'CAC': 'H',
+ 'CAA': 'Q', 'CAG': 'Q', 'CGT': 'R', 'CGC': 'R', 'CGA': 'R',
+ 'CGG': 'R', 'ATT': 'I', 'ATC': 'I', 'ATA': 'I', 'ATG': 'M',
+ 'ACT': 'T', 'ACC': 'T', 'ACA': 'T', 'ACG': 'T', 'AAT': 'N',
+ 'AAC': 'N', 'AAA': 'K', 'AAG': 'K', 'AGT': 'S', 'AGC': 'S',
+ 'AGA': 'R', 'AGG': 'R', 'GTT': 'V', 'GTC': 'V', 'GTA': 'V',
+ 'GTG': 'V', 'GCT': 'A', 'GCC': 'A', 'GCA': 'A', 'GCG': 'A',
+ 'GAT': 'D', 'GAC': 'D', 'GAA': 'E', 'GAG': 'E', 'GGT': 'G',
+ 'GGC': 'G', 'GGA': 'G', 'GGG': 'G', },
+ stop_codons = [ 'TGA', ],
+ start_codons = [ 'ATG', ]
+ )
+register_ncbi_table(name = 'Echinoderm Mitochondrial',
+ alt_name = 'SGC8', id = 9,
+ table = {
+ 'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L', 'TCT': 'S',
+ 'TCC': 'S', 'TCA': 'S', 'TCG': 'S', 'TAT': 'Y', 'TAC': 'Y',
+ 'TGT': 'C', 'TGC': 'C', 'TGA': 'W', 'TGG': 'W', 'CTT': 'L',
+ 'CTC': 'L', 'CTA': 'L', 'CTG': 'L', 'CCT': 'P', 'CCC': 'P',
+ 'CCA': 'P', 'CCG': 'P', 'CAT': 'H', 'CAC': 'H', 'CAA': 'Q',
+ 'CAG': 'Q', 'CGT': 'R', 'CGC': 'R', 'CGA': 'R', 'CGG': 'R',
+ 'ATT': 'I', 'ATC': 'I', 'ATA': 'I', 'ATG': 'M', 'ACT': 'T',
+ 'ACC': 'T', 'ACA': 'T', 'ACG': 'T', 'AAT': 'N', 'AAC': 'N',
+ 'AAA': 'N', 'AAG': 'K', 'AGT': 'S', 'AGC': 'S', 'AGA': 'S',
+ 'AGG': 'S', 'GTT': 'V', 'GTC': 'V', 'GTA': 'V', 'GTG': 'V',
+ 'GCT': 'A', 'GCC': 'A', 'GCA': 'A', 'GCG': 'A', 'GAT': 'D',
+ 'GAC': 'D', 'GAA': 'E', 'GAG': 'E', 'GGT': 'G', 'GGC': 'G',
+ 'GGA': 'G', 'GGG': 'G', },
+ stop_codons = [ 'TAA', 'TAG', ],
+ start_codons = [ 'ATG', ]
+ )
+register_ncbi_table(name = 'Euplotid Nuclear',
+ alt_name = 'SGC9', id = 10,
+ table = {
+ 'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L', 'TCT': 'S',
+ 'TCC': 'S', 'TCA': 'S', 'TCG': 'S', 'TAT': 'Y', 'TAC': 'Y',
+ 'TGT': 'C', 'TGC': 'C', 'TGA': 'C', 'TGG': 'W', 'CTT': 'L',
+ 'CTC': 'L', 'CTA': 'L', 'CTG': 'L', 'CCT': 'P', 'CCC': 'P',
+ 'CCA': 'P', 'CCG': 'P', 'CAT': 'H', 'CAC': 'H', 'CAA': 'Q',
+ 'CAG': 'Q', 'CGT': 'R', 'CGC': 'R', 'CGA': 'R', 'CGG': 'R',
+ 'ATT': 'I', 'ATC': 'I', 'ATA': 'I', 'ATG': 'M', 'ACT': 'T',
+ 'ACC': 'T', 'ACA': 'T', 'ACG': 'T', 'AAT': 'N', 'AAC': 'N',
+ 'AAA': 'K', 'AAG': 'K', 'AGT': 'S', 'AGC': 'S', 'AGA': 'R',
+ 'AGG': 'R', 'GTT': 'V', 'GTC': 'V', 'GTA': 'V', 'GTG': 'V',
+ 'GCT': 'A', 'GCC': 'A', 'GCA': 'A', 'GCG': 'A', 'GAT': 'D',
+ 'GAC': 'D', 'GAA': 'E', 'GAG': 'E', 'GGT': 'G', 'GGC': 'G',
+ 'GGA': 'G', 'GGG': 'G', },
+ stop_codons = [ 'TAA', 'TAG', ],
+ start_codons = [ 'ATG', ]
+ )
+register_ncbi_table(name = 'Bacterial',
+ alt_name = None, id = 11,
+ table = {
+ 'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L', 'TCT': 'S',
+ 'TCC': 'S', 'TCA': 'S', 'TCG': 'S', 'TAT': 'Y', 'TAC': 'Y',
+ 'TGT': 'C', 'TGC': 'C', 'TGG': 'W', 'CTT': 'L', 'CTC': 'L',
+ 'CTA': 'L', 'CTG': 'L', 'CCT': 'P', 'CCC': 'P', 'CCA': 'P',
+ 'CCG': 'P', 'CAT': 'H', 'CAC': 'H', 'CAA': 'Q', 'CAG': 'Q',
+ 'CGT': 'R', 'CGC': 'R', 'CGA': 'R', 'CGG': 'R', 'ATT': 'I',
+ 'ATC': 'I', 'ATA': 'I', 'ATG': 'M', 'ACT': 'T', 'ACC': 'T',
+ 'ACA': 'T', 'ACG': 'T', 'AAT': 'N', 'AAC': 'N', 'AAA': 'K',
+ 'AAG': 'K', 'AGT': 'S', 'AGC': 'S', 'AGA': 'R', 'AGG': 'R',
+ 'GTT': 'V', 'GTC': 'V', 'GTA': 'V', 'GTG': 'V', 'GCT': 'A',
+ 'GCC': 'A', 'GCA': 'A', 'GCG': 'A', 'GAT': 'D', 'GAC': 'D',
+ 'GAA': 'E', 'GAG': 'E', 'GGT': 'G', 'GGC': 'G', 'GGA': 'G',
+ 'GGG': 'G', },
+ stop_codons = [ 'TAA', 'TAG', 'TGA', ],
+ start_codons = [ 'TTG', 'CTG', 'ATT', 'ATC', 'ATA',
+ 'ATG', 'GTG', ]
+ )
+register_ncbi_table(name = 'Alternative Yeast Nuclear',
+ alt_name = None, id = 12,
+ table = {
+ 'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L', 'TCT': 'S',
+ 'TCC': 'S', 'TCA': 'S', 'TCG': 'S', 'TAT': 'Y', 'TAC': 'Y',
+ 'TGT': 'C', 'TGC': 'C', 'TGG': 'W', 'CTT': 'L', 'CTC': 'L',
+ 'CTA': 'L', 'CTG': 'S', 'CCT': 'P', 'CCC': 'P', 'CCA': 'P',
+ 'CCG': 'P', 'CAT': 'H', 'CAC': 'H', 'CAA': 'Q', 'CAG': 'Q',
+ 'CGT': 'R', 'CGC': 'R', 'CGA': 'R', 'CGG': 'R', 'ATT': 'I',
+ 'ATC': 'I', 'ATA': 'I', 'ATG': 'M', 'ACT': 'T', 'ACC': 'T',
+ 'ACA': 'T', 'ACG': 'T', 'AAT': 'N', 'AAC': 'N', 'AAA': 'K',
+ 'AAG': 'K', 'AGT': 'S', 'AGC': 'S', 'AGA': 'R', 'AGG': 'R',
+ 'GTT': 'V', 'GTC': 'V', 'GTA': 'V', 'GTG': 'V', 'GCT': 'A',
+ 'GCC': 'A', 'GCA': 'A', 'GCG': 'A', 'GAT': 'D', 'GAC': 'D',
+ 'GAA': 'E', 'GAG': 'E', 'GGT': 'G', 'GGC': 'G', 'GGA': 'G',
+ 'GGG': 'G', },
+ stop_codons = [ 'TAA', 'TAG', 'TGA', ],
+ start_codons = [ 'CTG', 'ATG', ]
+ )
+register_ncbi_table(name = 'Ascidian Mitochondrial',
+ alt_name = None, id = 13,
+ table = {
+ 'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L', 'TCT': 'S',
+ 'TCC': 'S', 'TCA': 'S', 'TCG': 'S', 'TAT': 'Y', 'TAC': 'Y',
+ 'TGT': 'C', 'TGC': 'C', 'TGA': 'W', 'TGG': 'W', 'CTT': 'L',
+ 'CTC': 'L', 'CTA': 'L', 'CTG': 'L', 'CCT': 'P', 'CCC': 'P',
+ 'CCA': 'P', 'CCG': 'P', 'CAT': 'H', 'CAC': 'H', 'CAA': 'Q',
+ 'CAG': 'Q', 'CGT': 'R', 'CGC': 'R', 'CGA': 'R', 'CGG': 'R',
+ 'ATT': 'I', 'ATC': 'I', 'ATA': 'M', 'ATG': 'M', 'ACT': 'T',
+ 'ACC': 'T', 'ACA': 'T', 'ACG': 'T', 'AAT': 'N', 'AAC': 'N',
+ 'AAA': 'K', 'AAG': 'K', 'AGT': 'S', 'AGC': 'S', 'AGA': 'G',
+ 'AGG': 'G', 'GTT': 'V', 'GTC': 'V', 'GTA': 'V', 'GTG': 'V',
+ 'GCT': 'A', 'GCC': 'A', 'GCA': 'A', 'GCG': 'A', 'GAT': 'D',
+ 'GAC': 'D', 'GAA': 'E', 'GAG': 'E', 'GGT': 'G', 'GGC': 'G',
+ 'GGA': 'G', 'GGG': 'G', },
+ stop_codons = [ 'TAA', 'TAG', ],
+ start_codons = [ 'ATG', ]
+ )
+register_ncbi_table(name = 'Flatworm Mitochondrial',
+ alt_name = None, id = 14,
+ table = {
+ 'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L', 'TCT': 'S',
+ 'TCC': 'S', 'TCA': 'S', 'TCG': 'S', 'TAT': 'Y', 'TAC': 'Y',
+ 'TAA': 'Y', 'TGT': 'C', 'TGC': 'C', 'TGA': 'W', 'TGG': 'W',
+ 'CTT': 'L', 'CTC': 'L', 'CTA': 'L', 'CTG': 'L', 'CCT': 'P',
+ 'CCC': 'P', 'CCA': 'P', 'CCG': 'P', 'CAT': 'H', 'CAC': 'H',
+ 'CAA': 'Q', 'CAG': 'Q', 'CGT': 'R', 'CGC': 'R', 'CGA': 'R',
+ 'CGG': 'R', 'ATT': 'I', 'ATC': 'I', 'ATA': 'I', 'ATG': 'M',
+ 'ACT': 'T', 'ACC': 'T', 'ACA': 'T', 'ACG': 'T', 'AAT': 'N',
+ 'AAC': 'N', 'AAA': 'N', 'AAG': 'K', 'AGT': 'S', 'AGC': 'S',
+ 'AGA': 'S', 'AGG': 'S', 'GTT': 'V', 'GTC': 'V', 'GTA': 'V',
+ 'GTG': 'V', 'GCT': 'A', 'GCC': 'A', 'GCA': 'A', 'GCG': 'A',
+ 'GAT': 'D', 'GAC': 'D', 'GAA': 'E', 'GAG': 'E', 'GGT': 'G',
+ 'GGC': 'G', 'GGA': 'G', 'GGG': 'G', },
+ stop_codons = [ 'TAG', ],
+ start_codons = [ 'ATG', ]
+ )
+register_ncbi_table(name = 'Blepharisma Macronuclear',
+ alt_name = None, id = 15,
+ table = {
+ 'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L', 'TCT': 'S',
+ 'TCC': 'S', 'TCA': 'S', 'TCG': 'S', 'TAT': 'Y', 'TAC': 'Y',
+ 'TAG': 'Q', 'TGT': 'C', 'TGC': 'C', 'TGG': 'W', 'CTT': 'L',
+ 'CTC': 'L', 'CTA': 'L', 'CTG': 'L', 'CCT': 'P', 'CCC': 'P',
+ 'CCA': 'P', 'CCG': 'P', 'CAT': 'H', 'CAC': 'H', 'CAA': 'Q',
+ 'CAG': 'Q', 'CGT': 'R', 'CGC': 'R', 'CGA': 'R', 'CGG': 'R',
+ 'ATT': 'I', 'ATC': 'I', 'ATA': 'I', 'ATG': 'M', 'ACT': 'T',
+ 'ACC': 'T', 'ACA': 'T', 'ACG': 'T', 'AAT': 'N', 'AAC': 'N',
+ 'AAA': 'K', 'AAG': 'K', 'AGT': 'S', 'AGC': 'S', 'AGA': 'R',
+ 'AGG': 'R', 'GTT': 'V', 'GTC': 'V', 'GTA': 'V', 'GTG': 'V',
+ 'GCT': 'A', 'GCC': 'A', 'GCA': 'A', 'GCG': 'A', 'GAT': 'D',
+ 'GAC': 'D', 'GAA': 'E', 'GAG': 'E', 'GGT': 'G', 'GGC': 'G',
+ 'GGA': 'G', 'GGG': 'G', },
+ stop_codons = [ 'TAA', 'TGA', ],
+ start_codons = [ 'ATG', ]
+ )
+
+######### Deal with ambiguous forward translations
+
+class AmbiguousCodonTable(CodonTable):
+ def __init__(self, codon_table,
+ ambiguous_nucleotide_alphabet,
+ ambiguous_nucleotide_values,
+ ambiguous_protein_alphabet,
+ ambiguous_protein_values):
+ CodonTable.__init__(self,
+ ambiguous_nucleotide_alphabet,
+ ambiguous_protein_alphabet,
+ AmbiguousForwardTable(codon_table.forward_table,
+ ambiguous_nucleotide_values,
+ ambiguous_protein_values),
+ codon_table.back_table,
+
+ # These two are WRONG! I need to get the
+ # list of ambiguous codons which code for
+ # the stop codons XXX
+ list_ambiguous_codons(codon_table.start_codons, ambiguous_nucleotide_values),
+ list_ambiguous_codons(codon_table.stop_codons, ambiguous_nucleotide_values)
+ )
+ self._codon_table = codon_table
+
+ # Be sneaky and forward attribute lookups to the original table.
+ # This lets us get the names, if the original table is an NCBI
+ # table.
+ def __getattr__(self, name):
+ return getattr(self._codon_table, name)
+
+def list_possible_proteins(codon, forward_table, ambiguous_nucleotide_values):
+ c1, c2, c3 = codon
+ x1 = ambiguous_nucleotide_values[c1]
+ x2 = ambiguous_nucleotide_values[c2]
+ x3 = ambiguous_nucleotide_values[c3]
+ possible = {}
+ stops = []
+ for y1 in x1:
+ for y2 in x2:
+ for y3 in x3:
+ try:
+ possible[forward_table[y1+y2+y3]] = 1
+ except KeyError:
+ # If tripping over a stop codon
+ stops.append(y1+y2+y3)
+ if stops:
+ if possible.keys():
+ raise TranslationError("ambiguous codon '%s' codes " % codon \
+ + "for both proteins and stop codons")
+ # This is a true stop codon - tell the caller about it
+ raise KeyError(codon)
+ return possible.keys()
+
+def list_ambiguous_codons(codons, ambiguous_nucleotide_values):
+ """Extends a codon list to include all possible ambigous codons.
+
+ e.g. ['TAG', 'TAA'] -> ['TAG', 'TAA', 'TAR']
+ ['UAG', 'UGA'] -> ['UAG', 'UGA', 'URA']
+
+ Note that ['TAG', 'TGA'] -> ['TAG', 'TGA'], this does not add 'TRR'.
+ Thus only two more codons are added in the following:
+
+ e.g. ['TGA', 'TAA', 'TAG'] -> ['TGA', 'TAA', 'TAG', 'TRA', 'TAR']
+
+ Returns a new (longer) list of codon strings.
+ """
+
+ #Note ambiguous_nucleotide_values['R'] = 'AG' (etc)
+ #This will generate things like 'TRR' from ['TAG', 'TGA'], which
+ #we don't want to include:
+ c1_list = [letter for (letter, meanings) \
+ in ambiguous_nucleotide_values.iteritems() \
+ if set([codon[0] for codon in codons]).issuperset(set(meanings))]
+ c2_list = [letter for (letter, meanings) \
+ in ambiguous_nucleotide_values.iteritems() \
+ if set([codon[1] for codon in codons]).issuperset(set(meanings))]
+ c3_list = [letter for (letter, meanings) \
+ in ambiguous_nucleotide_values.iteritems() \
+ if set([codon[2] for codon in codons]).issuperset(set(meanings))]
+ set2 = set([codon[1] for codon in codons])
+ set3 = set([codon[2] for codon in codons])
+ candidates = set([c1+c2+c3 for c1 in c1_list for c2 in c2_list for c3 in c3_list])
+ candidates.difference_update(codons)
+ answer = codons[:] #copy
+ #print "Have %i new candidates" % len(candidates)
+ for ambig_codon in candidates :
+ wanted = True
+ #e.g. 'TRR' -> 'TAA', 'TAG', 'TGA', 'TGG'
+ for codon in [c1+c2+c3 \
+ for c1 in ambiguous_nucleotide_values[ambig_codon[0]] \
+ for c2 in ambiguous_nucleotide_values[ambig_codon[1]] \
+ for c3 in ambiguous_nucleotide_values[ambig_codon[2]]]:
+ if codon not in codons :
+ #This ambiguous codon can code for a non-stop, exclude it!
+ wanted=False
+ #print "Rejecting %s" % ambig_codon
+ continue
+ if wanted :
+ answer.append(ambig_codon)
+ return answer
+assert list_ambiguous_codons(['TGA', 'TAA'],IUPACData.ambiguous_dna_values) == ['TGA', 'TAA', 'TRA']
+assert list_ambiguous_codons(['TAG', 'TGA'],IUPACData.ambiguous_dna_values) == ['TAG', 'TGA']
+assert list_ambiguous_codons(['TAG', 'TAA'],IUPACData.ambiguous_dna_values) == ['TAG', 'TAA', 'TAR']
+assert list_ambiguous_codons(['UAG', 'UAA'],IUPACData.ambiguous_rna_values) == ['UAG', 'UAA', 'UAR']
+assert list_ambiguous_codons(['TGA', 'TAA', 'TAG'],IUPACData.ambiguous_dna_values) == ['TGA', 'TAA', 'TAG', 'TAR', 'TRA']
+
+# Forward translation is "onto", that is, any given codon always maps
+# to the same protein, or it doesn't map at all. Thus, I can build
+# off of an existing table to produce the ambiguous mappings.
+#
+# This handles the general case. Perhaps it's overkill?
+# >>> t = CodonTable.ambiguous_dna_by_id[1]
+# >>> t.forward_table["AAT"]
+# 'N'
+# >>> t.forward_table["GAT"]
+# 'D'
+# >>> t.forward_table["RAT"]
+# 'B'
+# >>> t.forward_table["YTA"]
+# 'L'
+
+class AmbiguousForwardTable:
+ def __init__(self, forward_table, ambiguous_nucleotide, ambiguous_protein):
+ self.forward_table = forward_table
+
+ self.ambiguous_nucleotide = ambiguous_nucleotide
+ self.ambiguous_protein = ambiguous_protein
+
+ inverted = {}
+ for name, val in ambiguous_protein.items():
+ for c in val:
+ x = inverted.get(c, {})
+ x[name] = 1
+ inverted[c] = x
+ for name, val in inverted.items():
+ inverted[name] = val.keys()
+ self._inverted = inverted
+
+ self._cache = {}
+
+ def get(self, codon, failobj = None):
+ try:
+ return self.__getitem__(codon)
+ except KeyError:
+ return failobj
+
+ def __getitem__(self, codon):
+ try:
+ x = self._cache[codon]
+ except KeyError:
+ pass
+ else:
+ if x is TranslationError:
+ raise TranslationError(codon) # no unique translation
+ if x is KeyError:
+ raise KeyError(codon) # it's a stop codon
+ return x
+ try:
+ x = self.forward_table[codon]
+ self._cache[codon] = x
+ return x
+ except KeyError:
+ pass
+
+ # XXX Need to make part of this into a method which returns
+ # a list of all possible encodings for a codon!
+ try:
+ possible = list_possible_proteins(codon,
+ self.forward_table,
+ self.ambiguous_nucleotide)
+ except KeyError:
+ self._cache[codon] = KeyError
+ raise KeyError(codon) # stop codon
+ except TranslationError:
+ self._cache[codon] = TranslationError
+ raise TranslationError(codon) # does not code
+ assert len(possible) > 0, "unambiguous codons must code"
+
+ # Hah! Only one possible protein, so use it
+ if len(possible) == 1:
+ self._cache[codon] = possible[0]
+ return possible[0]
+
+ # See if there's an ambiguous protein encoding for the multiples.
+ # Find residues which exist in every coding set.
+ ambiguous_possible = {}
+ for amino in possible:
+ for term in self._inverted[amino]:
+ ambiguous_possible[term] = ambiguous_possible.get(term, 0) + 1
+
+ n = len(possible)
+ possible = []
+ for amino, val in ambiguous_possible.items():
+ if val == n:
+ possible.append(amino)
+
+ # No amino acid encoding for the results
+ if len(possible) == 0:
+ self._cache[codon] = TranslationError
+ raise TranslationError(codon) # no valid translation
+
+ # All of these are valid, so choose one
+ # To be unique, sort by smallet ambiguity then alphabetically
+ # Can get this if "X" encodes for everything.
+ def _sort(x, y, table = self.ambiguous_protein):
+ a = cmp(len(table[x]), len(table[y]))
+ if a == 0:
+ return cmp(x, y)
+ return a
+ possible.sort(_sort)
+
+ x = possible[0]
+ self._cache[codon] = x
+ return x
+
+#Prepare the ambiguous tables for DNA, RNA and Generic (DNA or RNA)
+ambiguous_dna_by_name = {}
+for key, val in unambiguous_dna_by_name.items():
+ ambiguous_dna_by_name[key] = AmbiguousCodonTable(val,
+ IUPAC.ambiguous_dna,
+ IUPACData.ambiguous_dna_values,
+ IUPAC.extended_protein,
+ IUPACData.extended_protein_values)
+ambiguous_dna_by_id = {}
+for key, val in unambiguous_dna_by_id.items():
+ ambiguous_dna_by_id[key] = AmbiguousCodonTable(val,
+ IUPAC.ambiguous_dna,
+ IUPACData.ambiguous_dna_values,
+ IUPAC.extended_protein,
+ IUPACData.extended_protein_values)
+
+ambiguous_rna_by_name = {}
+for key, val in unambiguous_rna_by_name.items():
+ ambiguous_rna_by_name[key] = AmbiguousCodonTable(val,
+ IUPAC.ambiguous_rna,
+ IUPACData.ambiguous_rna_values,
+ IUPAC.extended_protein,
+ IUPACData.extended_protein_values)
+ambiguous_rna_by_id = {}
+for key, val in unambiguous_rna_by_id.items():
+ ambiguous_rna_by_id[key] = AmbiguousCodonTable(val,
+ IUPAC.ambiguous_rna,
+ IUPACData.ambiguous_rna_values,
+ IUPAC.extended_protein,
+ IUPACData.extended_protein_values)
+
+#The following isn't very elegant, but seems to work nicely.
+_merged_values = dict(IUPACData.ambiguous_rna_values.iteritems())
+_merged_values["T"] = "U"
+
+for key, val in generic_by_name.items():
+ ambiguous_generic_by_name[key] = AmbiguousCodonTable(val,
+ Alphabet.NucleotideAlphabet(),
+ _merged_values,
+ IUPAC.extended_protein,
+ IUPACData.extended_protein_values)
+
+for key, val in generic_by_id.items():
+ ambiguous_generic_by_id[key] = AmbiguousCodonTable(val,
+ Alphabet.NucleotideAlphabet(),
+ _merged_values,
+ IUPAC.extended_protein,
+ IUPACData.extended_protein_values)
+del _merged_values
+del key, val
+
+#Basic sanity test,
+for n in ambiguous_generic_by_id.keys() :
+ assert ambiguous_rna_by_id[n].forward_table["GUU"] == "V"
+ assert ambiguous_rna_by_id[n].forward_table["GUN"] == "V"
+ assert ambiguous_rna_by_id[n].forward_table["UUN"] == "X" #F or L
+ #R = A or G, so URR = UAA or UGA / TRA = TAA or TGA = stop codons
+ if "UAA" in unambiguous_rna_by_id[n].stop_codons \
+ and "UGA" in unambiguous_rna_by_id[n].stop_codons :
+ try :
+ print ambiguous_dna_by_id[n].forward_table["TRA"]
+ assert False, "Should be a stop only"
+ except KeyError :
+ pass
+ assert "URA" in ambiguous_generic_by_id[n].stop_codons
+ assert "URA" in ambiguous_rna_by_id[n].stop_codons
+ assert "TRA" in ambiguous_generic_by_id[n].stop_codons
+ assert "TRA" in ambiguous_dna_by_id[n].stop_codons
+del n
+assert ambiguous_generic_by_id[1].stop_codons == ambiguous_generic_by_name["Standard"].stop_codons
+assert ambiguous_generic_by_id[4].stop_codons == ambiguous_generic_by_name["SGC3"].stop_codons
+assert ambiguous_generic_by_id[15].stop_codons == ambiguous_generic_by_name['Blepharisma Macronuclear'].stop_codons
git://source.jalview.org / jabaws.git / blobdiff