pyobo 0.12.2__py3-none-any.whl → 0.12.4__py3-none-any.whl

pyobo/__init__.py

@@ -57,20 +57,29 @@ from .api import (
 )
 from .getters import get_ontology
 from .ner import get_grounder, ground
-from .obographs import parse_results_from_obo
 from .plugins import (
     has_nomenclature_plugin,
     iter_nomenclature_plugins,
     run_nomenclature_plugin,
 )
-from .reader import from_obo_path, from_obonet
-from .struct import Obo, Reference, Synonym, SynonymTypeDef, Term, TypeDef, default_reference
+from .struct import (
+    Obo,
+    Reference,
+    StanzaType,
+    Synonym,
+    SynonymTypeDef,
+    Term,
+    TypeDef,
+    default_reference,
+)
+from .struct.obo import from_obo_path, from_obonet
 from .utils.path import ensure_path
 from .version import get_version
 
 __all__ = [
     "Obo",
     "Reference",
+    "StanzaType",
     "Synonym",
     "SynonymTypeDef",
     "Term",
@@ -138,6 +147,5 @@ __all__ = [
     "has_nomenclature_plugin",
     "is_descendent",
     "iter_nomenclature_plugins",
-    "parse_results_from_obo",
     "run_nomenclature_plugin",
 ]

pyobo/api/names.py

@@ -166,7 +166,14 @@ def get_references(prefix: str, **kwargs: Unpack[GetOntologyKwargs]) -> set[Refe
         ontology = get_ontology(prefix, **kwargs)
         return sorted(ontology.iterate_references())
 
-    return set(_get_references())
+    try:
+        return set(_get_references())
+    except NoBuildError:
+        logger.debug("[%s] no build", prefix)
+        return set()
+    except (Exception, subprocess.CalledProcessError) as e:
+        logger.exception("[%s v%s] could not load: %s", prefix, version, e)
+        return set()
 
 
 @lru_cache

pyobo/getters.py

@@ -33,8 +33,8 @@ from .constants import (
 )
 from .identifier_utils import ParseError, wrap_norm_prefix
 from .plugins import has_nomenclature_plugin, run_nomenclature_plugin
-from .reader import from_obo_path, from_obonet
 from .struct import Obo
+from .struct.obo import from_obo_path, from_obonet
 from .utils.io import safe_open_writer
 from .utils.path import ensure_path, prefix_directory_join
 from .version import get_git_hash, get_version
@@ -159,13 +159,20 @@ def get_ontology(
     elif ontology_format == "obo":
         pass  # all gucci
     elif ontology_format == "owl":
-        from bioontologies import robot
+        import bioontologies.robot
 
         _converted_obo_path = path.with_suffix(".obo")
         if prefix in REQUIRES_NO_ROBOT_CHECK:
             robot_check = False
-        robot.convert(path, _converted_obo_path, check=robot_check)
+        bioontologies.robot.convert(path, _converted_obo_path, check=robot_check)
         path = _converted_obo_path
+    elif ontology_format == "json":
+        from .struct.obograph import read_obograph
+
+        obo = read_obograph(prefix=prefix, path=path)
+        if cache:
+            obo.write_default(force=force_process)
+        return obo
     else:
         raise UnhandledFormatError(f"[{prefix}] unhandled ontology file format: {path.suffix}")
 

pyobo/identifier_utils/__init__.py

@@ -12,6 +12,7 @@ from .api import (
     UnregisteredPrefixError,
     _is_valid_identifier,
     _parse_str_or_curie_or_uri_helper,
+    get_converter,
     standardize_ec,
     wrap_norm_prefix,
 )
@@ -27,6 +28,7 @@ __all__ = [
     "UnregisteredPrefixError",
     "_is_valid_identifier",
     "_parse_str_or_curie_or_uri_helper",
+    "get_converter",
     "get_rules",
     "ground_relation",
     "standardize_ec",

pyobo/identifier_utils/api.py

@@ -135,9 +135,10 @@ def _preclean_uri(s: str) -> str:
 
 
 @lru_cache(1)
-def _get_converter() -> PreprocessingConverter:
+def get_converter() -> PreprocessingConverter:
+    """Get a converter."""
     return PreprocessingConverter(
-        converter=bioregistry.manager.converter,
+        records=bioregistry.manager.converter.records,
         rules=get_rules(),
         preclean=_preclean_uri,
     )

pyobo/sources/__init__.py

@@ -27,6 +27,7 @@ from .gtdb import GTDBGetter
 from .gwascentral import GWASCentralPhenotypeGetter, GWASCentralStudyGetter
 from .hgnc import HGNCGetter, HGNCGroupGetter
 from .icd import ICD10Getter, ICD11Getter
+from .intact import IntactGetter
 from .interpro import InterProGetter
 from .itis import ITISGetter
 from .kegg import KEGGGeneGetter, KEGGGenomeGetter, KEGGPathwayGetter
@@ -102,6 +103,7 @@ __all__ = [
     "ICD10Getter",
     "ICD11Getter",
     "ITISGetter",
+    "IntactGetter",
     "InterProGetter",
     "KEGGGeneGetter",
     "KEGGGenomeGetter",

pyobo/sources/drugbank/drugbank.py

@@ -149,7 +149,7 @@ def get_xml_root(version: str | None = None) -> ElementTree.Element:
         raise NoBuildError from e
 
     element = parse_drugbank(version=version, username=username, password=password)
-    return element.getroot()
+    return element.getroot()  # type:ignore
 
 
 ns = "{http://www.drugbank.ca}"

pyobo/sources/gwascentral/gwascentral_study.py

@@ -79,7 +79,7 @@ def iterate_terms(version: str, force: bool = False) -> Iterable[Term]:
                 except ElementTree.ParseError:
                     logger.warning("malformed XML in %s", tar_info.path)
                     continue
-            yield _get_term_from_tree(tree)
+            yield _get_term_from_tree(tree)  # type:ignore
 
 
 if __name__ == "__main__":

pyobo/sources/intact.py

@@ -0,0 +1,79 @@
+"""Converter for IntAct complexes."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Iterable
+
+import pandas as pd
+from pydantic import ValidationError
+from tqdm import tqdm
+
+from pyobo.struct import Obo, Reference, Term
+from pyobo.utils.path import ensure_path
+
+__all__ = [
+    "IntactGetter",
+]
+
+PREFIX = "intact"
+COMPLEXPORTAL_MAPPINGS_UNVERSIONED = (
+    "https://ftp.ebi.ac.uk/pub/databases/intact/complex/current/various/cpx_ebi_ac_translation.txt"
+)
+REACTOME_MAPPINGS_UNVERSIONED = (
+    "https://ftp.ebi.ac.uk/pub/databases/intact/current/various/reactome.dat"
+)
+
+
+# TODO it looks like it's probably also the case that
+#  this semantic space contains IDs for proteins/
+#  interactors. These need to be added too
+
+
+class IntactGetter(Obo):
+    """An ontology representation of Intact."""
+
+    bioversions_key = ontology = PREFIX
+
+    def iter_terms(self, force: bool = False) -> Iterable[Term]:
+        """Iterate over terms in the ontology."""
+        return get_terms(force=force, version=self._version_or_raise)
+
+
+def get_terms(version: str, force: bool = False) -> Iterable[Term]:
+    """Get terms from the Contributor Roles Taxonomy via GitHub."""
+    cplx = _get_mappings(
+        COMPLEXPORTAL_MAPPINGS_UNVERSIONED, "complexportal", version=version, force=force
+    )
+    reactome = _get_mappings(
+        REACTOME_MAPPINGS_UNVERSIONED, "reactome", version=version, force=force
+    )
+    for intact_id in sorted(set(cplx).union(reactome)):
+        term = Term.from_triple(PREFIX, intact_id)
+        for complexportal_xref in sorted(cplx.get(intact_id, [])):
+            term.append_exact_match(complexportal_xref)
+        for reactome_xref in sorted(reactome.get(intact_id, [])):
+            term.append_xref(reactome_xref)
+        yield term
+
+
+def _get_mappings(
+    url: str, target_prefix: str, version: str, *, force: bool = False
+) -> dict[str, set[Reference]]:
+    path = ensure_path(PREFIX, url=url, version=version, force=force)
+    df = pd.read_csv(path, sep="\t", header=None, usecols=[0, 1])
+
+    dd = defaultdict(set)
+    for intact_id, target_identifier in df.values:
+        try:
+            obj = Reference(prefix=target_prefix, identifier=target_identifier)
+        except ValidationError:
+            tqdm.write(f"[intact:{intact_id}] invalid xref: {target_prefix}:{target_identifier}")
+            continue
+        dd[intact_id].add(obj)
+
+    return dict(dd)
+
+
+if __name__ == "__main__":
+    IntactGetter.cli()

pyobo/struct/__init__.py

@@ -18,7 +18,7 @@ from .struct import (
     TypeDef,
     make_ad_hoc_ontology,
 )
-from .struct_utils import Annotation, Stanza
+from .struct_utils import Annotation, Stanza, StanzaType
 from .typedef import (
     derives_from,
     enables,
@@ -51,6 +51,7 @@ __all__ = [
     "Reference",
     "Referenced",
     "Stanza",
+    "StanzaType",
     "Synonym",
     "SynonymTypeDef",
     "Term",

pyobo/struct/functional/ontology.py

@@ -250,7 +250,7 @@ class Import(Box):
 
 def get_rdf_graph_oracle(boxes: list[Box], *, prefix_map: dict[str, str]) -> Graph:
     """Serialize to turtle via OFN and conversion with ROBOT."""
-    from bioontologies.robot import convert
+    import bioontologies.robot
 
     ontology = Ontology(
         iri=EXAMPLE_ONTOLOGY_IRI,
@@ -265,7 +265,7 @@ def get_rdf_graph_oracle(boxes: list[Box], *, prefix_map: dict[str, str]) -> Gra
         ofn_path.write_text(text)
         ttl_path = stub.with_suffix(".ttl")
         try:
-            convert(ofn_path, ttl_path)
+            bioontologies.robot.convert(ofn_path, ttl_path)
         except subprocess.CalledProcessError:
             raise RuntimeError(f"failed to convert axioms from:\n\n{text}") from None
         graph.parse(ttl_path)

pyobo/struct/obo/__init__.py

@@ -0,0 +1,9 @@
+"""OBO Flat file format."""
+
+from .reader import from_obo_path, from_obonet, from_str
+
+__all__ = [
+    "from_obo_path",
+    "from_obonet",
+    "from_str",
+]

pyobo/{reader.py → struct/obo/reader.py}

@@ -20,15 +20,6 @@ from curies.vocabulary import SynonymScope
 from more_itertools import pairwise
 from tqdm.auto import tqdm
 
-from .constants import DATE_FORMAT, PROVENANCE_PREFIXES
-from .identifier_utils import (
-    NotCURIEError,
-    ParseError,
-    UnparsableIRIError,
-    _is_valid_identifier,
-    _parse_str_or_curie_or_uri_helper,
-    get_rules,
-)
 from .reader_utils import (
     _chomp_axioms,
     _chomp_references,
@@ -36,7 +27,9 @@ from .reader_utils import (
     _chomp_typedef,
     _parse_provenance_list,
 )
-from .struct import (
+from .. import vocabulary as v
+from ..reference import OBOLiteral, _obo_parse_identifier
+from ..struct import (
     Obo,
     Reference,
     Synonym,
@@ -46,18 +39,26 @@ from .struct import (
     default_reference,
     make_ad_hoc_ontology,
 )
-from .struct import vocabulary as v
-from .struct.reference import OBOLiteral, _obo_parse_identifier
-from .struct.struct_utils import Annotation, Stanza
-from .struct.typedef import comment as has_comment
-from .struct.typedef import default_typedefs, has_ontology_root_term
-from .utils.cache import write_gzipped_graph
-from .utils.io import safe_open
-from .utils.misc import STATIC_VERSION_REWRITES, cleanup_version
+from ..struct_utils import Annotation, Stanza
+from ..typedef import comment as has_comment
+from ..typedef import default_typedefs, has_ontology_root_term
+from ...constants import DATE_FORMAT, PROVENANCE_PREFIXES
+from ...identifier_utils import (
+    NotCURIEError,
+    ParseError,
+    UnparsableIRIError,
+    _is_valid_identifier,
+    _parse_str_or_curie_or_uri_helper,
+    get_rules,
+)
+from ...utils.cache import write_gzipped_graph
+from ...utils.io import safe_open
+from ...utils.misc import STATIC_VERSION_REWRITES, cleanup_version
 
 __all__ = [
     "from_obo_path",
     "from_obonet",
+    "from_str",
 ]
 
 logger = logging.getLogger(__name__)
@@ -1353,6 +1354,8 @@ def _handle_prop(
             case None:
                 return None
 
+    return None
+
 
 def _get_prop(
     property_id: str,

pyobo/struct/obograph/__init__.py

@@ -0,0 +1,16 @@
+"""I/O for OBO Graph JSON."""
+
+from .export import to_obograph, to_parsed_obograph, to_parsed_obograph_oracle, write_obograph
+from .reader import from_obograph, from_standardized_graph, read_obograph
+from .utils import assert_graph_equal
+
+__all__ = [
+    "assert_graph_equal",
+    "from_obograph",
+    "from_standardized_graph",
+    "read_obograph",
+    "to_obograph",
+    "to_parsed_obograph",
+    "to_parsed_obograph_oracle",
+    "write_obograph",
+]

pyobo/struct/obograph/export.py

@@ -0,0 +1,315 @@
+"""Exports to OBO Graph JSON."""
+
+import tempfile
+from pathlib import Path
+
+import bioregistry
+import curies
+import obographs as og
+from curies import Converter, ReferenceTuple
+from curies import vocabulary as v
+
+from pyobo.identifier_utils.api import get_converter
+from pyobo.struct import Obo, OBOLiteral, Stanza, Term, TypeDef
+from pyobo.struct import typedef as tdv
+from pyobo.utils.io import safe_open
+
+__all__ = [
+    "to_obograph",
+    "to_parsed_obograph",
+    "write_obograph",
+]
+
+
+def write_obograph(obo: Obo, path: str | Path, *, converter: Converter | None = None) -> None:
+    """Write an ontology to a file as OBO Graph JSON."""
+    path = Path(path).expanduser().resolve()
+    raw_graph = to_obograph(obo, converter=converter)
+    with safe_open(path, read=False) as file:
+        file.write(raw_graph.model_dump_json(indent=2, exclude_none=True, exclude_unset=True))
+
+
+def to_parsed_obograph_oracle(
+    obo: Obo, *, converter: Converter | None = None
+) -> og.StandardizedGraphDocument:
+    """Serialize to OBO, convert to OBO Graph JSON with ROBOT, load, then parse."""
+    import bioontologies.robot
+
+    if converter is None:
+        converter = get_converter()
+
+    with tempfile.TemporaryDirectory() as directory:
+        stub = Path(directory).joinpath("test")
+        obo_path = stub.with_suffix(".obo")
+        obograph_path = stub.with_suffix(".json")
+        obo.write_obo(obo_path)
+        bioontologies.robot.convert(input_path=obo_path, output_path=obograph_path)
+        raw = og.read(obograph_path, squeeze=False)
+    rv = raw.standardize(converter)
+    for graph in rv.graphs:
+        if graph.meta and graph.meta.properties:
+            graph.meta.properties = [
+                p
+                for p in graph.meta.properties
+                if p.predicate.pair
+                != ReferenceTuple(prefix="oboinowl", identifier="hasOBOFormatVersion")
+            ] or None
+    return rv
+
+
+def to_obograph(obo: Obo, *, converter: Converter | None = None) -> og.GraphDocument:
+    """Convert an ontology to a OBO Graph JSON document."""
+    if converter is None:
+        converter = get_converter()
+    return to_parsed_obograph(obo).to_raw(converter)
+
+
+def to_parsed_obograph(obo: Obo) -> og.StandardizedGraphDocument:
+    """Convert an ontology to a processed OBO Graph JSON document."""
+    return og.StandardizedGraphDocument(graphs=[_to_parsed_graph(obo)])
+
+
+def _to_parsed_graph(obo: Obo) -> og.StandardizedGraph:
+    return og.StandardizedGraph(
+        id=f"http://purl.obolibrary.org/obo/{obo.ontology}.owl",
+        meta=_get_meta(obo),
+        nodes=_get_nodes(obo),
+        edges=_get_edges(obo),
+        equivalent_node_sets=_get_equivalent_node_sets(obo),
+        property_chain_axioms=_get_property_chain_axioms(obo),
+        domain_range_axioms=_get_domain_ranges(obo),
+        logical_definition_axioms=_get_logical_definition_axioms(obo),
+    )
+
+
+def _get_logical_definition_axioms(obo: Obo) -> list[og.StandardizedLogicalDefinition]:
+    rv: list[og.StandardizedLogicalDefinition] = []
+    # TODO
+    return rv
+
+
+def _get_domain_ranges(obo: Obo) -> list[og.StandardizedDomainRangeAxiom]:
+    rv = []
+    for typedef in obo.typedefs or []:
+        if typedef.domain or typedef.range:
+            rv.append(
+                og.StandardizedDomainRangeAxiom(
+                    predicate=typedef.reference,
+                    domains=[typedef.domain] if typedef.domain else [],
+                    ranges=[typedef.range] if typedef.range else [],
+                )
+            )
+    return rv
+
+
+def _get_equivalent_node_sets(obo: Obo) -> list[og.StandardizedEquivalentNodeSet]:
+    rv = []
+    for node in obo:
+        for e in node.equivalent_to:
+            rv.append(og.StandardizedEquivalentNodeSet(node=node.reference, equivalents=[e]))
+    return rv
+
+
+def _get_property_chain_axioms(obo: Obo) -> list[og.StandardizedPropertyChainAxiom]:
+    rv = []
+    for typedef in obo.typedefs or []:
+        for chain in typedef.holds_over_chain:
+            rv.append(
+                og.StandardizedPropertyChainAxiom(
+                    predicate=typedef.reference,
+                    chain=chain,
+                )
+            )
+        # TODO typedef.equivalent_to_chain
+    return rv
+
+
+def _get_meta(obo: Obo) -> og.StandardizedMeta | None:
+    properties = []
+
+    if description := bioregistry.get_description(obo.ontology):
+        properties.append(
+            og.StandardizedProperty(
+                predicate=v.has_description,
+                value=description,
+            )
+        )
+
+        for root_term in obo.root_terms or []:
+            properties.append(
+                og.StandardizedProperty(
+                    predicate=v.has_ontology_root_term,
+                    value=root_term,
+                )
+            )
+
+    if license_spdx_id := bioregistry.get_license(obo.ontology):
+        properties.append(
+            og.StandardizedProperty(
+                predicate=v.has_license,
+                value=license_spdx_id,
+            )
+        )
+
+    if obo.name:
+        properties.append(
+            og.StandardizedProperty(
+                predicate=v.has_title,
+                value=obo.name,
+            )
+        )
+
+    for p in obo.property_values or []:
+        properties.append(
+            og.StandardizedProperty(
+                predicate=p.predicate,
+                value=p.value.value if isinstance(p.value, OBOLiteral) else p.value,
+            )
+        )
+
+    if obo.data_version:
+        version_iri = (
+            f"http://purl.obolibrary.org/obo/{obo.ontology}/{obo.data_version}/{obo.ontology}.owl"
+        )
+    else:
+        version_iri = None
+
+    # comments don't make the round trip
+    subsets = [r for r, _ in obo.subsetdefs or []] or None
+
+    if not properties and not version_iri and not subsets:
+        return None
+
+    return og.StandardizedMeta(
+        properties=properties or None,
+        version_iri=version_iri,
+        subsets=subsets,
+    )
+
+
+def _get_nodes(obo: Obo) -> list[og.StandardizedNode]:
+    rv = []
+    for term in obo:
+        rv.append(_get_class_node(term))
+    for typedef in _get_typedefs(obo):
+        rv.append(_get_typedef_node(typedef))
+    return rv
+
+
+def _get_typedefs(obo: Obo) -> set[TypeDef]:
+    rv = set(obo.typedefs or [])
+    if obo.auto_generated_by:
+        rv.add(tdv.obo_autogenerated_by)
+    return rv
+
+
+def _get_definition(stanza: Stanza) -> og.StandardizedDefinition | None:
+    if not stanza.definition:
+        return None
+    return og.StandardizedDefinition(
+        value=stanza.definition,
+        xrefs=[p for p in stanza.provenance if isinstance(p, curies.Reference)],
+    )
+
+
+def _get_synonyms(stanza: Stanza) -> list[og.StandardizedSynonym] | None:
+    return [
+        og.StandardizedSynonym(
+            text=synonym.name,
+            predicate=v.synonym_scopes[synonym.specificity]
+            if synonym.specificity is not None
+            else v.has_related_synonym,
+            type=synonym.type,
+            xrefs=[p for p in synonym.provenance if isinstance(p, curies.Reference)],
+        )
+        for synonym in stanza.synonyms
+    ] or None
+
+
+def _get_properties(term: Stanza) -> list[og.StandardizedProperty] | None:
+    properties = []
+    for predicate, obj in term.iterate_object_properties():
+        properties.append(
+            og.StandardizedProperty(
+                predicate=predicate,
+                value=obj,
+            )
+        )
+    for predicate, literal in term.iterate_literal_properties():
+        properties.append(
+            og.StandardizedProperty(
+                predicate=predicate,
+                value=literal.value,
+            )
+        )
+    return properties or None
+
+
+def _get_xrefs(stanza: Stanza) -> list[og.StandardizedXref] | None:
+    return [og.StandardizedXref(reference=xref) for xref in stanza.xrefs] or None
+
+
+def _meta_or_none(meta: og.StandardizedMeta) -> og.StandardizedMeta | None:
+    if all(
+        x is None
+        for x in (
+            meta.definition,
+            meta.subsets,
+            meta.xrefs,
+            meta.synonyms,
+            meta.comments,
+            meta.version_iri,
+            meta.properties,
+        )
+    ):
+        return None
+    return meta
+
+
+def _get_class_node(term: Term) -> og.StandardizedNode:
+    meta = og.StandardizedMeta(
+        definition=_get_definition(term),
+        subsets=term.subsets or None,
+        xrefs=_get_xrefs(term),
+        synonyms=_get_synonyms(term),
+        comments=term.get_comments() or None,
+        deprecated=term.is_obsolete or False,
+        properties=_get_properties(term),
+    )
+    return og.StandardizedNode(
+        reference=term.reference,
+        label=term.name,
+        meta=_meta_or_none(meta),
+        type="CLASS" if term.type == "Term" else "INDIVIDUAL",
+    )
+
+
+def _get_typedef_node(typedef: TypeDef) -> og.StandardizedNode:
+    meta = og.StandardizedMeta(
+        definition=_get_definition(typedef),
+        subsets=typedef.subsets or None,
+        xrefs=_get_xrefs(typedef),
+        synonyms=_get_synonyms(typedef),
+        comments=typedef.get_comments() or None,
+        deprecated=typedef.is_obsolete or False,
+        properties=_get_properties(typedef),
+    )
+    return og.StandardizedNode(
+        reference=typedef.reference,
+        label=typedef.name,
+        meta=_meta_or_none(meta),
+        type="PROPERTY",
+        property_type="ANNOTATION" if typedef.is_metadata_tag else "OBJECT",
+    )
+
+
+def _get_edges(obo: Obo) -> list[og.StandardizedEdge]:
+    rv = [
+        og.StandardizedEdge(
+            subject=stanza.reference,
+            predicate=typedef.reference,
+            object=target,
+        )
+        for stanza, typedef, target in obo.iterate_edges(include_xrefs=False)
+    ]
+    return rv