Debian Codegraph @

csb/test/cases/bio/sequence/__init__.py

raw
1
2 import csb.bio.sequence as sequence
3 import csb.bio.io.fasta
4
5 import csb.test as test
6
7
8 @test.unit
9 class TestSequence(test.Case):
10
11 def setUp(self):
12
13 super(TestSequence, self).setUp()
14
15 self.data = '>id desc\nAB-CD'
16 self.sequence = sequence.Sequence('id', '>id desc', 'AB-CD', sequence.SequenceTypes.Protein)
17 assert str(self.sequence) == self.data
18
19 def testLength(self):
20 self.assertEqual(self.sequence.length, 5)
21 self.assertEqual(self.sequence.length, len(self.sequence))
22
23 def testId(self):
24 self.assertEqual(self.sequence.id, 'id')
25
26 def testHeader(self):
27 self.assertEqual(self.sequence.header, 'id desc')
28
29 def testSequence(self):
30 self.assertEqual(self.sequence.sequence, 'AB-CD')
31
32 def testType(self):
33
34 def test(v):
35 self.sequence.type = v
36
37 self.assertRaises(TypeError, test, sequence.ProteinAlphabet.ALA)
38 self.assertEqual(self.sequence.type, sequence.SequenceTypes.Protein)
39
40 def testAlphabet(self):
41 self.assertEqual(self.sequence.alphabet, sequence.ProteinAlphabet)
42
43 def testStrip(self):
44 self.assertEqual(self.sequence.strip().sequence, 'ABCD')
45
46 def testSubregion(self):
47
48 s = self.sequence
49
50 self.assertEqual(s.subregion(2, 3).sequence, 'B-')
51 self.assertRaises(sequence.SequencePositionError, s.subregion, -1, 2)
52 self.assertRaises(sequence.SequencePositionError, s.subregion, 1, 6)
53
54 def testExtract(self):
55
56 s = self.sequence
57 self.assertEqual(s.extract((2, 3, 5)).sequence, 'B-D')
58
59 self.assertRaises(sequence.SequencePositionError, s.extract, [-1])
60 self.assertRaises(sequence.SequencePositionError, s.extract, [6])
61
62 def testIndexeres(self):
63
64 s = self.sequence
65
66 self.assertEqual(s.residues[2].type, sequence.ProteinAlphabet.ASX)
67 self.assertEqual(s.residues[1].type, s[0].type)
68 self.assertEqual(s[:].sequence, s.sequence)
69 self.assertEqual(s[2:].sequence, '-CD')
70 self.assertEqual(s[2:3].sequence, '-')
71
72 for rank in [-1, 0, 6]:
73 self.assertRaises(sequence.SequencePositionError, lambda i: s.residues[i], rank)
74
75 for index in [-1, 5]:
76 self.assertRaises(IndexError, lambda i: s[i], index)
77
78 self.assertRaises(IndexError, lambda: s[-1:])
79
80 def testIterator(self):
81
82 chars = [ str(r.type) for r in self.sequence ]
83 seq = ''.join(chars)
84
85 self.assertEqual(self.sequence.sequence.upper(), seq)
86
87 def testToString(self):
88
89 self.assertEqual(str(self.sequence), self.data)
90 self.assertEqual(str(self.sequence), self.data)
91
92 def testDump(self):
93
94 with self.config.getTempStream() as tmp:
95 self.sequence.dump(tmp.name)
96 tmp.flush()
97
98 self.assertEqual(open(tmp.name).read().strip(), self.data)
99
100 with self.config.getTempStream() as tmp:
101 self.sequence.dump(tmp)
102 tmp.flush()
103
104 self.assertEqual(open(tmp.name).read().strip(), self.data)
105
106 @test.unit
107 class TestRichSequence(TestSequence):
108
109 def setUp(self):
110
111 super(TestRichSequence, self).setUp()
112 self.sequence = sequence.RichSequence.create(self.sequence)
113
114 @test.unit
115 class TestChainSequence(TestSequence):
116
117 def setUp(self):
118
119 super(TestChainSequence, self).setUp()
120
121 from csb.bio.structure import ProteinResidue, Chain
122 chain = Chain('A', name='desc', accession='accn')
123
124 for rank, char in enumerate('AB-CD', start=1):
125 chain.residues.append(ProteinResidue(rank, char))
126
127 self.sequence = sequence.ChainSequence.create(chain)
128 self.sequence.header = '>id desc'
129 self.sequence.id = 'id'
130
131
132 @test.unit
133 class TestSequenceCollection(test.Case):
134
135 def setUp(self):
136
137 super(TestSequenceCollection, self).setUp()
138
139 s1 = sequence.Sequence('id1', '>id1 desc', 'AB-CD', sequence.SequenceTypes.Protein)
140 s2 = sequence.Sequence('id2', '>id2 desc', 'ABCDE', sequence.SequenceTypes.Protein)
141
142 self.collection = sequence.SequenceCollection([s1, s2])
143 self.data = '>id1 desc\nAB-CD\n>id2 desc\nABCDE'
144
145 def testToFASTA(self):
146
147 with self.config.getTempStream() as tmp:
148 self.collection.to_fasta(tmp.name)
149 tmp.flush()
150
151 self.assertEqual(open(tmp.name).read().strip(), self.data)
152
153 with self.config.getTempStream() as tmp:
154 self.collection.to_fasta(tmp)
155 tmp.flush()
156
157 self.assertEqual(open(tmp.name).read().strip(), self.data)
158
159
160 @test.unit
161 class TestSequenceAlignment(test.Case):
162
163
164 def _factory(self, sequences, strict=True):
165 return sequence.SequenceAlignment(sequences, strict=strict)
166
167 def setUp(self):
168
169 super(TestSequenceAlignment, self).setUp()
170
171 seq1 = sequence.Sequence('s1', 's1 desc1', 'AB-CD', sequence.SequenceTypes.Protein)
172 seq2 = sequence.RichSequence('s2', 's2 desc2', list('ABX-D'), sequence.SequenceTypes.Protein)
173
174 self.ali = self._factory([seq1, seq2])
175 self.ali2 = self._factory([seq1, seq2, seq2, seq2], strict=False)
176
177 def testAdd(self):
178
179 # strict
180 self.assertRaises(sequence.SequenceError, self.ali.add, sequence.Sequence('sn', 'sn','TOO-LONG-SEQ'))
181 self.assertRaises(sequence.DuplicateSequenceError, self.ali.add, sequence.Sequence('s1', 's1','AB-CD'))
182
183 def testLength(self):
184 self.assertEqual(self.ali.length, 5)
185
186 def testSize(self):
187 self.assertEqual(self.ali.size, 2)
188 self.assertEqual(self.ali2.size, 4)
189
190 def testSubregion(self):
191
192 sub = self.ali.subregion(2, 4)
193
194 self.assertEqual(sub.length, 3)
195 self.assertEqual(sub.size, 2)
196 self.assertEqual(sub.rows[1].sequence, 'B-C')
197 self.assertEqual(sub.rows[2].sequence, 'BX-')
198
199 self.assertRaises(sequence.ColumnPositionError, self.ali.subregion, -1, 2)
200 self.assertRaises(sequence.ColumnPositionError, self.ali.subregion, 1, 6)
201
202 # should not raise DuplicateSequenceError
203 self.ali2.subregion(1, 2)
204
205 def testFormat(self):
206
207 self.assertEqual(self.ali.format(headers=False).strip(), 'AB-CD\nABX-D')
208 self.assertEqual(self.ali.format(headers=True).strip(), '>s1 desc1\nAB-CD\n>s2 desc2\nABX-D')
209
210 def testRows(self):
211
212 a = self.ali
213
214 self.assertEqual(a.rows[2].id, 's2')
215 self.assertRaises(sequence.SequenceNotFoundError, lambda i: a.rows[i], -1)
216 self.assertRaises(sequence.SequenceNotFoundError, lambda i: a.rows[i], 3)
217
218 # with duplicates
219 self.assertEqual(self.ali2.rows['s2'].id, 's2')
220 self.assertEqual(self.ali2.rows['s2:A1'].id, 's2')
221 self.assertEqual(self.ali2.rows['s2:A2'].id, 's2')
222
223 def testColumns(self):
224
225 a = self.ali
226
227 self.assertEqual(a.columns[4][0].id, 's1')
228 self.assertEqual(a.columns[4][0].column, 4)
229 self.assertEqual(a.columns[4][0].residue.type, sequence.ProteinAlphabet.CYS)
230 self.assertEqual(len(a.columns[4]), a.size)
231 self.assertEqual(len(a.columns[4]), len(a.columns[3]))
232
233 def testRowColumns(self):
234
235 a = self.ali
236
237 self.assertEqual(a.rows[1].columns[4].id, a.columns[4][0].id)
238 self.assertEqual(a.rows[1].columns[4].column, a.columns[4][0].column)
239 self.assertEqual(a.rows[1].columns[4].residue.type, a.columns[4][0].residue.type)
240
241 def testRowResidues(self):
242
243 a = self.ali
244
245 self.assertEqual(a.rows[1].residues[4].type, sequence.ProteinAlphabet.ASP)
246 self.assertEqual(a.rows[1].residues[3].type, sequence.ProteinAlphabet.CYS)
247
248 self.assertEqual(a.rows[2].residues[4].type, sequence.ProteinAlphabet.ASP)
249 self.assertEqual(a.rows[2].residues[3].type, sequence.ProteinAlphabet.UNK)
250
251 def testRowMap(self):
252
253 a = self.ali
254
255 self.assertEqual(a.rows[1].map_column(4), 3)
256 self.assertEqual(a.rows[1].map_residue(3), 4)
257
258 def testIndexer(self):
259
260 a = self.ali
261
262 self.assertEqual(a[0, 0].rows['s1'].id, 's1')
263 self.assertEqual(a[1, 4].rows['s2'].columns[1].residue.type, sequence.ProteinAlphabet.ASP)
264
265 self.assertEqual(a[0, 0].size, 1)
266 self.assertEqual(a[0, 0].length, 1)
267
268 self.assertEqual(a[:, 0].size, 2)
269 self.assertEqual(a[:, 0].length, 1)
270
271 self.assertEqual(a[0, :].size, 1)
272 self.assertEqual(a[0, :].length, 5)
273
274 self.assertEqual(a[0:2, 0:2].size, 2)
275 self.assertEqual(a[0:2, 0:2].length, 2)
276
277 self.assertEqual(a[(0, 1), (0, 1, 3)].size, 2)
278 self.assertEqual(a[(0, 1), (0, 1, 3)].length, 3)
279
280 self.assertRaises(IndexError, lambda: a[-1, :])
281 self.assertRaises(IndexError, lambda: a[:, -1])
282
283 self.assertRaises(TypeError, lambda: a['', :])
284 self.assertRaises(TypeError, lambda: a[:, ''])
285
286 self.assertRaises(ValueError, lambda: a[[], :])
287 self.assertRaises(ValueError, lambda: a[:, []])
288
289 self.assertRaises(IndexError, lambda: a[-1:, :])
290 self.assertRaises(IndexError, lambda: a[:, -1:])
291
292 def testGapAt(self):
293
294 self.assertFalse(self.ali.gap_at(1))
295 self.assertTrue(self.ali.gap_at(3))
296
297
298 @test.unit
299 class TestA3MAlignmentSimple(TestSequenceAlignment):
300
301 def _factory(self, sequences, strict=True):
302 return sequence.A3MAlignment(sequences, strict=strict)
303
304 @test.unit
305 class TestA3MAlignment(test.Case):
306
307 def setUp(self):
308
309 super(TestA3MAlignment, self).setUp()
310
311 self.file = self.config.getTestFile('d1nz0a_.a3m')
312 self.a3m = open(self.file).read()
313 self.ali = sequence.A3MAlignment.parse(self.a3m)
314
315 def testMatches(self):
316 self.assertEqual(self.ali.matches, 109)
317
318 def testLength(self):
319 self.assertEqual(self.ali.length, 135)
320
321 def testSize(self):
322 self.assertEqual(self.ali.size, 9)
323
324 def testRows(self):
325
326 # row 1 (master)
327 row = self.ali.rows[1]
328 self.assertEqual(row.id, 'd1nz0a_')
329
330 self.assertEqual(row.length, 135)
331 self.assertEqual(row.strip().length, 109)
332 self.assertEqual(row.strip().sequence, 'ERLRLRRDFLLIFKEGKSLQNEYFVVLFRKNGMDYSRLGIVVKRKFGKATRRNKLKRWVREIFRRNKGVIPKGFDIVVIPRKKLSEEFERVDFWTVREKLLNLLKRIEG')
333
334 def testToString(self):
335
336 self.assertEqual(self.a3m.strip(), self.ali.format().strip())
337
338 def testFormat(self):
339
340 fasta = self.ali.format(sequence.AlignmentFormats.FASTA, headers=False).splitlines()
341 self.assertEqual(len(fasta), 9)
342
343 for line in fasta:
344 self.assertEqual(len(line), 135)
345
346 ref = open(self.config.getTestFile('d1nz0a_.mfasta')).read()
347 self.assertEqual(ref.strip(), self.ali.format(sequence.AlignmentFormats.FASTA, headers=True).strip())
348
349 def testHMMSubregion(self):
350
351 sub = self.ali.hmm_subregion(2, 30)
352 self.assertEqual(sub.rows['d1nz0a_'].strip().sequence, 'RLRLRRDFLLIFKEGKSLQNEYFVVLFRK')
353 self.assertEqual(sub.size, self.ali.size)
354 self.assertEqual(sub.matches, 30 - 2 + 1)
355
356
357 fasta = self.ali.hmm_subregion(1, 109).format(sequence.AlignmentFormats.FASTA, headers=True)
358 ref = open(self.config.getTestFile('d1nz0a_.mfasta')).read()
359 self.assertEqual(ref, fasta.strip())
360
361 self.assertRaises(sequence.ColumnPositionError, self.ali.subregion, -1, 2)
362 self.assertRaises(sequence.ColumnPositionError, self.ali.hmm_subregion, -1, 2)
363 self.assertRaises(sequence.ColumnPositionError, self.ali.subregion, 1, 111110)
364 self.assertRaises(sequence.ColumnPositionError, self.ali.hmm_subregion, 1, 110)
365
366 def testInsertionAt(self):
367
368 self.assertFalse(self.ali.insertion_at(1))
369 self.assertTrue(self.ali.insertion_at(17))
370
371
372 if __name__ == '__main__':
373
374 test.Console()