def test_make_derivative_models(self):
rev = RevisionModule('archive')
cond_subst_1 = mnm_repr.PresentEntity(mnm_repr.Metabolite('met1'),
mnm_repr.Medium())
cond_subst_2 = mnm_repr.PresentEntity(mnm_repr.Metabolite('met2'),
mnm_repr.Medium())
base_model = mnm_repr.Model(
'm1', [cond_subst_1], [],
[]) #model that is compatible with interventions
second_mod = mnm_repr.Model('deriv_m1_0', [cond_subst_1, cond_subst_2],
[], [])
third_mod = mnm_repr.Model('deriv_m1_1', [], [], [])
exd1 = exp_repr.ExperimentDescription(None,
[mnm_repr.Add(cond_subst_2)])
exd2 = exp_repr.ExperimentDescription(None,
[mnm_repr.Remove(cond_subst_1)])
res1 = exp_repr.Result('r1', exd1, True)
res2 = exp_repr.Result('r2', exd2, True)
extracted_results = [res1, res2] #need interventions in description
models_results = rev.make_derivative_models(base_model,
extracted_results)
self.assertEqual(models_results, {
base_model: [],
second_mod: [res1],
third_mod: [res2]
})
def test_record_RevisedModel(self): old = mnm_repr.Model(None, [1], [], []) new = mnm_repr.Model(None, [2], [], []) event = archive.RevisedModel(old, [new]) self.archive.record(event) self.assertIn(event, self.archive.development_history) self.assertIn(new, self.archive.working_models)
def test_record_InitialModels(self): mod1 = mnm_repr.Model(None, [1], [], []) mod2 = mnm_repr.Model(None, [2], [], []) event = archive.InitialModels([mod1, mod2]) self.archive.record(event) self.assertIn(event, self.archive.development_history) self.assertIn(mod1, self.archive.working_models) self.assertIn(mod2, self.archive.working_models)
def test_models_nr_and_probabilities(self):
m1 = mnm_repr.Model('m1', [1], [], [])
m2 = mnm_repr.Model('m2', [2], [], [])
m1.quality = 5
m2.quality = 10
out = exporter.models_nr_and_probabilities([m1, m2])
self.assertEqual([
'\nnr(0,m1).', '\nprobability(5, m1).', '\nnr(1,m2).',
'\nprobability(10, m2).'
], out)
def test_export_force_new_model(self):
act1 = mnm_repr.Activity('act1', None, ['a'], [])
act2 = mnm_repr.Activity('act2', None, ['b'], [])
base_model = mnm_repr.Model('m1', [], [], [])
exm1 = mnm_repr.Model('m2', [], [act1], [])
exm2 = mnm_repr.Model('m3', [], [act2], [])
out = exporter.export_force_new_model(base_model, [exm1, exm2])
self.assertIn('\nexternal_model(m2).', out)
self.assertIn('\nexternal_model(m3).', out)
self.assertIn('\nin_model(act1,m2).', out)
self.assertIn('\nin_model(act2,m3).', out)
self.assertIn('\n#example different(m1, m2).', out)
self.assertIn('\n#example different(m1, m3).', out)
def test_RevCIAddB_revise_ignoring(self):
met1 = mnm_repr.Metabolite('met1')
met2 = mnm_repr.Metabolite('met2')
comp1 = mnm_repr.Medium()
cond_subst_1 = mnm_repr.PresentEntity(met1, comp1)
cond_subst_2 = mnm_repr.PresentEntity(met2, comp1)
a1 = mnm_repr.Reaction('act1', [], [cond_subst_1, cond_subst_2])
a1.remove_cost = None
a1.reversibility = False
a2 = mnm_repr.Reaction('act1', [], [cond_subst_1])
a2.reversibility = False
# model to be revised
mod = mnm_repr.Model('m_0', [], [a1], [])
# results
des1 = exp_repr.ExperimentDescription(exp_repr.DetectionEntity('met1'),
[])
des2 = exp_repr.ExperimentDescription(exp_repr.DetectionEntity('met2'),
[])
res1 = exp_repr.Result('res_0', des1, 'false')
res2 = exp_repr.Result('res_1', des2, 'true')
exp1 = exp_repr.Experiment('exp_0', [res1])
exp2 = exp_repr.Experiment('exp_1', [res2])
# archive with results and parts for revision
arch = Archive()
arch.known_results = [exp1, exp2]
arch.mnm_activities = [a1, a2]
arch.mnm_entities = [met1, met2]
arch.mnm_compartments = [comp1]
rev = RevCIAddB(arch)
out = rev.revise(mod)
self.assertEqual(out[0], [])
self.assertEqual(out[1], True)
def test_apply_intervention_raise_neither_cond_nor_activity(self):
intervention = mnm_repr.Intervention('nothing')
setup_conds = [self.con1, self.con2]
interm_activs = [self.act1, self.act2]
term_conds = [self.con3, self.con4]
model = mnm_repr.Model('ID', setup_conds, interm_activs, term_conds)
self.assertRaises(TypeError, model.apply_intervention, intervention)
def test_apply_intervention_raise_not_intervention(self):
intervention = 'fake intervention'
setup_conds = [self.con1, self.con2]
interm_activs = [self.act1, self.act2]
term_conds = [self.con3, self.con4]
model = mnm_repr.Model('ID', setup_conds, interm_activs, term_conds)
self.assertRaises(TypeError, model.apply_intervention, intervention)
def test_calculate_max_number_activities(self):
# model with activities, archive with results that have add activity in interventions
a1 = mnm_repr.Activity('act1', None, ['a'], [])
a2 = mnm_repr.Activity('act1', None, ['b'], [])
a3 = mnm_repr.Activity('act1', None, ['c'], [])
a4 = mnm_repr.Activity('act1', None, ['d'], [])
base_model = mnm_repr.Model('m1', [], [a1], [])
des1 = exp_repr.ExperimentDescription(
None, [mnm_repr.Add(a2), mnm_repr.Add(a1)])
des2 = exp_repr.ExperimentDescription(None, [mnm_repr.Add(a3)])
des3 = exp_repr.ExperimentDescription(
None, [mnm_repr.Add(a4), mnm_repr.Add(a3)])
res1 = exp_repr.Result('r1', des1, None)
res2 = exp_repr.Result('r2', des2, None)
res3 = exp_repr.Result('r3', des3, None)
exp1 = exp_repr.Experiment('exp1', [res1])
exp2 = exp_repr.Experiment('exp2', [res2])
exp3 = exp_repr.Experiment('exp3', [res3])
arch = Archive()
arch.known_results = [exp1, exp2, exp3]
rev = RevisionModule(arch)
out = rev.calculate_max_number_activities(base_model)
self.assertEqual(out, 4)
def test_apply_intervention_remove_activity(self):
intervention = mnm_repr.Remove(self.act1)
setup_conds = [self.con1, self.con2]
interm_activs = [self.act1, self.act2]
term_conds = [self.con3, self.con4]
model = mnm_repr.Model('ID', setup_conds, interm_activs, term_conds)
model.apply_intervention(intervention)
self.assertEqual(model.intermediate_activities, frozenset([self.act2]))
def test_copy(self):
setup_conds = [self.con1, self.con2]
interm_activs = [self.act1, self.act2]
term_conds = [self.con3, self.con4]
model = mnm_repr.Model('ID', setup_conds, interm_activs, term_conds)
copied_model = copy(model)
self.assertEqual(model, copied_model)
self.assertIsNot(model, copied_model)
def test_apply_intervention_add_condition(self):
intervention = mnm_repr.Add(self.con1)
setup_conds = [self.con2]
interm_activs = [self.act1, self.act2]
term_conds = [self.con3, self.con4]
model = mnm_repr.Model('ID', setup_conds, interm_activs, term_conds)
model.apply_intervention(intervention)
self.assertEqual(model.setup_conditions,
frozenset([self.con2, self.con1]))
def test_setup_with_lists(self):
setup_conds = [self.con1, self.con2]
interm_activs = [self.act1, self.act2]
term_conds = [self.con3, self.con4]
model = mnm_repr.Model('ID', setup_conds, interm_activs, term_conds)
self.assertEqual(model.ID, 'ID')
self.assertEqual(model.setup_conditions, frozenset(setup_conds))
self.assertEqual(model.intermediate_activities,
frozenset(interm_activs))
self.assertEqual(model.termination_conditions, frozenset(term_conds))
def test_export_termination_conds_consistency(self):
# one cond
cond_subst_1 = mnm_repr.PresentEntity(mnm_repr.Metabolite('met1'),
mnm_repr.Medium())
cond_subst_2 = mnm_repr.PresentEntity(mnm_repr.Metabolite('met2'),
mnm_repr.Medium())
m = mnm_repr.Model('m1', [], [], [cond_subst_1, cond_subst_2])
exported = exporter.export_termination_conds_consistency(m)
self.assertIn('\n:- not synthesizable(met1, none, c_01, m1).',
exported)
self.assertIn('\n:- not synthesizable(met2, none, c_01, m1).',
exported)
def test_apply_multiple_interventions(self):
intervention1 = mnm_repr.Add(self.con1)
intervention2 = mnm_repr.Remove(self.con1)
intervention3 = mnm_repr.Add(self.act1)
intervention4 = mnm_repr.Remove(self.act1)
setup_conds = [self.con2]
interm_activs = [self.act2]
term_conds = [self.con3, self.con4]
model = mnm_repr.Model('ID', setup_conds, interm_activs, term_conds)
model.apply_interventions(
[intervention1, intervention2, intervention3, intervention4])
self.assertEqual(model.setup_conditions, frozenset([self.con2]))
self.assertEqual(model.intermediate_activities, frozenset([self.act2]))
def test_export_model_specification(self):
# 2 conds + 2 activ
cond_subst_1 = mnm_repr.PresentEntity(mnm_repr.Metabolite('met1'),
mnm_repr.Medium())
cond_subst_2 = mnm_repr.PresentEntity(mnm_repr.Metabolite('met2'),
mnm_repr.Medium())
act_1 = mnm_repr.Activity('a1', None, ['1'], [])
act_2 = mnm_repr.Activity('a2', None, ['2'], [])
m = mnm_repr.Model('m1', [cond_subst_1, cond_subst_2], [act_1, act_2],
[])
exported = exporter.export_model_specification(m)
self.assertIn('\nadded_to_model(setup_present(met1,none,c_01),m1).',
exported)
self.assertIn('\nadded_to_model(setup_present(met2,none,c_01),m1).',
exported)
self.assertIn('\nadded_to_model(a1,m1).', exported)
self.assertIn('\nadded_to_model(a2,m1).', exported)
def test_export_relevancy_results_consistency(self):
# one ignored result, one not ignored
res1 = exp_repr.Result('res1', None, None)
res2 = exp_repr.Result('res2', None, None)
m = mnm_repr.Model('m1', [], [], [])
m.ignored_results = frozenset([res1])
base_model = m
models_results = {m: [res1, res2]}
exported = exporter.export_relevancy_results_consistency(
models_results, base_model)
self.assertNotIn('\nrelevant(res1, m1).', exported)
self.assertNotIn('\n:- inconsistent(m1, res1).', exported)
self.assertIn('\nrelevant(res2, m1).', exported)
self.assertIn('\n:- inconsistent(m1, res2).', exported)
def test_check_consistency_negative(self):
met1 = mnm_repr.Metabolite('met1')
met2 = mnm_repr.Metabolite('met2')
comp1 = mnm_repr.Medium()
cond_subst_1 = mnm_repr.PresentEntity(met1, comp1)
cond_subst_2 = mnm_repr.PresentEntity(met2, comp1)
base_model = mnm_repr.Model('m1', [cond_subst_1, cond_subst_2], [], [])
exd = exp_repr.ExperimentDescription(exp_repr.DetectionEntity('met1'),
[])
res = exp_repr.Result('r1', exd, 'false')
exp = exp_repr.Experiment('exp1', [res])
arch = Archive()
arch.mnm_entities = [met1, met2]
arch.mnm_compartments = [comp1]
ev1 = AdditionalModels([base_model])
ev2 = AcceptedResults(exp)
arch.record(ev1)
arch.record(ev2)
rev = RevisionModule(arch)
out = rev.check_consistency(base_model)
self.assertEqual(False, out)
