def setUp(self):
"""Define a few standard models and motifs"""
ile_mod_0 = Module('NNNCUACNNNNN', '(((((..(((((')
ile_mod_1 = Module('NNNNNUAUUGGGGNNN', ')))))......)))))')
ile_rule_0 = Rule(0, 0, 1, 15, 5)
ile_rule_1 = Rule(0, 7, 1, 4, 5)
ile_motif = Motif([ile_mod_0, ile_mod_1], \
[ile_rule_0, ile_rule_1])
helices = [PairedRegion('NNN'), PairedRegion('NNNNN')]
constants = [ConstantRegion('CUAC'), ConstantRegion('UAUUGGGG')]
order = "H0 C0 H1 - H1 C1 H0"
ile_model = SequenceModel(order=order, constants=constants, \
helices=helices, composition=BaseFrequency('UCAG'))
self.ile_embedder = SequenceEmbedder(length=50, num_to_do=10, \
motif=ile_motif, model=ile_model, composition=BaseFrequency('UCAG'))
short_ile_mod_0 = Module('NCUACNN', '(((..((')
short_ile_mod_1 = Module('NNUAUUGGGGN', '))......)))')
short_ile_rule_0 = Rule(0, 0, 1, 10, 3)
short_ile_rule_1 = Rule(0, 5, 1, 1, 2)
short_ile_motif = Motif([short_ile_mod_0, short_ile_mod_1], \
[short_ile_rule_0, short_ile_rule_1])
short_helices = [PairedRegion('N'), PairedRegion('NN')]
short_constants = [ConstantRegion('CUAC'), ConstantRegion('UAUUGGGG')]
short_order = "H0 C0 H1 - H1 C1 H0"
short_ile_model = SequenceModel(order=short_order, \
constants=short_constants, \
helices=short_helices, composition=BaseFrequency('UCAG'))
self.short_ile_embedder = SequenceEmbedder(length=50, num_to_do=10, \
motif=short_ile_motif, model=short_ile_model, \
composition=BaseFrequency('UCAG'))
class RuleTests_compatibility(TestCase):
"""Tests to see whether the Rule compatibility code works"""
def setUp(self):
"""Sets up some standard rules"""
self.x = Rule(1, 5, 2, 10, 3)
self.x_ok = Rule(1, 8, 2, 14, 4)
self.x_ok_diff_sequences = Rule(3, 5, 5, 10, 3)
self.x_bad_first = Rule(1, 0, 3, 10, 10)
self.x_bad_first_2 = Rule(0, 0, 1, 8, 2)
self.x_bad_second = Rule(1, 15, 2, 15, 8)
self.x_bad_second_2 = Rule(1, 14, 2, 8, 4)
def test_is_compatible_ok(self):
"""Rule.isCompatible should return True if rules don't overlap"""
self.assertEqual(self.x.isCompatible(self.x_ok), True) #no return value
self.assertEqual(self.x.isCompatible(self.x_ok_diff_sequences), True)
#check that it's transitive
self.assertEqual(self.x_ok.isCompatible(self.x), True)
self.assertEqual(self.x_ok_diff_sequences.isCompatible(self.x), True)
def test_is_compatible_bad(self):
"""Rule.isComaptible should return False if rules overlap"""
tests = [ (self.x, self.x_bad_first),
(self.x, self.x_bad_first_2),
(self.x, self.x_bad_second),
(self.x, self.x_bad_second_2),
]
for first, second in tests:
self.assertEqual(first.isCompatible(second), False)
#check that it's transitive
self.assertEqual(second.isCompatible(first), False)
def test_fits_in_sequence(self):
"""Rule.fitsInSequence should return True if sequence long enough"""
sequences = map('x'.__mul__, range(21)) #0 to 20 copies of 'x'
rules = [self.x, self.x_ok, self.x_ok_diff_sequences, self.x_bad_first,
self.x_bad_first_2, self.x_bad_second, self.x_bad_second_2]
#test a bunch of values for all the rules we have handy
for s in sequences:
for r in rules:
if r.UpstreamPosition + r.Length > len(s):
self.assertEqual(r.fitsInSequence(s), False)
else:
self.assertEqual(r.fitsInSequence(s), True)
#test a couple of specific boundary cases
#length-1 helix
r = Rule(0, 0, 1, 0, 1)
self.assertEqual(r.fitsInSequence(''), False)
self.assertEqual(r.fitsInSequence('x'), True)
self.assertEqual(r.fitsInSequence('xx'), True)
#length-2 helix starting one base from the start
r = Rule(1, 1, 2, 2, 2)
self.assertEqual(r.fitsInSequence(''), False)
self.assertEqual(r.fitsInSequence('x'), False)
self.assertEqual(r.fitsInSequence('xx'), False)
self.assertEqual(r.fitsInSequence('xxx'), True)
self.assertEqual(r.fitsInSequence('xxxx'), True)
def setUp(self):
"""Sets up some standard rules"""
self.x = Rule(1, 5, 2, 10, 3)
self.x_ok = Rule(1, 8, 2, 14, 4)
self.x_ok_diff_sequences = Rule(3, 5, 5, 10, 3)
self.x_bad_first = Rule(1, 0, 3, 10, 10)
self.x_bad_first_2 = Rule(0, 0, 1, 8, 2)
self.x_bad_second = Rule(1, 15, 2, 15, 8)
self.x_bad_second_2 = Rule(1, 14, 2, 8, 4)
def test_init_ok_length(self):
"""Rule should init OK if helix extends to exactly downstream start"""
x = Rule(0, 0, 1, 0, 1)
self.assertEqual(str(x), \
"Up Seq: 0 Up Pos: 0 Down Seq: 1 Down Pos: 0 Length: 1")
#check adjacent bases
x = Rule(0, 0, 0, 1, 1)
self.assertEqual(str(x), \
"Up Seq: 0 Up Pos: 0 Down Seq: 0 Down Pos: 1 Length: 1")
x = Rule(1, 10, 2, 8, 7)
#check rule that would cause overlap if motifs weren't different
self.assertEqual(str(x), \
"Up Seq: 1 Up Pos: 10 Down Seq: 2 Down Pos: 8 Length: 7")
def test_refresh_primers(self):
"""Module should appear in correct location with primers"""
first_module = Module('AAAAA', '(((((')
second_module = Module('UUUUU', ')))))')
rule_1 = Rule(0, 0, 1, 4, 5)
helix = Motif([first_module, second_module], [rule_1])
model = SequenceModel(constants=[ConstantRegion('AAAAA'), \
ConstantRegion('UUUUU')], order='C0 - C1', \
composition=BaseFrequency('A'))
embedder = SequenceEmbedder(length=30, num_to_do=100, \
motif=helix, model=model, composition=BaseFrequency('CG'), \
positions=[3, 6], primer_5 = 'UUU', primer_3 = 'AAA')
last = ''
for i in range(100):
embedder.refresh()
curr = str(embedder)
self.assertEqual(curr[0:3], 'UUU')
self.assertEqual(curr[6:11], 'AAAAA')
self.assertEqual(curr[14:19], 'UUUUU')
self.assertEqual(curr.count('A'), 8)
self.assertEqual(curr.count('U'), 8)
self.assertEqual(curr[-3:], 'AAA')
self.assertNotEqual(last, curr)
last = curr
def test_refresh_specific_position(self):
"""Should always find the module in the same position if specified"""
first_module = Module('AAAAA', '(((((')
second_module = Module('UUUUU', ')))))')
rule_1 = Rule(0, 0, 1, 4, 5)
helix = Motif([first_module, second_module], [rule_1])
model = SequenceModel(constants=[ConstantRegion('AAAAA'), \
ConstantRegion('UUUUU')], order='C0 - C1', \
composition=BaseFrequency('A'))
embedder = SequenceEmbedder(length=30, num_to_do=100, \
motif=helix, model=model, composition=BaseFrequency('CG'), \
positions=[3, 6])
last = ''
for i in range(100):
embedder.refresh()
curr = str(embedder)
self.assertEqual(curr[3:8], 'AAAAA')
self.assertEqual(curr[11:16], 'UUUUU')
self.assertEqual(curr.count('A'), 5)
self.assertEqual(curr.count('U'), 5)
self.assertNotEqual(last, curr)
last = curr
def setUp(self):
"""Defines a few standard motifs"""
self.ile_mod_0 = Module('NNNCUACNNNNN', '(((((..(((((')
self.ile_mod_1 = Module('NNNNNUAUUGGGGNNN', ')))))......)))))')
self.ile_rule_0 = Rule(0, 0, 1, 15, 3)
self.ile_rule_1 = Rule(0, 7, 1, 4, 5)
self.ile = Motif([self.ile_mod_0, self.ile_mod_1], \
[self.ile_rule_0, self.ile_rule_1])
self.hh_mod_0 = Module('NNNNUNNNNN', '(((((.((((')
self.hh_mod_1 = Module('NNNNCUGANGAGNNN', ')))).......((((')
self.hh_mod_2 = Module('NNNCGAAANNNN', '))))...)))))')
self.hh_rule_0 = Rule(0, 0, 2, 11, 5)
self.hh_rule_1 = Rule(0, 6, 1, 3, 4)
self.hh_rule_2 = Rule(1, 11, 2, 3, 4)
self.hh = Motif([self.hh_mod_0, self.hh_mod_1, self.hh_mod_2], \
[self.hh_rule_0, self.hh_rule_1, self.hh_rule_2])
self.simple_0 = Module('CCCCC', '(((..')
self.simple_1 = Module('GGGGG', '..)))')
self.simple_r = Rule(0, 0, 1, 4, 3)
self.simple = Motif([self.simple_0, self.simple_1], [self.simple_r])
def test_init_conflicting_rules(self):
"""Motif init should fail if rules overlap"""
interferer = Rule(0, 2, 2, 20, 4)
self.assertRaises(ValueError, Motif, [self.ile_mod_0, self.ile_mod_1, \
self.ile_mod_0], [self.ile_rule_0, interferer])
def test_init_bad_rule_lengths(self):
"""Motif init should fail if rules don't match module lengths"""
bad_rule = Rule(0, 0, 1, 8, 6)
self.assertRaises(ValueError, Motif, [self.simple_0, self.simple_1], \
[bad_rule])
def test_fits_in_sequence(self):
"""Rule.fitsInSequence should return True if sequence long enough"""
sequences = map('x'.__mul__, range(21)) #0 to 20 copies of 'x'
rules = [self.x, self.x_ok, self.x_ok_diff_sequences, self.x_bad_first,
self.x_bad_first_2, self.x_bad_second, self.x_bad_second_2]
#test a bunch of values for all the rules we have handy
for s in sequences:
for r in rules:
if r.UpstreamPosition + r.Length > len(s):
self.assertEqual(r.fitsInSequence(s), False)
else:
self.assertEqual(r.fitsInSequence(s), True)
#test a couple of specific boundary cases
#length-1 helix
r = Rule(0, 0, 1, 0, 1)
self.assertEqual(r.fitsInSequence(''), False)
self.assertEqual(r.fitsInSequence('x'), True)
self.assertEqual(r.fitsInSequence('xx'), True)
#length-2 helix starting one base from the start
r = Rule(1, 1, 2, 2, 2)
self.assertEqual(r.fitsInSequence(''), False)
self.assertEqual(r.fitsInSequence('x'), False)
self.assertEqual(r.fitsInSequence('xx'), False)
self.assertEqual(r.fitsInSequence('xxx'), True)
self.assertEqual(r.fitsInSequence('xxxx'), True)
def test_str(self):
"""Rule str method should give expected results"""
x = Rule(1, 10, 2, 8, 7)
self.assertEqual(str(x), \
"Up Seq: 1 Up Pos: 10 Down Seq: 2 Down Pos: 8 Length: 7")
