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

pyobo/sources/spdx.py

@@ -0,0 +1,85 @@
+"""Convert SPDX to an ontology."""
+
+from collections.abc import Iterable
+from typing import Any
+
+from pydantic import ValidationError
+from tqdm import tqdm
+
+from pyobo.struct import Obo, Reference, Term, TypeDef
+from pyobo.struct.typedef import see_also
+from pyobo.struct.vocabulary import xsd_boolean
+from pyobo.utils.path import ensure_json
+
+__all__ = [
+    "SPDXLicenseGetter",
+]
+
+DATA_URL = "https://github.com/spdx/license-list-data/raw/refs/heads/main/json/licenses.json"
+LICENSE_PREFIX = "spdx"
+TERM_PREFIX = "spdx.term"
+
+ROOT = Term.from_triple(TERM_PREFIX, "ListedLicense", "listed license")
+IS_OSI = TypeDef(
+    reference=Reference(prefix=TERM_PREFIX, identifier="isOsiApproved", name="is OSI approved"),
+    is_metadata_tag=True,
+    domain=ROOT.reference,
+    range=xsd_boolean,
+)
+IS_FSF = TypeDef(
+    reference=Reference(prefix=TERM_PREFIX, identifier="isFsfLibre", name="is FSF Libre"),
+    is_metadata_tag=True,
+    domain=ROOT.reference,
+    range=xsd_boolean,
+)
+
+
+def get_terms(version: str) -> Iterable[Term]:
+    """Iterate over terms."""
+    yield ROOT
+    data = ensure_json(
+        LICENSE_PREFIX,
+        url=DATA_URL,
+        version=version,
+    )
+    for record in data["licenses"]:
+        if term := _get_term(record):
+            yield term
+
+
+def _get_term(record: dict[str, Any]) -> Term | None:
+    try:
+        reference = Reference(
+            prefix=LICENSE_PREFIX, identifier=record["licenseId"], name=record["name"]
+        )
+    except ValidationError:
+        tqdm.write(f"invalid: {record['licenseId']}")
+        return None
+    term = Term(
+        reference=reference,
+        is_obsolete=True if record.get("isDeprecatedLicenseId") else None,
+        # type="Instance",
+    ).append_parent(ROOT)
+    if record.get("isOsiApproved"):
+        term.annotate_boolean(IS_OSI, True)
+    if record.get("isFsfLibre"):
+        term.annotate_boolean(IS_FSF, True)
+    for uri in record.get("seeAlso", []):
+        term.annotate_uri(see_also, uri)
+    return term
+
+
+class SPDXLicenseGetter(Obo):
+    """An ontology representation of the SPDX Licenses."""
+
+    bioversions_key = ontology = LICENSE_PREFIX
+    typedefs = [see_also, IS_FSF, IS_OSI]
+    root_terms = [ROOT.reference]
+
+    def iter_terms(self, force: bool = False) -> Iterable[Term]:
+        """Iterate over terms in the ontology."""
+        return get_terms(version=self._version_or_raise)
+
+
+if __name__ == "__main__":
+    SPDXLicenseGetter.cli(["--obo", "--owl", "--rewrite"])

pyobo/sources/uniprot/uniprot.py

@@ -4,6 +4,7 @@ from collections.abc import Iterable
 from pathlib import Path
 from typing import cast
 
+from pystow.utils import safe_open_reader
 from tqdm.auto import tqdm
 
 from pyobo import Obo, Reference
@@ -22,7 +23,6 @@ from pyobo.struct import (
     participates_in,
 )
 from pyobo.struct.typedef import gene_product_of, located_in, molecularly_interacts_with
-from pyobo.utils.io import open_reader
 
 PREFIX = "uniprot"
 BASE_URL = "https://rest.uniprot.org/uniprotkb/stream"
@@ -78,7 +78,7 @@ class UniProtGetter(Obo):
 
 def iter_terms(version: str | None = None) -> Iterable[Term]:
     """Iterate over UniProt Terms."""
-    with open_reader(ensure(version=version)) as reader:
+    with safe_open_reader(ensure(version=version)) as reader:
         _ = next(reader)  # header
         for (
             uniprot_id,

pyobo/sources/wikipathways.py

@@ -3,13 +3,14 @@
 import logging
 from collections.abc import Iterable
 
-from pystow.utils import DownloadError
+import pystow
+from pystow.utils import DownloadError, read_zipfile_rdf
 from tqdm import tqdm
 
 from .gmt_utils import parse_wikipathways_gmt
 from ..constants import SPECIES_REMAPPING
 from ..struct import Obo, Reference, Term, from_species
-from ..struct.typedef import has_participant
+from ..struct.typedef import contributes_to_condition, has_depiction, has_participant, located_in
 from ..utils.path import ensure_path
 
 __all__ = [
@@ -20,6 +21,7 @@ logger = logging.getLogger(__name__)
 
 PREFIX = "wikipathways"
 
+ROOT = Reference(prefix="pw", identifier="0000001", name="pathway")
 _PATHWAY_INFO = [
     ("Anopheles_gambiae", "7165"),
     ("Arabidopsis_thaliana", "3702"),
@@ -46,17 +48,27 @@ class WikiPathwaysGetter(Obo):
     """An ontology representation of WikiPathways' pathway database."""
 
     ontology = bioversions_key = PREFIX
-    typedefs = [from_species, has_participant]
+    typedefs = [from_species, has_participant, contributes_to_condition, located_in, has_depiction]
+    root_terms = [ROOT]
 
     def iter_terms(self, force: bool = False) -> Iterable[Term]:
         """Iterate over terms in the ontology."""
-        return iter_terms(version=self._version_or_raise)
+        yield Term(reference=ROOT)
+        yield from iter_terms(version=self._version_or_raise)
 
 
-def iter_terms(version: str) -> Iterable[Term]:
+PW_PREFIX = "http://purl.obolibrary.org/obo/PW_"
+DOID_PREFIX = "http://purl.obolibrary.org/obo/DOID_"
+CL_PREFIX = "http://purl.obolibrary.org/obo/CL_"
+
+
+def iter_terms(version: str, *, include_descriptions: bool = False) -> Iterable[Term]:
     """Get WikiPathways terms."""
-    base_url = f"http://data.wikipathways.org/{version}/gmt/wikipathways-{version}-gmt"
+    archive_url = f"https://data.wikipathways.org/current/rdf/wikipathways-{version}-rdf-wp.zip"
+    archive = pystow.ensure(PREFIX, url=archive_url, version=version)
 
+    base_url = f"http://data.wikipathways.org/{version}/gmt/wikipathways-{version}-gmt"
+    pw_references = set()
     for species_code, taxonomy_id in tqdm(_PATHWAY_INFO, desc=f"[{PREFIX}]", unit="species"):
         url = f"{base_url}-{species_code}.gmt"
         try:
@@ -68,15 +80,88 @@ def iter_terms(version: str) -> Iterable[Term]:
         taxonomy_name = SPECIES_REMAPPING.get(species_code, species_code)
 
         for identifier, _version, _revision, name, _species, genes in parse_wikipathways_gmt(path):
-            term = Term(reference=Reference(prefix=PREFIX, identifier=identifier, name=name))
+            graph = read_zipfile_rdf(archive, inner_path=f"wp/{identifier}.ttl")
+            uri = f"https://identifiers.org/wikipathways/{identifier}"
+
+            definition: str | None = None
+            if include_descriptions:
+                # TODO deal with weird characters breaking OFN
+                description_results = list(
+                    graph.query(
+                        f"SELECT ?p WHERE {{ <{uri}> pav:hasVersion/dcterms:description ?p }} LIMIT 1"
+                    )
+                )
+                if description_results:
+                    definition = str(description_results[0][0])  # type:ignore[index]
+
+            term = Term(
+                reference=Reference(prefix=PREFIX, identifier=identifier, name=name),
+                definition=definition,
+            )
             term.set_species(taxonomy_id, taxonomy_name)
+            term.annotate_uri(
+                has_depiction,
+                f"https://www.wikipathways.org/wikipathways-assets/pathways/{identifier}/{identifier}.svg",
+            )
             for ncbigene_id in genes:
                 term.annotate_object(
                     has_participant,
                     Reference(prefix="ncbigene", identifier=ncbigene_id),
                 )
+            # TODO switch query over to including chemicals from RDF SPARQL query
+            # TODO get description from SPARQL
+            parents = [  # type:ignore[misc]
+                p
+                for (p,) in graph.query(
+                    f"SELECT ?p WHERE {{ <{uri}> pav:hasVersion/wp:pathwayOntologyTag ?p }}"
+                )
+            ]
+            for parent in parents:
+                if parent.startswith(PW_PREFIX):
+                    ref = Reference(prefix="pw", identifier=parent.removeprefix(PW_PREFIX))
+                    pw_references.add(ref)
+                    term.append_parent(ref)
+            if not parents:
+                tqdm.write(f"[{term.curie}] could not find parent")
+                term.append_parent(ROOT)
+
+            diseases = graph.query(
+                f"SELECT ?p WHERE {{ <{uri}> pav:hasVersion/wp:diseaseOntologyTag ?p }}"
+            )
+            for (disease,) in diseases:  # type:ignore[misc]
+                if disease.startswith(DOID_PREFIX):
+                    term.annotate_object(
+                        contributes_to_condition,
+                        Reference(prefix="doid", identifier=disease.removeprefix(DOID_PREFIX)),
+                    )
+
+            cells = graph.query(
+                f"SELECT ?p WHERE {{ <{uri}> pav:hasVersion/wp:cellTypeOntologyTag ?p }}"
+            )
+            for (cell,) in cells:  # type:ignore[misc]
+                if cell.startswith(CL_PREFIX):
+                    term.annotate_object(
+                        located_in,
+                        Reference(prefix="cl", identifier=cell.removeprefix(CL_PREFIX)),
+                    )
+
             yield term
 
+    from ..api import get_ancestors
+    from ..getters import get_ontology
+
+    for pw_reference in list(pw_references):
+        pw_references.update(get_ancestors(pw_reference) or set())
+
+    for pw_term in get_ontology("pw"):
+        if pw_term.reference in pw_references:
+            yield Term(
+                reference=pw_term.reference,
+                definition=pw_term.definition,
+                # PW has issues in hierarchy - there are lots of leaves with no root
+                parents=pw_term.parents or [ROOT],
+            )
+
 
 if __name__ == "__main__":
     WikiPathwaysGetter.cli()

pyobo/struct/__init__.py

@@ -16,6 +16,7 @@ from .struct import (
     SynonymTypeDef,
     Term,
     TypeDef,
+    build_ontology,
     make_ad_hoc_ontology,
 )
 from .struct_utils import Annotation, Stanza, StanzaType
@@ -57,6 +58,7 @@ __all__ = [
     "Term",
     "TypeDef",
     "_parse_str_or_curie_or_uri",
+    "build_ontology",
     "default_reference",
     "derives_from",
     "enables",

pyobo/struct/functional/dsl.py

@@ -211,7 +211,16 @@ class LiteralBox(Box):
 
     def to_funowl(self) -> str:
         """Represent this literal for functional OWL."""
-        return self.literal.n3(self._namespace_manager)
+        rv = self.literal.n3(self._namespace_manager)
+        # it appears that the OFN format doesn't use triple quotes
+        if rv.startswith('"""') and rv.endswith('"""^^xsd:string'):
+            # strip them off
+            rv = rv.removeprefix('"""').removesuffix('"""^^xsd:string')
+            # escape quotes
+            rv = rv.replace('"', '\\"')
+            # stick back quotes and xsd tag
+            rv = '"' + rv + '"^^xsd:string'
+        return rv
 
     def to_funowl_args(self) -> str:  # pragma: no cover
         """Get the inside of the functional OWL tag representing the literal (unused)."""

pyobo/struct/functional/ontology.py

@@ -8,6 +8,7 @@ from collections.abc import Sequence
 from pathlib import Path
 
 from curies import Converter
+from pystow.utils import safe_open
 from rdflib import OWL, RDF, Graph, term
 
 from pyobo.struct.functional.dsl import Annotation, Annotations, Axiom, Box
@@ -16,7 +17,6 @@ from pyobo.struct.functional.utils import (
     FunctionalOWLSerializable,
     list_to_funowl,
 )
-from pyobo.utils.io import safe_open
 
 __all__ = [
     "Document",
@@ -108,9 +108,9 @@ class Document:
         return graph
 
     def write_funowl(self, path: str | Path) -> None:
-        """Write functional OWL to a file.."""
+        """Write functional OWL to a file."""
         path = Path(path).expanduser().resolve()
-        with safe_open(path, read=False) as file:
+        with safe_open(path, operation="write") as file:
             file.write(self.to_funowl())
 
     def to_funowl(self) -> str:

pyobo/struct/obo/reader.py

@@ -18,6 +18,7 @@ from curies import ReferenceTuple
 from curies.preprocessing import BlocklistError
 from curies.vocabulary import SynonymScope
 from more_itertools import pairwise
+from pystow.utils import safe_open
 from tqdm.auto import tqdm
 
 from .reader_utils import (
@@ -52,8 +53,7 @@ from ...identifier_utils import (
     get_rules,
 )
 from ...utils.cache import write_gzipped_graph
-from ...utils.io import safe_open
-from ...utils.misc import STATIC_VERSION_REWRITES, cleanup_version
+from ...utils.misc import _prioritize_version
 
 __all__ = [
     "from_obo_path",
@@ -90,7 +90,7 @@ def from_obo_path(
                 )
     else:
         logger.info("[%s] parsing OBO with obonet from %s", prefix or "<unknown>", path)
-        with safe_open(path, read=True) as file:
+        with safe_open(path, operation="read") as file:
             graph = _read_obo(file, prefix, ignore_obsolete=ignore_obsolete, use_tqdm=use_tqdm)
 
     if prefix:
@@ -157,7 +157,7 @@ def from_obonet(
     upgrade: bool = True,
     use_tqdm: bool = False,
 ) -> Obo:
-    """Get all of the terms from a OBO graph."""
+    """Get all the terms from a OBO graph."""
     ontology_prefix_raw = graph.graph["ontology"]
     ontology_prefix = _normalize_prefix_strict(ontology_prefix_raw)
     logger.info("[%s] extracting OBO using obonet", ontology_prefix)
@@ -168,8 +168,11 @@ def from_obonet(
 
     macro_config = MacroConfig(graph.graph, strict=strict, ontology_prefix=ontology_prefix)
 
-    data_version = _clean_graph_version(
-        graph, ontology_prefix=ontology_prefix, version=version, date=date
+    data_version = _prioritize_version(
+        data_version=graph.graph.get("data-version") or None,
+        ontology_prefix=ontology_prefix,
+        version=version,
+        date=date,
     )
     if data_version and "/" in data_version:
         raise ValueError(
@@ -533,17 +536,22 @@ def _process_subsets(stanza: Stanza, data, *, ontology_prefix: str, strict: bool
         stanza.append_subset(reference)
 
 
+# needed to parse OPMI
+_BOOLEAN_TRUE_VALUES = {"true", "1", 1}
+_BOOLEAN_FALSE_VALUES = {"false", "0", 0}
+
+
 def _get_boolean(data: Mapping[str, Any], tag: str) -> bool | None:
     value = data.get(tag)
     if value is None:
         return None
     if isinstance(value, list):
         value = value[0]
-    if value == "false":
+    if value in _BOOLEAN_FALSE_VALUES:
         return False
-    if value == "true":
+    if value in _BOOLEAN_TRUE_VALUES:
         return True
-    raise ValueError(value)
+    raise ValueError(f"unhandled value for boolean: ({type(value)}) {value}")
 
 
 def _get_reference(
@@ -703,50 +711,6 @@ def _clean_graph_ontology(graph, prefix: str) -> None:
         graph.graph["ontology"] = prefix
 
 
-def _clean_graph_version(
-    graph, ontology_prefix: str, version: str | None, date: datetime | None
-) -> str | None:
-    if ontology_prefix in STATIC_VERSION_REWRITES:
-        return STATIC_VERSION_REWRITES[ontology_prefix]
-
-    data_version: str | None = graph.graph.get("data-version") or None
-    if version:
-        clean_injected_version = cleanup_version(version, prefix=ontology_prefix)
-        if not data_version:
-            logger.debug(
-                "[%s] did not have a version, overriding with %s",
-                ontology_prefix,
-                clean_injected_version,
-            )
-            return clean_injected_version
-
-        clean_data_version = cleanup_version(data_version, prefix=ontology_prefix)
-        if clean_data_version != clean_injected_version:
-            # in this case, we're going to trust the one that's passed
-            # through explicitly more than the graph's content
-            logger.debug(
-                "[%s] had version %s, overriding with %s", ontology_prefix, data_version, version
-            )
-        return clean_injected_version
-
-    if data_version:
-        clean_data_version = cleanup_version(data_version, prefix=ontology_prefix)
-        logger.debug("[%s] using version %s", ontology_prefix, clean_data_version)
-        return clean_data_version
-
-    if date is not None:
-        derived_date_version = date.strftime("%Y-%m-%d")
-        logger.debug(
-            "[%s] does not report a version. falling back to date: %s",
-            ontology_prefix,
-            derived_date_version,
-        )
-        return derived_date_version
-
-    logger.debug("[%s] does not report a version nor a date", ontology_prefix)
-    return None
-
-
 def _iter_obo_graph(
     graph: nx.MultiDiGraph,
     *,

pyobo/struct/obograph/export.py

@@ -8,11 +8,11 @@ import curies
 import obographs as og
 from curies import Converter, ReferenceTuple
 from curies import vocabulary as v
+from pystow.utils import safe_open
 
 from pyobo.identifier_utils.api import get_converter
 from pyobo.struct import Obo, OBOLiteral, Stanza, Term, TypeDef
 from pyobo.struct import typedef as tdv
-from pyobo.utils.io import safe_open
 
 __all__ = [
     "to_obograph",
@@ -25,7 +25,7 @@ def write_obograph(obo: Obo, path: str | Path, *, converter: Converter | None =
     """Write an ontology to a file as OBO Graph JSON."""
     path = Path(path).expanduser().resolve()
     raw_graph = to_obograph(obo, converter=converter)
-    with safe_open(path, read=False) as file:
+    with safe_open(path, operation="write") as file:
         file.write(raw_graph.model_dump_json(indent=2, exclude_none=True, exclude_unset=True))
 
 

pyobo/struct/struct.py

@@ -25,6 +25,7 @@ import ssslm
 from curies import Converter, ReferenceTuple
 from curies import vocabulary as _cv
 from more_click import force_option, verbose_option
+from pystow.utils import safe_open
 from tqdm.auto import tqdm
 from typing_extensions import Self
 
@@ -70,7 +71,7 @@ from ..constants import (
     TARGET_PREFIX,
 )
 from ..utils.cache import write_gzipped_graph
-from ..utils.io import multidict, safe_open, write_iterable_tsv
+from ..utils.io import multidict, write_iterable_tsv
 from ..utils.path import (
     CacheArtifact,
     get_cache_path,
@@ -87,6 +88,7 @@ __all__ = [
     "TypeDef",
     "abbreviation",
     "acronym",
+    "build_ontology",
     "make_ad_hoc_ontology",
 ]
 
@@ -746,13 +748,23 @@ class Obo:
             help="Re-process the data, but don't download it again.",
         )
         @click.option("--owl", is_flag=True, help="Write OWL via ROBOT")
+        @click.option("--obo", is_flag=True, help="Write OBO")
         @click.option("--ofn", is_flag=True, help="Write Functional OWL (OFN)")
         @click.option("--ttl", is_flag=True, help="Write turtle RDF via OFN")
+        @click.option("--cache/--no-cache", is_flag=True, help="Write the cache", default=True)
         @click.option(
             "--version", help="Specify data version to get. Use this if bioversions is acting up."
         )
-        def _main(force: bool, owl: bool, ofn: bool, ttl: bool, version: str | None, rewrite: bool):
-            rewrite = True
+        def _main(
+            force: bool,
+            obo: bool,
+            owl: bool,
+            ofn: bool,
+            ttl: bool,
+            version: str | None,
+            rewrite: bool,
+            cache: bool,
+        ) -> None:
             try:
                 inst = cls(force=force, data_version=version)
             except Exception as e:
@@ -760,13 +772,14 @@ class Obo:
                 sys.exit(1)
             inst.write_default(
                 write_obograph=False,
-                write_obo=False,
+                write_obo=obo,
                 write_owl=owl,
                 write_ofn=ofn,
                 write_ttl=ttl,
                 write_nodes=True,
                 force=force or rewrite,
                 use_tqdm=True,
+                write_cache=cache,
             )
 
         return _main
@@ -909,6 +922,8 @@ class Obo:
                     end = f'"{obo_escape_slim(value.value)}" {reference_escape(value.datatype, ontology_prefix=self.ontology)}'
                 case Reference():
                     end = reference_escape(value, ontology_prefix=self.ontology)
+                case _:
+                    raise TypeError(f"Invalid property value: {value}")
             yield f"property_value: {reference_escape(predicate, ontology_prefix=self.ontology)} {end}"
 
     def _iterate_property_pairs(self) -> Iterable[Annotation]:
@@ -925,10 +940,21 @@ class Obo:
                 license_literal = OBOLiteral.string(license_spdx_id)
             yield Annotation(v.has_license, license_literal)
 
-        # Description
         if description := bioregistry.get_description(self.ontology):
-            description = obo_escape_slim(description.strip())
             yield Annotation(v.has_description, OBOLiteral.string(description.strip()))
+        if homepage := bioregistry.get_homepage(self.ontology):
+            yield Annotation(v.has_homepage, OBOLiteral.uri(homepage))
+        if repository := bioregistry.get_repository(self.ontology):
+            yield Annotation(v.has_repository, OBOLiteral.uri(repository))
+        if logo := bioregistry.get_logo(self.ontology):
+            yield Annotation(v.has_logo, OBOLiteral.uri(logo))
+        if mailing_list := bioregistry.get_mailing_list(self.ontology):
+            yield Annotation(v.has_mailing_list, OBOLiteral.string(mailing_list))
+        if (maintainer := bioregistry.get_contact(self.ontology)) and maintainer.orcid:
+            yield Annotation(
+                v.has_maintainer,
+                Reference(prefix="orcid", identifier=maintainer.orcid, name=maintainer.name),
+            )
 
         # Root terms
         for root_term in self.root_terms or []:
@@ -973,7 +999,7 @@ class Obo:
                 unit="line",
             )
         if isinstance(file, str | Path | os.PathLike):
-            with safe_open(file, read=False) as fh:
+            with safe_open(file, operation="write") as fh:
                 self._write_lines(it, fh)
         else:
             self._write_lines(it, file)
@@ -1149,7 +1175,7 @@ class Obo:
         metadata = self.get_metadata()
         for path in (self._root_metadata_path, self._get_cache_path(CacheArtifact.metadata)):
             logger.debug("[%s] caching metadata to %s", self._prefix_version, path)
-            with safe_open(path, read=False) as file:
+            with safe_open(path, operation="write") as file:
                 json.dump(metadata, file, indent=2)
 
     def write_prefix_map(self) -> None:
@@ -2265,6 +2291,87 @@ class AdHocOntologyBase(Obo):
     """A base class for ad-hoc ontologies."""
 
 
+def build_ontology(
+    prefix: str,
+    *,
+    terms: list[Term] | None = None,
+    synonym_typedefs: list[SynonymTypeDef] | None = None,
+    typedefs: list[TypeDef] | None = None,
+    name: str | None = None,  # inferred
+    version: str | None = None,
+    idspaces: dict[str, str] | None = None,
+    root_terms: list[Reference] | None = None,
+    subsetdefs: list[tuple[Reference, str]] | None = None,
+    properties: list[Annotation] | None = None,
+    imports: list[str] | None = None,
+    description: str | None = None,
+    homepage: str | None = None,
+    mailing_list: str | None = None,
+    logo: str | None = None,
+    repository: str | None = None,
+) -> Obo:
+    """Build an ontology from parts."""
+    if name is None:
+        name = bioregistry.get_name(prefix)
+    # TODO auto-populate license and other properties
+
+    if properties is None:
+        properties = []
+    if typedefs is None:
+        typedefs = []
+
+    if description:
+        from .typedef import has_description
+
+        properties.append(Annotation.string(has_description.reference, description))
+        if has_description not in typedefs:
+            typedefs.append(has_description)  # TODO get proper typedef
+
+    if homepage:
+        from .typedef import has_homepage
+
+        properties.append(Annotation.uri(has_homepage.reference, homepage))
+        if has_homepage not in typedefs:
+            typedefs.append(has_homepage)
+
+    if logo:
+        from .typedef import has_depiction
+
+        properties.append(Annotation.uri(has_depiction.reference, logo))
+        if has_depiction not in typedefs:
+            typedefs.append(has_depiction)
+
+    if mailing_list:
+        from .typedef import has_mailing_list
+
+        properties.append(Annotation.string(has_mailing_list.reference, mailing_list))
+        if has_mailing_list not in typedefs:
+            typedefs.append(has_mailing_list)
+
+    if repository:
+        from .typedef import has_repository
+
+        properties.append(Annotation.uri(has_repository.reference, repository))
+        if has_repository not in typedefs:
+            typedefs.append(has_repository)
+
+    return make_ad_hoc_ontology(
+        _ontology=prefix,
+        _name=name,
+        # _auto_generated_by
+        _typedefs=typedefs,
+        _synonym_typedefs=synonym_typedefs,
+        # _date: datetime.datetime | None = None,
+        _data_version=version,
+        _idspaces=idspaces,
+        _root_terms=root_terms,
+        _subsetdefs=subsetdefs,
+        _property_values=properties,
+        _imports=imports,
+        terms=terms,
+    )
+
+
 def make_ad_hoc_ontology(
     _ontology: str,
     _name: str | None = None,

pyobo/struct/struct_utils.py

@@ -63,6 +63,16 @@ class Annotation(NamedTuple):
         """Return a literal property for a float."""
         return cls(predicate, OBOLiteral.float(value))
 
+    @classmethod
+    def uri(cls, predicate: Reference, uri: str) -> Self:
+        """Return a literal property for a URI."""
+        return cls(predicate, OBOLiteral.uri(uri))
+
+    @classmethod
+    def string(cls, predicate: Reference, value: str, *, language: str | None = None) -> Self:
+        """Return a literal property for a float."""
+        return cls(predicate, OBOLiteral.string(value, language=language))
+
     @staticmethod
     def _sort_key(x: Annotation):
         return x.predicate, _reference_or_literal_key(x.value)