def testGPR(self):
model = self.model_class()
reaction = Reaction("test")
# set a gpr to reaction not in a model
reaction.gene_reaction_rule = "(g1 or g2) and g3"
self.assertEqual(reaction.gene_reaction_rule, "(g1 or g2) and g3")
self.assertEqual(len(reaction.genes), 3)
# adding reaction with a GPR propagates to the model
model.add_reaction(reaction)
self.assertEqual(len(model.genes), 3)
# ensure the gene objects are the same in the model and reaction
reaction_gene = list(reaction.genes)[0]
model_gene = model.genes.get_by_id(reaction_gene.id)
self.assertIs(reaction_gene, model_gene)
# test ability to handle uppercase AND/OR
with warnings.catch_warnings():
warnings.simplefilter("ignore")
reaction.gene_reaction_rule = "(b1 AND b2) OR (b3 and b4)"
self.assertEqual(reaction.gene_reaction_rule,
"(b1 and b2) or (b3 and b4)")
self.assertEqual(len(reaction.genes), 4)
# ensure regular expressions correctly extract genes from malformed
# GPR string
with warnings.catch_warnings():
warnings.simplefilter("ignore")
reaction.gene_reaction_rule = "(a1 or a2"
self.assertEqual(len(reaction.genes), 2)
reaction.gene_reaction_rule = "(forT or "
self.assertEqual(len(reaction.genes), 1)
def _replace_adapted_metabolites(self, reaction):
"""
Replace adapted metabolites by model metabolites
Parameters
----------
reaction: cameo.core.reaction.Reaction
Returns
-------
cameo.core.reaction.Reaction
"""
stoichiometry = {}
for metabolite, coefficient in six.iteritems(reaction.metabolites):
found = False
for adapter in self.adapters:
if metabolite == adapter.products[0]:
metabolite = adapter.reactants[0]
found = False
break
if not found:
metabolite = metabolite
stoichiometry[metabolite] = coefficient
reaction = Reaction(id=reaction.id,
name=reaction.name,
lower_bound=reaction.lower_bound,
upper_bound=reaction.upper_bound)
reaction.add_metabolites(stoichiometry)
return reaction
def test_iadd(self):
model = self.model
PGI = model.reactions.PGI
EX_h2o = model.reactions.EX_h2o_e
original_PGI_gpr = PGI.gene_reaction_rule
PGI += EX_h2o
self.assertEqual(PGI.gene_reaction_rule, original_PGI_gpr)
self.assertEqual(PGI.metabolites[model.metabolites.h2o_e], -1.0)
# original should not have changed
self.assertEqual(EX_h2o.gene_reaction_rule, '')
self.assertEqual(EX_h2o.metabolites[model.metabolites.h2o_e], -1.0)
# what about adding a reaction not in the model
new_reaction = Reaction("test")
new_reaction.add_metabolites({Metabolite("A"): -1, Metabolite("B"): 1})
PGI += new_reaction
self.assertEqual(PGI.gene_reaction_rule, original_PGI_gpr)
self.assertEqual(len(PGI.gene_reaction_rule), 5)
# and vice versa
new_reaction += PGI
self.assertEqual(len(new_reaction.metabolites), 5) # not 7
self.assertEqual(len(new_reaction.genes), 1)
self.assertEqual(new_reaction.gene_reaction_rule, original_PGI_gpr)
# what about combining 2 gpr's
model.reactions.ACKr += model.reactions.ACONTa
self.assertEqual(model.reactions.ACKr.gene_reaction_rule,
"(b2296 or b3115 or b1849) and (b0118 or b1276)")
self.assertEqual(len(model.reactions.ACKr.genes), 5)
def test_add_metabolite(self):
model = self.model
reaction = model.reactions.get_by_id("PGI")
reaction.add_metabolites({model.metabolites[0]: 1})
self.assertIn(model.metabolites[0], reaction._metabolites)
fake_metabolite = Metabolite("fake")
reaction.add_metabolites({fake_metabolite: 1})
self.assertIn(fake_metabolite, reaction._metabolites)
self.assertTrue(model.metabolites.has_id("fake"))
self.assertIs(model.metabolites.get_by_id("fake"), fake_metabolite)
# test adding by string
reaction.add_metabolites({"g6p_c": -1}) # already in reaction
self.assertTrue(
reaction._metabolites[model.metabolites.get_by_id("g6p_c")], -2)
reaction.add_metabolites({"h_c": 1}) # not currently in reaction
self.assertTrue(
reaction._metabolites[model.metabolites.get_by_id("h_c")], 1)
with self.assertRaises(KeyError):
reaction.add_metabolites({"missing": 1})
# test adding to a new Reaction
reaction = Reaction("test")
self.assertEqual(len(reaction._metabolites), 0)
reaction.add_metabolites({Metabolite("test_met"): -1})
self.assertEqual(len(reaction._metabolites), 1)
def parsimonious_fba(model, db):
'''
:param model: Takes in a model in SBML format and converts it into a cobrapy model
:param db: Takes in a database of reactions to be added to the model that will make
it feasible to solve
:return: Will run a parsimonious FBA on the model which reduces the sum of total fluxes through the model.
Then the sources and sinks of ATP in the reaction will be printed so that we can analyze where ATP comes from
and where it goes in this model as that will give us insight into the mechanism by which the GrowMatch algorithm has
added a reaction that allows the model to produce methanol.
'''
model = create_cobra_model_from_sbml_file(model)
rxn_list = pickle.load(open(db, 'rb'))
# For loop that adds the reactions in a given run present in the dictionary to the model using regular expressions
for run in rxn_list.keys():
model_test = model.copy()
fva_list = [model_test.reactions.ATPS]
for rxn in rxn_list[run]:
addID = re.search('(rxn\d{5}_reverse)|(rxn\d{5})', rxn).group(0)
formula = re.search('(cpd\d{5}.*$)|(\d+.\d+\scpd\d{5}.*$)', rxn).group(0)
rxn = Reaction(addID)
model_test.add_reaction(rxn)
rxn.reaction = formula
# Creates a test model to run ParsFBA on and then prints out the run as well as the sources/sinks of ATP in the
# reactions
model_fba_test = model_test.copy()
flux_analysis.optimize_minimal_flux(model_fba_test)
# fluxes = findInsAndOuts(model_fba_test)
# sorted_outs = fluxes[0]
# sorted_ins = fluxes[1]
print run
model_fba_test.metabolites.get_by_id('cpd00002_c0').summary()
def test_demand(self, model):
dm = Reaction("demand")
model.add_reaction(dm)
dm.build_reaction_from_string("atp_c ->")
dm = model.demands
assert len(dm) == 1
assert "demand" in [r.id for r in dm]
def _add_target_constraints(self, c):
"""Add the target constraints to the dual model"""
targets = self._target_constraints
w_reactions = []
for i, target in enumerate(targets):
assert isinstance(target, optlang.interface.Constraint)
if not target.is_Linear:
raise ValueError("Target constraints must be linear.")
if (target.lb is None and target.ub is None) or (target.lb is not None and target.ub is not None):
raise ValueError("Target constraints must be one-sided inequalities.")
coefficients_dict = target.expression.as_coefficients_dict()
w_reac = Reaction("w_" + str(i))
w_reac.lower_bound = c
if target.ub is not None:
coefficients = {
self._dual_model.metabolites.get_by_id(var.name): coef for var, coef in coefficients_dict.items()
if var.name in self._dual_model.metabolites}
elif target.lb is not None:
coefficients = {
self._dual_model.metabolites.get_by_id(var.name): -coef for var, coef in coefficients_dict.items()
if var.name in self._dual_model.metabolites}
w_reac.add_metabolites(coefficients)
w_reactions.append(w_reac)
self._dual_model.add_reactions(w_reactions)
return None
def add_exchange_reaction(met_id,model,lb=0,ub=1000):
met=model.metabolites.get_by_id(met_id)
reaction = Reaction(met.id)
reaction.lower_bound=lb
reaction.upper_bound=ub
reaction.add_metabolites({met: -1.0})
model.add_reaction(reaction)
def cad_reaction(core_model):
reaction = Reaction(id="CAD", name="Cis-Aconitate Decarboxylase")
acon = core_model.metabolites.acon_DASH_C_c
co2_c = core_model.metabolites.co2_c
ita_c = Metabolite(id="ita_c", name="Itaconate", compartment="c")
reaction.add_metabolites({acon: -1, co2_c: 1, ita_c: 1})
return reaction
def categorize_reactions(model, db, category):
fva_result_dict = {}
# Wide range of ATP Synthase flux values can be positive or negative
category_1_dict = {}
# ATP Synthase flux can only be negative
category_2_dict = {}
# ATP Synthase flux can only be positive
category_3_dict = {}
model = create_cobra_model_from_sbml_file(model)
rxn_list = pickle.load(open(db, 'rb'))
for run in rxn_list.keys():
model_test = model.copy()
fva_list = [model_test.reactions.ATPS]
for rxn in rxn_list[run]:
addID = re.search('(rxn\d{5}_reverse)|(rxn\d{5})', rxn).group(0)
formula = re.search('(cpd\d{5}.*$)|(\d+.\d+\scpd\d{5}.*$)', rxn).group(0)
rxn = Reaction(addID)
model_test.add_reaction(rxn)
rxn.reaction = formula
fva_list.append(rxn)
fva_result = flux_analysis.flux_variability_analysis(model_test, fva_list)
fva_result_dict[run] = fva_result
for run in fva_result_dict:
if fva_result_dict[run]['ATPS']['maximum'] > 0 and fva_result_dict[run]['ATPS']['minimum'] < 0:
category_1_dict[run] = fva_result_dict[run]
elif fva_result_dict[run]['ATPS']['maximum'] > 0:
category_2_dict[run] = fva_result_dict[run]
else:
category_3_dict[run] = fva_result_dict[run]
if category == 1:
return category_1_dict.keys()
elif category == 2:
return category_2_dict.keys()
else:
return category_3_dict.keys()
def test_add_reaction(self):
old_reaction_count = len(self.model.reactions)
old_metabolite_count = len(self.model.metabolites)
dummy_metabolite_1 = Metabolite("test_foo_1")
dummy_metabolite_2 = Metabolite("test_foo_2")
actual_metabolite = self.model.metabolites[0]
copy_metabolite = self.model.metabolites[1].copy()
dummy_reaction = Reaction("test_foo_reaction")
dummy_reaction.add_metabolites({dummy_metabolite_1: -1,
dummy_metabolite_2: 1,
copy_metabolite: -2,
actual_metabolite: 1})
self.model.add_reaction(dummy_reaction)
self.assertEqual(self.model.reactions.get_by_id(dummy_reaction.id),
dummy_reaction)
for x in [dummy_metabolite_1, dummy_metabolite_2]:
self.assertEqual(self.model.metabolites.get_by_id(x.id), x)
# should have added 1 reaction and 2 metabolites
self.assertEqual(len(self.model.reactions), old_reaction_count + 1)
self.assertEqual(len(self.model.metabolites), old_metabolite_count + 2)
# tests on theadded reaction
reaction_in_model = self.model.reactions.get_by_id(dummy_reaction.id)
self.assertIs(type(reaction_in_model), Reaction)
self.assertIs(reaction_in_model, dummy_reaction)
self.assertEqual(len(reaction_in_model._metabolites), 4)
for i in reaction_in_model._metabolites:
self.assertEqual(type(i), Metabolite)
# tests on the added metabolites
met1_in_model = self.model.metabolites.get_by_id(dummy_metabolite_1.id)
self.assertIs(met1_in_model, dummy_metabolite_1)
#assertIsNot is not in python 2.6
copy_in_model = self.model.metabolites.get_by_id(copy_metabolite.id)
self.assertTrue(copy_metabolite is not copy_in_model)
self.assertIs(type(copy_in_model), Metabolite)
self.assertTrue(dummy_reaction in actual_metabolite._reaction)
def test_find_dead_end_reactions(self, core_model):
assert len(structural.find_dead_end_reactions(core_model)) == 0
met1 = Metabolite("fake_metabolite_1")
met2 = Metabolite("fake_metabolite_2")
reac = Reaction("fake_reac")
reac.add_metabolites({met1: -1, met2: 1})
core_model.add_reaction(reac)
assert structural.find_dead_end_reactions(core_model) == {reac}
def test_sink(self, model):
sn = Reaction("sink")
model.add_reaction(sn)
sn.build_reaction_from_string("atp_c <->")
sn.bounds = -1000, 1000
sn = model.sinks
assert len(sn) == 1
assert "sink" in [r.id for r in sn]
def tiny_toy_model():
tiny = Model("Toy Model")
m1 = Metabolite("M1")
d1 = Reaction("ex1")
d1.add_metabolites({m1: -1})
d1.upper_bound = 0
d1.lower_bound = -1000
tiny.add_reactions([d1])
tiny.objective = 'ex1'
return tiny
def create_minimal_fux_model(metabolic_model,fraction_of_optimum_objective=0.8, fraction_of_flux_minimum=2,boundaries_precision=0.001,label_model=None,metabolite_list_file_name=None):
model=copy.deepcopy(metabolic_model)
if len(model.objective)>1:
raise ValueError('Error:Only one objective supported')
original_objective=copy.deepcopy(model.objective)
for reaction in model.objective:
fva=flux_variability_analysis(model,reaction_list=[reaction.id], fraction_of_optimum=fraction_of_optimum_objective)
if reaction.objective_coefficient>0:
reaction.lower_bound=min(fva[reaction.id]["maximum"],reaction.upper_bound)
reaction.upper_bound=min(fva[reaction.id]["maximum"],reaction.upper_bound)
elif reaction.objective_coefficient<0:
reaction.lower_bound=max(fva[reaction.id]["minimum"],reaction.lower_bound)
reaction.upper_bound=max(fva[reaction.id]["minimum"],reaction.lower_bound)
reaction.lower_bound-=boundaries_precision/2.0
reaction.upper_bound+=boundaries_precision/2.0
reaction.objective_coefficient=0
reversible_reactions=[]
#convert_to_irreversible(model)
for reaction in model.reactions:
if reaction.lower_bound<0:
reversible_reactions.append(reaction.id)
convert_to_irreversible_with_indicators(model,reversible_reactions,metabolite_list=[], mutually_exclusive_directionality_constraint = True)
if metabolite_list_file_name!=None and metabolite_list_file_name!="":
metabolite_id_list=read_metabolomics_data(model,metabolite_list_fname=metabolite_list_file_name)
else:
metabolite_id_list=[]
add_turnover_metabolites(model, metabolite_id_list=metabolite_id_list, epsilon=1e-6,label_model=label_model)
flux_reporter = Metabolite('flux_reporter_0',formula='',name='',compartment='0')
reporter_coef=1
for reaction in model.reactions:
if "IRRMILP_" in reaction.id or "RATIO_" in reaction.id or "RGROUP_" in reaction.id or "TMS_" in reaction.id:
continue
reaction.add_metabolites({flux_reporter:reporter_coef})
total_flux_reaction = Reaction('total_flux')
total_flux_reaction.name = 'total_flux'
total_flux_reaction.subsystem = 'misc'
total_flux_reaction.lower_bound = 0
total_flux_reaction.upper_bound = 1000*reporter_coef*len(model.reactions)
total_flux_reaction.objective_coefficient=-1
total_flux_reaction.add_metabolites({flux_reporter:-1})
model.add_reaction(total_flux_reaction)
minimal_flux=-1*model.optimize().f
total_flux_reaction.upper_bound = minimal_flux*fraction_of_flux_minimum
total_flux_reaction.objective_coefficient=0.0
for objective in original_objective:
reaction=model.reactions.get_by_id(objective.id)
reaction.lower_bound=(fva[reaction.id]["minimum"]-boundaries_precision/2.0)
reaction.upper_bound=(fva[reaction.id]["maximum"]+boundaries_precision/2.0)
milp_reactions=model.reactions.query("IRRMILP_")
non_milp_reactions=[]
for reaction in model.reactions:
if reaction not in milp_reactions:
non_milp_reactions.append(reaction)
return model,minimal_flux,non_milp_reactions
def test_remove_breaks(self):
model = Model("test model")
A = Metabolite("A")
r = Reaction("r")
r.add_metabolites({A: -1})
r.lower_bound = -1000
r.upper_bound = 1000
model.add_reaction(r)
convert_to_irreversible(model)
model.remove_reactions(["r"])
with pytest.raises(KeyError):
revert_to_reversible(model)
def test_add_reaction(self):
"""test adding and deleting reactions"""
old_reaction_count = len(self.model.reactions)
old_metabolite_count = len(self.model.metabolites)
dummy_metabolite_1 = Metabolite("test_foo_1")
dummy_metabolite_2 = Metabolite("test_foo_2")
dummy_reaction = Reaction("test_foo_reaction")
dummy_reaction.add_metabolites({dummy_metabolite_1: -1, dummy_metabolite_2: 1})
self.model.add_reaction(dummy_reaction)
self.assertEqual(self.model.reactions._object_dict[dummy_reaction.id], dummy_reaction)
for x in [dummy_metabolite_1, dummy_metabolite_2]:
self.assertEqual(self.model.metabolites._object_dict[x.id], x)
def convert_to_cobra_model(the_network):
""" Take a generic NAMpy model and convert to
a COBRA model. The model is assumed to be monopartite.
You need a functional COBRApy for this.
Arguments:
the_network
kwargs:
flux_bounds
"""
continue_flag = True
try:
from cobra import Model, Reaction, Metabolite
except:
print 'This function requires a functional COBRApy, exiting ...'
if continue_flag:
__default_objective_coefficient = 0
if 'flux_bounds' in kwargs:
flux_bounds = kwargs['flux_bounds']
else:
flux_bounds = len(the_nodes)
metabolite_dict = {}
for the_node in the_network.nodetypes[0].nodes:
the_metabolite = Metabolite(the_node.id)
metabolite_dict.update({the_node.id: the_metabolite})
cobra_reaction_list = []
for the_edge in the_network.edges:
the_reaction = Reaction(the_edge.id)
cobra_reaction_list.append(the_reaction)
the_reaction.upper_bound = flux_bounds
the_reaction.lower_bound = -1 * flux_bounds
cobra_metabolites = {}
the_metabolite_id_1 = the_edge._nodes[0].id
the_metabolite_id_2 = the_edge._nodes[1].id
cobra_metabolites[metabolite_dict[the_metabolite_id_1]] = 1.
cobra_metabolites[metabolite_dict[the_metabolite_id_2]] = -1.
reaction.add_metabolites(cobra_metabolites)
reaction.objective_coefficient = __default_objective_coefficient
cobra_model = Model(model_id)
cobra_model.add_reactions(cobra_reaction_list)
return cobra_model
else:
return None
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 test_inequality(self):
# The space enclosed by the constraints is a 2D triangle with
# vertexes as (3, 0), (1, 2), and (0, 1)
solver = self.solver
# c1 encodes y - x > 1 ==> y > x - 1
# c2 encodes y + x < 3 ==> y < 3 - x
c1 = Metabolite("c1")
c2 = Metabolite("c2")
x = Reaction("x")
x.lower_bound = 0
y = Reaction("y")
y.lower_bound = 0
x.add_metabolites({c1: -1, c2: 1})
y.add_metabolites({c1: 1, c2: 1})
c1._bound = 1
c1._constraint_sense = "G"
c2._bound = 3
c2._constraint_sense = "L"
m = Model()
m.add_reactions([x, y])
# test that optimal values are at the vertices
m.change_objective("x")
self.assertAlmostEqual(solver.solve(m).f, 1.0)
self.assertAlmostEqual(solver.solve(m).x_dict["y"], 2.0)
m.change_objective("y")
self.assertAlmostEqual(solver.solve(m).f, 3.0)
self.assertAlmostEqual(solver.solve(m, objective_sense="minimize").f,
1.0)
def testGPR(self):
model = self.model_class()
reaction = Reaction("test")
# set a gpr to reaction not in a model
reaction.gene_reaction_rule = "(g1 or g2) and g3"
self.assertEqual(reaction.gene_reaction_rule, "(g1 or g2) and g3")
self.assertEqual(len(reaction.genes), 3)
# adding reaction with a GPR propagates to the model
model.add_reaction(reaction)
self.assertEqual(len(model.genes), 3)
# ensure the gene objects are the same in the model and reaction
reaction_gene = list(reaction.genes)[0]
model_gene = model.genes.get_by_id(reaction_gene.id)
self.assertIs(reaction_gene, model_gene)
def LPLIPA2(model):
s1 = {
model.metabolites.get_by_id("C_BOIMMG_291_c"): -1,
model.metabolites.get_by_id("hdca_c"): 1
}
s2 = {
model.metabolites.get_by_id("C_BOIMMG_27923_c"): -1,
model.metabolites.get_by_id("hdcea_c"): 1
}
s3 = {
model.metabolites.get_by_id("C_BOIMMG_27877_c"): -1,
model.metabolites.get_by_id("ocdcea_c"): 1
}
s4 = {
model.metabolites.get_by_id("C_BOIMMG_27943_c"): -1,
model.metabolites.get_by_id("ttdca_c"): 1
}
s5 = {
model.metabolites.get_by_id("C_BOIMMG_27925_c"): -1,
model.metabolites.get_by_id("ttdcea_c"): 1
}
r1 = Reaction("LPLIPA2_1")
r2 = Reaction("LPLIPA2_2")
r3 = Reaction("LPLIPA2_3")
r4 = Reaction("LPLIPA2_4")
r5 = Reaction("LPLIPA2_5")
s = [s1, s2, s3, s4, s5]
r = [r1, r2, r3, r4, r5]
for i in range(len(r)):
si = s[i]
ri = r[i]
si[model.metabolites.get_by_id("h2o_c")] = -1
si[model.metabolites.get_by_id("h_c")] = 1
si[model.metabolites.get_by_id("g3pe_c")] = 1
ri.add_metabolites(si)
model.add_reactions(r)
def _build_reaction(identifier, stoichiometry, upper, lower, name, comments):
reaction = Reaction(identifier)
reaction.id = identifier
reaction.name = name
reaction.add_metabolites(stoichiometry)
reaction.upper_bound = upper
reaction.lower_bound = lower
reaction.notes["pathway_note"] = comments
return reaction
def Test():
model = Model('TEST')
nombre = "test_reaction"
reaction = Reaction(nombre)
reaction.name = '3 oxoacyl acyl carrier protein synthase n C140 '
reaction.subsystem = 'Cell Envelope Biosynthesis'
reaction.lower_bound = 0. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({
Metabolite('malACP_c',
formula='C14H22N2O10PRS',
name='Malonyl-acyl-carrier-protein',
compartment='c'):
-1.0,
Metabolite('h_c', formula='H', name='H', compartment='c'):
-1.0,
Metabolite('ddcaACP_c',
formula='C23H43N2O8PRS',
name='Dodecanoyl-ACP-n-C120ACP',
compartment='c'):
-1.0,
Metabolite('co2_c', formula='CO2', name='CO2', compartment='c'):
1.0,
Metabolite('ACP_c',
formula='C11H21N2O7PRS',
name='acyl-carrier-protein',
compartment='c'):
1.0,
Metabolite('3omrsACP_c',
formula='C25H45N2O9PRS',
name='3-Oxotetradecanoyl-acyl-carrier-protein',
compartment='c'):
1.0
})
reaction.reaction
reaction.gene_reaction_rule = '( STM2378 or STM1197 )'
reaction.genes
model.add_reactions([reaction])
print('%i reaction' % len(model.reactions))
print('%i metabolites' % len(model.metabolites))
print('%i genes' % len(model.genes))
MostrarSistema()
model.objective = nombre
print(model.objective.expression)
print(model.objective.direction)
def LPLIPA1(model):
s1 = {
model.metabolites.get_by_id("C_BOIMMG_314_c"): -1,
model.metabolites.get_by_id("hdca_c"): 1
}
s2 = {
model.metabolites.get_by_id("C_BOIMMG_16363_c"): -1,
model.metabolites.get_by_id("hdcea_c"): 1
}
s3 = {
model.metabolites.get_by_id("C_BOIMMG_16317_c"): -1,
model.metabolites.get_by_id("ocdcea_c"): 1
}
s4 = {
model.metabolites.get_by_id("C_BOIMMG_452_c"): -1,
model.metabolites.get_by_id("ttdca_c"): 1
}
s5 = {
model.metabolites.get_by_id("C_BOIMMG_16364_c"): -1,
model.metabolites.get_by_id("ttdcea_c"): 1
}
r1 = Reaction("LPLIPA1_1")
r2 = Reaction("LPLIPA1_2")
r3 = Reaction("LPLIPA1_3")
r4 = Reaction("LPLIPA1_4")
r5 = Reaction("LPLIPA1_5")
s = [s1, s2, s3, s4, s5]
r = [r1, r2, r3, r4, r5]
for i in range(len(r)):
si = s[i]
ri = r[i]
si[model.metabolites.get_by_id("h2o_c")] = -1
si[model.metabolites.get_by_id("h_c")] = 1
si[model.metabolites.get_by_id("g3pg_c")] = 1
ri.add_metabolites(si)
model.add_reactions(r)
def PASYN_EC(model):
s1 = {
model.metabolites.get_by_id("palmACP_c"): -1,
model.metabolites.get_by_id("C_BOIMMG_423_c"): 1
}
s2 = {
model.metabolites.get_by_id("myrsACP_c"): -1,
model.metabolites.get_by_id("C_BOIMMG_38435_c"): 1
}
s3 = {
model.metabolites.get_by_id("hdeACP_c"): -1,
model.metabolites.get_by_id("C_BOIMMG_38416_c"): 1
}
s4 = {
model.metabolites.get_by_id("octeACP_c"): -1,
model.metabolites.get_by_id("C_BOIMMG_38371_c"): 1
}
s5 = {
model.metabolites.get_by_id("tdeACP_c"): -1,
model.metabolites.get_by_id("C_BOIMMG_38417_c"): 1
}
r1 = Reaction("reaction_1")
r2 = Reaction("reaction_2")
r3 = Reaction("reaction_3")
r4 = Reaction("reaction_4")
r5 = Reaction("reaction_5")
s = [s1, s2, s3, s4, s5]
r = [r1, r2, r3, r4, r5]
for i in range(len(r)):
si = s[i]
ri = r[i]
si[model.metabolites.get_by_id("glyc3p_c")] = -1
si[model.metabolites.get_by_id("ACP_c")] = 2
ri.add_metabolites(si)
model.add_reactions(r)
def addFromSeedDB(mod, lineFromSeedDB):
import pandas
from cobra import Model, Reaction, Metabolite
comp = {'0':'_c0', '1':'_e0', '2':'_p0'}
model = mod.copy()
formula = lineFromSeedDB["stoichiometry"].values[0]
rea_met = {m.split(":")[1]+comp[m.split(":")[2]]:float(m.split(":")[0]) for m in formula.split(";")}
rea_id = lineFromSeedDB["id"].values[0] + "_c0" # always the case??
rea_name= lineFromSeedDB["name"].values[0]
rea = Reaction(id=rea_id, name=rea_name)
for m in rea_met:
if m not in model.metabolites:
model.add_metabolites(Metabolite(m))
model.add_reactions(rea)
rea_stoich = {model.metabolites.get_by_id(m):rea_met[m] for m in rea_met}
rea.add_metabolites(rea_stoich)
return(model)
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 add_reaction_basic(self, r_id, r_name):
if r_id not in self.reactions:
##############
# model_data #
##############
self.reactions[r_id] = r_name
self.listed_reactions.append(r_id)
self.reaction_position[r_id] = len(self.listed_reactions) - 1
self.reaction_bounds[r_id] = (-1000, 1000)
#########
# cobra #
#########
reaction = Reaction(r_id)
self.model.add_reactions([reaction])
reaction.name = r_name
r_metabolites = {}
reaction.add_metabolites(r_metabolites)
reaction.lower_bound = -1000
reaction.upper_bound = 1000
return 1
else:
return 0
def test_gene_knockout_computation(self):
cobra_model = self.model
delete_model_genes = delete.delete_model_genes
get_removed = lambda m: {x.id for x in m._trimmed_reactions}
gene_list = ['STM1067', 'STM0227']
dependent_reactions = {
'3HAD121', '3HAD160', '3HAD80', '3HAD140', '3HAD180', '3HAD100',
'3HAD181', '3HAD120', '3HAD60', '3HAD141', '3HAD161', 'T2DECAI',
'3HAD40'
}
delete_model_genes(cobra_model, gene_list)
self.assertEqual(get_removed(cobra_model), dependent_reactions)
# cumulative
delete_model_genes(cobra_model, ["STM4221"], cumulative_deletions=True)
dependent_reactions.add('PGI')
self.assertEqual(get_removed(cobra_model), dependent_reactions)
# non-cumulative
delete_model_genes(cobra_model, ["STM4221"],
cumulative_deletions=False)
self.assertEqual(get_removed(cobra_model), {'PGI'})
# make sure on reset that the bounds are correct
reset_bound = cobra_model.reactions.get_by_id("T2DECAI").upper_bound
self.assertEqual(reset_bound, 1000.)
# test computation when gene name is a subset of another
test_model = Model()
test_reaction_1 = Reaction("test1")
test_reaction_1.gene_reaction_rule = "eggs or (spam and eggspam)"
test_model.add_reaction(test_reaction_1)
delete.delete_model_genes(test_model, ["eggs"])
self.assertEqual(get_removed(test_model), set())
delete_model_genes(test_model, ["spam"], cumulative_deletions=True)
self.assertEqual(get_removed(test_model), {'test1'})
# test computation with nested boolean expression
delete.undelete_model_genes(test_model)
test_reaction_1.gene_reaction_rule = \
"g1 and g2 and (g3 or g4 or (g5 and g6))"
delete_model_genes(test_model, ["g3"], cumulative_deletions=False)
self.assertEqual(get_removed(test_model), set())
delete_model_genes(test_model, ["g1"], cumulative_deletions=False)
self.assertEqual(get_removed(test_model), {'test1'})
delete_model_genes(test_model, ["g5"], cumulative_deletions=False)
self.assertEqual(get_removed(test_model), set())
delete_model_genes(test_model, ["g3", "g4", "g5"],
cumulative_deletions=False)
self.assertEqual(get_removed(test_model), {'test1'})
def create_new_stoichiometric_matrix(self):
"""
Extracts the new graph without the small metabolites, inorganics and cofactor pairs.
:return: Networkx graph of the new network
"""
kept_rxns = []
kept_metabolites = set()
for rxn in self._redgem.reactions:
metabolites = {}
for metabolite, coefficient in rxn.metabolites.items():
metabolite_id = metabolite.id
if metabolite_id in self._cofactor_pairs \
or metabolite_id in self._small_metabolites \
or metabolite_id in self._inorganics:
continue
new_metabolite = Metabolite(metabolite_id,
formula=metabolite.formula,
name=metabolite.name,
compartment=metabolite.compartment)
metabolites[new_metabolite] = coefficient
kept_metabolites.add(metabolite)
new_rxn = Reaction(rxn.id,
name=rxn.name,
subsystem=rxn.subsystem,
lower_bound=rxn.lower_bound,
upper_bound=rxn.upper_bound)
new_rxn.add_metabolites(metabolites)
kept_rxns.append(new_rxn)
paths_struct = [{} for _ in range(self._d + 1)
] # Comprehension list to create multiple dicts
to_struct = [""] * (self._d + 1)
for metabolite in kept_metabolites:
self._graph.add_node(metabolite.id,
paths=paths_struct,
to=to_struct)
for rxn in kept_rxns:
for reactant in rxn.reactants:
for product in rxn.products:
self._graph.add_edge(reactant.id,
product.id,
rxn_id=rxn.id,
weight=1)
return self._graph
def LP7(model, the_reactions=None, epsilon=1e-3, solver=None):
model_lp7 = model.copy()
for reaction in model_lp7.reactions:
reaction.objective_coefficient = 0
if the_reactions is None:
the_reactions = [r.id for r in model_lp7.reactions]
if not hasattr(list(the_reactions)[0], 'id'):
the_reactions = map(model_lp7.reactions.get_by_id, the_reactions)
for reaction in the_reactions:
dummy_reaction = Reaction("dummy_rxn_" + reaction.id)
dummy_reaction.lower_bound = 0
dummy_reaction.upper_bound = epsilon
dummy_reaction.objective_coefficient = 1
model_lp7.add_reaction(dummy_reaction)
dummy_metabolite = Metabolite("dummy_met_" + reaction.id)
dummy_metabolite._constraint_sense = "L"
dummy_metabolite._bound = 0
reaction.add_metabolites({dummy_metabolite: -1})
dummy_reaction.add_metabolites({dummy_metabolite: 1})
model_lp7.optimize(solver=solver)
if model_lp7.solution is None or model_lp7.solution.x_dict is None:
print "INFEASIBLE LP7"
return {}
return dict([(k, v) for k, v in model_lp7.solution.x_dict.items()
if not k.startswith('dummy_')])
def eval_ind(individual, initial_pop, model, base_biomass, exp_ess, distance):
# Set this as warning
model.solver = 'gurobi'
old_biomass = list(linear_reaction_coefficients(model).keys())[0] # index removed
old_biomass.remove_from_model()
# Make a biomass reaction and optimize for it
biomass = Reaction('BIOMASS')
model.add_reaction(biomass)
index = initial_pop.index
for i in range(len(index)):
if individual[i] == 1:
biomass.add_metabolites({initial_pop.index[i]: -0.1})
biomass.add_metabolites(base_biomass)
biomass.objective_coefficient = 1.
# Generate deletion results --> BOTTLENECK FOR SURE
deletion_results = single_gene_deletion(model, model.genes, processes=1)
# Filter the results to get a boolean result
a = [(str(next(iter(i))), 1) for i in deletion_results[deletion_results['growth'] > 1e-3].index]
b = [(str(next(iter(i))), 0) for i in deletion_results[deletion_results['growth'] <= 1e-3].index]
c = a + b
pred_ess = pd.DataFrame(c, columns=['Genes', 'Predicted_growth'])
compare_df = pd.merge(right=exp_ess, left=pred_ess, on='Genes', how='inner')
# Apply hamming distance
u = np.array([f for f in compare_df.Measured_growth])
v = np.array([x for x in compare_df.Predicted_growth])
if distance == 'hd':
dist = hamming(u, v)
elif distance == 'mcc':
dist = matthews_corrcoef(u, v)
else:
print('Error: Invalid distance metric')
return dist, sum(individual)
def test_gene_knockout_computation(self):
cobra_model = self.model
delete_model_genes = delete.delete_model_genes
get_removed = lambda m: {x.id for x in m._trimmed_reactions}
gene_list = ['STM1067', 'STM0227']
dependent_reactions = {'3HAD121', '3HAD160', '3HAD80', '3HAD140',
'3HAD180', '3HAD100', '3HAD181','3HAD120',
'3HAD60', '3HAD141', '3HAD161', 'T2DECAI',
'3HAD40'}
delete_model_genes(cobra_model, gene_list)
self.assertEqual(get_removed(cobra_model), dependent_reactions)
# cumulative
delete_model_genes(cobra_model, ["STM4221"],
cumulative_deletions=True)
dependent_reactions.add('PGI')
self.assertEqual(get_removed(cobra_model), dependent_reactions)
# non-cumulative
delete_model_genes(cobra_model, ["STM4221"],
cumulative_deletions=False)
self.assertEqual(get_removed(cobra_model), {'PGI'})
# make sure on reset that the bounds are correct
reset_bound = cobra_model.reactions.get_by_id("T2DECAI").upper_bound
self.assertEqual(reset_bound, 1000.)
# test computation when gene name is a subset of another
test_model = Model()
test_reaction_1 = Reaction("test1")
test_reaction_1.gene_reaction_rule = "eggs or (spam and eggspam)"
test_model.add_reaction(test_reaction_1)
delete.delete_model_genes(test_model, ["eggs"])
self.assertEqual(get_removed(test_model), set())
delete_model_genes(test_model, ["spam"], cumulative_deletions=True)
self.assertEqual(get_removed(test_model), {'test1'})
# test computation with nested boolean expression
delete.undelete_model_genes(test_model)
test_reaction_1.gene_reaction_rule = \
"g1 and g2 and (g3 or g4 or (g5 and g6))"
delete_model_genes(test_model, ["g3"], cumulative_deletions=False)
self.assertEqual(get_removed(test_model), set())
delete_model_genes(test_model, ["g1"], cumulative_deletions=False)
self.assertEqual(get_removed(test_model), {'test1'})
delete_model_genes(test_model, ["g5"], cumulative_deletions=False)
self.assertEqual(get_removed(test_model), set())
delete_model_genes(test_model, ["g3", "g4", "g5"],
cumulative_deletions=False)
self.assertEqual(get_removed(test_model), {'test1'})
def createTokens(model,reactionmap):
from cobra import Reaction
from cobra import Metabolite
'''
Compares a CobraPy model and a reaction map. If several model reactions are
associated with the same experimental reaction, a token reaction is created
whose flux will equal a linear combination of those reactions (the token flux). This token
reaction can be used as a decision variable during quadratic optimization attempting
to match the token flux to that of the experimental reaction.
Noe that limiting the token flux to zero will prevent any flux through the separate reactions.
'''
for linkdict in reactionmap:
if len(linkdict['modrxns']) > 1:
experimental_r_id = linkdict['exprxns'][0]['rxid']
token_id = 't_{exprxnid}'.format(exprxnid = experimental_r_id)
new_token_reaction = Reaction(token_id)
new_token_reaction.name = 'Token exchange reaction for experimental reaction {exprxnid}'.format(exprxnid = experimental_r_id)
new_token_reaction.lower_bound = -1000
new_token_reaction.upper_bound = 1000
new_token_metabolite = Metabolite(token_id,name = 'Token metabolite for experimental reaction {exprxnid}'.format(exprxnid = experimental_r_id),compartment='c')
new_token_reaction.add_metabolites({new_token_metabolite: -1.0})
model.add_reactions(new_token_reaction)
for dictionary in linkdict['modrxns']:
modelreaction = model.reactions.get_by_id(dictionary['rxid'])
modelreaction.add_metabolites({new_token_metabolite: float(dictionary['coef'])})
return model
def fix_reaction_to_min(model: cobra.Model,
reac: cobra.Reaction) -> Tuple[str, float]:
"""Fix a reaction to its minimum."""
rev_id = _apply_rev(reac.id, model)
rev_reac = model.reactions.get_by_id(rev_id) if rev_id else None
with model:
if rev_reac is not None:
prev_bounds = reac.bounds
set_objective(model, {rev_reac: 1})
reac.bounds = 0, 0
lb = model.slim_optimize()
reac.bounds = prev_bounds
reac_to_fix = rev_id
else:
set_objective(model, {reac: -1})
lb = model.slim_optimize()
reac_to_fix = reac.id
return reac_to_fix, lb
def three_components_closed(base):
"""Returns a simple model with 3 metabolites in a closed system."""
met_a = Metabolite("A")
met_b = Metabolite("B")
met_c = Metabolite("C")
rxn_1 = Reaction("R1", lower_bound=-1000, upper_bound=1000)
rxn_1.add_metabolites({met_a: -1, met_b: 1})
rxn_2 = Reaction("R2", lower_bound=-1000, upper_bound=1000)
rxn_2.add_metabolites({met_b: -1, met_c: 1})
base.add_reactions([rxn_1, rxn_2])
return base
def add_reactions_for_metabolites(self, measured_metabolites):
for metabolite, change in measured_metabolites.items():
reaction = Reaction('R_{m}_spill'.format(m=metabolite))
reaction.lower_bound = 0. # This is the default
reaction.upper_bound = 1000. # This is the default
if change > 0:
reaction.add_metabolites({self.model.metabolites.get_by_id(metabolite): -1.0})
else:
reaction.add_metabolites({self.model.metabolites.get_by_id(metabolite): 1.0})
self.model.add_reactions([reaction])
def __process_reaction(
self, new_reaction: Reaction, new_compound: int,
model_parent: Metabolite, parent_and_precursors: dict,
new_reaction_metabolites: List[Metabolite]
) -> Tuple[Reaction, List[Tuple[Metabolite, int]]]:
"""
Granulates a given reaction. Replaces the generic metabolite by its structurally defined child and corrects the
precursors.
:param Reaction new_reaction: the new reaction
:param int new_compound: the reaction structurally defined product
:param Metabolite model_parent: the model parent of the structurally defined product
:param dict parent_and_precursors: dictionary with lipid parents and their children
:param List[Metabolite] new_reaction_metabolites: list of possibly new metabolites
:return Tuple[Reaction, List[Tuple[Metabolite, int]]]: returns a tuple with the granulated model reaction
and the new added compounds that will be processed further.
"""
i = 0
found = False
while not found and i < len(new_reaction_metabolites):
if new_reaction_metabolites[i].id == model_parent.id:
new_model_parent = new_reaction_metabolites[i]
found = True
i += 1
coef = new_reaction.get_coefficient(model_parent.id)
self.add_boimmg_metabolites_to_reaction(new_compound, coef,
new_reaction,
model_parent.compartment)
met_to_subtract = {}
met_to_subtract[new_model_parent] = coef
new_reaction.subtract_metabolites(met_to_subtract)
added = self._correct_precursors(new_reaction, new_compound,
parent_and_precursors)
return new_reaction, added
def add_metabolites(self, metabolites, rescale = True):
"""
We need to override this method if the reaction is scaled
v_hat = v/vmax
dM/dt = n1*v1 + ...
dM/dt = n1*vmax1 * v1_hat + ...
:param metabolites:
:return:
"""
if not hasattr(self, '_scaled') or not rescale or not self._scaled:
Reaction.add_metabolites(self, metabolites)
else:
Reaction.add_metabolites(self, {k:v*self.scaling_factor
for k,v in metabolites.items()})
def convert_to_irreversible(model,reactions_to_convert): ##### TO DO : implement ATP cost in reverse reaction (1 ATP)
"""
Split reversible reactions into two irreversible reactions.
cobra_model: A Cobra model object which will be modified in place.
reactions_to convert: list of reaction_id to convert
"""
reactions_to_add = []
convertedlist = []
atp_metabolites = [
model.metabolites.ppi_c,
model.metabolites.pi_c,
model.metabolites.atp_c,
model.metabolites.adp_c,
model.metabolites.adp_c]
for r in reactions_to_convert:
reaction = model.reactions.get_by_id(r)
if reaction.lower_bound < 0 and reaction.upper_bound > 0:
reverse_reaction = Reaction(id=reaction.id + '_reverse',
lower_bound = reaction.lower_bound,
upper_bound = 0)
reaction.lower_bound = 0
reaction.upper_bound = reaction.upper_bound
reverse_reaction_dict = {k: v * -1 for k, v in reaction.metabolites.items()
if k not in atp_metabolites} # <- disallows recovery of ATP metabolites from protein degradation
reverse_reaction.add_metabolites(reverse_reaction_dict)
reverse_reaction.subsystem = reaction.subsystem
reactions_to_add.append(reverse_reaction)
convertedlist.append(reverse_reaction.id)
model.add_reactions(reactions_to_add)
return convertedlist
def create_adapter_reactions(original_metabolites, universal_model, mapping, compartment_regexp):
"""Create adapter reactions that connect host and universal model.
Arguments
---------
original_metabolites : list
List of host metabolites.
universal_model : cobra.Model
The universal model.
mapping : dict
A mapping between between host and universal model metabolite IDs.
compartment_regexp : regex
A compiled regex that matches metabolites that should be connected to the universal model.
Returns
-------
reactions : list
The list of adapter reactions.
"""
adapter_reactions = []
metabolites_in_main_compartment = [m for m in original_metabolites if compartment_regexp.match(m.compartment)]
if len(metabolites_in_main_compartment) == 0:
raise ValueError('no metabolites matching regex for main compartment %s' % compartment_regexp)
for metabolite in metabolites_in_main_compartment: # model is the original host model
name = re.sub('_{}$'.format(metabolite.compartment), '', metabolite.id) # TODO: still a hack
mapped_name = None
for prefix in ['bigg:', 'kegg:', 'rhea:', 'brenda:', '']: # try no prefix at last
if prefix + name in mapping:
mapped_name = mapping[prefix + name]
break
if mapped_name is not None:
adapter_reaction = Reaction(str('adapter_' + metabolite.id + '_' + mapped_name))
adapter_reaction.lower_bound = -1000
try:
adapter_reaction.add_metabolites({metabolite: -1,
universal_model.metabolites.get_by_id(mapped_name): 1})
except KeyError:
pass
else:
adapter_reactions.append(adapter_reaction)
return adapter_reactions
def constrain_pool(self):
"""Constrain the draw reactions for the unmeasured (common protein pool) proteins.
Proteins without their own protein pool are collectively constrained by the common protein pool. Remove
protein pools for all proteins that don't have measurements, along with corresponding draw reactions,
and add these to the common protein pool and reaction.
"""
new_reactions = []
to_remove = []
# * section 2.5.1
# 1. and 2. introduce `prot_pool` and exchange reaction done in __init__
# 3. limiting total usage with the unmeasured amount of protein
# looks like the matlab code:
# self.fs_matched_adjusted = ((self.p_total - self.p_measured) / self.p_base *
# self.f_mass_fraction_measured_matched_to_total *
# self.sigma_saturation_factor)
# but this gives results more like reported:
self.fs_matched_adjusted = (
(self.p_total - self.p_measured) *
self.f_mass_fraction_measured_matched_to_total *
self.sigma_saturation_factor)
self.reactions.prot_pool_exchange.bounds = 0, self.fs_matched_adjusted
# 4. Remove other enzyme usage reactions and replace with pool exchange reactions
average_mmw = self.protein_properties['mw'].mean() / 1000.
for protein_id in self.unmeasured_proteins:
to_remove.extend(
self.reactions.query('prot_{}_exchange'.format(protein_id)))
draw_reaction_id = 'draw_prot_{}'.format(protein_id)
if draw_reaction_id not in self.reactions:
draw_rxn = Reaction(draw_reaction_id)
draw_rxn.annotation['uniprot'] = protein_id
protein_pool = self.metabolites.get_by_id(
'prot_{}_c'.format(protein_id))
try:
mmw = self.protein_properties.loc[protein_id, 'mw'] / 1000.
except KeyError:
mmw = average_mmw
metabolites = {self.common_protein_pool: -mmw, protein_pool: 1}
draw_rxn.add_metabolites(metabolites)
new_reactions.append(draw_rxn)
self.add_reactions(new_reactions)
self.remove_reactions(to_remove)
def gapfillfunc(model, database, runs):
""" This function gapfills the model using the growMatch algorithm that is built into cobrapy
Returns a dictionary which contains the pertinent information about the gapfilled model such as
the reactions added, the major ins and outs of the system and the objective value of the gapfilled
model.
This function calls on two other functions sort_and_deduplicate to assure the uniqueness of the solutions
and findInsAndOuts to find major ins and outs of the model when gapfilled when certain reactions
Args:
model: a model in SBML format
database: an external database database of reactions to be used for gapfilling
runs: integer number of iterations the gapfilling algorithm will run through
"""
# Read model from SBML file and create Universal model to add reactions to
func_model = create_cobra_model_from_sbml_file(model)
Universal = Model("Universal Reactions")
f = open(database, 'r')
next(f)
rxn_dict = {}
# Creates a dictionary of the reactions from the tab delimited database, storing their ID and the reaction string
for line in f:
rxn_items = line.split('\t')
rxn_dict[rxn_items[0]] = rxn_items[6], rxn_items[1]
# Adds the reactions from the above dictionary to the Universal model
for rxnName in rxn_dict.keys():
rxn = Reaction(rxnName)
Universal.add_reaction(rxn)
rxn.reaction = rxn_dict[rxnName][0]
rxn.name = rxn_dict[rxnName][1]
# Runs the growMatch algorithm filling gaps from the Universal model
result = flux_analysis.growMatch(func_model, Universal, iterations=runs)
resultShortened = sort_and_deduplicate(uniq(result))
rxns_added = {}
rxn_met_list = []
print resultShortened
for x in range(len(resultShortened)):
func_model_test = deepcopy(func_model)
# print func_model_test.optimize().f
for i in range(len(resultShortened[x])):
addID = resultShortened[x][i].id
rxn = Reaction(addID)
func_model_test.add_reaction(rxn)
rxn.reaction = resultShortened[x][i].reaction
rxn.reaction = re.sub('\+ dummy\S+', '', rxn.reaction)
rxn.name = resultShortened[x][i].name
mets = re.findall('cpd\d{5}_c0|cpd\d{5}_e0', rxn.reaction)
for met in mets:
y = func_model_test.metabolites.get_by_id(met)
rxn_met_list.append(y.name)
obj_value = func_model_test.optimize().f
fluxes = findInsAndOuts(func_model_test)
sorted_outs = fluxes[0]
sorted_ins = fluxes[1]
rxns_added[x] = resultShortened[x], obj_value, sorted_ins, sorted_outs, rxn_met_list
rxn_met_list = []
return rxns_added
def change_boimmg_reaction_id(self, reaction: Reaction):
new_id = self.__reactionsAnnotationConfigs["BOIMMG_ID_CONSTRUCTION"]
metabolites = reaction.metabolites
metabolites = sorted([metabolite.id for metabolite in metabolites])
new_id += "_".join(metabolites)
reaction.id = new_id
return reaction.id
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 create_reaction(rxn_id, name, subsystem, lower_bound, upper_bound, metabolites_d3):
reaction = Reaction(rxn_id)
reaction.name = name
reaction.subsystem = subsystem
reaction.lower_bound = lower_bound
reaction.upper_bound = upper_bound
for metabolite_d2 in metabolites_d3:
metabolite_data = metabolite_d2[0]
metabolite_coeff = metabolite_d2[1]
new_met = create_metabolite(metabolite_data)
reaction.add_metabolites({ new_met: metabolite_coeff })
return reaction
def PLIPA3(model):
s1 = {model.metabolites.get_by_id("BMGC427_c"): -1,
model.metabolites.get_by_id("hdca_c"): 1,
model.metabolites.get_by_id("BMGC314_c"): 1}
s2 = {model.metabolites.get_by_id("BMGC7454_c"): -1,
model.metabolites.get_by_id("hdcea_c"): 1,
model.metabolites.get_by_id("BMGC16363_c"): 1}
s3 = {model.metabolites.get_by_id("BMGC7408_c"): -1,
model.metabolites.get_by_id("ocdcea_c"): 1,
model.metabolites.get_by_id("BMGC16317_c"): 1}
s4 = {model.metabolites.get_by_id("BMGC7474_c"): -1,
model.metabolites.get_by_id("ttdca_c"): 1,
model.metabolites.get_by_id("BMGC452_c"): 1}
s5 = {model.metabolites.get_by_id("BMGC7456_c"): -1,
model.metabolites.get_by_id("ttdcea_c"): 1,
model.metabolites.get_by_id("BMGC16364_c"): 1}
r1 = Reaction("PLIPA3_1")
r2 = Reaction("PLIPA3_2")
r3 = Reaction("PLIPA3_3")
r4 = Reaction("PLIPA3_4")
r5 = Reaction("PLIPA3_5")
s = [s1, s2, s3, s4, s5]
r = [r1, r2, r3, r4, r5]
for i in range(len(r)):
si = s[i]
ri = r[i]
si[model.metabolites.get_by_id("h2o_c")] = -1
si[model.metabolites.get_by_id("h_c")] = 1
ri.add_metabolites(si)
model.add_reactions(r)
def get_reference(mod, newR, delete_unbalanced, verbose):
#refdb = seedrDB.loc[seedrDB['abbreviation'].isin(newR)] # vmh
refdb = seedrDB.loc[seedrDB['id'].isin(newR)]
refmod = Model("reaction_database")
Rmod = [re.sub("_.*$", "", r.id) for r in mod.reactions]
print "Consider", len(refdb.index), "reactions"
Cold = 0
Calready = 0
for i, row in refdb.iterrows():
#rid = row["abbreviation"] # vmh
rid = row["id"]
if row["is_obsolete"] == 1: # do not add old reactions
Cold += 1
continue
#if rid in Rmod: # vmh
elif rid in Rmod:
Calready += 1
continue
r = Reaction(rid + "_c0") # default seed model have compartment tag
refmod.add_reaction(r)
#rstr = row["formula"] # vmh
rstr = row["equation"]
#rstr = row["code"]
rstr = rstr.replace("[0]", "_c0").replace("[1]",
"_e0").replace("[3]", "_p0")
if "[2]" in rstr: # TODO: consider all compartments!
continue
r.build_reaction_from_string(rstr, verbose=False)
#r.reaction = rstr
for m in refmod.metabolites:
mid = re.sub("_.*$", "", m.id)
hit = seedmDB.loc[seedmDB["id"] == mid]
m.name = hit["name"].values[0]
m.formula = hit["formula"].values[0]
m.charge = hit["charge"].values[0]
print Calready, "reactions already in the model"
print Cold, "removed deprecated reactions"
#refmod = repair_mass_balance(refmod, delete_unbalanced, verbose)
print len(refmod.reactions), "remaining reaction in reference database:",
return (refmod)
def add_bigg_reactions(model,BiGG_id_list):
for r in BiGG_id_list:
d=cobrababel.get_bigg_reaction(r, model_bigg_id='universal')
reaction = Reaction(id=d['bigg_id'].replace('_e','(e)'),
name = d['name'],
subsystem = '',
lower_bound = -1000 ,
upper_bound = 1000 ,
objective_coefficient=0.0)
for k, val in enumerate(d['metabolites']):
met=Metabolite(val['bigg_id'].replace('__', '_')+'_'+val['compartment_bigg_id'])
met.name=val['name']
met.compartment=val['compartment_bigg_id']
reaction.add_metabolites({met:val['stoichiometry']})
if reaction not in model.reactions:
model.add_reaction(reaction)
return model
def LP7(model,the_reactions=None,epsilon=1e-3,solver=None):
model_lp7 = model.copy()
for reaction in model_lp7.reactions:
reaction.objective_coefficient = 0
if the_reactions is None:
the_reactions = [r.id for r in model_lp7.reactions]
if not hasattr(list(the_reactions)[0], 'id'):
the_reactions = map(model_lp7.reactions.get_by_id,the_reactions)
for reaction in the_reactions:
dummy_reaction = Reaction("dummy_rxn_" + reaction.id)
dummy_reaction.lower_bound = 0
dummy_reaction.upper_bound = epsilon
dummy_reaction.objective_coefficient = 1
model_lp7.add_reaction(dummy_reaction)
dummy_metabolite = Metabolite("dummy_met_" + reaction.id)
dummy_metabolite._constraint_sense = "L"
dummy_metabolite._bound = 0
reaction.add_metabolites({dummy_metabolite: -1})
dummy_reaction.add_metabolites({dummy_metabolite: 1})
model_lp7.optimize(solver=solver)
if model_lp7.solution is None or model_lp7.solution.x_dict is None:
print "INFEASIBLE LP7"
return {}
return dict([(k,v) for k,v in model_lp7.solution.x_dict.items() if not k.startswith('dummy_')])
def generateSinkReactions(M, sink_mets, setting):
''' When performing metabolomics mode: add sink reactions for the metabolites the user supplied.
setting is either '''
def sink_exists(met):
''' Figure out if an exchange for met exists'''
for r in M.reactions:
if len(r.metabolites) == 1 and met in r.metabolites:
return True, r
# if we get here such a reaction was not found
return False, ''
# make sure sink_mets are metabolite objects
if all([type(m) == str or type(m) == str for m in sink_mets]):
sink_mets = [M.metabolites.get_by_id(m) for m in sink_mets]
# add sink reactions
sinks = []
for met in sink_mets:
b, existing_sink = sink_exists(met)
if b:
sinks.append(existing_sink)
print(('Using existing sink reaction', existing_sink))
else:
rxn = Reaction('tmp_sink_' + met.id)
M.add_reaction(rxn)
rxn.add_metabolites({met: -1}) # X -> nothing
rxn.upper_bound = 0
rxn.lower_bound = 0 # Block by default. Only activate when simulating
sinks.append(rxn)
return M, sinks, sink_mets
def add_exchange_reaction(met_id, model, lb=0, ub=1000):
met = model.metabolites.get_by_id(met_id)
reaction = Reaction(met.id)
reaction.lower_bound = lb
reaction.upper_bound = ub
reaction.add_metabolites({met: -1.0})
model.add_reaction(reaction)
def excel_sbml(modelname,outputname):
import datetime
import cobra
from cobra import Metabolite, Reaction, Model
from cobra.io import write_sbml_model
#from __future__ import print_function
import pandas as pd
#myfolder='/media/jupyter/zhang_x/study/'
#mname="seed_1"
#若需包括更多代谢物信息，则可先在模型中创建代谢物对象并添加到模型
#A = Metabolite('A')
#model.add_metabolites([A, B, C, D, E, P])
starttime = datetime.datetime.now()
model = Model('model')
colnames=['id','reaction_eq','name','lower_bound','upper_bound','Object']
#将上述值改为excel表格中的相应列名称数据以便正确读出值，表格中不一定包括所有列,不需要改变列的顺序，通过列头识别
#objr='Objective' #目标反应的名字
#rin=[['PGI',-10,10]] #可设置多个输入反应及其上下限
#若表格中不包括目标反应数据需人为给出，同样对输入反应需人为添加约束,若已有相应数据则这两个值不用改
#data = pd.read_csv(mname+'.csv', delimiter=",", na_values=['(none)']).fillna('')
data = pd.read_excel(modelname, sheet_name='reactions', header=0, na_values=['(none)']).fillna('') #'(none)'变NaN，NaN数据用''填充
#print(data)
#直接从excel文件读取不用再转换txt,header行为数据起始行和表头（因前面行可能有模型说明文件） 表中空值替换为空字符以便处理，不能用dropna，否则整行数据都会丢掉
keys=data.keys()
for index, row in data.iterrows():
r = Reaction(row[colnames[0]].strip()) #r即每个反应对应的反应名字（name）
model.add_reaction(r)
r.build_reaction_from_string(row[colnames[1]],fwd_arrow='-->', rev_arrow='<--', reversible_arrow='<=>', term_split='+') #excel中方程式colnames[1],转成SBML格式
if colnames[2] in keys:
r.subsystem=row[colnames[2]]
if colnames[3]in keys:
r.lower_bound=row[colnames[3]]
r.upper_bound=row[colnames[4]]
if colnames[4] in keys: #目标反应
if row[colnames[5]]:
r.objective_coefficient=row[colnames[5]]
#if colnames[5] in keys:
# if row[colnames[5]]:
# r.objective_coefficient=1
#s=row[colnames[6]] #对基因关系处理要看表格中是如何存储and/or关系的
#if s:
# genes=s.split(", ")
# r.gene_reaction_rule='('+" or ".join(genes)+' )'
#if colnames[3] not in keys: #需人为设定输入反应边界，注意根据反应方向确定是改下限还是上限及值的正负
# for r in rin:
# rea=model.reactions.get_by_id(r[0])
# rea.lower_bound=r[1]
# rea.upper_bound=r[2]
write_sbml_model(model, outputname)
def generateSinkReactions(M, sink_mets, setting):
def sink_exists(met):
''' Find if an exchange for met exists'''
for r in M.reactions:
if len(r.metabolites) == 1 and met in r.metabolites:
return True, r
# if we get here such a reaction was not found
return False, ''
# make sure sink_mets are metabolite objects
if all([type(m) == str or type(m) == str for m in sink_mets]):
sink_mets = [M.metabolites.get_by_id(m) for m in sink_mets]
# add sink reactions
sinks = []
for met in sink_mets:
b, existing_sink = sink_exists(met)
if not b:
rxn = Reaction('tmp_sink_' + met.id)
M.add_reaction(rxn)
rxn.add_metabolites({met: -1})
rxn.upper_bound = 0
rxn.lower_bound = 0 # have to init to zero. Only activate when simulating
sinks.append(rxn)
else:
sinks.append(existing_sink)
print(('Taking existing sink reaction', existing_sink))
return M, sinks, sink_mets
def testGPR(self):
model = self.model_class()
reaction = Reaction("test")
# set a gpr to reaction not in a model
reaction.gene_reaction_rule = "(g1 or g2) and g3"
self.assertEqual(reaction.gene_reaction_rule, "(g1 or g2) and g3")
self.assertEqual(len(reaction.genes), 3)
# adding reaction with a GPR propagates to the model
model.add_reaction(reaction)
self.assertEqual(len(model.genes), 3)
# ensure the gene objects are the same in the model and reaction
reaction_gene = list(reaction.genes)[0]
model_gene = model.genes.get_by_id(reaction_gene.id)
self.assertIs(reaction_gene, model_gene)
# test ability to handle uppercase AND/OR
with warnings.catch_warnings():
warnings.simplefilter("ignore")
reaction.gene_reaction_rule = "(b1 AND b2) OR (b3 and b4)"
self.assertEqual(reaction.gene_reaction_rule,
"(b1 and b2) or (b3 and b4)")
self.assertEqual(len(reaction.genes), 4)
# ensure regular expressions correctly extract genes from malformed
# GPR string
with warnings.catch_warnings():
warnings.simplefilter("ignore")
reaction.gene_reaction_rule = "(a1 or a2"
self.assertEqual(len(reaction.genes), 2)
reaction.gene_reaction_rule = "(forT or "
self.assertEqual(len(reaction.genes), 1)
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 set2respiration(model):
mod = model.copy()
mql = mod.metabolites.get_by_id("cpd15499_c0")
mqn = mod.metabolites.get_by_id("cpd15500_c0")
uql = mod.metabolites.get_by_id("cpd15561_c0")
uqn = mod.metabolites.get_by_id("cpd15560_c0")
h = mod.metabolites.get_by_id("cpd00067_c0")
esp1 = Reaction(id="ESP1", lower_bound=0, upper_bound=1000)
esp2 = Reaction(id="ESP2", lower_bound=0, upper_bound=1000)
esp1.add_metabolites({mql: -1, h: 2, mqn: 1})
esp2.add_metabolites({uql: -1, h: 2, uqn: 1})
mod.add_reactions([esp1, esp2])
mod.objective = {esp1: 1, esp2: 1}
return (mod)
