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_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_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_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_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_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)
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_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_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_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_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_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_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_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))
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 test_primer():
'''Test primer function.'''
seq = 'ATGGTGAGCAAGGGCGAGGAGCTGTTCACCGGGGTGGTGCCCATCCTGGTCGAGCTGGACGGC' + \
'GACGTAAACGGCCACAAGTTCAGCGTGTCCGGCGAGGGCGAGGGCGATGCCACCTACGGCAAG' + \
'CTGACCCTGAAGTTCATCTGCACCACCGGCAAGCTGCCCGTGCCCTGGCCCACCCTCGTGACC' + \
'ACCTTCGGCTACGGCCTGCAGTGCTTCGCCCGCTACCCCGACCACATGAAGCAGCACGACTTC' + \
'TTCAAGTCCGCCATGCCCGAAGGCTACGTCCAGGAGCGCACCATCTTCTTCAAGGACGACGGC' + \
'AACTACAAGACCCGCGCCGAGGTGAAGTTCGAGGGCGACACCCTGGTGAACCGCATCGAGCTG' + \
'AAGGGCATCGACTTCAAGGAGGACGGCAACATCCTGGGGCACAAGCTGGAGTACAACTACAAC' + \
'AGCCACAACGTCTATATCATGGCCGACAAGCAGAAGAACGGCATCAAGGTGAACTTCAAGATC' + \
'CGCCACAACATCGAGGACGGCAGCGTGCAGCTCGCCGACCACTACCAGCAGAACACCCCCATC' + \
'GGCGACGGCCCCGTGCTGCTGCCCGACAACCACTACCTGAGCTACCAGTCCGCCCTGAGCAAA' + \
'GACCCCAACGAGAAGCGCGATCACATGGTCCTGCTGGAGTTCGTGACCGCCGCCGGGATCACT' + \
'CTCGGCATGGACGAGCTGTACAAGTAA'
dna_seq = DNA(seq)
primer = design.primer(dna_seq,
tm=72,
min_len=10,
tm_undershoot=1,
tm_overshoot=3,
end_gc=False,
tm_parameters='cloning',
overhang=None)
assert_equals(str(primer), 'ATGGTGAGCAAGGGCGAGGAG')
# Ensure that overhang is appropriately applied
overhang_primer = design.primer(dna_seq,
tm=72,
min_len=10,
tm_undershoot=1,
tm_overshoot=3,
end_gc=False,
tm_parameters='cloning',
overhang=DNA('GATCGATAT'))
assert_equals(str(overhang_primer), 'GATCGATATATGGTGAGCAAGGGCGAGGAG')
# If sequence is too short (too low of Tm), raise ValueError
too_short = DNA('at')
assert_raises(ValueError, design.primer, too_short, tm=72)
# Should design different primers (sometimes) if ending on GC is preferred
diff_template = DNA('GATCGATCGATACGATCGATATGCGATATGATCGATAT')
nogc = design.primer(diff_template,
tm=72,
min_len=10,
tm_undershoot=1,
tm_overshoot=3,
end_gc=False,
tm_parameters='cloning',
overhang=None)
withgc = design.primer(diff_template,
tm=72,
min_len=10,
tm_undershoot=1,
tm_overshoot=3,
end_gc=True,
tm_parameters='cloning',
overhang=None)
assert_not_equal(nogc, withgc)
# Should raise ValueError if it's impossible to create an end_gc primer
end_at_template = DNA('ATGCGATACGATACGCGATATGATATATatatatat' +
'ATAAaaaaaaaaaattttttttTTTTTTTTTTTTTT' +
'TTTTTTTTTT')
assert_raises(ValueError,
design.primer,
end_at_template,
end_gc=True,
tm=72)
def __init__(self):
self.dna = DNA('ATGC') * 50
self.apply_features()
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 test_ne(self):
assert_true(self.test_dna != DNA('aagc'))
def test_eq(self):
assert_true(self.test_dna == DNA('atgc'))
