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 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_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'), })