def objective(self, value):
if isinstance(value, sympy.Basic):
value = self.problem.Objective(value, sloppy=False)
if not isinstance(value, (dict, optlang.interface.Objective)):
try:
reactions = self.reactions.get_by_any(value)
except KeyError:
raise ValueError('invalid objective')
value = {rxn: 1 for rxn in reactions}
set_objective(self, value, additive=False)
def objective(self, value):
if isinstance(value, Basic):
value = self.problem.Objective(value, sloppy=False)
if not isinstance(value, (dict, optlang.interface.Objective)):
try:
reactions = self.reactions.get_by_any(value)
except KeyError:
raise ValueError('invalid objective')
value = {rxn: 1 for rxn in reactions}
set_objective(self, value, additive=False)
def test_fix_objective_as_constraint_minimize(self, solver, model):
model.reactions.Biomass_Ecoli_core.bounds = (0.1, 0.1)
minimize_glucose = model.problem.Objective(
model.reactions.EX_glc__D_e.flux_expression, direction='min')
su.set_objective(model, minimize_glucose)
su.fix_objective_as_constraint(model)
fx_name = 'Fixed_objective_{}'.format(model.objective.name)
constr = model.constraints
assert (constr[fx_name].lb,
constr[fx_name].ub) == (None, model.solver.objective.value)
def objective(self, objective):
if isinstance(objective, str):
self.model.objective = objective
elif isinstance(objective, dict):
from cobra.util.solver import set_objective
linear_coef = {self.model.reactions.get_by_id(r_id): v for r_id, v in objective.items()}
set_objective(self.model, linear_coef)
else:
raise ValueError(
'The objective must be a reaction identifier or a dictionary of \
reaction identifier with respective coeficients.')
def test_fix_objective_as_constraint_minimize(model, solver):
model.solver = solver
model.reactions.Biomass_Ecoli_core.bounds = (0.1, 0.1)
minimize_glucose = model.problem.Objective(
model.reactions.EX_glc__D_e.flux_expression, direction='min')
su.set_objective(model, minimize_glucose)
su.fix_objective_as_constraint(model)
fx_name = 'fixed_objective_{}'.format(model.objective.name)
constr = model.constraints
# Ensure that a solution exists on non-GLPK solvers.
model.slim_optimize()
assert (constr[fx_name].lb,
constr[fx_name].ub) == (None, model.solver.objective.value)
def optimize_for_species(model_file_name, species_id, medium,
time_point_folder):
""" Knock out the other species from a two species model, optimize, and save results.
"""
LOGGER.info('Loading model {0} to optimize for {1}'.format(
model_file_name, species_id))
pair_model = load_model_from_file(model_file_name)
# Figure out the species to knock out in the pair community model.
species_index = -1
for index in range(len(pair_model.notes['species'])):
if pair_model.notes['species'][index]['id'] == species_id:
species_index = index
if species_index < 0:
raise Exception(
'Species {0} is not a member of the community'.format(species_id))
if species_index == 0:
knockout_index = 1
else:
knockout_index = 0
knockout_id = pair_model.notes['species'][knockout_index]['id']
LOGGER.info('Going to knock out {0} from index {1}'.format(
knockout_id, knockout_index))
with pair_model:
# Apply the medium.
apply_medium(pair_model, medium)
# Knock out all of the reactions for the specified species.
knockout_reactions = pair_model.reactions.query(
lambda r: r.startswith(knockout_id), 'id')
for reaction in knockout_reactions:
reaction.knock_out()
# Remove the species objective from the community model objective.
knockout_objective = pair_model.reactions.get_by_id(
pair_model.notes['species'][knockout_index]['objective'])
linear_coefficients = linear_reaction_coefficients(pair_model)
del linear_coefficients[knockout_objective]
set_objective(pair_model, linear_coefficients)
save_model_to_file(pair_model,
join(time_point_folder, pair_model.id + '.json'))
# Optimize the community model with the specified species knocked out.
solution = pair_model.optimize()
solution.fluxes.to_json(
join(time_point_folder, pair_model.id +
'-solution.json')) # , orient='records', lines=True
return solution
def test_fix_objective_as_constraint_minimize(self, model, solver):
model.solver = solver
model.reactions.Biomass_Ecoli_core.bounds = (0.1, 0.1)
minimize_glucose = model.problem.Objective(
model.reactions.EX_glc__D_e.flux_expression,
direction='min')
su.set_objective(model, minimize_glucose)
su.fix_objective_as_constraint(model)
fx_name = 'fixed_objective_{}'.format(model.objective.name)
constr = model.constraints
# Ensure that a solution exists on non-GLPK solvers.
model.slim_optimize()
assert (constr[fx_name].lb, constr[fx_name].ub) == (
None, model.solver.objective.value)
def test_fix_objective_as_constraint_minimize(model: "Model",
solver: str) -> None:
"""Test fixing present objective as a constraint but as a minimization."""
model.solver = solver
model.reactions.Biomass_Ecoli_core.bounds = (0.1, 0.1)
minimize_glucose = model.problem.Objective(
model.reactions.EX_glc__D_e.flux_expression, direction="min")
su.set_objective(model, minimize_glucose)
su.fix_objective_as_constraint(model)
fx_name = f"fixed_objective_{model.objective.name}"
constr = model.constraints
# Ensure that a solution exists on non-GLPK solvers.
model.slim_optimize()
assert (constr[fx_name].lb, constr[fx_name].ub) == (
None,
model.solver.objective.value,
)
def model_from_dict(obj):
"""Build a model from a dict.
Models stored in json are first formulated as a dict that can be read to
cobra model using this function.
Parameters
----------
obj : dict
A dictionary with elements, 'genes', 'compartments', 'id',
'metabolites', 'notes' and 'reqctions' where 'metabolites', 'genes'
and 'metabolites' are in turn lists with dictionaries holding all
attributes to form the corresponding object.
Returns
-------
cora.core.Model
The generated model.
See Also
--------
cobra.io.json.model_to_dict
"""
if 'reactions' not in obj:
raise Exception('JSON object has no reactions attribute. Cannot load.')
model = Model()
model.add_metabolites([
metabolite_from_dict(metabolite) for metabolite in obj['metabolites']
])
model.genes.extend([gene_from_dict(gene) for gene in obj['genes']])
model.add_reactions(
[reaction_from_dict(reaction, model) for reaction in obj['reactions']])
objective_reactions = [
rxn for rxn in obj['reactions']
if rxn.get('objective_coefficient', 0) != 0
]
coefficients = {
model.reactions.get_by_id(rxn['id']): rxn['objective_coefficient']
for rxn in objective_reactions
}
set_objective(model, coefficients)
for k, v in iteritems(obj):
if k in {'id', 'name', 'notes', 'compartments', 'annotation'}:
setattr(model, k, v)
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 convert_to_irreversible(model):
"""Split reversible reactions into two irreversible reactions
These two reactions will proceed in opposite directions. This
guarentees that all reactions in the model will only allow
positive flux values, which is useful for some modeling problems.
Arguments
----------
* model: cobra.Model ~ A Model object which will be modified in place.
"""
#warn("deprecated, not applicable for optlang solvers", DeprecationWarning)
reactions_to_add = []
coefficients = {}
for reaction in model.reactions:
# If a reaction is reverse only, the forward reaction (which
# will be constrained to 0) will be left in the model.
if reaction.lower_bound < 0 and reaction.upper_bound > 0:
reverse_reaction = Reaction(reaction.id + "_reverse")
reverse_reaction.lower_bound = max(0, -reaction.upper_bound)
reverse_reaction.upper_bound = -reaction.lower_bound
coefficients[
reverse_reaction] = reaction.objective_coefficient * -1
reaction.lower_bound = max(0, reaction.lower_bound)
reaction.upper_bound = max(0, reaction.upper_bound)
# Make the directions aware of each other
reaction.notes["reflection"] = reverse_reaction.id
reverse_reaction.notes["reflection"] = reaction.id
reaction_dict = {
k: v * -1
for k, v in reaction._metabolites.items()
}
reverse_reaction.add_metabolites(reaction_dict)
reverse_reaction._model = reaction._model
reverse_reaction._genes = reaction._genes
for gene in reaction._genes:
gene._reaction.add(reverse_reaction)
reverse_reaction.subsystem = reaction.subsystem
reverse_reaction._gene_reaction_rule = reaction._gene_reaction_rule
reactions_to_add.append(reverse_reaction)
model.add_reactions(reactions_to_add)
set_objective(model, coefficients, additive=True)
def model_from_dict(obj):
"""Build a model from a dict.
Models stored in json are first formulated as a dict that can be read to
cobra model using this function.
Parameters
----------
obj : dict
A dictionary with elements, 'genes', 'compartments', 'id',
'metabolites', 'notes' and 'reactions'; where 'metabolites', 'genes'
and 'metabolites' are in turn lists with dictionaries holding all
attributes to form the corresponding object.
Returns
-------
cora.core.Model
The generated model.
See Also
--------
cobra.io.model_to_dict
"""
if 'reactions' not in obj:
raise ValueError('Object has no reactions attribute. Cannot load.')
model = Model()
model.add_metabolites(
[metabolite_from_dict(metabolite) for metabolite in obj['metabolites']]
)
model.genes.extend([gene_from_dict(gene) for gene in obj['genes']])
model.add_reactions(
[reaction_from_dict(reaction, model) for reaction in obj['reactions']]
)
objective_reactions = [rxn for rxn in obj['reactions'] if
rxn.get('objective_coefficient', 0) != 0]
coefficients = {
model.reactions.get_by_id(rxn['id']): rxn['objective_coefficient'] for
rxn in objective_reactions}
set_objective(model, coefficients)
for k, v in iteritems(obj):
if k in {'id', 'name', 'notes', 'compartments', 'annotation'}:
setattr(model, k, v)
return model
def test_change_objective(self, model):
expression = 1.0 * model.variables['ENO'] + \
1.0 * model.variables['PFK']
model.objective = model.problem.Objective(
expression)
assert model.objective.expression == expression
model.objective = "ENO"
eno_obj = model.problem.Objective(
model.reactions.ENO.flux_expression, direction="max")
pfk_obj = model.problem.Objective(
model.reactions.PFK.flux_expression, direction="max")
assert model.objective == eno_obj
with model:
model.objective = "PFK"
assert model.objective == pfk_obj
assert model.objective == eno_obj
expression = model.objective.expression
atpm = model.reactions.get_by_id("ATPM")
biomass = model.reactions.get_by_id("Biomass_Ecoli_core")
with model:
model.objective = atpm
assert model.objective.expression == expression
with model:
atpm.objective_coefficient = 1
biomass.objective_coefficient = 2
assert model.objective.expression == expression
with model:
set_objective(model, model.problem.Objective(
atpm.flux_expression))
assert model.objective.expression == atpm.flux_expression
assert model.objective.expression == expression
expression = model.objective.expression
with model:
with model: # Test to make sure nested contexts are OK
set_objective(model, atpm.flux_expression,
additive=True)
assert (model.objective.expression ==
expression + atpm.flux_expression)
assert model.objective.expression == expression
def test_change_objective(self, model):
expression = 1.0 * model.variables['ENO'] + \
1.0 * model.variables['PFK']
model.objective = model.problem.Objective(
expression)
assert same_ex(model.objective.expression, expression)
model.objective = "ENO"
eno_obj = model.problem.Objective(
model.reactions.ENO.flux_expression, direction="max")
pfk_obj = model.problem.Objective(
model.reactions.PFK.flux_expression, direction="max")
assert same_ex(model.objective.expression, eno_obj.expression)
with model:
model.objective = "PFK"
assert same_ex(model.objective.expression, pfk_obj.expression)
assert same_ex(model.objective.expression, eno_obj.expression)
expression = model.objective.expression
atpm = model.reactions.get_by_id("ATPM")
biomass = model.reactions.get_by_id("Biomass_Ecoli_core")
with model:
model.objective = atpm
assert same_ex(model.objective.expression, expression)
with model:
atpm.objective_coefficient = 1
biomass.objective_coefficient = 2
assert same_ex(model.objective.expression, expression)
with model:
set_objective(model, model.problem.Objective(
atpm.flux_expression))
assert same_ex(model.objective.expression, atpm.flux_expression)
assert same_ex(model.objective.expression, expression)
expression = model.objective.expression
with model:
with model: # Test to make sure nested contexts are OK
set_objective(model, atpm.flux_expression,
additive=True)
assert same_ex(model.objective.expression,
expression + atpm.flux_expression)
assert same_ex(model.objective.expression, expression)
def convert_to_irreversible(cobra_model):
"""Split reversible reactions into two irreversible reactions
These two reactions will proceed in opposite directions. This
guarentees that all reactions in the model will only allow
positive flux values, which is useful for some modeling problems.
cobra_model: A Model object which will be modified in place.
"""
warn("deprecated, not applicable for optlang solvers", DeprecationWarning)
reactions_to_add = []
coefficients = {}
for reaction in cobra_model.reactions:
# If a reaction is reverse only, the forward reaction (which
# will be constrained to 0) will be left in the model.
if reaction.lower_bound < 0:
reverse_reaction = Reaction(reaction.id + "_reverse")
reverse_reaction.lower_bound = max(0, -reaction.upper_bound)
reverse_reaction.upper_bound = -reaction.lower_bound
coefficients[
reverse_reaction] = reaction.objective_coefficient * -1
reaction.lower_bound = max(0, reaction.lower_bound)
reaction.upper_bound = max(0, reaction.upper_bound)
# Make the directions aware of each other
reaction.notes["reflection"] = reverse_reaction.id
reverse_reaction.notes["reflection"] = reaction.id
reaction_dict = {k: v * -1
for k, v in iteritems(reaction._metabolites)}
reverse_reaction.add_metabolites(reaction_dict)
reverse_reaction._model = reaction._model
reverse_reaction._genes = reaction._genes
for gene in reaction._genes:
gene._reaction.add(reverse_reaction)
reverse_reaction.subsystem = reaction.subsystem
reverse_reaction._gene_reaction_rule = reaction._gene_reaction_rule
reactions_to_add.append(reverse_reaction)
cobra_model.add_reactions(reactions_to_add)
set_objective(cobra_model, coefficients, additive=True)
def _from_dict(obj):
"""build a model from a dict"""
if 'reactions' not in obj:
raise Exception('JSON object has no reactions attribute. Cannot load.')
model = Model()
model.add_metabolites([
metabolite_from_dict(metabolite) for metabolite in obj['metabolites']
])
model.genes.extend([gene_from_dict(gene) for gene in obj['genes']])
model.add_reactions(
[reaction_from_dict(reaction, model) for reaction in obj['reactions']])
objective_reactions = [
rxn for rxn in obj['reactions']
if rxn.get('objective_coefficient', 0) != 0
]
coefficients = {
model.reactions.get_by_id(rxn['id']): rxn['objective_coefficient']
for rxn in objective_reactions
}
set_objective(model, coefficients)
for k, v in iteritems(obj):
if k in {'id', 'name', 'notes', 'compartments', 'annotation'}:
setattr(model, k, v)
return model
def _fva_step(reaction_id):
"""Run a maximization and a minization.
Modified from cobrapy to account for possibly duplicated (`_REV`) reactions
in the EC model.
"""
global _model
global _target
target = _model.__getattribute__(_target)
reac = target.get_by_id(reaction_id)
rev_id = _apply_rev(reaction_id, _model)
rev_reac = target.get_by_id(rev_id) if rev_id else None
set_objective(_model, {reac: 1})
if rev_reac is not None:
# if reac with duplicate is optimized, block counterpart
prev_bounds = rev_reac.bounds
rev_reac.bounds = 0, 0
ub = _model.slim_optimize()
rev_reac.bounds = prev_bounds
# and use the reverse for the minimum (blocking forward)
prev_bounds = reac.bounds
set_objective(_model, {rev_reac: 1}, False)
reac.bounds = 0, 0
lb = -_model.slim_optimize()
reac.bounds = prev_bounds
else:
ub = _model.slim_optimize()
set_objective(_model, {reac: -1}, False)
lb = _model.slim_optimize()
# handle infeasible case
if isnan_none(lb) or isnan_none(ub):
lb = 0.0 if isnan_none(lb) else lb
ub = 0.0 if isnan_none(ub) else ub
LOGGER.warning(
"Could not get flux for reaction %s, setting "
"it to 0. This is usually due to numerical instability.",
reaction_id,
)
return reaction_id, lb, ub
def single_species_knockout(community, species_id):
""" Knockout a species from a community model.
Parameters
----------
community : cobra.core.Model
Community model
species_id : str
ID of species to knockout from community model
Returns
-------
cobra.Solution
Solution after optimizing model with species knocked out
Raises
------
Exception
If specified species is not a member of the community.
"""
# Make sure the species is in the community model.
species_index = -1
for index in range(len(community.notes['species'])):
if community.notes['species'][index]['id'] == species_id:
species_index = index
if species_index < 0:
raise Exception(
'Species {0} is not a member of the community'.format(species_id))
if cobra06:
with community:
# Knock out all of the reactions for the specified species.
species_reactions = community.reactions.query(
lambda r: r.startswith(species_id), 'id')
for reaction in species_reactions:
reaction.knock_out()
# Remove the species objective from the community model objective.
species_objective = community.reactions.get_by_id(
community.notes['species'][species_index]['objective'])
linear_coefficients = linear_reaction_coefficients(community)
del linear_coefficients[species_objective]
set_objective(community, linear_coefficients)
# Optimize the community model with the specified species knocked out.
solution = community.optimize()
else:
# Knock out all of the reactions for the specified species.
species_reactions = community.reactions.query(
lambda r: r.startswith(species_id), 'id')
saved_bounds = dict()
for reaction in species_reactions:
saved_bounds[reaction.id] = reaction.bounds
reaction.knock_out()
# Remove the species objective from the community model objective.
species_objectives = dict()
for reaction in community.objective:
if reaction.id.startswith(species_id):
species_objectives[reaction] = reaction.objective_coefficient
reaction.objective_coefficient = 0.
# Optimize the community model with the specified species knocked out.
solution = community.optimize()
# Restore all species reactions to original values.
for reaction in species_reactions:
reaction.bounds = saved_bounds[reaction.id]
for reaction in species_objectives:
reaction.objective_coefficient = species_objectives[reaction]
return solution
def create_community_model(source_models):
""" Create a community model from a list of source models.
A community model contains all of the reactions and metabolites from the
source models. As a source model for a species is added to the community
model, a model ID prefix is added to the IDs of reactions and metabolites.
This is the same as assigning each species to a different compartment,
which is required because cells are closed compartments that do not share
metabolites. A shared compartment is added to the community model and all
unique exchange reactions from the source models are added to the community
model to exchange metabolites between the shared compartment and the system
boundary. For each source model, all exchange reactions are converted to
transport reactions to move the metabolite between the shared compartment
and the extracellular compartment of the source model.
Parameters
----------
source_models : list of str
List of path names to model files
Returns
-------
cobra.core.Model
Community model
Raises
------
Exception
If there are less than two models in the list of source models.
If there is a duplicate model ID in the list of source models.
If there is more than one objective
If the type of IDs in the model metabolites could not be determined.
"""
# There must be at least two source models to make a community model.
if len(source_models) < 2:
raise Exception(
'There must be at least two species in a community model')
# Start with an empty model.
community = Model('Community')
community.compartments['u'] = 'Lumen'
# Keep track of the source models. Each element is a tuple with ID and source file name.
community.notes['species'] = list()
# IDs of all exchange reactions in the community.
exchange_reaction_ids = set()
# IDs of all models in the community (duplicates are not allowed).
model_ids = set()
# Add of the source models to the community model.
for model_filename in source_models:
# Load the model from a file.
model = load_model_from_file(model_filename)
# Since the model ID is used as a prefix for reactions and metabolites it must be unique.
if model.id in model_ids:
raise Exception(
'Model ID {0} from {1} is a duplicate in the community'.format(
model.id, model_filename))
model_ids.add(model.id)
# Check for multiple objectives in the model (which changed significantly in cobra 0.6).
if cobra06:
linear_coefficients = linear_reaction_coefficients(model)
if len(linear_coefficients) != 1:
raise Exception(
'Wrong number of objectives for model {0}, only one growth objective is allowed'
.format(model_filename))
objective_id = '{0}_{1}'.format(
model.id,
six.next(six.iterkeys(linear_coefficients)).id)
objective_value = six.next(six.itervalues(linear_coefficients))
else:
if len(model.objective) != 1:
raise Exception(
'Wrong number of objectives for model {0}, only one growth objective is allowed'
.format(model_filename))
objective_id = '{0}_{1}'.format(
model.id,
six.next(six.iterkeys(model.objective)).id)
objective_value = six.next(six.itervalues(model.objective))
# All metabolites need to have a compartment suffix.
for metabolite in model.metabolites:
metabolite.notes['type'] = _id_type(metabolite.id)
unknown = model.metabolites.query(lambda x: 'unknown' in x['type'],
'notes')
if len(unknown) > 0:
raise Exception(
'Unknown compartment suffixes found in metabolites for {0}'.
format(model_filename))
# Get the exchange reactions from the species model.
exchange_reactions = model.reactions.query(
lambda x: x.startswith('EX_'), 'id')
# Add any exchange reactions that are not already in the community model.
for reaction in exchange_reactions:
if reaction.id not in exchange_reaction_ids:
exchange_reaction_ids.add(reaction.id)
if cobra06:
metabolite = six.next(six.iterkeys(
reaction.metabolites)).copy()
metabolite.compartment = community_compartment
metabolite.id = _change_compartment(
metabolite.id, community_compartment,
metabolite.notes['type'])
rxn = community.add_boundary(
metabolite) # This is slow on cobra06
rxn.id = reaction.id # Keep same ID as species model
else:
community.add_reactions([copy_exchange_reaction(reaction)])
# Update the reaction IDs with species prefix and convert exchange reactions to transport reactions.
for reaction in model.reactions:
# Change the exchange reactions to transport reactions to move the metabolite between the
# community compartment and the extracellular compartment of this organism.
if reaction in exchange_reactions:
e_metabolite = six.next(six.iterkeys(reaction.metabolites))
u_metabolite = community.metabolites.get_by_id(
_change_compartment(e_metabolite.id, community_compartment,
e_metabolite.notes['type']))
reaction.add_metabolites({u_metabolite: 1.})
reaction.id = '{0}_TR_{1}'.format(
model.id, reaction.id[3:]) # Strip "EX_" prefix
reaction.bounds = (-1000., 1000.)
else:
reaction.id = '{0}_{1}'.format(model.id, reaction.id)
# Update the metabolite IDs with species prefix.
for metabolite in model.metabolites:
if metabolite.compartment != community_compartment:
metabolite.id = '{0}_{1}'.format(model.id, metabolite.id)
# Add the species model to the community model.
community += model
if cobra06:
# Workaround until agreement reached on issue #505.
objective_reaction = community.reactions.get_by_id(objective_id)
set_objective(community, {objective_reaction: objective_value},
additive=True)
species = {
'id': model.id,
'objective': objective_id,
'filename': model_filename
}
community.notes['species'].append(species)
# Update the community ID to include all of the species in the community.
# Note that the community ID is used as the file name when saving the
# community model to a JSON file.
community.id = 'x'.join(model_ids)
return community
def create_cobra_model_from_sbml_file(sbml_filename, old_sbml=False,
legacy_metabolite=False,
print_time=False, use_hyphens=False):
"""convert an SBML XML file into a cobra.Model object.
Supports SBML Level 2 Versions 1 and 4. The function will detect if the
SBML fbc package is used in the file and run the converter if the fbc
package is used.
Parameters
----------
sbml_filename: string
old_sbml: bool
Set to True if the XML file has metabolite formula appended to
metabolite names. This was a poorly designed artifact that persists in
some models.
legacy_metabolite: bool
If True then assume that the metabolite id has the compartment id
appended after an underscore (e.g. _c for cytosol). This has not been
implemented but will be soon.
print_time: bool
deprecated
use_hyphens: bool
If True, double underscores (__) in an SBML ID will be converted to
hyphens
Returns
-------
Model : The parsed cobra model
"""
if not libsbml:
raise ImportError('create_cobra_model_from_sbml_file '
'requires python-libsbml')
__default_lower_bound = -1000
__default_upper_bound = 1000
__default_objective_coefficient = 0
# Ensure that the file exists
if not isfile(sbml_filename):
raise IOError('Your SBML file is not found: %s' % sbml_filename)
# Expressions to change SBML Ids to Palsson Lab Ids
metabolite_re = re.compile('^M_')
reaction_re = re.compile('^R_')
compartment_re = re.compile('^C_')
if print_time:
warn("print_time is deprecated", DeprecationWarning)
model_doc = libsbml.readSBML(sbml_filename)
if model_doc.getPlugin("fbc") is not None:
from libsbml import ConversionProperties, LIBSBML_OPERATION_SUCCESS
conversion_properties = ConversionProperties()
conversion_properties.addOption(
"convert fbc to cobra", True, "Convert FBC model to Cobra model")
result = model_doc.convert(conversion_properties)
if result != LIBSBML_OPERATION_SUCCESS:
raise Exception("Conversion of SBML+fbc to COBRA failed")
sbml_model = model_doc.getModel()
sbml_model_id = sbml_model.getId()
sbml_species = sbml_model.getListOfSpecies()
sbml_reactions = sbml_model.getListOfReactions()
sbml_compartments = sbml_model.getListOfCompartments()
compartment_dict = dict([(compartment_re.split(x.getId())[-1], x.getName())
for x in sbml_compartments])
if legacy_metabolite:
# Deal with the palsson lab appending the compartment id to the
# metabolite id
new_dict = {}
for the_id, the_name in compartment_dict.items():
if the_name == '':
new_dict[the_id[0].lower()] = the_id
else:
new_dict[the_id] = the_name
compartment_dict = new_dict
legacy_compartment_converter = dict(
[(v, k) for k, v in iteritems(compartment_dict)])
cobra_model = Model(sbml_model_id)
metabolites = []
metabolite_dict = {}
# Convert sbml_metabolites to cobra.Metabolites
for sbml_metabolite in sbml_species:
# Skip sbml boundary species
if sbml_metabolite.getBoundaryCondition():
continue
if (old_sbml or legacy_metabolite) and \
sbml_metabolite.getId().endswith('_b'):
# Deal with incorrect sbml from bigg.ucsd.edu
continue
tmp_metabolite = Metabolite()
metabolite_id = tmp_metabolite.id = sbml_metabolite.getId()
tmp_metabolite.compartment = compartment_re.split(
sbml_metabolite.getCompartment())[-1]
if legacy_metabolite:
if tmp_metabolite.compartment not in compartment_dict:
tmp_metabolite.compartment = legacy_compartment_converter[
tmp_metabolite.compartment]
tmp_metabolite.id = parse_legacy_id(
tmp_metabolite.id, tmp_metabolite.compartment,
use_hyphens=use_hyphens)
if use_hyphens:
tmp_metabolite.id = metabolite_re.split(
tmp_metabolite.id)[-1].replace('__', '-')
else:
# Just in case the SBML ids are ill-formed and use -
tmp_metabolite.id = metabolite_re.split(
tmp_metabolite.id)[-1].replace('-', '__')
tmp_metabolite.name = sbml_metabolite.getName()
tmp_formula = ''
tmp_metabolite.notes = parse_legacy_sbml_notes(
sbml_metabolite.getNotesString())
if sbml_metabolite.isSetCharge():
tmp_metabolite.charge = sbml_metabolite.getCharge()
if "CHARGE" in tmp_metabolite.notes:
note_charge = tmp_metabolite.notes["CHARGE"][0]
try:
note_charge = float(note_charge)
if note_charge == int(note_charge):
note_charge = int(note_charge)
except:
warn("charge of %s is not a number (%s)" %
(tmp_metabolite.id, str(note_charge)))
else:
if ((tmp_metabolite.charge is None) or
(tmp_metabolite.charge == note_charge)):
tmp_metabolite.notes.pop("CHARGE")
# set charge to the one from notes if not assigend before
# the same
tmp_metabolite.charge = note_charge
else: # tmp_metabolite.charge != note_charge
msg = "different charges specified for %s (%d and %d)"
msg = msg % (tmp_metabolite.id,
tmp_metabolite.charge, note_charge)
warn(msg)
# Chances are a 0 note charge was written by mistake. We
# will default to the note_charge in this case.
if tmp_metabolite.charge == 0:
tmp_metabolite.charge = note_charge
for the_key in tmp_metabolite.notes.keys():
if the_key.lower() == 'formula':
tmp_formula = tmp_metabolite.notes.pop(the_key)[0]
break
if tmp_formula == '' and old_sbml:
tmp_formula = tmp_metabolite.name.split('_')[-1]
tmp_metabolite.name = tmp_metabolite.name[:-len(tmp_formula) - 1]
tmp_metabolite.formula = tmp_formula
metabolite_dict.update({metabolite_id: tmp_metabolite})
metabolites.append(tmp_metabolite)
cobra_model.add_metabolites(metabolites)
# Construct the vectors and matrices for holding connectivity and numerical
# info to feed to the cobra toolbox.
# Always assume steady state simulations so b is set to 0
cobra_reaction_list = []
coefficients = {}
for sbml_reaction in sbml_reactions:
if use_hyphens:
# Change the ids to match conventions used by the Palsson lab.
reaction = Reaction(reaction_re.split(
sbml_reaction.getId())[-1].replace('__', '-'))
else:
# Just in case the SBML ids are ill-formed and use -
reaction = Reaction(reaction_re.split(
sbml_reaction.getId())[-1].replace('-', '__'))
cobra_reaction_list.append(reaction)
# reaction.exchange_reaction = 0
reaction.name = sbml_reaction.getName()
cobra_metabolites = {}
# Use the cobra.Metabolite class here
for sbml_metabolite in sbml_reaction.getListOfReactants():
tmp_metabolite_id = sbml_metabolite.getSpecies()
# This deals with boundary metabolites
if tmp_metabolite_id in metabolite_dict:
tmp_metabolite = metabolite_dict[tmp_metabolite_id]
cobra_metabolites[tmp_metabolite] = - \
sbml_metabolite.getStoichiometry()
for sbml_metabolite in sbml_reaction.getListOfProducts():
tmp_metabolite_id = sbml_metabolite.getSpecies()
# This deals with boundary metabolites
if tmp_metabolite_id in metabolite_dict:
tmp_metabolite = metabolite_dict[tmp_metabolite_id]
# Handle the case where the metabolite was specified both
# as a reactant and as a product.
if tmp_metabolite in cobra_metabolites:
warn("%s appears as a reactant and product %s" %
(tmp_metabolite_id, reaction.id))
cobra_metabolites[
tmp_metabolite] += sbml_metabolite.getStoichiometry()
# if the combined stoichiometry is 0, remove the metabolite
if cobra_metabolites[tmp_metabolite] == 0:
cobra_metabolites.pop(tmp_metabolite)
else:
cobra_metabolites[
tmp_metabolite] = sbml_metabolite.getStoichiometry()
# check for nan
for met, v in iteritems(cobra_metabolites):
if isnan(v) or isinf(v):
warn("invalid value %s for metabolite '%s' in reaction '%s'" %
(str(v), met.id, reaction.id))
reaction.add_metabolites(cobra_metabolites)
# Parse the kinetic law info here.
parameter_dict = {}
# If lower and upper bounds are specified in the Kinetic Law then
# they override the sbml reversible attribute. If they are not
# specified then the bounds are determined by getReversible.
if not sbml_reaction.getKineticLaw():
if sbml_reaction.getReversible():
parameter_dict['lower_bound'] = __default_lower_bound
parameter_dict['upper_bound'] = __default_upper_bound
else:
# Assume that irreversible reactions only proceed from left to
# right.
parameter_dict['lower_bound'] = 0
parameter_dict['upper_bound'] = __default_upper_bound
parameter_dict[
'objective_coefficient'] = __default_objective_coefficient
else:
for sbml_parameter in \
sbml_reaction.getKineticLaw().getListOfParameters():
parameter_dict[
sbml_parameter.getId().lower()] = sbml_parameter.getValue()
if 'lower_bound' in parameter_dict:
reaction.lower_bound = parameter_dict['lower_bound']
elif 'lower bound' in parameter_dict:
reaction.lower_bound = parameter_dict['lower bound']
elif sbml_reaction.getReversible():
reaction.lower_bound = __default_lower_bound
else:
reaction.lower_bound = 0
if 'upper_bound' in parameter_dict:
reaction.upper_bound = parameter_dict['upper_bound']
elif 'upper bound' in parameter_dict:
reaction.upper_bound = parameter_dict['upper bound']
else:
reaction.upper_bound = __default_upper_bound
objective_coefficient = parameter_dict.get(
'objective_coefficient', parameter_dict.get(
'objective_coefficient', __default_objective_coefficient))
if objective_coefficient != 0:
coefficients[reaction] = objective_coefficient
# ensure values are not set to nan or inf
if isnan(reaction.lower_bound) or isinf(reaction.lower_bound):
reaction.lower_bound = __default_lower_bound
if isnan(reaction.upper_bound) or isinf(reaction.upper_bound):
reaction.upper_bound = __default_upper_bound
reaction_note_dict = parse_legacy_sbml_notes(
sbml_reaction.getNotesString())
# Parse the reaction notes.
# POTENTIAL BUG: DEALING WITH LEGACY 'SBML' THAT IS NOT IN A
# STANDARD FORMAT
# TODO: READ IN OTHER NOTES AND GIVE THEM A reaction_ prefix.
# TODO: Make sure genes get added as objects
if 'GENE ASSOCIATION' in reaction_note_dict:
rule = reaction_note_dict['GENE ASSOCIATION'][0]
try:
rule.encode('ascii')
except (UnicodeEncodeError, UnicodeDecodeError):
warn("gene_reaction_rule '%s' is not ascii compliant" % rule)
if rule.startswith(""") and rule.endswith("""):
rule = rule[6:-6]
reaction.gene_reaction_rule = rule
if 'GENE LIST' in reaction_note_dict:
reaction.systematic_names = reaction_note_dict['GENE LIST'][0]
elif ('GENES' in reaction_note_dict and
reaction_note_dict['GENES'] != ['']):
reaction.systematic_names = reaction_note_dict['GENES'][0]
elif 'LOCUS' in reaction_note_dict:
gene_id_to_object = dict([(x.id, x) for x in reaction._genes])
for the_row in reaction_note_dict['LOCUS']:
tmp_row_dict = {}
the_row = 'LOCUS:' + the_row.lstrip('_').rstrip('#')
for the_item in the_row.split('#'):
k, v = the_item.split(':')
tmp_row_dict[k] = v
tmp_locus_id = tmp_row_dict['LOCUS']
if 'TRANSCRIPT' in tmp_row_dict:
tmp_locus_id = tmp_locus_id + \
'.' + tmp_row_dict['TRANSCRIPT']
if 'ABBREVIATION' in tmp_row_dict:
gene_id_to_object[tmp_locus_id].name = tmp_row_dict[
'ABBREVIATION']
if 'SUBSYSTEM' in reaction_note_dict:
reaction.subsystem = reaction_note_dict.pop('SUBSYSTEM')[0]
reaction.notes = reaction_note_dict
# Now, add all of the reactions to the model.
cobra_model.id = sbml_model.getId()
# Populate the compartment list - This will be done based on
# cobra.Metabolites in cobra.Reactions in the future.
cobra_model.compartments = compartment_dict
cobra_model.add_reactions(cobra_reaction_list)
set_objective(cobra_model, coefficients)
return cobra_model
def from_mat_struct(mat_struct, model_id=None, inf=inf):
"""create a model from the COBRA toolbox struct
The struct will be a dict read in by scipy.io.loadmat
"""
m = mat_struct
if m.dtype.names is None:
raise ValueError("not a valid mat struct")
if not {"rxns", "mets", "S", "lb", "ub"} <= set(m.dtype.names):
raise ValueError("not a valid mat struct")
if "c" in m.dtype.names:
c_vec = m["c"][0, 0]
else:
c_vec = None
warn("objective vector 'c' not found")
model = Model()
if model_id is not None:
model.id = model_id
elif "description" in m.dtype.names:
description = m["description"][0, 0][0]
if not isinstance(description, string_types) and len(description) > 1:
model.id = description[0]
warn("Several IDs detected, only using the first.")
else:
model.id = description
else:
model.id = "imported_model"
for i, name in enumerate(m["mets"][0, 0]):
new_metabolite = Metabolite()
new_metabolite.id = str(name[0][0])
if all(var in m.dtype.names for var in
['metComps', 'comps', 'compNames']):
comp_index = m["metComps"][0, 0][i][0] - 1
new_metabolite.compartment = m['comps'][0, 0][comp_index][0][0]
if new_metabolite.compartment not in model.compartments:
comp_name = m['compNames'][0, 0][comp_index][0][0]
model.compartments[new_metabolite.compartment] = comp_name
else:
new_metabolite.compartment = _get_id_compartment(new_metabolite.id)
if new_metabolite.compartment not in model.compartments:
model.compartments[
new_metabolite.compartment] = new_metabolite.compartment
try:
new_metabolite.name = str(m["metNames"][0, 0][i][0][0])
except (IndexError, ValueError):
pass
try:
new_metabolite.formula = str(m["metFormulas"][0][0][i][0][0])
except (IndexError, ValueError):
pass
try:
new_metabolite.charge = float(m["metCharge"][0, 0][i][0])
int_charge = int(new_metabolite.charge)
if new_metabolite.charge == int_charge:
new_metabolite.charge = int_charge
except (IndexError, ValueError):
pass
model.add_metabolites([new_metabolite])
new_reactions = []
coefficients = {}
for i, name in enumerate(m["rxns"][0, 0]):
new_reaction = Reaction()
new_reaction.id = str(name[0][0])
new_reaction.lower_bound = float(m["lb"][0, 0][i][0])
new_reaction.upper_bound = float(m["ub"][0, 0][i][0])
if isinf(new_reaction.lower_bound) and new_reaction.lower_bound < 0:
new_reaction.lower_bound = -inf
if isinf(new_reaction.upper_bound) and new_reaction.upper_bound > 0:
new_reaction.upper_bound = inf
if c_vec is not None:
coefficients[new_reaction] = float(c_vec[i][0])
try:
new_reaction.gene_reaction_rule = str(m['grRules'][0, 0][i][0][0])
except (IndexError, ValueError):
pass
try:
new_reaction.name = str(m["rxnNames"][0, 0][i][0][0])
except (IndexError, ValueError):
pass
try:
new_reaction.subsystem = str(m['subSystems'][0, 0][i][0][0])
except (IndexError, ValueError):
pass
new_reactions.append(new_reaction)
model.add_reactions(new_reactions)
set_objective(model, coefficients)
coo = scipy_sparse.coo_matrix(m["S"][0, 0])
for i, j, v in zip(coo.row, coo.col, coo.data):
model.reactions[j].add_metabolites({model.metabolites[i]: v})
return model
def objective_coefficient(self, value):
if self.model is None:
raise AttributeError('cannot assign objective to a missing model')
if self.flux_expression is not None:
set_objective(self.model, {self: value}, additive=True)
def convert_to_irreversible(cobra_model):
"""
Split reversible reactions into two irreversible reactions: one going in
the forward direction, the other in the backward direction. In this manner,
all reactions in the model carry non-negative flux values. Forward reactions
are tagged as "forward" while backward reactions as "backward".
cobra_model: A Model object which will be modified in place.
Modified from the deprecated cobrapy version by Semidan Robaina,
February 2019.
"""
reactions_to_add = []
coefficients = {}
def onlyBackward(reaction):
return reaction.lower_bound < 0 and reaction.upper_bound <= 0
def backwardAndForward(reaction):
return reaction.lower_bound < 0 and reaction.upper_bound > 0
def changeDirection(reaction):
def swapSign(number):
return -number
lb = swapSign(reaction.upper_bound)
ub = swapSign(reaction.lower_bound)
reaction.lower_bound = lb
reaction.upper_bound = ub
reaction.objective_coefficient * -1
reaction.notes["reflection"] = 'only reverse'
reaction.id += '_reverse'
reaction.name += '_reverse'
for met in reaction._metabolites.keys():
reaction._metabolites[met] *= -1
def createBackwardReaction(reaction):
backward_reaction = cobraReaction(reaction.id + '_reverse')
backward_reaction.lower_bound = 0
backward_reaction.upper_bound = -reaction.lower_bound
reaction_dict = {
k: v * -1
for k, v in iteritems(reaction._metabolites)
}
backward_reaction.add_metabolites(reaction_dict)
backward_reaction._model = reaction._model
backward_reaction._genes = reaction._genes
for gene in reaction._genes:
gene._reaction.add(backward_reaction)
backward_reaction.subsystem = reaction.subsystem
backward_reaction.name = reaction.name + '_reverse'
backward_reaction._gene_reaction_rule = reaction._gene_reaction_rule
coefficients[backward_reaction] = reaction.objective_coefficient * -1
return backward_reaction
for reaction in cobra_model.reactions:
if onlyBackward(reaction):
changeDirection(reaction)
elif backwardAndForward(reaction):
backward_reaction = createBackwardReaction(reaction)
reactions_to_add.append(backward_reaction)
reaction.lower_bound = 0
cobra_model.add_reactions(reactions_to_add)
set_objective(cobra_model, coefficients, additive=True)
def from_mat_struct(mat_struct, model_id=None, inf=inf):
"""create a model from the COBRA toolbox struct
The struct will be a dict read in by scipy.io.loadmat
"""
m = mat_struct
if m.dtype.names is None:
raise ValueError("not a valid mat struct")
if not {"rxns", "mets", "S", "lb", "ub"} <= set(m.dtype.names):
raise ValueError("not a valid mat struct")
if "c" in m.dtype.names:
c_vec = m["c"][0, 0]
else:
c_vec = None
warn("objective vector 'c' not found")
model = Model()
if model_id is not None:
model.id = model_id
elif "description" in m.dtype.names:
description = m["description"][0, 0][0]
if not isinstance(description, string_types) and len(description) > 1:
model.id = description[0]
warn("Several IDs detected, only using the first.")
else:
model.id = description
else:
model.id = "imported_model"
for i, name in enumerate(m["mets"][0, 0]):
new_metabolite = Metabolite()
new_metabolite.id = str(name[0][0])
if all(var in m.dtype.names
for var in ['metComps', 'comps', 'compNames']):
comp_index = m["metComps"][0, 0][i][0] - 1
new_metabolite.compartment = m['comps'][0, 0][comp_index][0][0]
if new_metabolite.compartment not in model.compartments:
comp_name = m['compNames'][0, 0][comp_index][0][0]
model.compartments[new_metabolite.compartment] = comp_name
else:
new_metabolite.compartment = _get_id_compartment(new_metabolite.id)
if new_metabolite.compartment not in model.compartments:
model.compartments[
new_metabolite.compartment] = new_metabolite.compartment
try:
new_metabolite.name = str(m["metNames"][0, 0][i][0][0])
except (IndexError, ValueError):
pass
try:
new_metabolite.formula = str(m["metFormulas"][0][0][i][0][0])
except (IndexError, ValueError):
pass
try:
new_metabolite.charge = float(m["metCharge"][0, 0][i][0])
int_charge = int(new_metabolite.charge)
if new_metabolite.charge == int_charge:
new_metabolite.charge = int_charge
except (IndexError, ValueError):
pass
model.add_metabolites([new_metabolite])
new_reactions = []
coefficients = {}
for i, name in enumerate(m["rxns"][0, 0]):
new_reaction = Reaction()
new_reaction.id = str(name[0][0])
new_reaction.lower_bound = float(m["lb"][0, 0][i][0])
new_reaction.upper_bound = float(m["ub"][0, 0][i][0])
if isinf(new_reaction.lower_bound) and new_reaction.lower_bound < 0:
new_reaction.lower_bound = -inf
if isinf(new_reaction.upper_bound) and new_reaction.upper_bound > 0:
new_reaction.upper_bound = inf
if c_vec is not None:
coefficients[new_reaction] = float(c_vec[i][0])
try:
new_reaction.gene_reaction_rule = str(m['grRules'][0, 0][i][0][0])
except (IndexError, ValueError):
pass
try:
new_reaction.name = str(m["rxnNames"][0, 0][i][0][0])
except (IndexError, ValueError):
pass
try:
new_reaction.subsystem = str(m['subSystems'][0, 0][i][0][0])
except (IndexError, ValueError):
pass
new_reactions.append(new_reaction)
model.add_reactions(new_reactions)
set_objective(model, coefficients)
coo = scipy_sparse.coo_matrix(m["S"][0, 0])
for i, j, v in zip(coo.row, coo.col, coo.data):
model.reactions[j].add_metabolites({model.metabolites[i]: v})
return model
def min_incon_parsi(self, **kwargs):
'''The main step called by compute_met_form to solve the MIP problem.
Return a min_incon_parsi_info object summarizing the results of solving MIP.
formulae: result formulae
infeas: infeasibility of each solve
bound: bound used for total inconsistency or the relaxation value eps0 for each solve
obj: objective function value for each solve
solution: solution values for each type of variables (m, xp, xn, Ap, An)
met_model: the MIP problems solved for each connected set of elements as individual cobra models
final: the final status of the solution
sol_stat: solution status for each connected set of elements
sol_constrain: 'minIncon' or 'minFill' indicating the solution used to constrain the minimal formulae problem.
'''
inf, neg_inf = self.infinity, self.negative_infinity
pre = self.pre
metK, metU, metF, rxnK, ele, ele_connect, met_fill_connect, feasTol, digitRounded \
= pre.met_known, pre.met_unknown, pre.met_fill, pre.rxn_known, \
pre.ele, pre.ele_connect, pre.met_fill_connect, pre.feasTol, pre.digitRounded
model = self.model
kwargs['objective_sense'] = 'minimize' #always minimize
#data to be stored
infeas, bound, solution, met_model, sol_constrain, sol_stat, obj = ({} for i in range(7))
for k in ['minIncon', 'minFill', 'minForm']: #pre-assignment
solution[k] = {'m': {}, 'xp': {}, 'xn': {}, 'Ap': {}, 'An': {}}
#Optimize for each connected componenet in ele_connect
ct = 0
for eCC in ele_connect:
ct += 1
print("Optimizing for %d / %d set of connected elements ... %s" %(ct, len(ele_connect), datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
metModelJ = Model(', '.join(eCC))
metModelJ.solver = self.__solver
infeasJ, boundJ, objJ = {}, {}, {}
constraint = {e: {j: Metabolite(j.id + ',' + e) for j in rxnK} for e in eCC}
m = {e: {i: Reaction('m_' + i.id + ',' + e) for i in metU} for e in eCC}
xp = {e: {j: Reaction('xp_' + j.id + ',' + e) for j in rxnK} for e in eCC}
xn = {e: {j: Reaction('xn_' + j.id + ',' + e) for j in rxnK} for e in eCC}
#add adjustment variable if filling mets associated with the current connected elements
Ap = {i: {j: Reaction('Ap_' + metF[i].formula + ',' + j.id) for j in rxnK} for i in met_fill_connect[eCC]}
An = {i: {j: Reaction('An_' + metF[i].formula + ',' + j.id) for j in rxnK} for i in met_fill_connect[eCC]}
for e in eCC:
for j in rxnK:
#RHS for each constraint: -sum(S_ij * m^known_ie) (obsolete)
constraint[e][j]._bound = -sum([S_ij * metK[i].elements[e] for i, S_ij in j._metabolites.items() if i in metK and e in metK[i].elements])
constraint[e][j]._constraint_sense = 'E'
#x_pos - x_neg for each constraint
xp[e][j].add_metabolites({constraint[e][j]: 1})
xn[e][j].add_metabolites({constraint[e][j]: -1})
xp[e][j].lower_bound, xn[e][j].lower_bound, xp[e][j].upper_bound, xn[e][j].upper_bound = 0, 0, inf, inf
#m * A_pos - m * A_neg for each constraint
for i in met_fill_connect[eCC]:
if e in metF[i].elements:
Ap[i][j].add_metabolites({constraint[e][j]: metF[i].elements[e]})
An[i][j].add_metabolites({constraint[e][j]: -metF[i].elements[e]})
for i in metU:
# S_ij x m_ie for each i
m[e][i].add_metabolites({constraint[e][j]: j._metabolites[i] for j in list(i._reaction) if j in rxnK})
m[e][i].upper_bound = inf
m[e][i].lower_bound = neg_inf if e == 'Charge' else 0
for i in met_fill_connect[eCC]:
for j in rxnK:
Ap[i][j].lower_bound, An[i][j].lower_bound, Ap[i][j].upper_bound, An[i][j].upper_bound = 0, 0, inf, inf
#add reactions into the model
metModelJ.add_reactions([m[e][i] for e in eCC for i in metU])
metModelJ.add_reactions([xp[e][j] for e in eCC for j in rxnK])
metModelJ.add_reactions([xn[e][j] for e in eCC for j in rxnK])
if bool(met_fill_connect[eCC]):
metModelJ.add_reactions([Ap[i][j] for i in met_fill_connect[eCC] for j in rxnK])
metModelJ.add_reactions([An[i][j] for i in met_fill_connect[eCC] for j in rxnK])
# the objective can be set as a dictionary of rxns {rxn_id: 1,...}
objective_dict = {xp[e][j]: 1 for e in eCC for j in rxnK}
objective_dict.update({xn[e][j]: 1 for e in eCC for j in rxnK})
set_objective(metModelJ, objective_dict)
#set RHS: -sum(S_ij * m^known_ie)
for e in eCC:
for j in rxnK:
metModelJ.constraints[constraint[e][j].id].ub = inf #ub must be set to be > lb to avoid error
metModelJ.constraints[constraint[e][j].id].lb, metModelJ.constraints[constraint[e][j].id].ub = constraint[e][j]._bound, constraint[e][j]._bound
#Solve for minimum inconsistency
sol = metModelJ.optimize(**kwargs)
solStatJ = 'minIncon'
infeasJ[solStatJ] = solution_infeasibility(metModelJ, sol)
if sol.fluxes is None:
boundJ[solStatJ] = {e: float('nan') for e in eCC}
else:
boundJ[solStatJ] = {e: sum([sol.fluxes[j.id] for j in chain(xp[e].values(), xn[e].values())]) for e in eCC}
if not infeasJ[solStatJ] <= feasTol:
#infeasible (should not happen)
infeasJ['minFill'], infeasJ['minForm'] = inf, inf
solConstrainJ = 'infeasible'
solStatJ = 'infeasible'
objJ['minIncon'], objJ['minFill'], objJ['minForm'] = (float('nan') for i in range(3))
else:
#Feasible. Store the solution
solution[solStatJ]['m'].update({e: {i: sol.fluxes[m[e][i].id] for i in metU} for e in eCC})
solution[solStatJ]['xp'].update({e: {j: sol.fluxes[xp[e][j].id] for j in rxnK} for e in eCC})
solution[solStatJ]['xn'].update({e: {j: sol.fluxes[xn[e][j].id] for j in rxnK} for e in eCC})
solution[solStatJ]['Ap'].update({i: {j: sol.fluxes[Ap[i][j].id] for j in rxnK} for i in met_fill_connect[eCC]})
solution[solStatJ]['An'].update({i: {j: sol.fluxes[An[i][j].id] for j in rxnK} for i in met_fill_connect[eCC]})
objJ[solStatJ] = sol.objective_value # .f deprecated since 2018 Oct
#solution used to constrain the minimal formula problem
solConstrainJ = 'minIncon'
#minimize total adjustment if filling metabolites exist
if bool(met_fill_connect[eCC]):
#Add constraint to fix the total inconsistency for each element
constraint_minIncon = {e: Metabolite('minIncon_'+e) for e in eCC}
for e in eCC:
#rounding to avoid infeasibility due to numerical issues
constraint_minIncon[e]._bound = round(boundJ[solStatJ][e], digitRounded)
constraint_minIncon[e]._constraint_sense = 'L'
#sum(xp) + sum(xn) <= total inconsistency
for j in rxnK:
xp[e][j].add_metabolites({constraint_minIncon[e]: 1})
xn[e][j].add_metabolites({constraint_minIncon[e]: 1})
metModelJ.constraints[constraint_minIncon[e].id].lb = neg_inf
metModelJ.constraints[constraint_minIncon[e].id].ub = round(boundJ[solStatJ][e], digitRounded)
#reset the objective function
objective_dict = {Ap[i][j]: 1 for i in met_fill_connect[eCC] for j in rxnK}
objective_dict.update({An[i][j]: 1 for i in met_fill_connect[eCC] for j in rxnK})
set_objective(metModelJ, objective_dict)
solStatJ = 'minFill'
eps0 = 1e-6
while True:
sol = metModelJ.optimize(**kwargs)
infeasJ[solStatJ] = solution_infeasibility(metModelJ, sol)
if infeasJ[solStatJ] <= feasTol or eps0 > 1e-4 + 1e-8:
break
eps0 *= 10
for e in eCC:
#rounding to avoid infeasibility due to numerical issues
metModelJ.constraints[constraint_minIncon[e].id].ub = round(boundJ['minIncon'][e] * (1 + eps0), digitRounded)
boundJ[solStatJ] = eps0
if infeasJ[solStatJ] <= feasTol:
#Feasible. Use this as the solution for constraining the minimal formula problem
solConstrainJ = 'minFill'
#Store the solution
solution[solStatJ]['m'].update({e: {i: sol.fluxes[m[e][i].id] for i in metU} for e in eCC})
solution[solStatJ]['xp'].update({e: {j: sol.fluxes[xp[e][j].id] for j in rxnK} for e in eCC})
solution[solStatJ]['xn'].update({e: {j: sol.fluxes[xn[e][j].id] for j in rxnK} for e in eCC})
solution[solStatJ]['Ap'].update({i: {j: sol.fluxes[Ap[i][j].id] for j in rxnK} for i in met_fill_connect[eCC]})
solution[solStatJ]['An'].update({i: {j: sol.fluxes[An[i][j].id] for j in rxnK} for i in met_fill_connect[eCC]})
objJ[solStatJ] = sol.objective_value
else:
#infeasible, should not happen
objJ[solStatJ] = float('nan')
#prepare to compute minimal formulae
eps0 = 1e-10
for j in rxnK:
for i in met_fill_connect[eCC]:
#Fix the adjustment
Ap[i][j].lower_bound = round(solution[solConstrainJ]['Ap'][i][j] * (1 - eps0), digitRounded)
Ap[i][j].upper_bound = round(solution[solConstrainJ]['Ap'][i][j] * (1 + eps0), digitRounded)
An[i][j].lower_bound = round(solution[solConstrainJ]['An'][i][j] * (1 - eps0), digitRounded)
An[i][j].upper_bound = round(solution[solConstrainJ]['An'][i][j] * (1 + eps0), digitRounded)
for e in eCC:
#remove all coefficients on the constraints for total inconsistency
tmp = xp[e][j]._metabolites.pop(constraint_minIncon[e])
tmp = xn[e][j]._metabolites.pop(constraint_minIncon[e])
for e in eCC:
#then remove the constraints
metModelJ.metabolites.remove(constraint_minIncon[e])
else:
#no filling metabolites
infeasJ['minFill'], boundJ['minFill'] = 0, 0
#compute minimal formulae
eps0 = 1e-10
for e in eCC:
for j in rxnK:
#fix the inconsistency
xp[e][j].lower_bound = round(solution[solConstrainJ]['xp'][e][j] * (1 - eps0), digitRounded)
xp[e][j].upper_bound = round(solution[solConstrainJ]['xp'][e][j] * (1 + eps0), digitRounded)
xn[e][j].lower_bound = round(solution[solConstrainJ]['xn'][e][j] * (1 - eps0), digitRounded)
xn[e][j].upper_bound = round(solution[solConstrainJ]['xn'][e][j] * (1 + eps0), digitRounded)
if e == 'Charge':
#add variables for the positive and negative part of charges
chargePos = {i: Reaction('chargePos_' + i.id) for i in metU}
chargeNeg = {i: Reaction('chargeNeg_' + i.id) for i in metU}
constraint_chargeDecomp = {i: Metabolite('chargeDecomp_' + i.id) for i in metU}
for i in metU:
#constraint_chargeDecomp[i]: m_charge,i - chargePos_i + chargeNeg_i = 0
m[e][i].add_metabolites({constraint_chargeDecomp[i]: 1})
chargePos[i].add_metabolites({constraint_chargeDecomp[i]: -1})
chargeNeg[i].add_metabolites({constraint_chargeDecomp[i]: 1})
chargePos[i].lower_bound, chargePos[i].upper_bound = 0, inf
chargeNeg[i].lower_bound, chargeNeg[i].upper_bound = 0, inf
constraint_chargeDecomp[i]._bound, constraint_chargeDecomp[i]._constraint_sense = 0, 'E'
metModelJ.add_metabolites(constraint_chargeDecomp.values())
metModelJ.add_reactions(list(chargePos.values()) + list(chargeNeg.values()))
#reset the objective function
objective_dict = {m[e][i]: 1 for e in eCC if e != 'Charge' for i in metU}
if 'Charge' in eCC:
objective_dict.update({chargePos[i]: 1 for i in metU})
objective_dict.update({chargeNeg[i]: 1 for i in metU})
set_objective(metModelJ, objective_dict)
#Solve for minimum formulae
solStatPrev, solStatJ =solStatJ, 'minForm'
while True:
sol = metModelJ.optimize(**kwargs)
infeasJ[solStatJ] = solution_infeasibility(metModelJ, sol)
if infeasJ[solStatJ] <= feasTol or eps0 > 1e-5 + 1e-8:
break
eps0 *= 10
#relax bounds, rounding to avoid infeasibility due to numerical issues
for j in rxnK:
for i in met_fill_connect[eCC]:
Ap[i][j].lower_bound = round(solution[solConstrainJ]['Ap'][i][j] * (1 - eps0), digitRounded)
Ap[i][j].upper_bound = round(solution[solConstrainJ]['Ap'][i][j] * (1 + eps0), digitRounded)
An[i][j].lower_bound = round(solution[solConstrainJ]['An'][i][j] * (1 - eps0), digitRounded)
An[i][j].upper_bound = round(solution[solConstrainJ]['An'][i][j] * (1 + eps0), digitRounded)
for e in eCC:
xp[e][j].lower_bound = round(solution[solConstrainJ]['xp'][e][j] * (1 - eps0), digitRounded)
xp[e][j].upper_bound = round(solution[solConstrainJ]['xp'][e][j] * (1 + eps0), digitRounded)
xn[e][j].lower_bound = round(solution[solConstrainJ]['xn'][e][j] * (1 - eps0), digitRounded)
xn[e][j].upper_bound = round(solution[solConstrainJ]['xn'][e][j] * (1 + eps0), digitRounded)
boundJ[solStatJ] = eps0
if infeasJ[solStatJ] <= feasTol:
#Feasible. Store the solution
solution[solStatJ]['m'].update({e: {i: sol.fluxes[m[e][i].id] for i in metU} for e in eCC})
solution[solStatJ]['xp'].update({e: {j: sol.fluxes[xp[e][j].id] for j in rxnK} for e in eCC})
solution[solStatJ]['xn'].update({e: {j: sol.fluxes[xn[e][j].id] for j in rxnK} for e in eCC})
solution[solStatJ]['Ap'].update({i: {j: sol.fluxes[Ap[i][j].id] for j in rxnK} for i in met_fill_connect[eCC]})
solution[solStatJ]['An'].update({i: {j: sol.fluxes[An[i][j].id] for j in rxnK} for i in met_fill_connect[eCC]})
objJ[solStatJ] = sol.objective_value
else:
#infeasible, should not happen
solStatJ = solStatPrev
objJ[solStatJ] = float('nan')
#store data
infeas[eCC] = infeasJ
bound[eCC] = boundJ
obj[eCC] = objJ
met_model[eCC] = metModelJ
sol_constrain[eCC] = solConstrainJ
sol_stat[eCC] = solStatJ
#summarize the final solution state
if any([k == 'infeasible' for k in sol_stat.values()]):
print('Failure: no feasible solution can be found.')
solFinal = 'infeasible'
else:
solMixed = True
for stat in ['minForm', 'minFill', 'minIncon']:
if all([k == stat for k in sol_stat.values()]):
solFinal, solMixed = stat, False
break
if solMixed:
solFinal = 'mixed'
#Get the resultant set of formulae. For each set of elements in ele_connect, choose the latest solution (minForm > minFill > minIncon), recorded in sol_stat.
if solFinal != 'infeasible':
formulae = {i: Formula('Mass0') for i in metU}
for i in metU:
for eCC in ele_connect:
formulae[i].update_elements({e: round(solution[sol_stat[eCC]]['m'][e][i], digitRounded) for e in eCC})
else:
formulae = {i: Formula() for i in metU}
formulae.update(metK)
mip_info = min_incon_parsi_info()
mip_info.formulae, mip_info.infeas, mip_info.bound, mip_info.obj, mip_info.solution, \
mip_info.met_model, mip_info.final, mip_info.sol_constrain, mip_info.sol_stat \
= formulae, infeas, bound, obj, solution, met_model, solFinal, sol_constrain, sol_stat
return mip_info
def min_incon_parsi_mwRange(self, metInterest, **kwargs):
'''The main step called by compute_met_range to find the range for the molecular weight
Return min_incon_parsi_info object summarizing the results of solving MIP.
formulae: (formula for min MW, formula max MW)
mw_range: (min MW, max MW)
rhs: {e: {i: RHS[i] for all metabolite i}} the RHS value in the MIP problem for each element solved. (compute_met_range only)
infeas: infeasibility of each solve
bound: bound used for total inconsistency or the relaxation value eps0 for each solve
obj: objective function value for each solve
solution: solution values for each type of variables (m, xp, xn)
met_model: the MIP problem solved for each element as a cobra model. Same model but different rhs for different elements.
final: the final status of the solution
sol_stat: solution status for each element/connected set of elements
'''
inf, neg_inf = self.infinity, self.negative_infinity
pre = self.pre
metK, metU, rxnK, ele, feasTol, digitRounded \
= pre.met_known, pre.met_unknown, pre.rxn_known, pre.ele, pre.feasTol, pre.digitRounded
model = self.model
#handle metInterest
if isinstance(metInterest,type(model.metabolites[0])):
metI = metInterest
elif isinstance(metInterest, str):
metI = model.metabolites.get_by_id(metInterest)
if metI in metK:
print("%s in the input is already known." %metI.id)
mip_info = min_incon_parsi_info()
mip_info.mw_range = (metK[metI].mw, metK[metI].mw)
return mip_info
print('Find the range for the molecular weight of %s ... %s' %(metI.id, datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
infeas, bound, solution, sol_stat, obj, rhs = ({} for i in range(6))
for k in ['minIncon', 'minMw', 'maxMw']: #pre-assignment
solution[k] = {'m': {}, 'xp': {}, 'xn': {}}
ct = 0
#The optimization problem for each element is the same except the RHS
met_model = Model('min/max Mw of ' + metI.id)
met_model.solver = self.__solver
constraint = {j: Metabolite(j.id) for j in rxnK}
m = {i: Reaction('m_' + i.id) for i in metU}
xp = {j: Reaction('xp_' + j.id) for j in rxnK}
xn = {j: Reaction('xn_' + j.id) for j in rxnK}
for j in rxnK:
xp[j].add_metabolites({constraint[j]: 1})
xn[j].add_metabolites({constraint[j]: -1})
xp[j].lower_bound, xn[j].lower_bound, xp[j].upper_bound, xn[j].upper_bound = 0, 0, inf, inf
constraint[j]._constraint_sense = 'E'
for i in metU:
# S_ij x m_ie for each i
m[i].add_metabolites({constraint[j]: j._metabolites[i] for j in list(i._reaction) if j in rxnK})
m[i].upper_bound = inf
#Add constraint to fix the total inconsistency for each element
constraint_minIncon = Metabolite('minIncon')
constraint_minIncon._bound = inf
constraint_minIncon._constraint_sense = 'L'
for j in rxnK:
xp[j].add_metabolites({constraint_minIncon: 1})
xn[j].add_metabolites({constraint_minIncon: 1})
met_model.add_reactions([m[i] for i in metU])
met_model.add_reactions([xp[j] for j in rxnK])
met_model.add_reactions([xn[j] for j in rxnK])
met_model.constraints[constraint_minIncon.id].lb = neg_inf #to avoid error
objective_dict_minIncon = {xp[j]: 1 for j in rxnK}
objective_dict_minIncon.update({xn[j]: 1 for j in rxnK})
for e in ele:
ct += 1
print("Optimizing for %d / %d element ... %s" %(ct, len(ele), datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
# metModelJ = Model('min/max ' + e)
# metModelJ.solver = self.__solver
infeasJ, boundJ, objJ, rhsJ = {}, {}, {}, {}
# constraint = {j: Metabolite(j.id + ',' + e) for j in rxnK}
# m = {i: Reaction('m_' + i.id + ',' + e) for i in metU}
# xp = {j: Reaction('xp_' + j.id + ',' + e) for j in rxnK}
# xn = {j: Reaction('xn_' + j.id + ',' + e) for j in rxnK}
# for j in rxnK:
#RHS for each constraint: -sum(S_ij * m^known_ie) (obsolete)
# constraint[j]._bound = -sum([S_ij * metK[i].elements[e] for i, S_ij in j._metabolites.items() if i in metK and e in metK[i].elements])
# constraint[j]._constraint_sense = 'E'
#x_pos - x_neg for each constraint
# xp[j].add_metabolites({constraint[j]: 1})
# xn[j].add_metabolites({constraint[j]: -1})
# xp[j].lower_bound, xn[j].lower_bound, xp[j].upper_bound, xn[j].upper_bound = 0, 0, inf, inf
for i in metU:
# # S_ij x m_ie for each i
# m[i].add_metabolites({constraint[j]: j._metabolites[i] for j in list(i._reaction) if j in rxnK})
# m[i].upper_bound = inf
m[i].lower_bound = neg_inf if e == 'Charge' else 0
#add reactions into the model
# metModelJ.add_reactions([m[i] for i in metU])
# metModelJ.add_reactions([xp[j] for j in rxnK])
# metModelJ.add_reactions([xn[j] for j in rxnK])
#set the objective function
# objective_dict = {xp[j]: 1 for j in rxnK}
# objective_dict.update({xn[j]: 1 for j in rxnK})
met_model.constraints[constraint_minIncon.id].ub = inf
set_objective(met_model, objective_dict_minIncon)
#set RHS: -sum(S_ij * m^known_ie)
for j in rxnK:
met_model.constraints[constraint[j].id].ub = inf #ub must be set to be > lb to avoid error
rhsJ[j] = -sum([S_ij * metK[i].elements[e] for i, S_ij in j._metabolites.items() if i in metK and e in metK[i].elements])
met_model.constraints[constraint[j].id].lb, met_model.constraints[constraint[j].id].ub = rhsJ[j], rhsJ[j]
constraint[j]._bound = rhsJ[j]
#Solve for minimum inconsistency
kwargs['objective_sense'] = 'minimize'
sol = met_model.optimize(**kwargs)
solStatJ = 'minIncon'
infeasJ[solStatJ] = solution_infeasibility(met_model, sol)
if sol.fluxes is None:
boundJ[solStatJ] = float('nan')
else:
boundJ[solStatJ] = sum([sol.fluxes[j.id] for j in chain(xp.values(), xn.values())])
if not infeasJ[solStatJ] <= feasTol:
#infeasible (should not happen)
infeasJ['minMw'], infeasJ['maxMw'] = inf, inf
solStatJ = 'infeasible'
objJ['minIncon'], objJ['minMw'], objJ['maxMw'] = (float('nan') for i in range(3))
for s in ['minIncon','minMw','maxMw']:
solution[s]['m'][e] = {i: float('nan') for i in metU}
solution[s]['xp'][e] = {j: float('nan') for j in rxnK}
solution[s]['xn'][e] = {j: float('nan') for j in rxnK}
else:
#Feasible. Store the solution
solution[solStatJ]['m'][e] = {i: sol.fluxes[m[i].id] for i in metU}
solution[solStatJ]['xp'][e] = {j: sol.fluxes[xp[j].id] for j in rxnK}
solution[solStatJ]['xn'][e] = {j: sol.fluxes[xn[j].id] for j in rxnK}
objJ[solStatJ] = sol.objective_value
# #Add constraint to fix the total inconsistency for each element
# constraint_minIncon = Metabolite('minIncon_'+e)
# constraint_minIncon._bound = round(boundJ['minIncon'], digitRounded)
# constraint_minIncon._constraint_sense = 'L'
# for j in rxnK:
# xp[j].add_metabolites({constraint_minIncon: 1})
# xn[j].add_metabolites({constraint_minIncon: 1})
# met_model.constraints[constraint_minIncon.id].lb = neg_inf #to avoid error
met_model.constraints[constraint_minIncon.id].ub = round(boundJ['minIncon'], digitRounded)
#reset the objective function to minimize molecular weight
objective_dict = {m[metI]: Formula(formula=e).mw}
set_objective(met_model, objective_dict)
solStatJ = 'minMw'
kwargs['objective_sense'] = 'minimize'
eps0 = 1e-6
while True:
sol = met_model.optimize(**kwargs)
infeasJ[solStatJ] = solution_infeasibility(met_model, sol)
if infeasJ[solStatJ] <= feasTol or eps0 > 1e-4 + 1e-8:
break
eps0 *= 10
#rounding to avoid infeasibility due to numerical issues
met_model.constraints[constraint_minIncon.id].ub = round(boundJ['minIncon'] * (1 + eps0), digitRounded)
boundJ[solStatJ] = eps0
if infeasJ[solStatJ] <= feasTol:
#Feasible. Store the solution
solution[solStatJ]['m'].update({e: {i: sol.fluxes[m[i].id] for i in metU}})
solution[solStatJ]['xp'].update({e: {j: sol.fluxes[xp[j].id] for j in rxnK}})
solution[solStatJ]['xn'].update({e: {j: sol.fluxes[xn[j].id] for j in rxnK}})
objJ[solStatJ] = sol.objective_value
else:
#infeasible, should not happen
objJ[solStatJ] = float('nan')
solution['minMw']['m'][e] = {i: float('nan') for i in metU}
solution['minMw']['xp'][e] = {j: float('nan') for j in rxnK}
solution['minMw']['xn'][e] = {j: float('nan') for j in rxnK}
#maximize molecular weight
solStatJ = 'maxMw'
#reset the bound for total inconsistency
met_model.constraints[constraint_minIncon.id].ub = round(boundJ['minIncon'], digitRounded)
kwargs['objective_sense'] = 'maximize'
eps0 = 1e-6
while True:
sol = met_model.optimize(**kwargs)
infeasJ[solStatJ] = solution_infeasibility(met_model, sol)
if infeasJ[solStatJ] <= feasTol or eps0 > 1e-4 + 1e-8:
break
eps0 *= 10
#rounding to avoid infeasibility due to numerical issues
met_model.constraints[constraint_minIncon.id].ub = round(boundJ['minIncon'] * (1 + eps0), digitRounded)
boundJ[solStatJ] = eps0
if infeasJ[solStatJ] <= feasTol:
#Feasible. Store the solution
solution[solStatJ]['m'].update({e: {i: sol.fluxes[m[i].id] for i in metU}})
solution[solStatJ]['xp'].update({e: {j: sol.fluxes[xp[j].id] for j in rxnK}})
solution[solStatJ]['xn'].update({e: {j: sol.fluxes[xn[j].id] for j in rxnK}})
objJ[solStatJ] = sol.objective_value
else:
#infeasible, should not happen
objJ[solStatJ] = float('nan')
solution['maxMw']['m'][e] = {i: float('nan') for i in metU}
solution['maxMw']['xp'][e] = {j: float('nan') for j in rxnK}
solution['maxMw']['xn'][e] = {j: float('nan') for j in rxnK}
#store data
infeas[e] = infeasJ
bound[e] = boundJ
obj[e] = objJ
# met_model[e] = met_model
sol_stat[e] = solStatJ
rhs[e] = rhsJ
#summarize the final solution state
if any([k == 'infeasible' for k in sol_stat.values()]):
print('Failure: no feasible solution can be found.')
solFinal = 'infeasible'
else:
if all([obj[e]['minMw'] == obj[e]['minMw'] for e in ele]):
if all([obj[e]['maxMw'] == obj[e]['maxMw'] for e in ele]):
solFinal = 'minMw + maxMw'
else:
solFinal = 'minMw only'
else:
if all([obj[e]['maxMw'] == obj[e]['maxMw'] for e in ele]):
solFinal = 'maxMw only'
else:
solFinal = 'minIncon'
mip_info = min_incon_parsi_info()
mip_info.infeas, mip_info.bound, mip_info.obj, mip_info.solution, \
mip_info.met_model, mip_info.final, mip_info.sol_stat \
= infeas, bound, obj, solution, met_model, solFinal, sol_stat
mip_info.rhs = rhs
mip_info.mw_range = (sum([obj[e]['minMw'] for e in ele]), sum([obj[e]['maxMw'] for e in ele]))
mip_info.formulae = tuple([formula_dict2str({e: solution[s]['m'][e][metI] for e in ele}) for s in ['minMw', 'maxMw']])
return mip_info
def create_cobra_model_from_sbml_file(sbml_filename, old_sbml=False,
legacy_metabolite=False,
print_time=False, use_hyphens=False):
"""convert an SBML XML file into a cobra.Model object.
Supports SBML Level 2 Versions 1 and 4. The function will detect if the
SBML fbc package is used in the file and run the converter if the fbc
package is used.
Parameters
----------
sbml_filename: string
old_sbml: bool
Set to True if the XML file has metabolite formula appended to
metabolite names. This was a poorly designed artifact that persists in
some models.
legacy_metabolite: bool
If True then assume that the metabolite id has the compartment id
appended after an underscore (e.g. _c for cytosol). This has not been
implemented but will be soon.
print_time: bool
deprecated
use_hyphens: bool
If True, double underscores (__) in an SBML ID will be converted to
hyphens
Returns
-------
Model : The parsed cobra model
"""
if not libsbml:
raise ImportError('create_cobra_model_from_sbml_file '
'requires python-libsbml')
__default_lower_bound = -1000
__default_upper_bound = 1000
__default_objective_coefficient = 0
# Ensure that the file exists
if not isfile(sbml_filename):
raise IOError('Your SBML file is not found: %s' % sbml_filename)
# Expressions to change SBML Ids to Palsson Lab Ids
metabolite_re = re.compile('^M_')
reaction_re = re.compile('^R_')
compartment_re = re.compile('^C_')
if print_time:
warn("print_time is deprecated", DeprecationWarning)
model_doc = libsbml.readSBML(sbml_filename)
if model_doc.getPlugin("fbc") is not None:
from libsbml import ConversionProperties, LIBSBML_OPERATION_SUCCESS
conversion_properties = ConversionProperties()
conversion_properties.addOption(
"convert fbc to cobra", True, "Convert FBC model to Cobra model")
result = model_doc.convert(conversion_properties)
if result != LIBSBML_OPERATION_SUCCESS:
raise Exception("Conversion of SBML+fbc to COBRA failed")
sbml_model = model_doc.getModel()
sbml_model_id = sbml_model.getId()
sbml_species = sbml_model.getListOfSpecies()
sbml_reactions = sbml_model.getListOfReactions()
sbml_compartments = sbml_model.getListOfCompartments()
compartment_dict = dict([(compartment_re.split(x.getId())[-1], x.getName())
for x in sbml_compartments])
if legacy_metabolite:
# Deal with the palsson lab appending the compartment id to the
# metabolite id
new_dict = {}
for the_id, the_name in compartment_dict.items():
if the_name == '':
new_dict[the_id[0].lower()] = the_id
else:
new_dict[the_id] = the_name
compartment_dict = new_dict
legacy_compartment_converter = dict(
[(v, k) for k, v in iteritems(compartment_dict)])
cobra_model = Model(sbml_model_id)
metabolites = []
metabolite_dict = {}
# Convert sbml_metabolites to cobra.Metabolites
for sbml_metabolite in sbml_species:
# Skip sbml boundary species
if sbml_metabolite.getBoundaryCondition():
continue
if (old_sbml or legacy_metabolite) and \
sbml_metabolite.getId().endswith('_b'):
# Deal with incorrect sbml from bigg.ucsd.edu
continue
tmp_metabolite = Metabolite()
metabolite_id = tmp_metabolite.id = sbml_metabolite.getId()
tmp_metabolite.compartment = compartment_re.split(
sbml_metabolite.getCompartment())[-1]
if legacy_metabolite:
if tmp_metabolite.compartment not in compartment_dict:
tmp_metabolite.compartment = legacy_compartment_converter[
tmp_metabolite.compartment]
tmp_metabolite.id = parse_legacy_id(
tmp_metabolite.id, tmp_metabolite.compartment,
use_hyphens=use_hyphens)
if use_hyphens:
tmp_metabolite.id = metabolite_re.split(
tmp_metabolite.id)[-1].replace('__', '-')
else:
# Just in case the SBML ids are ill-formed and use -
tmp_metabolite.id = metabolite_re.split(
tmp_metabolite.id)[-1].replace('-', '__')
tmp_metabolite.name = sbml_metabolite.getName()
tmp_formula = ''
tmp_metabolite.notes = parse_legacy_sbml_notes(
sbml_metabolite.getNotesString())
if sbml_metabolite.isSetCharge():
tmp_metabolite.charge = sbml_metabolite.getCharge()
if "CHARGE" in tmp_metabolite.notes:
note_charge = tmp_metabolite.notes["CHARGE"][0]
try:
note_charge = float(note_charge)
if note_charge == int(note_charge):
note_charge = int(note_charge)
except:
warn("charge of %s is not a number (%s)" %
(tmp_metabolite.id, str(note_charge)))
else:
if ((tmp_metabolite.charge is None) or
(tmp_metabolite.charge == note_charge)):
tmp_metabolite.notes.pop("CHARGE")
# set charge to the one from notes if not assigend before
# the same
tmp_metabolite.charge = note_charge
else: # tmp_metabolite.charge != note_charge
msg = "different charges specified for %s (%d and %d)"
msg = msg % (tmp_metabolite.id,
tmp_metabolite.charge, note_charge)
warn(msg)
# Chances are a 0 note charge was written by mistake. We
# will default to the note_charge in this case.
if tmp_metabolite.charge == 0:
tmp_metabolite.charge = note_charge
for the_key in tmp_metabolite.notes.keys():
if the_key.lower() == 'formula':
tmp_formula = tmp_metabolite.notes.pop(the_key)[0]
break
if tmp_formula == '' and old_sbml:
tmp_formula = tmp_metabolite.name.split('_')[-1]
tmp_metabolite.name = tmp_metabolite.name[:-len(tmp_formula) - 1]
tmp_metabolite.formula = tmp_formula
metabolite_dict.update({metabolite_id: tmp_metabolite})
metabolites.append(tmp_metabolite)
cobra_model.add_metabolites(metabolites)
# Construct the vectors and matrices for holding connectivity and numerical
# info to feed to the cobra toolbox.
# Always assume steady state simulations so b is set to 0
cobra_reaction_list = []
coefficients = {}
for sbml_reaction in sbml_reactions:
if use_hyphens:
# Change the ids to match conventions used by the Palsson lab.
reaction = Reaction(reaction_re.split(
sbml_reaction.getId())[-1].replace('__', '-'))
else:
# Just in case the SBML ids are ill-formed and use -
reaction = Reaction(reaction_re.split(
sbml_reaction.getId())[-1].replace('-', '__'))
cobra_reaction_list.append(reaction)
# reaction.exchange_reaction = 0
reaction.name = sbml_reaction.getName()
cobra_metabolites = {}
# Use the cobra.Metabolite class here
for sbml_metabolite in sbml_reaction.getListOfReactants():
tmp_metabolite_id = sbml_metabolite.getSpecies()
# This deals with boundary metabolites
if tmp_metabolite_id in metabolite_dict:
tmp_metabolite = metabolite_dict[tmp_metabolite_id]
cobra_metabolites[tmp_metabolite] = - \
sbml_metabolite.getStoichiometry()
for sbml_metabolite in sbml_reaction.getListOfProducts():
tmp_metabolite_id = sbml_metabolite.getSpecies()
# This deals with boundary metabolites
if tmp_metabolite_id in metabolite_dict:
tmp_metabolite = metabolite_dict[tmp_metabolite_id]
# Handle the case where the metabolite was specified both
# as a reactant and as a product.
if tmp_metabolite in cobra_metabolites:
warn("%s appears as a reactant and product %s" %
(tmp_metabolite_id, reaction.id))
cobra_metabolites[
tmp_metabolite] += sbml_metabolite.getStoichiometry()
# if the combined stoichiometry is 0, remove the metabolite
if cobra_metabolites[tmp_metabolite] == 0:
cobra_metabolites.pop(tmp_metabolite)
else:
cobra_metabolites[
tmp_metabolite] = sbml_metabolite.getStoichiometry()
# check for nan
for met, v in iteritems(cobra_metabolites):
if isnan(v) or isinf(v):
warn("invalid value %s for metabolite '%s' in reaction '%s'" %
(str(v), met.id, reaction.id))
reaction.add_metabolites(cobra_metabolites)
# Parse the kinetic law info here.
parameter_dict = {}
# If lower and upper bounds are specified in the Kinetic Law then
# they override the sbml reversible attribute. If they are not
# specified then the bounds are determined by getReversible.
if not sbml_reaction.getKineticLaw():
if sbml_reaction.getReversible():
parameter_dict['lower_bound'] = __default_lower_bound
parameter_dict['upper_bound'] = __default_upper_bound
else:
# Assume that irreversible reactions only proceed from left to
# right.
parameter_dict['lower_bound'] = 0
parameter_dict['upper_bound'] = __default_upper_bound
parameter_dict[
'objective_coefficient'] = __default_objective_coefficient
else:
for sbml_parameter in \
sbml_reaction.getKineticLaw().getListOfParameters():
parameter_dict[
sbml_parameter.getId().lower()] = sbml_parameter.getValue()
if 'lower_bound' in parameter_dict:
reaction.lower_bound = parameter_dict['lower_bound']
elif 'lower bound' in parameter_dict:
reaction.lower_bound = parameter_dict['lower bound']
elif sbml_reaction.getReversible():
reaction.lower_bound = __default_lower_bound
else:
reaction.lower_bound = 0
if 'upper_bound' in parameter_dict:
reaction.upper_bound = parameter_dict['upper_bound']
elif 'upper bound' in parameter_dict:
reaction.upper_bound = parameter_dict['upper bound']
else:
reaction.upper_bound = __default_upper_bound
objective_coefficient = parameter_dict.get(
'objective_coefficient', parameter_dict.get(
'objective_coefficient', __default_objective_coefficient))
if objective_coefficient != 0:
coefficients[reaction] = objective_coefficient
# ensure values are not set to nan or inf
if isnan(reaction.lower_bound) or isinf(reaction.lower_bound):
reaction.lower_bound = __default_lower_bound
if isnan(reaction.upper_bound) or isinf(reaction.upper_bound):
reaction.upper_bound = __default_upper_bound
reaction_note_dict = parse_legacy_sbml_notes(
sbml_reaction.getNotesString())
# Parse the reaction notes.
# POTENTIAL BUG: DEALING WITH LEGACY 'SBML' THAT IS NOT IN A
# STANDARD FORMAT
# TODO: READ IN OTHER NOTES AND GIVE THEM A reaction_ prefix.
# TODO: Make sure genes get added as objects
if 'GENE ASSOCIATION' in reaction_note_dict:
rule = reaction_note_dict['GENE ASSOCIATION'][0]
try:
rule.encode('ascii')
except (UnicodeEncodeError, UnicodeDecodeError):
warn("gene_reaction_rule '%s' is not ascii compliant" % rule)
if rule.startswith(""") and rule.endswith("""):
rule = rule[6:-6]
reaction.gene_reaction_rule = rule
if 'GENE LIST' in reaction_note_dict:
reaction.systematic_names = reaction_note_dict['GENE LIST'][0]
elif ('GENES' in reaction_note_dict and
reaction_note_dict['GENES'] != ['']):
reaction.systematic_names = reaction_note_dict['GENES'][0]
elif 'LOCUS' in reaction_note_dict:
gene_id_to_object = dict([(x.id, x) for x in reaction._genes])
for the_row in reaction_note_dict['LOCUS']:
tmp_row_dict = {}
the_row = 'LOCUS:' + the_row.lstrip('_').rstrip('#')
for the_item in the_row.split('#'):
k, v = the_item.split(':')
tmp_row_dict[k] = v
tmp_locus_id = tmp_row_dict['LOCUS']
if 'TRANSCRIPT' in tmp_row_dict:
tmp_locus_id = tmp_locus_id + \
'.' + tmp_row_dict['TRANSCRIPT']
if 'ABBREVIATION' in tmp_row_dict:
gene_id_to_object[tmp_locus_id].name = tmp_row_dict[
'ABBREVIATION']
if 'SUBSYSTEM' in reaction_note_dict:
reaction.subsystem = reaction_note_dict.pop('SUBSYSTEM')[0]
reaction.notes = reaction_note_dict
# Now, add all of the reactions to the model.
cobra_model.id = sbml_model.getId()
# Populate the compartment list - This will be done based on
# cobra.Metabolites in cobra.Reactions in the future.
cobra_model.compartments = compartment_dict
cobra_model.add_reactions(cobra_reaction_list)
set_objective(cobra_model, coefficients)
return cobra_model
def relax_dgo(tmodel, reactions_to_ignore=(), solver=None):
"""
:param t_tmodel:
:type t_tmodel: pytfa.thermo.ThermoModel:
:param reactions_to_ignore: Iterable of reactions that should not be relaxed
:param solver: solver to use (e.g. 'optlang-glpk', 'optlang-cplex',
'optlang-gurobi'
:return: a cobra_model with relaxed bounds on standard Gibbs free energy
"""
if solver is None:
solver = tmodel.solver.interface
# Create a copy of the cobra_model on which we will perform the slack addition
slack_model = deepcopy(tmodel)
slack_model.solver = solver
slack_model.name = 'SlackModel ' + tmodel.name
slack_model.id = 'SlackModel_' + tmodel.id
# Create a copy that will receive the relaxation
relaxed_model = deepcopy(tmodel)
relaxed_model.solver = solver
relaxed_model.name = 'RelaxedModel ' + tmodel.name
relaxed_model.id = 'RelaxedModel_' + tmodel.id
# Ensure the lazy updates are all done
slack_model.repair()
relaxed_model.repair()
# Do not relax if cobra_model is already optimal
# try:
# solution = tmodel.optimize()
# except SolverError as SE:
# status = tmodel.solver.status
# tmodel.logger.error(SE)
# tmodel.logger.warning('Solver status: {}'.format(status))
# if tmodel.solver.status == OPTIMAL:
# raise Exception('Model is already optimal')
# Find variables that represent standard Gibbs Energy change
my_dgo = relaxed_model.get_variables_of_type(DeltaGstd)
# Find constraints that represent negativity of Gibbs Energy change
my_neg_dg = slack_model.get_constraints_of_type(NegativeDeltaG)
changes = OrderedDict()
objective_symbols = []
slack_model.logger.info('Adding slack constraints')
hooks = dict()
for this_neg_dg in my_neg_dg:
# If there is no thermo, or relaxation forbidden, pass
if this_neg_dg.id in reactions_to_ignore or this_neg_dg.id not in my_dgo:
continue
# If there is no thermo, or relaxation forbidden, pass
if this_neg_dg.id in reactions_to_ignore or this_neg_dg.id not in my_dgo:
continue
# Create the negative and positive slack variables
neg_slack = slack_model.add_variable(NegSlackVariable,
this_neg_dg.reaction,
lb=0,
ub=BIGM_DG)
pos_slack = slack_model.add_variable(PosSlackVariable,
this_neg_dg.reaction,
lb=0,
ub=BIGM_DG)
subs_dict = {
k: slack_model.variables.get(k.name)
for k in this_neg_dg.constraint.variables
}
# Create the new constraint by adding the slack variables to the
# negative delta G constraint (from the initial cobra_model)
new_expr = this_neg_dg.constraint.expression.subs(subs_dict)
new_expr += (pos_slack - neg_slack)
this_reaction = this_neg_dg.reaction
# Remove former constraint to override it
slack_model.remove_constraint(slack_model._cons_dict[this_neg_dg.name])
# Add the new variant
slack_model.add_constraint(NegativeDeltaG,
this_reaction,
expr=new_expr,
lb=0,
ub=0)
# Update the objective with the new variables
objective_symbols += [neg_slack, pos_slack]
# objective = chunk_sum(objective_symbols)
objective = symbol_sum(objective_symbols)
# Change the objective to minimize slack
set_objective(slack_model, objective)
# Update variables and constraints references
slack_model.repair()
slack_model.logger.info('Optimizing slack model')
# Relax
slack_model.objective.direction = 'min'
relaxation = slack_model.optimize()
# Extract the relaxation values from the solution, by type
relaxed_model.logger.info('Extracting relaxation')
my_neg_slacks = slack_model.get_variables_of_type(NegSlackVariable)
my_pos_slacks = slack_model.get_variables_of_type(PosSlackVariable)
neg_slack_values = get_solution_value_for_variables(
relaxation, my_neg_slacks)
pos_slack_values = get_solution_value_for_variables(
relaxation, my_pos_slacks)
epsilon = relaxed_model.solver.configuration.tolerances.feasibility
for this_reaction in relaxed_model.reactions:
# No thermo, or relaxation forbidden
if this_reaction.id in reactions_to_ignore or this_reaction.id not in my_dgo:
continue
# Get the standard delta G variable
the_dgo = my_dgo.get_by_id(this_reaction.id)
# Get the relaxation
dgo_delta_lb = \
neg_slack_values[my_neg_slacks \
.get_by_id(this_reaction.id).name]
dgo_delta_ub = \
pos_slack_values[my_pos_slacks \
.get_by_id(this_reaction.id).name]
# Apply reaction delta G standard bound change
if dgo_delta_lb > 0 or dgo_delta_ub > 0:
# Store previous values
previous_dgo_lb = the_dgo.variable.lb
previous_dgo_ub = the_dgo.variable.ub
# Apply change
the_dgo.variable.lb -= (dgo_delta_lb + epsilon)
the_dgo.variable.ub += (dgo_delta_ub + epsilon)
# If needed, store that in a report table
changes[this_reaction.id] = [
previous_dgo_lb, previous_dgo_ub, dgo_delta_lb, dgo_delta_ub,
the_dgo.variable.lb, the_dgo.variable.ub
]
relaxed_model.logger.info('Testing relaxation')
relaxed_model.optimize()
# Format relaxation
relax_table = pd.DataFrame.from_dict(changes, orient='index')
relax_table.columns = [
'lb_in', 'ub_in', 'lb_change', 'ub_change', 'lb_out', 'ub_out'
]
relaxed_model.logger.info('\n' + relax_table.__str__())
return relaxed_model, slack_model, relax_table
def parse_xml_into_model(xml, number=float):
xml_model = xml.find(ns("sbml:model"))
if get_attrib(xml_model, "fbc:strict") != "true":
warn('loading SBML model without fbc:strict="true"')
model_id = get_attrib(xml_model, "id")
model = Model(model_id)
model.name = xml_model.get("name")
model.compartments = {c.get("id"): c.get("name") for c in
xml_model.findall(COMPARTMENT_XPATH)}
# add metabolites
for species in xml_model.findall(SPECIES_XPATH % 'false'):
met = get_attrib(species, "id", require=True)
met = Metabolite(clip(met, "M_"))
met.name = species.get("name")
annotate_cobra_from_sbml(met, species)
met.compartment = species.get("compartment")
met.charge = get_attrib(species, "fbc:charge", int)
met.formula = get_attrib(species, "fbc:chemicalFormula")
model.add_metabolites([met])
# Detect boundary metabolites - In case they have been mistakenly
# added. They should not actually appear in a model
boundary_metabolites = {clip(i.get("id"), "M_")
for i in xml_model.findall(SPECIES_XPATH % 'true')}
# add genes
for sbml_gene in xml_model.iterfind(GENES_XPATH):
gene_id = get_attrib(sbml_gene, "fbc:id").replace(SBML_DOT, ".")
gene = Gene(clip(gene_id, "G_"))
gene.name = get_attrib(sbml_gene, "fbc:name")
if gene.name is None:
gene.name = get_attrib(sbml_gene, "fbc:label")
annotate_cobra_from_sbml(gene, sbml_gene)
model.genes.append(gene)
def process_gpr(sub_xml):
"""recursively convert gpr xml to a gpr string"""
if sub_xml.tag == OR_TAG:
return "( " + ' or '.join(process_gpr(i) for i in sub_xml) + " )"
elif sub_xml.tag == AND_TAG:
return "( " + ' and '.join(process_gpr(i) for i in sub_xml) + " )"
elif sub_xml.tag == GENEREF_TAG:
gene_id = get_attrib(sub_xml, "fbc:geneProduct", require=True)
return clip(gene_id, "G_")
else:
raise Exception("unsupported tag " + sub_xml.tag)
bounds = {bound.get("id"): get_attrib(bound, "value", type=number)
for bound in xml_model.iterfind(BOUND_XPATH)}
# add reactions
reactions = []
for sbml_reaction in xml_model.iterfind(
ns("sbml:listOfReactions/sbml:reaction")):
reaction = get_attrib(sbml_reaction, "id", require=True)
reaction = Reaction(clip(reaction, "R_"))
reaction.name = sbml_reaction.get("name")
annotate_cobra_from_sbml(reaction, sbml_reaction)
lb_id = get_attrib(sbml_reaction, "fbc:lowerFluxBound", require=True)
ub_id = get_attrib(sbml_reaction, "fbc:upperFluxBound", require=True)
try:
reaction.upper_bound = bounds[ub_id]
reaction.lower_bound = bounds[lb_id]
except KeyError as e:
raise CobraSBMLError("No constant bound with id '%s'" % str(e))
reactions.append(reaction)
stoichiometry = defaultdict(lambda: 0)
for species_reference in sbml_reaction.findall(
ns("sbml:listOfReactants/sbml:speciesReference")):
met_name = clip(species_reference.get("species"), "M_")
stoichiometry[met_name] -= \
number(species_reference.get("stoichiometry"))
for species_reference in sbml_reaction.findall(
ns("sbml:listOfProducts/sbml:speciesReference")):
met_name = clip(species_reference.get("species"), "M_")
stoichiometry[met_name] += \
get_attrib(species_reference, "stoichiometry",
type=number, require=True)
# needs to have keys of metabolite objects, not ids
object_stoichiometry = {}
for met_id in stoichiometry:
if met_id in boundary_metabolites:
warn("Boundary metabolite '%s' used in reaction '%s'" %
(met_id, reaction.id))
continue
try:
metabolite = model.metabolites.get_by_id(met_id)
except KeyError:
warn("ignoring unknown metabolite '%s' in reaction %s" %
(met_id, reaction.id))
continue
object_stoichiometry[metabolite] = stoichiometry[met_id]
reaction.add_metabolites(object_stoichiometry)
# set gene reaction rule
gpr_xml = sbml_reaction.find(GPR_TAG)
if gpr_xml is not None and len(gpr_xml) != 1:
warn("ignoring invalid geneAssociation for " + repr(reaction))
gpr_xml = None
gpr = process_gpr(gpr_xml[0]) if gpr_xml is not None else ''
# remove outside parenthesis, if any
if gpr.startswith("(") and gpr.endswith(")"):
gpr = gpr[1:-1].strip()
gpr = gpr.replace(SBML_DOT, ".")
reaction.gene_reaction_rule = gpr
try:
model.add_reactions(reactions)
except ValueError as e:
warn(str(e))
# objective coefficients are handled after all reactions are added
obj_list = xml_model.find(ns("fbc:listOfObjectives"))
if obj_list is None:
warn("listOfObjectives element not found")
return model
target_objective_id = get_attrib(obj_list, "fbc:activeObjective")
target_objective = obj_list.find(
ns("fbc:objective[@fbc:id='{}']".format(target_objective_id)))
obj_direction_long = get_attrib(target_objective, "fbc:type")
obj_direction = LONG_SHORT_DIRECTION[obj_direction_long]
obj_query = OBJECTIVES_XPATH % target_objective_id
coefficients = {}
for sbml_objective in obj_list.findall(obj_query):
rxn_id = clip(get_attrib(sbml_objective, "fbc:reaction"), "R_")
try:
objective_reaction = model.reactions.get_by_id(rxn_id)
except KeyError:
raise CobraSBMLError("Objective reaction '%s' not found" % rxn_id)
try:
coefficients[objective_reaction] = get_attrib(
sbml_objective, "fbc:coefficient", type=number)
except ValueError as e:
warn(str(e))
set_objective(model, coefficients)
model.solver.objective.direction = obj_direction
return model
def relax_lc(tmodel, metabolites_to_ignore=(), solver=None):
"""
:param metabolites_to_ignore:
:param in_tmodel:
:type in_tmodel: pytfa.thermo.ThermoModel:
:param min_objective_value:
:return:
"""
if solver is None:
solver = tmodel.solver
# Create a copy of the cobra_model on which we will perform the slack addition
slack_model = deepcopy(tmodel)
slack_model.solver = solver
# Create a copy that will receive the relaxation
relaxed_model = deepcopy(tmodel)
relaxed_model.solver = solver
# Do not relax if cobra_model is already optimal
try:
solution = tmodel.optimize()
except SolverError as SE:
status = tmodel.solver.status
tmodel.logger.error(SE)
tmodel.logger.warning('Solver status: {}'.format(status))
# if tmodel.solver.status == OPTIMAL:
# raise Exception('Model is already optimal')
# Find variables that represent standard Gibbs Energy change
my_lc = relaxed_model.get_variables_of_type(LogConcentration)
# Find constraints that represent negativity of Gibbs Energy change
my_neg_dg = slack_model.get_constraints_of_type(NegativeDeltaG)
changes = OrderedDict()
objective = 0
pos_slack = dict()
neg_slack = dict()
for this_lc in my_lc:
if this_lc.name in metabolites_to_ignore:
continue
neg_slack[this_lc.name] = slack_model.add_variable(NegSlackLC,
this_lc,
lb=0,
ub=BIGM_DG)
pos_slack[this_lc.name] = slack_model.add_variable(PosSlackLC,
this_lc,
lb=0,
ub=BIGM_DG)
# Update the objective with the new variables
objective += (neg_slack[this_lc.name] + pos_slack[this_lc.name])
for this_neg_dg in my_neg_dg:
# If there is no thermo, or relaxation forbidden, pass
if this_neg_dg.id not in my_neg_dg:
continue
subs_dict = {k: slack_model.variables.get(k.name) \
for k in this_neg_dg.constraint.variables}
# Create the new constraint by adding the slack variables to the
# negative delta G constraint (from the initial cobra_model)
new_expr = this_neg_dg.constraint.expression.subs(subs_dict)
for this_var in this_neg_dg.constraint.variables:
if not this_var.name in neg_slack:
continue
met_id = pos_slack[this_var.name].id
the_met = slack_model.metabolites.get_by_id(met_id)
stoich = this_neg_dg.reaction.metabolites[the_met]
new_expr += slack_model.RT * stoich \
* \
(pos_slack[this_var.name] - neg_slack[this_var.name])
# Remove former constraint to override it
slack_model.remove_constraint(this_neg_dg)
# Add the new variant
slack_model.add_constraint(NegativeDeltaG,
this_neg_dg.reaction,
expr=new_expr,
lb=0,
ub=0)
# Change the objective to minimize slack
set_objective(slack_model, objective)
# Update variables and constraints references
slack_model.repair()
# Relax
slack_model.objective.direction = 'min'
relaxation = slack_model.optimize()
# Extract the relaxation values from the solution, by type
my_neg_slacks = slack_model.get_variables_of_type(NegSlackLC)
my_pos_slacks = slack_model.get_variables_of_type(PosSlackLC)
neg_slack_values = get_solution_value_for_variables(
relaxation, my_neg_slacks)
pos_slack_values = get_solution_value_for_variables(
relaxation, my_pos_slacks)
epsilon = relaxed_model.solver.configuration.tolerances.feasibility
for this_met in relaxed_model.metabolites:
# No thermo, or relaxation forbidden
if this_met.id in metabolites_to_ignore or this_met.id not in my_lc:
continue
# Get the standard delta G variable
the_lc = my_lc.get_by_id(this_met.id)
# Get the relaxation
lc_delta_lb = neg_slack_values[
my_neg_slacks \
.get_by_id(this_met.id).name]
lc_delta_ub = \
pos_slack_values[my_pos_slacks \
.get_by_id(this_met.id).name]
# Apply reaction delta G standard bound change
if lc_delta_lb > 0 or lc_delta_ub > 0:
# Store previous values
previous_lc_lb = the_lc.variable.lb
previous_lc_ub = the_lc.variable.ub
# Apply change
the_lc.variable.lb -= (lc_delta_lb + epsilon)
the_lc.variable.ub += (lc_delta_ub + epsilon)
# If needed, store that in a report table
changes[this_met.id] = [
previous_lc_lb, previous_lc_ub, lc_delta_lb, lc_delta_ub,
the_lc.variable.lb, the_lc.variable.ub
]
# Obtain relaxation
relaxed_model.optimize()
# Format relaxation
relax_table = pd.DataFrame.from_dict(changes, orient='index')
relax_table.columns = [
'lb_in', 'ub_in', 'lb_change', 'ub_change', 'lb_out', 'ub_out'
]
tmodel.logger.info('\n' + relax_table.__str__())
relaxed_model.relaxation = relax_table
return relaxed_model, slack_model, relax_table
def objective(self, value):
if isinstance(value, sympy.Basic):
value = self.problem.Objective(value, sloppy=False)
if not isinstance(value, (dict, optlang.interface.Objective)):
value = {rxn: 1 for rxn in self.reactions.get_by_any(value)}
set_objective(self, value, additive=False)
def relax_dgo(tmodel, reactions_to_ignore=(), solver=None, in_place=False):
"""
:param t_tmodel:
:type t_tmodel: pytfa.thermo.ThermoModel:
:param reactions_to_ignore: Iterable of reactions that should not be relaxed
:param solver: solver to use (e.g. 'optlang-glpk', 'optlang-cplex',
'optlang-gurobi'
:return: a cobra_model with relaxed bounds on standard Gibbs free energy
"""
if solver is None:
solver = tmodel.solver.interface
# Create a copy of the cobra_model on which we will perform the slack addition
slack_model = deepcopy(tmodel)
slack_model.solver = solver
slack_model.name = 'SlackModel ' + str(tmodel.name)
slack_model.id = 'SlackModel_' + tmodel.id
# Ensure the lazy updates are all done
slack_model.repair()
if not in_place:
# Create a copy that will receive the relaxation
relaxed_model = deepcopy(tmodel)
relaxed_model.solver = solver
relaxed_model.name = 'RelaxedModel ' + str(tmodel.name)
relaxed_model.id = 'RelaxedModel_' + tmodel.id
relaxed_model.repair()
else:
relaxed_model = slack_model
dg_relax_config(slack_model)
original_objective = relaxed_model.objective
# Do not relax if cobra_model is already optimal
# try:
# solution = tmodel.optimize()
# except SolverError as SE:
# status = tmodel.solver.status
# tmodel.logger.error(SE)
# tmodel.logger.warning('Solver status: {}'.format(status))
# if tmodel.solver.status == OPTIMAL:
# raise Exception('Model is already optimal')
# Find variables that represent standard Gibbs Energy change
my_dgo = relaxed_model.get_variables_of_type(DeltaGstd)
# Find constraints that represent negativity of Gibbs Energy change
my_neg_dg = slack_model.get_constraints_of_type(NegativeDeltaG)
changes = OrderedDict()
objective_symbols = []
slack_model.logger.info('Adding slack constraints')
slack_model.solver.update()
for this_neg_dg in tqdm(my_neg_dg, desc='adding slacks'):
# If there is no thermo, or relaxation forbidden, pass
if this_neg_dg.id in reactions_to_ignore or this_neg_dg.id not in my_dgo:
continue
# Create the negative and positive slack variables
# We can't queue them because they will be in an expression to declare
# the constraint
neg_slack = slack_model.add_variable(NegSlackVariable,
this_neg_dg.reaction,
lb=0,
ub=BIGM_DG,
queue=False)
pos_slack = slack_model.add_variable(PosSlackVariable,
this_neg_dg.reaction,
lb=0,
ub=BIGM_DG,
queue=False)
# Create the new constraint by adding the slack variables to the
# negative delta G constraint (from the initial cobra_model)
new_expr = this_neg_dg.constraint.expression
new_expr += (pos_slack - neg_slack)
this_reaction = this_neg_dg.reaction
# # Remove former constraint to override it
# slack_model.remove_constraint(slack_model._cons_dict[this_neg_dg.name])
#
# # Add the new variant
# slack_model.add_constraint(NegativeDeltaG,
# this_reaction,
# expr=new_expr,
# lb=0,
# ub=0,
# queue=True)
this_neg_dg.change_expr(new_expr)
# Update the objective with the new variables
objective_symbols += [neg_slack, pos_slack]
# objective = chunk_sum(objective_symbols)
objective = symbol_sum(objective_symbols)
# Change the objective to minimize slack
set_objective(slack_model, objective)
# Update variables and constraints references
slack_model.repair()
slack_model.logger.info('Optimizing slack model')
# Relax
slack_model.objective.direction = 'min'
relaxation = slack_model.optimize()
# Extract the relaxation values from the solution, by type
relaxed_model.logger.info('Extracting relaxation')
my_neg_slacks = slack_model.get_variables_of_type(NegSlackVariable)
my_pos_slacks = slack_model.get_variables_of_type(PosSlackVariable)
neg_slack_values = get_solution_value_for_variables(
relaxation, my_neg_slacks)
pos_slack_values = get_solution_value_for_variables(
relaxation, my_pos_slacks)
epsilon = relaxed_model.solver.configuration.tolerances.feasibility
relaxed_model.repair()
relaxed_model.solver.update()
# Apply reaction delta G standard bound change
for this_reaction in tqdm(relaxed_model.reactions, desc='applying slack'):
# No thermo, or relaxation forbidden
if this_reaction.id in reactions_to_ignore or this_reaction.id not in my_dgo:
continue
# Get the standard delta G variable
the_dgo = my_dgo.get_by_id(this_reaction.id)
# Get the relaxation
dgo_delta_lb = \
neg_slack_values[my_neg_slacks \
.get_by_id(this_reaction.id).name]
dgo_delta_ub = \
pos_slack_values[my_pos_slacks \
.get_by_id(this_reaction.id).name]
if in_place:
the_neg_slack = my_neg_slacks.get_by_id(this_reaction.id)
the_neg_slack_value = slack_model.solution.raw[the_neg_slack.name]
the_neg_slack.variable.lb = the_neg_slack_value - epsilon
the_neg_slack.variable.ub = the_neg_slack_value + epsilon
the_pos_slack = my_pos_slacks.get_by_id(this_reaction.id)
the_pos_slack_value = slack_model.solution.raw[the_pos_slack.name]
the_pos_slack.variable.lb = the_pos_slack_value - epsilon
the_pos_slack.variable.ub = the_pos_slack_value + epsilon
# Apply reaction delta G standard bound change
if dgo_delta_lb > 0 or dgo_delta_ub > 0:
# Store previous values
previous_dgo_lb = the_dgo.variable.lb
previous_dgo_ub = the_dgo.variable.ub
if not in_place:
# Apply change
the_dgo.variable.lb -= (dgo_delta_lb + epsilon)
the_dgo.variable.ub += (dgo_delta_ub + epsilon)
# If needed, store that in a report table
changes[this_reaction.id] = [
previous_dgo_lb, previous_dgo_ub, dgo_delta_lb, dgo_delta_ub,
the_dgo.variable.lb, the_dgo.variable.ub
]
relaxed_model.repair()
relaxed_model.logger.info('Testing relaxation')
relaxed_model.objective = original_objective
relaxed_model.objective.direction = 'max'
relaxed_model.optimize()
if len(changes) == 0:
# The model is infeasible or something went wrong
tmodel.logger.error('Relaxation could not complete '
'(no DeltaG relaxation found)')
return relaxed_model, slack_model, None
# Format relaxation
relax_table = pd.DataFrame.from_dict(changes, orient='index')
relax_table.columns = [
'lb_in', 'ub_in', 'lb_change', 'ub_change', 'lb_out', 'ub_out'
]
return relaxed_model, slack_model, relax_table
def objective_coefficient(self, value):
if self.model is None:
raise AttributeError("cannot assign objective to a missing model")
if self.flux_expression is not None:
set_objective(self.model, {self: value}, additive=True)
def read_sbml_ec_model(
filename: str,
number: float = float,
# re.Pattern does not exist in py36 so this type hint cannot be added now
f_replace=F_REPLACE,
set_missing_bounds: bool = False,
hardcoded_rev_reactions: bool = True,
**kwargs,
) -> Model:
"""Create `geckopy.Model` from SBMLDocument.
Parameters
----------
filename: str
number: data type of stoichiometry: {float, int}
In which data type should the stoichiometry be parsed.
f_replace : dict of replacement functions for id replacement
set_missing_bounds : flag to set missing bounds
hardcoded_rev_reactions: bool
if reversible reaction to account for proteins being consumed on both
directions are written explicitly for in the SBML
Returns
-------
cobra.core.Model
"""
try:
fsanitized = str(filename) if isinstance(filename, Path) else filename
doc = _get_doc_from_filename(fsanitized)
except IOError as e:
raise e
except Exception as original_error:
raise CobraSBMLError(
"Something went wrong reading the SBML model. Most likely the SBML"
" model is not valid. Please check that your model is valid using "
"the `cobra.io.sbml.validate_sbml_model` function or via the "
"online validator at http://sbml.org/validator .\n"
"\t`(model, errors) = validate_sbml_model(filename)`"
"\nIf the model is valid and cannot be read please open an issue "
f"at https://github.com/opencobra/cobrapy/issues: {original_error}"
)
if f_replace is None:
f_replace = {}
# SBML model
model: libsbml.Model = doc.getModel()
if model is None:
raise CobraSBMLError("No SBML model detected in file.")
model_fbc: libsbml.FbcModelPlugin = model.getPlugin("fbc")
if not model_fbc:
LOGGER.warning("Model does not contain SBML fbc package information.")
else:
if not model_fbc.isSetStrict():
LOGGER.warning('Loading SBML model without fbc:strict="true"')
# fbc-v1 (legacy)
doc_fbc = doc.getPlugin("fbc") # type: libsbml.FbcSBMLDocumentPlugin
fbc_version = doc_fbc.getPackageVersion()
if fbc_version == 1:
LOGGER.warning("Loading SBML with fbc-v1 (models should be encoded"
" using fbc-v2)")
conversion_properties = libsbml.ConversionProperties()
conversion_properties.addOption("convert fbc v1 to fbc v2", True,
"Convert FBC-v1 model to FBC-v2")
result = doc.convert(conversion_properties)
if result != libsbml.LIBSBML_OPERATION_SUCCESS:
raise Exception("Conversion of SBML fbc v1 to fbc v2 failed")
# Model
model_id = model.getIdAttribute()
if not libsbml.SyntaxChecker.isValidSBMLSId(model_id):
LOGGER.error("'%s' is not a valid SBML 'SId'." % model_id)
geckopy_model = Model(model_id,
hardcoded_rev_reactions=hardcoded_rev_reactions)
geckopy_model.name = model.getName()
# meta information
meta = {
"model.id": model_id,
"level": model.getLevel(),
"version": model.getVersion(),
"packages": [],
}
# History
creators = []
created = None
if model.isSetModelHistory():
history = model.getModelHistory() # type: libsbml.ModelHistory
if history.isSetCreatedDate():
created = history.getCreatedDate()
for c in history.getListCreators(): # type: libsbml.ModelCreator
creators.append({
"familyName":
c.getFamilyName() if c.isSetFamilyName() else None,
"givenName":
c.getGivenName() if c.isSetGivenName() else None,
"organisation":
c.getOrganisation() if c.isSetOrganisation() else None,
"email":
c.getEmail() if c.isSetEmail() else None,
})
meta["creators"] = creators
meta["created"] = created
meta["notes"] = _parse_notes_dict(doc)
meta["annotation"] = _parse_annotations(doc)
info = "<{}> SBML L{}V{}".format(model_id, model.getLevel(),
model.getVersion())
packages = {}
for k in range(doc.getNumPlugins()):
plugin = doc.getPlugin(k) # type:libsbml.SBasePlugin
key, value = plugin.getPackageName(), plugin.getPackageVersion()
packages[key] = value
info += ", {}-v{}".format(key, value)
if key not in ["fbc", "groups", "l3v2extendedmath"]:
LOGGER.warning(
"SBML package '%s' not supported by cobrapy, "
"information is not parsed",
key,
)
meta["info"] = info
meta["packages"] = packages
geckopy_model._sbml = meta
# notes and annotations
geckopy_model.notes = _parse_notes_dict(model)
geckopy_model.annotation = _parse_annotations(model)
# Compartments
# FIXME: update with new compartments
compartments = {}
for (compartment) in model.getListOfCompartments(
): # noqa: E501 type: libsbml.Compartment
cid = _check_required(compartment, compartment.getIdAttribute(), "id")
compartments[cid] = compartment.getName()
geckopy_model.compartments = compartments
# Species
metabolites = []
# proteins that rely on the naming convention "prot_UNIPROT_ID" will be
# catched here. Those who are annotated by groups membership will be parsed
# after the groups are processed.
proteins = []
boundary_metabolites = []
if model.getNumSpecies() == 0:
LOGGER.warning("No metabolites in model")
for specie in model.getListOfSpecies(): # type: libsbml.Species
sid = _check_required(specie, specie.getIdAttribute(), "id")
if f_replace and F_SPECIE in f_replace:
sid = f_replace[F_SPECIE](sid)
met = Metabolite(sid)
met.name = specie.getName()
met.notes = _parse_notes_dict(specie)
met.annotation = _parse_annotations(specie)
met.compartment = specie.getCompartment()
initial_amount = specie.getInitialAmount()
specie_fbc = specie.getPlugin("fbc") # type: libsbml.FbcSpeciesPlugin
if specie_fbc:
met.charge = specie_fbc.getCharge()
met.formula = specie_fbc.getChemicalFormula()
else:
if specie.isSetCharge():
LOGGER.warning(
"Use of the species charge attribute is "
"discouraged, use fbc:charge "
"instead: %s",
specie,
)
met.charge = specie.getCharge()
else:
if "CHARGE" in met.notes:
LOGGER.warning(
"Use of CHARGE in the notes element is "
"discouraged, use fbc:charge "
"instead: %s",
specie,
)
try:
met.charge = int(met.notes["CHARGE"])
except ValueError:
# handle nan, na, NA, ...
pass
if "FORMULA" in met.notes:
LOGGER.warning(
"Use of FORMULA in the notes element is "
"discouraged, use fbc:chemicalFormula "
"instead: %s",
specie,
)
met.formula = met.notes["FORMULA"]
# Detect boundary metabolites
if specie.getBoundaryCondition() is True:
boundary_metabolites.append(met)
if not PROT_PATTERN.match(met.id):
metabolites.append(met)
else:
proteins.append(Protein(met, concentration=initial_amount))
geckopy_model.add_metabolites(metabolites)
geckopy_model.add_proteins(proteins)
# Add exchange reactions for boundary metabolites
ex_reactions = []
for met in boundary_metabolites:
ex_rid = "EX_{}".format(met.id)
ex_reaction = Reaction(ex_rid)
ex_reaction.name = ex_rid
ex_reaction.annotation = {"sbo": SBO_EXCHANGE_REACTION}
ex_reaction.lower_bound = config.lower_bound
ex_reaction.upper_bound = config.upper_bound
LOGGER.warning("Adding exchange reaction %s with default bounds "
"for boundary metabolite: %s." %
(ex_reaction.id, met.id))
# species is reactant
ex_reaction.add_metabolites({met: -1})
ex_reactions.append(ex_reaction)
geckopy_model.add_reactions(ex_reactions)
# Genes
if model_fbc:
for (gp) in model_fbc.getListOfGeneProducts(
): # noqa: E501 type: libsbml.GeneProduct
gid = _check_required(gp, gp.getIdAttribute(), "id")
if f_replace and F_GENE in f_replace:
gid = f_replace[F_GENE](gid)
cobra_gene = Gene(gid)
cobra_gene.name = gp.getName()
if cobra_gene.name is None:
cobra_gene.name = gid
cobra_gene.annotation = _parse_annotations(gp)
cobra_gene.notes = _parse_notes_dict(gp)
geckopy_model.genes.append(cobra_gene)
else:
for (cobra_reaction) in model.getListOfReactions(
): # noqa: E501 type: libsbml.Reaction
# fallback to notes information
notes = _parse_notes_dict(cobra_reaction)
if "GENE ASSOCIATION" in notes:
gpr = notes["GENE ASSOCIATION"]
elif "GENE_ASSOCIATION" in notes:
gpr = notes["GENE_ASSOCIATION"]
else:
gpr = ""
if len(gpr) > 0:
gpr = gpr.replace("(", ";")
gpr = gpr.replace(")", ";")
gpr = gpr.replace("or", ";")
gpr = gpr.replace("and", ";")
# Interaction of the above replacements can lead to multiple
# ;, which results in empty gids
gids = [t.strip() for t in gpr.split(";")]
gids = set(gids).difference({""})
# create missing genes
for gid in gids:
if f_replace and F_GENE in f_replace:
gid = f_replace[F_GENE](gid)
if gid not in geckopy_model.genes:
cobra_gene = Gene(gid)
cobra_gene.name = gid
geckopy_model.genes.append(cobra_gene)
# GPR rules
def process_association(ass):
"""Recursively convert gpr association to a gpr string.
Defined as inline functions to not pass the replacement dict around.
"""
if ass.isFbcOr():
return " ".join([
"(",
" or ".join(
process_association(c)
for c in ass.getListOfAssociations()),
")",
])
elif ass.isFbcAnd():
return " ".join([
"(",
" and ".join(
process_association(c)
for c in ass.getListOfAssociations()),
")",
])
elif ass.isGeneProductRef():
gid = ass.getGeneProduct()
if f_replace and F_GENE in f_replace:
return f_replace[F_GENE](gid)
else:
return gid
# Reactions
missing_bounds = False
reactions = []
if model.getNumReactions() == 0:
LOGGER.warning("No reactions in model")
for reaction in model.getListOfReactions(): # type: libsbml.Reaction
rid = _check_required(reaction, reaction.getIdAttribute(), "id")
# proteins are parsed based on Species, prot exchanges are ignored
if PROT_EX_PATTERN.search(rid):
continue
if f_replace and F_REACTION in f_replace:
rid = f_replace[F_REACTION](rid)
cobra_reaction = Reaction(rid)
cobra_reaction.name = reaction.getName()
cobra_reaction.annotation = _parse_annotations(reaction)
cobra_reaction.notes = _parse_notes_dict(reaction)
# set bounds
p_ub, p_lb = None, None
r_fbc = reaction.getPlugin("fbc") # type: libsbml.FbcReactionPlugin
if r_fbc:
# bounds in fbc
lb_id = r_fbc.getLowerFluxBound()
if lb_id:
p_lb = model.getParameter(lb_id) # type: libsbml.Parameter
if p_lb and p_lb.getConstant() and (p_lb.getValue()
is not None):
cobra_reaction.lower_bound = p_lb.getValue()
else:
raise CobraSBMLError("No constant bound '%s' for "
"reaction: %s" % (p_lb, reaction))
ub_id = r_fbc.getUpperFluxBound()
if ub_id:
p_ub = model.getParameter(ub_id) # type: libsbml.Parameter
if p_ub and p_ub.getConstant() and (p_ub.getValue()
is not None):
cobra_reaction.upper_bound = p_ub.getValue()
else:
raise CobraSBMLError("No constant bound '%s' for "
"reaction: %s" % (p_ub, reaction))
elif reaction.isSetKineticLaw():
# some legacy models encode bounds in kinetic laws
klaw = reaction.getKineticLaw() # type: libsbml.KineticLaw
p_lb = klaw.getParameter(
"LOWER_BOUND") # noqa: E501 type: libsbml.LocalParameter
if p_lb:
cobra_reaction.lower_bound = p_lb.getValue()
p_ub = klaw.getParameter(
"UPPER_BOUND") # noqa: E501 type: libsbml.LocalParameter
if p_ub:
cobra_reaction.upper_bound = p_ub.getValue()
if p_ub is not None or p_lb is not None:
LOGGER.warning(
"Encoding LOWER_BOUND and UPPER_BOUND in "
"KineticLaw is discouraged, "
"use fbc:fluxBounds instead: %s",
reaction,
)
if p_lb is None:
missing_bounds = True
lower_bound = config.lower_bound
cobra_reaction.lower_bound = lower_bound
LOGGER.warning(
"Missing lower flux bound set to '%s' for "
" reaction: '%s'",
lower_bound,
reaction,
)
if p_ub is None:
missing_bounds = True
upper_bound = config.upper_bound
cobra_reaction.upper_bound = upper_bound
LOGGER.warning(
"Missing upper flux bound set to '%s' for "
" reaction: '%s'",
upper_bound,
reaction,
)
# add reaction
reactions.append(cobra_reaction)
# parse equation
stoichiometry = defaultdict(lambda: 0)
for (sref) in reaction.getListOfReactants(
): # noqa: E501 type: libsbml.SpeciesReference
sid = _check_required(sref, sref.getSpecies(), "species")
if f_replace and F_SPECIE in f_replace:
sid = f_replace[F_SPECIE](sid)
stoichiometry[sid] -= number(
_check_required(sref, sref.getStoichiometry(),
"stoichiometry"))
for (sref) in reaction.getListOfProducts(
): # noqa: E501 type: libsbml.SpeciesReference
sid = _check_required(sref, sref.getSpecies(), "species")
if f_replace and F_SPECIE in f_replace:
sid = f_replace[F_SPECIE](sid)
stoichiometry[sid] += number(
_check_required(sref, sref.getStoichiometry(),
"stoichiometry"))
# convert to metabolite objects
object_stoichiometry = {}
for met_id in stoichiometry:
target_set = (geckopy_model.proteins
if met_id in geckopy_model.proteins else
geckopy_model.metabolites)
metabolite = target_set.get_by_id(met_id)
object_stoichiometry[metabolite] = stoichiometry[met_id]
cobra_reaction.add_metabolites(object_stoichiometry)
# GPR
if r_fbc:
gpr = ""
gpa = (r_fbc.getGeneProductAssociation()
) # noqa: E501 type: libsbml.GeneProductAssociation
if gpa is not None:
association = (gpa.getAssociation()
) # noqa: E501 type: libsbml.FbcAssociation
gpr = process_association(association)
else:
# fallback to notes information
notes = cobra_reaction.notes
if "GENE ASSOCIATION" in notes:
gpr = notes["GENE ASSOCIATION"]
elif "GENE_ASSOCIATION" in notes:
gpr = notes["GENE_ASSOCIATION"]
else:
gpr = ""
if len(gpr) > 0:
LOGGER.warning(
"Use of GENE ASSOCIATION or GENE_ASSOCIATION "
"in the notes element is discouraged, use "
"fbc:gpr instead: %s",
reaction,
)
if f_replace and F_GENE in f_replace:
gpr = " ".join(f_replace[F_GENE](t)
for t in gpr.split(" "))
# remove outside parenthesis, if any
if gpr.startswith("(") and gpr.endswith(")"):
try:
parse_gpr(gpr[1:-1].strip())
gpr = gpr[1:-1].strip()
except (SyntaxError, TypeError) as e:
LOGGER.warning(
f"Removing parenthesis from gpr {gpr} leads to "
f"an error, so keeping parenthesis, error: {e}", )
cobra_reaction.gene_reaction_rule = gpr
geckopy_model.add_reactions(reactions)
# Objective
obj_direction = "max"
coefficients = {}
if model_fbc:
obj_list = (model_fbc.getListOfObjectives()
) # noqa: E501 type: libsbml.ListOfObjectives
if obj_list is None:
LOGGER.warning("listOfObjectives element not found")
elif obj_list.size() == 0:
LOGGER.warning("No objective in listOfObjectives")
elif not obj_list.getActiveObjective():
LOGGER.warning("No active objective in listOfObjectives")
else:
obj_id = obj_list.getActiveObjective()
obj = model_fbc.getObjective(obj_id) # type: libsbml.Objective
obj_direction = LONG_SHORT_DIRECTION[obj.getType()]
for (flux_obj) in (obj.getListOfFluxObjectives()
): # noqa: E501 type: libsbml.FluxObjective
rid = flux_obj.getReaction()
if f_replace and F_REACTION in f_replace:
rid = f_replace[F_REACTION](rid)
try:
objective_reaction = geckopy_model.reactions.get_by_id(rid)
except KeyError:
raise CobraSBMLError("Objective reaction '%s' "
"not found" % rid)
try:
coefficients[objective_reaction] = number(
flux_obj.getCoefficient())
except ValueError as e:
LOGGER.warning(str(e))
else:
# some legacy models encode objective coefficients in kinetic laws
for reaction in model.getListOfReactions(): # type: libsbml.Reaction
if reaction.isSetKineticLaw():
klaw = reaction.getKineticLaw() # type: libsbml.KineticLaw
p_oc = klaw.getParameter(
"OBJECTIVE_COEFFICIENT") # type: libsbml.LocalParameter
if p_oc:
rid = _check_required(reaction, reaction.getIdAttribute(),
"id")
if f_replace and F_REACTION in f_replace:
rid = f_replace[F_REACTION](rid)
try:
objective_reaction = geckopy_model.reactions.get_by_id(
rid)
except KeyError:
raise CobraSBMLError(
"Objective reaction '%s' "
"not found", rid)
try:
coefficients[objective_reaction] = number(
p_oc.getValue())
except ValueError as e:
LOGGER.warning(str(e))
LOGGER.warning(
"Encoding OBJECTIVE_COEFFICIENT in "
"KineticLaw is discouraged, "
"use fbc:fluxObjective "
"instead: %s",
reaction,
)
if len(coefficients) == 0:
LOGGER.error("No objective coefficients in model. Unclear what should "
"be optimized")
set_objective(geckopy_model, coefficients)
geckopy_model.solver.objective.direction = obj_direction
# parse groups
model_groups = model.getPlugin("groups") # type: libsbml.GroupsModelPlugin
groups = []
if model_groups:
# calculate hashmaps to lookup objects in O(1)
sid_map = {}
metaid_map = {}
for obj_list in [
model.getListOfCompartments(),
model.getListOfSpecies(),
model.getListOfReactions(),
model_groups.getListOfGroups(),
]:
for sbase in obj_list: # type: libsbml.SBase
if sbase.isSetId():
sid_map[sbase.getIdAttribute()] = sbase
if sbase.isSetMetaId():
metaid_map[sbase.getMetaId()] = sbase
# create groups
for group in model_groups.getListOfGroups(): # type: libsbml.Group
gid = _check_required(group, group.getIdAttribute(), "id")
if f_replace and F_GROUP in f_replace:
gid = f_replace[F_GROUP](gid)
cobra_group = Group(gid)
cobra_group.name = group.getName()
if group.isSetKind():
cobra_group.kind = group.getKindAsString()
cobra_group.annotation = _parse_annotations(group)
cobra_group.notes = _parse_notes_dict(group)
cobra_members = []
for member in group.getListOfMembers(): # type: libsbml.Member
if member.isSetIdRef():
obj = sid_map[member.getIdRef()]
elif member.isSetMetaIdRef():
obj = metaid_map[member.getMetaIdRef()]
typecode = obj.getTypeCode()
obj_id = _check_required(obj, obj.getIdAttribute(), "id")
# id replacements
cobra_member = None
if typecode == libsbml.SBML_SPECIES:
if f_replace and F_SPECIE in f_replace:
obj_id = f_replace[F_SPECIE](obj_id)
try:
cobra_member = geckopy_model.metabolites.get_by_id(
obj_id)
except KeyError:
cobra_member = geckopy_model.proteins.get_by_id(obj_id)
elif typecode == libsbml.SBML_REACTION:
if f_replace and F_REACTION in f_replace:
obj_id = f_replace[F_REACTION](obj_id)
cobra_member = geckopy_model.reactions.get_by_id(obj_id)
elif typecode == libsbml.SBML_FBC_GENEPRODUCT:
if f_replace and F_GENE in f_replace:
obj_id = f_replace[F_GENE](obj_id)
cobra_member = geckopy_model.genes.get_by_id(obj_id)
else:
LOGGER.warning("Member %s could not be added to group %s."
"unsupported type code: "
"%s" % (member, group, typecode))
if cobra_member:
cobra_members.append(cobra_member)
cobra_group.add_members(cobra_members)
groups.append(cobra_group)
else:
# parse deprecated subsystems on reactions
groups_dict = {}
for cobra_reaction in geckopy_model.reactions:
if "SUBSYSTEM" in cobra_reaction.notes:
g_name = cobra_reaction.notes["SUBSYSTEM"]
if g_name in groups_dict:
groups_dict[g_name].append(cobra_reaction)
else:
groups_dict[g_name] = [cobra_reaction]
for gid, cobra_members in groups_dict.items():
if f_replace and F_GROUP in f_replace:
gid = f_replace[F_GROUP](gid)
cobra_group = Group(gid, name=gid, kind="collection")
cobra_group.add_members(cobra_members)
groups.append(cobra_group)
geckopy_model.add_groups(groups)
# now add everything under group Proteins to model.proteins if it was not
# already added based on naming conventions
if geckopy_model.groups.query("Protein"):
g_proteins = geckopy_model.groups.Protein.members.copy()
g_proteins = {
prot: {reac: reac.metabolites[prot]
for reac in prot.reactions}
for prot in g_proteins if prot not in geckopy_model.proteins
}
if g_proteins:
geckopy_model.remove_metabolites(g_proteins.keys())
geckopy_model.add_proteins([Protein(prot) for prot in g_proteins])
for prot, reactions in g_proteins.items():
for reac, stoich in reactions.items():
# reverse the (negative) stoichiometry coefficient to kcat
# we expect that Proteins that are identified only by their
# group are respecting the specification and do form part
# of reactions
# TODO: provide options to tune this behvior
reac.add_protein(prot.id, -1 / (stoich * 3600))
# general hint for missing flux bounds
if missing_bounds:
LOGGER.warning(
"Missing flux bounds on reactions set to default bounds."
"As best practise and to avoid confusion flux bounds "
"should be set explicitly on all reactions.")
return geckopy_model