oaklib 0.2.6__tar.gz → 0.2.8__tar.gz

{oaklib-0.2.6 → oaklib-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: oaklib
-Version: 0.2.6
+Version: 0.2.8
 Summary: Ontology Access Kit: Python library for common ontology operations over a variety of backends
 Author: cmungall
 Author-email: cjm@berkeleybop.org

{oaklib-0.2.6 → oaklib-0.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "oaklib"
-version = "v0.2.6"
+version = "v0.2.8"
 description = "Ontology Access Kit: Python library for common ontology operations over a variety of backends"
 authors = ["cmungall <cjm@berkeleybop.org>"]
 

{oaklib-0.2.6 → oaklib-0.2.8}/src/oaklib/__init__.py

@@ -6,6 +6,6 @@ __version__ = "0.1.0"
 
 from oaklib.interfaces import BasicOntologyInterface  # noqa:F401
 from oaklib.resource import OntologyResource  # noqa:F401
-from oaklib.selector import get_implementation_from_shorthand  # noqa:F401
+from oaklib.selector import get_adapter, get_implementation_from_shorthand  # noqa:F401
 
 schemes = {}

{oaklib-0.2.6 → oaklib-0.2.8}/src/oaklib/cli.py

@@ -11,7 +11,6 @@ import logging
 import os
 import re
 import secrets
-import subprocess
 import sys
 from collections import defaultdict
 from dataclasses import dataclass
@@ -744,6 +743,18 @@ def query_terms_iterator(query_terms: NESTED_LIST, impl: BasicOntologyInterface)
                 chain_results(impl.ancestors(rest, predicates=this_predicates))
             else:
                 raise NotImplementedError
+        elif term.startswith(".mrca"):
+            # graph query: most recent common ancestors
+            params = _parse_params(term)
+            this_predicates = params.get("predicates", predicates)
+            rest = list(query_terms_iterator([query_terms[0]], impl))
+            query_terms = query_terms[1:]
+            if isinstance(impl, SemanticSimilarityInterface):
+                chain_results(
+                    impl.setwise_most_recent_common_ancestors(rest, predicates=this_predicates)
+                )
+            else:
+                raise NotImplementedError
         else:
             # term is not query syntax: feed directly to search
             if not isinstance(impl, SearchInterface):
@@ -1698,11 +1709,9 @@ def viz(
     if output_type:
         write_graph(graph, format=output_type, output=output)
     else:
-        imgfile = graph_to_image(
-            graph, seeds=curies, stylemap=stylemap, configure=configure, imgfile=output
+        graph_to_image(
+            graph, seeds=curies, stylemap=stylemap, configure=configure, imgfile=output, view=view
         )
-        if view:
-            subprocess.run(["open", imgfile])
 
 
 @main.command()
@@ -2169,10 +2178,14 @@ def paths(
         else:
             if stylemap is None:
                 stylemap = default_stylemap_path()
-            imgfile = graph_to_image(
-                path_graph, seeds=all_curies, imgfile=output, stylemap=stylemap, configure=configure
+            graph_to_image(
+                path_graph,
+                seeds=all_curies,
+                imgfile=output,
+                stylemap=stylemap,
+                configure=configure,
+                view=viz,
             )
-            subprocess.run(["open", imgfile])
 
 
 @main.command()
@@ -2266,6 +2279,12 @@ def descendants(
     show_default=True,
     help="For formats that export only IS_A by default, this will include all possible predicates",
 )
+@click.option(
+    "--enforce-canonical-ordering/--no-enforce-canonical-ordering",
+    default=False,
+    show_default=True,
+    help="Forces the serialization to be in canonical order, which is useful for diffing",
+)
 @output_type_option
 def dump(terms, output, output_type: str, **kwargs):
     """

{oaklib-0.2.6 → oaklib-0.2.8}/src/oaklib/converters/data_model_converter.py

@@ -21,6 +21,9 @@ class DataModelConverter(ABC):
     labeler: Callable[[CURIE], Optional[str]] = None
     """A function that returns a label for a given CURIE"""
 
+    enforce_canonical_ordering: Optional[bool] = None
+    """If True, will enforce canonical ordering of keys in the output"""
+
     def __hash__(self):
         return hash(str(self))
 

{oaklib-0.2.6 → oaklib-0.2.8}/src/oaklib/implementations/__init__.py

@@ -1,3 +1,6 @@
+"""
+This package serves as the master index for all implementations.
+"""
 from functools import cache
 
 from class_resolver import ClassResolver
@@ -70,6 +73,26 @@ __all__ = [
 
 @cache
 def get_implementation_resolver() -> ClassResolver[OntologyInterface]:
+    """
+    Get a class resolver for all implementations (adapters).
+
+    See `<https://class-resolver.readthedocs.io/>`_
+
+    Note that typical OAK users should never need to call this directly;
+    this is used by OAK to dynamically select the right implementation given
+    a selector descriptions
+
+    As far as possible we try and use generic mechanisms to resolve.
+
+    Any class specified in __all__ above will be checked to see if it inherits from
+    OntologyInterface.
+
+    If the class name ends with "Implementation" (which is the convention in OAK
+    for all implementations), then it should be available here, wiith a descriptor
+    name that is downcases class name, with "Implementation" removed.
+
+    :return: A ClassResolver capable of resolving an OntologyInterface implementation
+    """
     implementation_resolver: ClassResolver[OntologyInterface] = ClassResolver.from_subclasses(
         OntologyInterface,
         suffix="Implementation",
@@ -78,6 +101,9 @@ def get_implementation_resolver() -> ClassResolver[OntologyInterface]:
             BaseOlsImplementation,
         },
     )
+    # if an implementation uses a shorthand name that is
+    # different from the class name (minus Implementation), then
+    # it should be added here
     implementation_resolver.synonyms.update(
         {
             "obolibrary": ProntoImplementation,

{oaklib-0.2.6 → oaklib-0.2.8}/src/oaklib/implementations/pronto/pronto_implementation.py

@@ -582,10 +582,14 @@ class ProntoImplementation(
         shutil.copyfile(self.resource.slug, resource.slug)
         return type(self)(resource)
 
-    def dump(self, path: str = None, syntax: str = "obo", **kwargs):
+    def dump(
+        self, path: str = None, syntax: str = "obo", enforce_canonical_ordering=False, **kwargs
+    ):
         if syntax is None:
             syntax = "obo"
         if syntax in ["obo", "json"]:
+            if enforce_canonical_ordering:
+                raise NotImplementedError("enforce_canonical_ordering not implemented for pronto")
             # TODO: simplify the logic here; not clear why pronto wants a binary file
             if isinstance(path, str):
                 with open(path, "wb") as file:

{oaklib-0.2.6 → oaklib-0.2.8}/src/oaklib/implementations/simpleobo/simple_obo_implementation.py

@@ -774,21 +774,26 @@ class SimpleOboImplementation(
         od = self.obo_document
         tidy_change_object(patch)
         logging.debug(f"Applying {patch}")
+        modified_entities = []
         if isinstance(patch, kgcl.NodeRename):
             # self.set_label(patch.about_node, _clean(patch.new_value))
             self.set_label(patch.about_node, patch.new_value)
+            modified_entities.append(patch.about_node)
         elif isinstance(patch, kgcl.NodeObsoletion):
             t = self._stanza(patch.about_node, strict=True)
             t.set_singular_tag(TAG_IS_OBSOLETE, "true")
             if isinstance(patch, kgcl.NodeObsoletionWithDirectReplacement):
                 t.set_singular_tag(TAG_REPLACED_BY, patch.has_direct_replacement)
+            modified_entities.append(patch.about_node)
         elif isinstance(patch, kgcl.NodeDeletion):
             t = self._stanza(patch.about_node, strict=True)
             od.stanzas = [s for s in od.stanzas if s.id != patch.about_node]
         elif isinstance(patch, kgcl.NodeCreation):
             self.create_entity(patch.about_node, patch.name)
+            modified_entities.append(patch.about_node)
         elif isinstance(patch, kgcl.ClassCreation):
             self.create_entity(patch.about_node, patch.name)
+            modified_entities.append(patch.about_node)
         elif isinstance(patch, kgcl.SynonymReplacement):
             t = self._stanza(patch.about_node, strict=True)
             n = 0
@@ -800,6 +805,7 @@ class SimpleOboImplementation(
                         n += 1
             if not n:
                 raise ValueError(f"Failed to find synonym {patch.old_value} for {t.id}")
+            modified_entities.append(patch.about_node)
         elif isinstance(patch, kgcl.NodeTextDefinitionChange):
             t = self._stanza(patch.about_node, strict=True)
             for tv in t.tag_values:
@@ -808,6 +814,7 @@ class SimpleOboImplementation(
         elif isinstance(patch, kgcl.NewTextDefinition):
             t = self._stanza(patch.about_node, strict=True)
             t.add_tag_value(TAG_DEFINITION, patch.new_value)
+            modified_entities.append(patch.about_node)
         elif isinstance(patch, kgcl.NewSynonym):
             t = self._stanza(patch.about_node, strict=True)
             # Get scope from patch.qualifier
@@ -818,6 +825,7 @@ class SimpleOboImplementation(
                 scope = str(patch.qualifier.value).upper() if patch.qualifier else "RELATED"
             v = patch.new_value.replace('"', '\\"')
             t.add_tag_value(TAG_SYNONYM, f'"{v}" {scope} []')
+            modified_entities.append(patch.about_node)
         elif isinstance(patch, kgcl.RemoveSynonym):
             t = self._stanza(patch.about_node, strict=True)
             # scope = str(patch.qualifier.value).upper() if patch.qualifier else "RELATED"
@@ -825,6 +833,7 @@ class SimpleOboImplementation(
             t.remove_simple_tag_value(TAG_SYNONYM, f'"{v}"')
         elif isinstance(patch, kgcl.EdgeCreation):
             self.add_relationship(patch.subject, patch.predicate, patch.object)
+            modified_entities.append(patch.subject)
         elif isinstance(patch, kgcl.EdgeDeletion):
             self.remove_relationship(patch.subject, patch.predicate, patch.object)
         elif isinstance(patch, kgcl.NodeMove):
@@ -844,8 +853,13 @@ class SimpleOboImplementation(
             else:
                 t.add_tag_value(TAG_RELATIONSHIP, f"{patch.new_value} {object}")
             self._clear_relationship_index()
+            modified_entities.append(subject)
         else:
             raise NotImplementedError(f"cannot handle KGCL type {type(patch)}")
         if patch.contributor:
             self.add_contributors(patch.about_node, [patch.contributor])
+            modified_entities.append(patch.about_node)
+        for e in modified_entities:
+            stanza = self._stanza(e, strict=True)
+            stanza.normalize_order()
         return patch

{oaklib-0.2.6 → oaklib-0.2.8}/src/oaklib/implementations/simpleobo/simple_obo_parser.py

@@ -80,18 +80,18 @@ TERM_TAGS = [
     TAG_SYNONYM,
     TAG_XREF,
     # TAG_BUILTIN,
-    TAG_PROPERTY_VALUE,
     TAG_IS_A,
     TAG_INTERSECTION_OF,
     TAG_UNION_OF,
     TAG_EQUIVALENT_TO,
     TAG_DISJOINT_FROM,
     TAG_RELATIONSHIP,
-    TAG_CREATED_BY,
-    TAG_CREATION_DATE,
+    TAG_PROPERTY_VALUE,
     TAG_IS_OBSOLETE,
     TAG_REPLACED_BY,
     TAG_CONSIDER,
+    TAG_CREATED_BY,
+    TAG_CREATION_DATE,
 ]
 
 
@@ -101,6 +101,47 @@ def _parse_list(as_str: str) -> List[str]:
     return as_str.split(", ")
 
 
+@dataclass
+class ValueComponent:
+    pass
+
+    def order(self) -> Tuple:
+        pass
+
+
+@dataclass
+class QuotedText(ValueComponent):
+    value: str
+
+    def order(self) -> Tuple[str, str]:
+        return self.value.lower(), self.value
+
+
+@dataclass
+class SimpleValue(ValueComponent):
+    value: str
+
+    def order(self) -> Tuple[str, str]:
+        return (self.value,)
+        # return self.value.lower(), self.value
+
+
+@dataclass
+class XrefList(ValueComponent):
+    values: List[str]
+
+    def order(self) -> Tuple:
+        return tuple(self.values)
+
+
+@dataclass
+class Comment(ValueComponent):
+    value: str
+
+    def order(self) -> Tuple:
+        return (0,)
+
+
 @dataclass
 class TagValue:
     """Simple unparsed tag-value pair"""
@@ -171,11 +212,101 @@ class TagValue:
         toks = [curie_map.get(x, x) for x in toks]
         self.value = " ".join(toks)
 
-    def order(self) -> Tuple[int, int]:
+    def values_as_tuple(self) -> Tuple:
+        """
+        Return a tuple of values for sorting
+
+        :return:
+        """
+        toks = [x for x in self.value.split(" ") if x]
+        tpl = []
+        for t in toks:
+            if t.startswith("!"):
+                break
+            tpl.append(t)
+        return tuple(tpl)
+
+    def tokenize(self) -> List[ValueComponent]:
+        """
+        Tokenize the value
+
+        :return:
+        """
+        if self.tag == TAG_NAME:
+            return [SimpleValue(self.value)]
+        toks = [x for x in self.value.split(" ") if x]
+        cmt = ""
+        components = []
+        while toks:
+            t = toks.pop(0)
+            if t.startswith("!"):
+                cmt = " ".join(toks)
+                break
+            if t.startswith('"'):
+                toks.insert(0, t)
+                s = ""
+                while True:
+                    if not toks:
+                        raise ValueError(f"Badly quoted value: {self.value}")
+                    if s:
+                        s += " "
+                    s += toks.pop(0)
+                    closed = False
+                    if '"' in s:
+                        for i, char in enumerate(s):
+                            # Check if the current character is a quote and not escaped
+                            if char == '"' and i > 0 and s[i - 1] != "\\":
+                                s = s[0:i]
+                                rest = s[i + 1 :]
+                                if len(rest) > 0:
+                                    toks.insert(0, rest)
+                                closed = True
+                                break
+                    if closed:
+                        break
+                components.append(QuotedText(s))
+            elif t.startswith("["):
+                toks.insert(0, t[1:])
+                xrefs = []
+                while True:
+                    if not toks:
+                        raise ValueError(f"Xref list does not terminate: {self.value}")
+                    next_tok = toks.pop(0)
+                    if next_tok.endswith("]"):
+                        xrefs.append(next_tok[:-1])
+                        break
+                    xrefs.append(next_tok)
+                # TODO
+                components.append(XrefList(xrefs))
+            else:
+                components.append(SimpleValue(t))
+        if cmt:
+            components.append(Comment(cmt))
+        return components
+
+    def order(self) -> Tuple:
+        """
+        Order for sorting tag-value pairs.
+
+        Note: we aim for consistency with OWLAPI, which differs partially from
+        https://owlcollab.github.io/oboformat/doc/GO.format.obo-1_4.html
+        :return:
+        """
         t = self.tag
         v1 = TERM_TAGS.index(t) if t in TERM_TAGS else 99
-        v2 = str(self.value)
-        return v1, v2
+        toks = self.tokenize()
+        if self.tag == TAG_SYNONYM:
+            # normalize a synonym by placing a blank type if not present
+            if isinstance(toks[2], XrefList):
+                # necessary to preserve owlapi order
+                toks.insert(2, SimpleValue("zzzzz"))
+        order_values = []
+        for x in toks:
+            order_values.append(x.order())
+        if self.tag == TAG_INTERSECTION_OF:
+            tpl = self.values_as_tuple()
+            order_values = [chr(96 + len(list(tpl)))] + order_values
+        return tuple([v1] + order_values)
 
 
 @dataclass
@@ -420,28 +551,56 @@ class OboDocument:
     stanzas: Mapping[CURIE, Stanza] = field(default_factory=lambda: {})
 
     def add_stanza(self, stanza: Stanza) -> None:
+        """
+        Adds a stanza to the document.
+
+        Ensures stanza added in order.
+        :param stanza:
+        :return:
+        """
         self.stanzas[stanza.id] = stanza
+        self.order_stanzas()
 
     def reindex(self) -> None:
         self.stanzas = {s.id: s for s in self.stanzas.values()}
 
-    def dump(self, file: TextIO, sort_tags=True) -> None:
+    def order_stanzas(self) -> None:
+        """
+        Orders stanzas by ID
+
+        Does not change tag-value ordering within stanzas
+        """
+        stanzas = self.stanzas.values()
+        stanzas = sorted(stanzas, key=lambda x: x.id)
+        self.stanzas = {s.id: s for s in stanzas}
+
+    def normalize_line_order(self) -> None:
+        """
+        Normalizes line order within stanzas
+        """
+        for s in self.stanzas.values():
+            s.normalize_order()
+
+    def dump(self, file: TextIO, ensure_sorted=False, normalize_line_order=False) -> None:
         """Export to a file
 
         :param file:
+        :param ensure_sorted: Sort stanzas
+        :param normalize_line_order: Sort tags within stanzas
         """
-        if sort_tags:
-            stanzas = self.stanzas.values()
-            stanzas = sorted(stanzas, key=lambda x: x.id)
-            self.stanzas = {s.id: s for s in stanzas}
-            for s in stanzas:
-                s.normalize_order()
+        if ensure_sorted:
+            self.order_stanzas()
+        if normalize_line_order:
+            self.normalize_line_order()
 
         self._dump_tag_values(self.header.tag_values, file)
         for s in self.stanzas.values():
-            file.write(f"[{s.type}]\n")
-            file.write(f"id: {s.id}\n")
-            self._dump_tag_values(s.tag_values, file)
+            self._dump_stanza(s, file)
+
+    def _dump_stanza(self, stanza: Stanza, file: TextIO):
+        file.write(f"[{stanza.type}]\n")
+        file.write(f"id: {stanza.id}\n")
+        self._dump_tag_values(stanza.tag_values, file)
 
     def _dump_tag_values(self, tag_values: List[TagValue], file: TextIO):
         for tv in tag_values:

{oaklib-0.2.6 → oaklib-0.2.8}/src/oaklib/interfaces/differ_interface.py

@@ -137,7 +137,7 @@ class DifferInterface(BasicOntologyInterface, ABC):
                             id=_gen_id(), about_edge=edge, old_value=pred, new_value=switches[0]
                         )
                 else:
-                    yield kgcl.NodeMove(id=_gen_id(), about_edge=edge, old_value=pred)
+                    yield kgcl.EdgeDeletion(id=_gen_id(), subject=e1, predicate=pred, object=filler)
             for rel in e2_rels.difference(e1_rels):
                 pred, filler = rel
                 edge = kgcl.Edge(subject=e1, predicate=pred, object=filler)
@@ -191,7 +191,10 @@ class DifferInterface(BasicOntologyInterface, ABC):
             if isinstance(change, kgcl.NodeChange):
                 about = change.about_node
             elif isinstance(change, kgcl.EdgeChange):
-                about = change.about_edge.subject
+                if isinstance(change, kgcl.EdgeDeletion):
+                    about = change.subject
+                else:
+                    about = change.about_edge.subject
             else:
                 about = None
             partition = RESIDUAL_KEY

{oaklib-0.2.6 → oaklib-0.2.8}/src/oaklib/interfaces/dumper_interface.py

@@ -32,12 +32,16 @@ class DumperInterface(BasicOntologyInterface, ABC):
     An OntologyInterface that is capable of exporting entire contents.
     """
 
-    def dump(self, path: str = None, syntax: str = None, **kwargs):
+    def dump(
+        self, path: str = None, syntax: str = None, enforce_canonical_ordering=False, **kwargs
+    ):
         """
         Exports current contents.
 
-        :param path:
-        :param syntax:
+        :param path: Path to file to write to. If None, then write to stdout.
+        :param syntax: Syntax to use. If None, then use the default syntax.
+        :param enforce_canonical_ordering:
+        :param kwargs: Additional arguments to pass to the dumper
         :return:
         """
         logging.info(f"Dumping graph to {path} in {syntax}")
@@ -58,6 +62,7 @@ class DumperInterface(BasicOntologyInterface, ABC):
                 print(json_str)
         else:
             converter = OBOGRAPH_CONVERTERS[syntax]()
+            converter.enforce_canonical_ordering = enforce_canonical_ordering
             logging.info(f"Using {converter}")
             converter.curie_converter = self.converter
             kwargs = {k: v for k, v in kwargs.items() if v is not None}

{oaklib-0.2.6 → oaklib-0.2.8}/src/oaklib/interfaces/semsim_interface.py

@@ -65,6 +65,42 @@ class SemanticSimilarityInterface(BasicOntologyInterface, ABC):
         else:
             raise NotImplementedError
 
+    def setwise_most_recent_common_ancestors(
+        self,
+        subjects: List[CURIE],
+        predicates: List[PRED_CURIE] = None,
+        include_owl_thing: bool = True,
+    ) -> Iterable[CURIE]:
+        """
+        Most recent common ancestors (MRCAs) for a set of entities
+
+        The MRCAs are the set of Common Ancestors (CAs) that are not themselves proper
+        ancestors of another CA
+
+        :param subjects:
+        :param predicates:
+        :param include_owl_thing:
+        :return:
+        """
+        if not isinstance(self, OboGraphInterface):
+            raise NotImplementedError
+        ancs = []
+        for s in subjects:
+            ancs.append(set(self.ancestors([s], predicates)))
+        common = set.intersection(*ancs)
+        ancs_of_common = []
+        for ca in common:
+            for caa in self.ancestors(ca, predicates):
+                if caa != ca:
+                    ancs_of_common.append(caa)
+        n = 0
+        for a in common:
+            if a not in ancs_of_common:
+                yield a
+                n += 1
+        if n == 0 and include_owl_thing:
+            yield OWL_THING
+
     def multiset_most_recent_common_ancestors(
         self, subjects: List[CURIE], predicates: List[PRED_CURIE] = None, asymmetric=True
     ) -> Iterable[Tuple[CURIE, CURIE, CURIE]]: