tooluniverse 0.1.4__py3-none-any.whl → 1.0.0__py3-none-any.whl

tooluniverse/dataset_tool.py

@@ -0,0 +1,296 @@
+import pandas as pd
+import os
+from copy import deepcopy
+from .base_tool import BaseTool
+from .utils import download_from_hf
+from .tool_registry import register_tool
+
+
+@register_tool("DatasetTool")
+class DatasetTool(BaseTool):
+    """
+    Tool to search and filter the DrugBank vocabulary dataset.
+    Provides functionality to search drugs by name, ID, synonyms and filter by various criteria.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.dataset = None
+        self.query_schema = tool_config[
+            "query_schema"
+        ]  # TODO: Move query_schema to BaseTool
+        self.parameters = tool_config["parameter"][
+            "properties"
+        ]  # TODO: Move parameters to BaseTool
+        self._load_dataset()
+
+    def _load_dataset(self):
+        """Load the drugbank vocabulary CSV dataset."""
+        try:
+            if "hf_dataset_path" in self.tool_config:
+                # Download dataset from Hugging Face Hub
+                result = download_from_hf(self.tool_config)
+
+                if not result.get("success", False):
+                    print(f"Failed to download dataset: {result.get('error')}")
+                    self.dataset = pd.DataFrame()
+                    return
+
+                # Load the downloaded CSV
+                dataset_path = result["local_path"]
+
+            elif "local_dataset_path" in self.tool_config:
+                dataset_path = self.tool_config["local_dataset_path"]
+
+                # If relative path, make it relative to the project root
+                if not os.path.isabs(dataset_path):
+                    # Go up from src/tooluniverse to project root
+                    project_root = os.path.dirname(
+                        os.path.dirname(os.path.dirname(__file__))
+                    )
+                    dataset_path = os.path.join(project_root, dataset_path)
+
+            else:
+                print("No dataset path provided in tool configuration")
+                self.dataset = pd.DataFrame()
+                return
+
+            # Load the CSV file
+            if dataset_path.endswith(".csv"):
+                self.dataset = pd.read_csv(dataset_path)
+            elif dataset_path.endswith(".tsv"):
+                self.dataset = pd.read_csv(dataset_path, sep="\t")
+            elif dataset_path.endswith(".txt"):
+                self.dataset = pd.read_table(dataset_path, sep="\t")
+            elif dataset_path.endswith(".xlsx"):
+                self.dataset = pd.read_excel(dataset_path)
+            elif dataset_path.endswith(".pkl"):
+                self.dataset = pd.read_pickle(dataset_path)
+            elif dataset_path.endswith(".parquet"):
+                self.dataset = pd.read_parquet(dataset_path)
+
+            # Clean column names
+            self.dataset.columns = self.dataset.columns.str.strip()
+
+            # Fill NaN values with empty strings for better searching
+            self.dataset = self.dataset.fillna("")
+
+            print(f"Loaded dataset with {len(self.dataset)} records")
+
+        except Exception as e:
+            print(f"Error loading dataset: {e}")
+            self.dataset = pd.DataFrame()
+
+    def run(self, arguments):
+        """Main entry point for the tool."""
+        if self.dataset is None or self.dataset.empty:
+            return {"error": "Dataset not loaded or is empty"}
+
+        query_params = deepcopy(self.query_schema)
+        expected_param_names = self.parameters.keys()
+
+        # Prepare API parameters from arguments
+        for k in expected_param_names:
+            if k in arguments and arguments[k] is not None:
+                query_params[k] = arguments[k]
+
+        # Determine operation based on arguments - completely separate functions
+        if "field" in query_params:
+            # Use dedicated filter function
+            return self._drugbank_filter(query_params)
+        elif "query" in query_params:
+            # Use dedicated search function
+            return self._drugbank_search(query_params)
+        else:
+            return {
+                "error": "Invalid arguments: must provide either 'query' for search or 'field' for filtering"
+            }
+
+    # ==================== SEARCH FUNCTIONALITY ====================
+
+    def _drugbank_search(self, arguments):
+        """
+        Search drugs by name, ID, synonyms, or other fields using text-based queries.
+
+        This function is dedicated to text-based searching across specified fields.
+        It performs substring or exact matching based on user preferences.
+
+        Args:
+            arguments (dict): Search parameters including:
+                - query (str): Text to search for
+                - search_fields (list): Fields to search in
+                - case_sensitive (bool): Whether search is case sensitive
+                - exact_match (bool): Whether to perform exact matching
+                - limit (int): Maximum number of results
+
+        Returns:
+            dict: Search results with matched records and metadata
+        """
+        query = arguments.get("query", "")
+        search_fields = arguments.get("search_fields")
+        case_sensitive = arguments.get("case_sensitive", False)
+        exact_match = arguments.get("exact_match", False)
+        limit = arguments.get("limit", 50)
+
+        if not query:
+            return {"error": "Query parameter is required for search"}
+
+        # Prepare search query
+        if not case_sensitive:
+            query = query.lower()
+
+        results = []
+
+        for _, row in self.dataset.iterrows():
+            match_found = False
+            matched_fields = []
+
+            for field in search_fields:
+                if field not in self.dataset.columns:
+                    continue
+
+                field_value = str(row[field])
+                if not case_sensitive:
+                    field_value = field_value.lower()
+
+                if exact_match:
+                    # For synonyms, check each synonym separately
+                    if (
+                        field.lower() == "synonyms" and "|" in field_value
+                    ):  # TODO: rename correpsonding columns in each dataset to `synonyms` and use `|` to separate keywords
+                        synonyms = [s.strip() for s in field_value.split("|")]
+                        if query in synonyms:
+                            match_found = True
+                            matched_fields.append(field)
+                    elif query == field_value:
+                        match_found = True
+                        matched_fields.append(field)
+                else:
+                    if query in field_value:
+                        match_found = True
+                        matched_fields.append(field)
+
+            if match_found:
+                result_row = row.to_dict()
+                result_row["matched_fields"] = matched_fields
+                results.append(result_row)
+
+                if len(results) >= limit:
+                    break
+
+        return {
+            "query": arguments.get("query"),
+            "total_results": len(results),
+            "results": results,
+            "search_parameters": {
+                "search_fields": search_fields,
+                "case_sensitive": case_sensitive,
+                "exact_match": exact_match,
+                "limit": limit,
+            },
+        }
+
+    # ==================== FILTER FUNCTIONALITY ====================
+
+    def _drugbank_filter(self, arguments):
+        """
+        Filter drugs based on specific criteria and field-based conditions.
+
+        This function is dedicated to criteria-based filtering using simple field-condition-value parameters.
+        It supports filter types like contains, starts_with, ends_with, exact, not_empty.
+
+        Args:
+            arguments (dict): Filter parameters including:
+                - field (str): Field name to filter on
+                - condition (str): Type of condition (contains, starts_with, ends_with, exact, not_empty)
+                - value (str): Value to filter by (optional for not_empty condition)
+                - limit (int): Maximum number of results
+
+        Returns:
+            dict: Filtered results with matched records and applied filters
+        """
+        field = arguments.get("field")
+        condition = arguments.get("condition")
+        value = arguments.get("value", "")
+        limit = arguments.get("limit", 100)
+
+        if not field or not condition:
+            return {
+                "error": "Both 'field' and 'condition' parameters are required for filtering"
+            }
+
+        if field not in self.dataset.columns:
+            return {
+                "error": f"Field '{field}' not found in dataset. Available fields: {list(self.dataset.columns)}"
+            }
+
+        # Check if value is required for this condition
+        if condition != "not_empty" and not value:
+            return {
+                "error": f"'value' parameter is required for condition '{condition}'"
+            }
+
+        filtered_data = self.dataset.copy()
+        applied_filter = ""
+
+        try:
+            if condition == "contains":
+                mask = filtered_data[field].str.contains(value, case=False, na=False)
+                applied_filter = f"{field} contains '{value}'"
+
+            elif condition == "starts_with":
+                mask = filtered_data[field].str.startswith(value, na=False)
+                applied_filter = f"{field} starts with '{value}'"
+
+            elif condition == "ends_with":
+                mask = filtered_data[field].str.endswith(value, na=False)
+                applied_filter = f"{field} ends with '{value}'"
+
+            elif condition == "exact":
+                mask = filtered_data[field] == value
+                applied_filter = f"{field} equals '{value}'"
+
+            elif condition == "not_empty":
+                mask = (filtered_data[field] != "") & (filtered_data[field].notna())
+                applied_filter = f"{field} is not empty"
+
+            else:
+                return {
+                    "error": f"Unknown condition '{condition}'. Supported: contains, starts_with, ends_with, exact, not_empty"
+                }
+
+            filtered_data = filtered_data[mask]
+
+        except Exception as e:
+            return {"error": f"Error applying filter: {str(e)}"}
+
+        # Apply limit
+        results = filtered_data.head(limit).to_dict("records")
+
+        return {
+            "total_matches": len(filtered_data),
+            "returned_results": len(results),
+            "results": results,
+            "applied_filter": applied_filter,
+            "filter_parameters": {
+                "field": field,
+                "condition": condition,
+                "value": value if condition != "not_empty" else None,
+                "limit": limit,
+            },
+        }
+
+    # ==================== UTILITY FUNCTIONS ====================
+
+    def get_dataset_info(self):
+        """Get information about the loaded dataset."""
+        if self.dataset is None or self.dataset.empty:
+            return {"error": "Dataset not loaded or is empty"}
+
+        return {
+            "total_records": len(self.dataset),
+            "columns": list(self.dataset.columns),
+            "sample_record": (
+                self.dataset.iloc[0].to_dict() if len(self.dataset) > 0 else None
+            ),
+        }

tooluniverse/default_config.py

@@ -0,0 +1,165 @@
+"""
+Default tool configuration files mapping.
+
+This module contains the default mapping of tool categories to their JSON configuration files.
+It's separated from __init__.py to avoid circular imports.
+"""
+
+import os
+
+# Get the current directory where this file is located
+current_dir = os.path.dirname(os.path.abspath(__file__))
+
+default_tool_files = {
+    "special_tools": os.path.join(current_dir, "data", "special_tools.json"),
+    "tool_finder": os.path.join(current_dir, "data", "finder_tools.json"),
+    # 'tool_finder_llm': os.path.join(current_dir, 'data', 'tool_finder_llm_config.json'),
+    "opentarget": os.path.join(current_dir, "data", "opentarget_tools.json"),
+    "fda_drug_label": os.path.join(current_dir, "data", "fda_drug_labeling_tools.json"),
+    "monarch": os.path.join(current_dir, "data", "monarch_tools.json"),
+    "clinical_trials": os.path.join(
+        current_dir, "data", "clinicaltrials_gov_tools.json"
+    ),
+    "fda_drug_adverse_event": os.path.join(
+        current_dir, "data", "fda_drug_adverse_event_tools.json"
+    ),
+    "ChEMBL": os.path.join(current_dir, "data", "chembl_tools.json"),
+    "EuropePMC": os.path.join(current_dir, "data", "europe_pmc_tools.json"),
+    "semantic_scholar": os.path.join(
+        current_dir, "data", "semantic_scholar_tools.json"
+    ),
+    "pubtator": os.path.join(current_dir, "data", "pubtator_tools.json"),
+    "EFO": os.path.join(current_dir, "data", "efo_tools.json"),
+    "Enrichr": os.path.join(current_dir, "data", "enrichr_tools.json"),
+    "HumanBase": os.path.join(current_dir, "data", "humanbase_tools.json"),
+    "OpenAlex": os.path.join(current_dir, "data", "openalex_tools.json"),
+    "agents": os.path.join(current_dir, "data", "agentic_tools.json"),
+    "dataset": os.path.join(current_dir, "data", "dataset_tools.json"),
+    # 'mcp_clients': os.path.join(current_dir, 'data', 'mcp_client_tools_example.json'),
+    "mcp_auto_loader_txagent": os.path.join(
+        current_dir, "data", "txagent_client_tools.json"
+    ),
+    "mcp_auto_loader_expert_feedback": os.path.join(
+        current_dir, "data", "expert_feedback_tools.json"
+    ),
+    "adverse_event": os.path.join(current_dir, "data", "adverse_event_tools.json"),
+    "dailymed": os.path.join(current_dir, "data", "dailymed_tools.json"),
+    "hpa": os.path.join(current_dir, "data", "hpa_tools.json"),
+    "reactome": os.path.join(current_dir, "data", "reactome_tools.json"),
+    "pubchem": os.path.join(current_dir, "data", "pubchem_tools.json"),
+    "medlineplus": os.path.join(current_dir, "data", "medlineplus_tools.json"),
+    "uniprot": os.path.join(current_dir, "data", "uniprot_tools.json"),
+    # 'software': os.path.join(current_dir, 'data', 'software_tools.json'),
+    # Package tools - categorized software tools
+    "software_bioinformatics": os.path.join(
+        current_dir, "data", "packages", "bioinformatics_core_tools.json"
+    ),
+    "software_genomics": os.path.join(
+        current_dir, "data", "packages", "genomics_tools.json"
+    ),
+    "software_single_cell": os.path.join(
+        current_dir, "data", "packages", "single_cell_tools.json"
+    ),
+    "software_structural_biology": os.path.join(
+        current_dir, "data", "packages", "structural_biology_tools.json"
+    ),
+    "software_cheminformatics": os.path.join(
+        current_dir, "data", "packages", "cheminformatics_tools.json"
+    ),
+    "software_machine_learning": os.path.join(
+        current_dir, "data", "packages", "machine_learning_tools.json"
+    ),
+    "software_visualization": os.path.join(
+        current_dir, "data", "packages", "visualization_tools.json"
+    ),
+    "software_scientific_computing": os.path.join(
+        current_dir, "data", "packages", "scientific_computing_tools.json"
+    ),
+    "software_physics_astronomy": os.path.join(
+        current_dir, "data", "packages", "physics_astronomy_tools.json"
+    ),
+    "software_earth_sciences": os.path.join(
+        current_dir, "data", "packages", "earth_sciences_tools.json"
+    ),
+    "software_image_processing": os.path.join(
+        current_dir, "data", "packages", "image_processing_tools.json"
+    ),
+    "software_neuroscience": os.path.join(
+        current_dir, "data", "packages", "neuroscience_tools.json"
+    ),
+    "go": os.path.join(current_dir, "data", "gene_ontology_tools.json"),
+    "compose": os.path.join(current_dir, "data", "compose_tools.json"),
+    "idmap": os.path.join(current_dir, "data", "idmap_tools.json"),
+    "disease_target_score": os.path.join(
+        current_dir, "data", "disease_target_score_tools.json"
+    ),
+    "mcp_auto_loader_uspto_downloader": os.path.join(
+        current_dir, "data", "uspto_downloader_tools.json"
+    ),
+    "uspto": os.path.join(current_dir, "data", "uspto_tools.json"),
+    "xml": os.path.join(current_dir, "data", "xml_tools.json"),
+    "mcp_auto_loader_boltz": os.path.join(current_dir, "data", "boltz_tools.json"),
+    "url": os.path.join(current_dir, "data", "url_fetch_tools.json"),
+    # 'langchain': os.path.join(current_dir, 'data', 'langchain_tools.json'),
+    "rcsb_pdb": os.path.join(current_dir, "data", "rcsb_pdb_tools.json"),
+    "tool_composition": os.path.join(
+        current_dir, "data", "tool_composition_tools.json"
+    ),
+    "embedding": os.path.join(current_dir, "data", "embedding_tools.json"),
+    "gwas": os.path.join(current_dir, "data", "gwas_tools.json"),
+    "admetai": os.path.join(current_dir, "data", "admetai_tools.json"),
+    # duplicate key removed
+    "alphafold": os.path.join(current_dir, "data", "alphafold_tools.json"),
+    "output_summarization": os.path.join(
+        current_dir, "data", "output_summarization_tools.json"
+    ),
+}
+
+
+def get_default_hook_config():
+    """
+    Get default hook configuration.
+
+    Returns:
+        dict: Default hook configuration with basic settings
+    """
+    return {
+        "global_settings": {
+            "default_timeout": 30,
+            "max_hook_depth": 3,
+            "enable_hook_caching": True,
+            "hook_execution_order": "priority_desc",
+        },
+        "hook_type_defaults": {
+            "SummarizationHook": {
+                "default_output_length_threshold": 5000,
+                "default_chunk_size": 32000,
+                "default_focus_areas": "key_findings_and_results",
+                "default_max_summary_length": 3000,
+            },
+            "FileSaveHook": {
+                "default_temp_dir": None,
+                "default_file_prefix": "tool_output",
+                "default_include_metadata": True,
+                "default_auto_cleanup": False,
+                "default_cleanup_age_hours": 24,
+            },
+        },
+        "hooks": [
+            {
+                "name": "default_summarization_hook",
+                "type": "SummarizationHook",
+                "enabled": True,
+                "priority": 1,
+                "conditions": {"output_length": {"operator": ">", "threshold": 5000}},
+                "hook_config": {
+                    "composer_tool": "OutputSummarizationComposer",
+                    "chunk_size": 32000,
+                    "focus_areas": "key_findings_and_results",
+                    "max_summary_length": 3000,
+                },
+            }
+        ],
+        "tool_specific_hooks": {},
+        "category_hooks": {},
+    }

tooluniverse/efo_tool.py

@@ -0,0 +1,42 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("EFOTool")
+class EFOTool(BaseTool):
+    """
+    Tool to lookup Experimental Factor Ontology (EFO) IDs for diseases via the EMBL-EBI OLS API.
+    """
+
+    def __init__(self, tool_config, base_url="https://www.ebi.ac.uk/ols4/api/search"):
+        super().__init__(tool_config)
+        self.base_url = base_url
+
+    def run(self, arguments):
+        disease = arguments.get("disease")
+        rows = arguments.get("rows", 1)
+        if not disease:
+            return {"error": "`disease` parameter is required."}
+        return self._search(disease, rows)
+
+    def _search(self, disease, rows):
+        params = {"ontology": "efo", "q": disease, "rows": rows}
+        try:
+            response = requests.get(self.base_url, params=params, timeout=20)
+            response.raise_for_status()
+        except requests.RequestException as e:
+            return {"error": "OLS API request failed.", "details": str(e)}
+
+        data = response.json().get("response", {})
+        docs = data.get("docs", [])
+        if not docs:
+            return None
+
+        if rows == 1:
+            doc = docs[0]
+            return {"efo_id": doc.get("short_form"), "name": doc.get("label")}
+
+        return [
+            {"efo_id": doc.get("short_form"), "name": doc.get("label")} for doc in docs
+        ]