Source code for cobra.test.solvers

from unittest import TestCase, TestLoader, TextTestRunner
import sys
# deal with absolute imports by adding the appropriate directory to the path
if __name__ == "__main__":
    sys.path.insert(0, "../..")
    from cobra.manipulation import initialize_growth_medium
    from cobra.test import create_test_model
    from cobra import Model, Reaction, Metabolite
    from cobra import solvers
    from cobra.solvers import __legacy_solver
    sys.path.pop(0)  # remove the added directory to the path
else:
    from ..manipulation import initialize_growth_medium
    from . import create_test_model
    from .. import Model, Reaction, Metabolite
    from .. import solvers
    __legacy_solver = solvers.__legacy_solver

[docs]class TestCobraSolver(TestCase):
[docs] 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_2: 1}) reaction_1.lower_bound = 1 reaction_2.upper_bound = 2 self.infeasible_model.add_reactions([reaction_1, reaction_2]) #self.infeasible_model.update()
[docs]def add_new_test(TestCobraSolver, solver_name, solver): """Creates a test set for each of the solvers that are installed using the modular interface. """ def test_attributes(self): self.assertTrue(hasattr(solver, "create_problem")) self.assertTrue(hasattr(solver, "solve_problem")) # self.assertTrue(hasattr(solver, "update_problem")) def test_setup(self): solver.create_problem(self.model) def test_solve_feasible(self): solver.solve(self.model) solution = self.model.solution self.assertEqual(solution.status, "optimal") self.assertAlmostEqual(self.old_solution, \ solution.f, places=4) def test_solve_minimize(self): solver.solve(self.model, objective_sense='minimize') solution = self.model.solution self.assertEqual(solution.status, "optimal") self.assertAlmostEqual(0, \ solution.f, places=4) def test_solve_mip(self): cone_selling_price = 7. cone_production_cost = 3. popsicle_selling_price = 2. popsicle_production_cost = 1. starting_budget = 100. cobra_model = Model('MILP_implementation_test') cone_out = Metabolite(id='cone_out', compartment='c') cone_in = Metabolite(id='cone_in', compartment='c') cone_consumed = Metabolite(id='cone_consumed', compartment='c') popsicle_out = Metabolite(id='popsicle_out', compartment='c') popsicle_in = Metabolite(id='popsicle_in', compartment='c') popsicle_consumed = Metabolite(id='popsicle_consumed', compartment='c') the_reactions = [] # SOURCE Cone_source = Reaction(name='Cone_source') temp_metabolite_dict = {cone_out: 1} Cone_source.add_metabolites(temp_metabolite_dict) the_reactions.append(Cone_source) Popsicle_source = Reaction(name='Popsicle_source') temp_metabolite_dict = {popsicle_out: 1} Popsicle_source.add_metabolites(temp_metabolite_dict) the_reactions.append(Popsicle_source) ## PRODUCTION Cone_production = Reaction(name='Cone_production') temp_metabolite_dict = {cone_out: -1, cone_in: 1} Cone_production.add_metabolites(temp_metabolite_dict) the_reactions.append(Cone_production) Popsicle_production = Reaction(name='Popsicle_production') temp_metabolite_dict = {popsicle_out: -1, popsicle_in: 1} Popsicle_production.add_metabolites(temp_metabolite_dict) the_reactions.append(Popsicle_production) ## CONSUMPTION Cone_consumption = Reaction(name='Cone_consumption') temp_metabolite_dict = {cone_in: -1, cone_consumed: 1} Cone_consumption.add_metabolites(temp_metabolite_dict) the_reactions.append(Cone_consumption) Popsicle_consumption = Reaction(name='Popsicle_consumption') temp_metabolite_dict = {popsicle_in: -1, popsicle_consumed: 1} Popsicle_consumption.add_metabolites(temp_metabolite_dict) the_reactions.append(Popsicle_consumption) # SINK Cone_consumed_sink = Reaction(name='Cone_consumed_sink') temp_metabolite_dict = {cone_consumed: -1} Cone_consumed_sink.add_metabolites(temp_metabolite_dict) the_reactions.append(Cone_consumed_sink) Popsicle_consumed_sink = Reaction(name='Popsicle_consumed_sink') temp_metabolite_dict = {popsicle_consumed: -1} Popsicle_consumed_sink.add_metabolites(temp_metabolite_dict) the_reactions.append(Popsicle_consumed_sink) ## add all reactions cobra_model.add_reactions(the_reactions) # set objective coefficients Cone_consumption.objective_coefficient = cone_selling_price Popsicle_consumption.objective_coefficient = popsicle_selling_price Cone_production.objective_coefficient = -1*cone_production_cost Popsicle_production.objective_coefficient = -1*popsicle_production_cost #Make sure we produce whole cones Cone_production.variable_kind = 'integer' Popsicle_production.variable_kind = 'integer' production_capacity_constraint = Metabolite(id='production_capacity_constraint') production_capacity_constraint._constraint_sense = 'L' production_capacity_constraint._bound = starting_budget; Cone_production.add_metabolites({production_capacity_constraint: cone_production_cost }) Popsicle_production.add_metabolites({production_capacity_constraint: popsicle_production_cost }) cobra_model.optimize() self.assertEqual(133, cobra_model.solution.f) def test_solve_infeasible(self): solver.solve(self.infeasible_model) solution = self.infeasible_model.solution self.assertEqual(solution.status, "infeasible") def test_independent_creation(self): feasible_lp = solver.create_problem(self.model) infeasible_lp = solver.create_problem(self.infeasible_model) solver.solve_problem(feasible_lp) solver.solve_problem(infeasible_lp) feasible_solution = solver.format_solution(feasible_lp, self.model) infeasible_solution = solver.format_solution(infeasible_lp, self.infeasible_model) self.assertEqual(feasible_solution.status, "optimal") self.assertAlmostEqual(self.old_solution, \ feasible_solution.f, places=4) self.assertEqual(infeasible_solution.status, "infeasible") setattr(TestCobraSolver, "test_%s_create" % solver_name, \ test_setup) setattr(TestCobraSolver, "test_%s_attributes" % solver_name, \ test_attributes) setattr(TestCobraSolver, "test_%s_feasible_solve" % solver_name, \ test_solve_feasible) setattr(TestCobraSolver, "test_%s_infeasible_solve" % solver_name, \ test_solve_infeasible) setattr(TestCobraSolver, "test_%s_independent_creation" % solver_name, \ test_independent_creation) setattr(TestCobraSolver, "test_%s_solve_minimize" % solver_name, \ test_solve_minimize) setattr(TestCobraSolver, "test_%s_solve_mip" % solver_name, \ test_solve_mip)
[docs]def add_legacy_test(TestCobraSolver, solver_name, solver_function): """Creates a test set for each of the installed solvers using the legacy interface. """ def test_solve_feasible(self): the_solution = solver_function(self.model)['the_solution'] self.assertEqual(the_solution.status, 'optimal') self.assertAlmostEqual(self.old_solution, the_solution.f, places=4) setattr(TestCobraSolver, "test_%s_feasible_solve" % solver_name, \ test_solve_feasible)
if not __legacy_solver: add_test = add_new_test else: add_test = add_legacy_test for solver_name, solver in solvers.solver_dict.iteritems(): add_test(TestCobraSolver, solver_name, solver) # make a test suite to run all of the tests loader = TestLoader() suite = loader.loadTestsFromModule(sys.modules[__name__])
[docs]def test_all(): TextTestRunner(verbosity=2).run(suite)
if __name__ == "__main__": test_all()