pyobo 0.11.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

pyobo/struct/typedef.py

@@ -1,202 +1,91 @@
 """Default typedefs, references, and other structures."""
 
-from collections.abc import Iterable
-from dataclasses import dataclass, field
-from typing import Optional, Union
+from __future__ import annotations
 
-from .reference import Reference, Referenced
-from ..identifier_utils import normalize_curie
+from collections.abc import Sequence
+
+from curies import ReferenceTuple
+
+from . import vocabulary as v
+from .reference import Reference, default_reference
+from .struct import TypeDef
 from ..resources.ro import load_ro
 
 __all__ = [
-    "TypeDef",
-    "RelationHint",
-    "get_reference_tuple",
+    "alternative_term",
+    "broad_match",
+    "close_match",
     "default_typedefs",
+    "editor_note",
+    "enables",
+    "exact_match",
+    "example_of_usage",
     "from_species",
-    "species_specific",
+    "gene_product_member_of",
+    "has_contributor",
+    "has_dbxref",
+    "has_end_date",
+    "has_gene_product",
+    "has_homepage",
+    "has_inchi",
+    "has_mature",
+    "has_member",
     "has_part",
-    "part_of",
+    "has_participant",
+    "has_predecessor",
+    "has_role",
+    "has_salt",
+    "has_smiles",
+    "has_start_date",
+    "has_successor",
+    "has_taxonomy_rank",
     "is_a",
-    "see_also",
-    "has_member",
+    "located_in",
+    "mapping_has_confidence",
+    "mapping_has_justification",
+    "match_typedefs",
     "member_of",
-    "superclass_of",
+    "narrow_match",
     "orthologous",
-    "has_role",
+    "part_of",
+    "participates_in",
+    "related_match",
     "role_of",
-    "has_mature",
-    "has_gene_product",
-    "gene_product_member_of",
-    "has_gene_product",
+    "see_also",
+    "species_specific",
+    "superclass_of",
     "transcribes_to",
     "translates_to",
-    "gene_product_member_of",
-    "example_of_usage",
-    "alternative_term",
-    "editor_note",
-    "has_salt",
-    "enables",
-    "participates_in",
-    "has_participant",
-    "exact_match",
-    "has_dbxref",
-    "located_in",
-    "has_successor",
-    "has_predecessor",
-    # Properties
-    "has_inchi",
-    "has_smiles",
-    "has_homepage",
 ]
 
-
-def _bool_to_obo(v: bool) -> str:
-    return "true" if v else "false"
-
-
-@dataclass
-class TypeDef(Referenced):
-    """A type definition in OBO.
-
-    See the subsection of https://owlcollab.github.io/oboformat/doc/GO.format.obo-1_4.html#S.2.2.
-    """
-
-    reference: Reference
-    comment: Optional[str] = None
-    namespace: Optional[str] = None
-    definition: Optional[str] = None
-    is_transitive: Optional[bool] = None
-    is_symmetric: Optional[bool] = None
-    domain: Optional[Reference] = None
-    range: Optional[Reference] = None
-    parents: list[Reference] = field(default_factory=list)
-    xrefs: list[Reference] = field(default_factory=list)
-    inverse: Optional[Reference] = None
-    created_by: Optional[str] = None
-    holds_over_chain: Optional[list[Reference]] = None
-    #: Whether this relationship is a metadata tag. Properties that are marked as metadata tags are
-    #: used to record object metadata. Object metadata is additional information about an object
-    #: that is useful to track, but does not impact the definition of the object or how it should
-    #: be treated by a reasoner. Metadata tags might be used to record special term synonyms or
-    #: structured notes about a term, for example.
-    is_metadata_tag: Optional[bool] = None
-
-    def __hash__(self) -> int:
-        return hash((self.__class__, self.prefix, self.identifier))
-
-    def iterate_obo_lines(self) -> Iterable[str]:
-        """Iterate over the lines to write in an OBO file."""
-        yield "\n[Typedef]"
-        yield f"id: {self.reference.preferred_curie}"
-        if self.name:
-            yield f"name: {self.reference.name}"
-        if self.definition:
-            yield f'def: "{self.definition}"'
-
-        if self.is_metadata_tag is not None:
-            yield f"is_metadata_tag: {_bool_to_obo(self.is_metadata_tag)}"
-
-        if self.namespace:
-            yield f"namespace: {self.namespace}"
-
-        if self.created_by:
-            yield f"created_by: {self.created_by}"
-
-        if self.comment:
-            yield f"comment: {self.comment}"
-
-        for xref in self.xrefs:
-            yield f"xref: {xref.preferred_curie}"
-
-        if self.is_transitive is not None:
-            yield f'is_transitive: {"true" if self.is_transitive else "false"}'
-
-        if self.is_symmetric is not None:
-            yield f'is_symmetric: {"true" if self.is_symmetric else "false"}'
-        if self.holds_over_chain:
-            _chain = " ".join(link.preferred_curie for link in self.holds_over_chain)
-            _names = " / ".join(link.name or "_" for link in self.holds_over_chain)
-            yield f"holds_over_chain: {_chain} ! {_names}"
-        if self.inverse:
-            yield f"inverse_of: {self.inverse}"
-        if self.domain:
-            yield f"domain: {self.domain}"
-        if self.range:
-            yield f"range: {self.range}"
-
-    @classmethod
-    def from_triple(cls, prefix: str, identifier: str, name: Optional[str] = None) -> "TypeDef":
-        """Create a typedef from a reference."""
-        return cls(reference=Reference(prefix=prefix, identifier=identifier, name=name))
-
-    @classmethod
-    def from_curie(cls, curie: str, name: Optional[str] = None) -> "TypeDef":
-        """Create a TypeDef directly from a CURIE and optional name."""
-        prefix, identifier = normalize_curie(curie)
-        if prefix is None or identifier is None:
-            raise ValueError
-        return cls.from_triple(prefix=prefix, identifier=identifier, name=name)
-
-
-RelationHint = Union[Reference, TypeDef, tuple[str, str], str]
-
-
-def get_reference_tuple(relation: RelationHint) -> tuple[str, str]:
-    """Get tuple for typedef/reference."""
-    if isinstance(relation, (Reference, TypeDef)):
-        return relation.prefix, relation.identifier
-    elif isinstance(relation, tuple):
-        return relation
-    elif isinstance(relation, str):
-        prefix, identifier = normalize_curie(relation)
-        if prefix is None or identifier is None:
-            raise ValueError(f"string given is not valid curie: {relation}")
-        return prefix, identifier
-    else:
-        raise TypeError(f"Relation is invalid type: {relation}")
-
-
 RO_PREFIX = "RO"
 BFO_PREFIX = "BFO"
 IAO_PREFIX = "IAO"
 SIO_PREFIX = "SIO"
 
-from_species = TypeDef(
-    reference=Reference(prefix=RO_PREFIX, identifier="0002162", name="in taxon"),
-)
+from_species = TypeDef(reference=v.from_species)
 species_specific = TypeDef(
-    reference=Reference(prefix="debio", identifier="0000007", name="species specific"),
+    reference=v.species_specific,
     definition="X speciesSpecific Y means that Y is a general phenomena, "
     "like a pathway, and X is the version that appears in a species. X should state which"
     "species with RO:0002162 (in taxon)",
 )
-has_left_to_right_reaction = TypeDef(
-    Reference(prefix="debio", identifier="0000007", name="has left-to-right reaction"),
-    is_metadata_tag=True,
-)
-has_right_to_left_reaction = TypeDef(
-    Reference(prefix="debio", identifier="0000008", name="has right-to-left reaction"),
-    is_metadata_tag=True,
-)
+has_left_to_right_reaction = TypeDef(v.has_left_to_right_reaction, is_metadata_tag=True)
+has_right_to_left_reaction = TypeDef(v.has_right_to_left_reaction, is_metadata_tag=True)
 has_bidirectional_reaction = TypeDef(
-    Reference(prefix="debio", identifier="0000009", name="has bi-directional reaction"),
+    reference=default_reference("RO", "hasBiDirectionalReaction"),
     is_metadata_tag=True,
-)
+).append_xref(Reference(prefix="debio", identifier="0000009", name="has bi-directional reaction"))
 reaction_enabled_by_molecular_function = TypeDef(
+    reference=default_reference("RO", "reactionEnabledByMolecularFunction")
+).append_xref(
     Reference(prefix="debio", identifier="0000047", name="reaction enabled by molecular function")
 )
 
-
-part_of = TypeDef(
-    reference=Reference(prefix=BFO_PREFIX, identifier="0000050", name="part of"),
-    comment="Inverse of has_part",
-    inverse=Reference(prefix=BFO_PREFIX, identifier="0000051", name="has part"),
-)
-has_part = TypeDef(
-    reference=Reference(prefix=BFO_PREFIX, identifier="0000051", name="has part"),
-    comment="Inverse of part_of",
-    inverse=Reference(prefix=BFO_PREFIX, identifier="0000050", name="part of"),
+part_of = TypeDef(reference=v.part_of, comment="Inverse of has_part", inverse=v.has_part)
+has_part = TypeDef(reference=v.has_part, comment="Inverse of part_of", inverse=v.part_of)
+occurs_in = TypeDef(
+    reference=Reference(prefix=BFO_PREFIX, identifier="BFO:0000066", name="occurs in")
 )
 participates_in = TypeDef(
     reference=Reference(prefix=RO_PREFIX, identifier="0000056", name="participates in"),
@@ -208,6 +97,9 @@ has_participant = TypeDef(
     comment="Inverse of has participant",
     inverse=Reference(prefix=RO_PREFIX, identifier="0000056", name="participates in"),
 )
+has_component = TypeDef(
+    reference=Reference(prefix=RO_PREFIX, identifier="0002180", name="has component"),
+)
 derives_from = TypeDef(
     reference=Reference(prefix=RO_PREFIX, identifier="0001000", name="derives from"),
 )
@@ -217,16 +109,22 @@ molecularly_interacts_with = TypeDef(
 located_in = TypeDef(
     reference=Reference(prefix=RO_PREFIX, identifier="0001025", name="located in"),
 )
-exact_match = TypeDef(
-    reference=Reference(prefix="skos", identifier="exactMatch", name="exact match"),
-)
-is_a = TypeDef(
-    reference=Reference(prefix="rdfs", identifier="subClassOf", name="subclass of"),
-)
-see_also = TypeDef(
-    reference=Reference(prefix="rdfs", identifier="seeAlso", name="see also"),
-)
-comment = TypeDef(reference=Reference(prefix="rdfs", identifier="comment", name="comment"))
+exact_match = TypeDef(reference=v.exact_match, is_metadata_tag=True)
+narrow_match = TypeDef(reference=v.narrow_match, is_metadata_tag=True)
+broad_match = TypeDef(reference=v.broad_match, is_metadata_tag=True)
+close_match = TypeDef(reference=v.close_match, is_metadata_tag=True)
+related_match = TypeDef(reference=v.related_match, is_metadata_tag=True)
+owl_same_as = TypeDef(
+    reference=v.owl_same_as,
+)
+equivalent_class = TypeDef(reference=v.equivalent_class)
+equivalent_property = TypeDef(reference=v.equivalent_property)
+
+is_a = TypeDef(reference=v.is_a)
+rdf_type = TypeDef(reference=v.rdf_type)
+subproperty_of = TypeDef(reference=v.subproperty_of)
+see_also = TypeDef(reference=v.see_also, is_metadata_tag=True)
+comment = TypeDef(reference=v.comment, is_metadata_tag=True)
 has_member = TypeDef(
     reference=Reference(prefix=RO_PREFIX, identifier="0002351", name="has member"),
 )
@@ -241,12 +139,7 @@ superclass_of = TypeDef(
 )
 
 develops_from = TypeDef.from_triple(prefix=RO_PREFIX, identifier="0002202", name="develops from")
-orthologous = TypeDef(
-    reference=Reference(
-        prefix=RO_PREFIX, identifier="HOM0000017", name="in orthology relationship with"
-    ),
-    is_symmetric=True,
-)
+orthologous = TypeDef(reference=v.orthologous, is_symmetric=True)
 
 has_role = TypeDef(
     reference=Reference(prefix=RO_PREFIX, identifier="0000087", name="has role"),
@@ -286,8 +179,10 @@ has_gene_product = TypeDef(
 gene_product_member_of = TypeDef(
     reference=Reference(prefix="debio", identifier="0000001", name="gene product is a member of"),
     holds_over_chain=[
-        has_gene_product.reference,
-        member_of.reference,
+        [
+            has_gene_product.reference,
+            member_of.reference,
+        ]
     ],
 )
 
@@ -295,24 +190,23 @@ has_salt = TypeDef(
     reference=Reference(prefix="debio", identifier="0000006", name="has salt"),
 )
 
-term_replaced_by = TypeDef.from_triple(
-    prefix=IAO_PREFIX, identifier="0100001", name="term replaced by"
-)
-example_of_usage = TypeDef.from_triple(
-    prefix=IAO_PREFIX, identifier="0000112", name="example of usage"
-)
-alternative_term = TypeDef.from_triple(
-    prefix=IAO_PREFIX, identifier="0000118", name="alternative term"
-)
-has_ontology_root_term = TypeDef.from_triple(
-    prefix=IAO_PREFIX, identifier="0000700", name="has ontology root term"
+term_replaced_by = TypeDef(reference=v.term_replaced_by, is_metadata_tag=True)
+example_of_usage = TypeDef(
+    reference=Reference(prefix=IAO_PREFIX, identifier="0000112", name="example of usage"),
+    is_metadata_tag=True,
 )
-definition_source = TypeDef.from_triple(
-    prefix=IAO_PREFIX, identifier="0000119", name="definition source"
+alternative_term = TypeDef(reference=v.alternative_term, is_metadata_tag=True)
+has_ontology_root_term = TypeDef(reference=v.has_ontology_root_term, is_metadata_tag=True)
+definition_source = TypeDef(
+    reference=Reference(prefix=IAO_PREFIX, identifier="0000119", name="definition source"),
+    is_metadata_tag=True,
 )
-has_dbxref = TypeDef.from_curie("oboInOwl:hasDbXref", name="has database cross-reference")
+has_dbxref = TypeDef(reference=v.has_dbxref, is_metadata_tag=True)
 
-editor_note = TypeDef.from_triple(prefix=IAO_PREFIX, identifier="0000116", name="editor note")
+editor_note = TypeDef(
+    reference=Reference(prefix=IAO_PREFIX, identifier="0000116", name="editor note"),
+    is_metadata_tag=True,
+)
 
 is_immediately_transformed_from = TypeDef.from_triple(
     prefix=SIO_PREFIX, identifier="000658", name="is immediately transformed from"
@@ -329,7 +223,7 @@ has_output = TypeDef.from_triple(prefix=RO_PREFIX, identifier="0002234", name="h
 has_successor = TypeDef.from_triple(prefix="BFO", identifier="0000063", name="has successor")
 has_predecessor = TypeDef.from_triple(prefix="BFO", identifier="0000062", name="has predecessor")
 
-"""ChEBI"""
+# ChEBI
 
 is_conjugate_base_of = TypeDef(
     reference=Reference(prefix="ro", identifier="0018033", name="is conjugate base of"),
@@ -353,13 +247,15 @@ has_functional_parent = TypeDef(
     reference=Reference(prefix="ro", identifier="0018038", name="has functional parent"),
 )
 
-has_smiles = TypeDef(
-    reference=Reference(prefix="debio", identifier="0000022", name="has SMILES"),
+has_citation = TypeDef(
+    reference=v.has_citation,
+    is_metadata_tag=True,
+    range=Reference(prefix="IAO", identifier="0000013", name="journal article"),
 )
 
-has_inchi = TypeDef(
-    reference=Reference(prefix="debio", identifier="0000020", name="has InChI"),
-)
+has_smiles = TypeDef(reference=v.has_smiles, is_metadata_tag=True).append_xref(v.debio_has_smiles)
+
+has_inchi = TypeDef(reference=v.has_inchi, is_metadata_tag=True).append_xref(v.debio_has_inchi)
 
 has_homepage = TypeDef(
     reference=Reference(prefix="foaf", identifier="homepage", name="homepage"), is_metadata_tag=True
@@ -370,10 +266,66 @@ has_category = TypeDef(
     is_metadata_tag=True,
 )
 
-default_typedefs: dict[tuple[str, str], TypeDef] = {
-    v.pair: v for k, v in locals().items() if isinstance(v, TypeDef)
+has_taxonomy_rank = TypeDef(
+    reference=Reference(prefix="taxrank", identifier="1000000", name="has rank"),
+    is_metadata_tag=True,
+)
+
+mapping_has_justification = TypeDef(
+    reference=v.mapping_has_justification,
+    is_metadata_tag=True,
+    range=Reference(prefix="semapv", identifier="Matching", name="matching process"),
+)
+mapping_has_confidence = TypeDef(
+    reference=v.mapping_has_confidence, is_metadata_tag=True, range=v.xsd_float
+)
+has_contributor = TypeDef(reference=v.has_contributor, is_metadata_tag=True)
+has_source = TypeDef(reference=v.has_source, is_metadata_tag=True)
+
+has_start_date = TypeDef(
+    reference=Reference(prefix="dcat", identifier="startDate", name="has start date"),
+    is_metadata_tag=True,
+)
+has_end_date = TypeDef(
+    reference=Reference(prefix="dcat", identifier="endDate", name="has end date"),
+    is_metadata_tag=True,
+)
+
+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)
+
+in_subset = TypeDef(reference=v.in_subset, is_metadata_tag=True)
+has_term_editor = TypeDef(reference=v.has_term_editor, is_metadata_tag=True)
+
+default_typedefs: dict[ReferenceTuple, TypeDef] = {
+    v.pair: v for v in locals().values() if isinstance(v, TypeDef)
 }
 
-for pair, name in load_ro().items():
-    if pair not in default_typedefs:
-        default_typedefs[pair] = TypeDef.from_triple(pair[0], pair[1], name)
+for reference, name in load_ro().items():
+    if reference not in default_typedefs:
+        default_typedefs[reference] = TypeDef.from_triple(
+            reference.prefix, reference.identifier, name
+        )
+
+#: SSSOM-compliant match type definitions
+#: .. seealso:: https://mapping-commons.github.io/sssom/spec-model/
+match_typedefs: Sequence[TypeDef] = (
+    broad_match,
+    close_match,
+    exact_match,
+    narrow_match,
+    related_match,
+    owl_same_as,  # for instances
+    equivalent_class,  # for classes
+    equivalent_property,  # for properties
+    has_dbxref,
+    see_also,
+)
+
+# Extension past the SSSOM spec
+extended_match_typedefs = (
+    *match_typedefs,
+    alternative_term,
+    term_replaced_by,
+)

pyobo/struct/utils.py

@@ -1,11 +1,14 @@
 """Utilities for data structures for OBO."""
 
+from __future__ import annotations
+
+from collections.abc import Iterable
+
 __all__ = [
-    "OBO_ESCAPE_SLIM",
     "OBO_ESCAPE",
+    "OBO_ESCAPE_SLIM",
     "obo_escape",
     "obo_escape_slim",
-    "comma_separate",
 ]
 
 OBO_ESCAPE_SLIM = {c: f"\\{c}" for c in ':,"\\()[]{}'}
@@ -24,6 +27,10 @@ def obo_escape_slim(string: str) -> str:
     return rv
 
 
-def comma_separate(elements) -> str:
-    """Map a list to strings and make comma separated."""
-    return ", ".join(map(str, elements))
+def _bool_to_obo(v: bool) -> str:
+    return "true" if v else "false"
+
+
+def _boolean_tag(tag: str, bv: bool | None) -> Iterable[str]:
+    if bv is not None:
+        yield f"{tag}: {_bool_to_obo(bv)}"

pyobo/struct/vocabulary.py

@@ -0,0 +1,138 @@
+"""Reusable vocabulary."""
+
+from collections.abc import Sequence
+
+import curies
+from curies import vocabulary as _v
+
+from .reference import Reference, default_reference
+
+__all__ = [
+    "equivalent_class",
+    "has_contributor",
+    "mapping_has_confidence",
+    "mapping_has_justification",
+]
+
+RO_PREFIX = "RO"
+BFO_PREFIX = "BFO"
+
+
+def _c(c: curies.Reference) -> Reference:
+    if isinstance(c, curies.NamableReference):
+        return Reference(prefix=c.prefix, identifier=c.identifier, name=c.name)
+    else:
+        return Reference(prefix=c.prefix, identifier=c.identifier)
+
+
+broad_match = _c(_v.broad_match)
+close_match = _c(_v.close_match)
+exact_match = _c(_v.exact_match)
+narrow_match = _c(_v.narrow_match)
+related_match = _c(_v.related_match)
+
+has_related_synonym = _c(_v.has_related_synonym)
+has_exact_synonym = _c(_v.has_exact_synonym)
+has_narrow_synonym = _c(_v.has_narrow_synonym)
+has_broad_synonym = _c(_v.has_broad_synonym)
+
+mapping_has_justification = Reference(
+    prefix="sssom", identifier="mapping_justification", name="mapping justification"
+)
+mapping_has_confidence = Reference(prefix="sssom", identifier="confidence", name="has confidence")
+has_contributor = _c(_v.has_contributor)
+has_source = _c(_v.has_source)
+has_date = _c(_v.has_date)
+has_dbxref = _c(_v.has_dbxref)
+
+in_subset = _c(_v.obo_in_subset)
+has_obo_namespace = _c(_v.obo_has_namespace)
+obo_autogenerated_by = _c(_v.obo_autogenerated_by)
+obo_creation_date = _c(_v.obo_creation_date)
+
+equivalent_class = _c(_v.equivalent_property)
+equivalent_property = _c(_v.equivalent_class)
+owl_same_as = _c(_v.same_as)
+version_info = _c(_v.owl_version_info)
+term_replaced_by = _c(_v.term_replaced_by)
+alternative_term = _c(_v.alternative_term)
+has_ontology_root_term = _c(_v.has_ontology_root_term)
+has_term_editor = _c(_v.has_term_editor)
+
+see_also = _c(_v.see_also)
+comment = _c(_v.has_comment)
+label = _c(_v.has_label)
+
+from_species = Reference(prefix=RO_PREFIX, identifier="0002162", name="in taxon")
+species_specific = Reference(prefix="debio", identifier="0000007", name="species specific")
+has_left_to_right_reaction = Reference(
+    prefix="debio", identifier="0000007", name="has left-to-right reaction"
+)
+has_right_to_left_reaction = Reference(
+    prefix="debio", identifier="0000008", name="has right-to-left reaction"
+)
+debio_has_inchi = Reference(prefix="debio", identifier="0000020", name="has InChI")
+has_inchi = Reference(prefix="chemrof", identifier="inchi_string")
+
+debio_has_smiles = Reference(prefix="debio", identifier="0000022", name="has SMILES")
+has_smiles = Reference(prefix="chemrof", identifier="smiles_string")
+
+# TODO update to use debio, or put in RO
+has_citation = default_reference(prefix="RO", identifier="hasCitation", name="has citation")
+has_description = _c(_v.has_description)
+has_license = _c(_v.has_license)
+has_title = _c(_v.has_title)
+
+has_part = Reference(prefix=BFO_PREFIX, identifier="0000051", name="has part")
+part_of = Reference(prefix=BFO_PREFIX, identifier="0000050", name="part of")
+orthologous = Reference(
+    prefix=RO_PREFIX, identifier="HOM0000017", name="in orthology relationship with"
+)
+is_a = _c(_v.is_a)
+subproperty_of = _c(_v.subproperty_of)
+rdf_type = _c(_v.rdf_type)
+
+xsd_string = _c(_v.xsd_string)
+xsd_float = _c(_v.xsd_float)
+xsd_decimal = _c(_v.xsd_decimal)
+xsd_integer = _c(_v.xsd_integer)
+xsd_boolean = _c(_v.xsd_boolean)
+xsd_year = _c(_v.xsd_year)
+xsd_uri = _c(_v.xsd_uri)
+
+CHARLIE = _c(_v.charlie)
+HUMAN = _c(_v.human)
+
+#: See https://mapping-commons.github.io/sssom/spec-model/
+match_typedefs: Sequence[Reference] = (
+    broad_match,
+    close_match,
+    exact_match,
+    narrow_match,
+    related_match,
+    owl_same_as,  # for instances
+    equivalent_class,  # for classes
+    equivalent_property,  # for properties
+    has_dbxref,
+    see_also,
+)
+
+# Extension past the SSSOM spec
+extended_match_typedefs: Sequence[Reference] = (
+    *match_typedefs,
+    alternative_term,
+    term_replaced_by,
+)
+
+#: These are predicates that have their own dedicated fields
+#: in OBO and FunOWL output
+SKIP_PROPERTY_PREDICATES_OBJECTS = [
+    term_replaced_by,  # maps to "replaced_by:" line
+    see_also,  # maps to "consider:" line
+    alternative_term,  # maps to "alt_id:" line
+]
+
+SKIP_PROPERTY_PREDICATES_LITERAL = [
+    comment,  # maps to "comment:" line with strings
+    obo_creation_date,
+]