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')
