def test_transcription():
test_dna = DNA('ATGATGGGCAGTGTCGAATTAAATCTGCGTGAGACAGAATTGTGTT' +
'TGGGACTACCAGGCGGTGATACAGTTGCACCAGTAACAGGAAACAA' +
'AAGAGGATTCTCTGAAACAGTAGATTTGAAACTTAATTTGAACAAT' +
'GAGCCAGCCAACAAGGAAGGTTCCACCACTCATGACGTCGTCACAT' +
'TTGATAGTAAAGAAAAGAGTGCGTGTCCAAAAGATCCAGCTAAGCC' +
'ACCTGCCAAGGCTCAAGTCGTCGGATGGCCACCTGTGAGATCTTAT' +
'AGAAAGAACGTAATGGTTTCTTGTCAGAAGTCCAGTGGTGGTCCTG' +
'AAGCAGCGGCTtgaaaa')
reference_rna = RNA('AUGAUGGGCAGUGUCGAAUUAAAUCUGCGUGAGACAGAAUU' +
'GUGUUUGGGACUACCAGGCGGUGAUACAGUUGCACCAGUAA' +
'CAGGAAACAAAAGAGGAUUCUCUGAAACAGUAGAUUUGAAA' +
'CUUAAUUUGAACAAUGAGCCAGCCAACAAGGAAGGUUCCAC' +
'CACUCAUGACGUCGUCACAUUUGAUAGUAAAGAAAAGAGUG' +
'CGUGUCCAAAAGAUCCAGCUAAGCCACCUGCCAAGGCUCAA' +
'GUCGUCGGAUGGCCACCUGUGAGAUCUUAUAGAAAGAACGU' +
'AAUGGUUUCUUGUCAGAAGUCCAGUGGUGGUCCUGAAGCAG' +
'CGGCUugaaaa')
# Basic transcription should work
transcription_output = reaction.transcribe(test_dna)
assert_equal(transcription_output, reference_rna)
# Coding RNA should exclude anything after a stop codon
coding_rna_output = reaction.coding_sequence(transcription_output)
assert_equal(coding_rna_output, reference_rna[:-3])
# Should fail is sequence lacks start codon or stop codon
assert_raises(ValueError, reaction.coding_sequence,
reaction.transcribe(DNA('aaatag')))
assert_raises(ValueError, reaction.coding_sequence,
reaction.transcribe(DNA('atgaaa')))
def test_multiple_priming():
''' test multiple binding sites '''
current_path = os.path.dirname(__file__)
template = seqio.read_dna(os.path.join(current_path,
"pMODKan-HO-pACT1GEV.ape"))
template = template.circularize()
seq = DNA('cgccagggttttcccagtcacgac')
template = template.linearize()
template = template + seq + DNA("AGGCGTATGC") + seq
template = (template + DNA("GGGGGGG") + seq.reverse_complement() +
DNA("GGAAAG"))
template = template.circularize()
primer = Primer(seq, 50.6)
matches = analysis.anneal(template, primer)
fwd_matches, rev_matches = matches
fwd_indices = [match[0] for match in fwd_matches]
rev_indices = [match[0] for match in rev_matches]
loc = template.locate(seq)
assert_true(len(fwd_matches) == len(loc[0]))
assert_true(len(rev_matches) == len(loc[1]))
for match in loc[0]:
assert_true(match + len(seq) in fwd_indices)
for match in loc[1]:
assert_true(match + len(seq) in rev_indices)
def test_psti_cut(self):
'''Test 3\' cutter.'''
psti = RestrictionSite(DNA('CTGCAG'), (5, 1), name='PstI')
assert_equal(
reaction.digest(DNA('ACTGCAGA'), psti),
[DNA('ACTGCA', bottom='----GT'),
DNA('----GA', bottom='TCTGCA')])
class TestFeatures(object):
'''Test features model using DNA object.'''
def __init__(self):
self.dna = DNA('ATGC') * 50
self.apply_features()
def apply_features(self):
misc_feature = Feature('Misc Feature', 1, 20, 'misc_feature')
misc_1_feature = Feature('Misc Feature', 1, 20, 'misc_feature',
strand=1)
coding_feature = Feature('Coding Feature', 21, 40, 'CDS')
primer_feature = Feature('Primer Feature', 41, 60, 'primer_bind')
promoter_feature = Feature('Promoter Feature', 61, 80, 'promoter')
terminator_feature = Feature('Terminator Feature', 81, 100,
'terminator')
rbs_feature = Feature('RBS Feature', 101, 120, 'RBS')
origin_feature = Feature('Origin Feature', 121, 140, 'rep_origin')
utr3_feature = Feature("3'UTR Feature", 141, 160, "3'UTR")
origin_feature2 = Feature('Origin Feature', 161, 180, 'rep_origin')
input_features = [misc_feature, misc_1_feature, coding_feature,
primer_feature, promoter_feature, terminator_feature,
rbs_feature, origin_feature, utr3_feature,
origin_feature2]
self.dna.features = input_features
def test_good_features(self):
for feature in self.dna.features:
assert_true(feature.copy() in self.dna.features)
def test_rev_comp(self):
rev = self.dna.reverse_complement()
for feature, rev_feature in zip(self.dna.features, rev.features):
assert_not_equal(feature.strand, rev_feature.strand)
assert_equal(len(self.dna) - feature.start, rev_feature.stop)
assert_equal(len(self.dna) - feature.stop, rev_feature.start)
def test_extract(self):
test_utr3_feature = [feature for feature in self.dna.features if
feature.name == "3'UTR Feature"][0]
extracted = self.dna.extract(test_utr3_feature)
assert_equal(str(extracted), 'TGCATGCATGCATGCATGC')
def test_getitem(self):
subsequence = self.dna[30:100]
remaining_features = [Feature('Primer Feature', 11, 30, 'primer_bind'),
Feature('Promoter Feature', 31, 50, 'promoter'),
Feature('Terminator Feature', 51, 70,
'terminator')]
assert_equal(subsequence.features, remaining_features)
assert_false(self.dna[10].features)
new_seq = DNA('ATGC', features=[Feature('A', 0, 0, 'misc_feature')])
assert_equal(new_seq[0].features[0],
Feature('A', 0, 0, 'misc_feature'))
def test_ne(self):
'''Test != operator'''
assert_true(self.dna.features[0] != self.dna.features[4])
assert_false(self.dna.features[0] != self.dna.features[0])
def test_ncoi_cut(self):
'''Test standard TypeII cutter.'''
ncoi = RestrictionSite(DNA('CCATGG'), (1, 5), name='NcoI')
assert_equal(reaction.digest(self.dna, ncoi), [
DNA('TGAC----', bottom='CATGGTCA'),
DNA('CATGGAAA', bottom='TTTC----')
])
assert_equal(reaction.digest(self.dna.circularize(), ncoi),
[DNA('CATGGAAATGAC----', bottom='CATGGTCATTTC----')])
def test_palindrome(self):
palindromic_seq_even = DNA('ATGCGCAT')
nonpalindromic_seq_even = DNA('ATGCGCAA')
almost_palindrome_odd = DNA('ATGCCAT')
assert_true(palindromic_seq_even.is_palindrome())
assert_false(nonpalindromic_seq_even.is_palindrome())
assert_false(almost_palindrome_odd.is_palindrome())
def test_dimers():
'''Test dimers function.'''
anneal_f = DNA('gatcgatcgatacgatcgatatgcgat', stranded='ss')
tm_f = 71.86183729637946
primer_f = Primer(anneal_f, tm_f)
anneal_r = DNA('atatcgatcatatcgcatatcgatcgtatcgat', stranded='ss')
tm_r = 72.14300162714233
primer_r = Primer(anneal_r, tm_r)
dimer_output = analysis.dimers(primer_f, primer_r)
assert_equal(dimer_output, 0.8529446)
def test_min_tm():
current_path = os.path.dirname(__file__)
template = seqio.read_dna(os.path.join(current_path,
"pMODKan-HO-pACT1GEV.ape"))
# Test forward priming
# Tm should be ~40 C
seq = DNA('CTTCTATCGAACAA')
primer = Primer(seq, seq.tm())
matches = analysis.anneal(template, primer, min_tm=60.0)
assert_true(len(matches[0]) == 0)
matches = analysis.anneal(template, primer, min_tm=30.0)
assert_true(len(matches[0]) > 0)
def test_min_tm():
current_path = os.path.dirname(__file__)
template = seqio.read_dna(
os.path.join(current_path, "pMODKan-HO-pACT1GEV.ape"))
# Test forward priming
# Tm should be ~40 C
seq = DNA('CTTCTATCGAACAA')
primer = Primer(seq, seq.tm())
matches = analysis.anneal(template, primer, min_tm=60.0)
assert_true(len(matches[0]) == 0)
matches = analysis.anneal(template, primer, min_tm=30.0)
assert_true(len(matches[0]) > 0)
def test_primers():
'''Test primers function.'''
seq = 'ATGGTGAGCAAGGGCGAGGAGCTGTTCACCGGGGTGGTGCCCATCCTGGTCGAGCTGGACGGC' + \
'GACGTAAACGGCCACAAGTTCAGCGTGTCCGGCGAGGGCGAGGGCGATGCCACCTACGGCAAG' + \
'CTGACCCTGAAGTTCATCTGCACCACCGGCAAGCTGCCCGTGCCCTGGCCCACCCTCGTGACC' + \
'ACCTTCGGCTACGGCCTGCAGTGCTTCGCCCGCTACCCCGACCACATGAAGCAGCACGACTTC' + \
'TTCAAGTCCGCCATGCCCGAAGGCTACGTCCAGGAGCGCACCATCTTCTTCAAGGACGACGGC' + \
'AACTACAAGACCCGCGCCGAGGTGAAGTTCGAGGGCGACACCCTGGTGAACCGCATCGAGCTG' + \
'AAGGGCATCGACTTCAAGGAGGACGGCAACATCCTGGGGCACAAGCTGGAGTACAACTACAAC' + \
'AGCCACAACGTCTATATCATGGCCGACAAGCAGAAGAACGGCATCAAGGTGAACTTCAAGATC' + \
'CGCCACAACATCGAGGACGGCAGCGTGCAGCTCGCCGACCACTACCAGCAGAACACCCCCATC' + \
'GGCGACGGCCCCGTGCTGCTGCCCGACAACCACTACCTGAGCTACCAGTCCGCCCTGAGCAAA' + \
'GACCCCAACGAGAAGCGCGATCACATGGTCCTGCTGGAGTTCGTGACCGCCGCCGGGATCACT' + \
'CTCGGCATGGACGAGCTGTACAAGTAA'
dna_seq = DNA(seq)
primers_list = design.primers(dna_seq,
tm=72,
min_len=10,
tm_undershoot=1,
tm_overshoot=3,
end_gc=False,
tm_parameters='cloning',
overhangs=None)
primers = [str(x.primer()) for x in primers_list]
assert_equals(primers,
['ATGGTGAGCAAGGGCGAGGAG', 'TTACTTGTACAGCTCGTCCATGCCG'])
def test_find_repeats():
input_sequence = DNA('atgatgccccgatagtagtagtag')
expected = [('ATG', 2), ('GTA', 3), ('GAT', 2), ('AGT', 3), ('CCC', 2),
('TAG', 4)]
output = analysis.repeats(input_sequence, 3)
assert_equal(output, expected)
def test_near_index():
'''Test binding near index for circular templates.'''
current_path = os.path.dirname(__file__)
template = seqio.read_dna(
os.path.join(current_path, "pMODKan-HO-pACT1GEV.ape"))
template = template.circularize()
seq = DNA('aggccctttcgtctcgcgcgttt')
primer = Primer(seq, 50.6)
matches = analysis.anneal(template, primer)
fwd_matches, rev_matches = matches
fwd_indices = [match[0] for match in fwd_matches]
rev_indices = [match[0] for match in rev_matches]
loc = template.locate(seq)
print fwd_matches
print loc[0]
print loc[1]
assert_true(len(fwd_matches) == len(loc[0]))
assert_true(len(rev_matches) == len(loc[1]))
for match in loc[0]:
expected = match + len(seq)
if expected > len(template):
expected -= len(template)
assert_true(expected in fwd_indices)
for match in loc[1]:
expected = match + len(seq)
if expected > len(template):
expected -= len(template)
assert_true(expected in rev_indices)
class TestDigest(object):
'''Test digest function.'''
def __init__(self):
# Contains NcoI site
self.dna = DNA('TGACCATGGAAA')
def test_not_found(self):
'''If site not found, should return input sequence in list.'''
ecorv = RestrictionSite(DNA('GATATC'), (3, 3), name='EcoRV')
assert_equal(self.dna, reaction.digest(self.dna, ecorv)[0])
def test_ncoi_cut(self):
'''Test standard TypeII cutter.'''
ncoi = RestrictionSite(DNA('CCATGG'), (1, 5), name='NcoI')
assert_equal(reaction.digest(self.dna, ncoi),
[DNA('TGAC----', bottom='CATGGTCA'),
DNA('CATGGAAA', bottom='TTTC----')])
assert_equal(reaction.digest(self.dna.circularize(), ncoi),
[DNA('CATGGAAATGAC----', bottom='CATGGTCATTTC----')])
def test_ecorv_cut(self):
'''Test blunt-end cutter.'''
ecorv = RestrictionSite(DNA('GATATC'), (3, 3), name='EcoRV')
assert_equal(reaction.digest(DNA('GATATC'), ecorv),
[DNA('GAT'), DNA('ATC')])
def test_psti_cut(self):
'''Test 3\' cutter.'''
psti = RestrictionSite(DNA('CTGCAG'), (5, 1), name='PstI')
assert_equal(reaction.digest(DNA('ACTGCAGA'), psti),
[DNA('ACTGCA', bottom='----GT'),
DNA('----GA', bottom='TCTGCA')])
class TestDigest(object):
'''Test digest function.'''
def __init__(self):
# Contains NcoI site
self.dna = DNA('TGACCATGGAAA')
def test_not_found(self):
'''If site not found, should return input sequence in list.'''
ecorv = RestrictionSite(DNA('GATATC'), (3, 3), name='EcoRV')
assert_equal(self.dna, reaction.digest(self.dna, ecorv)[0])
def test_ncoi_cut(self):
'''Test standard TypeII cutter.'''
ncoi = RestrictionSite(DNA('CCATGG'), (1, 5), name='NcoI')
assert_equal(reaction.digest(self.dna, ncoi), [
DNA('TGAC----', bottom='CATGGTCA'),
DNA('CATGGAAA', bottom='TTTC----')
])
assert_equal(reaction.digest(self.dna.circularize(), ncoi),
[DNA('CATGGAAATGAC----', bottom='CATGGTCATTTC----')])
def test_ecorv_cut(self):
'''Test blunt-end cutter.'''
ecorv = RestrictionSite(DNA('GATATC'), (3, 3), name='EcoRV')
assert_equal(reaction.digest(DNA('GATATC'), ecorv),
[DNA('GAT'), DNA('ATC')])
def test_psti_cut(self):
'''Test 3\' cutter.'''
psti = RestrictionSite(DNA('CTGCAG'), (5, 1), name='PstI')
assert_equal(
reaction.digest(DNA('ACTGCAGA'), psti),
[DNA('ACTGCA', bottom='----GT'),
DNA('----GA', bottom='TCTGCA')])
def test_overhang():
''' test forward priming '''
current_path = os.path.dirname(__file__)
template = seqio.read_dna(
os.path.join(current_path, "pMODKan-HO-pACT1GEV.ape"))
seq = DNA('cgccagggttttcccagtcacgac')
overhang = DNA('ggggggg')
seq2 = overhang + seq
primer = Primer(seq2, 50.6)
matches = analysis.anneal(template, primer)
fwd_matches, rev_matches = matches
fwd_indices = [match[0] for match in fwd_matches]
rev_indices = [match[0] for match in rev_matches]
loc = template.locate(seq)
assert_true(len(fwd_indices) == len(loc[0]))
assert_true(len(rev_indices) == len(loc[1]))
# FIXME: Add match length check for all these cases.
for match in loc[0]:
assert_true(match + len(seq) in fwd_indices)
for match in loc[1]:
assert_true(match + len(seq) in rev_indices)
# Test forward priming.
current_path = os.path.dirname(__file__)
template = seqio.read_dna(
os.path.join(current_path, "pMODKan-HO-pACT1GEV.ape"))
seq = DNA('ACAAGAGAGATTGGGAAGGAAAGGATCA')
overhang = DNA('ggggggg')
seq2 = overhang + seq
primer = Primer(seq2, 50.6)
matches = analysis.anneal(template, primer)
fwd_matches, rev_matches = matches
fwd_indices = [match[0] for match in fwd_matches]
rev_indices = [match[0] for match in rev_matches]
loc = template.locate(seq)
assert_true(len(fwd_indices) == len(loc[0]))
assert_true(len(rev_indices) == len(loc[1]))
for match in loc[0]:
assert_true(match + len(seq) in fwd_indices)
for match in loc[1]:
assert_true(match + len(seq) in rev_indices)
def test_finnzymes():
'''
Tests finnzymes method output.
'''
melt = analysis.tm(DNA('ATGCGATAGCGATAGC'), parameters='cloning')
assert_equal(melt, 55.2370030020752)
def test_utils():
test_DNA = DNA('ATAGCGATACGAT')
test_RNA = RNA('AUGCGAUAGCGAU')
test_peptide = Peptide('msvkkkpvqg')
test_str = 'msvkkkpvgq'
assert_equal(analysis.utils.sequence_type(test_DNA), 'dna')
assert_equal(analysis.utils.sequence_type(test_RNA), 'rna')
assert_equal(analysis.utils.sequence_type(test_peptide), 'peptide')
assert_raises(Exception, analysis.utils.sequence_type, test_str)
def test_basic():
current_path = os.path.dirname(__file__)
template = seqio.read_dna(
os.path.join(current_path, "pMODKan-HO-pACT1GEV.ape"))
# Test forward priming.
seq = DNA('cgccagggttttcccagtcacgac')
primer = Primer(seq, 50.6)
matches = analysis.anneal(template, primer)
fwd_matches, rev_matches = matches
fwd_indices = [match[0] for match in fwd_matches]
# fwd_lens = [match[1] for match in fwd_matches]
rev_indices = [match[0] for match in rev_matches]
# rev_lens = [match[1] for match in rev_matches]
loc = template.locate(seq)
assert_true(len(fwd_matches) == len(loc[0]))
assert_true(len(rev_matches) == len(loc[1]))
# Top strand matches
for match in loc[0]:
assert_true(match + len(seq) in fwd_indices)
# Top strand matches
for match in loc[1]:
assert_true(match + len(seq) in rev_indices)
# Test reverse priming
seq = DNA('ACAAGAGAGATTGGGAAGGAAAGGATCA')
primer = Primer(seq, 50.6)
matches = analysis.anneal(template, primer)
fwd_matches, rev_matches = matches
fwd_indices = [match[0] for match in fwd_matches]
rev_indices = [match[0] for match in rev_matches]
loc = template.locate(seq)
assert_true(len(fwd_indices) == len(loc[0]))
assert_true(len(rev_indices) == len(loc[1]))
for match in loc[0]:
assert_true(match + len(seq) in fwd_indices)
for match in loc[1]:
assert_true(match + len(seq) in rev_indices)
def test_getitem(self):
subsequence = self.dna[30:100]
remaining_features = [Feature('Primer Feature', 11, 30, 'primer_bind'),
Feature('Promoter Feature', 31, 50, 'promoter'),
Feature('Terminator Feature', 51, 70,
'terminator')]
assert_equal(subsequence.features, remaining_features)
assert_false(self.dna[10].features)
new_seq = DNA('ATGC', features=[Feature('A', 0, 0, 'misc_feature')])
assert_equal(new_seq[0].features[0],
Feature('A', 0, 0, 'misc_feature'))
def test_multiple_priming():
''' test multiple binding sites '''
current_path = os.path.dirname(__file__)
template = seqio.read_dna(
os.path.join(current_path, "pMODKan-HO-pACT1GEV.ape"))
template = template.circularize()
seq = DNA('cgccagggttttcccagtcacgac')
template = template.linearize()
template = template + seq + DNA("AGGCGTATGC") + seq
template = (template + DNA("GGGGGGG") + seq.reverse_complement() +
DNA("GGAAAG"))
template = template.circularize()
primer = Primer(seq, 50.6)
matches = analysis.anneal(template, primer)
fwd_matches, rev_matches = matches
fwd_indices = [match[0] for match in fwd_matches]
rev_indices = [match[0] for match in rev_matches]
loc = template.locate(seq)
assert_true(len(fwd_matches) == len(loc[0]))
assert_true(len(rev_matches) == len(loc[1]))
for match in loc[0]:
assert_true(match + len(seq) in fwd_indices)
for match in loc[1]:
assert_true(match + len(seq) in rev_indices)
def test_palindrome(self):
palindromic_seq_even = DNA('ATGCGCAT')
nonpalindromic_seq_even = DNA('ATGCGCAA')
almost_palindrome_odd = DNA('ATGCCAT')
assert_true(palindromic_seq_even.is_palindrome())
assert_false(nonpalindromic_seq_even.is_palindrome())
assert_false(almost_palindrome_odd.is_palindrome())
def test_convert_sequence():
'''Tests DNA translation function.'''
seq = 'ATGGTGAGCAAGGGCGAGGAGCTGTTCACCGGGGTGGTGCCCATCCTGGTCGAGCTGGACGGC' + \
'GACGTAAACGGCCACAAGTTCAGCGTGTCCGGCGAGGGCGAGGGCGATGCCACCTACGGCAAG' + \
'CTGACCCTGAAGTTCATCTGCACCACCGGCAAGCTGCCCGTGCCCTGGCCCACCCTCGTGACC' + \
'ACCTTCGGCTACGGCCTGCAGTGCTTCGCCCGCTACCCCGACCACATGAAGCAGCACGACTTC' + \
'TTCAAGTCCGCCATGCCCGAAGGCTACGTCCAGGAGCGCACCATCTTCTTCAAGGACGACGGC' + \
'AACTACAAGACCCGCGCCGAGGTGAAGTTCGAGGGCGACACCCTGGTGAACCGCATCGAGCTG' + \
'AAGGGCATCGACTTCAAGGAGGACGGCAACATCCTGGGGCACAAGCTGGAGTACAACTACAAC' + \
'AGCCACAACGTCTATATCATGGCCGACAAGCAGAAGAACGGCATCAAGGTGAACTTCAAGATC' + \
'CGCCACAACATCGAGGACGGCAGCGTGCAGCTCGCCGACCACTACCAGCAGAACACCCCCATC' + \
'GGCGACGGCCCCGTGCTGCTGCCCGACAACCACTACCTGAGCTACCAGTCCGCCCTGAGCAAA' + \
'GACCCCAACGAGAAGCGCGATCACATGGTCCTGCTGGAGTTCGTGACCGCCGCCGGGATCACT' + \
'CTCGGCATGGACGAGCTGTACAAGTAA'
dna = DNA(seq)
prot = 'MVSKGEELFTGVVPILVELDGDVNGHKFSVSGEGEGDATYGKLTLKFICTTGKLPVPWPTLV' + \
'TTFGYGLQCFARYPDHMKQHDFFKSAMPEGYVQERTIFFKDDGNYKTRAEVKFEGDTLVNRI' + \
'ELKGIDFKEDGNILGHKLEYNYNSHNVYIMADKQKNGIKVNFKIRHNIEDGSVQLADHYQQN' + \
'TPIGDGPVLLPDNHYLSYQSALSKDPNEKRDHMVLLEFVTAAGITLGMDELYK'
rna = reaction.utils.convert_sequence(dna, 'rna')
r_trans = reaction.utils.convert_sequence(rna, 'dna')
trans = reaction.utils.convert_sequence(rna, 'peptide')
assert_equal(str(trans), prot)
assert_equal(str(r_trans), seq)
assert_raises(ValueError, reaction.utils.convert_sequence, seq, 'rna')
# Gapped sequence shouldfail
assert_raises(ValueError, reaction.utils.convert_sequence, DNA('atg-'),
'rna')
# Sequence without stop codon should still work
nostop_dna = DNA('atgaaaaaaaaaaaa')
nostop_rna = reaction.utils.convert_sequence(nostop_dna, 'rna')
nostop_peptide = reaction.utils.convert_sequence(nostop_rna, 'peptide')
assert_equal(str(nostop_rna), 'AUGAAAAAAAAAAAA')
assert_equal(str(nostop_peptide), 'MKKKK')
assert_raises(ValueError, reaction.utils.convert_sequence, 'duck', 'rna')
def test_min_primer_length():
current_path = os.path.dirname(__file__)
template = seqio.read_dna(
os.path.join(current_path, "pMODKan-HO-pACT1GEV.ape"))
# Test forward priming
seq = DNA('cgccagggttttcccagtcacgac')
seq = seq[:15]
primer = Primer(seq, 50.6)
assert_raises(analysis._sequence.anneal.PrimerLengthError,
analysis.anneal,
template,
primer,
min_len=16)
def test_no_priming():
''' test no priming '''
current_path = os.path.dirname(__file__)
template = seqio.read_dna(
os.path.join(current_path, "pMODKan-HO-pACT1GEV.ape"))
seq = DNA('ggaggagggcggcgaggcgagcgacggaggggga')
primer = Primer(seq, 50.6)
matches = analysis.anneal(template, primer)
fwd_matches, rev_matches = matches
loc = template.locate(seq)
assert_true(len(fwd_matches) == len(loc[0]))
assert_true(len(rev_matches) == len(loc[1]))
for match in loc[0]:
assert_true(match + len(seq) in fwd_matches)
for match in loc[1]:
assert_true(match + len(seq) in rev_matches)
def test_overlapping_overlaps():
'''
Sometimes, an assembly produces a result with 'overlapping overlaps' -
not ideal. This should eventually be replaced by a catchable exception or
prevented outright.
'''
test_seq = DNA('ATCAATACTTATTACGATATATATAT' * 34)
oligo_n_assembly = design.OligoAssembly(test_seq,
tm=65,
length_range=(80, 150),
require_even=True,
start_5=True,
overlap_min=20,
oligo_number=10)
oligo_n_assembly.design_assembly()
assert_true(type(oligo_n_assembly.warning) == str)
def test_reverse_transcription():
test_rna = RNA('AUGAUGGGCAGUGUCGAAUUAAAUCUGCGUGAGACAGAAUU' +
'GUGUUUGGGACUACCAGGCGGUGAUACAGUUGCACCAGUAA' +
'CAGGAAACAAAAGAGGAUUCUCUGAAACAGUAGAUUUGAAA' +
'CUUAAUUUGAACAAUGAGCCAGCCAACAAGGAAGGUUCCAC' +
'CACUCAUGACGUCGUCACAUUUGAUAGUAAAGAAAAGAGUG' +
'CGUGUCCAAAAGAUCCAGCUAAGCCACCUGCCAAGGCUCAA' +
'GUCGUCGGAUGGCCACCUGUGAGAUCUUAUAGAAAGAACGU' +
'AAUGGUUUCUUGUCAGAAGUCCAGUGGUGGUCCUGAAGCAG' + 'CGGCUugaaaa')
ref_dna = DNA('ATGATGGGCAGTGTCGAATTAAATCTGCGTGAGACAGAATTGTGTT' +
'TGGGACTACCAGGCGGTGATACAGTTGCACCAGTAACAGGAAACAA' +
'AAGAGGATTCTCTGAAACAGTAGATTTGAAACTTAATTTGAACAAT' +
'GAGCCAGCCAACAAGGAAGGTTCCACCACTCATGACGTCGTCACAT' +
'TTGATAGTAAAGAAAAGAGTGCGTGTCCAAAAGATCCAGCTAAGCC' +
'ACCTGCCAAGGCTCAAGTCGTCGGATGGCCACCTGTGAGATCTTAT' +
'AGAAAGAACGTAATGGTTTCTTGTCAGAAGTCCAGTGGTGGTCCTG' +
'AAGCAGCGGCTtgaaaa')
# Basic transcription should work
r_transcription = reaction.reverse_transcribe(test_rna)
assert_equal(r_transcription, ref_dna)
def test_gibson_primers():
'''Test gibson_primers function.'''
# Fuse tdh3 promoter sequence to yfp (trimmed for readability)
tdh3_3prime = DNA('aaccagttccctgaaattattcccctacttgactaataagtat' +
'ataaagacggtaggtattgattgtaattctgtaaatctatttc' +
'ttaaacttc')
yfp_nterm = DNA('atggtgagcaagggcgaggagctgttcaccggggtggtgcccatc' +
'ctggtcgagctggacggcgacgtaaacggccacaagttcagcgtg' +
'tccggcgagggcgagggcgatgccacctacggcaagctgaccctg' + 'aag')
# Expected annealing sequences and their Tms
fwd_anneal = DNA('atggtgagcaagggcg')
fwd_tm = 64.64172107821065
rev_anneal = DNA('gaagtttaagaaatagatttacagaattacaatcaatac')
rev_tm = 64.24536287254085
# Expected overlaps
all_right = DNA('TCGCCCTTGCTCACCAT')
all_left = DNA('GGTATTGATTGTAATTCTGTAAATCTATTTCTTAAACTTC')
mixed_fwd = DNA('TTCTTAAACTTC')
mixed_rev = DNA('CCTTGCTCACCAT')
# Design primers - with homology all on left side, right side, or mixed
# All on the 'right' - i.e. fwd primer
right = design.gibson_primers(tdh3_3prime, yfp_nterm, 'right')
right_rev = Primer(rev_anneal, tm=rev_tm, overhang=all_right)
right_fwd = Primer(fwd_anneal, tm=fwd_tm)
assert_equal(right, (right_rev, right_fwd))
# All on the 'left' - i.e. rev primer
left = design.gibson_primers(tdh3_3prime, yfp_nterm, 'left')
left_rev = Primer(rev_anneal, tm=rev_tm)
left_fwd = Primer(fwd_anneal, tm=fwd_tm, overhang=all_left)
assert_equal(left, (left_rev, left_fwd))
# On both primers
mixed = design.gibson_primers(tdh3_3prime, yfp_nterm, 'mixed')
mixed_primer1 = Primer(rev_anneal, tm=rev_tm, overhang=mixed_rev)
mixed_primer2 = Primer(fwd_anneal, tm=fwd_tm, overhang=mixed_fwd)
assert_equal(mixed, (mixed_primer1, mixed_primer2))
assert_raises(ValueError, design.gibson_primers, tdh3_3prime, yfp_nterm,
'duck')
def test_structure_windows():
'''Tests StructureWindows class in structure_windows.'''
seq = 'atggtgagcaagggcgaggagctgttcaccggggtggtgcccatcctggtcgagctggacggc' + \
'gacgtaaacggccacaagttcagcgtgtccggcgagggcgagggcgatgccacctacggcaag' + \
'ctgaccctgaagttcatctgcaccaccggcaagctgcccgtgccctggcccaccctcgtgacc' + \
'accttcggctacggcctgcagtgcttcgcccgctaccccgaccacatgaagcagcacgacttc' + \
'ttcaagtccgccatgcccgaaggctacgtccaggagcgcaccatcttcttcaaggacgacggc' + \
'aactacaagacccgcgccgaggtgaagttcgagggcgacaccctggtgaaccgcatcgagctg' + \
'aagggcatcgacttcaaggaggacggcaacatcctggggcacaagctggagtacaactacaac' + \
'agccacaacgtctatatcatggccgacaagcagaagaacggcatcaaggtgaacttcaagatc' + \
'cgccacaacatcgaggacggcagcgtgcagctcgccgaccactaccagcagaacacccccatc' + \
'ggcgacggccccgtgctgctgcccgacaaccactacctgagctaccagtccgccctgagcaaa' + \
'gaccccaacgagaagcgcgatcacatggtcctgctggagttcgtgaccgccgccgggatcact' + \
'ctcggcatggacgagctgtacaagtaa'
dna_seq = DNA(seq)
walker = analysis.StructureWindows(dna_seq)
walker.windows(window_size=60, context_len=90, step=10)
assert_equal(walker.scores,
(0.578570075,
0.5928413833333335,
0.5535072916666667,
0.5425574666666667,
0.6028716333333335,
0.5907444666666667,
0.5532209166666666,
0.5882098916666667,
0.6471799,
0.6957834999999999,
0.6209094583333334,
0.5929873583333332,
0.6117790833333332,
0.6116499166666667,
0.5987705999999998,
0.6439044999999999,
0.6817365833333334,
0.6488576499999998,
0.6900404249999998,
0.6657639999999999,
0.7083993333333333,
0.6360369916666666,
0.6452116666666665,
0.6395126666666666,
0.6288818333333333,
0.6351839999999999,
0.6463396666666666,
0.6717609166666665,
0.67853025,
0.7012450833333332,
0.6620117499999998,
0.7250783333333332,
0.6995034166666668,
0.7386933333333333,
0.7494905833333333,
0.7247731666666668,
0.7510857500000001,
0.7458025000000003,
0.7434455,
0.6702263583333334,
0.6390452499999999,
0.6503500249999998,
0.646285175,
0.606586825,
0.5707148,
0.644573625,
0.6644399750000001,
0.6716777749999999,
0.6807071583333334))
class TestDNA(object):
'''Testing class for DNA'''
def __init__(self):
self.test_dna = DNA('atgc')
def test_reverse_complement(self):
assert_equal(str(self.test_dna.reverse_complement()), 'GCAT')
def test_linearize(self):
circ_dna = self.test_dna.circularize()
assert_equal(str(circ_dna.linearize()), 'ATGC')
assert_equal(str(circ_dna.linearize(0)), 'ATGC')
assert_equal(str(circ_dna.linearize(1)), 'TGCA')
assert_equal(str(circ_dna.linearize(2)), 'GCAT')
assert_equal(str(circ_dna.linearize(3)), 'CATG')
assert_equal(str(circ_dna.linearize(-1)), 'CATG')
assert_raises(ValueError, circ_dna.linearize().linearize)
def test_to_ss_ds(self):
assert_equal(self.test_dna.to_ds(), self.test_dna)
ss_dna = self.test_dna.to_ss()
assert_equal(ss_dna.stranded, 'ss')
ds_dna = self.test_dna.to_ds()
assert_equal(ds_dna.stranded, 'ds')
assert_equal(ds_dna.top(), str(ss_dna))
ds_to_ss_to_ds = self.test_dna.to_ss().to_ds()
assert_equal(self.test_dna, ds_to_ss_to_ds)
empty_top = reaction.three_resect(self.test_dna, 400)
assert_equal(empty_top.to_ds(), self.test_dna)
def test_locate(self):
assert_equal(self.test_dna.locate('a'), [[0], [2]])
assert_equal(self.test_dna.locate('at'), [[0], [2]])
assert_equal(self.test_dna.locate('gc'), [[2], [0]])
assert_equal(self.test_dna.locate('atgg'), [[], []])
# Circular DNA tests
assert_equal(self.test_dna.circularize().locate('a'), [[0], [2]])
assert_equal(self.test_dna.circularize().locate('at'), [[0], [2]])
assert_equal(self.test_dna.circularize().locate('gc'), [[2], [0]])
assert_equal(self.test_dna.circularize().locate('atgg'), [[], []])
def test_copy(self):
assert_equal(self.test_dna, self.test_dna.copy())
def test_palindrome(self):
palindromic_seq_even = DNA('ATGCGCAT')
nonpalindromic_seq_even = DNA('ATGCGCAA')
almost_palindrome_odd = DNA('ATGCCAT')
assert_true(palindromic_seq_even.is_palindrome())
assert_false(nonpalindromic_seq_even.is_palindrome())
assert_false(almost_palindrome_odd.is_palindrome())
def test_getitem(self):
assert_equal(str(self.test_dna[0]), 'A')
assert_equal(str(self.test_dna[1]), 'T')
assert_equal(str(self.test_dna[2]), 'G')
assert_equal(str(self.test_dna[3]), 'C')
assert_equal(str(self.test_dna[-1]), 'C')
def test_delitem(self):
copy0 = self.test_dna.copy()
del copy0[0]
assert_equal(str(copy0), 'TGC')
copy1 = self.test_dna.copy()
del copy1[1]
assert_equal(str(copy1), 'AGC')
copy2 = self.test_dna.copy()
del copy2[2]
assert_equal(str(copy2), 'ATC')
copy3 = self.test_dna.copy()
del copy3[3]
assert_equal(str(copy3), 'ATG')
copy_1 = self.test_dna.copy()
del copy_1[-1]
assert_equal(str(copy_1), 'ATG')
def test_setitem(self):
copy0 = self.test_dna.copy()
copy0[0] = 't'
assert_equal(str(copy0), 'TTGC')
copy1 = self.test_dna.copy()
copy1[1] = 'a'
assert_equal(str(copy1), 'AAGC')
copy2 = self.test_dna.copy()
copy2[2] = 'a'
assert_equal(str(copy2), 'ATAC')
copy3 = self.test_dna.copy()
copy3[3] = 'a'
assert_equal(str(copy3), 'ATGA')
copy_1 = self.test_dna.copy()
copy_1[-1] = 'a'
assert_equal(str(copy_1), 'ATGA')
def set_gap(seq):
seq[2] = '-'
assert_raises(ValueError, set_gap, self.test_dna)
def test_repr(self):
expected_repr = 'linear dsDNA:\nATGC\nTACG'
assert_equal(repr(self.test_dna), expected_repr)
expected_circ_repr = 'circular dsDNA:\nATGC\nTACG'
assert_equal(repr(self.test_dna.circularize()), expected_circ_repr)
repr_1 = 'linear dsDNA:\nATGCATGCATGCATGCATGCATGCATGCATGCATGCATGC ... '
repr_2 = 'ATGCATGCATGCATGCATGCATGCATGCATGCATGCATGC\n'
repr_3 = 'TACGTACGTACGTACGTACGTACGTACGTACGTACGTACG ... '
repr_4 = 'TACGTACGTACGTACGTACGTACGTACGTACGTACGTACG'
expected_long_repr = repr_1 + repr_2 + repr_3 + repr_4
assert_equal(repr(self.test_dna * 50), expected_long_repr)
def test_str(self):
assert_equal(str(self.test_dna), 'ATGC')
def test_len(self):
assert_equal(len(self.test_dna), 4)
def test_add(self):
assert_equal(str(self.test_dna + self.test_dna), 'ATGCATGC')
assert_equal(str(self.test_dna.to_ss() + self.test_dna.to_ss()),
'ATGCATGC')
def test_radd(self):
assert_equal(str(sum([self.test_dna, self.test_dna])), 'ATGCATGC')
def radd_800(seq):
return 800 + seq
assert_raises(TypeError, radd_800, self.test_dna)
def test_mul(self):
assert_equal(str(self.test_dna * 4), 'ATGCATGCATGCATGC')
def mul_float(seq):
return seq * 7.56
assert_raises(TypeError, mul_float, self.test_dna)
# TODO: reimplement this test using manual sequence input
# def mul_incompatible(seq):
# return seq * 3
# incompatible_seq = self.test_dna.copy()
# incompatible_seq = incompatible_seq.five_resect(1)
# incompatible_seq = incompatible_seq.reverse_complement()
# incompatible_seq = incompatible_seq.five_resect(1)
# incompatible_seq = incompatible_seq.reverse_complement()
# assert_raises(Exception, mul_incompatible, incompatible_seq)
def test_eq(self):
assert_true(self.test_dna == DNA('atgc'))
def test_ne(self):
assert_true(self.test_dna != DNA('aagc'))
def test_contains(self):
assert_true('a' in self.test_dna)
assert_true('t' in self.test_dna)
assert_true('g' in self.test_dna)
assert_true('c' in self.test_dna)
assert_false('u' in self.test_dna)
def test_flip(self):
flipped = self.test_dna.flip()
assert_equal(str(self.test_dna), flipped._bottom)
assert_equal(self.test_dna._bottom, str(flipped))
def __init__(self):
self.test_dna = DNA('atgc')
def __init__(self):
self.ecorv = RestrictionSite(DNA('GATATC'), (3, 3), name='EcoRV')
self.foki = RestrictionSite(DNA('GGATG'), (14, 18), name='FokI')
def __init__(self):
# Contains NcoI site
self.dna = DNA('TGACCATGGAAA')
class TestFeatures(object):
'''Test features model using DNA object.'''
def __init__(self):
self.dna = DNA('ATGC') * 50
self.apply_features()
def apply_features(self):
misc_feature = Feature('Misc Feature', 1, 20, 'misc_feature')
misc_1_feature = Feature('Misc Feature',
1,
20,
'misc_feature',
strand=1)
coding_feature = Feature('Coding Feature', 21, 40, 'CDS')
primer_feature = Feature('Primer Feature', 41, 60, 'primer_bind')
promoter_feature = Feature('Promoter Feature', 61, 80, 'promoter')
terminator_feature = Feature('Terminator Feature', 81, 100,
'terminator')
rbs_feature = Feature('RBS Feature', 101, 120, 'RBS')
origin_feature = Feature('Origin Feature', 121, 140, 'rep_origin')
utr3_feature = Feature("3'UTR Feature", 141, 160, "3'UTR")
origin_feature2 = Feature('Origin Feature', 161, 180, 'rep_origin')
input_features = [
misc_feature, misc_1_feature, coding_feature, primer_feature,
promoter_feature, terminator_feature, rbs_feature, origin_feature,
utr3_feature, origin_feature2
]
self.dna.features = input_features
def test_good_features(self):
for feature in self.dna.features:
assert_true(feature.copy() in self.dna.features)
def test_rev_comp(self):
rev = self.dna.reverse_complement()
for feature, rev_feature in zip(self.dna.features, rev.features):
assert_not_equal(feature.strand, rev_feature.strand)
assert_equal(len(self.dna) - feature.start, rev_feature.stop)
assert_equal(len(self.dna) - feature.stop, rev_feature.start)
def test_extract(self):
test_utr3_feature = [
feature for feature in self.dna.features
if feature.name == "3'UTR Feature"
][0]
extracted = self.dna.extract(test_utr3_feature)
assert_equal(str(extracted), 'TGCATGCATGCATGCATGC')
def test_getitem(self):
subsequence = self.dna[30:100]
remaining_features = [
Feature('Primer Feature', 11, 30, 'primer_bind'),
Feature('Promoter Feature', 31, 50, 'promoter'),
Feature('Terminator Feature', 51, 70, 'terminator')
]
assert_equal(subsequence.features, remaining_features)
assert_false(self.dna[10].features)
new_seq = DNA('ATGC', features=[Feature('A', 0, 0, 'misc_feature')])
assert_equal(new_seq[0].features[0], Feature('A', 0, 0,
'misc_feature'))
def test_ne(self):
'''Test != operator'''
assert_true(self.dna.features[0] != self.dna.features[4])
assert_false(self.dna.features[0] != self.dna.features[0])
def __init__(self):
self.dna = DNA('ATGC') * 50
self.apply_features()
def test_stranded_init():
ss_dna = DNA('atgc', stranded='ss')
assert_true(all([base == '-' for base in ss_dna.bottom()]))
ds_dna = DNA('atgc')
assert_equal(str(ds_dna), ds_dna.reverse_complement().bottom())
def test_stranded_complemented():
ss_dna = DNA('atgc', stranded='ss')
r_ss_dna = ss_dna.reverse_complement()
assert_equal(r_ss_dna.top(), 'GCAT')
assert_equal(r_ss_dna.bottom(), '----')
def test_stranded_init():
ss_dna = DNA('atgc', stranded='ss')
assert_true(all([base == '-' for base in ss_dna.bottom()]))
ds_dna = DNA('atgc')
assert_equal(str(ds_dna), ds_dna.reverse_complement().bottom())
def __init__(self):
self.test_dna = DNA('atgc')
class TestDNA(object):
'''Testing class for DNA'''
def __init__(self):
self.test_dna = DNA('atgc')
def test_reverse_complement(self):
assert_equal(str(self.test_dna.reverse_complement()), 'GCAT')
def test_linearize(self):
circ_dna = self.test_dna.circularize()
assert_equal(str(circ_dna.linearize()), 'ATGC')
assert_equal(str(circ_dna.linearize(0)), 'ATGC')
assert_equal(str(circ_dna.linearize(1)), 'TGCA')
assert_equal(str(circ_dna.linearize(2)), 'GCAT')
assert_equal(str(circ_dna.linearize(3)), 'CATG')
assert_equal(str(circ_dna.linearize(-1)), 'CATG')
assert_raises(ValueError, circ_dna.linearize().linearize)
def test_locate(self):
assert_equal(self.test_dna.locate('a'), [[0], [2]])
assert_equal(self.test_dna.locate('at'), [[0], [2]])
assert_equal(self.test_dna.locate('gc'), [[2], [0]])
assert_equal(self.test_dna.locate('atgg'), [[], []])
# Circular DNA tests
assert_equal(self.test_dna.circularize().locate('a'), [[0], [2]])
assert_equal(self.test_dna.circularize().locate('at'), [[0], [2]])
assert_equal(self.test_dna.circularize().locate('gc'), [[2], [0]])
assert_equal(self.test_dna.circularize().locate('atgg'), [[], []])
def test_copy(self):
assert_equal(self.test_dna, self.test_dna.copy())
def test_palindrome(self):
palindromic_seq_even = DNA('ATGCGCAT')
nonpalindromic_seq_even = DNA('ATGCGCAA')
almost_palindrome_odd = DNA('ATGCCAT')
assert_true(palindromic_seq_even.is_palindrome())
assert_false(nonpalindromic_seq_even.is_palindrome())
assert_false(almost_palindrome_odd.is_palindrome())
def test_getitem(self):
assert_equal(str(self.test_dna[0]), 'A')
assert_equal(str(self.test_dna[1]), 'T')
assert_equal(str(self.test_dna[2]), 'G')
assert_equal(str(self.test_dna[3]), 'C')
assert_equal(str(self.test_dna[-1]), 'C')
def test_delitem(self):
copy0 = self.test_dna.copy()
del copy0[0]
assert_equal(str(copy0), 'TGC')
copy1 = self.test_dna.copy()
del copy1[1]
assert_equal(str(copy1), 'AGC')
copy2 = self.test_dna.copy()
del copy2[2]
assert_equal(str(copy2), 'ATC')
copy3 = self.test_dna.copy()
del copy3[3]
assert_equal(str(copy3), 'ATG')
copy_1 = self.test_dna.copy()
del copy_1[-1]
assert_equal(str(copy_1), 'ATG')
def test_setitem(self):
copy0 = self.test_dna.copy()
copy0[0] = 't'
assert_equal(str(copy0), 'TTGC')
copy1 = self.test_dna.copy()
copy1[1] = 'a'
assert_equal(str(copy1), 'AAGC')
copy2 = self.test_dna.copy()
copy2[2] = 'a'
assert_equal(str(copy2), 'ATAC')
copy3 = self.test_dna.copy()
copy3[3] = 'a'
assert_equal(str(copy3), 'ATGA')
copy_1 = self.test_dna.copy()
copy_1[-1] = 'a'
assert_equal(str(copy_1), 'ATGA')
def set_gap(seq):
seq[2] = '-'
assert_raises(ValueError, set_gap, self.test_dna)
def test_repr(self):
expected_repr = 'ATGC\nTACG'
assert_equal(repr(self.test_dna), expected_repr)
expected_circ_repr = 'ATGC\nTACG'
assert_equal(repr(self.test_dna.circularize()), expected_circ_repr)
repr_1 = 'ATGCATGCATGCATGCATGCATGCATGCATGCATGCATGC ... '
repr_2 = 'ATGCATGCATGCATGCATGCATGCATGCATGCATGCATGC\n'
repr_3 = 'TACGTACGTACGTACGTACGTACGTACGTACGTACGTACG ... '
repr_4 = 'TACGTACGTACGTACGTACGTACGTACGTACGTACGTACG'
expected_long_repr = repr_1 + repr_2 + repr_3 + repr_4
assert_equal(repr(self.test_dna * 50), expected_long_repr)
def test_str(self):
assert_equal(str(self.test_dna), 'ATGC')
def test_len(self):
assert_equal(len(self.test_dna), 4)
def test_add(self):
assert_equal(str(self.test_dna + self.test_dna), 'ATGCATGC')
def test_radd(self):
assert_equal(str(sum([self.test_dna, self.test_dna])), 'ATGCATGC')
def radd_800(seq):
return 800 + seq
assert_raises(TypeError, radd_800, self.test_dna)
def test_mul(self):
assert_equal(str(self.test_dna * 4), 'ATGCATGCATGCATGC')
def mul_float(seq):
return seq * 7.56
assert_raises(TypeError, mul_float, self.test_dna)
# TODO: reimplement this test using manual sequence input
# def mul_incompatible(seq):
# return seq * 3
# incompatible_seq = self.test_dna.copy()
# incompatible_seq = incompatible_seq.five_resect(1)
# incompatible_seq = incompatible_seq.reverse_complement()
# incompatible_seq = incompatible_seq.five_resect(1)
# incompatible_seq = incompatible_seq.reverse_complement()
# assert_raises(Exception, mul_incompatible, incompatible_seq)
def test_eq(self):
assert_true(self.test_dna == DNA('atgc'))
def test_ne(self):
assert_true(self.test_dna != DNA('aagc'))
def test_contains(self):
assert_true('a' in self.test_dna)
assert_true('t' in self.test_dna)
assert_true('g' in self.test_dna)
assert_true('c' in self.test_dna)
assert_false('u' in self.test_dna)
def test_flip(self):
flipped = self.test_dna.flip()
assert_equal(str(self.test_dna), flipped.bottom)
assert_equal(self.test_dna.bottom, str(flipped))
def test_stranded_complemented():
ss_dna = DNA('atgc', stranded='ss')
r_ss_dna = ss_dna.reverse_complement()
assert_equal(r_ss_dna.top(), 'GCAT')
assert_equal(r_ss_dna.bottom(), '----')
def __init__(self):
self.dna = DNA('ATGC') * 50
self.apply_features()
