def curie_lookup(curie: str) -> Optional[str]: """ Given a CURIE, find its label. This method first does a lookup in predefined maps. If none found, it makes use of CurieLookupService to look for the CURIE in a set of preloaded ontologies. Parameters ---------- curie: str A CURIE Returns ------- Optional[str] The label corresponding to the given CURIE """ cls = get_curie_lookup_service() name: Optional[str] = None prefix = PrefixManager.get_prefix(curie) if prefix in ['OIO', 'OWL', 'owl', 'OBO', 'rdfs']: name = stringcase.snakecase(curie.split(':', 1)[1]) elif curie in cls.curie_map: name = cls.curie_map[curie] elif curie in cls.ontology_graph: name = cls.ontology_graph.nodes()[curie]['name'] return name
def infer_category(iri: URIRef, rdfgraph:rdflib.Graph) -> List[str]: """ Infer category for a given iri by traversing rdfgraph. Parameters ---------- iri: rdflib.term.URIRef IRI rdfgraph: rdflib.Graph A graph to traverse Returns ------- List[str] A list of category corresponding to the given IRI """ category = None subj = None closure = list(rdfgraph.transitive_objects(iri, URIRef(RDFS.subClassOf))) category = [top_level_terms[x] for x in closure if x in top_level_terms.keys()] if category: logging.debug("Inferred category as {} based on transitive closure over 'subClassOf' relation".format(category)) else: subj = closure[-1] if subj == iri: return category subject_curie = contract(subj) if '_' in subject_curie: fixed_curie = subject_curie.split(':', 1)[1].split('_', 1)[1] logging.warning("Malformed CURIE {} will be fixed to {}".format(subject_curie, fixed_curie)) subject_curie = fixed_curie cls = get_curie_lookup_service() category = get_category_via_superclass(cls.ontology_graph, subject_curie) return category
def get_category_via_superclass(graph: BaseGraph, curie: str, load_ontology: bool = True) -> Set[str]: """ Get category for a given CURIE by tracing its superclass, via ``subclass_of`` hierarchy, and getting the most appropriate category based on the superclass. Parameters ---------- graph: kgx.graph.base_graph.BaseGraph Graph to traverse curie: str Input CURIE load_ontology: bool Determines whether to load ontology, based on CURIE prefix, or to simply rely on ``subclass_of`` hierarchy from graph Returns ------- Set[str] A set containing one (or more) category for the given CURIE """ log.debug("curie: {}".format(curie)) new_categories = [] toolkit = get_toolkit() if PrefixManager.is_curie(curie): ancestors = get_ancestors(graph, curie, relations=['subclass_of']) if len(ancestors) == 0 and load_ontology: cls = get_curie_lookup_service() ontology_graph = cls.ontology_graph new_categories += [ x for x in get_category_via_superclass(ontology_graph, curie, False) ] log.debug("Ancestors for CURIE {} via subClassOf: {}".format( curie, ancestors)) seen = [] for anc in ancestors: mapping = toolkit.get_by_mapping(anc) seen.append(anc) if mapping: # there is direct mapping to BioLink Model log.debug("Ancestor {} mapped to {}".format(anc, mapping)) seen_labels = [ graph.nodes()[x]['name'] for x in seen if 'name' in graph.nodes()[x] ] new_categories += [x for x in seen_labels] new_categories += [x for x in toolkit.ancestors(mapping)] break return set(new_categories)
def test_get_curie_lookup_service(): cls = get_curie_lookup_service() assert isinstance(cls, CurieLookupService)
def test_get_curie_lookup_service(): """ Test to get an instance of CurieLookupService via get_curie_lookup_service. """ cls = get_curie_lookup_service() assert isinstance(cls, CurieLookupService)