def test_merge(self):
model = native.NativeModel()
model.compounds.update([
entry.DictCompoundEntry({
'id': 'g6p_c',
'name': 'G6P'
}),
entry.DictCompoundEntry({
'id': 'g6p_e',
'name': 'G6P'
})
])
model.reactions.update([
entry.DictReactionEntry({
'id': 'TP_g6p',
'equation': parse_reaction('g6p_c[c] <=> g6p_e[e]')
})
])
exchange_compound = Compound('g6p_e', 'e')
model.exchange[exchange_compound] = (
exchange_compound, 'EX_g6p_e', -10, 0)
sbml.merge_equivalent_compounds(model)
self.assertEqual({entry.id for entry in model.compounds}, {'g6p'})
self.assertEqual(
model.reactions['TP_g6p'].equation,
parse_reaction('g6p[c] <=> g6p[e]'))
new_exchange_compound = Compound('g6p', 'e')
self.assertEqual(
model.exchange[new_exchange_compound],
(new_exchange_compound, 'EX_g6p_e', -10, 0))
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self._database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self._database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self._database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self._mm = MetabolicModel.load_model(
self._database, self._database.reactions)
def test_load_model_with_reaction_subset(self):
database = DictDatabase()
database.set_reaction('rxn_1', parse_reaction('|A| => |B|'))
database.set_reaction('rxn_2', parse_reaction('|B| => |C|'))
database.set_reaction('rxn_3', parse_reaction('|C| => |D|'))
model = MetabolicModel.load_model(database, {'rxn_1'})
self.assertEqual(set(model.reactions), {'rxn_1'})
def test_add_all_database_reactions(self):
# Should get added
self.database.set_reaction('rxn_7', parse_reaction('D[c] => E[c]'))
# Not added because of compartment
self.database.set_reaction('rxn_8', parse_reaction('D[c] => E[p]'))
added = gapfilling.add_all_database_reactions(self.model, {'c', 'e'})
self.assertEqual(added, {'rxn_7'})
self.assertEqual(
set(self.model.reactions),
{'rxn_1', 'rxn_2', 'rxn_3', 'rxn_4', 'rxn_5', 'rxn_6', 'rxn_7'})
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self._database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self._database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self._database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self._mm = MetabolicModel.load_model(
self._database, self._database.reactions)
self._strategy = randomsparse.ReactionDeletionStrategy(self._mm)
def test_add_all_database_reactions(self):
# Should get added
self.database.set_reaction('rxn_7', parse_reaction('D[c] => E[c]'))
# Not added because of compartment
self.database.set_reaction('rxn_8', parse_reaction('D[c] => E[p]'))
added = gapfilling.add_all_database_reactions(self.model, {'c', 'e'})
self.assertEqual(added, {'rxn_7'})
self.assertEqual(set(self.model.reactions), {
'rxn_1', 'rxn_2', 'rxn_3', 'rxn_4', 'rxn_5', 'rxn_6', 'rxn_7'
})
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self._database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self._database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self._database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self._mm = MetabolicModel.load_model(
self._database, self._database.reactions)
self._assoc = {'rxn_2': boolean.Expression('gene_1 or gene_2')}
self._strategy = randomsparse.GeneDeletionStrategy(
self._mm, self._assoc)
def setUp(self):
self.dest = tempfile.mkdtemp()
self.model = NativeModel({
'id': 'test_mode',
'name': 'Test model',
})
# Compounds
self.model.compounds.add_entry(
CompoundEntry({
'id': 'cpd_1',
'formula': Formula.parse('CO2')
}))
self.model.compounds.add_entry(CompoundEntry({
'id': 'cpd_2',
}))
self.model.compounds.add_entry(CompoundEntry({
'id': 'cpd_3',
}))
# Compartments
self.model.compartments.add_entry(CompartmentEntry({'id': 'c'}))
self.model.compartments.add_entry(CompartmentEntry({'id': 'e'}))
# Reactions
self.model.reactions.add_entry(
ReactionEntry({
'id':
'rxn_1',
'equation':
parse_reaction('(2) cpd_1[c] <=> cpd_2[e] + cpd_3[c]'),
'genes':
boolean.Expression('g_1 and (g_2 or g_3)'),
'subsystem':
'Some subsystem'
}))
self.model.reactions.add_entry(
ReactionEntry({
'id':
'rxn_2',
'equation':
parse_reaction(
'(0.234) cpd_1[c] + (1.34) cpd_2[c] => cpd_3[c]'),
'subsystem':
'Biomass'
}))
self.model.biomass_reaction = 'rxn_2'
self.model.limits['rxn_1'] = 'rxn_1', Decimal(-42), Decimal(1000)
self.model.exchange[Compound('cpd_2', 'e')] = (Compound('cpd_2', 'e'),
'EX_cpd_2', -10, 0)
def setUp(self):
# TODO use mock model instead of actual model
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> |A|'))
self.database.set_reaction('rxn_2',
parse_reaction('(0.000001) |A| =>'))
self.model = MetabolicModel.load_model(self.database,
self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def setUp(self):
# TODO use mock model instead of actual model
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> |A|'))
self.database.set_reaction('rxn_2',
parse_reaction('(0.000001) |A| =>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self.database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_4', parse_reaction('|C| => |D|'))
self.database.set_reaction('rxn_5', parse_reaction('|D| <=> |E|'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
try:
self.solver = generic.Solver(integer=True)
except generic.RequirementsError:
self.skipTest('Unable to find an MILP solver for tests')
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> |A|'))
self.database.set_reaction('rxn_2',
parse_reaction('(0.000001) |A| =>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
# Skip these tests with GLPK because of issue #61.
if self.solver.properties['name'] == 'glpk':
self.skipTest('Test has known issue with GLPK')
def test_predict_compound_pairs(self):
"""Test prediction of HEX1 reaction."""
reaction = parse_reaction(
'atp[c] + glc-D[c] => adp[c] + g6p[c] + h[c]')
formulas = {
'atp': Formula.parse('C10H12N5O13P3'),
'adp': Formula.parse('C10H12N5O10P2'),
'glc-D': Formula.parse('C6H12O6'),
'g6p': Formula.parse('C6H11O9P'),
'h': Formula.parse('H')
}
solutions = list(
mapmaker.predict_compound_pairs(reaction, formulas, self.solver))
self.assertEqual(len(solutions), 1)
self.assertEqual(
solutions[0], {
(Compound('atp', 'c'), Compound('adp', 'c')):
Formula.parse('C10N5O10P2'),
(Compound('glc-D', 'c'), Compound('g6p', 'c')):
Formula.parse('C6O6'),
(Compound('atp', 'c'), Compound('g6p', 'c')):
Formula.parse('O3P'),
})
def test_predict_compound_pairs(self):
"""Test prediction of HEX1 reaction."""
reaction = parse_reaction(
'atp[c] + glc-D[c] => adp[c] + g6p[c] + h[c]')
formulas = {
'atp': Formula.parse('C10H12N5O13P3'),
'adp': Formula.parse('C10H12N5O10P2'),
'glc-D': Formula.parse('C6H12O6'),
'g6p': Formula.parse('C6H11O9P'),
'h': Formula.parse('H'),
}
transfer, balance = findprimarypairs.predict_compound_pairs(
reaction, formulas)
self.assertEqual(balance, {})
self.assertEqual(transfer, {
((Compound('atp', 'c'), 1), (Compound('adp', 'c'), 1)):
Formula.parse('C10H12N5O10P2'),
((Compound('glc-D', 'c'), 1), (Compound('g6p', 'c'), 1)):
Formula.parse('C6H11O6'),
((Compound('atp', 'c'), 1), (Compound('g6p', 'c'), 1)):
Formula.parse('O3P'),
((Compound('glc-D', 'c'), 1), (Compound('h', 'c'), 1)):
Formula.parse('H'),
})
def test_predict_with_multiple_solutions(self):
"""Test prediction where multiple solutions exist (TALA)."""
reaction = parse_reaction(
'r5p[c] + xu5p-D[c] <=> g3p[c] + s7p[c]')
formulas = {
'r5p': Formula.parse('C5H9O8P'),
'xu5p-D': Formula.parse('C5H9O8P'),
'g3p': Formula.parse('C3H5O6P'),
's7p': Formula.parse('C7H13O10P'),
}
solutions = list(
mapmaker.predict_compound_pairs(reaction, formulas, self.solver))
self.assertEqual(len(solutions), 2)
# Solution A
self.assertIn({
(Compound('r5p', 'c'), Compound('s7p', 'c')):
Formula.parse('C5O8P'),
(Compound('xu5p-D', 'c'), Compound('g3p', 'c')):
Formula.parse('C3O6P'),
(Compound('xu5p-D', 'c'), Compound('s7p', 'c')):
Formula.parse('C2O2'),
}, solutions)
# Solution B
self.assertIn({
(Compound('xu5p-D', 'c'), Compound('s7p', 'c')):
Formula.parse('C5O8P'),
(Compound('r5p', 'c'), Compound('g3p', 'c')):
Formula.parse('C3O6P'),
(Compound('r5p', 'c'), Compound('s7p', 'c')):
Formula.parse('C2O2'),
}, solutions)
def test_add_all_database_reactions(self):
self.database.set_reaction('rxn_7', parse_reaction('|D| => |E|'))
added = self.model.add_all_database_reactions({None, 'e'})
self.assertEqual(added, { 'rxn_7' })
self.assertEqual(set(self.model.reactions), {
'rxn_1', 'rxn_2', 'rxn_3', 'rxn_4', 'rxn_5', 'rxn_6', 'rxn_7'
})
def test_predict_with_multiple_solutions(self):
"""Test prediction where multiple solutions exist (TALA)."""
reaction = parse_reaction(
'r5p[c] + xu5p-D[c] <=> g3p[c] + s7p[c]')
formulas = {
'r5p': Formula.parse('C5H9O8P'),
'xu5p-D': Formula.parse('C5H9O8P'),
'g3p': Formula.parse('C3H5O6P'),
's7p': Formula.parse('C7H13O10P'),
}
solutions = list(
mapmaker.predict_compound_pairs(reaction, formulas, self.solver))
self.assertEqual(len(solutions), 2)
# Solution A
self.assertIn({
(Compound('r5p', 'c'), Compound('s7p', 'c')):
Formula.parse('C5O8P'),
(Compound('xu5p-D', 'c'), Compound('g3p', 'c')):
Formula.parse('C3O6P'),
(Compound('xu5p-D', 'c'), Compound('s7p', 'c')):
Formula.parse('C2O2'),
}, solutions)
# Solution B
self.assertIn({
(Compound('xu5p-D', 'c'), Compound('s7p', 'c')):
Formula.parse('C5O8P'),
(Compound('r5p', 'c'), Compound('g3p', 'c')):
Formula.parse('C3O6P'),
(Compound('r5p', 'c'), Compound('s7p', 'c')):
Formula.parse('C2O2'),
}, solutions)
def setUp(self):
self.dest = tempfile.mkdtemp()
self.model = NativeModel({
'id': 'test_mode',
'name': 'Test model',
})
# Compounds
self.model.compounds.add_entry(CompoundEntry({
'id': 'cpd_1',
'formula': Formula.parse('CO2')
}))
self.model.compounds.add_entry(CompoundEntry({
'id': 'cpd_2',
}))
self.model.compounds.add_entry(CompoundEntry({
'id': 'cpd_3',
}))
# Compartments
self.model.compartments.add_entry(CompartmentEntry({
'id': 'c'
}))
self.model.compartments.add_entry(CompartmentEntry({
'id': 'e'
}))
# Reactions
self.model.reactions.add_entry(ReactionEntry({
'id': 'rxn_1',
'equation': parse_reaction('(2) cpd_1[c] <=> cpd_2[e] + cpd_3[c]'),
'genes': boolean.Expression('g_1 and (g_2 or g_3)'),
'subsystem': 'Some subsystem'
}))
self.model.reactions.add_entry(ReactionEntry({
'id': 'rxn_2',
'equation': parse_reaction(
'(0.234) cpd_1[c] + (1.34) cpd_2[c] => cpd_3[c]'),
'subsystem': 'Biomass'
}))
self.model.biomass_reaction = 'rxn_2'
self.model.limits['rxn_1'] = 'rxn_1', Decimal(-42), Decimal(1000)
self.model.exchange[Compound('cpd_2', 'e')] = (
Compound('cpd_2', 'e'), 'EX_cpd_2', -10, 0)
def test_gapfill_reverse_reaction_not_allowed(self):
self.model.database.set_reaction('rxn_4', parse_reaction('|D| => |C|'))
core = set(self.model.reactions)
blocked = {Compound('D'), Compound('E')}
with self.assertRaises(GapFillError):
add, rev = gapfill(
self.model, core, blocked, {}, self.solver, epsilon=0.1)
def test_gapfill_reverse_reaction(self):
self.model.database.set_reaction('rxn_4', parse_reaction('|D| => |C|'))
core = set(self.model.reactions)
blocked = {Compound('D'), Compound('E')}
add, rev = gapfill(self.model, core, blocked, self.solver)
self.assertEqual(set(rev), {'rxn_4'})
self.assertEqual(set(add), set())
def test_reaction_parse_with_multichar_compartment(self):
r = reaction.parse_reaction(
'(2) |H2[C_c]| + |O2[C_c]| => (2) |H2O[C_e]|')
self.assertEqual(r, Reaction(
Direction.Forward,
[(Compound('H2', compartment='C_c'), 2),
(Compound('O2', compartment='C_c'), 1)],
[(Compound('H2O', compartment='C_e'), 2)]))
def test_reaction_parse_space(self):
r = reaction.parse_reaction(
'(2) |Some compound[c]| <=> '
'abc[c] + |Some other compound| + (3) def')
self.assertEqual(r, Reaction(
Direction.Both, [(Compound('Some compound', 'c'), 2)],
[(Compound('abc', 'c'), 1),
(Compound('Some other compound'), 1), (Compound('def'), 3)]))
def test_no_compartment_change(self):
model = ModelReader.reader_from_path(
os.path.join(self._model_dir, 'model.yaml')).create_model()
translated = tr_id.TranslatedModel(model,
self._translated.cpd_mapping_id,
self._translated.rxn_mapping_id)
self.assertEqual(translated.reactions['rxn_1a'].equation,
parse_reaction('A1[e] => B2[c]'))
self.assertEqual(
translated.reactions['rxn_3c'].equation,
parse_reaction('A1[e] + (6) B2[c] <=> (6) A1[e] + (6) D4[c]'))
self.assertIn('c', translated.compartments)
self.assertNotIn('s', translated.compartments)
self.assertIn('e', translated.compartments)
self.assertSetEqual(translated._compartment_boundaries,
set({('c', 'e')}))
self.assertEqual(translated.extracellular_compartment, 'e')
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('A[e] => B[e]'))
self._database.set_reaction('rxn_2', parse_reaction('B[e] => C[e]'))
self._database.set_reaction('rxn_3', parse_reaction('B[e] => D[e]'))
self._database.set_reaction('rxn_4', parse_reaction('C[e] => E[e]'))
self._database.set_reaction('rxn_5', parse_reaction('D[e] => E[e]'))
self._database.set_reaction('rxn_6', parse_reaction('E[e] =>'))
self._database.set_reaction('ex_A', parse_reaction('A[e] <=>'))
self._mm = MetabolicModel.load_model(
self._database, self._database.reactions)
self._assoc = {
'rxn_1': boolean.Expression('gene_1'),
'rxn_2': boolean.Expression('gene_2 or gene_3'),
'rxn_5': boolean.Expression('gene_3 and gene_4')
}
self._obj_reaction = 'rxn_6'
try:
self._solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
self._prob = fluxanalysis.FluxBalanceProblem(self._mm, self._solver)
def test_reaction_formula_none_return(self):
reaction = parse_reaction('A[e] + (6) B[c] <=> (6) C[e] + (6) D[c]')
compound_formula = {
'A': Formula.parse('C6H12O6'),
'B': Formula.parse('O2'),
'C': Formula.parse('CO2'),
}
result = balancecheck.reaction_formula(reaction, compound_formula)
self.assertIsNone(result)
def test_reaction_formula_none_return(self):
reaction = parse_reaction('A[e] + (6) B[c] <=> (6) C[e] + (6) D[c]')
compound_formula = {
'A': Formula.parse('C6H12O6'),
'B': Formula.parse('O2'),
'C': Formula.parse('CO2'),
}
result = balancecheck.reaction_formula(reaction, compound_formula)
self.assertIsNone(result)
def test_gapfill_exclude_reversal(self):
self.model.database.set_reaction('rxn_4', parse_reaction('D => C'))
core = set(self.model.reactions)
blocked = {Compound('D'), Compound('E')}
exclude = {'rxn_4'}
with self.assertRaises(GapFillError):
gapfill(self.model, core, blocked, exclude, self.solver,
epsilon=0.1)
def test_gapfill_reverse_reaction(self):
self.model.database.set_reaction('rxn_4', parse_reaction('|D| => |C|'))
core = set(self.model.reactions)
blocked = {Compound('D'), Compound('E')}
add, rev = gapfill(
self.model, core, blocked, {}, self.solver, epsilon=0.1,
allow_bounds_expansion=True)
self.assertEqual(set(rev), {'rxn_4'})
self.assertEqual(set(add), set())
def test_reaction_formula_normal_return(self):
reaction = parse_reaction('A[e] + (6) B[c] <=> (6) C[e] + (6) D[c]')
compound_formula = {
'A': Formula.parse('C6H12O6'),
'B': Formula.parse('O2'),
'C': Formula.parse('CO2'),
'D': Formula.parse('H2O')
}
left_form, right_form = balancecheck.reaction_formula(
reaction, compound_formula)
self.assertEqual(left_form, Formula.parse('C6H12O18'))
self.assertEqual(right_form, Formula.parse('C6H12O18'))
def setUp(self):
database1 = DictDatabase()
database1.set_reaction('rxn_1', parse_reaction('|A| => |B|'))
database1.set_reaction('rxn_2', parse_reaction('|B| => |C| + |D|'))
database1.set_reaction('rxn_3', parse_reaction('|D| <=> |E|'))
database1.set_reaction('rxn_4', parse_reaction('|F| => |G|'))
database2 = DictDatabase()
database2.set_reaction('rxn_2', parse_reaction('|B| => |C|'))
database2.set_reaction('rxn_3', parse_reaction('|C| => |D|'))
database2.set_reaction('rxn_4', parse_reaction('|F| <=> |G|'))
database2.set_reaction('rxn_5', parse_reaction('|G| + |I| <=> |H|'))
self.database = ChainedDatabase(database2, database1)
def test_predict_compound_pairs_unbalanced(self):
"""Test prediction of (non-sense) unbalanced reaction."""
reaction = parse_reaction(
'a[c] <=> b[c] + c[c]')
formulas = {
'a': Formula.parse('C10H12'),
'b': Formula.parse('C9H11'),
'c': Formula.parse('CO2'),
}
with self.assertRaises(mapmaker.UnbalancedReactionError):
list(mapmaker.predict_compound_pairs(
reaction, formulas, self.solver))
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |D[e]|'))
self.database.set_reaction('rxn_4', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_5', parse_reaction('|C| => |D[e]|'))
self.database.set_reaction('rxn_6', parse_reaction('|D[e]| =>'))
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> 2 A'))
self.database.set_reaction('rxn_2', parse_reaction('A <=> B'))
self.database.set_reaction('rxn_3', parse_reaction('A => D[e]'))
self.database.set_reaction('rxn_4', parse_reaction('A + 2 B => C'))
self.database.set_reaction('rxn_5', parse_reaction('C => 3 D[e]'))
self.database.set_reaction('rxn_6', parse_reaction('D[e] =>'))
def setUp(self):
self.model = native.NativeModel()
self.model.reactions.update([
entry.DictReactionEntry({
'id': 'EX_g6p',
'equation': parse_reaction('g6p[e] <=>')
}),
entry.DictReactionEntry({
'id': 'EX_glc-D',
'equation': parse_reaction('glc-D[e] <=>')
}),
entry.DictReactionEntry({
'id': 'SINK_glc-D',
'equation': parse_reaction('glc-D[c] <=>')
}),
entry.DictReactionEntry({
'id': 'rxn_1',
'equation': parse_reaction('g6p[c] <=> glc-D[c]')
}),
entry.DictReactionEntry({
'id': 'TP_glc-D',
'equation': parse_reaction('glc-D[c] <=> glc-D[e]')
})
])
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |D|'))
self.database.set_reaction('rxn_4', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_5', parse_reaction('|C| => |D|'))
self.database.set_reaction('rxn_6', parse_reaction('|D| =>'))
self.database.set_reaction('rxn_7', parse_reaction('|E| => |F|'))
self.database.set_reaction('rxn_8', parse_reaction('|F| => |E|'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
try:
self.solver = generic.Solver(integer=True)
except generic.RequirementsError:
self.skipTest('Unable to find an MILP solver for tests')
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) A[c]'))
self.database.set_reaction('rxn_2', parse_reaction('A[c] <=> B[c]'))
self.database.set_reaction('rxn_3', parse_reaction('A[c] => D[e]'))
self.database.set_reaction('rxn_4', parse_reaction('A[c] => C[c]'))
self.database.set_reaction('rxn_5', parse_reaction('C[c] => D[e]'))
self.database.set_reaction('rxn_6', parse_reaction('D[e] =>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
def test_predict_compound_pairs_multiple(self):
"""Test prediction of reaction with multiple instances."""
reaction = parse_reaction(
'a[c] <=> (2) b[c] + c[c]')
formulas = {
'a': Formula.parse('C10H13O6'),
'b': Formula.parse('C5H6O3'),
'c': Formula.parse('H'),
}
solutions = list(
mapmaker.predict_compound_pairs(reaction, formulas, self.solver))
self.assertEqual(len(solutions), 1)
self.assertEqual(solutions[0], {
(Compound('a', 'c'), Compound('b', 'c')): Formula.parse('C10O6'),
})
