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

pyobo/reader.py

@@ -15,20 +15,19 @@ from typing import Any
 import bioregistry
 import networkx as nx
 from curies import ReferenceTuple
+from curies.preprocessing import BlocklistError
 from curies.vocabulary import SynonymScope
 from more_itertools import pairwise
 from tqdm.auto import tqdm
 
 from .constants import DATE_FORMAT, PROVENANCE_PREFIXES
 from .identifier_utils import (
-    BlacklistedError,
     NotCURIEError,
     ParseError,
     UnparsableIRIError,
     _is_valid_identifier,
     _parse_str_or_curie_or_uri_helper,
-    remap_prefix,
-    str_is_blacklisted,
+    get_rules,
 )
 from .reader_utils import (
     _chomp_axioms,
@@ -53,6 +52,7 @@ from .struct.struct_utils import Annotation, Stanza
 from .struct.typedef import comment as has_comment
 from .struct.typedef import default_typedefs, has_ontology_root_term
 from .utils.cache import write_gzipped_graph
+from .utils.io import safe_open
 from .utils.misc import STATIC_VERSION_REWRITES, cleanup_version
 
 __all__ = [
@@ -76,13 +76,7 @@ def from_obo_path(
 ) -> Obo:
     """Get the OBO graph from a path."""
     path = Path(path).expanduser().resolve()
-    if path.suffix.endswith(".gz"):
-        import gzip
-
-        logger.info("[%s] parsing gzipped OBO with obonet from %s", prefix or "<unknown>", path)
-        with gzip.open(path, "rt") as file:
-            graph = _read_obo(file, prefix, ignore_obsolete=ignore_obsolete, use_tqdm=use_tqdm)
-    elif path.suffix.endswith(".zip"):
+    if path.suffix.endswith(".zip"):
         import io
         import zipfile
 
@@ -95,7 +89,7 @@ def from_obo_path(
                 )
     else:
         logger.info("[%s] parsing OBO with obonet from %s", prefix or "<unknown>", path)
-        with open(path) as file:
+        with safe_open(path, read=True) as file:
             graph = _read_obo(file, prefix, ignore_obsolete=ignore_obsolete, use_tqdm=use_tqdm)
 
     if prefix:
@@ -1262,7 +1256,7 @@ def _handle_prop(
         ):
             case Reference() as datatype_:
                 datatype = datatype_
-            case BlacklistedError():
+            case BlocklistError():
                 return None
             case ParseError() as exc:
                 if strict:
@@ -1304,7 +1298,7 @@ def _handle_prop(
         ):
             case Reference() as obj_reference:
                 return Annotation(prop_reference, obj_reference)
-            case BlacklistedError():
+            case BlocklistError():
                 return None
             case UnparsableIRIError():
                 return Annotation(prop_reference, OBOLiteral.uri(value))
@@ -1330,7 +1324,7 @@ def _handle_prop(
         ):
             case Reference() as obj_reference:
                 return Annotation(prop_reference, obj_reference)
-            case BlacklistedError():
+            case BlocklistError():
                 return None
             case ParseError():
                 if datatype:
@@ -1535,10 +1529,12 @@ def _parse_xref_line(
 ) -> tuple[Reference, list[Reference | OBOLiteral]] | None:
     xref, _, rest = line.partition(" [")
 
-    if str_is_blacklisted(xref, ontology_prefix=ontology_prefix) or ":" not in xref:
+    rules = get_rules()
+
+    if rules.str_is_blocked(xref, context=ontology_prefix) or ":" not in xref:
         return None  # sometimes xref to self... weird
 
-    xref = remap_prefix(xref, ontology_prefix=ontology_prefix)
+    xref = rules.remap_prefix(xref, context=ontology_prefix)
 
     split_space = " " in xref
     if split_space:
@@ -1552,7 +1548,7 @@ def _parse_xref_line(
         xref, ontology_prefix=ontology_prefix, node=node, line=line, context="xref", upgrade=upgrade
     )
     match xref_ref:
-        case BlacklistedError():
+        case BlocklistError():
             return None
         case ParseError() as exc:
             if strict:

pyobo/sources/cgnc.py

@@ -45,7 +45,15 @@ HEADER = [
 
 def get_terms(force: bool = False) -> Iterable[Term]:
     """Get CGNC terms."""
-    df = ensure_df(PREFIX, url=URL, name=f"{PREFIX}.tsv", force=force, header=0, names=HEADER)
+    df = ensure_df(
+        PREFIX,
+        url=URL,
+        name=f"{PREFIX}.tsv",
+        force=force,
+        header=0,
+        names=HEADER,
+        on_bad_lines="skip",
+    )
     for i, (cgnc_id, entrez_id, ensembl_id, name, synonym_1, synoynm_2, _, _) in enumerate(
         df.values
     ):

pyobo/sources/credit.py

@@ -7,7 +7,7 @@ from collections.abc import Iterable
 
 from more_itertools import chunked
 
-from pyobo.struct import Obo, Term
+from pyobo.struct import CHARLIE_TERM, HUMAN_TERM, Obo, Reference, Term, default_reference
 from pyobo.utils.path import ensure_path
 
 __all__ = [
@@ -16,6 +16,12 @@ __all__ = [
 
 url = "https://api.github.com/repos/CASRAI-CRedIT/Dictionary/contents/Picklists/Contributor%20Roles"
 PREFIX = "credit"
+ROOT = default_reference(prefix=PREFIX, identifier="contributor-role", name="contributor role")
+ROOT_TERM = (
+    Term(reference=ROOT)
+    .append_contributor(CHARLIE_TERM)
+    .append_xref(Reference(prefix="cro", identifier="0000000"))
+)
 
 
 class CreditGetter(Obo):
@@ -23,6 +29,7 @@ class CreditGetter(Obo):
 
     ontology = PREFIX
     static_version = "2022"
+    root_terms = [ROOT]
 
     def iter_terms(self, force: bool = False) -> Iterable[Term]:
         """Iterate over terms in the ontology."""
@@ -34,14 +41,16 @@ def get_terms(force: bool = False) -> list[Term]:
     path = ensure_path(PREFIX, url=url, name="picklist-api.json", force=force)
     with open(path) as f:
         data = json.load(f)
-    terms = []
+    terms = [
+        CHARLIE_TERM,
+        HUMAN_TERM,
+        ROOT_TERM,
+    ]
     for x in data:
-        name = x["name"].removesuffix(".md").lower()
-
         pp = ensure_path(PREFIX, "picklist", url=x["download_url"], backend="requests")
         with open(pp) as f:
             header, *rest = f.read().splitlines()
-            name = header = header.removeprefix("# Contributor Roles/")
+            name = header.removeprefix("# Contributor Roles/")
             dd = {k.removeprefix("## "): v for k, v in chunked(rest, 2)}
             identifier = (
                 dd["Canonical URL"]
@@ -50,7 +59,9 @@ def get_terms(force: bool = False) -> list[Term]:
             )
             desc = dd["Short definition"]
             terms.append(
-                Term.from_triple(prefix=PREFIX, identifier=identifier, name=name, definition=desc)
+                Term.from_triple(
+                    prefix=PREFIX, identifier=identifier, name=name, definition=desc
+                ).append_parent(ROOT)
             )
 
     return terms

pyobo/sources/flybase.py

@@ -18,7 +18,7 @@ __all__ = [
 
 logger = logging.getLogger(__name__)
 
-BASE_URL = "http://ftp.flybase.net/releases"
+BASE_URL = "https://s3ftp.flybase.org/releases"
 PREFIX = "flybase"
 NAME = "FlyBase"
 
@@ -51,7 +51,7 @@ def _get_names(version: str, force: bool = False) -> pd.DataFrame:
 
 def _get_organisms(version: str, force: bool = False) -> Mapping[str, str]:
     """Get mapping from abbreviation column to NCBI taxonomy ID column."""
-    url = f"http://ftp.flybase.net/releases/FB{version}/precomputed_files/species/organism_list_fb_{version}.tsv.gz"
+    url = f"{BASE_URL}/FB{version}/precomputed_files/species/organism_list_fb_{version}.tsv.gz"
     df = ensure_df(
         PREFIX, url=url, force=force, version=version, skiprows=4, header=None, usecols=[2, 4]
     )
@@ -60,7 +60,7 @@ def _get_organisms(version: str, force: bool = False) -> Mapping[str, str]:
 
 
 def _get_definitions(version: str, force: bool = False) -> Mapping[str, str]:
-    url = f"http://ftp.flybase.net/releases/FB{version}/precomputed_files/genes/automated_gene_summaries.tsv.gz"
+    url = f"{BASE_URL}/FB{version}/precomputed_files/genes/automated_gene_summaries.tsv.gz"
     df = ensure_df(
         PREFIX, url=url, force=force, version=version, skiprows=2, header=None, usecols=[0, 1]
     )
@@ -69,7 +69,7 @@ def _get_definitions(version: str, force: bool = False) -> Mapping[str, str]:
 
 def _get_human_orthologs(version: str, force: bool = False) -> Mapping[str, set[str]]:
     url = (
-        f"http://ftp.flybase.net/releases/FB{version}/precomputed_files/"
+        f"{BASE_URL}/FB{version}/precomputed_files/"
         f"orthologs/dmel_human_orthologs_disease_fb_{version}.tsv.gz"
     )
     df = ensure_df(
@@ -86,7 +86,7 @@ def _get_human_orthologs(version: str, force: bool = False) -> Mapping[str, set[
 
 
 def _get_synonyms(version, force):
-    url = f"http://ftp.flybase.net/releases/FB{version}/precomputed_files/synonyms/fb_synonym_fb_{version}.tsv.gz"
+    url = f"{BASE_URL}/FB{version}/precomputed_files/synonyms/fb_synonym_fb_{version}.tsv.gz"
     df = ensure_df(PREFIX, url=url, force=force, version=version, skiprows=4, usecols=[0, 2])
     return df  # TODO use this
 

pyobo/sources/omim_ps.py

@@ -13,7 +13,7 @@ __all__ = [
 
 logger = logging.getLogger(__name__)
 PREFIX = "omim.ps"
-URL = "https://omim.org/phenotypicSeriesTitles/all"
+URL = "https://omim.org/phenotypicSeriesTitles/"
 
 
 class OMIMPSGetter(Obo):
@@ -26,13 +26,13 @@ class OMIMPSGetter(Obo):
         soup = get_soup(URL, user_agent="Mozilla/5.0")
         content = soup.find(id="mimContent")
         if content is None:
-            raise ValueError
+            raise ValueError("omim.ps failed - scraper could not find id='mimContent' in HTML")
         table = content.find("table")  # type:ignore[attr-defined]
         if table is None:
-            raise ValueError
+            raise ValueError("omim.ps failed - scraper could not find table in HTML")
         tbody = table.find("tbody")
         if tbody is None:
-            raise ValueError
+            raise ValueError("omim.ps failed - scraper could not find table body in HTML")
         for row in tbody.find_all("tr"):
             anchor = row.find("td").find("a")
             name = anchor.text.strip()

pyobo/sources/pharmgkb/pharmgkb_gene.py

@@ -105,4 +105,4 @@ def iter_terms(force: bool = False) -> Iterable[Term]:
 
 
 if __name__ == "__main__":
-    PharmGKBGeneGetter().write_default(force=True, write_obo=True, use_tqdm=True)
+    PharmGKBGeneGetter.cli()

pyobo/struct/functional/ontology.py

@@ -16,6 +16,7 @@ from pyobo.struct.functional.utils import (
     FunctionalOWLSerializable,
     list_to_funowl,
 )
+from pyobo.utils.io import safe_open
 
 __all__ = [
     "Document",
@@ -109,7 +110,8 @@ class Document:
     def write_funowl(self, path: str | Path) -> None:
         """Write functional OWL to a file.."""
         path = Path(path).expanduser().resolve()
-        path.write_text(self.to_funowl())
+        with safe_open(path, read=False) as file:
+            file.write(self.to_funowl())
 
     def to_funowl(self) -> str:
         """Get the document as a functional OWL string."""

pyobo/struct/reference.py

@@ -14,9 +14,9 @@ import dateutil.parser
 import pytz
 from bioregistry import NormalizedNamableReference as Reference
 from curies import ReferenceTuple
+from curies.preprocessing import BlocklistError
 
 from ..identifier_utils import (
-    BlacklistedError,
     NotCURIEError,
     ParseError,
     UnparsableIRIError,
@@ -62,7 +62,7 @@ def _parse_str_or_curie_or_uri(
     match reference:
         case Reference():
             return reference
-        case BlacklistedError():
+        case BlocklistError():
             return None
         case ParseError():
             if strict:
@@ -224,7 +224,7 @@ def _obo_parse_identifier(
     ):
         case Reference() as reference:
             return reference
-        case BlacklistedError():
+        case BlocklistError():
             return None
         case NotCURIEError() as exc:
             # this means there's no colon `:`
@@ -272,7 +272,7 @@ def _parse_reference_or_uri_literal(
     ):
         case Reference() as reference:
             return reference
-        case BlacklistedError():
+        case BlocklistError():
             return None
         case UnparsableIRIError():
             # this means that it's defininitely a URI,

pyobo/struct/struct.py

@@ -70,7 +70,7 @@ from ..constants import (
     TARGET_PREFIX,
 )
 from ..utils.cache import write_gzipped_graph
-from ..utils.io import multidict, write_iterable_tsv
+from ..utils.io import multidict, safe_open, write_iterable_tsv
 from ..utils.path import (
     CacheArtifact,
     get_cache_path,
@@ -712,6 +712,13 @@ class Obo:
             raise ValueError(f"There is no version available for {self.ontology}")
         return self.data_version
 
+    @property
+    def _prefix_version(self) -> str:
+        """Get the prefix and version (for logging)."""
+        if self.data_version:
+            return f"{self.ontology} {self.data_version}"
+        return self.ontology
+
     def iter_terms(self, force: bool = False) -> Iterable[Term]:
         """Iterate over terms in this ontology."""
         raise NotImplementedError
@@ -722,10 +729,11 @@ class Obo:
 
         return graph_from_obo(self)
 
-    def write_obograph(self, path: Path) -> None:
+    def write_obograph(self, path: str | Path) -> None:
         """Write OBO Graph json."""
         graph = self.get_graph()
-        path.write_text(graph.model_dump_json(indent=2, exclude_none=True, exclude_unset=True))
+        with safe_open(path, read=False) as file:
+            file.write(graph.model_dump_json(indent=2, exclude_none=True, exclude_unset=True))
 
     @classmethod
     def cli(cls, *args, default_rewrite: bool = False) -> Any:
@@ -761,13 +769,12 @@ class Obo:
                 click.secho(f"[{cls.ontology}] Got an exception during instantiation - {type(e)}")
                 sys.exit(1)
             inst.write_default(
-                write_obograph=True,
-                write_obo=True,
+                write_obograph=False,
+                write_obo=False,
                 write_owl=owl,
                 write_ofn=ofn,
                 write_ttl=ttl,
                 write_nodes=True,
-                write_edges=True,
                 force=force or rewrite,
                 use_tqdm=True,
             )
@@ -969,9 +976,14 @@ class Obo:
             emit_annotation_properties=emit_annotation_properties,
         )
         if use_tqdm:
-            it = tqdm(it, desc=f"[{self.ontology}] writing OBO", unit_scale=True, unit="line")
+            it = tqdm(
+                it,
+                desc=f"[{self._prefix_version}] writing OBO",
+                unit_scale=True,
+                unit="line",
+            )
         if isinstance(file, str | Path | os.PathLike):
-            with open(file, "w") as fh:
+            with safe_open(file, read=False) as fh:
                 self._write_lines(it, fh)
         else:
             self._write_lines(it, file)
@@ -1002,11 +1014,72 @@ class Obo:
 
     def write_nodes(self, path: str | Path) -> None:
         """Write a nodes TSV file."""
-        # TODO reimplement internally
-        self.get_graph().get_nodes_df().to_csv(path, sep="\t", index=False)
+        write_iterable_tsv(
+            path=path,
+            header=self.nodes_header,
+            it=self.iterate_edge_rows(),
+        )
+
+    @property
+    def nodes_header(self) -> Sequence[str]:
+        """Get the header for nodes."""
+        return [
+            "curie:ID",
+            "name:string",
+            "synonyms:string[]",
+            "synonym_predicates:string[]",
+            "synonym_types:string[]",
+            "definition:string",
+            "deprecated:boolean",
+            "type:string",
+            "provenance:string[]",
+            "alts:string[]",
+            "replaced_by:string[]",
+            "mapping_objects:string[]",
+            "mapping_predicates:string[]",
+            "version:string",
+        ]
+
+    def _get_node_row(self, node: Term, sep: str, version: str) -> Sequence[str]:
+        synonym_predicate_curies, synonym_type_curies, synonyms = [], [], []
+        for synonym in node.synonyms:
+            synonym_predicate_curies.append(synonym.predicate.curie)
+            synonym_type_curies.append(synonym.type.curie if synonym.type else "")
+            synonyms.append(synonym.name)
+        mapping_predicate_curies, mapping_target_curies = [], []
+        for predicate, obj in node.get_mappings(include_xrefs=True, add_context=False):
+            mapping_predicate_curies.append(predicate.curie)
+            mapping_target_curies.append(obj.curie)
+        return (
+            node.curie,
+            node.name or "",
+            sep.join(synonyms),
+            sep.join(synonym_predicate_curies),
+            sep.join(synonym_type_curies),
+            node.definition or "",
+            "true" if node.is_obsolete else "false",
+            node.type,
+            sep.join(
+                reference.curie for reference in node.provenance if isinstance(reference, Reference)
+            ),
+            sep.join(alt_reference.curie for alt_reference in node.alt_ids),
+            sep.join(ref.curie for ref in node.get_replaced_by()),
+            sep.join(mapping_target_curies),
+            sep.join(mapping_predicate_curies),
+            version,
+        )
+
+    def iterate_node_rows(self, sep: str = ";") -> Iterable[Sequence[str]]:
+        """Get a nodes iterator appropriate for serialization."""
+        version = self.data_version or ""
+        for node in self.iter_terms():
+            if node.prefix != self.ontology:
+                continue
+            yield self._get_node_row(node, sep=sep, version=version)
 
     def write_edges(self, path: str | Path) -> None:
         """Write a edges TSV file."""
+        # node, this is actually taken care of as part of the cache configuration
         write_iterable_tsv(
             path=path,
             header=self.edges_header,
@@ -1025,15 +1098,15 @@ class Obo:
 
     @property
     def _obo_path(self) -> Path:
-        return self._path(BUILD_SUBDIRECTORY_NAME, name=f"{self.ontology}.obo")
+        return self._path(BUILD_SUBDIRECTORY_NAME, name=f"{self.ontology}.obo.gz")
 
     @property
     def _obograph_path(self) -> Path:
-        return self._path(BUILD_SUBDIRECTORY_NAME, name=f"{self.ontology}.json")
+        return self._path(BUILD_SUBDIRECTORY_NAME, name=f"{self.ontology}.json.gz")
 
     @property
     def _owl_path(self) -> Path:
-        return self._path(BUILD_SUBDIRECTORY_NAME, name=f"{self.ontology}.owl")
+        return self._path(BUILD_SUBDIRECTORY_NAME, name=f"{self.ontology}.owl.gz")
 
     @property
     def _obonet_gz_path(self) -> Path:
@@ -1041,7 +1114,7 @@ class Obo:
 
     @property
     def _ofn_path(self) -> Path:
-        return self._path(BUILD_SUBDIRECTORY_NAME, name=f"{self.ontology}.ofn")
+        return self._path(BUILD_SUBDIRECTORY_NAME, name=f"{self.ontology}.ofn.gz")
 
     @property
     def _ttl_path(self) -> Path:
@@ -1060,22 +1133,10 @@ class Obo:
                 [f"{self.ontology}_id", "taxonomy_id"],
                 self.iterate_id_species,
             ),
-            (
-                # TODO deprecate this in favor of literal mappings output
-                CacheArtifact.synonyms,
-                [f"{self.ontology}_id", "synonym"],
-                self.iterate_synonym_rows,
-            ),
             (CacheArtifact.alts, [f"{self.ontology}_id", "alt_id"], self.iterate_alt_rows),
             (CacheArtifact.mappings, SSSOM_DF_COLUMNS, self.iterate_mapping_rows),
             (CacheArtifact.relations, self.relations_header, self.iter_relation_rows),
             (CacheArtifact.edges, self.edges_header, self.iterate_edge_rows),
-            (
-                # TODO deprecate this in favor of pair of literal and object properties
-                CacheArtifact.properties,
-                self.properties_header,
-                self._iter_property_rows,
-            ),
             (
                 CacheArtifact.object_properties,
                 self.object_properties_header,
@@ -1097,8 +1158,8 @@ class Obo:
         """Write the metadata JSON file."""
         metadata = self.get_metadata()
         for path in (self._root_metadata_path, self._get_cache_path(CacheArtifact.metadata)):
-            logger.debug("[%s v%s] caching metadata to %s", self.ontology, self.data_version, path)
-            with path.open("w") as file:
+            logger.debug("[%s] caching metadata to %s", self._prefix_version, path)
+            with safe_open(path, read=False) as file:
                 json.dump(metadata, file, indent=2)
 
     def write_prefix_map(self) -> None:
@@ -1110,9 +1171,8 @@ class Obo:
         """Write cache parts."""
         typedefs_path = self._get_cache_path(CacheArtifact.typedefs)
         logger.debug(
-            "[%s v%s] caching typedefs to %s",
-            self.ontology,
-            self.data_version,
+            "[%s] caching typedefs to %s",
+            self._prefix_version,
             typedefs_path,
         )
         typedef_df: pd.DataFrame = self.get_typedef_df()
@@ -1121,10 +1181,10 @@ class Obo:
 
         for cache_artifact, header, fn in self._get_cache_config():
             path = self._get_cache_path(cache_artifact)
-            if path.exists() and not force:
+            if path.is_file() and not force:
                 continue
             tqdm.write(
-                f"[{self.ontology} {self.data_version}] writing {cache_artifact.name} to {path}",
+                f"[{self._prefix_version}] writing {cache_artifact.name} to {path}",
             )
             write_iterable_tsv(
                 path=path,
@@ -1139,12 +1199,11 @@ class Obo:
             relations_path = get_relation_cache_path(
                 self.ontology, reference=relation, version=self.data_version
             )
-            if relations_path.exists() and not force:
+            if relations_path.is_file() and not force:
                 continue
             logger.debug(
-                "[%s v%s] caching relation %s ! %s",
-                self.ontology,
-                self.data_version,
+                "[%s] caching relation %s ! %s",
+                self._prefix_version,
                 relation.curie,
                 relation.name,
             )
@@ -1164,8 +1223,7 @@ class Obo:
         write_owl: bool = False,
         write_ofn: bool = False,
         write_ttl: bool = False,
-        write_nodes: bool = True,
-        write_edges: bool = True,
+        write_nodes: bool = False,
         obograph_use_internal: bool = False,
         write_cache: bool = True,
     ) -> None:
@@ -1174,15 +1232,15 @@ class Obo:
         self.write_prefix_map()
         if write_cache:
             self.write_cache(force=force)
-        if write_obo and (not self._obo_path.exists() or force):
-            tqdm.write(f"[{self.ontology}] writing OBO to {self._obo_path}")
+        if write_obo and (not self._obo_path.is_file() or force):
+            tqdm.write(f"[{self._prefix_version}] writing OBO to {self._obo_path}")
             self.write_obo(self._obo_path, use_tqdm=use_tqdm)
-        if (write_ofn or write_owl or write_obograph) and (not self._ofn_path.exists() or force):
-            tqdm.write(f"[{self.ontology}] writing OFN to {self._ofn_path}")
+        if (write_ofn or write_owl or write_obograph) and (not self._ofn_path.is_file() or force):
+            tqdm.write(f"[{self._prefix_version}] writing OFN to {self._ofn_path}")
             self.write_ofn(self._ofn_path)
-        if write_obograph and (not self._obograph_path.exists() or force):
+        if write_obograph and (not self._obograph_path.is_file() or force):
             if obograph_use_internal:
-                tqdm.write(f"[{self.ontology}] writing OBO Graph to {self._obograph_path}")
+                tqdm.write(f"[{self._prefix_version}] writing OBO Graph to {self._obograph_path}")
                 self.write_obograph(self._obograph_path)
             else:
                 import bioontologies.robot
@@ -1193,22 +1251,22 @@ class Obo:
                 bioontologies.robot.convert(
                     self._ofn_path, self._obograph_path, debug=True, merge=False, reason=False
                 )
-        if write_owl and (not self._owl_path.exists() or force):
-            tqdm.write(f"[{self.ontology}] writing OWL to {self._owl_path}")
+        if write_owl and (not self._owl_path.is_file() or force):
+            tqdm.write(f"[{self._prefix_version}] writing OWL to {self._owl_path}")
             import bioontologies.robot
 
             bioontologies.robot.convert(
                 self._ofn_path, self._owl_path, debug=True, merge=False, reason=False
             )
-        if write_ttl and (not self._ttl_path.exists() or force):
-            tqdm.write(f"[{self.ontology}] writing Turtle to {self._ttl_path}")
+        if write_ttl and (not self._ttl_path.is_file() or force):
+            tqdm.write(f"[{self._prefix_version}] writing Turtle to {self._ttl_path}")
             self.write_rdf(self._ttl_path)
-        if write_obonet and (not self._obonet_gz_path.exists() or force):
-            tqdm.write(f"[{self.ontology}] writing obonet to {self._obonet_gz_path}")
+        if write_obonet and (not self._obonet_gz_path.is_file() or force):
+            tqdm.write(f"[{self._prefix_version}] writing obonet to {self._obonet_gz_path}")
             self.write_obonet_gz(self._obonet_gz_path)
         if write_nodes:
             nodes_path = self._get_cache_path(CacheArtifact.nodes)
-            tqdm.write(f"[{self.ontology}] writing nodes TSV to {nodes_path}")
+            tqdm.write(f"[{self._prefix_version}] writing nodes TSV to {nodes_path}")
             self.write_nodes(nodes_path)
 
     @property
@@ -1335,9 +1393,8 @@ class Obo:
             rv.add_edge(_source, _target, key=_key)
 
         logger.info(
-            "[%s v%s] exported graph with %d nodes",
-            self.ontology,
-            self.data_version,
+            "[%s] exported graph with %d nodes",
+            self._prefix_version,
             rv.number_of_nodes(),
         )
         return rv

pyobo/utils/cache.py

@@ -1,6 +1,5 @@
 """Utilities for caching files."""
 
-import gzip
 import json
 import logging
 from collections.abc import Iterable, Mapping
@@ -14,7 +13,7 @@ from pystow.cache import CachedDataFrame as cached_df  # noqa:N813
 from pystow.cache import CachedJSON as cached_json  # noqa:N813
 from pystow.cache import CachedPickle as cached_pickle  # noqa:N813
 
-from .io import open_map_tsv, open_multimap_tsv, write_map_tsv, write_multimap_tsv
+from .io import open_map_tsv, open_multimap_tsv, safe_open, write_map_tsv, write_multimap_tsv
 
 __all__ = [
     "cached_collection",
@@ -70,13 +69,13 @@ NODE_LINK_STYLE = "links"  # TODO update to "edges"
 
 def get_gzipped_graph(path: str | Path) -> nx.MultiDiGraph:
     """Read a graph that's gzipped nodelink."""
-    with gzip.open(path, "rt") as file:
+    with safe_open(path, read=True) as file:
         return nx.node_link_graph(json.load(file), edges=NODE_LINK_STYLE)
 
 
 def write_gzipped_graph(graph: nx.MultiDiGraph, path: str | Path) -> None:
     """Write a graph as gzipped nodelink."""
-    with gzip.open(path, "wt") as file:
+    with safe_open(path, read=False) as file:
         json.dump(nx.node_link_data(graph, edges=NODE_LINK_STYLE), file)