Debian Codegraph @

csb/test/cases/bio/io/clans/__init__.py

raw
1 import csb.test as test
2
3 from csb.bio.io import ClansParser
4 from csb.bio.io.clans import Clans, ClansEntry, ClansParams, ClansSeqgroup,\
5 Color, ClansEntryCollection, ClansSeqgroupCollection, DuplicateEntryError,\
6 DuplicateEntryNameError
7
8
9 @test.unit
10 class TestClansColor(test.Case):
11
12 def setUp(self):
13
14 super(TestClansColor, self).setUp()
15
16 def testColorInit(self):
17 color = Color()
18
19 self.assertEqual(color.r, 0)
20 self.assertEqual(color.g, 0)
21 self.assertEqual(color.b, 0)
22
23 def testColorSetter(self):
24 color = Color()
25 for color_name in ('r', 'g', 'b'):
26 self.assertRaises(ValueError, color.__setattr__, color_name, -1)
27 self.assertRaises(ValueError, color.__setattr__, color_name, 256)
28
29 def testParseClansColorWithCorrectInput(self):
30
31 correct_input = '83;92;3'
32 color = Color.from_string(correct_input)
33 self.assertEqual(color.r, 83)
34 self.assertEqual(color.g, 92)
35 self.assertEqual(color.b, 3)
36
37 def testParseClansColorWithWrongInput(self):
38 color = Color()
39
40 wrong_input_1 = (83, 92, 3)
41 self.assertRaises(TypeError,
42 color.from_string, wrong_input_1)
43
44 wrong_input_2 = '83;92;3;'
45 self.assertRaises(ValueError, color.from_string, wrong_input_2)
46
47 wrong_input_3 = '83;92'
48 self.assertRaises(ValueError, color.from_string, wrong_input_3)
49
50 def testToClansColor(self):
51 color = Color()
52
53 self.assertEqual(color.to_clans_color(), '0;0;0;255')
54
55 testValues = (83, 92, 3, 87)
56 color.r = testValues[0]
57 color.g = testValues[1]
58 color.b = testValues[2]
59 color.a = testValues[3]
60
61 self.assertEqual(color.to_clans_color(),
62 ';'.join(map(str, testValues)))
63
64
65 @test.functional
66 class TestClansParams(test.Case):
67
68 def setUp(self):
69
70 super(TestClansParams, self).setUp()
71
72 def testInstatiation(self):
73 cp = ClansParams()
74 for attribute_name, default_value in cp._DEFAULTS.items():
75 if attribute_name == 'colors':
76 continue
77 self.assertEqual(cp.__getattribute__(attribute_name),
78 default_value)
79
80 def testUnknownParamFail(self):
81 self.assertRaises(KeyError, ClansParams, **{'unknownParam': True})
82
83 def testForbiddenAssignments(self):
84 self.assertRaises(ValueError, ClansParams, **{'attfactor': 'a'})
85 self.assertRaises(ValueError, ClansParams, **{'attvalpow': 'a'})
86 self.assertRaises(ValueError, ClansParams, **{'avgfoldchange': 'a'})
87 self.assertRaises(ValueError, ClansParams, **{'blastpath': 3})
88 self.assertRaises(ValueError, ClansParams, **{'cluster2d': 'a'})
89 self.assertRaises(ValueError, ClansParams, **{'colors': 'a'})
90 self.assertRaises(ValueError, ClansParams, **{'complexatt': 'a'})
91 self.assertRaises(ValueError, ClansParams, **{'cooling': 'a'})
92 self.assertRaises(ValueError, ClansParams, **{'currcool': 'a'})
93 self.assertRaises(ValueError, ClansParams, **{'dampening': 'a'})
94 self.assertRaises(ValueError, ClansParams, **{'dotsize': 'a'})
95 self.assertRaises(ValueError, ClansParams, **{'formatdbpath': 3})
96 self.assertRaises(ValueError, ClansParams, **{'groupsize': 'a'})
97 self.assertRaises(ValueError, ClansParams, **{'maxmove': 'a'})
98 self.assertRaises(ValueError, ClansParams, **{'minattract': 'a'})
99 self.assertRaises(ValueError, ClansParams, **{'ovalsize': 'a'})
100 self.assertRaises(ValueError, ClansParams, **{'pval': 'a'})
101 self.assertRaises(ValueError, ClansParams, **{'repfactor': 'a'})
102 self.assertRaises(ValueError, ClansParams, **{'repvalpow': 'a'})
103 self.assertRaises(ValueError, ClansParams, **{'showinfo': 'a'})
104 self.assertRaises(ValueError, ClansParams, **{'usefoldchange': 'a'})
105 self.assertRaises(ValueError, ClansParams, **{'usescval': 'a'})
106 self.assertRaises(ValueError, ClansParams, **{'zoom': 'a'})
107
108
109 @test.functional
110 class TestClans(test.Case):
111
112 def setUp(self):
113
114 super(TestClans, self).setUp()
115
116 def testClansInit(self):
117 '''
118 Test creating an empty L{Clans} instance.
119 '''
120
121 c = Clans()
122
123 param_names = ['attfactor', 'attvalpow', 'avgfoldchange', 'blastpath',
124 'cluster2d', 'colors', 'complexatt', 'cooling',
125 'currcool', 'dampening', 'dotsize', 'formatdbpath',
126 'groupsize', 'maxmove', 'minattract', 'ovalsize',
127 'pval', 'repfactor', 'repvalpow', 'showinfo',
128 'usefoldchange', 'usescval', 'zoom']
129
130 for param_name in param_names:
131 self.assertTrue(hasattr(c.params, param_name))
132
133 self.assertEqual(c.filename, None)
134 self.assertEqual(c.rotmtx.shape, (3, 3))
135 self.assertEqual(len(c.entries), 0)
136 self.assertEqual(len(c.seqgroups), 0)
137
138 self.assertTrue(isinstance(c.entries, ClansEntryCollection))
139 self.assertTrue(isinstance(c.seqgroups, ClansSeqgroupCollection))
140
141 def testClansEntryAddingAndSorting(self):
142 c = Clans()
143
144 names = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
145 shuffled_names = ['g', 'f', 'b', 'd', 'e', 'c', 'a']
146
147 for name in shuffled_names:
148 c.add_entry(ClansEntry(name=name))
149
150 c.sort()
151
152 for i, e in enumerate(c):
153 self.assertEqual(e.name, names[i])
154
155 def testClansEntrySortingWithCustomKeyFunction(self):
156 c = Clans()
157
158 sequences = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
159 shuffled_sequences = ['g', 'f', 'b', 'd', 'e', 'c', 'a']
160
161 for i, sequence in enumerate(sequences):
162 c.add_entry(ClansEntry(name=str(i), seq=shuffled_sequences[i]))
163
164 custom_key_function = lambda e: e.seq # sort by sequence instead of name
165 c.sort(key=custom_key_function)
166
167 for i, e in enumerate(c):
168 self.assertEqual(e.seq, sequences[i])
169
170 def testGetEntry(self):
171 c = Clans()
172
173 ## get non-existant entry from empty clans instance
174 self.assertRaises(ValueError, c.get_entry, 'a')
175
176 names = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
177 entries = [ClansEntry(name=name) for name in names]
178 [c.add_entry(e) for e in entries]
179
180 ## check whether entries fetched by name match those created
181 for i, name in enumerate(names):
182 self.assertEqual(c.get_entry(name), entries[i])
183
184 ## check pedantic flag for duplicate name='a' entries
185 c.add_entry(ClansEntry(name='a'))
186
187 self.assertTrue(c.get_entry('a', False).name == 'a')
188
189 self.assertRaises(DuplicateEntryNameError, c.get_entry, 'a', True)
190
191 def testDuplicateEntryError(self):
192 c = Clans()
193 e = ClansEntry(name='a', seq='A', coords=(1., 1., 1.))
194 c.add_entry(e)
195 c.add_entry(e)
196 original_length = len(c)
197
198 self.assertRaises(DuplicateEntryError, c._update_index)
199 self.assertEqual(original_length, len(c))
200
201 @test.functional
202 class TestClansSeqgroup(test.Case):
203
204 def setUp(self):
205
206 super(TestClansSeqgroup, self).setUp()
207
208 def testInit(self):
209 sg = ClansSeqgroup()
210
211 self.assertTrue(sg.is_empty())
212
213 def testAddingAndRemovingSeqgroups(self):
214 c = Clans()
215
216 names = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
217 for i, name in enumerate(names):
218 c.add_group(ClansSeqgroup(name=name))
219 self.assertEqual(len(c.seqgroups), i + 1)
220
221 removed = 0
222 while len(c.seqgroups) != 0:
223 c.remove_group(c.seqgroups[-1])
224 removed += 1
225
226 self.assertEqual(removed, len(names))
227 self.assertEqual(len(c.seqgroups), 0)
228
229 testGroup = ClansSeqgroup()
230 self.assertRaises(TypeError, testGroup.add, 23)
231 self.assertRaises(TypeError, testGroup.remove, 23)
232
233
234 def testAppendingSeqgroupsFromOtherInstance(self):
235 source = Clans()
236 source_entry1 = ClansEntry(name='X', seq='S')
237 source_entry2 = ClansEntry(name='A', seq='S')
238 source.add_entry(source_entry1)
239 source.add_entry(source_entry2)
240
241 seqgroup_names_to_transfer = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
242 for i, name in enumerate(seqgroup_names_to_transfer):
243 sg = ClansSeqgroup(name=name)
244 sg.add(source_entry1)
245 source.add_group(sg)
246
247 seqgroup_names_to_omit = ['x', 'y', 'z']
248 for i, name in enumerate(seqgroup_names_to_omit):
249 sg = ClansSeqgroup(name=name)
250 sg.add(source_entry2)
251 source.add_group(sg)
252
253 target = Clans()
254
255 # different seq is tolerated, only name identity is checked
256 target_entry = ClansEntry(name='X', seq='Q')
257 target.add_entry(target_entry)
258 self.assertEqual(source[0].name, target[0].name)
259
260 target.append_groups_from(source)
261
262 ## each group should have exactly one member
263 self.assertEqual(len(set([len(group.members) for group in target.seqgroups])), 1)
264
265 ## all groups of seqgroup_names should have been transferred
266 self.assertEqual(len(target.seqgroups), len(seqgroup_names_to_transfer))
267 self.assertEqual([group.name for group in target.seqgroups], seqgroup_names_to_transfer)
268
269 ## the ones from seqgroup_names_to_omit should not be there
270 self.assertEqual(len([group.name for group in target.seqgroups
271 if group.name in seqgroup_names_to_omit]), 0)
272
273 def testAddingClansEntries(self):
274 c = Clans()
275
276 sg = ClansSeqgroup()
277 c.add_group(sg)
278
279 e = ClansEntry()
280 c.add_entry(e)
281
282 ## add entry to seqgroup
283 sg.add(e)
284 self.assertEqual(len(sg), 1)
285 self.assertEqual(len(e.groups), 1)
286
287 ## adding the same entry is forbidden
288 self.assertRaises(ValueError, sg.add, e)
289
290 ## adding s.th. else than a ClansEntry
291 self.assertRaises(TypeError, sg.add, 23)
292
293 def testRemovingClansEntries(self):
294 c = Clans()
295
296 sg = ClansSeqgroup()
297 c.add_group(sg)
298
299 e = ClansEntry()
300 c.add_entry(e)
301
302 sg.add(e)
303 sg.remove(e)
304 self.assertEqual(len(sg), 0)
305 self.assertEqual(len(e.groups), 0)
306 self.assertRaises(TypeError, sg.remove, 23)
307 self.assertRaises(ValueError, sg.remove, e)
308
309
310 @test.functional
311 class TestClansParser(test.Case):
312
313 def setUp(self):
314
315 super(TestClansParser, self).setUp()
316
317 self.filename = self.config.getTestFile('out.clans')
318
319 def testPrematureGetter(self):
320 '''
321 Test whether the premature (before parsing) access to clans_instance is
322 properly handled.
323 '''
324 cp = ClansParser()
325 self.assertRaises(ValueError, cp.__getattribute__, 'clans_instance')
326
327 def testParseFile(self):
328 '''
329 Test parsing of a small dummy file with known values
330 '''
331
332 from numpy import array
333
334 cp = ClansParser()
335
336 self.clans_instance = cp.parse_file(self.filename)
337
338 self.assertEqual(len(self.clans_instance), 41)
339 self.assertRaises(IndexError, self.clans_instance.__getitem__, 41)
340
341 correct_rotmtx = array([[0.75614862, 0.65439992, 0.],
342 [-0.65439992, 0.75614862, 0.],
343 [0., 0., 1.]])
344 self.assertEqual(self.clans_instance.rotmtx.shape, (3, 3))
345 self.assertTrue(
346 (self.clans_instance.rotmtx - correct_rotmtx < 1e-6).all())
347
348 self.assertEqual(len(self.clans_instance.seqgroups), 4)
349
350 seqgroup_names = ('insect hypoth. protein (2 copies, C term)',
351 'allergens >= xyz',
352 'empty group WITH terminal semicolon in numbers line',
353 'empty group WITHOUT terminal semicolon in numbers line')
354 seqgroup_sizes = (20, 17, 0, 0)
355
356 for i, seqgroup in enumerate(self.clans_instance.seqgroups):
357 self.assertEqual(len(seqgroup), seqgroup_sizes[i])
358 self.assertEqual(seqgroup.name, seqgroup_names[i])
359
360
361 @test.functional
362 class TestClansFileWriter(test.Case):
363
364 def setUp(self):
365
366 super(TestClansFileWriter, self).setUp()
367
368 self.filename = self.config.getTestFile('out.clans')
369 self.temp = self.config.getTempStream()
370
371 def testWrittenIsIdenticalToOriginal(self):
372 cp = ClansParser()
373 clans_instance = cp.parse_file(self.filename)
374
375 clans_instance.write(self.temp.name)
376 self.temp.flush()
377
378 with open(self.filename) as original_file:
379 original_lines = original_file.readlines()
380
381 with open(self.temp.name) as written_file:
382 written_lines = written_file.readlines()
383
384 self.assertEqual(len(original_lines), len(written_lines))
385
386 in_hsps = False
387 start_tag_hsp = '<hsp>\n'
388 end_tag_hsp = '</hsp>\n'
389
390 in_seqgroups = False
391 start_tag_seqgroups = '<seqgroups>\n'
392 end_tag_seqgroups = '</seqgroups>\n'
393
394 colorarr_tag = 'colorarr='
395 color_tag = 'color='
396
397 for i, original_line in enumerate(original_lines):
398
399 if original_line == start_tag_hsp:
400 in_hsps = True
401 continue
402 if original_line == end_tag_hsp:
403 in_hsps = False
404 continue
405
406 if original_line == start_tag_seqgroups:
407 in_seqgroups = True
408 continue
409 if original_line == end_tag_seqgroups:
410 in_seqgroups = False
411 continue
412
413 if original_line.startswith(colorarr_tag):
414 ## remove colorarr_tag from beginning of line
415 original_line = original_line[len(colorarr_tag):].strip().strip(':')
416 self.assertTrue(written_lines[i].startswith(colorarr_tag))
417 written_line = written_lines[i][len(colorarr_tag):].strip().strip(':')
418
419 original_colors = original_line.replace('(', ''). replace(')', '').split(':')
420 written_colors = written_line.replace('(', ''). replace(')', '').split(':')
421
422 self.assertEqual(len(original_colors), len(written_colors))
423
424 for j, original_color_string in enumerate(original_colors):
425 original_color = Color.from_string(original_color_string)
426 written_color = Color.from_string(written_colors[j])
427 self.assertEqual(original_color.r, written_color.r)
428 self.assertEqual(original_color.g, written_color.g)
429 self.assertEqual(original_color.b, written_color.b)
430 self.assertEqual(original_color.a, written_color.a)
431
432 continue
433
434 if original_line.startswith(color_tag):
435 original_color_string = original_line[len(color_tag):].strip()
436 self.assertTrue(written_lines[i].startswith(color_tag))
437 written_color_string = written_lines[i][len(color_tag):].strip()
438
439 original_color = Color.from_string(original_color_string)
440 written_color = Color.from_string(written_color_string)
441 self.assertEqual(original_color.r, written_color.r)
442 self.assertEqual(original_color.g, written_color.g)
443 self.assertEqual(original_color.b, written_color.b)
444 self.assertEqual(original_color.a, written_color.a)
445
446 continue
447
448 if in_hsps:
449 original_start_end, original_value \
450 = original_line.strip().split(':')
451 written_start_end, written_value \
452 = written_lines[i].strip().split(':')
453 self.assertEqual(original_start_end, written_start_end)
454 self.assertTrue((float(original_value) - float(written_value)) < 1e-6)
455
456 elif in_seqgroups and (original_line == 'numbers=\n'):
457 ## a terminal semicolon is added by the ClansWriter
458 self.assertEqual(original_line.strip() + ';', written_lines[i].strip())
459
460 else:
461 self.assertEqual(original_line, written_lines[i])
462
463
464 def tearDown(self):
465 self.temp.close()
466
467
468 if __name__ == '__main__':
469
470 test.Console()