def _replace_adapted_metabolites(self, reaction):
"""
Replace adapted metabolites by model metabolites
Parameters
----------
reaction: cameo.core.reaction.Reaction
Returns
-------
cameo.core.reaction.Reaction
"""
stoichiometry = {}
for metabolite, coefficient in six.iteritems(reaction.metabolites):
found = False
for adapter in self.adapters:
if metabolite == adapter.products[0]:
metabolite = Metabolite.clone(adapter.reactants[0])
found = False
break
if not found:
metabolite = Metabolite.clone(metabolite)
stoichiometry[metabolite] = coefficient
reaction = Reaction(id=reaction.id,
name=reaction.name,
lower_bound=reaction.lower_bound,
upper_bound=reaction.upper_bound)
reaction.add_metabolites(stoichiometry)
return reaction
def setUpClass(cls):
cls.model = load_model(os.path.join(TESTDIR, 'data', 'EcoliCore.xml'))
cls.cad_reaction = Reaction(id="CAD", name="Cis-Aconitate Decarboxylase")
acon_C_c = cls.model.metabolites.acon_dsh_C_c
co2_c = cls.model.metabolites.co2_c
ita_c = Metabolite(id="ita_c", name="Itaconate", compartment="c")
cls.cad_reaction.add_metabolites({acon_C_c: -1, co2_c: 1, ita_c: 1})
def cad_reaction(core_model):
reaction = Reaction(id="CAD", name="Cis-Aconitate Decarboxylase")
acon = core_model.metabolites.acon_DASH_C_c
co2_c = core_model.metabolites.co2_c
ita_c = Metabolite(id="ita_c", name="Itaconate", compartment="c")
reaction.add_metabolites({acon: -1, co2_c: 1, ita_c: 1})
return reaction
def parse_coeff_and_metabolites(term):
try:
coeff, metabolite_id = term.strip().split(' ')
except:
raise ValueError(
'Something is fishy with the provided term %s' % term)
return Metabolite(metabolite_id), factor * float(coeff)
def test_reaction_knock_in_target(self):
reaction = Reaction(id="atpzase", name="Cosmic ATP generator")
atp_z = Metabolite(id="atp_z", name="Cosmic ATP", compartment="c")
reaction.add_metabolites({self.model.metabolites.atp_c: 1, atp_z: -1})
knockin_target = ReactionKnockinTarget("atpzase", reaction)
with TimeMachine() as tm:
knockin_target.apply(self.model, time_machine=tm)
self.assertIn(atp_z, self.model.metabolites)
self.assertIn(reaction, self.model.reactions)
self.assertNotIn(atp_z, self.model.metabolites)
self.assertNotIn(reaction, self.model.reactions)
def test_reaction_knock_in_target(self, model):
reaction = Reaction(id="atpzase", name="Cosmic ATP generator")
atp_z = Metabolite(id="atp_z", name="Cosmic ATP", compartment="c")
reaction.add_metabolites({model.metabolites.atp_c: 1, atp_z: -1})
knockin_target = ReactionKnockinTarget("atpzase", reaction)
with TimeMachine() as tm:
knockin_target.apply(model, time_machine=tm)
assert atp_z in model.metabolites
assert reaction in model.reactions
assert atp_z not in model.metabolites
assert reaction not in model.reactions
def test_gnomic_integration(self):
from gnomic.models import Accession, Feature, Mutation, FeatureTree
abstract_target = Target("test")
abstract_target_gnomic = abstract_target.to_gnomic()
self.assertIsInstance(abstract_target_gnomic, Accession)
self.assertEqual(abstract_target_gnomic.identifier, abstract_target.id)
flux_modulation_target = FluxModulationTarget("test", 1, 0)
flux_modulation_target_gnomic = flux_modulation_target.to_gnomic()
self.assertIsInstance(flux_modulation_target_gnomic, Mutation)
self.assertIsInstance(flux_modulation_target_gnomic.old, FeatureTree)
self.assertIsInstance(flux_modulation_target_gnomic.old[0], Feature)
self.assertEqual(
flux_modulation_target_gnomic.old[0].accession.identifier,
flux_modulation_target.id)
self.assertEqual(flux_modulation_target_gnomic.old[0].variant, None)
self.assertEqual(flux_modulation_target_gnomic.old[0].type, 'flux')
self.assertIsInstance(flux_modulation_target_gnomic.new, FeatureTree)
self.assertIsInstance(flux_modulation_target_gnomic.new[0], Feature)
self.assertEqual(
flux_modulation_target_gnomic.new[0].accession.identifier,
flux_modulation_target.id)
self.assertEqual(flux_modulation_target_gnomic.new[0].type, 'flux')
self.assertEqual(
flux_modulation_target_gnomic.new[0].variant,
"over-expression(%f)" % flux_modulation_target.fold_change)
flux_modulation_target = FluxModulationTarget("test", 0.5, 1)
flux_modulation_target_gnomic = flux_modulation_target.to_gnomic()
self.assertIsInstance(flux_modulation_target_gnomic, Mutation)
self.assertIsInstance(flux_modulation_target_gnomic.old, FeatureTree)
self.assertIsInstance(flux_modulation_target_gnomic.old[0], Feature)
self.assertEqual(
flux_modulation_target_gnomic.old[0].accession.identifier,
flux_modulation_target.id)
self.assertEqual(flux_modulation_target_gnomic.old[0].variant, None)
self.assertEqual(flux_modulation_target_gnomic.old[0].type, 'flux')
self.assertIsInstance(flux_modulation_target_gnomic.new, FeatureTree)
self.assertIsInstance(flux_modulation_target_gnomic.new[0], Feature)
self.assertEqual(
flux_modulation_target_gnomic.new[0].accession.identifier,
flux_modulation_target.id)
self.assertEqual(flux_modulation_target_gnomic.new[0].type, 'flux')
self.assertEqual(
flux_modulation_target_gnomic.new[0].variant,
"down-regulation(%f)" % flux_modulation_target.fold_change)
flux_modulation_target = FluxModulationTarget("test", 0, 1)
flux_modulation_target_gnomic = flux_modulation_target.to_gnomic()
self.assertIsInstance(flux_modulation_target_gnomic, Mutation)
self.assertIsInstance(flux_modulation_target_gnomic.old, FeatureTree)
self.assertIsInstance(flux_modulation_target_gnomic.old[0], Feature)
self.assertEqual(
flux_modulation_target_gnomic.old[0].accession.identifier,
flux_modulation_target.id)
self.assertEqual(flux_modulation_target_gnomic.old[0].variant, None)
self.assertEqual(flux_modulation_target_gnomic.old[0].type, 'flux')
self.assertIs(flux_modulation_target_gnomic.new, None)
reaction = Reaction(id="atpzase", name="Cosmic ATP generator")
atp_z = Metabolite(id="atp_z", name="Cosmic ATP", compartment="c")
reaction.add_metabolites({self.model.metabolites.atp_c: 1, atp_z: -1})
knockin_target = ReactionKnockinTarget("atpzase", reaction)
knockin_target_gnomic = knockin_target.to_gnomic()
self.assertIsInstance(knockin_target_gnomic, Mutation)
self.assertIsInstance(knockin_target_gnomic.new, FeatureTree)
self.assertIsInstance(knockin_target_gnomic.new[0], Feature)
self.assertEqual(knockin_target_gnomic.new[0].accession.identifier,
knockin_target.id)
self.assertEqual(knockin_target_gnomic.new[0].variant, None)
self.assertEqual(knockin_target_gnomic.new[0].type, 'reaction')
self.assertIs(knockin_target_gnomic.old, None)
cofactor_id_swaps = [("nad_c", "nadh_c"), ("nadp_c", "nadph_c")]
swap_pairs = ([
self.model.metabolites.get_by_id(m) for m in cofactor_id_swaps[0]
], [self.model.metabolites.get_by_id(m) for m in cofactor_id_swaps[1]])
swap_target = ReactionCofactorSwapTarget("GAPD", swap_pairs)
swap_target_gnomic = swap_target.to_gnomic()
self.assertIsInstance(swap_target_gnomic, Mutation)
self.assertIsInstance(swap_target_gnomic.old, FeatureTree)
self.assertIsInstance(swap_target_gnomic.old[0], Feature)
self.assertEqual(swap_target_gnomic.old[0].accession.identifier,
swap_target.id)
self.assertEqual(swap_target_gnomic.old[0].variant, None)
self.assertEqual(swap_target_gnomic.old[0].type, 'reaction')
self.assertIsInstance(swap_target_gnomic.new, FeatureTree)
self.assertIsInstance(swap_target_gnomic.new[0], Feature)
self.assertEqual(swap_target_gnomic.new[0].accession.identifier,
swap_target.id + swap_target.swap_str)
self.assertEqual(swap_target_gnomic.new[0].variant, None)
self.assertEqual(swap_target_gnomic.new[0].type, 'reaction')
def test_gnomic_integration(self, model):
from gnomic.models import Accession, Feature, Mutation, FeatureTree
abstract_target = Target("test")
abstract_target_gnomic = abstract_target.to_gnomic()
assert isinstance(abstract_target_gnomic, Accession)
assert abstract_target_gnomic.identifier == abstract_target.id
flux_modulation_target = FluxModulationTarget("test", 1, 0)
flux_modulation_target_gnomic = flux_modulation_target.to_gnomic()
flux_mod_new = flux_modulation_target_gnomic.new
flux_mod_old = flux_modulation_target_gnomic.old
assert isinstance(flux_modulation_target_gnomic, Mutation)
assert isinstance(flux_mod_old, FeatureTree)
assert isinstance(flux_mod_old[0], Feature)
assert flux_mod_old[
0].accession.identifier == flux_modulation_target.id
assert flux_mod_old[0].variant is None
assert flux_mod_old[0].type == 'flux'
assert isinstance(flux_mod_new, FeatureTree)
assert isinstance(flux_mod_new[0], Feature)
assert flux_mod_new[
0].accession.identifier == flux_modulation_target.id
assert flux_mod_new[0].type == 'flux'
assert flux_mod_new[
0].variant == "over-expression(%.3f)" % flux_modulation_target.fold_change
flux_modulation_target = FluxModulationTarget("test", 0.5, 1)
flux_modulation_target_gnomic = flux_modulation_target.to_gnomic()
flux_mod_new = flux_modulation_target_gnomic.new
flux_mod_old = flux_modulation_target_gnomic.old
assert isinstance(flux_modulation_target_gnomic, Mutation)
assert isinstance(flux_mod_old, FeatureTree)
assert isinstance(flux_mod_old[0], Feature)
assert flux_mod_old[
0].accession.identifier == flux_modulation_target.id
assert flux_mod_old[0].variant is None
assert flux_mod_old[0].type == 'flux'
assert isinstance(flux_mod_new, FeatureTree)
assert isinstance(flux_mod_new[0], Feature)
assert flux_mod_new[
0].accession.identifier == flux_modulation_target.id
assert flux_mod_new[0].type == 'flux'
assert flux_mod_new[
0].variant == "down-regulation(%.3f)" % flux_modulation_target.fold_change
flux_modulation_target = FluxModulationTarget("test", 0, 1)
flux_modulation_target_gnomic = flux_modulation_target.to_gnomic()
assert isinstance(flux_modulation_target_gnomic, Mutation)
assert isinstance(flux_modulation_target_gnomic.old, FeatureTree)
assert isinstance(flux_modulation_target_gnomic.old[0], Feature)
assert flux_modulation_target_gnomic.old[
0].accession.identifier == flux_modulation_target.id
assert flux_modulation_target_gnomic.old[0].variant is None
assert flux_modulation_target_gnomic.old[0].type == 'flux'
assert flux_modulation_target_gnomic.new is None
reaction = Reaction(id="atpzase", name="Cosmic ATP generator")
atp_z = Metabolite(id="atp_z", name="Cosmic ATP", compartment="c")
reaction.add_metabolites({model.metabolites.atp_c: 1, atp_z: -1})
knockin_target = ReactionKnockinTarget("atpzase", reaction)
knockin_target_gnomic = knockin_target.to_gnomic()
assert isinstance(knockin_target_gnomic, Mutation)
assert isinstance(knockin_target_gnomic.new, FeatureTree)
assert isinstance(knockin_target_gnomic.new[0], Feature)
assert knockin_target_gnomic.new[
0].accession.identifier == knockin_target.id
assert knockin_target_gnomic.new[0].variant is None
assert knockin_target_gnomic.new[0].type == 'reaction'
assert knockin_target_gnomic.old is None
cofactor_id_swaps = [("nad_c", "nadh_c"), ("nadp_c", "nadph_c")]
swap_pairs = ([
model.metabolites.get_by_id(m) for m in cofactor_id_swaps[0]
], [model.metabolites.get_by_id(m) for m in cofactor_id_swaps[1]])
swap_target = ReactionCofactorSwapTarget("GAPD", swap_pairs)
swap_target_gnomic = swap_target.to_gnomic()
assert isinstance(swap_target_gnomic, Mutation)
assert isinstance(swap_target_gnomic.old, FeatureTree)
assert isinstance(swap_target_gnomic.old[0], Feature)
assert swap_target_gnomic.old[0].accession.identifier == swap_target.id
assert swap_target_gnomic.old[0].variant is None
assert swap_target_gnomic.old[0].type == 'reaction'
assert isinstance(swap_target_gnomic.new, FeatureTree)
assert isinstance(swap_target_gnomic.new[0], Feature)
assert swap_target_gnomic.new[
0].accession.identifier == swap_target.id + swap_target.swap_str
assert swap_target_gnomic.new[0].variant is None
assert swap_target_gnomic.new[0].type == 'reaction'