def _write_seq(self, record):
"""Write the sequence.
Note that SeqXML requires a DNA, RNA or protein alphabet.
"""
if isinstance(record.seq, UnknownSeq):
raise TypeError(
"Sequence type is UnknownSeq but SeqXML requires sequence")
seq = str(record.seq)
if not len(seq) > 0:
raise ValueError("The sequence length should be greater than 0")
# Get the base alphabet (underneath any Gapped or StopCodon encoding)
alpha = Alphabet._get_base_alphabet(record.seq.alphabet)
if isinstance(alpha, Alphabet.RNAAlphabet):
seqElem = "RNAseq"
elif isinstance(alpha, Alphabet.DNAAlphabet):
seqElem = "DNAseq"
elif isinstance(alpha, Alphabet.ProteinAlphabet):
seqElem = "AAseq"
else:
raise ValueError("Need a DNA, RNA or Protein alphabet")
self.xml_generator.startElement(seqElem, AttributesImpl({}))
self.xml_generator.characters(seq)
self.xml_generator.endElement(seqElem)
def _write_seq(self, record):
"""Write the sequence.
Note that SeqXML requires a DNA, RNA or protein alphabet.
"""
if isinstance(record.seq, UnknownSeq):
raise TypeError("Sequence type is UnknownSeq but SeqXML requires sequence")
seq = str(record.seq)
if not len(seq) > 0:
raise ValueError("The sequence length should be greater than 0")
# Get the base alphabet (underneath any Gapped or StopCodon encoding)
alpha = Alphabet._get_base_alphabet(record.seq.alphabet)
if isinstance(alpha, Alphabet.RNAAlphabet):
seqElem = "RNAseq"
elif isinstance(alpha, Alphabet.DNAAlphabet):
seqElem = "DNAseq"
elif isinstance(alpha, Alphabet.ProteinAlphabet):
seqElem = "AAseq"
else:
raise ValueError("Need a DNA, RNA or Protein alphabet")
self.xml_generator.startElement(seqElem, AttributesImpl({}))
self.xml_generator.characters(seq)
self.xml_generator.endElement(seqElem)
def _classify_alphabet_for_nexus(self, alphabet):
"""Returns 'protein', 'dna', 'rna' based on the alphabet (PRIVATE).
Raises an exception if this is not possible."""
# Get the base alphabet (underneath any Gapped or StopCodon encoding)
a = Alphabet._get_base_alphabet(alphabet)
"""condition loop below was edited by Ambuj Kumar in order to make
it align with ConCat"""
if 'Alphabet.Alphabet' not in str(
type(a)) and 'Alphabet.ProteinAlphabet' not in str(
type(a)) and 'Alphabet.DNAAlphabet' not in str(
type(a)) and 'Alphabet.RNAAlphabet' not in str(
type(a)) and 'Alphabet.Gapped' not in str(type(a)):
raise TypeError("Invalid alphabet")
elif 'Protein' in str(type(a)):
return "protein"
elif 'DNA' in str(type(a)):
return "dna"
elif 'RNA' in str(type(a)):
return "rna"
else:
# Must be something like NucleotideAlphabet or
# just the generic Alphabet (default for fasta files)
raise ValueError("Need a DNA, RNA or Protein alphabet")
def _write_the_first_lines(self, record):
"""Write the ID and AC lines."""
if "." in record.id and record.id.rsplit(".", 1)[1].isdigit():
version = "SV " + record.id.rsplit(".", 1)[1]
accession = self._get_annotation_str(record, "accession",
record.id.rsplit(".", 1)[0],
just_first=True)
else:
version = ""
accession = self._get_annotation_str(record, "accession",
record.id,
just_first=True)
if ";" in accession:
raise ValueError("Cannot have semi-colon in EMBL accession, %s"
% repr(str(accession)))
if " " in accession:
# This is out of practicallity... might it be allowed?
raise ValueError("Cannot have spaces in EMBL accession, %s"
% repr(str(accession)))
# Get the molecule type
# TODO - record this explicitly in the parser?
# Get the base alphabet (underneath any Gapped or StopCodon encoding)
a = Alphabet._get_base_alphabet(record.seq.alphabet)
if not isinstance(a, Alphabet.Alphabet):
raise TypeError("Invalid alphabet")
elif isinstance(a, Alphabet.DNAAlphabet):
mol_type = "DNA"
units = "BP"
elif isinstance(a, Alphabet.RNAAlphabet):
mol_type = "RNA"
units = "BP"
elif isinstance(a, Alphabet.ProteinAlphabet):
mol_type = "PROTEIN"
units = "AA"
else:
# Must be something like NucleotideAlphabet
raise ValueError("Need a DNA, RNA or Protein alphabet")
# Get the taxonomy division
division = self._get_data_division(record)
# TODO - Full ID line
handle = self.handle
# ID <1>; SV <2>; <3>; <4>; <5>; <6>; <7> BP.
# 1. Primary accession number
# 2. Sequence version number
# 3. Topology: 'circular' or 'linear'
# 4. Molecule type
# 5. Data class
# 6. Taxonomic division
# 7. Sequence length
self._write_single_line("ID", "%s; %s; ; %s; ; %s; %i %s."
% (accession, version, mol_type,
division, len(record), units))
handle.write("XX\n")
self._write_single_line("AC", accession + ";")
handle.write("XX\n")
def _write_the_first_lines(self, record):
"""Write the ID and AC lines."""
if "." in record.id and record.id.rsplit(".", 1)[1].isdigit():
version = "SV " + record.id.rsplit(".", 1)[1]
accession = self._get_annotation_str(record, "accession",
record.id.rsplit(".", 1)[0],
just_first=True)
else :
version = ""
accession = self._get_annotation_str(record, "accession",
record.id,
just_first=True)
if ";" in accession :
raise ValueError("Cannot have semi-colon in EMBL accession, %s" \
% repr(str(accession)))
if " " in accession :
#This is out of practicallity... might it be allowed?
raise ValueError("Cannot have spaces in EMBL accession, %s" \
% repr(str(accession)))
#Get the molecule type
#TODO - record this explicitly in the parser?
#Get the base alphabet (underneath any Gapped or StopCodon encoding)
a = Alphabet._get_base_alphabet(record.seq.alphabet)
if not isinstance(a, Alphabet.Alphabet):
raise TypeError("Invalid alphabet")
elif isinstance(a, Alphabet.DNAAlphabet):
mol_type = "DNA"
units = "BP"
elif isinstance(a, Alphabet.RNAAlphabet):
mol_type = "RNA"
units = "BP"
elif isinstance(a, Alphabet.ProteinAlphabet):
mol_type = "PROTEIN"
units = "AA"
else:
#Must be something like NucleotideAlphabet
raise ValueError("Need a DNA, RNA or Protein alphabet")
#Get the taxonomy division
division = self._get_data_division(record)
#TODO - Full ID line
handle = self.handle
#ID <1>; SV <2>; <3>; <4>; <5>; <6>; <7> BP.
#1. Primary accession number
#2. Sequence version number
#3. Topology: 'circular' or 'linear'
#4. Molecule type
#5. Data class
#6. Taxonomic division
#7. Sequence length
self._write_single_line("ID", "%s; %s; ; %s; ; %s; %i %s." \
% (accession, version, mol_type,
division, len(record), units))
handle.write("XX\n")
self._write_single_line("AC", accession+";")
handle.write("XX\n")
def _guess_consensus_alphabet(self, ambiguous):
"""Pick an (ungapped) alphabet for an alignment consesus sequence (PRIVATE).
This just looks at the sequences we have, checks their type, and
returns as appropriate type which seems to make sense with the
sequences we've got.
"""
# Start with the (un-gapped version of) the alignment alphabet
a = Alphabet._get_base_alphabet(self.alignment._alphabet)
# Now check its compatible with all the rest of the sequences
for record in self.alignment:
# Get the (un-gapped version of) the sequence's alphabet
alt = Alphabet._get_base_alphabet(record.seq.alphabet)
if not isinstance(alt, a.__class__):
raise ValueError(
"Alignment contains a sequence with an incompatible alphabet."
)
# Check the ambiguous character we are going to use in the consensus
# is in the alphabet's list of valid letters (if defined).
if (
hasattr(a, "letters")
and a.letters is not None
and ambiguous not in a.letters
):
# We'll need to pick a more generic alphabet...
if isinstance(a, IUPAC.IUPACUnambiguousDNA):
if ambiguous in IUPAC.IUPACUnambiguousDNA().letters:
a = IUPAC.IUPACUnambiguousDNA()
else:
a = Alphabet.generic_dna
elif isinstance(a, IUPAC.IUPACUnambiguousRNA):
if ambiguous in IUPAC.IUPACUnambiguousRNA().letters:
a = IUPAC.IUPACUnambiguousRNA()
else:
a = Alphabet.generic_rna
elif isinstance(a, IUPAC.IUPACProtein):
if ambiguous in IUPAC.ExtendedIUPACProtein().letters:
a = IUPAC.ExtendedIUPACProtein()
else:
a = Alphabet.generic_protein
else:
a = Alphabet.single_letter_alphabet
return a
def _write_sequence(self, record):
LETTERS_PER_BLOCK = 10
BLOCKS_PER_LINE = 6
LETTERS_PER_LINE = LETTERS_PER_BLOCK * BLOCKS_PER_LINE
POSITION_PADDING = 10
handle = self.handle # save looking up this multiple times
if isinstance(record.seq, UnknownSeq):
# We have already recorded the length, and there is no need
# to record a long sequence of NNNNNNN...NNN or whatever.
if "contig" in record.annotations:
self._write_contig(record)
else:
# TODO - Can the sequence just be left out as in GenBank files?
handle.write("SQ \n")
return
# Catches sequence being None
data = self._get_seq_string(record).lower()
seq_len = len(data)
# Get the base alphabet (underneath any Gapped or StopCodon encoding)
a = Alphabet._get_base_alphabet(record.seq.alphabet)
if isinstance(a, Alphabet.DNAAlphabet):
# TODO - What if we have RNA?
a_count = data.count('A') + data.count('a')
c_count = data.count('C') + data.count('c')
g_count = data.count('G') + data.count('g')
t_count = data.count('T') + data.count('t')
other = seq_len - (a_count + c_count + g_count + t_count)
handle.write(
"SQ Sequence %i BP; %i A; %i C; %i G; %i T; %i other;\n" %
(seq_len, a_count, c_count, g_count, t_count, other))
else:
handle.write("SQ \n")
for line_number in range(0, seq_len // LETTERS_PER_LINE):
handle.write(" ") # Just four, not five
for block in range(BLOCKS_PER_LINE):
index = LETTERS_PER_LINE * line_number + \
LETTERS_PER_BLOCK * block
handle.write((" %s" % data[index:index + LETTERS_PER_BLOCK]))
handle.write(
str((line_number + 1) *
LETTERS_PER_LINE).rjust(POSITION_PADDING))
handle.write("\n")
if seq_len % LETTERS_PER_LINE:
# Final (partial) line
line_number = (seq_len // LETTERS_PER_LINE)
handle.write(" ") # Just four, not five
for block in range(BLOCKS_PER_LINE):
index = LETTERS_PER_LINE * line_number + \
LETTERS_PER_BLOCK * block
handle.write(
(" %s" % data[index:index + LETTERS_PER_BLOCK]).ljust(11))
handle.write(str(seq_len).rjust(POSITION_PADDING))
handle.write("\n")
def _write_sequence(self, record):
LETTERS_PER_BLOCK = 10
BLOCKS_PER_LINE = 6
LETTERS_PER_LINE = LETTERS_PER_BLOCK * BLOCKS_PER_LINE
POSITION_PADDING = 10
handle = self.handle # save looking up this multiple times
if isinstance(record.seq, UnknownSeq):
# We have already recorded the length, and there is no need
# to record a long sequence of NNNNNNN...NNN or whatever.
if "contig" in record.annotations:
self._write_contig(record)
else:
# TODO - Can the sequence just be left out as in GenBank files?
handle.write("SQ \n")
return
# Catches sequence being None
data = self._get_seq_string(record).lower()
seq_len = len(data)
# Get the base alphabet (underneath any Gapped or StopCodon encoding)
a = Alphabet._get_base_alphabet(record.seq.alphabet)
if isinstance(a, Alphabet.DNAAlphabet):
# TODO - What if we have RNA?
a_count = data.count('A') + data.count('a')
c_count = data.count('C') + data.count('c')
g_count = data.count('G') + data.count('g')
t_count = data.count('T') + data.count('t')
other = seq_len - (a_count + c_count + g_count + t_count)
handle.write("SQ Sequence %i BP; %i A; %i C; %i G; %i T; %i other;\n"
% (seq_len, a_count, c_count, g_count, t_count, other))
else:
handle.write("SQ \n")
for line_number in range(0, seq_len // LETTERS_PER_LINE):
handle.write(" ") # Just four, not five
for block in range(BLOCKS_PER_LINE):
index = LETTERS_PER_LINE * line_number + \
LETTERS_PER_BLOCK * block
handle.write((" %s" % data[index:index + LETTERS_PER_BLOCK]))
handle.write(str((line_number + 1) *
LETTERS_PER_LINE).rjust(POSITION_PADDING))
handle.write("\n")
if seq_len % LETTERS_PER_LINE:
# Final (partial) line
line_number = (seq_len // LETTERS_PER_LINE)
handle.write(" ") # Just four, not five
for block in range(BLOCKS_PER_LINE):
index = LETTERS_PER_LINE * line_number + \
LETTERS_PER_BLOCK * block
handle.write(
(" %s" % data[index:index + LETTERS_PER_BLOCK]).ljust(11))
handle.write(str(seq_len).rjust(POSITION_PADDING))
handle.write("\n")
def _guess_consensus_alphabet(self, ambiguous):
"""Pick an (ungapped) alphabet for an alignment consesus sequence.
This just looks at the sequences we have, checks their type, and
returns as appropriate type which seems to make sense with the
sequences we've got.
"""
# Start with the (un-gapped version of) the alignment alphabet
a = Alphabet._get_base_alphabet(self.alignment._alphabet)
# Now check its compatible with all the rest of the sequences
for record in self.alignment:
# Get the (un-gapped version of) the sequence's alphabet
alt = Alphabet._get_base_alphabet(record.seq.alphabet)
if not isinstance(alt, a.__class__):
raise ValueError(
"Alignment contains a sequence with \
an incompatible alphabet."
)
# Check the ambiguous character we are going to use in the consensus
# is in the alphabet's list of valid letters (if defined).
if hasattr(a, "letters") and a.letters is not None and ambiguous not in a.letters:
# We'll need to pick a more generic alphabet...
if isinstance(a, IUPAC.IUPACUnambiguousDNA):
if ambiguous in IUPAC.IUPACUnambiguousDNA().letters:
a = IUPAC.IUPACUnambiguousDNA()
else:
a = Alphabet.generic_dna
elif isinstance(a, IUPAC.IUPACUnambiguousRNA):
if ambiguous in IUPAC.IUPACUnambiguousRNA().letters:
a = IUPAC.IUPACUnambiguousRNA()
else:
a = Alphabet.generic_rna
elif isinstance(a, IUPAC.IUPACProtein):
if ambiguous in IUPAC.ExtendedIUPACProtein().letters:
a = IUPAC.ExtendedIUPACProtein()
else:
a = Alphabet.generic_protein
else:
a = Alphabet.single_letter_alphabet
return a
def _write_the_first_lines(self, record):
"""Write the ID and AC lines."""
if "." in record.id and record.id.rsplit(".",1)[1].isdigit():
version = "SV " + record.id.rsplit(".",1)[1]
accession = self._get_annotation_str(record, "accession",
record.id.rsplit(".",1)[0],
just_first=True)
else :
version = ""
accession = self._get_annotation_str(record, "accession",
record.id,
just_first=True)
if ";" in accession :
raise ValueError("Cannot have semi-colon in EMBL accession, %s" \
% repr(accession))
if " " in accession :
#This is out of practicallity... might it be allowed?
raise ValueError("Cannot have spaces in EMBL accession, %s" \
% repr(accession))
#Get the molecule type
#TODO - record this explicitly in the parser?
#Get the base alphabet (underneath any Gapped or StopCodon encoding)
a = Alphabet._get_base_alphabet(record.seq.alphabet)
if not isinstance(a, Alphabet.Alphabet):
raise TypeError("Invalid alphabet")
elif not isinstance(a, Alphabet.NucleotideAlphabet):
raise ValueError("Need a Nucleotide alphabet")
elif isinstance(a, Alphabet.DNAAlphabet):
mol_type = "DNA"
elif isinstance(a, Alphabet.RNAAlphabet):
mol_type = "RNA"
else:
#Must be something like NucleotideAlphabet
raise ValueError("Need a DNA or RNA alphabet")
#TODO - Full ID line
handle = self.handle
self._write_single_line("ID", "%s; %s; ; %s; ; ; %i BP." \
% (accession, version, mol_type, len(record)))
handle.write("XX\n")
self._write_single_line("AC", accession+";")
handle.write("XX\n")
def _classify_alphabet_for_nexus(self, alphabet):
"""Returns 'protein', 'dna', 'rna' based on the alphabet (PRIVATE).
Raises an exception if this is not possible."""
# Get the base alphabet (underneath any Gapped or StopCodon encoding)
a = Alphabet._get_base_alphabet(alphabet)
if not isinstance(a, Alphabet.Alphabet):
raise TypeError("Invalid alphabet")
elif isinstance(a, Alphabet.ProteinAlphabet):
return "protein"
elif isinstance(a, Alphabet.DNAAlphabet):
return "dna"
elif isinstance(a, Alphabet.RNAAlphabet):
return "rna"
else:
# Must be something like NucleotideAlphabet or
# just the generic Alphabet (default for fasta files)
raise ValueError("Need a DNA, RNA or Protein alphabet")
def _classify_alphabet_for_nexus(self, alphabet):
"""Returns 'protein', 'dna', 'rna' based on the alphabet (PRIVATE).
Raises an exception if this is not possible."""
#Get the base alphabet (underneath any Gapped or StopCodon encoding)
a = Alphabet._get_base_alphabet(alphabet)
if not isinstance(a, Alphabet.Alphabet):
raise TypeError("Invalid alphabet")
elif isinstance(a, Alphabet.ProteinAlphabet):
return "protein"
elif isinstance(a, Alphabet.DNAAlphabet):
return "dna"
elif isinstance(a, Alphabet.RNAAlphabet):
return "rna"
else:
#Must be something like NucleotideAlphabet or
#just the generic Alphabet (default for fasta files)
raise ValueError("Need a DNA, RNA or Protein alphabet")
def _write_references(self, record):
number = 0
for ref in record.annotations["references"]:
if not isinstance(ref, SeqFeature.Reference):
continue
number += 1
data = str(number)
# TODO - support more complex record reference locations?
if ref.location and len(ref.location) == 1:
a = Alphabet._get_base_alphabet(record.seq.alphabet)
if isinstance(a, Alphabet.ProteinAlphabet):
units = "residues"
else:
units = "bases"
data += " (%s %i to %i)" % (units,
ref.location[0].nofuzzy_start + 1,
ref.location[0].nofuzzy_end)
self._write_single_line("REFERENCE", data)
if ref.authors:
# We store the AUTHORS data as a single string
self._write_multi_line(" AUTHORS", ref.authors)
if ref.consrtm:
# We store the consortium as a single string
self._write_multi_line(" CONSRTM", ref.consrtm)
if ref.title:
# We store the title as a single string
self._write_multi_line(" TITLE", ref.title)
if ref.journal:
# We store this as a single string - holds the journal name,
# volume, year, and page numbers of the citation
self._write_multi_line(" JOURNAL", ref.journal)
if ref.medline_id:
# This line type is obsolete and was removed from the GenBank
# flatfile format in April 2005. Should we write it?
# Note this has a two space indent:
self._write_multi_line(" MEDLINE", ref.medline_id)
if ref.pubmed_id:
# Note this has a THREE space indent:
self._write_multi_line(" PUBMED", ref.pubmed_id)
if ref.comment:
self._write_multi_line(" REMARK", ref.comment)
def _write_references(self, record):
number = 0
for ref in record.annotations["references"]:
if not isinstance(ref, SeqFeature.Reference):
continue
number += 1
data = str(number)
# TODO - support more complex record reference locations?
if ref.location and len(ref.location) == 1:
a = Alphabet._get_base_alphabet(record.seq.alphabet)
if isinstance(a, Alphabet.ProteinAlphabet):
units = "residues"
else:
units = "bases"
data += " (%s %i to %i)" % (units,
ref.location[0].nofuzzy_start + 1,
ref.location[0].nofuzzy_end)
self._write_single_line("REFERENCE", data)
if ref.authors:
# We store the AUTHORS data as a single string
self._write_multi_line(" AUTHORS", ref.authors)
if ref.consrtm:
# We store the consortium as a single string
self._write_multi_line(" CONSRTM", ref.consrtm)
if ref.title:
# We store the title as a single string
self._write_multi_line(" TITLE", ref.title)
if ref.journal:
# We store this as a single string - holds the journal name,
# volume, year, and page numbers of the citation
self._write_multi_line(" JOURNAL", ref.journal)
if ref.medline_id:
# This line type is obsolete and was removed from the GenBank
# flatfile format in April 2005. Should we write it?
# Note this has a two space indent:
self._write_multi_line(" MEDLINE", ref.medline_id)
if ref.pubmed_id:
# Note this has a THREE space indent:
self._write_multi_line(" PUBMED", ref.pubmed_id)
if ref.comment:
self._write_multi_line(" REMARK", ref.comment)
def _classify_alphabet_for_nexus(self, alphabet):
"""Returns 'protein', 'dna', 'rna' based on the alphabet (PRIVATE).
Raises an exception if this is not possible."""
# Get the base alphabet (underneath any Gapped or StopCodon encoding)
a = Alphabet._get_base_alphabet(alphabet)
"""condition loop below was edited by Ambuj Kumar in order to make
it align with ConCat"""
if 'Alphabet.Alphabet' not in str(type(a)) and 'Alphabet.ProteinAlphabet' not in str(type(a)) and 'Alphabet.DNAAlphabet' not in str(type(a)) and 'Alphabet.RNAAlphabet' not in str(type(a)) and 'Alphabet.Gapped' not in str(type(a)):
raise TypeError("Invalid alphabet")
elif 'Protein' in str(type(a)):
return "protein"
elif 'DNA' in str(type(a)):
return "dna"
elif 'RNA' in str(type(a)):
return "rna"
else:
# Must be something like NucleotideAlphabet or
# just the generic Alphabet (default for fasta files)
raise ValueError("Need a DNA, RNA or Protein alphabet")
def information_content(self, start=0,
end=None,
e_freq_table=None, log_base=2,
chars_to_ignore=None, pseudo_count=0):
"""Calculate the information content for each residue along an alignment.
Arguments:
- start, end - The starting an ending points to calculate the
information content. These points should be relative to the first
sequence in the alignment, starting at zero (ie. even if the 'real'
first position in the seq is 203 in the initial sequence, for
the info content, we need to use zero). This defaults to the entire
length of the first sequence.
- e_freq_table - A FreqTable object specifying the expected frequencies
for each letter in the alphabet we are using (e.g. {'G' : 0.4,
'C' : 0.4, 'T' : 0.1, 'A' : 0.1}). Gap characters should not be
included, since these should not have expected frequencies.
- log_base - The base of the logathrim to use in calculating the
information content. This defaults to 2 so the info is in bits.
- chars_to_ignore - A listing of characters which should be ignored
in calculating the info content. Defaults to none.
Returns:
- A number representing the info content for the specified region.
Please see the Biopython manual for more information on how information
content is calculated.
"""
# if no end was specified, then we default to the end of the sequence
if end is None:
end = len(self.alignment[0].seq)
if chars_to_ignore is None:
chars_to_ignore = []
if start < 0 or end > len(self.alignment[0].seq):
raise ValueError("Start (%s) and end (%s) are not in the \
range %s to %s"
% (start, end, 0, len(self.alignment[0].seq)))
# determine random expected frequencies, if necessary
random_expected = None
if not e_freq_table:
# TODO - What about ambiguous alphabets?
base_alpha = Alphabet._get_base_alphabet(self.alignment._alphabet)
if isinstance(base_alpha, Alphabet.ProteinAlphabet):
random_expected = Protein20Random
elif isinstance(base_alpha, Alphabet.NucleotideAlphabet):
random_expected = Nucleotide4Random
else:
errstr = "Error in alphabet: not Nucleotide or Protein, "
errstr += "supply expected frequencies"
raise ValueError(errstr)
del base_alpha
elif not isinstance(e_freq_table, FreqTable.FreqTable):
raise ValueError("e_freq_table should be a FreqTable object")
# determine all of the letters we have to deal with
all_letters = self._get_all_letters()
for char in chars_to_ignore:
all_letters = all_letters.replace(char, '')
info_content = {}
for residue_num in range(start, end):
freq_dict = self._get_letter_freqs(residue_num,
self.alignment,
all_letters,
chars_to_ignore,
pseudo_count,
e_freq_table,
random_expected)
# print freq_dict,
column_score = self._get_column_info_content(freq_dict,
e_freq_table,
log_base,
random_expected)
info_content[residue_num] = column_score
# sum up the score
total_info = sum(info_content.values())
# fill in the ic_vector member: holds IC for each column
# reset ic_vector to empty list at each call
self.ic_vector = []
for (i, k) in enumerate(info_content):
self.ic_vector.append(info_content[i + start])
return total_info
# Check Bio.SeqIO.read(...)
if t_count == 1:
record = SeqIO.read(handle=open(t_filename, mode), format=t_format)
assert isinstance(record, SeqRecord)
else:
try:
record = SeqIO.read(open(t_filename), t_format)
assert False, "Bio.SeqIO.read(...) should have failed"
except ValueError:
#Expected to fail
pass
# Check alphabets
for record in records:
base_alpha = Alphabet._get_base_alphabet(record.seq.alphabet)
if isinstance(base_alpha, Alphabet.SingleLetterAlphabet):
if t_format in no_alpha_formats:
assert base_alpha == Alphabet.single_letter_alphabet # Too harsh?
else:
base_alpha = None
if base_alpha is None:
good = []
bad = []
given_alpha = None
elif isinstance(base_alpha, Alphabet.ProteinAlphabet):
good = protein_alphas
bad = dna_alphas + rna_alphas + nucleotide_alphas
elif isinstance(base_alpha, Alphabet.RNAAlphabet):
good = nucleotide_alphas + rna_alphas
bad = protein_alphas + dna_alphas
def _write_the_first_line(self, record):
"""Write the LOCUS line."""
locus = record.name
if not locus or locus == "<unknown name>":
locus = record.id
if not locus or locus == "<unknown id>":
locus = self._get_annotation_str(record,
"accession",
just_first=True)
if len(locus) > 16:
raise ValueError("Locus identifier %s is too long" % repr(locus))
if len(record) > 99999999999:
#Currently GenBank only officially support up to 350000, but
#the length field can take eleven digits
raise ValueError("Sequence too long!")
#Get the base alphabet (underneath any Gapped or StopCodon encoding)
a = Alphabet._get_base_alphabet(record.seq.alphabet)
if not isinstance(a, Alphabet.Alphabet):
raise TypeError("Invalid alphabet")
elif isinstance(a, Alphabet.ProteinAlphabet):
units = "aa"
elif isinstance(a, Alphabet.NucleotideAlphabet):
units = "bp"
else:
#Must be something like NucleotideAlphabet or
#just the generic Alphabet (default for fasta files)
raise ValueError("Need a Nucleotide or Protein alphabet")
#Get the molecule type
#TODO - record this explicitly in the parser?
if isinstance(a, Alphabet.ProteinAlphabet):
mol_type = ""
elif isinstance(a, Alphabet.DNAAlphabet):
mol_type = "DNA"
elif isinstance(a, Alphabet.RNAAlphabet):
mol_type = "RNA"
else:
#Must be something like NucleotideAlphabet or
#just the generic Alphabet (default for fasta files)
raise ValueError("Need a DNA, RNA or Protein alphabet")
try:
division = record.annotations["data_file_division"]
except KeyError:
division = "UNK"
if division not in [
"PRI", "ROD", "MAM", "VRT", "INV", "PLN", "BCT", "VRL", "PHG",
"SYN", "UNA", "EST", "PAT", "STS", "GSS", "HTG", "HTC", "ENV",
"CON"
]:
division = "UNK"
assert len(units) == 2
assert len(division) == 3
#TODO - date
#TODO - mol_type
line = "LOCUS %s %s %s %s %s %s\n" \
% (locus.ljust(16),
str(len(record)).rjust(11),
units,
mol_type.ljust(6),
division,
self._get_date(record))
assert len(line) == 79 + 1, repr(line) #plus one for new line
assert line[12:28].rstrip() == locus, \
'LOCUS line does not contain the locus at the expected position:\n' + line
assert line[28:29] == " "
assert line[29:40].lstrip() == str(len(record)), \
'LOCUS line does not contain the length at the expected position:\n' + line
#Tests copied from Bio.GenBank.Scanner
assert line[40:44] in [' bp ', ' aa '] , \
'LOCUS line does not contain size units at expected position:\n' + line
assert line[44:47] in [' ', 'ss-', 'ds-', 'ms-'], \
'LOCUS line does not have valid strand type (Single stranded, ...):\n' + line
assert line[47:54].strip() == "" \
or line[47:54].strip().find('DNA') != -1 \
or line[47:54].strip().find('RNA') != -1, \
'LOCUS line does not contain valid sequence type (DNA, RNA, ...):\n' + line
assert line[54:55] == ' ', \
'LOCUS line does not contain space at position 55:\n' + line
assert line[55:63].strip() in ['','linear','circular'], \
'LOCUS line does not contain valid entry (linear, circular, ...):\n' + line
assert line[63:64] == ' ', \
'LOCUS line does not contain space at position 64:\n' + line
assert line[67:68] == ' ', \
'LOCUS line does not contain space at position 68:\n' + line
assert line[70:71] == '-', \
'LOCUS line does not contain - at position 71 in date:\n' + line
assert line[74:75] == '-', \
'LOCUS line does not contain - at position 75 in date:\n' + line
self.handle.write(line)
def abi_iterator(handle, alphabet=None):
"""Iterator for the Abi file format."""
# raise exception is alphabet is not dna
if alphabet is not None:
if isinstance(
Alphabet._get_base_alphabet(alphabet), Alphabet.ProteinAlphabet
):
raise ValueError(
"Invalid alphabet, ABI files do not hold proteins."
)
if isinstance(
Alphabet._get_base_alphabet(alphabet), Alphabet.RNAAlphabet
):
raise ValueError("Invalid alphabet, ABI files do not hold RNA.")
# raise exception if handle mode is not 'rb'
if hasattr(handle, "mode"):
if set("rb") != set(handle.mode.lower()):
raise ValueError("ABI files has to be opened in 'rb' mode.")
# check if input file is a valid Abi file
handle.seek(0)
marker = handle.read(4)
if not marker:
# handle empty file gracefully
raise StopIteration
if marker != b"ABIF":
raise IOError("File should start ABIF, not %r" % marker)
# dirty hack for handling time information
times = {"RUND1": "", "RUND2": "", "RUNT1": "", "RUNT2": ""}
# initialize annotations
annot = dict(zip(_EXTRACT.values(), [None] * len(_EXTRACT)))
# parse header and extract data from directories
header = struct.unpack(_HEADFMT, handle.read(struct.calcsize(_HEADFMT)))
for tag_name, tag_number, tag_data in _abi_parse_header(header, handle):
# stop iteration if all desired tags have been extracted
# 4 tags from _EXTRACT + 2 time tags from _SPCTAGS - 3,
# and seq, qual, id
# todo
key = tag_name + str(tag_number)
# PBAS2 is base-called sequence
if key == "PBAS2":
seq = tag_data
ambigs = "KYWMRS"
if alphabet is None:
if set(seq).intersection(ambigs):
alphabet = ambiguous_dna
else:
alphabet = unambiguous_dna
# PCON2 is quality values of base-called sequence
elif key == "PCON2":
qual = [ord(val) for val in tag_data]
# PLOC2 is the location of peaks
elif key == "PLOC2":
peakamps = [float(val) for val in tag_data]
annot["peak positions"] = peakamps
# DATA1-DATA4 is raw channel 1-4 output, DATA9-12 the analyzed one
elif key in ["DATA9", "DATA10", "DATA11", "DATA12"]:
rawch = [float(val) for val in tag_data]
annot["channel " + str(int(key[4:]) - 8)] = rawch
# FWO_1 is the order of channels in bases
elif key == "FWO_1":
channelorders = tag_data
annot["channels"] = channelorders
# SMPL1 is sample id entered before sequencing run
elif key == "SMPL1":
sample_id = tag_data
elif key in times:
times[key] = tag_data
else:
# extract sequence annotation as defined in _EXTRACT
if key in _EXTRACT:
annot[_EXTRACT[key]] = tag_data
# set time annotations
annot["run_start"] = "%s %s" % (times["RUND1"], times["RUNT1"])
annot["run_finish"] = "%s %s" % (times["RUND2"], times["RUNT2"])
# use the file name as SeqRecord.name if available
# try:
file_name = basename(handle.name).replace(".ab1", "")
# except:
# file_name = ""
record = SeqRecord(
Seq(seq, alphabet),
id=sample_id,
name=file_name,
description="",
annotations=annot,
letter_annotations={"phred_quality": qual},
)
# yield _abi_trim(record)
yield record
def iterate(self, handle):
"""Parse the file and generate SeqRecord objects."""
alphabet = self.alphabet
# raise exception if alphabet is not dna
if alphabet is not None:
if isinstance(Alphabet._get_base_alphabet(alphabet),
Alphabet.ProteinAlphabet):
raise ValueError(
"Invalid alphabet, ABI files do not hold proteins.")
if isinstance(Alphabet._get_base_alphabet(alphabet),
Alphabet.RNAAlphabet):
raise ValueError(
"Invalid alphabet, ABI files do not hold RNA.")
# dirty hack for handling time information
times = {"RUND1": "", "RUND2": "", "RUNT1": "", "RUNT2": ""}
# initialize annotations
annot = dict(zip(_EXTRACT.values(), [None] * len(_EXTRACT)))
# parse header and extract data from directories
header = struct.unpack(_HEADFMT,
handle.read(struct.calcsize(_HEADFMT)))
# Set default sample ID value, which we expect to be present in most
# cases in the SMPL1 tag, but may be missing.
sample_id = "<unknown id>"
raw = {}
for tag_name, tag_number, tag_data in _abi_parse_header(
header, handle):
key = tag_name + str(tag_number)
raw[key] = tag_data
# PBAS2 is base-called sequence, only available in 3530
if key == "PBAS2":
seq = tag_data.decode()
ambigs = "KYWMRS"
if alphabet is None:
if set(seq).intersection(ambigs):
alphabet = ambiguous_dna
else:
alphabet = unambiguous_dna
# PCON2 is quality values of base-called sequence
elif key == "PCON2":
qual = [ord(val) for val in tag_data.decode()]
# SMPL1 is sample id entered before sequencing run, it must be
# a string.
elif key == "SMPL1":
sample_id = _get_string_tag(tag_data)
elif key in times:
times[key] = tag_data
else:
if key in _EXTRACT:
annot[_EXTRACT[key]] = tag_data
# set time annotations
annot["run_start"] = "%s %s" % (times["RUND1"], times["RUNT1"])
annot["run_finish"] = "%s %s" % (times["RUND2"], times["RUNT2"])
# raw data (for advanced end users benefit)
annot["abif_raw"] = raw
# fsa check
is_fsa_file = all(tn not in raw for tn in ("PBAS1", "PBAS2"))
if is_fsa_file:
try:
file_name = basename(handle.name).replace(".fsa", "")
except AttributeError:
file_name = ""
sample_id = _get_string_tag(raw.get("LIMS1"), sample_id)
description = _get_string_tag(raw.get("CTID1"),
"<unknown description>")
record = SeqRecord(
Seq(""),
id=sample_id,
name=file_name,
description=description,
annotations=annot,
)
else:
# use the file name as SeqRecord.name if available
try:
file_name = basename(handle.name).replace(".ab1", "")
except AttributeError:
file_name = ""
record = SeqRecord(
Seq(seq, alphabet),
id=sample_id,
name=file_name,
description="",
annotations=annot,
letter_annotations={"phred_quality": qual},
)
if self.trim and not is_fsa_file:
record = _abi_trim(record)
record.annotations["molecule_type"] = "DNA"
yield record
def AbiIterator(handle, alphabet=None, trim=False):
"""Iterator for the Abi file format.
"""
# raise exception is alphabet is not dna
if alphabet is not None:
if isinstance(Alphabet._get_base_alphabet(alphabet),
Alphabet.ProteinAlphabet):
raise ValueError(
"Invalid alphabet, ABI files do not hold proteins.")
if isinstance(Alphabet._get_base_alphabet(alphabet),
Alphabet.RNAAlphabet):
raise ValueError("Invalid alphabet, ABI files do not hold RNA.")
# raise exception if handle mode is not 'rb'
if hasattr(handle, 'mode'):
if set('rb') != set(handle.mode.lower()):
raise ValueError("ABI files has to be opened in 'rb' mode.")
# check if input file is a valid Abi file
handle.seek(0)
marker = handle.read(4)
if not marker:
# handle empty file gracefully
raise StopIteration
if marker != b"ABIF":
raise IOError('File should start ABIF, not %r' % marker)
# dirty hack for handling time information
times = {
'RUND1': '',
'RUND2': '',
'RUNT1': '',
'RUNT2': '',
}
# initialize annotations
annot = dict(zip(_EXTRACT.values(), [None] * len(_EXTRACT)))
# parse header and extract data from directories
header = struct.unpack(_HEADFMT, handle.read(struct.calcsize(_HEADFMT)))
raw = dict()
for tag_name, tag_number, tag_data in _abi_parse_header(header, handle):
key = tag_name + str(tag_number)
raw[key] = tag_data
# PBAS2 is base-called sequence, only available in 3530
if key == 'PBAS2':
seq = tag_data
ambigs = 'KYWMRS'
if alphabet is None:
if set(seq).intersection(ambigs):
alphabet = ambiguous_dna
else:
alphabet = unambiguous_dna
# PCON2 is quality values of base-called sequence
elif key == 'PCON2':
qual = [ord(val) for val in tag_data]
# SMPL1 is sample id entered before sequencing run
elif key == 'SMPL1':
sample_id = tag_data
elif key in times:
times[key] = tag_data
else:
if key in _EXTRACT:
annot[_EXTRACT[key]] = tag_data
# set time annotations
annot['run_start'] = '%s %s' % (times['RUND1'], times['RUNT1'])
annot['run_finish'] = '%s %s' % (times['RUND2'], times['RUNT2'])
# raw data (for advanced end users benefit)
annot['abif_raw'] = raw
# fsa check
is_fsa_file = set(['SpNm1', 'LIMS1', 'CTID1']).issubset(raw)
if is_fsa_file:
try:
file_name = basename(handle.name).replace('.fsa', '')
except AttributeError:
file_name = ""
sample_id = raw['LIMS1']
description = raw['CTID1']
record = SeqRecord(Seq(''),
id=sample_id,
name=file_name,
description=description,
annotations=annot)
else:
# use the file name as SeqRecord.name if available
try:
file_name = basename(handle.name).replace('.ab1', '')
except AttributeError:
file_name = ""
record = SeqRecord(Seq(seq, alphabet),
id=sample_id,
name=file_name,
description='',
annotations=annot,
letter_annotations={'phred_quality': qual})
if not trim or is_fsa_file:
yield record
else:
yield _abi_trim(record)
def AbiIterator(handle, alphabet=None, trim=False):
"""Iterator for the Abi file format."""
# raise exception is alphabet is not dna
if alphabet is not None:
if isinstance(Alphabet._get_base_alphabet(alphabet),
Alphabet.ProteinAlphabet):
raise ValueError(
"Invalid alphabet, ABI files do not hold proteins.")
if isinstance(Alphabet._get_base_alphabet(alphabet),
Alphabet.RNAAlphabet):
raise ValueError("Invalid alphabet, ABI files do not hold RNA.")
# raise exception if handle mode is not 'rb'
if hasattr(handle, 'mode'):
if set('rb') != set(handle.mode.lower()):
raise ValueError("ABI files has to be opened in 'rb' mode.")
# check if input file is a valid Abi file
handle.seek(0)
marker = handle.read(4)
if not marker:
# handle empty file gracefully
return
if marker != b"ABIF":
raise IOError('File should start ABIF, not %r' % marker)
# dirty hack for handling time information
times = {'RUND1': '', 'RUND2': '', 'RUNT1': '', 'RUNT2': '', }
# initialize annotations
annot = dict(zip(_EXTRACT.values(), [None] * len(_EXTRACT)))
# parse header and extract data from directories
header = struct.unpack(_HEADFMT,
handle.read(struct.calcsize(_HEADFMT)))
raw = dict()
for tag_name, tag_number, tag_data in _abi_parse_header(header, handle):
key = tag_name + str(tag_number)
raw[key] = tag_data
# PBAS2 is base-called sequence, only available in 3530
if key == 'PBAS2':
seq = tag_data
ambigs = 'KYWMRS'
if alphabet is None:
if set(seq).intersection(ambigs):
alphabet = ambiguous_dna
else:
alphabet = unambiguous_dna
# PCON2 is quality values of base-called sequence
elif key == 'PCON2':
qual = [ord(val) for val in tag_data]
# SMPL1 is sample id entered before sequencing run
elif key == 'SMPL1':
sample_id = tag_data
elif key in times:
times[key] = tag_data
else:
if key in _EXTRACT:
annot[_EXTRACT[key]] = tag_data
# set time annotations
annot['run_start'] = '%s %s' % (times['RUND1'], times['RUNT1'])
annot['run_finish'] = '%s %s' % (times['RUND2'], times['RUNT2'])
# raw data (for advanced end users benefit)
annot['abif_raw'] = raw
# fsa check
is_fsa_file = all([tn not in raw for tn in ('PBAS1', 'PBAS2')])
if is_fsa_file:
try:
file_name = basename(handle.name).replace('.fsa', '')
except AttributeError:
file_name = ""
sample_id = raw.get('LIMS1', '<unknown id>')
description = raw.get('CTID1', '<unknown description>')
record = SeqRecord(Seq(''),
id=sample_id,
name=file_name,
description=description,
annotations=annot)
else:
# use the file name as SeqRecord.name if available
try:
file_name = basename(handle.name).replace('.ab1', '')
except AttributeError:
file_name = ""
record = SeqRecord(Seq(seq, alphabet),
id=sample_id, name=file_name,
description='',
annotations=annot,
letter_annotations={'phred_quality': qual})
if not trim or is_fsa_file:
yield record
else:
yield _abi_trim(record)
def AbiIterator(handle, alphabet=None, trim=False):
"""Iterator for the Abi file format.
"""
# raise exception is alphabet is not dna
if alphabet is not None:
if isinstance(Alphabet._get_base_alphabet(alphabet),
Alphabet.ProteinAlphabet):
raise ValueError(
"Invalid alphabet, ABI files do not hold proteins.")
if isinstance(Alphabet._get_base_alphabet(alphabet),
Alphabet.RNAAlphabet):
raise ValueError("Invalid alphabet, ABI files do not hold RNA.")
# raise exception if handle mode is not 'rb'
if hasattr(handle, 'mode'):
if set('rb') != set(handle.mode.lower()):
raise ValueError("ABI files has to be opened in 'rb' mode.")
# check if input file is a valid Abi file
handle.seek(0)
marker = handle.read(4)
if not marker:
# handle empty file gracefully
raise StopIteration
if marker != _as_bytes('ABIF'):
raise IOError('File should start ABIF, not %r' % marker)
# dirty hack for handling time information
times = {
'RUND1': '',
'RUND2': '',
'RUNT1': '',
'RUNT2': '',
}
# initialize annotations
annot = dict(zip(_EXTRACT.values(), [None] * len(_EXTRACT)))
# parse header and extract data from directories
header = struct.unpack(_HEADFMT, handle.read(struct.calcsize(_HEADFMT)))
for tag_name, tag_number, tag_data in _abi_parse_header(header, handle):
# stop iteration if all desired tags have been extracted
# 4 tags from _EXTRACT + 2 time tags from _SPCTAGS - 3,
# and seq, qual, id
# todo
key = tag_name + str(tag_number)
# PBAS2 is base-called sequence
if key == 'PBAS2':
seq = tag_data
ambigs = 'KYWMRS'
if alphabet is None:
if set(seq).intersection(ambigs):
alphabet = ambiguous_dna
else:
alphabet = unambiguous_dna
# PCON2 is quality values of base-called sequence
elif key == 'PCON2':
qual = [ord(val) for val in tag_data]
# DATA9 is first processed trace data set
elif key == 'DATA9':
data9 = tag_data
# DATA10 is second processed trace data set
elif key == 'DATA10':
data10 = tag_data
# DATA11 is third processed trace data set
elif key == 'DATA11':
data11 = tag_data
# DATA12 is fourth processed trace data set
elif key == 'DATA12':
data12 = tag_data
# PLOC1 is location for each base call position
elif key == 'PLOC1':
ploc1 = tag_data
# SMPL1 is sample id entered before sequencing run
elif key == 'SMPL1':
sample_id = tag_data
elif key in times:
times[key] = tag_data
else:
# extract sequence annotation as defined in _EXTRACT
if key in _EXTRACT:
annot[_EXTRACT[key]] = tag_data
# set time annotations
annot['run_start'] = '%s %s' % (times['RUND1'], times['RUNT1'])
annot['run_finish'] = '%s %s' % (times['RUND2'], times['RUNT2'])
# use the file name as SeqRecord.name if available
try:
file_name = basename(handle.name).replace('.ab1', '')
except:
file_name = ""
record = SeqRecord(Seq(seq, alphabet),
id=sample_id,
name=file_name,
description='',
annotations=annot,
data1=data9,
data2=data10,
data3=data11,
data4=data12,
pos=ploc1,
letter_annotations={'phred_quality': qual})
if not trim:
yield record
else:
yield _abi_trim(record)
def write_file(self, records):
"""Write the specified record to a Xdna file.
Note that the function expects a list (or iterable) of records
as per the SequenceWriter interface, but the list should contain
only one record as the Xdna format is a mono-record format.
"""
records = iter(records)
try:
record = next(records)
except StopIteration:
raise ValueError("Must have one sequence")
try:
next(records)
raise ValueError("More than one sequence found")
except StopIteration:
pass
self._has_truncated_strings = False
alptype = Alphabet._get_base_alphabet(record.seq.alphabet)
if isinstance(alptype, Alphabet.DNAAlphabet):
seqtype = 1
elif isinstance(alptype, Alphabet.RNAAlphabet):
seqtype = 3
elif isinstance(alptype, Alphabet.ProteinAlphabet):
seqtype = 4
else:
seqtype = 0
if record.annotations.get("topology", "linear") == "circular":
topology = 1
else:
topology = 0
# We store the record's id and description in the comment field.
# Make sure to avoid duplicating the id if it is already
# contained in the description.
if record.description.startswith(record.id):
comment = record.description
else:
comment = f"{record.id} {record.description}"
# Write header
self.handle.write(
pack(
">BBB25xII60xI11xB",
0, # version
seqtype,
topology,
len(record),
0, # negative length
len(comment),
255, # end of header
))
# Actual sequence and comment
self.handle.write(str(record.seq).encode("ASCII"))
self.handle.write(comment.encode("ASCII"))
self.handle.write(pack(">B", 0)) # Annotation section marker
self._write_pstring("0") # right-side overhang
self._write_pstring("0") # left-side overhand
# Write features
# We must skip features with fuzzy locations as they cannot be
# represented in the Xdna format
features = [
f for f in record.features
if type(f.location.start) == ExactPosition
and type(f.location.end) == ExactPosition
]
drop = len(record.features) - len(features)
if drop > 0:
warnings.warn(f"Dropping {drop} features with fuzzy locations",
BiopythonWarning)
# We also cannot store more than 255 features as the number of
# features is stored on a single byte...
if len(features) > 255:
drop = len(features) - 255
warnings.warn(f"Too many features, dropping the last {drop}",
BiopythonWarning)
features = features[:255]
self.handle.write(pack(">B", len(features)))
for feature in features:
self._write_pstring(feature.qualifiers.get("label", [""])[0])
description = ""
for qname in feature.qualifiers:
if qname in ("label", "translation"):
continue
for val in feature.qualifiers[qname]:
if len(description) > 0:
description = description + "\x0D"
description = description + '%s="%s"' % (qname, val)
self._write_pstring(description)
self._write_pstring(feature.type)
start = feature.location.start.position + 1 # 1-based coordinates
end = feature.location.end.position
strand = 1
if feature.location.strand == -1:
start, end = end, start
strand = 0
self._write_pstring(str(start))
self._write_pstring(str(end))
self.handle.write(pack(">BBBB", strand, 1, 0, 1))
self._write_pstring("127,127,127")
if self._has_truncated_strings:
warnings.warn("Some annotations were truncated to 255 characters",
BiopythonWarning)
return 1
def AbiIterator(handle, alphabet=None, trim=False):
"""Return an iterator for the Abi file format."""
# raise exception is alphabet is not dna
if alphabet is not None:
if isinstance(Alphabet._get_base_alphabet(alphabet), Alphabet.ProteinAlphabet):
raise ValueError("Invalid alphabet, ABI files do not hold proteins.")
if isinstance(Alphabet._get_base_alphabet(alphabet), Alphabet.RNAAlphabet):
raise ValueError("Invalid alphabet, ABI files do not hold RNA.")
# raise exception if handle mode is not 'rb'
if hasattr(handle, "mode"):
if set("rb") != set(handle.mode.lower()):
raise ValueError("ABI files has to be opened in 'rb' mode.")
# check if input file is a valid Abi file
handle.seek(0)
marker = handle.read(4)
if not marker:
# handle empty file gracefully
return
if marker != b"ABIF":
raise IOError("File should start ABIF, not %r" % marker)
# dirty hack for handling time information
times = {"RUND1": "", "RUND2": "", "RUNT1": "", "RUNT2": ""}
# initialize annotations
annot = dict(zip(_EXTRACT.values(), [None] * len(_EXTRACT)))
# parse header and extract data from directories
header = struct.unpack(_HEADFMT, handle.read(struct.calcsize(_HEADFMT)))
# Set default sample ID value, which we expect to be present in most cases
# in the SMPL1 tag, but may be missing.
sample_id = "<unknown id>"
raw = {}
for tag_name, tag_number, tag_data in _abi_parse_header(header, handle):
key = tag_name + str(tag_number)
raw[key] = tag_data
# PBAS2 is base-called sequence, only available in 3530
if key == "PBAS2":
seq = _bytes_to_string(tag_data)
ambigs = "KYWMRS"
if alphabet is None:
if set(seq).intersection(ambigs):
alphabet = ambiguous_dna
else:
alphabet = unambiguous_dna
# PCON2 is quality values of base-called sequence
elif key == "PCON2":
qual = [ord(val) for val in _bytes_to_string(tag_data)]
# SMPL1 is sample id entered before sequencing run, it must be a string.
elif key == "SMPL1":
sample_id = _get_string_tag(tag_data)
elif key in times:
times[key] = tag_data
else:
if key in _EXTRACT:
annot[_EXTRACT[key]] = tag_data
# set time annotations
annot["run_start"] = "%s %s" % (times["RUND1"], times["RUNT1"])
annot["run_finish"] = "%s %s" % (times["RUND2"], times["RUNT2"])
# raw data (for advanced end users benefit)
annot["abif_raw"] = raw
# fsa check
is_fsa_file = all(tn not in raw for tn in ("PBAS1", "PBAS2"))
if is_fsa_file:
try:
file_name = basename(handle.name).replace(".fsa", "")
except AttributeError:
file_name = ""
sample_id = _get_string_tag(raw.get("LIMS1"), sample_id)
description = _get_string_tag(raw.get("CTID1"), "<unknown description>")
record = SeqRecord(
Seq(""),
id=sample_id,
name=file_name,
description=description,
annotations=annot,
)
else:
# use the file name as SeqRecord.name if available
try:
file_name = basename(handle.name).replace(".ab1", "")
except AttributeError:
file_name = ""
record = SeqRecord(
Seq(seq, alphabet),
id=sample_id,
name=file_name,
description="",
annotations=annot,
letter_annotations={"phred_quality": qual},
)
if not trim or is_fsa_file:
yield record
else:
yield _abi_trim(record)
def molecular_weight(seq, seq_type=None, double_stranded=False, circular=False,
monoisotopic=False):
"""Calculates the molecular weight of a DNA, RNA or protein sequence.
Only unambiguous letters are allowed. Nucleotide sequences are assumed to
have a 5' phosphate.
- seq: String or Biopython sequence object.
- seq_type: The default (None) is to take the alphabet from the seq argument,
or assume DNA if the seq argument is a string. Override this with
a string 'DNA', 'RNA', or 'protein'.
- double_stranded: Calculate the mass for the double stranded molecule?
- circular: Is the molecule circular (has no ends)?
- monoisotopic: Use the monoisotopic mass tables?
Note that for backwards compatibility, if the seq argument is a string,
or Seq object with a generic alphabet, and no seq_type is specified
(i.e. left as None), then DNA is assumed.
>>> print("%0.2f" % molecular_weight("AGC"))
949.61
>>> print("%0.2f" % molecular_weight(Seq("AGC")))
949.61
However, it is better to be explicit - for example with strings:
>>> print("%0.2f" % molecular_weight("AGC", "DNA"))
949.61
>>> print("%0.2f" % molecular_weight("AGC", "RNA"))
997.61
>>> print("%0.2f" % molecular_weight("AGC", "protein"))
249.29
Or, with the sequence alphabet:
>>> from Bio.Seq import Seq
>>> from Bio.Alphabet import generic_dna, generic_rna, generic_protein
>>> print("%0.2f" % molecular_weight(Seq("AGC", generic_dna)))
949.61
>>> print("%0.2f" % molecular_weight(Seq("AGC", generic_rna)))
997.61
>>> print("%0.2f" % molecular_weight(Seq("AGC", generic_protein)))
249.29
Also note that contradictory sequence alphabets and seq_type will also
give an exception:
>>> from Bio.Seq import Seq
>>> from Bio.Alphabet import generic_dna
>>> print("%0.2f" % molecular_weight(Seq("AGC", generic_dna), "RNA"))
Traceback (most recent call last):
...
ValueError: seq_type='RNA' contradicts DNA from seq alphabet
"""
# Rewritten by Markus Piotrowski, 2014
# Find the alphabet type
tmp_type = ''
if isinstance(seq, Seq) or isinstance(seq, MutableSeq):
base_alphabet = Alphabet._get_base_alphabet(seq.alphabet)
if isinstance(base_alphabet, Alphabet.DNAAlphabet):
tmp_type = 'DNA'
elif isinstance(base_alphabet, Alphabet.RNAAlphabet):
tmp_type = 'RNA'
elif isinstance(base_alphabet, Alphabet.ProteinAlphabet):
tmp_type = 'protein'
elif isinstance(base_alphabet, Alphabet.ThreeLetterProtein):
tmp_type = 'protein'
# Convert to one-letter sequence. Have to use a string for seq1
seq = Seq(seq1(str(seq)), alphabet=Alphabet.ProteinAlphabet())
elif not isinstance(base_alphabet, Alphabet.Alphabet):
raise TypeError("%s is not a valid alphabet for mass calculations"
% base_alphabet)
else:
tmp_type = "DNA" # backward compatibity
if seq_type and tmp_type and tmp_type != seq_type:
raise ValueError("seq_type=%r contradicts %s from seq alphabet"
% (seq_type, tmp_type))
seq_type = tmp_type
elif isinstance(seq, str):
if seq_type is None:
seq_type = "DNA" # backward compatibity
else:
raise TypeError("Expected a string or Seq object, not seq=%r" % seq)
seq = ''.join(str(seq).split()).upper() # Do the minimum formatting
if seq_type == 'DNA':
if monoisotopic:
weight_table = IUPACData.monoisotopic_unambiguous_dna_weights
else:
weight_table = IUPACData.unambiguous_dna_weights
elif seq_type == 'RNA':
if monoisotopic:
weight_table = IUPACData.monoisotopic_unambiguous_rna_weights
else:
weight_table = IUPACData.unambiguous_rna_weights
elif seq_type == 'protein':
if monoisotopic:
weight_table = IUPACData.monoisotopic_protein_weights
else:
weight_table = IUPACData.protein_weights
else:
raise ValueError("Allowed seq_types are DNA, RNA or protein, not %r"
% seq_type)
if monoisotopic:
water = 18.010565
else:
water = 18.0153
try:
weight = sum(weight_table[x] for x in seq) - (len(seq)-1) * water
if circular:
weight -= water
except KeyError as e:
raise ValueError('%s is not a valid unambiguous letter for %s'
%(e, seq_type))
except:
raise
if seq_type in ('DNA', 'RNA') and double_stranded:
seq = str(Seq(seq).complement())
weight += sum(weight_table[x] for x in seq) - (len(seq)-1) * water
if circular:
weight -= water
elif seq_type == 'protein' and double_stranded:
raise ValueError('double-stranded proteins await their discovery')
return weight
def _write_the_first_line(self, record):
"""Write the LOCUS line."""
locus = record.name
if not locus or locus == "<unknown name>":
locus = record.id
if not locus or locus == "<unknown id>":
locus = self._get_annotation_str(record,
"accession",
just_first=True)
if len(locus) > 16:
if len(locus) + 1 + len(str(len(record))) > 28:
# Locus name and record length to long to squeeze in.
raise ValueError("Locus identifier %r is too long" % locus)
else:
warnings.warn(
"Stealing space from length field to allow long name in LOCUS line",
BiopythonWarning)
if len(locus.split()) > 1:
# locus could be unicode, and u'with space' versus 'with space'
# causes trouble with doctest or print-and-compare tests, so
tmp = repr(locus)
if tmp.startswith("u'") and tmp.endswith("'"):
tmp = tmp[1:]
raise ValueError("Invalid whitespace in %s for LOCUS line" % tmp)
if len(record) > 99999999999:
# Currently GenBank only officially support up to 350000, but
# the length field can take eleven digits
raise ValueError("Sequence too long!")
# Get the base alphabet (underneath any Gapped or StopCodon encoding)
a = Alphabet._get_base_alphabet(record.seq.alphabet)
if not isinstance(a, Alphabet.Alphabet):
raise TypeError("Invalid alphabet")
elif isinstance(a, Alphabet.ProteinAlphabet):
units = "aa"
elif isinstance(a, Alphabet.NucleotideAlphabet):
units = "bp"
else:
# Must be something like NucleotideAlphabet or
# just the generic Alphabet (default for fasta files)
raise ValueError("Need a Nucleotide or Protein alphabet")
# Get the molecule type
# TODO - record this explicitly in the parser?
if isinstance(a, Alphabet.ProteinAlphabet):
mol_type = ""
elif isinstance(a, Alphabet.DNAAlphabet):
mol_type = "DNA"
elif isinstance(a, Alphabet.RNAAlphabet):
mol_type = "RNA"
else:
# Must be something like NucleotideAlphabet or
# just the generic Alphabet (default for fasta files)
raise ValueError("Need a DNA, RNA or Protein alphabet")
topology = self._get_topology(record)
division = self._get_data_division(record)
name_length = str(len(record)).rjust(28)
name_length = locus + name_length[len(locus):]
assert len(name_length) == 28, name_length
assert " " in name_length, name_length
assert len(units) == 2
assert len(division) == 3
line = "LOCUS %s %s %s %s %s %s\n" \
% (name_length,
units,
mol_type.ljust(7),
topology,
division,
self._get_date(record))
assert len(line) == 79 + 1, repr(line) # plus one for new line
# We're bending the rules to allow an identifier over 16 characters
# if we can steal spaces from the length field:
# assert line[12:28].rstrip() == locus, \
# 'LOCUS line does not contain the locus at the expected position:\n' + line
# assert line[28:29] == " "
# assert line[29:40].lstrip() == str(len(record)), \
# 'LOCUS line does not contain the length at the expected position:\n' + line
assert line[12:40].split() == [locus, str(len(record))], line
# Tests copied from Bio.GenBank.Scanner
assert line[40:44] in [' bp ', ' aa '], \
'LOCUS line does not contain size units at expected position:\n' + \
line
assert line[44:47] in [' ', 'ss-', 'ds-', 'ms-'], \
'LOCUS line does not have valid strand type (Single stranded, ...):\n' + line
assert line[47:54].strip() == "" \
or 'DNA' in line[47:54].strip() \
or 'RNA' in line[47:54].strip(), \
'LOCUS line does not contain valid sequence type (DNA, RNA, ...):\n' + line
assert line[54:55] == ' ', \
'LOCUS line does not contain space at position 55:\n' + line
assert line[55:63].strip() in ['', 'linear', 'circular'], \
'LOCUS line does not contain valid entry (linear, circular, ...):\n' + line
assert line[63:64] == ' ', \
'LOCUS line does not contain space at position 64:\n' + line
assert line[67:68] == ' ', \
'LOCUS line does not contain space at position 68:\n' + line
assert line[70:71] == '-', \
'LOCUS line does not contain - at position 71 in date:\n' + line
assert line[74:75] == '-', \
'LOCUS line does not contain - at position 75 in date:\n' + line
self.handle.write(line)
def information_content(self, start=0,
end=None,
e_freq_table=None, log_base=2,
chars_to_ignore=[]):
"""Calculate the information content for each residue along an alignment.
Arguments:
- start, end - The starting an ending points to calculate the
information content. These points should be relative to the first
sequence in the alignment, starting at zero (ie. even if the 'real'
first position in the seq is 203 in the initial sequence, for
the info content, we need to use zero). This defaults to the entire
length of the first sequence.
- e_freq_table - A FreqTable object specifying the expected frequencies
for each letter in the alphabet we are using (e.g. {'G' : 0.4,
'C' : 0.4, 'T' : 0.1, 'A' : 0.1}). Gap characters should not be
included, since these should not have expected frequencies.
- log_base - The base of the logathrim to use in calculating the
information content. This defaults to 2 so the info is in bits.
- chars_to_ignore - A listing of characterw which should be ignored
in calculating the info content.
Returns:
- A number representing the info content for the specified region.
Please see the Biopython manual for more information on how information
content is calculated.
"""
# if no end was specified, then we default to the end of the sequence
if end is None:
end = len(self.alignment._records[0].seq)
if start < 0 or end > len(self.alignment._records[0].seq):
raise ValueError("Start (%s) and end (%s) are not in the \
range %s to %s"
% (start, end, 0, len(self.alignment._records[0].seq)))
# determine random expected frequencies, if necessary
random_expected = None
if not e_freq_table:
# TODO - What about ambiguous alphabets?
base_alpha = Alphabet._get_base_alphabet(self.alignment._alphabet)
if isinstance(base_alpha, Alphabet.ProteinAlphabet):
random_expected = Protein20Random
elif isinstance(base_alpha, Alphabet.NucleotideAlphabet):
random_expected = Nucleotide4Random
else:
errstr = "Error in alphabet: not Nucleotide or Protein, "
errstr += "supply expected frequencies"
raise ValueError(errstr)
del base_alpha
elif not isinstance(e_freq_table, FreqTable.FreqTable):
raise ValueError("e_freq_table should be a FreqTable object")
# determine all of the letters we have to deal with
all_letters = self._get_all_letters()
for char in chars_to_ignore:
all_letters = all_letters.replace(char, '')
info_content = {}
for residue_num in range(start, end):
freq_dict = self._get_letter_freqs(residue_num,
self.alignment._records,
all_letters, chars_to_ignore)
# print freq_dict,
column_score = self._get_column_info_content(freq_dict,
e_freq_table,
log_base,
random_expected)
info_content[residue_num] = column_score
# sum up the score
total_info = sum(info_content.values())
# fill in the ic_vector member: holds IC for each column
for i in info_content:
self.ic_vector[i] = info_content[i]
return total_info
def _write_the_first_line(self, record):
"""Write the LOCUS line."""
locus = record.name
if not locus or locus == "<unknown name>":
locus = record.id
if not locus or locus == "<unknown id>":
locus = self._get_annotation_str(
record, "accession", just_first=True)
if len(locus) > 16:
raise ValueError("Locus identifier %r is too long" % str(locus))
if len(record) > 99999999999:
# Currently GenBank only officially support up to 350000, but
# the length field can take eleven digits
raise ValueError("Sequence too long!")
# Get the base alphabet (underneath any Gapped or StopCodon encoding)
a = Alphabet._get_base_alphabet(record.seq.alphabet)
if not isinstance(a, Alphabet.Alphabet):
raise TypeError("Invalid alphabet")
elif isinstance(a, Alphabet.ProteinAlphabet):
units = "aa"
elif isinstance(a, Alphabet.NucleotideAlphabet):
units = "bp"
else:
# Must be something like NucleotideAlphabet or
# just the generic Alphabet (default for fasta files)
raise ValueError("Need a Nucleotide or Protein alphabet")
# Get the molecule type
# TODO - record this explicitly in the parser?
if isinstance(a, Alphabet.ProteinAlphabet):
mol_type = ""
elif isinstance(a, Alphabet.DNAAlphabet):
mol_type = "DNA"
elif isinstance(a, Alphabet.RNAAlphabet):
mol_type = "RNA"
else:
# Must be something like NucleotideAlphabet or
# just the generic Alphabet (default for fasta files)
raise ValueError("Need a DNA, RNA or Protein alphabet")
division = self._get_data_division(record)
assert len(units) == 2
assert len(division) == 3
# TODO - date
# TODO - mol_type
line = "LOCUS %s %s %s %s %s %s\n" \
% (locus.ljust(16),
str(len(record)).rjust(11),
units,
mol_type.ljust(6),
division,
self._get_date(record))
assert len(line) == 79 + 1, repr(line) # plus one for new line
assert line[12:28].rstrip() == locus, \
'LOCUS line does not contain the locus at the expected position:\n' + line
assert line[28:29] == " "
assert line[29:40].lstrip() == str(len(record)), \
'LOCUS line does not contain the length at the expected position:\n' + line
# Tests copied from Bio.GenBank.Scanner
assert line[40:44] in [' bp ', ' aa '], \
'LOCUS line does not contain size units at expected position:\n' + \
line
assert line[44:47] in [' ', 'ss-', 'ds-', 'ms-'], \
'LOCUS line does not have valid strand type (Single stranded, ...):\n' + line
assert line[47:54].strip() == "" \
or 'DNA' in line[47:54].strip() \
or 'RNA' in line[47:54].strip(), \
'LOCUS line does not contain valid sequence type (DNA, RNA, ...):\n' + line
assert line[54:55] == ' ', \
'LOCUS line does not contain space at position 55:\n' + line
assert line[55:63].strip() in ['', 'linear', 'circular'], \
'LOCUS line does not contain valid entry (linear, circular, ...):\n' + line
assert line[63:64] == ' ', \
'LOCUS line does not contain space at position 64:\n' + line
assert line[67:68] == ' ', \
'LOCUS line does not contain space at position 68:\n' + line
assert line[70:71] == '-', \
'LOCUS line does not contain - at position 71 in date:\n' + line
assert line[74:75] == '-', \
'LOCUS line does not contain - at position 75 in date:\n' + line
self.handle.write(line)
def _write_the_first_lines(self, record):
"""Write the ID and AC lines."""
if "." in record.id and record.id.rsplit(".", 1)[1].isdigit():
version = "SV " + record.id.rsplit(".", 1)[1]
accession = self._get_annotation_str(record, "accession",
record.id.rsplit(".", 1)[0],
just_first=True)
else :
version = "XXX"
accession = self._get_annotation_str(record, "accession",
record.id,
just_first=True)
if ";" in accession :
raise ValueError("Cannot have semi-colon in EMBL accession, %s" \
% repr(accession))
if " " in accession :
#This is out of practicallity... might it be allowed?
raise ValueError("Cannot have spaces in EMBL accession, %s" \
% repr(accession))
#Get the molecule type
#TODO - record this explicitly in the parser?
#Get the base alphabet (underneath any Gapped or StopCodon encoding)
a = Alphabet._get_base_alphabet(record.seq.alphabet)
if not isinstance(a, Alphabet.Alphabet):
raise TypeError("Invalid alphabet")
elif not isinstance(a, Alphabet.NucleotideAlphabet):
raise ValueError("Need a Nucleotide alphabet")
elif isinstance(a, Alphabet.DNAAlphabet):
mol_type = "DNA"
elif isinstance(a, Alphabet.RNAAlphabet):
mol_type = "RNA"
else:
#Must be something like NucleotideAlphabet
raise ValueError("Need a DNA or RNA alphabet")
#Get the topology -- circular or linear
if 'topology' in record.annotations:
topology = record.annotations['topology']
if topology not in ['linear', 'circular']:
raise ValueError("Cannot have '%s' for topology in EMBL ID line, must be 'circular' or 'linear'" % topology)
else:
topology = 'linear' # default topology
#Get the taxonomy division
division = self._get_data_division(record)
#Get Data class
data_class = self._get_data_class(record)
#Full ID line
#ID <1>; SV <2>; <3>; <4>; <5>; <6>; <7> BP.
#1. Primary accession number
#2. Sequence version number
#3. Topology: 'circular' or 'linear'
#4. Molecule type (see note 1 below)
#5. Data class (see section 3.1)
#6. Taxonomic division (see section 3.2)
#7. Sequence length (see note 2 below)
#All tokens that are non-mandatory can be represented by a universal placeholder "XXX",
#so in the ID line in the new submission can look as follows:
#ID XXX; XXX; linear; XXX; XXX; XXX; 500 BP.
handle = self.handle
self._write_single_line("ID", "%s; %s; %s; %s; %s; %s; %i BP." \
% (accession, version, topology, mol_type, data_class, division, len(record)))
handle.write("XX\n")
self._write_single_line("AC", accession+";")
handle.write("XX\n")
assert (isinstance(a,str) or isinstance(b,str)), \
"Nucleotide+Protein addition should fail!"
except TypeError :
pass
###########################################################################
print
print "Testing Seq string methods"
print "=========================="
for a in dna + rna + nuc + protein :
if not isinstance(a, Seq.Seq) : continue
assert a.strip().tostring() == a.tostring().strip()
assert a.lstrip().tostring() == a.tostring().lstrip()
assert a.rstrip().tostring() == a.tostring().rstrip()
test_chars = ["-", Seq.Seq("-"), Seq.Seq("*"), "-X@"]
alpha = Alphabet._get_base_alphabet(a.alphabet)
if isinstance(alpha, Alphabet.DNAAlphabet) :
test_chars.append(Seq.Seq("A", IUPAC.ambiguous_dna))
if isinstance(alpha, Alphabet.RNAAlphabet) :
test_chars.append(Seq.Seq("A", IUPAC.ambiguous_rna))
if isinstance(alpha, Alphabet.NucleotideAlphabet) :
test_chars.append(Seq.Seq("A", Alphabet.generic_nucleotide))
if isinstance(alpha, Alphabet.ProteinAlphabet) :
test_chars.append(Seq.Seq("K", Alphabet.generic_protein))
test_chars.append(Seq.Seq("K-", Alphabet.Gapped(Alphabet.generic_protein,"-")))
test_chars.append(Seq.Seq("K@", Alphabet.Gapped(IUPAC.protein,"@")))
#Setup a clashing alphabet sequence
b = Seq.Seq("-", Alphabet.generic_nucleotide)
else :
b = Seq.Seq("-", Alphabet.generic_protein)
try :
def AbiIterator(handle, alphabet=None, trim=False):
"""Iterator for the Abi file format.
"""
# raise exception is alphabet is not dna
if alphabet is not None:
if isinstance(Alphabet._get_base_alphabet(alphabet),
Alphabet.ProteinAlphabet):
raise ValueError(
"Invalid alphabet, ABI files do not hold proteins.")
if isinstance(Alphabet._get_base_alphabet(alphabet),
Alphabet.RNAAlphabet):
raise ValueError("Invalid alphabet, ABI files do not hold RNA.")
# raise exception if handle mode is not 'rb'
if hasattr(handle, 'mode'):
if set('rb') != set(handle.mode.lower()):
raise ValueError("ABI files has to be opened in 'rb' mode.")
# check if input file is a valid Abi file
handle.seek(0)
marker = handle.read(4)
if not marker:
# handle empty file gracefully
raise StopIteration
if marker != _as_bytes('ABIF'):
raise IOError('File should start ABIF, not %r' % marker)
# dirty hack for handling time information
times = {'RUND1': '', 'RUND2': '', 'RUNT1': '', 'RUNT2': '', }
# initialize annotations
annot = dict(zip(_EXTRACT.values(), [None] * len(_EXTRACT)))
# parse header and extract data from directories
header = struct.unpack(_HEADFMT,
handle.read(struct.calcsize(_HEADFMT)))
for tag_name, tag_number, tag_data in _abi_parse_header(header, handle):
# stop iteration if all desired tags have been extracted
# 4 tags from _EXTRACT + 2 time tags from _SPCTAGS - 3,
# and seq, qual, id
# todo
key = tag_name + str(tag_number)
# PBAS2 is base-called sequence
if key == 'PBAS2':
seq = tag_data
ambigs = 'KYWMRS'
if alphabet is None:
if set(seq).intersection(ambigs):
alphabet = ambiguous_dna
else:
alphabet = unambiguous_dna
# PCON2 is quality values of base-called sequence
elif key == 'PCON2':
qual = [ord(val) for val in tag_data]
# SMPL1 is sample id entered before sequencing run
elif key == 'SMPL1':
sample_id = tag_data
elif key in times:
times[key] = tag_data
else:
# extract sequence annotation as defined in _EXTRACT
if key in _EXTRACT:
annot[_EXTRACT[key]] = tag_data
# set time annotations
annot['run_start'] = '%s %s' % (times['RUND1'], times['RUNT1'])
annot['run_finish'] = '%s %s' % (times['RUND2'], times['RUNT2'])
# use the file name as SeqRecord.name if available
try:
file_name = basename(handle.name).replace('.ab1', '')
except:
file_name = ""
record = SeqRecord(Seq(seq, alphabet),
id=sample_id, name=file_name,
description='',
annotations=annot,
letter_annotations={'phred_quality': qual})
if not trim:
yield record
else:
yield _abi_trim(record)
# Check Bio.SeqIO.read(...)
if t_count == 1:
record = SeqIO.read(t_filename, format=t_format)
assert isinstance(record, SeqRecord)
else:
try:
record = SeqIO.read(t_filename, t_format)
assert False, "Bio.SeqIO.read(...) should have failed"
except ValueError:
# Expected to fail
pass
# Check alphabets
for record in records:
base_alpha = Alphabet._get_base_alphabet(record.seq.alphabet)
if isinstance(base_alpha, Alphabet.SingleLetterAlphabet):
if t_format in no_alpha_formats:
# Too harsh?
assert base_alpha == Alphabet.single_letter_alphabet
else:
base_alpha = None
if base_alpha is None:
good = []
bad = []
given_alpha = None
elif isinstance(base_alpha, Alphabet.ProteinAlphabet):
good = protein_alphas
bad = dna_alphas + rna_alphas + nucleotide_alphas
elif isinstance(base_alpha, Alphabet.RNAAlphabet):
good = nucleotide_alphas + rna_alphas
def _write_the_first_line(self, record):
"""Write the LOCUS line."""
locus = record.name
if not locus or locus == "<unknown name>":
locus = record.id
if not locus or locus == "<unknown id>":
locus = self._get_annotation_str(record, "accession", just_first=True)
if len(locus) > 16:
raise ValueError("Locus identifier %s is too long" % repr(locus))
if len(record) > 99999999999:
# Currently GenBank only officially support up to 350000, but
# the length field can take eleven digits
raise ValueError("Sequence too long!")
# Get the base alphabet (underneath any Gapped or StopCodon encoding)
a = Alphabet._get_base_alphabet(record.seq.alphabet)
if not isinstance(a, Alphabet.Alphabet):
raise TypeError("Invalid alphabet")
elif isinstance(a, Alphabet.ProteinAlphabet):
units = "bp"
elif isinstance(a, Alphabet.NucleotideAlphabet):
units = "aa"
else:
# Must be something like NucleotideAlphabet or
# just the generic Alphabet (default for fasta files)
raise ValueError("Need a Nucleotide or Protein alphabet")
# Get the molecule type
# TODO - record this explicitly in the parser?
if isinstance(a, Alphabet.ProteinAlphabet):
mol_type = ""
elif isinstance(a, Alphabet.DNAAlphabet):
mol_type = "DNA"
elif isinstance(a, Alphabet.RNAAlphabet):
mol_type = "RNA"
else:
# Must be something like NucleotideAlphabet or
# just the generic Alphabet (default for fasta files)
raise ValueError("Need a DNA, RNA or Protein alphabet")
try:
division = record.annotations["data_file_division"]
except KeyError:
division = "UNK"
if division not in [
"PRI",
"ROD",
"MAM",
"VRT",
"INV",
"PLN",
"BCT",
"VRL",
"PHG",
"SYN",
"UNA",
"EST",
"PAT",
"STS",
"GSS",
"HTG",
"HTC",
"ENV",
]:
division = "UNK"
assert len(units) == 2
assert len(division) == 3
# TODO - date
# TODO - mol_type
line = "LOCUS %s %s %s %s %s 01-JAN-1980\n" % (
locus.ljust(16),
str(len(record)).rjust(11),
units,
mol_type.ljust(6),
division,
)
assert len(line) == 79 + 1, repr(line) # plus one for new line
assert line[12:28].rstrip() == locus, "LOCUS line does not contain the locus at the expected position:\n" + line
assert line[28:29] == " "
assert line[29:40].lstrip() == str(len(record)), (
"LOCUS line does not contain the length at the expected position:\n" + line
)
# Tests copied from Bio.GenBank.Scanner
assert line[40:44] in [" bp ", " aa "], "LOCUS line does not contain size units at expected position:\n" + line
assert line[44:47] in [" ", "ss-", "ds-", "ms-"], (
"LOCUS line does not have valid strand type (Single stranded, ...):\n" + line
)
assert (
line[47:54].strip() == "" or line[47:54].strip().find("DNA") != -1 or line[47:54].strip().find("RNA") != -1
), ("LOCUS line does not contain valid sequence type (DNA, RNA, ...):\n" + line)
assert line[54:55] == " ", "LOCUS line does not contain space at position 55:\n" + line
assert line[55:63].strip() in ["", "linear", "circular"], (
"LOCUS line does not contain valid entry (linear, circular, ...):\n" + line
)
assert line[63:64] == " ", "LOCUS line does not contain space at position 64:\n" + line
assert line[67:68] == " ", "LOCUS line does not contain space at position 68:\n" + line
assert line[70:71] == "-", "LOCUS line does not contain - at position 71 in date:\n" + line
assert line[74:75] == "-", "LOCUS line does not contain - at position 75 in date:\n" + line
self.handle.write(line)
pass
###########################################################################
print
print "Testing Seq string methods"
print "=========================="
for a in dna + rna + nuc + protein:
if not isinstance(a, Seq.Seq):
continue
assert str(a.strip()) == str(a).strip()
assert str(a.lstrip()) == str(a).lstrip()
assert str(a.rstrip()) == str(a).rstrip()
assert str(a.lower()) == str(a).lower()
assert str(a.upper()) == str(a).upper()
test_chars = ["-", Seq.Seq("-"), Seq.Seq("*"), "-X@"]
alpha = Alphabet._get_base_alphabet(a.alphabet)
if isinstance(alpha, Alphabet.DNAAlphabet):
test_chars.append(Seq.Seq("A", IUPAC.ambiguous_dna))
if isinstance(alpha, Alphabet.RNAAlphabet):
test_chars.append(Seq.Seq("A", IUPAC.ambiguous_rna))
if isinstance(alpha, Alphabet.NucleotideAlphabet):
test_chars.append(Seq.Seq("A", Alphabet.generic_nucleotide))
if isinstance(alpha, Alphabet.ProteinAlphabet):
test_chars.append(Seq.Seq("K", Alphabet.generic_protein))
test_chars.append(
Seq.Seq("K-", Alphabet.Gapped(Alphabet.generic_protein, "-")))
test_chars.append(Seq.Seq("K@", Alphabet.Gapped(IUPAC.protein, "@")))
#Setup a clashing alphabet sequence
b = Seq.Seq("-", Alphabet.generic_nucleotide)
else:
b = Seq.Seq("-", Alphabet.generic_protein)
def _write_the_first_line(self, record):
"""Write the LOCUS line."""
locus = record.name
if not locus or locus == "<unknown name>":
locus = record.id
if not locus or locus == "<unknown id>":
locus = self._get_annotation_str(
record, "accession", just_first=True)
if len(locus) > 16:
if len(locus) + 1 + len(str(len(record))) > 28:
# Locus name and record length to long to squeeze in.
raise ValueError("Locus identifier %r is too long" % locus)
else:
warnings.warn("Stealing space from length field to allow long name in LOCUS line", BiopythonWarning)
if len(locus.split()) > 1:
# locus could be unicode, and u'with space' versus 'with space'
# causes trouble with doctest or print-and-compare tests, so
tmp = repr(locus)
if tmp.startswith("u'") and tmp.endswith("'"):
tmp = tmp[1:]
raise ValueError("Invalid whitespace in %s for LOCUS line" % tmp)
if len(record) > 99999999999:
# Currently GenBank only officially support up to 350000, but
# the length field can take eleven digits
raise ValueError("Sequence too long!")
# Get the base alphabet (underneath any Gapped or StopCodon encoding)
a = Alphabet._get_base_alphabet(record.seq.alphabet)
if not isinstance(a, Alphabet.Alphabet):
raise TypeError("Invalid alphabet")
elif isinstance(a, Alphabet.ProteinAlphabet):
units = "aa"
elif isinstance(a, Alphabet.NucleotideAlphabet):
units = "bp"
else:
# Must be something like NucleotideAlphabet or
# just the generic Alphabet (default for fasta files)
raise ValueError("Need a Nucleotide or Protein alphabet")
# Get the molecule type
# TODO - record this explicitly in the parser?
if isinstance(a, Alphabet.ProteinAlphabet):
mol_type = ""
elif isinstance(a, Alphabet.DNAAlphabet):
mol_type = "DNA"
elif isinstance(a, Alphabet.RNAAlphabet):
mol_type = "RNA"
else:
# Must be something like NucleotideAlphabet or
# just the generic Alphabet (default for fasta files)
raise ValueError("Need a DNA, RNA or Protein alphabet")
topology = self._get_topology(record)
division = self._get_data_division(record)
name_length = str(len(record)).rjust(28)
name_length = locus + name_length[len(locus):]
assert len(name_length) == 28, name_length
assert " " in name_length, name_length
assert len(units) == 2
assert len(division) == 3
line = "LOCUS %s %s %s %s %s %s\n" \
% (name_length,
units,
mol_type.ljust(7),
topology,
division,
self._get_date(record))
assert len(line) == 79 + 1, repr(line) # plus one for new line
# We're bending the rules to allow an identifier over 16 characters
# if we can steal spaces from the length field:
# assert line[12:28].rstrip() == locus, \
# 'LOCUS line does not contain the locus at the expected position:\n' + line
# assert line[28:29] == " "
# assert line[29:40].lstrip() == str(len(record)), \
# 'LOCUS line does not contain the length at the expected position:\n' + line
assert line[12:40].split() == [locus, str(len(record))], line
# Tests copied from Bio.GenBank.Scanner
assert line[40:44] in [' bp ', ' aa '], \
'LOCUS line does not contain size units at expected position:\n' + \
line
assert line[44:47] in [' ', 'ss-', 'ds-', 'ms-'], \
'LOCUS line does not have valid strand type (Single stranded, ...):\n' + line
assert line[47:54].strip() == "" \
or 'DNA' in line[47:54].strip() \
or 'RNA' in line[47:54].strip(), \
'LOCUS line does not contain valid sequence type (DNA, RNA, ...):\n' + line
assert line[54:55] == ' ', \
'LOCUS line does not contain space at position 55:\n' + line
assert line[55:63].strip() in ['', 'linear', 'circular'], \
'LOCUS line does not contain valid entry (linear, circular, ...):\n' + line
assert line[63:64] == ' ', \
'LOCUS line does not contain space at position 64:\n' + line
assert line[67:68] == ' ', \
'LOCUS line does not contain space at position 68:\n' + line
assert line[70:71] == '-', \
'LOCUS line does not contain - at position 71 in date:\n' + line
assert line[74:75] == '-', \
'LOCUS line does not contain - at position 75 in date:\n' + line
self.handle.write(line)
