def test_revcomp(self):
a = Dseqrecord("attt")
rc = a.rc()
self.assertTrue(str(rc.seq) == "aaat")
def test_revcomp(self):
a=Dseqrecord("attt")
rc = a.rc()
self.assertTrue( str(rc.seq) == "aaat")
def test_primer_Design():
''' test_primer_design'''
a=Dseqrecord("atgactgctaacccttccttggtgttgaacaagatcgacgacatttcgttcgaaacttacgatg")
b=Dseqrecord("ccaaacccaccaggtaccttatgtaagtacttcaagtcgccagaagacttcttggtcaagttgcc")
c=Dseqrecord("tgtactggtgctgaaccttgtatcaagttgggtgttgacgccattgccccaggtggtcgtttcgtt")
primer_pairs = assembly_primers([a,b,c])
frags=[]
for (f,r),t in zip(primer_pairs,[a,b,c]):
frags.append(pcr(f,r,t))
asm=Assembly(frags)
assert asm.linear_products[0].seguid() == "1eNv3d_1PqDPP8qJZIVoA45Www8"
frags=[]
primer_pairs = assembly_primers([a,b,c], circular=True)
for (f,r),t in zip(primer_pairs,[a,b,c]):
frags.append(pcr(f,r,t))
#print frags
asm=Assembly(frags)
assert asm.circular_products[0].cseguid() == "V3Mi8zilejgyoH833UbjJOtDMbc"
def test_Dseq_slicing2(self):
from Bio.Restriction import BamHI, EcoRI, KpnI
a = Dseq("aaGGATCCnnnnnnnnnGAATTCccc", circular=True)
self.assertEqual(a.cut(
EcoRI,
BamHI,
KpnI,
), a.cut(
BamHI,
EcoRI,
KpnI,
))
a = Dseqrecord("aaGGATCCnnnnnnnnnGAATTCccc", circular=True)
self.assertEqual(
a.cut(
EcoRI,
BamHI,
KpnI,
)[0].seq,
a.cut(
BamHI,
EcoRI,
KpnI,
)[0].seq)
def test_rogerstager(self):
from Bio.Seq import Seq
from Bio.Restriction import BsaI
answ = []
answ.append(Dseq('aaaaaaaaaaaaggtctca', 'ttttttttccagagttttt'[::-1]))
answ.append(Dseq('aaaaaaaaaggtctca', 'tttttccagagttttt'[::-1]))
tests = [Seq("aaaaaaggtctcaaaaaaa"), Seq("aaaaaaggtctcaaaa")]
for s in tests:
d = Dseqrecord(s).looped()
for f in d.cut(BsaI):
a = answ.pop(0)
self.assertTrue(f.seq.watson == a.watson)
self.assertTrue(f.seq.crick == a.crick)
self.assertTrue(f.seq.ovhg == a.ovhg)
self.assertTrue(eq(f.seq, a))
def test_rogerstager(self):
from Bio.Seq import Seq
from Bio.Restriction import BsaI
answ = []
answ.append( Dseq('aaaaaaaaaaaaggtctca', 'ttttttttccagagttttt'[::-1]) )
answ.append( Dseq('aaaaaaaaaggtctca', 'tttttccagagttttt'[::-1]) )
tests = [Seq("aaaaaaggtctcaaaaaaa"),
Seq("aaaaaaggtctcaaaa") ]
for s in tests:
d = Dseqrecord(s).looped()
for f in d.cut(BsaI):
a = answ.pop(0)
self.assertTrue( f.seq.watson == a.watson )
self.assertTrue( f.seq.crick == a.crick )
self.assertTrue( f.seq.ovhg == a.ovhg )
self.assertTrue( eq(f.seq, a) )
def test_Dseqrecord_cutting_circular(self):
from Bio.Restriction import BsaI, KpnI, Acc65I
test = "aaaaaaGGTACCggtctcaaaa"
for i in range(len(test)):
nt = test[i:] + test[:i]
d = Dseqrecord(nt, circular=True).cut(Acc65I)[0]
self.assertEqual(d.seq.watson.upper(), "GTACCGGTCTCAAAAAAAAAAG")
self.assertEqual(d.seq.crick.upper(), "GTACCTTTTTTTTTTGAGACCG")
self.assertEqual(d.seq.ovhg, -4)
d = Dseqrecord(nt, circular=True).cut(KpnI)[0]
self.assertEqual(d.seq.watson.upper(), "CGGTCTCAAAAAAAAAAGGTAC")
self.assertEqual(d.seq.crick.upper(), "CTTTTTTTTTTGAGACCGGTAC")
self.assertEqual(d.seq.ovhg, 4)
d = Dseqrecord(nt, circular=True).cut(BsaI)[0]
self.assertEqual(d.seq.watson.upper(), "AAAAAAAAAGGTACCGGTCTCA")
self.assertEqual(d.seq.crick.upper(), "TTTTTGAGACCGGTACCTTTTT")
self.assertEqual(d.seq.ovhg, -4)
def test_primer_Design_with_linker():
''' test_primer_design'''
from pydna import Dseqrecord, Assembly, pcr, assembly_primers
b = Dseqrecord("agctactgactattaggggttattctgatcatctgatctactatctgactgtactgatcta")
l = Dseqrecord("AAATTTCCCGGG")
c = Dseqrecord("tctgatctactatctgactgtactgatctattgacactgtgatcattctagtgtattactc")
((bf,br),(cf,cr)) = assembly_primers((b,l,c))
nb = pcr((bf,br),b)
nc = pcr((cf,cr),c)
asm1 = Assembly((nb,nc))
assert asm1.linear_products[0].seguid(),(b+l+c).seguid() == 'l95igKB8iKAKrvvqE9CYksyNx40'
b = Dseqrecord("agctactgactattaggggttattctgatcatctgatctactatctgactgtactgatcta")
l = Dseqrecord("AAATTTCCCGGG")
c = Dseqrecord("tctgatctactatctgactgtactgatctattgacactgtgatcattctagtgtattactc")
((bf,br),(cf,cr)) = assembly_primers((b,l,c), circular = True)
nb = pcr((bf,br),b)
nc = pcr((cf,cr),c)
asm = Assembly((nb,nc))
#print (b+l+c).looped().seq
assert (b+l+c).looped().cseguid() == asm.circular_products[0].cseguid()
#print (b+l+c).looped().cseguid() == 'jdHXfQI5k4Sk2ESiZYfKv4oP2FI'
assert (b+l+c).looped().cseguid() == 'jdHXfQI5k4Sk2ESiZYfKv4oP2FI'
def test_map(self):
traces = []
import glob
for name in glob.glob('*.ab1'):
traces.append(abiread(name, "abi"))
for t in traces:
d = Dseqrecord(t.seq)
if "ITVFFKEYPYDVPDYAIEGIFHAT" in d:
tag = "tat cca tat gac gtt cca gac tat gca"
trc = "ata ggt ata ctg caa ggt ctg ata cgt"[::-1]
s = Dseqrecord(Dseq(tag, trc))
sl = s.find_aa("YPYDVPDYA")
self.assertTrue(str(s[sl].seq.translate()) == "YPYDVPDYA")
self.assertTrue("YPYDVPDYA" in s)
tag = "AAA tat cca tat gac gtt cca gac tat gca"
trc = " ata ggt ata ctg caa ggt ctg ata cgt"[::-1]
s = Dseqrecord(Dseq(tag, trc))
sl = s.find_aa("YPYDVPDYA")
self.assertTrue(str(s[sl].seq.translate()) == "YPYDVPDYA")
self.assertTrue("YPYDVPDYA" in s)
tag = " tat cca tat gac gtt cca gac tat gca"
trc = "AAA ata ggt ata ctg caa ggt ctg ata cgt"[::-1]
s = Dseqrecord(Dseq(tag, trc))
sl = s.find_aa("YPYDVPDYA")
self.assertTrue(str(s[sl].seq.translate()) == "YPYDVPDYA")
self.assertTrue("YPYDVPDYA" in s)
tag = " tat cca tat gac gtt cca gac tat gca"
trc = "AAA ata ggt ata ctg caa ggt ctg ata cgt"[::-1]
s = Dseqrecord(Dseq(tag, trc))
sl = s.find_aa("YPYDVPDYA")
self.assertTrue(str(s[sl].seq.translate()) == "YPYDVPDYA")
tag = "tat cca tat gac gtt cca gac tat gca"
trc = "ata ggt ata ctg caa ggt ctg ata cgt"[::-1]
tag, trc = trc, tag
s = Dseqrecord(Dseq(tag, trc))
sl = s.rc().find_aa("YPYDVPDYA")
self.assertTrue(str(s.rc()[sl].seq.translate()) == "YPYDVPDYA")
self.assertTrue("YPYDVPDYA" in s.rc())
tag = "aaa tat cca tat gac gtt cca gac tat gca"
trc = "ttt ata ggt ata ctg caa ggt ctg ata cgt"[::-1]
s = Dseqrecord(Dseq(tag, trc, circular=True))
sl = s.find_aa("YPYDVPDYA")
self.assertTrue(str(s[sl].seq.translate()) == "YPYDVPDYA")
self.assertTrue("YPYDVPDYA" in s)
def amplicon_to_dseqrecord(a):
d = Dseqrecord(a.seq)
d.features = a.features
return d
def test_linear_circular(self):
''' test Dseqrecord linear & circular property'''
a = Dseqrecord("attt")
a.stamp()
self.assertTrue(a.verify_stamp())
a = Dseqrecord("attt", linear=True)
self.assertTrue(a.linear == True)
self.assertTrue(a.circular == False)
self.assertTrue(a.rc().linear == True)
self.assertTrue(a.rc().circular == False)
self.assertTrue(a.seq.linear == True)
self.assertTrue(a.seq.circular == False)
a = Dseqrecord("attt", linear=False)
self.assertTrue(a.linear == False)
self.assertTrue(a.circular == True)
self.assertTrue(a.rc().linear == False)
self.assertTrue(a.rc().circular == True)
self.assertTrue(a.seq.linear == False)
self.assertTrue(a.seq.circular == True)
a = Dseqrecord("attt", circular=True)
self.assertTrue(a.linear == False)
self.assertTrue(a.circular == True)
self.assertTrue(a.rc().linear == False)
self.assertTrue(a.rc().circular == True)
self.assertTrue(a.seq.linear == False)
self.assertTrue(a.seq.circular == True)
a = Dseqrecord("attt", circular=False)
self.assertTrue(a.linear == True)
self.assertTrue(a.circular == False)
self.assertTrue(a.rc().linear == True)
self.assertTrue(a.rc().circular == False)
self.assertTrue(a.seq.linear == True)
self.assertTrue(a.seq.circular == False)
print pydna.read("/home/bjorn/Desktop/python_packages/pydna/pydna/pydna_read_test.txt").format()
print pydna.read("/home/bjorn/Desktop/python_packages/pydna/pydna/pydna_read_test2.txt").format()[3270:3281]
import sys;sys.exit(42)
import StringIO
from Bio import SeqIO
from Bio.Alphabet.IUPAC import IUPACAmbiguousDNA
import textwrap, re
raw = open("pydna_read_test.txt", 'rU').read()
pattern = r"(?:>.+\n^(?:^[^>]+?)(?=\n\n|>|LOCUS|ID))|(?:(?:LOCUS|ID)(?:(?:.|\n)+?)^//)"
rawseq = re.findall(pattern, textwrap.dedent(raw + "\n\n"), flags=re.MULTILINE).pop(0)
handle = StringIO.StringIO(raw)
sr = SeqIO.read(handle, "genbank", alphabet=IUPACAmbiguousDNA())
s = sr.format("gb").strip()
print pretty_string(s[:55]+"circular"+s[63:])[3200:3300]
from pydna import Dseqrecord
v = Dseqrecord(sr)
print v.format("gb")
def test_primer_Design_saving_to_text_file():
files_ = [dedent(x) for x in
('''\
>fw64 t-sequence
atgactgctaacccttc
>rv64 t-sequence
catcgtaagtttcgaac''',
'''\
>fw64 t-sequence
atgactgctaacccttcN
>rv64 t-sequence
catcgtaagtttcgaacN''',
'''\
>fw64 t-sequence
atgactgctaacccttcN''',
'''\
>fw64 t-sequence
atgactgctaacccttcN
>rv64 t-sequence
catcgtaagtttcgaac''',
'''\
>rv64 t-sequence
catcgtaagtttcgaacN''',
'''\
>rv64 t-sequence
catcgtaagtttcgaacN
>fw64 t-sequence
atgactgctaacccttc''',
'''\
>fw64 t-sequenceZ
atgactgctaacccttc
>rv64 t-sequenceZ
catcgtaagtttcgaac''',
'''\
>fw64 t-sequenceZ
atgactgctaacccttc
>rv64 t-sequenceZ
catcgtaagtttcgaac
>fw64 t-sequence
atgactgctaacccttc
>rv64 t-sequence
catcgtaagtttcgaac''',
'''\
>fw64x t-sequence
atgactgctaacccttc
>rv64x t-sequence
catcgtaagtttcgaac''',
'''\
>fw64x t-sequence
atgactgctaacccttc
>rv64x t-sequence
catcgtaagtttcgaac
>fw64 t-sequence
atgactgctaacccttc
>rv64 t-sequence
catcgtaagtttcgaac''',
)]
templ=Dseqrecord("atgactgctaacccttccttggtgttgaacaagatcgacgacatttcgttcgaaacttacgatg")
templ.accession = "t-sequence"
try:
os.remove("PRIMERS.TXT")
except OSError:
pass
pf, pr = cloning_primers(templ, path="PRIMERS.TXT")
assert os.path.isfile("PRIMERS.TXT")
with open("PRIMERS.TXT", "r") as f: text=f.read().strip()
assert text == files_[0]
with open("PRIMERS.TXT", "w") as f: text=f.write(files_[1])
pf, pr = cloning_primers(templ, path="PRIMERS.TXT")
with open("PRIMERS.TXT", "r") as f: text=f.read().strip()
assert text == files_[1]
with open("PRIMERS.TXT", "w") as f: text=f.write(files_[2])
pf, pr = cloning_primers(templ, path="PRIMERS.TXT")
with open("PRIMERS.TXT", "r") as f: text=f.read().strip()
assert text == files_[3]
with open("PRIMERS.TXT", "w") as f: text=f.write(files_[4])
pf, pr = cloning_primers(templ, path="PRIMERS.TXT")
with open("PRIMERS.TXT", "r") as f: text=f.read().strip()
assert text == files_[5]
with open("PRIMERS.TXT", "w") as f: text=f.write(files_[6])
pf, pr = cloning_primers(templ, path="PRIMERS.TXT")
with open("PRIMERS.TXT", "r") as f: text=f.read().strip()
assert text == files_[7]
with open("PRIMERS.TXT", "w") as f: text=f.write(files_[8])
pf, pr = cloning_primers(templ, path="PRIMERS.TXT")
with open("PRIMERS.TXT", "r") as f: text=f.read().strip()
assert text == files_[9]
with open("PRIMERS.TXT", "w") as f: text=f.write('')
pf, pr = cloning_primers(templ, path="PRIMERS.TXT")
f, r = parse("PRIMERS.TXT", ds=False)
assert f.description == "fw64 t-sequence"
assert r.description == "rv64 t-sequence"
def test_initialization(self):
a = []
a.append(Dseqrecord("attt"))
a.append(Dseqrecord(Dseq("attt")))
a.append(Dseqrecord(Seq("attt")))
a.append(Dseqrecord(Srec(Seq("attt"))))
a.append(Dseqrecord(Dseqrecord("attt")))
for b in a:
self.assertTrue(type(b.seq) == Dseq)
self.assertTrue(str(b.seq.watson) == "attt")
self.assertTrue(str(b.seq.crick) == "aaat")
self.assertTrue(str(b.seq) == "attt")
self.assertTrue(str(b.seq) == "attt")
self.assertTrue(b.linear == b.seq.linear)
self.assertTrue(b.linear == True)
self.assertTrue(b.circular == False)
self.assertTrue(b.seq.linear == True)
self.assertTrue(b.seq.circular == False)
a = []
a.append(Dseqrecord("attt", circular=True))
a.append(Dseqrecord(Dseq("attt"), circular=True))
a.append(Dseqrecord(Seq("attt"), circular=True))
a.append(Dseqrecord(Srec(Seq("attt")), circular=True))
a.append(Dseqrecord(Dseqrecord("attt"), circular=True))
for b in a:
self.assertTrue(type(b.seq) == Dseq)
self.assertTrue(str(b.seq.watson) == "attt")
self.assertTrue(str(b.seq.crick) == "aaat")
self.assertTrue(str(b.seq) == "attt")
self.assertTrue(str(b.seq) == "attt")
self.assertTrue(b.linear == b.seq.linear)
self.assertTrue(b.linear == False)
self.assertTrue(b.circular == True)
self.assertTrue(b.seq.linear == False)
self.assertTrue(b.seq.circular == True)
a = []
a.append(Dseqrecord(Dseq("attt", circular=True), circular=True))
a.append(Dseqrecord(Dseq("attt", circular=False), circular=True))
a.append(Dseqrecord(Dseq("attt", circular=True), circular=False))
a.append(Dseqrecord(Dseq("attt", circular=False), circular=False))
circular = [True, True, False, False]
linear = [False, False, True, True]
for b, ci, li in zip(a, circular, linear):
self.assertTrue(type(b.seq) == Dseq)
self.assertTrue(str(b.seq.watson) == "attt")
self.assertTrue(str(b.seq.crick) == "aaat")
self.assertTrue(str(b.seq) == "attt")
self.assertTrue(str(b.seq) == "attt")
self.assertTrue(b.linear == b.seq.linear)
self.assertTrue(b.linear == li)
self.assertTrue(b.circular == ci)
self.assertTrue(b.seq.linear == li)
self.assertTrue(b.seq.circular == ci)
a = []
ds = Dseq("attt", "taaa")
self.assertTrue(ds.linear == True)
self.assertTrue(ds.ovhg == -1)
self.assertTrue(str(ds.watson) == "attt")
self.assertTrue(str(ds.crick) == "taaa")
# attt
# aaat
a.append(Dseqrecord(ds, circular=False))
self.assertTrue(ds.linear == True)
a.append(Dseqrecord(ds, linear=True))
self.assertTrue(ds.linear == True)
a.append(Dseqrecord(ds, circular=True))
self.assertTrue(ds.linear == True)
a.append(Dseqrecord(ds, linear=False))
self.assertTrue(ds.linear == True)
circular = [False, False, True, True]
linear = [True, True, False, False]
crick = ["taaa", "taaa", "aaat", "aaat"]
sek = ["attta", "attta", "attt", "attt"]
for b, ci, li, s, cri in zip(a, circular, linear, sek, crick):
self.assertTrue(type(b.seq) == Dseq)
self.assertTrue(str(b.seq.watson) == "attt")
self.assertTrue(str(b.seq.crick) == cri)
self.assertTrue(str(b.seq) == s)
self.assertTrue(b.linear == b.seq.linear)
self.assertTrue(b.linear == li)
self.assertTrue(b.circular == ci)
self.assertTrue(b.seq.linear == li)
self.assertTrue(b.seq.circular == ci)
a = []
ds = Dseq("attt", "caaa")
self.assertTrue(ds.linear == True)
self.assertTrue(ds.ovhg == -1)
a.append(Dseqrecord(ds, circular=False))
self.assertTrue(ds.linear == True)
a.append(Dseqrecord(ds, linear=True))
self.assertTrue(ds.linear == True)
with self.assertRaises(TypeError):
Dseqrecord(ds, circular=True)
self.assertTrue(ds.linear == True)
with self.assertRaises(TypeError):
Dseqrecord(ds, linear=False)
self.assertTrue(ds.linear == True)
with self.assertRaises(TypeError):
b = Dseqrecord([])
with self.assertRaises(TypeError):
b = Dseqrecord(("a", ))
with self.assertRaises(TypeError):
b = Dseqrecord(0)
from pydna import read
input = '''
LOCUS New_DNA 4 bp ds-DNA linear 30-MAR-2013
DEFINITION .
ACCESSION
VERSION
SOURCE .
ORGANISM .
COMMENT
COMMENT ApEinfo:methylated:1
FEATURES Location/Qualifiers
misc_feature 2..3
/label=NewFeature
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
ORIGIN
1 acgt
//
'''
a = read(input)
self.assertEqual(a.features[0].extract(a).seq.watson, "CG")
b = a + a
for f in b.features:
self.assertEqual(b.features[0].extract(a).seq.watson, "CG")
feature = a.features[0]
s = Dseq("agctt", "agcta")
#print s.fig()
#Dseq(-6)
# agctt
#atcga
b = Dseqrecord(s)
b.features.append(feature)
cb = Dseqrecord(b, circular=True)
self.assertEqual(b.features[0].extract(b).seq.watson.lower(),
cb.features[0].extract(b).seq.watson.lower())
self.assertEqual(b.features[0].extract(b).seq.crick.lower(),
cb.features[0].extract(b).seq.crick.lower())
s = Dseq("aagct", "aagct")
#print s.fig()
#Dseq(-6)
#aagct
# tcgaa
b = Dseqrecord(s)
with self.assertRaises(TypeError):
cb = Dseqrecord(b, circular=True)
s = Dseq("agctt", "agcta")
#print s.fig()
#Dseq(-6)
# agcta
#ttcga
b = Dseqrecord(s)
b.features.append(feature)
cb = Dseqrecord(b, circular=True)
self.assertEqual(b.features[0].extract(b).seq.watson.lower(),
cb.features[0].extract(b).seq.watson.lower())
self.assertEqual(b.features[0].extract(b).seq.crick.lower(),
cb.features[0].extract(b).seq.crick.lower())
def test_stamp(self):
a = Dseqrecord("attt")
a.stamp()
self.assertTrue(a.verify_stamp())
def test_Dseqrecord_cutting_adding(self):
from Bio.Restriction import Bsu36I, BstAPI
pCAPs = read("./pCAPs.gb")
a, b = pCAPs.cut(Bsu36I, BstAPI)
c = (a + b).looped()
self.assertTrue(eq(c, pCAPs))
a = (
Dseqrecord(
Dseq('AATTCACANGGTACCNGGTACCNGCGGATATC',
'GTGTNCCATGGNCCATGGNCGCCTATAG'[::-1], -4)),
Dseqrecord(
Dseq('CACANGGTACCNGGTACCNGCGGATATC',
'GTGTNCCATGGNCCATGGNCGCCTATAG'[::-1], 0)),
Dseqrecord(
Dseq('CACANGGTACCNGGTACCNGCGGATATC',
'AATTGTGTNCCATGGNCCATGGNCGCCTATAG'[::-1], 4)),
)
from Bio.Restriction import KpnI, Acc65I, NlaIV
enzymes = [Acc65I, NlaIV, KpnI]
for enz in enzymes:
for f in a:
b, c, d = f.cut(enz)
e = b + c + d
assert str(e.seq).lower() == str(f.seq).lower()
#from pydna import *
#from pydna_helper import gb, ape
from Bio.Restriction import KpnI, BamHI, Acc65I, NlaIV, EcoRI, EcoRV
a = read('''
LOCUS New_DNA 10 bp ds-DNA linear 02-APR-2013
DEFINITION
ACCESSION New_DNA
VERSION New_DNA
KEYWORDS .
SOURCE
ORGANISM . .
COMMENT
COMMENT ApEinfo:methylated:1
FEATURES Location/Qualifiers
misc_feature 1..1
/label=1
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 2..2
/label=2
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 3..3
/label=3
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 4..4
/label=4
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 5..5
/label=5
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 6..6
/label=6
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 7..7
/label=7
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 8..8
/label=8
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 9..9
/label=9
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 10..10
/label=10
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
ORIGIN
1 ttGGTACCgg
//''')
b, c = a.cut(Acc65I)
self.assertEqual([f.qualifiers["label"] for f in b.features],
[['1'], ['2'], ['3'], ['4'], ['5'], ['6'], ['7']])
self.assertEqual([f.qualifiers["label"] for f in c.features],
[['4'], ['5'], ['6'], ['7'], ['8'], ['9'], ['10']])
a = read('''
LOCUS New_DNA 33 bp ds-DNA linear 08-NOV-2012
DEFINITION .
ACCESSION
VERSION
SOURCE .
ORGANISM .
COMMENT
COMMENT ApEinfo:methylated:1
FEATURES Location/Qualifiers
misc_feature 1..11
/label=Acc65I-1
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 12..18
/label=Acc65I-2
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 19..33
/label=Acc65I-3
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 1..15
/label=KpnI-1
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 16..22
/label=KpnI-2
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 23..33
/label=KpnI-3
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 1..13
/label=NlaIV-1
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 14..20
/label=NlaIV-2
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
misc_feature 21..33
/label=NlaIV-3
/ApEinfo_fwdcolor=cyan
/ApEinfo_revcolor=green
/ApEinfo_graphicformat=arrow_data {{0 1 2 0 0 -1} {} 0}
width 5 offset 0
ORIGIN
1 GAATTCacan ggtaccnGGT ACCngcgGAT ATC
//
''')
self.assertTrue(a.seguid() == "di3hL8t2G4iQQsxlm_CtvnUMBz8")
self.assertTrue(([x.qualifiers["label"][0] for x in a.features] == [
'Acc65I-1', 'Acc65I-2', 'Acc65I-3', 'KpnI-1', 'KpnI-2', 'KpnI-3',
'NlaIV-1', 'NlaIV-2', 'NlaIV-3'
]))
b, c, d = a.cut(Acc65I)
self.assertTrue(
[x.qualifiers["label"][0]
for x in b.features] == ['Acc65I-1', 'KpnI-1', 'NlaIV-1'])
self.assertTrue(
[x.qualifiers["label"][0]
for x in c.features] == ['Acc65I-2', 'KpnI-2', 'NlaIV-2'])
self.assertTrue(
[x.qualifiers["label"][0]
for x in d.features] == ['Acc65I-3', 'KpnI-3', 'NlaIV-3'])
e = b + c + d
self.assertTrue(
sorted([x.qualifiers["label"][0] for x in e.features]) ==
[x.qualifiers["label"][0] for x in a.features])
self.assertTrue(str(a.seq) == str(e.seq))
b, c, d = a.cut(KpnI)
self.assertTrue(
[x.qualifiers["label"][0]
for x in b.features] == ['Acc65I-1', 'KpnI-1', 'NlaIV-1'])
self.assertTrue(
[x.qualifiers["label"][0]
for x in c.features] == ['Acc65I-2', 'KpnI-2', 'NlaIV-2'])
self.assertTrue(
[x.qualifiers["label"][0]
for x in d.features] == ['Acc65I-3', 'KpnI-3', 'NlaIV-3'])
e = b + c + d
self.assertTrue(
sorted([x.qualifiers["label"][0] for x in e.features]) ==
[x.qualifiers["label"][0] for x in a.features])
b, c, d = a.cut(NlaIV)
self.assertTrue([x.qualifiers["label"][0]
for x in b.features] == ['Acc65I-1', 'NlaIV-1'])
self.assertTrue([x.qualifiers["label"][0]
for x in c.features] == ['NlaIV-2'])
self.assertTrue([x.qualifiers["label"][0]
for x in d.features] == ['KpnI-3', 'NlaIV-3'])
e = b + c + d
self.assertTrue(str(a.seq) == str(e.seq))
b, c = a.cut(EcoRI)
e = b + c
self.assertTrue(str(a.seq) == str(e.seq))
b, c = a.cut(EcoRV)
e = b + c
self.assertTrue(str(a.seq) == str(e.seq))
b, c, d = a.cut(EcoRI, EcoRV)
e = b + c + d
self.assertTrue(str(a.seq) == str(e.seq))
b, c, d, f = a.cut(Acc65I, EcoRI)
e = b + c + d + f
self.assertTrue(str(a.seq) == str(e.seq))
b, c, d, f = a.cut(EcoRI, Acc65I)
e = b + c + d + f
self.assertTrue(str(a.seq) == str(e.seq))
def amplicon_to_dseqrecord(a):
d = Dseqrecord(a.seq)
d.features = a.features
return d
def test_linear_circular(self):
''' test Dseqrecord linear & circular property'''
a=Dseqrecord("attt")
a.stamp()
self.assertTrue( a.verify_stamp() )
a=Dseqrecord("attt", linear = True)
self.assertTrue(a.linear == True)
self.assertTrue(a.circular == False)
self.assertTrue(a.rc().linear == True)
self.assertTrue(a.rc().circular == False)
self.assertTrue(a.seq.linear == True)
self.assertTrue(a.seq.circular == False)
a=Dseqrecord("attt", linear = False)
self.assertTrue(a.linear == False)
self.assertTrue(a.circular == True)
self.assertTrue(a.rc().linear == False)
self.assertTrue(a.rc().circular == True)
self.assertTrue(a.seq.linear == False)
self.assertTrue(a.seq.circular == True)
a=Dseqrecord("attt", circular = True)
self.assertTrue(a.linear == False)
self.assertTrue(a.circular == True)
self.assertTrue(a.rc().linear == False)
self.assertTrue(a.rc().circular == True)
self.assertTrue(a.seq.linear == False)
self.assertTrue(a.seq.circular == True)
a=Dseqrecord("attt", circular = False)
self.assertTrue(a.linear == True)
self.assertTrue(a.circular == False)
self.assertTrue(a.rc().linear == True)
self.assertTrue(a.rc().circular == False)
self.assertTrue(a.seq.linear == True)
self.assertTrue(a.seq.circular == False)
).format()[3270:3281]
import sys
sys.exit(42)
import StringIO
from Bio import SeqIO
from Bio.Alphabet.IUPAC import IUPACAmbiguousDNA
import textwrap, re
raw = open("pydna_read_test.txt", 'rU').read()
pattern = r"(?:>.+\n^(?:^[^>]+?)(?=\n\n|>|LOCUS|ID))|(?:(?:LOCUS|ID)(?:(?:.|\n)+?)^//)"
rawseq = re.findall(pattern,
textwrap.dedent(raw + "\n\n"),
flags=re.MULTILINE).pop(0)
handle = StringIO.StringIO(raw)
sr = SeqIO.read(handle, "genbank", alphabet=IUPACAmbiguousDNA())
s = sr.format("gb").strip()
print pretty_string(s[:55] + "circular" + s[63:])[3200:3300]
from pydna import Dseqrecord
v = Dseqrecord(sr)
print v.format("gb")
def test_stamp(self):
a=Dseqrecord("attt")
a.stamp()
self.assertTrue( a.verify_stamp() )
def test_map(self):
traces = []
import glob
for name in glob.glob('*.ab1'):
traces.append( abiread( name, "abi") )
for t in traces:
d = Dseqrecord(t.seq)
if "ITVFFKEYPYDVPDYAIEGIFHAT" in d:
tag = "tat cca tat gac gtt cca gac tat gca"
trc = "ata ggt ata ctg caa ggt ctg ata cgt"[::-1]
s = Dseqrecord(Dseq(tag,trc))
sl = s.find_aa("YPYDVPDYA")
self.assertTrue( str( s[sl].seq.translate() ) == "YPYDVPDYA")
self.assertTrue( "YPYDVPDYA" in s)
tag = "AAA tat cca tat gac gtt cca gac tat gca"
trc = " ata ggt ata ctg caa ggt ctg ata cgt"[::-1]
s = Dseqrecord(Dseq(tag,trc))
sl = s.find_aa("YPYDVPDYA")
self.assertTrue( str( s[sl].seq.translate() ) == "YPYDVPDYA" )
self.assertTrue( "YPYDVPDYA" in s )
tag = " tat cca tat gac gtt cca gac tat gca"
trc = "AAA ata ggt ata ctg caa ggt ctg ata cgt"[::-1]
s = Dseqrecord(Dseq(tag,trc))
sl = s.find_aa("YPYDVPDYA")
self.assertTrue( str( s[sl].seq.translate() ) == "YPYDVPDYA" )
self.assertTrue( "YPYDVPDYA" in s )
tag = " tat cca tat gac gtt cca gac tat gca"
trc = "AAA ata ggt ata ctg caa ggt ctg ata cgt"[::-1]
s = Dseqrecord(Dseq(tag,trc))
sl = s.find_aa("YPYDVPDYA")
self.assertTrue( str( s[sl].seq.translate() ) == "YPYDVPDYA" )
tag = "tat cca tat gac gtt cca gac tat gca"
trc = "ata ggt ata ctg caa ggt ctg ata cgt"[::-1]
tag, trc = trc, tag
s = Dseqrecord(Dseq(tag,trc))
sl = s.rc().find_aa("YPYDVPDYA")
self.assertTrue( str( s.rc()[sl].seq.translate()) == "YPYDVPDYA" )
self.assertTrue( "YPYDVPDYA" in s.rc() )
tag = "aaa tat cca tat gac gtt cca gac tat gca"
trc = "ttt ata ggt ata ctg caa ggt ctg ata cgt"[::-1]
s = Dseqrecord(Dseq(tag,trc, circular=True))
sl = s.find_aa("YPYDVPDYA")
self.assertTrue( str( s[sl].seq.translate() ) == "YPYDVPDYA" )
self.assertTrue( "YPYDVPDYA" in s )
def test_eq(self):
''' test eq'''
self.assertTrue(eq("AAA", "TTT", linear=True))
self.assertTrue(eq("AAA", "TTT", linear=False))
self.assertTrue(eq("aAA", "TtT", linear=True))
self.assertTrue(eq("AAa", "TtT", linear=False))
self.assertTrue(eq("ATA", "AAT", circular=True))
self.assertFalse(eq("ATA", "AAT", circular=False))
self.assertTrue(eq("AAA", "AAA", linear=True))
self.assertTrue(eq("AAA", "AAA", linear=False))
self.assertTrue(eq("ATA", Seq("AAT"), circular=True))
self.assertFalse(eq("ATA", Seq("AAT"), circular=False))
self.assertTrue(eq("AAA", Seq("AAA"), linear=True))
self.assertTrue(eq("AAA", Seq("AAA"), linear=False))
self.assertTrue(eq("ATA", SeqRecord("AAT"), circular=True))
self.assertFalse(eq("ATA", SeqRecord("AAT"), circular=False))
self.assertTrue(eq("AAA", SeqRecord("AAA"), linear=True))
self.assertTrue(eq("AAA", SeqRecord("AAA"), linear=False))
self.assertTrue(eq("ATA", Dseqrecord("AAT"), circular=True))
self.assertFalse(eq("ATA", Dseqrecord("AAT"), circular=False))
self.assertTrue(eq("AAA", Dseqrecord("AAA"), linear=True))
self.assertTrue(eq("AAA", Dseqrecord("AAA"), linear=False))
self.assertTrue(eq(Seq("ATA"), SeqRecord("AAT"), circular=True))
self.assertFalse(eq(Seq("ATA"), SeqRecord("AAT"), circular=False))
self.assertTrue(eq(Seq("AAA"), SeqRecord("AAA"), linear=True))
self.assertTrue(eq(Seq("AAA"), SeqRecord("AAA"), linear=False))
self.assertTrue(eq(Seq("ATA"), Dseqrecord("AAT"), circular=True))
self.assertFalse(eq(Seq("ATA"), Dseqrecord("AAT"), circular=False))
self.assertTrue(eq(Seq("AAA"), Dseqrecord("AAA"), linear=True))
self.assertTrue(eq(Seq("AAA"), Dseqrecord("AAA"), linear=False))
self.assertTrue(
eq(Dseqrecord("AAA", circular=False),
Dseqrecord("AAA", circular=False)))
self.assertTrue(
eq(Dseqrecord("AAA", circular=True),
Dseqrecord("AAA", circular=True)))
self.assertFalse(
eq(Dseqrecord("ATA", circular=False),
Dseqrecord("AAT", circular=False)))
self.assertTrue(
eq(Dseqrecord("ATA", circular=True),
Dseqrecord("AAT", circular=True)))
self.assertEqual(True, True)
self.assertTrue(True)
self.assertFalse(False)
with self.assertRaises(TypeError):
1 + "1"
with self.assertRaisesRegexp(TypeError, "unsupported"):
1 + "1"
