def setUp(self): """ fragment attached at 5' end of model. """ 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"))
def test_add_write(self): """A modified base should be written to PDB.""" s = ModernaStructure('file', A_RESIDUE) add_modification(s['1'], 'm1A') s.write_pdb_file(OUTPUT) t = ModernaStructure('file', OUTPUT) self.assertEqual(t['1'].long_abbrev, s['1'].long_abbrev)
def __init__(self, template_data, template_data_type='file', \ template_chain_name='A', seq=None): #TODO: same order of arguments as in ModernaStructure ModernaStructure.__init__(self, data_type= template_data_type, \ data=template_data, chain_name=template_chain_name, seq=seq) self.template_residues = {} self.set_template_numeration()
def setUp(self): """Initializes class instances used for testing.""" self.rna = ModernaStructure('file', RNA_TWO_PIECES) self.example1 = ModernaStructure('file', AC_BASEPAIR, '0') self.example1_dist = ModernaStructure('file', DISTANT_AC_BASEPAIR, '0') self.ehz = ModernaStructure('file', RNA_1EHZ, 'A') self.hb = HBondCalculator()
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_fill_doublegap(self): """Should insert fragments into correct sites.""" # prepare model t = Template(DOUBLEGAP, 'file', 'A') m = RnaModel() for r in t: m.copy_residue(r) # insert first fragment struc = ModernaStructure('file', FRAGMENT1) f1 = ModernaFragment53(struc, anchor5=m['20'], anchor3=m['24'], \ new_sequence=Sequence('AUA'), keep=keep_first_last) m.insert_fragment(f1) resids = [r.identifier for r in m] expected_resids1 = [ '18', '19', '20', '21', '21A', '23', '24', '27', '28', '29', '30', '31', '32', '33', '34', '35' ] self.assertEqual(resids, expected_resids1) # insert second fragment struc = ModernaStructure('file', FRAGMENT2) f2 = ModernaFragment53(struc, anchor5=m['23'], anchor3=m['28'], \ new_sequence=Sequence('AUUA'), keep=keep_first_last) m.insert_fragment(f2) resids = [r.identifier for r in m] expected_resids2 = [ '18', '19', '20', '21', '21A', '23', '24', '24A', '24B', '27', '28', '29', '30', '31', '32', '33', '34', '35' ] self.assertEqual(resids, expected_resids2)
def test_helix(self): struc = ModernaStructure('file', BROKEN_HELIX_EXAMPLE) resi1 = struc['0Z'] resi2 = struc['1'] bb = BackboneBuilder(resi1, resi2, struc) struc.write_pdb_file('out.pdb') self.assertTrue(bb.is_intact())
def test_fccd(self): struc = ModernaStructure('file',FCCD_EXAMPLE) resi1 = struc['5'] resi2 = struc['6'] struc.remove_residue('5A') bb = BackboneBuilder(resi1, resi2, struc) self.assertTrue(bb.is_intact())
def test_clash_recognition_moderna_structure(self): """Should find clashes in ModernaStructure object""" s = ModernaStructure('file', CLASH) self.assertEqual(str(self.cr.find_clashes_in_residues(s)), \ "[(<Residue 3 G>, <Residue 4 G>)]") s = ModernaStructure('file', NOCLASH) self.assertFalse(self.cr.find_clashes_in_residues(s))
def test_renumber_residue_letter(self): s = ModernaStructure('file', MINI_TEMPLATE) self.assertTrue(s['3']) self.assertRaises(RNAChainError, s.__getitem__, '3A') s.renumber_residue('3', '3A') self.assertTrue(s['3A']) self.assertRaises(RNAChainError, s.__getitem__, '3') self.assertEqual(s['3A'].identifier, '3A')
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_get_base_pairs(self): """Calculates one canonical and two noncanonicals correctly.""" m = ModernaStructure('file', RNA_HAIRPIN, 'D') result = m.get_base_pairs() result = map(str, result['31']) self.assertTrue('31 +/+ 39' in result) self.assertTrue('31 HS 32' in result) self.assertTrue('31 SS 30' in result)
def setUp(self): """Loads the A residue to start with.""" self.struc = ModernaStructure('file', A_RESIDUE) self.adenosine = self.struc['1'] struc = ModernaStructure('file', C_RESIDUE, '0') self.cytosine = struc['494'] self.chain = PDBParser().get_structure('test_struc', MINI_TEMPLATE)[0].child_list[0] self.unk = ModernaStructure('file', PDB_UNK)
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 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"))
def test_wc_pairs_hairpin(self): """Exactly two W-C pairs in a hairpin are recognized.""" m = ModernaStructure('file', RNA_HAIRPIN, 'D') result = m.get_base_pairs() # calc number of +/+ pairs count = 0 for val in result.values(): for bpair in val: if bpair.type == '+/+': count += 1 self.assertEqual(count, 4)
def check_example(self, fn): ll = open(fn).readlines() ll = [l for l in ll if l.startswith('ATOM')] chain1 = ll[3][21] chain2 = ll[-3][21] bp1 = ModernaStructure('file', fn, chain1) bp2 = ModernaStructure('file', fn, chain2) resi1 = [r for r in bp1][0] resi2 = [r for r in bp2][-1] hbonds = self.hb.calc_hbond_list(resi1, resi2) return hbonds
def test_chain_renumbering(self): """Chain should be renumbered""" m = ModernaStructure('file', RNA_1EHZ) m.renumber_chain('100') # check residues self.assertEqual(m['100'].long_abbrev, 'G') self.assertEqual(m['107'].long_abbrev, 'U') self.assertEqual(m['109'].long_abbrev, 'm2G') self.assertEqual(m['175'].long_abbrev, 'A') self.assertEqual(m['115'].long_abbrev, 'D') self.assertRaises(RNAChainError, m.renumber_chain, '77A')
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 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_repair_congested(self): """Should avoid clashes between atoms.""" #TODO: reactivate test struc = ModernaStructure('file',BB_MESSED_UP) self.assertFalse(struc['33'].is_phosphate_intact()) bb = BackboneBuilder(struc['32'], struc['33'], struc) struc.write_pdb_file('out.pdb') self.assertTrue(bb.is_intact()) #TODO: criteria are now more strict, therefore test fails. self.assertTrue(struc['32'].is_backbone_intact()) self.assertTrue(struc['33'].is_backbone_intact()) self.assertTrue(struc['33'].is_phosphate_intact()) self.assertFalse(struc['33'].is_backbone_congested()) self.assertFalse(struc['32'].is_backbone_congested())
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_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 merge_region(self): """Merges the optimized residues with the memorized ones.""" residues = [r for r in self.model] if self.model_passive: # apply old residue numbers print '\nRestoring original numeration in the optimized region.' for num, resi in zip(self.model_resnumbers, residues): #print resi, num #self.model.renumber_residue(resi.identifier, num) resi.change_number(num) self.model = ModernaStructure('residues',residues) # do the superposition print '\nSuperimposing the optimized part onto the rest of the model.' all_atoms = self.model.get_all_atoms() sup = ModernaSuperimposer(moved_atoms = all_atoms) sup.get_atoms([self.stem5, self.stem3], BACKBONE_ATOMS, 'fixed') resi5, resi3 = self.model[self.residues[0]], self.model[self.residues[1]] sup.get_atoms([resi5, resi3], BACKBONE_ATOMS, 'moved') sup.superimpose() # merge residues print '\nMerging the optimized part with the rest of the model.' resi = [r for r in self.model] for r in self.model_passive: if r.identifier not in self.residues: resi.append(r) self.model = RnaModel(None, None, self.options.chain_name, 'residues', resi)
def check_disconnected_residues(self): """ Looks for residues that belong to the chain, are not connected to the chain and represents synthetic residues, ligands or stereoisomers. """ temp = [] st = ModernaStructure('residues', self.standard + self.unidentified_rna) all_resi = [x for x in st] if len(all_resi) == 1: temp.append(all_resi[0].identifier) elif not self.continuous: for x in range(len(all_resi) - 1): if not are_residues_connected(all_resi[x], all_resi[x + 1]): if len(all_resi) == 2: temp += [y.identifier for y in all_resi] elif x + 1 == len(all_resi) - 1: temp.append(all_resi[x + 1].identifier) elif not are_residues_connected(all_resi[x + 1], all_resi[x + 2]): temp.append(all_resi[x + 1].identifier) # checking whether disconnected residues are not sandard or modified ones for resi in temp: if not self.is_typical_category_residue(st[resi]): self.disconnected_residues.append(st[resi])
def test_validate_resi_list(self): m = ModernaStructure('file', MINI_TEMPLATE) expected = list(m) self.assertEqual(validate_resi_list(m), expected) self.assertEqual(validate_resi_list([m['2'], m['3']]), expected[1:3]) self.assertRaises(ParameterError, validate_resi_list, ['not a residue']) self.assertRaises(ParameterError, validate_resi_list, 123)
def test_multi(self): "Memory should not run full - this test should not terminate!" print 'THIS TEST RUNS FOREVER IF OK! - WATCH MEMORY' s = ModernaStructure('file', FIRST) while 1: cr = ClashRecognizer() cr.find_clashes_in_residues(s)
def force_superimpose(self, old_bp, new_bp): """ Superimposes base pairs if there is no interaction between old_bp and force mode is True """ min_rmsd = 100.0 pdb_name = '' base_pair = None path = DATA_PATH+'base_pairs/' for pdb in os.listdir(path): if new_bp in pdb: moved_residues = ModernaStructure('file', path+pdb).moderna_residues moved, fixed, to_move = self.create_atoms_lists(moved_residues) rmsd = ModernaSuperimposer(fixed, moved, to_move).rmsd if rmsd < min_rmsd: pdb_name = pdb min_rmsd = rmsd base_pair = moved_residues log.write_message("The best RMSD ("+str(min_rmsd)+") with structure: "+pdb_name) if min_rmsd <= self.cutoff: log.write_message("RMSD <= cutoff (" + str(self.cutoff) + ")") self.assign_residue_numbers(base_pair['1'], base_pair['2']) else: log.write_message("RMSD > cutoff (" + str(self.cutoff) + ") - starting backbone builder") self.run_backbone_builder()