def test_flux_variability(self):
fva_results = {
"5DGLCNtex": {"minimum": 0.0, "maximum": 0.0},
"ABTA": {"minimum": 0.0, "maximum": 0.0},
"5DOAN": {"minimum": 0.0, "maximum": 0.0},
"A5PISO": {"minimum": 0.00692, "maximum": 0.00692},
"AACPS1": {"minimum": 0.0, "maximum": 0.0},
"AACPS2": {"minimum": 0.0, "maximum": 0.0},
"ACALDtex": {"minimum": 0.0, "maximum": 0.0},
"AACPS3": {"minimum": 0.0, "maximum": 0.0},
"AACPS4": {"minimum": 0.0, "maximum": 0.0},
"ABUTD": {"minimum": 0.0, "maximum": 0.0},
"AACPS5": {"minimum": 0.0, "maximum": 0.0},
"AACPS6": {"minimum": 0.0, "maximum": 0.0},
"AACPS7": {"minimum": 0.0, "maximum": 0.0},
"AACPS8": {"minimum": 0.0, "maximum": 0.0},
"AACPS9": {"minimum": 0.0, "maximum": 0.0},
"AACTOOR": {"minimum": 0.0, "maximum": 0.0},
"ABUTt2pp": {"minimum": 0.0, "maximum": 0.0},
"3OAS140": {"minimum": 0.50419, "maximum": 0.50419},
"3OAS141": {"minimum": 0.03748, "maximum": 0.03748},
"3OAS160": {"minimum": 0.41769, "maximum": 0.41769},
"3OAS161": {"minimum": 0.03748, "maximum": 0.03748},
"3OAS180": {"minimum": 0.01071, "maximum": 0.01071},
"3OAS181": {"minimum": 0.01606, "maximum": 0.01606},
"ABUTtex": {"minimum": 0.0, "maximum": 0.0},
"3OAS60": {"minimum": 0.54399, "maximum": 0.54399},
"3OAS80": {"minimum": 0.54399, "maximum": 0.54399},
"AAMYL": {"minimum": 0.0, "maximum": 0.0},
"3PEPTabcpp": {"minimum": 0.0, "maximum": 0.0},
"3PEPTtex": {"minimum": 0.0, "maximum": 0.0},
"3UMPtex": {"minimum": 0.0, "maximum": 0.0},
"4HOXPACDtex": {"minimum": 0.0, "maximum": 0.0},
"ACACtex": {"minimum": 0.0, "maximum": 0.0},
"4PCP": {"minimum": 0.0, "maximum": 0.0},
"4PCPpp": {"minimum": 0.0, "maximum": 0.0},
"AAMYLpp": {"minimum": 0.0, "maximum": 0.0},
"4PEPTabcpp": {"minimum": 0.0, "maximum": 0.0},
"4PEPTtex": {"minimum": 0.0, "maximum": 0.0},
"5DGLCNR": {"minimum": 0.0, "maximum": 0.0},
"5DGLCNt2rpp": {"minimum": 0.0, "maximum": 0.0},
"ACALD": {"minimum": 3.35702, "maximum": 7.49572},
}
infeasible_model = create_test_model()
infeasible_model.reactions.get_by_id("EX_glyc_e").lower_bound = 0
for solver in solver_dict:
# esolver is really slow
if solver == "esolver":
continue
cobra_model = create_test_model()
initialize_growth_medium(cobra_model, "LB")
fva_out = flux_variability_analysis(
cobra_model, solver=solver, reaction_list=cobra_model.reactions[100:140:2]
)
for the_reaction, the_range in iteritems(fva_out):
for k, v in iteritems(the_range):
self.assertAlmostEqual(fva_results[the_reaction][k], v, places=5)
# ensure that an infeasible model does not run FVA
self.assertRaises(ValueError, flux_variability_analysis, infeasible_model, solver=solver)
def test_modify_reversible(self):
model1 = create_test_model("textbook")
model1.optimize()
model2 = create_test_model("textbook")
modify.convert_to_irreversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
modify.revert_to_reversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
# Ensure revert_to_reversible is robust to solutions generated both
# before and after reversibility conversion, or not solved at all.
model3 = create_test_model("textbook")
model3.optimize()
modify.convert_to_irreversible(model3)
modify.revert_to_reversible(model3)
self.assertAlmostEqual(model1.solution.f, model3.solution.f, places=3)
# test reaction where both bounds are negative
model4 = create_test_model("textbook")
glc = model4.reactions.get_by_id("EX_glc__D_e")
glc.upper_bound = -1
modify.convert_to_irreversible(model4)
model4.optimize()
self.assertAlmostEqual(model1.solution.f, model4.solution.f, places=3)
glc_rev = model4.reactions.get_by_id(glc.notes["reflection"])
self.assertEqual(glc_rev.lower_bound, 1)
self.assertEqual(glc.upper_bound, 0)
modify.revert_to_reversible(model4)
self.assertEqual(glc.upper_bound, -1)
def test_flux_variability(self):
fva_results = {
'5DGLCNtex': {'minimum': 0.0, 'maximum': 0.0},
'ABTA': {'minimum': 0.0, 'maximum': 0.0},
'5DOAN': {'minimum': 0.0, 'maximum': 0.0},
'A5PISO': {'minimum': 0.00692, 'maximum': 0.00692},
'AACPS1': {'minimum': 0.0, 'maximum': 0.0},
'AACPS2': {'minimum': 0.0, 'maximum': 0.0},
'ACALDtex': {'minimum': 0.0, 'maximum': 0.0},
'AACPS3': {'minimum': 0.0, 'maximum': 0.0},
'AACPS4': {'minimum': 0.0, 'maximum': 0.0},
'ABUTD': {'minimum': 0.0, 'maximum': 0.0},
'AACPS5': {'minimum': 0.0, 'maximum': 0.0},
'AACPS6': {'minimum': 0.0, 'maximum': 0.0},
'AACPS7': {'minimum': 0.0, 'maximum': 0.0},
'AACPS8': {'minimum': 0.0, 'maximum': 0.0},
'AACPS9': {'minimum': 0.0, 'maximum': 0.0},
'AACTOOR': {'minimum': 0.0, 'maximum': 0.0},
'ABUTt2pp': {'minimum': 0.0, 'maximum': 0.0},
'3OAS140': {'minimum': 0.50419, 'maximum': 0.50419},
'3OAS141': {'minimum': 0.03748, 'maximum': 0.03748},
'3OAS160': {'minimum': 0.41769, 'maximum': 0.41769},
'3OAS161': {'minimum': 0.03748, 'maximum': 0.03748},
'3OAS180': {'minimum': 0.01071, 'maximum': 0.01071},
'3OAS181': {'minimum': 0.01606, 'maximum': 0.01606},
'ABUTtex': {'minimum': 0.0, 'maximum': 0.0},
'3OAS60': {'minimum': 0.54399, 'maximum': 0.54399},
'3OAS80': {'minimum': 0.54399, 'maximum': 0.54399},
'AAMYL': {'minimum': 0.0, 'maximum': 0.0},
'3PEPTabcpp': {'minimum': 0.0, 'maximum': 0.0},
'3PEPTtex': {'minimum': 0.0, 'maximum': 0.0},
'3UMPtex': {'minimum': 0.0, 'maximum': 0.0},
'4HOXPACDtex': {'minimum': 0.0, 'maximum': 0.0},
'ACACtex': {'minimum': 0.0, 'maximum': 0.0},
'4PCP': {'minimum': 0.0, 'maximum': 0.0},
'4PCPpp': {'minimum': 0.0, 'maximum': 0.0},
'AAMYLpp': {'minimum': 0.0, 'maximum': 0.0},
'4PEPTabcpp': {'minimum': 0.0, 'maximum': 0.0},
'4PEPTtex': {'minimum': 0.0, 'maximum': 0.0},
'5DGLCNR': {'minimum': 0.0, 'maximum': 0.0},
'5DGLCNt2rpp': {'minimum': 0.0, 'maximum': 0.0},
'ACALD': {'minimum': 3.35702, 'maximum': 7.49572}}
infeasible_model = create_test_model()
infeasible_model.reactions.get_by_id("EX_glyc_e").lower_bound = 0
for solver in solver_dict:
cobra_model = create_test_model()
initialize_growth_medium(cobra_model, 'LB')
fva_out = flux_variability_analysis(
cobra_model, solver=solver,
reaction_list=cobra_model.reactions[100:140:2])
for the_reaction, the_range in iteritems(fva_out):
for k, v in iteritems(the_range):
self.assertAlmostEqual(fva_results[the_reaction][k], v,
places=5)
# ensure that an infeasible model does not run FVA
self.assertRaises(ValueError, flux_variability_analysis,
infeasible_model, solver=solver)
def test_add_reaction_from_other_model(self):
model = self.model
other = model.copy()
for i in other.reactions:
i.id += "_other"
other.repair()
model.add_reactions(other.reactions)
# what if the other reaction has an error in its GPR
m1 = create_test_model("textbook")
m2 = create_test_model("textbook")
m1.reactions.PGI.remove_from_model()
m2.genes.b4025._reaction.clear()
m1.add_reaction(m2.reactions.PGI)
def test_double_gene_deletion(self):
cobra_model = create_test_model("textbook")
genes = ["b0726", "b4025", "b0724", "b0720",
"b2935", "b2935", "b1276", "b1241"]
growth_list = [
[0.858, 0.857, 0.814, 0.000, 0.858, 0.858, 0.858, 0.858],
[0.857, 0.863, 0.739, 0.000, 0.863, 0.863, 0.863, 0.863],
[0.814, 0.739, 0.814, 0.000, 0.814, 0.814, 0.814, 0.814],
[0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000],
[0.858, 0.863, 0.814, 0.000, 0.874, 0.874, 0.874, 0.874],
[0.858, 0.863, 0.814, 0.000, 0.874, 0.874, 0.874, 0.874],
[0.858, 0.863, 0.814, 0.000, 0.874, 0.874, 0.874, 0.874],
[0.858, 0.863, 0.814, 0.000, 0.874, 0.874, 0.874, 0.874]]
opts = {"number_of_processes": 1} if name == "nt" else {}
solution = double_gene_deletion(cobra_model, gene_list1=genes, **opts)
self.assertEqual(solution["x"], genes)
self.assertEqual(solution["y"], genes)
self.compare_matrices(growth_list, solution["data"])
# test when lists differ slightly
solution = double_gene_deletion(cobra_model, gene_list1=genes[:-1],
gene_list2=genes,
number_of_processes=1)
self.assertEqual(solution["x"], genes[:-1])
self.assertEqual(solution["y"], genes)
self.compare_matrices(growth_list[:-1], solution["data"])
def test_validate_reaction_bounds(self):
model = create_test_model("textbook")
model.reactions[0].lower_bound = float("-inf")
model.reactions[1].lower_bound = float("nan")
model.reactions[0].upper_bound = float("inf")
model.reactions[1].upper_bound = float("nan")
errors = check_reaction_bounds(model)
self.assertEqual(len(errors), 4)
def test_phenotype_phase_plane(self):
model = create_test_model("textbook")
data = calculate_phenotype_phase_plane(
model, "EX_glc__D_e", "EX_o2_e",
reaction1_npoints=20, reaction2_npoints=20)
self.assertEqual(data.growth_rates.shape, (20, 20))
self.assertAlmostEqual(data.growth_rates.max(), 1.20898, places=4)
self.assertAlmostEqual(abs(data.growth_rates[0, :]).max(), 0, places=4)
def test_pFBA(self):
model = create_test_model("textbook")
for solver in solver_dict:
optimize_minimal_flux(model, solver=solver)
abs_x = [abs(i) for i in model.solution.x]
self.assertEqual(model.solution.status, "optimal")
self.assertAlmostEqual(model.solution.f, 0.8739, places=3)
self.assertAlmostEqual(sum(abs_x), 518.4221, places=3)
def test_single_gene_deletion_fba(self):
cobra_model = create_test_model("textbook")
# expected knockouts for textbook model
growth_dict = {"b0008": 0.87, "b0114": 0.80, "b0116": 0.78, "b2276": 0.21, "b1779": 0.00}
rates, statuses = single_gene_deletion(cobra_model, gene_list=growth_dict.keys(), method="fba")
for gene, expected_value in iteritems(growth_dict):
self.assertEqual(statuses[gene], "optimal")
self.assertAlmostEqual(rates[gene], expected_value, places=2)
def test_flux_variability(self):
with open(join(data_directory, "textbook_fva.json"), "r") as infile:
fva_results = load(infile)
infeasible_model = create_test_model("textbook")
infeasible_model.reactions.get_by_id("EX_glc__D_e").lower_bound = 0
for solver in solver_dict:
# esolver is really slow
if solver == "esolver":
continue
cobra_model = create_test_model("textbook")
fva_out = flux_variability_analysis(cobra_model, solver=solver, reaction_list=cobra_model.reactions[1::3])
for name, result in iteritems(fva_out):
for k, v in iteritems(result):
self.assertAlmostEqual(fva_results[name][k], v, places=5)
# ensure that an infeasible model does not run FVA
self.assertRaises(ValueError, flux_variability_analysis, infeasible_model, solver=solver)
def test_phenotype_phase_plane(self):
model = create_test_model("textbook")
data = calculate_phenotype_phase_plane(model,
"EX_glc__D_e",
"EX_o2_e",
reaction1_npoints=20,
reaction2_npoints=20)
self.assertEqual(data.growth_rates.shape, (20, 20))
self.assertAlmostEqual(data.growth_rates.max(), 1.20898, places=4)
self.assertAlmostEqual(abs(data.growth_rates[0, :]).max(), 0, places=4)
def test_find_blocked_reactions(self):
m = create_test_model("textbook")
result = find_blocked_reactions(m, m.reactions[40:46])
self.assertEqual(result, ["FRUpts2"])
result = find_blocked_reactions(m, m.reactions[42:48])
self.assertEqual(set(result), {"FUMt2_2", "FRUpts2"})
result = find_blocked_reactions(m, m.reactions[30:50], open_exchanges=True)
self.assertEqual(result, [])
def test_modify_reversible(self):
model1 = self.model
model1.optimize()
model2 = create_test_model()
modify.convert_to_irreversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
modify.revert_to_reversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
def test_modify_reversible(self):
model1 = self.model
model1.optimize()
model2 = create_test_model()
modify.convert_to_irreversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
modify.revert_to_reversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
def test_summary_methods(self):
# Test model summary methods
model = create_test_model("textbook")
model.optimize()
desired_entries = [
u'glc__D_e -9.76 \u00B1 0.24'
u'co2_e 21.81 \u00B1 2.86',
u'nh4_e -4.84 \u00B1 0.32'
u'h_e 19.51 \u00B1 2.86',
u'pi_e -3.13 \u00B1 0.08'
u'for_e 2.86 \u00B1 2.86',
u'ac_e 0.95 \u00B1 0.95',
u'acald_e 0.64 \u00B1 0.64',
u'pyr_e 0.64 \u00B1 0.64',
u'etoh_e 0.55 \u00B1 0.55',
u'lac__D_e 0.54 \u00B1 0.54',
u'succ_e 0.42 \u00B1 0.42',
u'akg_e 0.36 \u00B1 0.36',
u'glu__L_e 0.32 \u00B1 0.32']
with captured_output() as (out, err):
model.summary(fva=0.95)
output = out.getvalue().strip()
output_set = set((re.sub('\s', '', l) for l in output.splitlines()))
for item in desired_entries:
self.assertIn(re.sub('\s', '', item), output_set)
# Test metabolite summary methods
desired_entries = [
'PRODUCING REACTIONS -- Ubiquinone-8',
'-----------------------------------',
'% FLUX RXN ID'
'REACTION',
'100.0% 44 CYTBD'
'2.0 h_c + 0.5 o2_c + q8h2_c --> h2o_c + 2.0 h_e +...',
'CONSUMING REACTIONS -- Ubiquinone-8',
'-----------------------------------',
'88.4% -39 NADH16'
'4.0 h_c + nadh_c + q8_c --> 3.0 h_e + nad_c + q8h2_c',
'11.6% -5.1 SUCDi '
'q8_c + succ_c --> fum_c + q8h2_c',
]
with captured_output() as (out, err):
model.metabolites.q8_c.summary()
output = out.getvalue().strip()
output_set = set((re.sub('\s', '', l) for l in output.splitlines()))
for item in desired_entries:
self.assertIn(re.sub('\s', '', item), output_set)
def test_optknock(self):
model = create_test_model("textbook")
model.reactions.get_by_id("EX_o2_e").lower_bound = 0
knockable_reactions = ["ACKr", "AKGDH", "ACALD", "LDH_D"]
optknock_problem = set_up_optknock(model, "EX_lac__D_e",
knockable_reactions, n_knockouts=2,
copy=False)
solution = run_optknock(optknock_problem, tolerance_integer=1e-9)
self.assertIn("ACKr", solution.knockouts)
self.assertIn("ACALD", solution.knockouts)
self.assertAlmostEqual(solution.f, 17.891, places=3)
def test_validate_mass_balance(self):
model = create_test_model("textbook")
self.assertEqual(len(check_mass_balance(model)), 0)
# if we remove the SBO term which marks the reaction as
# mass balanced, then the reaction should be detected as
# no longer mass balanced
EX_rxn = model.reactions.query("EX")[0]
EX_rxn.annotation.pop("SBO")
balance = check_mass_balance(model)
self.assertEqual(len(balance), 1)
self.assertIn(EX_rxn, balance)
def test_canonical_form(self):
model = create_test_model("textbook")
# add G constraint to test
g_constr = Metabolite("SUCCt2_2__test_G_constraint")
g_constr._constraint_sense = "G"
g_constr._bound = 5.0
model.reactions.get_by_id("SUCCt2_2").add_metabolites({g_constr: 1})
self.assertAlmostEqual(model.optimize("maximize").f, 0.855, places=3)
# convert to canonical form
model = canonical_form(model)
self.assertAlmostEqual(model.optimize("maximize").f, 0.855, places=3)
def test_validate_mass_balance(self):
model = create_test_model("textbook")
self.assertEqual(len(check_mass_balance(model)), 0)
# if we remove the SBO term which marks the reaction as
# mass balanced, then the reaction should be detected as
# no longer mass balanced
EX_rxn = model.reactions.query("EX")[0]
EX_rxn.annotation.pop("SBO")
balance = check_mass_balance(model)
self.assertEqual(len(balance), 1)
self.assertIn(EX_rxn, balance)
def test_canonical_form(self):
model = create_test_model("textbook")
# add G constraint to test
g_constr = Metabolite("SUCCt2_2__test_G_constraint")
g_constr._constraint_sense = "G"
g_constr._bound = 5.0
model.reactions.get_by_id("SUCCt2_2").add_metabolites({g_constr: 1})
self.assertAlmostEqual(model.optimize("maximize").f, 0.855, places=3)
# convert to canonical form
model = canonical_form(model)
self.assertAlmostEqual(model.optimize("maximize").f, 0.855, places=3)
def test_find_blocked_reactions(self):
m = create_test_model("textbook")
result = find_blocked_reactions(m, m.reactions[40:46])
self.assertEqual(result, ['FRUpts2'])
result = find_blocked_reactions(m, m.reactions[42:48])
self.assertEqual(set(result), {'FUMt2_2', 'FRUpts2'})
result = find_blocked_reactions(m, m.reactions[30:50],
open_exchanges=True)
self.assertEqual(result, [])
def test_phenotype_phase_plane(self):
model = create_test_model("textbook")
data = calculate_phenotype_phase_plane(
model, "EX_glc__D_e", "EX_o2_e",
reaction1_npoints=20, reaction2_npoints=20)
self.assertEqual(data.growth_rates.shape, (20, 20))
self.assertAlmostEqual(data.growth_rates.max(), 1.20898, places=4)
self.assertAlmostEqual(abs(data.growth_rates[0, :]).max(), 0, places=4)
if matplotlib is None:
self.skipTest("can't test plots without matplotlib")
data.plot()
def test_single_reaction_deletion(self):
cobra_model = create_test_model("textbook")
expected_results = {"FBA": 0.70404, "FBP": 0.87392, "CS": 0, "FUM": 0.81430, "GAPD": 0, "GLUDy": 0.85139}
results, status = single_reaction_deletion(cobra_model, reaction_list=expected_results.keys())
self.assertEqual(len(results), 6)
self.assertEqual(len(status), 6)
for status_value in status.values():
self.assertEqual(status_value, "optimal")
for reaction, value in results.items():
self.assertAlmostEqual(value, expected_results[reaction], 5)
def test_phenotype_phase_plane(self):
model = create_test_model("textbook")
data = calculate_phenotype_phase_plane(
model, "EX_glc__D_e", "EX_o2_e", reaction1_npoints=20, reaction2_npoints=20
)
self.assertEqual(data.growth_rates.shape, (20, 20))
self.assertAlmostEqual(data.growth_rates.max(), 1.20898, places=4)
self.assertAlmostEqual(abs(data.growth_rates[0, :]).max(), 0, places=4)
if matplotlib is None:
self.skipTest("can't test plots without matplotlib")
data.plot()
def test_pFBA(self):
model = create_test_model("textbook")
for solver in solver_dict:
optimize_minimal_flux(model, solver=solver)
abs_x = [abs(i) for i in model.solution.x]
self.assertEqual(model.solution.status, "optimal")
self.assertAlmostEqual(model.solution.f, 0.8739, places=3)
self.assertAlmostEqual(sum(abs_x), 518.4221, places=3)
# Test desired_objective_value
desired_objective = 0.8
optimize_minimal_flux(model,
solver=solver,
desired_objective_value=desired_objective)
abs_x = [abs(i) for i in model.solution.x]
self.assertEqual(model.solution.status, "optimal")
self.assertAlmostEqual(model.solution.f,
desired_objective,
places=3)
self.assertAlmostEqual(sum(abs_x), 476.1594, places=3)
# Test fraction_of_optimum
optimize_minimal_flux(model,
solver=solver,
fraction_of_optimum=0.95)
abs_x = [abs(i) for i in model.solution.x]
self.assertEqual(model.solution.status, "optimal")
self.assertAlmostEqual(model.solution.f, 0.95 * 0.8739, places=3)
self.assertAlmostEqual(sum(abs_x), 493.4400, places=3)
# Make sure the model works for non-unity objective values
model.reactions.Biomass_Ecoli_core.objective_coefficient = 2
optimize_minimal_flux(model, solver=solver)
self.assertAlmostEqual(model.solution.f, 2 * 0.8739, places=3)
model.reactions.Biomass_Ecoli_core.objective_coefficient = 1
# Test some erroneous inputs -- multiple objectives
model.reactions.ATPM.objective_coefficient = 1
with self.assertRaises(ValueError):
optimize_minimal_flux(model, solver=solver)
model.reactions.ATPM.objective_coefficient = 0
# Minimization of objective
with self.assertRaises(ValueError):
optimize_minimal_flux(model,
solver=solver,
objective_sense='minimize')
# Infeasible solution
atpm = float(model.reactions.ATPM.lower_bound)
model.reactions.ATPM.lower_bound = 500
with self.assertRaises(ValueError):
optimize_minimal_flux(model, solver=solver)
model.reactions.ATPM.lower_bound = atpm
def test_single_gene_deletion_fba(self):
cobra_model = create_test_model("textbook")
# expected knockouts for textbook model
growth_dict = {"b0008": 0.87, "b0114": 0.80, "b0116": 0.78,
"b2276": 0.21, "b1779": 0.00}
rates, statuses = single_gene_deletion(cobra_model,
gene_list=growth_dict.keys(),
method="fba")
for gene, expected_value in iteritems(growth_dict):
self.assertEqual(statuses[gene], 'optimal')
self.assertAlmostEqual(rates[gene], expected_value, places=2)
def test_dual_integer_vars_as_lp(self):
model = create_test_model("textbook")
var = _add_decision_variable(model, "AKGDH")
self.assertAlmostEqual(model.optimize("maximize").f, 0.874, places=3)
# as lp: make integer continuous, set to 1
dual = dual_problem(model, "maximize", [var.id], copy=True)
r = dual.reactions.get_by_id(var.id)
r.variable_kind = "continuous"
r.lower_bound = r.upper_bound = 1
self.assertAlmostEqual(dual.optimize("minimize").f, 0.874, places=3)
r.lower_bound = r.upper_bound = 0
self.assertAlmostEqual(dual.optimize("minimize").f, 0.858, places=3)
def test_flux_variability(self):
with open(join(data_directory, "textbook_fva.json"), "r") as infile:
fva_results = load(infile)
infeasible_model = create_test_model("textbook")
infeasible_model.reactions.get_by_id("EX_glc__D_e").lower_bound = 0
for solver in solver_dict:
# esolver is really slow
if solver == "esolver":
continue
cobra_model = create_test_model("textbook")
fva_out = flux_variability_analysis(
cobra_model, solver=solver,
reaction_list=cobra_model.reactions[1::3])
for name, result in iteritems(fva_out):
for k, v in iteritems(result):
self.assertAlmostEqual(fva_results[name][k], v, places=5)
# ensure that an infeasible model does not run FVA
self.assertRaises(ValueError, flux_variability_analysis,
infeasible_model, solver=solver)
def test_rename_gene(self):
model = create_test_model('textbook')
original_name = model.genes.b1241.name
modify.rename_genes(model, {"b1241": "foo", "hello": "world"})
self.assertNotIn("b1241", model.genes)
self.assertIn("foo", model.genes)
# make sure the object name was preserved
self.assertEqual(model.genes.foo.name, original_name)
# make sure the reactions are correct
self.assertEqual(len(model.genes.foo.reactions), 2)
self.assertEqual(model.reactions.ACALD.gene_reaction_rule,
"b0351 or foo")
def test_summary_methods(self):
# Test model summary methods
model = create_test_model("textbook")
model.optimize()
desired_entries = [
u'glc__D_e -9.76 \u00B1 0.24'
u'co2_e 21.81 \u00B1 2.86', u'nh4_e -4.84 \u00B1 0.32'
u'h_e 19.51 \u00B1 2.86', u'pi_e -3.13 \u00B1 0.08'
u'for_e 2.86 \u00B1 2.86', u'ac_e 0.95 \u00B1 0.95',
u'acald_e 0.64 \u00B1 0.64', u'pyr_e 0.64 \u00B1 0.64',
u'etoh_e 0.55 \u00B1 0.55', u'lac__D_e 0.54 \u00B1 0.54',
u'succ_e 0.42 \u00B1 0.42', u'akg_e 0.36 \u00B1 0.36',
u'glu__L_e 0.32 \u00B1 0.32'
]
with captured_output() as (out, err):
model.summary(fva=0.95)
self.check_entries(out, desired_entries)
# test non-fva version (these should be fixed for textbook model
desired_entries = [
"o2_e -21.80", "glc__D_e -10.00", "nh4_e -4.77",
"pi_e -3.21", "h2o_e 29.18", "co2_e 22.81",
"h_e 17.53", "Biomass_Ecoli_core 0.874"
]
# Need to use a different method here because
# there are multiple entries per line.
with captured_output() as (out, err):
model.summary()
s = out.getvalue()
for i in desired_entries:
self.assertIn(i, s)
# Test metabolite summary methods
desired_entries = [
'PRODUCING REACTIONS -- Ubiquinone-8',
'-----------------------------------',
'% FLUX RXN ID'
'REACTION',
'100.0% 44 CYTBD'
'2.0 h_c + 0.5 o2_c + q8h2_c --> h2o_c + 2.0 h_e +...',
'CONSUMING REACTIONS -- Ubiquinone-8',
'-----------------------------------',
'88.4% -39 NADH16'
'4.0 h_c + nadh_c + q8_c --> 3.0 h_e + nad_c + q8h2_c',
'11.6% -5.1 SUCDi '
'q8_c + succ_c --> fum_c + q8h2_c',
]
with captured_output() as (out, err):
model.metabolites.q8_c.summary()
self.check_entries(out, desired_entries)
def test_single_reaction_deletion(self):
cobra_model = create_test_model("textbook")
expected_results = {'FBA': 0.70404, 'FBP': 0.87392, 'CS': 0,
'FUM': 0.81430, 'GAPD': 0, 'GLUDy': 0.85139}
results, status = single_reaction_deletion(
cobra_model, reaction_list=expected_results.keys())
self.assertEqual(len(results), 6)
self.assertEqual(len(status), 6)
for status_value in status.values():
self.assertEqual(status_value, "optimal")
for reaction, value in results.items():
self.assertAlmostEqual(value, expected_results[reaction], 5)
def test_canonical_form_minimize(self):
model = create_test_model("textbook")
# make a minimization problem
model.reactions.get_by_id("Biomass_Ecoli_core").lower_bound = 0.5
for reaction in model.reactions:
reaction.objective_coefficient = reaction.id == "GAPD"
self.assertAlmostEqual(model.optimize("minimize").f, 6.27, places=3)
# convert to canonical form. Convert minimize to maximize
model = canonical_form(model, objective_sense="minimize")
self.assertAlmostEqual(model.optimize("maximize").f, -6.27, places=3)
# lower bounds should now be <= constraints
self.assertEqual(
model.reactions.get_by_id("Biomass_Ecoli_core").lower_bound, 0.0)
def test_modify_reversible(self):
model1 = self.model
model1.optimize()
model2 = create_test_model()
modify.convert_to_irreversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
modify.revert_to_reversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
# Ensure revert_to_reversible is robust to solutions generated both
# before and after reversibility conversion, or not solved at all.
model3 = create_test_model()
model3.optimize()
modify.convert_to_irreversible(model3)
modify.revert_to_reversible(model3)
self.assertAlmostEqual(model1.solution.f, model3.solution.f, places=3)
model4 = create_test_model()
modify.convert_to_irreversible(model4)
modify.revert_to_reversible(model4)
def setUp(self):
self.solver = solvers.solver_dict[self.solver_name]
self.model = create_test_model()
self.old_solution = 0.380008
self.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
self.infeasible_model.add_reactions([reaction_1, reaction_2])
def test_canonical_form_minimize(self):
model = create_test_model("textbook")
# make a minimization problem
model.reactions.get_by_id("Biomass_Ecoli_core").lower_bound = 0.5
for reaction in model.reactions:
reaction.objective_coefficient = reaction.id == "GAPD"
self.assertAlmostEqual(model.optimize("minimize").f, 6.27, places=3)
# convert to canonical form. Convert minimize to maximize
model = canonical_form(model, objective_sense="minimize")
self.assertAlmostEqual(model.optimize("maximize").f, -6.27, places=3)
# lower bounds should now be <= constraints
self.assertEqual(
model.reactions.get_by_id("Biomass_Ecoli_core").lower_bound, 0.0)
def test_array_based_model_add(self):
for matrix_type in ["scipy.dok_matrix", "scipy.lil_matrix"]:
model = create_test_model().to_array_based_model(matrix_type=matrix_type)
test_reaction = Reaction("test")
test_reaction.add_metabolites({model.metabolites[0]: 4})
test_reaction.lower_bound = -3.14
model.add_reaction(test_reaction)
self.assertEqual(len(model.reactions), 2547)
self.assertEqual(model.S.shape[1], 2547)
self.assertEqual(len(model.lower_bounds), 2547)
self.assertEqual(model.S[0, 2546], 4)
self.assertEqual(model.S[1605, 0], -1)
self.assertEqual(model.lower_bounds[2546], -3.14)
def setUp(self):
self.solver = solvers.solver_dict[self.solver_name]
self.model = create_test_model("textbook")
self.old_solution = 0.8739215
self.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
self.infeasible_model.add_reactions([reaction_1, reaction_2])
def test_modify_reversible(self):
model1 = create_test_model("textbook")
model1.optimize()
model2 = create_test_model("textbook")
modify.convert_to_irreversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
modify.revert_to_reversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
# Ensure revert_to_reversible is robust to solutions generated both
# before and after reversibility conversion, or not solved at all.
model3 = create_test_model("textbook")
model3.optimize()
modify.convert_to_irreversible(model3)
modify.revert_to_reversible(model3)
self.assertAlmostEqual(model1.solution.f, model3.solution.f, places=3)
model4 = create_test_model("textbook")
modify.convert_to_irreversible(model4)
modify.revert_to_reversible(model4)
def test_flux_variability(self):
fva_results = {
'5DGLCNtex': {'minimum': -1.9748300208638403e-05, 'maximum': 0.0},
'ABTA': {'minimum': 0.0, 'maximum': 0.00014811225541408996},
'5DOAN': {'minimum': 0.0, 'maximum': 3.2227507421302166e-06},
'A5PISO': {'minimum': 0.006920856282000001, 'maximum': 0.006922717378372606},
'AACPS1': {'minimum': 0.0, 'maximum': 3.7028063376249126e-05},
'AACPS2': {'minimum': 0.0, 'maximum': 3.7028063733878864e-05},
'ACALDtex': {'minimum': -0.00011848980305159615, 'maximum': 0.0},
'AACPS3': {'minimum': 0.0, 'maximum': 3.702806337623859e-05},
'AACPS4': {'minimum': 0.0, 'maximum': 3.702806373387888e-05},
'ABUTD': {'minimum': 0.0, 'maximum': 0.00014811225541406058},
'AACPS5': {'minimum': 0.0, 'maximum': 2.8211857518389774e-05},
'AACPS6': {'minimum': 0.0, 'maximum': 2.821185753295664e-05},
'AACPS7': {'minimum': 0.0, 'maximum': 3.702806368868028e-05},
'AACPS8': {'minimum': 0.0, 'maximum': 3.702806338788376e-05},
'AACPS9': {'minimum': 0.0, 'maximum': 3.702806309933293e-05},
'AACTOOR': {'minimum': 0.0, 'maximum': 1.5388286124597477e-05},
'ABUTt2pp': {'minimum': 0.0, 'maximum': 0.0},
'3OAS140': {'minimum': 0.5041754136687804, 'maximum': 0.5042009621703677},
'3OAS141': {'minimum': 0.037484893950000084, 'maximum': 0.03750284695065363},
'3OAS160': {'minimum': 0.41767086529953557, 'maximum': 0.41769641380045963},
'3OAS161': {'minimum': 0.03748489395, 'maximum': 0.03750284695060761},
'3OAS180': {'minimum': 0.01069201669939239, 'maximum': 0.010717565200387778},
'3OAS181': {'minimum': 0.01606495455, 'maximum': 0.01608290755044158},
'ABUTtex': {'minimum': 0.0, 'maximum': 0.0},
'3OAS60': {'minimum': 0.5439852127139995, 'maximum': 0.5439896193596934},
'3OAS80': {'minimum': 0.5439852127140001, 'maximum': 0.5439896193596934},
'AAMYL': {'minimum': 0.0, 'maximum': 0.0},
'3PEPTabcpp': {'minimum': 0.0, 'maximum': 5.808323730923103e-06},
'3PEPTtex': {'minimum': -3.4245609402880297e-06, 'maximum': 0.0},
'3UMPtex': {'minimum': 0.0, 'maximum': 0.0},
'4HOXPACDtex': {'minimum': 0.0, 'maximum': 0.0},
'ACACtex': {'minimum': 0.0, 'maximum': 0.0},
'4PCP': {'minimum': 0.0, 'maximum': 6.171343917391756e-06},
'4PCPpp': {'minimum': 0.0, 'maximum': 5.58914186256664e-06},
'AAMYLpp': {'minimum': 0.0, 'maximum': 0.0},
'4PEPTabcpp': {'minimum': 0.0, 'maximum': 5.696625084349692e-06},
'4PEPTtex': {'minimum': -3.2198316806921494e-06, 'maximum': 0.0},
'5DGLCNR': {'minimum': -2.1942555793285538e-05, 'maximum': 0.0},
'5DGLCNt2rpp': {'minimum': -1.9748300208638403e-05, 'maximum': 0.0},
'ACALD': {'minimum': 3.356574143593833, 'maximum': 7.4957163478682105}}
for solver in solver_dict:
cobra_model = create_test_model()
initialize_growth_medium(cobra_model, 'LB')
fva_out = flux_variability_analysis(cobra_model, solver=solver,
reaction_list=cobra_model.reactions[100:140])
for the_reaction, the_range in fva_out.iteritems():
for k, v in the_range.iteritems():
self.assertAlmostEqual(fva_results[the_reaction][k], v, places=3)
def test_pFBA(self):
model = create_test_model("textbook")
for solver in solver_dict:
optimize_minimal_flux(model, solver=solver)
abs_x = [abs(i) for i in model.solution.x]
self.assertEqual(model.solution.status, "optimal")
self.assertAlmostEqual(model.solution.f, 0.8739, places=3)
self.assertAlmostEqual(sum(abs_x), 518.4221, places=3)
# Test desired_objective_value
desired_objective = 0.8
optimize_minimal_flux(model, solver=solver,
desired_objective_value=desired_objective)
abs_x = [abs(i) for i in model.solution.x]
self.assertEqual(model.solution.status, "optimal")
self.assertAlmostEqual(model.solution.f, desired_objective,
places=3)
self.assertAlmostEqual(sum(abs_x), 476.1594, places=3)
# Test fraction_of_optimum
optimize_minimal_flux(model, solver=solver,
fraction_of_optimum=0.95)
abs_x = [abs(i) for i in model.solution.x]
self.assertEqual(model.solution.status, "optimal")
self.assertAlmostEqual(model.solution.f, 0.95*0.8739, places=3)
self.assertAlmostEqual(sum(abs_x), 493.4400, places=3)
# Make sure the model works for non-unity objective values
model.reactions.Biomass_Ecoli_core.objective_coefficient = 2
optimize_minimal_flux(model, solver=solver)
self.assertAlmostEqual(model.solution.f, 2*0.8739, places=3)
model.reactions.Biomass_Ecoli_core.objective_coefficient = 1
# Test some erroneous inputs -- multiple objectives
model.reactions.ATPM.objective_coefficient = 1
with self.assertRaises(ValueError):
optimize_minimal_flux(model, solver=solver)
model.reactions.ATPM.objective_coefficient = 0
# Minimization of objective
with self.assertRaises(ValueError):
optimize_minimal_flux(model, solver=solver,
objective_sense='minimize')
# Infeasible solution
atpm = float(model.reactions.ATPM.lower_bound)
model.reactions.ATPM.lower_bound = 500
with self.assertRaises(ValueError):
optimize_minimal_flux(model, solver=solver)
model.reactions.ATPM.lower_bound = atpm
def setUp(self):
self.model = create_test_model()
initialize_growth_medium(self.model, 'MgM')
self.old_solution = 0.320064
self.infeasible_model = Model()
metabolite_1 = Metabolite("met1")
#metabolite_2 = Metabolite("met2")
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
self.infeasible_model.add_reactions([reaction_1, reaction_2])
def test_SBO_annotation(self):
model = create_test_model("textbook")
rxns = model.reactions
rxns.EX_o2_e.annotation.clear()
fake_DM = Reaction("DM_h_c")
model.add_reaction(fake_DM)
fake_DM.add_metabolites({model.metabolites.get_by_id("h_c"): -1})
# this exchange will be set wrong. The function should not overwrite
# an existing SBO annotation
rxns.get_by_id("EX_h_e").annotation["SBO"] = "SBO:0000628"
add_SBO(model)
self.assertEqual(rxns.EX_o2_e.annotation["SBO"], "SBO:0000627")
self.assertEqual(rxns.DM_h_c.annotation["SBO"], "SBO:0000628")
self.assertEqual(rxns.EX_h_e.annotation["SBO"], "SBO:0000628")
def test_summary_methods(self):
# Test model summary methods
model = create_test_model("textbook")
model.optimize()
desired_entries = [
u'glc__D_e -9.76 \u00B1 0.24'
u'co2_e 21.81 \u00B1 2.86', u'nh4_e -4.84 \u00B1 0.32'
u'h_e 19.51 \u00B1 2.86', u'pi_e -3.13 \u00B1 0.08'
u'for_e 2.86 \u00B1 2.86', u'ac_e 0.95 \u00B1 0.95',
u'acald_e 0.64 \u00B1 0.64', u'pyr_e 0.64 \u00B1 0.64',
u'etoh_e 0.55 \u00B1 0.55', u'lac__D_e 0.54 \u00B1 0.54',
u'succ_e 0.42 \u00B1 0.42', u'akg_e 0.36 \u00B1 0.36',
u'glu__L_e 0.32 \u00B1 0.32'
]
with captured_output() as (out, err):
model.summary(fva=0.95)
output = out.getvalue().strip()
output_set = set((re.sub('\s', '', l) for l in output.splitlines()))
for item in desired_entries:
self.assertIn(re.sub('\s', '', item), output_set)
# Test metabolite summary methods
desired_entries = [
'PRODUCING REACTIONS -- Ubiquinone-8',
'-----------------------------------',
'% FLUX RXN ID'
'REACTION',
'100.0% 44 CYTBD'
'2.0 h_c + 0.5 o2_c + q8h2_c --> h2o_c + 2.0 h_e +...',
'CONSUMING REACTIONS -- Ubiquinone-8',
'-----------------------------------',
'88.4% -39 NADH16'
'4.0 h_c + nadh_c + q8_c --> 3.0 h_e + nad_c + q8h2_c',
'11.6% -5.1 SUCDi '
'q8_c + succ_c --> fum_c + q8h2_c',
]
with captured_output() as (out, err):
model.metabolites.q8_c.summary()
output = out.getvalue().strip()
output_set = set((re.sub('\s', '', l) for l in output.splitlines()))
for item in desired_entries:
self.assertIn(re.sub('\s', '', item), output_set)
def test_double_reaction_deletion(self):
cobra_model = create_test_model("textbook")
reactions = ['FBA', 'ATPS4r', 'ENO', 'FRUpts2']
growth_list = [[0.704, 0.135, 0.000, 0.704],
[0.135, 0.374, 0.000, 0.374],
[0.000, 0.000, 0.000, 0.000],
[0.704, 0.374, 0.000, 0.874]]
solution = double_reaction_deletion(cobra_model,
reaction_list1=reactions,
number_of_processes=1)
self.assertEqual(solution["x"], reactions)
self.assertEqual(solution["y"], reactions)
self.compare_matrices(growth_list, solution["data"])
def test_SBO_annotation(self):
model = create_test_model("textbook")
rxns = model.reactions
rxns.EX_o2_e.annotation.clear()
fake_DM = Reaction("DM_h_c")
model.add_reaction(fake_DM)
fake_DM.add_metabolites({model.metabolites.get_by_id("h_c"): -1})
# this exchange will be set wrong. The function should not overwrite
# an existing SBO annotation
rxns.get_by_id("EX_h_e").annotation["SBO"] = "SBO:0000628"
add_SBO(model)
self.assertEqual(rxns.EX_o2_e.annotation["SBO"], "SBO:0000627")
self.assertEqual(rxns.DM_h_c.annotation["SBO"], "SBO:0000628")
self.assertEqual(rxns.EX_h_e.annotation["SBO"], "SBO:0000628")
def test_array_based_model_add(self):
for matrix_type in ["scipy.dok_matrix", "scipy.lil_matrix"]:
model = create_test_model().to_array_based_model(
matrix_type=matrix_type)
test_reaction = Reaction("test")
test_reaction.add_metabolites({model.metabolites[0]: 4})
test_reaction.lower_bound = -3.14
model.add_reaction(test_reaction)
self.assertEqual(len(model.reactions), 2547)
self.assertEqual(model.S.shape[1], 2547)
self.assertEqual(len(model.lower_bounds), 2547)
self.assertEqual(model.S[0, 2546], 4)
self.assertEqual(model.S[0, 0], -1)
self.assertEqual(model.lower_bounds[2546], -3.14)
def setUp(self):
self.model = create_test_model()
initialize_growth_medium(self.model, "MgM")
self.old_solution = 0.320064
self.infeasible_model = Model()
metabolite_1 = Metabolite("met1")
# metabolite_2 = Metabolite("met2")
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
self.infeasible_model.add_reactions([reaction_1, reaction_2])
def test_double_reaction_deletion(self):
cobra_model = create_test_model("textbook")
reactions = ["FBA", "ATPS4r", "ENO", "FRUpts2"]
growth_list = [
[0.704, 0.135, 0.000, 0.704],
[0.135, 0.374, 0.000, 0.374],
[0.000, 0.000, 0.000, 0.000],
[0.704, 0.374, 0.000, 0.874],
]
solution = double_reaction_deletion(cobra_model, reaction_list1=reactions, number_of_processes=1)
self.assertEqual(solution["x"], reactions)
self.assertEqual(solution["y"], reactions)
self.compare_matrices(growth_list, solution["data"])
def test_single_gene_deletion_moma(self):
# MOMA requires a QP solver
try:
get_solver_name(qp=True)
except:
self.skipTest("no qp support")
cobra_model = create_test_model("textbook")
# expected knockouts for textbook model
growth_dict = {"b0008": 0.87, "b0114": 0.71, "b0116": 0.56, "b2276": 0.11, "b1779": 0.00}
rates, statuses = single_gene_deletion(cobra_model, gene_list=growth_dict.keys(), method="moma")
for gene, expected_value in iteritems(growth_dict):
self.assertEqual(statuses[gene], "optimal")
self.assertAlmostEqual(rates[gene], expected_value, places=2)
def create_fba_model(solver=GLPK):
# g6p_c = cobra.Metabolite(id = 'g6p_c', formula = 'C6H13O9P')
# f6p_c = cobra.Metabolite(id = 'f6p_c', formula = 'C6H13O9P')
#
# g6p_ex = cobra.Reaction(id='EX_g6p')
# g6p_ex.add_metabolites({g6p_c: -1})
#
# f6p_ex = cobra.Reaction(id='EX_g6p')
# f6p_ex.add_metabolites({f6p_c: -1})
#
# pgi = cobra.Reaction(id='PGI')
# pgi.add_metabolites({g6p_c: -1, f6p_c: 1})
# pgi.gene_reaction_rule = 'b4025'
#
# pgi.lower_bound = -1000
# g6p_ex.lower_bound = -1000
# f6p_ex.lower_bound = -1000
# the_model = cobra.Model()
the_model = create_test_model('textbook')
# the_model.add_reactions([g6p_ex, pgi, f6p_ex])
pi = the_model.metabolites.pi_c
h = the_model.metabolites.h_c
h2o = the_model.metabolites.h2o_c
ppi = cobra.Metabolite(id='ppi_c', formula='P2O7', compartment='c')
ppi_hydrolysis = cobra.Reaction(id='pi_to_ppi')
ppi_hydrolysis.add_metabolites({ppi: -1, h2o: -1, pi: 2, h: 2})
gdp = cobra.Metabolite(id='gdp_c',
formula='C10H15N5O11P2',
compartment='c')
gdp_ex = cobra.Reaction(id='EX_g6p')
gdp_ex.add_metabolites({gdp: -1})
the_model.add_reactions([ppi_hydrolysis, gdp_ex])
add_e_metabolites(the_model)
for met in ['dttp', 'dctp', 'datp', 'dgtp']:
the_ex = the_model.reactions.get_by_id('EX_' + met + '_c')
the_ex.lower_bound = -1
# add_growth(the_model)
the_model.solver = solver
return the_model
def setUp(self):
self.test_model = create_test_model()
self.test_file = salmonella_pickle
self.load = load
self.dump = dump
def read_function(filename):
with open(filename, "rb") as infile:
return self.load(infile)
def write_function(model, filename):
with open(filename, "wb") as outfile:
self.dump(model, outfile)
self.read_function = read_function
self.write_function = write_function
def test_array_based_model(self):
m = len(self.model.metabolites)
n = len(self.model.reactions)
assertEqual = self.assertEqual # alias
for matrix_type in ["scipy.dok_matrix", "scipy.lil_matrix"]:
model = create_test_model("textbook").\
to_array_based_model(matrix_type=matrix_type)
assertEqual(model.S[7, 0], -1)
assertEqual(model.S[43, 0], 0)
model.S[43, 0] = 1
assertEqual(model.S[43, 0], 1)
assertEqual(
model.reactions[0].metabolites[model.metabolites[43]], 1)
model.S[43, 0] = 0
assertEqual(model.lower_bounds[0], model.reactions[0].lower_bound)
assertEqual(model.lower_bounds[5], model.reactions[5].lower_bound)
assertEqual(model.upper_bounds[0], model.reactions[0].upper_bound)
assertEqual(model.upper_bounds[5], model.reactions[5].upper_bound)
model.lower_bounds[6] = 2
self.assertEqual(model.lower_bounds[6], 2)
self.assertEqual(model.reactions[6].lower_bound, 2)
# this should fail because it is the wrong size
with self.assertRaises(Exception):
model.upper_bounds = [0, 1]
model.upper_bounds = [0] * len(model.reactions)
self.assertEqual(max(model.upper_bounds), 0)
# test something for all the attributes
model.lower_bounds[2] = -1
assertEqual(model.reactions[2].lower_bound, -1)
assertEqual(model.lower_bounds[2], -1)
model.objective_coefficients[2] = 1
assertEqual(model.reactions[2].objective_coefficient, 1)
assertEqual(model.objective_coefficients[2], 1)
model.b[2] = 1
assertEqual(model.metabolites[2]._bound, 1)
assertEqual(model.b[2], 1)
model.constraint_sense[2] = "L"
assertEqual(model.metabolites[2]._constraint_sense, "L")
assertEqual(model.constraint_sense[2], "L")
# test resize matrix on reaction removal
m, n = model.S.shape
model.remove_reactions([model.reactions[2]], remove_orphans=False)
self.assertEqual(len(model.metabolites), model.S.shape[0])
self.assertEqual(len(model.reactions), model.S.shape[1])
self.assertEqual(model.S.shape, (m, n - 1))
def test_array_based_model_add(self):
m = len(self.model.metabolites)
n = len(self.model.reactions)
for matrix_type in ["scipy.dok_matrix", "scipy.lil_matrix"]:
model = create_test_model("textbook").\
to_array_based_model(matrix_type=matrix_type)
test_reaction = Reaction("test")
test_reaction.add_metabolites({model.metabolites[0]: 4})
test_reaction.lower_bound = -3.14
model.add_reaction(test_reaction)
self.assertEqual(len(model.reactions), n + 1)
self.assertEqual(model.S.shape, (m, n + 1))
self.assertEqual(len(model.lower_bounds), n + 1)
self.assertEqual(len(model.upper_bounds), n + 1)
self.assertEqual(model.S[0, n], 4)
self.assertEqual(model.S[7, 0], -1)
self.assertEqual(model.lower_bounds[n], -3.14)
def fluxSampling(model):
from cobra.test import create_test_model
from cobra.flux_analysis import sample
model = create_test_model("textbook")
s = sample(model, 100) #number of samples to generate
s.head()
s = sample(model, 1000)
s
#The sampling process can be controlled on a lower level by using the sampler classes directly.
from cobra.flux_analysis.sampling import OptGPSampler, ACHRSampler
achr = ACHRSampler(
model, thinning=10
) #“Thinning” means only recording samples every n iterations. A higher thinning factor means less correlated samples but also larger computation times.
optgp = OptGPSampler(
model, processes=4
) #an additional processes argument specifying how many processes are used to create parallel sampling chains.
#For OptGPSampler the number of samples should be a multiple of the number of
# processes, otherwise it will be increased to the nearest multiple automatically.
s1 = achr.sample(100)
s2 = optgp.sample(100)
# Sampling and validation
import numpy as np
bad = np.random.uniform(-1000, 1000, size=len(model.reactions))
achr.validate(np.atleast_2d(bad)) #should not be feasible
achr.validate(s1)
# Batch sampling
counts = [
np.mean(s.Biomass_Ecoli_core > 0.1) for s in optgp.batch(100, 10)
]
print("Usually {:.2f}% +- {:.2f}% grow...".format(
np.mean(counts) * 100.0,
np.std(counts) * 100.0))
# Adding constraints
co = model.problem.Constraint(
model.reactions.Biomass_Ecoli_core.flux_expression, lb=0.1)
model.add_cons_vars([co])
# Note that this is only for demonstration purposes. usually you could set
# the lower bound of the reaction directly instead of creating a new constraint.
s = sample(model, 10)
print(s.Biomass_Ecoli_core)
def test_single_gene_deletion_moma(self):
# MOMA requires a QP solver
try:
get_solver_name(qp=True)
except:
self.skipTest("no qp support")
cobra_model = create_test_model("textbook")
# expected knockouts for textbook model
growth_dict = {"b0008": 0.87, "b0114": 0.71, "b0116": 0.56,
"b2276": 0.11, "b1779": 0.00}
rates, statuses = single_gene_deletion(cobra_model,
gene_list=growth_dict.keys(),
method="moma")
for gene, expected_value in iteritems(growth_dict):
self.assertEqual(statuses[gene], 'optimal')
self.assertAlmostEqual(rates[gene], expected_value, places=2)
def test_single_gene_deletion(self):
cobra_model = create_test_model("textbook")
# expected knockouts for textbook model
growth_dict = {"fba": {"b0008": 0.87, "b0114": 0.80, "b0116": 0.78,
"b2276": 0.21, "b1779": 0.00},
"moma": {"b0008": 0.87, "b0114": 0.71, "b0116": 0.56,
"b2276": 0.11, "b1779": 0.00},
}
# MOMA requires cplex or gurobi
try:
get_solver_name(qp=True)
except:
growth_dict.pop('moma')
for method, expected in growth_dict.items():
rates, statuses = single_gene_deletion(cobra_model,
gene_list=expected.keys(),
method=method)
for gene, expected_value in iteritems(expected):
self.assertEqual(statuses[gene], 'optimal')
self.assertAlmostEqual(rates[gene], expected_value, places=2)
def test_double_gene_deletion(self):
cobra_model = create_test_model("textbook")
genes = ["b0726", "b4025", "b0724", "b0720",
"b2935", "b2935", "b1276", "b1241"]
growth_list = [
[0.858, 0.857, 0.814, 0.000, 0.858, 0.858, 0.858, 0.858],
[0.857, 0.863, 0.739, 0.000, 0.863, 0.863, 0.863, 0.863],
[0.814, 0.739, 0.814, 0.000, 0.814, 0.814, 0.814, 0.814],
[0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000],
[0.858, 0.863, 0.814, 0.000, 0.874, 0.874, 0.874, 0.874],
[0.858, 0.863, 0.814, 0.000, 0.874, 0.874, 0.874, 0.874],
[0.858, 0.863, 0.814, 0.000, 0.874, 0.874, 0.874, 0.874],
[0.858, 0.863, 0.814, 0.000, 0.874, 0.874, 0.874, 0.874]]
solution = double_gene_deletion(cobra_model, gene_list1=genes)
self.assertEqual(solution["x"], genes)
self.assertEqual(solution["y"], genes)
self.compare_matrices(growth_list, solution["data"])
# test when lists differ slightly
solution = double_gene_deletion(cobra_model, gene_list1=genes[:-1],
gene_list2=genes,
number_of_processes=1)
self.assertEqual(solution["x"], genes[:-1])
self.assertEqual(solution["y"], genes)
self.compare_matrices(growth_list[:-1], solution["data"])
def setUp(self):
self.test_model = create_test_model(ecoli_pickle)
self.test_file = ecoli_mat
self.read_function = io.load_matlab_model
self.write_function = io.save_matlab_model
def setUp(self):
self.test_model = create_test_model()
self.test_file = salmonella_fbc_sbml
self.read_function = io.read_sbml_model
self.write_function = partial(io.write_sbml_model,
use_fbc_package=True)
def setUp(self):
self.test_model = create_test_model()
self.test_file = salmonella_sbml
self.read_function = io.read_sbml_model
self.write_function = io.write_sbml_model