def test_handle_relationships(self): # Tests the insertion, update and deletion of relationships between CV terms # Populate the database with essentials other_dbxref = general.DbxRef(db_id=self.default_db.db_id, accession="otheraccession") self.client.add_and_flush(other_dbxref) other_cvterm = cv.CvTerm(cv_id=self.default_cv.cv_id, dbxref_id=other_dbxref.dbxref_id, name="otherterm") self.client.add_and_flush(other_cvterm) default_id = ontology.create_dbxref(self.default_db.name, self.default_dbxref.accession) other_id = ontology.create_dbxref(self.default_db.name, other_dbxref.accession) all_cvterms = {default_id: self.default_cvterm, other_id: other_cvterm} # Check that an ontology term without relationships will not create a cvterm_relationship entry term = pronto.Term("defaultdb:defaultaccession") first_relationships = self.client._handle_relationships(term, self.default_cvterm, all_cvterms) self.assertEqual(len(first_relationships), 0) # Insert a relationship term.relations = {pronto.Relationship("part_of"): [pronto.Term(other_id, other_cvterm.name)]} second_relationships = self.client._handle_relationships(term, self.default_cvterm, all_cvterms) self.assertEqual(len(second_relationships), 1) self.assertIsNotNone(second_relationships[0].cvterm_relationship_id) self.assertEqual(second_relationships[0].subject_id, self.default_cvterm.cvterm_id) self.assertEqual(second_relationships[0].object_id, other_cvterm.cvterm_id) self.assertEqual(second_relationships[0].type_id, self.client._relationship_terms["part_of"].cvterm_id) # Insert a new relationship between the same terms term.relations.clear() term.relations = {pronto.Relationship("is_a"): [pronto.Term(other_id, other_cvterm.name)]} third_relationships = self.client._handle_relationships(term, self.default_cvterm, all_cvterms) self.assertEqual(len(third_relationships), 1) self.assertEqual(third_relationships[0].type_id, self.client._relationship_terms["is_a"].cvterm_id)
def test_create_cvterm_entry(self): # Checks if an ontology term is correctly converted into a CV term entry term = pronto.Term(id="testid", name="testname", desc="testdescription", other={"is_obsolete": ["True"]}) cvterm_entry = ontology.create_cvterm_entry(term, 100, 200) self.assertEqual(cvterm_entry, cv.CvTerm(cv_id=100, dbxref_id=200, name="testname", definition="testdescription", is_obsolete=1)) term = pronto.Term(id="otherid", name="othername", other={"is_obsolete": ["False"]}) cvterm_entry = ontology.create_cvterm_entry(term, 10, 20) self.assertEqual(cvterm_entry, cv.CvTerm(cv_id=10, dbxref_id=20, name="othername", is_obsolete=0))
def test_filter_ontology(self): # Checks the filtering of ontology terms by a database authority ont = pronto.Ontology() ont.include(pronto.Term("test:001:abc")) ont.include(pronto.Term("test:002")) ont.include(pronto.Term("other:001")) filtered_ontology = ontology.filter_ontology_by_db(ont, "test") self.assertEqual(len(filtered_ontology), 2) self.assertIn("test:001:abc", filtered_ontology) self.assertEqual(filtered_ontology["test:002"].id, "test:002")
def test_are_terms_equivalent(self): term1_a = pronto.Term(id='term1') term1_b = pronto.Term(id='term1') term2 = pronto.Term(id='term2') self.assertFalse(term1_a == term1_b) self.assertTrue( wc_utils.util.ontology.are_terms_equivalent(term1_a, term1_b)) self.assertTrue( wc_utils.util.ontology.are_terms_equivalent(term1_b, term1_a)) self.assertFalse( wc_utils.util.ontology.are_terms_equivalent(term1_a, term2)) self.assertFalse( wc_utils.util.ontology.are_terms_equivalent(term2, term1_a))
def test_handle_cross_references(self): # Tests the insertion, update and deletion of cross references for CV terms # Check that an ontology term without cross references will not create a cvterm_dbxref entry term = pronto.Term("defaultdb:defaultaccession") first_crossrefs = self.client._handle_cross_references(term, self.default_cvterm) self.assertEqual(len(first_crossrefs), 0) # Insert a further cross reference to the same database term.other = {"alt_id": ["defaultdb:furtheraccession"]} second_crossrefs = self.client._handle_cross_references(term, self.default_cvterm) self.assertEqual(len(second_crossrefs), 1) corresponding_dbxref = self.client.find_or_insert(general.DbxRef, db_id=self.default_db.db_id, accession="furtheraccession") self.assertEqual(corresponding_dbxref.dbxref_id, second_crossrefs[0].dbxref_id) # Insert a cross reference to another database term.other = {"xref": ["otherdb:otheraccession 'with comment'"]} third_crossrefs = self.client._handle_cross_references(term, self.default_cvterm) self.assertEqual(len(third_crossrefs), 1) other_db = self.client.query_table(general.Db, name="otherdb").first() self.assertIsNotNone(other_db) corresponding_dbxref = self.client.find_or_insert(general.DbxRef, db_id=other_db.db_id, accession="otheraccession") self.assertEqual(corresponding_dbxref.dbxref_id, third_crossrefs[0].dbxref_id)
def test_handle_synonyms(self): # Tests the insertion, update and deletion of synonyms of CV terms # Check that an ontology term without synonym will not create a cvtermsynonym entry term = pronto.Term("defaultdb:defaultaccession") first_synonyms = self.client._handle_synonyms(term, self.default_cvterm) self.assertEqual(len(first_synonyms), 0) # Insert a synonym term.synonyms = {pronto.Synonym("another_name", "EXACT")} second_synonyms = self.client._handle_synonyms(term, self.default_cvterm) self.assertEqual(len(second_synonyms), 1) self.assertIsNotNone(second_synonyms[0].cvtermsynonym_id) self.assertEqual(second_synonyms[0].synonym, "another_name") self.assertEqual(second_synonyms[0].type_id, self.client._synonym_type_terms["exact"].cvterm_id) # Try to insert an existing synonym with changed scope, and check that this updates the existing entry term.synonyms = {pronto.Synonym("another_name", "NARROW")} third_synonyms = self.client._handle_synonyms(term, self.default_cvterm) self.assertEqual(len(third_synonyms), 1) self.assertEqual(third_synonyms[0].cvtermsynonym_id, second_synonyms[0].cvtermsynonym_id) self.assertEqual(third_synonyms[0].type_id, self.client._synonym_type_terms["narrow"].cvterm_id) # Insert another synonym term.synonyms.add(pronto.Synonym("yet_another_name", "BROAD")) fourth_synonyms = self.client._handle_synonyms(term, self.default_cvterm) self.assertEqual(len(fourth_synonyms), 2)
def _handle_typedef(self, typedef: pronto.Relationship, default_db: general.Db, default_cv: cv.Cv): """Inserts CV terms for relationship ontology terms (so-called "typedefs")""" # Check if a relationship CV term with this name already exists cvterm_entry = self.query_table(cv.CvTerm, name=typedef.obo_name, is_relationshiptype=1).first() if not cvterm_entry: # Create dbxref dbxref = create_dbxref(default_db.name, typedef.obo_name) term = pronto.Term(dbxref, typedef.obo_name) dbxref_entry = self._handle_dbxref(term, default_db) # Create CV term cvterm_entry = cv.CvTerm(cv_id=default_cv.cv_id, dbxref_id=dbxref_entry.dbxref_id, name=typedef.obo_name, is_relationshiptype=1) self.add_and_flush(cvterm_entry) self._cvterm_inserts += 1 self.printer.print("Inserted CV term '" + cvterm_entry.name + "' for dbxref " + dbxref) return cvterm_entry
def test_extract_comments(self): # Tests the extraction of comments from an ontology term term = pronto.Term("testid") comment = ontology.extract_comment(term) self.assertEqual(comment, "") term.other = {"comment": ["testcomment"]} comment = ontology.extract_comment(term) self.assertEqual(comment, "testcomment")
def test_extract_synonyms(self): # Tests the extraction of synonyms from an ontology term term = pronto.Term("testid") synonyms = ontology.extract_synonyms(term) self.assertEqual(len(synonyms), 0) term.synonyms = {pronto.Synonym("first_synonym"), pronto.Synonym("second_synonym")} synonyms = ontology.extract_synonyms(term) self.assertEqual(len(synonyms), 2) self.assertIn("second_synonym", synonyms)
def _handle_cross_references( self, term: pronto.Term, cvterm_entry: cv.CvTerm) -> List[cv.CvTermDbxRef]: """Inserts, updates or deletes database cross references to a CV term in the cvterm_dbxref table""" # Get existing cross references, i.e. cross references present in database existing_crossrefs = self.query_table( cv.CvTermDbxRef, cvterm_id=cvterm_entry.cvterm_id).all() edited_entries = [] # Get cross references present in the file and loop over them new_crossrefs = extract_cross_references(term) for crossref in new_crossrefs: # Obtain the corresponding entry from the dbxref table, insert if not existing db_authority = split_dbxref(crossref)[0] corresponding_db_entry = self._handle_db(db_authority) corresponding_dbxref_entry = self._handle_dbxref( pronto.Term(crossref), corresponding_db_entry) # Check if the cross reference is already present in the database matching_crossrefs = utils.filter_objects( existing_crossrefs, dbxref_id=corresponding_dbxref_entry.dbxref_id ) # type: List[cv.CvTermDbxRef] if matching_crossrefs: # Save the existing cross reference edited_entries.append(matching_crossrefs[0]) else: # Insert cross reference cvterm_dbxref_entry = cv.CvTermDbxRef( cvterm_id=cvterm_entry.cvterm_id, dbxref_id=corresponding_dbxref_entry.dbxref_id, is_for_definition=0) self.add_and_flush(cvterm_dbxref_entry) self.printer.print("Inserted cross reference '" + crossref + "' for CV term '" + cvterm_entry.name + "'") self._crossref_inserts += 1 edited_entries.append(cvterm_dbxref_entry) # Delete cross references not present in file for cvterm_dbxref_entry in existing_crossrefs: # type: cv.CvTermDbxRef matching_crossrefs = utils.filter_objects( edited_entries, dbxref_id=cvterm_dbxref_entry.dbxref_id) if not matching_crossrefs: # Delete cross reference self.session.delete(cvterm_dbxref_entry) self.printer.print("Deleted cross reference with dbxref-ID " + str(cvterm_dbxref_entry.dbxref_id) + " for CV term '" + cvterm_entry.name + "'") self._crossref_deletes += 1 return edited_entries
def test_extract_cross_references(self): # Tests the extraction of cross references from an ontology term term = pronto.Term("testid") crossrefs = ontology.extract_cross_references(term) self.assertEqual(len(crossrefs), 0) term.other = {"alt_id": ["alternative_id"], "xref": ["first_ref", "second_ref"]} crossrefs = ontology.extract_cross_references(term) self.assertEqual(len(crossrefs), 3) self.assertIn("alternative_id", crossrefs) self.assertIn("second_ref", crossrefs)
def load(self, filename: str, file_format: str, db_authority: str): """Loads CV terms from a file into a database""" # Parse the file self.printer.print("Parsing ontology file ...") ontology = parse_ontology(filename, file_format) # type: pronto.Ontology # Filter content: Only retain the terms stemming from the database authority of interest default_namespace = get_default_namespace(ontology) ontology_terms = filter_ontology_by_db( ontology, db_authority) # type: Dict[str, pronto.Term] self.printer.print("Retrieved " + str(len(ontology_terms)) + " terms for database authority " + db_authority) # Find/create parent vocabulary and db of ontology terms in file; load dependencies default_db_entry = self._handle_db(db_authority) default_cv_entry = self._handle_cv(pronto.Term(""), default_namespace) # Create global containers to reduce the number of database requests all_cvterm_entries = {} # type: Dict[str, cv.CvTerm] # Handle typedefs for typedef in ontology.typedefs: # type: pronto.Relationship self._handle_typedef(typedef, default_db_entry, default_cv_entry) # First loop over all terms retrieved from the file: handle vocabulary, dbxref, CV terms, synonyms, comments for term in ontology_terms.values(): # type: pronto.Term # Insert, update and/or delete entries in various tables cv_entry = self._handle_cv(term, default_namespace) dbxref_entry = self._handle_dbxref(term, default_db_entry) cvterm_entry = self._handle_cvterms(ontology_terms, default_db_entry, dbxref_entry, cv_entry.cv_id) self._handle_comments(term, cvterm_entry) self._handle_synonyms(term, cvterm_entry) # Save CV term in global container all_cvterm_entries[term.id] = cvterm_entry # Second loop over all terms retrieved from file: cross references and relationships for term in ontology_terms.values(): # type: pronto.Term # Insert, update and/or delete entries in various tables self._handle_cross_references(term, all_cvterm_entries[term.id]) self._handle_relationships(term, all_cvterm_entries[term.id], all_cvterm_entries) # Mark obsolete CV terms self._mark_obsolete_terms(ontology_terms, default_db_entry) # Commit changes self.session.commit() self._print_statistics()
def test_handle_comments(self): # Tests the insertion, update and deletion of comments (cvtermprop entries) # Check that an ontology term without comment will not create a cvtermprop entry term = pronto.Term("defaultdb:defaultaccession") first_cvtermprop = self.client._handle_comments(term, self.default_cvterm) self.assertIsNone(first_cvtermprop) # Insert a comment term.other = {"comment": ["testcomment"]} second_cvtermprop = self.client._handle_comments(term, self.default_cvterm) self.assertIsNotNone(second_cvtermprop.cvtermprop_id) self.assertEqual(second_cvtermprop.cvterm_id, self.default_cvterm.cvterm_id) self.assertEqual(second_cvtermprop.type_id, self.client._comment_term.cvterm_id) self.assertEqual(second_cvtermprop.value, "testcomment") # Try to insert another comment and check that this updates the existing entry term.other = {"comment": ["othercomment"]} third_cvtermprop = self.client._handle_comments(term, self.default_cvterm) self.assertEqual(third_cvtermprop.cvtermprop_id, second_cvtermprop.cvtermprop_id) self.assertEqual(third_cvtermprop.value, "othercomment")
def test_handle_cv(self): # Tests the insertion of CV entries # Insert a new entry term = pronto.Term("testdb:testaccession") first_cv = self.client._handle_cv(term, "testnamespace") self.assertEqual(first_cv.name, "testnamespace") self.assertIsNotNone(first_cv.cv_id) # Try to insert an entry without namespace, and fail with self.assertRaises(iobase.InputFileError): self.client._handle_cv(term, "") # Insert a further entry with another namespace term.other = {"namespace": ["othernamespace"]} second_cv = self.client._handle_cv(term, "") self.assertEqual(second_cv.name, "othernamespace") self.assertNotEqual(first_cv.cv_id, second_cv.cv_id) # Try to insert an entry with the same namespace, and check that the function returns the existing entry third_cv = self.client._handle_cv(term, "") self.assertEqual(third_cv.cv_id, second_cv.cv_id)
def test_handle_dbxref(self): # Tests the insertion and update of dbxref entries # Insert a new entry term = pronto.Term("defaultdb:testaccession") first_dbxref = self.client._handle_dbxref(term, self.default_db) self.assertEqual(first_dbxref.accession, "testaccession") self.assertEqual(first_dbxref.version, "") self.assertIsNotNone(first_dbxref.dbxref_id) # Insert a further entry with another accession term.id = "defaultdb:otheraccession" second_dbxref = self.client._handle_dbxref(term, self.default_db) self.assertEqual(second_dbxref.accession, "otheraccession") self.assertNotEqual(first_dbxref.dbxref_id, second_dbxref.dbxref_id) # Try to insert an entry with the same accession, but other version, and check that the function returns # the existing entry with updated version term.id = "defaultdb:testaccession:testversion" third_dbxref = self.client._handle_dbxref(term, self.default_db) self.assertEqual(third_dbxref.accession, "testaccession") self.assertEqual(third_dbxref.version, "testversion") self.assertEqual(first_dbxref.dbxref_id, third_dbxref.dbxref_id)
def metric_143_ncbitaxon(doc): taxonomies = list( map( json.loads, set( json.dumps({ 'value': isAbout['name'], 'valueIRI': isAbout.get('identifier', {}).get('identifierSource', '') + isAbout.get('identifier', {}).get('identifier', '') }) for node in jsonld_frame( doc, { '@type': 'Dataset', 'isAbout': { '@type': 'TaxonomicInformation', 'name': {}, 'identifier': { 'identifier': {}, 'identifierSource': { '@default': '' }, } } })['@graph'] if node['isAbout'] for isAbout in force_list(node['isAbout']) if isAbout['name']))) if taxonomies: for taxonomy in taxonomies: value_ns = IRI_to_NS(taxonomy.get('valueIRI')) if taxonomy.get( 'value') and taxonomy.get('valueIRI') and pronto.Term( value_ns, taxonomy['value']) in NCBITaxon: yield { 'value': 1, 'comment': 'Ontological IRI for taxonomy {} and term match what is found in NCBITaxon.' .format(value_ns), } elif taxonomy.get('valueIRI') and value_ns in NCBITaxon: yield { 'value': 0.75, 'comment': 'Ontological IRI for taxonomy {} found in NCBITaxon.'. format(value_ns), } elif taxonomy.get( 'value') and taxonomy['value'] in NCBITaxon_reversed: yield { 'value': 0.75, 'comment': 'Taxonomy `{}` found in NCBITaxon.'.format( taxonomy['value']), } elif taxonomy.get('value') and taxonomy[ 'value'] in NCBITaxon_reversed_synonyms: yield { 'value': 0.5, 'comment': 'Taxonomy `{}` found in NCBITaxon synonyms.'.format( taxonomy['value']), } else: yield { 'value': 0.25, 'comment': 'Taxonomy `{}` found but not in NCBITaxon.'.format( taxonomy.get('value', '') + (('<' + value_ns + '>') if value_ns else '')), } else: yield { 'value': 0.0, 'comment': 'Taxonomy could not be identified', }
def metric_142_edam(doc): filetypes = list(map(json.loads,set( json.dumps({ 'value': information['value'], 'valueIRI': information['valueIRI'], }) for node in jsonld_frame(doc, { '@type': 'Dataset', 'types': { 'information': { 'value': { '@default': '' }, 'valueIRI': { '@default': '' } } } })['@graph'] if node['types'] for types in force_list(node['types']) if types['information'] for information in force_list(types['information']) if information['value'] and information['valueIRI'] ))) if filetypes: for filetype in filetypes: value_ns = IRI_to_NS(filetype.get('valueIRI')) if filetype.get('value') and filetype.get('valueIRI') and pronto.Term(value_ns, filetype['value']) in EDAM: yield { 'value': 1, 'comment': 'Ontological IRI for file type {} and term match what is found in EDAM.'.format( value_ns ), } elif filetype.get('valueIRI') and value_ns in EDAM: yield { 'value': 0.75, 'comment': 'Ontological IRI for filetype {} found in EDAM.'.format( value_ns ), } elif filetype.get('value') and filetype['value'] in EDAM_reversed: yield { 'value': 0.75, 'comment': 'Filetype `{}` found in EDAM.'.format( filetype['value'] ), } elif filetype.get('value') and filetype['value'] in EDAM_reversed_synonyms: yield { 'value': 0.5, 'comment': 'Filetype `{}` found in EDAM synonyms.'.format( filetype['value'] ), } else: yield { 'value': 0.25, 'comment': 'Filetype `{}` found but not in EDAM.'.format( filetype.get('value', '') + (('<' + value_ns + '>') if value_ns else '') ), } else: yield { 'value': 0.0, 'comment': 'filetype could not be identified', }
def metric_140_uberon(doc): anatomical_parts = list( map( json.loads, set( json.dumps({ 'value': isAbout['name'], 'valueIRI': isAbout.get('identifier', {}).get('identifierSource', '') + isAbout.get('identifier', {}).get('identifier', '') }) for node in jsonld_frame( doc, { '@type': 'Dataset', 'isAbout': { '@type': 'AnatomicalPart', 'name': {}, 'identifier': { 'identifier': {}, 'identifierSource': { '@default': '' }, } } })['@graph'] if node['isAbout'] for isAbout in force_list(node['isAbout']) if isAbout['name']))) if anatomical_parts: for anatomical_part in anatomical_parts: value_ns = IRI_to_NS(anatomical_part.get('valueIRI')) if anatomical_part.get('value') and anatomical_part.get( 'valueIRI') and pronto.Term( value_ns, anatomical_part['value']) in UBERON: yield { 'value': 1, 'comment': 'Ontological IRI for anatomical part {} and term match what is found in UBERON.' .format(value_ns), } elif anatomical_part.get('valueIRI') and value_ns in UBERON: yield { 'value': 0.75, 'comment': 'Ontological IRI for anatomical part {} found in UBERON.'. format(value_ns), } elif anatomical_part.get( 'value') and anatomical_part['value'] in UBERON_reversed: yield { 'value': 0.75, 'comment': 'Anatomical part `{}` found in UBERON.'.format( anatomical_part['value']), } elif anatomical_part.get('value') and anatomical_part[ 'value'] in UBERON_reversed_synonyms: yield { 'value': 0.5, 'comment': 'Anatomical part `{}` found in UBERON synonyms.'.format( anatomical_part['value']), } else: yield { 'value': 0.25, 'comment': 'Anatomical part `{}` found but not in UBERON.'.format( anatomical_part.get('value', '') + (('<' + value_ns + '>') if value_ns else '')), } else: yield { 'value': 0.0, 'comment': 'Anatomical part could not be identified', }
def metric_141_mondo(doc): diseases = list( map( json.loads, set( json.dumps({ 'value': isAbout['name'], 'valueIRI': ( isAbout['identifier'].get('identifierSource', '') + isAbout['identifier'].get('identifier', '') ) if isAbout['identifier'] else '' }) for node in jsonld_frame( doc, { '@type': 'Dataset', 'isAbout': { '@type': 'Disease', 'name': {}, 'identifier': { 'identifier': {}, 'identifierSource': { '@default': '' }, } } })['@graph'] if node['isAbout'] for isAbout in force_list(node['isAbout']) if isAbout['name']))) if diseases: for disease in diseases: value_ns = IRI_to_NS(disease.get('valueIRI')) if disease.get( 'value') and disease.get('valueIRI') and pronto.Term( value_ns, disease['value']) in MONDO: yield { 'value': 1, 'comment': 'Ontological IRI for disease {} and term match what is found in MONDO.' .format(value_ns), } elif disease.get('valueIRI') and disease['valueIRI'] in MONDO: yield { 'value': 0.75, 'comment': 'Ontological IRI for disease {} found in MONDO.'.format( value_ns), } elif disease.get('value') and disease['value'] in MONDO_reversed: yield { 'value': 0.75, 'comment': 'Disease `{}` found in MONDO.'.format(disease['value']), } elif disease.get( 'value') and disease['value'] in MONDO_reversed_synonyms: yield { 'value': 0.5, 'comment': 'Disease `{}` found in MONDO synonyms.'.format( disease['value']), } else: yield { 'value': 0.5, 'comment': 'Disease `{}` found but not in MONDO.'.format( disease.get('value', '') + (('<' + value_ns + '>') if value_ns else '')), } else: yield { 'value': 0.0, 'comment': 'Disease could not be identified', }
def test_handle_cvterm(self): # Tests the insertion and update of cvterm entries # Populate the database with essentials ontology_terms = {"defaultdb:001": pronto.Term("defaultdb:001", "term1"), "defaultdb:002": pronto.Term("defaultdb:002", "term2")} # Call the function with a dbxref that is not part of the ontology, and check that the corresponding CV term # is marked as obsolete obsolete_cvterm = self.client._handle_cvterms(ontology_terms, self.default_db, self.default_dbxref, self.default_cv.cv_id) self.assertEqual(obsolete_cvterm.is_obsolete, 1) self.assertEqual(self.client._cvterm_inserts, 0) self.assertEqual(self.client._cvterm_updates, 0) self.assertEqual(self.client._cvterm_deletes, 1) # Call the function with a dbxref that is part of the ontology, and check that a CV term is created novel_dbxref = general.DbxRef(db_id=self.default_db.db_id, accession="001") self.client.add_and_flush(novel_dbxref) novel_cvterm = self.client._handle_cvterms(ontology_terms, self.default_db, novel_dbxref, self.default_cv.cv_id) self.assertIsNotNone(novel_cvterm.cvterm_id) self.assertEqual(novel_cvterm.dbxref_id, novel_dbxref.dbxref_id) self.assertEqual(novel_cvterm.name, "term1") self.assertEqual(self.client._cvterm_inserts, 1) self.assertEqual(self.client._cvterm_updates, 0) self.assertEqual(self.client._cvterm_deletes, 1) # Call the function with changed ontology term, and check that this updates the existing entry ontology_terms["defaultdb:001"].name = "newname" updated_cvterm = self.client._handle_cvterms(ontology_terms, self.default_db, novel_dbxref, self.default_cv.cv_id) self.assertEqual(novel_cvterm.cvterm_id, updated_cvterm.cvterm_id) self.assertEqual(updated_cvterm.name, "newname") self.assertEqual(self.client._cvterm_inserts, 1) self.assertEqual(self.client._cvterm_updates, 1) self.assertEqual(self.client._cvterm_deletes, 1) # Call the function with a dbxref that corresponds to an existing CV term, and check that nothing happens unaltered_cvterm = self.client._handle_cvterms(ontology_terms, self.default_db, novel_dbxref, self.default_cv.cv_id) self.assertEqual(unaltered_cvterm, updated_cvterm) self.assertEqual(self.client._cvterm_inserts, 1) self.assertEqual(self.client._cvterm_updates, 1) self.assertEqual(self.client._cvterm_deletes, 1) # Call the function with an obsolete ontology term that has the same properties as an existing CV term, and # check that the new CV term is marked as 'more obsolete' before insertion ontology_terms["defaultdb:003"] = pronto.Term("defaultdb:003", "testterm", other={"is_obsolete": ["True"]}) duplicate_obsolete_dbxref = general.DbxRef(db_id=self.default_db.db_id, accession="003") self.client.add_and_flush(duplicate_obsolete_dbxref) duplicate_obsolete_cvterm = self.client._handle_cvterms(ontology_terms, self.default_db, duplicate_obsolete_dbxref, self.default_cv.cv_id) self.assertEqual(obsolete_cvterm.is_obsolete, 1) self.assertEqual(duplicate_obsolete_cvterm.is_obsolete, 2) self.assertEqual(self.client._cvterm_inserts, 2) self.assertEqual(self.client._cvterm_updates, 1) self.assertEqual(self.client._cvterm_deletes, 1) # Call the function with a non-obsolete ontology term that has the same properties as an existing CV term, and # check that the existing term is updated first ontology_terms["defaultdb:001"].name = "oldname" ontology_terms["defaultdb:004"] = pronto.Term("defaultdb:004", "newname") duplicate_dbxref = general.DbxRef(db_id=self.default_db.db_id, accession="004") self.client.add_and_flush(duplicate_dbxref) duplicate_cvterm = self.client._handle_cvterms(ontology_terms, self.default_db, duplicate_dbxref, self.default_cv.cv_id) self.assertEqual(novel_cvterm.name, "oldname") self.assertEqual(duplicate_cvterm.name, "newname") self.assertEqual(self.client._cvterm_inserts, 3) self.assertEqual(self.client._cvterm_updates, 2) self.assertEqual(self.client._cvterm_deletes, 1)
def metric_139_bao(doc): assays = list( map( json.loads, set( json.dumps({ 'value': method if type(method) == str else method['value'], 'valueIRI': '' if type(method) == str else method['valueIRI'], }) for node in jsonld_frame( doc, { '@type': 'Dataset', 'types': { 'method': { 'value': { '@default': '' }, 'valueIRI': { '@default': '' } } } })['@graph'] if node['types'] for types in force_list(node['types']) if types['method'] for method in force_list(types['method']) if type(method) == str or (type(method) == dict and method['value'] or method['valueIRI'] )))) if assays: for assay in assays: value_ns = IRI_to_NS(assay.get('valueIRI')) if assay.get('value') and assay.get('valueIRI') and pronto.Term( value_ns, assay.get('value')) in BAO: yield { 'value': 1, 'comment': 'Ontological IRI for Assay {} and term match what is found in BAO.' .format(assay['valueIRI']), } elif value_ns and assay['valueIRI'] in BAO: yield { 'value': 0.75, 'comment': 'Ontological IRI for Assay {} found in BAO.'.format( assay['valueIRI']), } elif assay.get('value') and assay['value'] in BAO_reversed: yield { 'value': 0.75, 'comment': 'Assay {} found in BAO.'.format(assay['value']), } elif assay.get( 'value') and assay['value'] in BAO_reversed_synonyms: yield { 'value': 0.5, 'comment': 'Assay `{}` found in BAO synonyms.'.format(assay['value']), } else: yield { 'value': 0.25, 'comment': 'Assay {} found but not in BAO.'.format( assay.get('value', '') + (('<' + value_ns + '>') if value_ns else '')), } else: yield { 'value': 0.0, 'comment': 'Assay could not be identified', }