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())
