Debian Codegraph @

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

raw
1 import csb.test as test
2 import csb.core
3
4 from csb.bio.io.wwpdb import FileSystemStructureProvider
5 from csb.bio.io.fasta import SequenceParser, PDBSequenceParser, SequenceAlignmentReader, StructureAlignmentFactory, OutputBuilder
6 from csb.bio.sequence import AbstractSequence, Sequence, SequenceTypes, ProteinAlphabet, DuplicateSequenceError, SequenceError
7 from csb.bio.sequence import AlignmentFormats, SequenceAlignment, A3MAlignment
8
9
10 @test.unit
11 class TestSequenceParser(test.Case):
12
13 def setUp(self):
14
15 super(TestSequenceParser, self).setUp()
16
17 self.parser = SequenceParser(product=Sequence)
18 self.file = self.config.getTestFile('test.fa')
19 self.data = open(self.file).read()
20
21 def testParseFile(self):
22
23 s = self.parser.parse_file(self.file)
24
25 self.assertEqual(len(s), 3)
26
27 self.assertTrue(isinstance(s[0], Sequence))
28 self.assertEqual(s[0].id, 'gi|148654187')
29 self.assertEqual(s[2].sequence, 'RLSRSHEFQRLRREGTRVRSGYLwCVMLQDPSLPGPAVAFAIGRPFGSAVRRNRLRRQLRSILSDRESAMGGGMFLIGVNNPHRDLPMPSFAQLTHDIDEILNK')
30 self.assertEqual(s[1].header, 'gi|142801636|gb|EDA68688.1 hypothetical protein GOS_1956086')
31
32 def testParseString(self):
33
34 s = self.parser.parse_string(self.data)
35
36 self.assertEqual(len(s), 3)
37
38 self.assertTrue(isinstance(s[0], Sequence))
39 self.assertEqual(s[0].id, 'gi|148654187')
40 self.assertEqual(s[2].sequence, 'RLSRSHEFQRLRREGTRVRSGYLwCVMLQDPSLPGPAVAFAIGRPFGSAVRRNRLRRQLRSILSDRESAMGGGMFLIGVNNPHRDLPMPSFAQLTHDIDEILNK')
41 self.assertEqual(s[1].header, 'gi|142801636|gb|EDA68688.1 hypothetical protein GOS_1956086')
42
43 def testRead(self):
44
45 for s in self.parser.read(self.file):
46 self.assertTrue(s.id.startswith('gi'))
47
48
49 @test.unit
50 class TestPDBSequenceParser(test.Case):
51
52 def setUp(self):
53
54 super(TestPDBSequenceParser, self).setUp()
55
56 self.protein = '>3bx6_A mol:protein length:192 ALPHA-1-ACID GLYCOPROTE\nAB-CD'
57 self.nucleic = '>3bx6_A mol:na length:192 ALPHA-1-ACID GLYCOPROTE\nAB-CD'
58
59 self.parser = PDBSequenceParser()
60
61 def testReadJunk(self):
62
63 self.assertRaises(ValueError, self.parser.read_sequence, '>junk')
64
65 def testReadNucleicSequence(self):
66
67 s = self.parser.read_sequence(self.nucleic)
68
69 self.assertEqual(s.id, '3bx6A')
70 self.assertEqual(s.header, '3bx6_A mol:na length:192 ALPHA-1-ACID GLYCOPROTE')
71 self.assertEqual(s.sequence, 'AB-CD')
72 self.assertEqual(s.type, SequenceTypes.NucleicAcid)
73
74 def testReadProteinSequence(self):
75
76 s = self.parser.read_sequence(self.protein)
77
78 self.assertEqual(s.id, '3bx6A')
79 self.assertEqual(s.header, '3bx6_A mol:protein length:192 ALPHA-1-ACID GLYCOPROTE')
80 self.assertEqual(s.sequence, 'AB-CD')
81
82 def testParseString(self):
83
84 string = '{0}\n{1}'.format(self.nucleic, self.protein)
85 seqs = self.parser.parse_string(string)
86
87 self.assertEqual(len(seqs), 2)
88 self.assertEqual(seqs[0].type, SequenceTypes.NucleicAcid)
89 self.assertEqual(seqs[1].type, SequenceTypes.Protein)
90
91
92 @test.unit
93 class TestSequenceAlignmentReader(test.Case):
94
95 def setUp(self):
96
97 super(TestSequenceAlignmentReader, self).setUp()
98
99 self.reader = SequenceAlignmentReader()
100 self.a3m = self.config.getContent('d1nz0a_.a3m')
101 self.fasta = self.config.getContent('d1nz0a_.mfasta')
102
103 @property
104 def size(self):
105 return 9
106
107 def testReadFASTA(self):
108
109 ali = self.reader.read_fasta(self.fasta)
110
111 self.assertEqual(ali.size, self.size)
112 self.assertEqual(ali.length, 135)
113 self.assertEqual(ali.rows[5].id, 'gi|139352214|gb|ECE59672.1|(37-150:150)')
114 self.assertEqual(ali.rows[1].sequence, 'ERLRLRRDFLLIFKEG-KSLQNEYF-V---VLFRK--N------GMD---YSRLGIVV-KRK-FGKATRRNKLKRWVR---EIFRRNKGVI---PKGFDIVVIPRK--KLSEEFERVDFWTVREKLLNLLKRIEG')
115
116 string = ali.format(AlignmentFormats.FASTA, headers=True).strip()
117 self.assertEqual(string, self.fasta.strip())
118
119 def testReadA3M(self):
120
121 ali = self.reader.read_a3m(self.a3m)
122
123 self.assertEqual(ali.size, self.size)
124 self.assertEqual(ali.length, 135)
125 self.assertEqual(ali.rows[5].id, 'gi|139352214|gb|ECE59672.1|(37-150:150)')
126 self.assertEqual(ali.rows[3].sequence, '-RLTSSKDWKEVRTRG.RCSRSSFA.T...ICVLF..E......GES...E-KFGFAA.AKS.IGSVAKRNRAKRRLR...EAFRQTYKFG...SKPCLVIAIA--..--GPECLTMDFQELKSKL---------')
127
128 string = ali.format(AlignmentFormats.A3M, headers=True).strip()
129 self.assertEqual(string, self.a3m.strip())
130
131 string = ali.format(AlignmentFormats.FASTA, headers=True).strip()
132 self.assertEqual(string, self.fasta.strip())
133
134
135 @test.unit
136 class TestNonStrictAlignmentReader(TestSequenceAlignmentReader):
137
138 def setUp(self):
139
140 super(TestSequenceAlignmentReader, self).setUp()
141
142 self.reader = SequenceAlignmentReader(strict=False)
143 self.strict = SequenceAlignmentReader(strict=True)
144
145 self.a3m = '{0}\n{0}'.format(self.config.getContent('d1nz0a_.a3m'))
146 self.fasta = '{0}\n{0}'.format(self.config.getContent('d1nz0a_.mfasta'))
147
148 @property
149 def size(self):
150 return super(TestNonStrictAlignmentReader, self).size * 2
151
152 def testStrict(self):
153
154 self.assertRaises(DuplicateSequenceError, self.strict.read_fasta, self.fasta)
155 self.assertRaises(DuplicateSequenceError, self.strict.read_a3m, self.a3m)
156
157
158 @test.unit
159 class TestStructureAlignmentFactory(test.Case):
160
161 def setUp(self):
162
163 super(TestStructureAlignmentFactory, self).setUp()
164
165 self.provider = FileSystemStructureProvider(self.config.data)
166 self.provider.add_template('{id}.regular.pdb')
167 self.factory = StructureAlignmentFactory(self.provider)
168
169 self.fasta = self.config.getContent('struct.ali.mfasta')
170
171 def testMakeAlignment(self):
172
173 ali = self.factory.make_alignment(self.fasta)
174
175 self.assertEqual(ali.format().strip(), self.fasta.strip())
176 self.assertEqual(ali.rows[1].columns[1].residue.type, ProteinAlphabet.GLU)
177 self.assertEqual(ali.rows[2].columns[12].residue.atoms['CA'].vector[0], 58.911000000000001)
178
179 def testMakeEntry(self):
180
181 row = Sequence('1d3zA', '', 'DTI--ENVK', SequenceTypes.Protein)
182 chain = self.provider.get('1d3z').chains['A']
183
184 entry = self.factory.make_entry(row, chain)
185 self.assertEqual(row.sequence, entry.sequence)
186 self.assertEqual(row.residues[4].type, ProteinAlphabet.GAP)
187 self.assertEqual(row.residues[5].type, ProteinAlphabet.GAP)
188
189 row = Sequence('1d3zA', '', 'DBUG-ENVK', SequenceTypes.Protein)
190 self.assertRaises(SequenceError, self.factory.make_entry, row, chain)
191
192
193 @test.unit
194 class TestOutputBuilder(test.Case):
195
196 def testCreate(self):
197
198 sequence = Sequence('s1', 's1', 'ABC', SequenceTypes.Protein)
199
200 with self.config.getTempStream() as tmp:
201 for format in csb.core.Enum.members(AlignmentFormats):
202
203 builder = OutputBuilder.create(format, tmp, True)
204 builder.add_sequence(sequence)
205
206
207 self.assertRaises(ValueError, OutputBuilder.create, 'bug', tmp, True)
208
209 @test.unit
210 class TestFASTAOutputBuilder(test.Case):
211
212 def setUp(self):
213 super(TestFASTAOutputBuilder, self).setUp()
214
215 self.s1 = Sequence('s1A', 's1A desc', 'A.-D', SequenceTypes.Protein)
216 self.s2 = Sequence('s2A', 's2A desc', 'ABCD', SequenceTypes.Protein)
217 self.ali = SequenceAlignment([self.s1, self.s2])
218
219 @property
220 def format(self):
221 return AlignmentFormats.FASTA
222
223 @property
224 def sequence_string(self):
225 return '>s1A desc\nA--D'
226
227 @property
228 def alignment_string(self):
229 return '>s1A desc\nA--D\n>s2A desc\nABCD'
230
231 def testAddSequence(self):
232
233 with self.config.getTempStream() as tmp:
234
235 builder = OutputBuilder.create(self.format, tmp, True)
236 builder.add_sequence(self.s1)
237
238 tmp.flush()
239 self.assertEqual(open(tmp.name).read().strip(), self.sequence_string)
240
241 def testAddAlignment(self):
242
243 with self.config.getTempStream() as tmp:
244
245 builder = OutputBuilder.create(self.format, tmp, True)
246 builder.add_alignment(self.ali)
247
248 tmp.flush()
249 self.assertEqual(open(tmp.name).read().strip(), self.alignment_string)
250
251 @test.unit
252 class TestA3MOutputBuilder(TestFASTAOutputBuilder):
253
254 def setUp(self):
255
256 super(TestA3MOutputBuilder, self).setUp()
257 self.ali = A3MAlignment([self.s1, self.s2])
258
259 @property
260 def format(self):
261 return AlignmentFormats.A3M
262
263 @property
264 def sequence_string(self):
265 return '>s1A desc\nA.-D'
266
267 @property
268 def alignment_string(self):
269 return '>s1A desc\nA-D\n>s2A desc\nAbCD'
270
271 @test.unit
272 class TestPIROutputBuilder(TestFASTAOutputBuilder):
273
274 @property
275 def format(self):
276 return AlignmentFormats.PIR
277
278 @property
279 def sequence_string(self):
280 return '>P1;s1\nstructure:s1:.:A:.:A::::\nA--D*'
281
282 @property
283 def alignment_string(self):
284 return r'''
285 >P1;s1
286 sequence:s1:.:A:.:A::::
287 A--D*
288 >P1;s2
289 structure:s2:.:A:.:A::::
290 ABCD*
291 '''.strip()
292
293 @test.unit
294 class TestCrossAlignmentBuilding(test.Case):
295
296 def setUp(self):
297 super(TestCrossAlignmentBuilding, self).setUp()
298
299 self.s1s = Sequence('s1A', 's1A desc', 'A-CD', SequenceTypes.Protein)
300 self.s1a = Sequence('s1A', 's1A desc', 'A.CD', SequenceTypes.Protein)
301 self.s2 = Sequence('s2A', 's2A desc', 'AB-D', SequenceTypes.Protein)
302
303 self.seq = SequenceAlignment([self.s1s, self.s2])
304 self.a3m = A3MAlignment([self.s1a, self.s2])
305
306 def testFastaToA3m(self):
307
308 with self.config.getTempStream() as tmp:
309
310 builder = OutputBuilder.create(AlignmentFormats.A3M, tmp, headers=False)
311 builder.add_alignment(self.seq)
312
313 tmp.flush()
314 self.assertEqual(open(tmp.name).read().strip(), 'ACD\nAb-D')
315
316 def testA3mToFasta(self):
317
318 with self.config.getTempStream() as tmp:
319
320 builder = OutputBuilder.create(AlignmentFormats.FASTA, tmp, headers=False)
321 builder.add_alignment(self.a3m)
322
323 tmp.flush()
324 self.assertEqual(open(tmp.name).read().strip(), 'A-CD\nAB-D')
325
326
327 if __name__ == '__main__':
328
329 test.Console()