def test_setting_resetting_boundaries(self):
gene = Gene()
reaction = Reaction(lower_bound=-1000., upper_bound=1000.)
reaction.add_child(gene)
gene.functional = True
condition = GeneSetting(gene, False)
assert gene.functional is True
assert reaction.upper_bound == 1000.
assert reaction.lower_bound == -1000.
condition.do()
assert gene.functional is False
assert reaction.upper_bound == 0.
assert reaction.lower_bound == 0.
condition.undo()
assert gene.functional is True
assert reaction.upper_bound == 1000.
assert reaction.lower_bound == -1000.
# Check that calling undo second time does not change value
condition.undo()
assert gene.functional is True
assert reaction.upper_bound == 1000.
assert reaction.lower_bound == -1000.
def test_reaction_is_disabled_with_disabled_gene_only(self):
reaction = Reaction()
gene = Gene()
gene.functional = False
reaction.add_child(gene)
assert reaction.functional is False
def test_reaction_is_disabled_with_gene_in_and_group(self):
reaction = Reaction()
genegroup = GeneGroup(type="and")
reaction.add_child(genegroup)
gene = Gene()
genegroup.add_child(gene)
gene.functional = False
assert reaction.functional is False
def test_get_items(self):
evidence1 = Evidence(entity=Gene("g1"))
evidence2 = Evidence(entity=Gene("g2"))
self.table.update_row_from_item(evidence1)
self.table.update_row_from_item(evidence2)
items = self.table.get_items()
assert len(items) == 2
assert items[0] is evidence1
assert items[1] is evidence2
def test_nested_genegroups_with_gene(self):
genegroup1 = GeneGroup()
genegroup2 = GeneGroup()
gene = Gene("gene id")
genegroup1.add_child(genegroup2)
genegroup2.add_child(gene)
assert genegroup1.gem_reaction_rule == gene.id
gene2 = Gene("gene2 id")
genegroup2.add_child(gene2)
assert genegroup1.gem_reaction_rule == "("+gene.id+" and "+gene2.id+")"
def test_two_genes_one_gene_group(self, reaction):
gene1 = Gene("test 1")
gene2 = Gene("test 2")
group = GeneGroup(type="and")
group.add_child(gene1)
group.add_child(gene2)
reaction.add_child(group)
assert reaction.gene_reaction_rule == gene1.id + " and " + gene2.id
group.type = "or"
assert reaction.gene_reaction_rule == gene1.id + " or " + gene2.id
def test_multiple_nested(self):
reaction = Reaction()
parent = reaction
for _ in range(5):
genegroup = GeneGroup()
parent.add_child(genegroup)
parent = genegroup
gene = Gene("Gene id")
parent.add_child(gene)
assert reaction.gene_reaction_rule == gene.id
gene2 = Gene("Gene 2")
parent.add_child(gene2)
assert reaction.gene_reaction_rule == "(" + gene.id+" and "+gene2.id+")"
def test_gene_and_gene_group(self):
gene1 = Gene("gene 1")
gene2 = Gene("gene 2")
gene3 = Gene("gene 3")
genegroup1 = GeneGroup(type="and")
genegroup2 = GeneGroup(type="or")
reaction = Reaction()
reaction.add_child(genegroup1)
genegroup1.add_child(gene1)
genegroup1.add_child(genegroup2)
genegroup2.add_child(gene2)
assert reaction.gene_reaction_rule == gene1.id+" and "+gene2.id
genegroup2.add_child(gene3)
assert reaction.gene_reaction_rule == gene1.id+" and ("+gene2.id+" or "+gene3.id+")"
def test_default_values(self):
gene = Gene()
assert gene.id == ""
assert gene.name == ""
assert gene.genome == ""
assert gene.annotation == set()
assert gene.functional is True
def test_gene_addition(self):
reaction = Reaction("reaction_id")
gene = Gene("gene_id")
reaction.add_child(gene)
assert gene in reaction.genes
assert reaction in gene.reactions
def test_full_example(self):
""" Test that a minimal evidence example is parsed correctly """
xml_tree = ET.fromstring(full_evidence)
model = Model()
reaction = Reaction("Test")
target_item = Gene("target_id")
reference = Reference("ref_id")
model.add_reaction(reaction)
model.add_gene(target_item)
model.add_reference(reference)
assert len(model.all_evidences) == 0
assert len(reaction.evidences) == 0
parse_evidences_from_xml(xml_tree, model)
assert len(model.all_evidences) == 1
assert len(reaction.evidences) == 1
evidence = list(reaction.evidences)[0]
assert evidence.entity is reaction
assert evidence.target is target_item
assert evidence.assertion == "Catalyzed by"
assert evidence.eco == "ECO:0000000"
assert len(evidence.references) == 1
assert list(evidence.references)[0] is reference
assert evidence.comment == "test comment"
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 save_state(self):
genes_added = 0
for gene_id in self.plainTextEdit.toPlainText().split("\n"):
try:
gene = self.model.genes.get_by_id(gene_id.strip())
except KeyError:
if self.comboBox_missing.currentText() == "Add":
gene = Gene(gene_id.strip())
self.model.add_gene(gene)
self.model.QtGeneTable.update_row_from_item(gene)
genes_added += 1
else:
continue
# Generate an evidence item for each gene
evidence = Evidence(entity=gene,
eco=self.evidence.eco,
assertion=self.evidence.assertion,
comment=self.evidence.comment,
target=self.evidence.target)
# Add reference
for reference in self.evidence.references:
evidence.add_reference(reference)
# Add evidence to model
self.model.all_evidences[evidence.internal_id] = evidence
if genes_added:
QMessageBox(self).information(
self, "Genes added",
"{} new genes added!".format(str(genes_added)))
def test_setting_item(self):
gene = Gene("test_id", "name", "genome")
model = Model()
widget = GeneAttributesDisplayWidget()
# Test prestate
assert widget.iDLineEdit.text() == ""
assert widget.nameLineEdit.text() == ""
assert widget.genomeLineEdit.text() == ""
widget.set_item(gene, model)
assert widget.iDLineEdit.text() == gene.id
assert widget.nameLineEdit.text() == gene.name
assert widget.genomeLineEdit.text() == gene.genome
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.genomeLineEdit.text() == ""
assert widget.valid_inputs() is False
assert widget.content_changed is False
def _parse_gene_xml_tree(node, reaction, genes):
""" Parse the gene tree as saved in an sbml file with fbc package """
# Check that
if node.tag == fbc_geneProductAssociation:
top_level_child = _parse_gene_xml_tree(node.getchildren()[0], reaction,
genes)
reaction.add_child(top_level_child)
elif node.tag in (fbc_and, fbc_or):
gene_group = GeneGroup(id=node.get(ge_id),
type="and" if node.tag == fbc_and else "or")
for child in node.getchildren():
child_object = _parse_gene_xml_tree(child, reaction, genes)
gene_group.add_child(child_object)
return gene_group
elif node.tag == fbc_geneProductRef:
gene_id = clip(node.attrib[fbc_geneProduct], "G_")
# Resubstitute dots
gene_id = gene_id.replace(SBML_DOT, ".")
try:
return genes.get_by_id(gene_id)
except KeyError:
new_gene = Gene(id=gene_id, name=gene_id)
genes.append(new_gene)
warn("Gene {0} not found in gene list. New gene created!".format(
gene_id))
return new_gene
else:
raise TypeError("Unknown node.tag {0} at line {1}".format(
node.tag, node.sourceline))
def test_copy_evidence(self):
entity = Reaction()
target = Gene()
eco = "ECO:000000"
assertion = "Presence"
comment = "test comment"
reference = Reference()
evidence = Evidence(entity=entity,
eco=eco,
assertion=assertion,
comment=comment,
target=target)
evidence.add_reference(reference)
# Create copy
copy = evidence.copy()
# Check the correctness of the copy
assert evidence.entity is copy.entity
assert evidence.target is copy.target
assert evidence.eco == copy.eco
assert evidence.assertion == copy.assertion
assert evidence.comment == copy.comment
assert evidence.references == copy.references
assert evidence.references is not copy.references
# Check that the copy is not linked
assert copy not in entity.evidences
assert copy not in reference.linked_items
assert copy not in target.evidences
def addItemSlot(self):
new_gene = Gene()
dialog = GeneEditDialog(self, new_gene, self.model)
status = dialog.exec_()
if status:
self.model.genes.append(new_gene)
self.dataTable.update_row_from_item(new_gene)
def test_evidence_init(self):
entity = Reaction()
target = Gene("id2")
eco = "ECO:000000"
assertion = "Presence"
comment = "test comment"
reference = Reference()
evidence = Evidence(entity=entity,
eco=eco,
assertion=assertion,
comment=comment,
target=target)
evidence.add_reference(reference)
# Check proper linking
assert evidence.entity is entity
assert evidence in entity.evidences
assert evidence.target is target
assert evidence in target.evidences
# Check attributes
assert evidence.assertion == assertion
assert evidence.eco == eco
assert evidence.comment == comment
# Check id is set
assert type(evidence.internal_id) is str
assert evidence.internal_id != ""
# Check the references
assert reference in evidence.references
assert evidence in reference.linked_items
def test_execute_action_deletion(self):
action = "deletion"
# Delete Gene
target = Mock()
gene = Gene()
self.widget.execute_action((target, action, gene))
target.remove_child.assert_called_once_with(gene)
# Delete GeneGroup
target = Mock()
gene_group = GeneGroup()
gene_group.delete_children = Mock()
self.widget.execute_action((target, action, gene_group))
target.remove_child.assert_called_once_with(gene_group)
assert gene_group.delete_children.called is False
# Check that children are deleted if genegroup has only one parent
target = Mock()
gene_group = GeneGroup()
gene_group.add_parent(self.reaction)
gene_group.delete_children = Mock()
self.widget.execute_action((target, action, gene_group))
target.remove_child.assert_called_once_with(gene_group)
assert gene_group.delete_children.called is True
def test_gene_deletion(self):
receiver = MockSlot()
gene = Gene("Test id")
self.widget.changed.connect(receiver.slot)
self.reaction.add_child(gene)
self.widget.set_item(self.reaction, self.model)
# Check prior state
assert len(self.widget.cached_actions) == 0
assert self.widget.geneTable.rowCount() == 1
assert gene in self.reaction._children
# Action
self.widget.geneView.setCurrentIndex(
self.widget.geneTable.item(0).index())
self.widget.delete_item()
# Check emission of the changed signal
assert receiver.called is True
assert receiver.last_caller is self.widget
# Check cached actions
assert len(self.widget.cached_actions) == 1
action = self.widget.cached_actions[0]
assert action[0] is self.reaction
assert action[1] == "deletion"
assert action[2] is gene
# Check the table item
assert self.widget.geneTable.rowCount() == 0
# Check that child is still present
assert gene in self.reaction._children
def test_add_gene(self):
receiver = MockSlot()
self.widget.changed.connect(receiver.slot)
self.widget.set_item(self.reaction, self.model)
# Check prior state
assert len(self.widget.cached_actions) == 0
assert self.widget.geneTable.rowCount() == 0
assert len(self.reaction._children) == 0
# Action
new_gene_id = "test id"
new_gene = Gene(new_gene_id)
self.widget.add_gene(new_gene)
# Check emission of the changed signal
assert receiver.called is True
assert receiver.last_caller is self.widget
# Check cached actions
assert len(self.widget.cached_actions) == 1
action = self.widget.cached_actions[0]
assert action[0] is self.reaction
assert action[1] == "addition"
assert action[2] is new_gene
# Check the table item
assert self.widget.geneTable.rowCount() == 1
assert self.widget.geneTable.item(0, 0).text() == new_gene_id
assert self.widget.geneTable.item(0, 0).link is new_gene
# Check that no children has been added
assert len(self.reaction._children) == 0
def test_addition_emits_changed(self):
parent = QWidget()
widget = GeneSettingDisplayWidget(parent)
test = ModelTest()
gene = Gene()
setting = GeneSetting(gene, False)
model = Model()
test.add_setting(setting)
widget.set_item(test, model)
detector = Mock()
widget.changed.connect(detector.test)
widget.dataTable.update_row_from_item(GeneSetting(Gene(), True))
assert detector.test.called is True
assert widget.content_changed is True
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 __init__(self, model, parent=None):
super(BatchEvidenceDialog, self).__init__(parent)
self.setupUi(self)
self.model = model
self.evidence = Evidence(entity=Gene())
self.accepted.connect(self.save_state)
self.pushButton.clicked.connect(self.edit_evidence)
def test_removal_of_nested_or_groups(self):
reaction = Reaction("r1")
gene_group1 = GeneGroup(type="or")
gene_group2 = GeneGroup(type="or")
gene1 = Gene("g1")
gene2 = Gene("g2")
gene3 = Gene("g3")
gene_group1.add_child(gene1)
for x in (gene2, gene3):
gene_group2.add_child(x)
gene_group1.add_child(gene_group2)
reaction.add_child(gene_group1)
assert reaction.genes == set([gene1, gene2, gene3])
prune_gene_tree(reaction)
assert reaction.genes == set([gene1, gene2, gene3])
assert not gene_group2._children
assert not gene_group2._parents
def setup_items(self):
self.table = GeneTable()
self.test_id = "Test id"
self.test_name = "test_name"
self.test_genome = "test_genome"
self.gene = Gene(id=self.test_id,
name=self.test_name,
genome=self.test_genome)
def setup_items(self):
self.test_id = "test.id"
self.test_name = "test_name"
self.test_genome = "test_genome"
self.gene = Gene(id=self.test_id,
name=self.test_name,
genome=self.test_genome)
self.model = Model("Test_model")
self.model.genes.append(self.gene)
def patch_gene_selection_accepted(self, monkeypatch):
gene = Gene("test")
monkeypatch.setattr(
"GEMEditor.model.selection.gene.GeneSelectionDialog.exec_",
Mock(return_value=True))
monkeypatch.setattr(
"GEMEditor.model.selection.gene.GeneSelectionDialog.selected_items",
Mock(return_value=[gene]))
return gene
def patch_gene_selection_accepted(self, monkeypatch):
gene = Gene()
monkeypatch.setattr(
"GEMEditor.dialogs.evidence.GeneSelectionDialog",
Mock(return_value=Mock(
**{
"exec_": Mock(return_value=True),
"selected_items": Mock(return_value=[gene])
})))
return gene
def test_valid_input(self):
gene = Gene(id="test")
model = Model()
widget = GeneAttributesDisplayWidget()
widget.set_item(gene, model)
assert widget.valid_inputs() is True
widget.iDLineEdit.clear()
assert widget.valid_inputs() is False