tooluniverse 1.0.7__py3-none-any.whl → 1.0.9__py3-none-any.whl

tooluniverse/generate_tools.py

@@ -1,8 +1,11 @@
 #!/usr/bin/env python3
 """Minimal tools generator - one tool, one file."""
 
+import os
+import shutil
+import subprocess
 from pathlib import Path
-from typing import Dict, Any
+from typing import Dict, Any, Optional, List
 
 
 def json_type_to_python(json_type: str) -> str:
@@ -17,7 +20,11 @@ def json_type_to_python(json_type: str) -> str:
     }.get(json_type, "Any")
 
 
-def generate_tool_file(tool_name: str, tool_config: Dict[str, Any], output_dir: Path):
+def generate_tool_file(
+    tool_name: str,
+    tool_config: Dict[str, Any],
+    output_dir: Path,
+) -> Path:
     """Generate one file for one tool."""
     schema = tool_config.get("parameter", {}) or {}
     description = tool_config.get("description", f"Execute {tool_name}")
@@ -48,7 +55,9 @@ def generate_tool_file(tool_name: str, tool_config: Dict[str, Any], output_dir:
                     # Use None as default and handle in function body
                     optional_params.append(f"{name}: Optional[{py_type}] = None")
                     mutable_defaults_code.append(
-                        f"    if {name} is None:\n        {name} = {repr(default)}"
+                        ("    if {n} is None:\n" "        {n} = {d}").format(
+                            n=name, d=repr(default)
+                        )
                     )
                 else:
                     optional_params.append(
@@ -75,9 +84,10 @@ def generate_tool_file(tool_name: str, tool_config: Dict[str, Any], output_dir:
 
     # Infer return type
     return_schema = tool_config.get("return_schema", {})
-    return_type = (
-        json_type_to_python(return_schema.get("type", "")) if return_schema else "Any"
-    )
+    if return_schema:
+        return_type = json_type_to_python(return_schema.get("type", ""))
+    else:
+        return_type = "Any"
 
     content = f'''"""
 {tool_name}
@@ -131,10 +141,12 @@ def {tool_name}(
 __all__ = ["{tool_name}"]
 '''
 
-    (output_dir / f"{tool_name}.py").write_text(content)
+    output_path = output_dir / f"{tool_name}.py"
+    output_path.write_text(content)
+    return output_path
 
 
-def generate_init(tool_names: list, output_dir: Path):
+def generate_init(tool_names: list, output_dir: Path) -> Path:
     """Generate __init__.py with all imports."""
     imports = [f"from .{name} import {name}" for name in sorted(tool_names)]
 
@@ -167,12 +179,238 @@ __all__ = [
 ]
 '''
 
-    (output_dir / "__init__.py").write_text(content)
+    init_path = output_dir / "__init__.py"
+    init_path.write_text(content)
+    return init_path
+
+
+def _create_shared_client(shared_client_path: Path) -> None:
+    """Create _shared_client.py if it doesn't exist."""
+    content = '''"""
+Shared ToolUniverse client for all tools.
+
+This module provides a singleton ToolUniverse client to avoid reloading
+tools multiple times when using different tool functions.
+
+Thread Safety:
+    The shared client is thread-safe and uses double-checked locking to
+    ensure only one ToolUniverse instance is created even in multi-threaded
+    environments.
+
+Configuration:
+    You can provide custom configuration parameters that will be used during
+    the initial creation of the ToolUniverse instance. These parameters are
+    ignored if the client has already been initialized.
+
+Custom Instance:
+    You can provide your own ToolUniverse instance to be used instead of
+    the shared singleton. This is useful when you need specific configurations
+    or want to maintain separate instances.
+
+Examples:
+    Basic usage (default behavior):
+        from tooluniverse.tools import get_shared_client
+        client = get_shared_client()
+
+    With custom configuration (only effective on first call):
+        client = get_shared_client(hooks_enabled=True, log_level="INFO")
+
+    Using your own instance:
+        my_tu = ToolUniverse(hooks_enabled=True)
+        client = get_shared_client(custom_instance=my_tu)
+
+    Reset for testing:
+        from tooluniverse.tools import reset_shared_client
+        reset_shared_client()
+"""
+
+import threading
+from typing import Optional
+from tooluniverse import ToolUniverse
+
+_client: Optional[ToolUniverse] = None
+_client_lock = threading.Lock()
 
 
-def main():
-    """Generate tools."""
+def get_shared_client(
+    custom_instance: Optional[ToolUniverse] = None, **config_kwargs
+) -> ToolUniverse:
+    """
+    Get the shared ToolUniverse client instance.
+
+    This function implements a thread-safe singleton pattern with support for
+    custom configurations and external instances.
+
+    Args:
+        custom_instance: Optional ToolUniverse instance to use instead of
+                        the shared singleton. If provided, this instance
+                        will be returned directly without any singleton logic.
+
+        **config_kwargs: Optional configuration parameters to pass to
+                        ToolUniverse constructor. These are only used during
+                        the initial creation of the shared instance. If the
+                        shared instance already exists, these parameters are
+                        ignored.
+
+    Returns:
+        ToolUniverse: The client instance to use for tool execution
+
+    Thread Safety:
+        This function is thread-safe. Multiple threads can call this function
+        concurrently without risk of creating multiple ToolUniverse instances.
+
+    Configuration:
+        Configuration parameters are only applied during the initial creation
+        of the shared instance. Subsequent calls with different parameters
+        will not affect the already-created instance.
+
+    Examples:
+        # Basic usage
+        client = get_shared_client()
+
+        # With custom configuration (only effective on first call)
+        client = get_shared_client(hooks_enabled=True, log_level="DEBUG")
+
+        # Using your own instance
+        my_tu = ToolUniverse(hooks_enabled=True)
+        client = get_shared_client(custom_instance=my_tu)
+    """
+    # If user provides their own instance, use it directly
+    if custom_instance is not None:
+        return custom_instance
+
+    global _client
+
+    # Double-checked locking pattern for thread safety
+    if _client is None:
+        with _client_lock:
+            # Check again inside the lock to avoid race conditions
+            if _client is None:
+                # Create new instance with provided configuration
+                if config_kwargs:
+                    _client = ToolUniverse(**config_kwargs)
+                else:
+                    _client = ToolUniverse()
+                _client.load_tools()
+
+    return _client
+
+
+def reset_shared_client():
+    """
+    Reset the shared client (useful for testing or when you need to reload).
+
+    This function clears the shared client instance, allowing a new instance
+    to be created on the next call to get_shared_client(). This is primarily
+    useful for testing scenarios where you need to ensure a clean state.
+
+    Thread Safety:
+        This function is thread-safe and uses the same lock as
+        get_shared_client() to ensure proper synchronization.
+
+    Warning:
+        Calling this function while other threads are using the shared client
+        may cause unexpected behavior. It's recommended to only call this
+        function when you're certain no other threads are accessing the client.
+
+    Examples:
+        # Reset for testing
+        reset_shared_client()
+
+        # Now get_shared_client() will create a new instance
+        client = get_shared_client(hooks_enabled=True)
+    """
+    global _client
+
+    with _client_lock:
+        _client = None
+'''
+    shared_client_path.write_text(content)
+
+
+def _chunked(sequence: List[str], chunk_size: int) -> List[List[str]]:
+    """Yield chunks of the sequence with up to chunk_size elements."""
+    if chunk_size <= 0:
+        return [sequence]
+    return [sequence[i : i + chunk_size] for i in range(0, len(sequence), chunk_size)]
+
+
+def _format_files(paths: List[str]) -> None:
+    """Format files using pre-commit if available, else ruff/autoflake/black.
+
+    Honors TOOLUNIVERSE_SKIP_FORMAT=1 to skip formatting entirely.
+    """
+    if not paths:
+        return
+    if os.getenv("TOOLUNIVERSE_SKIP_FORMAT") == "1":
+        return
+
+    pre_commit = shutil.which("pre-commit")
+    if pre_commit:
+        # Run pre-commit on specific files to match repo config filters
+        for batch in _chunked(paths, 80):
+            try:
+                subprocess.run(
+                    [pre_commit, "run", "--files", *batch],
+                    check=False,
+                )
+            except Exception:
+                # Best-effort; continue to fallback below
+                pass
+        return
+
+    # Fallback to direct formatter CLIs in the same spirit/order as hooks
+    ruff = shutil.which("ruff")
+    if ruff:
+        try:
+            subprocess.run(
+                [
+                    ruff,
+                    "--fix",
+                    "--line-length=88",
+                    "--ignore=E203",
+                    *paths,
+                ],
+                check=False,
+            )
+        except Exception:
+            pass
+
+    autoflake = shutil.which("autoflake")
+    if autoflake:
+        try:
+            subprocess.run(
+                [
+                    autoflake,
+                    "--remove-all-unused-imports",
+                    "--remove-unused-variables",
+                    "--in-place",
+                    *paths,
+                ],
+                check=False,
+            )
+        except Exception:
+            pass
+
+    black = shutil.which("black")
+    if black:
+        try:
+            subprocess.run(
+                [black, "--line-length=88", *paths],
+                check=False,
+            )
+        except Exception:
+            pass
+
+
+def main(format_enabled: Optional[bool] = None) -> 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").
+    """
     from tooluniverse import ToolUniverse
+    from .build_optimizer import cleanup_orphaned_files, get_changed_tools
 
     print("🔧 Generating tools...")
 
@@ -182,17 +420,62 @@ def main():
     output = Path("src/tooluniverse/tools")
     output.mkdir(parents=True, exist_ok=True)
 
-    # Generate all tools
-    for i, (tool_name, tool_config) in enumerate(tu.all_tool_dict.items(), 1):
-        generate_tool_file(tool_name, tool_config, output)
-        if i % 50 == 0:
-            print(f"  Generated {i} tools...")
+    # Cleanup orphaned files
+    current_tool_names = set(tu.all_tool_dict.keys())
+    cleaned_count = cleanup_orphaned_files(output, current_tool_names)
+    if cleaned_count > 0:
+        print(f"🧹 Removed {cleaned_count} orphaned tool files")
+
+    # Check for changes
+    metadata_file = output / ".tool_metadata.json"
+    new_tools, changed_tools, unchanged_tools = get_changed_tools(
+        tu.all_tool_dict, metadata_file
+    )
 
-    # Generate __init__.py
-    generate_init(list(tu.all_tool_dict.keys()), output)
+    generated_paths: List[str] = []
 
-    print(f"✅ Generated {len(tu.all_tool_dict)} tools in {output}")
+    # Generate only changed tools if there are changes
+    if new_tools or changed_tools:
+        print(f"🔄 Generating {len(new_tools + changed_tools)} changed tools...")
+        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))
+            if i % 50 == 0:
+                print(f"  Processed {i} tools...")
+    else:
+        print("✨ No changes detected, skipping tool generation")
+
+    # Always regenerate __init__.py to include all tools
+    init_path = generate_init(list(tu.all_tool_dict.keys()), output)
+    generated_paths.append(str(init_path))
+
+    # Always ensure _shared_client.py exists
+    shared_client_path = output / "_shared_client.py"
+    if not shared_client_path.exists():
+        _create_shared_client(shared_client_path)
+        generated_paths.append(str(shared_client_path))
+
+    # Determine formatting behavior
+    if format_enabled is None:
+        # Enabled unless explicitly opted-out via env
+        format_enabled = os.getenv("TOOLUNIVERSE_SKIP_FORMAT") != "1"
+
+    if format_enabled:
+        _format_files(generated_paths)
+
+    print(f"✅ Generated {len(generated_paths)} files in {output}")
 
 
 if __name__ == "__main__":
-    main()
+    # Lightweight CLI to allow opting out of formatting when run directly
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Generate ToolUniverse tools")
+    parser.add_argument(
+        "--no-format",
+        action="store_true",
+        help="Do not run formatters on generated files",
+    )
+    args = parser.parse_args()
+    main(format_enabled=not args.no_format)

tooluniverse/genomics_gene_search_tool.py

@@ -0,0 +1,56 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("GWASGeneSearch")
+class GWASGeneSearch(BaseTool):
+    """
+    Local tool wrapper for GWAS Catalog REST API.
+    Searches associations by gene name.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.base_url = "https://www.ebi.ac.uk/gwas/rest/api"
+        self.session = requests.Session()
+        self.session.headers.update(
+            {"Accept": "application/json", "Content-Type": "application/json"}
+        )
+
+    def run(self, arguments):
+        gene_name = arguments.get("gene_name")
+        if not gene_name:
+            return {"error": "Missing required parameter: gene_name"}
+
+        # Search for associations by gene name
+        url = f"{self.base_url}/v2/associations"
+        params = {"mapped_gene": gene_name, "size": 20, "page": 0}
+
+        try:
+            response = self.session.get(url, params=params, timeout=30)
+            response.raise_for_status()
+            data = response.json()
+
+            # Extract associations from _embedded structure
+            associations = []
+            if "_embedded" in data and "associations" in data["_embedded"]:
+                associations = data["_embedded"]["associations"]
+
+            return {
+                "gene_name": gene_name,
+                "association_count": len(associations),
+                "associations": (
+                    associations[:5] if associations else []
+                ),  # Return first 5
+                "total_found": (
+                    data.get("page", {}).get("totalElements", 0)
+                    if "page" in data
+                    else 0
+                ),
+            }
+
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Request failed: {str(e)}"}
+        except Exception as e:
+            return {"error": f"Unexpected error: {str(e)}"}

tooluniverse/geo_tool.py

@@ -0,0 +1,116 @@
+"""
+GEO Database REST API Tool
+
+This tool provides access to gene expression data from the GEO database.
+GEO is a public repository that archives and freely distributes microarray,
+next-generation sequencing, and other forms of high-throughput functional
+genomics data.
+"""
+
+import requests
+from typing import Dict, Any, List
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+GEO_BASE_URL = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
+
+
+@register_tool("GEORESTTool")
+class GEORESTTool(BaseTool):
+    """
+    GEO Database REST API tool.
+    Generic wrapper for GEO API endpoints defined in expression_tools.json.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        fields = tool_config.get("fields", {})
+        parameter = tool_config.get("parameter", {})
+
+        self.endpoint_template: str = fields.get("endpoint", "/esearch.fcgi")
+        self.required: List[str] = parameter.get("required", [])
+        self.output_format: str = fields.get("return_format", "JSON")
+
+    def _build_url(self, arguments: Dict[str, Any]) -> str | Dict[str, Any]:
+        """Build URL for GEO API request."""
+        url_path = self.endpoint_template
+        return GEO_BASE_URL + url_path
+
+    def _build_params(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Build parameters for GEO API request."""
+        params = {"db": "gds", "retmode": "json", "retmax": 50}
+
+        # Build search query
+        query_parts = []
+        if "query" in arguments:
+            query_parts.append(arguments["query"])
+
+        if "organism" in arguments:
+            organism = arguments["organism"]
+            if organism.lower() == "homo sapiens":
+                query_parts.append("Homo sapiens[organism]")
+            elif organism.lower() == "mus musculus":
+                query_parts.append("Mus musculus[organism]")
+            else:
+                query_parts.append(f'"{organism}"[organism]')
+
+        if "study_type" in arguments:
+            study_type = arguments["study_type"]
+            query_parts.append(f'"{study_type}"[study_type]')
+
+        if "platform" in arguments:
+            platform = arguments["platform"]
+            query_parts.append(f'"{platform}"[platform]')
+
+        if "date_range" in arguments:
+            date_range = arguments["date_range"]
+            if ":" in date_range:
+                start_year, end_year = date_range.split(":")
+                query_parts.append(f'"{start_year}"[PDAT] : "{end_year}"[PDAT]')
+
+        if query_parts:
+            params["term"] = " AND ".join(query_parts)
+
+        if "limit" in arguments:
+            params["retmax"] = min(arguments["limit"], 500)
+
+        if "sort" in arguments:
+            sort = arguments["sort"]
+            if sort == "date":
+                params["sort"] = "relevance"
+            elif sort == "title":
+                params["sort"] = "title"
+            else:
+                params["sort"] = "relevance"
+
+        return params
+
+    def _make_request(self, url: str, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Perform a GET request and handle common errors."""
+        try:
+            response = requests.get(url, params=params, timeout=30)
+            response.raise_for_status()
+
+            if self.output_format == "JSON":
+                return response.json()
+            else:
+                return {"data": response.text}
+
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Request failed: {str(e)}"}
+        except Exception as e:
+            return {"error": f"Unexpected error: {str(e)}"}
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the tool with given arguments."""
+        # Validate required parameters
+        for param in self.required:
+            if param not in arguments:
+                return {"error": f"Missing required parameter: {param}"}
+
+        url = self._build_url(arguments)
+        if isinstance(url, dict) and "error" in url:
+            return url
+
+        params = self._build_params(arguments)
+        return self._make_request(url, params)

tooluniverse/gnomad_tool.py

@@ -0,0 +1,63 @@
+import requests
+import json
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("GnomadTool")
+class GnomadTool(BaseTool):
+    """
+    Local tool wrapper for gnomAD GraphQL API.
+    Queries variant information including allele frequencies.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.base = "https://gnomad.broadinstitute.org/api"
+        self.session = requests.Session()
+        self.session.headers.update({"Content-Type": "application/json"})
+
+    def run(self, arguments):
+        variant_id = arguments.get("variant_id")
+        dataset = arguments.get("dataset", "gnomad_r4")
+
+        if not variant_id:
+            return {"error": "Missing required parameter: variant_id"}
+
+        # GraphQL query for variant with genome frequencies
+        query = """
+        query($variant: String!, $dataset: DatasetId!) {
+            variant(variantId: $variant, dataset: $dataset) {
+                variantId
+                genome {
+                    ac
+                    an
+                    af
+                }
+            }
+        }
+        """
+
+        payload = {
+            "query": query,
+            "variables": {
+                "variant": variant_id,
+                "dataset": dataset,
+            },
+        }
+
+        resp = self.session.post(self.base, data=json.dumps(payload), timeout=30)
+        resp.raise_for_status()
+        data = resp.json()
+
+        if "errors" in data:
+            return {"error": f"GraphQL errors: {data['errors']}"}
+
+        variant = data.get("data", {}).get("variant")
+        if not variant:
+            return {"error": "Variant not found"}
+
+        return {
+            "variantId": variant.get("variantId"),
+            "genome": variant.get("genome", {}),
+        }

tooluniverse/logging_config.py

@@ -104,8 +104,11 @@ class ToolUniverseLogger:
 
         self._logger.setLevel(level)
 
-        # Create console handler
-        handler = logging.StreamHandler(sys.stdout)
+        # Create console handler - use stderr for stdio mode
+        output_stream = (
+            sys.stderr if os.getenv("TOOLUNIVERSE_STDIO_MODE") == "1" else sys.stdout
+        )
+        handler = logging.StreamHandler(output_stream)
         handler.setLevel(level)
 
         # Create formatter
@@ -118,6 +121,29 @@ class ToolUniverseLogger:
         # Add handler to logger
         self._logger.addHandler(handler)
 
+    def reconfigure_for_stdio(self):
+        """Reconfigure logger to output to stderr for stdio mode"""
+        # Remove existing handlers
+        for handler in self._logger.handlers[:]:
+            self._logger.removeHandler(handler)
+
+        # Get current level
+        level = self._logger.level
+
+        # Create new handler with stderr
+        handler = logging.StreamHandler(sys.stderr)
+        handler.setLevel(level)
+
+        # Create formatter
+        formatter = ToolUniverseFormatter(
+            fmt="%(message)s",
+            datefmt="%H:%M:%S",
+        )
+        handler.setFormatter(formatter)
+
+        # Add handler to logger
+        self._logger.addHandler(handler)
+
         # Prevent propagation to root logger
         self._logger.propagate = False
 
@@ -152,6 +178,42 @@ class ToolUniverseLogger:
 _logger_manager = ToolUniverseLogger()
 
 
+def reconfigure_for_stdio() -> None:
+    """
+    Reconfigure logging to output to stderr for stdio mode.
+
+    This function should be called at the very beginning of stdio mode
+    to ensure all logs go to stderr instead of stdout.
+    """
+    _logger_manager.reconfigure_for_stdio()
+    # Ensure third-party rich/traceback pretty outputs do not go to stdout
+    try:
+        import rich
+        from rich.console import Console
+
+        # Redirect rich default console to stderr in stdio mode
+        rich_console = Console(
+            file=sys.stderr,
+            force_terminal=False,
+            markup=False,
+            highlight=False,
+            emoji=False,
+            soft_wrap=False,
+        )
+        rich.get_console = lambda: rich_console
+    except Exception:
+        pass
+    # Force Python warnings and tracebacks to stderr
+    try:
+        import warnings
+
+        warnings.showwarning = lambda *args, **kwargs: print(
+            warnings.formatwarning(*args, **kwargs), file=sys.stderr
+        )
+    except Exception:
+        pass
+
+
 def setup_logging(level: Optional[str] = None) -> None:
     """
     Setup global logging configuration