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 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_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
class TestAssertionCatalyzingReaction: @pytest.fixture(autouse=True) def setup_items(self): self.reaction = Reaction("r1") self.gene = Gene("g1") self.evidence = Evidence(entity=self.gene, target=self.reaction, assertion="Catalyzing reaction") def test_valid_if_gene_in_reaction(self): self.reaction.add_child(self.gene) assert self.evidence.is_valid() is True def test_invalid_if_gene_not_in_reaction(self): assert self.evidence.is_valid() is False def test_gene_needed(self): evidence = Evidence(entity=self.gene, assertion="Catalyzing reaction") assert evidence.is_valid() is None def test_reaction_needed(self): evidence = Evidence(target=self.reaction, assertion="Catalyzing reaction") assert evidence.is_valid() is None def test_fix_gene_added(self): assert self.gene not in self.reaction.genes status = self.evidence.fix() assert status is True assert self.gene in self.reaction.genes
def complete_evidence(self): evidence = Evidence(entity=self.entity, assertion=self.assertion, target=self.target, eco=self.eco, comment=self.comment) evidence.add_reference(self.reference) return evidence
def test_sorting_erroneous(self): evidence = Evidence() assert evidence.is_valid() is None conflicts, failing, errors = sort_evidences([evidence]) assert not conflicts assert not failing assert evidence in errors
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 add_item(self): new_evidence = Evidence() # Set base_item externally in order to avoid linkage from base_item to # evidence new_evidence.entity = self.item dialog = EditEvidenceDialog(self.window(), self.model, evidence=new_evidence) if dialog.exec_(): self.dataTable.update_row_from_item(new_evidence)
def test_saving_changes(self): reaction = Reaction() reference = Reference() model = Model() evidence = Evidence(entity=reaction) evidence.add_reference(reference) widget = EvidenceDisplayWidget() model.all_evidences[evidence.internal_id] = evidence assert evidence in reaction.evidences assert evidence.internal_id in model.all_evidences assert reference in evidence.references # Set reaction and model to widget widget.set_item(reaction, model) assert widget.dataTable.rowCount() == 1 # Remove evidence copy from data table widget.dataTable.setRowCount(0) # Setup new evidence item new_evidence = Evidence() new_evidence.assertion = "Catalyzed by" new_evidence.entity = reaction reference = Reference() new_evidence.add_reference(reference, reciprocal=False) # Test the setup i.e. that items are only linked in a one way (evidence -> item) fashion assert new_evidence not in reaction.evidences assert new_evidence not in reference.linked_items # Add new reference to widget table widget.dataTable.update_row_from_item(new_evidence) assert widget.dataTable.rowCount() == 1 assert widget.dataTable.item(0).link is new_evidence # Action - Save evidences widget.save_state() # Check that old instance is detached from all links assert evidence not in reaction.evidences assert len(evidence.references) == 0 # Old evidence still kept alive by this test old_id = evidence.internal_id assert old_id in model.all_evidences evidence = None gc.collect() assert old_id not in model.all_evidences # Check that new evidence is linked properly assert new_evidence in reaction.evidences assert new_evidence.internal_id in model.all_evidences
def test_set_item(self): widget = EvidenceDisplayWidget() evidence = Evidence() reaction = Reaction() model = Model() evidence.set_entity(reaction) widget.set_item(reaction, model) # Check that a copy of the evidence has been added to the table assert widget.dataTable.rowCount() == 1 assert widget.dataTable.item(0).link is not evidence assert widget.dataTable.item( 0).link.internal_id == evidence.internal_id
def test_sorting_failing(self): reaction = Reaction() gene = Gene() evidence = Evidence(entity=gene, target=reaction, assertion="Catalyzing reaction") assert evidence.is_valid() is False conflicts, failing, errors = sort_evidences([evidence]) assert not conflicts assert [evidence] in failing assert not errors
def test_equality(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) assert evidence.copy() == evidence
def test_sorting_valid(self): reaction = Reaction() gene = Gene() evidence = Evidence(entity=gene, target=reaction, assertion="Catalyzing reaction") reaction.add_child(gene) assert evidence.is_valid() is True conflicts, failing, errors = sort_evidences([evidence]) assert not conflicts assert not failing assert not errors
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)
class TestAssertionIrreversible: @pytest.fixture(autouse=True) def setup_items(self): self.reaction = Reaction("r1") self.evidence = Evidence(entity=self.reaction, assertion="Irreversible") def test_not_valid_if_reaction_reversible(self): self.reaction.lower_bound = -1000. self.reaction.upper_bound = 1000. assert self.evidence.is_valid() is False def test_valid_if_irreversible(self): self.reaction.lower_bound = 0. self.reaction.upper_bound = 1000. assert self.evidence.is_valid() is True self.reaction.lower_bound = -1000. self.reaction.upper_bound = 0. assert self.evidence.is_valid() is True def test_reaction_needed(self): evidence = Evidence(assertion="Irreversible") assert evidence.is_valid() is None def test_fix_reaction(self): self.reaction.lower_bound = -1000. self.reaction.upper_bound = 1000. status = self.evidence.fix() assert status is True assert self.reaction.lower_bound == 0. assert self.reaction.upper_bound == 1000. def test_fix_nonstandard_boundary_kept(self): self.reaction.lower_bound = -1000. self.reaction.upper_bound = 500. status = self.evidence.fix() assert status is True assert self.reaction.lower_bound == 0. assert self.reaction.upper_bound == 500.
def test_entity_needed(self): evidence = Evidence(assertion="Localization") assert evidence.is_valid() is None evidence.set_entity(self.gene) assert evidence.is_valid() is None evidence.set_target(self.compartment) assert evidence.is_valid() is not None
def test_changes_are_saved(self): dialog = self.dialog evidence = Evidence(entity=self.entity) dialog.set_evidence(evidence, None) # Generate new values assert self.dialog.combo_assertion.currentIndex() == -1 new_assertion = self.dialog.combo_assertion.itemText(1) new_target = Reaction("r2") new_comment = "Comment" new_eco = "ECO:0000000" # Set new values self.dialog.set_assertion(new_assertion) self.dialog.set_eco(new_eco) self.dialog.set_target(new_target) self.dialog.set_comment(new_comment) self.dialog.referenceWidget.dataTable.update_row_from_item( self.reference) # Action self.dialog.save_state() # Check updates assert evidence.target is new_target assert evidence in new_target.evidences assert evidence.comment == new_comment assert evidence.eco == new_eco assert evidence.assertion == new_assertion assert self.reference in evidence.references assert evidence in self.reference.linked_items
def test_changed_triggered_deletion(self): widget = EvidenceDisplayWidget() evidence = Evidence() reaction = Reaction() model = Model() evidence.set_entity(reaction) widget.set_item(reaction, model) mock = Mock() widget.changed.connect(mock.test) assert mock.test.called is False assert widget.dataTable.rowCount() == 1 widget.dataView.selectRow(0) QtTest.QTest.mouseClick(widget.delete_button, QtCore.Qt.LeftButton) assert widget.dataTable.rowCount() == 0 assert mock.test.called is True
def test_changed_triggered_edition(self): widget = EvidenceDisplayWidget() evidence = Evidence() reaction = Reaction() model = Model() evidence.set_entity(reaction) reaction.add_evidence(evidence) widget.set_item(reaction, model) mock = Mock() widget.changed.connect(mock.test) assert mock.test.called is False assert widget.dataTable.rowCount() == 1 widget.dataView.selectRow(0) widget.edit_item() assert widget.dataTable.rowCount() == 1 assert mock.test.called 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_inequality(self, attribute, new_value): 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) new_copy = evidence.copy() setattr(new_copy, attribute, new_value) assert new_copy != evidence assert not new_copy == evidence
def test_inequality_reference(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) new_copy = evidence.copy() new_copy.remove_all_references() assert new_copy != evidence assert not new_copy == evidence
def setup_empty_dialog(self): self.model = Model() self.evidence = Evidence() self.entity = Gene("g1") self.assertion = "Catalyzing reaction" self.target = Reaction("r1") self.eco = "ECO:0000250" self.comment = "Similarity to XY" self.reference = Reference() self.dialog = EditEvidenceDialog()
def parse_evidences_from_xml(model_node, model, progress=None): list_of_evidences_node = model_node.find(ge_listOfEvidences) if list_of_evidences_node is None: return elif progress is None: pass elif not progress.wasCanceled(): progress.setLabelText("Reading evidences...") progress.setRange(0, len(list_of_evidences_node)) else: return for i, evidence_node in enumerate( list_of_evidences_node.iterfind(ge_evidence)): if progress is None: pass elif not progress.wasCanceled(): progress.setValue(i) QApplication.processEvents() else: return new_evidence = Evidence(internal_id=evidence_node.get("id"), assertion=evidence_node.get("assertion"), comment=evidence_node.get("comment"), eco=evidence_node.get("eco")) entity_id = evidence_node.get("entity_id") entity_type = evidence_node.get("entity_type") entity = get_item_from_model(entity_type, entity_id, model) new_evidence.set_entity(entity) # Add target item if present target_id = evidence_node.get("target_id") target_type = evidence_node.get("target_type") if target_id and target_type: target = get_item_from_model(target_type, target_id, model) new_evidence.set_target(target) # Add all references if present reference_list_node = evidence_node.find(ge_listOfReferenceLinks) if reference_list_node is not None: for refLink_node in reference_list_node.iterfind(ge_referenceLink): new_evidence.add_reference( model.references[refLink_node.get("id")]) model.all_evidences[new_evidence.internal_id] = new_evidence
def setup_evidence(self): self.reaction = Reaction("r_id") self.gene = Gene("g_id") self.target = Gene("g_id2") self.model = Model("test id") self.reference = Reference() self.model.add_gene(self.gene) self.model.add_gene(self.target) self.model.add_reactions([self.reaction]) self.model.add_reference(self.reference) # Set type self.assertion = "Catalyzed by" self.eco = "ECO:0000000" self.comment = "test" self.evidence = Evidence(entity=self.reaction, eco=self.eco, assertion=self.assertion, comment=self.comment, target=self.target) self.evidence.add_reference(self.reference) self.model.all_evidences[self.evidence.internal_id] = self.evidence self.root = Element("root", nsmap={None: ge_ns})
class TestAssertionPresent: @pytest.fixture(autouse=True) def setup_items(self): self.reaction = Reaction("r1") self.evidence = Evidence(entity=self.reaction, assertion="Present") def test_valid_if_reaction_is_active(self): self.reaction.lower_bound = -1000. self.reaction.upper_bound = 0. assert self.evidence.is_valid() is True self.reaction.upper_bound = 1000. assert self.evidence.is_valid() is True self.reaction.lower_bound = 0. assert self.evidence.is_valid() is True def test_invalid_if_reaction_not_active(self): self.reaction.lower_bound = 0. self.reaction.upper_bound = 0. assert self.evidence.is_valid() is False def test_valid_if_metabolite_entity(self): self.evidence.set_entity(Metabolite("m1")) assert self.evidence.is_valid() is True def test_entity_needed(self): evidence = Evidence() assert evidence.is_valid() is None def test_fixing_not_implemented(self): self.reaction.lower_bound = 0 self.reaction.upper_bound = 0 self.evidence.fix() assert self.reaction.lower_bound == 0. assert self.reaction.upper_bound == 0.
def test_row_from_item(self): gene1 = Gene("test id1") reaction1 = Reaction("react1") evidence = Evidence(entity=gene1, target=reaction1, assertion="Catalyze reaction", eco="ECO:001") return_values = self.table.row_from_item(evidence) assert len(return_values) == len(self.table.header) assert isinstance(return_values[0], LinkedItem) assert return_values[0].link is evidence assert return_values[0].text() == gene1.id assert return_values[1].text() == evidence.assertion assert return_values[2].text() == evidence.target.id assert return_values[3].text() == evidence.eco assert return_values[4].text() == evidence.comment assert return_values[5].text() == ""
def test_override_entity(self): entity = Reaction() eco = "ECO:000000" assertion = "Presence" comment = "test comment" reference = Reference() evidence = Evidence(entity=entity, eco=eco, assertion=assertion, comment=comment) evidence.add_reference(reference) new_reaction = Reaction() evidence.set_entity(new_reaction) # Check disconnection of old reaction assert evidence.entity is new_reaction assert evidence not in entity.evidences
def test_sorting_conflicting(self): reaction = Reaction() gene = Gene() reaction.add_child(gene) evidence1 = Evidence(entity=gene, target=reaction, assertion="Catalyzing reaction") evidence2 = Evidence(entity=gene, target=reaction, assertion="Not catalyzing reaction") assert evidence1.is_valid() is True assert evidence2.is_valid() is False conflicts, failing, errors = sort_evidences([evidence1, evidence2]) assert len(conflicts) == 1 assert set(conflicts[0]) == set([evidence1, evidence2]) assert not failing assert not errors