obographs 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

obographs/__init__.py

@@ -1,13 +1,72 @@
 """A python data model for OBO Graphs."""
 
-from .model import Graph, GraphDocument, Meta, Node, Property, Synonym, Xref, read
+from .model import (
+    Definition,
+    DomainRangeAxiom,
+    Edge,
+    EquivalentNodeSet,
+    ExistentialRestrictionExpression,
+    Graph,
+    GraphDocument,
+    LogicalDefinition,
+    Meta,
+    Node,
+    NodeType,
+    Property,
+    PropertyChainAxiom,
+    PropertyType,
+    Synonym,
+    Xref,
+    read,
+)
+from .standardized import (
+    StandardizedBaseModel,
+    StandardizedDefinition,
+    StandardizedDomainRangeAxiom,
+    StandardizedEdge,
+    StandardizedEquivalentNodeSet,
+    StandardizedExistentialRestriction,
+    StandardizedGraph,
+    StandardizedGraphDocument,
+    StandardizedLogicalDefinition,
+    StandardizedMeta,
+    StandardizedNode,
+    StandardizedProperty,
+    StandardizedPropertyChainAxiom,
+    StandardizedSynonym,
+    StandardizedXref,
+)
 
 __all__ = [
+    "Definition",
+    "DomainRangeAxiom",
+    "Edge",
+    "EquivalentNodeSet",
+    "ExistentialRestrictionExpression",
     "Graph",
     "GraphDocument",
+    "LogicalDefinition",
     "Meta",
     "Node",
+    "NodeType",
     "Property",
+    "PropertyChainAxiom",
+    "PropertyType",
+    "StandardizedBaseModel",
+    "StandardizedDefinition",
+    "StandardizedDomainRangeAxiom",
+    "StandardizedEdge",
+    "StandardizedEquivalentNodeSet",
+    "StandardizedExistentialRestriction",
+    "StandardizedGraph",
+    "StandardizedGraphDocument",
+    "StandardizedLogicalDefinition",
+    "StandardizedMeta",
+    "StandardizedNode",
+    "StandardizedProperty",
+    "StandardizedPropertyChainAxiom",
+    "StandardizedSynonym",
+    "StandardizedXref",
     "Synonym",
     "Xref",
     "read",

obographs/model.py

@@ -9,27 +9,35 @@
 
 from __future__ import annotations
 
+import gzip
 import json
 import logging
 from collections import defaultdict
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, TypeAlias, overload
+from typing import TYPE_CHECKING, Literal, TypeAlias, overload
 
+import curies
+from curies.vocabulary import SynonymScopeOIO
 from pydantic import BaseModel, Field
 
 if TYPE_CHECKING:
-    import curies
-
     from .standardized import StandardizedGraph
 
 __all__ = [
     "Definition",
+    "DomainRangeAxiom",
     "Edge",
+    "EquivalentNodeSet",
+    "ExistentialRestrictionExpression",
     "Graph",
     "GraphDocument",
+    "LogicalDefinition",
     "Meta",
     "Node",
+    "NodeType",
     "Property",
+    "PropertyChainAxiom",
+    "PropertyType",
     "Synonym",
     "Xref",
     "read",
@@ -40,31 +48,24 @@ logger = logging.getLogger(__name__)
 OBO_URI_PREFIX = "http://purl.obolibrary.org/obo/"
 OBO_URI_PREFIX_LEN = len(OBO_URI_PREFIX)
 
-SynonymPredicate: TypeAlias = Literal[
-    "hasExactSynonym",
-    "hasBroadSynonym",
-    "hasNarrowSynonym",
-    "hasRelatedSynonym",
-]
 NodeType: TypeAlias = Literal["CLASS", "PROPERTY", "INDIVIDUAL"]
 
-TimeoutHint = int | float | None
+#: When node type is ``PROPERTY``, this is extra information
+PropertyType: TypeAlias = Literal["ANNOTATION", "OBJECT", "DATA"]
 
-#: A mapping from OBO flat file format internal synonym types to OBO in OWL vocabulary
-#: identifiers. See https://owlcollab.github.io/oboformat/doc/GO.format.obo-1_4.html
-OBO_SYNONYM_TO_OIO: dict[str, SynonymPredicate] = {
-    "EXACT": "hasExactSynonym",
-    "BROAD": "hasBroadSynonym",
-    "NARROW": "hasNarrowSynonym",
-    "RELATED": "hasRelatedSynonym",
-}
+TimeoutHint = int | float | None
 
 
 class Property(BaseModel):
     """Represent a property inside a metadata element."""
 
     pred: str
-    val: str
+    val: str | None = Field(
+        None,
+        description="Stores the value of the property. This can be a string representing a "
+        "literal or IRI. This isn't supposed to be nullable, but it happens a lot - might be a "
+        "bug in OWLAPI or ROBOT",
+    )
     xrefs: list[str] | None = None
     meta: Meta | None = None
 
@@ -86,8 +87,8 @@ class Synonym(BaseModel):
     """Represents a synonym inside an object meta."""
 
     val: str | None = Field(default=None)
-    pred: str = Field(default="hasExactSynonym")
-    synonymType: str | None = Field(examples=["OMO:0003000"])  # noqa:N815
+    pred: SynonymScopeOIO = Field(default="hasExactSynonym")
+    synonymType: str | None = Field(None, examples=["OMO:0003000"])  # noqa:N815
     xrefs: list[str] = Field(
         default_factory=list,
         description="A list of CURIEs/IRIs for provenance for the synonym",
@@ -123,7 +124,52 @@ class Node(BaseModel):
     id: str = Field(..., description="The IRI for the node")
     lbl: str | None = Field(None, description="The name of the node")
     meta: Meta | None = None
-    type: NodeType = Field(..., description="Type of node")
+    type: NodeType | None = Field(None, description="Type of node")
+    propertyType: PropertyType | None = Field(  # noqa:N815
+        None, description="Type of property, if the node type is a property"
+    )
+
+
+class DomainRangeAxiom(BaseModel):
+    """Represents a domain/range axiom."""
+
+    predicateId: str  # noqa:N815
+    domainClassIds: list[str] | None = None  # noqa:N815
+    rangeClassIds: list[str] | None = None  # noqa:N815
+    allValuesFromEdges: list[Edge] | None = None  # noqa:N815
+    meta: Meta | None = None
+
+
+class PropertyChainAxiom(BaseModel):
+    """Represents a property chain axiom."""
+
+    predicateId: str  # noqa:N815
+    chainPredicateIds: list[str]  # noqa:N815
+    meta: Meta | None = None
+
+
+class ExistentialRestrictionExpression(BaseModel):
+    """Represents an existential restriction."""
+
+    propertyId: str  # noqa:N815
+    fillerId: str  # noqa:N815
+
+
+class LogicalDefinition(BaseModel):
+    """Represents a logical definition chain axiom."""
+
+    definedClassId: str  # noqa:N815
+    genusIds: list[str] | None = None  # noqa:N815
+    restrictions: list[ExistentialRestrictionExpression] | None = None
+    meta: Meta | None = None
+
+
+class EquivalentNodeSet(BaseModel):
+    """Represents a set of equivalent nodes."""
+
+    representativeNodeId: str  # noqa:N815
+    nodeIds: list[str]  # noqa:N815
+    meta: Meta | None = None
 
 
 class Graph(BaseModel):
@@ -133,10 +179,10 @@ class Graph(BaseModel):
     meta: Meta | None = None
     nodes: list[Node] = Field(default_factory=list)
     edges: list[Edge] = Field(default_factory=list)
-    equivalentNodesSets: list[Any] = Field(default_factory=list)  # noqa:N815
-    logicalDefinitionAxioms: list[Any] = Field(default_factory=list)  # noqa:N815
-    domainRangeAxioms: list[Any] = Field(default_factory=list)  # noqa:N815
-    propertyChainAxioms: list[Any] = Field(default_factory=list)  # noqa:N815
+    equivalentNodesSets: list[EquivalentNodeSet] = Field(default_factory=list)  # noqa:N815
+    logicalDefinitionAxioms: list[LogicalDefinition] = Field(default_factory=list)  # noqa:N815
+    domainRangeAxioms: list[DomainRangeAxiom] = Field(default_factory=list)  # noqa:N815
+    propertyChainAxioms: list[PropertyChainAxiom] = Field(default_factory=list)  # noqa:N815
 
     def standardize(self, converter: curies.Converter) -> StandardizedGraph:
         """Standardize the graph."""
@@ -205,12 +251,14 @@ def read(
 
     elif isinstance(source, str | Path):
         path = Path(source).expanduser().resolve()
-        if path.is_file():
-            if path.suffix.endswith(".gz"):
-                raise NotImplementedError
-            else:
-                with path.open() as file:
-                    graph_document = GraphDocument.model_validate(json.load(file))
+        if not path.is_file():
+            raise FileNotFoundError
+        if path.suffix.endswith(".gz"):
+            with gzip.open(path, mode="rt") as file:
+                graph_document = GraphDocument.model_validate(json.load(file))
+        else:
+            with path.open() as file:
+                graph_document = GraphDocument.model_validate(json.load(file))
     else:
         raise TypeError(f"Unhandled source: {source}")
 

obographs/standardized.py

@@ -2,68 +2,172 @@
 
 from __future__ import annotations
 
-from curies import Converter, Reference
+import logging
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar, cast
+
+import curies.preprocessing
+from curies import Converter, Reference, Triple, vocabulary
+from curies.vocabulary import SynonymScopeOIO
 from pydantic import BaseModel, Field
 from typing_extensions import Self
 
-from obographs.model import Definition, Edge, Graph, Meta, Node, NodeType, Property, Synonym, Xref
+from obographs.model import (
+    Definition,
+    DomainRangeAxiom,
+    Edge,
+    EquivalentNodeSet,
+    ExistentialRestrictionExpression,
+    Graph,
+    GraphDocument,
+    LogicalDefinition,
+    Meta,
+    Node,
+    NodeType,
+    Property,
+    PropertyChainAxiom,
+    PropertyType,
+    Synonym,
+    Xref,
+)
 
 __all__ = [
+    "StandardizedBaseModel",
     "StandardizedDefinition",
+    "StandardizedDomainRangeAxiom",
     "StandardizedEdge",
+    "StandardizedEquivalentNodeSet",
+    "StandardizedExistentialRestriction",
     "StandardizedGraph",
+    "StandardizedGraphDocument",
+    "StandardizedLogicalDefinition",
     "StandardizedMeta",
     "StandardizedNode",
+    "StandardizedProperty",
+    "StandardizedPropertyChainAxiom",
+    "StandardizedSynonym",
     "StandardizedXref",
 ]
 
+logger = logging.getLogger(__name__)
+
+
+def _expand_list(references: list[Reference] | None, converter: Converter) -> list[str] | None:
+    if references is None or not references:
+        return None
+    return [converter.expand_reference(r, strict=True) for r in references]
+
+
+X = TypeVar("X")
 
-class StandardizedProperty(BaseModel):
+
+class StandardizedBaseModel(BaseModel, ABC, Generic[X]):
+    """A standardized property."""
+
+    @classmethod
+    @abstractmethod
+    def from_obograph_raw(
+        cls, obj: X, converter: Converter, *, strict: bool = False
+    ) -> Self | None:
+        """Instantiate by standardizing a raw OBO Graph object."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def to_raw(self, converter: Converter) -> X:
+        """Create a raw object."""
+        raise NotImplementedError
+
+
+class StandardizedProperty(StandardizedBaseModel[Property]):
     """A standardized property."""
 
     predicate: Reference
-    value: Reference
+    value: Reference | str = Field(
+        ..., description="Parsed into a Reference if a CURIE or IRI, or a string if it's a literal"
+    )
     xrefs: list[Reference] | None = None
     meta: StandardizedMeta | None = None
 
     @classmethod
-    def from_obograph_raw(cls, prop: Property, converter: Converter) -> Self:
+    def from_obograph_raw(
+        cls, prop: Property, converter: Converter, *, strict: bool = False
+    ) -> Self:
         """Instantiate by standardizing a raw OBO Graph object."""
+        if not prop.val or not prop.pred:
+            raise ValueError
+        value: Reference | str | None
+
+        if (
+            prop.val.startswith("http://")
+            or prop.val.startswith("https")
+            or converter.is_curie(prop.val)
+            or prop.val in BUILTINS
+        ):
+            value = _curie_or_uri_to_ref(prop.val, converter, strict=False) or prop.val
+        else:
+            value = prop.val
         return cls(
-            predicate=_curie_or_uri_to_ref(prop.pred, converter),
-            value=_curie_or_uri_to_ref(prop.val, converter),
+            predicate=_curie_or_uri_to_ref(prop.pred, converter, strict=strict),
+            value=value,
         )
 
+    def to_raw(self, converter: Converter) -> Property:
+        """Create a raw object."""
+        return Property(
+            pred=converter.expand_reference(self.predicate),
+            val=converter.expand_reference(self.value)
+            if isinstance(self.value, Reference)
+            else self.value,
+            xrefs=_expand_list(self.xrefs, converter),
+            meta=self.meta.to_raw(converter) if self.meta is not None else None,
+        )
 
-class StandardizedDefinition(BaseModel):
+
+class StandardizedDefinition(StandardizedBaseModel[Definition]):
     """A standardized definition."""
 
     value: str | None = Field(default=None)
     xrefs: list[Reference] | None = Field(default=None)
 
     @classmethod
-    def from_obograph_raw(cls, definition: Definition | None, converter: Converter) -> Self | None:
-        """Instantiate by standardizing a raw OBO Graph object."""
+    def from_obograph_raw(
+        cls, definition: Definition | None, converter: Converter, *, strict: bool = False
+    ) -> Self | None:
+        """Parse a raw object."""
         if definition is None:
             return None
         return cls(
             value=definition.val,
-            xrefs=_parse_list(definition.xrefs, converter),
+            xrefs=_parse_list(definition.xrefs, converter, strict=strict),
+        )
+
+    def to_raw(self, converter: Converter) -> Definition:
+        """Create a raw object."""
+        return Definition(
+            val=self.value,
+            xrefs=_expand_list(self.xrefs, converter),
         )
 
 
-class StandardizedXref(BaseModel):
+class StandardizedXref(StandardizedBaseModel[Xref]):
     """A standardized database cross-reference."""
 
     reference: Reference
 
     @classmethod
-    def from_obograph_raw(cls, xref: Xref, converter: Converter) -> Self:
+    def from_obograph_raw(cls, xref: Xref, converter: Converter, *, strict: bool = False) -> Self:
         """Instantiate by standardizing a raw OBO Graph object."""
-        return cls(reference=_curie_or_uri_to_ref(xref.val, converter))
+        reference = _curie_or_uri_to_ref(xref.val, converter, strict=strict)
+        if reference is None:
+            raise ValueError(f"could not parse xref: {xref.val}")
+        return cls(reference=reference)
 
+    def to_raw(self, converter: Converter) -> Xref:
+        """Create a raw object."""
+        return Xref(val=self.reference.curie)
 
-class StandardizedSynonym(BaseModel):
+
+class StandardizedSynonym(StandardizedBaseModel[Synonym]):
     """A standardized synonym."""
 
     text: str
@@ -72,17 +176,31 @@ class StandardizedSynonym(BaseModel):
     xrefs: list[Reference] | None = None
 
     @classmethod
-    def from_obograph_raw(cls, synonym: Synonym, converter: Converter) -> Self:
+    def from_obograph_raw(
+        cls, synonym: Synonym, converter: Converter, *, strict: bool = False
+    ) -> Self:
         """Instantiate by standardizing a raw OBO Graph object."""
         return cls(
             text=synonym.val,
             predicate=Reference(prefix="oboInOwl", identifier=synonym.pred),
-            type=synonym.synonymType and _curie_or_uri_to_ref(synonym.synonymType, converter),
-            xrefs=_parse_list(synonym.xrefs, converter),
+            type=synonym.synonymType
+            and _curie_or_uri_to_ref(synonym.synonymType, converter, strict=strict),
+            xrefs=_parse_list(synonym.xrefs, converter, strict=strict),
+        )
+
+    def to_raw(self, converter: Converter) -> Synonym:
+        """Create a raw object."""
+        if self.predicate.prefix.lower() != "oboinowl":
+            raise ValueError
+        return Synonym(
+            val=self.text,
+            pred=cast(SynonymScopeOIO, self.predicate.identifier),
+            synonymType=converter.expand_reference(self.type) if self.type is not None else None,
+            xrefs=_expand_list(self.xrefs, converter) or [],
         )
 
 
-class StandardizedMeta(BaseModel):
+class StandardizedMeta(StandardizedBaseModel[Meta]):
     """A standardized meta object."""
 
     definition: StandardizedDefinition | None
@@ -95,56 +213,131 @@ class StandardizedMeta(BaseModel):
     properties: list[StandardizedProperty] | None = None
 
     @classmethod
-    def from_obograph_raw(cls, meta: Meta | None, converter: Converter) -> Self | None:
+    def from_obograph_raw(  # noqa:C901
+        cls, meta: Meta | None, converter: Converter, flag: str = "", strict: bool = False
+    ) -> Self | None:
         """Instantiate by standardizing a raw OBO Graph object."""
         if meta is None:
             return None
+
+        xrefs = []
+        for raw_xref in meta.xrefs or []:
+            if raw_xref.val:
+                try:
+                    st_xref = StandardizedXref.from_obograph_raw(raw_xref, converter, strict=strict)
+                except ValueError:
+                    if strict:
+                        raise
+                    logger.debug("[%s] failed to standardize xref: %s", flag, raw_xref)
+                else:
+                    xrefs.append(st_xref)
+
+        synonyms = []
+        for raw_synonym in meta.synonyms or []:
+            if raw_synonym.val:
+                try:
+                    s = StandardizedSynonym.from_obograph_raw(raw_synonym, converter, strict=strict)
+                except ValueError:
+                    if strict:
+                        raise
+                    logger.debug("[%s] failed to standardize synonym: %s", flag, raw_synonym)
+                else:
+                    synonyms.append(s)
+
+        props = []
+        for raw_prop in meta.basicPropertyValues or []:
+            if raw_prop.val and raw_prop.pred:
+                try:
+                    prop = StandardizedProperty.from_obograph_raw(
+                        raw_prop, converter, strict=strict
+                    )
+                except ValueError:
+                    if strict:
+                        raise
+                    logger.debug("[%s] failed to standardize property: %s", flag, raw_prop)
+                else:
+                    props.append(prop)
+
         return cls(
-            definition=StandardizedDefinition.from_obograph_raw(meta.definition, converter),
-            subsets=[_curie_or_uri_to_ref(subset, converter) for subset in meta.subsets]
-            if meta.subsets
-            else None,
-            xrefs=[StandardizedXref.from_obograph_raw(xref, converter) for xref in meta.xrefs]
-            if meta.xrefs
-            else None,
-            synonyms=[
-                StandardizedSynonym.from_obograph_raw(synonym, converter)
-                for synonym in meta.synonyms
+            definition=StandardizedDefinition.from_obograph_raw(
+                meta.definition, converter, strict=strict
+            ),
+            subsets=[
+                _curie_or_uri_to_ref(subset, converter, strict=strict) for subset in meta.subsets
             ]
-            if meta.synonyms
+            if meta.subsets
             else None,
+            xrefs=xrefs or None,
+            synonyms=synonyms or None,
             comments=meta.comments,
             version=meta.version,
             deprecated=meta.deprecated,
-            properties=[
-                StandardizedProperty.from_obograph_raw(p, converter)
-                for p in meta.basicPropertyValues
-            ]
-            if meta.basicPropertyValues
+            properties=props or None,
+        )
+
+    def to_raw(self, converter: Converter) -> Meta:
+        """Create a raw object."""
+        return Meta(
+            definition=self.definition.to_raw(converter)
+            if self.definition and self.definition.value
+            else None,
+            subsets=_expand_list(self.subsets, converter),
+            xrefs=[xref.to_raw(converter) for xref in self.xrefs] if self.xrefs else None,
+            synonyms=[s.to_raw(converter) for s in self.synonyms] if self.synonyms else None,
+            comments=self.comments,
+            version=self.version,  # TODO might need some kind of expansion?
+            deprecated=self.deprecated,
+            basicPropertyValues=[p.to_raw(converter) for p in self.properties]
+            if self.properties
             else None,
         )
 
 
-class StandardizedNode(BaseModel):
+class StandardizedNode(StandardizedBaseModel[Node]):
     """A standardized node."""
 
     reference: Reference
     label: str | None = Field(None)
     meta: StandardizedMeta | None = None
-    type: NodeType = Field(..., description="Type of node")
+    type: NodeType | None = Field(None, description="Type of node")
+    property_type: PropertyType | None = Field(
+        None, description="Type of property, if the node type is a property"
+    )
 
     @classmethod
-    def from_obograph_raw(cls, node: Node, converter: Converter) -> Self:
+    def from_obograph_raw(
+        cls, node: Node, converter: Converter, *, strict: bool = False
+    ) -> Self | None:
         """Instantiate by standardizing a raw OBO Graph object."""
+        reference = _curie_or_uri_to_ref(node.id, converter, strict=strict)
+        if reference is None:
+            if strict:
+                raise ValueError(f"failed to parse node's ID: {node.id}")
+            logger.warning("failed to parse node's ID %s", node.id)
+            return None
+
         return cls(
-            reference=_curie_or_uri_to_ref(node.id, converter),
+            reference=reference,
             label=node.lbl,
-            meta=StandardizedMeta.from_obograph_raw(node.meta, converter),
+            meta=StandardizedMeta.from_obograph_raw(
+                node.meta, converter, flag=reference.curie, strict=strict
+            ),
             type=node.type,
+            property_type=node.propertyType,
+        )
+
+    def to_raw(self, converter: Converter) -> Node:
+        """Create a raw object."""
+        return Node(
+            id=converter.expand_reference(self.reference),
+            lbl=self.label,
+            meta=self.meta.to_raw(converter) if self.meta is not None else None,
+            type=self.type,
+            propertyType=self.property_type,
         )
 
 
-class StandardizedEdge(BaseModel):
+class StandardizedEdge(Triple, StandardizedBaseModel[Edge]):
     """A standardized edge."""
 
     subject: Reference
@@ -153,17 +346,205 @@ class StandardizedEdge(BaseModel):
     meta: StandardizedMeta | None = None
 
     @classmethod
-    def from_obograph_raw(cls, node: Edge, converter: Converter) -> Self:
+    def from_obograph_raw(
+        cls, edge: Edge, converter: Converter, *, strict: bool = False
+    ) -> Self | None:
         """Instantiate by standardizing a raw OBO Graph object."""
+        subject = _curie_or_uri_to_ref(edge.sub, converter, strict=strict)
+        if not subject:
+            if strict:
+                raise ValueError
+            logger.warning("failed to parse edge's subject %s", edge.sub)
+            return None
+        predicate = _curie_or_uri_to_ref(edge.pred, converter, strict=strict)
+        if not predicate:
+            if strict:
+                raise ValueError
+            logger.warning("failed to parse edge's predicate %s", edge.pred)
+            return None
+        obj = _curie_or_uri_to_ref(edge.obj, converter, strict=strict)
+        if not obj:
+            if strict:
+                raise ValueError
+            logger.warning("failed to parse edge's object %s", edge.obj)
+            return None
         return cls(
-            subject=_curie_or_uri_to_ref(node.sub, converter),
-            predicate=_curie_or_uri_to_ref(node.pred, converter),
-            object=_curie_or_uri_to_ref(node.obj, converter),
-            meta=StandardizedMeta.from_obograph_raw(node.meta, converter),
+            subject=subject,
+            predicate=predicate,
+            object=obj,
+            meta=StandardizedMeta.from_obograph_raw(
+                edge.meta,
+                converter,
+                flag=f"{subject.curie} {predicate.curie} {obj.curie}",
+                strict=strict,
+            ),
+        )
+
+    def to_raw(self, converter: Converter) -> Edge:
+        """Create a raw object."""
+        if self.predicate in REVERSE_BUILTINS:
+            predicate = REVERSE_BUILTINS[self.predicate]
+        else:
+            predicate = converter.expand_reference(self.predicate, strict=True)
+
+        return Edge(
+            sub=converter.expand_reference(self.subject),
+            pred=predicate,
+            obj=converter.expand_reference(self.object),
+            meta=self.meta.to_raw(converter) if self.meta is not None else None,
         )
 
 
-class StandardizedGraph(BaseModel):
+class StandardizedDomainRangeAxiom(StandardizedBaseModel[DomainRangeAxiom]):
+    """Represents a domain/range axiom."""
+
+    predicate: Reference
+    domains: list[Reference] = Field(default_factory=list)
+    ranges: list[Reference] = Field(default_factory=list)
+    all_values_from_edges: list[StandardizedEdge] = Field(default_factory=list)
+    meta: StandardizedMeta | None = None
+
+    @classmethod
+    def from_obograph_raw(
+        cls, obj: DomainRangeAxiom, converter: Converter, *, strict: bool = False
+    ) -> Self | None:
+        """Parse a raw object."""
+        return cls(
+            predicate=_curie_or_uri_to_ref(obj.predicateId, converter, strict=strict),
+            domains=_parse_list(obj.domainClassIds, converter, strict=strict) or [],
+            ranges=_parse_list(obj.rangeClassIds, converter, strict=strict) or [],
+            all_values_from_edges=[
+                StandardizedEdge.from_obograph_raw(edge, converter, strict=strict)
+                for edge in obj.allValuesFromEdges or []
+            ],
+            meta=StandardizedMeta.from_obograph_raw(obj.meta, converter, strict=strict),
+        )
+
+    def to_raw(self, converter: Converter) -> DomainRangeAxiom:
+        """Create a raw object."""
+        return DomainRangeAxiom(
+            predicateId=converter.expand_reference(self.predicate),
+            domainClassIds=_expand_list(self.domains, converter),
+            rangeClassIds=_expand_list(self.ranges, converter),
+            allValuesFromEdges=[edge.to_raw(converter) for edge in self.all_values_from_edges]
+            if self.all_values_from_edges
+            else None,
+            meta=self.meta.to_raw(converter) if self.meta is not None else None,
+        )
+
+
+class StandardizedPropertyChainAxiom(StandardizedBaseModel[PropertyChainAxiom]):
+    """Represents a property chain axiom."""
+
+    predicate: Reference
+    chain: list[Reference] = Field(default_factory=list)
+    meta: StandardizedMeta | None = None
+
+    @classmethod
+    def from_obograph_raw(
+        cls, obj: PropertyChainAxiom, converter: Converter, *, strict: bool = False
+    ) -> Self | None:
+        """Parse a raw object."""
+        return cls(
+            predicate=_curie_or_uri_to_ref(obj.predicateId, converter, strict=strict),
+            chain=_parse_list(obj.chainPredicateIds, converter, strict=strict),
+            meta=StandardizedMeta.from_obograph_raw(obj.meta, converter, strict=strict),
+        )
+
+    def to_raw(self, converter: Converter) -> PropertyChainAxiom:
+        """Create a raw object."""
+        return PropertyChainAxiom(
+            predicateId=converter.expand_reference(self.predicate),
+            chainPredicateIds=_expand_list(self.chain, converter),
+            meta=self.meta.to_raw(converter) if self.meta is not None else None,
+        )
+
+
+class StandardizedEquivalentNodeSet(StandardizedBaseModel[EquivalentNodeSet]):
+    """Represents an equivalence set."""
+
+    node: Reference
+    equivalents: list[Reference] = Field(default_factory=list)
+    meta: StandardizedMeta | None = None
+
+    @classmethod
+    def from_obograph_raw(
+        cls, obj: EquivalentNodeSet, converter: Converter, *, strict: bool = False
+    ) -> Self | None:
+        """Parse a raw object."""
+        return cls(
+            node=_curie_or_uri_to_ref(obj.representativeNodeId, converter, strict=strict),
+            equivalents=_parse_list(obj.nodeIds, converter, strict=strict),
+            meta=StandardizedMeta.from_obograph_raw(obj.meta, converter, strict=strict),
+        )
+
+    def to_raw(self, converter: Converter) -> EquivalentNodeSet:
+        """Create a raw object."""
+        return EquivalentNodeSet(
+            representativeNodeId=converter.expand_reference(self.node),
+            nodeIds=_expand_list(self.equivalents, converter),
+            meta=self.meta.to_raw(converter) if self.meta is not None else None,
+        )
+
+
+class StandardizedExistentialRestriction(StandardizedBaseModel[ExistentialRestrictionExpression]):
+    """Represents an existential restriction expression."""
+
+    predicate: Reference
+    target: Reference
+
+    @classmethod
+    def from_obograph_raw(
+        cls, obj: ExistentialRestrictionExpression, converter: Converter, *, strict: bool = False
+    ) -> Self | None:
+        """Parse a raw object."""
+        return cls(
+            predicate=_curie_or_uri_to_ref(obj.propertyId, converter, strict=strict),
+            target=_curie_or_uri_to_ref(obj.fillerId, converter, strict=strict),
+        )
+
+    def to_raw(self, converter: Converter) -> ExistentialRestrictionExpression:
+        """Create a raw object."""
+        return ExistentialRestrictionExpression(
+            propertyId=converter.expand_reference(self.predicate),
+            fillerId=converter.expand_reference(self.target),
+        )
+
+
+class StandardizedLogicalDefinition(StandardizedBaseModel[LogicalDefinition]):
+    """Represents a logical definition axiom."""
+
+    node: Reference
+    geni: list[Reference] = Field(default_factory=list)
+    restrictions: list[StandardizedExistentialRestriction] = Field(default_factory=list)
+    meta: StandardizedMeta | None = None
+
+    @classmethod
+    def from_obograph_raw(
+        cls, obj: LogicalDefinition, converter: Converter, *, strict: bool = False
+    ) -> Self | None:
+        """Parse a raw object."""
+        return cls(
+            node=_curie_or_uri_to_ref(obj.definedClassId, converter, strict=strict),
+            geni=_parse_list(obj.genusIds, converter, strict=strict),
+            restrictions=[
+                StandardizedExistentialRestriction.from_obograph_raw(r, converter, strict=strict)
+                for r in obj.restrictions or []
+            ],
+            meta=StandardizedMeta.from_obograph_raw(obj.meta, converter, strict=strict),
+        )
+
+    def to_raw(self, converter: Converter) -> LogicalDefinition:
+        """Create a raw object."""
+        return LogicalDefinition(
+            definedClassId=converter.expand_reference(self.node),
+            genusIds=_expand_list(self.geni, converter),
+            restrictions=[r.to_raw(converter) for r in self.restrictions],
+            meta=self.meta.to_raw(converter) if self.meta is not None else None,
+        )
+
+
+class StandardizedGraph(StandardizedBaseModel[Graph]):
     """A standardized graph."""
 
     id: str | None = None
@@ -171,40 +552,148 @@ class StandardizedGraph(BaseModel):
     nodes: list[StandardizedNode] = Field(default_factory=list)
     edges: list[StandardizedEdge] = Field(default_factory=list)
 
-    # TODO other bits
+    equivalent_node_sets: list[StandardizedEquivalentNodeSet] = Field(default_factory=list)
+    logical_definition_axioms: list[StandardizedLogicalDefinition] = Field(default_factory=list)
+    domain_range_axioms: list[StandardizedDomainRangeAxiom] = Field(default_factory=list)
+    property_chain_axioms: list[StandardizedPropertyChainAxiom] = Field(default_factory=list)
 
     @classmethod
-    def from_obograph_raw(cls, graph: Graph, converter: Converter) -> Self:
+    def from_obograph_raw(cls, graph: Graph, converter: Converter, *, strict: bool = False) -> Self:
         """Instantiate by standardizing a raw OBO Graph object."""
         return cls(
             id=graph.id,
-            meta=StandardizedMeta.from_obograph_raw(graph.meta, converter),
-            nodes=[StandardizedNode.from_obograph_raw(node, converter) for node in graph.nodes],
-            edges=[StandardizedEdge.from_obograph_raw(edge, converter) for edge in graph.edges],
+            meta=StandardizedMeta.from_obograph_raw(
+                graph.meta, converter, flag=graph.id or "", strict=strict
+            ),
+            nodes=[
+                s_node
+                for node in graph.nodes
+                if (s_node := StandardizedNode.from_obograph_raw(node, converter, strict=strict))
+            ],
+            edges=[
+                s_edge
+                for edge in graph.edges
+                if (s_edge := StandardizedEdge.from_obograph_raw(edge, converter, strict=strict))
+            ],
+            equivalent_node_sets=[
+                StandardizedEquivalentNodeSet.from_obograph_raw(e, converter, strict=strict)
+                for e in graph.equivalentNodesSets or []
+            ],
+            logical_definition_axioms=[
+                StandardizedLogicalDefinition.from_obograph_raw(e, converter, strict=strict)
+                for e in graph.logicalDefinitionAxioms or []
+            ],
+            property_chain_axioms=[
+                StandardizedPropertyChainAxiom.from_obograph_raw(e, converter, strict=strict)
+                for e in graph.propertyChainAxioms or []
+            ],
+            domain_range_axioms=[
+                StandardizedDomainRangeAxiom.from_obograph_raw(e, converter, strict=strict)
+                for e in graph.domainRangeAxioms or []
+            ],
+        )
+
+    def to_raw(self, converter: Converter) -> Graph:
+        """Create a raw object."""
+        return Graph(
+            id=self.id,
+            meta=self.meta.to_raw(converter) if self.meta is not None else None,
+            nodes=[node.to_raw(converter) for node in self.nodes],
+            edges=[edge.to_raw(converter) for edge in self.edges],
+            logicalDefinitionAxioms=[
+                axiom.to_raw(converter) for axiom in self.logical_definition_axioms
+            ],
+            propertyChainAxioms=[axiom.to_raw(converter) for axiom in self.property_chain_axioms],
+            domainRangeAxioms=[axiom.to_raw(converter) for axiom in self.domain_range_axioms],
+            equivalentNodesSets=[axiom.to_raw(converter) for axiom in self.equivalent_node_sets],
+        )
+
+    def _get_property(self, predicate: Reference) -> str | Reference | None:
+        if self.meta is None:
+            return None
+
+        for p in self.meta.properties or []:
+            if p.predicate == predicate:
+                return p.value
+
+        return None
+
+    @property
+    def name(self) -> str | None:
+        """Look up the name of the graph."""
+        r = self._get_property(Reference(prefix="dcterms", identifier="title"))
+        if isinstance(r, Reference):
+            raise TypeError
+        return r
+
+
+class StandardizedGraphDocument(StandardizedBaseModel[GraphDocument]):
+    """A standardized graph document."""
+
+    graphs: list[StandardizedGraph]
+    meta: StandardizedMeta | None = None
+
+    @classmethod
+    def from_obograph_raw(
+        cls, graph_document: GraphDocument, converter: Converter, *, strict: bool = False
+    ) -> Self:
+        """Instantiate by standardizing a raw OBO Graph Document object."""
+        return cls(
+            graphs=[
+                StandardizedGraph.from_obograph_raw(graph, converter, strict=strict)
+                for graph in graph_document.graphs
+            ],
+            meta=StandardizedMeta.from_obograph_raw(graph_document.meta, converter, strict=strict),
+        )
+
+    def to_raw(self, converter: Converter) -> GraphDocument:
+        """Create a raw object."""
+        return GraphDocument(
+            graphs=[graph.to_raw(converter) for graph in self.graphs],
+            meta=self.meta.to_raw(converter) if self.meta is not None else None,
         )
 
 
-def _parse_list(ss: list[str] | None, converter: Converter) -> list[Reference] | None:
-    if not ss:
+def _parse_list(
+    curie_or_uris: list[str] | None, converter: Converter, *, strict: bool
+) -> list[Reference] | None:
+    if not curie_or_uris:
         return None
-    return [_curie_or_uri_to_ref(x, converter) for x in ss]
+    return [
+        reference
+        for curie_or_uri in curie_or_uris
+        if (reference := _curie_or_uri_to_ref(curie_or_uri, converter, strict=strict))
+    ]
 
 
 #: defined in https://github.com/geneontology/obographs/blob/6676b10a5cce04707d75b9dd46fa08de70322b0b/obographs-owlapi/src/main/java/org/geneontology/obographs/owlapi/FromOwl.java#L36-L39
-BUILTINS = {
-    "is_a": Reference(prefix="rdfs", identifier="subClassOf"),
-    "subPropertyOf": Reference(prefix="rdfs", identifier="subPropertyOf"),
-    "type": Reference(prefix="rdf", identifier="type"),
+#: this list is complete.
+BUILTINS: dict[str, Reference] = {
+    "is_a": vocabulary.is_a,
+    "subPropertyOf": vocabulary.subproperty_of,
+    "type": vocabulary.rdf_type,
     "inverseOf": Reference(prefix="owl", identifier="inverseOf"),
 }
 
+"""maybe add these later?
+    # predicates, see https://github.com/geneontology/obographs/blob/6676b10a5cce04707d75b9dd46fa08de70322b0b/obographs-core/src/test/java/org/geneontology/obographs/core/model/axiom/PropertyChainAxiomTest.java#L12-L14
+    # "part_of": vocabulary.part_of,
+    # "has_part": vocabulary.has_part,
+    # "overlaps": Reference(prefix="RO", identifier="0002131"),
+"""
 
-def _curie_or_uri_to_ref(s: str, converter: Converter) -> Reference:
+REVERSE_BUILTINS: dict[Reference, str] = {v: k for k, v in BUILTINS.items()}
+
+
+def _curie_or_uri_to_ref(s: str, converter: Converter, *, strict: bool) -> Reference | None:
     if s in BUILTINS:
         return BUILTINS[s]
-    if converter.is_uri(s):
-        p, o = converter.parse_uri(s)
-        return Reference(prefix=p, identifier=o)
-    elif converter.is_curie(s):
-        pass
-    raise ValueError(f"can't parse string: {s}")
+    try:
+        reference_tuple = converter.parse(s, strict=False)
+    except curies.preprocessing.BlocklistError:
+        return None
+    if reference_tuple is not None:
+        return reference_tuple.to_pydantic()
+    if strict:
+        raise ValueError(f"could not parse {s}")
+    return None

obographs/version.py

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

{obographs-0.0.2.dist-info → obographs-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: obographs
-Version: 0.0.2
+Version: 0.0.4
 Summary: A python data model for OBO Graphs
 Keywords: snekpack,cookiecutter
 Author: Charles Tapley Hoyt
@@ -23,15 +23,8 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Typing :: Typed
 Requires-Dist: pydantic
-Requires-Dist: curies
+Requires-Dist: curies>=0.10.19
 Requires-Dist: typing-extensions
-Requires-Dist: sphinx>=8 ; extra == 'docs'
-Requires-Dist: sphinx-rtd-theme>=3.0 ; extra == 'docs'
-Requires-Dist: sphinx-automodapi ; extra == 'docs'
-Requires-Dist: autodoc-pydantic ; extra == 'docs'
-Requires-Dist: requests ; extra == 'network'
-Requires-Dist: pytest ; extra == 'tests'
-Requires-Dist: coverage[toml] ; extra == 'tests'
 Maintainer: Charles Tapley Hoyt
 Maintainer-email: Charles Tapley Hoyt <cthoyt@gmail.com>
 Requires-Python: >=3.10
@@ -40,9 +33,6 @@ Project-URL: Documentation, https://obographs.readthedocs.io
 Project-URL: Funding, https://github.com/sponsors/cthoyt
 Project-URL: Homepage, https://github.com/cthoyt/obographs
 Project-URL: Repository, https://github.com/cthoyt/obographs.git
-Provides-Extra: docs
-Provides-Extra: network
-Provides-Extra: tests
 Description-Content-Type: text/markdown
 
 <!--
@@ -97,7 +87,7 @@ graph_raw = obographs.read(url)
 The OBO Graph JSON schema uses non-Pythonic names, and it's inherently not aware
 of semantics - it uses a combination of URIs and ad-hoc symbols as identifiers.
 `obographs` implements a standardization workflow that creates new data
-structures with parsed/normalized URIs and symbols that has Pythonic nams. Use
+structures with parsed/normalized URIs and symbols that has Pythonic names. Use
 it like:
 
 ```python
@@ -129,18 +119,15 @@ $ python3 -m pip install obographs
 The most recent code and data can be installed directly from GitHub with uv:
 
 ```console
-$ uv --preview pip install git+https://github.com/cthoyt/obographs.git
+$ uv pip install git+https://github.com/cthoyt/obographs.git
 ```
 
 or with pip:
 
 ```console
-$ UV_PREVIEW=1 python3 -m pip install git+https://github.com/cthoyt/obographs.git
+$ python3 -m pip install git+https://github.com/cthoyt/obographs.git
 ```
 
-Note that this requires setting `UV_PREVIEW` mode enabled until the uv build
-backend becomes a stable feature.
-
 ## 👐 Contributing
 
 Contributions, whether filing an issue, making a pull request, or forking, are
@@ -203,18 +190,15 @@ To install in development mode, use the following:
 ```console
 $ git clone git+https://github.com/cthoyt/obographs.git
 $ cd obographs
-$ uv --preview pip install -e .
+$ uv pip install -e .
 ```
 
 Alternatively, install using pip:
 
 ```console
-$ UV_PREVIEW=1 python3 -m pip install -e .
+$ python3 -m pip install -e .
 ```
 
-Note that this requires setting `UV_PREVIEW` mode enabled until the uv build
-backend becomes a stable feature.
-
 ### Updating Package Boilerplate
 
 This project uses `cruft` to keep boilerplate (i.e., configuration, contribution

obographs-0.0.4.dist-info/RECORD

@@ -0,0 +1,10 @@
+obographs/__init__.py,sha256=55f4bf18441bd7f6c41afa68d094532933b02b21dbdd20679cf8807c1791d494,1601
+obographs/model.py,sha256=1f1bda132b83d8e08d7301eddb9be8d58b7e61c5b30e9baab9c24fd22348db53,8457
+obographs/py.typed,sha256=01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b,1
+obographs/standardized.py,sha256=69d26bbd35b49232b8d4bc2ae462f864f4fffcadf3acb7d541783fc8745dbd5e,25791
+obographs/version.py,sha256=c50bb52fc81eb5b19dedfb8583a0c19b6127aff659301cb2d3d51f4d244fefc3,961
+obographs-0.0.4.dist-info/licenses/LICENSE,sha256=4be0ec343e3bf11fd54321a6b576d5616ebb7d18898f741f63c517209e33bcb2,1076
+obographs-0.0.4.dist-info/WHEEL,sha256=65f6765ba93534713730ff2172cd912ef280aa42867625a73f77c2fef0639dae,78
+obographs-0.0.4.dist-info/entry_points.txt,sha256=9a9819cedd2186e28d5d42ddce5e3de1417b0db2b07392ff35f9adc7c86a8619,50
+obographs-0.0.4.dist-info/METADATA,sha256=ac4daf3fa7f23379788e758debc91663ee15663ee1c9fabbf79bc69ca79c5e5b,12768
+obographs-0.0.4.dist-info/RECORD,,

{obographs-0.0.2.dist-info → obographs-0.0.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.5.31
+Generator: uv 0.7.3
 Root-Is-Purelib: true
 Tag: py3-none-any

obographs-0.0.2.dist-info/RECORD

@@ -1,10 +0,0 @@
-obographs/version.py,sha256=04839f3ad0ad481ebb750f5228278ee8a55b26c17bd61c0a3f2ccc6da50204ae,961
-obographs/__init__.py,sha256=93807a9cc6f4002ac923a84a8c5e1a9b6301c5368cd61a957c9115adfaef1a56,254
-obographs/model.py,sha256=3387390f1a30fe47b22c7c346dfdf2b6a595ccbc7cd8d7d09debf4a13f8f6e6c,6846
-obographs/py.typed,sha256=01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b,1
-obographs/standardized.py,sha256=15a58dcb9af39a01565fdb096389caf2702f94052e933f9368d93caf620022f5,7099
-obographs-0.0.2.dist-info/licenses/LICENSE,sha256=4be0ec343e3bf11fd54321a6b576d5616ebb7d18898f741f63c517209e33bcb2,1076
-obographs-0.0.2.dist-info/WHEEL,sha256=e3765529bb0cc791d07188d72ec6a759d7625ff6d3a5e4b710d25409bae03770,79
-obographs-0.0.2.dist-info/entry_points.txt,sha256=9a9819cedd2186e28d5d42ddce5e3de1417b0db2b07392ff35f9adc7c86a8619,50
-obographs-0.0.2.dist-info/METADATA,sha256=3e577f9dcce8afd6b2b0694935c320b898e5253ba6f0dcf8520b4d1a996ef3a3,13429
-obographs-0.0.2.dist-info/RECORD,,