def parse_metabolites(metabolites_node,
model=None,
progress=None,
use_fbc=True):
species_node = metabolites_node.find(sbml3_listOfSpecies)
if species_node is None:
return
elif progress is None:
pass
elif not progress.wasCanceled():
progress.setLabelText("Reading metabolites...")
progress.setRange(0, len(species_node))
else:
return
metabolites = []
for i, xml_element in enumerate(species_node.iterfind(sbml3_species)):
if progress is None:
pass
elif not progress.wasCanceled():
progress.setValue(i)
QApplication.processEvents()
else:
return
new_metabolite = Metabolite(id=clip(xml_element.get("id"), "M_"),
name=xml_element.get("name"),
compartment=xml_element.get("compartment"))
if use_fbc:
formula = xml_element.get(fbc_chemicalFormula)
if formula:
if re.match(formula_validator, formula):
new_metabolite.formula = formula
else:
# Todo: Implement logging of errors
print("Formula '{}' for {} is invalid!".format(
formula, new_metabolite.id))
charge = xml_element.get(fbc_charge)
if charge is not None:
new_metabolite.charge = int(charge)
# Defaults to the standard value of 0 if charge not set in file
annotate_element_from_xml(xml_element, new_metabolite)
metabolites.append(new_metabolite)
if model is not None:
model.add_metabolites(metabolites)
return metabolites
def setup_table(self):
self.item1_text = "test text1"
self.item1_obj = Metabolite(id=self.item1_text)
self.item2_text = "test text2"
self.item2_obj = Metabolite(id=self.item2_text)
self.expected_items = [
LinkedItem(text=self.item1_text, link=self.item1_obj),
LinkedItem(text=self.item2_text, link=self.item2_obj)
]
self.table = ElementTable()
self.table.row_from_item = Mock(return_value=self.expected_items)
def setup_items(self):
self.table = StoichiometryTable()
self.met1_id = "test id"
self.metabolite1 = Metabolite(id=self.met1_id)
self.met2_id = "test_id2"
self.metabolite2 = Metabolite(id=self.met2_id)
self.met2_coefficient = 1.
self.met1_coefficient = -1.
self.stoichiometry = OrderedDict(
((self.metabolite1, self.met1_coefficient),
(self.metabolite2, self.met2_coefficient)))
def test_successful_update(self):
""" Check that metabolite formula is successfully updated
from a reaction where all other metabolite formulae are set """
react = Reaction("rea")
met1 = Metabolite("met1", formula="C7H8O2")
met2 = Metabolite("met2", formula="C8H8O4")
met3 = Metabolite("met3")
react.add_metabolites({met1: 1, met3: 1, met2: -1})
result = update_formula_from_neighborhood(met3)
assert result is True
assert met3.formula == "CO2"
def test_no_map_by_stoichiometry_if_any_metabolite_not_mapped(
self, database, progress):
model = Model()
met1 = Metabolite("m1")
met2 = Metabolite("m2")
model.add_metabolites((met1, met2))
model.database_mapping.update({met1: 1})
reaction = Reaction("r1")
reaction.add_metabolites({met1: -1, met2: -1})
model.add_reactions([reaction])
update_reaction_database_mapping(database, model, progress)
assert reaction not in model.database_mapping
def test_no_update_if_mutliple_metabolites_wo_formula(self):
""" Check that formula is not updated if multiple metabolites
have no formula set """
react = Reaction("rea")
met1 = Metabolite("met1", formula="C7H8O2")
met2 = Metabolite("met2")
met3 = Metabolite("met3")
react.add_metabolites({met1: 1, met3: 1, met2: -1})
result = update_formula_from_neighborhood(met3)
assert result is False
assert not met3.formula
def test_invalid_if_any_reaction_not_in_same_compartment(self):
self.metabolite1.compartment = "c"
self.metabolite2.compartment = "c"
self.compartment.id = "c"
assert self.evidence.is_valid() is True
met1 = Metabolite("m1")
met2 = Metabolite("m2")
react2 = Reaction("r2")
react2.add_metabolites({met1: -1, met2: 1})
react2.add_child(self.gene)
assert self.evidence.is_valid() is False
def test_map_reaction_by_stoichiometry(self, database, progress):
model = Model()
met1 = Metabolite("m1")
met2 = Metabolite("m2")
met3 = Metabolite("m3")
met4 = Metabolite("m4")
model.add_metabolites((met1, met2, met3, met4))
model.database_mapping.update({met1: 1, met2: 2, met3: 3, met4: 4})
reaction = Reaction("r1")
reaction.add_metabolites({met1: -1, met2: -1, met3: 1, met4: 1})
model.add_reactions([reaction])
update_reaction_database_mapping(database, model, progress)
assert model.database_mapping[reaction] == 1
def test_map_reaction_by_annotation(self, database, progress):
model = Model()
met1 = Metabolite("m1")
met2 = Metabolite("m2")
model.add_metabolites([met1, met2])
reaction = Reaction("r1")
reaction.add_metabolites({met1: -1, met2: 1})
reaction.annotation.add(
Annotation(identifier="MNXR14892", collection="metanetx.reaction"))
model.add_reactions([reaction])
update_reaction_database_mapping(database, model, progress)
assert model.database_mapping[reaction] == 1
def test_balancing_status2(self):
charge = 0
formula = "H2O"
met1 = Metabolite("test1", charge=charge, formula=formula)
met2 = Metabolite("test2", charge=charge, formula=formula)
stoichiometry = 1
reaction = Reaction("test")
reaction.add_metabolites({met1: stoichiometry, met2: -stoichiometry})
self.widget.set_item(reaction, self.model)
assert self.widget.statusLabel.toolTip(
) == self.widget.msg_standard.format(status="balanced",
charge="OK",
elements="OK")
def setup_items(self):
self.gene = Gene("g1")
self.compartment = Compartment("c")
self.metabolite1 = Metabolite("m1")
self.metabolite2 = Metabolite("m2")
self.reaction = Reaction("r1")
self.reaction.add_metabolites({
self.metabolite1: -1,
self.metabolite2: 1
})
self.reaction.add_child(self.gene)
self.evidence = Evidence(entity=self.gene,
assertion="Localization",
target=self.compartment)
def test_map_metabolite_by_formula(self, database, progress):
model = Model()
met1 = Metabolite("m1", formula="H2O")
model.add_metabolites([met1])
update_metabolite_database_mapping(database, model, progress)
assert model.database_mapping[met1] == 1
def test_not_mapped_for_name_substring(self, database, progress):
model = Model()
met1 = Metabolite("m1", name="ater")
model.add_metabolites([met1])
update_metabolite_database_mapping(database, model, progress)
assert model.database_mapping[met1] is None
def test_map_metabolite_by_name(self, database, progress):
model = Model()
met1 = Metabolite("m1", name="Water")
model.add_metabolites([met1])
update_metabolite_database_mapping(database, model, progress)
assert model.database_mapping[met1] == 1
def test_save_state_new_metabolite(self):
metabolite = Metabolite()
model = Model()
widget = MetaboliteAttributesDisplayWidget()
widget.set_item(metabolite, model)
new_id = "New"
new_name = "Name"
new_charge = 2.
new_formula = "H20"
new_compartment = "c"
widget.iDLineEdit.setText(new_id)
widget.nameLineEdit.setText(new_name)
widget.chargeSpinBox.setValue(new_charge)
widget.formulaLineEdit.setText(new_formula)
widget.compartmentComboBox.addItem(new_compartment)
widget.compartmentComboBox.setCurrentText(new_compartment)
widget.save_state()
assert metabolite.id == new_id
assert metabolite.name == new_name
assert metabolite.charge == new_charge
assert metabolite.formula == new_formula
assert metabolite.compartment == new_compartment
assert metabolite in model.metabolites
assert metabolite in model.QtMetaboliteTable.get_items()
def test_get_item_from_model(self):
model = Model("test id")
reaction = Reaction("r_id")
metabolite = Metabolite("m_id")
gene = Gene("g_id")
# ToDo: Add gene group
model.add_reactions([reaction])
model.add_metabolites([metabolite]),
model.add_gene(gene)
# ToDo: Add gene group
assert get_item_from_model("Model", model.id, model) is model
assert get_item_from_model("Reaction", reaction.id, model) is reaction
assert get_item_from_model("Metabolite", metabolite.id, model) is metabolite
assert get_item_from_model("Gene", gene.id, model) is gene
# Test expected errors
# GeneGroup not implemented
with pytest.raises(NotImplementedError):
get_item_from_model("GeneGroup", "test_id", model)
# ID not in model
with pytest.raises(KeyError):
get_item_from_model("Reaction", "Not in model", model)
with pytest.raises(KeyError):
get_item_from_model("Metabolite", "Not in model", model)
with pytest.raises(KeyError):
get_item_from_model("Gene", "Not in model", model)
def test_setting_item(self):
metabolite = Metabolite("test_id", "H2O", "Test metabolie", -5, "m")
model = Model()
widget = MetaboliteAttributesDisplayWidget()
# Test prestate
assert widget.iDLineEdit.text() == ""
assert widget.nameLineEdit.text() == ""
assert widget.compartmentComboBox.currentText() == ""
assert widget.chargeSpinBox.value() == 0
assert widget.formulaLineEdit.text() == ""
widget.set_item(metabolite, model)
assert widget.iDLineEdit.text() == metabolite.id
assert widget.nameLineEdit.text() == metabolite.name
assert widget.compartmentComboBox.currentText(
) == metabolite.compartment
assert widget.chargeSpinBox.value() == metabolite.charge
assert widget.formulaLineEdit.text() == metabolite.formula
assert widget.valid_inputs() is True
assert widget.content_changed is False
widget.set_item(None, model)
assert widget.iDLineEdit.text() == ""
assert widget.nameLineEdit.text() == ""
assert widget.compartmentComboBox.currentText() == ""
assert widget.chargeSpinBox.value() == 0.
assert widget.formulaLineEdit.text() == ""
assert widget.valid_inputs() is False
assert widget.content_changed is False
def test_do_nothing_if_no_ambiguous_maps(self):
model = Model()
metabolite = Metabolite()
model.database_mapping[metabolite] = 1
check_ambiguous_mappings(model, None)
assert model.database_mapping[metabolite] == 1
def test_save_state_existing_metabolite(self):
metabolite = Metabolite(id="m1",
charge=1,
name="old name",
formula="O2",
compartment="c")
model = Model()
model.gem_add_metabolites((metabolite, ))
widget = MetaboliteAttributesDisplayWidget()
widget.set_item(metabolite, model)
new_id = "New_id"
new_name = "New name"
new_charge = 3.
new_compartment = "m"
new_formula = "H2O"
widget.iDLineEdit.setText(new_id)
widget.nameLineEdit.setText(new_name)
widget.chargeSpinBox.setValue(new_charge)
widget.compartmentComboBox.addItem(new_compartment)
widget.compartmentComboBox.setCurrentIndex(
widget.compartmentComboBox.count() - 1)
widget.formulaLineEdit.setText(new_formula)
widget.save_state()
assert metabolite.id == new_id
assert metabolite.name == new_name
assert metabolite.charge == new_charge
assert metabolite.compartment == new_compartment
assert metabolite.formula == new_formula
assert model.metabolites.has_id(new_id)
def test_standard_values(self):
metabolite = Metabolite()
assert metabolite.id == ""
assert metabolite.name == ""
assert metabolite.charge == 0
assert metabolite.compartment == ""
assert metabolite.annotation == set()
def test_map_metabolites(self, database):
metabolite = Metabolite("m1")
metabolite.annotation.add(
Annotation(identifier="MNXM2", collection="metanetx.chemical"))
metabolite.annotation.add(
Annotation(identifier="MNXM215", collection="metanetx.chemical"))
assert map_by_annotation(database, metabolite) == set([1, 2])
def setup_complete_model(self):
self.model = Model("model")
# Setup reaction1
self.metabolite = Metabolite("m1")
self.reaction = Reaction("r1")
self.gene = Gene("g1")
self.reaction.add_child(self.gene)
self.model.add_genes((self.gene,))
self.reaction.add_metabolites({self.metabolite: -1})
self.model.add_reactions((self.reaction,))
# Setup reaction2
self.metabolite2 = Metabolite("m2")
self.reaction2 = Reaction("r2")
self.gene2 = Gene("g2")
self.genegroup = GeneGroup()
self.genegroup.add_child(self.gene2)
self.reaction2.add_child(self.genegroup)
self.model.add_genes((self.gene2,))
self.reaction2.add_metabolites({self.metabolite2: 1})
self.model.add_reactions((self.reaction2,))
# Setup evidences
self.evidence = Evidence(assertion="Catalyzes")
self.evidence.set_entity(self.gene)
self.evidence.set_target(self.reaction)
self.reference = Reference()
self.model.add_reference(self.reference)
self.evidence.add_reference(self.reference)
self.model.add_evidence(self.evidence)
# Setup test case
self.testcase = ModelTest()
reaction_setting = ReactionSetting(self.reaction, 1000., -1000., 0.)
gene_setting = GeneSetting(gene=self.gene2, activity=False)
outcome = Outcome(self.reaction2, 0., "greater")
self.testcase.add_outcome(outcome)
self.testcase.add_setting(gene_setting)
self.testcase.add_setting(reaction_setting)
self.model.add_test(self.testcase)
self.reference2 = Reference()
self.model.add_reference(self.reference2)
self.testcase.add_reference(self.reference2)
self.model.setup_tables()
def test_add_metabolites(self):
model = Model()
metabolite = Metabolite("m1", compartment="c")
model.gem_add_metabolites((metabolite,))
assert metabolite in model.metabolites
assert metabolite in model.QtMetaboliteTable.get_items()
assert "c" in model.gem_compartments
def test_annotations(self):
# Setup metabolites
met1 = Metabolite("met1")
annotation1 = Annotation(collection="chebi", identifier="test1")
annotation2 = Annotation(collection="chebi", identifier="test2")
met1.annotation.update((annotation1, annotation2))
met2 = Metabolite("met2")
annotation3 = Annotation(collection="chebi", identifier="test3")
met2.annotation.add(annotation3)
# Run
mapping = get_annotation_to_item_map([met1, met2])
assert mapping[annotation1] == [met1]
assert mapping[annotation2] == [met1]
assert mapping[annotation3] == [met2]
def test_map_metabolite_by_annotation(self, database, progress):
model = Model()
met1 = Metabolite("m1")
model.add_metabolites([met1])
met1.annotation.add(
Annotation(identifier="MNXM2", collection="metanetx.chemical"))
update_metabolite_database_mapping(database, model, progress)
assert model.database_mapping[met1] == 1
def test_no_update_for_contradicting_formulae(self):
""" Check that the formula is not updated if there are
multiple reactions and the derived formula of those
are contradicting """
react = Reaction("rea") # CO2 expected
met1 = Metabolite("met1", formula="C7H8O2")
met2 = Metabolite("met2", formula="C8H8O4")
met3 = Metabolite("met3")
react.add_metabolites({met1: 1, met3: 1, met2: -1})
react1 = Reaction("rea2") # H2O expected
met4 = Metabolite("met4", formula="H2O")
react1.add_metabolites({met3: -1, met4: 1})
result = update_formula_from_neighborhood(met3)
assert result is False
assert not met3.formula
def setup_items(self):
self.parent = QWidget()
self.widget = StoichiometryDisplayWidget(self.parent)
self.test_met_id = "test_id"
self.test_react_id = "test_id2"
self.test_stoich = -1.5
self.metabolite = Metabolite(id=self.test_met_id)
self.reaction = Reaction(id=self.test_react_id)
self.reaction.add_metabolites({self.metabolite: self.test_stoich})
self.model = Model("test")
def test_valid_input(self):
# Note: The compartment needs to be set as valid input
metabolite = Metabolite(id="test", compartment="m")
model = Model()
widget = MetaboliteAttributesDisplayWidget()
widget.set_item(metabolite, model)
assert widget.valid_inputs() is True
widget.iDLineEdit.clear()
assert widget.valid_inputs() is False
def test_get_item_to_row_mapping(self):
self.table.appendRow(self.expected_items)
additional_item = Metabolite("test")
self.table.appendRow(
[LinkedItem("test", additional_item),
LinkedItem("None", None)])
assert self.table.rowCount() == 2
assert self.table.get_item_to_row_mapping() == {
additional_item: 1,
self.item1_obj: 0
}
def test_no_update_if_boundary(self):
""" Check that formula is not updated when metabolite is
part of a boundary reaction """
react = Reaction("rea")
met1 = Metabolite("met1")
react.add_metabolites({met1: -1})
result = update_formula_from_neighborhood(met1)
assert result is False
assert not met1.formula
