pyobo 0.11.2__py3-none-any.whl → 0.12.1__py3-none-any.whl

pyobo/gilda_utils.py

@@ -2,271 +2,73 @@
 
 from __future__ import annotations
 
-import logging
-from collections.abc import Iterable
-from subprocess import CalledProcessError
+import warnings
+from collections.abc import Iterable, Sequence
+from typing import TYPE_CHECKING, Any, cast
 
-import bioregistry
-import gilda.api
-import gilda.term
-from gilda.grounder import Grounder
-from gilda.process import normalize
-from gilda.term import filter_out_duplicates
-from tqdm.auto import tqdm
+import ssslm
+from ssslm import literal_mappings_to_gilda
+from typing_extensions import Unpack
 
-from pyobo import (
-    get_descendants,
-    get_id_name_mapping,
-    get_id_species_mapping,
-    get_id_synonyms_mapping,
-    get_ids,
-    get_obsolete,
+from pyobo.api import (
+    get_literal_mappings,
+    get_literal_mappings_subset,
 )
-from pyobo.getters import NoBuildError
-from pyobo.utils.io import multidict
+from pyobo.constants import GetOntologyKwargs
+from pyobo.struct.reference import Reference
+
+if TYPE_CHECKING:
+    import gilda
 
 __all__ = [
-    "iter_gilda_prediction_tuples",
-    "get_grounder",
+    "get_gilda_term_subset",
     "get_gilda_terms",
+    "get_grounder",
 ]
 
-logger = logging.getLogger(__name__)
-
-
-def iter_gilda_prediction_tuples(
-    prefix: str,
-    relation: str = "skos:exactMatch",
-    *,
-    grounder: Grounder | None = None,
-    identifiers_are_names: bool = False,
-    strict: bool = False,
-) -> Iterable[tuple[str, str, str, str, str, str, str, str, float]]:
-    """Iterate over prediction tuples for a given prefix."""
-    if grounder is None:
-        grounder = gilda.api.grounder
-    id_name_mapping = get_id_name_mapping(prefix, strict=strict)
-    it = tqdm(
-        id_name_mapping.items(), desc=f"[{prefix}] gilda tuples", unit_scale=True, unit="name"
-    )
-    for identifier, name in it:
-        for scored_match in grounder.ground(name):
-            target_prefix = scored_match.term.db.lower()
-            yield (
-                prefix,
-                normalize_identifier(prefix, identifier),
-                name,
-                relation,
-                target_prefix,
-                normalize_identifier(target_prefix, scored_match.term.id),
-                scored_match.term.entry_name,
-                "semapv:LexicalMatching",
-                round(scored_match.score, 3),
-            )
-
-    if identifiers_are_names:
-        it = tqdm(get_ids(prefix), desc=f"[{prefix}] gilda tuples", unit_scale=True, unit="id")
-        for identifier in it:
-            for scored_match in grounder.ground(identifier):
-                target_prefix = scored_match.term.db.lower()
-                yield (
-                    prefix,
-                    normalize_identifier(prefix, identifier),
-                    identifier,
-                    relation,
-                    target_prefix,
-                    normalize_identifier(target_prefix, scored_match.term.id),
-                    scored_match.term.entry_name,
-                    "semapv:LexicalMatching",
-                    scored_match.score,
-                )
 
+def get_grounder(*args: Any, **kwargs: Any) -> gilda.Grounder:
+    """Get a grounder."""
+    warnings.warn("use pyobo.ner.get_grounder", DeprecationWarning, stacklevel=2)
+    import pyobo.ner
 
-def normalize_identifier(prefix: str, identifier: str) -> str:
-    """Normalize the identifier."""
-    resource = bioregistry.get_resource(prefix)
-    if resource is None:
-        raise KeyError
-    return resource.miriam_standardize_identifier(identifier) or identifier
+    grounder = cast(ssslm.ner.GildaGrounder, pyobo.get_grounder(*args, **kwargs))
+    return grounder._grounder
 
 
-def get_grounder(
-    prefixes: str | Iterable[str],
-    *,
-    unnamed: Iterable[str] | None = None,
-    grounder_cls: type[Grounder] | None = None,
-    versions: None | str | Iterable[str | None] | dict[str, str] = None,
-    strict: bool = True,
-    skip_obsolete: bool = False,
-    progress: bool = True,
-) -> Grounder:
-    """Get a Gilda grounder for the given prefix(es)."""
-    unnamed = set() if unnamed is None else set(unnamed)
-    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
-
-    terms: list[gilda.term.Term] = []
-    for prefix, version in zip(tqdm(prefixes, leave=False, disable=not progress), versions):
-        try:
-            p_terms = list(
-                get_gilda_terms(
-                    prefix,
-                    identifiers_are_names=prefix in unnamed,
-                    version=version,
-                    strict=strict,
-                    skip_obsolete=skip_obsolete,
-                    progress=progress,
-                )
-            )
-        except (NoBuildError, CalledProcessError):
-            continue
-        else:
-            terms.extend(p_terms)
-    terms = filter_out_duplicates(terms)
-    terms_dict = multidict((term.norm_text, term) for term in terms)
-    if grounder_cls is None:
-        return Grounder(terms_dict)
-    else:
-        return grounder_cls(terms_dict)
-
-
-def _fast_term(
-    *,
-    text: str,
-    prefix: str,
-    identifier: str,
-    name: str,
-    status: str,
-    organism: str | None = None,
-) -> gilda.term.Term | None:
-    try:
-        term = gilda.term.Term(
-            norm_text=normalize(text),
-            text=text,
-            db=prefix,
-            id=identifier,
-            entry_name=name,
-            status=status,
-            source=prefix,
-            organism=organism,
-        )
-    except ValueError:
-        return None
-    return term
+def get_gilda_terms(prefix: str, *, skip_obsolete: bool = False, **kwargs) -> Iterable[gilda.Term]:
+    """Get gilda terms."""
+    warnings.warn(
+        "use pyobo.get_literal_mappings() directly and convert to gilda yourself",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    yield from literal_mappings_to_gilda(
+        get_literal_mappings(prefix, skip_obsolete=skip_obsolete, **kwargs)
+    )
 
 
-def get_gilda_terms(
-    prefix: str,
+def get_gilda_term_subset(
+    source: str,
+    ancestors: str | Sequence[str],
     *,
-    identifiers_are_names: bool = False,
-    version: str | None = None,
-    strict: bool = True,
     skip_obsolete: bool = False,
-    progress: bool = True,
-) -> Iterable[gilda.term.Term]:
-    """Get gilda terms for the given namespace."""
-    id_to_name = get_id_name_mapping(prefix, version=version, strict=strict)
-    id_to_species = get_id_species_mapping(prefix, version=version, strict=strict)
-    obsoletes = get_obsolete(prefix, version=version, strict=strict) if skip_obsolete else set()
-
-    it = tqdm(
-        id_to_name.items(),
-        desc=f"[{prefix}] mapping",
-        unit_scale=True,
-        unit="name",
-        disable=not progress,
+    **kwargs: Unpack[GetOntologyKwargs],
+) -> Iterable[gilda.Term]:
+    """Get a subset of terms."""
+    warnings.warn(
+        "use pyobo.get_literal_mappings_subset() directly and convert to gilda yourself",
+        DeprecationWarning,
+        stacklevel=2,
     )
-    for identifier, name in it:
-        if identifier in obsoletes:
-            continue
-        term = _fast_term(
-            text=name,
-            prefix=prefix,
-            identifier=identifier,
-            name=name,
-            status="name",
-            organism=id_to_species.get(identifier),
-        )
-        if term is not None:
-            yield term
-
-    id_to_synonyms = get_id_synonyms_mapping(prefix, version=version)
-    if id_to_synonyms:
-        it = tqdm(
-            id_to_synonyms.items(),
-            desc=f"[{prefix}] mapping",
-            unit_scale=True,
-            unit="synonym",
-            disable=not progress,
-        )
-        for identifier, synonyms in it:
-            if identifier in obsoletes:
-                continue
-            name = id_to_name[identifier]
-            for synonym in synonyms:
-                if not synonym:
-                    continue
-                term = _fast_term(
-                    text=synonym,
-                    prefix=prefix,
-                    identifier=identifier,
-                    name=name,
-                    status="synonym",
-                    organism=id_to_species.get(identifier),
-                )
-                if term is not None:
-                    yield term
-
-    if identifiers_are_names:
-        it = tqdm(
-            get_ids(prefix),
-            desc=f"[{prefix}] mapping",
-            unit_scale=True,
-            unit="id",
-            disable=not progress,
+    if isinstance(ancestors, str):
+        ancestors = [ancestors]
+
+    yield from literal_mappings_to_gilda(
+        get_literal_mappings_subset(
+            source,
+            ancestors=[Reference.from_curie(a) for a in ancestors],
+            skip_obsolete=skip_obsolete,
+            **kwargs,
         )
-        for identifier in it:
-            if identifier in obsoletes:
-                continue
-            term = _fast_term(
-                text=identifier,
-                prefix=prefix,
-                identifier=identifier,
-                name=identifier,
-                status="name",
-                organism=id_to_species.get(identifier),
-            )
-            if term is not None:
-                yield term
-
-
-def get_gilda_term_subset(
-    source: str, ancestors: str | list[str], **kwargs
-) -> Iterable[gilda.term.Term]:
-    """Get a subset of terms."""
-    subset = {
-        descendant
-        for parent_curie in _ensure_list(ancestors)
-        for descendant in get_descendants(*parent_curie.split(":")) or []
-    }
-    for term in get_gilda_terms(source, **kwargs):
-        if bioregistry.curie_to_str(term.db, term.id) in subset:
-            yield term
-
-
-def _ensure_list(s: str | list[str]) -> list[str]:
-    if isinstance(s, str):
-        return [s]
-    return s
+    )

pyobo/identifier_utils/__init__.py

@@ -0,0 +1,33 @@
+"""Extract registry information."""
+
+from .api import (
+    DefaultCoercionError,
+    EmptyStringError,
+    NotCURIEError,
+    ParseError,
+    ParseValidationError,
+    UnparsableIRIError,
+    UnregisteredPrefixError,
+    _is_valid_identifier,
+    _parse_str_or_curie_or_uri_helper,
+    standardize_ec,
+    wrap_norm_prefix,
+)
+from .preprocessing import get_rules
+from .relations import ground_relation
+
+__all__ = [
+    "DefaultCoercionError",
+    "EmptyStringError",
+    "NotCURIEError",
+    "ParseError",
+    "ParseValidationError",
+    "UnparsableIRIError",
+    "UnregisteredPrefixError",
+    "_is_valid_identifier",
+    "_parse_str_or_curie_or_uri_helper",
+    "get_rules",
+    "ground_relation",
+    "standardize_ec",
+    "wrap_norm_prefix",
+]

pyobo/identifier_utils/api.py

@@ -0,0 +1,305 @@
+"""Utilities for handling prefixes."""
+
+from __future__ import annotations
+
+import logging
+from functools import lru_cache, wraps
+from typing import Annotated, ClassVar
+
+import bioregistry
+import click
+from bioregistry import NormalizedNamableReference as Reference
+from bioregistry.constants import FailureReturnType
+from curies import ReferenceTuple
+from curies.preprocessing import BlocklistError, PreprocessingConverter
+from pydantic import ValidationError
+from typing_extensions import Doc
+
+from .preprocessing import get_rules
+from .relations import ground_relation
+
+__all__ = [
+    "DefaultCoercionError",
+    "EmptyStringError",
+    "NotCURIEError",
+    "ParseError",
+    "ParseValidationError",
+    "UnparsableIRIError",
+    "UnregisteredPrefixError",
+    "_parse_str_or_curie_or_uri_helper",
+    "standardize_ec",
+    "wrap_norm_prefix",
+]
+
+logger = logging.getLogger(__name__)
+
+
+Line = Annotated[str | None, Doc("""The OBO line where the parsing happened""")]
+
+
+class ParseError(BaseException):
+    """Raised on a missing prefix."""
+
+    message: ClassVar[str]
+
+    def __init__(
+        self,
+        curie: str,
+        *,
+        context: str | None,
+        ontology_prefix: str | None = None,
+        node: Reference | None = None,
+        predicate: Reference | None = None,
+        line: Line = None,
+    ) -> None:
+        """Initialize the error."""
+        self.curie = curie
+        self.context = context
+        self.ontology_prefix = ontology_prefix
+        self.node = node
+        self.predicate = predicate
+        self.line = line
+
+    def __str__(self) -> str:
+        s = ""
+        if self.node:
+            if self.predicate:
+                s += f"[{self.node.curie} - {self.predicate.curie}] "
+            else:
+                s += f"[{self.node.curie}] "
+        elif self.ontology_prefix:
+            s += f"[{self.ontology_prefix}] "
+        s += f"{self.message} {click.style(self.curie, fg='cyan')}"
+        if self.context:
+            s += f" in {self.context}"
+        if self.line and self.line != self.curie:
+            s += f" in {click.style(self.line, fg='yellow')}"
+        return s
+
+
+class ParseValidationError(ParseError):
+    """Raised on a validation error."""
+
+    message = "failed Pydantic validation"
+
+    def __init__(self, *args, exc: ValidationError, **kwargs) -> None:
+        """Initialize the error."""
+        super().__init__(*args, **kwargs)
+        self.exc = exc
+
+
+class UnregisteredPrefixError(ParseError):
+    """Raised on a missing prefix."""
+
+    message = "unregistered prefix in"
+
+
+class UnparsableIRIError(ParseError):
+    """Raised on a an unparsable IRI."""
+
+    message = "couldn't parse IRI"
+
+
+class EmptyStringError(ParseError):
+    """Raised on a an empty string."""
+
+    message = "is empty"
+
+
+class NotCURIEError(ParseError):
+    """Raised on a text that can't be parsed as a CURIE."""
+
+    message = "not a CURIE"
+
+
+class DefaultCoercionError(ParseError):
+    """Raised on a text that can't be coerced into a default reference."""
+
+    message = "can't be coerced into a default reference"
+
+
+def _is_uri(s: str) -> bool:
+    return s.startswith("http:") or s.startswith("https:")
+
+
+def _preclean_uri(s: str) -> str:
+    s = s.strip().removeprefix(r"url\:").removeprefix(r"uri\:")
+    s = s.strip().removeprefix(r"URL\:").removeprefix(r"URI\:")
+    s = s.strip().removeprefix("url:").removeprefix("uri:")
+    s = s.removeprefix("URL:").removeprefix("URI:")
+    s = s.removeprefix("WWW:").removeprefix("www:").lstrip()
+    s = s.replace("http\\:", "http:")
+    s = s.replace("https\\:", "https:")
+    s = s.rstrip("/")
+    return s
+
+
+@lru_cache(1)
+def _get_converter() -> PreprocessingConverter:
+    return PreprocessingConverter(
+        converter=bioregistry.manager.converter,
+        rules=get_rules(),
+        preclean=_preclean_uri,
+    )
+
+
+def _parse_str_or_curie_or_uri_helper(
+    str_or_curie_or_uri: str,
+    *,
+    ontology_prefix: str | None = None,
+    node: Reference | None = None,
+    predicate: Reference | None = None,
+    upgrade: bool = True,
+    line: str | None = None,
+    name: str | None = None,
+    context: str | None = None,
+) -> Reference | ParseError | BlocklistError:
+    """Parse a string that looks like a CURIE.
+
+    :param str_or_curie_or_uri: A compact uniform resource identifier (CURIE)
+    :param ontology_prefix: The ontology in which the CURIE appears
+
+    :returns: A parse tuple or a tuple of None, None if not able to parse and not strict
+
+    - Normalizes the namespace
+    - Checks against a blacklist for the entire curie, for the namespace, and for
+      suffixes.
+    """
+    str_or_curie_or_uri = _preclean_uri(str_or_curie_or_uri)
+    if not str_or_curie_or_uri:
+        return EmptyStringError(
+            str_or_curie_or_uri,
+            ontology_prefix=ontology_prefix,
+            node=node,
+            predicate=predicate,
+            line=line,
+            context=context,
+        )
+
+    rules = get_rules()
+
+    if upgrade:
+        # Remap the curie with the full list
+        if r1 := rules.remap_full(
+            str_or_curie_or_uri, reference_cls=Reference, context=ontology_prefix
+        ):
+            return r1
+
+        # Remap node's prefix (if necessary)
+        str_or_curie_or_uri = rules.remap_prefix(str_or_curie_or_uri, context=ontology_prefix)
+
+        if r2 := ground_relation(str_or_curie_or_uri):
+            return r2
+
+    if rules.str_is_blocked(str_or_curie_or_uri, context=ontology_prefix):
+        return BlocklistError()
+
+    if _is_uri(str_or_curie_or_uri):
+        rt = bioregistry.parse_iri(
+            str_or_curie_or_uri, on_failure_return_type=FailureReturnType.single
+        )
+        if rt is None:
+            return UnparsableIRIError(
+                str_or_curie_or_uri,
+                ontology_prefix=ontology_prefix,
+                node=node,
+                predicate=predicate,
+                line=line,
+                context=context,
+            )
+        try:
+            rv = Reference.model_validate(
+                {"prefix": rt.prefix, "identifier": rt.identifier, "name": name}
+            )
+        except ValidationError as exc:
+            return ParseValidationError(
+                str_or_curie_or_uri,
+                ontology_prefix=ontology_prefix,
+                node=node,
+                predicate=predicate,
+                line=line,
+                context=context,
+                exc=exc,
+            )
+        else:
+            return rv
+
+    prefix, delimiter, identifier = str_or_curie_or_uri.partition(":")
+    if not delimiter:
+        return NotCURIEError(
+            str_or_curie_or_uri,
+            ontology_prefix=ontology_prefix,
+            node=node,
+            predicate=predicate,
+            line=line,
+            context=context,
+        )
+
+    norm_node_prefix = bioregistry.normalize_prefix(prefix)
+    if not norm_node_prefix:
+        return UnregisteredPrefixError(
+            str_or_curie_or_uri,
+            ontology_prefix=ontology_prefix,
+            node=node,
+            predicate=predicate,
+            line=line,
+            context=context,
+        )
+
+    identifier = bioregistry.standardize_identifier(norm_node_prefix, identifier)
+    try:
+        rv = Reference.model_validate(
+            {"prefix": norm_node_prefix, "identifier": identifier, "name": name}
+        )
+    except ValidationError as exc:
+        return ParseValidationError(
+            str_or_curie_or_uri,
+            ontology_prefix=ontology_prefix,
+            node=node,
+            predicate=predicate,
+            line=line,
+            exc=exc,
+            context=context,
+        )
+    else:
+        return rv
+
+
+def wrap_norm_prefix(f):
+    """Decorate a function that take in a prefix to auto-normalize, or return None if it can't be normalized."""
+
+    @wraps(f)
+    def _wrapped(prefix: str | Reference | ReferenceTuple, *args, **kwargs):
+        if isinstance(prefix, str):
+            norm_prefix = bioregistry.normalize_prefix(prefix)
+            if norm_prefix is None:
+                raise ValueError(f"Invalid prefix: {prefix}")
+            prefix = norm_prefix
+        elif isinstance(prefix, Reference):
+            norm_prefix = bioregistry.normalize_prefix(prefix.prefix)
+            if norm_prefix is None:
+                raise ValueError(f"Invalid prefix: {prefix.prefix}")
+            prefix = Reference(prefix=norm_prefix, identifier=prefix.identifier)
+        elif isinstance(prefix, ReferenceTuple):
+            norm_prefix = bioregistry.normalize_prefix(prefix.prefix)
+            if norm_prefix is None:
+                raise ValueError(f"Invalid prefix: {prefix.prefix}")
+            prefix = ReferenceTuple(norm_prefix, prefix.identifier)
+        else:
+            raise TypeError
+        return f(prefix, *args, **kwargs)
+
+    return _wrapped
+
+
+def standardize_ec(ec: str) -> str:
+    """Standardize an EC code identifier by removing all trailing dashes and dots."""
+    ec = ec.strip().replace(" ", "")
+    for _ in range(4):
+        ec = ec.rstrip("-").rstrip(".")
+    return ec
+
+
+def _is_valid_identifier(curie_or_uri: str) -> bool:
+    # TODO this needs more careful implementation
+    return bool(curie_or_uri.strip()) and " " not in curie_or_uri