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

pyobo/struct/obograph/reader.py

@@ -0,0 +1,242 @@
+"""Import of OBO Graph JSON."""
+
+import logging
+from pathlib import Path
+
+import curies
+import obographs
+from curies import Converter
+from curies.vocabulary import SynonymScope, synonym_scopes
+from obographs import (
+    Graph,
+    NodeType,
+    StandardizedGraph,
+    StandardizedMeta,
+    StandardizedNode,
+    StandardizedSynonym,
+)
+
+from pyobo import Obo, Reference, StanzaType, Synonym, Term, TypeDef
+from pyobo.identifier_utils import get_converter
+from pyobo.struct import Annotation, OBOLiteral, make_ad_hoc_ontology
+from pyobo.struct import vocabulary as v
+from pyobo.struct.typedef import has_ontology_root_term
+
+__all__ = [
+    "from_node",
+    "from_obograph",
+    "from_standardized_graph",
+    "read_obograph",
+]
+
+logger = logging.getLogger(__name__)
+
+
+def read_obograph(
+    prefix: str, path: str | Path, *, converter: Converter | None = None, strict: bool = False
+) -> Obo:
+    """Read an OBO Graph JSON file using :func:`obographs.read` then process into a PyOBO structure."""
+    graph = obographs.read(path, squeeze=True)
+    return from_obograph(prefix=prefix, graph=graph, converter=converter, strict=strict)
+
+
+def from_obograph(
+    prefix: str, graph: Graph, *, converter: Converter | None = None, strict: bool = False
+) -> Obo:
+    """Parse a raw OBO Graph JSON into a PyOBO structure."""
+    if converter is None:
+        converter = get_converter()
+    standardized_graph = graph.standardize(converter, strict=strict)
+    return from_standardized_graph(prefix, standardized_graph)
+
+
+def from_standardized_graph(prefix: str, graph: StandardizedGraph) -> Obo:
+    """Generate an OBO data structure from OBO Graph JSON."""
+    terms: dict[Reference, Term] = {}
+    typedefs: dict[Reference, TypeDef] = {}
+    for node in graph.nodes:
+        stanza = from_node(node)
+        match stanza:
+            case Term():
+                terms[stanza.reference] = stanza
+            case TypeDef():
+                typedefs[stanza.reference] = stanza
+
+    for edge in graph.edges:
+        s, p, o = (Reference.from_reference(r) for r in (edge.subject, edge.predicate, edge.object))
+        if s in terms:
+            stanza = terms[s]
+            stanza.append_relationship(p, o)
+        elif s in typedefs:
+            stanza = typedefs[s]
+            stanza.append_relationship(p, o)
+
+    root_terms: list[Reference] = []
+    property_values = []
+    auto_generated_by: str | None = None
+    if graph.meta:
+        for prop in graph.meta.properties or []:
+            predicate = Reference.from_reference(prop.predicate)
+            if predicate == has_ontology_root_term:
+                if isinstance(prop.value, str):
+                    raise TypeError
+                else:
+                    root_terms.append(Reference.from_reference(prop.value))
+            elif predicate == v.obo_autogenerated_by:
+                if not isinstance(prop.value, str):
+                    raise TypeError
+                auto_generated_by = prop.value
+            # TODO specific subsetdef, imports
+            else:
+                property_values.append(
+                    Annotation(
+                        predicate=predicate,
+                        # TODO obographs are limited by ability to specify datatype?
+                        value=OBOLiteral.string(prop.value)
+                        if isinstance(prop.value, str)
+                        else Reference.from_reference(prop.value),
+                    )
+                )
+
+    for equivalent_node_set in graph.equivalent_node_sets:
+        equivalent_reference = Reference.from_reference(equivalent_node_set.node)
+        if equivalent_reference in terms:
+            for equivalent in equivalent_node_set.equivalents:
+                terms[equivalent_reference].append_equivalent_to(
+                    Reference.from_reference(equivalent)
+                )
+        elif equivalent_reference in typedefs:
+            for equivalent in equivalent_node_set.equivalents:
+                typedefs[equivalent_reference].append_equivalent_to(
+                    Reference.from_reference(equivalent)
+                )
+        else:
+            logger.warning(
+                "unknown reference node in equivalent_node_set: %s", equivalent_reference.curie
+            )
+
+    for _domain_range_axiom in graph.domain_range_axioms or []:
+        p = Reference.from_reference(_domain_range_axiom.predicate)
+        if p not in typedefs:
+            continue
+        # the OBO Graph model allows for multiple ranges
+        # or domains, but OBO only one.
+        if _domain_range_axiom.ranges:
+            typedefs[p].range = Reference.from_reference(_domain_range_axiom.ranges[0])
+        if _domain_range_axiom.domains:
+            typedefs[p].domain = Reference.from_reference(_domain_range_axiom.domains[0])
+
+    for _property_chain_axiom in graph.property_chain_axioms:
+        p = Reference.from_reference(_property_chain_axiom.predicate)
+        if p not in typedefs or not _property_chain_axiom.chain:
+            continue
+        # TODO check if its also transitive_over and/or equivalent_to_chain
+        typedefs[p].holds_over_chain.append(
+            [Reference.from_reference(r) for r in _property_chain_axiom.chain]
+        )
+
+    for _logical_definition_axiom in graph.logical_definition_axioms:
+        pass  # TODO
+
+    return make_ad_hoc_ontology(
+        _ontology=prefix,
+        _name=graph.name,
+        terms=list(terms.values()),
+        _typedefs=list(typedefs.values()),
+        _root_terms=root_terms,
+        _property_values=property_values,
+        _data_version=graph.version or (graph.meta.version_iri if graph.meta is not None else None),
+        _auto_generated_by=auto_generated_by,
+    )
+
+
+#: A mapping between OBO Graph JSON node types and OBO stanza types
+MAPPING: dict[NodeType, StanzaType] = {
+    "CLASS": "Term",
+    "INDIVIDUAL": "Instance",
+    "PROPERTY": "TypeDef",
+}
+
+
+def from_node(node: StandardizedNode) -> Term | TypeDef:
+    """Generate a term from a node."""
+    if node.type == "PROPERTY":
+        return _from_property(node)
+    return _from_term(node)
+
+
+def _from_term(node: StandardizedNode) -> Term:
+    term = Term(
+        reference=_get_ref(node),
+        type=MAPPING[node.type] if node.type else "Term",
+    )
+    if node.meta is not None:
+        _process_term_meta(node.meta, term)
+    return term
+
+
+def _from_property(node: StandardizedNode) -> TypeDef:
+    typedef = TypeDef(
+        reference=_get_ref(node),
+        is_metadata_tag=node.property_type == "ANNOTATION",
+    )
+    if node.meta is not None:
+        _process_typedef_meta(node.meta, typedef)
+    return typedef
+
+
+def _get_ref(node: StandardizedNode) -> Reference:
+    return Reference(
+        prefix=node.reference.prefix,
+        identifier=node.reference.identifier,
+        name=node.label,
+    )
+
+
+def _process_term_meta(meta: StandardizedMeta, term: Term) -> None:
+    """Process the ``meta`` object associated with a term node."""
+    if meta.definition:
+        term.definition = meta.definition.value
+        for definition_xref in meta.definition.xrefs or []:
+            term.append_definition_xref(definition_xref)
+
+    if meta.subsets:
+        term.subsets.extend(Reference.from_reference(r) for r in meta.subsets)
+
+    for xref in meta.xrefs or []:
+        term.append_xref(xref.reference)
+
+    for synonym in meta.synonyms or []:
+        if s := _from_synonym(synonym):
+            term.append_synonym(s)
+
+    for comment in meta.comments or []:
+        term.append_comment(comment)
+
+    if meta.deprecated:
+        term.is_obsolete = True
+
+    for prop in meta.properties or []:
+        match prop.value:
+            case Reference():
+                term.annotate_object(prop.predicate, prop.value)
+            case str():
+                # note, OBO Graph format does not allow for annotating data type
+                term.annotate_literal(prop.predicate, OBOLiteral.string(prop.value))
+
+
+REV_SYNONYM_SCOPE: dict[curies.Reference, SynonymScope] = {v: k for k, v in synonym_scopes.items()}
+
+
+def _from_synonym(syn: StandardizedSynonym) -> Synonym | None:
+    return Synonym(
+        name=syn.text,
+        specificity=REV_SYNONYM_SCOPE[syn.predicate],
+        type=Reference.from_reference(syn.type) if syn.type is not None else None,
+        provenance=[Reference.from_reference(r) for r in syn.xrefs or []],
+    )
+
+
+def _process_typedef_meta(meta: StandardizedMeta, typedef: TypeDef) -> None:
+    """Process the ``meta`` object associated with a property node."""
+    # TODO everything else is in here

pyobo/struct/obograph/utils.py

@@ -0,0 +1,47 @@
+"""Testing utilities."""
+
+import unittest
+from typing import cast
+
+from curies import Reference
+from obographs import StandardizedGraph, StandardizedMeta
+
+__all__ = [
+    "assert_graph_equal",
+]
+
+
+def assert_graph_equal(
+    test_case: unittest.TestCase, expected: StandardizedGraph, actual: StandardizedGraph
+) -> None:
+    """Assert two graphs are equal."""
+    if expected.meta is not None:
+        test_case.assertIsNotNone(actual.meta)
+        test_case.assertEqual(
+            expected.meta.model_dump(exclude_unset=True, exclude_none=True, exclude_defaults=True),
+            cast(StandardizedMeta, actual.meta).model_dump(
+                exclude_unset=True, exclude_none=True, exclude_defaults=True
+            ),
+        )
+
+    # strip out extra info
+    for node in actual.nodes:
+        node.reference = Reference.from_reference(node.reference)
+
+    test_case.assertEqual(
+        {node.reference.curie: node for node in expected.nodes},
+        {node.reference.curie: node for node in actual.nodes},
+    )
+    test_case.assertEqual(
+        {node.as_str_triple(): node for node in expected.edges},
+        {node.as_str_triple(): node for node in actual.edges},
+    )
+    excludes = {"nodes", "edges", "meta"}
+    test_case.assertEqual(
+        expected.model_dump(
+            exclude_none=True, exclude_unset=True, exclude_defaults=True, exclude=excludes
+        ),
+        actual.model_dump(
+            exclude_none=True, exclude_unset=True, exclude_defaults=True, exclude=excludes
+        ),
+    )

pyobo/struct/struct.py

@@ -22,7 +22,7 @@ import curies
 import networkx as nx
 import pandas as pd
 import ssslm
-from curies import ReferenceTuple
+from curies import Converter, ReferenceTuple
 from curies import vocabulary as _cv
 from more_click import force_option, verbose_option
 from tqdm.auto import tqdm
@@ -84,6 +84,7 @@ __all__ = [
     "Synonym",
     "SynonymTypeDef",
     "Term",
+    "TypeDef",
     "abbreviation",
     "acronym",
     "make_ad_hoc_ontology",
@@ -91,9 +92,6 @@ __all__ = [
 
 logger = logging.getLogger(__name__)
 
-#: This is what happens if no specificity is given
-DEFAULT_SPECIFICITY: _cv.SynonymScope = "RELATED"
-
 #: Columns in the SSSOM dataframe
 SSSOM_DF_COLUMNS = [
     "subject_id",
@@ -104,7 +102,6 @@ SSSOM_DF_COLUMNS = [
     "confidence",
     "contributor",
 ]
-UNSPECIFIED_MATCHING_CURIE = "sempav:UnspecifiedMatching"
 FORMAT_VERSION = "1.4"
 
 
@@ -153,14 +150,14 @@ class Synonym(HasReferencesMixin):
     def _sort_key(self) -> tuple[str, _cv.SynonymScope, str]:
         return (
             self.name,
-            self.specificity or DEFAULT_SPECIFICITY,
+            self.specificity or _cv.DEFAULT_SYNONYM_SCOPE,
             self.type.curie if self.type else "",
         )
 
     @property
     def predicate(self) -> curies.NamedReference:
         """Get the specificity reference."""
-        return _cv.synonym_scopes[self.specificity or DEFAULT_SPECIFICITY]
+        return _cv.synonym_scopes[self.specificity or _cv.DEFAULT_SYNONYM_SCOPE]
 
     def to_obo(
         self,
@@ -189,7 +186,7 @@ class Synonym(HasReferencesMixin):
         elif self.type is not None:
             # it's not valid to have a synonym type without a specificity,
             # so automatically assign one if we'll need it
-            x = f"{x} {DEFAULT_SPECIFICITY}"
+            x = f"{x} {_cv.DEFAULT_SYNONYM_SCOPE}"
 
         # Add on the synonym type, if exists
         if self.type is not None:
@@ -429,9 +426,8 @@ class Term(Stanza):
         if self.definition:
             yield f"def: {self._definition_fp()}"
         # 7
-        for x in self.get_property_values(v.comment):
-            if isinstance(x, OBOLiteral):
-                yield f'comment: "{x.value}"'
+        for comment in self.get_comments():
+            yield f'comment: "{comment}"'
         # 8
         yield from _reference_list_tag("subset", self.subsets, ontology_prefix)
         # 9
@@ -723,17 +719,11 @@ class Obo:
         """Iterate over terms in this ontology."""
         raise NotImplementedError
 
-    def get_graph(self):
-        """Get an OBO Graph object."""
-        from ..obographs import graph_from_obo
-
-        return graph_from_obo(self)
-
-    def write_obograph(self, path: str | Path) -> None:
+    def write_obograph(self, path: str | Path, *, converter: Converter | None = None) -> None:
         """Write OBO Graph json."""
-        graph = self.get_graph()
-        with safe_open(path, read=False) as file:
-            file.write(graph.model_dump_json(indent=2, exclude_none=True, exclude_unset=True))
+        from . import obograph
+
+        obograph.write_obograph(self, path, converter=converter)
 
     @classmethod
     def cli(cls, *args, default_rewrite: bool = False) -> Any:
@@ -1642,13 +1632,13 @@ class Obo:
     #############
 
     def iterate_edges(
-        self, *, use_tqdm: bool = False
+        self, *, use_tqdm: bool = False, include_xrefs: bool = True
     ) -> Iterable[tuple[Stanza, TypeDef, Reference]]:
         """Iterate over triples of terms, relations, and their targets."""
         _warned: set[ReferenceTuple] = set()
         typedefs = self._index_typedefs()
         for stanza in self._iter_stanzas(use_tqdm=use_tqdm, desc=f"[{self.ontology}] edge"):
-            for predicate, reference in stanza._iter_edges():
+            for predicate, reference in stanza._iter_edges(include_xrefs=include_xrefs):
                 if td := self._get_typedef(stanza, predicate, _warned, typedefs):
                     yield stanza, td, reference
 

pyobo/struct/struct_utils.py

@@ -231,6 +231,8 @@ class Stanza(Referenced, HasReferencesMixin):
     ) -> None:
         self._axioms[_property_resolve(p, o)].append(annotation)
 
+    # TODO check different usages of this
+
     def append_equivalent(
         self,
         reference: ReferenceHint,
@@ -242,6 +244,15 @@ class Stanza(Referenced, HasReferencesMixin):
             stanza_type_to_eq_prop[self.type], reference, annotations=annotations
         )
 
+    def append_equivalent_to(
+        self, reference: ReferenceHint, *, annotations: Iterable[Annotation] | None = None
+    ) -> Self:
+        """Append to the "equivalent to" list."""
+        reference = _ensure_ref(reference)
+        self.equivalent_to.append(reference)
+        self._extend_annotations(stanza_type_to_eq_prop[self.type], reference, annotations)
+        return self
+
     def append_xref(
         self,
         reference: ReferenceHint,
@@ -317,15 +328,6 @@ class Stanza(Referenced, HasReferencesMixin):
         self.union_of.append(_ensure_ref(reference))
         return self
 
-    def append_equivalent_to(
-        self, reference: ReferenceHint, *, annotations: Iterable[Annotation] | None = None
-    ) -> Self:
-        """Append to the "equivalent to" list."""
-        reference = _ensure_ref(reference)
-        self.equivalent_to.append(reference)
-        self._extend_annotations(stanza_type_to_eq_prop[self.type], reference, annotations)
-        return self
-
     def _iterate_intersection_of_obo(self, *, ontology_prefix: str) -> Iterable[str]:
         for element in sorted(self.intersection_of, key=self._intersection_of_key):
             match element:
@@ -679,14 +681,18 @@ class Stanza(Referenced, HasReferencesMixin):
         """Add a comment property."""
         return self.annotate_string(v.comment, value, annotations=annotations, language=language)
 
+    def get_comments(self) -> list[str]:
+        """Get all comment strings."""
+        return [x.value for x in self.get_property_values(v.comment) if isinstance(x, OBOLiteral)]
+
     @property
     def alt_ids(self) -> Sequence[Reference]:
         """Get alternative terms."""
         return tuple(self.get_property_objects(v.alternative_term))
 
-    def get_edges(self) -> list[tuple[Reference, Reference]]:
+    def get_edges(self, *, include_xrefs: bool = True) -> list[tuple[Reference, Reference]]:
         """Get edges."""
-        return list(self._iter_edges())
+        return list(self._iter_edges(include_xrefs=include_xrefs))
 
     def _iter_parents(self) -> Iterable[tuple[Reference, Reference]]:
         parent_prop = stanza_type_to_prop[self.type]
@@ -702,7 +708,7 @@ class Stanza(Referenced, HasReferencesMixin):
                 case (predicate, target):
                     yield predicate, target
 
-    def _iter_edges(self) -> Iterable[tuple[Reference, Reference]]:
+    def _iter_edges(self, *, include_xrefs: bool = True) -> Iterable[tuple[Reference, Reference]]:
         # The following are "object" properties, meaning
         # they're part of the definition of the object
         yield from self.iterate_relations()
@@ -715,8 +721,10 @@ class Stanza(Referenced, HasReferencesMixin):
         for subset in self.subsets:
             yield v.in_subset, subset
         yield from self.iterate_object_properties()
-        for xref_reference in self.xrefs:
-            yield v.has_dbxref, xref_reference
+
+        if include_xrefs:
+            for xref_reference in self.xrefs:
+                yield v.has_dbxref, xref_reference
 
         # TODO disjoint_from
 

pyobo/struct/typedef.py

@@ -294,6 +294,10 @@ has_end_date = TypeDef(
 has_title = TypeDef(reference=v.has_title, is_metadata_tag=True)
 has_license = TypeDef(reference=v.has_license, is_metadata_tag=True)
 has_description = TypeDef(reference=v.has_description, is_metadata_tag=True)
+obo_autogenerated_by = TypeDef(reference=v.obo_autogenerated_by, is_metadata_tag=True)
+obo_has_format_version = TypeDef(reference=v.obo_has_format_version, is_metadata_tag=True)
+obo_is_metadata_tag = TypeDef(reference=v.obo_is_metadata_tag, is_metadata_tag=True)
+obo_has_id = TypeDef(reference=v.obo_has_id, is_metadata_tag=True)
 
 in_subset = TypeDef(reference=v.in_subset, is_metadata_tag=True)
 has_term_editor = TypeDef(reference=v.has_term_editor, is_metadata_tag=True)

pyobo/struct/vocabulary.py

@@ -47,6 +47,13 @@ has_dbxref = _c(_v.has_dbxref)
 
 in_subset = _c(_v.obo_in_subset)
 has_obo_namespace = _c(_v.obo_has_namespace)
+obo_is_metadata_tag = Reference(
+    prefix="oboinowl", identifier="is_metadata_tag", name="is metadata tag"
+)
+obo_has_id = Reference(prefix="oboinowl", identifier="id", name="has ID")
+obo_has_format_version = Reference(
+    prefix="oboinowl", identifier="hasOBOFormatVersion", name="has OBO format version"
+)
 obo_autogenerated_by = _c(_v.obo_autogenerated_by)
 obo_creation_date = _c(_v.obo_creation_date)
 

pyobo/version.py

@@ -12,7 +12,7 @@ __all__ = [
     "get_version",
 ]
 
-VERSION = "0.12.2"
+VERSION = "0.12.4"
 
 
 def get_git_hash() -> str:

{pyobo-0.12.2.dist-info → pyobo-0.12.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyobo
-Version: 0.12.2
+Version: 0.12.4
 Summary: A python package for handling and generating OBO
 Keywords: snekpack,cookiecutter,ontologies,biomedical ontologies,life sciences,natural sciences,bioinformatics,cheminformatics,Open Biomedical Ontologies,OBO
 Author: Charles Tapley Hoyt
@@ -45,7 +45,7 @@ Requires-Dist: zenodo-client>=0.3.6
 Requires-Dist: class-resolver>=0.6.0
 Requires-Dist: psycopg2-binary
 Requires-Dist: pydantic>=2.0
-Requires-Dist: curies>=0.10.13
+Requires-Dist: curies>=0.10.17
 Requires-Dist: curies-processing>=0.1.0
 Requires-Dist: python-dateutil
 Requires-Dist: networkx>=3.4
@@ -56,6 +56,7 @@ Requires-Dist: clinicaltrials-downloader>=0.0.2
 Requires-Dist: nih-reporter-downloader>=0.0.1
 Requires-Dist: typing-extensions
 Requires-Dist: rdflib
+Requires-Dist: obographs>=0.0.8
 Requires-Dist: ssslm[gilda] ; extra == 'gilda'
 Requires-Dist: ssslm[gilda-slim] ; extra == 'gilda-slim'
 Maintainer: Charles Tapley Hoyt