tooluniverse 1.0.11.2__py3-none-any.whl → 1.0.12__py3-none-any.whl

tooluniverse/execute_function.py

@@ -1404,8 +1404,12 @@ class ToolUniverse:
             # Validate tools have required fields
             valid_tools = []
             for tool in tools_in_file:
+                # Validate that tool is a dict, has "name" field, and name is a string
                 if isinstance(tool, dict) and "name" in tool:
-                    valid_tools.append(tool)
+                    name_value = tool["name"]
+                    # Ensure name is a string (not a dict/object) - this filters out schema files
+                    if isinstance(name_value, str):
+                        valid_tools.append(tool)
 
             return valid_tools
 
@@ -1428,7 +1432,13 @@ class ToolUniverse:
         for _category, file_path in self.tool_files.items():
             tools_in_category = self._read_tools_from_file(file_path)
             all_tools.extend(tools_in_category)
-            all_tool_names.update([tool["name"] for tool in tools_in_category])
+            # Only add string names to the set (filter out any non-string names as extra safety)
+            tool_names = [
+                tool["name"]
+                for tool in tools_in_category
+                if isinstance(tool.get("name"), str)
+            ]
+            all_tool_names.update(tool_names)
 
         # Also include remote tools
         try:
@@ -1441,7 +1451,13 @@ class ToolUniverse:
                     remote_tools = self._read_tools_from_file(fpath)
                     if remote_tools:
                         all_tools.extend(remote_tools)
-                        all_tool_names.update([tool["name"] for tool in remote_tools])
+                        # Only add string names to the set (filter out any non-string names as extra safety)
+                        tool_names = [
+                            tool["name"]
+                            for tool in remote_tools
+                            if isinstance(tool.get("name"), str)
+                        ]
+                        all_tool_names.update(tool_names)
         except Exception as e:
             warning(f"Warning: Failed to scan remote tools directory: {e}")
 
@@ -1465,11 +1481,17 @@ class ToolUniverse:
             warning(f"Warning: Data directory not found: {data_dir}")
             return all_tools, all_tool_names
 
-        # Recursively find all JSON files
+        # Recursively find all JSON files, excluding schema files
         json_files = []
         for root, _dirs, files in os.walk(data_dir):
+            # Skip schemas directory (contains JSON schema definition files, not tool configs)
+            if "schemas" in root:
+                continue
             for file in files:
                 if file.lower().endswith(".json"):
+                    # Skip files with "schema" in the name
+                    if "schema" in file.lower():
+                        continue
                     json_files.append(os.path.join(root, file))
 
         self.logger.debug(f"Found {len(json_files)} JSON files to scan")
@@ -1479,7 +1501,13 @@ class ToolUniverse:
             tools_in_file = self._read_tools_from_file(json_file)
             if tools_in_file:
                 all_tools.extend(tools_in_file)
-                all_tool_names.update([tool["name"] for tool in tools_in_file])
+                # Only add string names to the set (filter out any non-string names as extra safety)
+                tool_names = [
+                    tool["name"]
+                    for tool in tools_in_file
+                    if isinstance(tool.get("name"), str)
+                ]
+                all_tool_names.update(tool_names)
                 self.logger.debug(f"Loaded {len(tools_in_file)} tools from {json_file}")
 
         self.logger.info(
@@ -1868,7 +1896,10 @@ class ToolUniverse:
                 continue
 
             tool_instance = self._ensure_tool_instance(job)
-            if not tool_instance or not tool_instance.supports_caching():
+            if (
+                not tool_instance
+                or not getattr(tool_instance, "supports_caching", lambda: True)()
+            ):
                 continue
 
             cache_key = tool_instance.get_cache_key(job.arguments or {})
@@ -2087,7 +2118,10 @@ class ToolUniverse:
 
         if cache_enabled:
             tool_instance = self._get_tool_instance(function_name, cache=True)
-            if tool_instance and tool_instance.supports_caching():
+            if (
+                tool_instance
+                and getattr(tool_instance, "supports_caching", lambda: True)()
+            ):
                 cache_namespace = tool_instance.get_cache_namespace()
                 cache_version = tool_instance.get_cache_version()
                 cache_key = self._make_cache_key(function_name, arguments)
@@ -2211,7 +2245,11 @@ class ToolUniverse:
                 )
 
             # Cache result if enabled
-            if cache_enabled and tool_instance and tool_instance.supports_caching():
+            if (
+                cache_enabled
+                and tool_instance
+                and getattr(tool_instance, "supports_caching", lambda: True)()
+            ):
                 if cache_key is None:
                     cache_key = self._make_cache_key(function_name, arguments)
                 if cache_namespace is None:

tooluniverse/gbif_tool.py

@@ -0,0 +1,166 @@
+import json
+from typing import Any, Dict
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from tooluniverse.tool_registry import register_tool
+
+
+def _http_get(
+    url: str,
+    headers: Dict[str, str] | None = None,
+    timeout: int = 30,
+) -> Dict[str, Any]:
+    req = Request(url, headers=headers or {})
+    with urlopen(req, timeout=timeout) as resp:
+        data = resp.read()
+        try:
+            return json.loads(data.decode("utf-8", errors="ignore"))
+        except Exception:
+            return {"raw": data.decode("utf-8", errors="ignore")}
+
+
+@register_tool(
+    "GBIFTool",
+    config={
+        "name": "GBIF_search_species",
+        "type": "GBIFTool",
+        "description": "Search species via GBIF species/search",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "Query keyword, e.g., Homo",
+                },
+                "limit": {
+                    "type": "integer",
+                    "default": 10,
+                    "minimum": 1,
+                    "maximum": 300,
+                },
+                "offset": {
+                    "type": "integer",
+                    "default": 0,
+                    "minimum": 0,
+                },
+            },
+            "required": ["query"],
+        },
+        "settings": {
+            "base_url": "https://api.gbif.org/v1",
+            "timeout": 30,
+        },
+    },
+)
+class GBIFTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://api.gbif.org/v1"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+        query_text = arguments.get("query")
+        limit = int(arguments.get("limit", 10))
+        offset = int(arguments.get("offset", 0))
+
+        query = {"q": query_text, "limit": limit, "offset": offset}
+        url = f"{base}/species/search?{urlencode(query)}"
+        try:
+            data = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            return {
+                "source": "GBIF",
+                "endpoint": "species/search",
+                "query": query,
+                "data": data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "GBIF",
+                "endpoint": "species/search",
+                "success": False,
+            }
+
+
+@register_tool(
+    "GBIFOccurrenceTool",
+    config={
+        "name": "GBIF_search_occurrences",
+        "type": "GBIFOccurrenceTool",
+        "description": "Search occurrences via GBIF occurrence/search",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "taxonKey": {
+                    "type": "integer",
+                    "description": "GBIF taxonKey filter",
+                },
+                "country": {
+                    "type": "string",
+                    "description": "Country code, e.g., US",
+                },
+                "hasCoordinate": {"type": "boolean", "default": True},
+                "limit": {
+                    "type": "integer",
+                    "default": 10,
+                    "minimum": 1,
+                    "maximum": 300,
+                },
+                "offset": {
+                    "type": "integer",
+                    "default": 0,
+                    "minimum": 0,
+                },
+            },
+        },
+        "settings": {
+            "base_url": "https://api.gbif.org/v1",
+            "timeout": 30,
+        },
+    },
+)
+class GBIFOccurrenceTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://api.gbif.org/v1"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        query = {}
+        for key in ("taxonKey", "country", "hasCoordinate", "limit", "offset"):
+            if key in arguments and arguments[key] is not None:
+                query[key] = arguments[key]
+
+        if "limit" not in query:
+            query["limit"] = 10
+        if "offset" not in query:
+            query["offset"] = 0
+
+        url = f"{base}/occurrence/search?{urlencode(query)}"
+        try:
+            data = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            return {
+                "source": "GBIF",
+                "endpoint": "occurrence/search",
+                "query": query,
+                "data": data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "GBIF",
+                "endpoint": "occurrence/search",
+                "success": False,
+            }

tooluniverse/gdc_tool.py

@@ -0,0 +1,175 @@
+import json
+from typing import Any, Dict
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from tooluniverse.tool_registry import register_tool
+
+
+def _http_get(
+    url: str,
+    headers: Dict[str, str] | None = None,
+    timeout: int = 30,
+) -> Dict[str, Any]:
+    req = Request(url, headers=headers or {})
+    with urlopen(req, timeout=timeout) as resp:
+        data = resp.read()
+        try:
+            return json.loads(data.decode("utf-8", errors="ignore"))
+        except Exception:
+            return {"raw": data.decode("utf-8", errors="ignore")}
+
+
+@register_tool(
+    "GDCCasesTool",
+    config={
+        "name": "GDC_search_cases",
+        "type": "GDCCasesTool",
+        "description": "Search NCI GDC cases via /cases",
+        "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)",
+                },
+            },
+        },
+        "settings": {"base_url": "https://api.gdc.cancer.gov", "timeout": 30},
+    },
+)
+class GDCCasesTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://api.gdc.cancer.gov"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        query: Dict[str, Any] = {}
+        if arguments.get("project_id"):
+            # Build filters JSON for project_id
+            filters = {
+                "op": "=",
+                "content": {
+                    "field": "projects.project_id",
+                    "value": [arguments["project_id"]],
+                },
+            }
+            query["filters"] = json.dumps(filters)
+        if arguments.get("size") is not None:
+            query["size"] = int(arguments["size"])
+        if arguments.get("offset") is not None:
+            query["from"] = int(arguments["offset"])
+
+        url = f"{base}/cases?{urlencode(query)}"
+        try:
+            data = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            return {
+                "source": "GDC",
+                "endpoint": "cases",
+                "query": query,
+                "data": data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "GDC",
+                "endpoint": "cases",
+                "success": False,
+            }
+
+
+@register_tool(
+    "GDCFilesTool",
+    config={
+        "name": "GDC_list_files",
+        "type": "GDCFilesTool",
+        "description": "List NCI GDC files via /files with optional data_type filter",
+        "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)",
+                },
+            },
+        },
+        "settings": {"base_url": "https://api.gdc.cancer.gov", "timeout": 30},
+    },
+)
+class GDCFilesTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://api.gdc.cancer.gov"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        query: Dict[str, Any] = {}
+        if arguments.get("data_type"):
+            filters = {
+                "op": "=",
+                "content": {
+                    "field": "files.data_type",
+                    "value": [arguments["data_type"]],
+                },
+            }
+            query["filters"] = json.dumps(filters)
+        if arguments.get("size") is not None:
+            query["size"] = int(arguments["size"])
+        if arguments.get("offset") is not None:
+            query["from"] = int(arguments["offset"])
+
+        url = f"{base}/files?{urlencode(query)}"
+        try:
+            data = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            return {
+                "source": "GDC",
+                "endpoint": "files",
+                "query": query,
+                "data": data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "GDC",
+                "endpoint": "files",
+                "success": False,
+            }

tooluniverse/generate_tools.py

@@ -5,7 +5,7 @@ import os
 import shutil
 import subprocess
 from pathlib import Path
-from typing import Dict, Any, Optional, List
+from typing import Dict, Any, Optional, List, Tuple
 
 
 def json_type_to_python(json_type: str) -> str:
@@ -20,6 +20,55 @@ def json_type_to_python(json_type: str) -> str:
     }.get(json_type, "Any")
 
 
+def validate_generated_code(
+    tool_name: str, tool_config: Dict[str, Any], generated_file: Path
+) -> Tuple[bool, list]:
+    """Validate that generated code matches the tool configuration.
+
+    Args:
+        tool_name: Name of the tool
+        tool_config: Original tool configuration
+        generated_file: Path to the generated Python file
+
+    Returns:
+        Tuple of (is_valid, list_of_issues)
+    """
+    issues = []
+
+    if not generated_file.exists():
+        return False, [f"Generated file does not exist: {generated_file}"]
+
+    try:
+        content = generated_file.read_text(encoding="utf-8")
+
+        # Check that function name matches tool name
+        if f"def {tool_name}(" not in content:
+            issues.append(f"Function definition not found for {tool_name}")
+
+        # Check that all required parameters are present
+        schema = tool_config.get("parameter", {}) or {}
+        properties = schema.get("properties", {}) or {}
+        required = schema.get("required", []) or []
+
+        for param_name in required:
+            # Check if parameter appears in function signature
+            if f"{param_name}:" not in content:
+                issues.append(
+                    f"Required parameter '{param_name}' missing from function signature"
+                )
+
+        # Check that all parameters in config appear in generated code
+        for param_name in properties.keys():
+            # Parameter should appear either in signature or in kwargs
+            if f'"{param_name}"' not in content and f"{param_name}:" not in content:
+                issues.append(f"Parameter '{param_name}' missing from generated code")
+
+    except Exception as e:
+        issues.append(f"Error reading generated file: {e}")
+
+    return len(issues) == 0, issues
+
+
 def generate_tool_file(
     tool_name: str,
     tool_config: Dict[str, Any],
@@ -403,11 +452,18 @@ def _format_files(paths: List[str]) -> None:
             pass
 
 
-def main(format_enabled: Optional[bool] = None) -> None:
+def main(
+    format_enabled: Optional[bool] = None,
+    force_regenerate: bool = False,
+    verbose: bool = False,
+) -> None:
     """Generate tools and format the generated files if enabled.
 
-    If format_enabled is None, decide based on TOOLUNIVERSE_SKIP_FORMAT env var
-    (skip when set to "1").
+    Args:
+        format_enabled: If None, decide based on TOOLUNIVERSE_SKIP_FORMAT env var
+                       (skip when set to "1").
+        force_regenerate: If True, regenerate all tools regardless of changes
+        verbose: If True, print detailed change information
     """
     from tooluniverse import ToolUniverse
     from .build_optimizer import cleanup_orphaned_files, get_changed_tools
@@ -428,23 +484,64 @@ def main(format_enabled: Optional[bool] = None) -> None:
 
     # Check for changes
     metadata_file = output / ".tool_metadata.json"
-    new_tools, changed_tools, unchanged_tools = get_changed_tools(
-        tu.all_tool_dict, metadata_file
+    # Allow override via environment variable or function parameter
+    force_regenerate = force_regenerate or (
+        os.getenv("TOOLUNIVERSE_FORCE_REGENERATE") == "1"
+    )
+    verbose = verbose or (os.getenv("TOOLUNIVERSE_VERBOSE") == "1")
+
+    new_tools, changed_tools, unchanged_tools, change_details = get_changed_tools(
+        tu.all_tool_dict,
+        metadata_file,
+        force_regenerate=force_regenerate,
+        verbose=verbose,
     )
 
     generated_paths: List[str] = []
 
     # Generate only changed tools if there are changes
     if new_tools or changed_tools:
-        print(f"🔄 Generating {len(new_tools + changed_tools)} changed tools...")
+        total_changed = len(new_tools + changed_tools)
+        print(f"🔄 Generating {total_changed} changed tools...")
+        if new_tools:
+            print(f"  ✨ {len(new_tools)} new tools")
+        if changed_tools:
+            print(f"  🔄 {len(changed_tools)} modified tools")
+            if (
+                verbose and len(changed_tools) <= 20
+            ):  # Only show details for reasonable number
+                for tool_name in changed_tools[:20]:
+                    print(f"    - {tool_name}")
+                if len(changed_tools) > 20:
+                    print(f"    ... and {len(changed_tools) - 20} more")
+
+        validation_errors = []
         for i, (tool_name, tool_config) in enumerate(tu.all_tool_dict.items(), 1):
             if tool_name in new_tools or tool_name in changed_tools:
                 path = generate_tool_file(tool_name, tool_config, output)
                 generated_paths.append(str(path))
+
+                # Validate generated code matches configuration
+                is_valid, issues = validate_generated_code(tool_name, tool_config, path)
+                if not is_valid:
+                    validation_errors.extend([(tool_name, issue) for issue in issues])
+                    if verbose:
+                        print(f"  ⚠️  Validation issues for {tool_name}:")
+                        for issue in issues:
+                            print(f"      - {issue}")
+
             if i % 50 == 0:
-                print(f"  Processed {i} tools...")
+                print(f"  Processed {i}/{len(tu.all_tool_dict)} tools...")
+
+        if validation_errors:
+            print(f"\n⚠️  Found {len(validation_errors)} validation issue(s):")
+            for tool_name, issue in validation_errors[:10]:  # Show first 10
+                print(f"  - {tool_name}: {issue}")
+            if len(validation_errors) > 10:
+                print(f"  ... and {len(validation_errors) - 10} more issues")
     else:
         print("✨ No changes detected, skipping tool generation")
+        print(f"  📊 Status: {len(unchanged_tools)} tools unchanged")
 
     # Always regenerate __init__.py to include all tools
     init_path = generate_init(list(tu.all_tool_dict.keys()), output)
@@ -477,5 +574,20 @@ if __name__ == "__main__":
         action="store_true",
         help="Do not run formatters on generated files",
     )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Force regeneration of all tools regardless of changes",
+    )
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Print detailed change information",
+    )
     args = parser.parse_args()
-    main(format_enabled=not args.no_format)
+    main(
+        format_enabled=not args.no_format,
+        force_regenerate=args.force,
+        verbose=args.verbose,
+    )