class TestFluxBalanceThermodynamic(unittest.TestCase):
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('ex_A', parse_reaction('|A| <=>'))
self.database.set_reaction('ex_D', parse_reaction('|D| <=>'))
self.database.set_reaction('rxn_1', parse_reaction('|A| => |B|'))
self.database.set_reaction('rxn_2', parse_reaction('|B| <=> |C|'))
self.database.set_reaction('rxn_3', parse_reaction('|C| <=> |D|'))
self.database.set_reaction('rxn_4', parse_reaction('|D| <=> |E|'))
self.database.set_reaction('rxn_5', parse_reaction('|E| => |B|'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
self.model.limits['ex_A'].lower = -10 # Low uptake
self.model.limits['ex_D'].lower = 0 # No uptake
try:
self.solver = generic.Solver(integer=True)
except generic.RequirementsError:
self.skipTest('Unable to find an MILP solver for tests')
def test_flux_balance_tfba_exchange_d(self):
fluxes = dict(fluxanalysis.flux_balance(
self.model, 'ex_D', tfba=True, solver=self.solver))
self.assertAlmostEqual(fluxes['ex_A'], -10)
self.assertAlmostEqual(fluxes['ex_D'], 10)
self.assertAlmostEqual(fluxes['rxn_2'], 10)
self.assertAlmostEqual(fluxes['rxn_4'], 0)
self.assertAlmostEqual(fluxes['rxn_5'], 0)
class TestFastcoreTinyBiomassModel(unittest.TestCase):
"""Test fastcore using a model with tiny values in biomass reaction
This model is consistent mathematically since there is a flux solution
within the flux bounds. However, the numerical nature of the fastcore
algorithm requires an epsilon-parameter indicating the minimum flux that
is considered non-zero. For this reason, some models with reactions where
tiny stoichiometric values appear can be seen as inconsistent by
fastcore.
In this particular model, rxn_2 can take a maximum flux of 1000. At the
same time rxn_1 will have to take a flux of 1e-4. This is the maximum
possible flux for rxn_1 so running fastcore with an epsilon larger than
1e-4 will indicate that the model is not consistent.
"""
def setUp(self):
# TODO use mock model instead of actual model
self.database = DictDatabase()
self.database.set_reaction("rxn_1", parse_reaction("=> |A|"))
self.database.set_reaction("rxn_2", parse_reaction("(0.000001) |A| =>"))
self.model = MetabolicModel.load_model(self.database, self.database.reactions)
self.solver = cplex.Solver()
def test_fastcc_is_consistent(self):
self.assertTrue(fastcore.fastcc_is_consistent(self.model, 0.001, solver=self.solver))
def test_fastcore_induced_model(self):
core = {"rxn_2"}
self.assertEquals(set(fastcore.fastcore(self.model, core, 0.001, solver=self.solver)), {"rxn_1", "rxn_2"})
def test_fastcore_induced_model_high_epsilon(self):
core = {"rxn_2"}
self.assertEquals(set(fastcore.fastcore(self.model, core, 0.1, solver=self.solver)), {"rxn_1", "rxn_2"})
class TestMassConsistencyZeroMass(unittest.TestCase):
"""Test mass consistency using a model with zero-mass compound"""
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction(
'|A| + |B| => |C|'))
self.database.set_reaction('rxn_2', parse_reaction(
'|C| + |Z| => |A| + |B|'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def test_is_consistent_with_zeromass(self):
consistent = massconsistency.is_consistent(
self.model, solver=self.solver, zeromass={Compound('Z')})
self.assertTrue(consistent)
def test_compound_consistency_with_zeromass(self):
compounds = dict(massconsistency.check_compound_consistency(
self.model, solver=self.solver, zeromass={Compound('Z')}))
for c, value in iteritems(compounds):
self.assertGreaterEqual(value, 1)
def test_reaction_consistency_with_zeromass(self):
reactions, _ = massconsistency.check_reaction_consistency(
self.model, solver=self.solver, zeromass={Compound('Z')})
reactions = dict(reactions)
for r, value in iteritems(reactions):
self.assertAlmostEqual(value, 0)
class TestFluxBalanceThermodynamic(unittest.TestCase):
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('ex_A', parse_reaction('|A| <=>'))
self.database.set_reaction('ex_D', parse_reaction('|D| <=>'))
self.database.set_reaction('rxn_1', parse_reaction('|A| => |B|'))
self.database.set_reaction('rxn_2', parse_reaction('|B| <=> |C|'))
self.database.set_reaction('rxn_3', parse_reaction('|C| <=> |D|'))
self.database.set_reaction('rxn_4', parse_reaction('|D| <=> |E|'))
self.database.set_reaction('rxn_5', parse_reaction('|E| => |B|'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
self.model.limits['ex_A'].lower = -10 # Low uptake
self.model.limits['ex_D'].lower = 0 # No uptake
self.solver = cplex.Solver()
def test_flux_balance_tfba_exchange_d(self):
fluxes = dict(fluxanalysis.flux_balance(
self.model, 'ex_D', tfba=True, solver=self.solver))
self.assertEquals(fluxes['ex_A'], -10)
self.assertEquals(fluxes['ex_D'], 10)
self.assertEquals(fluxes['rxn_2'], 10)
self.assertEquals(fluxes['rxn_4'], 0)
self.assertEquals(fluxes['rxn_5'], 0)
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('A[e] => B[e]'))
self._database.set_reaction('rxn_2', parse_reaction('B[e] => C[e]'))
self._database.set_reaction('rxn_3', parse_reaction('B[e] <=> D[e]'))
self._database.set_reaction('rxn_4', parse_reaction('C[e] <=> E[e]'))
self._database.set_reaction('rxn_5', parse_reaction('D[e] => E[e]'))
self._database.set_reaction('rxn_6', parse_reaction('E[e] =>'))
self._database.set_reaction('ex_A', parse_reaction('A[e] <=>'))
self._mm = MetabolicModel.load_model(
self._database, self._database.reactions)
self._assoc = {
'rxn_1': str('gene_1'),
'rxn_2': str('gene_2'),
'rxn_3': str('gene_5'),
'rxn_4': str('gene_3 or gene_4'),
'rxn_5': str('gene_5 and gene_6')
}
self._obj_reaction = 'rxn_6'
try:
self._solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
try:
self.solver = generic.Solver(integer=True)
except generic.RequirementsError:
self.skipTest('Needs and integer programming solver')
class TestFluxBalanceThermodynamic(unittest.TestCase):
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('ex_A', parse_reaction('|A| <=>'))
self.database.set_reaction('ex_D', parse_reaction('|D| <=>'))
self.database.set_reaction('rxn_1', parse_reaction('|A| => |B|'))
self.database.set_reaction('rxn_2', parse_reaction('|B| <=> |C|'))
self.database.set_reaction('rxn_3', parse_reaction('|C| <=> |D|'))
self.database.set_reaction('rxn_4', parse_reaction('|D| <=> |E|'))
self.database.set_reaction('rxn_5', parse_reaction('|E| => |B|'))
self.model = MetabolicModel.load_model(self.database,
self.database.reactions)
self.model.limits['ex_A'].lower = -10 # Low uptake
self.model.limits['ex_D'].lower = 0 # No uptake
try:
self.solver = generic.Solver(integer=True)
except generic.RequirementsError:
self.skipTest('Unable to find an MILP solver for tests')
def test_flux_balance_tfba_exchange_d(self):
fluxes = dict(
fluxanalysis.flux_balance(self.model,
'ex_D',
tfba=True,
solver=self.solver))
self.assertAlmostEqual(fluxes['ex_A'], -10)
self.assertAlmostEqual(fluxes['ex_D'], 10)
self.assertAlmostEqual(fluxes['rxn_2'], 10)
self.assertAlmostEqual(fluxes['rxn_4'], 0)
self.assertAlmostEqual(fluxes['rxn_5'], 0)
class TestMassConsistencyZeroMass(unittest.TestCase):
"""Test mass consistency using a model with zero-mass compound"""
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('|A| + |B| => |C|'))
self.database.set_reaction('rxn_2',
parse_reaction('|C| + |Z| => |A| + |B|'))
self.model = MetabolicModel.load_model(self.database,
self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def test_is_consistent_with_zeromass(self):
consistent = massconsistency.is_consistent(self.model,
solver=self.solver,
zeromass={Compound('Z')})
self.assertTrue(consistent)
def test_compound_consistency_with_zeromass(self):
compounds = dict(
massconsistency.check_compound_consistency(
self.model, solver=self.solver, zeromass={Compound('Z')}))
for c, value in iteritems(compounds):
self.assertGreaterEqual(value, 1)
def test_reaction_consistency_with_zeromass(self):
reactions, _ = massconsistency.check_reaction_consistency(
self.model, solver=self.solver, zeromass={Compound('Z')})
reactions = dict(reactions)
for r, value in iteritems(reactions):
self.assertAlmostEqual(value, 0)
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('A[e] => B[e]'))
self._database.set_reaction('rxn_2', parse_reaction('B[e] => C[e]'))
self._database.set_reaction('rxn_3', parse_reaction('B[e] => D[e]'))
self._database.set_reaction('rxn_4', parse_reaction('C[e] => E[e]'))
self._database.set_reaction('rxn_5', parse_reaction('D[e] => E[e]'))
self._database.set_reaction('rxn_6', parse_reaction('E[e] =>'))
self._database.set_reaction('ex_A', parse_reaction('A[e] <=>'))
self._mm = MetabolicModel.load_model(self._database,
self._database.reactions)
self._assoc = {
'rxn_1': boolean.Expression('gene_1'),
'rxn_2': boolean.Expression('gene_2 or gene_3'),
'rxn_5': boolean.Expression('gene_3 and gene_4')
}
self._obj_reaction = 'rxn_6'
try:
self._solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
self._prob = fluxanalysis.FluxBalanceProblem(self._mm, self._solver)
class TestMassConsistencyZeroMass(unittest.TestCase):
"""Test mass consistency using a model with zero-mass compound"""
def setUp(self):
# TODO use mock model instead of actual model
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction(
'|A| + |B| => |C|'))
self.database.set_reaction('rxn_2', parse_reaction(
'|C| + |Z| => |A| + |B|'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
self.solver = cplex.Solver()
def test_is_consistent_with_zeromass(self):
consistent = massconsistency.is_consistent(
self.model, solver=self.solver, zeromass={'Z'})
self.assertTrue(consistent)
def test_compound_consistency_with_zeromass(self):
compounds = dict(massconsistency.check_compound_consistency(
self.model, solver=self.solver, zeromass={'Z'}))
self.assertEquals(compounds[Compound('Z')], 0)
for c, value in compounds.iteritems():
if c.name != 'Z':
self.assertGreaterEqual(value, 1)
def test_reaction_consistency_with_zeromass(self):
reactions, _ = massconsistency.check_reaction_consistency(
self.model, solver=self.solver, zeromass={'Z'})
reactions = dict(reactions)
for r, value in reactions.iteritems():
self.assertEqual(value, 0)
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> 2 A'))
self.database.set_reaction('rxn_2', parse_reaction('A <=> B'))
self.database.set_reaction('rxn_3', parse_reaction('A => D[e]'))
self.database.set_reaction('rxn_4', parse_reaction('A + 2 B => C'))
self.database.set_reaction('rxn_5', parse_reaction('C => 3 D[e]'))
self.database.set_reaction('rxn_6', parse_reaction('D[e] =>'))
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self._database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self._database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self._database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self._mm = MetabolicModel.load_model(self._database,
self._database.reactions)
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |D[e]|'))
self.database.set_reaction('rxn_4', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_5', parse_reaction('|C| => |D[e]|'))
self.database.set_reaction('rxn_6', parse_reaction('|D[e]| =>'))
class TestFastcoreTinyBiomassModel(unittest.TestCase):
"""Test fastcore using a model with tiny values in biomass reaction
This model is consistent mathematically since there is a flux solution
within the flux bounds. However, the numerical nature of the fastcore
algorithm requires an epsilon-parameter indicating the minimum flux that
is considered non-zero. For this reason, some models with reactions where
tiny stoichiometric values appear can be seen as inconsistent by
fastcore.
In this particular model, rxn_2 can take a maximum flux of 1000. At the
same time rxn_1 will have to take a flux of 1e-3. This is the maximum
possible flux for rxn_1 so running fastcore with an epsilon larger than
1e-3 will indicate that the model is not consistent.
"""
def setUp(self):
# TODO use mock model instead of actual model
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> |A|'))
self.database.set_reaction('rxn_2',
parse_reaction('(0.000001) |A| =>'))
self.model = MetabolicModel.load_model(self.database,
self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def test_fastcc_is_consistent(self):
self.assertTrue(
fastcore.fastcc_is_consistent(self.model,
0.0001,
solver=self.solver))
def test_fastcc_is_consistent_high_epsilon(self):
self.assertFalse(
fastcore.fastcc_is_consistent(self.model, 0.1, solver=self.solver))
def test_fastcore_induced_model(self):
core = {'rxn_2'}
self.assertEqual(
set(
fastcore.fastcore(self.model,
core,
0.0001,
scaling=1e7,
solver=self.solver)), {'rxn_1', 'rxn_2'})
def test_fastcore_induced_model_high_epsilon(self):
core = {'rxn_2'}
self.assertEqual(
set(
fastcore.fastcore(self.model,
core,
0.1,
scaling=1e7,
solver=self.solver)), {'rxn_1', 'rxn_2'})
class TestLinearMOMA(unittest.TestCase):
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |D|'))
self.database.set_reaction('rxn_4', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_5', parse_reaction('|C| => |D|'))
self.database.set_reaction('rxn_6', parse_reaction('|D| =>'))
self.model = MetabolicModel.load_model(self.database,
self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def test_moma_fba(self):
p = moma.MOMAProblem(self.model, self.solver)
fluxes = p.get_fba_flux('rxn_6')
self.assertAlmostEqual(fluxes['rxn_1'], 500)
self.assertAlmostEqual(fluxes['rxn_2'], 0)
self.assertAlmostEqual(fluxes['rxn_6'], 1000)
def test_moma_minimal_fba(self):
p = moma.MOMAProblem(self.model, self.solver)
fluxes = p.get_minimal_fba_flux('rxn_6')
self.assertAlmostEqual(fluxes['rxn_1'], 500)
self.assertAlmostEqual(fluxes['rxn_2'], 0)
self.assertAlmostEqual(fluxes['rxn_3'], 1000)
self.assertAlmostEqual(fluxes['rxn_6'], 1000)
def test_linear_moma(self):
p = moma.MOMAProblem(self.model, self.solver)
with p.constraints(p.get_flux_var('rxn_3') == 0):
p.lin_moma({
'rxn_3': 1000,
'rxn_4': 0,
'rxn_5': 0,
})
# The closest solution when these are constrained is for
# rxn_6 to take on a flux of zero.
self.assertAlmostEqual(p.get_flux('rxn_6'), 0)
def test_linear_moma2(self):
p = moma.MOMAProblem(self.model, self.solver)
with p.constraints(p.get_flux_var('rxn_3') == 0):
p.lin_moma2('rxn_6', 1000)
self.assertAlmostEqual(p.get_flux('rxn_1'), 500)
self.assertAlmostEqual(p.get_flux('rxn_2'), 0)
self.assertAlmostEqual(p.get_flux('rxn_3'), 0)
self.assertAlmostEqual(p.get_flux('rxn_4'), 1000)
self.assertAlmostEqual(p.get_flux('rxn_5'), 1000)
self.assertAlmostEqual(p.get_flux('rxn_6'), 1000)
class TestLinearMOMA(unittest.TestCase):
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |D|'))
self.database.set_reaction('rxn_4', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_5', parse_reaction('|C| => |D|'))
self.database.set_reaction('rxn_6', parse_reaction('|D| =>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def test_moma_fba(self):
p = moma.MOMAProblem(self.model, self.solver)
fluxes = p.get_fba_flux('rxn_6')
self.assertAlmostEqual(fluxes['rxn_1'], 500)
self.assertAlmostEqual(fluxes['rxn_2'], 0)
self.assertAlmostEqual(fluxes['rxn_6'], 1000)
def test_moma_minimal_fba(self):
p = moma.MOMAProblem(self.model, self.solver)
fluxes = p.get_minimal_fba_flux('rxn_6')
self.assertAlmostEqual(fluxes['rxn_1'], 500)
self.assertAlmostEqual(fluxes['rxn_2'], 0)
self.assertAlmostEqual(fluxes['rxn_3'], 1000)
self.assertAlmostEqual(fluxes['rxn_6'], 1000)
def test_linear_moma(self):
p = moma.MOMAProblem(self.model, self.solver)
with p.constraints(p.get_flux_var('rxn_3') == 0):
p.lin_moma({
'rxn_3': 1000,
'rxn_4': 0,
'rxn_5': 0,
})
# The closest solution when these are constrained is for
# rxn_6 to take on a flux of zero.
self.assertAlmostEqual(p.get_flux('rxn_6'), 0)
def test_linear_moma2(self):
p = moma.MOMAProblem(self.model, self.solver)
with p.constraints(p.get_flux_var('rxn_3') == 0):
p.lin_moma2('rxn_6', 1000)
self.assertAlmostEqual(p.get_flux('rxn_1'), 500)
self.assertAlmostEqual(p.get_flux('rxn_2'), 0)
self.assertAlmostEqual(p.get_flux('rxn_3'), 0)
self.assertAlmostEqual(p.get_flux('rxn_4'), 1000)
self.assertAlmostEqual(p.get_flux('rxn_5'), 1000)
self.assertAlmostEqual(p.get_flux('rxn_6'), 1000)
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self._database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self._database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self._database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self._mm = MetabolicModel.load_model(self._database,
self._database.reactions)
self._strategy = randomsparse.ReactionDeletionStrategy(self._mm)
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) A[c]'))
self.database.set_reaction('rxn_2', parse_reaction('A[c] <=> B[c]'))
self.database.set_reaction('rxn_3', parse_reaction('A[c] => D[e]'))
self.database.set_reaction('rxn_4', parse_reaction('A[c] => C[c]'))
self.database.set_reaction('rxn_5', parse_reaction('C[c] => D[e]'))
self.database.set_reaction('rxn_6', parse_reaction('D[e] =>'))
self.model = MetabolicModel.load_model(self.database,
self.database.reactions)
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |D[e]|'))
self.database.set_reaction('rxn_4', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_5', parse_reaction('|C| => |D[e]|'))
self.database.set_reaction('rxn_6', parse_reaction('|D[e]| =>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
class TestFastcoreTinyBiomassModel(unittest.TestCase):
"""Test fastcore using a model with tiny values in biomass reaction
This model is consistent mathematically since there is a flux solution
within the flux bounds. However, the numerical nature of the fastcore
algorithm requires an epsilon-parameter indicating the minimum flux that
is considered non-zero. For this reason, some models with reactions where
tiny stoichiometric values appear can be seen as inconsistent by
fastcore.
In this particular model, rxn_2 can take a maximum flux of 1000. At the
same time rxn_1 will have to take a flux of 1e-3. This is the maximum
possible flux for rxn_1 so running fastcore with an epsilon larger than
1e-3 will indicate that the model is not consistent.
"""
def setUp(self):
# TODO use mock model instead of actual model
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> |A|'))
self.database.set_reaction('rxn_2',
parse_reaction('(0.000001) |A| =>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
# Skip these tests with GLPK because of issue #61.
if self.solver.properties['name'] == 'glpk':
self.skipTest('Test has known issue with GLPK')
def test_fastcc_is_consistent(self):
self.assertTrue(fastcore.fastcc_is_consistent(
self.model, 0.0001, solver=self.solver))
def test_fastcc_is_consistent_high_epsilon(self):
self.assertFalse(fastcore.fastcc_is_consistent(
self.model, 0.1, solver=self.solver))
def test_fastcore_induced_model(self):
core = {'rxn_2'}
self.assertEqual(
set(fastcore.fastcore(
self.model, core, 0.0001, scaling=1e7, solver=self.solver)),
{'rxn_1', 'rxn_2'})
def test_fastcore_induced_model_high_epsilon(self):
core = {'rxn_2'}
self.assertEqual(
set(fastcore.fastcore(
self.model, core, 0.1, scaling=1e7, solver=self.solver)),
{'rxn_1', 'rxn_2'})
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('|A| + |B| => |C|'))
self.database.set_reaction('rxn_2',
parse_reaction('|C| + |Z| => |A| + |B|'))
self.model = MetabolicModel.load_model(self.database,
self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def setUp(self):
# TODO use mock database instead of actual database
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |D|'))
self.database.set_reaction('rxn_4', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_5', parse_reaction('|C| => |D|'))
self.database.set_reaction('rxn_6', parse_reaction('|D| =>'))
model = MetabolicModel.load_model(self.database, self.database.reactions)
self.model = FlipableModelView(model)
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self._database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self._database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self._database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self._mm = MetabolicModel.load_model(self._database,
self._database.reactions)
self._assoc = {'rxn_2': boolean.Expression('gene_1 or gene_2')}
self._strategy = randomsparse.GeneDeletionStrategy(
self._mm, self._assoc)
def setUp(self):
# TODO use mock model instead of actual model
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> |A|'))
self.database.set_reaction('rxn_2',
parse_reaction('(0.000001) |A| =>'))
self.model = MetabolicModel.load_model(self.database,
self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_4', parse_reaction('|C| => |D|'))
self.database.set_reaction('rxn_5', parse_reaction('|D| <=> |E|'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
try:
self.solver = generic.Solver(integer=True)
except generic.RequirementsError:
self.skipTest('Unable to find an MILP solver for tests')
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> |A|'))
self.database.set_reaction('rxn_2',
parse_reaction('(0.000001) |A| =>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
# Skip these tests with GLPK because of issue #61.
if self.solver.properties['name'] == 'glpk':
self.skipTest('Test has known issue with GLPK')
def setUp(self):
# TODO use mock model instead of actual model
self.database = DictDatabase()
self.database.set_reaction("rxn_1", parse_reaction("=> |A|"))
self.database.set_reaction("rxn_2", parse_reaction("(0.000001) |A| =>"))
self.model = MetabolicModel.load_model(self.database, self.database.reactions)
self.solver = cplex.Solver()
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('A[e] => B[e]'))
self._database.set_reaction('rxn_2', parse_reaction('B[e] => C[e]'))
self._database.set_reaction('rxn_3', parse_reaction('B[e] => D[e]'))
self._database.set_reaction('rxn_4', parse_reaction('C[e] => E[e]'))
self._database.set_reaction('rxn_5', parse_reaction('D[e] => E[e]'))
self._database.set_reaction('rxn_6', parse_reaction('E[e] =>'))
self._database.set_reaction('ex_A', parse_reaction('A[e] <=>'))
self._mm = MetabolicModel.load_model(
self._database, self._database.reactions)
self._assoc = {
'rxn_1': boolean.Expression('gene_1'),
'rxn_2': boolean.Expression('gene_2 or gene_3'),
'rxn_5': boolean.Expression('gene_3 and gene_4')
}
self._obj_reaction = 'rxn_6'
try:
self._solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
self._prob = fluxanalysis.FluxBalanceProblem(self._mm, self._solver)
class TestMetabolicModelFlipableView(unittest.TestCase):
def setUp(self):
# TODO use mock database instead of actual database
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |D|'))
self.database.set_reaction('rxn_4', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_5', parse_reaction('|C| => |D|'))
self.database.set_reaction('rxn_6', parse_reaction('|D| =>'))
model = MetabolicModel.load_model(self.database,
self.database.reactions)
self.model = FlipableModelView(model)
def test_flipable_model_view_matrix_get_item_after_flip(self):
self.model.flip({'rxn_4'})
self.assertEqual(self.model.matrix[Compound('A'), 'rxn_1'], 2)
self.assertEqual(self.model.matrix[Compound('A'), 'rxn_2'], -1)
self.assertEqual(self.model.matrix[Compound('A'), 'rxn_4'], 1)
self.assertEqual(self.model.matrix[Compound('C'), 'rxn_4'], -1)
def test_flipable_model_view_matrix_get_item_after_double_flip(self):
self.model.flip({'rxn_4', 'rxn_5'})
self.model.flip({'rxn_1', 'rxn_4', 'rxn_2'})
self.assertEqual(self.model.matrix[Compound('A'), 'rxn_1'], -2)
self.assertEqual(self.model.matrix[Compound('A'), 'rxn_2'], 1)
self.assertEqual(self.model.matrix[Compound('B'), 'rxn_2'], -1)
self.assertEqual(self.model.matrix[Compound('A'), 'rxn_4'], -1)
self.assertEqual(self.model.matrix[Compound('C'), 'rxn_4'], 1)
self.assertEqual(self.model.matrix[Compound('C'), 'rxn_5'], 1)
self.assertEqual(self.model.matrix[Compound('D'), 'rxn_5'], -1)
def test_flipable_model_view_limits_get_item_after_flip(self):
self.model.flip({'rxn_1', 'rxn_2'})
self.assertEqual(self.model.limits['rxn_1'].bounds, (-1000, 0))
self.assertEqual(self.model.limits['rxn_2'].bounds, (-1000, 1000))
self.assertEqual(self.model.limits['rxn_3'].bounds, (0, 1000))
def test_flipable_model_view_limits_set_item_after_flip(self):
self.model.flip({'rxn_1'})
self.model.limits['rxn_1'].bounds = -20, 500
self.assertEqual(self.model.limits['rxn_1'].bounds, (-20, 500))
self.model.flip({'rxn_1'})
self.assertEqual(self.model.limits['rxn_1'].bounds, (-500, 20))
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> 2 A'))
self.database.set_reaction('rxn_2', parse_reaction('A <=> B'))
self.database.set_reaction('rxn_3', parse_reaction('A => D[e]'))
self.database.set_reaction('rxn_4', parse_reaction('A + 2 B => C'))
self.database.set_reaction('rxn_5', parse_reaction('C => 3 D[e]'))
self.database.set_reaction('rxn_6', parse_reaction('D[e] =>'))
class TestRandomSparse(unittest.TestCase):
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('A[e] => B[e]'))
self._database.set_reaction('rxn_2', parse_reaction('B[e] => C[e]'))
self._database.set_reaction('rxn_3', parse_reaction('B[e] => D[e]'))
self._database.set_reaction('rxn_4', parse_reaction('C[e] => E[e]'))
self._database.set_reaction('rxn_5', parse_reaction('D[e] => E[e]'))
self._database.set_reaction('rxn_6', parse_reaction('E[e] =>'))
self._database.set_reaction('ex_A', parse_reaction('A[e] <=>'))
self._mm = MetabolicModel.load_model(
self._database, self._database.reactions)
self._assoc = {
'rxn_1': boolean.Expression('gene_1'),
'rxn_2': boolean.Expression('gene_2 or gene_3'),
'rxn_5': boolean.Expression('gene_3 and gene_4')
}
self._obj_reaction = 'rxn_6'
try:
self._solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
self._prob = fluxanalysis.FluxBalanceProblem(self._mm, self._solver)
def test_random_sparse_reaction_strategy(self):
expected = [
({'rxn_1', 'rxn_6', 'ex_A', 'rxn_2', 'rxn_4'}, {'rxn_3', 'rxn_5'}),
({'rxn_1', 'rxn_6', 'ex_A', 'rxn_3', 'rxn_5'}, {'rxn_2', 'rxn_4'})
]
strategy = randomsparse.ReactionDeletionStrategy(self._mm)
essential, deleted = randomsparse.random_sparse(
strategy,
self._prob,
self._obj_reaction,
flux_threshold=100)
self.assertTrue((essential, deleted) in expected)
def test_random_sparse_gene_strategy(self):
expected = [
({'gene_1', 'gene_2'}, {'gene_3', 'gene_4'}),
({'gene_1', 'gene_3'}, {'gene_2', 'gene_4'})
]
strategy = randomsparse.GeneDeletionStrategy(
self._mm, self._assoc)
essential, deleted = randomsparse.random_sparse(
strategy,
self._prob,
self._obj_reaction,
flux_threshold=100)
self.assertTrue((essential, deleted) in expected)
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |D[e]|'))
self.database.set_reaction('rxn_4', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_5', parse_reaction('|C| => |D[e]|'))
self.database.set_reaction('rxn_6', parse_reaction('|D[e]| =>'))
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self._database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self._database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self._database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self._mm = MetabolicModel.load_model(
self._database, self._database.reactions)
class TestMetabolicModelFlipableView(unittest.TestCase):
def setUp(self):
# TODO use mock database instead of actual database
self.database = DictDatabase()
self.database.set_reaction("rxn_1", parse_reaction("=> (2) |A|"))
self.database.set_reaction("rxn_2", parse_reaction("|A| <=> |B|"))
self.database.set_reaction("rxn_3", parse_reaction("|A| => |D|"))
self.database.set_reaction("rxn_4", parse_reaction("|A| => |C|"))
self.database.set_reaction("rxn_5", parse_reaction("|C| => |D|"))
self.database.set_reaction("rxn_6", parse_reaction("|D| =>"))
model = MetabolicModel.load_model(self.database, self.database.reactions)
self.model = FlipableModelView(model)
def test_flipable_model_view_matrix_get_item_after_flip(self):
self.model.flip({"rxn_4"})
self.assertEqual(self.model.matrix[Compound("A"), "rxn_1"], 2)
self.assertEqual(self.model.matrix[Compound("A"), "rxn_2"], -1)
self.assertEqual(self.model.matrix[Compound("A"), "rxn_4"], 1)
self.assertEqual(self.model.matrix[Compound("C"), "rxn_4"], -1)
def test_flipable_model_view_matrix_get_item_after_double_flip(self):
self.model.flip({"rxn_4", "rxn_5"})
self.model.flip({"rxn_1", "rxn_4", "rxn_2"})
self.assertEqual(self.model.matrix[Compound("A"), "rxn_1"], -2)
self.assertEqual(self.model.matrix[Compound("A"), "rxn_2"], 1)
self.assertEqual(self.model.matrix[Compound("B"), "rxn_2"], -1)
self.assertEqual(self.model.matrix[Compound("A"), "rxn_4"], -1)
self.assertEqual(self.model.matrix[Compound("C"), "rxn_4"], 1)
self.assertEqual(self.model.matrix[Compound("C"), "rxn_5"], 1)
self.assertEqual(self.model.matrix[Compound("D"), "rxn_5"], -1)
def test_flipable_model_view_limits_get_item_after_flip(self):
self.model.flip({"rxn_1", "rxn_2"})
self.assertEqual(self.model.limits["rxn_1"].bounds, (-1000, 0))
self.assertEqual(self.model.limits["rxn_2"].bounds, (-1000, 1000))
self.assertEqual(self.model.limits["rxn_3"].bounds, (0, 1000))
def test_flipable_model_view_limits_set_item_after_flip(self):
self.model.flip({"rxn_1"})
self.model.limits["rxn_1"].bounds = -20, 500
self.assertEqual(self.model.limits["rxn_1"].bounds, (-20, 500))
self.model.flip({"rxn_1"})
self.assertEqual(self.model.limits["rxn_1"].bounds, (-500, 20))
class TestMetabolicModelFlipableView(unittest.TestCase):
def setUp(self):
# TODO use mock database instead of actual database
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |D|'))
self.database.set_reaction('rxn_4', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_5', parse_reaction('|C| => |D|'))
self.database.set_reaction('rxn_6', parse_reaction('|D| =>'))
model = MetabolicModel.load_model(self.database, self.database.reactions)
self.model = FlipableModelView(model)
def test_flipable_model_view_matrix_get_item_after_flip(self):
self.model.flip({ 'rxn_4' })
self.assertEqual(self.model.matrix[Compound('A'), 'rxn_1'], 2)
self.assertEqual(self.model.matrix[Compound('A'), 'rxn_2'], -1)
self.assertEqual(self.model.matrix[Compound('A'), 'rxn_4'], 1)
self.assertEqual(self.model.matrix[Compound('C'), 'rxn_4'], -1)
def test_flipable_model_view_matrix_get_item_after_double_flip(self):
self.model.flip({ 'rxn_4', 'rxn_5' })
self.model.flip({ 'rxn_1', 'rxn_4', 'rxn_2' })
self.assertEqual(self.model.matrix[Compound('A'), 'rxn_1'], -2)
self.assertEqual(self.model.matrix[Compound('A'), 'rxn_2'], 1)
self.assertEqual(self.model.matrix[Compound('B'), 'rxn_2'], -1)
self.assertEqual(self.model.matrix[Compound('A'), 'rxn_4'], -1)
self.assertEqual(self.model.matrix[Compound('C'), 'rxn_4'], 1)
self.assertEqual(self.model.matrix[Compound('C'), 'rxn_5'], 1)
self.assertEqual(self.model.matrix[Compound('D'), 'rxn_5'], -1)
def test_flipable_model_view_limits_get_item_after_flip(self):
self.model.flip({ 'rxn_1', 'rxn_2' })
self.assertEqual(self.model.limits['rxn_1'].bounds, (-1000, 0))
self.assertEqual(self.model.limits['rxn_2'].bounds, (-1000, 1000))
self.assertEqual(self.model.limits['rxn_3'].bounds, (0, 1000))
def test_flipable_model_view_limits_set_item_after_flip(self):
self.model.flip({ 'rxn_1' })
self.model.limits['rxn_1'].bounds = -20, 500
self.assertEqual(self.model.limits['rxn_1'].bounds, (-20, 500))
self.model.flip({ 'rxn_1' })
self.assertEqual(self.model.limits['rxn_1'].bounds, (-500, 20))
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |D|'))
self.database.set_reaction('rxn_4', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_5', parse_reaction('|C| => |D|'))
self.database.set_reaction('rxn_6', parse_reaction('|D| =>'))
self.database.set_reaction('rxn_7', parse_reaction('|E| => |F|'))
self.database.set_reaction('rxn_8', parse_reaction('|F| => |E|'))
self.model = MetabolicModel.load_model(self.database,
self.database.reactions)
self.model.limits['rxn_5'].upper = 100
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('ex_A', parse_reaction('|A| <=>'))
self.database.set_reaction('ex_D', parse_reaction('|D| <=>'))
self.database.set_reaction('rxn_1', parse_reaction('|A| => |B|'))
self.database.set_reaction('rxn_2', parse_reaction('|B| <=> |C|'))
self.database.set_reaction('rxn_3', parse_reaction('|C| <=> |D|'))
self.database.set_reaction('rxn_4', parse_reaction('|D| <=> |E|'))
self.database.set_reaction('rxn_5', parse_reaction('|E| => |B|'))
self.model = MetabolicModel.load_model(self.database,
self.database.reactions)
self.model.limits['ex_A'].lower = -10 # Low uptake
self.model.limits['ex_D'].lower = 0 # No uptake
try:
self.solver = generic.Solver(integer=True)
except generic.RequirementsError:
self.skipTest('Unable to find an MILP solver for tests')
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) A[c]'))
self.database.set_reaction('rxn_2', parse_reaction('A[c] <=> B[c]'))
self.database.set_reaction('rxn_3', parse_reaction('A[c] => D[e]'))
self.database.set_reaction('rxn_4', parse_reaction('A[c] => C[c]'))
self.database.set_reaction('rxn_5', parse_reaction('C[c] => D[e]'))
self.database.set_reaction('rxn_6', parse_reaction('D[e] =>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self._database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self._database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self._database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self._mm = MetabolicModel.load_model(
self._database, self._database.reactions)
self._strategy = randomsparse.ReactionDeletionStrategy(self._mm)
def setUp(self):
# TODO use mock database instead of actual database
self.database = DictDatabase()
self.database.set_reaction("rxn_1", parse_reaction("=> (2) |A|"))
self.database.set_reaction("rxn_2", parse_reaction("|A| <=> |B|"))
self.database.set_reaction("rxn_3", parse_reaction("|A| => |D[e]|"))
self.database.set_reaction("rxn_4", parse_reaction("|A| => |C|"))
self.database.set_reaction("rxn_5", parse_reaction("|C| => |D[e]|"))
self.database.set_reaction("rxn_6", parse_reaction("|D[e]| =>"))
self.model = MetabolicModel.load_model(self.database, self.database.reactions)
def setUp(self):
# TODO use mock database instead of actual database
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |D[e]|'))
self.database.set_reaction('rxn_4', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_5', parse_reaction('|C| => |D[e]|'))
self.database.set_reaction('rxn_6', parse_reaction('|D[e]| =>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |D|'))
self.database.set_reaction('rxn_4', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_5', parse_reaction('|C| => |D|'))
self.database.set_reaction('rxn_6', parse_reaction('|D| =>'))
model = MetabolicModel.load_model(self.database, self.database.reactions)
self.model = FlipableModelView(model)
def setUp(self):
# TODO use mock model instead of actual model
self.database = DictDatabase()
self.database.set_reaction("rxn_1", parse_reaction("=> (2) |A|"))
self.database.set_reaction("rxn_2", parse_reaction("|A| <=> |B|"))
self.database.set_reaction("rxn_3", parse_reaction("|A| => |D|"))
self.database.set_reaction("rxn_4", parse_reaction("|A| => |C|"))
self.database.set_reaction("rxn_5", parse_reaction("|C| => |D|"))
self.database.set_reaction("rxn_6", parse_reaction("|D| =>"))
self.model = MetabolicModel.load_model(self.database, self.database.reactions)
self.solver = cplex.Solver()
def setUp(self):
# TODO use mock model instead of actual model
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction(
'|A| + |B| => |C|'))
self.database.set_reaction('rxn_2', parse_reaction(
'|C| + |Z| => |A| + |B|'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
self.solver = cplex.Solver()
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |D|'))
self.database.set_reaction('rxn_4', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_5', parse_reaction('|C| => |D|'))
self.database.set_reaction('rxn_6', parse_reaction('|D| =>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
self.solver = cplex.Solver()
class TestRandomSparse(unittest.TestCase):
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('A[e] => B[e]'))
self._database.set_reaction('rxn_2', parse_reaction('B[e] => C[e]'))
self._database.set_reaction('rxn_3', parse_reaction('B[e] => D[e]'))
self._database.set_reaction('rxn_4', parse_reaction('C[e] => E[e]'))
self._database.set_reaction('rxn_5', parse_reaction('D[e] => E[e]'))
self._database.set_reaction('rxn_6', parse_reaction('E[e] =>'))
self._database.set_reaction('ex_A', parse_reaction('A[e] <=>'))
self._mm = MetabolicModel.load_model(self._database,
self._database.reactions)
self._assoc = {
'rxn_1': boolean.Expression('gene_1'),
'rxn_2': boolean.Expression('gene_2 or gene_3'),
'rxn_5': boolean.Expression('gene_3 and gene_4')
}
self._obj_reaction = 'rxn_6'
try:
self._solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
self._prob = fluxanalysis.FluxBalanceProblem(self._mm, self._solver)
def test_random_sparse_reaction_strategy(self):
expected = [({'rxn_1', 'rxn_6', 'ex_A', 'rxn_2',
'rxn_4'}, {'rxn_3', 'rxn_5'}),
({'rxn_1', 'rxn_6', 'ex_A', 'rxn_3',
'rxn_5'}, {'rxn_2', 'rxn_4'})]
strategy = randomsparse.ReactionDeletionStrategy(self._mm)
essential, deleted = randomsparse.random_sparse(strategy,
self._prob,
self._obj_reaction,
flux_threshold=100)
self.assertTrue((essential, deleted) in expected)
def test_random_sparse_gene_strategy(self):
expected = [({'gene_1', 'gene_2'}, {'gene_3', 'gene_4'}),
({'gene_1', 'gene_3'}, {'gene_2', 'gene_4'})]
strategy = randomsparse.GeneDeletionStrategy(self._mm, self._assoc)
essential, deleted = randomsparse.random_sparse(strategy,
self._prob,
self._obj_reaction,
flux_threshold=100)
self.assertTrue((essential, deleted) in expected)
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self._database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self._database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self._database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self._mm = MetabolicModel.load_model(
self._database, self._database.reactions)
self._assoc = {'rxn_2': boolean.Expression('gene_1 or gene_2')}
self._strategy = randomsparse.GeneDeletionStrategy(
self._mm, self._assoc)
class TestFastGapFill(unittest.TestCase):
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self._database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self._database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self._database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self._mm = MetabolicModel.load_model(
self._database, self._database.reactions)
try:
self._solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def test_fastgapfill(self):
core = {'rxn_2', 'rxn_3'}
induced = fastgapfill.fastgapfill(
self._mm,
core,
epsilon=0.001,
solver=self._solver)
self.assertEqual(
set(induced),
{'rxn_1', 'rxn_2', 'rxn_3', 'rxn_4'})
class TestGeneDeletionStrategy(unittest.TestCase):
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self._database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self._database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self._database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self._mm = MetabolicModel.load_model(self._database,
self._database.reactions)
self._assoc = {'rxn_2': boolean.Expression('gene_1 or gene_2')}
self._strategy = randomsparse.GeneDeletionStrategy(
self._mm, self._assoc)
def test_method_get_all(self):
expected_total = {'gene_1', 'gene_2'}
self.assertEqual(set(self._strategy.entities), expected_total)
def test_method_tests_and_delete(self):
expected_genes = {'gene_1', 'gene_2'}
expected_reaction_set = {'rxn_2'}
test_dict = {}
for i, (gene, deleted_reac) in enumerate(self._strategy.iter_tests()):
self._strategy.delete(gene, deleted_reac)
if i == 0:
self.assertEqual(deleted_reac, set())
else:
self.assertEqual(deleted_reac, {'rxn_2'})
test_dict[gene] = deleted_reac
self.assertTrue(all(x in test_dict for x in expected_genes))
self.assertTrue(expected_reaction_set in test_dict.values())
class TestGeneDeletionStrategy(unittest.TestCase):
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self._database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self._database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self._database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self._mm = MetabolicModel.load_model(
self._database, self._database.reactions)
self._assoc = {'rxn_2': boolean.Expression('gene_1 or gene_2')}
self._strategy = randomsparse.GeneDeletionStrategy(
self._mm, self._assoc)
def test_method_get_all(self):
expected_total = {'gene_1', 'gene_2'}
self.assertEqual(set(self._strategy.entities), expected_total)
def test_method_tests_and_delete(self):
expected_genes = {'gene_1', 'gene_2'}
expected_reaction_set = {'rxn_2'}
test_dict = {}
for i, (gene, deleted_reac) in enumerate(self._strategy.iter_tests()):
self._strategy.delete(gene, deleted_reac)
if i == 0:
self.assertEqual(deleted_reac, set())
else:
self.assertEqual(deleted_reac, {'rxn_2'})
test_dict[gene] = deleted_reac
self.assertTrue(all(x in test_dict for x in expected_genes))
self.assertTrue(expected_reaction_set in test_dict.values())
class TestFluxBalance(unittest.TestCase):
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> (2) |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |D|'))
self.database.set_reaction('rxn_4', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_5', parse_reaction('|C| => |D|'))
self.database.set_reaction('rxn_6', parse_reaction('|D| =>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
self.solver = cplex.Solver()
def test_flux_balance_rxn_1(self):
fluxes = dict(fluxanalysis.flux_balance(
self.model, 'rxn_1', tfba=False, solver=self.solver))
self.assertEqual(fluxes['rxn_1'], 500)
self.assertEqual(fluxes['rxn_2'], 0)
self.assertEqual(fluxes['rxn_6'], 1000)
def test_flux_balance_rxn_2(self):
fluxes = dict(fluxanalysis.flux_balance(
self.model, 'rxn_2', tfba=False, solver=self.solver))
self.assertEqual(fluxes['rxn_2'], 0)
def test_flux_balance_rxn_3(self):
fluxes = dict(fluxanalysis.flux_balance(
self.model, 'rxn_3', tfba=False, solver=self.solver))
self.assertEqual(fluxes['rxn_1'], 500)
self.assertEqual(fluxes['rxn_2'], 0)
self.assertEqual(fluxes['rxn_3'], 1000)
self.assertEqual(fluxes['rxn_6'], 1000)
def test_flux_balance_rxn_6(self):
fluxes = dict(fluxanalysis.flux_balance(
self.model, 'rxn_6', tfba=False, solver=self.solver))
self.assertEqual(fluxes['rxn_1'], 500)
self.assertEqual(fluxes['rxn_2'], 0)
self.assertEqual(fluxes['rxn_6'], 1000)
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self.database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def setUp(self):
# TODO use mock model instead of actual model
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> |A|'))
self.database.set_reaction('rxn_2',
parse_reaction('(0.000001) |A| =>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def test_load_model_with_reaction_subset(self):
database = DictDatabase()
database.set_reaction('rxn_1', parse_reaction('|A| => |B|'))
database.set_reaction('rxn_2', parse_reaction('|B| => |C|'))
database.set_reaction('rxn_3', parse_reaction('|C| => |D|'))
model = MetabolicModel.load_model(database, {'rxn_1'})
self.assertEqual(set(model.reactions), {'rxn_1'})
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('|A| => |B|'))
self.database.set_reaction('rxn_2', parse_reaction('|B| => |G|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |G|'))
self.database.set_reaction('rxn_4', parse_reaction('|B| => |H|'))
self.database.set_reaction('rxn_5', parse_reaction('|B| => |C| + |F|'))
self.database.set_reaction('rxn_6', parse_reaction('|C| => |D|'))
self.database.set_reaction('rxn_7', parse_reaction('|E| <=> |D|'))
self.database.set_reaction('rxn_9', parse_reaction('|I| => |J|'))
self.database.set_reaction('rxn_10', parse_reaction('|J| => |K|'))
self.database.set_reaction('rxn_A', parse_reaction('=> |A|'))
self.database.set_reaction('rxn_G', parse_reaction('|G| =>'))
self.database.set_reaction('rxn_E', parse_reaction('|E| =>'))
self.database.set_reaction(
'rxn_bio', parse_reaction('|D| + (2.5) |F| =>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
class TestGetExchangeReactions(unittest.TestCase):
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self._database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self._database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self._database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self._mm = MetabolicModel.load_model(self._database,
self._database.reactions)
def test_get_exchange_reactions(self):
expected_reactions = {'rxn_1', 'rxn_4'}
self.assertEqual(set(randomsparse.get_exchange_reactions(self._mm)),
expected_reactions)
class TestGapfind(unittest.TestCase):
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('=> |A|'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|A| => |C|'))
self.database.set_reaction('rxn_4', parse_reaction('|C| => |D|'))
self.database.set_reaction('rxn_5', parse_reaction('|D| <=> |E|'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
try:
self.solver = generic.Solver(integer=True)
except generic.RequirementsError:
self.skipTest('Unable to find an MILP solver for tests')
def test_gapfind(self):
self.model.remove_reaction('rxn_4')
compounds = set(gapfind(self.model, self.solver))
self.assertEqual(compounds, {Compound('D'), Compound('E')})
def test_gapfill_add_reaction(self):
core = set(self.model.reactions) - {'rxn_4'}
blocked = {Compound('D'), Compound('E')}
add, rev = gapfill(self.model, core, blocked, self.solver)
self.assertEqual(set(rev), set())
self.assertEqual(set(add), {'rxn_4'})
def test_gapfill_reverse_reaction(self):
self.model.database.set_reaction('rxn_4', parse_reaction('|D| => |C|'))
core = set(self.model.reactions)
blocked = {Compound('D'), Compound('E')}
add, rev = gapfill(self.model, core, blocked, self.solver)
self.assertEqual(set(rev), {'rxn_4'})
self.assertEqual(set(add), set())
class TestFlippingModel(unittest.TestCase):
"""Test fastcore on a model that has to flip"""
def setUp(self):
self.database = DictDatabase()
self.database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self.database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self.database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self.database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self.model = MetabolicModel.load_model(
self.database, self.database.reactions)
try:
self.solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def test_fastcore_induced_model(self):
core = {'rxn_2', 'rxn_3'}
self.assertEqual(set(
fastcore.fastcore(self.model, core, 0.001, solver=self.solver)),
{'rxn_1', 'rxn_2', 'rxn_3', 'rxn_4'})
class TestFastGapFill(unittest.TestCase):
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self._database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self._database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self._database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self._mm = MetabolicModel.load_model(self._database,
self._database.reactions)
try:
self._solver = generic.Solver()
except generic.RequirementsError:
self.skipTest('Unable to find an LP solver for tests')
def test_fastgapfill(self):
core = {'rxn_2', 'rxn_3'}
induced = fastgapfill.fastgapfill(self._mm,
core,
epsilon=0.001,
solver=self._solver)
self.assertEqual(set(induced), {'rxn_1', 'rxn_2', 'rxn_3', 'rxn_4'})
class TestReactionDeletionStrategy(unittest.TestCase):
def setUp(self):
self._database = DictDatabase()
self._database.set_reaction('rxn_1', parse_reaction('|A| <=>'))
self._database.set_reaction('rxn_2', parse_reaction('|A| <=> |B|'))
self._database.set_reaction('rxn_3', parse_reaction('|C| <=> |B|'))
self._database.set_reaction('rxn_4', parse_reaction('|C| <=>'))
self._mm = MetabolicModel.load_model(self._database,
self._database.reactions)
self._strategy = randomsparse.ReactionDeletionStrategy(self._mm)
def test_method_get_all(self):
expected_total = {'rxn_1', 'rxn_2', 'rxn_3', 'rxn_4'}
self.assertEqual(set(self._strategy.entities), expected_total)
def test_method_tests(self):
expected_reactions = {
'rxn_1': {'rxn_1'},
'rxn_2': {'rxn_2'},
'rxn_3': {'rxn_3'},
'rxn_4': {'rxn_4'}
}
self.assertEqual(dict(self._strategy.iter_tests()), expected_reactions)
