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

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,
+    )

tooluniverse/gtex_tool.py

@@ -0,0 +1,168 @@
+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(
+    "GTExExpressionTool",
+    config={
+        "name": "GTEx_get_expression_summary",
+        "type": "GTExExpressionTool",
+        "description": "Get GTEx expression summary for a gene via /expression/geneExpression",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "ensembl_gene_id": {
+                    "type": "string",
+                    "description": "Ensembl gene ID, e.g., ENSG00000141510",
+                }
+            },
+            "required": ["ensembl_gene_id"],
+        },
+        "settings": {"base_url": "https://gtexportal.org/api/v2", "timeout": 30},
+    },
+)
+class GTExExpressionTool:
+    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://gtexportal.org/api/v2"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        query = {"gencodeId": arguments.get("ensembl_gene_id")}
+        url = f"{base}/expression/geneExpression?{urlencode(query)}"
+        try:
+            api_response = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            # Wrap API response to match schema: data.geneExpression should be array
+            # API returns {"data": [...], "paging_info": {...}}
+            # Schema expects {"data": {"geneExpression": [...]}}
+            if isinstance(api_response, dict) and "data" in api_response:
+                wrapped_data = {"geneExpression": api_response.get("data", [])}
+            else:
+                # Fallback if response format is unexpected
+                wrapped_data = {
+                    "geneExpression": (
+                        api_response if isinstance(api_response, list) else []
+                    )
+                }
+
+            return {
+                "source": "GTEx",
+                "endpoint": "expression/geneExpression",
+                "query": query,
+                "data": wrapped_data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "GTEx",
+                "endpoint": "expression/geneExpression",
+                "success": False,
+            }
+
+
+@register_tool(
+    "GTExEQTLTool",
+    config={
+        "name": "GTEx_query_eqtl",
+        "type": "GTExEQTLTool",
+        "description": "Query GTEx single-tissue eQTL via /association/singleTissueEqtl",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "ensembl_gene_id": {
+                    "type": "string",
+                    "description": "Ensembl gene ID, e.g., ENSG00000141510",
+                },
+                "page": {
+                    "type": "integer",
+                    "default": 1,
+                    "minimum": 1,
+                    "description": "Page number (1-based)",
+                },
+                "size": {
+                    "type": "integer",
+                    "default": 10,
+                    "minimum": 1,
+                    "maximum": 100,
+                    "description": "Page size (1–100)",
+                },
+            },
+            "required": ["ensembl_gene_id"],
+        },
+        "settings": {"base_url": "https://gtexportal.org/api/v2", "timeout": 30},
+    },
+)
+class GTExEQTLTool:
+    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://gtexportal.org/api/v2"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        query: Dict[str, Any] = {
+            "gencodeId": arguments.get("ensembl_gene_id"),
+        }
+        if "page" in arguments:
+            query["page"] = int(arguments["page"])
+        if "size" in arguments:
+            query["pageSize"] = int(arguments["size"])
+
+        url = f"{base}/association/singleTissueEqtl?{urlencode(query)}"
+        try:
+            api_response = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            # Wrap API response to match schema: data.singleTissueEqtl should be array
+            # API returns {"data": [...], "paging_info": {...}}
+            # Schema expects {"data": {"singleTissueEqtl": [...]}}
+            if isinstance(api_response, dict) and "data" in api_response:
+                wrapped_data = {"singleTissueEqtl": api_response.get("data", [])}
+            else:
+                # Fallback if response format is unexpected
+                wrapped_data = {
+                    "singleTissueEqtl": (
+                        api_response if isinstance(api_response, list) else []
+                    )
+                }
+
+            return {
+                "source": "GTEx",
+                "endpoint": "association/singleTissueEqtl",
+                "query": query,
+                "data": wrapped_data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "GTEx",
+                "endpoint": "association/singleTissueEqtl",
+                "success": False,
+            }