Debian Codegraph @

csb/test/cases/io/__init__.py

raw
1
2 import os
3 import sys
4 import numpy
5 import types
6 import csb.io
7 import csb.io.tsv
8 import csb.test as test
9 import csb.bio.structure
10
11 from csb.bio.io.wwpdb import LegacyStructureParser
12 # Workaround I just need some class which I can abuse to create a graph
13 from csb.statistics.pdf import Gamma as Node
14
15
16 @test.unit
17 class TestShell(test.Case):
18
19 def setUp(self):
20
21 super(TestShell, self).setUp()
22
23 cmd = '{0.python} -c "print({0.text})"'
24
25 self.python = sys.executable.replace("\\", "/") # "\" fails on win7
26 self.text = "123"
27 self.output = csb.io.Shell.run(cmd.format(self))
28
29 if not self.python:
30 self.skipTest("Can't get interpreter's path")
31
32 def testSTDOUT(self):
33 self.assertEqual(self.output.stdout.strip(), self.text)
34
35 def testSTDERR(self):
36 self.assertEqual(self.output.stderr, '')
37
38 def testExitCode(self):
39 self.assertEqual(self.output.code, 0)
40
41
42 @test.unit
43 class TestTable(test.Case):
44
45 def setUp(self):
46 super(TestTable, self).setUp()
47
48 self.tsv = self.config.getTestFile('csb.tsv')
49 self.table = csb.io.tsv.Table.from_tsv(self.tsv)
50 self.t = csb.io.tsv.Table.from_table(self.table, data=True)
51
52 def testIteration(self):
53
54 data = list(self.table)
55 self.assertEqual(len(data), 3)
56
57 def testArrayCompatibility(self):
58
59 array = numpy.array(self.table)
60 self.assertEqual(array.shape, (3, 3))
61
62 t = csb.io.tsv.Table('a:int b:float')
63 t.insert([1, 1.2])
64 array = numpy.array(t)
65 self.assertEqual(list(array[0]), [1, 1.2])
66
67 def testDataAccess(self):
68
69 firstrow = list(self.table)[0]
70
71 self.assertEqual(firstrow[1], 11.1)
72 self.assertEqual(firstrow['ID'], 11)
73 self.assertEqual(firstrow['B'], 'Row eleven')
74
75 self.assertEqual(firstrow.columns, ('ID', 'A', 'B'))
76 self.assertEqual(firstrow.dump('|'), '11|11.1|Row eleven')
77
78 self.assertRaises(IndexError, lambda:firstrow[4])
79 self.assertRaises(KeyError, lambda:firstrow['Missing'])
80
81 def testSQLDataAccess(self):
82
83 reader = self.table.query('SELECT A, ID FROM TSV WHERE ID > ?', [0])
84 data = list(reader)
85 firstrow = data[0]
86
87 self.assertEqual(len(data), 3)
88 self.assertEqual(firstrow[0], 11.1)
89 self.assertEqual(firstrow[1], 11)
90
91 def testInsert(self):
92
93 self.t.insert([333, 333.0, '3 3 3'])
94 self.assertEqual(self.t[3, 2], '3 3 3')
95
96 self.assertRaises(Exception, lambda:self.t.insert([1]))
97
98 def testUpdate(self):
99
100 self.assertRaises(csb.io.tsv.InvalidColumnError, lambda:self.t.where('ID').equals(11).update('Missing', 0))
101 self.t.where('ID').equals(11).update('ID', 133)
102 self.assertEqual(self.t[0, 'ID'], 133)
103 self.assertEqual(self.t[1, 'ID'], 12)
104
105 self.assertRaises(csb.io.tsv.InvalidColumnError, lambda:self.t.update('Missing', 0))
106 self.assertRaises(csb.io.tsv.InvalidColumnError, lambda:self.t[0, 'Missing'])
107 self.t.update('ID', 13)
108
109 for r in self.t[:, 'ID']:
110 self.assertEqual(r['ID'], 13)
111
112 self.t[0, 'ID'] = 11
113 self.t[1, 'ID'] = 12
114 self.assertEqual(self.t[0, 'ID'], 11)
115 self.assertEqual(self.t[2, 'ID'], 13)
116
117 def testDump(self):
118
119 with self.config.getTempStream() as dump:
120
121 self.table.dump(dump)
122 dump.flush()
123
124 self.assertEqual(open(self.tsv).read(), open(dump.name).read())
125
126 def testScalar(self):
127
128 self.assertEqual(self.table.scalar(0, 'ID'), 11)
129 self.assertEqual(self.table[0, 'ID'], 11)
130 self.assertEqual(self.table[0, 0], 11)
131
132 self.assertTrue(isinstance(self.table[:, :], csb.io.tsv.Table))
133 self.assertTrue(isinstance(self.table[:, ('A',)], csb.io.tsv.Table))
134 self.assertTrue(isinstance(self.table[:, 'A':], csb.io.tsv.Table))
135 self.assertTrue(isinstance(self.table[1:2, 0], csb.io.tsv.Table))
136 self.assertTrue(isinstance(self.table[(1, 2), 0], csb.io.tsv.Table))
137
138 def testSelect(self):
139
140 # test column selection
141 self.assertEqual(self.table.select().columns, ('ID', 'A', 'B'))
142 self.assertEqual(self.table.select('*').columns, ('ID', 'A', 'B'))
143 self.assertEqual(self.table[:, :].columns, ('ID', 'A', 'B'))
144 self.assertEqual(self.table[:, :'A'].columns, ('ID',))
145 self.assertEqual(self.table[:, 'ID':'B'].columns, ('ID', 'A'))
146
147 self.assertEqual(self.table.select(['B', 'A']).columns, ('B', 'A'))
148 self.assertEqual(self.table.select('A', 'B').columns, ('A', 'B'))
149 self.assertEqual(self.table[:, ('B', 'A')].columns, ('B', 'A'))
150
151 self.assertEqual(self.table.select(['A']).columns, ('A',))
152 self.assertEqual(self.table.select(['A']).columns, ('A',))
153
154 def fr(t):
155 return list(t)[0]
156
157 # test data
158 self.assertEqual(len(list(self.table[1:2, :])), 1)
159 self.assertEqual(len(list(self.table[1:, :])), 2)
160 self.assertEqual(len(list(self.table[(1, 2), :])), 2)
161 self.assertEqual(len(list(self.table[(0, 1, 2), :])), 3)
162 self.assertEqual(len(list(self.table[:, :])), 3)
163
164 firstrow = fr(self.table.select('B', 'A'))
165 self.assertEqual(firstrow[0], 'Row eleven')
166 self.assertEqual(firstrow[1], 11.1)
167
168 self.assertEqual(fr(self.table[:, :])[0], 11)
169
170 self.assertEqual(fr(self.table[:, 'A'])[0], 11.1)
171 self.assertEqual(fr(self.table[:, 'B':])[0], 'Row eleven')
172
173 self.assertEqual(fr(self.table[2, :])[0], 13)
174 self.assertEqual(fr(self.table[(1, 2), :])[0], 12)
175 self.assertEqual(fr(self.table[1:9, :])[0], 12)
176
177 def testWhere(self):
178
179 self.assertEqual(self.table.where('ID').equals(11).select('A').scalar(), 11.1)
180 self.assertEqual(self.table.where('ID').greater(12).select('A').scalar(), None)
181 self.assertEqual(self.table.where('ID').between(11, 12).select('A').scalar(), 11.1)
182 self.assertEqual(self.table.where('ID').in_(11).select('A').scalar(), 11.1)
183 self.assertEqual(self.table.where('ID').in_(11, 12).select('A').scalar(), 11.1)
184
185
186 @test.unit
187 class TestAutoFlushStream(test.Case):
188
189 def setUp(self):
190
191 super(TestAutoFlushStream, self).setUp()
192 self.temp = self.config.getTempStream()
193
194 def testWrite(self):
195
196 stream = csb.io.AutoFlushStream(self.temp)
197 stream.write('$')
198
199 content = open(self.temp.name).read()
200 self.assertEqual(content, '$') # will fail if not flushed (this is the actual test)
201 stream.flush()
202 self.assertEqual(content, '$')
203
204 def tearDown(self):
205 self.temp.close()
206
207
208 @test.unit
209 class TestMemoryStream(test.Case):
210
211 def setUp(self):
212
213 super(TestMemoryStream, self).setUp()
214 self.stream = csb.io.MemoryStream()
215
216 def testWrite(self):
217
218 self.stream.write('tesT')
219 self.assertEqual(self.stream.getvalue(), 'tesT')
220
221 def testFlush(self):
222
223 self.stream.write('tesT')
224 self.stream.flush()
225 self.assertEqual(self.stream.getvalue(), 'tesT')
226
227 def testClose(self):
228 self.stream.close()
229 self.assertTrue(self.stream.closed)
230
231 def testContextManager(self):
232 with csb.io.MemoryStream() as stream:
233 stream.write('tesT')
234 stream.flush()
235 self.assertEqual(stream.getvalue(), 'tesT')
236
237
238 @test.unit
239 class TestTempFile(test.Case):
240
241 def testCallForwarding(self):
242
243 with csb.io.TempFile() as temp:
244
245 self.assertTrue(hasattr(temp, 'write'))
246 self.assertTrue(hasattr(temp, 'flush'))
247 self.assertTrue(hasattr(temp, 'name'))
248 self.assertTrue(hasattr(temp, 'close'))
249 self.assertTrue(hasattr(temp, 'read'))
250 self.assertTrue(hasattr(temp, 'readline'))
251
252 self.assertFalse(hasattr(temp, 'jxYUgg8'))
253 self.assertRaises(AttributeError, lambda:getattr(temp, 'jxYUgg8'))
254
255 def testContextManager(self):
256
257 with csb.io.TempFile() as temp:
258 self.assertTrue(os.path.exists(temp.name))
259 self.assertFalse(os.path.exists(temp.name))
260
261 def testClose(self):
262
263 temp = csb.io.TempFile()
264
265 self.assertTrue(os.path.isfile(temp.name))
266 temp.close()
267 self.assertFalse(os.path.exists(temp.name))
268
269 def testAutoCleanup(self):
270
271 for dispose in [True, False]:
272 temp = csb.io.TempFolder(dispose=dispose)
273 name = temp.name
274
275 self.assertTrue(os.path.isdir(name))
276 del temp
277 self.assertEqual(os.path.isdir(name), not dispose)
278
279 def testMultipleHandles(self):
280
281 with csb.io.TempFile() as temp:
282
283 data = '_Test_'
284 temp.write(data)
285 temp.flush()
286
287 self.assertEqual(data, open(temp.name).read())
288
289
290 @test.unit
291 class TestTempFolder(test.Case):
292
293 def testContextManager(self):
294
295 with csb.io.TempFolder() as temp:
296 self.assertTrue(os.path.isdir(temp.name))
297
298 self.assertFalse(os.path.exists(temp.name))
299
300 def testClose(self):
301
302 temp = csb.io.TempFolder()
303
304 for i in range(3):
305 name = os.path.join(temp.name, 'test{0}.txt'.format(i))
306 with open(name, 'w') as f:
307 f.write('.')
308
309 self.assertTrue(os.path.isdir(temp.name))
310 temp.close()
311 self.assertFalse(os.path.exists(temp.name))
312
313 def testAutoCleanup(self):
314
315 for dispose in [True, False]:
316 temp = csb.io.TempFolder(dispose=dispose)
317 name = temp.name
318
319 self.assertTrue(os.path.isdir(name))
320 del temp
321 self.assertEqual(os.path.isdir(name), not dispose)
322
323
324 @test.unit
325 class TestEntryReader(test.Case):
326
327 def setUp(self):
328
329 super(TestEntryReader, self).setUp()
330
331 self.stream = csb.io.MemoryStream()
332 self.data = r"""
333
334 >>E0
335 text
336 >>E1
337 text1
338 text2
339
340 text3
341 >>E2
342 // """
343 self.stream.write(self.data)
344
345 def testStartMarker(self):
346
347 reader = csb.io.EntryReader(self.stream, '>>', None)
348 e = reader.readall()
349
350 self.assertEqual(e[0].splitlines(), ['>>E0', 'text'])
351 self.assertEqual(e[1].splitlines(), ['>>E1', 'text1', 'text2', '', 'text3'])
352 self.assertEqual(e[2].splitlines(), ['>>E2', '// '])
353
354 def testAllMarkers(self):
355
356 reader = csb.io.EntryReader(self.stream, '>>', '//')
357 e = reader.readall()
358
359 self.assertEqual(e[0].splitlines(), ['>>E0', 'text'])
360 self.assertEqual(e[1].splitlines(), ['>>E1', 'text1', 'text2', '', 'text3'])
361 self.assertEqual(e[2].splitlines(), ['>>E2'])
362
363 def testReadAll(self):
364
365 r1 = csb.io.EntryReader(self.stream, '>>', '//')
366 self.assertEqual(len(r1.readall()), 3)
367
368 r2 = csb.io.EntryReader(self.stream, '>>', None)
369 self.assertEqual(len(r2.readall()), 3)
370
371 def testRead(self):
372
373 reader = csb.io.EntryReader(self.stream, '>>', '//')
374 self.assertEqual(reader.readall(), list(reader.entries()))
375
376 self.assertEqual(type(reader.entries()), types.GeneratorType)
377
378 def testDel(self):
379
380 stream = csb.io.MemoryStream()
381 reader = csb.io.EntryReader(stream, None, None)
382
383 self.assertFalse(stream.closed)
384 del reader
385 self.assertTrue(stream.closed)
386
387
388 @test.unit
389 class TestEntryWriter(test.Case):
390
391 def testConstructor(self):
392
393 # test with a file name
394 tempFileName = self.config.getTempStream().name
395 writer = csb.io.EntryWriter(tempFileName, close=False) # see below:
396 self.assertTrue(hasattr(writer.stream, 'write'))
397 self.assertTrue(writer.autoclose) # close is ignored in init when destination is a path, not a stream
398
399 # with a stream, autoclose
400 temp = self.config.getTempStream()
401 writer = csb.io.EntryWriter(temp, close=True)
402 # - test .stream
403 self.assertEqual(writer.stream, temp)
404 # - test .autoclose
405 self.assertTrue(writer.autoclose)
406 # - test del
407 del writer
408 self.assertTrue(temp.closed)
409
410 # with a stream, no autoclose
411 temp = self.config.getTempStream()
412 writer = csb.io.EntryWriter(temp, close=False)
413 self.assertEqual(writer.stream, temp)
414 self.assertFalse(writer.autoclose)
415 del writer
416 self.assertFalse(temp.closed)
417 temp.close()
418
419 def testContextManager(self):
420
421 with csb.io.EntryWriter(self.config.getTempStream(), close=True) as w:
422 w.write('.')
423 self.assertFalse(w.stream.closed)
424 self.assertTrue(w.stream.closed)
425
426 with csb.io.EntryWriter(self.config.getTempStream(), close=False) as w:
427 w.write('.')
428 self.assertFalse(w.stream.closed)
429 self.assertFalse(w.stream.closed)
430
431 def testWrite(self):
432
433 with self.config.getTempStream() as temp:
434
435 writer = csb.io.EntryWriter(temp, close=False)
436 writer.write('D')
437 writer.stream.flush()
438
439 self.assertEqual(open(temp.name).read(), 'D')
440
441 def testWriteLine(self):
442
443 with self.config.getTempStream() as temp:
444
445 writer = csb.io.EntryWriter(temp, close=False)
446 writer.writeline('D')
447 writer.stream.flush()
448
449 self.assertEqual(open(temp.name).read(), 'D' + csb.io.NEWLINE)
450
451 def testWriteAll(self):
452
453 with self.config.getTempStream() as temp:
454
455 writer = csb.io.EntryWriter(temp, close=False)
456 writer.writeall(('A', 'B', 'C',), '/')
457 writer.stream.flush()
458
459 self.assertEqual(open(temp.name).read(), 'A/B/C/')
460
461
462
463 @test.functional
464 class TestDumpLoad(test.Case):
465
466 def setUp(self):
467 super(TestDumpLoad, self).setUp()
468
469 self.lists = [[],
470 list(range(1000)),
471 list("Although that way may not be" +
472 "obvious at first" +
473 "unless you're Dutch.")]
474 self.arrays = [numpy.array([]),
475 numpy.random.random(1000),
476 numpy.arange(1000), ]
477
478 self.strings = ["",
479 "Although that way may not be" + \
480 "obvious at first" + \
481 "unless you're Dutch.",
482 "([0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])"]
483
484 # Completly connnected graph
485
486 self.big_graph = []
487 for _i in range(250):
488 n = Node()
489 self.big_graph.append(n)
490 for n in self.big_graph:
491 n.connections = set(self.big_graph)
492 n.connections.remove(n)
493
494 # Protein
495 pdbfile = self.config.getTestFile('ake-xray-ensemble-ca.pdb')
496 self.protein = LegacyStructureParser(pdbfile).parse_models()[0]
497
498 self.objs = [self.lists, self.arrays, self.strings,
499 self.protein]
500
501 def testSimple(self):
502 load_func = csb.io.load
503 dump_func = csb.io.dump
504 self._test(load_func, dump_func)
505
506 def testGzip(self):
507 load_func = lambda x: csb.io.load(x, gzip=True)
508 dump_func = lambda x, y: csb.io.dump(x, y, gzip=True)
509 self._test(load_func, dump_func)
510
511 def testGzipFail(self):
512 load_func = lambda x: csb.io.load(x, gzip=True)
513 dump_func = lambda x, y: csb.io.dump(x, y, gzip=False)
514 with self.assertRaises(IOError):
515 self._test(load_func, dump_func)
516
517 def testLock(self):
518 load_func = lambda x: csb.io.load(x, lock=True)
519 dump_func = lambda x, y: csb.io.dump(x, y, lock=True)
520 self._test(load_func, dump_func)
521
522 def testLockGzip(self):
523 load_func = lambda x: csb.io.load(x, gzip=True, lock=True)
524 dump_func = lambda x, y: csb.io.dump(x, y, gzip=True, lock=True)
525 self._test(load_func, dump_func)
526
527 def testRecusionLimit(self):
528 with self.assertRaises(RuntimeError):
529 with csb.io.TempFile(mode='b') as temp:
530 csb.io.dump(self.big_graph, temp.name)
531
532 def _test(self, load_func, dump_func):
533 for ob in self.objs:
534 with csb.io.TempFile(mode='b') as temp:
535 dump_func(ob, temp.name)
536 ob2 = load_func(temp.name)
537 if isinstance(ob, list):
538 for a, b in zip(ob2, ob):
539 if isinstance(a, numpy.ndarray):
540 self.assertTrue(numpy.all(a == b))
541 else:
542 self.assertEqual(a, b)
543 elif isinstance(ob, csb.bio.structure.Structure):
544 self.assertEqual(ob.to_fasta(),
545 ob2.to_fasta())
546 self.assertTrue(numpy.all(ob.get_coordinates()
547 == ob2.get_coordinates()))
548 else:
549 self.assertEqual(ob, ob2)
550
551
552 if __name__ == '__main__':
553
554 test.Console()