tooluniverse 1.0.11.2__tar.gz → 1.0.12__tar.gz

{tooluniverse-1.0.11.2 → tooluniverse-1.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tooluniverse
-Version: 1.0.11.2
+Version: 1.0.12
 Summary: A comprehensive collection of scientific tools for Agentic AI, offering integration with the ToolUniverse SDK and MCP Server to support advanced scientific workflows.
 Author-email: Shanghua Gao <shanghuagao@gmail.com>
 Project-URL: Homepage, https://github.com/mims-harvard/ToolUniverse
@@ -40,6 +40,8 @@ Requires-Dist: beautifulsoup4>=4.12.0
 Requires-Dist: markitdown[all]>=0.1.0
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: ddgs>=9.0.0
+Provides-Extra: smolagents
+Requires-Dist: smolagents>=1.22.0; extra == "smolagents"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"

{tooluniverse-1.0.11.2 → tooluniverse-1.0.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tooluniverse"
-version = "1.0.11.2"
+version = "1.0.12"
 description = "A comprehensive collection of scientific tools for Agentic AI, offering integration with the ToolUniverse SDK and MCP Server to support advanced scientific workflows."
 authors = [
     { name = "Shanghua Gao", email = "shanghuagao@gmail.com" }
@@ -48,6 +48,9 @@ requires-python = ">=3.10"
 readme = "README.md"
 
 [project.optional-dependencies]
+smolagents = [
+    "smolagents>=1.22.0",
+]
 dev = [
     "pytest>=7.0",
     "pytest-cov>=4.0",

tooluniverse-1.0.12/src/tooluniverse/build_optimizer.py

@@ -0,0 +1,180 @@
+"""Build optimization utilities for ToolUniverse tools."""
+
+import json
+import hashlib
+from pathlib import Path
+from typing import Dict, Any, Set, Tuple
+
+
+def _normalize_value(value: Any) -> Any:
+    """Recursively normalize values for consistent hashing."""
+    if isinstance(value, dict):
+        # Sort dictionary keys and normalize values
+        return {k: _normalize_value(v) for k, v in sorted(value.items())}
+    elif isinstance(value, list):
+        # Normalize list elements
+        return [_normalize_value(item) for item in value]
+    elif isinstance(value, (str, int, float, bool)) or value is None:
+        return value
+    else:
+        # Convert other types to string representation for hashing
+        return str(value)
+
+
+def calculate_tool_hash(tool_config: Dict[str, Any], verbose: bool = False) -> str:
+    """Calculate a hash for tool configuration to detect changes.
+
+    Args:
+        tool_config: Tool configuration dictionary
+        verbose: If True, print excluded fields (for debugging)
+
+    Returns:
+        MD5 hash string of the normalized configuration
+    """
+    # Fields to exclude from hash calculation (metadata/timestamp fields)
+    excluded_fields = {"timestamp", "last_updated", "created_at", "_cache", "_metadata"}
+
+    # Create a normalized version of the config for hashing
+    normalized_config = {}
+    excluded_values = []
+
+    for key, value in sorted(tool_config.items()):
+        if key not in excluded_fields:
+            # Recursively normalize nested structures
+            normalized_config[key] = _normalize_value(value)
+        elif verbose:
+            excluded_values.append(key)
+
+    if verbose and excluded_values:
+        print(f"  Excluded fields from hash: {', '.join(excluded_values)}")
+
+    # Use consistent JSON serialization with sorted keys
+    config_str = json.dumps(
+        normalized_config, sort_keys=True, separators=(",", ":"), ensure_ascii=False
+    )
+    return hashlib.md5(config_str.encode("utf-8")).hexdigest()
+
+
+def load_metadata(metadata_file: Path) -> Dict[str, str]:
+    """Load tool metadata from file."""
+    if not metadata_file.exists():
+        return {}
+
+    try:
+        with open(metadata_file, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return {}
+
+
+def save_metadata(metadata: Dict[str, str], metadata_file: Path) -> None:
+    """Save tool metadata to file."""
+    metadata_file.parent.mkdir(parents=True, exist_ok=True)
+    with open(metadata_file, "w", encoding="utf-8") as f:
+        json.dump(metadata, f, indent=2, sort_keys=True)
+
+
+def cleanup_orphaned_files(tools_dir: Path, current_tool_names: Set[str]) -> int:
+    """Remove files for tools that no longer exist."""
+    if not tools_dir.exists():
+        return 0
+
+    cleaned_count = 0
+    keep_files = {"__init__", "_shared_client", "__pycache__"}
+
+    for file_path in tools_dir.iterdir():
+        if (
+            file_path.is_file()
+            and file_path.suffix == ".py"
+            and file_path.stem not in keep_files
+            and file_path.stem not in current_tool_names
+        ):
+            print(f"🗑️  Removing orphaned tool file: {file_path.name}")
+            file_path.unlink()
+            cleaned_count += 1
+
+    return cleaned_count
+
+
+def _compare_configs(old_config: Dict[str, Any], new_config: Dict[str, Any]) -> list:
+    """Compare two configs and return list of changed field paths."""
+    changes = []
+
+    all_keys = set(old_config.keys()) | set(new_config.keys())
+    excluded_fields = {"timestamp", "last_updated", "created_at", "_cache", "_metadata"}
+
+    for key in all_keys:
+        if key in excluded_fields:
+            continue
+
+        old_val = old_config.get(key)
+        new_val = new_config.get(key)
+
+        if old_val != new_val:
+            changes.append(key)
+
+    return changes
+
+
+def get_changed_tools(
+    current_tools: Dict[str, Any],
+    metadata_file: Path,
+    force_regenerate: bool = False,
+    verbose: bool = False,
+) -> Tuple[list, list, list, Dict[str, list]]:
+    """Get lists of new, changed, and unchanged tools.
+
+    Args:
+        current_tools: Dictionary of current tool configurations
+        metadata_file: Path to metadata file storing previous hashes
+        force_regenerate: If True, mark all tools as changed
+        verbose: If True, provide detailed change information
+
+    Returns:
+        Tuple of (new_tools, changed_tools, unchanged_tools, change_details)
+        where change_details maps tool_name -> list of changed field names
+    """
+    old_metadata = load_metadata(metadata_file)
+    new_metadata = {}
+    new_tools = []
+    changed_tools = []
+    unchanged_tools = []
+    change_details: Dict[str, list] = {}
+
+    if force_regenerate:
+        print("🔄 Force regeneration enabled - all tools will be regenerated")
+        for tool_name, tool_config in current_tools.items():
+            current_hash = calculate_tool_hash(tool_config, verbose=verbose)
+            new_metadata[tool_name] = current_hash
+            if tool_name in old_metadata:
+                changed_tools.append(tool_name)
+                change_details[tool_name] = ["force_regenerate"]
+            else:
+                new_tools.append(tool_name)
+    else:
+        for tool_name, tool_config in current_tools.items():
+            current_hash = calculate_tool_hash(tool_config, verbose=verbose)
+            new_metadata[tool_name] = current_hash
+
+            old_hash = old_metadata.get(tool_name)
+            if old_hash is None:
+                new_tools.append(tool_name)
+                if verbose:
+                    print(f"  ✨ New tool detected: {tool_name}")
+            elif old_hash != current_hash:
+                changed_tools.append(tool_name)
+                # Try to identify which fields changed (if we have the old config)
+                # Note: We only have hashes, so we can't do detailed field comparison
+                # This would require storing full configs, which we avoid for size reasons
+                change_details[tool_name] = ["hash_mismatch"]
+                if verbose:
+                    print(
+                        f"  🔄 Tool changed: {tool_name} (hash: {old_hash[:8]}... -> {current_hash[:8]}...)"
+                    )
+            else:
+                unchanged_tools.append(tool_name)
+
+    # Save updated metadata
+    save_metadata(new_metadata, metadata_file)
+
+    return new_tools, changed_tools, unchanged_tools, change_details

tooluniverse-1.0.12/src/tooluniverse/data/encode_tools.json

@@ -0,0 +1,139 @@
+[
+  {
+    "name": "ENCODE_search_experiments",
+    "type": "ENCODESearchTool",
+    "description": "Search ENCODE functional genomics experiments (e.g., ChIP-seq, ATAC-seq) by assay/target/organism/status. Use to discover datasets and access experiment-level metadata.",
+    "parameter": {
+      "type": "object",
+      "properties": {
+        "assay_title": {
+          "type": "string",
+          "description": "Assay name filter (e.g., 'ChIP-seq', 'ATAC-seq')."
+        },
+        "target": {
+          "type": "string",
+          "description": "Target filter (e.g., 'CTCF')."
+        },
+        "organism": {
+          "type": "string",
+          "description": "Organism filter (e.g., 'Homo sapiens', 'Mus musculus')."
+        },
+        "status": {
+          "type": "string",
+          "default": "released",
+          "description": "Record status filter (default 'released')."
+        },
+        "limit": {
+          "type": "integer",
+          "default": 10,
+          "minimum": 1,
+          "maximum": 100,
+          "description": "Max number of results (1–100)."
+        }
+      }
+    },
+    "fields": {
+      "endpoint": "https://www.encodeproject.org/search/",
+      "format": "json"
+    },
+    "return_schema": {
+      "type": "object",
+      "description": "ENCODE experiments search response",
+      "properties": {
+        "status": {"type": "string"},
+        "data": {
+          "type": "object",
+          "properties": {
+            "total": {"type": "integer"},
+            "@graph": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "accession": {"type": "string"},
+                  "assay_title": {"type": "string"},
+                  "target": {"type": "object"},
+                  "organism": {"type": "string"},
+                  "status": {"type": "string"}
+                }
+              }
+            }
+          }
+        },
+        "url": {"type": "string"}
+      }
+    },
+    "test_examples": [
+      {"assay_title": "ChIP-seq", "limit": 1},
+      {"assay_title": "ATAC-seq", "limit": 1}
+    ],
+    "label": ["ENCODE", "Experiment", "Search"],
+    "metadata": {
+      "tags": ["functional-genomics", "chip-seq", "atac-seq"],
+      "estimated_execution_time": "< 3 seconds"
+    }
+  },
+  {
+    "name": "ENCODE_list_files",
+    "type": "ENCODEFilesTool",
+    "description": "List ENCODE files with filters (file_format, output_type, assay). Use to programmatically retrieve downloadable artifact metadata (FASTQ, BAM, bigWig, peaks).",
+    "parameter": {
+      "type": "object",
+      "properties": {
+        "file_type": {
+          "type": "string",
+          "description": "File type filter (e.g., 'fastq', 'bam', 'bigWig')."
+        },
+        "assay_title": {
+          "type": "string",
+          "description": "Assay filter (e.g., 'ChIP-seq')."
+        },
+        "limit": {
+          "type": "integer",
+          "default": 10,
+          "minimum": 1,
+          "maximum": 100,
+          "description": "Max number of results (1–100)."
+        }
+      }
+    },
+    "fields": {
+      "endpoint": "https://www.encodeproject.org/search/",
+      "format": "json"
+    },
+    "return_schema": {
+      "type": "object",
+      "description": "ENCODE files search response",
+      "properties": {
+        "status": {"type": "string"},
+        "data": {
+          "type": "object",
+          "properties": {
+            "total": {"type": "integer"},
+            "@graph": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "accession": {"type": "string"},
+                  "file_format": {"type": "string"},
+                  "output_type": {"type": "string"},
+                  "file_type": {"type": "string"}
+                }
+              }
+            }
+          }
+        },
+        "url": {"type": "string"}
+      }
+    },
+    "test_examples": [
+      {"file_type": "fastq", "limit": 1}
+    ],
+    "label": ["ENCODE", "File", "Search"],
+    "metadata": {
+      "tags": ["downloads", "artifacts", "metadata"],
+      "estimated_execution_time": "< 3 seconds"
+    }
+  }
+]

tooluniverse-1.0.12/src/tooluniverse/data/gbif_tools.json

@@ -0,0 +1,152 @@
+[
+  {
+    "name": "GBIF_search_species",
+    "type": "GBIFTool",
+    "description": "Find taxa by keyword (scientific/common names) in GBIF. Use to resolve organism names to stable taxon keys (rank, lineage) for downstream biodiversity/occurrence queries.",
+    "parameter": {
+      "type": "object",
+      "properties": {
+        "query": {
+          "type": "string",
+          "description": "Search string for species/taxa (supports scientific/common names), e.g., 'Homo', 'Atlantic cod'."
+        },
+        "limit": {
+          "type": "integer",
+          "default": 10,
+          "minimum": 1,
+          "maximum": 300,
+          "description": "Maximum number of results to return (1–300)."
+        },
+        "offset": {
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Result offset for pagination (0-based)."
+        }
+      },
+      "required": ["query"]
+    },
+    "fields": {
+      "endpoint": "https://api.gbif.org/v1/species/search",
+      "format": "json"
+    },
+    "return_schema": {
+      "type": "object",
+      "description": "GBIF species search response",
+      "properties": {
+        "status": {"type": "string"},
+        "data": {
+          "type": "object",
+          "properties": {
+            "count": {"type": "integer"},
+            "results": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "key": {"type": "integer", "description": "taxonKey"},
+                  "scientificName": {"type": "string"},
+                  "rank": {"type": "string"},
+                  "kingdom": {"type": "string"},
+                  "phylum": {"type": "string"},
+                  "class": {"type": "string"},
+                  "order": {"type": "string"},
+                  "family": {"type": "string"},
+                  "genus": {"type": "string"}
+                }
+              }
+            }
+          }
+        },
+        "url": {"type": "string"}
+      }
+    },
+    "test_examples": [
+      {"query": "Homo", "limit": 1},
+      {"query": "Gadus", "limit": 1}
+    ],
+    "label": ["GBIF", "Taxonomy", "Search"],
+    "metadata": {
+      "tags": ["biodiversity", "taxonomy", "species", "search"],
+      "estimated_execution_time": "< 2 seconds"
+    }
+  },
+  {
+    "name": "GBIF_search_occurrences",
+    "type": "GBIFOccurrenceTool",
+    "description": "Retrieve species occurrence records from GBIF with optional filters (taxonKey, country, coordinates). Use for distribution mapping, presence-only modeling, and sampling context.",
+    "parameter": {
+      "type": "object",
+      "properties": {
+        "taxonKey": {
+          "type": "integer",
+          "description": "GBIF taxon key to filter occurrences by a specific taxon (from species search)."
+        },
+        "country": {
+          "type": "string",
+          "description": "ISO 3166-1 alpha-2 country code filter (e.g., 'US', 'CN')."
+        },
+        "hasCoordinate": {
+          "type": "boolean",
+          "default": true,
+          "description": "Only return records with valid latitude/longitude coordinates when true."
+        },
+        "limit": {
+          "type": "integer",
+          "default": 10,
+          "minimum": 1,
+          "maximum": 300,
+          "description": "Maximum number of results to return (1–300)."
+        },
+        "offset": {
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Result offset for pagination (0-based)."
+        }
+      }
+    },
+    "fields": {
+      "endpoint": "https://api.gbif.org/v1/occurrence/search",
+      "format": "json"
+    },
+    "return_schema": {
+      "type": "object",
+      "description": "GBIF occurrence search response",
+      "properties": {
+        "status": {"type": "string"},
+        "data": {
+          "type": "object",
+          "properties": {
+            "count": {"type": "integer"},
+            "results": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "key": {"type": "integer"},
+                  "speciesKey": {"type": "integer"},
+                  "scientificName": {"type": "string"},
+                  "decimalLatitude": {"type": "number"},
+                  "decimalLongitude": {"type": "number"},
+                  "eventDate": {"type": "string"},
+                  "countryCode": {"type": "string"}
+                }
+              }
+            }
+          }
+        },
+        "url": {"type": "string"}
+      }
+    },
+    "test_examples": [
+      {"hasCoordinate": true, "limit": 1},
+      {"country": "US", "limit": 1}
+    ],
+    "label": ["GBIF", "Occurrence", "Geospatial"],
+    "metadata": {
+      "tags": ["biodiversity", "occurrence", "distribution", "geospatial"],
+      "estimated_execution_time": "< 3 seconds"
+    }
+  }
+]

tooluniverse-1.0.12/src/tooluniverse/data/gdc_tools.json

@@ -0,0 +1,116 @@
+[
+  {
+    "name": "GDC_search_cases",
+    "type": "GDCCasesTool",
+    "description": "Search cancer cohort cases in NCI GDC by project and filters. Use to retrieve case-level metadata for cohort construction and downstream file queries.",
+    "parameter": {
+      "type": "object",
+      "properties": {
+        "project_id": {
+          "type": "string",
+          "description": "GDC project identifier (e.g., 'TCGA-BRCA')."
+        },
+        "size": {
+          "type": "integer",
+          "default": 10,
+          "minimum": 1,
+          "maximum": 100,
+          "description": "Number of results (1–100)."
+        },
+        "offset": {
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Offset for pagination (0-based)."
+        }
+      }
+    },
+    "fields": {
+      "endpoint": "https://api.gdc.cancer.gov/cases",
+      "format": "json"
+    },
+    "return_schema": {
+      "type": "object",
+      "description": "GDC cases response",
+      "properties": {
+        "status": {"type": "string"},
+        "data": {
+          "type": "object",
+          "properties": {
+            "hits": {
+              "type": "array",
+              "items": {"type": "object"}
+            },
+            "pagination": {"type": "object"}
+          }
+        },
+        "url": {"type": "string"}
+      }
+    },
+    "test_examples": [
+      {"project_id": "TCGA-BRCA", "size": 1}
+    ],
+    "label": ["GDC", "Cases", "Oncogenomics"],
+    "metadata": {
+      "tags": ["oncogenomics", "cohort", "cases"],
+      "estimated_execution_time": "< 3 seconds"
+    }
+  },
+  {
+    "name": "GDC_list_files",
+    "type": "GDCFilesTool",
+    "description": "List GDC files filtered by data_type and other fields. Use to identify downloadable artifacts (e.g., expression quantification) for analysis pipelines.",
+    "parameter": {
+      "type": "object",
+      "properties": {
+        "data_type": {
+          "type": "string",
+          "description": "Data type filter (e.g., 'Gene Expression Quantification')."
+        },
+        "size": {
+          "type": "integer",
+          "default": 10,
+          "minimum": 1,
+          "maximum": 100,
+          "description": "Number of results (1–100)."
+        },
+        "offset": {
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Offset for pagination (0-based)."
+        }
+      }
+    },
+    "fields": {
+      "endpoint": "https://api.gdc.cancer.gov/files",
+      "format": "json"
+    },
+    "return_schema": {
+      "type": "object",
+      "description": "GDC files response",
+      "properties": {
+        "status": {"type": "string"},
+        "data": {
+          "type": "object",
+          "properties": {
+            "hits": {
+              "type": "array",
+              "items": {"type": "object"}
+            },
+            "pagination": {"type": "object"}
+          }
+        },
+        "url": {"type": "string"}
+      }
+    },
+    "test_examples": [
+      {"data_type": "Gene Expression Quantification", "size": 1}
+    ],
+    "label": ["GDC", "Files", "Oncogenomics"],
+    "metadata": {
+      "tags": ["downloads", "files", "expression"],
+      "estimated_execution_time": "< 3 seconds"
+    }
+  }
+]