def test_bond_span_range_disulfide(self): """Test bond_span_range argument with disulfides""" env = self.get_environ() mdl = Model(env) mdl.read('1HEL.pdb') aln = Alignment(env) aln.append_model(mdl, align_codes='test') mlib = self.get_mdt_library() mlib.bond_classes.read('data/bndgrp.lib') dist = mdt.features.AtomDistance(mlib, bins=mdt.uniform_bins(60, 0, 0.5)) # Four disulfide bond in this structure m = mdt.Table(mlib, features=dist) m.add_alignment(aln, bond_span_range=(1, 1), residue_span_range=(-9999, 0, 0, 9999)) m2 = mdt.Table(mlib, features=dist) m2.add_alignment(aln, bond_span_range=(1, 1), residue_span_range=(-9999, 0, 0, 9999), disulfide=True) self.assertEqual(m2.sample_size - m.sample_size, 4.0) m = mdt.Table(mlib, features=dist) m.add_alignment(aln, bond_span_range=(3, 3), residue_span_range=(-9999, 0, 0, 9999)) m2 = mdt.Table(mlib, features=dist) m2.add_alignment(aln, bond_span_range=(3, 3), residue_span_range=(-9999, 0, 0, 9999), disulfide=True) self.assertEqual(m2.sample_size - m.sample_size, 12.0)
def test_chain_span_range(self): """Test chain_span_range argument""" env = self.get_environ() mdl = Model(env) mdl.build_sequence('G/G') aln = Alignment(env) aln.append_model(mdl, align_codes='test') mlib = self.get_mdt_library() mlib.tuple_classes.read('data/dblcls.lib') tuple_dist = mdt.features.TupleDistance(mlib, bins=mdt.uniform_bins( 49, 2.0, 0.2)) # All chain differences should be out of range, so this MDT should # end up empty: m = mdt.Table(mlib, features=tuple_dist) m.add_alignment(aln, chain_span_range=(-999, -999, 999, 999), residue_span_range=(-999, 0, 0, 999)) self.assertEqual(m.sum(), 0.0) # Default chain separation should allow intra-chain interactions, so # should yield more (56) than only allowing inter-chain # interactions (32) m = mdt.Table(mlib, features=tuple_dist) m.add_alignment(aln, residue_span_range=(-999, 0, 0, 999)) self.assertEqual(m.sum(), 56.0) m = mdt.Table(mlib, features=tuple_dist) m.add_alignment(aln, chain_span_range=(-999, -1, 1, 999), residue_span_range=(-999, 0, 0, 999)) self.assertEqual(m.sum(), 32.0)
def test_disulfide(self): """Test handling of disulfide bonds""" mlib = self.get_all_libraries() bsep = mdt.features.AtomBondSeparation(mlib, bins=mdt.uniform_bins( 20, 0, 1.0)) bsep_ss = mdt.features.AtomBondSeparation(mlib, bins=mdt.uniform_bins( 20, 0, 1.0), disulfide=True) env = self.get_environ() mdl = modeller.Model(env) mdl.build_sequence('CC') # When SG-SG distance is small enough, an extra bond # (separation feature = 1) should be detected, but only with # disulfide=True for (dist, num) in [(2.6, 11.0), (2.4, 12.0)]: sg1 = mdl.residues[0].atoms['SG'] sg2 = mdl.residues[1].atoms['SG'] sg1.x = sg1.y = sg1.z = 0. sg2.x = sg2.y = 0. sg2.z = dist a = modeller.Alignment(env) a.append_model(mdl, atom_files='test', align_codes='test') m = mdt.Table(mlib, features=bsep) m.add_alignment(a, residue_span_range=(-999, 0, 0, 999)) self.assertEqual(m[1], 11.0) m2 = mdt.Table(mlib, features=bsep_ss) m2.add_alignment(a, residue_span_range=(-999, 0, 0, 999)) self.assertEqual(m2[1], num)
def test_integrate(self): """Make sure MDT integration works""" env = self.get_environ() mlib = self.get_mdt_library() restyp0 = mdt.features.ResidueType(mlib, protein=0) restyp1 = mdt.features.ResidueType(mlib, protein=1) chi1 = mdt.features.Chi1Dihedral(mlib, mdt.uniform_bins(36, -180, 10)) m1 = mdt.Table(mlib, features=restyp0) m2 = mdt.Table(mlib, features=restyp1) mboth = mdt.Table(mlib, features=(restyp0, restyp1)) seq1 = "AFVVTDNCIK" seq2 = "DCVEVCPVDC" aln = Alignment(env) aln.append_sequence(seq1) aln.append_sequence(seq2) for m in (m1, m2, mboth): m.add_alignment(aln) # Number of features must be correct: for features in ((), (restyp0, restyp1), (restyp0, restyp1, chi1)): self.assertRaises(ValueError, mboth.integrate, features=features) # Features must exist in input MDT: self.assertRaises(ValueError, mboth.integrate, features=chi1) m1int = mboth.integrate(features=restyp0) self.assertMDTsEqual(m1, m1int) m2int = mboth.integrate(features=restyp1) self.assertMDTsEqual(m2, m2int)
def test_add(self): """Check adding MDTs""" mlib = self.get_mdt_library() bins = mdt.uniform_bins(3, -1.0, 1.5) xray0 = mdt.features.XRayResolution(mlib, bins, protein=0) xray1 = mdt.features.XRayResolution(mlib, bins, protein=1) m1 = mdt.Table(mlib, features=xray0) for (n, val) in enumerate((1, 2, 3, 4)): m1[n] = val m2 = mdt.Table(mlib, features=xray0) for (n, val) in enumerate((10, 20, 30, 40)): m2[n] = val m3 = m1 + m2 m1 += m2 self.assertMDTsEqual(m1, m3) for (n, val) in enumerate((11, 22, 33, 44)): self.assertEqual(m3[n], val) # Cannot add if numbers of features are different badmdt = mdt.Table(mlib, features=(xray0, xray1)) self.assertRaises(ValueError, m1.__add__, badmdt) # Cannot add if feature types are different badmdt = mdt.Table(mlib, features=xray1) self.assertRaises(ValueError, m1.__add__, badmdt) # Cannot add if starts are different badmdt = m2.reshape(features=xray0, offset=1, shape=0) self.assertRaises(ValueError, m1.__add__, badmdt) # Cannot add if nbins are different badmdt = m2.reshape(features=xray0, offset=0, shape=-1) self.assertRaises(ValueError, m1.__add__, badmdt)
def test_residue_span_range(self): """Test residue_span_range argument""" env = self.get_environ() aln = Alignment(env, file='test/data/tiny.ali') mlib = self.get_mdt_library() mlib.tuple_classes.read('data/dblcls.lib') tuple_dist = mdt.features.TupleDistance(mlib, bins=mdt.uniform_bins( 49, 2.0, 0.2)) # All residue-residue pairs should be out of range, so this MDT should # end up empty: m = mdt.Table(mlib, features=tuple_dist) m.add_alignment(aln, residue_span_range=(-999, -999, 999, 999)) self.assertEqual(m.sum(), 0.0) m1 = mdt.Table(mlib, features=tuple_dist) m2 = mdt.Table(mlib, features=tuple_dist) # When excluding only intra-residue interactions, the short-range # bins should differ but the long-range behavior should be the same: m1.add_alignment(aln, residue_span_range=(-999, 0, 0, 999)) m2.add_alignment(aln, residue_span_range=(-999, -1, 1, 999)) self.assertEqual(m1.shape, m2.shape) for i in range(1, 5): self.assertNotEqual(m1[i], m2[i]) for i in range(38, 49): self.assertEqual(m1[i], m2[i])
def test_bin_type(self): """Check building tables with different bin storage types""" env = self.get_environ() mlib = self.get_mdt_library() restyp0 = mdt.features.ResidueType(mlib, protein=0) restyp1 = mdt.features.ResidueType(mlib, protein=1) features = (restyp0, restyp1) aln = Alignment(env, file='test/data/alignment.ali') # bin_type must be a valid MDT BinType self.assertRaises(TypeError, mdt.Table, mlib, features=features, bin_type='garbage') m1 = mdt.Table(mlib, features=features, bin_type=mdt.Double) m1.add_alignment(aln) for bin_type in (mdt.Int8, mdt.Int16, mdt.Int32, mdt.UnsignedInt8, mdt.UnsignedInt16, mdt.UnsignedInt32, mdt.Float, mdt.Double): m2 = mdt.Table(mlib, features=features, bin_type=bin_type) m2.add_alignment(aln) m2.write_hdf5('test.hdf5') self.assertMDTsEqual(m1, m2) m3 = m1.copy(bin_type=bin_type) self.assertMDTsEqual(m1, m3) os.unlink('test.hdf5')
def test_tuple_pair_bond_span_range(self): """Test bond_span_range with tuple pair scan""" env = self.get_environ() mdl = Model(env) mdl.build_sequence('A') aln = Alignment(env) aln.append_model(mdl, align_codes='test') mlib = self.get_mdt_library() mlib.bond_classes.read('data/bndgrp.lib') mlib.tuple_classes.read('data/trpcls.lib') _ = mdt.features.TupleType(mlib) _ = mdt.features.TupleType(mlib, pos2=True) dist = mdt.features.TupleDistance(mlib, bins=mdt.uniform_bins(9, 2.0, 0.2)) m = mdt.Table(mlib, features=dist) m.add_alignment(aln, residue_span_range=(0, 0, 0, 0)) self.assertEqual(m.sample_size, 10.0) m = mdt.Table(mlib, features=dist) m.add_alignment(aln, bond_span_range=(1, 1), residue_span_range=(0, 0, 0, 0)) # Bond span should restrict interactions to 6 # (C:CA:CB-CA:C:O, CA:C:O-N:CA:C, CA:C:O-N:CA:CB, and the reverse) self.assertEqual(m.sample_size, 6.0)
def test_atom_tuple_pair_exclusions(self): """Test exclusion of atom pairs from atom tuple pair features""" env = self.get_environ() mdl = Model(env) mdl.build_sequence('GG') aln = Alignment(env) aln.append_model(mdl, align_codes='test') mlib = self.get_mdt_library() mlib.tuple_classes.read('data/trpcls.lib') mlib.bond_classes.read('data/bndgrp.lib') mlib.angle_classes.read('data/anggrp.lib') mlib.dihedral_classes.read('data/impgrp.lib') dist = mdt.features.TupleDistance(mlib, bins=mdt.uniform_bins(49, 0.0, 0.2)) m = mdt.Table(mlib, features=dist) m.add_alignment(aln, residue_span_range=(-9999, 0, 0, 9999), exclude_bonds=False) self.assertEqual(m.sample_size, 38) # Exclusions should cut number of sample points m = mdt.Table(mlib, features=dist) m.add_alignment(aln, residue_span_range=(-9999, 0, 0, 9999), exclude_bonds=True, exclude_angles=True) self.assertEqual(m.sample_size, 20)
def test_features_same_library(self): """Features must all come from the same Library""" mlib1 = self.get_mdt_library() mlib2 = self.get_mdt_library() restyp1 = mdt.features.ResidueType(mlib1, protein=0) restyp2 = mdt.features.ResidueType(mlib2, protein=1) _ = mdt.Table(mlib1, features=restyp1) _ = mdt.Table(mlib2, features=restyp2) for mlib in (mlib1, mlib2): self.assertRaises(ValueError, mdt.Table, mlib, features=(restyp1, restyp2))
def test_sources(self): """Make sure that alignments and models both work as sources""" env = self.get_environ() mlib = self.get_mdt_library() dist = mdt.features.AtomDistance(mlib, bins=mdt.uniform_bins(60, 0, 0.5)) m1 = mdt.Table(mlib, features=dist) m2 = mdt.Table(mlib, features=dist) a1 = Alignment(env, file='test/data/tiny.ali', align_codes='5fd1') m1.add_alignment(a1) mdl = Model(env, file='test/data/5fd1.atm', model_segment=('1:', '6:')) a2 = Alignment(env) # Atom file 'foo' does not exist; all data should be taken from mdl a2.append_model(mdl, align_codes='foo', atom_files='foo') m2.add_alignment(a2) self.assertMDTsEqual(m1, m2)
def test_simple_smooth(self): """Test smoothing of a simple input distribution""" mlib = self.get_mdt_library() restyp0 = mdt.features.ResidueType(mlib, protein=0) restyp1 = mdt.features.ResidueType(mlib, protein=1) m = mdt.Table(mlib, features=(restyp0, restyp1)) m[0, 0] = m[1, 1] = m[1, 2] = 1.0 m2 = m.super_smooth(dimensions=1, prior_weight=1.0, entropy_weighing=False) # Get first level distribution from all data (1,1,1,0,0,0...): w1, w2 = self._get_weights(1.0, 22, 3.0) lev1 = [w1 / 22. + w2 / 3.] * 3 + [w1 / 22.] * 19 # First row should be a combination of the apriori (level1) # distribution and the data (1,0,0,0...): w1, w2 = self._get_weights(1.0, 22, 1.0) self.assertAlmostEqual(m2[0, 0], w1 * lev1[0] + w2 * 1.0, delta=1e-5) for i in range(1, 22): self.assertAlmostEqual(m2[0, i], w1 * lev1[i], delta=1e-5) # Same deal for second row, using data (0,1,1,0,0,0...): w1, w2 = self._get_weights(1.0, 22, 2.0) for i in (1, 2): self.assertAlmostEqual(m2[1, i], w1 * lev1[i] + w2 * 0.5, delta=1e-5) for i in list(range(3, 22)) + [0]: self.assertAlmostEqual(m2[1, i], w1 * lev1[i], delta=1e-5) # Every other row is just the level1 data: for i in range(2, 22): for j in range(22): self.assertAlmostEqual(m2[i, j], lev1[j], delta=1e-5)
def test_1d_mdt(self): """Make sure a 1D MDT matches known residue data""" env = self.get_environ() mlib = self.get_mdt_library() restyp = mdt.features.ResidueType(mlib) m = mdt.Table(mlib, features=restyp) aln = Alignment(env) seq = "AFVVTDNCIKXCKYTDCVEVCPVDCFYEG" aln.append_sequence(seq) # Get known counts of all residue types (including undefined) seq_types = [self.__mdt_restyp(a) for a in seq] known_dist = [seq_types.count(n) for n in range(22)] # Now compare with that obtained by mdt.add_alignment() m.add_alignment(aln) for i in range(22): self.assertEqual(known_dist[i], int(m[i])) # Now do the same test on individually-queried indices: source = m.open_alignment(aln) bins = [ source.index(restyp, 0, n, 0, n, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) - 1 for n in range(len(seq)) ] bin_dist = [bins.count(n) for n in range(22)] self.assertEqual(bin_dist, known_dist) # source.sum() should return each sample nsample times, so it should be # equal to the sum of the squares: self.assertEqual(source.sum(), sum([i * i for i in known_dist]))
def get_test_mdt(self, mlib, features): """Build a simple test MDT""" env = self.get_environ() m = mdt.Table(mlib, features=features) aln = modeller.Alignment(env, file='test/data/alignment.ali') m.add_alignment(aln) return m
def test_clear(self): """Check Table.clear()""" mlib = self.get_mdt_library() restyp = mdt.features.ResidueType(mlib) t = mdt.Table(mlib, features=restyp) t[0] = 5 t.clear() self.assertEqual(t[0], 0)
def test_make_shape(self): """Test Table.make() with shape""" mlib = self.get_mdt_library() restyp = mdt.features.ResidueType(mlib) for shape in [[0, 0], [-22], [23]]: self.assertRaises(ValueError, mdt.Table, mlib, features=restyp, shape=shape) for shape in [[], [0], [22]]: t = mdt.Table(mlib, features=restyp, shape=shape) self.assertEqual(t.shape, (22, )) t = mdt.Table(mlib, features=restyp, shape=[10]) self.assertEqual(t.shape, (10, )) t = mdt.Table(mlib, features=restyp, shape=[-4]) self.assertEqual(t.shape, (18, ))
def test_save_reshape(self): """Check that we can correctly load and save reshaped MDTs""" mlib = self.get_mdt_library() restyp0 = mdt.features.ResidueType(mlib, protein=0) restyp1 = mdt.features.ResidueType(mlib, protein=1) m = self.get_test_mdt(mlib, features=(restyp0, restyp1)) m = m.reshape(features=(restyp0, restyp1), offset=(4, 2), shape=(11, 10)) m.write('test.mdt') m.write_hdf5('test.hdf5') m2 = mdt.Table(mlib, 'test.mdt') self.assertMDTsEqual(m, m2) m2 = mdt.Table(mlib, 'test.hdf5') self.assertMDTsEqual(m, m2) os.unlink('test.mdt') os.unlink('test.hdf5')
def test_empty_aln(self): """Make sure that adding an empty alignment works OK""" env = self.get_environ() mlib = self.get_mdt_library() restyp = mdt.features.ResidueType(mlib) bondtype = mdt.features.BondType(mlib) m = mdt.Table(mlib, features=(restyp, bondtype)) aln = Alignment(env) self.assertRaises(mdt.MDTError, m.add_alignment, aln)
def test_features_to_ifeat(self): """Test Table._features_to_ifeat method""" mlib = self.get_mdt_library() f = mdt.features.ResidueType(mlib) m = mdt.Table(mlib, features=f) for arg in [f, [f], (f, )]: ifeat = m._features_to_ifeat(arg) self.assertEqual(ifeat, [1]) self.assertRaises(TypeError, m._features_to_ifeat, 'garbage')
def get_feature_names(self): if len(self.fclist)>1: raise Exception('we can only get feature names for single feature') fl=self.get_featurelist() m=mdt.Table(self.mlib,features=fl) sl=[] for bin in m.features[0].bins: sl.append(bin.symbol) return sl
def test_entropy_full(self): """Test entropy_full()""" mlib = self.get_mdt_library() restyp = mdt.features.ResidueType(mlib) chi1 = mdt.features.Chi1Dihedral(mlib, mdt.uniform_bins(36, -180, 10)) m = self.get_test_mdt(mlib, features=(restyp, chi1)) m.entropy_full() # Empty table should give an error empty = mdt.Table(mlib, features=(restyp, chi1)) self.assertRaises(mdt.MDTError, empty.entropy_full)
def get_test_mdt(self, mlib, features): env = self.get_environ() mdl = modeller.Model(env) mdl.build_sequence('C') m = mdt.Table(mlib, features=features) a = modeller.Alignment(env) a.append_model(mdl, atom_files='test', align_codes='test') m.add_alignment(a) m = m.reshape(features, [0] * len(features), [-1] * len(features)) return m
def build_mdt_from_sequence(self, mlib, features, seq, **keys): """Build a simple test MDT for a given sequence""" env = self.get_environ() mdl = modeller.Model(env) mdl.build_sequence(seq) m = mdt.Table(mlib, features=features) a = modeller.Alignment(env) a.append_model(mdl, atom_files='test', align_codes='test') m.add_alignment(a, **keys) return m
def test_dimensions(self): """Check acceptable values for dimensions for super_smooth""" mlib = self.get_mdt_library() restyp0 = mdt.features.ResidueType(mlib, protein=0) restyp1 = mdt.features.ResidueType(mlib, protein=1) chi1 = mdt.features.Chi1Dihedral(mlib, mdt.uniform_bins(36, -180, 10)) m = mdt.Table(mlib, features=(restyp0, restyp1, chi1)) for dimensions in (1, 2): _ = m.super_smooth(dimensions, 1.0, True) for dimensions in (-1, 0, 3, 4): self.assertRaises(ValueError, m.super_smooth, dimensions, 1.0, True)
def test_entropy_hx(self): """Check for expected dependent entropy value""" mlib = self.get_mdt_library() restyp = mdt.features.ResidueType(mlib) chi1 = mdt.features.Chi1Dihedral(mlib, mdt.uniform_bins(36, -180, 10)) m = self.get_test_mdt(mlib, features=(restyp, chi1)) # Check against ENTROPY_MDT_HX value for this system in MDT: self.assertAlmostEqual(m.entropy_hx(), 2.7048, places=3) # Empty table should give an error empty = mdt.Table(mlib, features=(restyp, chi1)) self.assertRaises(mdt.MDTError, empty.entropy_hx)
def test_triple_protein_scan(self): """Test scan of triples of proteins""" env = self.get_environ() mlib = self.get_mdt_library() a = Alignment(env, file='test/data/resol.ali', align_codes=('bin1', 'bin2', 'undef2')) f1 = mdt.features.XRayResolution(mlib, mdt.uniform_bins(5, 0, 1.0), protein=0) f2 = mdt.features.XRayResolution(mlib, mdt.uniform_bins(5, 0, 1.0), protein=1) f3 = mdt.features.XRayResolution(mlib, mdt.uniform_bins(5, 0, 1.0), protein=2) # When we have features that cover proteins 0,1,2, triple scan should # be forced; different number of samples for symmetric/non-symmetric for (sym, size) in ((False, 6.0), (True, 3.0)): t = mdt.Table(mlib, features=(f1, f2, f3)) t.add_alignment(a, symtriples=sym) self.assertAlmostEqual(t.sample_size, size, delta=1e-6) # When feature only covers some of the proteins, triplet scan does # not occur. for sym in (True, False): t = mdt.Table(mlib, features=f3) t.add_alignment(a, symtriples=sym) self.assertAlmostEqual(t.sample_size, 3.0, delta=1e-6) # Exercise residue pair features in combination with triplet scans ri = mdt.features.ResidueIndexDifference(mlib, mdt.uniform_bins(5, 0, 1.0), protein=2) t = mdt.Table(mlib, features=(f1, f2, ri)) t.add_alignment(a, symtriples=sym) self.assertAlmostEqual(t.sample_size, 12, delta=1e-6)
def test_empty_2d(self): """Super-smoothed empty 2D MDT should be the even distribution""" mlib = self.get_mdt_library() restyp0 = mdt.features.ResidueType(mlib, protein=0) restyp1 = mdt.features.ResidueType(mlib, protein=1) m = mdt.Table(mlib, features=(restyp0, restyp1)) # A super-smoothed empty MDT should be the even distribution, # i.e. weight/nbin, for any value of the prior weight: for weight in (1.0, 2.0, 0.0): m2 = m.super_smooth(1, weight, True) inds = [] while self.roll_inds(inds, m.shape, m.offset): self.assertAlmostEqual(1. / 22., m2[inds], places=3)
def test_reshape_distancemdt(self): """Check that reshaping distance mdt produces the table correctly""" env = self.get_environ() mlib = self.get_mdt_library() dist = mdt.features.AtomDistance(mlib, bins=mdt.uniform_bins(30, 0, 0.5)) aln = Alignment(env, file='test/data/alignment.ali', align_codes='5fd1') m1 = mdt.Table(mlib, features=dist) m1.reshape(dist, [0], [-1]) m1.add_alignment(aln, residue_span_range=(-999, -1, 1, 999)) self.assertEqual(m1[29], 10014.0) self.assertAlmostEqual(m1[28], 9758.5, delta=0.6)
def test_section_bins(self): """Test checks of section bin indices""" import _mdt mlib = self.get_mdt_library() restyp = mdt.features.ResidueType(mlib) chi1 = mdt.features.Chi1Dihedral(mlib, mdt.uniform_bins(36, -180, 10)) m = mdt.Table(mlib, features=(restyp, chi1)) self.assertRaises(ValueError, _mdt.mdt_section_sum, m._basept, [0, 0, 0]) self.assertRaises(IndexError, _mdt.mdt_section_sum, m._basept, [22]) self.assertRaises(IndexError, _mdt.mdt_section_entropy, m._basept, [22]) self.assertRaises(IndexError, _mdt.mdt_section_meanstdev, m._basept, mlib._modpt, [22])
def test_mdt_formats(self): """Make sure we can read and write MDT files""" env = self.get_environ() mlib = self.get_mdt_library() restyp0 = mdt.features.ResidueType(mlib, protein=0) restyp1 = mdt.features.ResidueType(mlib, protein=1) m = mdt.Table(mlib, features=(restyp0, restyp1)) aln = Alignment(env) aln.append_sequence('AFVVTDNCIKCKYTDCVEVXPVDCFYEG') aln.append_sequence('CVEVCPVDCFYEGAFVVTDNCIKCKYTX') m.add_alignment(aln) m.write('test.mdt') self.assertRaises(IOError, m.write, '/does/not/exist/foo.mdt') m2 = m.copy() self.assertMDTsEqual(m, m2) m2 = mdt.Table(mlib, file='test.mdt') self.assertMDTsEqual(m, m2) m.write_hdf5('test.hdf5') m.write_hdf5('test.hdf5', gzip=True) m.write_hdf5('test.hdf5', gzip=4) self.assertRaises(ValueError, m.write_hdf5, 'test.hdf5', gzip=True, chunk_size=(2, 3, 4)) m.write_hdf5('test.hdf5', gzip=9, chunk_size=(4, 4)) self.assertRaises(mdt.MDTError, m.write_hdf5, '/does/not/exist/foo.hdf5') m2 = mdt.Table(mlib, file='test.hdf5') self.assertMDTsEqual(m, m2) m2 = mdt.Table(mlib) # Trying to read an HDF5 file in text format should fail gracefully: self.assertRaises(mdt.MDTError, m2.read, 'test.hdf5') # Same problem should occur starting with a non-empty MDT: m2 = mdt.Table(mlib, features=(restyp0, restyp1)) self.assertRaises(mdt.MDTError, m2.read, 'test.hdf5') os.unlink('test.hdf5')