def is_transitive(A, B, C, windowsize=20, threshold=.5):
ab = paircomp.do_simple_nxn_compare(A, B, windowsize, threshold)
bc = paircomp.do_simple_nxn_compare(B, C, windowsize, threshold)
ac = paircomp.do_simple_nxn_compare(A, C, windowsize, threshold)
ac_tran1 = paircomp.build_transitive(ab, bc, A, C, threshold)
ac_tran2 = paircomp.filter_transitively(ab, bc, ac)[2]
assert ac_tran1 == ac_tran2
def test():
t1 = fasta.load_single(thisdir + 't1.fa', force='DNA')
t2 = fasta.load_single(thisdir + 't2.fa', force='DNA')
t3 = fasta.load_single(thisdir + 't3.fa', force='DNA')
AB = paircomp.do_simple_nxn_compare(t1, t2, 4, 1.0)
BC = paircomp.do_simple_nxn_compare(t2, t3, 4, 1.0)
AC = paircomp.do_simple_nxn_compare(t1, t3, 4, 1.0)
(new_AB, new_BC, new_AC) = paircomp.filter_transitively(AB, BC, AC)
#print_cmp(new_AB)
#print_cmp(new_BC)
#print_cmp(new_AC)
expected = \
"""
4:0,0,20
4:0,0,-5
4:0,29,20
4:0,29,-5
4:0,-16,-5
4:0,-16,20
4:33,6,33
4:33,6,-33
4:33,43,33
4:33,43,-33
4:33,-43,-33
4:33,-43,33
4:33,-6,-33
4:33,-6,33\
"""
print 'Comparing paircomp output to Mussa\'s...',
l = print_tristan_3way(new_AB, new_BC, new_AC)
l.sort()
l2 = parse_tristan_3way(expected)
l2.sort()
assert l == l2
print 'success'
if l != l2:
print 'DIFF: CTB'
for x in l:
if not x in l2:
print x
print 'vs TDB'
for x in l2:
if not x in l:
print x
def test(self):
el = self.el
br = self.br
el_path = self.el_path
br_path = self.br_path
### four different ways of doing analyses:
#
# execute paircomp
#
outname = 'el-br-0.5.p.cmp'
os.system('rm %s >& /dev/null' % (outname,))
os.system('%s/paircomp %s %s 20 .5 %s >& /dev/null' % \
(bindir, self.el_path, self.br_path, outname))
p_cmp = paircomp.parse_paircomp(open(outname).read(),
len(el), len(br), 20)
os.system('rm %s >& /dev/null' % (outname,))
#
# execute seqcomp
#
outname = 'el-br-0.5.s.cmp'
os.system('rm %s >& /dev/null' % (outname,))
os.system('%s/seqcomp %s %s 20 10 noxml %s >& /dev/null' % \
(bindir, el_path, br_path, outname))
s_cmp = paircomp.parse_seqcomp(open(outname).read(),
len(el), len(br), 20)
os.system('rm %s >& /dev/null' % (outname,))
#
# & use the python interface.
#
rolling_cmp = self.cmp
simple_cmp = paircomp.do_simple_nxn_compare(el, br, 20, .5)
## also load in an old analysis for regression testing
old_paircomp = paircomp.parse_paircomp(open('%s/orig-el-br.txt' % \
(thisdir,)).read(),
len(el), len(br), 20)
## check to make sure they all return the same result!
print 'Testing equality of internal vs external analyses...',
assert p_cmp == s_cmp
assert p_cmp == simple_cmp
assert p_cmp == rolling_cmp
assert p_cmp == old_paircomp
def test():
el = fasta.load_single(thisdir + 'el.txt')
br = fasta.load_single(thisdir + 'br.txt')
re = fasta.load_single(thisdir + 're.txt')
### first break the algorithms.
simple_cmp = None
try:
simple_cmp = paircomp.do_simple_nxn_compare("ATCCGRRRRUUUUU", br, 10, .5)
except:
pass
assert simple_cmp is None
# break on windowsizes
try:
simple_cmp = paircomp.do_simple_nxn_compare(el, br, -1, .5)
except:
pass
assert simple_cmp is None
try:
simple_cmp = paircomp.do_simple_nxn_compare(el, br, 256, .5)
except:
pass
assert simple_cmp is None
try:
# break on windowsizes in relation to sequence len
simple_cmp = paircomp.do_simple_nxn_compare("AAAAAAAAAAAAAAAAAAA",
br, 20, .5)
except:
pass
assert simple_cmp is None
try:
simple_cmp = paircomp.do_simple_nxn_compare(el, "AAAAAAAAAAAAAAAAAAA",
20, .5)
except:
pass
assert simple_cmp is None
# break on threshold
try:
simple_cmp = paircomp.do_simple_nxn_compare(el, br, 9, -.01)
except:
pass
assert simple_cmp is None
try:
simple_cmp = paircomp.do_simple_nxn_compare(el, br, 9, 1.01)
except:
pass
assert simple_cmp is None
simple_cmp_1 = paircomp.do_simple_nxn_compare(el, br, 20, .5)
simple_cmp_2 = paircomp.do_simple_nxn_compare(el, br, 22, .5)
result = None
try:
result = simple_cmp_1.contains(simple_cmp_2)
except:
pass
assert result is None
try:
result = simple_cmp_1.equals(simple_cmp_2)
except:
pass
assert result is None
try:
result = simple_cmp_1.subtract(simple_cmp_2)
except:
pass
assert result is None
try:
result = simple_cmp_1.intersect(simple_cmp_2)
except:
pass
assert result is None
### test transitivity stuff
windowsize = 20
threshold = 0.7
ab = paircomp.do_simple_nxn_compare(el, br, windowsize, threshold)
ab2 = paircomp.do_simple_nxn_compare(el, br, windowsize+1, threshold)
bc = paircomp.do_simple_nxn_compare(br, re, windowsize, threshold)
bc2 = paircomp.do_simple_nxn_compare(br, re, windowsize+1, threshold)
ac = paircomp.do_simple_nxn_compare(el, re, windowsize, threshold)
results = None
try:
results = paircomp.build_transitive(ab, bc, el, br, threshold)
except:
pass
assert results is None
try:
results = paircomp.build_transitive(ab, bc, br, re, threshold)
except Exception, e:
pass
#! /usr/bin/env python import sys import fasta import paircomp top = fasta.load_single(sys.argv[1]) bot = fasta.load_single(sys.argv[2]) windowsize = int(sys.argv[3]) threshold = float(sys.argv[4]) outfile = sys.argv[5] cmp = paircomp.do_simple_nxn_compare(top, bot, windowsize, threshold) cmp.save(outfile)
def test():
A='aaaaaaaaaaaaaaaaaaaa'
B='aaaaaaaaaaaaaaaaaaaa'
C='aaaaaaaaaaaaaaaaaaaa'
AB=paircomp.do_simple_nxn_compare(A, B, 20, .9)
BC=paircomp.do_simple_nxn_compare(B, C, 20, .9)
AC=paircomp.do_simple_nxn_compare(A, C, 20, .9)
l = [i.is_empty() for i in paircomp.parser.filter_transitively(AB, BC, AC) ]
A='aaaaaaaaaaaaaaaaaaaa'
B='tttttttttttttttttttt'
C='tttttttttttttttttttt'
AB=paircomp.do_simple_nxn_compare(A, B, 20, .9)
BC=paircomp.do_simple_nxn_compare(B, C, 20, .9)
AC=paircomp.do_simple_nxn_compare(A, C, 20, .9)
l = [i.is_empty() for i in paircomp.parser.filter_transitively(AB, BC, AC) ]
assert l == [0, 0, 0]
A='tttttttttttttttttttt'
B='aaaaaaaaaaaaaaaaaaaa'
C='tttttttttttttttttttt'
AB=paircomp.do_simple_nxn_compare(A, B, 20, .9)
BC=paircomp.do_simple_nxn_compare(B, C, 20, .9)
AC=paircomp.do_simple_nxn_compare(A, C, 20, .9)
l = [i.is_empty() for i in paircomp.parser.filter_transitively(AB, BC, AC) ]
assert l == [0, 0, 0]
A='tttttttttttttttttttt'
B='tttttttttttttttttttt'
C='aaaaaaaaaaaaaaaaaaaa'
AB=paircomp.do_simple_nxn_compare(A, B, 20, .9)
BC=paircomp.do_simple_nxn_compare(B, C, 20, .9)
AC=paircomp.do_simple_nxn_compare(A, C, 20, .9)
l = [i.is_empty() for i in paircomp.parser.filter_transitively(AB, BC, AC) ]
assert l == [0, 0, 0]
print 'Tests PASSED.'
def test_python_functions(self):
el, br = self.el, self.br
cmp = self.cmp
#
# ok, now abuse the Python interface.
#
print 'Testing basic functions...',
assert cmp.windowsize == 20
assert cmp.top_len == len(el)
assert cmp.bot_len == len(br)
n = []
for i in range(0, len(el)):
l = cmp[i]
for m in l:
assert m.top == i
n.extend(l)
n2 = []
for match in cmp:
n2.append(match)
for (a, b) in zip(n, n2):
assert a == b
print 'Testing reverse of top/bottom...',
a = cmp.reverse_top()
b = a.reverse_top()
c = b.reverse_top()
assert cmp == b
assert a == c
assert b != c
a = cmp.reverse_bottom()
b = a.reverse_bottom()
c = b.reverse_bottom()
assert cmp == b
assert a == c
assert b != c
el_rc = fasta.reverse_complement(el)
br_rc = fasta.reverse_complement(br)
cmp_fr = paircomp.do_simple_nxn_compare(el, br_rc, 20, .5)
cmp_rf = paircomp.do_simple_nxn_compare(el_rc, br, 20, .5)
cmp_rr = paircomp.do_simple_nxn_compare(el_rc, br_rc, 20, .5)
assert cmp == cmp_fr.reverse_bottom()
assert cmp == cmp_rf.reverse_top()
assert cmp == cmp_rr.reverse_bottom().reverse_top()
print 'Testing inverse...',
a = cmp.invert()
b = a.invert()
c = b.invert()
assert cmp == b
assert a == c
cmp_i = paircomp.do_simple_nxn_compare(br, el, 20, .5)
assert cmp == cmp_i.invert()
print 'Testing filter by orientation...',
# should be equal
a = cmp.filter_orientation(True, True)
assert a == cmp
# should not be equal!
a = cmp.filter_orientation(True, False)
assert a != cmp
b = cmp.filter_orientation(False, True)
assert a != cmp
# should be equal
a = cmp.filter_orientation(True, False)
b = cmp.reverse_bottom().filter_orientation(False, True)
b = b.reverse_bottom()
assert a == b
# should be equal
a = cmp.filter_orientation(True, False)
b = cmp.reverse_top().filter_orientation(False, True)
b = b.reverse_top()
assert a == b
print 'Testing filter by threshold...',
# filter gradually...
a = cmp.filter(.6)
b = cmp.filter(.7)
c = cmp.filter(.8)
# and all at once
d = cmp.filter(.8)
assert d == c
###
print 'Testing set operations...',
a = b = cmp
assert a.contains(b)
assert b.contains(a)
c = a - b
assert c.is_empty()
assert a.contains(c)
assert c == a - (a.intersect(b))
b = cmp.filter(.6)
assert a.contains(b)
assert not b.contains(a)
c = a - b
assert not c.is_empty()
### 1bp conversion
print 'Testing 1bp conversion...',
a = b = cmp
b = cmp.filter(.6)
b = b.isolate_matching_bases(el, br)
a = a.isolate_matching_bases(el, br)
assert a.contains(b)
def test_3way(self):
"Test transitivity filtering"
A='aaaaaaaaaaaaaaaaaaaa'
B='tttttttttttttttttttt'
C='tttttttttttttttttttt'
AB=paircomp.do_simple_nxn_compare(A, B, 20, .9)
BC=paircomp.do_simple_nxn_compare(B, C, 20, .9)
AC=paircomp.do_simple_nxn_compare(A, C, 20, .9)
l = [i.is_empty() for i in paircomp.parser.filter_transitively(AB, BC, AC) ]
assert l == [0, 0, 0]
A='tttttttttttttttttttt'
B='aaaaaaaaaaaaaaaaaaaa'
C='tttttttttttttttttttt'
AB=paircomp.do_simple_nxn_compare(A, B, 20, .9)
BC=paircomp.do_simple_nxn_compare(B, C, 20, .9)
AC=paircomp.do_simple_nxn_compare(A, C, 20, .9)
l = [i.is_empty() for i in paircomp.parser.filter_transitively(AB, BC, AC) ]
assert l == [0, 0, 0]
A='tttttttttttttttttttt'
B='tttttttttttttttttttt'
C='aaaaaaaaaaaaaaaaaaaa'
AB=paircomp.do_simple_nxn_compare(A, B, 20, .9)
BC=paircomp.do_simple_nxn_compare(B, C, 20, .9)
AC=paircomp.do_simple_nxn_compare(A, C, 20, .9)
l = [i.is_empty() for i in paircomp.parser.filter_transitively(AB, BC, AC) ]
assert l == [0, 0, 0]
### try some broken ones.
A='ttttttttttttttttttttt'
B='tttttttttttttttttttt'
C='aaaaaaaaaaaaaaaaaaa'
AB=paircomp.do_simple_nxn_compare(A, B, 15, .9)
BC=paircomp.do_simple_nxn_compare(B, C, 15, .9)
AC=paircomp.do_simple_nxn_compare(A, C, 15, .9)
failed = False
try:
# should fail: AB-->AC
paircomp.parser.filter_transitively(AB, BC, AB)
# ---------------------------------------^^
except:
failed = True
assert failed