Debian Codegraph @

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

raw ◀ ▶
1 Debian patch touch this file
1 import os
2 import sys
3 import csb.test as test
4
5 from csb.bio.io.wwpdb import EntryID, StandardID, DegenerateID, SeqResID, InvalidEntryIDError, HeaderFormatError
6 from csb.bio.io.wwpdb import RobustResidueMapper, FastResidueMapper, CombinedResidueMapper, ResidueMappingError, SparseChainSequence
7 from csb.bio.io.wwpdb import StructureParser, RegularStructureParser, LegacyStructureParser, UnknownPDBResidueError
8 from csb.bio.io.wwpdb import get, find, FileSystemStructureProvider, RemoteStructureProvider, CustomStructureProvider, StructureNotFoundError
9 from csb.bio.sequence import SequenceAlphabets, ProteinAlphabet, SequenceTypes, RichSequence
10 from csb.bio.structure import ChemElements, SecStructures, Structure, Chain
11
12
13 @test.regression
14 class TestBiomoleculeRegressions(test.Case):
15
16 def testCommaSplitting(self):
17 """
18 @see: [CSB 0000067]
19 """
20 pdbfile = self.config.getTestFile('3shm_ca.pdb')
21 parser = LegacyStructureParser(pdbfile)
22
23 s1 = parser.parse_biomolecule(1, True)
24
25 self.assertEqual(len(s1.chains), 60)
26 self.assertEqual(s1.first_chain.id, 'A')
27
28 @test.regression
29 class TestSecStructureRegressions(test.Case):
30
31 def testSecStructureParsing(self):
32 """
33 @see: [CSB 0000045]
34 """
35 pdbfile = self.config.getTestFile('1d3z.regular.pdb')
36 structure = StructureParser(pdbfile).parse_structure(1)
37
38 self.assertTrue(structure.chains['A'].secondary_structure is not None)
39
40 @test.regression
41 class TestMappingRegressions(test.Case):
42
43 def testHetMapping(self):
44 """
45 @see: [CSB 0000031]
46 """
47 pdbfile = self.config.getTestFile('1d3z.regular.pdb')
48 structure = StructureParser(pdbfile).parse_structure(1)
49
50 residue = structure.chains['A'].find(26)
51 self.assertTrue(residue.has_structure)
52 self.assertTrue(residue.atoms.length > 0)
53
54 for an in residue.atoms:
55 self.assertTrue(residue[an].vector.tolist())
56
57 def testNonStandardResidueMapping(self):
58 """
59 @see: [CSB 0000052]
60 """
61 pdbfile = self.config.getTestFile('3p1u.pdb')
62 chain = StructureParser(pdbfile).parse_structure().chains['A']
63
64 for residue in chain.residues:
65
66 if residue.rank < 15:
67 self.assertFalse(residue.has_structure)
68
69 elif residue.rank in (15, 16):
70 self.assertTrue(residue.has_structure)
71
72 self.assertEqual(chain.residues[2].sequence_number, None)
73 self.assertEqual(chain.residues[15].sequence_number, 39)
74 self.assertEqual(chain.residues[16].sequence_number, 40)
75
76
77 @test.unit
78 class TestStructureParser(test.Case):
79
80 def setUp(self):
81
82 super(TestStructureParser, self).setUp()
83
84 regular_file = self.config.getTestFile('1d3z.regular.pdb')
85 legacy_file = self.config.getTestFile('1d3z.legacy.pdb')
86
87 self.rp = StructureParser(regular_file)
88 self.lp = StructureParser(legacy_file)
89
90 def testFactory(self):
91
92 self.assertTrue(isinstance(self.rp, RegularStructureParser))
93 self.assertTrue(isinstance(self.lp, LegacyStructureParser))
94
95
96 @test.unit
97 class TestLegacyStructureParser(test.Case):
98
99 def setUp(self):
100
101 super(TestLegacyStructureParser, self).setUp()
102
103 self.pdb = self.config.getTestFile('1d3z.legacy.pdb')
104 self.parser = LegacyStructureParser(self.pdb)
105
106 def testParseModels(self):
107
108 ensemble = self.parser.parse_models()
109 self.assertEqual(ensemble.models.length, 10)
110 self.assertEqual(ensemble[0].model_id, 1)
111 self.assertEqual(ensemble.models[1].model_id, 1)
112
113 def testParseStructure(self):
114
115 structure = self.parser.parse(model=1)
116
117 self.assertEqual(self.parser.parse_structure().model_id, 1)
118
119 self.assertEqual(structure.accession, '1d3z')
120 self.assertEqual(structure.model_id, 1)
121
122 # Chain level
123 self.assertEqual(structure.chains.length, 1)
124 self.assertEqual(len(structure.chains), 1)
125 self.assertEqual(structure.first_chain.molecule_id, '1')
126 self.assertEqual(structure.chains['A'].sequence, 'MQIFVKTLTGKTITLEVEPSDTIENVKAKIQDKEGIPPDQQRLIFAGKQLEDGRTLSDYNIQKESTLHLVLRLRGG')
127
128 self.assertEqual(len(structure.chains['A']), 76)
129 self.assertEqual(len(structure['A']), 76)
130
131 # Residue level
132 self.assertEqual(len(structure['A'][1:10]), 9)
133 self.assertEqual(structure['A'][0].type, SequenceAlphabets.Protein.MET)
134 self.assertEqual(structure['A'][0].label, 'MSE')
135 self.assertEqual(structure['A'][1].label, 'GLN')
136 self.assertTrue(structure['A'][0].is_modified)
137 self.assertFalse(structure['A'][1].is_modified)
138
139 # Atom level
140 self.assertEqual(structure['A'][1].atoms['CA'].element, None)
141 self.assertNotEqual(structure['A'][2].atoms['CA'].element, None)
142 self.assertEqual(structure['A'][2].atoms['CA'].element, ChemElements.C)
143
144 vector = [51.653, -89.304, 8.833]
145 self.assertEqual(structure['A'][0]['CA'].vector.tolist(), vector)
146
147 def testParseResidue(self):
148
149 self.assertEqual(self.parser.parse_residue('AGM'), SequenceAlphabets.Protein.ARG.name) #@UndefinedVariable
150 self.assertEqual(self.parser.parse_residue('AGM', as_type=SequenceTypes.Protein), SequenceAlphabets.Protein.ARG.name) #@UndefinedVariable
151 self.assertRaises(UnknownPDBResidueError, self.parser.parse_residue, 'AGM', as_type=SequenceTypes.NucleicAcid)
152
153 def testParseResidueSafe(self):
154
155 self.assertEqual(self.parser.parse_residue_safe('AGM', as_type=None), SequenceAlphabets.Protein.ARG.name) #@UndefinedVariable
156 self.assertEqual(self.parser.parse_residue_safe('AGM', as_type=SequenceTypes.Protein), SequenceAlphabets.Protein.ARG.name) #@UndefinedVariable
157 self.assertEqual(self.parser.parse_residue_safe('AGM', as_type=SequenceTypes.NucleicAcid), SequenceAlphabets.Nucleic.Any.name) #@UndefinedVariable
158 self.assertEqual(self.parser.parse_residue_safe('junk', as_type=SequenceTypes.Protein), SequenceAlphabets.Unknown.UNK.name) #@UndefinedVariable
159
160 def testGuessSequenceType(self):
161
162 self.assertEqual(self.parser.guess_sequence_type('AGM'), SequenceTypes.Protein)
163 self.assertEqual(self.parser.guess_sequence_type('DOC'), SequenceTypes.NucleicAcid)
164 self.assertRaises(UnknownPDBResidueError, self.parser.guess_sequence_type, 'junk')
165
166 def testFileName(self):
167 self.assertEqual(self.parser.filename, self.pdb)
168
169 def testModels(self):
170 self.assertEqual(self.parser.models(), list(range(1, 11)))
171
172 def testParseBiomolecule(self):
173
174 pdbfile = self.config.getTestFile('3p1u.pdb')
175 parser = LegacyStructureParser(pdbfile)
176
177 s2 = parser.parse_biomolecule(2)
178
179 self.assertEqual(len(s2.chains), 1)
180 self.assertEqual(s2.first_chain.id, 'B1')
181 self.assertRaises(KeyError, parser.parse_biomolecule, 3)
182
183 def testParseHetMolecules(self):
184
185 with self.config.getTempStream() as tmp:
186
187 tmp.write('HETATM 1 NA BLM A 1 -14.575 27.241 3.310 1.00 0.00 N ')
188 tmp.flush()
189
190 parser = LegacyStructureParser(tmp.name)
191 self.assertRaises(HeaderFormatError, parser.parse_structure)
192 del parser
193
194
195 @test.unit
196 class TestRegularStructureParser(test.Case):
197
198 def setUp(self):
199
200 super(TestRegularStructureParser, self).setUp()
201
202 self.pdb = self.config.getTestFile('1d3z.regular.pdb')
203 self.mapping = self.config.getTestFile('mapping.pdb')
204 self.parser = RegularStructureParser(self.pdb)
205
206 def testMapper(self):
207
208 p = RegularStructureParser(self.pdb, mapper=None)
209 self.assertTrue(isinstance(p.mapper, CombinedResidueMapper))
210
211 p.mapper = FastResidueMapper()
212 self.assertTrue(isinstance(p.mapper, FastResidueMapper))
213
214 def testCombinedMapping(self):
215
216 # default mapper
217 c = self.parser.parse(self.mapping)['E']
218 self.assertEqual(c.residues[14].type, ProteinAlphabet.GLU)
219 self.assertEqual(c.residues[15].type, ProteinAlphabet.GLU)
220 self.assertEqual(c.residues[16].type, ProteinAlphabet.THR)
221 self.assertEqual(4, sum([1 for r in c if r.has_structure]))
222
223 # explicit combined mapper
224 self.parser.mapper = CombinedResidueMapper()
225 c = self.parser.parse(self.mapping)['E']
226 self.assertEqual(4, sum([1 for r in c if r.has_structure]))
227
228 def testFastMapping(self):
229
230 self.parser.mapper = FastResidueMapper()
231 self.assertRaises(ResidueMappingError, self.parser.parse, self.mapping)
232
233 mapping2 = self.config.getTestFile('mapping2.pdb')
234
235 c = self.parser.parse(mapping2)['E']
236 self.assertEqual(2, sum([1 for r in c if r.has_structure]))
237
238 def testRobustMapping(self):
239
240 mapping3 = self.config.getTestFile('mapping3.pdb')
241
242 self.parser.mapper = RobustResidueMapper()
243 self.assertRaises(ResidueMappingError, self.parser.parse, mapping3)
244
245 c = self.parser.parse(self.mapping)['E']
246 self.assertEqual(4, sum([1 for r in c if r.has_structure]))
247
248 def testParseModels(self):
249
250 ensemble = self.parser.parse_models()
251 self.assertEqual(ensemble.models.length, 10)
252 self.assertEqual(ensemble[0].model_id, 1)
253 self.assertEqual(ensemble.models[1].model_id, 1)
254
255 self.assertRaises(ValueError, self.parser.parse_models, (999, 1000))
256
257 pdb = self.config.getTestFile('3p1u.pdb')
258 ensemble = RegularStructureParser(pdb).parse_models()
259 self.assertEqual(ensemble.models.length, 1)
260 self.assertEqual(ensemble[0].model_id, 1)
261 self.assertEqual(ensemble[0].resolution, 2.05)
262
263 def testParseStructure(self):
264
265 structure = self.parser.parse(model=2)
266
267 self.assertEqual(self.parser.parse_structure().model_id, 1)
268 self.assertEqual(structure.resolution, None)
269
270 self.assertEqual(structure.accession, '1d3z')
271 self.assertEqual(structure.model_id, 2)
272
273 # Chain level
274 self.assertEqual(structure.chains.length, 1)
275 self.assertEqual(len(structure.chains), 1)
276 self.assertEqual(structure.chains['A'].sequence, 'MQIFVKTLTGKTITLEVEPSDTIENVKAKIQDKEGIPPDQQRLIFAGKQLEDGRTLSDYNIQKESTLHLVLRLRGG')
277 self.assertEqual(structure.chains['A'].sequence, ''.join([str(r.type) for r in structure.chains['A'] if r.has_structure]))
278
279 ss = structure.chains['A'].secondary_structure
280 self.assertEqual(ss.to_string(), '-EEEEE-----EEEEE-----HHHHHHHHHHHHHH-HHH-EEEEE--EE------HHHHH-----EEEEEE')
281 self.assertEqual(len(ss.scan(1, 99, filter=SecStructures.Helix)), 3)
282 self.assertEqual(ss[1].start, 2)
283 self.assertEqual(ss[1].end, 6)
284
285 self.assertEqual(len(structure.chains['A']), 76)
286 self.assertEqual(len(structure['A']), 76)
287
288 # Residue level
289 self.assertEqual(len(structure['A'][1:10]), 9)
290 self.assertEqual(structure['A'][0].type, SequenceAlphabets.Protein.MET)
291 self.assertEqual(structure['A'][0].label, 'MSE')
292 self.assertEqual(structure['A'][1].label, 'GLN')
293
294 # Atom
295 vector = [52.647, -87.443, 9.674]
296 self.assertEqual(structure['A'][0]['CA'].vector.tolist(), vector)
297
298 def testParseResidue(self):
299
300 self.assertEqual(self.parser.parse_residue('AGM'), SequenceAlphabets.Protein.ARG.name) #@UndefinedVariable
301 self.assertEqual(self.parser.parse_residue('AGM', as_type=SequenceTypes.Protein), SequenceAlphabets.Protein.ARG.name) #@UndefinedVariable
302 self.assertRaises(UnknownPDBResidueError, self.parser.parse_residue, 'AGM', as_type=SequenceTypes.NucleicAcid)
303
304 def testParseResidueSafe(self):
305
306 self.assertEqual(self.parser.parse_residue_safe('AGM', as_type=None), SequenceAlphabets.Protein.ARG.name) #@UndefinedVariable
307 self.assertEqual(self.parser.parse_residue_safe('AGM', as_type=SequenceTypes.Protein), SequenceAlphabets.Protein.ARG.name) #@UndefinedVariable
308 self.assertEqual(self.parser.parse_residue_safe('AGM', as_type=SequenceTypes.NucleicAcid), SequenceAlphabets.Nucleic.Any.name) #@UndefinedVariable
309 self.assertEqual(self.parser.parse_residue_safe('junk', as_type=SequenceTypes.Protein), SequenceAlphabets.Unknown.UNK.name) #@UndefinedVariable
310
311 def testGuessSequenceType(self):
312
313 self.assertEqual(self.parser.guess_sequence_type('AGM'), SequenceTypes.Protein)
314 self.assertEqual(self.parser.guess_sequence_type('DOC'), SequenceTypes.NucleicAcid)
315 self.assertRaises(UnknownPDBResidueError, self.parser.guess_sequence_type, 'junk')
316
317 def testFileName(self):
318 self.assertEqual(self.parser.filename, self.pdb)
319
320 def testModels(self):
321 self.assertEqual(self.parser.models(), list(range(1, 11)))
322
323
324 @test.unit
325 class TestFastResidueMapper(test.Case):
326
327 def setUp(self):
328 super(TestFastResidueMapper, self).setUp()
329 self.mapper = FastResidueMapper()
330
331 def _build(self, string):
332
333 id = str(hash(string))
334 seq = RichSequence(id, "", string, SequenceTypes.Protein)
335
336 return SparseChainSequence.create(Chain.from_sequence(seq))
337
338 def testMap(self):
339
340 ref = self._build("ZABCD")
341 sparse = self._build("AC")
342
343 self.assertRaises(ResidueMappingError, self.mapper.map, sparse, ref)
344
345 sparse.residues[2].id = (22, None)
346 result = self.mapper.map(sparse, ref)
347
348 self.assertEqual(result.sequence, "-A-C-")
349
350 def testModifiedResidueMapping(self):
351 """
352 Strictly speaking, this is a regression test. But it so essential that
353 we should keep it here.
354
355 @see: [csb: 19]
356 """
357 pdb = self.config.getTestFile('modified.pdb')
358
359 structure = StructureParser(pdb, mapper=self.mapper).parse_structure()
360 chain = structure.first_chain
361
362 self.assertFalse(chain.residues[1].has_structure)
363 self.assertEqual(chain.residues[1].label, "MET")
364
365 self.assertTrue(chain.residues[19].has_structure)
366 self.assertEqual(chain.residues[19].label, "MSE")
367
368
369 @test.unit
370 class TestRobustResidueMapper(TestFastResidueMapper):
371
372 def setUp(self):
373 super(TestRobustResidueMapper, self).setUp()
374 self.mapper = RobustResidueMapper()
375
376 def testMap(self):
377
378 ref = self._build("ABCD")
379 sparse = self._build("EF")
380
381 self.assertRaises(ResidueMappingError, self.mapper.map, sparse, ref)
382
383 ref = self._build("ZABCD")
384 sparse = self._build("AC")
385 result = self.mapper.map(sparse, ref)
386
387 self.assertEqual(result.sequence, "-A-C-")
388
389 def testModifiedResidueMapping(self):
390
391 pdb = self.config.getTestFile('modified2.pdb')
392
393 structure = StructureParser(pdb, mapper=self.mapper).parse_structure()
394 chain = structure.first_chain
395
396 self.assertTrue(chain.residues[1].has_structure)
397 self.assertEqual(chain.residues[1].label, "MSE")
398
399 self.assertFalse(chain.residues[19].has_structure)
400 self.assertEqual(chain.residues[19].label, "MET")
401
402
403 @test.unit
404 class TestCombinedResidueMapper(TestFastResidueMapper):
405
406 def setUp(self):
407 super(TestCombinedResidueMapper, self).setUp()
408 self.mapper = CombinedResidueMapper()
409
410 def testMap(self):
411
412 ref = self._build("ZABCD")
413 sparse = self._build("AC")
414 result = self.mapper.map(sparse, ref)
415
416 self.assertEqual(result.sequence, "-A-C-")
417
418 @test.unit
419 class TestFileSystemProvider(test.Case):
420
421 def setUp(self):
422
423 super(TestFileSystemProvider, self).setUp()
424
425 self.path = self.config.data
426 self.provider = FileSystemStructureProvider()
427 self.provider.add(self.path)
428
429 def testAdd(self):
430
431 self.assertEqual(len(self.provider.paths), 1)
432
433 self.provider.add('.')
434 self.assertEqual(self.provider.paths[1], '.')
435 self.assertEqual(len(self.provider.paths), 2)
436
437 self.assertRaises(IOError, self.provider.add, 'non-exi$ting path')
438
439 def testRemove(self):
440
441 self.assertEqual(len(self.provider.paths), 1)
442 self.provider.remove(self.path)
443 self.assertEqual(len(self.provider.paths), 0)
444
445 self.assertRaises(ValueError, self.provider.remove, 'non-exi$ting path')
446
447 def testFind(self):
448
449 f1 = self.provider.find('3p1u')
450 f2 = self.config.getTestFile('3p1u.pdb')
451
452 self.assertEqual(os.path.abspath(f1), os.path.abspath(f2))
453 self.assertEqual(None, self.provider.find('$'))
454
455 def testGet(self):
456
457 s = self.provider.get('3p1u')
458 self.assertEqual(s.accession, '3p1u')
459 self.assertTrue(isinstance(s, Structure))
460 self.assertRaises(StructureNotFoundError, self.provider.get, '$')
461
462
463 @test.unit
464 class TestCustomProvider(test.Case):
465
466 def setUp(self):
467
468 super(TestCustomProvider, self).setUp()
469
470 self.path = self.config.getTestFile('3p1u.pdb')
471 self.provider = CustomStructureProvider({'3p1u': self.path})
472
473 def testAdd(self):
474
475 self.assertEqual(len(self.provider.paths), 1)
476 self.assertEqual(self.provider.paths[0], self.path)
477
478 self.provider.add('test', self.config.getTestFile('d1nz0a_.pdb'))
479 self.assertEqual(len(self.provider.paths), 2)
480
481 self.assertRaises(IOError, self.provider.add, 'test', 'non-exi$ting path')
482
483 def testRemove(self):
484
485 self.assertEqual(len(self.provider.paths), 1)
486 self.provider.remove('3p1u')
487 self.assertEqual(len(self.provider.paths), 0)
488
489 self.assertRaises(ValueError, self.provider.remove, '$')
490
491 def testFind(self):
492
493 f1 = self.provider.find('3p1u')
494 f2 = self.config.getTestFile('3p1u.pdb')
495
496 self.assertEqual(os.path.abspath(f1), os.path.abspath(f2))
497 self.assertEqual(None, self.provider.find('$'))
498
499 def testGet(self):
500
501 s = self.provider.get('3p1u')
502 self.assertEqual(s.accession, '3p1u')
503 self.assertTrue(isinstance(s, Structure))
504 self.assertRaises(StructureNotFoundError, self.provider.get, '$')
505
506
507 @test.functional
508 class TestFind(test.Case):
509
510 def runTest(self):
511
512 f2 = find('3p1u', [self.config.data])
513 f1 = self.config.getTestFile('3p1u.pdb')
514
515 self.assertEqual(os.path.abspath(f1), os.path.abspath(f2))
516 self.assertEqual(None, find('$', self.config.data))
517
518
519 @test.unit
520 class TestEntryID(test.Case):
521
522 def setUp(self):
523 super(TestEntryID, self).setUp()
524
525 def testFactory(self):
526 self.assertTrue(isinstance(EntryID.create('abcdE'), StandardID))
527 self.assertTrue(isinstance(EntryID.create('abcdddE'), DegenerateID))
528 self.assertTrue(isinstance(EntryID.create('abcd_E'), SeqResID))
529
530 @test.unit
531 class TestStandardID(test.Case):
532
533 def setUp(self):
534 super(TestStandardID, self).setUp()
535
536 self.id = StandardID('abCdE')
537 self.accession = 'abcd'
538 self.chain = 'E'
539
540 def testAccession(self):
541 self.assertEqual(self.id.accession, self.accession)
542
543 def testChain(self):
544 self.assertEqual(self.id.chain, self.chain)
545
546 def testEntryID(self):
547 self.assertEqual(self.id.entry_id, self.accession + self.chain)
548
549 def testFormat(self):
550 self.assertEqual(self.id.format(), self.accession + self.chain)
551
552 def testConstructor(self):
553 self.assertRaises(InvalidEntryIDError, StandardID, 'aE')
554
555 @test.unit
556 class TestDegenerateID(TestStandardID):
557
558 def setUp(self):
559 super(TestDegenerateID, self).setUp()
560
561 self.id = DegenerateID('abCdddE')
562 self.accession = 'abcddd'
563 self.chain = 'E'
564
565 @test.unit
566 class TestSeqResID(TestStandardID):
567
568 def setUp(self):
569 super(TestSeqResID, self).setUp()
570 self.id = SeqResID('abCd_E')
571
572 def testFormat(self):
573 self.assertEqual(self.id.format(), 'abcd_E')
574
575 def testConstructor(self):
576 self.assertRaises(InvalidEntryIDError, SeqResID, 'abcdE')
577
578
579 @test.custom
580 def TestPDB():
581
582 import glob
583
584 class PDBTestCase(test.Case):
585
586 def runTest(self):
587
588 try:
589 StructureParser(self.entry).parse_structure()
590 except:
591 sys.stdout.write("\n{0}\n".format(self.entry))
592 self.reRaise([self.entry])
593
594 var = 'PDBMASK'
595 suite = test.unittest.TestSuite()
596
597 if var in os.environ:
598 for entry in glob.glob(os.environ[var]):
599 case = PDBTestCase()
600 case.entry = entry
601 suite.addTest(case)
602
603 return suite
604
605
606
607 if __name__ == '__main__':
608
609 test.Console()