def common_ops(self):
"""Performs Dna operations common to all Designs in a Batch"""
basename = lambda f: f.name.split('/')[-1].split('.')[0]
with open(MAP_PLASMID_PATH[self.marker_name]) as f:
name = basename(f)
self.M = dna.Dna(str(SeqIO.read(f, 'genbank').seq),
name=name,
circular=True)
with open(MAP_PLASMID_PATH[VECTOR]) as f:
name = basename(f)
self.V = dna.Dna(str(SeqIO.read(f, 'genbank').seq),
name=name,
circular=True)
if self.assembly_method == 'SoePcr':
self.M = dna.Pcr(M_BASE_PRIMER_PAIR, self.M, name='pcr_M')
# Global is in insert order. Reverse for vector order.
self.V = dna.Digest(V_CUTSITE_PAIR[::-1], self.V, name='dig_V')
elif self.assembly_method == 'Gibson':
self.M = dna.Pcr(M_GIBSON_PRIMER_PAIR, self.M, name='pcr_M')
self.V = dna.Pcr(V_GIBSON_PRIMER_PAIR, self.V, name='pcr_V')
else:
raise AttributeError('Unrecognized assembly method {}'.format(
self.assembly_method))
if self.tag:
self.T = tool.primer3_clone(self.tag)
self.T.label = self.tag.name
self.T.name = 'pcr_T'
else:
self.T = None
return
def flanking_pcrs(self):
if self.locus.precise:
super(NtagDesign, self).flanking_pcrs()
return
size_range = (self.opt_arm, self.opt_arm + self.search)
options = {}
options['SEQUENCE_PRIMER_PAIR_OK_REGION_LIST'] = ','.join(
map(str, [
len(self.locus.up) - 1 - self.opt_arm -
(self.search - 1), self.search,
len(self.locus.up) - 1 - (self.up_out - 1), self.up_out
]))
template = dna.Dna(self.locus.up, name='P.p. gDNA')
self.U = tool.primer3_pcr(template, size_range, options=options)
options = {}
options['SEQUENCE_PRIMER_PAIR_OK_REGION_LIST'] = ','.join(
map(str, [0, self.search, self.opt_arm, self.search]))
options['SEQUENCE_FORCE_LEFT_START'] = 0
if self.in_frame:
# Fusion to first codon after ATG
options['SEQUENCE_FORCE_LEFT_START'] = 3
# Append downstream in case the locus sequence is shorter than opt_arm
template = dna.Dna(self.locus.seq + self.locus.down, name='P.p. gDNA')
self.D = tool.primer3_pcr(template, size_range, options=options)
return
def flanking_pcrs(self):
if self.locus.precise:
super(CtagDesign, self).flanking_pcrs()
return
size_range = (self.opt_arm, self.opt_arm + self.search)
options = {}
# Include upstream in template in case locus seq shorter than opt_arm
template = dna.Dna(self.locus.up + self.locus.seq, name='P.p. gDNA')
options['SEQUENCE_PRIMER_PAIR_OK_REGION_LIST'] = ','.join(
map(str, [
len(template.seq) - 1 - self.opt_arm -
(self.search - 1), self.search,
len(template.seq) - 1 - (self.search - 1), self.search
]))
options['SEQUENCE_FORCE_RIGHT_START'] = len(template.seq) - 1
if self.in_frame:
# Fusion to last codon before STOP
options['SEQUENCE_FORCE_RIGHT_START'] = len(template.seq) - 1 - 3
self.U = tool.primer3_pcr(template, size_range, options=options)
options = {}
options['SEQUENCE_PRIMER_PAIR_OK_REGION_LIST'] = ','.join(
map(str, [0, self.down_out, self.opt_arm, self.search]))
# Append downstream in case the locus sequence is shorter than opt_arm
template = dna.Dna(self.locus.down, name='P.p. gDNA')
self.D = tool.primer3_pcr(template, size_range, options=options)
return
def flanking_pcrs(self):
if self.locus.precise:
super(KoDesign, self).flanking_pcrs()
return
else:
size_range = (self.opt_arm, self.opt_arm + self.search)
options = {}
options['SEQUENCE_PRIMER_PAIR_OK_REGION_LIST'] = ','.join(
map(str, [
len(self.locus.up) - self.opt_arm - self.up_out,
self.up_out + self.up_in,
len(self.locus.up) - self.up_out, self.up_out + self.up_in
]))
template = dna.Dna(self.locus.up + self.locus.seq[:self.up_in],
name='P.p. gDNA')
self.U = tool.primer3_pcr(template, size_range, options=options)
options = {}
options['SEQUENCE_PRIMER_PAIR_OK_REGION_LIST'] = ','.join(
map(str, [
0, self.down_in + self.down_out, self.opt_arm,
self.down_in + self.down_out
]))
template = dna.Dna(self.locus.seq[-self.down_in:] +
self.locus.down,
name='P.p. gDNA')
self.D = tool.primer3_pcr(template, size_range, options=options)
return
def test_Digest(self):
a = dna.CutSite('ata')
c = dna.CutSite('cgc')
d = dna.Dna('AataAAAgcgA')
x = dna.Digest((a, c), d)
self.assertEquals(x.seq, 'ataAAAgcg'.lower())
# Nonpalindromic, searches opposite strand like primer pair
x.pair = (c, a)
self.assertEquals(x.seq, 'cgcTTTtat'.lower())
# CutSite C tandem palindrome
d.base = 'AataAAAgcgcA'
with self.assertRaises(ValueError):
dna.Digest((a, c), d).seq
# Palindromic
a = dna.CutSite('aatt')
c = dna.CutSite('ccgg')
d = dna.Dna('AaattAAAccggA')
x = dna.Digest((a, c), d)
self.assertEquals(x.seq, 'aattAAAccgg'.lower())
d.circular = True
# Now two products made, but returns top strand match only
self.assertEquals(x.seq, 'aattAAAccgg'.lower())
# Flipping strand prioritizes the shorter match around the circuit
d.base = dna.revc(d.seq)
self.assertEquals(x.seq, 'aattTTccgg'.lower())
def test_Ligation(self):
a8 = 'a' * 8
c8 = 'c' * 8
ac = dna.Dna(a8 + 'AC' + c8)
ca = dna.Dna(c8 + 'CA' + a8)
# Assembly will greedily merge homology,
# while Ligation does between 6 and 8
self.assertEquals(
dna.Assembly([ac, ca]).seq, (a8 + 'A' + c8 + 'CA' + a8).lower())
self.assertEquals(
dna.Ligation([ac, ca]).seq, ('AC' + c8 + 'CA' + a8).lower())
def test_Assembly(self):
w = dna.Dna('aaaccc')
x = dna.Dna('cccttt')
y = dna.Dna('tttggg')
z = dna.Dna('gggaaa')
a = dna.Assembly((w, x, y, z))
self.assertFalse(a.circular)
a.circularize = True
a.min_overlap = 0
# string appearance in linear form should be
# deletion of starting overlap
self.assertEquals(a.assemble(), 'ccctttgggaaa')
def test_blastn(self):
p = self.plus['locus']
# If indel in the sequence, retrieves corrected sequence
indel = p.seq[:90] + p.seq[100:]
seqloc = locus.Locus(dna.Dna(indel))
self.assertEquals(seqloc.name, self.plus['coord'])
self.assertEquals(seqloc.seq.lower(), self.plus['seq_file'].lower())
with self.assertRaises(ValueError):
# Nonsense
locus.Locus(dna.Dna('tact' * 1000))
with self.assertRaises(ValueError):
# Paste together in wrong order
locus.Locus(dna.Dna(p.down + p.seq + p.up))
def parse(self, text):
"""Parse textarea input to Dna objects.
Must be either gene IDs, one per line, or FASTA records."""
if not text:
return [None]
if text[0] == '>':
# try to parse as FASTA records
return [
dna.Dna(str(r.seq), name=r.name)
for r in SeqIO.parse(StringIO(text), 'fasta')
]
else:
return [
dna.Dna('', name=t)
for t in text.strip().replace('\r', '').split('\n')
]
def test_SoePcr(self):
# w-x-y will assemble, but will not SOE-PCR
# due to interior primer binding
w = dna.Dna('aaaccc')
x = dna.Dna('cccttt')
y = dna.Dna('tttggg')
self.assertEquals(dna.Assembly((w, x, y)).seq, 'aaaccctttggg')
f = dna.Primer('aaa')
r = dna.Primer('ccc')
soe = dna.SoePcr((f, r), [w, x, y])
with self.assertRaises(ValueError):
soe.seq
# increasing specificity allows SOE-PCR
f.base = 'aaac'
r.base = 'ccca'
self.assertEqual(soe.seq, 'aaaccctttggg')
def test_search_by_seq(self):
# Ensure that searching by sequence using blastn gives same results"""
for d in self.dicts:
seqloc = locus.Locus(dna.Dna(d['locus'].seq), context=self.context)
self.assertEquals(seqloc.name, d['coord'])
self.assertEquals(seqloc.seq.lower(), d['seq_file'].lower())
full = d['locus'].up + d['locus'].seq + d['locus'].down
self.assertEquals(full.lower(), d['context_file'].lower())
def __init__(self, populationSize, target, mutation):
self.targetPhrase = target
self.populationSize = populationSize
self.dnaSize = len(self.targetPhrase)
self.mutationRate = int(mutation * 100)
self.generationCount = self.generationCount + 1
for population in range(0, populationSize + 1):
self.populationList.append(dna.Dna(self.dnaSize))
def test_Dna(self):
self.assertRaises(TypeError, dna.Dna, [self.s])
self.assertRaises(ValueError, dna.Dna, self.s + 'n')
with self.assertRaises(ValueError):
self.d.base = self.d.seq + 'n'
with self.assertRaises(AttributeError):
dna.Dna(self.s).seq = 'atg'
self.assertNotIn('tga', self.d.search_seq.lower())
self.d.circular = True
self.assertIn('tga', self.d.search_seq.lower())
def __init__(self, x, y, target, lifespan):
self.location = PVector(x, y)
self.target = target
self.velocity = PVector(0, 0)
self.acc = PVector(0, 0)
self.lifespan = lifespan
self._dna = dna.Dna(self.lifespan)
self.fitness = 0
self.reached = False
self.crashed = False
def flanking_pcrs(self):
"""Precise flanking primer design, triggered by FASTA target input.
By default, primer3 is 0-indexed.
Must override for interior primer search radius."""
size_range = (self.opt_arm, self.opt_arm + self.search)
options = {}
options['SEQUENCE_PRIMER_PAIR_OK_REGION_LIST'] = ','.join(
map(str, [
len(self.locus.up) - 1 - self.opt_arm -
(self.search - 1), self.search,
len(self.locus.up) - 1 - (self.search - 1), self.search
]))
# This should override the search radius above
options['SEQUENCE_FORCE_RIGHT_START'] = len(self.locus.up) - 1
template = dna.Dna(self.locus.up, name='P.p. gDNA')
self.U = tool.primer3_pcr(template, size_range, options=options)
options = {}
options['SEQUENCE_PRIMER_PAIR_OK_REGION_LIST'] = ','.join(
map(str, [0, self.search, self.opt_arm, self.search]))
# This should override the search radius above
options['SEQUENCE_FORCE_LEFT_START'] = 0
template = dna.Dna(self.locus.down, name='P.p. gDNA')
self.D = tool.primer3_pcr(template, size_range, options=options)
return
def colony_pcr(self):
if not all([self.U, self.D]):
raise AttributeError(
'Must first generate U and D fragments with flanking_pcrs().')
full = self.locus.up + self.locus.seq + self.locus.down
spacer = 30
start = full.index(self.U.f.base) - spacer
end = full.index(dna.revc(self.D.r.base)) + len(self.D.r.base) + spacer
options = {
'SEQUENCE_EXCLUDED_REGION': ','.join(map(str,
(start, end - start)))
}
# Also set this region as a target to prevent N/Ctag from sidestepping
options['SEQUENCE_TARGET'] = options['SEQUENCE_EXCLUDED_REGION']
size_range = (end - start, end - start + 2 * self.search)
self.colony = tool.primer3_pcr(dna.Dna(full, name='STRAIN'),
size_range=size_range,
options=options)
def setUp(self):
# short genes on each strand. Seqs from Ensembl in static/testdata/
self.context = 100
self.plus = {}
self.plus['id'] = 'PAS_chr2-1_0751'
self.plus['coord'] = '2:1427323-1427517(+)'
self.minus = {}
self.minus['id'] = 'PAS_chr1-4_0504'
self.minus['coord'] = '1:2322810-2322980(-)'
self.dicts = (self.plus, self.minus)
for d in self.dicts:
d['locus'] = locus.Locus(dna.Dna('', name=d['id']),
context=self.context)
with open(paths.TESTDATA_PATH + d['id'] + '.seq', 'r') as f:
d['seq_file'] = f.read().strip()
with open(paths.TESTDATA_PATH + d['id'] + '_context100.seq',
'r') as f:
d['context_file'] = f.read().strip()
def test_Pcr(self):
non = dna.Primer('tact')
pal = dna.Primer('aatt')
d = dna.Dna('AAAtactGGGaattAAA')
pcr = dna.Pcr((non, pal), d)
# palindromic primer has too many bindings
with self.assertRaises(ValueError):
pcr.seq
new = dna.Primer('aattcc')
pcr.pair = (non, new)
self.assertEqual(pcr.seq, 'tactgggaatt')
# Swapping pair returns reverse complement of product
pcr.pair = pcr.pair[::-1]
self.assertEqual(pcr.seq, dna.revc('tactgggaatt'))
# Reversing each primer's orientation will raise exception
# unless circular
pcr.pair = [dna.Primer(dna.revc(p.seq)) for p in pcr.pair]
with self.assertRaises(ValueError):
pcr.seq
pcr.template.circular = True
self.assertEquals(pcr.seq, 'ggaattaaaaaatact')
def setUp(self):
self.s = 'GAGAtact'
self.d = dna.Dna(self.s, name='test')
self.asci, self.sbfi = batch.V_CUTSITE_PAIR
self.bsai = dna.CutSite('ggtctc', 'BsaI')
