pyobo 0.11.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

pyobo/identifier_utils/relations/data_owl.json

@@ -0,0 +1,57 @@
+[
+  {
+    "identifier": "backwardCompatibleWith",
+    "label": "backwardCompatibleWith",
+    "prefix": "owl"
+  },
+  {
+    "identifier": "bottomDataProperty",
+    "label": "bottomDataProperty",
+    "prefix": "owl"
+  },
+  {
+    "identifier": "bottomObjectProperty",
+    "label": "bottomObjectProperty",
+    "prefix": "owl"
+  },
+  {
+    "identifier": "deprecated",
+    "label": "deprecated",
+    "prefix": "owl"
+  },
+  {
+    "identifier": "imports",
+    "label": "imports",
+    "prefix": "owl"
+  },
+  {
+    "identifier": "incompatibleWith",
+    "label": "incompatibleWith",
+    "prefix": "owl"
+  },
+  {
+    "identifier": "priorVersion",
+    "label": "priorVersion",
+    "prefix": "owl"
+  },
+  {
+    "identifier": "topDataProperty",
+    "label": "topDataProperty",
+    "prefix": "owl"
+  },
+  {
+    "identifier": "topObjectProperty",
+    "label": "topObjectProperty",
+    "prefix": "owl"
+  },
+  {
+    "identifier": "versionIRI",
+    "label": "versionIRI",
+    "prefix": "owl"
+  },
+  {
+    "identifier": "versionInfo",
+    "label": "versionInfo",
+    "prefix": "owl"
+  }
+]

pyobo/identifier_utils/relations/data_rdf.json

@@ -0,0 +1 @@
+[]

pyobo/identifier_utils/relations/data_rdfs.json

@@ -0,0 +1,7 @@
+[
+  {
+    "identifier": "seeAlso",
+    "label": "see also",
+    "prefix": "rdfs"
+  }
+]

pyobo/mocks.py

@@ -1,7 +1,9 @@
 """Mocks for PyOBO."""
 
+from __future__ import annotations
+
 from collections.abc import Mapping
-from typing import Optional, TypeVar, Union
+from typing import TypeVar
 from unittest import mock
 
 import pandas as pd
@@ -9,10 +11,10 @@ import pandas as pd
 from pyobo.constants import XREF_COLUMNS
 
 __all__ = [
-    "get_mock_id_name_mapping",
-    "get_mock_id_synonyms_mapping",
     "get_mock_get_xrefs_df",
     "get_mock_id_alts_mapping",
+    "get_mock_id_name_mapping",
+    "get_mock_id_synonyms_mapping",
 ]
 
 
@@ -35,7 +37,8 @@ def get_mock_id_synonyms_mapping(data: Mapping[str, Mapping[str, list[str]]]) ->
 def get_mock_id_alts_mapping(data: Mapping[str, Mapping[str, list[str]]]) -> mock._patch:
     """Mock the :func:`pyobo.extract.get_id_to_alts` function.
 
-    :param data: A mapping from prefix to mappings of identifier to lists of alternative identifiers.
+    :param data: A mapping from prefix to mappings of identifier to lists of alternative
+        identifiers.
     """
     return _replace_mapping_getter("pyobo.api.alts.get_id_to_alts", data)
 
@@ -51,7 +54,7 @@ def _replace_mapping_getter(name: str, data: Mapping[str, Mapping[str, X]]) -> m
 
 
 def get_mock_get_xrefs_df(
-    df: Union[list[tuple[str, str, str, str, str]], pd.DataFrame],
+    df: list[tuple[str, str, str, str, str]] | pd.DataFrame,
 ) -> mock._patch:
     """Mock the :func:`pyobo.xrefsdb.xrefs_pipeline.get_xref_df` function.
 
@@ -69,7 +72,7 @@ def get_mock_get_xrefs_df(
 
 
 def _make_mock_get_name(name: str, data: Mapping[str, Mapping[str, X]]) -> mock._patch:
-    def _get_name(prefix: str, identifier: str) -> Optional[X]:
+    def _get_name(prefix: str, identifier: str) -> X | None:
         return data.get(prefix, {}).get(identifier)
 
     return mock.patch(name, side_effect=_get_name)

pyobo/ner/__init__.py

@@ -0,0 +1,9 @@
+"""Wrapper around NER functionalities."""
+
+from .api import get_grounder
+from .normalizer import ground
+
+__all__ = [
+    "get_grounder",
+    "ground",
+]

pyobo/ner/api.py

@@ -0,0 +1,72 @@
+"""NER functionality."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from subprocess import CalledProcessError
+from typing import TYPE_CHECKING
+
+import ssslm
+from ssslm import LiteralMapping
+from tqdm import tqdm
+from typing_extensions import Unpack
+
+from pyobo.api import get_literal_mappings
+from pyobo.constants import GetOntologyKwargs, check_should_use_tqdm
+from pyobo.getters import NoBuildError
+
+if TYPE_CHECKING:
+    import gilda
+
+__all__ = [
+    "get_grounder",
+]
+
+
+def get_grounder(
+    prefixes: str | Iterable[str],
+    *,
+    grounder_cls: type[gilda.Grounder] | None = None,
+    versions: None | str | Iterable[str | None] | dict[str, str] = None,
+    skip_obsolete: bool = False,
+    **kwargs: Unpack[GetOntologyKwargs],
+) -> ssslm.Grounder:
+    """Get a grounder for the given prefix(es)."""
+    literal_mappings: list[LiteralMapping] = []
+    it = _clean_prefix_versions(prefixes, versions=versions)
+    disable = len(it) == 1 or not check_should_use_tqdm(kwargs)
+    for prefix, kwargs["version"] in tqdm(it, leave=False, disable=disable):
+        try:
+            literal_mappings.extend(
+                get_literal_mappings(
+                    prefix,
+                    skip_obsolete=skip_obsolete,
+                    **kwargs,
+                )
+            )
+        except (NoBuildError, CalledProcessError):
+            continue
+
+    return ssslm.make_grounder(literal_mappings, implementation="gilda", grounder_cls=grounder_cls)
+
+
+def _clean_prefix_versions(
+    prefixes: str | Iterable[str],
+    versions: None | str | Iterable[str | None] | dict[str, str] = None,
+) -> list[tuple[str, str | None]]:
+    if isinstance(prefixes, str):
+        prefixes = [prefixes]
+    else:
+        prefixes = list(prefixes)
+    if versions is None:
+        versions = [None] * len(prefixes)
+    elif isinstance(versions, str):
+        versions = [versions]
+    elif isinstance(versions, dict):
+        versions = [versions.get(prefix) for prefix in prefixes]
+    else:
+        versions = list(versions)
+    if len(prefixes) != len(versions):
+        raise ValueError
+
+    return list(zip(prefixes, versions, strict=True))

pyobo/ner/normalizer.py

@@ -0,0 +1,33 @@
+"""Use synonyms from OBO to normalize names."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from typing_extensions import Unpack
+
+from .api import get_grounder
+from ..constants import GetOntologyKwargs
+from ..struct import Reference
+
+__all__ = [
+    "ground",
+]
+
+
+def ground(
+    prefix: str | Iterable[str], query: str, **kwargs: Unpack[GetOntologyKwargs]
+) -> Reference | None:
+    """Normalize a string given the prefix's labels and synonyms.
+
+    :param prefix: If a string, only grounds against that namespace. If a list, will try grounding
+        against all in that order
+    :param query: The string to try grounding
+    """
+    grounder = get_grounder(prefix, **kwargs)
+    match = grounder.get_best_match(query)
+    if match:
+        # TODO when generics are working, the grounder
+        #  can be type annotated with the right reference
+        return Reference.from_reference(match.reference)
+    return None

pyobo/obographs.py

@@ -1,12 +1,12 @@
 """Convert PyOBO into OBO Graph."""
 
+from __future__ import annotations
+
+import logging
 from collections.abc import Iterable
 
 import bioregistry
-import curies
 from bioontologies.obograph import (
-    OBO_SYNONYM_TO_OIO,
-    OIO_TO_REFERENCE,
     Definition,
     Edge,
     Graph,
@@ -19,7 +19,7 @@ from bioontologies.obograph import (
 from bioontologies.robot import ParseResults
 from tqdm import tqdm
 
-from pyobo.struct import Obo, Reference, Term
+from pyobo.struct import Obo, OBOLiteral, Reference, Term
 from pyobo.struct.typedef import definition_source, is_a
 
 __all__ = [
@@ -27,6 +27,8 @@ __all__ = [
     "parse_results_from_obo",
 ]
 
+logger = logging.getLogger(__name__)
+
 
 def parse_results_from_obo(obo: Obo) -> ParseResults:
     """Get parse results from an OBO graph."""
@@ -59,40 +61,28 @@ def _get_meta(obo: Obo) -> Meta:
     )
 
 
-def _rewire(r: Reference) -> curies.Reference:
-    return curies.Reference(prefix=r.prefix, identifier=r.identifier)
-
-
 def _get_class_node(term: Term) -> Node:
-    if term.definition or term.provenance:
+    if term.provenance or term.definition:
         definition = Definition.from_parsed(
-            value=term.definition, references=[_rewire(p) for p in term.provenance]
+            value=term.definition, references=_prep_prov(term.provenance)
         )
     else:
         definition = None
-
-    if term.xrefs:
-        if not term.xref_types:
-            term.xref_types = [
-                Reference(prefix="oboInOwl", identifier="hasDbXref") for _ in term.xrefs
-            ]
-        elif len(term.xrefs) != len(term.xref_types):
-            raise ValueError
-
     xrefs = [
         Xref.from_parsed(
-            predicate=_rewire(xref_type),
-            value=_rewire(xref),
+            predicate=Reference.from_reference(mapping_predicate),
+            value=Reference.from_reference(mapping_object),
+        )
+        for mapping_predicate, mapping_object in term.get_mappings(
+            include_xrefs=True, add_context=False
         )
-        for xref, xref_type in zip(term.xrefs, term.xref_types)
     ]
-    default_st = Reference(prefix="oboInOwl", identifier="SynonymType")
     synonyms = [
         Synonym.from_parsed(
             name=synonym.name,
-            predicate=OIO_TO_REFERENCE[OBO_SYNONYM_TO_OIO[synonym.specificity]],
-            synonym_type=_rewire(synonym.type.reference) if synonym.type else default_st,
-            references=[_rewire(x) for x in synonym.provenance],
+            predicate=Reference.from_reference(synonym.predicate),
+            synonym_type=Reference.from_reference(synonym.type) if synonym.type else None,
+            references=_prep_prov(synonym.provenance),
         )
         for synonym in term.synonyms
     ]
@@ -105,35 +95,49 @@ def _get_class_node(term: Term) -> Node:
         deprecated=term.is_obsolete or False,
     )
     return Node(
-        id=term.bioregistry_link,
+        # FIXME do expansion same as for OFN
+        id=f"https://bioregistry.io/{term.curie}",
         lbl=term.name,
         meta=meta,
         type="CLASS",
-        reference=_rewire(term.reference),
+        reference=Reference.from_reference(term.reference),
         standardized=True,
     )
 
 
+def _prep_prov(provenance):
+    rv = []
+    for x in provenance:
+        match x:
+            case Reference():
+                rv.append(Reference.from_reference(x))
+            case OBOLiteral():
+                logger.debug("not implemented to convert literal provenance")
+                continue
+    return rv
+
+
 def _iter_edges(term: Term) -> Iterable[Edge]:
     for parent in term.parents:
         yield Edge.from_parsed(
-            _rewire(term.reference),
-            _rewire(is_a.reference),
-            _rewire(parent),
+            Reference.from_reference(term.reference),
+            Reference.from_reference(is_a.reference),
+            Reference.from_reference(parent),
         )
 
     for typedef, targets in term.relationships.items():
         for target in targets:
             yield Edge.from_parsed(
-                _rewire(term.reference),
-                _rewire(typedef.reference),
-                _rewire(target),
+                Reference.from_reference(term.reference),
+                Reference.from_reference(typedef),
+                Reference.from_reference(target),
             )
 
     for provenance_reference in term.provenance:
-        yield Edge.from_parsed(
-            _rewire(term.reference),
-            _rewire(definition_source.reference),
-            _rewire(provenance_reference),
-        )
+        if isinstance(provenance_reference, Reference):
+            yield Edge.from_parsed(
+                Reference.from_reference(term.reference),
+                Reference.from_reference(definition_source.reference),
+                Reference.from_reference(provenance_reference),
+            )
     # TODO also look through xrefs and seealso to get provenance xrefs?

pyobo/plugins.py

@@ -1,15 +1,16 @@
 """Tools for loading entry points."""
 
-from collections.abc import Iterable, Mapping
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Mapping
 from functools import lru_cache
-from typing import Callable, Optional
 
 from .struct import Obo
 
 __all__ = [
     "has_nomenclature_plugin",
-    "run_nomenclature_plugin",
     "iter_nomenclature_plugins",
+    "run_nomenclature_plugin",
 ]
 
 
@@ -32,7 +33,7 @@ def has_nomenclature_plugin(prefix: str) -> bool:
         return True
 
 
-def run_nomenclature_plugin(prefix: str, version: Optional[str] = None) -> Obo:
+def run_nomenclature_plugin(prefix: str, version: str | None = None) -> Obo:
     """Get a converted PyOBO source."""
     from .sources import ontology_resolver