def test_long_5p_extension(self):
a = read_alignment("""> target
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCGGAUUUALCUCAG
> template
----------------------------------------GCGGAUUUALCUCAG
""")
# first number == 1 should not work
m = RnaModel(None, a, data_type='file', data=MINI_TEMPLATE)
self.assertRaises(RenumeratorError, m.add_missing_5p)
# first number == 100 should work
m = RnaModel(None, a, data_type='file', data=MINI_TEMPLATE)
renumber_chain(m, 100)
m.add_missing_5p()
self.assertEqual(m.get_sequence(), a.target_seq)
def create_model(template=None, alignment=None, model_chain_name=None):
"""*create_model(template=None, alignment=None, model_chain_name=None)*
Creates a RNA structure model.
Produces a RnaModel object that can be saved
in a variable (see example).
If no arguments are given, an empty RNAModel is created.
If both a Template and an Alignment are given as arguments,
the complete model is built automatically.
The chain id that the model should have can be specified optionally.
:Arguments:
* Template object (optional)
* Alignment object (optional)
* chain id of the model to be built
"""
if template: template = validate_template(template)
if alignment: alignment = validate_alignment(alignment)
model = RnaModel(template=template, alignment=alignment, model_chain_name=model_chain_name, data_type=None, data=None)
if template and alignment:
if not match_template_with_alignment(template,alignment):
raise ModernaError("""Template and alignment sequences do not match!
The model cannot be built automatically.
Template : %s
Alignment: %s
"""%(template.get_sequence(),alignment.template_seq))
model.create_model()
match_alignment_with_model(alignment,model)
return model
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 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 load_model(data, chain_name='A',data_type='file',template=None,alignment=None):
"""*load_model(file_path, chain_name='A', data_type='file', template=None, alignment=None)*
Loads a structure model that has been built previously,
or any PDB struture that is then to be modified.
Produces a RnaModel object that can be saved in a variable.
Each model in ModeRNA contains only one chain.
Multi-chain structures can be modeled by using more than one
Template/Alignment/RNAModel at a time.
By default, RNAModels are created by reading files.
They can also be created from BioPython PDB objects
(precisely Bio.PDB.Structure.Structure and Bio.PDB.Chain.Chain objects)
:Arguments:
* path+filename of a PDB structure file; or a Structure or Chain object from BioPython.
* chain id (by default 'A')
* data type ('file' by default; if set to 'structure' or 'chain', Bio.PDB objects are read)
* Template object to be used for this model (optional)
* Alignment object to be used for this model (optional)
"""
if data_type == 'file': data = validate_filename(data)
elif data_type == 'residues': data = validate_resi_list(data)
if template: template = validate_template(template)
if alignment: alignment = validate_alignment(alignment)
return RnaModel(template=template, alignment=alignment, model_chain_name=chain_name, data_type=data_type, data=data)
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_model_with_close_gaps(self):
t = Template('test_data/rna_structures/2du3_excerpt.ent', 'file', 'D')
a = read_alignment('''> 1qru_B.pdb X55374.1/1-72
GCA-UUCCG
> 2du3_D.pdb
CUUUA-CCC
''')
m = RnaModel()
copy_some_residues([t['944'], t['946'], t['947']], m)
lc = find_fragment(m, '946', '947', Sequence('U'))
insert_fragment(m, lc[0])
lc = find_fragment(m, '944', '946', Sequence(''))
insert_fragment(m, lc[0])
return #TODO: remove
# generate model
m = RnaModel(t, a)
m.create_model()
def setUp(self):
self.s = ModernaStructure('file', MINI_TEMPLATE)
self.t = Template(MINI_TEMPLATE, 'file')
self.m = RnaModel(None, None, 'A', 'file', MINI_TEMPLATE)
self.f = ModernaFragment53(self.s,
anchor5=self.m['1'],
anchor3=self.m['14'])
self.struc = PDBParser().get_structure('test_struc', MINI_TEMPLATE)
def test_gaps_in_target(self):
"""Moderna should model gaps in the target, too."""
a = read_alignment(ALIGN_TARGET_GAP)
m = RnaModel(self.t, a)
m.apply_alignment()
m.insert_all_fragments()
self.assertEqual(
m.get_sequence().seq_with_modifications.replace('_', ''),
'..CUGACCU#P')
def test_model_with_5p3p_ends(self):
a = read_alignment('''> target
CAUGCGGAYYYALCUCAGGUA
> mini_template
---GCGGAUUUALCUCAG---
''')
m = RnaModel(self.t, a)
m.create_model()
self.assertEqual(m.get_sequence(), Sequence('CAUGCGGAYYYALCUCAGGUA'))
def test_5p_extension(self):
a = read_alignment("""> target
AAAAAAAAAAGCGGAUUUALCUCAG
> template
----------GCGGAUUUALCUCAG
""")
m = RnaModel(None, a, data_type='file', data=MINI_TEMPLATE)
m.add_missing_5p()
self.assertEqual(m.get_sequence(), a.target_seq)
def test_insert_all_fragments_retain_template(self):
"""The template sequence should not change."""
m2 = RnaModel(template=self.t,
alignment=self.a,
model_chain_name='A',
data_type='file',
data=MINI_TEMPLATE)
m2.insert_all_fragments()
self.assertEqual(self.t.get_sequence(), self.seq_before)
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_create_model_with_gaps(self):
"""Should create the model automatically."""
a = read_alignment(ALIGN_1B23_1QF6)
t = Template(RNA_1B23, 'file', 'R')
m = RnaModel(t, a)
m.apply_alignment()
m.insert_all_fragments()
self.assertEqual(
m.get_sequence().seq_with_modifications.replace('_', ''),
'GCCGAUAUAGCUCAGDDGGDAGAGCAGCGCAUUCGUEAUGCGAAG7UCGUAGGTPCGACUCCUAUUAUCGGCACCA'
)
def test_model_with_hydro_template(self):
"""If the template contains hydrogens, modifications should be added."""
t = Template(RNA_HYDRO, 'file', 'B')
a = read_alignment("""> 3tra_A.pdb Z73314.1/2358-2429
UPA
> 1qru_B.pdb X55374.1/1-72
CAA
""")
m = RnaModel(t, a)
m.create_model()
self.assertEqual(m.get_sequence(), Sequence('UPA'))
def test_number_gap(self):
"""Builds model with numbering gap in the template."""
a = read_alignment("""> target
CCGACCUUCGGCCACCUGACAGUCCUGUGCGGGAAACCGCACAGGACUGUCAACCAGGUAAUAUAACCACCGGGAAACGGUGGUUAUAUUACCUGGUACGCCUUGACGUGGGGGAAACCCCACGUCAAGGCGUGGUGGCCGAAGGUCGG
> template
CCGACCUUCGGCCACCUGACAGUCCUGUGCGG----CCGCACAGGACUGUCAACCAGGUAAUAUAACCACCGG----CGGUGGUUAUAUUACCUGGUACGCCUUGACGUGGGG----CCCCACGUCAAGGCGUGGUGGCCGAAGGUCGG
""")
t = Template(JMB_TEMPLATE, 'file')
clean_structure(t)
m = RnaModel(t, a)
m.create_model()
self.assertEqual(m.get_sequence().seq_without_breaks, a.target_seq)
def test_model_with_alignment_adjustment(self):
"""Introduces small corrections on alignment."""
a = read_alignment("""> target
ACUGUGAYUA[UACCU#P-G
> template with small errors.
GCG7A----U.UAGCUCA_G
""")
t = Template(MINI_TEMPLATE, 'file')
match_template_with_alignment(t, a)
m = RnaModel(t, a)
m.create_model()
self.assertEqual(m.get_sequence(), Sequence("ACUGUGAYUA[UACCU#PG"))
def test_doublegap_model(self):
"""Should create a model filling two gaps"""
a = read_alignment('''> target
GGGAUAGUUCCAGABU#A
> template
GGGA-AG--CCAGABU#A
''')
t = Template(DOUBLEGAP, 'file', 'A')
m = RnaModel(t, a)
m.apply_alignment()
m.insert_all_fragments()
m.fix_backbone()
self.assertEqual(m.get_sequence(), Sequence('GGGAUAGUUCCAGABU#A'))
def test_insert_eliminate(self):
"""Inserts a 2D fragment into a model."""
helix = load_model(HELIX, 'A')
helix = RnaModel(None, None, 'A', 'residues',
helix['1':'8'] + helix['73':'80'])
mf = ModernaFragment2D(self.motif, \
anchor5=helix['7'], anchor3=helix['74'], \
anchor5_upper=helix['8'], anchor3_upper=helix['73'], \
frag5_upper=self.motif['196'], frag3_upper=self.motif['217'], \
new_sequence=Sequence('C'), \
model=helix)
helix.insert_fragment(mf)
self.assertEqual(helix.get_sequence(), Sequence('AAAAAAAA_UCUUUUUUU'))
self.assertEqual(helix.get_secstruc(), '(((((((().)))))))')
def test_oppositegap_model(self):
"""Should create a model with close gaps in the other respective sequence"""
a = read_alignment('''> target
GGGAGAGCRUUAG-BU#A
> template
GGGAGAGCR--AGABU#A
''')
t = Template(OPPOSITEGAP, 'file', 'A')
m = RnaModel(t, a)
m.apply_alignment()
m.insert_all_fragments()
self.assertEqual(
m.get_sequence().seq_with_modifications.replace('_', ''),
'GGGAGAGCRUUAGBU#A')
def test_eliminate_middle(self):
"""Builds a fragment to shorten the connection between two anchor pairs"""
helix = ModernaStructure('file', HELIX, 'A')
helix = RnaModel(data_type='residues',
data=helix['1':'10'] + helix['71':'80'])
frag = ModernaFragment2D(self.motif, \
anchor5=helix['2'], anchor3=helix['79'], \
anchor5_upper=helix['8'], anchor3_upper=helix['73'], \
frag5_upper=self.motif['196'], frag3_upper=self.motif['217'], \
new_sequence=Sequence('C'), \
model=helix)
finsert = FragmentInserter()
finsert.prepare_fragment(frag, helix)
frag.fix_backbone()
self.assertEqual(frag.struc.get_sequence(), Sequence('AAAA_UUUCU'))
def test_fill_gap_numbering(self):
"""Should insert fragment with correct numbering."""
t = Template(DOUBLEGAP, 'file', 'A')
m = RnaModel()
for r in t:
m.copy_residue(r)
struc = ModernaStructure('file', FRAGMENT1)
f1 = ModernaFragment53(struc,
anchor5=m['20'],
anchor3=m['24'],
new_sequence=Sequence('AUA'))
m.insert_fragment(f1)
resids = [r.identifier for r in m]
expected_resids1 = [
'18', '19', '20', '20A', '20B', '20C', '24', '27', '28', '29',
'30', '31', '32', '33', '34', '35'
]
self.assertEqual(resids, expected_resids1)
def extract_region(self):
self.model.renumber_chain()
"""Cuts out the residues for optimization and keeps the rest in memory."""
if self.residues:
print '\nExtracting the region to be optimized (%s-%s) from the model.'%(self.residues[0], self.residues[1])
print '\t.. total residues in model : %4i'%len(self.model)
self.model_passive = self.model.find_residues_not_in_range(self.residues[0], self.residues[1])
print '\t.. residues not participating in optimization : %4i (+2 for superposition afterwards)'%(len(self.model_passive)-2)
print '\t '+','.join([r.identifier for r in self.model_passive])
self.model = RnaModel(None, None, self.options.chain_name, 'residues', self.model[self.residues[0]:self.residues[1]])
# memorize residue numbers because MMTK screws them
self.model_resnumbers = [r.identifier for r in self.model]
print '\t.. residues participating in optimization : %4i'%len(self.model)
print '\t '+','.join([r.identifier for r in self.model])
# keeps duplicate versions of the residues indicated by self.residues,
# so they can be superimposed later
self.stem5, self.stem3 = self.model[self.residues[0]], self.model[self.residues[1]]
else:
self.struc_to_optimize = self.model
def test_fix_backbone_residues(self):
"""Accepts two residue numbers as parameters."""
m = RnaModel(data_type='file', data=FIXABLE_BACKBONE)
fix_backbone(m, '4', '5')
self.assertEqual(m.get_sequence(), Sequence('ACUGUG'))
def test_gap_optimization_example_2(self):
t = Template('test_data/gaps/mini_1h4s_T_gap2.pdb', 'file', 'T')
a = read_alignment('test_data/gaps/ali_gap2.fasta')
m = RnaModel(t, a)
m.create_model()
def test_insert_indel_quality_1(self):
"""Insert a fragment without strand break"""
t = Template('test_data/gaps/mini_1h4s_T_gap2.pdb', 'file', 'T')
a = read_alignment('test_data/gaps/ali_gap2.fasta')
m = RnaModel(t, a)
self.assertEqual(m.get_sequence().seq_with_modifications.find('_'), -1)
def test_create_model_with_unknown(self):
"""Alignment that contains unknown bases in the target."""
a = read_alignment(MINI_ALIGNMENT_WITH_UNK)
m = RnaModel(self.t, a)
m.create_model()
self.assertEqual(m.get_sequence(), Sequence('..CUGUQQUACCU#P'))
def setUp(self):
self.a = read_alignment(MINI_ALIGNMENT)
self.a2 = read_alignment(MINI_ALIGNMENT_WITH_UNK)
self.t = Template(MINI_TEMPLATE, seq=Sequence("GCGGAUUUALCUCAG"))
self.m = RnaModel()
def setUp(self):
self.a = read_alignment(MINI_ALIGNMENT)
self.t = Template(MINI_TEMPLATE, seq=Sequence("GCGGAUUUALCUCAG"))
self.m = RnaModel(self.t, self.a)
self.seq_before = self.t.get_sequence()
self.br = BaseRecognizer()
def test_load_model(self):
"""A model should be loadable from a file."""
m = RnaModel(None, None, 'A', 'file', MINI_TEMPLATE)
self.assertEqual(len(m), 15)