def test_ligand_removal(self):
"""Should remove RNA ligand from 3FU2 when there is no ribose and phosphate group."""
st2 = ModernaStructure('file', PDB_WITH_LIGAND)
pc2 = PdbController(st2)
self.assertEqual(st2.get_sequence(), Sequence('AGAGGUUCUAG_._CACCCUCUAUAAAAAACUAA_x_._._._._._._._._._._._._.'))
pc2.clean_structure()
self.assertEqual(st2.get_sequence(), Sequence('AGAGGUUCUAG_CACCCUCUAUAAAAAACUAA'))
def test_missing_phosphates2(self):
"""Messy residues with missing phosphates are not delted."""
st2 = ModernaStructure('file', MISSING_PHOSPHATES2)
pc = PdbController(st2)
self.assertEqual(st2.get_sequence(), Sequence('C_C_G_A_C_C_U_U_C_G_G_C_C_A_C_C_U_G'))
pc.clean_structure()
self.assertEqual(st2.get_sequence(), Sequence('CCGACCUUCGGCCACC_UG'))
def test_AMP_detection_and_removal(self):
"""Should detect AMP in the structure and remove it while cleaning."""
st4 = ModernaStructure('file', PDB_WITH_AMP)
self.assertEqual(st4.get_sequence(), Sequence('GGGAAGGGAAGAAACUGCGGCUUCGGCCGGCUUCCC_H'))
pc4 = PdbController(st4)
self.assertEqual(len(pc4.rna_ligand), 1)
pc4.clean_structure()
self.assertEqual(len(pc4.rna_ligand), 0)
self.assertEqual(st4.get_sequence(), Sequence('GGGAAGGGAAGAAACUGCGGCUUCGGCCGGCUUCCC'))
def test_missing_phosphates(self):
"""residues with missing phosphates are fixed."""
st2 = ModernaStructure('file', MISSING_PHOSPHATES)
pc = PdbController(st2)
self.assertEqual(len(pc.P_missing), 2)
self.assertEqual(st2.get_sequence(), Sequence('GCG_GAUUUALCUCAG'))
pc.clean_structure()
self.assertEqual(st2.get_sequence(), Sequence('GCG_GAUUUALCUCAG'))
pc = PdbController(st2)
self.assertEqual(len(pc.P_missing), 0)
def test_bad_insertion(self):
"""Should fix at least some breaks in a disastrous case"""
struc = ModernaStructure('file', BAD_LOOP_INSERTION)
breaks_before = str(struc.get_sequence()).count('_')
self.assertEqual(breaks_before, 3)
prev = None
for resi in struc:
if prev:
bb = BackboneBuilder(prev, resi, struc)
prev = resi
breaks_after = str(struc.get_sequence()).count('_')
self.assertTrue(breaks_after < breaks_before)
def get_structure(self, name, chain='A'):
"""Returns a ModernaStructure object from a PDB file."""
key = (name, chain)
if self.structures.has_key(key):
seq = self.sequences[key]
struc = ModernaStructure('file',
self.path + name,
chain,
seq,
new_atoms=False)
# KR: the following lines are SLOWER
#struc = self.structures[key]
#struc = ModernaStructure('residues', [r for r in struc], seq)
else:
seq = self.sequences.get(key, None)
struc = ModernaStructure('file',
self.path + name,
chain,
seq,
new_atoms=False)
seq = struc.get_sequence()
self.structures[key] = struc
self.sequences[key] = seq
struc = ModernaStructure('residues',
[r for r in self.structures[key]], seq)
return struc
def test_change_sequence(self):
"""Checks whether sequence is changed into given by user"""
m = ModernaStructure('file', MINI_TEMPLATE) #residues_mixed.ent')
m.change_sequence('UUUUUUUUUUUUUUU')
self.assertEqual(m.get_sequence(), Sequence('UUUUUUUUUUUUUUU'))
self.assertRaises(ModernaStructureError, m.change_sequence, 'AAAAA')
m.change_sequence('GGGG', '1', '4')
self.assertEqual(m.get_sequence(), Sequence('GGGGUUUUUUUUUUU'))
m.change_sequence('AAAA', '12')
self.assertEqual(m.get_sequence(), Sequence('GGGGUUUUUUUAAAA'))
m.change_sequence('CC', None, '2')
self.assertEqual(m.get_sequence(), Sequence('CCGGUUUUUUUAAAA'))
m.change_sequence(Sequence('UUUUUUUUUUUUUUU'))
self.assertEqual(m.get_sequence(), Sequence('UUUUUUUUUUUUUUU'))
unk = load_model(PDB_UNK)
unk.change_sequence('DAAAPAEA?A7A')
self.assertEqual(unk.get_sequence(), Sequence('DAAAPAEA?A7A'))
def setUp(self):
t = ModernaStructure('file', MINI_TEMPLATE)
self.ga = GeometryAnalyzer(t)
t = ModernaStructure('file',
BAD_TEMPLATE,
chain_name='A',
seq=t.get_sequence())
self.bad_ga = GeometryAnalyzer(t)
def test_create_long_fragment(self):
"""Fragments with 26+ residues should be OK."""
t = load_template(RNA_1C0A, 'B')
resis = t['5':'45']
long_seq = Sequence("AUAUAUAUAUGCGCGCGCGCAUAUAUAUAUGCGCGCGCG")
struc = ModernaStructure('residues', resis)
frag = ModernaFragment53(struc, anchor5=t['5'],anchor3=t['45'], new_sequence=long_seq)
frag.superimpose()
frag.prepare_anchor_residues()
frag.renumber()
frag.apply_seq()
self.assertEqual(struc.get_sequence(), Sequence("CAUAUAUAUAUGCGCGCGCGCAUAUAUAUAUGCGCGCGCGG"))
class CheckPdbTests(TestCase):
def setUp(self):
self.st = ModernaStructure('file', NASTY_PDB)
self.pc = PdbController(self.st)
def test_ions_detection(self):
self.assertEqual(len(self.pc.ions), 9)
def test_water_detection(self):
self.assertEqual(len(self.pc.water), 160)
def test_unidentifiedRNA_detection(self):
self.assertEqual(len(self.pc.unidentified_rna), 1)
def test_stars_detection(self):
self.assertTrue(self.pc.stars)
def test_O1P_detection(self):
self.assertTrue(self.pc.OP)
def test_clean_structure(self):
self.pc.clean_structure()
self.assertEqual(len(self.pc.ions), 0)
self.assertEqual(len(self.pc.ions), 0)
self.assertEqual(len(self.pc.unidentified_rna), 1)
self.assertEqual(len(self.pc.P_missing), 0)
def test_clean_structure_in_struc(self):
self.assertEqual(
self.st.get_sequence(),
Sequence(
'G_C_GGAU.UALCUCAGDDGGGAGAGCRCCAGABU#AAYAP?UGGAG7UC?UGUGTPCG"UCCACAGAAUUCGCACCA_._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._._.'
))
self.pc.clean_structure()
self.assertEqual(
self.st.get_sequence(),
Sequence(
'GCGGAU.UALCUCAGDDGGGAGAGCRCCAGABU#AAYAP?UGGAG7UC?UGUGTPCG"UCCACAGAAUUCGCACCA'
))
def test_add_missing_p(self):
"""Identifies residues with P missing"""
self.assertEqual(len(self.pc.P_missing), 1)
self.assertEqual(self.pc.P_missing[0].identifier, '1')
def test_atom_names(self):
"""Names of O1P, C1* etc should be fixed properly."""
self.pc.clean_structure()
at1 = self.st['2']["C1'"]
self.assertEqual(at1.name, "C1'")
self.assertEqual(at1.fullname, " C1'")
at2 = self.st['4']["OP1"]
self.assertEqual(at2.name, "OP1")
self.assertEqual(at2.fullname, " OP1")
at3 = self.st['2']["O5'"]
self.assertEqual(at3.name, "O5'")
self.assertEqual(at3.fullname, " O5'")
def test_missing_phosphates(self):
"""residues with missing phosphates are fixed."""
st2 = ModernaStructure('file', MISSING_PHOSPHATES)
pc = PdbController(st2)
self.assertEqual(len(pc.P_missing), 2)
self.assertEqual(st2.get_sequence(), Sequence('GCG_GAUUUALCUCAG'))
pc.clean_structure()
self.assertEqual(st2.get_sequence(), Sequence('GCG_GAUUUALCUCAG'))
pc = PdbController(st2)
self.assertEqual(len(pc.P_missing), 0)
def test_missing_phosphates2(self):
"""Messy residues with missing phosphates are not delted."""
st2 = ModernaStructure('file', MISSING_PHOSPHATES2)
pc = PdbController(st2)
self.assertEqual(st2.get_sequence(),
Sequence('C_C_G_A_C_C_U_U_C_G_G_C_C_A_C_C_U_G'))
pc.clean_structure()
self.assertEqual(st2.get_sequence(), Sequence('CCGACCUUCGGCCACC_UG'))
def test_ligand_removal(self):
"""Should remove RNA ligand from 3FU2 when there is no ribose and phosphate group."""
st2 = ModernaStructure('file', PDB_WITH_LIGAND)
pc2 = PdbController(st2)
self.assertEqual(
st2.get_sequence(),
Sequence(
'AGAGGUUCUAG_._CACCCUCUAUAAAAAACUAA_x_._._._._._._._._._._._._.'
))
pc2.clean_structure()
self.assertEqual(st2.get_sequence(),
Sequence('AGAGGUUCUAG_CACCCUCUAUAAAAAACUAA'))
def test_double_coordinates_identification(self):
"""Should remove RNA ligand when there is no ribose and phosphate group."""
st3 = ModernaStructure('file', PDB_WITH_DOUBLE_COORDINATES)
pc3 = PdbController(st3)
self.assertEqual(len(pc3.disordered), 3)
pc3.clean_structure()
self.assertEqual(len(pc3.disordered), 3)
def test_AMP_detection_and_removal(self):
"""Should detect AMP in the structure and remove it while cleaning."""
st4 = ModernaStructure('file', PDB_WITH_AMP)
self.assertEqual(st4.get_sequence(),
Sequence('GGGAAGGGAAGAAACUGCGGCUUCGGCCGGCUUCCC_H'))
pc4 = PdbController(st4)
self.assertEqual(len(pc4.rna_ligand), 1)
pc4.clean_structure()
self.assertEqual(len(pc4.rna_ligand), 0)
self.assertEqual(st4.get_sequence(),
Sequence('GGGAAGGGAAGAAACUGCGGCUUCGGCCGGCUUCCC'))
def test_phosphate_detection_and_removal(self):
"""Should detect pfosphate group (P, OP1, OP2, O5') in 3FU2 (resi 12) and remove it."""
st5 = ModernaStructure('file', PDB_WITH_PHOSPHATE)
pc5 = PdbController(st5)
self.assertEqual(len(pc5.phosphate), 1)
pc5.clean_structure()
self.assertEqual(len(pc5.phosphate), 0)
def test_double_coordinates(self):
"""Disordered residues should be recognized only when they have double coordinates."""
st6 = ModernaStructure('file', PDB_WITHOUT_DOUBLE_COORD)
pc6 = PdbController(st6)
self.assertEqual(len(pc6.disordered), 0)
class ModernaFragmentTests(TestCase):
def setUp(self):
self.s1 = ModernaStructure('file',
SMALL_FRAGMENT,
seq=Sequence("GCGG"))
self.s2 = ModernaStructure('file',
SMALL_FRAGMENT,
seq=Sequence("GCGG"))
self.s3 = ModernaStructure('file',
MINI_TEMPLATE,
seq=Sequence("GCGGAUUUALCUCAG"))
def test_init(self):
"""Should have ModernaStructure as an attribute."""
f1 = ModernaFragment(self.s1)
self.assertEqual(f1.struc.get_sequence(), Sequence('GCGG'))
def test_attributes(self):
"""object attributes should have been set up correctly."""
f1 = ModernaFragment(self.s1)
f2 = ModernaFragment(self.s2, new_sequence=Sequence('GCLG'))
modfrag = ModernaFragment(self.s3,
new_sequence=Sequence('GL7L7L7ULL7L7AG'))
self.assertEqual(len(modfrag.struc), 15)
self.assertEqual(f1.struc.get_sequence(), Sequence("GCGG"))
self.assertEqual(f2.struc.get_sequence(), Sequence("GCGG"))
self.assertTrue(str(f1))
def test_anchor_residues(self):
"""Abstract superclass should have no anchors yet."""
f1 = ModernaFragment(self.s1)
self.assertEqual(f1.anchor_residues, [])
def test_nonanchor_residues(self):
"""Stems defined in subclasses, thus should return all residues."""
f1 = ModernaFragment(self.s1)
self.assertEqual(len(f1.nonanchor_residues), 4)
def test_superimpose(self):
"""Should just exist as an abstract method."""
f1 = ModernaFragment(self.s1)
self.assertRaises(ModernaSuperimposerError, f1.superimpose)
def test_prepare_anchor_residues(self):
"""Should exist as an abstract method."""
f1 = ModernaFragment(self.s1)
self.assertRaises(ModernaSuperimposerError, f1.prepare_anchor_residues)
def test_renumber(self):
"""Should exist as an abstract method."""
f1 = ModernaFragment(self.s1)
f1.renumber()
self.assertEqual([r.identifier for r in self.s1],
['1A', '1B', '1C', '1D'])
def test_abstract_methods(self):
"""Some placeholder methods should be there."""
f1 = ModernaFragment(self.s1)
f1.get_resi_to_remove(self.s2)
f1.fix_backbone()
def test_has_clashes(self):
f1 = ModernaFragment(self.s1)
clashes = f1.has_clashes(list(self.s2))
self.assertEqual(len(clashes), 8)
struc = ModernaStructure('file', FRAGMENT1)
clashes = f1.has_clashes(list(struc))
self.assertEqual(len(clashes), 0)
def test_apply_sequence(self):
"""Should change the sequence of the entire fragment."""
frag = ModernaFragment(self.s1, new_sequence=Sequence('AAAA'))
frag.apply_seq()
self.assertEqual(self.s1.get_sequence(), Sequence('AAAA'))
# test lengths that do not fit
frag = ModernaFragment(self.s2, new_sequence=Sequence('AAA'))
self.assertRaises(ModernaFragmentError, frag.apply_seq)
frag = ModernaFragment(self.s2, new_sequence=Sequence('AAAAA'))
self.assertRaises(ModernaFragmentError, frag.apply_seq)
def test_apply_sequence_modified(self):
"""Applying a sequence with modifications should work."""
f2 = ModernaFragment(self.s2, new_sequence=Sequence('GCLG'))
f2.apply_seq()
self.assertEqual(self.s2.get_sequence(), Sequence("GCLG"))
modfrag = ModernaFragment(self.s3,
new_sequence=Sequence('GL7L7L7ULL7L7AG'))
modfrag.apply_seq()
self.assertEqual(self.s3.get_sequence(), Sequence('GL7L7L7ULL7L7AG'))
def test_broken_fragment_fail(self):
"""Chain breaks and unknown residues cause errors."""
broken = ModernaStructure('file', BROKEN_FRAGMENT)
self.assertRaises(ModernaFragmentError, ModernaFragment, broken)
unknown = ModernaStructure('file', UNKNOWN_FRAGMENT)
self.assertRaises(ModernaFragmentError, ModernaFragment, unknown)
class ModernaFragment53Tests(TestCase):
"""
Checks basic functionality of the ModernaFragment class.
"""
def setUp(self):
self.m = RnaModel(data_type='file',
data=MINI_TEMPLATE,
seq=Sequence("GCGGAUUUALCUCAG"))
self.s1 = ModernaStructure('file',
SMALL_FRAGMENT,
seq=Sequence("GCGG"))
self.s2 = ModernaStructure('file',
SMALL_FRAGMENT,
seq=Sequence("GCGG"))
self.s3 = ModernaStructure('file',
MINI_TEMPLATE,
seq=Sequence("GCGGAUUUALCUCAG"))
def test_attributes(self):
"""object attributes are set up correctly."""
f1 = ModernaFragment53(self.s1,
anchor5=self.m['10'],
anchor3=self.m['13'])
self.assertEqual(len(f1.struc), 4)
self.assertEqual(f1.anchor5.fixed_resi, self.m['10'])
self.assertEqual(f1.anchor3.fixed_resi, self.m['13'])
self.assertEqual(f1.struc.get_sequence(), Sequence("GCGG"))
self.assertTrue(str(f1))
# anchor residues
self.assertEqual(len(f1.anchor_residues), 2)
self.assertEqual(f1.anchor_residues[0].mobile_resi.identifier, '1')
self.assertEqual(f1.anchor_residues[1].mobile_resi.identifier, '4')
f1.prepare_anchor_residues()
self.assertEqual(f1.anchor_residues[0].mobile_resi.identifier, '1')
self.assertEqual(f1.anchor_residues[1].mobile_resi.identifier, '4')
# non-anchors
self.assertEqual(len(f1.nonanchor_residues), 2)
# second example
f2 = ModernaFragment53(self.s2,
anchor5=self.m['1'],
anchor3=self.m['4'],
new_sequence=Sequence('GL'))
self.assertEqual(len(f2.struc), 4)
self.assertEqual(f2.struc.get_sequence(), Sequence("GCGG"))
self.assertEqual(f2.new_sequence, Sequence("GL"))
def test_get_resi_to_remove(self):
"""Should return resi identifiers between anchors and of anchors itself."""
f1 = ModernaFragment53(self.s1,
anchor5=self.m['10'],
anchor3=self.m['13'])
result = f1.get_resi_to_remove(self.m)
self.assertEqual(result, ['10', '11', '12', '13'])
def test_renumber(self):
"""New numbering should start at anchor5, and then go through alphabet."""
f1 = ModernaFragment53(self.s1,
anchor5=self.m['10'],
anchor3=self.m['13'])
f1.prepare_anchor_residues()
f1.renumber()
self.assertEqual([r.identifier for r in self.s1],
['10', '10A', '10B', '13'])
# second example
f2 = ModernaFragment53(self.s2,
anchor5=self.m['1'],
anchor3=self.m['4'],
new_sequence=Sequence('GL'))
f2.prepare_anchor_residues()
f2.renumber()
self.assertEqual([r.identifier for r in self.s2],
['1', '1A', '1B', '4'])
def test_superimpose_fragment(self):
"""Should apply superimposition and return RMSD"""
f1 = ModernaFragment53(self.s1,
anchor5=self.m['10'],
anchor3=self.m['13'])
rmsd = f1.superimpose()
self.assertAlmostEqual(rmsd, 1.0, 0) # MM: ? 1.1253267913922658
# second fragment should fit perfectly
f2 = ModernaFragment53(self.s2,
anchor5=self.m['1'],
anchor3=self.m['4'],
new_sequence=Sequence('GL'))
rmsd = f2.superimpose()
self.assertAlmostEqual(rmsd, 0.00)
def test_refine(self):
"""Should change both numbers and sequence, and superimpose."""
f2 = ModernaFragment53(self.s2,
anchor5=self.m['1'],
anchor3=self.m['4'],
new_sequence=Sequence('GL'))
f2.superimpose()
f2.prepare_anchor_residues()
f2.renumber()
f2.apply_seq()
numbers = [r.identifier for r in self.s2]
self.assertEqual(numbers, ['1', '1A', '1B', '4'])
self.assertEqual(self.s2.get_sequence(), Sequence('GGLG'))
def test_clash(self):
"""Should not clash with a given piece of structure."""
f1 = ModernaFragment53(self.s1,
anchor5=self.m['10'],
anchor3=self.m['13'])
self.assertFalse(f1.has_clashes(self.m['8':'10']))
f2 = ModernaFragment53(self.s2,
anchor5=self.m['1'],
anchor3=self.m['4'],
new_sequence=Sequence('GL'))
self.assertTrue(f2.has_clashes(self.m['1':'4']))
def test_create_long_fragment(self):
"""Fragments with 26+ residues should be OK."""
t = load_template(RNA_1C0A, 'B')
resis = t['5':'45']
long_seq = Sequence("AUAUAUAUAUGCGCGCGCGCAUAUAUAUAUGCGCGCGCG")
struc = ModernaStructure('residues', resis)
frag = ModernaFragment53(struc,
anchor5=t['5'],
anchor3=t['45'],
new_sequence=long_seq)
frag.superimpose()
frag.prepare_anchor_residues()
frag.renumber()
frag.apply_seq()
self.assertEqual(struc.get_sequence(),
Sequence("CAUAUAUAUAUGCGCGCGCGCAUAUAUAUAUGCGCGCGCGG"))
def test_add_numbering_letters(self):
"""Model numbers should change accordingly."""
middle1 = ModernaFragment53(self.s1,
anchor5=self.m['9'],
anchor3=self.m['14'],
keep=keep_nothing)
middle1.prepare_anchor_residues()
middle1.renumber(self.m)
self.m.insert_fragment(middle1)
numbers = [r.identifier for r in self.m]
expected = [
'1', '2', '3', '4', '5', '6', '7', '8', '9', '9A', '9B', '14', '15'
]
self.assertEqual(numbers, expected)
def test_add_keep_numbers(self):
"""Model numbers should change accordingly."""
middle1 = ModernaFragment53(self.s1,
anchor5=self.m['9'],
anchor3=self.m['14'],
keep=keep_first_last)
middle1.prepare_anchor_residues()
middle1.renumber(self.m)
self.m.insert_fragment(middle1)
numbers = [r.identifier for r in self.m]
expected = [
'1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '13', '14', '15'
]
self.assertEqual(numbers, expected)
def test_add_continuous_exact(self):
"""Model sequence should change accordingly."""
f2 = ModernaFragment53(self.s2,
anchor5=self.m['1'],
anchor3=self.m['4'],
new_sequence=Sequence('GL'))
self.m.insert_fragment(f2)
self.assertEqual(self.m.get_sequence(), Sequence("GGLGAUUUALCUCAG"))
self.assertAlmostEqual(f2.rmsd, 0.000, 2)
def test_fix_backbone(self):
s = ModernaStructure('file', FIXABLE_BACKBONE)
self.assertEqual(s.get_sequence(), Sequence('ACUG_UG'))
s.fix_backbone()
self.assertEqual(s.get_sequence(), Sequence('ACUGUG'))
def test_is_connected_strict(self):
"""All backbones need to be connected between two bases."""
s = ModernaStructure('file', BROKEN_BACKBONE)
self.assertEqual(s.get_sequence(), Sequence('G_C_GG_A_U_UUALCUCAG'))
def test_cap5(self):
"""Caps in mRNA are recognized."""
struc = ModernaStructure('file', CAP_EXAMPLE, 'B')
seq = str(struc.get_sequence())
self.assertEqual(seq, 'x_GAA')
self.assertEqual(struc['900'].long_abbrev, 'm7Gpp_cap')
