def test_inequality(self, solver_test): solver, old_solution, infeasible_model = solver_test # The space enclosed by the constraints is a 2D triangle with # vertexes as (3, 0), (1, 2), and (0, 1) # c1 encodes y - x > 1 ==> y > x - 1 # c2 encodes y + x < 3 ==> y < 3 - x c1 = Metabolite("c1") c2 = Metabolite("c2") x = Reaction("x") x.lower_bound = 0 y = Reaction("y") y.lower_bound = 0 x.add_metabolites({c1: -1, c2: 1}) y.add_metabolites({c1: 1, c2: 1}) c1._bound = 1 c1._constraint_sense = "G" c2._bound = 3 c2._constraint_sense = "L" m = Model() m.add_reactions([x, y]) # test that optimal values are at the vertices m.objective = "x" assert abs(solver.solve(m).f - 1.0) < 10 ** -3 assert abs(solver.solve(m).x_dict["y"] - 2.0) < 10 ** -3 m.objective = "y" assert abs(solver.solve(m).f - 3.0) < 10 ** -3 assert abs( solver.solve(m, objective_sense="minimize").f - 1.0) < 10 ** -3
def test_complicated_model(): """Test a complicated model. Difficult model since the online mean calculation is numerically unstable so many samples weakly violate the equality constraints. """ model = Model('flux_split') reaction1 = Reaction('V1') reaction2 = Reaction('V2') reaction3 = Reaction('V3') reaction1.bounds = (0, 6) reaction2.bounds = (0, 8) reaction3.bounds = (0, 10) A = Metabolite('A') reaction1.add_metabolites({A: -1}) reaction2.add_metabolites({A: -1}) reaction3.add_metabolites({A: 1}) model.add_reactions([reaction1, reaction2, reaction3]) optgp = OptGPSampler(model, 1, seed=42) achr = ACHRSampler(model, seed=42) optgp_samples = optgp.sample(100) achr_samples = achr.sample(100) assert any(optgp_samples.corr().abs() < 1.0) assert any(achr_samples.corr().abs() < 1.0) # > 95% are valid assert sum(optgp.validate(optgp_samples) == "v") > 95 assert sum(achr.validate(achr_samples) == "v") > 95
def test_get_yield_not_working_if_input_formula_missing(self): model = Model("test") met1 = Metabolite(id="S7P") met2 = Metabolite(id="T3P1", formula="C3H7O6P") met3 = Metabolite(id="E4P", formula="C4H9O7P") met4 = Metabolite(id="F6P", formula="C6H13O9P") model.add_metabolites((met1, met2, met3, met4)) react1 = Reaction(id="r1", name="Transaldolase") react1.add_metabolites({met1: -1, met2: -1, met3: 1, met4: 1}) react2 = Reaction(id="r2") react2.add_metabolites({met1: -1}) react3 = Reaction(id="r3") react3.add_metabolites({met2: -1}) react4 = Reaction(id="r4") react4.add_metabolites({met3: -1}) react5 = Reaction(id="r5") react5.add_metabolites({met4: -1}) model.add_reactions((react1, react2, react3, react4, react5)) fluxes = { react1.id: 1, react2.id: -1, react3.id: -1, react4.id: 1, react5.id: 1 } status, _ = get_yields(fluxes, model) assert status is False
def test_solve_mip(self, solver_test): solver, old_solution, infeasible_model = solver_test if not hasattr(solver, "_SUPPORTS_MILP") or not solver._SUPPORTS_MILP: pytest.skip("no milp support") cobra_model = Model('MILP_implementation_test') constraint = Metabolite("constraint") constraint._bound = 2.5 x = Reaction("x") x.lower_bound = 0. x.objective_coefficient = 1. x.add_metabolites({constraint: 2.5}) y = Reaction("y") y.lower_bound = 0. y.objective_coefficient = 1. y.add_metabolites({constraint: 1.}) cobra_model.add_reactions([x, y]) float_sol = solver.solve(cobra_model) # add an integer constraint y.variable_kind = "integer" int_sol = solver.solve(cobra_model) assert abs(float_sol.f - 2.5) < 10 ** -5 assert abs(float_sol.x_dict["y"] - 2.5) < 10 ** -5 assert int_sol.status == "optimal" assert abs(int_sol.f - 2.2) < 10 ** -3 assert abs(int_sol.x_dict["y"] - 2.0) < 10 ** -3
def test_add_reactions(self, model): r1 = Reaction('r1') r1.add_metabolites({Metabolite('A'): -1, Metabolite('B'): 1}) r1.lower_bound, r1.upper_bound = -999999., 999999. r2 = Reaction('r2') r2.add_metabolites({ Metabolite('A'): -1, Metabolite('C'): 1, Metabolite('D'): 1 }) r2.lower_bound, r2.upper_bound = 0., 999999. model.add_reactions([r1, r2]) r2.objective_coefficient = 3. assert r2.objective_coefficient == 3. assert model.reactions[-2] == r1 assert model.reactions[-1] == r2 assert isinstance(model.reactions[-2].reverse_variable, model.problem.Variable) coefficients_dict = model.objective.expression. \ as_coefficients_dict() biomass_r = model.reactions.get_by_id('Biomass_Ecoli_core') assert coefficients_dict[biomass_r.forward_variable] == 1. assert coefficients_dict[biomass_r.reverse_variable] == -1. assert coefficients_dict[model.reactions.r2.forward_variable] == 3. assert coefficients_dict[model.reactions.r2.reverse_variable] == -3.
def construct_ll_test_model(): test_model = Model() test_model.add_metabolites(Metabolite("A")) test_model.add_metabolites(Metabolite("B")) test_model.add_metabolites(Metabolite("C")) EX_A = Reaction("EX_A") EX_A.add_metabolites({test_model.metabolites.A: 1}) DM_C = Reaction("DM_C") DM_C.add_metabolites({test_model.metabolites.C: -1}) v1 = Reaction("v1") v1.add_metabolites({ test_model.metabolites.A: -1, test_model.metabolites.B: 1 }) v2 = Reaction("v2") v2.add_metabolites({ test_model.metabolites.B: -1, test_model.metabolites.C: 1 }) v3 = Reaction("v3") v3.add_metabolites({ test_model.metabolites.C: -1, test_model.metabolites.A: 1 }) test_model.add_reactions([EX_A, DM_C, v1, v2, v3]) DM_C.objective_coefficient = 1 return test_model
def test_complicated_model(self): """Difficult model since the online mean calculation is numerically unstable so many samples weakly violate the equality constraints.""" model = Model('flux_split') reaction1 = Reaction('V1') reaction2 = Reaction('V2') reaction3 = Reaction('V3') reaction1.lower_bound = 0 reaction2.lower_bound = 0 reaction3.lower_bound = 0 reaction1.upper_bound = 6 reaction2.upper_bound = 8 reaction3.upper_bound = 10 A = Metabolite('A') reaction1.add_metabolites({A: -1}) reaction2.add_metabolites({A: -1}) reaction3.add_metabolites({A: 1}) model.add_reactions([reaction1]) model.add_reactions([reaction2]) model.add_reactions([reaction3]) optgp = OptGPSampler(model, 1, seed=42) achr = ACHRSampler(model, seed=42) optgp_samples = optgp.sample(100) achr_samples = achr.sample(100) assert any(optgp_samples.corr().abs() < 1.0) assert any(achr_samples.corr().abs() < 1.0) # > 95% are valid assert (sum(optgp.validate(optgp_samples) == "v") > 95) assert (sum(achr.validate(achr_samples) == "v") > 95)
def test_change_coefficient(self, solver_test): solver, old_solution, infeasible_model = solver_test c = Metabolite("c") c._bound = 6 x = Reaction("x") x.lower_bound = 1. y = Reaction("y") y.lower_bound = 0. x.add_metabolites({c: 1}) z = Reaction("z") z.add_metabolites({c: 1}) z.objective_coefficient = 1 m = Model("test_model") m.add_reactions([x, y, z]) # change an existing coefficient lp = solver.create_problem(m) solver.solve_problem(lp) sol1 = solver.format_solution(lp, m) assert sol1.status == "optimal" solver.change_coefficient(lp, 0, 0, 2) solver.solve_problem(lp) sol2 = solver.format_solution(lp, m) assert sol2.status == "optimal" assert abs(sol1.f - 5.0) < 10 ** -3 assert abs(sol2.f - 4.0) < 10 ** -3 # change a new coefficient z.objective_coefficient = 0. y.objective_coefficient = 1. lp = solver.create_problem(m) solver.change_coefficient(lp, 0, 1, 2) solver.solve_problem(lp) solution = solver.format_solution(lp, m) assert solution.status == "optimal" assert abs(solution.x_dict["y"] - 2.5) < 10 ** -3
def construct_geometric_fba_model(): test_model = Model('geometric_fba_paper_model') test_model.add_metabolites(Metabolite('A')) test_model.add_metabolites(Metabolite('B')) v1 = Reaction('v1', upper_bound=1.0) v1.add_metabolites({test_model.metabolites.A: 1.0}) v2 = Reaction('v2', lower_bound=-1000.0) v2.add_metabolites({ test_model.metabolites.A: -1.0, test_model.metabolites.B: 1.0 }) v3 = Reaction('v3', lower_bound=-1000.0) v3.add_metabolites({ test_model.metabolites.A: -1.0, test_model.metabolites.B: 1.0 }) v4 = Reaction('v4', lower_bound=-1000.0) v4.add_metabolites({ test_model.metabolites.A: -1.0, test_model.metabolites.B: 1.0 }) v5 = Reaction('v5') v5.add_metabolites({ test_model.metabolites.A: 0.0, test_model.metabolites.B: -1.0 }) test_model.add_reactions([v1, v2, v3, v4, v5]) test_model.objective = 'v5' return test_model
def test_gapfilling(self, salmonella): m = Model() m.add_metabolites([Metabolite(m_id) for m_id in ["a", "b", "c"]]) exa = Reaction("EX_a") exa.add_metabolites({m.metabolites.a: 1}) b2c = Reaction("b2c") b2c.add_metabolites({m.metabolites.b: -1, m.metabolites.c: 1}) dmc = Reaction("DM_c") dmc.add_metabolites({m.metabolites.c: -1}) m.add_reactions([exa, b2c, dmc]) m.objective = 'DM_c' universal = Model() a2b = Reaction("a2b") a2d = Reaction("a2d") universal.add_reactions([a2b, a2d]) a2b.build_reaction_from_string("a --> b", verbose=False) a2d.build_reaction_from_string("a --> d", verbose=False) # # GrowMatch # result = gapfilling.growMatch(m, universal)[0] result = gapfilling.gapfill(m, universal)[0] assert len(result) == 1 assert result[0].id == "a2b" # # SMILEY # result = gapfilling.SMILEY(m, "b", universal)[0] with m: m.objective = m.add_boundary(m.metabolites.b, type='demand') result = gapfilling.gapfill(m, universal)[0] assert len(result) == 1 assert result[0].id == "a2b" # # 2 rounds of GrowMatch with exchange reactions # result = gapfilling.growMatch(m, None, ex_rxns=True, iterations=2) result = gapfilling.gapfill(m, None, exchange_reactions=True, iterations=2) assert len(result) == 2 assert len(result[0]) == 1 assert len(result[1]) == 1 assert {i[0].id for i in result} == {"EX_b", "EX_c"} # somewhat bigger model universal = Model("universal_reactions") with salmonella as model: for i in [i.id for i in model.metabolites.f6p_c.reactions]: reaction = model.reactions.get_by_id(i) universal.add_reactions([reaction.copy()]) model.remove_reactions([reaction]) gf = gapfilling.GapFiller(model, universal, penalties={'TKT2': 1e3}, demand_reactions=False) solution = gf.fill() assert 'TKT2' not in {r.id for r in solution[0]} assert gf.validate(solution[0])
def construct_loopless_model(cobra_model): """Construct a loopless model. This adds MILP constraints to prevent flux from proceeding in a loop, as done in http://dx.doi.org/10.1016/j.bpj.2010.12.3707 Please see the documentation for an explanation of the algorithm. This must be solved with an MILP capable solver. """ # copy the model and make it irreversible model = cobra_model.copy() convert_to_irreversible(model) max_ub = max(model.reactions.list_attr("upper_bound")) # a dict for storing S^T thermo_stoic = { "thermo_var_" + metabolite.id: {} for metabolite in model.metabolites } # Slice operator is so that we don't get newly added metabolites original_metabolites = model.metabolites[:] for reaction in model.reactions[:]: # Boundary reactions are not subjected to these constraints if len(reaction._metabolites) == 1: continue # populate the S^T dict bound_id = "thermo_bound_" + reaction.id for met, stoic in iteritems(reaction._metabolites): thermo_stoic["thermo_var_" + met.id][bound_id] = stoic # I * 1000 > v --> I * 1000 - v > 0 reaction_ind = Reaction(reaction.id + "_indicator") reaction_ind.variable_kind = "integer" reaction_ind.upper_bound = 1 reaction_ub = Metabolite(reaction.id + "_ind_ub") reaction_ub._constraint_sense = "G" reaction.add_metabolites({reaction_ub: -1}) reaction_ind.add_metabolites({reaction_ub: max_ub}) # This adds a compensating term for 0 flux reactions, so we get # S^T x - (1 - I) * 1001 < -1 which becomes # S^T x < 1000 for 0 flux reactions and # S^T x < -1 for reactions with nonzero flux. reaction_bound = Metabolite(bound_id) reaction_bound._constraint_sense = "L" reaction_bound._bound = max_ub reaction_ind.add_metabolites({reaction_bound: max_ub + 1}) model.add_reaction(reaction_ind) for metabolite in original_metabolites: metabolite_var = Reaction("thermo_var_" + metabolite.id) metabolite_var.lower_bound = -max_ub model.add_reaction(metabolite_var) metabolite_var.add_metabolites({ model.metabolites.get_by_id(k): v for k, v in iteritems(thermo_stoic[metabolite_var.id]) }) return model
def test_add_reactions_duplicate(model): rxn = model.reactions[0] r1 = Reaction('r1') r1.add_metabolites({Metabolite('A'): -1, Metabolite('B'): 1}) r1.lower_bound, r1.upper_bound = -999999., 999999. r2 = Reaction(rxn.id) r2.add_metabolites( {Metabolite('A'): -1, Metabolite('C'): 1, Metabolite('D'): 1}) model.add_reactions([r1, r2]) assert r1 in model.reactions assert rxn in model.reactions assert r2 is not model.reactions.get_by_id(rxn.id)
def test_get_yield(self): model = Model("test") met1 = Metabolite(id="S7P", formula="C7H15O10P") met2 = Metabolite(id="T3P1", formula="C3H7O6P") met3 = Metabolite(id="E4P", formula="C4H9O7P") met4 = Metabolite(id="F6P", formula="C6H13O9P") model.add_metabolites((met1, met2, met3, met4)) react1 = Reaction(id="r1", name="Transaldolase") react1.add_metabolites({met1: -1, met2: -1, met3: 1, met4: 1}) react2 = Reaction(id="r2") react2.add_metabolites({met1: -1}) react3 = Reaction(id="r3") react3.add_metabolites({met2: -1}) react4 = Reaction(id="r4") react4.add_metabolites({met3: -1}) react5 = Reaction(id="r5") react5.add_metabolites({met4: -1}) model.add_reactions((react1, react2, react3, react4, react5)) fluxes = { react1.id: 1, react2.id: -1, react3.id: -1, react4.id: 1, react5.id: 1 } status, yields = get_yields(fluxes, model) assert status is True assert yields == { "C": { met3: 0.4, met4: 0.6 }, "H": { met3: 9 / 22, met4: 13 / 22 }, "O": { met3: 7 / 16, met4: 9 / 16 }, "P": { met3: 0.5, met4: 0.5 } }
def test_quadratic(self, solver_test): solver, old_solution, infeasible_model = solver_test if not hasattr(solver, "set_quadratic_objective"): pytest.skip("no qp support") c = Metabolite("c") c._bound = 2 x = Reaction("x") x.objective_coefficient = -0.5 x.lower_bound = 0. y = Reaction("y") y.objective_coefficient = -0.5 y.lower_bound = 0. x.add_metabolites({c: 1}) y.add_metabolites({c: 1}) m = Model() m.add_reactions([x, y]) lp = solver.create_problem(m) quadratic_obj = scipy.sparse.eye(2) * 2 solver.set_quadratic_objective(lp, quadratic_obj) solver.solve_problem(lp, objective_sense="minimize") solution = solver.format_solution(lp, m) assert solution.status == "optimal" # Respecting linear objectives also makes the objective value 1. assert abs(solution.f - 1.) < 10 ** -3 assert abs(solution.x_dict["y"] - 1.) < 10 ** -3 assert abs(solution.x_dict["y"] - 1.) < 10 ** -3 # When the linear objectives are removed the objective value is 2. solver.change_variable_objective(lp, 0, 0.) solver.change_variable_objective(lp, 1, 0.) solver.solve_problem(lp, objective_sense="minimize") solution = solver.format_solution(lp, m) assert solution.status == "optimal" assert abs(solution.f - 2.) < 10 ** -3 # test quadratic from solve function solution = solver.solve(m, quadratic_component=quadratic_obj, objective_sense="minimize") assert solution.status == "optimal" assert abs(solution.f - 1.) < 10 ** -3 c._bound = 6 z = Reaction("z") x.objective_coefficient = 0. y.objective_coefficient = 0. z.lower_bound = 0. z.add_metabolites({c: 1}) m.add_reaction(z) solution = solver.solve(m, quadratic_component=scipy.sparse.eye(3), objective_sense="minimize") # should be 12 not 24 because 1/2 (V^T Q V) assert solution.status == "optimal" assert abs(solution.f - 6) < 10 ** -3 assert abs(solution.x_dict["x"] - 2) < 10 ** -6 assert abs(solution.x_dict["y"] - 2) < 10 ** -6 assert abs(solution.x_dict["z"] - 2) < 10 ** -6
def solver_test(request): solver = solvers.solver_dict[request.param] old_solution = 0.8739215 infeasible_model = Model() metabolite_1 = Metabolite("met1") reaction_1 = Reaction("rxn1") reaction_2 = Reaction("rxn2") reaction_1.add_metabolites({metabolite_1: 1}) reaction_2.add_metabolites({metabolite_1: 1}) reaction_1.lower_bound = 1 reaction_2.upper_bound = 2 infeasible_model.add_reactions([reaction_1, reaction_2]) return solver, old_solution, infeasible_model
def geometric_fba_model(): """ Generate geometric FBA model as described in [1]_ References ---------- .. [1] Smallbone, Kieran & Simeonidis, Vangelis. (2009). Flux balance analysis: A geometric perspective. Journal of theoretical biology.258. 311-5. 10.1016/j.jtbi.2009.01.027. """ test_model = Model("geometric_fba_paper_model") test_model.add_metabolites(Metabolite("A")) test_model.add_metabolites(Metabolite("B")) v_1 = Reaction("v1", upper_bound=1.0) v_1.add_metabolites({test_model.metabolites.A: 1.0}) v_2 = Reaction("v2", lower_bound=-1000.0) v_2.add_metabolites({ test_model.metabolites.A: -1.0, test_model.metabolites.B: 1.0 }) v_3 = Reaction("v3", lower_bound=-1000.0) v_3.add_metabolites({ test_model.metabolites.A: -1.0, test_model.metabolites.B: 1.0 }) v_4 = Reaction("v4", lower_bound=-1000.0) v_4.add_metabolites({ test_model.metabolites.A: -1.0, test_model.metabolites.B: 1.0 }) v_5 = Reaction("v5") v_5.add_metabolites({ test_model.metabolites.A: 0.0, test_model.metabolites.B: -1.0 }) test_model.add_reactions([v_1, v_2, v_3, v_4, v_5]) test_model.objective = "v5" return test_model
def test_get_turnover(): met = Metabolite("m1") r1 = Reaction("r1") r1.add_metabolites({met: -2}) r2 = Reaction("r2") r2.add_metabolites({met: 1}) solution = LegacySolution(f=1, x_dict={r1.id: 500, r2.id: 1000}) assert get_turnover(solution, met) == 1000 solution = Solution(objective_value=1, status="optimal", fluxes=pd.Series(data=[500, 1000], index=[r1.id, r2.id])) assert get_turnover(solution, met) == 1000
def test_add_reactions_duplicate(model): rxn = model.reactions[0] r1 = Reaction("r1") r1.add_metabolites({Metabolite("A"): -1, Metabolite("B"): 1}) r1.lower_bound, r1.upper_bound = -999999.0, 999999.0 r2 = Reaction(rxn.id) r2.add_metabolites({ Metabolite("A"): -1, Metabolite("C"): 1, Metabolite("D"): 1 }) model.add_reactions([r1, r2]) assert r1 in model.reactions assert rxn in model.reactions assert r2 is not model.reactions.get_by_id(rxn.id)
def test_gpr(self): model = Model() reaction = Reaction("test") # set a gpr to reaction not in a model reaction.gene_reaction_rule = "(g1 or g2) and g3" assert reaction.gene_reaction_rule == "(g1 or g2) and g3" assert len(reaction.genes) == 3 # adding reaction with a GPR propagates to the model model.add_reaction(reaction) assert len(model.genes) == 3 # ensure the gene objects are the same in the model and reaction reaction_gene = list(reaction.genes)[0] model_gene = model.genes.get_by_id(reaction_gene.id) assert reaction_gene is model_gene # test ability to handle uppercase AND/OR with warnings.catch_warnings(): warnings.simplefilter("ignore") reaction.gene_reaction_rule = "(b1 AND b2) OR (b3 and b4)" assert reaction.gene_reaction_rule == "(b1 and b2) or (b3 and b4)" assert len(reaction.genes) == 4 # ensure regular expressions correctly extract genes from malformed # GPR string with warnings.catch_warnings(): warnings.simplefilter("ignore") reaction.gene_reaction_rule = "(a1 or a2" assert len(reaction.genes) == 2 reaction.gene_reaction_rule = "(forT or " assert len(reaction.genes) == 1
def test_iadd(self, model): PGI = model.reactions.PGI EX_h2o = model.reactions.EX_h2o_e original_PGI_gpr = PGI.gene_reaction_rule PGI += EX_h2o assert PGI.gene_reaction_rule == original_PGI_gpr assert PGI.metabolites[model.metabolites.h2o_e] == -1.0 # original should not have changed assert EX_h2o.gene_reaction_rule == '' assert EX_h2o.metabolites[model.metabolites.h2o_e] == -1.0 # what about adding a reaction not in the model new_reaction = Reaction("test") new_reaction.add_metabolites({Metabolite("A"): -1, Metabolite("B"): 1}) PGI += new_reaction assert PGI.gene_reaction_rule == original_PGI_gpr assert len(PGI.gene_reaction_rule) == 5 # and vice versa new_reaction += PGI assert len(new_reaction.metabolites) == 5 # not assert len(new_reaction.genes) == 1 assert new_reaction.gene_reaction_rule == original_PGI_gpr # what about combining 2 gpr's model.reactions.ACKr += model.reactions.ACONTa expected_rule = '(b2296 or b3115 or b1849) and (b0118 or b1276)' assert model.reactions.ACKr.gene_reaction_rule == expected_rule assert len(model.reactions.ACKr.genes) == 5
def test_assess(self, model, solver): with model: assert assess(model, model.reactions.GLCpts, solver=solver) is True pyr = model.metabolites.pyr_c a = Metabolite('a') b = Metabolite('b') model.add_metabolites([a, b]) pyr_a2b = Reaction('pyr_a2b') pyr_a2b.add_metabolites({pyr: -1, a: -1, b: 1}) model.add_reactions([pyr_a2b]) res = assess(model, pyr_a2b, 0.01, solver=solver) expected = { 'precursors': { a: { 'required': 0.01, 'produced': 0.0 } }, 'products': { b: { 'required': 0.01, 'capacity': 0.0 } } } assert res == expected
def test__normalize_pseudoreaction_biomass_has_gpr(): reaction = Reaction('my_biomass_2') reaction.gene_reaction_rule = 'b1779' with pytest.raises(ConflictingPseudoreaction) as excinfo: _ = _normalize_pseudoreaction(reaction.id, reaction) assert 'has a gene_reaction_rule' in str(excinfo.value) assert reaction.id == 'my_biomass_2'
def test__has_gene_reaction_rule(): reaction = Reaction('rxn') assert _has_gene_reaction_rule(reaction) is False reaction.gene_reaction_rule = 'b1779' assert _has_gene_reaction_rule(reaction) is True reaction.gene_reaction_rule = ' ' assert _has_gene_reaction_rule(reaction) is False
def test_reverse_reaction(): model = Model() reaction = Reaction('AB') model.add_reaction(reaction) reaction.build_reaction_from_string('a --> b') _reverse_reaction(reaction) assert reaction.reaction == 'b <-- a'
def test__normalize_pseudoreaction_exchange_error_bad_coeff(): reaction = Reaction('EX_gone') reaction.add_metabolites({Metabolite('glu__L_e'): -2}) with pytest.raises(ConflictingPseudoreaction) as excinfo: _ = _normalize_pseudoreaction(reaction.id, reaction) assert 'with coefficient' in str(excinfo.value) assert reaction.id == 'EX_gone'
def test_prune_unused_rxns_output_type(self, model): # test that the output contains reaction objects reaction = Reaction('foo') model.add_reaction(reaction) model_pruned, unused = delete.prune_unused_reactions(model) assert isinstance(model_pruned, Model) assert isinstance(unused[0], Reaction)
def constrainSumOfFluxes(cobra_model, rxn2avoid, SFvalue, objvalue): from cobra.core import Metabolite, Reaction temp = cobra_model.copy() SFMet = Metabolite("SFMet", name="Sum of fluxes pseudometabolite", compartment="c2") for rxn in cobra_model.reactions: if not rxn2avoid.__contains__(rxn.id): if rxn.id.__contains__("reverse"): temp.reactions.get_by_id(rxn.id).add_metabolites({SFMet: -1}) else: temp.reactions.get_by_id(rxn.id).add_metabolites({SFMet: 1}) SFRxn = Reaction("SFRxn", name="Sum of fluxes pseudoreaction") SFRxn.add_metabolites({SFMet: -1}) SFRxn.lower_bound = SFvalue SFRxn.upper_bound = SFvalue temp.add_reaction(SFRxn) if (not objvalue == "") and (len( [rxn for rxn in temp.reactions if rxn.objective_coefficient == 1]) == 1): for rxn in [ rxn for rxn in temp.reactions if rxn.objective_coefficient == 1 ]: rxn.lower_bound = float(objvalue) rxn.upper_bound = float(objvalue) return temp
def test_add_reaction_context(self, model): old_reaction_count = len(model.reactions) old_metabolite_count = len(model.metabolites) dummy_metabolite_1 = Metabolite("test_foo_1") dummy_metabolite_2 = Metabolite("test_foo_2") actual_metabolite = model.metabolites[0] copy_metabolite = model.metabolites[1].copy() dummy_reaction = Reaction("test_foo_reaction") dummy_reaction.add_metabolites({ dummy_metabolite_1: -1, dummy_metabolite_2: 1, copy_metabolite: -2, actual_metabolite: 1 }) dummy_reaction.gene_reaction_rule = 'dummy_gene' with model: model.add_reaction(dummy_reaction) assert model.reactions.get_by_id(dummy_reaction.id) == \ dummy_reaction assert len(model.reactions) == old_reaction_count + 1 assert len(model.metabolites) == old_metabolite_count + 2 assert dummy_metabolite_1._model == model assert 'dummy_gene' in model.genes assert len(model.reactions) == old_reaction_count assert len(model.metabolites) == old_metabolite_count with pytest.raises(KeyError): model.reactions.get_by_id(dummy_reaction.id) assert dummy_metabolite_1._model is None assert 'dummy_gene' not in model.genes
def convert_modelreaction(self, reaction, bigg=False): mr_id = reaction.id name = reaction.name annotation = reaction.annotation lower_bound, upper_bound = reaction.get_reaction_constraints() id = build_rxn_id(mr_id) if bigg and "bigg.reaction" in annotation: id = annotation["bigg.reaction"] gpr = reaction.get_gpr() cobra_reaction = Reaction(id, name=name, lower_bound=lower_bound, upper_bound=upper_bound) cobra_reaction.annotation[self.SBO_ANNOTATION] = "SBO:0000176" #biochemical reaction cobra_reaction.annotation.update(annotation) if id.startswith('rxn'): cobra_reaction.annotation["seed.reaction"] = id.split("_")[0] cobra_reaction.add_metabolites(self.convert_modelreaction_stoichiometry(reaction)) cobra_reaction.gene_reaction_rule = reaction.gene_reaction_rule for genes in gpr: for gene in genes: if not gene in self.genes: self.genes[gene] = gene return cobra_reaction
def convert_ids_model(example_model): example_model.id = 'A bad id' example_model.add_reaction(Reaction('DADA')) example_model.reactions.get_by_id('DADA').add_metabolites({ Metabolite('dad_DASH_2_c'): -1 }) return convert_ids(example_model.copy())