pyobo 0.10.7__py3-none-any.whl → 0.10.9__py3-none-any.whl

pyobo/sources/omim_ps.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+"""Converter for OMIM Phenotypic Series."""
+
+import logging
+from typing import Iterable
+
+from bioversions.utils import get_soup
+
+from pyobo.struct import Obo, Term
+
+__all__ = [
+    "OMIMPSGetter",
+]
+
+
+logger = logging.getLogger(__name__)
+PREFIX = "omim.ps"
+URL = "https://omim.org/phenotypicSeriesTitles/all"
+
+
+class OMIMPSGetter(Obo):
+    """An ontology representation of OMIM Phenotypic Series."""
+
+    ontology = bioversions_key = PREFIX
+
+    def iter_terms(self, force: bool = False) -> Iterable[Term]:
+        """Iterate over terms in the ontology."""
+        soup = get_soup(URL, user_agent="Mozilla/5.0")
+        rows = soup.find(id="mimContent").find("table").find("tbody").find_all("tr")
+        for row in rows:
+            anchor = row.find("td").find("a")
+            name = anchor.text.strip()
+            identifier = anchor.attrs["href"][len("/phenotypicSeries/") :]
+            yield Term.from_triple(PREFIX, identifier, name)
+
+
+if __name__ == "__main__":
+    OMIMPSGetter.cli()

pyobo/sources/rhea.py

@@ -3,31 +3,51 @@
 """Converter for Rhea."""
 
 import logging
-from typing import Iterable
+from typing import TYPE_CHECKING, Dict, Iterable, Optional
 
+import bioversions
 import pystow
 
 from pyobo.struct import Obo, Reference, Term
 from pyobo.struct.typedef import (
+    TypeDef,
+    enabled_by,
     has_bidirectional_reaction,
+    has_input,
     has_left_to_right_reaction,
+    has_output,
+    has_participant,
     has_right_to_left_reaction,
+    reaction_enabled_by_molecular_function,
 )
 from pyobo.utils.path import ensure_df
 
+if TYPE_CHECKING:
+    import rdflib
+
 __all__ = [
     "RheaGetter",
 ]
 
 logger = logging.getLogger(__name__)
 PREFIX = "rhea"
+RHEA_RDF_GZ_URL = "ftp://ftp.expasy.org/databases/rhea/rdf/rhea.rdf.gz"
 
 
 class RheaGetter(Obo):
     """An ontology representation of Rhea's chemical reaction database."""
 
     ontology = bioversions_key = PREFIX
-    typedefs = [has_left_to_right_reaction, has_bidirectional_reaction, has_right_to_left_reaction]
+    typedefs = [
+        has_left_to_right_reaction,
+        has_bidirectional_reaction,
+        has_right_to_left_reaction,
+        enabled_by,
+        has_input,
+        has_output,
+        has_participant,
+        reaction_enabled_by_molecular_function,
+    ]
 
     def iter_terms(self, force: bool = False) -> Iterable[Term]:
         """Iterate over terms in the ontology."""
@@ -39,25 +59,54 @@ def get_obo(force: bool = False) -> Obo:
     return RheaGetter(force=force)
 
 
+def ensure_rhea_rdf(version: Optional[str] = None, force: bool = False) -> "rdflib.Graph":
+    """Get the Rhea RDF graph."""
+    # see docs: https://ftp.expasy.org/databases/rhea/rdf/rhea_rdf_documentation.pdf
+    if version is None:
+        version = bioversions.get_version(PREFIX)
+    return pystow.ensure_rdf(
+        "pyobo",
+        "raw",
+        PREFIX,
+        version,
+        url=RHEA_RDF_GZ_URL,
+        force=force,
+        parse_kwargs=dict(format="xml"),
+    )
+
+
+def _get_lr_name(name: str) -> str:
+    return name.replace(" = ", " => ")
+
+
+def _get_rl_name(name: str) -> str:
+    left, right = name.split(" = ", 1)
+    return f"{right} => {left}"
+
+
+def _get_bi_name(name: str) -> str:
+    return name.replace(" = ", " <=> ")
+
+
 def iter_terms(version: str, force: bool = False) -> Iterable[Term]:
     """Iterate over terms in Rhea."""
-    url = "ftp://ftp.expasy.org/databases/rhea/rdf/rhea.rdf.gz"
-    graph = pystow.ensure_rdf(
-        "pyobo", "raw", PREFIX, version, url=url, force=force, parse_kwargs=dict(format="xml")
-    )
+    graph = ensure_rhea_rdf(version=version, force=force)
     result = graph.query(
-        """
-    PREFIX rh:<http://rdf.rhea-db.org/>
-    SELECT ?reaction ?reactionId ?reactionLabel WHERE {
-      ?reaction rdfs:subClassOf rh:Reaction .
-      ?reaction rh:id ?reactionId .
-      ?reaction rdfs:label ?reactionLabel .
-    }
+        """\
+        PREFIX rh:<http://rdf.rhea-db.org/>
+        SELECT ?reaction ?reactionId ?reactionLabel WHERE {
+          ?reaction rdfs:subClassOf rh:Reaction ;
+                    rh:id ?reactionId ;
+                    rdfs:label ?reactionLabel .
+        }
     """
     )
-    names = {str(identifier): name for _, identifier, name in result}
+    names = {str(identifier): str(name) for _, identifier, name in result}
 
-    terms = {}
+    terms: Dict[str, Term] = {}
+    master_to_left: Dict[str, str] = {}
+    master_to_right: Dict[str, str] = {}
+    master_to_bi: Dict[str, str] = {}
 
     directions = ensure_df(
         PREFIX,
@@ -66,12 +115,16 @@ def iter_terms(version: str, force: bool = False) -> Iterable[Term]:
         force=force,
     )
     for master, lr, rl, bi in directions.values:
-        terms[master] = Term(
-            reference=Reference(prefix=PREFIX, identifier=master, name=names.get(master))
-        )
-        terms[lr] = Term(reference=Reference(prefix=PREFIX, identifier=lr, name=names.get(lr)))
-        terms[rl] = Term(reference=Reference(prefix=PREFIX, identifier=rl, name=names.get(rl)))
-        terms[bi] = Term(reference=Reference(prefix=PREFIX, identifier=bi, name=names.get(bi)))
+        master_to_left[master] = lr
+        master_to_right[master] = rl
+        master_to_bi[master] = bi
+
+        name = names[master]
+
+        terms[master] = Term(reference=Reference(prefix=PREFIX, identifier=master, name=name))
+        terms[lr] = Term(reference=Reference(prefix=PREFIX, identifier=lr, name=_get_lr_name(name)))
+        terms[rl] = Term(reference=Reference(prefix=PREFIX, identifier=rl, name=_get_rl_name(name)))
+        terms[bi] = Term(reference=Reference(prefix=PREFIX, identifier=bi, name=_get_bi_name(name)))
 
         terms[master].append_relationship(has_left_to_right_reaction, terms[lr])
         terms[master].append_relationship(has_right_to_left_reaction, terms[rl])
@@ -80,6 +133,38 @@ def iter_terms(version: str, force: bool = False) -> Iterable[Term]:
         terms[rl].append_parent(terms[master])
         terms[bi].append_parent(terms[master])
 
+    # inspired by https://github.com/geneontology/go-ontology/blob/master/src/sparql/construct-rhea-reactions.sparql
+    sparql = """\
+    PREFIX rh:<http://rdf.rhea-db.org/>
+    SELECT ?reactionId ?side ?chebi WHERE {
+      ?reaction rdfs:subClassOf rh:Reaction ;
+                rh:id ?reactionId .
+
+      ?reaction rh:side ?side .
+      ?side rh:contains ?participant .
+      ?participant rh:compound ?compound .
+      ?compound rh:chebi|rh:underlyingChebi|(rh:reactivePart/rh:chebi) ?chebi .
+    }
+    """
+    for master_rhea_id, side_uri, chebi_uri in graph.query(sparql):
+        master_rhea_id = str(master_rhea_id)
+        chebi_reference = Reference(
+            prefix="chebi", identifier=chebi_uri[len("http://purl.obolibrary.org/obo/CHEBI_") :]
+        )
+        side = side_uri.split("_")[-1]  # L or R
+        if side == "L":
+            left_rhea_id = master_to_left[master_rhea_id]
+            right_rhea_id = master_to_right[master_rhea_id]
+        elif side == "R":
+            left_rhea_id = master_to_right[master_rhea_id]
+            right_rhea_id = master_to_left[master_rhea_id]
+        else:
+            raise ValueError(f"Invalid side: {side_uri}")
+        terms[master_rhea_id].append_relationship(has_participant, chebi_reference)
+        terms[master_to_bi[master_rhea_id]].append_relationship(has_participant, chebi_reference)
+        terms[left_rhea_id].append_relationship(has_input, chebi_reference)
+        terms[right_rhea_id].append_relationship(has_output, chebi_reference)
+
     hierarchy = ensure_df(
         PREFIX,
         url="ftp://ftp.expasy.org/databases/rhea/tsv/rhea-relationships.tsv",
@@ -91,12 +176,14 @@ def iter_terms(version: str, force: bool = False) -> Iterable[Term]:
             raise ValueError(f"RHEA unrecognized relation: {relation}")
         terms[source].append_parent(terms[target])
 
-    for xref_prefix, url in [
-        ("ecocyc", "rhea2ecocyc"),
-        ("kegg.reaction", "rhea2kegg_reaction"),
-        ("reactome", "rhea2reactome"),
-        ("macie", "rhea2macie"),
-        ("metacyc", "rhea2metacyc"),
+    for xref_prefix, url, relation in [
+        ("ecocyc", "rhea2ecocyc", None),
+        ("kegg.reaction", "rhea2kegg_reaction", None),
+        ("reactome", "rhea2reactome", None),
+        ("macie", "rhea2macie", None),
+        ("metacyc", "rhea2metacyc", None),
+        ("go", "rhea2go", reaction_enabled_by_molecular_function),
+        ("uniprot", "rhea2uniprot", enabled_by),
     ]:
         xref_df = ensure_df(
             PREFIX,
@@ -104,26 +191,44 @@ def iter_terms(version: str, force: bool = False) -> Iterable[Term]:
             version=version,
             force=force,
         )
-        for rhea_id, _, _, xref_id in xref_df.values:
-            if rhea_id not in terms:
+        for directional_rhea_id, _direction, _master_rhea_id, xref_id in xref_df.values:
+            if directional_rhea_id not in terms:
                 logger.debug(
                     "[%s] could not find %s:%s for xref %s:%s",
                     PREFIX,
                     PREFIX,
-                    rhea_id,
+                    directional_rhea_id,
                     xref_prefix,
                     xref_id,
                 )
                 continue
-            terms[rhea_id].append_xref(Reference(prefix=xref_prefix, identifier=xref_id))
+            target_reference = Reference(prefix=xref_prefix, identifier=xref_id)
+            if isinstance(relation, TypeDef):
+                terms[directional_rhea_id].append_relationship(relation, target_reference)
+            else:
+                terms[directional_rhea_id].append_xref(target_reference)
 
-    # TODO are EC codes equivalent?
-    # TODO uniprot enabled by (RO:0002333)
-    # TODO names?
-    # TODO participants?
+    ec_df = ensure_df(
+        PREFIX,
+        url="ftp://ftp.expasy.org/databases/rhea/tsv/rhea-ec-iubmb.tsv",
+        version=version,
+        force=force,
+    )
+    for (
+        directional_rhea_id,
+        _status,
+        _direction,
+        _master_id,
+        ec,
+        _enzyme_status,
+        _iubmb,
+    ) in ec_df.values:
+        terms[directional_rhea_id].append_relationship(
+            enabled_by, Reference(prefix="eccode", identifier=ec)
+        )
 
     yield from terms.values()
 
 
 if __name__ == "__main__":
-    RheaGetter.cli()
+    RheaGetter().write_default(write_obo=True, force=True)

pyobo/sources/umls/umls.py

@@ -7,12 +7,13 @@ Run with ``python -m pyobo.sources.umls``
 
 import itertools as itt
 import operator
-from typing import Iterable
+from collections import defaultdict
+from typing import Iterable, Mapping, Set
 
 import bioregistry
 import pandas as pd
 from tqdm.auto import tqdm
-from umls_downloader import open_umls
+from umls_downloader import open_umls, open_umls_semantic_types
 
 from pyobo import Obo, Reference, Synonym, SynonymTypeDef, Term
 
@@ -66,8 +67,20 @@ def get_obo() -> Obo:
     return UMLSGetter()
 
 
+def get_semantic_types() -> Mapping[str, Set[str]]:
+    """Get UMLS semantic types for each term."""
+    dd = defaultdict(set)
+    with open_umls_semantic_types() as file:
+        for line in tqdm(file, unit_scale=True):
+            cui, sty, _ = line.decode("utf8").split("|", 2)
+            dd[cui].add(sty)
+    return dict(dd)
+
+
 def iter_terms(version: str) -> Iterable[Term]:
     """Iterate over UMLS terms."""
+    semantic_types = get_semantic_types()
+
     with open_umls(version=version) as file:
         it = tqdm(file, unit_scale=True, desc="[umls] parsing")
         lines = (line.decode("utf-8").strip().split("|") for line in it)
@@ -118,6 +131,8 @@ def iter_terms(version: str) -> Iterable[Term]:
                 synonyms=synonyms,
                 xrefs=xrefs,
             )
+            for sty_id in semantic_types.get(cui, set()):
+                term.append_parent(Reference(prefix="sty", identifier=sty_id))
             yield term
 
 

pyobo/sources/uniprot/uniprot.py

@@ -2,8 +2,9 @@
 
 """Converter for UniProt."""
 
+from operator import attrgetter
 from pathlib import Path
-from typing import Iterable, Optional
+from typing import Iterable, List, Optional, cast
 
 import bioversions
 from tqdm.auto import tqdm
@@ -11,22 +12,52 @@ from tqdm.auto import tqdm
 from pyobo import Obo, Reference
 from pyobo.constants import RAW_MODULE
 from pyobo.identifier_utils import standardize_ec
-from pyobo.struct import Term, enables, from_species
+from pyobo.struct import Term, derives_from, enables, from_species, participates_in
+from pyobo.struct.typedef import gene_product_of, located_in, molecularly_interacts_with
 from pyobo.utils.io import open_reader
 
 PREFIX = "uniprot"
-REVIEWED_URL = (
-    "https://rest.uniprot.org/uniprotkb/stream?compressed=true"
-    "&fields=accession%2Cid%2Corganism_id%2Cprotein_name%2Cec%2Clit_pubmed_id%2Cxref_pdb"
-    "&format=tsv&query=%28%2A%29%20AND%20%28reviewed%3Atrue%29"
-)
+BASE_URL = "https://rest.uniprot.org/uniprotkb/stream"
+SEARCH_URL = "https://rest.uniprot.org/uniprotkb/search"
+QUERY = "(*) AND (reviewed:true)"
+FIELDS = [
+    "accession",
+    "id",
+    "organism_id",
+    "protein_name",
+    "ec",
+    "lit_pubmed_id",
+    "xref_pdb",
+    "xref_proteomes",
+    "xref_geneid",
+    "rhea",
+    "go_c",
+    "go_f",
+    "go_p",
+    "ft_binding",
+    "cc_function",
+]
+PARAMS = {
+    "compressed": "true",
+    "format": "tsv",
+    # "size": 10,  # only used with search
+    "query": QUERY,
+    "fields": FIELDS,
+}
 
 
 class UniProtGetter(Obo):
     """An ontology representation of the UniProt database."""
 
     bioversions_key = ontology = PREFIX
-    typedefs = [from_species, enables]
+    typedefs = [
+        from_species,
+        enables,
+        participates_in,
+        gene_product_of,
+        molecularly_interacts_with,
+        derives_from,
+    ]
 
     def iter_terms(self, force: bool = False) -> Iterable[Term]:
         """Iterate over terms in the ontology."""
@@ -42,13 +73,73 @@ def iter_terms(version: Optional[str] = None) -> Iterable[Term]:
     """Iterate over UniProt Terms."""
     with open_reader(ensure(version=version)) as reader:
         _ = next(reader)  # header
-        for uniprot_id, name, taxonomy_id, _synonyms, ecs, pubmeds, pdbs in tqdm(
-            reader, desc="Mapping UniProt", unit_scale=True
-        ):
-            term = Term.from_triple(prefix=PREFIX, identifier=uniprot_id, name=name)
-            # TODO add gene encodes from relationship
-            # TODO add description
+        for (
+            uniprot_id,
+            accession,
+            taxonomy_id,
+            _name,  # this field should have the name, but it's a mismatch of random name annotations
+            ecs,
+            pubmeds,
+            pdbs,
+            proteome,
+            gene_id,
+            rhea_curies,
+            go_components,
+            go_functions,
+            go_processes,
+            bindings,
+            description,
+        ) in tqdm(reader, desc="Mapping UniProt", unit_scale=True):
+            if description:
+                description = description.removeprefix("FUNCTION: ")
+            term = Term(
+                reference=Reference(prefix=PREFIX, identifier=uniprot_id, name=accession),
+                definition=description or None,
+            )
             term.set_species(taxonomy_id)
+            if gene_id:
+                term.append_relationship(
+                    gene_product_of, Reference(prefix="ncbigene", identifier=gene_id)
+                )
+
+            # TODO add type=Reference(prefix="xsd", identifier="boolean")
+            term.append_property("reviewed", "true")
+
+            for go_process_ref in _parse_go(go_processes):
+                term.append_relationship(participates_in, go_process_ref)
+            for go_function_ref in _parse_go(go_functions):
+                term.append_relationship(enables, go_function_ref)
+            for go_component_ref in _parse_go(go_components):
+                term.append_relationship(located_in, go_component_ref)
+
+            if proteome:
+                uniprot_proteome_id = proteome.split(":")[0]
+                term.append_relationship(
+                    derives_from,
+                    Reference(prefix="uniprot.proteome", identifier=uniprot_proteome_id),
+                )
+
+            if rhea_curies:
+                for rhea_curie in rhea_curies.split(" "):
+                    term.append_relationship(
+                        # FIXME this needs a different relation than enables
+                        #  see https://github.com/biopragmatics/pyobo/pull/168#issuecomment-1918680152
+                        enables,
+                        cast(Reference, Reference.from_curie(rhea_curie, strict=True)),
+                    )
+
+            if bindings:
+                binding_references = set()
+                for part in bindings.split(";"):
+                    part = part.strip()
+                    if part.startswith("/ligand_id"):
+                        curie = part.removeprefix('/ligand_id="').rstrip('"')
+                        binding_references.add(
+                            cast(Reference, Reference.from_curie(curie, strict=True))
+                        )
+                for binding_reference in sorted(binding_references, key=attrgetter("curie")):
+                    term.append_relationship(molecularly_interacts_with, binding_reference)
+
             if ecs:
                 for ec in ecs.split(";"):
                     term.append_relationship(
@@ -63,11 +154,27 @@ def iter_terms(version: Optional[str] = None) -> Iterable[Term]:
             yield term
 
 
-def ensure(version: Optional[str] = None) -> Path:
+def _parse_go(go_terms) -> List[Reference]:
+    rv = []
+    if go_terms:
+        for go_term in go_terms.split(";"):
+            go_id = go_term.rsplit("[GO:")[1].rstrip("]")
+            rv.append(Reference(prefix="go", identifier=go_id))
+    return rv
+
+
+def ensure(version: Optional[str] = None, force: bool = False) -> Path:
     """Ensure the reviewed uniprot names are available."""
     if version is None:
         version = bioversions.get_version("uniprot")
-    return RAW_MODULE.ensure(PREFIX, version, name="reviewed.tsv.gz", url=REVIEWED_URL)
+    return RAW_MODULE.ensure(
+        PREFIX,
+        version,
+        force=force,
+        name="reviewed.tsv.gz",
+        url=BASE_URL,  # switch to SEARCH_URL for debugging
+        download_kwargs={"backend": "requests", "params": PARAMS},
+    )
 
 
 if __name__ == "__main__":

pyobo/struct/__init__.py

@@ -15,6 +15,7 @@ from .struct import (  # noqa: F401
 from .typedef import (  # noqa: F401
     RelationHint,
     TypeDef,
+    derives_from,
     enables,
     from_species,
     gene_product_member_of,

pyobo/struct/struct.py

@@ -53,6 +53,7 @@ from .typedef import (
     orthologous,
     part_of,
     see_also,
+    term_replaced_by,
 )
 from .utils import comma_separate, obo_escape_slim
 from ..constants import (
@@ -299,6 +300,11 @@ class Term(Referenced):
         self.append_property(comment.curie, value)
         return self
 
+    def append_replaced_by(self, reference: ReferenceHint) -> "Term":
+        """Add a replaced by relationship."""
+        self.append_relationship(term_replaced_by, reference)
+        return self
+
     def append_parent(self, reference: ReferenceHint) -> "Term":
         """Add a parent to this entity."""
         reference = _ensure_ref(reference)
@@ -395,14 +401,14 @@ class Term(Referenced):
 
     def iterate_relations(self) -> Iterable[Tuple[TypeDef, Reference]]:
         """Iterate over pairs of typedefs and targets."""
-        for typedef, targets in self.relationships.items():
-            for target in targets:
+        for typedef, targets in sorted(self.relationships.items(), key=_sort_relations):
+            for target in sorted(targets, key=lambda ref: ref.preferred_curie):
                 yield typedef, target
 
     def iterate_properties(self) -> Iterable[Tuple[str, str]]:
         """Iterate over pairs of property and values."""
-        for prop, values in self.properties.items():
-            for value in values:
+        for prop, values in sorted(self.properties.items()):
+            for value in sorted(values):
                 yield prop, value
 
     def iterate_obo_lines(self, *, ontology, typedefs) -> Iterable[str]:
@@ -466,7 +472,7 @@ _TYPEDEF_WARNINGS: Set[Tuple[str, str]] = set()
 
 def _sort_relations(r):
     typedef, _references = r
-    return typedef.reference.name or typedef.reference.identifier
+    return typedef.preferred_curie
 
 
 def _sort_properties(r):
@@ -1017,7 +1023,7 @@ class Obo:
     def iterate_id_name(self, *, use_tqdm: bool = False) -> Iterable[Tuple[str, str]]:
         """Iterate identifier name pairs."""
         for term in self._iter_terms(use_tqdm=use_tqdm, desc=f"[{self.ontology}] getting names"):
-            if term.name:
+            if term.prefix == self.ontology and term.name:
                 yield term.identifier, term.name
 
     def get_id_name_mapping(self, *, use_tqdm: bool = False) -> Mapping[str, str]:

pyobo/struct/typedef.py

@@ -48,6 +48,10 @@ __all__ = [
 ]
 
 
+def _bool_to_obo(v: bool) -> str:
+    return "true" if v else "false"
+
+
 @dataclass
 class TypeDef(Referenced):
     """A type definition in OBO.
@@ -88,7 +92,7 @@ class TypeDef(Referenced):
             yield f'def: "{self.definition}"'
 
         if self.is_metadata_tag is not None:
-            yield f'is_metadata_tag: {"true" if self.is_metadata_tag else "false"}'
+            yield f"is_metadata_tag: {_bool_to_obo(self.is_metadata_tag)}"
 
         if self.namespace:
             yield f"namespace: {self.namespace}"
@@ -113,6 +117,10 @@ class TypeDef(Referenced):
             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":
@@ -161,13 +169,19 @@ species_specific = TypeDef(
     "species with RO:0002162 (in taxon)",
 )
 has_left_to_right_reaction = TypeDef(
-    Reference(prefix="debio", identifier="0000007", name="has left-to-right reaction")
+    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")
+    Reference(prefix="debio", identifier="0000008", name="has right-to-left reaction"),
+    is_metadata_tag=True,
 )
 has_bidirectional_reaction = TypeDef(
-    Reference(prefix="debio", identifier="0000009", name="has bi-directional reaction")
+    Reference(prefix="debio", identifier="0000009", name="has bi-directional reaction"),
+    is_metadata_tag=True,
+)
+reaction_enabled_by_molecular_function = TypeDef(
+    Reference(prefix="debio", identifier="0000047", name="reaction enabled by molecular function")
 )
 
 
@@ -191,6 +205,15 @@ has_participant = TypeDef(
     comment="Inverse of has participant",
     inverse=Reference(prefix=RO_PREFIX, identifier="0000056", name="participates in"),
 )
+derives_from = TypeDef(
+    reference=Reference(prefix=RO_PREFIX, identifier="0001000", name="derives from"),
+)
+molecularly_interacts_with = TypeDef(
+    reference=Reference(prefix=RO_PREFIX, identifier="0002436", name="molecularly interacts with"),
+)
+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"),
 )
@@ -291,7 +314,14 @@ editor_note = TypeDef.from_triple(prefix=IAO_PREFIX, identifier="0000116", name=
 is_immediately_transformed_from = TypeDef.from_triple(
     prefix=SIO_PREFIX, identifier="000658", name="is immediately transformed from"
 )
-enables = TypeDef.from_triple(prefix="RO", identifier="0002327", name="enables")
+
+_enables_reference = Reference(prefix=RO_PREFIX, identifier="0002327", name="enables")
+_enabled_by_reference = Reference(prefix=RO_PREFIX, identifier="0002333", name="enabled by")
+enables = TypeDef(reference=_enables_reference, inverse=_enabled_by_reference)
+enabled_by = TypeDef(reference=_enabled_by_reference, inverse=_enables_reference)
+
+has_input = TypeDef.from_triple(prefix=RO_PREFIX, identifier="0002233", name="has input")
+has_output = TypeDef.from_triple(prefix=RO_PREFIX, identifier="0002234", name="has output")
 
 """ChEBI"""