napistu 0.4.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

napistu/constants.py

@@ -402,12 +402,14 @@ ONTOLOGIES = SimpleNamespace(
     ENSEMBL_PROTEIN_VERSION="ensembl_protein_version",
     GENE_NAME="gene_name",
     GO="go",
+    KEGG="kegg",
     MIRBASE="mirbase",
     NCBI_ENTREZ_GENE="ncbi_entrez_gene",
     PHAROS="pharos",
     REACTOME="reactome",
     SYMBOL="symbol",
     UNIPROT="uniprot",
+    WIKIPATHWAYS="wikipathways",
 )
 
 ONTOLOGIES_LIST = list(ONTOLOGIES.__dict__.values())

napistu/gcs/constants.py

@@ -5,17 +5,17 @@ from types import SimpleNamespace
 
 GCS_SUBASSET_NAMES = SimpleNamespace(
     SBML_DFS="sbml_dfs",
-    IDENTIFIERS="identifiers",
-    REGULATORY_GRAPH="regulatory_graph",
+    NAPISTU_GRAPH="napistu_graph",
+    SPECIES_IDENTIFIERS="species_identifiers",
     REGULATORY_DISTANCES="regulatory_distances",
 )
 
 
 GCS_FILETYPES = SimpleNamespace(
     SBML_DFS="sbml_dfs.pkl",
-    IDENTIFIERS="identifiers.tsv",
-    REGULATORY_GRAPH="regulatory_graph.pkl",
-    REGULATORY_DISTANCES="regulatory_distances.json",
+    NAPISTU_GRAPH="napistu_graph.pkl",
+    SPECIES_IDENTIFIERS="species_identifiers.tsv",
+    REGULATORY_DISTANCES="regulatory_distances.parquet",
 )
 
 
@@ -27,8 +27,8 @@ GCS_ASSETS = SimpleNamespace(
             "file": "test_pathway.tar.gz",
             "subassets": {
                 GCS_SUBASSET_NAMES.SBML_DFS: GCS_FILETYPES.SBML_DFS,
-                GCS_SUBASSET_NAMES.IDENTIFIERS: GCS_FILETYPES.IDENTIFIERS,
-                GCS_SUBASSET_NAMES.REGULATORY_GRAPH: GCS_FILETYPES.REGULATORY_GRAPH,
+                GCS_SUBASSET_NAMES.NAPISTU_GRAPH: GCS_FILETYPES.NAPISTU_GRAPH,
+                GCS_SUBASSET_NAMES.SPECIES_IDENTIFIERS: GCS_FILETYPES.SPECIES_IDENTIFIERS,
                 GCS_SUBASSET_NAMES.REGULATORY_DISTANCES: GCS_FILETYPES.REGULATORY_DISTANCES,
             },
             "public_url": "https://storage.googleapis.com/shackett-napistu-public/test_pathway.tar.gz",
@@ -37,8 +37,8 @@ GCS_ASSETS = SimpleNamespace(
             "file": "human_consensus.tar.gz",
             "subassets": {
                 GCS_SUBASSET_NAMES.SBML_DFS: GCS_FILETYPES.SBML_DFS,
-                GCS_SUBASSET_NAMES.IDENTIFIERS: GCS_FILETYPES.IDENTIFIERS,
-                GCS_SUBASSET_NAMES.REGULATORY_GRAPH: GCS_FILETYPES.REGULATORY_GRAPH,
+                GCS_SUBASSET_NAMES.NAPISTU_GRAPH: GCS_FILETYPES.NAPISTU_GRAPH,
+                GCS_SUBASSET_NAMES.SPECIES_IDENTIFIERS: GCS_FILETYPES.SPECIES_IDENTIFIERS,
             },
             "public_url": "https://storage.googleapis.com/shackett-napistu-public/human_consensus.tar.gz",
         },
@@ -46,8 +46,8 @@ GCS_ASSETS = SimpleNamespace(
             "file": "human_consensus_w_distances.tar.gz",
             "subassets": {
                 GCS_SUBASSET_NAMES.SBML_DFS: GCS_FILETYPES.SBML_DFS,
-                GCS_SUBASSET_NAMES.IDENTIFIERS: GCS_FILETYPES.IDENTIFIERS,
-                GCS_SUBASSET_NAMES.REGULATORY_GRAPH: GCS_FILETYPES.REGULATORY_GRAPH,
+                GCS_SUBASSET_NAMES.NAPISTU_GRAPH: GCS_FILETYPES.NAPISTU_GRAPH,
+                GCS_SUBASSET_NAMES.SPECIES_IDENTIFIERS: GCS_FILETYPES.SPECIES_IDENTIFIERS,
                 GCS_SUBASSET_NAMES.REGULATORY_DISTANCES: GCS_FILETYPES.REGULATORY_DISTANCES,
             },
             "public_url": "https://storage.googleapis.com/calico-cpr-public/human_consensus_w_distances.tar.gz",

napistu/ontologies/id_tables.py

@@ -0,0 +1,282 @@
+import logging
+from typing import Optional, Union, Set
+
+import pandas as pd
+
+from napistu import sbml_dfs_utils
+from napistu.constants import (
+    BQB,
+    BQB_DEFINING_ATTRS_LOOSE,
+    IDENTIFIERS,
+    SBML_DFS_SCHEMA,
+    SCHEMA_DEFS,
+    VALID_BQB_TERMS,
+)
+from napistu import utils
+
+logger = logging.getLogger(__name__)
+
+
+def filter_id_table(
+    id_table: pd.DataFrame,
+    identifiers: Optional[Union[str, list, set]] = None,
+    ontologies: Optional[Union[str, list, set]] = None,
+    bqbs: Optional[Union[str, list, set]] = BQB_DEFINING_ATTRS_LOOSE + [BQB.HAS_PART],
+) -> pd.DataFrame:
+    """
+    Filter an identifier table by identifiers, ontologies, and BQB terms for a given entity type.
+
+    Parameters
+    ----------
+    id_table : pd.DataFrame
+        DataFrame containing identifier mappings to be filtered.
+    identifiers : str, list, set, or None, optional
+        Identifiers to filter by. If None, no filtering is applied on identifiers.
+    ontologies : str, list, set, or None, optional
+        Ontologies to filter by. If None, no filtering is applied on ontologies.
+    bqbs : str, list, set, or None, optional
+        BQB terms to filter by. If None, no filtering is applied on BQB terms. Default is [BQB.IS, BQB.HAS_PART].
+
+    Returns
+    -------
+    pd.DataFrame
+        Filtered DataFrame containing only rows matching the specified criteria.
+
+    Raises
+    ------
+    ValueError
+        If the id_table or filter values are invalid, or required columns are missing.
+    """
+
+    entity_type = sbml_dfs_utils.infer_entity_type(id_table)
+    _validate_id_table(id_table, entity_type)
+
+    # bqbs
+    if bqbs is not None:
+        bqbs = _sanitize_id_table_bqbs(bqbs, id_table)
+        id_table = id_table.query("bqb in @bqbs")
+
+    # ontologies
+    if ontologies is not None:
+        ontologies = _sanitize_id_table_ontologies(ontologies, id_table)
+        id_table = id_table.query("ontology in @ontologies")
+
+    # identifiers
+    if identifiers is not None:
+        identifiers = _sanitize_id_table_identifiers(identifiers, id_table)
+        id_table = id_table.query("identifier in @identifiers")
+
+    # return the filtered id_table
+    return id_table
+
+
+def _validate_id_table(id_table: pd.DataFrame, entity_type: str) -> None:
+    """
+    Validate that the id_table contains the required columns and matches the schema for the given entity_type.
+
+    Parameters
+    ----------
+    id_table : pd.DataFrame
+        DataFrame containing identifier mappings for a given entity type.
+    entity_type : str
+        The type of entity (e.g., 'species', 'reactions') to validate against the schema.
+
+    Returns
+    -------
+    None
+
+    Raises
+    ------
+    ValueError
+        If entity_type is not present in the schema, or if required columns are missing in id_table.
+    """
+
+    schema = SBML_DFS_SCHEMA.SCHEMA
+
+    if entity_type not in schema.keys():
+        raise ValueError(
+            f"{entity_type} does not match a table in the SBML_dfs object. The tables "
+            f"which are present are {', '.join(schema.keys())}"
+        )
+
+    entity_table_attrs = schema[entity_type]
+
+    if SCHEMA_DEFS.ID not in entity_table_attrs.keys():
+        raise ValueError(f"{entity_type} does not have an 'id' attribute")
+
+    entity_pk = entity_table_attrs[SCHEMA_DEFS.PK]
+
+    utils.match_pd_vars(
+        id_table,
+        req_vars={
+            entity_pk,
+            IDENTIFIERS.ONTOLOGY,
+            IDENTIFIERS.IDENTIFIER,
+            IDENTIFIERS.URL,
+            IDENTIFIERS.BQB,
+        },
+        allow_series=False,
+    ).assert_present()
+
+    return None
+
+
+def _sanitize_id_table_values(
+    values: Union[str, list, set],
+    id_table: pd.DataFrame,
+    column_name: str,
+    valid_values: Optional[Set[str]] = None,
+    value_type_name: str = None,
+) -> set:
+    """
+    Generic function to sanitize and validate values against an id_table column.
+
+    Parameters
+    ----------
+    values : str, list, or set
+        Values to sanitize and validate. Can be a single string, list of strings,
+        or set of strings.
+    id_table : pd.DataFrame
+        DataFrame containing the reference data to validate against.
+    column_name : str
+        Name of the column in id_table to check values against.
+    valid_values : set of str, optional
+        Optional set of globally valid values for additional validation
+        (e.g., VALID_BQB_TERMS). If provided, values must be a subset of this set.
+    value_type_name : str, optional
+        Human-readable name for the value type used in error messages.
+        If None, defaults to column_name.
+
+    Returns
+    -------
+    set
+        Set of sanitized and validated values.
+
+    Raises
+    ------
+    ValueError
+        If values is not a string, list, or set.
+        If any values are not in valid_values (when provided).
+        If none of the requested values are present in the id_table.
+
+    Warnings
+    --------
+    Logs a warning if some (but not all) requested values are missing from id_table.
+    """
+    if value_type_name is None:
+        value_type_name = column_name
+
+    # Convert to set
+    if isinstance(values, str):
+        values = {values}
+    elif isinstance(values, list):
+        values = set(values)
+    elif isinstance(values, set):
+        pass
+    else:
+        raise ValueError(
+            f"{value_type_name} must be a string, a set, or list, got {type(values).__name__}"
+        )
+
+    # Check against global valid values if provided
+    if valid_values is not None:
+        invalid_values = values.difference(valid_values)
+        if len(invalid_values) > 0:
+            raise ValueError(
+                f"The following {value_type_name} are not valid: {', '.join(invalid_values)}.\n"
+                f"Valid {value_type_name} are {', '.join(valid_values)}"
+            )
+
+    # Check against values present in the id_table
+    available_values = set(id_table[column_name].unique())
+    missing_values = values.difference(available_values)
+
+    if len(missing_values) == len(values):
+        raise ValueError(
+            f"None of the requested {value_type_name} are present in the id_table: {', '.join(missing_values)}.\n"
+            f"The included {value_type_name} are {', '.join(available_values)}"
+        )
+    elif len(missing_values) > 0:
+        logger.warning(
+            f"The following {value_type_name} are not present in the id_table: {', '.join(missing_values)}.\n"
+            f"The included {value_type_name} are {', '.join(available_values)}"
+        )
+
+    return values
+
+
+def _sanitize_id_table_ontologies(
+    ontologies: Union[str, list, set], id_table: pd.DataFrame
+) -> set:
+    """
+    Sanitize and validate ontologies against the id_table.
+
+    Parameters
+    ----------
+    ontologies : str, list, or set
+        Ontology names to validate.
+    id_table : pd.DataFrame
+        DataFrame containing ontology reference data.
+
+    Returns
+    -------
+    set
+        Set of validated ontology names.
+    """
+    return _sanitize_id_table_values(
+        values=ontologies,
+        id_table=id_table,
+        column_name=IDENTIFIERS.ONTOLOGY,
+        value_type_name="ontologies",
+    )
+
+
+def _sanitize_id_table_bqbs(bqbs: Union[str, list, set], id_table: pd.DataFrame) -> set:
+    """
+    Sanitize and validate BQBs against the id_table.
+
+    Parameters
+    ----------
+    bqbs : str, list, or set
+        BQB terms to validate.
+    id_table : pd.DataFrame
+        DataFrame containing BQB reference data.
+
+    Returns
+    -------
+    set
+        Set of validated BQB terms.
+    """
+    return _sanitize_id_table_values(
+        values=bqbs,
+        id_table=id_table,
+        column_name=IDENTIFIERS.BQB,
+        valid_values=VALID_BQB_TERMS,
+        value_type_name="bqbs",
+    )
+
+
+def _sanitize_id_table_identifiers(
+    identifiers: Union[str, list, set], id_table: pd.DataFrame
+) -> set:
+    """
+    Sanitize and validate identifiers against the id_table.
+
+    Parameters
+    ----------
+    identifiers : str, list, or set
+        Identifier values to validate.
+    id_table : pd.DataFrame
+        DataFrame containing identifier reference data.
+
+    Returns
+    -------
+    set
+        Set of validated identifiers.
+    """
+    return _sanitize_id_table_values(
+        values=identifiers,
+        id_table=id_table,
+        column_name=IDENTIFIERS.IDENTIFIER,
+        value_type_name="identifiers",
+    )

napistu/sbml_dfs_core.py

@@ -19,17 +19,23 @@ from napistu import sbml_dfs_utils
 from napistu import source
 from napistu import utils
 from napistu.ingestion import sbml
-from napistu.constants import SBML_DFS
-from napistu.constants import SBML_DFS_SCHEMA
-from napistu.constants import IDENTIFIERS
-from napistu.constants import NAPISTU_STANDARD_OUTPUTS
-from napistu.constants import BQB_PRIORITIES
-from napistu.constants import ONTOLOGY_PRIORITIES
-from napistu.constants import MINI_SBO_FROM_NAME
-from napistu.constants import MINI_SBO_TO_NAME
-from napistu.constants import SBOTERM_NAMES
-from napistu.constants import ENTITIES_W_DATA
-from napistu.constants import ENTITIES_TO_ENTITY_DATA
+from napistu.ontologies import id_tables
+from napistu.constants import (
+    BQB,
+    BQB_DEFINING_ATTRS_LOOSE,
+    BQB_PRIORITIES,
+    ENTITIES_W_DATA,
+    ENTITIES_TO_ENTITY_DATA,
+    IDENTIFIERS,
+    MINI_SBO_FROM_NAME,
+    MINI_SBO_TO_NAME,
+    NAPISTU_STANDARD_OUTPUTS,
+    ONTOLOGY_PRIORITIES,
+    SBML_DFS,
+    SBML_DFS_SCHEMA,
+    SBOTERM_NAMES,
+    SCHEMA_DEFS,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -101,7 +107,7 @@ class SBML_dfs:
         Remove a reactions data table by label.
     remove_species_data(label)
         Remove a species data table by label.
-    search_by_ids(ids, entity_type, identifiers_df, ontologies=None)
+    search_by_ids(id_table, identifiers=None, ontologies=None, bqbs=None)
         Find entities and identifiers matching a set of query IDs.
     search_by_name(name, entity_type, partial_match=True)
         Find entities by exact or partial name match.
@@ -455,12 +461,12 @@ class SBML_dfs:
         ValueError
             If id_type is invalid or identifiers are malformed
         """
-        selected_table = self.get_table(id_type, {"id"})
+        selected_table = self.get_table(id_type, {SCHEMA_DEFS.ID})
         schema = SBML_DFS_SCHEMA.SCHEMA
 
         identifiers_dict = dict()
         for sysid in selected_table.index:
-            id_entry = selected_table[schema[id_type]["id"]][sysid]
+            id_entry = selected_table[schema[id_type][SCHEMA_DEFS.ID]][sysid]
 
             if isinstance(id_entry, identifiers.Identifiers):
                 identifiers_dict[sysid] = pd.DataFrame(id_entry.ids)
@@ -473,16 +479,16 @@ class SBML_dfs:
                 )
         if not identifiers_dict:
             # Return empty DataFrame with expected columns if nothing found
-            return pd.DataFrame(columns=[schema[id_type]["pk"], "entry"])
+            return pd.DataFrame(columns=[schema[id_type][SCHEMA_DEFS.PK], "entry"])
 
         identifiers_tbl = pd.concat(identifiers_dict)
 
-        identifiers_tbl.index.names = [schema[id_type]["pk"], "entry"]
+        identifiers_tbl.index.names = [schema[id_type][SCHEMA_DEFS.PK], "entry"]
         identifiers_tbl = identifiers_tbl.reset_index()
 
         named_identifiers = identifiers_tbl.merge(
-            selected_table.drop(schema[id_type]["id"], axis=1),
-            left_on=schema[id_type]["pk"],
+            selected_table.drop(schema[id_type][SCHEMA_DEFS.ID], axis=1),
+            left_on=schema[id_type][SCHEMA_DEFS.PK],
             right_index=True,
         )
 
@@ -1163,24 +1169,25 @@ class SBML_dfs:
 
     def search_by_ids(
         self,
-        ids: list[str],
-        entity_type: str,
-        identifiers_df: pd.DataFrame,
-        ontologies: None | set[str] = None,
+        id_table: pd.DataFrame,
+        identifiers: Optional[Union[str, list, set]] = None,
+        ontologies: Optional[Union[str, list, set]] = None,
+        bqbs: Optional[Union[str, list, set]] = BQB_DEFINING_ATTRS_LOOSE
+        + [BQB.HAS_PART],
     ) -> tuple[pd.DataFrame, pd.DataFrame]:
         """
         Find entities and identifiers matching a set of query IDs.
 
         Parameters
         ----------
-        ids : List[str]
-            List of identifiers to search for
-        entity_type : str
-            Type of entity to search (e.g., 'species', 'reactions')
-        identifiers_df : pd.DataFrame
+        id_table : pd.DataFrame
             DataFrame containing identifier mappings
-        ontologies : Optional[Set[str]], optional
-            Set of ontologies to filter by, by default None
+        identifiers : Optional[Union[str, list, set]], optional
+            Identifiers to filter by, by default None
+        ontologies : Optional[Union[str, list, set]], optional
+            Ontologies to filter by, by default None
+        bqbs : Optional[Union[str, list, set]], optional
+            BQB terms to filter by, by default [BQB.IS, BQB.HAS_PART]
 
         Returns
         -------
@@ -1196,42 +1203,25 @@ class SBML_dfs:
             If ontologies is not a set
         """
         # validate inputs
-        entity_table = self.get_table(entity_type, required_attributes={"id"})
-        entity_pk = self.schema[entity_type]["pk"]
-
-        utils.match_pd_vars(
-            identifiers_df,
-            req_vars={
-                entity_pk,
-                IDENTIFIERS.ONTOLOGY,
-                IDENTIFIERS.IDENTIFIER,
-                IDENTIFIERS.URL,
-                IDENTIFIERS.BQB,
-            },
-            allow_series=False,
-        ).assert_present()
-
-        if ontologies is not None:
-            if not isinstance(ontologies, set):
-                # for clarity this should not be reachable based on type hints
-                raise TypeError(
-                    f"ontologies must be a set, but got {type(ontologies).__name__}"
-                )
-            ALL_VALID_ONTOLOGIES = identifiers_df["ontology"].unique()
-            invalid_ontologies = ontologies.difference(ALL_VALID_ONTOLOGIES)
-            if len(invalid_ontologies) > 0:
-                raise ValueError(
-                    f"The following ontologies are not valid: {', '.join(invalid_ontologies)}.\n"
-                    f"Valid ontologies are {', '.join(ALL_VALID_ONTOLOGIES)}"
-                )
 
-            # fitler to just to identifiers matchign the ontologies of interest
-            identifiers_df = identifiers_df.query("ontology in @ontologies")
+        entity_type = sbml_dfs_utils.infer_entity_type(id_table)
+        entity_table = self.get_table(entity_type, required_attributes={SCHEMA_DEFS.ID})
+        entity_pk = self.schema[entity_type][SCHEMA_DEFS.PK]
 
-        matching_identifiers = identifiers_df.loc[
-            identifiers_df["identifier"].isin(ids)
-        ]
-        entity_subset = entity_table.loc[matching_identifiers[entity_pk].tolist()]
+        matching_identifiers = id_tables.filter_id_table(
+            id_table=id_table, identifiers=identifiers, ontologies=ontologies, bqbs=bqbs
+        )
+
+        matching_keys = matching_identifiers[entity_pk].tolist()
+        entity_subset = entity_table.loc[matching_keys]
+
+        if matching_identifiers.shape[0] != entity_subset.shape[0]:
+            raise ValueError(
+                f"Some identifiers did not match to an entity for {entity_type}. "
+                "This suggests that the identifiers and sbml_dfs are not in sync. "
+                "Please create new identifiers with sbml_dfs.get_characteristic_species_ids() "
+                "or sbml_dfs.get_identifiers()."
+            )
 
         return entity_subset, matching_identifiers
 

napistu/sbml_dfs_utils.py

@@ -14,24 +14,29 @@ from napistu import utils
 from napistu import identifiers
 from napistu import indices
 
-from napistu.constants import BQB
-from napistu.constants import SBML_DFS
-from napistu.constants import SBML_DFS_SCHEMA
-from napistu.constants import IDENTIFIERS
-from napistu.constants import BQB_DEFINING_ATTRS
-from napistu.constants import BQB_DEFINING_ATTRS_LOOSE
-from napistu.constants import REQUIRED_REACTION_FROMEDGELIST_COLUMNS
-from napistu.constants import INTERACTION_EDGELIST_EXPECTED_VARS
-from napistu.constants import SBO_ROLES_DEFS
-from napistu.constants import MINI_SBO_FROM_NAME
-from napistu.constants import MINI_SBO_TO_NAME
-from napistu.constants import SBO_NAME_TO_ROLE
-from napistu.constants import ONTOLOGIES
-from napistu.constants import VALID_SBO_TERM_NAMES
-from napistu.constants import VALID_SBO_TERMS
-from napistu.ingestion.constants import VALID_COMPARTMENTS
-from napistu.ingestion.constants import COMPARTMENTS_GO_TERMS
-from napistu.ingestion.constants import GENERIC_COMPARTMENT
+from napistu.constants import (
+    BQB,
+    BQB_DEFINING_ATTRS,
+    BQB_DEFINING_ATTRS_LOOSE,
+    SBML_DFS,
+    SBML_DFS_SCHEMA,
+    SCHEMA_DEFS,
+    IDENTIFIERS,
+    INTERACTION_EDGELIST_EXPECTED_VARS,
+    ONTOLOGIES,
+    MINI_SBO_FROM_NAME,
+    MINI_SBO_TO_NAME,
+    REQUIRED_REACTION_FROMEDGELIST_COLUMNS,
+    SBO_ROLES_DEFS,
+    SBO_NAME_TO_ROLE,
+    VALID_SBO_TERM_NAMES,
+    VALID_SBO_TERMS,
+)
+from napistu.ingestion.constants import (
+    COMPARTMENTS_GO_TERMS,
+    GENERIC_COMPARTMENT,
+    VALID_COMPARTMENTS,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -418,6 +423,65 @@ def id_formatter_inv(ids: list[str]) -> list[int]:
     return id_val
 
 
+def infer_entity_type(df: pd.DataFrame) -> str:
+    """
+    Infer the entity type of a DataFrame based on its structure and schema.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        The DataFrame to analyze
+
+    Returns
+    -------
+    str
+        The inferred entity type name
+
+    Raises
+    ------
+    ValueError
+        If no entity type can be determined
+    """
+    schema = SBML_DFS_SCHEMA.SCHEMA
+
+    # Get all primary keys
+    primary_keys = [
+        entity_schema.get(SCHEMA_DEFS.PK) for entity_schema in schema.values()
+    ]
+    primary_keys = [pk for pk in primary_keys if pk is not None]
+
+    # Check if index matches a primary key
+    if df.index.name in primary_keys:
+        for entity_type, entity_schema in schema.items():
+            if entity_schema.get(SCHEMA_DEFS.PK) == df.index.name:
+                return entity_type
+
+    # Get DataFrame columns that are also primary keys
+    df_columns = set(df.columns).intersection(primary_keys)
+
+    # Check for exact match with primary key + foreign keys
+    for entity_type, entity_schema in schema.items():
+        expected_keys = set()
+
+        # Add primary key
+        pk = entity_schema.get(SCHEMA_DEFS.PK)
+        if pk:
+            expected_keys.add(pk)
+
+        # Add foreign keys
+        fks = entity_schema.get(SCHEMA_DEFS.FK, [])
+        expected_keys.update(fks)
+
+        # Check for exact match
+        if df_columns == expected_keys:
+            return entity_type
+
+    # No match found
+    raise ValueError(
+        f"No entity type matches DataFrame with columns: {sorted(df_columns)}"
+    )
+
+
 def match_entitydata_index_to_entity(
     entity_data_dict: dict,
     an_entity_data_type: str,

{napistu-0.4.0.dist-info → napistu-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: napistu
-Version: 0.4.0
+Version: 0.4.1
 Summary: Connecting high-dimensional data to curated pathways
 Home-page: https://github.com/napistu/napistu-py
 Author: Sean Hackett
@@ -61,7 +61,12 @@ Dynamic: license-file
 
 # Napistu Python Library
 
+[![PyPI version](https://badge.fury.io/py/napistu.svg)](https://badge.fury.io/py/napistu)
 [![Documentation Status](https://readthedocs.org/projects/napistu/badge/?version=latest)](https://napistu.readthedocs.io/en/latest/?badge=latest)
+[![CI](https://github.com/napistu/napistu-py/actions/workflows/ci.yml/badge.svg)](https://github.com/napistu/napistu-py/actions/workflows/ci.yml)
+[![Release](https://github.com/napistu/napistu-py/actions/workflows/release.yml/badge.svg)](https://github.com/napistu/napistu-py/actions/workflows/release.yml)
+[![Deploy to Cloud Run](https://github.com/napistu/napistu-py/actions/workflows/deploy.yml/badge.svg)](https://github.com/napistu/napistu-py/actions/workflows/deploy.yml)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 This Python package hosts the majority of the algorithmic code for the [Napistu project](https://github.com/napistu/napistu).
 

{napistu-0.4.0.dist-info → napistu-0.4.1.dist-info}/RECORD

@@ -1,18 +1,18 @@
 napistu/__init__.py,sha256=dFXAhIqlTLJMwowS4BUDT08-Vy3Q0u1L0CMCErSZT1Y,239
 napistu/__main__.py,sha256=xwlbh_0Ig3a-yG6BIJRiDPSN9R2HnX2pEBvlodlO6h4,29015
 napistu/consensus.py,sha256=xWXiqIM6ot-SSPJZXTrVpohbINSCkZXBtRi-5REfk_g,69897
-napistu/constants.py,sha256=CA-8OnE8LudLSML8piIdfPyRwgdp143Yh9eVwk3uLTw,13377
+napistu/constants.py,sha256=8sp1l0cxu2rsnCrWBEEwhcBKvDtc4u0D0f_72zILLW0,13427
 napistu/identifiers.py,sha256=e2-nTVzr5AINa0y1ER9218bKXyF2kAeJ9At22S4Z00o,33914
 napistu/indices.py,sha256=Zjg3gE0JQ3T879lCPazYg-WXVE6hvcAr713ZKpJ32rk,9830
-napistu/sbml_dfs_core.py,sha256=3Z2Kg-aVnZMGK9iK-_vztY2ORgNpta8BUMuWEZg80iE,73125
-napistu/sbml_dfs_utils.py,sha256=hfTxPerJIKuPC_jpGRCGHE8XMagsHTEe1h2E99VEWL4,44980
+napistu/sbml_dfs_core.py,sha256=s0OyoHs-AjOcbZu1d3KNkW_PI7Rxbhu5ZLpfQeO4iY8,72639
+napistu/sbml_dfs_utils.py,sha256=w5dFcJFDKnKDK9jxPOCuCW8IccxdXmyNmP9vCUhVdf8,46184
 napistu/source.py,sha256=UGpN70bqbC9gnKmM0ivSdQYim9hfzgABeXoQKzRr9oU,13646
 napistu/utils.py,sha256=PEAsLn7VGN8JlNJQcAMYpjF1gr2mWmb5IqBsypP9hi0,35768
 napistu/context/__init__.py,sha256=LQBEqipcHKK0E5UlDEg1ct-ymCs93IlUrUaH8BCevf0,242
 napistu/context/discretize.py,sha256=Qq7zg46F_I-PvQIT2_pEDQV7YEtUQCxKoRvT5Gu9QsE,15052
 napistu/context/filtering.py,sha256=l1oq-43ysSGqU9VmhTOO_pYT4DSMf20yxvktPC1MI0I,13696
 napistu/gcs/__init__.py,sha256=dFXAhIqlTLJMwowS4BUDT08-Vy3Q0u1L0CMCErSZT1Y,239
-napistu/gcs/constants.py,sha256=g6PaU99GY5XvaRHx4BGmWHUpcJ36-Zh_GzeNVOeHviM,2856
+napistu/gcs/constants.py,sha256=5hLp1pL7SHEiscLNKcdI4IeOP4vUaasBCIHJrEedl0o,2909
 napistu/gcs/downloads.py,sha256=SvGv9WYr_Vt3guzyz1QiAuBndeKPTBtWSFLj1-QbLf4,6348
 napistu/gcs/utils.py,sha256=eLSsvewWJdCguyj2k0ozUGP5BTemaE1PZg41Z3aY5kM,571
 napistu/ingestion/__init__.py,sha256=dFXAhIqlTLJMwowS4BUDT08-Vy3Q0u1L0CMCErSZT1Y,239
@@ -73,6 +73,7 @@ napistu/ontologies/__init__.py,sha256=dFXAhIqlTLJMwowS4BUDT08-Vy3Q0u1L0CMCErSZT1
 napistu/ontologies/constants.py,sha256=GyOFvezSxDK1VigATcruTKtNhjcYaid1ggulEf_HEtQ,4345
 napistu/ontologies/dogma.py,sha256=VVj6NKBgNym4SdOSu8g22OohALj7cbObhIJmdY2Sfy0,8860
 napistu/ontologies/genodexito.py,sha256=ZZmb7V38BmFjy9VOGdxbD3-BD5tKGl5izr0nwO_eEdA,24967
+napistu/ontologies/id_tables.py,sha256=q_31eQwlkRNFzLOkJNT4Fp6ra6kkzFOByzgJu5WFh0U,8372
 napistu/ontologies/mygene.py,sha256=RMFQTWsLkeYxmsOPxxmeIya2phdcUMcF5V2abaS8MVg,11109
 napistu/ontologies/renaming.py,sha256=aZR5oxjeZhse026fuvFyQiKM8PVzbBT915J8AfXGv1M,7006
 napistu/rpy2/__init__.py,sha256=8WzSK_tmdcbyMUtb17OmqdQqbisqIBl8OQrDsaFDeX4,8356
@@ -82,7 +83,7 @@ napistu/rpy2/rids.py,sha256=AfXLTfTdonfspgAHYO0Ph7jSUWv8YuyT8x3fyLfAqc8,3413
 napistu/scverse/__init__.py,sha256=Lgxr3iMQAkTzXE9BNz93CndNP5djzerLvmHM-D0PU3I,357
 napistu/scverse/constants.py,sha256=0iAkhyJUIeFGHdLLU3fCaEU1O3Oix4qAsxr3CxGTjVs,653
 napistu/scverse/loading.py,sha256=jqiE71XB-wdV50GyZrauFNY0Lai4bX9Fm2Gv80VR8t8,27016
-napistu-0.4.0.dist-info/licenses/LICENSE,sha256=kW8wVT__JWoHjl2BbbJDAZInWa9AxzJeR_uv6-i5x1g,1063
+napistu-0.4.1.dist-info/licenses/LICENSE,sha256=kW8wVT__JWoHjl2BbbJDAZInWa9AxzJeR_uv6-i5x1g,1063
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/conftest.py,sha256=t-GHb0MvSsC-MyhkFpOy2K3t5fi7eaig_Rc2xEQC-t8,9678
 tests/test_consensus.py,sha256=Hzfrgp4SpkRDnEMVMD3f0UInSycndB8kKzC4wDDvRas,15076
@@ -113,14 +114,15 @@ tests/test_network_ng_utils.py,sha256=QVVuRnvCRfTSIlGdwQTIF9lr0wOwoc5gGeXAUY_Adg
 tests/test_network_paths.py,sha256=TWZnxY5bF3m6gahcxcYJGrBIawh2-_vUcec1LyPmXV8,1686
 tests/test_network_precompute.py,sha256=zwJrKNC3s8rIrsyAQfQMYxbl8HZXUr7u09nMJ_K8jiU,9005
 tests/test_ontologies_genodexito.py,sha256=6fINyUiubHZqu7qxye09DQfJXw28ZMAJc3clPb-cCoY,2298
+tests/test_ontologies_id_tables.py,sha256=CpwpbmQvTc1BaVd6jbDKHAVE2etwN0vx93nC8jpnMlE,7265
 tests/test_ontologies_mygene.py,sha256=VkdRcKIWmcG6V-2dpfvsBiOJN5dO-j0RqZNxtJRcyBU,1583
 tests/test_ontologies_renaming.py,sha256=pawp3pV1hxW8nskWc4f2YHwMUqTilEEBD2BtpcSay5Q,3839
 tests/test_pathwayannot.py,sha256=bceosccNy9tgxQei_7j7ATBSSvBSxOngJvK-mAzR_K0,3312
 tests/test_rpy2_callr.py,sha256=V4a-QH5krgYOQRgqzksMzIkGAFjBqKOAqgprxrH6bE0,2904
 tests/test_rpy2_init.py,sha256=T3gnxC1O7XNvYM2P4018ikpPPAy-kwQLm7Erj0RfA-4,5895
 tests/test_sbml.py,sha256=f25zj1NogYrmLluvBDboLameTuCiQ309433Qn3iPvhg,1483
-tests/test_sbml_dfs_core.py,sha256=CH5OXNSAozWTl6qBvbHfgTG0NcgdlKJ_WcG0lTYBm3k,26217
-tests/test_sbml_dfs_utils.py,sha256=WLR-b7VQ7VW4d9rv0DePPd9l-CG-FkpsHTa3OOvrbXQ,8630
+tests/test_sbml_dfs_core.py,sha256=nnLPpZTVtCznOBohk7CX67x6sMqktJWt-sZMWQKoaDs,26521
+tests/test_sbml_dfs_utils.py,sha256=gWIhzUEtQlOR9c1TiCyhlSAELmWnBSncn6vCEqH5hl0,11029
 tests/test_sbo.py,sha256=x_PENFaXYsrZIzOZu9cj_Wrej7i7SNGxgBYYvcigLs0,308
 tests/test_scverse_loading.py,sha256=bnU1lQSYYWhOAs0IIBoi4ZohqPokDQJ0n_rtkAfEyMU,29948
 tests/test_set_coverage.py,sha256=J-6m6LuOjcQa9pxRuWglSfJk4Ltm7kt_eOrn_Q-7P6Q,1604
@@ -129,8 +131,8 @@ tests/test_uncompartmentalize.py,sha256=nAk5kfAVLU9a2VWe2x2HYVcKqj-EnwmwddERIPRa
 tests/test_utils.py,sha256=qPSpV-Q9b6vmdycgaDmQqtcvzKnAVnN9j5xJ9x-T6bg,23959
 tests/utils.py,sha256=SoWQ_5roJteFGcMaOeEiQ5ucwq3Z2Fa3AAs9iXHTsJY,749
 tests/test_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-napistu-0.4.0.dist-info/METADATA,sha256=fejMxUkQvO_EqBaZIowvumw5KRzXsjZ9gGGX0tc-YkE,3397
-napistu-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-napistu-0.4.0.dist-info/entry_points.txt,sha256=_QnaPOvJNA3IltxmZgWIiBoen-L1bPYX18YQfC7oJgQ,41
-napistu-0.4.0.dist-info/top_level.txt,sha256=Gpvk0a_PjrtqhYcQ9IDr3zR5LqpZ-uIHidQMIpjlvhY,14
-napistu-0.4.0.dist-info/RECORD,,
+napistu-0.4.1.dist-info/METADATA,sha256=zl_710wCsatB3lKZAgHba-MLEOPSDOyrxs3b5FB6toA,4078
+napistu-0.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+napistu-0.4.1.dist-info/entry_points.txt,sha256=_QnaPOvJNA3IltxmZgWIiBoen-L1bPYX18YQfC7oJgQ,41
+napistu-0.4.1.dist-info/top_level.txt,sha256=Gpvk0a_PjrtqhYcQ9IDr3zR5LqpZ-uIHidQMIpjlvhY,14
+napistu-0.4.1.dist-info/RECORD,,

tests/test_ontologies_id_tables.py

@@ -0,0 +1,198 @@
+import pytest
+import pandas as pd
+from unittest.mock import patch
+
+from napistu.ontologies import id_tables
+from napistu.constants import (
+    BQB,
+    IDENTIFIERS,
+    ONTOLOGIES,
+    SBML_DFS,
+    VALID_BQB_TERMS,
+)
+
+
+@pytest.fixture
+def sample_id_table():
+    """Create a sample DataFrame for testing."""
+    return pd.DataFrame(
+        {
+            SBML_DFS.S_ID: ["s1", "s2", "s3", "s4"],
+            IDENTIFIERS.ONTOLOGY: [
+                ONTOLOGIES.GO,
+                ONTOLOGIES.KEGG,
+                ONTOLOGIES.REACTOME,
+                ONTOLOGIES.WIKIPATHWAYS,
+            ],
+            IDENTIFIERS.IDENTIFIER: ["GO:0001", "hsa00010", "R-HSA-123", "WP123"],
+            IDENTIFIERS.BQB: [BQB.IS, BQB.HAS_PART, BQB.IS_PART_OF, BQB.IS_VERSION_OF],
+            IDENTIFIERS.URL: ["foo", "bar", "baz", "qux"],
+            "other_col": ["a", "b", "c", "d"],
+        }
+    )
+
+
+def test_sanitize_id_table_values_valid_cases(sample_id_table):
+    """Test all valid use cases for _sanitize_id_table_values function."""
+
+    # Test string input conversion
+    result = id_tables._sanitize_id_table_values(
+        ONTOLOGIES.GO, sample_id_table, IDENTIFIERS.ONTOLOGY
+    )
+    assert result == {ONTOLOGIES.GO}
+    assert isinstance(result, set)
+
+    # Test list input conversion
+    result = id_tables._sanitize_id_table_values(
+        [ONTOLOGIES.GO, ONTOLOGIES.KEGG], sample_id_table, IDENTIFIERS.ONTOLOGY
+    )
+    assert result == {ONTOLOGIES.GO, ONTOLOGIES.KEGG}
+    assert isinstance(result, set)
+
+    # Test set input unchanged
+    input_set = {ONTOLOGIES.GO, ONTOLOGIES.KEGG}
+    result = id_tables._sanitize_id_table_values(
+        input_set, sample_id_table, IDENTIFIERS.ONTOLOGY
+    )
+    assert result == input_set
+    assert isinstance(result, set)
+
+    # Test successful validation against valid_values
+    result = id_tables._sanitize_id_table_values(
+        BQB.IS, sample_id_table, IDENTIFIERS.BQB, set(VALID_BQB_TERMS)
+    )
+    assert result == {BQB.IS}
+
+    # Test duplicate values in input list are handled correctly
+    result = id_tables._sanitize_id_table_values(
+        [ONTOLOGIES.GO, ONTOLOGIES.GO, ONTOLOGIES.KEGG],
+        sample_id_table,
+        IDENTIFIERS.ONTOLOGY,
+    )
+    assert result == {
+        ONTOLOGIES.GO,
+        ONTOLOGIES.KEGG,
+    }  # Duplicates removed by set conversion
+
+    # Test all values present in table
+    result = id_tables._sanitize_id_table_values(
+        [ONTOLOGIES.GO, ONTOLOGIES.KEGG, ONTOLOGIES.REACTOME],
+        sample_id_table,
+        IDENTIFIERS.ONTOLOGY,
+    )
+    assert result == {ONTOLOGIES.GO, ONTOLOGIES.KEGG, ONTOLOGIES.REACTOME}
+
+    # Test single value present in table
+    result = id_tables._sanitize_id_table_values(
+        ONTOLOGIES.WIKIPATHWAYS, sample_id_table, IDENTIFIERS.ONTOLOGY
+    )
+    assert result == {ONTOLOGIES.WIKIPATHWAYS}
+
+    # Test with different column (BQB)
+    result = id_tables._sanitize_id_table_values(
+        BQB.HAS_PART, sample_id_table, IDENTIFIERS.BQB
+    )
+    assert result == {BQB.HAS_PART}
+
+
+@patch("napistu.ontologies.id_tables.logger")
+def test_sanitize_id_table_values_error_cases(mock_logger, sample_id_table):
+    """Test error cases and edge cases for _sanitize_id_table_values function."""
+
+    # Test invalid input types raise ValueError
+    with pytest.raises(ValueError, match="ontology must be a string, a set, or list"):
+        id_tables._sanitize_id_table_values(123, sample_id_table, IDENTIFIERS.ONTOLOGY)
+
+    with pytest.raises(ValueError, match="ontology must be a string, a set, or list"):
+        id_tables._sanitize_id_table_values(
+            {"key": "value"}, sample_id_table, IDENTIFIERS.ONTOLOGY
+        )
+
+    # Test validation failure against valid_values
+    with pytest.raises(
+        ValueError, match="The following bqb are not valid: INVALID_BQB"
+    ):
+        id_tables._sanitize_id_table_values(
+            "INVALID_BQB", sample_id_table, IDENTIFIERS.BQB, set(VALID_BQB_TERMS), "bqb"
+        )
+
+    # Test multiple invalid values against valid_values
+    with pytest.raises(ValueError, match="The following bqb are not valid"):
+        id_tables._sanitize_id_table_values(
+            ["INVALID1", "INVALID2"],
+            sample_id_table,
+            IDENTIFIERS.BQB,
+            set(VALID_BQB_TERMS),
+            "bqb",
+        )
+
+    # Test all values missing from table raises error
+    missing_values = {"MISSING1", "MISSING2"}
+    with pytest.raises(ValueError, match="None of the requested ontology are present"):
+        id_tables._sanitize_id_table_values(
+            missing_values, sample_id_table, IDENTIFIERS.ONTOLOGY
+        )
+
+    # Test case-sensitive matching (lowercase 'go' should fail)
+    with pytest.raises(ValueError, match="None of the requested ontology are present"):
+        id_tables._sanitize_id_table_values(
+            "INVALID_ONTOLOGY", sample_id_table, IDENTIFIERS.ONTOLOGY
+        )
+
+    # Test custom value_type_name in error messages
+    with pytest.raises(ValueError, match="custom_type must be a string"):
+        id_tables._sanitize_id_table_values(
+            123, sample_id_table, IDENTIFIERS.ONTOLOGY, value_type_name="custom_type"
+        )
+
+    # Test default value_type_name uses column_name
+    with pytest.raises(ValueError, match="test_column must be a string"):
+        id_tables._sanitize_id_table_values(123, sample_id_table, "test_column")
+
+    # Test empty dataframe column
+    empty_df = pd.DataFrame({"ontology": []})
+    with pytest.raises(ValueError, match="None of the requested ontology are present"):
+        id_tables._sanitize_id_table_values("GO", empty_df, IDENTIFIERS.ONTOLOGY)
+
+    # Test partial values missing logs warning but doesn't raise error
+    mixed_values = {ONTOLOGIES.GO, "MISSING"}  # GO exists, MISSING doesn't
+    result = id_tables._sanitize_id_table_values(
+        mixed_values, sample_id_table, IDENTIFIERS.ONTOLOGY
+    )
+
+    assert result == mixed_values
+    mock_logger.warning.assert_called_once()
+    warning_call = mock_logger.warning.call_args[0][0]
+    assert "MISSING" in warning_call
+    assert "not present in the id_table" in warning_call
+
+    # Test multiple partial missing values
+    mock_logger.reset_mock()
+    mixed_values = {ONTOLOGIES.GO, ONTOLOGIES.KEGG, "MISSING1", "MISSING2"}
+    result = id_tables._sanitize_id_table_values(
+        mixed_values, sample_id_table, IDENTIFIERS.ONTOLOGY
+    )
+
+    assert result == mixed_values
+    mock_logger.warning.assert_called_once()
+    warning_call = mock_logger.warning.call_args[0][0]
+    assert "MISSING1" in warning_call and "MISSING2" in warning_call
+
+
+def test_filter_id_table_basic(sample_id_table):
+    """Basic test for filter_id_table filtering by identifier, ontology, and bqb."""
+
+    # Use a known identifier, ontology, and bqb from the fixture
+    filtered = id_tables.filter_id_table(
+        id_table=sample_id_table,
+        identifiers=["GO:0001"],
+        ontologies=[ONTOLOGIES.GO],
+        bqbs=[BQB.IS],
+    )
+    # Should return a DataFrame with only the matching row
+    assert isinstance(filtered, pd.DataFrame)
+    assert len(filtered) == 1
+    row = filtered.iloc[0]
+    assert row[IDENTIFIERS.ONTOLOGY] == ONTOLOGIES.GO
+    assert row[IDENTIFIERS.IDENTIFIER] == "GO:0001"
+    assert row[IDENTIFIERS.BQB] == BQB.IS

tests/test_sbml_dfs_core.py

@@ -13,10 +13,12 @@ from napistu.modify import pathwayannot
 
 from napistu import identifiers as napistu_identifiers
 from napistu.constants import (
-    SBML_DFS,
+    BQB,
     BQB_DEFINING_ATTRS,
     BQB_DEFINING_ATTRS_LOOSE,
-    BQB,
+    SBML_DFS,
+    SCHEMA_DEFS,
+    ONTOLOGIES,
 )
 from napistu.sbml_dfs_core import SBML_dfs
 from unittest.mock import patch
@@ -291,53 +293,62 @@ def test_read_sbml_with_invalid_ids():
 
 
 def test_get_table(sbml_dfs):
-    assert isinstance(sbml_dfs.get_table("species"), pd.DataFrame)
-    assert isinstance(sbml_dfs.get_table("species", {"id"}), pd.DataFrame)
+    assert isinstance(sbml_dfs.get_table(SBML_DFS.SPECIES), pd.DataFrame)
+    assert isinstance(
+        sbml_dfs.get_table(SBML_DFS.SPECIES, {SCHEMA_DEFS.ID}), pd.DataFrame
+    )
 
     # invalid table
     with pytest.raises(ValueError):
-        sbml_dfs.get_table("foo", {"id"})
+        sbml_dfs.get_table("foo", {SCHEMA_DEFS.ID})
 
     # bad type
     with pytest.raises(TypeError):
-        sbml_dfs.get_table("reaction_species", "id")
+        sbml_dfs.get_table(SBML_DFS.REACTION_SPECIES, SCHEMA_DEFS.ID)
 
     # reaction species don't have ids
     with pytest.raises(ValueError):
-        sbml_dfs.get_table("reaction_species", {"id"})
+        sbml_dfs.get_table(SBML_DFS.REACTION_SPECIES, {SCHEMA_DEFS.ID})
 
 
 def test_search_by_name(sbml_dfs_metabolism):
-    assert sbml_dfs_metabolism.search_by_name("atp", "species", False).shape[0] == 1
-    assert sbml_dfs_metabolism.search_by_name("pyr", "species").shape[0] == 3
-    assert sbml_dfs_metabolism.search_by_name("kinase", "reactions").shape[0] == 4
+    assert (
+        sbml_dfs_metabolism.search_by_name("atp", SBML_DFS.SPECIES, False).shape[0] == 1
+    )
+    assert sbml_dfs_metabolism.search_by_name("pyr", SBML_DFS.SPECIES).shape[0] == 3
+    assert (
+        sbml_dfs_metabolism.search_by_name("kinase", SBML_DFS.REACTIONS).shape[0] == 4
+    )
 
 
 def test_search_by_id(sbml_dfs_metabolism):
-    identifiers_tbl = sbml_dfs_metabolism.get_identifiers("species")
+    identifiers_tbl = sbml_dfs_metabolism.get_identifiers(SBML_DFS.SPECIES)
     ids, species = sbml_dfs_metabolism.search_by_ids(
-        ["P40926"], "species", identifiers_tbl
+        identifiers_tbl, identifiers=["P40926"]
     )
     assert ids.shape[0] == 1
     assert species.shape[0] == 1
 
     ids, species = sbml_dfs_metabolism.search_by_ids(
-        ["57540", "30744"], "species", identifiers_tbl, {"chebi"}
+        identifiers_tbl,
+        identifiers=["57540", "30744"],
+        ontologies={ONTOLOGIES.CHEBI},
     )
     assert ids.shape[0] == 2
     assert species.shape[0] == 2
 
-    ids, species = sbml_dfs_metabolism.search_by_ids(
-        ["baz"], "species", identifiers_tbl
-    )
-    assert ids.shape[0] == 0
-    assert species.shape[0] == 0
+    with pytest.raises(
+        ValueError, match="None of the requested identifiers are present"
+    ):
+        ids, species = sbml_dfs_metabolism.search_by_ids(
+            identifiers_tbl, identifiers=["baz"]  # Non-existent identifier
+        )
 
 
 def test_species_status(sbml_dfs):
 
     species = sbml_dfs.species
-    select_species = species[species["s_name"] == "OxyHbA"]
+    select_species = species[species[SBML_DFS.S_NAME] == "OxyHbA"]
     assert select_species.shape[0] == 1
 
     status = sbml_dfs.species_status(select_species.index[0])

tests/test_sbml_dfs_utils.py

@@ -264,3 +264,73 @@ def test_sbo_constants_internal_consistency():
         assert MINI_SBO_TO_NAME[term] == name
     for term, name in MINI_SBO_TO_NAME.items():
         assert MINI_SBO_FROM_NAME[name] == term
+
+
+def test_infer_entity_type():
+    """Test entity type inference with valid keys"""
+    # when index matches primary key.
+    # Test compartments with index as primary key
+    df = pd.DataFrame(
+        {SBML_DFS.C_NAME: ["cytoplasm"], SBML_DFS.C_IDENTIFIERS: ["GO:0005737"]}
+    )
+    df.index.name = SBML_DFS.C_ID
+    result = sbml_dfs_utils.infer_entity_type(df)
+    assert result == SBML_DFS.COMPARTMENTS
+
+    # Test species with index as primary key
+    df = pd.DataFrame(
+        {SBML_DFS.S_NAME: ["glucose"], SBML_DFS.S_IDENTIFIERS: ["CHEBI:17234"]}
+    )
+    df.index.name = SBML_DFS.S_ID
+    result = sbml_dfs_utils.infer_entity_type(df)
+    assert result == SBML_DFS.SPECIES
+
+    # Test entity type inference by exact column matching.
+    # Test compartmentalized_species (has foreign keys)
+    df = pd.DataFrame(
+        {
+            SBML_DFS.SC_ID: ["glucose_c"],
+            SBML_DFS.S_ID: ["glucose"],
+            SBML_DFS.C_ID: ["cytoplasm"],
+        }
+    )
+    result = sbml_dfs_utils.infer_entity_type(df)
+    assert result == "compartmentalized_species"
+
+    # Test reaction_species (has foreign keys)
+    df = pd.DataFrame(
+        {
+            SBML_DFS.RSC_ID: ["rxn1_glc"],
+            SBML_DFS.R_ID: ["rxn1"],
+            SBML_DFS.SC_ID: ["glucose_c"],
+        }
+    )
+    result = sbml_dfs_utils.infer_entity_type(df)
+    assert result == SBML_DFS.REACTION_SPECIES
+
+    # Test reactions (only primary key)
+    df = pd.DataFrame({SBML_DFS.R_ID: ["rxn1"]})
+    result = sbml_dfs_utils.infer_entity_type(df)
+    assert result == SBML_DFS.REACTIONS
+
+
+def test_infer_entity_type_errors():
+    """Test error cases for entity type inference."""
+    # Test no matching entity type
+    df = pd.DataFrame({"random_column": ["value"], "another_col": ["data"]})
+    with pytest.raises(ValueError, match="No entity type matches DataFrame"):
+        sbml_dfs_utils.infer_entity_type(df)
+
+    # Test partial match (missing required foreign key)
+    df = pd.DataFrame(
+        {SBML_DFS.SC_ID: ["glucose_c"], SBML_DFS.S_ID: ["glucose"]}
+    )  # Missing c_id
+    with pytest.raises(ValueError):
+        sbml_dfs_utils.infer_entity_type(df)
+
+    # Test extra primary keys that shouldn't be there
+    df = pd.DataFrame(
+        {SBML_DFS.R_ID: ["rxn1"], SBML_DFS.S_ID: ["glucose"]}
+    )  # Two primary keys
+    with pytest.raises(ValueError):
+        sbml_dfs_utils.infer_entity_type(df)