def test_does_not_return_front_back_junction_verification_primers_if_they_are_not_useful(
self):
upstream = "gagattgtccgcgttttagctgatacgtacgtgtcgatcgacttgcgtatctgatcatctgacgtagat"
front_bs = "catagcgcacaggacgcggag"
middle = "ccagtcgctgaggcagtcgatgcaggcatcgatcaggctggcacctgtgagccgagctcacgtatgcatcatcattga"
back_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacatagctagtactagtcacgtagtcatttgtcgtacgtacgtattgagtcatca"
replaced = "gactacgatcagtcgtagtaacgcgtagcgtagtcagcgtacacgtacgtagacgacgtacatgcatcgtactgtatc"
template = ''.join([upstream, front_bs, middle, back_bs, downstream])
cassette = ''.join([front_bs, replaced, back_bs])
arm_len = min(len(front_bs), len(back_bs))
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 same as region to be replaced, front and back verification
# primers are not useful
cassette = ''.join([front_bs, middle, back_bs])
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), 0)
self.assertEquals(len(r[0].verification_back), 0)
def test_does_not_return_front_back_junction_verification_primers_if_they_are_not_useful(self):
upstream = "gagattgtccgcgttttagctgatacgtacgtgtcgatcgacttgcgtatctgatcatctgacgtagat"
front_bs = "catagcgcacaggacgcggag"
middle = "ccagtcgctgaggcagtcgatgcaggcatcgatcaggctggcacctgtgagccgagctcacgtatgcatcatcattga"
back_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacatagctagtactagtcacgtagtcatttgtcgtacgtacgtattgagtcatca"
replaced = "gactacgatcagtcgtagtaacgcgtagcgtagtcagcgtacacgtacgtagacgacgtacatgcatcgtactgtatc"
template = ''.join([upstream, front_bs, middle, back_bs, downstream])
cassette = ''.join([front_bs, replaced, back_bs])
arm_len = min(len(front_bs), len(back_bs))
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 same as region to be replaced, front and back verification
# primers are not useful
cassette = ''.join([front_bs, middle, back_bs])
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), 0)
self.assertEquals(len(r[0].verification_back), 0)
def test_finding_swap_region_across_circular_boundary(self):
upstream = "gagattgtccgcgtttt"
front_bs = "catagcgcacaggacgcggag"
middle = "cggcacctgtgagccg"
back_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacat"
replaced = "aaaaaaaaaaaaaaaaaaa"
cassette = ''.join([front_bs, replaced, back_bs])
arm_len = min(len(front_bs), len(back_bs))
template = ''.join(
[middle[8:], back_bs, downstream, upstream, front_bs, middle[0:8]])
g = self.build_genome(True, template)
r = find_swap_region(g, cassette, arm_len)
self.assertEquals(len(r), 1)
self.assertEquals(r[0].fragment_id, g.fragments.all()[0].id)
self.assertEquals(r[0].fragment_name, g.fragments.all()[0].name)
self.assertEquals(r[0].start, len(template) - 8 - len(front_bs) + 1)
self.assertEquals(r[0].end, len(middle) - 8 + len(back_bs))
self.assertEquals(r[0].sequence, ''.join([front_bs, middle, back_bs]))
self.assertEquals(r[0].cassette_reversed, False)
self.assertEquals(r[0].front_arm, front_bs[0:arm_len])
self.assertEquals(r[0].back_arm, back_bs[-arm_len:])
def test_finds_correct_region_for_swapping_with_reverse_complement_cassette(
self):
upstream = "gagattgtccgcgtttt"
front_bs = "catagcgcacaggacgcggag"
middle = "cggcacctgtgagccg"
back_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacat"
replaced = "aaaaaaaaaaaaaaaaaaa"
cassette = str(
Seq(''.join([front_bs, replaced, back_bs])).reverse_complement())
arm_len = min(len(front_bs), len(back_bs))
template = ''.join([upstream, front_bs, middle, back_bs, downstream])
g = self.build_genome(False, template)
r = find_swap_region(g, cassette, arm_len)
self.assertEquals(len(r), 1)
self.assertEquals(r[0].fragment_id, g.fragments.all()[0].id)
self.assertEquals(r[0].fragment_name, g.fragments.all()[0].name)
self.assertEquals(r[0].start, len(upstream) + 1)
self.assertEquals(r[0].end, len(template) - len(downstream))
self.assertEquals(r[0].sequence, ''.join([front_bs, middle, back_bs]))
self.assertEquals(r[0].cassette_reversed, True)
self.assertEquals(r[0].front_arm,
str(Seq(back_bs[-arm_len:]).reverse_complement()))
self.assertEquals(r[0].back_arm,
str(Seq(front_bs[0:arm_len]).reverse_complement()))
def test_finding_reverse_complement_region_when_back_arm_is_across_circular_boundary(
self, ):
upstream = "gagattgtccgcgtttt"
front_bs = "catagcgcacaggacgcggag"
middle = "cggcacctgtgagccg"
back_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacat"
replaced = "aaaaaaaaaaaaaaaaaaa"
cassette = str(
Seq("".join([front_bs, replaced, back_bs])).reverse_complement())
arm_len = min(len(front_bs), len(back_bs))
template = "".join([
back_bs[8:], downstream, upstream, front_bs, middle, back_bs[0:8]
])
g = self.build_genome(True, template)
r = find_swap_region(g, cassette, arm_len)
self.assertEquals(len(r), 1)
self.assertEquals(r[0].fragment_id, g.fragments.all()[0].id)
self.assertEquals(r[0].fragment_name, g.fragments.all()[0].name)
self.assertEquals(r[0].start,
len(back_bs) - 8 + len(downstream + upstream) + 1)
self.assertEquals(r[0].end, len(back_bs) - 8)
self.assertEquals(r[0].sequence, "".join([front_bs, middle, back_bs]))
self.assertEquals(r[0].cassette_reversed, True)
self.assertEquals(r[0].front_arm,
str(Seq(back_bs[-arm_len:]).reverse_complement()))
self.assertEquals(r[0].back_arm,
str(Seq(front_bs[0:arm_len]).reverse_complement()))
def test_finds_single_crossover_region(self):
upstream = "gagattgtccgcgtttt"
locus = "catagcgcacaggacgcggagtaggcgtagtcggttgatctgatgtc"
downstream = "gttaaggcgcgaacat"
insertion = "aaaaaaaaaaaaaaaaaaa"
locus_len = len(locus)
bs_len = int(locus_len / 2)
template = "".join([upstream, locus, downstream])
cassette = "".join(
[locus[locus_len - bs_len:], insertion, locus[0:bs_len]])
g = self.build_genome(False, template)
arm_len = bs_len - 2
r = find_swap_region(g, cassette, arm_len)
self.assertEquals(len(r), 1)
self.assertEquals(r[0].fragment_id, g.fragments.all()[0].id)
self.assertEquals(r[0].fragment_name, g.fragments.all()[0].name)
self.assertEquals(r[0].is_double_crossover, False)
self.assertEquals(r[0].start, 20)
self.assertEquals(r[0].end, 62)
def test_finds_correct_region_for_swapping(self):
upstream = "gagattgtccgcgtttt"
front_bs = "catagcgcacaggacgcggag"
middle = "cggcacctgtgagccg"
back_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacat"
replaced = "aaaaaaaaaaaaaaaaaaa"
template = ''.join([upstream, front_bs, middle, back_bs, downstream])
cassette = ''.join([front_bs, replaced, back_bs])
arm_len = min(len(front_bs), len(back_bs))
g = self.build_genome(False, template)
r = find_swap_region(g, cassette, arm_len)
self.assertEquals(len(r), 1)
self.assertEquals(r[0].fragment_id, g.fragments.all()[0].id)
self.assertEquals(r[0].fragment_name, g.fragments.all()[0].name)
self.assertEquals(r[0].start, len(upstream)+1)
self.assertEquals(r[0].end, len(template)-len(downstream))
self.assertEquals(r[0].sequence, ''.join([front_bs, middle, back_bs]))
self.assertEquals(r[0].cassette_reversed, False)
self.assertEquals(r[0].front_arm, front_bs[0:arm_len])
self.assertEquals(r[0].back_arm, back_bs[-arm_len:])
def test_finding_swap_region_across_circular_boundary(self):
upstream = "gagattgtccgcgtttt"
front_bs = "catagcgcacaggacgcggag"
middle = "cggcacctgtgagccg"
back_bs = "taatgaccccgaagcagg"
downstream = "gttaaggcgcgaacat"
replaced = "aaaaaaaaaaaaaaaaaaa"
cassette = ''.join([front_bs, replaced, back_bs])
arm_len = min(len(front_bs), len(back_bs))
template = ''.join([middle[8:], back_bs, downstream, upstream, front_bs, middle[0:8]])
g = self.build_genome(True, template)
r = find_swap_region(g, cassette, arm_len)
self.assertEquals(len(r), 1)
self.assertEquals(r[0].fragment_id, g.fragments.all()[0].id)
self.assertEquals(r[0].fragment_name, g.fragments.all()[0].name)
self.assertEquals(r[0].start, len(template)-8-len(front_bs)+1)
self.assertEquals(r[0].end, len(middle)-8+len(back_bs))
self.assertEquals(r[0].sequence, ''.join([front_bs, middle, back_bs]))
self.assertEquals(r[0].cassette_reversed, False)
self.assertEquals(r[0].front_arm, front_bs[0:arm_len])
self.assertEquals(r[0].back_arm, back_bs[-arm_len:])
def on_post(self, request, genome_id):
from edge.recombine import find_swap_region, recombine
genome = get_genome_or_404(genome_id)
parser = RequestParser()
parser.add_argument('cassette', field_type=str, required=True, location='json')
parser.add_argument('homology_arm_length', field_type=int, required=True, location='json')
parser.add_argument('create', field_type=bool, required=True, location='json')
parser.add_argument('genome_name', field_type=str, required=False,
default=None, location='json')
parser.add_argument('cassette_name', field_type=str, required=False,
default=None, location='json')
parser.add_argument('notes', field_type=str, required=False,
default=None, location='json')
args = parser.parse_args(request)
cassette = args['cassette']
arm_length = args['homology_arm_length']
create = args['create']
genome_name = args['genome_name']
cassette_name = args['cassette_name']
notes = args['notes']
if create is False:
r = find_swap_region(genome, cassette, arm_length)
return [x.to_dict() for x in r], 200
else:
c = recombine(genome, cassette, arm_length,
genome_name=genome_name,
cassette_name=cassette_name,
notes=notes)
if c is None:
return None, 400
else:
schedule_building_blast_db(c.id)
return GenomeView.to_dict(c), 201
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)
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)
