pyobo 0.11.2__py3-none-any.whl → 0.12.1__py3-none-any.whl

pyobo/api/properties.py

@@ -1,140 +1,159 @@
 """High-level API for properties."""
 
 import logging
-import os
 from collections.abc import Mapping
-from typing import Optional
 
 import pandas as pd
-
-from .utils import get_version
+from tqdm import tqdm
+from typing_extensions import Unpack
+
+from .utils import get_version_from_kwargs
+from ..constants import (
+    GetOntologyKwargs,
+    check_should_cache,
+    check_should_force,
+    check_should_use_tqdm,
+)
 from ..getters import get_ontology
 from ..identifier_utils import wrap_norm_prefix
-from ..utils.cache import cached_df, cached_mapping, cached_multidict
+from ..struct import Reference
+from ..struct.struct_utils import OBOLiteral, ReferenceHint, _ensure_ref
+from ..utils.cache import cached_df
 from ..utils.io import multidict
-from ..utils.path import prefix_cache_join
+from ..utils.path import CacheArtifact, get_cache_path
 
 __all__ = [
-    "get_properties_df",
     "get_filtered_properties_df",
     "get_filtered_properties_mapping",
     "get_filtered_properties_multimapping",
-    "get_property",
+    "get_literal_properties",
+    "get_literal_properties_df",
+    "get_object_properties",
+    "get_object_properties_df",
     "get_properties",
+    "get_properties_df",
+    "get_property",
 ]
 
 logger = logging.getLogger(__name__)
 
 
+def get_object_properties_df(prefix, **kwargs: Unpack[GetOntologyKwargs]) -> pd.DataFrame:
+    """Get a dataframe of object property triples."""
+    version = get_version_from_kwargs(prefix, kwargs)
+    path = get_cache_path(prefix, CacheArtifact.object_properties, version=version)
+
+    @cached_df(
+        path=path, dtype=str, force=check_should_force(kwargs), cache=check_should_cache(kwargs)
+    )
+    def _df_getter() -> pd.DataFrame:
+        return get_ontology(prefix, **kwargs).get_object_properties_df(
+            use_tqdm=check_should_use_tqdm(kwargs)
+        )
+
+    return _df_getter()
+
+
+def get_object_properties(
+    prefix, **kwargs: Unpack[GetOntologyKwargs]
+) -> list[tuple[Reference, Reference, Reference]]:
+    """Get a list of object property triples."""
+    df = get_object_properties_df(prefix, **kwargs)
+    return [
+        (Reference.from_curie(s), Reference.from_curie(p), Reference.from_curie(o))
+        for s, p, o in df.values
+    ]
+
+
+def get_literal_properties(
+    prefix: str, **kwargs: Unpack[GetOntologyKwargs]
+) -> list[tuple[Reference, Reference, OBOLiteral]]:
+    """Get a list of literal property triples."""
+    df = get_literal_properties_df(prefix, **kwargs)
+    return [
+        (
+            Reference.from_curie(s),
+            Reference.from_curie(p),
+            OBOLiteral(
+                value,
+                Reference.from_curie(datatype),
+                language if language and pd.notna(language) else None,
+            ),
+        )
+        for s, p, value, datatype, language in tqdm(
+            df.values,
+            desc=f"[{prefix}] parsing properties",
+            unit_scale=True,
+            unit="triple",
+            disable=not check_should_use_tqdm(kwargs),
+        )
+    ]
+
+
+def get_literal_properties_df(prefix: str, **kwargs: Unpack[GetOntologyKwargs]) -> pd.DataFrame:
+    """Get a dataframe of literal property quads."""
+    version = get_version_from_kwargs(prefix, kwargs)
+    path = get_cache_path(prefix, CacheArtifact.literal_properties, version=version)
+
+    @cached_df(
+        path=path, dtype=str, force=check_should_force(kwargs), cache=check_should_cache(kwargs)
+    )
+    def _df_getter() -> pd.DataFrame:
+        return get_ontology(prefix, **kwargs).get_literal_properties_df(
+            use_tqdm=check_should_use_tqdm(kwargs)
+        )
+
+    return _df_getter()
+
+
 @wrap_norm_prefix
-def get_properties_df(
-    prefix: str, *, force: bool = False, version: Optional[str] = None
-) -> pd.DataFrame:
+def get_properties_df(prefix: str, **kwargs: Unpack[GetOntologyKwargs]) -> pd.DataFrame:
     """Extract properties.
 
     :param prefix: the resource to load
-    :param force: should the resource be re-downloaded, re-parsed, and re-cached?
     :returns: A dataframe with the properties
     """
-    if version is None:
-        version = get_version(prefix)
-    path = prefix_cache_join(prefix, name="properties.tsv", version=version)
-
-    @cached_df(path=path, dtype=str, force=force)
-    def _df_getter() -> pd.DataFrame:
-        if force:
-            logger.info("[%s] forcing reload for properties", prefix)
-        else:
-            logger.info("[%s] no cached properties found. getting from OBO loader", prefix)
-        ontology = get_ontology(prefix, force=force, version=version)
-        df = ontology.get_properties_df()
-        df.dropna(inplace=True)
-        return df
-
-    return _df_getter()
+    df1 = get_literal_properties_df(prefix, **kwargs)
+    df2 = get_object_properties_df(prefix, **kwargs)
+    df = pd.concat([df1[["source", "predicate", "target"]], df2])
+    ll = len(prefix) + 1
+    df[f"{prefix}_id"] = df["source"].map(lambda x: x[ll:])
+    df = df.rename(columns={"predicate": "property", "target": "value"})
+    del df["source"]
+    return df[[f"{prefix}_id", "property", "value"]]
 
 
 @wrap_norm_prefix
 def get_filtered_properties_mapping(
-    prefix: str,
-    prop: str,
-    *,
-    use_tqdm: bool = False,
-    force: bool = False,
-    version: Optional[str] = None,
+    prefix: str, prop: ReferenceHint, **kwargs: Unpack[GetOntologyKwargs]
 ) -> Mapping[str, str]:
     """Extract a single property for each term as a dictionary.
 
     :param prefix: the resource to load
     :param prop: the property to extract
-    :param use_tqdm: should a progress bar be shown?
-    :param force: should the resource be re-downloaded, re-parsed, and re-cached?
     :returns: A mapping from identifier to property value
     """
-    df = get_properties_df(prefix=prefix, force=force, version=version)
-    df = df[df["property"] == prop]
-    return dict(df[[f"{prefix}_id", "value"]].values)
-
-    if version is None:
-        version = get_version(prefix)
-    path = prefix_cache_join(prefix, "properties", name=f"{prop}.tsv", version=version)
-    all_properties_path = prefix_cache_join(prefix, name="properties.tsv", version=version)
-
-    @cached_mapping(path=path, header=[f"{prefix}_id", prop], force=force)
-    def _mapping_getter() -> Mapping[str, str]:
-        if os.path.exists(all_properties_path):
-            logger.info("[%s] loading pre-cached properties", prefix)
-            df = pd.read_csv(all_properties_path, sep="\t")
-            logger.info("[%s] filtering pre-cached properties", prefix)
-            df = df.loc[df["property"] == prop, [f"{prefix}_id", "value"]]
-            return dict(df.values)
-
-        logger.info("[%s] no cached properties found. getting from OBO loader", prefix)
-        ontology = get_ontology(prefix, force=force, version=version)
-        return ontology.get_filtered_properties_mapping(prop, use_tqdm=use_tqdm)
-
-    return _mapping_getter()
+    df = get_filtered_properties_df(prefix, prop, **kwargs)
+    return dict(df.values)
 
 
 @wrap_norm_prefix
 def get_filtered_properties_multimapping(
-    prefix: str,
-    prop: str,
-    *,
-    use_tqdm: bool = False,
-    force: bool = False,
-    version: Optional[str] = None,
+    prefix: str, prop: ReferenceHint, **kwargs: Unpack[GetOntologyKwargs]
 ) -> Mapping[str, list[str]]:
     """Extract multiple properties for each term as a dictionary.
 
     :param prefix: the resource to load
     :param prop: the property to extract
-    :param use_tqdm: should a progress bar be shown?
-    :param force: should the resource be re-downloaded, re-parsed, and re-cached?
     :returns: A mapping from identifier to property values
     """
-    if version is None:
-        version = get_version(prefix)
-    path = prefix_cache_join(prefix, "properties", name=f"{prop}.tsv", version=version)
-    all_properties_path = prefix_cache_join(prefix, name="properties.tsv", version=version)
+    df = get_filtered_properties_df(prefix, prop, **kwargs)
+    return multidict(df.values)
 
-    @cached_multidict(path=path, header=[f"{prefix}_id", prop], force=force)
-    def _mapping_getter() -> Mapping[str, list[str]]:
-        if os.path.exists(all_properties_path):
-            logger.info("[%s] loading pre-cached properties", prefix)
-            df = pd.read_csv(all_properties_path, sep="\t")
-            logger.info("[%s] filtering pre-cached properties", prefix)
-            df = df.loc[df["property"] == prop, [f"{prefix}_id", "value"]]
-            return multidict(df.values)
 
-        logger.info("[%s] no cached properties found. getting from OBO loader", prefix)
-        ontology = get_ontology(prefix, force=force, version=version)
-        return ontology.get_filtered_properties_multimapping(prop, use_tqdm=use_tqdm)
-
-    return _mapping_getter()
-
-
-def get_property(prefix: str, identifier: str, prop: str, **kwargs) -> Optional[str]:
+def get_property(
+    prefix: str, identifier: str, prop: ReferenceHint, **kwargs: Unpack[GetOntologyKwargs]
+) -> str | None:
     """Extract a single property for the given entity.
 
     :param prefix: the resource to load
@@ -152,7 +171,12 @@ def get_property(prefix: str, identifier: str, prop: str, **kwargs) -> Optional[
     return filtered_properties_mapping.get(identifier)
 
 
-def get_properties(prefix: str, identifier: str, prop: str, **kwargs) -> Optional[list[str]]:
+def get_properties(
+    prefix: str,
+    identifier: str,
+    prop: ReferenceHint,
+    **kwargs: Unpack[GetOntologyKwargs],
+) -> list[str] | None:
     """Extract a set of properties for the given entity.
 
     :param prefix: the resource to load
@@ -168,39 +192,15 @@ def get_properties(prefix: str, identifier: str, prop: str, **kwargs) -> Optiona
 
 @wrap_norm_prefix
 def get_filtered_properties_df(
-    prefix: str,
-    prop: str,
-    *,
-    use_tqdm: bool = False,
-    force: bool = False,
-    version: Optional[str] = None,
+    prefix: str, prop: ReferenceHint, **kwargs: Unpack[GetOntologyKwargs]
 ) -> pd.DataFrame:
     """Extract a single property for each term.
 
     :param prefix: the resource to load
     :param prop: the property to extract
-    :param use_tqdm: should a progress bar be shown?
-    :param force: should the resource be re-downloaded, re-parsed, and re-cached?
     :returns: A dataframe from identifier to property value. Columns are [<prefix>_id, value].
     """
-    if version is None:
-        version = get_version(prefix)
-    path = prefix_cache_join(prefix, "properties", name=f"{prop}.tsv", version=version)
-    all_properties_path = prefix_cache_join(prefix, name="properties.tsv", version=version)
-
-    @cached_df(path=path, dtype=str, force=force)
-    def _df_getter() -> pd.DataFrame:
-        if os.path.exists(all_properties_path):
-            logger.info("[%s] loading pre-cached properties", prefix)
-            df = pd.read_csv(all_properties_path, sep="\t")
-            logger.info("[%s] filtering pre-cached properties", prefix)
-            return df.loc[df["property"] == prop, [f"{prefix}_id", "value"]]
-
-        if force:
-            logger.info("[%s] forcing reload for properties", prefix)
-        else:
-            logger.info("[%s] no cached properties found. getting from OBO loader", prefix)
-        ontology = get_ontology(prefix, force=force, version=version)
-        return ontology.get_filtered_properties_df(prop, use_tqdm=use_tqdm)
-
-    return _df_getter()
+    prop = _ensure_ref(prop, ontology_prefix=prefix)
+    df = get_properties_df(prefix, **kwargs)
+    df = df.loc[df["property"] == prop.curie, [f"{prefix}_id", "value"]]
+    return df

pyobo/api/relations.py

@@ -1,15 +1,13 @@
 """High-level API for relations."""
 
 import logging
-import os
 from collections.abc import Mapping
 from functools import lru_cache
-from typing import Optional
 
-import networkx as nx
 import pandas as pd
+from typing_extensions import Unpack
 
-from .utils import get_version
+from .utils import get_version_from_kwargs
 from ..constants import (
     RELATION_COLUMNS,
     RELATION_ID,
@@ -18,50 +16,60 @@ from ..constants import (
     SOURCE_PREFIX,
     TARGET_ID,
     TARGET_PREFIX,
+    GetOntologyKwargs,
+    check_should_cache,
+    check_should_force,
+    check_should_use_tqdm,
 )
 from ..getters import get_ontology
 from ..identifier_utils import wrap_norm_prefix
-from ..struct import Reference, RelationHint, TypeDef, get_reference_tuple
+from ..struct.reference import Reference
+from ..struct.struct_utils import ReferenceHint, _ensure_ref
 from ..utils.cache import cached_df
-from ..utils.path import prefix_cache_join
+from ..utils.path import CacheArtifact, get_cache_path, get_relation_cache_path
 
 __all__ = [
-    "get_relations_df",
     "get_filtered_relations_df",
     "get_id_multirelations_mapping",
-    "get_relation_mapping",
     "get_relation",
-    "get_graph",
+    "get_relation_mapping",
+    "get_relations",
+    "get_relations_df",
 ]
 
-# TODO get_relation, get_relations
-
 logger = logging.getLogger(__name__)
 
 
+@wrap_norm_prefix
+def get_relations(
+    prefix: str, **kwargs: Unpack[GetOntologyKwargs]
+) -> list[tuple[Reference, Reference, Reference]]:
+    """Get relations."""
+    df = get_relations_df(prefix, wide=False, **kwargs)
+    return [
+        (
+            Reference(prefix=prefix, identifier=source_id),
+            Reference(prefix=relation_prefix, identifier=relation_id),
+            Reference(prefix=target_prefix, identifier=target_id),
+        )
+        for source_id, relation_prefix, relation_id, target_prefix, target_id in df.values
+    ]
+
+
 @wrap_norm_prefix
 def get_relations_df(
-    prefix: str,
-    *,
-    use_tqdm: bool = False,
-    force: bool = False,
-    wide: bool = False,
-    strict: bool = True,
-    version: Optional[str] = None,
+    prefix: str, *, wide: bool = False, **kwargs: Unpack[GetOntologyKwargs]
 ) -> pd.DataFrame:
     """Get all relations from the OBO."""
-    if version is None:
-        version = get_version(prefix)
-    path = prefix_cache_join(prefix, name="relations.tsv", version=version)
+    version = get_version_from_kwargs(prefix, kwargs)
+    path = get_cache_path(prefix, CacheArtifact.relations, version=version)
 
-    @cached_df(path=path, dtype=str, force=force)
+    @cached_df(
+        path=path, dtype=str, force=check_should_force(kwargs), cache=check_should_cache(kwargs)
+    )
     def _df_getter() -> pd.DataFrame:
-        if force:
-            logger.info("[%s] forcing reload for relations", prefix)
-        else:
-            logger.info("[%s] no cached relations found. getting from OBO loader", prefix)
-        ontology = get_ontology(prefix, force=force, version=version, strict=strict)
-        return ontology.get_relations_df(use_tqdm=use_tqdm)
+        ontology = get_ontology(prefix, **kwargs)
+        return ontology.get_relations_df(use_tqdm=check_should_use_tqdm(kwargs))
 
     rv = _df_getter()
 
@@ -76,38 +84,29 @@ def get_relations_df(
 @wrap_norm_prefix
 def get_filtered_relations_df(
     prefix: str,
-    relation: RelationHint,
-    *,
-    use_tqdm: bool = False,
-    force: bool = False,
-    version: Optional[str] = None,
+    relation: ReferenceHint,
+    **kwargs: Unpack[GetOntologyKwargs],
 ) -> pd.DataFrame:
     """Get all the given relation."""
-    relation_prefix, relation_identifier = relation = get_reference_tuple(relation)
-    if version is None:
-        version = get_version(prefix)
-    path = prefix_cache_join(
-        prefix,
-        "relations",
-        name=f"{relation_prefix}:{relation_identifier}.tsv",
-        version=version,
+    relation = _ensure_ref(relation, ontology_prefix=prefix)
+    version = get_version_from_kwargs(prefix, kwargs)
+    all_relations_path = get_cache_path(prefix, CacheArtifact.relations, version=version)
+    if all_relations_path.is_file():
+        logger.debug("[%] loading all relations from %s", prefix, all_relations_path)
+        df = pd.read_csv(all_relations_path, sep="\t", dtype=str)
+        idx = (df[RELATION_PREFIX] == relation.prefix) & (df[RELATION_ID] == relation.identifier)
+        columns = [f"{prefix}_id", TARGET_PREFIX, TARGET_ID]
+        return df.loc[idx, columns]
+
+    path = get_relation_cache_path(prefix, relation, version=version)
+
+    @cached_df(
+        path=path, dtype=str, force=check_should_force(kwargs), cache=check_should_cache(kwargs)
     )
-    all_relations_path = prefix_cache_join(prefix, name="relations.tsv", version=version)
-
-    @cached_df(path=path, dtype=str, force=force)
     def _df_getter() -> pd.DataFrame:
-        if os.path.exists(all_relations_path):
-            logger.debug("[%] loading all relations from %s", prefix, all_relations_path)
-            df = pd.read_csv(all_relations_path, sep="\t", dtype=str)
-            idx = (df[RELATION_PREFIX] == relation_prefix) & (
-                df[RELATION_ID] == relation_identifier
-            )
-            columns = [f"{prefix}_id", TARGET_PREFIX, TARGET_ID]
-            return df.loc[idx, columns]
-
         logger.info("[%s] no cached relations found. getting from OBO loader", prefix)
-        ontology = get_ontology(prefix, force=force, version=version)
-        return ontology.get_filtered_relations_df(relation, use_tqdm=use_tqdm)
+        ontology = get_ontology(prefix, **kwargs)
+        return ontology.get_filtered_relations_df(relation, use_tqdm=check_should_use_tqdm(kwargs))
 
     return _df_getter()
 
@@ -115,29 +114,24 @@ def get_filtered_relations_df(
 @wrap_norm_prefix
 def get_id_multirelations_mapping(
     prefix: str,
-    typedef: TypeDef,
-    *,
-    use_tqdm: bool = False,
-    force: bool = False,
-    version: Optional[str] = None,
+    typedef: ReferenceHint,
+    **kwargs: Unpack[GetOntologyKwargs],
 ) -> Mapping[str, list[Reference]]:
     """Get the OBO file and output a synonym dictionary."""
-    if version is None:
-        version = get_version(prefix)
-    ontology = get_ontology(prefix, force=force, version=version)
-    return ontology.get_id_multirelations_mapping(typedef=typedef, use_tqdm=use_tqdm)
+    kwargs["version"] = get_version_from_kwargs(prefix, kwargs)
+    ontology = get_ontology(prefix, **kwargs)
+    return ontology.get_id_multirelations_mapping(
+        typedef=typedef, use_tqdm=check_should_use_tqdm(kwargs)
+    )
 
 
 @lru_cache
 @wrap_norm_prefix
 def get_relation_mapping(
     prefix: str,
-    relation: RelationHint,
+    relation: ReferenceHint,
     target_prefix: str,
-    *,
-    use_tqdm: bool = False,
-    force: bool = False,
-    version: Optional[str] = None,
+    **kwargs: Unpack[GetOntologyKwargs],
 ) -> Mapping[str, str]:
     """Get relations from identifiers in the source prefix to target prefix with the given relation.
 
@@ -151,11 +145,9 @@ def get_relation_mapping(
     >>> hgnc_mgi_orthology_mapping = pyobo.get_relation_mapping("hgnc", "ro:HOM0000017", "mgi")
     >>> assert mouse_mapt_mgi_id == hgnc_mgi_orthology_mapping[human_mapt_hgnc_id]
     """
-    if version is None:
-        version = get_version(prefix)
-    ontology = get_ontology(prefix, force=force, version=version)
+    ontology = get_ontology(prefix, **kwargs)
     return ontology.get_relation_mapping(
-        relation=relation, target_prefix=target_prefix, use_tqdm=use_tqdm
+        relation=relation, target_prefix=target_prefix, use_tqdm=check_should_use_tqdm(kwargs)
     )
 
 
@@ -163,13 +155,10 @@ def get_relation_mapping(
 def get_relation(
     prefix: str,
     source_identifier: str,
-    relation: RelationHint,
+    relation: ReferenceHint,
     target_prefix: str,
-    *,
-    use_tqdm: bool = False,
-    force: bool = False,
-    **kwargs,
-) -> Optional[str]:
+    **kwargs: Unpack[GetOntologyKwargs],
+) -> str | None:
     """Get the target identifier corresponding to the given relationship from the source prefix/identifier pair.
 
     .. warning:: Assumes there's only one version of the property for each term.
@@ -187,21 +176,6 @@ def get_relation(
         prefix=prefix,
         relation=relation,
         target_prefix=target_prefix,
-        use_tqdm=use_tqdm,
-        force=force,
         **kwargs,
     )
     return relation_mapping.get(source_identifier)
-
-
-def get_graph(prefix: str, **kwargs) -> nx.DiGraph:
-    """Get the relation graph."""
-    rv = nx.MultiDiGraph()
-    df = get_relations_df(prefix=prefix, **kwargs)
-    for source_id, relation_prefix, relation_id, target_ns, target_id in df.values:
-        rv.add_edge(
-            f"{prefix}:{source_id}",
-            f"{target_ns}:{target_id}",
-            key=f"{relation_prefix}:{relation_id}",
-        )
-    return rv

pyobo/api/species.py

@@ -3,14 +3,17 @@
 import logging
 from collections.abc import Mapping
 from functools import lru_cache
-from typing import Optional
+
+import curies
+from typing_extensions import Unpack
 
 from .alts import get_primary_identifier
-from .utils import get_version
+from .utils import _get_pi, get_version_from_kwargs
+from ..constants import GetOntologyKwargs, check_should_force
 from ..getters import NoBuildError, get_ontology
 from ..identifier_utils import wrap_norm_prefix
 from ..utils.cache import cached_mapping
-from ..utils.path import prefix_cache_join
+from ..utils.path import CacheArtifact, get_cache_path
 
 __all__ = [
     "get_id_species_mapping",
@@ -20,34 +23,35 @@ __all__ = [
 logger = logging.getLogger(__name__)
 
 
-@wrap_norm_prefix
-def get_species(prefix: str, identifier: str, *, version: Optional[str] = None) -> Optional[str]:
+def get_species(
+    prefix: str | curies.Reference | curies.ReferenceTuple,
+    identifier: str | None = None,
+    /,
+    **kwargs: Unpack[GetOntologyKwargs],
+) -> str | None:
     """Get the species."""
-    if prefix == "uniprot":
+    t = _get_pi(prefix, identifier)
+
+    if t.prefix == "uniprot":
         raise NotImplementedError
 
     try:
-        id_species = get_id_species_mapping(prefix, version=version)
+        id_species = get_id_species_mapping(t.prefix, **kwargs)
     except NoBuildError:
-        logger.warning("unable to look up species for prefix %s", prefix)
+        logger.warning("unable to look up species for prefix %s", t.prefix)
         return None
 
     if not id_species:
-        logger.warning("no results produced for prefix %s", prefix)
+        logger.warning("no results produced for prefix %s", t.prefix)
         return None
 
-    primary_id = get_primary_identifier(prefix, identifier, version=version)
+    primary_id = get_primary_identifier(t, **kwargs)
     return id_species.get(primary_id)
 
 
 @lru_cache
 @wrap_norm_prefix
-def get_id_species_mapping(
-    prefix: str,
-    force: bool = False,
-    strict: bool = True,
-    version: Optional[str] = None,
-) -> Mapping[str, str]:
+def get_id_species_mapping(prefix: str, **kwargs: Unpack[GetOntologyKwargs]) -> Mapping[str, str]:
     """Get an identifier to species mapping."""
     if prefix == "ncbigene":
         from ..sources.ncbigene import get_ncbigene_id_to_species_mapping
@@ -57,14 +61,13 @@ def get_id_species_mapping(
         logger.info("[%s] done loading species mappings", prefix)
         return rv
 
-    if version is None:
-        version = get_version(prefix)
-    path = prefix_cache_join(prefix, name="species.tsv", version=version)
+    version = get_version_from_kwargs(prefix, kwargs)
+    path = get_cache_path(prefix, CacheArtifact.species, version=version)
 
-    @cached_mapping(path=path, header=[f"{prefix}_id", "species"], force=force)
+    @cached_mapping(path=path, header=[f"{prefix}_id", "species"], force=check_should_force(kwargs))
     def _get_id_species_mapping() -> Mapping[str, str]:
         logger.info("[%s] no cached species found. getting from OBO loader", prefix)
-        ontology = get_ontology(prefix, force=force, strict=strict, version=version)
+        ontology = get_ontology(prefix, **kwargs)
         logger.info("[%s] loading species mappings", prefix)
         return ontology.get_id_species_mapping()