def test_pcr_does_produce_product_when_duplicate_regions_on_different_genome(
self):
p1_bs = "catagcgcacaggacgcggag"
upstream = "gagattgtccgcgtttt"
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacat"
template = ''.join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = 'aaaaaaaaaa' + p1_bs
p2 = 'tttttttttt' + str(Seq(p2_bs).reverse_complement())
g1 = self.build_genome(False, template, template)
g2 = self.build_genome(False, template)
r = pcr_from_genome(g1, p1, p2)
self.assertEquals(r[0], None)
self.assertEquals(len(r[1]), 2) # two binding sites for each primer
self.assertEquals(len(r[2]), 2) # two binding sites for each primer
r = pcr_from_genome(g2, p1, p2)
self.assertEquals(
r[0], ''.join([p1, middle,
str(Seq(p2).reverse_complement())]))
self.assertEquals(len(r[1]), 1)
self.assertEquals(len(r[2]), 1)
def test_pcr_does_produce_product_when_duplicate_regions_on_different_genome(
self):
upstream = get_random_sequence(2000)
p1_bs = "catagcgcacaggacgcggag"
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = get_random_sequence(2000)
template = "".join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = "aaaaaaaaaa" + p1_bs
p2 = "aaaaaaaaaa" + str(Seq(p2_bs).reverse_complement())
g1 = self.build_genome(False, template, template)
g2 = self.build_genome(False, template)
r = pcr_from_genome(g1, p1, p2)
self.assertEquals(r[0], None)
# 2 binding sites + 2*5 partial primer binding sites (-15 to -20 bps of primers)
self.assertEquals(len(r[1]),
118) # multiple blast results for each primer
self.assertEquals(len(r[2]),
62) # multiple blast results for each primer
r = pcr_from_genome(g2, p1, p2)
self.assertEquals(
r[0], "".join([p1, middle,
str(Seq(p2).reverse_complement())]))
# 1 binding site + 5 partial primer binding sites (-15 to -20 bps of primers)
self.assertEquals(len(r[1]), 121)
self.assertEquals(len(r[2]), 143)
def test_pcr_does_not_produce_product_when_primer_binding_site_has_too_many_mutations(self):
def mutate(s, n):
c = s[n]
if c == 'a':
c = 'g'
if c == 'g':
c = 't'
if c == 't':
c = 'c'
if c == 'c':
c = 'a'
return s[0:n]+c+s[n+1:]
p1_bs = "catagcgcacaggacgcggag"
upstream = "gagattgtccgcgtttt"
middle = "cggcacctgtgagccg"
p2_bs = "gctagcatcagtacgta"
downstream = "gttaaggcgcgaacat"
template = ''.join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = 'aaaaaaaaaa'+mutate(mutate(mutate(p1_bs, 5), 9), 11)
p1_good = 'aaaaaaaaaa'+p1_bs
p2 = 'tttttttttt'+str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(r[0], None)
self.assertEquals(len(r[1]), 1)
self.assertEquals(len(r[2]), 1)
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1_good, p2)
self.assertEquals(r[0], ''.join([p1_good, middle, str(Seq(p2).reverse_complement())]))
self.assertEquals(len(r[1]), 1)
self.assertEquals(len(r[2]), 1)
def test_pcr_produces_product_with_multiple_binding_sites_but_one_overlapping_region(
self):
p1_bs = "catagcgcacaggacgcggag"
upstream = "gagattgtccgcgtttt" + str(Seq(p1_bs).reverse_complement())
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacat"
template = ''.join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = 'aaaaaaaaaa' + p1_bs
p2 = 'tttttttttt' + str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(
r[0], ''.join([p1, middle,
str(Seq(p2).reverse_complement())]))
# 2 binding sites + 2*5 partial primer binding sites (-15 to -20 bps of primers)
self.assertEquals(len(r[1]), 12) # two binding sites for each primer
# 1 binding site + 5 partial primer binding sites (-15 to -20 bps of primers)
self.assertEquals(len(r[2]), 6) # one binding site for this primer
self.assertEquals(r[3]['fragment_name'], g.fragments.all()[0].name)
self.assertEquals(r[3]['fragment_id'], g.fragments.all()[0].id)
self.assertEquals(
r[3]['region'],
(len(upstream) + 1, len(upstream + p1_bs + middle + p2_bs)))
def test_pcr_produces_expected_product(self):
upstream = get_random_sequence(2000)
p1_bs = "catagcgcacaggacgcggag"
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = get_random_sequence(2000)
template = "".join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = "aaaaaaaaaa" + p1_bs
p2 = "aaaaaaaaaa" + str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(
r[0], "".join([p1, middle,
str(Seq(p2).reverse_complement())]))
# 1 binding site + 5 partial primer binding sites (-15 to -20 bps of primers)
self.assertEquals(len(r[1]),
121) # multiple blast results for each primer
self.assertEquals(len(r[2]),
143) # multiple blast results for each primer
self.assertEquals(r[3]["fragment_name"], g.fragments.all()[0].name)
self.assertEquals(r[3]["fragment_id"], g.fragments.all()[0].id)
self.assertEquals(
r[3]["region"],
(len(upstream) + 1, len(upstream + p1_bs + middle + p2_bs)))
def remove_working_primers(genome, primers):
failed_primers = []
for primer in primers:
p1 = primer['PRIMER_LEFT_SEQUENCE']
p2 = primer['PRIMER_RIGHT_SEQUENCE']
p = pcr_from_genome(genome, p1, p2)
if p[0] is None:
failed_primers.append(primer)
return failed_primers
def remove_working_primers(genome, primers):
failed_primers = []
for primer in primers:
p1 = primer['PRIMER_LEFT_SEQUENCE']
p2 = primer['PRIMER_RIGHT_SEQUENCE']
p = pcr_from_genome(genome, p1, p2)
if p[0] is None:
failed_primers.append(primer)
return failed_primers
def test_pcr_does_not_produce_product_when_primer_binding_site_has_too_many_mutations(
self):
def mutate(s, n):
c = s[n]
if c == 'a':
c = 'g'
if c == 'g':
c = 't'
if c == 't':
c = 'c'
if c == 'c':
c = 'a'
return s[0:n] + c + s[n + 1:]
p1_bs = "catagcgcacaggacgcggag"
upstream = "gagattgtccgcgtttt"
middle = "cggcacctgtgagccg"
p2_bs = "gctagcatcagtacgta"
downstream = "gttaaggcgcgaacat"
template = ''.join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = 'aaaaaaaaaa' + mutate(mutate(mutate(p1_bs, 5), 9), 11)
p1_good = 'aaaaaaaaaa' + p1_bs
p2 = 'tttttttttt' + str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(r[0], None)
# 1 binding site + 5 partial primer binding sites (-15 to -20 bps of primers)
self.assertEquals(len(r[1]), 6)
self.assertEquals(len(r[2]), 6)
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1_good, p2)
self.assertEquals(
r[0], ''.join([p1_good, middle,
str(Seq(p2).reverse_complement())]))
# 1 binding site + 5 partial primer binding sites (-15 to -20 bps of primers)
self.assertEquals(len(r[1]), 6)
self.assertEquals(len(r[2]), 6)
def test_pcr_does_not_produce_product_when_primer_binding_site_has_too_many_mutations(
self, ):
def mutate(s, n):
c = s[n]
if c == "a":
c = "g"
if c == "g":
c = "t"
if c == "t":
c = "c"
if c == "c":
c = "a"
return s[0:n] + c + s[n + 1:]
upstream = get_random_sequence(2000)
p1_bs = "catagcgcacaggacgcggag"
middle = "cggcacctgtgagccg"
p2_bs = "gctagcatcagtacgta"
downstream = get_random_sequence(2000)
template = "".join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = "aaaaaaaaaa" + mutate(mutate(mutate(p1_bs, 5), 9), 11)
p1_good = "aaaaaaaaaa" + p1_bs
p2 = "aaaaaaaaaa" + str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(r[0], None)
# 1 binding site + 5 partial primer binding sites (-15 to -20 bps of primers)
self.assertEquals(len(r[1]), 114)
self.assertEquals(len(r[2]), 128)
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1_good, p2)
self.assertEquals(
r[0], "".join([p1_good, middle,
str(Seq(p2).reverse_complement())]))
# 1 binding site + 5 partial primer binding sites (-15 to -20 bps of primers)
self.assertEquals(len(r[1]), 121)
self.assertEquals(len(r[2]), 128)
def test_pcr_does_produce_product_when_duplicate_regions_on_different_genome(self):
p1_bs = "catagcgcacaggacgcggag"
upstream = "gagattgtccgcgtttt"
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacat"
template = ''.join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = 'aaaaaaaaaa'+p1_bs
p2 = 'tttttttttt'+str(Seq(p2_bs).reverse_complement())
g1 = self.build_genome(False, template, template)
g2 = self.build_genome(False, template)
r = pcr_from_genome(g1, p1, p2)
self.assertEquals(r[0], None)
self.assertEquals(len(r[1]), 2) # two binding sites for each primer
self.assertEquals(len(r[2]), 2) # two binding sites for each primer
r = pcr_from_genome(g2, p1, p2)
self.assertEquals(r[0], ''.join([p1, middle, str(Seq(p2).reverse_complement())]))
self.assertEquals(len(r[1]), 1)
self.assertEquals(len(r[2]), 1)
def test_pcr_does_not_produce_product_with_multiple_overlapping_regions(self):
p1_bs = "catagcgcacaggacgcggag"
upstream = "gagattgtccgcgtttt"+str(Seq(p1_bs).reverse_complement())
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = "gttaaggc"+p2_bs+"gcgaacat"
template = ''.join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = 'aaaaaaaaaa'+p1_bs
p2 = 'tttttttttt'+str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(r[0], None)
self.assertEquals(len(r[1]), 2) # two binding sites for each primer
self.assertEquals(len(r[2]), 2) # two binding sites for each primer
def on_post(self, request, genome_id):
from edge.pcr import pcr_from_genome
genome = get_genome_or_404(genome_id)
parser = RequestParser()
parser.add_argument('primers', field_type=list, required=True, location='json')
args = parser.parse_args(request)
primers = args['primers']
if len(primers) != 2:
raise Exception('Expecting two primers, got %s' % (primers,))
r = pcr_from_genome(genome, primers[0], primers[1])
r = (r[0], [b.to_dict() for b in r[1]], [b.to_dict() for b in r[2]], r[3])
return r, 200
def test_pcr_does_not_produce_product_when_primer_binding_site_is_too_small(self):
p1_bs = "catagcgcacaggacgcggag"
upstream = "gagattgtccgcgtttt"
middle = "cggcacctgtgagccg"
p2_bs = "gctagcatca"
downstream = "gttaaggcgcgaacat"
template = ''.join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = 'aaaaaaaaaa'+p1_bs
p2 = 'tttttttttt'+str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(r[0], None)
self.assertEquals(len(r[1]), 1)
self.assertEquals(len(r[2]), 0)
def test_pcr_does_not_produce_product_with_multiple_overlapping_regions(
self):
p1_bs = "catagcgcacaggacgcggag"
upstream = "gagattgtccgcgtttt" + str(Seq(p1_bs).reverse_complement())
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = "gttaaggc" + p2_bs + "gcgaacat"
template = ''.join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = 'aaaaaaaaaa' + p1_bs
p2 = 'tttttttttt' + str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(r[0], None)
self.assertEquals(len(r[1]), 2) # two binding sites for each primer
self.assertEquals(len(r[2]), 2) # two binding sites for each primer
def test_pcr_does_not_produce_product_when_primer_binding_site_is_too_small(
self):
p1_bs = "catagcgcacaggacgcggag"
upstream = "gagattgtccgcgtttt"
middle = "cggcacctgtgagccg"
p2_bs = "gctagcatca"
downstream = "gttaaggcgcgaacat"
template = ''.join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = 'aaaaaaaaaa' + p1_bs
p2 = 'tttttttttt' + str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(r[0], None)
self.assertEquals(len(r[1]), 1)
self.assertEquals(len(r[2]), 0)
def test_finds_pcr_product_when_rev_primer_is_across_circular_boundary(self):
upstream = "gagattgtccgcgtttt"
p1_bs = "catagcgcacaggacgcggag"
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacat"
p1 = 'aaaaaaaaaa'+p1_bs
p2 = 'tttttttttt'+str(Seq(p2_bs).reverse_complement())
template = ''.join([p2_bs[5:], downstream, upstream, p1_bs, middle, p2_bs[0:5]])
g = self.build_genome(True, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(r[0], ''.join([p1, middle, str(Seq(p2).reverse_complement())]))
self.assertEquals(r[3]['fragment_name'], g.fragments.all()[0].name)
self.assertEquals(r[3]['fragment_id'], g.fragments.all()[0].id)
self.assertEquals(r[3]['region'], (len(p2_bs)-5+len(downstream+upstream)+1, len(p2_bs)-5))
def test_primer3_finds_primers_when_given_range_to_find_primers(self):
upstream = "cagtacgatcgttggtatgctgactactagcgtagctagcacgtcgtgtccaggcttgagcgacgt"
product = "cagctggtaatcgtactcgtactagcatcgtacgtgtctgatcatctgacgtatcatctga"
downstream = "agtgacgtcgtgtgtagcgtactgtatcgtgtgtcgcgcgtagtcatctgatcgtacgtactgaat"
template = ''.join([upstream, product, downstream])
g = self.build_genome(False, 'a'*40+template+'a'*40)
f = g.fragments.all()[0]
res = design_primers(f, 40+len(upstream)+1, len(product), 50, 50, {})
self.assertEquals(len(res), 5)
for r in res:
p = pcr_from_genome(g, r['PRIMER_LEFT_SEQUENCE'], r['PRIMER_RIGHT_SEQUENCE'])
self.assertNotEqual(p[0], None)
self.assertEquals(p[0].index(product) >= 0, True)
def test_pcr_does_not_produce_product_when_primer_binds_to_different_fragments(self):
p1_bs = "catagcgcacaggacgcggag"
upstream = "gagattgtccgcgtttt"
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacat"
template1 = ''.join([upstream, p1_bs, middle])
template2 = ''.join([middle, p2_bs, downstream])
p1 = 'aaaaaaaaaa'+p1_bs
p2 = 'tttttttttt'+str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template1, template2)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(r[0], None)
self.assertEquals(len(r[1]), 1)
self.assertEquals(len(r[2]), 1)
def test_pcr_does_not_produce_product_when_primer_binding_site_is_too_small(
self):
upstream = get_random_sequence(2000)
p1_bs = "catagcgcacaggacgcggag"
middle = "cggcacctgtgagccg"
p2_bs = "gctagcatca"
downstream = get_random_sequence(2000)
template = "".join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = "aaaaaaaaaa" + p1_bs
p2 = "aaaaaaaaaa" + str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(r[0], None)
# 1 binding site + 5 partial primer binding sites (-15 to -20 bps of primers)
self.assertEquals(len(r[1]), 121)
self.assertEquals(len(r[2]), 65)
def test_pcr_does_not_produce_product_when_primer_binds_to_different_fragments(
self):
p1_bs = "catagcgcacaggacgcggag"
upstream = "gagattgtccgcgtttt"
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacat"
template1 = ''.join([upstream, p1_bs, middle])
template2 = ''.join([middle, p2_bs, downstream])
p1 = 'aaaaaaaaaa' + p1_bs
p2 = 'tttttttttt' + str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template1, template2)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(r[0], None)
self.assertEquals(len(r[1]), 1)
self.assertEquals(len(r[2]), 1)
def test_pcr_does_not_produce_product_when_primer_binds_to_different_fragments(
self, ):
upstream = get_random_sequence(2000)
p1_bs = "catagcgcacaggacgcggag"
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = get_random_sequence(2000)
template1 = "".join([upstream, p1_bs, middle])
template2 = "".join([middle, p2_bs, downstream])
p1 = "aaaaaaaaaa" + p1_bs
p2 = "aaaaaaaaaa" + str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template1, template2)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(r[0], None)
# 1 binding site + 5 partial primer binding sites (-15 to -20 bps of primers)
self.assertEquals(len(r[1]), 126)
self.assertEquals(len(r[2]), 143)
def test_pcr_produces_product_with_multiple_binding_sites_but_one_overlapping_region(self):
p1_bs = "catagcgcacaggacgcggag"
upstream = "gagattgtccgcgtttt"+str(Seq(p1_bs).reverse_complement())
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacat"
template = ''.join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = 'aaaaaaaaaa'+p1_bs
p2 = 'tttttttttt'+str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(r[0], ''.join([p1, middle, str(Seq(p2).reverse_complement())]))
self.assertEquals(len(r[1]), 2) # two binding sites for each primer
self.assertEquals(len(r[2]), 1) # one binding site for this primer
self.assertEquals(r[3]['fragment_name'], g.fragments.all()[0].name)
self.assertEquals(r[3]['fragment_id'], g.fragments.all()[0].id)
self.assertEquals(r[3]['region'], (len(upstream)+1, len(upstream+p1_bs+middle+p2_bs)))
def test_finds_pcr_product_across_circular_boundary(self):
upstream = "gagattgtccgcgtttt"
p1_bs = "catagcgcacaggacgcggag"
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacat"
p1 = 'aaaaaaaaaa' + p1_bs
p2 = 'tttttttttt' + str(Seq(p2_bs).reverse_complement())
template = ''.join(
[middle[10:], p2_bs, downstream, upstream, p1_bs, middle[0:10]])
g = self.build_genome(True, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(
r[0], ''.join([p1, middle,
str(Seq(p2).reverse_complement())]))
self.assertEquals(r[3]['fragment_name'], g.fragments.all()[0].name)
self.assertEquals(r[3]['fragment_id'], g.fragments.all()[0].id)
self.assertEquals(r[3]['region'], (len(template) - 10 - len(p1_bs) + 1,
len(middle) - 10 + len(p2_bs)))
def test_pcr_does_not_produce_product_with_multiple_overlapping_regions(
self):
p1_bs = "catagcgcacaggacgcggag"
upstream = get_random_sequence(2000) + str(
Seq(p1_bs).reverse_complement())
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = get_random_sequence(2000) + p2_bs + get_random_sequence(
2000)
template = "".join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = "aaaaaaaaaa" + p1_bs
p2 = "aaaaaaaaaa" + str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(r[0], None)
# 2 binding sites + 2*5 partial primer binding sites (-15 to -20 bps of primers)
self.assertEquals(len(r[1]),
97) # multiple blast results for each primer
self.assertEquals(len(r[2]),
101) # multiple blast results for each primer
def test_pcr_produces_expected_product(self):
upstream = "gagattgtccgcgtttt"
p1_bs = "catagcgcacaggacgcggag"
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacat"
template = ''.join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = 'aaaaaaaaaa' + p1_bs
p2 = 'tttttttttt' + str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(r[0], ''.join([p1, middle, str(Seq(p2).reverse_complement())]))
# 1 binding site + 5 partial primer binding sites (-15 to -20 bps of primers)
self.assertEquals(len(r[1]), 6) # one binding site for each primer
self.assertEquals(len(r[2]), 6) # one binding site for each primer
self.assertEquals(r[3]['fragment_name'], g.fragments.all()[0].name)
self.assertEquals(r[3]['fragment_id'], g.fragments.all()[0].id)
self.assertEquals(
r[3]['region'],
(len(upstream) + 1, len(upstream + p1_bs + middle + p2_bs)))
def on_post(self, request, genome_id):
from edge.pcr import pcr_from_genome
from edge.blastdb import check_and_build_genome_db
genome = get_genome_or_404(genome_id)
check_and_build_genome_db(genome)
parser = RequestParser()
parser.add_argument('primers',
field_type=list,
required=True,
location='json')
args = parser.parse_args(request)
primers = args['primers']
if len(primers) != 2:
raise Exception('Expecting two primers, got %s' % (primers, ))
r = pcr_from_genome(genome, primers[0], primers[1])
r = (r[0], [b.to_dict() for b in r[1]], [b.to_dict()
for b in r[2]], r[3])
return r, 200
def test_pcr_produces_expected_product(self):
upstream = "gagattgtccgcgtttt"
p1_bs = "catagcgcacaggacgcggag"
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacat"
template = ''.join([upstream, p1_bs, middle, p2_bs, downstream])
p1 = 'aaaaaaaaaa' + p1_bs
p2 = 'tttttttttt' + str(Seq(p2_bs).reverse_complement())
g = self.build_genome(False, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(
r[0], ''.join([p1, middle,
str(Seq(p2).reverse_complement())]))
self.assertEquals(len(r[1]), 1) # one binding site for each primer
self.assertEquals(len(r[2]), 1) # one binding site for each primer
self.assertEquals(r[3]['fragment_name'], g.fragments.all()[0].name)
self.assertEquals(r[3]['fragment_id'], g.fragments.all()[0].id)
self.assertEquals(
r[3]['region'],
(len(upstream) + 1, len(upstream + p1_bs + middle + p2_bs)))
def test_finds_pcr_product_when_fwd_primer_is_across_circular_boundary(
self):
upstream = get_random_sequence(2000)
p1_bs = "catagcgcacaggacgcggag"
middle = "cggcacctgtgagccg"
p2_bs = "taatgaccccgaagcagg"
downstream = get_random_sequence(2000)
p1 = "aaaaaaaaaa" + p1_bs
p2 = "aaaaaaaaaa" + str(Seq(p2_bs).reverse_complement())
template = "".join(
[p1_bs[5:], middle, p2_bs, downstream, upstream, p1_bs[0:5]])
g = self.build_genome(True, template)
r = pcr_from_genome(g, p1, p2)
self.assertEquals(
r[0], "".join([p1, middle,
str(Seq(p2).reverse_complement())]))
self.assertEquals(r[3]["fragment_name"], g.fragments.all()[0].name)
self.assertEquals(r[3]["fragment_id"], g.fragments.all()[0].id)
self.assertEquals(
r[3]["region"],
(len(template) - 5 + 1, len(p1_bs) - 5 + len(middle + p2_bs)),
)
def __test_verification_primers(self, template, middle, cassette, arm_len,
is_reversed):
from edge.pcr import pcr_from_genome
g = self.build_genome(False, template)
r = find_swap_region(g, cassette, arm_len, design_primers=True)
self.assertEquals(len(r), 1)
self.assertEquals(len(r[0].verification_cassette), 5)
self.assertEquals(len(r[0].verification_front), 5)
self.assertEquals(len(r[0].verification_back), 5)
# cassette verification primers should work on unmodified genome
for primer in r[0].verification_cassette:
p = pcr_from_genome(g, primer['PRIMER_LEFT_SEQUENCE'],
primer['PRIMER_RIGHT_SEQUENCE'])
self.assertNotEqual(p[0], None)
self.assertEquals(p[0].index(middle) >= 0, True)
# front verification primers should NOT produce product
for primer in r[0].verification_front:
p = pcr_from_genome(g, primer['PRIMER_LEFT_SEQUENCE'],
primer['PRIMER_RIGHT_SEQUENCE'])
self.assertEqual(p[0], None)
# back verification primers should NOT produce product
for primer in r[0].verification_back:
p = pcr_from_genome(g, primer['PRIMER_LEFT_SEQUENCE'],
primer['PRIMER_RIGHT_SEQUENCE'])
self.assertEqual(p[0], None)
# do recombination, then try primers again on modified genome
c = recombine(g, cassette, arm_len)
for f in c.fragments.all():
try:
os.unlink(fragment_fasta_fn(f))
except:
pass
build_all_genome_dbs(refresh=True)
# reload to get blastdb
c = Genome.objects.get(pk=c.id)
if is_reversed:
cassette = str(Seq(cassette).reverse_complement())
# cassette verification primers should work on modified genome, finding cassette
for primer in r[0].verification_cassette:
p = pcr_from_genome(c, primer['PRIMER_LEFT_SEQUENCE'],
primer['PRIMER_RIGHT_SEQUENCE'])
self.assertNotEqual(p[0], None)
self.assertEquals(p[0].index(cassette) >= 0, True)
# front verification primers should find a product including front of cassette
for primer in r[0].verification_front:
p = pcr_from_genome(c, primer['PRIMER_LEFT_SEQUENCE'],
primer['PRIMER_RIGHT_SEQUENCE'])
self.assertNotEqual(p[0], None)
self.assertEquals(
p[0].index(cassette[0:edge.recombine.CHECK_JUNCTION_LEFT_DN])
>= 0, True)
# back verification primers should find a product including back of cassette
for primer in r[0].verification_back:
p = pcr_from_genome(c, primer['PRIMER_LEFT_SEQUENCE'],
primer['PRIMER_RIGHT_SEQUENCE'])
self.assertNotEqual(p[0], None)
self.assertEquals(
p[0].index(cassette[-edge.recombine.CHECK_JUNCTION_RIGHT_UP:])
>= 0, True)
# flake8: noqa
import django
django.setup()
import sys
from edge.models import Genome
from edge.blast import blast_genome
from edge.pcr import pcr_from_genome
genome = Genome.objects.get(pk=36161)
print(genome.fragments.count())
res = blast_genome(genome, "blastn", "ctcacgttactgtggggtggaggggaca")
for r in res:
print("p: %s" % r.evalue)
primer_fwd = "aggaagtgccattccgcctgacctcgtctcactgaccgtctctctcctgagtccgga"
primer_rev = "aaagtgtcaaggtctcacgttactgtggggtggaggggaca"
res = blast_genome(genome, "blastn", primer_fwd)
for r in res:
print("fwd: %s" % r.evalue)
res = blast_genome(genome, "blastn", primer_rev)
for r in res:
print("rev: %s" % r.evalue)
print(pcr_from_genome(genome, primer_fwd, primer_rev))
def __test_verification_primers(self, template, middle, cassette, arm_len, is_reversed):
from edge.pcr import pcr_from_genome
g = self.build_genome(False, template)
r = find_swap_region(g, cassette, arm_len, design_primers=True)
self.assertEquals(len(r), 1)
self.assertEquals(len(r[0].verification_cassette), 5)
self.assertEquals(len(r[0].verification_front), 5)
self.assertEquals(len(r[0].verification_back), 5)
# cassette verification primers should work on unmodified genome
for primer in r[0].verification_cassette:
p = pcr_from_genome(g, primer['PRIMER_LEFT_SEQUENCE'], primer['PRIMER_RIGHT_SEQUENCE'])
self.assertNotEqual(p[0], None)
self.assertEquals(p[0].index(middle) >= 0, True)
# front verification primers should NOT produce product
for primer in r[0].verification_front:
p = pcr_from_genome(g, primer['PRIMER_LEFT_SEQUENCE'], primer['PRIMER_RIGHT_SEQUENCE'])
self.assertEqual(p[0], None)
# back verification primers should NOT produce product
for primer in r[0].verification_back:
p = pcr_from_genome(g, primer['PRIMER_LEFT_SEQUENCE'], primer['PRIMER_RIGHT_SEQUENCE'])
self.assertEqual(p[0], None)
# do recombination, then try primers again on modified genome
c = recombine(g, cassette, arm_len)
for f in c.fragments.all():
try:
os.unlink(fragment_fasta_fn(f))
except:
pass
build_all_genome_dbs(refresh=True)
# reload to get blastdb
c = Genome.objects.get(pk=c.id)
if is_reversed:
cassette = str(Seq(cassette).reverse_complement())
# cassette verification primers should work on modified genome, finding cassette
for primer in r[0].verification_cassette:
p = pcr_from_genome(c, primer['PRIMER_LEFT_SEQUENCE'], primer['PRIMER_RIGHT_SEQUENCE'])
self.assertNotEqual(p[0], None)
self.assertEquals(p[0].index(cassette) >= 0, True)
# front verification primers should find a product including front of cassette
for primer in r[0].verification_front:
p = pcr_from_genome(c, primer['PRIMER_LEFT_SEQUENCE'], primer['PRIMER_RIGHT_SEQUENCE'])
self.assertNotEqual(p[0], None)
self.assertEquals(p[0].index(cassette[0:edge.recombine.CHECK_JUNCTION_LEFT_DN]) >= 0,
True)
# back verification primers should find a product including back of cassette
for primer in r[0].verification_back:
p = pcr_from_genome(c, primer['PRIMER_LEFT_SEQUENCE'], primer['PRIMER_RIGHT_SEQUENCE'])
self.assertNotEqual(p[0], None)
self.assertEquals(p[0].index(cassette[-edge.recombine.CHECK_JUNCTION_RIGHT_UP:]) >= 0,
True)
