diff --git a/.github/workflows/codespell.yml b/.github/workflows/codespell.yml
index fb600ee..3336ccd 100644
--- a/.github/workflows/codespell.yml
+++ b/.github/workflows/codespell.yml
@@ -14,6 +14,10 @@ on:
permissions:
contents: read
+concurrency:
+ group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+ cancel-in-progress: true
+
jobs:
codespell:
name: Check for spelling errors
@@ -27,6 +31,6 @@ jobs:
with:
python-version: '3.11'
- name: Install uv
- uses: astral-sh/setup-uv@v3
+ uses: astral-sh/setup-uv@v4
- name: Run codespell via Makefile
run: make spell
\ No newline at end of file
diff --git a/.github/workflows/sphinx.yml b/.github/workflows/sphinx.yml
index 6141268..e7bec93 100644
--- a/.github/workflows/sphinx.yml
+++ b/.github/workflows/sphinx.yml
@@ -2,6 +2,10 @@ name: "Sphinx: Render docs"
on: push
+concurrency:
+ group: ${{ github.workflow }}-${{ github.ref }}
+ cancel-in-progress: true
+
jobs:
build:
runs-on: ubuntu-latest
diff --git a/README.md b/README.md
index 9e91b08..23536e8 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,7 @@ Explore knowledge graphs in Translator
Find neighbors in the Translator KGs for a given node
Find paths between node A and node B in the Translator KG
Find a subnetwork given a list of nodes in the Translator KG
-Experimental developer-friendly wrappers for resolving labels/CURIEs, caching Translator resources, and returning parsed finder results
+Developer-friendly wrappers for resolving labels/CURIEs, caching Translator resources, and returning parsed finder results
Connecting user's API with Translator API
@@ -85,10 +85,10 @@ Example notebook for **[PathFinder](https://github.com/NCATSTranslator/Translato
#### Network finder
Example notebook for **[NetworkFinder](https://github.com/NCATSTranslator/Translator_component_toolkit/blob/main/notebooks/Neighborhood_finder_multiple_nodes.ipynb)**
-#### Experimental API tutorial
-Quick-start notebook for the experimental developer-friendly finder wrappers: **[Experimental API tutorial](https://github.com/NCATSTranslator/Translator_component_toolkit/blob/main/notebooks/Experimental_API_tutorial.ipynb)**
+#### Developer-friendly finder APIs
+The finder notebooks above include quick-start sections using the developer-friendly `pathfinder` and `neighborhood_finder` APIs, now part of TCT's main API surface (`from TCT import pathfinder, neighborhood_finder`).
-Use the detailed NeighborhoodFinder, PathFinder, NetworkFinder, KG overview, and visualization notebooks above when you need more fine-grained endpoint selection, predicate control, raw query construction, parser workflows, or visualization setup.
+Use the detailed NeighborhoodFinder, PathFinder, NetworkFinder, KG overview, and visualization notebooks when you need more fine-grained endpoint selection, predicate control, raw query construction, parser workflows, or visualization setup.
#### Connecting to a user's API
diff --git a/TCT/TCT.py b/TCT/TCT.py
index 48434f4..cb164a4 100644
--- a/TCT/TCT.py
+++ b/TCT/TCT.py
@@ -1,3 +1,6 @@
+from dataclasses import dataclass
+from typing import Any, Optional, TypeAlias, Union
+
import requests
import json
import pandas as pd
@@ -6,7 +9,7 @@
import networkx as nx
import numpy as np
#import openai
-from . import name_resolver
+from . import name_resolver, node_normalizer, translator_query
# plt.switch_backend('module://ipykernel.pylab.backend_inline')
@@ -19,8 +22,13 @@
'get_SmartAPI_Translator_KP_info',
'list_Translator_APIs',
'load_translator_resources',
- 'Neighborhood_finder',
- 'Path_finder',
+ 'neighborhood_finder',
+ 'pathfinder',
+ 'get_translator_resources',
+ 'clear_translator_resource_cache',
+ 'FinderResult',
+ 'ResolvedNode',
+ 'TranslatorResources',
'format_query_json',
'select_API',
'select_concept',
@@ -1099,188 +1107,597 @@ def Neighborhood_finder_mcp(input_node, node2_categories):
return ranked_result
-def Neighborhood_finder(input_node, node2_categories, APInames, metaKG, API_predicates, input_node_category = []):
+# ---------------------------------------------------------------------------
+# Developer-friendly finder APIs (promoted from the former TCT.experimental
+# module). These wrappers resolve human-readable names, normalize CURIEs,
+# load Translator resources lazily, and return a small result object with the
+# most useful output fields surfaced directly. Import them from the
+# top-level package, e.g. ``from TCT import pathfinder, neighborhood_finder``.
+# ---------------------------------------------------------------------------
+
+NodeInput: TypeAlias = str
+CategoryInput: TypeAlias = str
+CategoryList: TypeAlias = list[CategoryInput]
+
+
+@dataclass(frozen=True)
+class ResolvedNode:
+ """Resolved node metadata used by the finder APIs."""
+
+ input_value: str
+ curie: str
+ label: Optional[str]
+ categories: list[str]
+
+
+@dataclass
+class TranslatorResources:
+ """Translator API metadata required by the finder query functions."""
+
+ api_names: dict[str, str]
+ meta_kg: pd.DataFrame
+ api_predicates: dict[str, list[str]]
+
+
+@dataclass
+class FinderResult:
+ """Convenience wrapper around a parsed TRAPI-style finder response."""
+
+ query: dict[str, Any]
+ knowledge_graph: dict[str, Any]
+ results: list[dict[str, Any]]
+ auxiliary_graphs: dict[str, Any]
+ resolved_nodes: dict[str, ResolvedNode]
+ raw: dict[str, Any]
+
+ def to_dict(self) -> dict[str, Any]:
+ """
+ Return the raw parsed TRAPI-style output dictionary.
+
+ Returns
+ -------
+ dict
+ Full parsed output generated by the existing finder parser.
+
+ Examples
+ --------
+ >>> result = FinderResult({}, {}, [], {}, {}, {})
+ >>> result.to_dict()
+ {}
+ """
+ return self.raw
+
+
+_DEFAULT_TRANSLATOR_RESOURCES: Optional[TranslatorResources] = None
+
+
+def get_translator_resources(*, refresh: bool = False) -> TranslatorResources:
"""
- This function is used to find the neighborhood of a given input node with intermediate categories.
+ Return cached Translator API metadata, loading it on first use.
- --------------
- Parameters:
- input_node (str): The input node - should be a CURIE id.
- node2_categories (list): A list of intermediate categories to be used in the neighborhood finding process.
- APInames (dict): A dictionary containing the names of the APIs to be used.
- metaKG (DataFrame): The metadata knowledge graph containing information about the APIs and their predicates.
- API_predicates (dict): A dictionary containing the predicates for each API.
- input_node_category (list): Optional. A list of categories for the input node. If empty, it will be derived from the input node's types.
+ Parameters
+ ----------
+ refresh : bool
+ If true, refetch SmartAPI/MetaKG data even when the singleton is
+ already populated.
- --------------
- Returns:
- input_node_id (str): The curie id of the input node.
- result (dict): The result of the query for the input node.
- result_parsed (DataFrame): The parsed results for the input node.
- result_ranked_by_primary_infores (DataFrame): The ranked results based on primary infores.
+ Returns
+ -------
+ TranslatorResources
+ API names, MetaKG dataframe, and API predicate mapping used by the
+ finder functions.
- --------------
- Example:
- >>> input_node_id, result, result_parsed, result_ranked_by_primary_infores1 = Neighborhood_finder('MONDO:0008170', #Ovarian Cancer
- node2_categories = ['biolink:SmallMolecule', 'biolink:Drug', 'biolink:ChemicalEntity'],
- APInames = APInames,
- metaKG = metaKG,
- API_predicates = API_predicates)
- --------------
+ Examples
+ --------
+ >>> resources = get_translator_resources()
+ >>> paths = pathfinder("asthma", "albuterol", ["Gene"], resources=resources)
+ """
+ global _DEFAULT_TRANSLATOR_RESOURCES
+ if refresh or _DEFAULT_TRANSLATOR_RESOURCES is None:
+ api_names, meta_kg, api_predicates = (
+ translator_query.get_translator_API_predicates()
+ )
+ _DEFAULT_TRANSLATOR_RESOURCES = TranslatorResources(
+ api_names=api_names,
+ meta_kg=meta_kg,
+ api_predicates=api_predicates,
+ )
+ return _DEFAULT_TRANSLATOR_RESOURCES
+
+
+def clear_translator_resource_cache() -> None:
+ """
+ Clear the in-memory Translator resource singleton.
+ Examples
+ --------
+ >>> clear_translator_resource_cache()
+ >>> resources = get_translator_resources() # refetches
"""
- from . import node_normalizer
- from . import translator_query
+ global _DEFAULT_TRANSLATOR_RESOURCES
+ _DEFAULT_TRANSLATOR_RESOURCES = None
+
+
+def pathfinder(
+ start: NodeInput,
+ end: NodeInput,
+ intermediate_categories: CategoryList,
+ *,
+ start_categories: Optional[CategoryList] = None,
+ end_categories: Optional[CategoryList] = None,
+ api_names: Optional[dict[str, str]] = None,
+ meta_kg: Optional[pd.DataFrame] = None,
+ api_predicates: Optional[dict[str, list[str]]] = None,
+ resources: Optional[TranslatorResources] = None,
+ scoring_method: str = "infores",
+ name_resolver_kwargs: Optional[dict[str, Any]] = None,
+ node_normalizer_kwargs: Optional[dict[str, Any]] = None,
+) -> FinderResult:
+ """
+ Find paths between two biomedical concepts using Translator KPs.
+
+ Parameters
+ ----------
+ start : str
+ Start node as either a CURIE (for example, ``"MONDO:0004979"``) or a
+ human-readable string (for example, ``"asthma"``).
+ end : str
+ End node as either a CURIE or human-readable string.
+ intermediate_categories : list[str]
+ Allowed categories for intermediate path nodes. Values may be short
+ names like ``"Gene"`` or full Biolink names like ``"biolink:Gene"``.
+ start_categories : list[str], optional
+ Category override for the start node. If omitted, categories are
+ inferred from Node Normalizer.
+ end_categories : list[str], optional
+ Category override for the end node. If omitted, categories are inferred
+ from Node Normalizer.
+ resources : TranslatorResources, optional
+ Preloaded Translator resources. If omitted, the module-level singleton
+ is loaded on first use and reused.
+ api_names, meta_kg, api_predicates : optional
+ Advanced partial overrides for the Translator resources used by the
+ pathfinder implementation.
+ scoring_method : str
+ Scoring method passed to the legacy parser. Current values are
+ ``"infores"`` and ``"edges"``.
+ name_resolver_kwargs : dict, optional
+ Extra keyword arguments for ``name_resolver.lookup``.
+ node_normalizer_kwargs : dict, optional
+ Extra keyword arguments for ``node_normalizer.get_normalized_nodes``.
+
+ Returns
+ -------
+ FinderResult
+ Convenience wrapper containing resolved input nodes, the parsed
+ knowledge graph, results, auxiliary graphs, and the raw TRAPI-style
+ output dictionary.
- input_node_id = input_node
- # Step 1: Resolve the input node to get its curie id and categories
- input_node_info = node_normalizer.get_normalized_nodes(input_node_id)
- print(input_node_id)
+ Examples
+ --------
+ >>> from TCT import pathfinder
+ >>> result = pathfinder("asthma", "albuterol", ["Gene"])
+ >>> result.resolved_nodes["start"].curie
+ 'MONDO:0004979'
+ """
+ from .TCT_pathfinder import parse_results_for_pathfinder
+
+ start_node = _resolve_node(
+ start,
+ name_resolver_kwargs=name_resolver_kwargs,
+ node_normalizer_kwargs=node_normalizer_kwargs,
+ )
+ end_node = _resolve_node(
+ end,
+ name_resolver_kwargs=name_resolver_kwargs,
+ node_normalizer_kwargs=node_normalizer_kwargs,
+ )
+ intermediate_categories = _normalize_categories(intermediate_categories) or []
+ start_categories = _normalize_categories(start_categories) or start_node.categories
+ end_categories = _normalize_categories(end_categories) or end_node.categories
+ resolved_resources = _get_resources(
+ resources=resources,
+ api_names=api_names,
+ meta_kg=meta_kg,
+ api_predicates=api_predicates,
+ )
+
+ predicates1, apis1, _ = sele_predicates_API(
+ start_categories,
+ intermediate_categories,
+ resolved_resources.meta_kg,
+ resolved_resources.api_names,
+ )
+ predicates2, apis2, _ = sele_predicates_API(
+ intermediate_categories,
+ end_categories,
+ resolved_resources.meta_kg,
+ resolved_resources.api_names,
+ )
+ query1 = translator_query.format_query_json(
+ [start_node.curie],
+ [],
+ start_categories,
+ intermediate_categories,
+ predicates1,
+ )
+ query2 = translator_query.format_query_json(
+ [],
+ [end_node.curie],
+ intermediate_categories,
+ end_categories,
+ predicates2,
+ )
+ result1 = translator_query.parallel_api_query(
+ query_json=query1,
+ select_APIs=apis1,
+ APInames=resolved_resources.api_names,
+ API_predicates=resolved_resources.api_predicates,
+ max_workers=max(1, len(apis1)),
+ )
+ result2 = translator_query.parallel_api_query(
+ query_json=query2,
+ select_APIs=apis2,
+ APInames=resolved_resources.api_names,
+ API_predicates=resolved_resources.api_predicates,
+ max_workers=max(1, len(apis2)),
+ )
+ raw_output = parse_results_for_pathfinder(
+ start_node.curie,
+ end_node.curie,
+ result1,
+ result2,
+ start_node_categories=start_categories,
+ end_node_categories=end_categories,
+ scoring_method=scoring_method,
+ get_node_info=True,
+ )
+ return _build_finder_result(
+ raw_output,
+ resolved_nodes={"start": start_node, "end": end_node},
+ )
+
+
+def neighborhood_finder(
+ node: Union[NodeInput, list[NodeInput]],
+ neighbor_categories: CategoryList,
+ *,
+ node_categories: Optional[CategoryList] = None,
+ api_names: Optional[dict[str, str]] = None,
+ meta_kg: Optional[pd.DataFrame] = None,
+ api_predicates: Optional[dict[str, list[str]]] = None,
+ resources: Optional[TranslatorResources] = None,
+ predicates_subset: Optional[list[str]] = None,
+ attribute_constraints: Optional[list[dict[str, Any]]] = None,
+ name_resolver_kwargs: Optional[dict[str, Any]] = None,
+ node_normalizer_kwargs: Optional[dict[str, Any]] = None,
+) -> FinderResult:
+ """
+ Find one-hop neighbors for one or more biomedical concepts.
+
+ Parameters
+ ----------
+ node : str or list[str]
+ Source node or nodes. Each value may be a CURIE or human-readable
+ string. Human-readable strings are resolved with Name Resolver and then
+ normalized with Node Normalizer.
+ neighbor_categories : list[str]
+ Desired neighbor categories. Values may be short names like ``"Drug"``
+ or full Biolink names like ``"biolink:Drug"``.
+ node_categories : list[str], optional
+ Category override for source nodes. If omitted, categories are inferred
+ from the first normalized source node.
+ resources : TranslatorResources, optional
+ Preloaded Translator resources. If omitted, the module-level singleton
+ is loaded on first use and reused.
+ api_names, meta_kg, api_predicates : optional
+ Advanced partial overrides for the Translator resources used by the
+ neighborhood implementation.
+ predicates_subset : list[str], optional
+ Optional predicate filter applied after MetaKG predicate selection.
+ attribute_constraints : list[dict], optional
+ TRAPI attribute constraints passed through to query construction.
+ name_resolver_kwargs : dict, optional
+ Extra keyword arguments for ``name_resolver.lookup``.
+ node_normalizer_kwargs : dict, optional
+ Extra keyword arguments for ``node_normalizer.get_normalized_nodes``.
+
+ Returns
+ -------
+ FinderResult
+ Convenience wrapper containing resolved input nodes, parsed neighborhood
+ knowledge graph, results, auxiliary graphs, and raw TRAPI-style output.
- if len(input_node_category) == 0:
- input_node_category = input_node_info.types
+ Examples
+ --------
+ >>> from TCT import neighborhood_finder
+ >>> result = neighborhood_finder("asthma", ["SmallMolecule", "Drug"])
+ >>> result.knowledge_graph["nodes"]
+ {...}
+ """
+ from .TCT_neighborhood_finder import (
+ parse_results_for_neighborhood_finder,
+ parse_results_for_neighborhood_finder_multiple_inputs,
+ )
+
+ resolved_nodes = _resolve_nodes(
+ node,
+ name_resolver_kwargs=name_resolver_kwargs,
+ node_normalizer_kwargs=node_normalizer_kwargs,
+ )
+ source_categories = (
+ _normalize_categories(node_categories) or resolved_nodes[0].categories
+ )
+ neighbor_categories = _normalize_categories(neighbor_categories) or []
+ resolved_resources = _get_resources(
+ resources=resources,
+ api_names=api_names,
+ meta_kg=meta_kg,
+ api_predicates=api_predicates,
+ )
+
+ predicates, apis, _ = sele_predicates_API(
+ source_categories,
+ neighbor_categories,
+ resolved_resources.meta_kg,
+ resolved_resources.api_names,
+ )
+ if predicates_subset is not None:
+ predicates = list(set(predicates).intersection(predicates_subset))
+ if len(predicates) == 0:
+ predicates = ["biolink:related_to"]
+
+ input_curies = [resolved_node.curie for resolved_node in resolved_nodes]
+ query = translator_query.format_query_json(
+ subject_ids=input_curies,
+ object_ids=None,
+ subject_categories=None,
+ object_categories=neighbor_categories,
+ predicates=predicates,
+ attribute_constraints=attribute_constraints,
+ )
+ raw_edges = translator_query.parallel_api_query(
+ query_json=query,
+ select_APIs=apis,
+ APInames=resolved_resources.api_names,
+ API_predicates=resolved_resources.api_predicates,
+ max_workers=max(1, len(apis)),
+ )
+ if isinstance(node, str):
+ raw_output = parse_results_for_neighborhood_finder(
+ input_curies[0],
+ raw_edges,
+ source_categories,
+ neighbor_categories,
+ )
+ result_nodes = {"node": resolved_nodes[0]}
else:
- input_node_category = list(set(input_node_category).intersection(set(input_node_info.types)))
- if len(input_node_category) == 0:
- input_node_category = input_node_info.types
+ raw_output = parse_results_for_neighborhood_finder_multiple_inputs(
+ input_curies,
+ raw_edges,
+ source_categories,
+ neighbor_categories,
+ )
+ result_nodes = {
+ f"node_{index}": resolved_node
+ for index, resolved_node in enumerate(resolved_nodes)
+ }
+ return _build_finder_result(raw_output, resolved_nodes=result_nodes)
- # Step 2: Select predicates and APIs based on the intermediate categories
- sele_predicates, sele_APIs, API_URLs = sele_predicates_API(input_node_category,
- node2_categories,
- metaKG, APInames)
- # Step 3: Format the query JSON for the input node
- query_json = format_query_json([input_node_id], [],
- [input_node_category],
- node2_categories,
- sele_predicates)
+def _normalize_category(category: str) -> str:
+ """
+ Convert a category into a Biolink-prefixed category string.
- # Step 4: Query the APIs in parallel
- result = translator_query.parallel_api_query(query_json=query_json,
- select_APIs= sele_APIs,
- APInames=APInames,
- API_predicates=API_predicates,
- max_workers=len(sele_APIs))
- result_parsed = parse_KG(result)
- # Step 7: Ranking the results. This ranking method is based on the number of unique
- # primary infores. It can only be used to rank the results with one defined node.
- result_ranked_by_primary_infores1 = rank_by_primary_infores(result_parsed, input_node_id) # input_node1_id is the curie id of the
- return input_node_id, result, result_parsed, result_ranked_by_primary_infores1
+ Parameters
+ ----------
+ category : str
+ Category name, with or without the ``biolink:`` prefix.
-def Path_finder(input_node1, input_node2, intermediate_categories, APInames, metaKG, API_predicates, input_node1_category = [], input_node2_category = []):
+ Returns
+ -------
+ str
+ Biolink-prefixed category.
+
+ Examples
+ --------
+ >>> _normalize_category("Gene")
+ 'biolink:Gene'
"""
- This function is used to find paths between two input nodes with intermediate categories.
+ category = category.strip()
+ if category.startswith("biolink:"):
+ return category
+ return f"biolink:{category}"
- --------------
- Parameters:
- input_node1 (str): The first input node - should be a CURIE id.
- input_node2 (str): The second input node - should be a CURIE id.
- intermediate_categories (list): A list of intermediate categories to be used in the path finding process.
- --------------
- Returns:
- paths (DataFrame): A DataFrame containing the paths found between the two input nodes.
- input_node1_id (str): The curie id of the first input node.
- input_node2_id (str): The curie id of the second input node.
- result1 (dict): The result of the query for the first input node.
- result2 (dict): The result of the query for the second input node.
- result_parsed1 (DataFrame): The parsed results for the first input node.
- result_parsed2 (DataFrame): The parsed results for the second input node.
- result_ranked_by_primary_infores1 (DataFrame): The ranked results for the first input node based on primary infores.
- result_ranked_by_primary_infores2 (DataFrame): The ranked results for the second
- --------------
- Example:
- >>> paths, input_node1_id, input_node2_id, result1, result2, result_parsed1, result_parsed2, result_ranked_by_primary_infores1, result_ranked_by_primary_infores2 = Path_finder('NCBIGene:7477', 'NCBIGene:4869', ['biolink:Gene', 'biolink:Protein']) # Input genes are WNT7B, NPM1
- --------------
+def _normalize_categories(categories: Optional[CategoryList]) -> Optional[list[str]]:
+ """
+ Normalize a list of category strings.
+ Parameters
+ ----------
+ categories : list[str], optional
+ Category names, with or without ``biolink:`` prefixes.
+
+ Returns
+ -------
+ list[str] or None
+ Normalized category names, or None when no categories were provided.
"""
- from . import node_normalizer
- from . import translator_query
- input_node1_id = input_node1
- input_node2_id = input_node2
- print(input_node1_id)
- normalized_node_dict = node_normalizer.get_normalized_nodes([input_node1_id, input_node2_id])
- input_node1_info = normalized_node_dict[input_node1]
- input_node1_list = [input_node1_id]
- if len(input_node1_category) == 0:
- input_node1_category = input_node1_info.types
- else:
- input_node1_category = list(set(input_node1_category).intersection(set(input_node1_info.types)))
- if len(input_node1_category) == 0:
- input_node1_category = input_node1_info.types
+ if categories is None:
+ return None
+ return [_normalize_category(category) for category in categories]
- input_node2_info = normalized_node_dict[input_node2_id]
- print(input_node2_id)
- input_node2_list = [input_node2_id]
- if len(input_node2_category) == 0:
- input_node2_category = input_node2_info.types
- else:
- input_node2_category = list(set(input_node2_category).intersection(set(input_node2_info.types)))
- if len(input_node2_category) == 0:
- input_node2_category = input_node2_info.types
+def _looks_like_curie(value: str) -> bool:
+ """
+ Return whether a string looks like a CURIE.
+ Parameters
+ ----------
+ value : str
+ Candidate node input.
- # Step 5: Select predicates and APIs based on the intermediate categories
- sele_predicates1, sele_APIs1, API_URLs1 = sele_predicates_API(input_node1_category,
- intermediate_categories,
- metaKG, APInames)
- sele_predicates2, sele_APIs2, API_URLs2 = sele_predicates_API(input_node2_category,
- intermediate_categories,
- metaKG, APInames)
+ Returns
+ -------
+ bool
+ True when the value appears to be a CURIE.
+ """
+ return ":" in value and " " not in value
- query_json1 = format_query_json(input_node1_list, # a list of identifiers for input node1
- [], # id list for the intermediate node, it can be empty list if only want to query node1
- input_node1_category, # a list of categories of input node1
- intermediate_categories, # a list of categories of the intermediate node
- sele_predicates1) # a list of predicates
- query_json2 = format_query_json(input_node2_list, # a list of identifiers for input node2
- [], # id list for the intermediate node, it can be empty list if only want to query node2
- input_node2_category, # a list of categories of input node2
- intermediate_categories, # a list of categories of the intermediate node
- sele_predicates2) # a list of predicates
+def _resolve_node(
+ value: str,
+ *,
+ name_resolver_kwargs: Optional[dict[str, Any]] = None,
+ node_normalizer_kwargs: Optional[dict[str, Any]] = None,
+) -> ResolvedNode:
+ """
+ Resolve a CURIE or display string into a normalized Translator node.
+
+ Parameters
+ ----------
+ value : str
+ CURIE or human-readable name.
+ name_resolver_kwargs : dict, optional
+ Additional keyword arguments for Name Resolver lookup.
+ node_normalizer_kwargs : dict, optional
+ Additional keyword arguments for Node Normalizer.
+
+ Returns
+ -------
+ ResolvedNode
+ Original input, preferred CURIE, label, and Biolink categories.
+
+ Raises
+ ------
+ LookupError
+ If the input cannot be resolved or normalized.
+ """
+ node_normalizer_kwargs = node_normalizer_kwargs or {}
+
+ if _looks_like_curie(value):
+ node = node_normalizer.get_normalized_nodes(value, **node_normalizer_kwargs)
+ if node is None:
+ raise LookupError(f"Could not normalize CURIE: {value}")
+ else:
+ resolved = name_resolver.lookup(
+ value,
+ return_top_response=True,
+ **(name_resolver_kwargs or {}),
+ )
+ node = (
+ node_normalizer.get_normalized_nodes(
+ resolved.curie,
+ **node_normalizer_kwargs,
+ )
+ or resolved
+ )
+
+ return ResolvedNode(
+ input_value=value,
+ curie=node.curie,
+ label=node.label,
+ categories=node.types or [],
+ )
+
+
+def _resolve_nodes(
+ values: Union[NodeInput, list[NodeInput]],
+ *,
+ name_resolver_kwargs: Optional[dict[str, Any]] = None,
+ node_normalizer_kwargs: Optional[dict[str, Any]] = None,
+) -> list[ResolvedNode]:
+ """
+ Resolve one or more node inputs.
+
+ Parameters
+ ----------
+ values : str or list[str]
+ CURIE or display-string node inputs.
+ name_resolver_kwargs : dict, optional
+ Additional keyword arguments for Name Resolver lookup.
+ node_normalizer_kwargs : dict, optional
+ Additional keyword arguments for Node Normalizer.
+
+ Returns
+ -------
+ list[ResolvedNode]
+ Resolved nodes in the same order as input.
+ """
+ if isinstance(values, str):
+ values = [values]
+ return [
+ _resolve_node(
+ value,
+ name_resolver_kwargs=name_resolver_kwargs,
+ node_normalizer_kwargs=node_normalizer_kwargs,
+ )
+ for value in values
+ ]
+
+
+def _get_resources(
+ *,
+ resources: Optional[TranslatorResources] = None,
+ api_names: Optional[dict[str, str]] = None,
+ meta_kg: Optional[pd.DataFrame] = None,
+ api_predicates: Optional[dict[str, list[str]]] = None,
+) -> TranslatorResources:
+ """
+ Merge explicit resource overrides with caller-provided or singleton resources.
+
+ Parameters
+ ----------
+ resources : TranslatorResources, optional
+ Complete resource object to use as the base.
+ api_names, meta_kg, api_predicates : optional
+ Partial overrides for the base resource object.
+
+ Returns
+ -------
+ TranslatorResources
+ Complete resource bundle for a query.
+ """
+ base = resources or get_translator_resources()
+ return TranslatorResources(
+ api_names=api_names if api_names is not None else base.api_names,
+ meta_kg=meta_kg if meta_kg is not None else base.meta_kg,
+ api_predicates=api_predicates
+ if api_predicates is not None
+ else base.api_predicates,
+ )
+
+
+def _build_finder_result(
+ raw_output: dict[str, Any],
+ *,
+ resolved_nodes: dict[str, ResolvedNode],
+) -> FinderResult:
+ """
+ Build a FinderResult from a parsed TRAPI-style output dictionary.
+
+ Parameters
+ ----------
+ raw_output : dict
+ Parsed output from an existing finder parser.
+ resolved_nodes : dict[str, ResolvedNode]
+ Resolved input-node metadata keyed by role.
+
+ Returns
+ -------
+ FinderResult
+ Convenience result wrapper.
+ """
+ return FinderResult(
+ query=raw_output.get("query_graph", {}),
+ knowledge_graph=raw_output.get("knowledge_graph", {}),
+ results=raw_output.get("results", []),
+ auxiliary_graphs=raw_output.get("auxiliary_graphs", {}),
+ resolved_nodes=resolved_nodes,
+ raw=raw_output,
+ )
- result1 = translator_query.parallel_api_query(query_json=query_json1,
- select_APIs = sele_APIs1,
- APInames=APInames,
- API_predicates=API_predicates,
- max_workers=len(sele_APIs1))
- result2 = translator_query.parallel_api_query(query_json=query_json2,
- select_APIs = sele_APIs2,
- APInames=APInames,
- API_predicates=API_predicates,
- max_workers=len(sele_APIs2))
-
- result_parsed1 = parse_KG(result1)
- # Step 7: Ranking the results. This ranking method is based on the number of unique
- # primary infores. It can only be used to rank the results with one defined node.
- result_ranked_by_primary_infores1 = rank_by_primary_infores(result_parsed1, input_node1_id) # input_node1_id is the curie id of the
-
- result_parsed2 = parse_KG(result2)
- result_ranked_by_primary_infores2 = rank_by_primary_infores(result_parsed2, input_node2_id) # input_node2_id is the curie id of the
-
- possible_paths = len(set(result_ranked_by_primary_infores1['output_node']).intersection(set(result_ranked_by_primary_infores2['output_node'])))
- print("Number of possible paths: ", possible_paths)
-
- paths = merge_ranking_by_number_of_infores(result_ranked_by_primary_infores1, result_ranked_by_primary_infores2,
- top_n = 30,
- fontsize=10,
- title_fontsize=12,)
- # return an boject containing the paths and the ranked results for both input nodes. The ranked results can be used for further analysis or visualization.
- result = {
- "paths": paths,
- "input_node1_id": input_node1_id,
- "input_node2_id": input_node2_id,
- "result1": result1,
- "result2": result2,
- "result_parsed1": result_parsed1,
- "result_parsed2": result_parsed2,
- "result_ranked_by_primary_infores1": result_ranked_by_primary_infores1,
- "result_ranked_by_primary_infores2": result_ranked_by_primary_infores2
- }
- #return paths, input_node1_id, input_node2_id, result1, result2, result_parsed1, result_parsed2, result_ranked_by_primary_infores1, result_ranked_by_primary_infores2
- return result
# used. Dec 5, 2023 (Example_query_one_hop_with_category.ipynb)
diff --git a/TCT/TCT_pathfinder.py b/TCT/TCT_pathfinder.py
index 1400aa5..67207c0 100644
--- a/TCT/TCT_pathfinder.py
+++ b/TCT/TCT_pathfinder.py
@@ -3,9 +3,6 @@
from collections import Counter
-from . import node_normalizer
-from . import translator_query
-from .TCT import sele_predicates_API
def format_query_json_for_pathfinder_with_constraints(subject_ids,
object_ids=None,
@@ -297,64 +294,6 @@ def parse_results_for_pathfinder(start_node_id:str, end_node_id:str, result1:dic
return output
-def pathfinder(input_node1_id:str, input_node2_id:str,
- intermediate_categories:list, APInames, metaKG, API_predicates,
- scoring_method='infores'):
- """
- Returns a Pathfinder output for the given pair of nodes. scoring_method could be 'infores' or 'edges'.
- """
- # get categories for input nodes
- normalized_node_dict = node_normalizer.get_normalized_nodes([input_node1_id, input_node2_id])
- input_node1_info = normalized_node_dict[input_node1_id]
- input_node1_list = [input_node1_id]
- input_node1_category = input_node1_info.types
-
- input_node2_info = normalized_node_dict[input_node2_id]
- print(input_node2_id)
- input_node2_list = [input_node2_id]
-
- input_node2_category = input_node2_info.types
-
- # Select predicates and APIs based on the intermediate categories
- sele_predicates1, sele_APIs1, API_URLs1 = sele_predicates_API(input_node1_category,
- intermediate_categories,
- metaKG, APInames)
- sele_predicates2, sele_APIs2, API_URLs2 = sele_predicates_API(intermediate_categories,
- input_node2_category,
- metaKG, APInames)
- query_json1 = translator_query.format_query_json(input_node1_list, # a list of identifiers for input node1
- [], # id list for the intermediate node, it can be empty list if only want to query node1
- input_node1_category, # a list of categories of input node1
- intermediate_categories, # a list of categories of the intermediate node
- sele_predicates1) # a list of predicates
-
- # for the second hop, we want the predicates to be...
- query_json2 = translator_query.format_query_json([],
- input_node2_list,
- intermediate_categories, # a list of categories of input node2
- input_node2_category, # a list of categories of the intermediate node
- sele_predicates2) # a list of predicates
-
- result1 = translator_query.parallel_api_query(query_json=query_json1,
- select_APIs = sele_APIs1,
- APInames=APInames,
- API_predicates=API_predicates,
- max_workers=len(sele_APIs1))
- result2 = translator_query.parallel_api_query(query_json=query_json2,
- select_APIs = sele_APIs2,
- APInames=APInames,
- API_predicates=API_predicates,
- max_workers=len(sele_APIs2))
- output = parse_results_for_pathfinder(input_node1_id, input_node2_id, result1, result2,
- start_node_categories=input_node1_category,
- end_node_categories=input_node2_category,
- scoring_method=scoring_method,
- get_node_info=True)
-
- return result1, result2, output
-
-
-
# define a function that uses the query_json as an template and change the ids and categories of the nodes
def format_pathfinder_query(node1_id, node1_category, node2_id, node2_category):
'''
diff --git a/TCT/experimental.py b/TCT/experimental.py
deleted file mode 100644
index 234c156..0000000
--- a/TCT/experimental.py
+++ /dev/null
@@ -1,598 +0,0 @@
-"""
-Experimental developer-friendly APIs for common Translator finder patterns.
-
-This module provides higher-level wrappers around the existing pathfinder and
-neighborhood finder code. The wrappers resolve human-readable names, normalize
-CURIEs, load Translator resources lazily, and return a small result object with
-the most useful output fields surfaced directly.
-"""
-
-from dataclasses import dataclass
-from typing import Any, Optional, TypeAlias, Union
-
-import pandas as pd
-
-from . import name_resolver, node_normalizer, translator_query
-from .TCT import sele_predicates_API
-from .TCT_neighborhood_finder import (
- parse_results_for_neighborhood_finder,
- parse_results_for_neighborhood_finder_multiple_inputs,
-)
-from .TCT_pathfinder import parse_results_for_pathfinder
-
-
-NodeInput: TypeAlias = str
-CategoryInput: TypeAlias = str
-CategoryList: TypeAlias = list[CategoryInput]
-
-
-@dataclass(frozen=True)
-class ResolvedNode:
- """Resolved node metadata used by the experimental finder APIs."""
-
- input_value: str
- curie: str
- label: Optional[str]
- categories: list[str]
-
-
-@dataclass
-class TranslatorResources:
- """Translator API metadata required by the legacy query functions."""
-
- api_names: dict[str, str]
- meta_kg: pd.DataFrame
- api_predicates: dict[str, list[str]]
-
-
-@dataclass
-class FinderResult:
- """Convenience wrapper around a parsed TRAPI-style finder response."""
-
- query: dict[str, Any]
- knowledge_graph: dict[str, Any]
- results: list[dict[str, Any]]
- auxiliary_graphs: dict[str, Any]
- resolved_nodes: dict[str, ResolvedNode]
- raw: dict[str, Any]
-
- def to_dict(self) -> dict[str, Any]:
- """
- Return the raw parsed TRAPI-style output dictionary.
-
- Returns
- -------
- dict
- Full parsed output generated by the existing finder parser.
-
- Examples
- --------
- >>> result = FinderResult({}, {}, [], {}, {}, {})
- >>> result.to_dict()
- {}
- """
- return self.raw
-
-
-_DEFAULT_TRANSLATOR_RESOURCES: Optional[TranslatorResources] = None
-
-
-def get_translator_resources(*, refresh: bool = False) -> TranslatorResources:
- """
- Return cached Translator API metadata, loading it on first use.
-
- Parameters
- ----------
- refresh : bool
- If true, refetch SmartAPI/MetaKG data even when the singleton is
- already populated.
-
- Returns
- -------
- TranslatorResources
- API names, MetaKG dataframe, and API predicate mapping used by the
- legacy query functions.
-
- Examples
- --------
- >>> resources = get_translator_resources()
- >>> paths = pathfinder("asthma", "albuterol", ["Gene"], resources=resources)
- """
- global _DEFAULT_TRANSLATOR_RESOURCES
- if refresh or _DEFAULT_TRANSLATOR_RESOURCES is None:
- api_names, meta_kg, api_predicates = (
- translator_query.get_translator_API_predicates()
- )
- _DEFAULT_TRANSLATOR_RESOURCES = TranslatorResources(
- api_names=api_names,
- meta_kg=meta_kg,
- api_predicates=api_predicates,
- )
- return _DEFAULT_TRANSLATOR_RESOURCES
-
-
-def clear_translator_resource_cache() -> None:
- """
- Clear the in-memory Translator resource singleton.
-
- Examples
- --------
- >>> clear_translator_resource_cache()
- >>> resources = get_translator_resources() # refetches
- """
- global _DEFAULT_TRANSLATOR_RESOURCES
- _DEFAULT_TRANSLATOR_RESOURCES = None
-
-
-def pathfinder(
- start: NodeInput,
- end: NodeInput,
- intermediate_categories: CategoryList,
- *,
- start_categories: Optional[CategoryList] = None,
- end_categories: Optional[CategoryList] = None,
- api_names: Optional[dict[str, str]] = None,
- meta_kg: Optional[pd.DataFrame] = None,
- api_predicates: Optional[dict[str, list[str]]] = None,
- resources: Optional[TranslatorResources] = None,
- scoring_method: str = "infores",
- name_resolver_kwargs: Optional[dict[str, Any]] = None,
- node_normalizer_kwargs: Optional[dict[str, Any]] = None,
-) -> FinderResult:
- """
- Find paths between two biomedical concepts using Translator KPs.
-
- Parameters
- ----------
- start : str
- Start node as either a CURIE (for example, ``"MONDO:0004979"``) or a
- human-readable string (for example, ``"asthma"``).
- end : str
- End node as either a CURIE or human-readable string.
- intermediate_categories : list[str]
- Allowed categories for intermediate path nodes. Values may be short
- names like ``"Gene"`` or full Biolink names like ``"biolink:Gene"``.
- start_categories : list[str], optional
- Category override for the start node. If omitted, categories are
- inferred from Node Normalizer.
- end_categories : list[str], optional
- Category override for the end node. If omitted, categories are inferred
- from Node Normalizer.
- resources : TranslatorResources, optional
- Preloaded Translator resources. If omitted, the module-level singleton
- is loaded on first use and reused.
- api_names, meta_kg, api_predicates : optional
- Advanced partial overrides for the Translator resources used by the
- legacy pathfinder implementation.
- scoring_method : str
- Scoring method passed to the legacy parser. Current values are
- ``"infores"`` and ``"edges"``.
- name_resolver_kwargs : dict, optional
- Extra keyword arguments for ``name_resolver.lookup``.
- node_normalizer_kwargs : dict, optional
- Extra keyword arguments for ``node_normalizer.get_normalized_nodes``.
-
- Returns
- -------
- FinderResult
- Convenience wrapper containing resolved input nodes, the parsed
- knowledge graph, results, auxiliary graphs, and the raw TRAPI-style
- output dictionary.
-
- Examples
- --------
- >>> from TCT.experimental import pathfinder
- >>> result = pathfinder("asthma", "albuterol", ["Gene"])
- >>> result.resolved_nodes["start"].curie
- 'MONDO:0004979'
- """
- start_node = _resolve_node(
- start,
- name_resolver_kwargs=name_resolver_kwargs,
- node_normalizer_kwargs=node_normalizer_kwargs,
- )
- end_node = _resolve_node(
- end,
- name_resolver_kwargs=name_resolver_kwargs,
- node_normalizer_kwargs=node_normalizer_kwargs,
- )
- intermediate_categories = _normalize_categories(intermediate_categories) or []
- start_categories = _normalize_categories(start_categories) or start_node.categories
- end_categories = _normalize_categories(end_categories) or end_node.categories
- resolved_resources = _get_resources(
- resources=resources,
- api_names=api_names,
- meta_kg=meta_kg,
- api_predicates=api_predicates,
- )
-
- predicates1, apis1, _ = sele_predicates_API(
- start_categories,
- intermediate_categories,
- resolved_resources.meta_kg,
- resolved_resources.api_names,
- )
- predicates2, apis2, _ = sele_predicates_API(
- intermediate_categories,
- end_categories,
- resolved_resources.meta_kg,
- resolved_resources.api_names,
- )
- query1 = translator_query.format_query_json(
- [start_node.curie],
- [],
- start_categories,
- intermediate_categories,
- predicates1,
- )
- query2 = translator_query.format_query_json(
- [],
- [end_node.curie],
- intermediate_categories,
- end_categories,
- predicates2,
- )
- result1 = translator_query.parallel_api_query(
- query_json=query1,
- select_APIs=apis1,
- APInames=resolved_resources.api_names,
- API_predicates=resolved_resources.api_predicates,
- max_workers=max(1, len(apis1)),
- )
- result2 = translator_query.parallel_api_query(
- query_json=query2,
- select_APIs=apis2,
- APInames=resolved_resources.api_names,
- API_predicates=resolved_resources.api_predicates,
- max_workers=max(1, len(apis2)),
- )
- raw_output = parse_results_for_pathfinder(
- start_node.curie,
- end_node.curie,
- result1,
- result2,
- start_node_categories=start_categories,
- end_node_categories=end_categories,
- scoring_method=scoring_method,
- get_node_info=True,
- )
- return _build_finder_result(
- raw_output,
- resolved_nodes={"start": start_node, "end": end_node},
- )
-
-
-def neighborhood_finder(
- node: Union[NodeInput, list[NodeInput]],
- neighbor_categories: CategoryList,
- *,
- node_categories: Optional[CategoryList] = None,
- api_names: Optional[dict[str, str]] = None,
- meta_kg: Optional[pd.DataFrame] = None,
- api_predicates: Optional[dict[str, list[str]]] = None,
- resources: Optional[TranslatorResources] = None,
- predicates_subset: Optional[list[str]] = None,
- attribute_constraints: Optional[list[dict[str, Any]]] = None,
- name_resolver_kwargs: Optional[dict[str, Any]] = None,
- node_normalizer_kwargs: Optional[dict[str, Any]] = None,
-) -> FinderResult:
- """
- Find one-hop neighbors for one or more biomedical concepts.
-
- Parameters
- ----------
- node : str or list[str]
- Source node or nodes. Each value may be a CURIE or human-readable
- string. Human-readable strings are resolved with Name Resolver and then
- normalized with Node Normalizer.
- neighbor_categories : list[str]
- Desired neighbor categories. Values may be short names like ``"Drug"``
- or full Biolink names like ``"biolink:Drug"``.
- node_categories : list[str], optional
- Category override for source nodes. If omitted, categories are inferred
- from the first normalized source node.
- resources : TranslatorResources, optional
- Preloaded Translator resources. If omitted, the module-level singleton
- is loaded on first use and reused.
- api_names, meta_kg, api_predicates : optional
- Advanced partial overrides for the Translator resources used by the
- legacy neighborhood implementation.
- predicates_subset : list[str], optional
- Optional predicate filter applied after MetaKG predicate selection.
- attribute_constraints : list[dict], optional
- TRAPI attribute constraints passed through to query construction.
- name_resolver_kwargs : dict, optional
- Extra keyword arguments for ``name_resolver.lookup``.
- node_normalizer_kwargs : dict, optional
- Extra keyword arguments for ``node_normalizer.get_normalized_nodes``.
-
- Returns
- -------
- FinderResult
- Convenience wrapper containing resolved input nodes, parsed neighborhood
- knowledge graph, results, auxiliary graphs, and raw TRAPI-style output.
-
- Examples
- --------
- >>> from TCT.experimental import neighborhood_finder
- >>> result = neighborhood_finder("asthma", ["SmallMolecule", "Drug"])
- >>> result.knowledge_graph["nodes"]
- {...}
- """
- resolved_nodes = _resolve_nodes(
- node,
- name_resolver_kwargs=name_resolver_kwargs,
- node_normalizer_kwargs=node_normalizer_kwargs,
- )
- source_categories = (
- _normalize_categories(node_categories) or resolved_nodes[0].categories
- )
- neighbor_categories = _normalize_categories(neighbor_categories) or []
- resolved_resources = _get_resources(
- resources=resources,
- api_names=api_names,
- meta_kg=meta_kg,
- api_predicates=api_predicates,
- )
-
- predicates, apis, _ = sele_predicates_API(
- source_categories,
- neighbor_categories,
- resolved_resources.meta_kg,
- resolved_resources.api_names,
- )
- if predicates_subset is not None:
- predicates = list(set(predicates).intersection(predicates_subset))
- if len(predicates) == 0:
- predicates = ["biolink:related_to"]
-
- input_curies = [resolved_node.curie for resolved_node in resolved_nodes]
- query = translator_query.format_query_json(
- subject_ids=input_curies,
- object_ids=None,
- subject_categories=None,
- object_categories=neighbor_categories,
- predicates=predicates,
- attribute_constraints=attribute_constraints,
- )
- raw_edges = translator_query.parallel_api_query(
- query_json=query,
- select_APIs=apis,
- APInames=resolved_resources.api_names,
- API_predicates=resolved_resources.api_predicates,
- max_workers=max(1, len(apis)),
- )
- if isinstance(node, str):
- raw_output = parse_results_for_neighborhood_finder(
- input_curies[0],
- raw_edges,
- source_categories,
- neighbor_categories,
- )
- result_nodes = {"node": resolved_nodes[0]}
- else:
- raw_output = parse_results_for_neighborhood_finder_multiple_inputs(
- input_curies,
- raw_edges,
- source_categories,
- neighbor_categories,
- )
- result_nodes = {
- f"node_{index}": resolved_node
- for index, resolved_node in enumerate(resolved_nodes)
- }
- return _build_finder_result(raw_output, resolved_nodes=result_nodes)
-
-
-def _normalize_category(category: str) -> str:
- """
- Convert a category into a Biolink-prefixed category string.
-
- Parameters
- ----------
- category : str
- Category name, with or without the ``biolink:`` prefix.
-
- Returns
- -------
- str
- Biolink-prefixed category.
-
- Examples
- --------
- >>> _normalize_category("Gene")
- 'biolink:Gene'
- """
- category = category.strip()
- if category.startswith("biolink:"):
- return category
- return f"biolink:{category}"
-
-
-def _normalize_categories(categories: Optional[CategoryList]) -> Optional[list[str]]:
- """
- Normalize a list of category strings.
-
- Parameters
- ----------
- categories : list[str], optional
- Category names, with or without ``biolink:`` prefixes.
-
- Returns
- -------
- list[str] or None
- Normalized category names, or None when no categories were provided.
- """
- if categories is None:
- return None
- return [_normalize_category(category) for category in categories]
-
-
-def _looks_like_curie(value: str) -> bool:
- """
- Return whether a string looks like a CURIE.
-
- Parameters
- ----------
- value : str
- Candidate node input.
-
- Returns
- -------
- bool
- True when the value appears to be a CURIE.
- """
- return ":" in value and " " not in value
-
-
-def _resolve_node(
- value: str,
- *,
- name_resolver_kwargs: Optional[dict[str, Any]] = None,
- node_normalizer_kwargs: Optional[dict[str, Any]] = None,
-) -> ResolvedNode:
- """
- Resolve a CURIE or display string into a normalized Translator node.
-
- Parameters
- ----------
- value : str
- CURIE or human-readable name.
- name_resolver_kwargs : dict, optional
- Additional keyword arguments for Name Resolver lookup.
- node_normalizer_kwargs : dict, optional
- Additional keyword arguments for Node Normalizer.
-
- Returns
- -------
- ResolvedNode
- Original input, preferred CURIE, label, and Biolink categories.
-
- Raises
- ------
- LookupError
- If the input cannot be resolved or normalized.
- """
- node_normalizer_kwargs = node_normalizer_kwargs or {}
-
- if _looks_like_curie(value):
- node = node_normalizer.get_normalized_nodes(value, **node_normalizer_kwargs)
- if node is None:
- raise LookupError(f"Could not normalize CURIE: {value}")
- else:
- resolved = name_resolver.lookup(
- value,
- return_top_response=True,
- **(name_resolver_kwargs or {}),
- )
- node = (
- node_normalizer.get_normalized_nodes(
- resolved.curie,
- **node_normalizer_kwargs,
- )
- or resolved
- )
-
- return ResolvedNode(
- input_value=value,
- curie=node.curie,
- label=node.label,
- categories=node.types or [],
- )
-
-
-def _resolve_nodes(
- values: Union[NodeInput, list[NodeInput]],
- *,
- name_resolver_kwargs: Optional[dict[str, Any]] = None,
- node_normalizer_kwargs: Optional[dict[str, Any]] = None,
-) -> list[ResolvedNode]:
- """
- Resolve one or more node inputs.
-
- Parameters
- ----------
- values : str or list[str]
- CURIE or display-string node inputs.
- name_resolver_kwargs : dict, optional
- Additional keyword arguments for Name Resolver lookup.
- node_normalizer_kwargs : dict, optional
- Additional keyword arguments for Node Normalizer.
-
- Returns
- -------
- list[ResolvedNode]
- Resolved nodes in the same order as input.
- """
- if isinstance(values, str):
- values = [values]
- return [
- _resolve_node(
- value,
- name_resolver_kwargs=name_resolver_kwargs,
- node_normalizer_kwargs=node_normalizer_kwargs,
- )
- for value in values
- ]
-
-
-def _get_resources(
- *,
- resources: Optional[TranslatorResources] = None,
- api_names: Optional[dict[str, str]] = None,
- meta_kg: Optional[pd.DataFrame] = None,
- api_predicates: Optional[dict[str, list[str]]] = None,
-) -> TranslatorResources:
- """
- Merge explicit resource overrides with caller-provided or singleton resources.
-
- Parameters
- ----------
- resources : TranslatorResources, optional
- Complete resource object to use as the base.
- api_names, meta_kg, api_predicates : optional
- Partial overrides for the base resource object.
-
- Returns
- -------
- TranslatorResources
- Complete resource bundle for a query.
- """
- base = resources or get_translator_resources()
- return TranslatorResources(
- api_names=api_names if api_names is not None else base.api_names,
- meta_kg=meta_kg if meta_kg is not None else base.meta_kg,
- api_predicates=api_predicates
- if api_predicates is not None
- else base.api_predicates,
- )
-
-
-def _build_finder_result(
- raw_output: dict[str, Any],
- *,
- resolved_nodes: dict[str, ResolvedNode],
-) -> FinderResult:
- """
- Build a FinderResult from a parsed TRAPI-style output dictionary.
-
- Parameters
- ----------
- raw_output : dict
- Parsed output from an existing finder parser.
- resolved_nodes : dict[str, ResolvedNode]
- Resolved input-node metadata keyed by role.
-
- Returns
- -------
- FinderResult
- Convenience result wrapper.
- """
- return FinderResult(
- query=raw_output.get("query_graph", {}),
- knowledge_graph=raw_output.get("knowledge_graph", {}),
- results=raw_output.get("results", []),
- auxiliary_graphs=raw_output.get("auxiliary_graphs", {}),
- resolved_nodes=resolved_nodes,
- raw=raw_output,
- )
diff --git a/docs/source/_static/.gitkeep b/docs/source/_static/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/docs/source/intro.md b/docs/source/intro.md
index 52954d3..0f98471 100644
--- a/docs/source/intro.md
+++ b/docs/source/intro.md
@@ -10,6 +10,7 @@ Parallel and fast querying of the selected APIs.
Providing reproducible results by setting constraints.
Allowing testing whether a user defined API follows a [TRAPI](https://github.com/NCATSTranslator/ReasonerAPI) standard or not.
Faciliting to explore knowledge graphs from both Translator ecosystem and user defined APIs.
+Developer-friendly `pathfinder` and `neighborhood_finder` wrappers for resolving labels/CURIEs, caching Translator resources, and returning parsed finder results (`from TCT import pathfinder, neighborhood_finder`).
Connecting large language models to convert user's questions into TRAPI queries.
### Contributing
diff --git a/notebooks/Connecting_userAPI.ipynb b/notebooks/Connecting_userAPI.ipynb
index 7c36727..1d71324 100644
--- a/notebooks/Connecting_userAPI.ipynb
+++ b/notebooks/Connecting_userAPI.ipynb
@@ -13,6 +13,7 @@
"from TCT import translator_kpinfo\n",
"from TCT import TCT\n",
"from TCT import TCT_pathfinder\n",
+ "from TCT import pathfinder\n",
"from TCT import TCT_neighborhood_finder\n",
"\n",
"import matplotlib.pyplot as plt\n",
@@ -692,70 +693,29 @@
},
{
"cell_type": "code",
- "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "NCBIGene:596\n",
- "MONDO:0018874\n",
- "CATRAX Pharmacogenomics KP - TRAPI 1.5.0: Success!\n",
- "CATRAX BigGIM DrugResponse Performance Phase KP - TRAPI 1.5.0: Success!\n",
- "RTX KG2 - TRAPI 1.5.0: Success!\n",
- "Genetics Data Provider for NCATS Biomedical Translator Reasoners: Success!\n",
- "Drug Approvals KP - TRAPI 1.5.0: Success!\n",
- "CATRAX Pharmacogenomics KP - TRAPI 1.5.0: Success!\n",
- "RTX KG2 - TRAPI 1.5.0: Success!CATRAX BigGIM DrugResponse Performance Phase KP - TRAPI 1.5.0: Success!\n",
- "\n",
- "Clinical Trials KP - TRAPI 1.5.0: Success!\n",
- "NodeNorm does not know about these identifiers: DRUGBANK:DB15060,ttd.target:Indole-based_analog_3,ttd.target:Indole-based_analog_2,ttd.target:PMID27744724-Compound-18,ttd.target:BCL201,ttd.target:Oral_paclitaxel,ttd.target:PMID27744724-Compound-10,ttd.target:PMID27744724-Compound-21,ttd.target:Pc4_(topical_formulation,ttd.target:Liposomal_encapsulated_paclitaxel_(LEP),ttd.target:Irofulven/Taxotere,ttd.target:PI-88/Taxotere,ttd.target:Taxol/Paraplatin/Herceptin,orphanet:119007\n",
- "NodeNorm does not know about these identifiers: DRUGBANK:DB15060,REACT:R-ALL-9692345,CHEBI:233318,UMLS:C5908001,GTOPDB:13607,UMLS:C5907931,UMLS:C5888788,CHEBI:233593,UMLS:C5979854,UMLS:C5907992,CHEBI:232584,CHEBI:232328,CHEBI:233359\n",
- "Number of possible paths: 129\n",
- "NodeNorm does not know about these identifiers: DRUGBANK:DB15060\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/Users/gqin/Github_repo/Translator_component_toolkit/TCT/TCT.py:1653: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n",
- " ax.set_xticklabels(ax.get_xticklabels(), rotation=90, ha=\"center\", fontsize=fontsize)\n"
- ]
- },
- {
- "data": {
- "image/png": "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",
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
+ "execution_count": null,
+ "outputs": [],
"source": [
"# test pathfinder by adding a new API to the metaKG\n",
- "result = TCT.Path_finder(input_node1=subject_node, #IFNG \n",
- " input_node2= object_node, #COVID-19\n",
- " intermediate_categories=intermediate_categories, \n",
- " APInames=select_APIs, \n",
- " metaKG=selected_metaKG, \n",
- " API_predicates=API_predicates)"
+ "result = pathfinder(start=subject_node, # e.g. IFNG\n",
+ " end=object_node, # e.g. disease node\n",
+ " intermediate_categories=intermediate_categories,\n",
+ " api_names=select_APIs,\n",
+ " meta_kg=selected_metaKG,\n",
+ " api_predicates=API_predicates)\n"
]
},
{
"cell_type": "code",
- "execution_count": 40,
"metadata": {},
+ "execution_count": null,
"outputs": [],
"source": [
- "TCT_path_finder_result = TCT_pathfinder.parse_results_for_pathfinder(subject_node, object_node, result1=result['result1'], result2=result['result2'])\n",
- "# return results path_finder_result to a json file\n",
+ "# pathfinder already returns parsed results inside a FinderResult\n",
"import json\n",
"with open(f'TCT_path_finder_result__{subject_node.replace(\":\", \"_\")}__{object_node.replace(\":\", \"_\")}.json', 'w') as f:\n",
- " json.dump(TCT_path_finder_result, f, indent=4)"
+ " json.dump(result.to_dict(), f, indent=4)\n"
]
},
{
diff --git a/notebooks/Experimental_API_tutorial.ipynb b/notebooks/Experimental_API_tutorial.ipynb
deleted file mode 100644
index 80884a6..0000000
--- a/notebooks/Experimental_API_tutorial.ipynb
+++ /dev/null
@@ -1,278 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Experimental Finder API\n",
- "\n",
- "This notebook introduces the developer-friendly experimental API in `TCT.experimental`. The functions wrap common Translator query boilerplate so you can start with labels like `\"asthma\"` or CURIEs like `\"MONDO:0004979\"`.\n",
- "\n",
- "The API is experimental: import from `TCT.experimental`, pin behavior in your own notebooks or applications, and expect the interface to evolve as it graduates into the stable package surface.\n",
- "\n",
- "Use this notebook when you want a concise pathfinder or neighborhood-finder workflow. If you need fine-grained endpoint selection, custom TRAPI query construction, manual parser workflows, or visualization setup, see the legacy notebooks linked from the README."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "from TCT.experimental import (\n",
- " clear_translator_resource_cache,\n",
- " get_translator_resources,\n",
- " neighborhood_finder,\n",
- " pathfinder,\n",
- ")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## What the wrapper handles\n",
- "\n",
- "The experimental API combines several lower-level TCT steps:\n",
- "\n",
- "- Resolve names with Name Resolver when inputs are labels.\n",
- "- Normalize CURIEs and labels with Node Normalizer.\n",
- "- Load and cache Translator API metadata.\n",
- "- Select compatible predicates and APIs from the MetaKG.\n",
- "- Query selected Translator KPs in parallel.\n",
- "- Return a `FinderResult` object with parsed graph sections surfaced directly.\n",
- "\n",
- "Live result counts vary with Translator metadata and KP availability, so examples below focus on reusable code patterns and result shape."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Resource Cache\n",
- "\n",
- "Translator API metadata is expensive to fetch. The experimental API loads it lazily on the first query and reuses it for later calls in the same Python process.\n",
- "\n",
- "Use `get_translator_resources()` when you want to preload metadata once, pass it to multiple calls, or make caching explicit in a notebook. Use `clear_translator_resource_cache()` when you want the next call to refetch metadata."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "resources = get_translator_resources()\n",
- "\n",
- "{\n",
- " \"api_count\": len(resources.api_names),\n",
- " \"meta_kg_shape\": resources.meta_kg.shape,\n",
- " \"predicate_api_count\": len(resources.api_predicates),\n",
- "}"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Pathfinder Quick Start\n",
- "\n",
- "`pathfinder(start, end, intermediate_categories)` searches for two-hop paths between two concepts.\n",
- "\n",
- "Inputs:\n",
- "\n",
- "- `start`: start concept as a display string or CURIE.\n",
- "- `end`: end concept as a display string or CURIE.\n",
- "- `intermediate_categories`: allowed categories for the connecting node. Short names such as `\"Gene\"` are automatically converted to `\"biolink:Gene\"`.\n",
- "\n",
- "The return value is a `FinderResult` with `.knowledge_graph`, `.results`, `.auxiliary_graphs`, `.resolved_nodes`, `.raw`, and `.to_dict()`."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "paths = pathfinder(\n",
- " start=\"asthma\",\n",
- " end=\"albuterol\",\n",
- " intermediate_categories=[\"Gene\", \"Protein\"],\n",
- " resources=resources,\n",
- ")\n",
- "paths.resolved_nodes"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "{\n",
- " \"node_count\": len(paths.knowledge_graph.get(\"nodes\", {})),\n",
- " \"edge_count\": len(paths.knowledge_graph.get(\"edges\", {})),\n",
- " \"result_count\": len(paths.results),\n",
- " \"raw_sections\": list(paths.to_dict().keys()),\n",
- "}"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Neighborhood Finder Quick Start\n",
- "\n",
- "`neighborhood_finder(node, neighbor_categories)` searches for one-hop neighbors of a concept. `node` can be a single string/CURIE or a list of strings/CURIEs.\n",
- "\n",
- "The optional `node_categories` argument lets you provide the source category directly when you know it. Short category names like `\"Disease\"` are converted to Biolink categories."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "neighbors = neighborhood_finder(\n",
- " node=\"MONDO:0004979\",\n",
- " neighbor_categories=[\"SmallMolecule\", \"Drug\"],\n",
- " node_categories=[\"Disease\"],\n",
- " resources=resources,\n",
- ")\n",
- "neighbors.resolved_nodes"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "{\n",
- " \"node_count\": len(neighbors.knowledge_graph.get(\"nodes\", {})),\n",
- " \"edge_count\": len(neighbors.knowledge_graph.get(\"edges\", {})),\n",
- " \"result_count\": len(neighbors.results),\n",
- " \"raw_sections\": list(neighbors.to_dict().keys()),\n",
- "}"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Multiple Input Neighborhood Queries\n",
- "\n",
- "Pass a list of labels or CURIEs to query neighborhoods for multiple source nodes with the same neighbor categories."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "multi_neighbors = neighborhood_finder(\n",
- " node=[\"asthma\", \"MONDO:0004979\"],\n",
- " neighbor_categories=[\"Gene\"],\n",
- " resources=resources,\n",
- ")\n",
- "multi_neighbors.resolved_nodes"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## CURIE Inputs\n",
- "\n",
- "When an input contains `:` and no spaces, the experimental API treats it as a CURIE and skips Name Resolver. It still uses Node Normalizer to get the preferred identifier, label, and categories. This makes CURIE examples more reproducible when Name Resolver rankings change."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "curie_neighbors = neighborhood_finder(\n",
- " node=\"MONDO:0004979\",\n",
- " neighbor_categories=[\"Gene\"],\n",
- " node_categories=[\"Disease\"],\n",
- " resources=resources,\n",
- ")\n",
- "curie_neighbors.resolved_nodes[\"node\"]"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Advanced Controls\n",
- "\n",
- "The wrapper still exposes useful controls for common tuning:\n",
- "\n",
- "- `start_categories`, `end_categories`, and `node_categories` override inferred categories.\n",
- "- `predicates_subset` narrows neighborhood predicates after MetaKG selection.\n",
- "- `attribute_constraints` passes TRAPI attribute constraints into the query edge.\n",
- "- `resources` lets you reuse metadata or pass a filtered `TranslatorResources` object.\n",
- "\n",
- "For lower-level control over endpoint lists, predicate dictionaries, query JSON, and result parsing, use the detailed PathFinder, NeighborhoodFinder, NetworkFinder, KG overview, and visualization notebooks."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "constrained_neighbors = neighborhood_finder(\n",
- " node=\"asthma\",\n",
- " neighbor_categories=[\"SmallMolecule\"],\n",
- " node_categories=[\"Disease\"],\n",
- " predicates_subset=[\"biolink:treats\", \"biolink:ameliorates\"],\n",
- " attribute_constraints=[\n",
- " {\n",
- " \"id\": \"biolink:knowledge_level\",\n",
- " \"operator\": \"==\",\n",
- " \"value\": \"knowledge_assertion\",\n",
- " }\n",
- " ],\n",
- " resources=resources,\n",
- ")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Refreshing Metadata\n",
- "\n",
- "Use `refresh=True` to refetch metadata, or clear the cache before the next query."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "fresh_resources = get_translator_resources(refresh=True)\n",
- "clear_translator_resource_cache()"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "name": "python",
- "pygments_lexer": "ipython3"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/notebooks/Neighborhood_finder.ipynb b/notebooks/Neighborhood_finder.ipynb
index a3f3810..2a3aee8 100644
--- a/notebooks/Neighborhood_finder.ipynb
+++ b/notebooks/Neighborhood_finder.ipynb
@@ -7,6 +7,165 @@
"## This notebook can be used to rank a list of nodes from a category that connect to an entity such as a gene. "
]
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Quick start: `neighborhood_finder` API\n",
+ "\n",
+ "TCT now provides a developer-friendly `neighborhood_finder` wrapper as part of the main API. It accepts labels or CURIEs (single or list), resolves and normalizes inputs, caches Translator resources, and returns a `FinderResult`. Short category names like `\"Disease\"` are converted to `\"biolink:Disease\"` automatically. Advanced controls: `node_categories`, `predicates_subset`, `attribute_constraints`, `resources`.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-08-06T20:26:55.592995Z",
+ "iopub.status.busy": "2026-08-06T20:26:55.592823Z",
+ "iopub.status.idle": "2026-08-06T20:28:36.877822Z",
+ "shell.execute_reply": "2026-08-06T20:28:36.877572Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Skipping server without x-maturity: {'url': '/sipr'}\n",
+ "Skipping server without x-maturity: {'description': 'Local dev', 'url': 'http://127.0.0.1:5001'}\n",
+ "59\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(18613, 5)\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(30174, 5)\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Automat-monarchinitiative(Trapi v1.5.0): Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "COHD TRAPI: Success!\n",
+ "RTX KG2 - TRAPI 1.5.0: Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Automat-icees-kg(Trapi v1.5.0): Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Retriever: Success!\n",
+ "Automat-robokop(Trapi v1.5.0): Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "MolePro: Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Service Provider TRAPI: Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "BioThings Explorer (BTE) TRAPI: Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ARAX Translator Reasoner - TRAPI 1.6.0: Success!\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{'node_count': 3986, 'edge_count': 13160, 'result_count': 1}"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from TCT import get_translator_resources, neighborhood_finder\n",
+ "\n",
+ "resources = get_translator_resources()\n",
+ "neighbors = neighborhood_finder(\n",
+ " node=\"MONDO:0004979\",\n",
+ " neighbor_categories=[\"SmallMolecule\", \"Drug\"],\n",
+ " node_categories=[\"Disease\"],\n",
+ " resources=resources,\n",
+ ")\n",
+ "{\n",
+ " \"node_count\": len(neighbors.knowledge_graph.get(\"nodes\", {})),\n",
+ " \"edge_count\": len(neighbors.knowledge_graph.get(\"edges\", {})),\n",
+ " \"result_count\": len(neighbors.results),\n",
+ "}\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-08-06T20:28:36.878890Z",
+ "iopub.status.busy": "2026-08-06T20:28:36.878697Z",
+ "iopub.status.idle": "2026-08-06T20:28:37.999195Z",
+ "shell.execute_reply": "2026-08-06T20:28:37.998622Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "constrained = neighborhood_finder(\n",
+ " node=\"asthma\",\n",
+ " neighbor_categories=[\"SmallMolecule\"],\n",
+ " node_categories=[\"Disease\"],\n",
+ " predicates_subset=[\"biolink:treats\", \"biolink:ameliorates\"],\n",
+ " attribute_constraints=[\n",
+ " {\n",
+ " \"id\": \"biolink:knowledge_level\",\n",
+ " \"operator\": \"==\",\n",
+ " \"value\": \"knowledge_assertion\",\n",
+ " }\n",
+ " ],\n",
+ " resources=resources,\n",
+ ")\n"
+ ]
+ },
{
"cell_type": "code",
"execution_count": 1,
diff --git a/notebooks/Neighborhood_finder_multiple_nodes.ipynb b/notebooks/Neighborhood_finder_multiple_nodes.ipynb
index def126b..3973f72 100644
--- a/notebooks/Neighborhood_finder_multiple_nodes.ipynb
+++ b/notebooks/Neighborhood_finder_multiple_nodes.ipynb
@@ -8,10 +8,123 @@
"# Neighborhood finder with multiple starting nodes"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "678a97ef",
+ "metadata": {},
+ "source": [
+ "## Quick start: `neighborhood_finder` API with multiple inputs\n",
+ "\n",
+ "The developer-friendly `neighborhood_finder` wrapper (now part of the main API) accepts a list of labels/CURIEs and queries all neighborhoods with the same neighbor categories.\n"
+ ]
+ },
{
"cell_type": "code",
+ "id": "885480b3",
"execution_count": 1,
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-08-06T20:32:24.194848Z",
+ "iopub.status.busy": "2026-08-06T20:32:24.194752Z",
+ "iopub.status.idle": "2026-08-06T20:33:54.104667Z",
+ "shell.execute_reply": "2026-08-06T20:33:54.084666Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Skipping server without x-maturity: {'url': '/sipr'}\n",
+ "Skipping server without x-maturity: {'description': 'Local dev', 'url': 'http://127.0.0.1:5001'}\n",
+ "59\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(18613, 5)\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(30174, 5)\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Microbiome KP - TRAPI 1.5.0: Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CATRAX Pharmacogenomics KP - TRAPI 1.5.0: Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "RTX KG2 - TRAPI 1.5.0: Success!\n",
+ "Genetics Data Provider for NCATS Biomedical Translator Reasoners: Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Automat-robokop(Trapi v1.5.0): Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Retriever: Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "BioThings Explorer (BTE) TRAPI: Success!\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{'node_0': ResolvedNode(input_value='asthma', curie='MONDO:0004979', label='asthma', categories=['biolink:Disease', 'biolink:DiseaseOrPhenotypicFeature', 'biolink:BiologicalEntity', 'biolink:ThingWithTaxon', 'biolink:NamedThing']),\n",
+ " 'node_1': ResolvedNode(input_value='MONDO:0004979', curie='MONDO:0004979', label='asthma', categories=['biolink:Disease', 'biolink:DiseaseOrPhenotypicFeature', 'biolink:BiologicalEntity', 'biolink:ThingWithTaxon', 'biolink:NamedThing'])}"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from TCT import get_translator_resources, neighborhood_finder\n",
+ "\n",
+ "resources = get_translator_resources()\n",
+ "multi_neighbors = neighborhood_finder(\n",
+ " node=[\"asthma\", \"MONDO:0004979\"],\n",
+ " neighbor_categories=[\"Gene\"],\n",
+ " resources=resources,\n",
+ ")\n",
+ "multi_neighbors.resolved_nodes\n"
+ ]
+ },
+ {
+ "cell_type": "code",
"id": "f1df4a59-caf9-4477-a789-ad6aba33ba90",
+ "execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
@@ -36,8 +149,8 @@
},
{
"cell_type": "code",
- "execution_count": 3,
"id": "ab0711e0-bc03-48f2-8282-65bbe9ea30d5",
+ "execution_count": 3,
"metadata": {},
"outputs": [
{
@@ -64,8 +177,8 @@
},
{
"cell_type": "code",
- "execution_count": 4,
"id": "02fc8d7b",
+ "execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
@@ -123,8 +236,8 @@
},
{
"cell_type": "code",
- "execution_count": 5,
"id": "b68f54d0-dfa5-4ef1-a2cc-da31bc5f18aa",
+ "execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
@@ -134,8 +247,8 @@
},
{
"cell_type": "code",
- "execution_count": null,
"id": "504cfba0",
+ "execution_count": null,
"metadata": {},
"outputs": [
{
@@ -167,8 +280,8 @@
},
{
"cell_type": "code",
- "execution_count": 7,
"id": "45f0ddbb-0368-4a2e-9b19-ed4969a51718",
+ "execution_count": 7,
"metadata": {},
"outputs": [
{
@@ -190,8 +303,8 @@
},
{
"cell_type": "code",
- "execution_count": 8,
"id": "8682160f-ee2b-4cb0-925e-1f6dcd9c8264",
+ "execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
@@ -207,8 +320,8 @@
},
{
"cell_type": "code",
- "execution_count": 9,
"id": "600eec1f",
+ "execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
diff --git a/notebooks/Path_finder.ipynb b/notebooks/Path_finder.ipynb
index ae2c584..d872d7f 100644
--- a/notebooks/Path_finder.ipynb
+++ b/notebooks/Path_finder.ipynb
@@ -8,6 +8,165 @@
"### This pipeline can be used to get a ranked path between A and B given a set of paths."
]
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Quick start: `pathfinder` API\n",
+ "\n",
+ "TCT now provides a developer-friendly `pathfinder` wrapper as part of the main API. It resolves labels/CURIEs, loads and caches Translator resources, selects compatible APIs/predicates, queries KPs in parallel, and returns a `FinderResult` with parsed graph sections surfaced directly. Use the fine-grained workflow below when you need endpoint selection, predicate control, raw query construction, or visualization setup.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-08-06T20:43:56.356037Z",
+ "iopub.status.busy": "2026-08-06T20:43:56.355890Z",
+ "iopub.status.idle": "2026-08-06T20:48:27.140992Z",
+ "shell.execute_reply": "2026-08-06T20:48:27.139014Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Skipping server without x-maturity: {'url': '/sipr'}\n",
+ "Skipping server without x-maturity: {'description': 'Local dev', 'url': 'http://127.0.0.1:5001'}\n",
+ "59\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(18613, 5)\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(30174, 5)\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Microbiome KP - TRAPI 1.5.0: Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CATRAX Pharmacogenomics KP - TRAPI 1.5.0: Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Genetics Data Provider for NCATS Biomedical Translator Reasoners: Success!\n",
+ "RTX KG2 - TRAPI 1.5.0: Success!\n",
+ "Automat-robokop(Trapi v1.5.0): Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "BioThings Explorer (BTE) TRAPI: Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Service Provider TRAPI: Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CATRAX BigGIM DrugResponse Performance Phase KP - TRAPI 1.5.0: Success!\n",
+ "CATRAX Pharmacogenomics KP - TRAPI 1.5.0: Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "RTX KG2 - TRAPI 1.5.0: Success!\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{'start': ResolvedNode(input_value='asthma', curie='MONDO:0004979', label='asthma', categories=['biolink:Disease', 'biolink:DiseaseOrPhenotypicFeature', 'biolink:BiologicalEntity', 'biolink:ThingWithTaxon', 'biolink:NamedThing']),\n",
+ " 'end': ResolvedNode(input_value='albuterol', curie='CHEBI:2549', label='Salbutamol', categories=['biolink:SmallMolecule', 'biolink:MolecularEntity', 'biolink:ChemicalEntity', 'biolink:PhysicalEssence', 'biolink:ChemicalOrDrugOrTreatment', 'biolink:ChemicalEntityOrGeneOrGeneProduct', 'biolink:ChemicalEntityOrProteinOrPolypeptide', 'biolink:NamedThing', 'biolink:PhysicalEssenceOrOccurrent'])}"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from TCT import get_translator_resources, pathfinder\n",
+ "\n",
+ "resources = get_translator_resources()\n",
+ "paths = pathfinder(\n",
+ " start=\"asthma\",\n",
+ " end=\"albuterol\",\n",
+ " intermediate_categories=[\"Gene\", \"Protein\"],\n",
+ " resources=resources,\n",
+ ")\n",
+ "paths.resolved_nodes\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-08-06T20:48:27.147806Z",
+ "iopub.status.busy": "2026-08-06T20:48:27.146164Z",
+ "iopub.status.idle": "2026-08-06T20:48:27.152112Z",
+ "shell.execute_reply": "2026-08-06T20:48:27.151874Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'node_count': 6,\n",
+ " 'edge_count': 30,\n",
+ " 'result_count': 1,\n",
+ " 'raw_sections': ['query_graph',\n",
+ " 'knowledge_graph',\n",
+ " 'results',\n",
+ " 'auxiliary_graphs']}"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "{\n",
+ " \"node_count\": len(paths.knowledge_graph.get(\"nodes\", {})),\n",
+ " \"edge_count\": len(paths.knowledge_graph.get(\"edges\", {})),\n",
+ " \"result_count\": len(paths.results),\n",
+ " \"raw_sections\": list(paths.to_dict().keys()),\n",
+ "}\n"
+ ]
+ },
{
"cell_type": "code",
"execution_count": 1,
@@ -153,67 +312,81 @@
},
{
"cell_type": "code",
- "execution_count": 6,
- "metadata": {},
+ "execution_count": 8,
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-08-06T20:48:46.428981Z",
+ "iopub.status.busy": "2026-08-06T20:48:46.428922Z",
+ "iopub.status.idle": "2026-08-06T20:48:49.648986Z",
+ "shell.execute_reply": "2026-08-06T20:48:49.648699Z"
+ }
+ },
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "PUBCHEM.COMPOUND:132212657\n",
- "MONDO:0018874\n",
- "RTX KG2 - TRAPI 1.5.0: Success!\n",
- "MolePro: Success!\n",
- "Automat-monarchinitiative(Trapi v1.5.0): Success!\n",
- "CATRAX Pharmacogenomics KP - TRAPI 1.5.0: Success!\n",
- "Genetics Data Provider for NCATS Biomedical Translator Reasoners: Success!\n",
- "Automat-pharos(Trapi v1.5.0): Success!\n",
- "Automat-robokop(Trapi v1.5.0): Success!\n",
- "CATRAX BigGIM DrugResponse Performance Phase KP - TRAPI 1.5.0: Success!\n",
- "Clinical Trials KP - TRAPI 1.5.0: Success!\n",
- "RTX KG2 - TRAPI 1.5.0: Success!\n",
- "Number of possible paths: 2\n"
+ "RTX KG2 - TRAPI 1.5.0: Success!\n"
]
},
{
- "name": "stderr",
+ "name": "stdout",
"output_type": "stream",
"text": [
- "/Users/gqin/Github_repo/Translator_component_toolkit/TCT/TCT.py:1653: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n",
- " ax.set_xticklabels(ax.get_xticklabels(), rotation=90, ha=\"center\", fontsize=fontsize)\n"
+ "MolePro: Success!\n"
]
},
{
- "data": {
- "image/png": "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",
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CATRAX Pharmacogenomics KP - TRAPI 1.5.0: Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CATRAX BigGIM DrugResponse Performance Phase KP - TRAPI 1.5.0: Success!\n",
+ "Clinical Trials KP - TRAPI 1.5.0: Success!\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "RTX KG2 - TRAPI 1.5.0: Success!\n"
+ ]
}
],
"source": [
- "result = TCT.Path_finder(input_node1=subject_node, #IFNG \n",
- " input_node2= object_node, #COVID-19\n",
- " intermediate_categories=intermediate_categories, \n",
- " APInames=select_APIs, \n",
- " metaKG=selected_metaKG, \n",
- " API_predicates=API_predicates)"
+ "from TCT import pathfinder\n",
+ "\n",
+ "result = pathfinder(start=subject_node, # e.g. IFNG\n",
+ " end=object_node, # e.g. disease node\n",
+ " intermediate_categories=intermediate_categories,\n",
+ " api_names=select_APIs,\n",
+ " meta_kg=selected_metaKG,\n",
+ " api_predicates=API_predicates)\n"
]
},
{
"cell_type": "code",
- "execution_count": 7,
- "metadata": {},
+ "execution_count": 9,
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-08-06T20:48:49.650309Z",
+ "iopub.status.busy": "2026-08-06T20:48:49.650229Z",
+ "iopub.status.idle": "2026-08-06T20:48:49.654287Z",
+ "shell.execute_reply": "2026-08-06T20:48:49.654134Z"
+ }
+ },
"outputs": [],
"source": [
- "TCT_path_finder_result = TCT_pathfinder.parse_results_for_pathfinder(subject_node, object_node, result1=result['result1'], result2=result['result2'])\n",
- "# return results path_finder_result to a json file\n",
+ "# pathfinder already returns parsed results inside a FinderResult\n",
"import json\n",
"with open(f'TCT_path_finder_result__{subject_node.replace(\":\", \"_\")}__{object_node.replace(\":\", \"_\")}.json', 'w') as f:\n",
- " json.dump(TCT_path_finder_result, f, indent=4)"
+ " json.dump(result.to_dict(), f, indent=4)\n"
]
},
{
diff --git a/tests/test_experimental.py b/tests/test_finder_api.py
similarity index 81%
rename from tests/test_experimental.py
rename to tests/test_finder_api.py
index de73a76..720beb8 100644
--- a/tests/test_experimental.py
+++ b/tests/test_finder_api.py
@@ -1,10 +1,19 @@
-"""Tests for the experimental developer-friendly API."""
+"""Tests for the developer-friendly finder API (promoted to the main API)."""
import pandas as pd
import pytest
-from TCT import experimental
-from TCT.experimental import FinderResult, TranslatorResources
+from TCT import (
+ FinderResult,
+ TranslatorResources,
+ clear_translator_resource_cache,
+ get_translator_resources,
+ neighborhood_finder,
+ pathfinder,
+)
+from TCT import TCT as tct_main
+from TCT import TCT_neighborhood_finder as tct_neighborhood_finder
+from TCT import TCT_pathfinder as tct_pathfinder
from TCT.translator_node import TranslatorNode
@@ -34,10 +43,10 @@ def _raw_output():
def test_normalize_category_accepts_short_and_prefixed_names():
- assert experimental._normalize_category("Gene") == "biolink:Gene"
- assert experimental._normalize_category("biolink:Disease") == "biolink:Disease"
- assert experimental._normalize_categories([" Drug "]) == ["biolink:Drug"]
- assert experimental._normalize_categories(None) is None
+ assert tct_main._normalize_category("Gene") == "biolink:Gene"
+ assert tct_main._normalize_category("biolink:Disease") == "biolink:Disease"
+ assert tct_main._normalize_categories([" Drug "]) == ["biolink:Drug"]
+ assert tct_main._normalize_categories(None) is None
def test_translator_resources_cache_lifecycle(monkeypatch):
@@ -48,39 +57,39 @@ def fake_fetch():
return {"api": "url"}, pd.DataFrame({"call": [len(calls)]}), {"api": []}
monkeypatch.setattr(
- experimental.translator_query,
+ tct_main.translator_query,
"get_translator_API_predicates",
fake_fetch,
)
- experimental.clear_translator_resource_cache()
+ clear_translator_resource_cache()
- first = experimental.get_translator_resources()
- second = experimental.get_translator_resources()
- refreshed = experimental.get_translator_resources(refresh=True)
+ first = get_translator_resources()
+ second = get_translator_resources()
+ refreshed = get_translator_resources(refresh=True)
assert first is second
assert refreshed is not first
assert len(calls) == 2
- experimental.clear_translator_resource_cache()
- assert experimental._DEFAULT_TRANSLATOR_RESOURCES is None
+ clear_translator_resource_cache()
+ assert tct_main._DEFAULT_TRANSLATOR_RESOURCES is None
def test_resolve_node_normalizes_curie_without_name_lookup(monkeypatch):
name_lookup_calls = []
monkeypatch.setattr(
- experimental.node_normalizer,
+ tct_main.node_normalizer,
"get_normalized_nodes",
lambda value, **kwargs: _node(value, "Asthma", ["biolink:Disease"]),
)
monkeypatch.setattr(
- experimental.name_resolver,
+ tct_main.name_resolver,
"lookup",
lambda *args, **kwargs: name_lookup_calls.append(args),
)
- resolved = experimental._resolve_node("MONDO:0004979")
+ resolved = tct_main._resolve_node("MONDO:0004979")
assert resolved.input_value == "MONDO:0004979"
assert resolved.curie == "MONDO:0004979"
@@ -93,7 +102,7 @@ def test_resolve_node_uses_name_resolver_for_strings(monkeypatch):
calls = []
monkeypatch.setattr(
- experimental.name_resolver,
+ tct_main.name_resolver,
"lookup",
lambda value, **kwargs: _node("MONDO:0004979", value, ["biolink:Disease"]),
)
@@ -103,12 +112,12 @@ def fake_normalize(value, **kwargs):
return _node(value, "asthma", ["biolink:Disease"])
monkeypatch.setattr(
- experimental.node_normalizer,
+ tct_main.node_normalizer,
"get_normalized_nodes",
fake_normalize,
)
- resolved = experimental._resolve_node(
+ resolved = tct_main._resolve_node(
"asthma",
node_normalizer_kwargs={"conflate": True},
)
@@ -120,25 +129,25 @@ def fake_normalize(value, **kwargs):
def test_resolve_node_raises_for_unknown_curie(monkeypatch):
monkeypatch.setattr(
- experimental.node_normalizer,
+ tct_main.node_normalizer,
"get_normalized_nodes",
lambda value, **kwargs: None,
)
with pytest.raises(LookupError, match="Could not normalize CURIE"):
- experimental._resolve_node("MISSING:CURIE")
+ tct_main._resolve_node("MISSING:CURIE")
def test_get_resources_uses_complete_resources_and_partial_overrides(monkeypatch):
monkeypatch.setattr(
- experimental,
+ tct_main,
"get_translator_resources",
lambda: pytest.fail("cache should not be used when resources are provided"),
)
base = _resources()
override_meta = pd.DataFrame({"Subject": ["biolink:Disease"]})
- resolved = experimental._get_resources(resources=base, meta_kg=override_meta)
+ resolved = tct_main._get_resources(resources=base, meta_kg=override_meta)
assert resolved.api_names is base.api_names
assert resolved.api_predicates is base.api_predicates
@@ -163,7 +172,7 @@ def test_pathfinder_resolves_inputs_queries_apis_and_wraps_output(monkeypatch):
queries = []
monkeypatch.setattr(
- experimental,
+ tct_main,
"_resolve_node",
lambda value, **kwargs: _node(
value if ":" in value else f"CURIE:{value}",
@@ -172,7 +181,7 @@ def test_pathfinder_resolves_inputs_queries_apis_and_wraps_output(monkeypatch):
),
)
monkeypatch.setattr(
- experimental,
+ tct_main,
"sele_predicates_API",
lambda source, target, meta_kg, api_names: (
["biolink:related_to"],
@@ -186,15 +195,15 @@ def fake_parallel(query_json, select_APIs, APInames, API_predicates, max_workers
return {f"edge-{len(queries)}": {"subject": "s", "object": "o"}}
monkeypatch.setattr(
- experimental.translator_query, "parallel_api_query", fake_parallel
+ tct_main.translator_query, "parallel_api_query", fake_parallel
)
monkeypatch.setattr(
- experimental,
+ tct_pathfinder,
"parse_results_for_pathfinder",
lambda *args, **kwargs: _raw_output(),
)
- result = experimental.pathfinder(
+ result = pathfinder(
"asthma",
"albuterol",
["Gene"],
@@ -220,14 +229,14 @@ def test_neighborhood_finder_single_input_queries_and_wraps_output(monkeypatch):
queries = []
monkeypatch.setattr(
- experimental,
+ tct_main,
"_resolve_nodes",
lambda values, **kwargs: [
_node("MONDO:0004979", "asthma", ["biolink:Disease"])
],
)
monkeypatch.setattr(
- experimental,
+ tct_main,
"sele_predicates_API",
lambda source, target, meta_kg, api_names: (
["biolink:treats"],
@@ -241,15 +250,15 @@ def fake_parallel(query_json, select_APIs, APInames, API_predicates, max_workers
return {"edge-1": {"subject": "MONDO:0004979", "object": "CHEBI:1"}}
monkeypatch.setattr(
- experimental.translator_query, "parallel_api_query", fake_parallel
+ tct_main.translator_query, "parallel_api_query", fake_parallel
)
monkeypatch.setattr(
- experimental,
+ tct_neighborhood_finder,
"parse_results_for_neighborhood_finder",
lambda *args, **kwargs: _raw_output(),
)
- result = experimental.neighborhood_finder(
+ result = neighborhood_finder(
"asthma",
["Drug"],
resources=_resources(),
@@ -267,14 +276,14 @@ def test_neighborhood_finder_places_attribute_constraints_on_query_edge(monkeypa
queries = []
monkeypatch.setattr(
- experimental,
+ tct_main,
"_resolve_nodes",
lambda values, **kwargs: [
_node("MONDO:0004979", "asthma", ["biolink:Disease"])
],
)
monkeypatch.setattr(
- experimental,
+ tct_main,
"sele_predicates_API",
lambda source, target, meta_kg, api_names: (
["biolink:treats"],
@@ -288,10 +297,10 @@ def fake_parallel(query_json, select_APIs, APInames, API_predicates, max_workers
return {}
monkeypatch.setattr(
- experimental.translator_query, "parallel_api_query", fake_parallel
+ tct_main.translator_query, "parallel_api_query", fake_parallel
)
monkeypatch.setattr(
- experimental,
+ tct_neighborhood_finder,
"parse_results_for_neighborhood_finder",
lambda *args, **kwargs: _raw_output(),
)
@@ -303,7 +312,7 @@ def fake_parallel(query_json, select_APIs, APInames, API_predicates, max_workers
}
]
- experimental.neighborhood_finder(
+ neighborhood_finder(
"asthma",
["Drug"],
resources=_resources(),
@@ -319,7 +328,7 @@ def test_neighborhood_finder_multiple_inputs_uses_multiple_parser(monkeypatch):
parser_calls = []
monkeypatch.setattr(
- experimental,
+ tct_main,
"_resolve_nodes",
lambda values, **kwargs: [
_node("MONDO:1", "one", ["biolink:Disease"]),
@@ -327,12 +336,12 @@ def test_neighborhood_finder_multiple_inputs_uses_multiple_parser(monkeypatch):
],
)
monkeypatch.setattr(
- experimental,
+ tct_main,
"sele_predicates_API",
lambda source, target, meta_kg, api_names: ([], ["fake-api"], []),
)
monkeypatch.setattr(
- experimental.translator_query,
+ tct_main.translator_query,
"parallel_api_query",
lambda **kwargs: {},
)
@@ -342,12 +351,12 @@ def fake_parser(*args, **kwargs):
return _raw_output()
monkeypatch.setattr(
- experimental,
+ tct_neighborhood_finder,
"parse_results_for_neighborhood_finder_multiple_inputs",
fake_parser,
)
- result = experimental.neighborhood_finder(
+ result = neighborhood_finder(
["one", "two"],
["Gene"],
resources=_resources(),