tooluniverse 1.0.10__py3-none-any.whl → 1.0.11__py3-none-any.whl

tooluniverse/file_download_tool.py

@@ -0,0 +1,269 @@
+"""
+File download tool - A curl-like tool for downloading files from URLs.
+Supports Windows, Mac, and Linux platforms.
+"""
+
+import requests
+import os
+import tempfile
+from urllib.parse import urlparse
+from typing import Dict, Any
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("FileDownloadTool")
+class FileDownloadTool(BaseTool):
+    """
+    Download files from HTTP/HTTPS URLs - similar to curl.
+
+    Supports:
+    - Direct file downloads to specified or temporary locations
+    - Binary and text file handling
+    - Progress tracking (optional)
+    - Cross-platform (Windows, Mac, Linux)
+
+    Expects: {"url": "https://...", "output_path": "/path/to/save"}
+    Optional: {"timeout": seconds, "return_content": bool}
+    Returns: {"file_path": "...", "file_size": bytes} or {"error": "..."}
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        fields = tool_config.get("fields", {})
+        self.return_key = fields.get("return_key", "file_path")
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Download a file from a URL.
+
+        Args:
+            arguments: Dictionary containing:
+                - url (str): URL to download from
+                - output_path (str, optional): Path to save the file
+                - timeout (int, optional): Request timeout (default: 30)
+                - return_content (bool): Return as text (default: False)
+                - chunk_size (int, optional): Chunk size (default: 8192)
+                - follow_redirects (bool): Follow redirects (default: True)
+        Returns:
+            Dict with file_path and file_size, or content, or error
+        """
+        url = arguments.get("url")
+        if not url:
+            return {"error": "Parameter 'url' is required."}
+
+        if not (url.startswith("http://") or url.startswith("https://")):
+            return {"error": "URL must start with http:// or https://"}
+
+        # Parse parameters
+        output_path = arguments.get("output_path")
+        timeout = arguments.get("timeout", 30)
+        return_content = arguments.get("return_content", False)
+        chunk_size = arguments.get("chunk_size", 8192)
+        follow_redirects = arguments.get("follow_redirects", True)
+
+        # Determine output path
+        if output_path:
+            output_path = self._normalize_path(output_path)
+            output_dir = os.path.dirname(output_path)
+            if output_dir and not os.path.exists(output_dir):
+                try:
+                    os.makedirs(output_dir, exist_ok=True)
+                except Exception as e:
+                    return {"error": f"Failed to create directory: {e}"}
+        else:
+            temp_dir = tempfile.gettempdir()
+            parsed_url = urlparse(url)
+            filename = os.path.basename(parsed_url.path) or "downloaded_file"
+            filename = filename.split("?")[0]
+            if not filename:
+                filename = "downloaded_file"
+            output_path = os.path.join(temp_dir, filename)
+        try:
+            response = requests.get(
+                url, timeout=timeout, allow_redirects=follow_redirects, stream=True
+            )
+            response.raise_for_status()
+
+            if return_content:
+                content = response.text
+                content_type = response.headers.get("Content-Type", "").lower()
+                return {
+                    "content": content,
+                    "content_type": content_type,
+                    "size": len(content),
+                    "url": url,
+                }
+
+            file_size = 0
+            with open(output_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=chunk_size):
+                    if chunk:
+                        f.write(chunk)
+                        file_size += len(chunk)
+
+            return {
+                "file_path": output_path,
+                "file_size": file_size,
+                "url": url,
+                "content_type": response.headers.get("Content-Type", ""),
+                "status_code": response.status_code,
+            }
+
+        except requests.exceptions.Timeout:
+            return {"error": f"Request timed out after {timeout} seconds"}
+        except requests.exceptions.HTTPError as e:
+            return {"error": f"HTTP error: {e}"}
+        except requests.exceptions.ConnectionError as e:
+            return {"error": f"Connection error: {e}"}
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Request failed: {e}"}
+        except IOError as e:
+            return {"error": f"Failed to write file: {e}"}
+        except Exception as e:
+            return {"error": f"Unexpected error: {e}"}
+
+    def _normalize_path(self, path: str) -> str:
+        """
+        Normalize file path for cross-platform compatibility.
+
+        Args:
+            path: File path to normalize
+
+        Returns:
+            Normalized path
+        """
+        path = os.path.expanduser(path)
+        path = os.path.expandvars(path)
+
+        if not os.path.isabs(path):
+            path = os.path.abspath(path)
+
+        return path
+
+
+@register_tool("BinaryDownloadTool")
+class BinaryDownloadTool(BaseTool):
+    """
+    Download binary files with chunked streaming.
+
+    Optimized for large binary files like images, videos, executables.
+    Supports chunked downloads for better memory management.
+
+    Expects: {"url": "https://...", "output_path": "/path/to/save"}
+    Optional: {"chunk_size": bytes, "timeout": seconds}
+    Returns: {"file_path": "...", "size": bytes, "content_type": "..."}
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Download binary file from URL.
+
+        Args:
+            arguments: Dictionary containing url and optional parameters
+
+        Returns:
+            Dictionary with file_path and metadata, or error
+        """
+        url = arguments.get("url")
+        if not url:
+            return {"error": "Parameter 'url' is required."}
+
+        output_path = arguments.get("output_path")
+        if not output_path:
+            msg = "Parameter 'output_path' is required for binary downloads."
+            return {"error": msg}
+
+        timeout = arguments.get("timeout", 30)
+        # 1MB chunks for binary files
+        chunk_size = arguments.get("chunk_size", 1024 * 1024)
+
+        output_path = os.path.expanduser(output_path)
+        output_path = os.path.expandvars(output_path)
+
+        output_dir = os.path.dirname(output_path)
+        if output_dir and not os.path.exists(output_dir):
+            try:
+                os.makedirs(output_dir, exist_ok=True)
+            except Exception as e:
+                return {"error": f"Failed to create directory: {e}"}
+
+        try:
+            response = requests.get(url, timeout=timeout, stream=True)
+            response.raise_for_status()
+
+            file_size = 0
+            with open(output_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=chunk_size):
+                    if chunk:
+                        f.write(chunk)
+                        file_size += len(chunk)
+
+            return {
+                "file_path": output_path,
+                "size": file_size,
+                "content_type": response.headers.get("Content-Type", ""),
+                "content_length": response.headers.get("Content-Length", ""),
+                "url": url,
+                "status_code": response.status_code,
+            }
+
+        except Exception as e:
+            return {"error": f"Failed to download binary file: {e}"}
+
+
+@register_tool("TextDownloadTool")
+class TextDownloadTool(BaseTool):
+    """
+    Download and return text content from URLs.
+
+    Optimized for text files - returns content as string directly.
+    Supports encoding detection and normalization.
+
+    Expects: {"url": "https://..."}
+    Optional: {"encoding": "utf-8", "timeout": seconds}
+    Returns: {"content": "text content", "encoding": "utf-8"}
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Download text content from URL.
+
+        Args:
+            arguments: Dictionary containing url and optional parameters
+
+        Returns:
+            Dictionary with content and encoding, or error
+        """
+        url = arguments.get("url")
+        if not url:
+            return {"error": "Parameter 'url' is required."}
+
+        timeout = arguments.get("timeout", 30)
+        encoding = arguments.get("encoding", None)  # Auto-detect if None
+
+        try:
+            response = requests.get(url, timeout=timeout)
+            response.raise_for_status()
+
+            if encoding:
+                content = response.content.decode(encoding)
+            else:
+                content = response.text
+
+            return {
+                "content": content,
+                "encoding": response.encoding,
+                "size": len(content),
+                "url": url,
+                "content_type": response.headers.get("Content-Type", ""),
+            }
+
+        except Exception as e:
+            return {"error": f"Failed to download text content: {e}"}

tooluniverse/geo_tool.py

@@ -7,18 +7,15 @@ 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 .ncbi_eutils_tool import NCBIEUtilsTool
 from .tool_registry import register_tool
 
-GEO_BASE_URL = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
-
 
 @register_tool("GEORESTTool")
-class GEORESTTool(BaseTool):
+class GEORESTTool(NCBIEUtilsTool):
     """
-    GEO Database REST API tool.
+    GEO Database REST API tool with rate limiting.
     Generic wrapper for GEO API endpoints defined in expression_tools.json.
     """
 
@@ -34,7 +31,7 @@ class GEORESTTool(BaseTool):
     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
+        return self.base_url + url_path
 
     def _build_params(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
         """Build parameters for GEO API request."""
@@ -85,22 +82,6 @@ class GEORESTTool(BaseTool):
 
         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
@@ -108,9 +89,81 @@ class GEORESTTool(BaseTool):
             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
-
+        # Set endpoint for the base class
+        self.endpoint = self.endpoint_template
         params = self._build_params(arguments)
-        return self._make_request(url, params)
+
+        # Use the parent class's _make_request with rate limiting
+        return self._make_request(self.endpoint, params)
+
+
+@register_tool("GEOSearchDatasets")
+class GEOSearchDatasets(GEORESTTool):
+    """Search GEO datasets by various criteria."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint_template = "/esearch.fcgi"
+
+    def _build_params(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Build parameters for GEO dataset search."""
+        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"]
+            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 query_parts:
+            params["term"] = " AND ".join(query_parts)
+
+        if "limit" in arguments:
+            params["retmax"] = min(arguments["limit"], 500)
+
+        return params
+
+
+@register_tool("GEOGetDatasetInfo")
+class GEOGetDatasetInfo(GEORESTTool):
+    """Get detailed information about a specific GEO dataset."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint_template = "/esummary.fcgi"
+
+    def _build_params(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Build parameters for GEO dataset info retrieval."""
+        dataset_id = arguments.get("dataset_id", "")
+        if not dataset_id:
+            return {"error": "dataset_id is required"}
+
+        return {"db": "gds", "id": dataset_id, "retmode": "json"}
+
+
+@register_tool("GEOGetSampleInfo")
+class GEOGetSampleInfo(GEORESTTool):
+    """Get sample information for a GEO dataset."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint_template = "/esummary.fcgi"
+
+    def _build_params(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Build parameters for GEO sample info retrieval."""
+        dataset_id = arguments.get("dataset_id", "")
+        if not dataset_id:
+            return {"error": "dataset_id is required"}
+
+        return {"db": "gds", "id": dataset_id, "retmode": "json"}

tooluniverse/gnomad_tool.py

@@ -1,63 +1,111 @@
+"""
+gnomAD GraphQL API Tool
+
+This tool provides access to the gnomAD (Genome Aggregation Database) for
+population genetics data, variant frequencies, and gene constraint metrics using GraphQL.
+"""
+
 import requests
-import json
+from typing import Dict, Any
 from .base_tool import BaseTool
 from .tool_registry import register_tool
+from .graphql_tool import execute_query
 
 
-@register_tool("GnomadTool")
-class GnomadTool(BaseTool):
-    """
-    Local tool wrapper for gnomAD GraphQL API.
-    Queries variant information including allele frequencies.
-    """
+class gnomADGraphQLTool(BaseTool):
+    """Base class for gnomAD GraphQL API tools."""
 
     def __init__(self, tool_config):
         super().__init__(tool_config)
-        self.base = "https://gnomad.broadinstitute.org/api"
+        self.endpoint_url = "https://gnomad.broadinstitute.org/api"
+        self.query_schema = tool_config.get("query_schema", "")
         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
+        self.session.headers.update(
+            {
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+                "User-Agent": "ToolUniverse/1.0",
+            }
+        )
+        self.timeout = 30
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute GraphQL query with given arguments."""
+        try:
+            result = execute_query(
+                endpoint_url=self.endpoint_url,
+                query=self.query_schema,
+                variables=arguments,
+            )
+
+            if result is None:
+                return {
+                    "status": "error",
+                    "error": "No data returned from gnomAD API",
+                    "data": None,
                 }
+
+            return {"status": "success", "data": result, "url": self.endpoint_url}
+
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": f"gnomAD GraphQL request failed: {str(e)}",
+                "data": None,
             }
-        }
-        """
-
-        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", {}),
-        }
+
+
+@register_tool("gnomADGetGeneConstraints")
+class gnomADGetGeneConstraints(gnomADGraphQLTool):
+    """Get gene constraint metrics from gnomAD."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        # Set default query schema if not provided in config
+        if not self.query_schema:
+            self.query_schema = """
+query GeneConstraints($geneSymbol: String!) {
+  gene(gene_symbol: $geneSymbol, reference_genome: GRCh38) {
+    symbol
+    gene_id
+    exac_constraint {
+      exp_lof
+      obs_lof
+      pLI
+      exp_mis
+      obs_mis
+      exp_syn
+      obs_syn
+    }
+    gnomad_constraint {
+      exp_lof
+      obs_lof
+      oe_lof
+      pLI
+      exp_mis
+      obs_mis
+      oe_mis
+      exp_syn
+      obs_syn
+      oe_syn
+    }
+  }
+}
+"""
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Get gene constraints."""
+        gene_symbol = arguments.get("gene_symbol", "")
+        if not gene_symbol:
+            return {"status": "error", "error": "gene_symbol is required"}
+
+        # Convert gene_symbol to geneSymbol for GraphQL variable
+        graphql_args = {"geneSymbol": gene_symbol}
+
+        result = super().run(graphql_args)
+
+        # Add gene_symbol to result for reference
+        if result.get("status") == "success":
+            result["gene_symbol"] = gene_symbol
+
+        return result

tooluniverse/gtopdb_tool.py

@@ -0,0 +1,41 @@
+import requests
+from typing import Any, Dict
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("GtoPdbRESTTool")
+class GtoPdbRESTTool(BaseTool):
+    def __init__(self, tool_config: Dict):
+        super().__init__(tool_config)
+        self.base_url = "https://www.guidetopharmacology.org/services"
+        self.session = requests.Session()
+        self.session.headers.update({"Accept": "application/json"})
+        self.timeout = 30
+
+    def _build_url(self, args: Dict[str, Any]) -> str:
+        url = self.tool_config["fields"]["endpoint"]
+        for k, v in args.items():
+            url = url.replace(f"{{{k}}}", str(v))
+        return url
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            url = self._build_url(arguments)
+            response = self.session.get(url, timeout=self.timeout)
+            response.raise_for_status()
+            data = response.json()
+
+            # Apply limit if specified
+            limit = arguments.get("limit", 20)
+            if isinstance(data, list) and len(data) > limit:
+                data = data[:limit]
+
+            return {
+                "status": "success",
+                "data": data,
+                "url": url,
+                "count": len(data) if isinstance(data, list) else 1,
+            }
+        except Exception as e:
+            return {"status": "error", "error": f"GtoPdb API error: {str(e)}"}

tooluniverse/interpro_tool.py

@@ -0,0 +1,72 @@
+import requests
+from typing import Any, Dict
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("InterProRESTTool")
+class InterProRESTTool(BaseTool):
+    def __init__(self, tool_config: Dict):
+        super().__init__(tool_config)
+        self.base_url = "https://www.ebi.ac.uk/interpro/api"
+        self.session = requests.Session()
+        self.session.headers.update(
+            {"Accept": "application/json", "User-Agent": "ToolUniverse/1.0"}
+        )
+        self.timeout = 30
+
+    def _build_url(self, args: Dict[str, Any]) -> str:
+        """Build URL from endpoint template and arguments"""
+        url = self.tool_config["fields"]["endpoint"]
+        for k, v in args.items():
+            url = url.replace(f"{{{k}}}", str(v))
+        return url
+
+    def _extract_data(self, data: Dict, extract_path: str = None) -> Any:
+        """Extract specific data from API response"""
+        if not extract_path:
+            return data
+
+        # Handle specific InterPro extraction patterns
+        if extract_path == "results":
+            return data.get("results", [])
+        elif extract_path == "count":
+            return data.get("count", 0)
+        elif extract_path == "metadata":
+            return data.get("metadata", {})
+
+        return data
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the InterPro API call"""
+        try:
+            # Build URL from endpoint template
+            url = self._build_url(arguments)
+
+            # Make API request
+            response = self.session.get(url, timeout=self.timeout)
+            response.raise_for_status()
+
+            # Parse JSON response
+            data = response.json()
+
+            # Extract data if specified
+            extract_path = self.tool_config["fields"].get("extract_path")
+            if extract_path:
+                result = self._extract_data(data, extract_path)
+            else:
+                result = data
+
+            return {
+                "status": "success",
+                "data": result,
+                "url": url,
+                "count": len(result) if isinstance(result, list) else 1,
+            }
+
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": f"InterPro API error: {str(e)}",
+                "url": url,
+            }