spice-mcp 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

spice_mcp/adapters/dune/client.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import os
-import re
 import time
 from collections.abc import Mapping, Sequence
 from typing import Any
@@ -24,6 +23,10 @@ from ...polars_utils import collect_preview
 from ..http_client import HttpClient, HttpClientConfig
 from . import extract, urls
 
+# Use wrapper to avoid FastMCP detecting overloads in extract.query()
+# Note: We still import extract for _determine_input_type and other non-overloaded functions
+from .query_wrapper import execute_query as _execute_dune_query
+
 
 class DuneAdapter(QueryExecutor, CatalogExplorer):
     """Thin façade around the vendored extract module."""
@@ -43,11 +46,10 @@ class DuneAdapter(QueryExecutor, CatalogExplorer):
         self._ensure_api_key()
         start = time.time()
         q = request.query
-        if isinstance(q, str):
-            q_rewritten = _maybe_rewrite_show_sql(q)
-            if q_rewritten is not None:
-                q = q_rewritten
-        result = extract.query(
+        # Use native SHOW statements directly - they're faster than information_schema queries
+        # See issue #10: https://github.com/Evan-Kim2028/spice-mcp/issues/10
+        # Removed rewrite to avoid performance issues with information_schema queries
+        result = _execute_dune_query(
             query_or_execution=q,
             verbose=False,
             refresh=request.refresh,
@@ -123,9 +125,10 @@ class DuneAdapter(QueryExecutor, CatalogExplorer):
                     pass
 
             url = urls.get_query_results_url(query_id, parameters=params, csv=False)
+            from .user_agent import get_user_agent
             headers = {
                 "X-Dune-API-Key": self._api_key(),
-                "User-Agent": extract.get_user_agent(),
+                "User-Agent": get_user_agent(),
             }
             try:
                 resp = self._http.request("GET", url, headers=headers)
@@ -195,9 +198,11 @@ class DuneAdapter(QueryExecutor, CatalogExplorer):
     # Internal helpers --------------------------------------------------------------
     def _run_sql(self, sql: str, *, limit: int | None = None) -> pl.DataFrame:
         self._ensure_api_key()
-        sql_eff = _maybe_rewrite_show_sql(sql) or sql
-        df = extract.query(
-            sql_eff,
+        # Use native SHOW statements directly - they're faster than information_schema queries
+        # See issue #10: https://github.com/Evan-Kim2028/spice-mcp/issues/10
+        sql_eff = sql
+        df = _execute_dune_query(
+            query_or_execution=sql_eff,
             verbose=False,
             performance="medium",
             timeout_seconds=self.config.default_timeout_seconds,
@@ -228,28 +233,12 @@ def _build_preview(lf: pl.LazyFrame, columns: list[str], rowcount: int) -> Resul
 
 
 def _maybe_rewrite_show_sql(sql: str) -> str | None:
-    """Rewrite certain SHOW statements to information_schema SELECTs for portability.
-
-    This allows running discovery-style commands through the parameterized raw SQL
-    template which expects SELECT statements.
+    """DEPRECATED: This function is no longer used.
+    
+    Native SHOW statements are now used directly as they're faster than
+    information_schema queries in Dune. See issue #10 for details.
+    
+    This function is kept for backward compatibility but is not called.
     """
-    s = sql.strip()
-    m = re.match(r"^SHOW\s+SCHEMAS\s+LIKE\s+'([^']+)'\s*;?$", s, flags=re.IGNORECASE)
-    if m:
-        pat = m.group(1)
-        return (
-            "SELECT schema_name AS Schema FROM information_schema.schemata "
-            f"WHERE schema_name LIKE '{pat}'"
-        )
-    if re.match(r"^SHOW\s+SCHEMAS\s*;?$", s, flags=re.IGNORECASE):
-        return "SELECT schema_name AS Schema FROM information_schema.schemata"
-
-    m = re.match(r"^SHOW\s+TABLES\s+FROM\s+([A-Za-z0-9_\.]+)\s*;?$", s, flags=re.IGNORECASE)
-    if m:
-        schema = m.group(1)
-        return (
-            "SELECT table_name AS Table FROM information_schema.tables "
-            f"WHERE table_schema = '{schema}'"
-        )
-
+    # Function body kept for reference but not executed
     return None

spice_mcp/adapters/dune/extract.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import io
+import os
 import time
 from typing import TYPE_CHECKING, overload
-import os
 
 from ..http_client import HttpClient
 from . import cache as _cache
@@ -289,6 +289,14 @@ def query(
 
         # execute or retrieve query
         if query_id:
+            # Check if this is a parameterized query (raw SQL via template or parameterized query)
+            # For parameterized queries, results don't exist until execution, so skip GET attempt
+            is_parameterized = (
+                parameters is not None 
+                and len(parameters) > 0 
+                and ('query' in parameters or any(k != 'query' for k in parameters))
+            )
+            
             if cache and load_from_cache and not refresh:
                 cache_result, cache_execution = _cache.load_from_cache(
                     execute_kwargs, result_kwargs, output_kwargs
@@ -301,7 +309,8 @@ def query(
                 age = get_query_latest_age(**execute_kwargs, verbose=verbose)  # type: ignore
                 if age is None or age > max_age:
                     refresh = True
-            if not refresh:
+            # Skip GET results attempt for parameterized queries - they need execution first
+            if not refresh and not is_parameterized:
                 df = get_results(**execute_kwargs, **result_kwargs)
                 if df is not None:
                     return process_result(df, execution, **output_kwargs)
@@ -334,9 +343,44 @@ def query(
             return execution
 
 
-@overload
-@overload
-@overload
+if TYPE_CHECKING:
+    @overload
+    def _process_result(
+        df: pl.DataFrame,
+        execution: Execution | None,
+        execute_kwargs: ExecuteKwargs,
+        result_kwargs: RetrievalKwargs,
+        cache: bool,
+        save_to_cache: bool,
+        cache_dir: str | None,
+        include_execution: Literal[False],
+    ) -> pl.DataFrame: ...
+
+    @overload
+    def _process_result(
+        df: pl.DataFrame,
+        execution: Execution | None,
+        execute_kwargs: ExecuteKwargs,
+        result_kwargs: RetrievalKwargs,
+        cache: bool,
+        save_to_cache: bool,
+        cache_dir: str | None,
+        include_execution: Literal[True],
+    ) -> tuple[pl.DataFrame, Execution]: ...
+
+    @overload
+    def _process_result(
+        df: pl.DataFrame,
+        execution: Execution | None,
+        execute_kwargs: ExecuteKwargs,
+        result_kwargs: RetrievalKwargs,
+        cache: bool,
+        save_to_cache: bool,
+        cache_dir: str | None,
+        include_execution: bool,
+    ) -> pl.DataFrame | tuple[pl.DataFrame, Execution]: ...
+
+
 def _process_result(
     df: pl.DataFrame,
     execution: Execution | None,

spice_mcp/adapters/dune/query_wrapper.py

@@ -0,0 +1,86 @@
+"""Wrapper for extract.query() to avoid FastMCP overload detection.
+
+This module provides a clean interface to extract.query() without exposing
+the @overload decorators that FastMCP detects during runtime validation.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from ..http_client import HttpClient
+from .types import Execution, Performance, Query
+
+
+def execute_query(
+    query_or_execution: Query | Execution,
+    *,
+    verbose: bool = True,
+    refresh: bool = False,
+    max_age: float | None = None,
+    parameters: Mapping[str, Any] | None = None,
+    api_key: str | None = None,
+    performance: Performance = "medium",
+    poll: bool = True,
+    poll_interval: float = 1.0,
+    timeout_seconds: float | None = None,
+    limit: int | None = None,
+    offset: int | None = None,
+    sample_count: int | None = None,
+    sort_by: str | None = None,
+    columns: Sequence[str] | None = None,
+    extras: Mapping[str, Any] | None = None,
+    types: Sequence[type] | Mapping[str, type] | None = None,
+    all_types: Sequence[type] | Mapping[str, type] | None = None,
+    cache: bool = True,
+    cache_dir: str | None = None,
+    save_to_cache: bool = True,
+    load_from_cache: bool = True,
+    include_execution: bool = False,
+    http_client: HttpClient | None = None,
+) -> Any:
+    """
+    Execute a Dune query without exposing overloads to FastMCP.
+    
+    This is a wrapper around extract.query() that has a single, non-overloaded
+    signature. FastMCP won't detect overloads when inspecting this function.
+    """
+    # Import here to avoid FastMCP seeing overloads during module import
+    from . import extract
+    
+    # Call the actual query function - FastMCP won't trace through this wrapper
+    try:
+        return extract.query(
+            query_or_execution=query_or_execution,
+            verbose=verbose,
+            refresh=refresh,
+            max_age=max_age,
+            parameters=parameters,
+            api_key=api_key,
+            performance=performance,
+            poll=poll,
+            poll_interval=poll_interval,
+            timeout_seconds=timeout_seconds,
+            limit=limit,
+            offset=offset,
+            sample_count=sample_count,
+            sort_by=sort_by,
+            columns=columns,
+            extras=extras,
+            types=types,
+            all_types=all_types,
+            cache=cache,
+            cache_dir=cache_dir,
+            save_to_cache=save_to_cache,
+            load_from_cache=load_from_cache,
+            include_execution=include_execution,
+            http_client=http_client,
+        )
+    except NotImplementedError as exc:
+        # Provide additional context to help diagnose overload issues
+        raise RuntimeError(
+            "Underlying extract.query() raised NotImplementedError. "
+            "This suggests we're calling an overloaded stub."
+        ) from exc
+

spice_mcp/adapters/dune/user_agent.py

@@ -0,0 +1,9 @@
+"""User agent utility to avoid importing overloaded functions."""
+
+ADAPTER_VERSION = "0.1.4"
+
+
+def get_user_agent() -> str:
+    """Get user agent string for HTTP requests."""
+    return f"spice-mcp/{ADAPTER_VERSION}"
+

spice_mcp/adapters/spellbook/explorer.py

@@ -133,11 +133,43 @@ class SpellbookExplorer(CatalogExplorer):
                     if not schema_yml.exists():
                         schema_yml = sql_file.parent.parent / "schema.yml"
                     
+                    # Parse dbt config to get actual Dune table name
+                    config = self._parse_dbt_config(sql_file)
+
+                    # Ignore templated dbt config values like "{{ target.schema }}"
+                    def _is_templated(val: Any) -> bool:
+                        try:
+                            s = str(val)
+                        except Exception:
+                            return False
+                        return "{{" in s and "}}" in s
+
+                    raw_schema = config.get("schema")
+                    raw_alias = config.get("alias")
+
+                    dune_schema = (
+                        raw_schema.strip() if isinstance(raw_schema, str) else raw_schema
+                    )
+                    dune_alias = (
+                        raw_alias.strip() if isinstance(raw_alias, str) else raw_alias
+                    )
+
+                    # Fall back to original names when values are templated or empty
+                    if not dune_schema or _is_templated(dune_schema):
+                        dune_schema = schema_name
+                    if not dune_alias or _is_templated(dune_alias):
+                        dune_alias = model_name
+
+                    dune_table = f"{dune_schema}.{dune_alias}"
+                    
                     models[schema_name].append({
                         "name": model_name,
                         "file": sql_file,
                         "schema_yml": schema_yml if schema_yml.exists() else None,
                         "schema": schema_name,
+                        "dune_schema": dune_schema,
+                        "dune_alias": dune_alias,
+                        "dune_table": dune_table,
                     })
         
         self._models_cache = models
@@ -264,6 +296,58 @@ class SpellbookExplorer(CatalogExplorer):
         
         return []
 
+    def _parse_dbt_config(self, sql_file: Path) -> dict[str, str]:
+        """
+        Parse dbt config block from SQL file to extract schema and alias.
+        
+        Looks for patterns like:
+        {{ config(schema='sui_walrus', alias='base_table') }}
+        {{ config(schema="sui_walrus", alias="base_table") }}
+        
+        Returns dict with 'schema' and 'alias' keys, or empty dict if not found.
+        """
+        try:
+            with open(sql_file, encoding="utf-8") as f:
+                sql = f.read()
+            
+            # Match dbt config block: {{ config(...) }}
+            # Use non-greedy match to get first config block
+            config_match = re.search(
+                r"{{\s*config\s*\((.*?)\)\s*}}",
+                sql,
+                re.IGNORECASE | re.DOTALL,
+            )
+            
+            if not config_match:
+                return {}
+            
+            config_content = config_match.group(1)
+            result: dict[str, str] = {}
+            
+            # Extract schema parameter (supports single and double quotes)
+            schema_match = re.search(
+                r"schema\s*=\s*['\"]([^'\"]+)['\"]",
+                config_content,
+                re.IGNORECASE,
+            )
+            if schema_match:
+                result["schema"] = schema_match.group(1)
+            
+            # Extract alias parameter (supports single and double quotes)
+            alias_match = re.search(
+                r"alias\s*=\s*['\"]([^'\"]+)['\"]",
+                config_content,
+                re.IGNORECASE,
+            )
+            if alias_match:
+                result["alias"] = alias_match.group(1)
+            
+            return result
+        except Exception:
+            # On any error (file read, parsing, etc.), return empty dict
+            # This allows fallback to using schema_name and model_name
+            return {}
+
     def _parse_sql_columns(self, sql_file: Path) -> list[TableColumn]:
         """Parse SQL file to extract column names from SELECT statements."""
         try:
@@ -310,4 +394,3 @@ class SpellbookExplorer(CatalogExplorer):
             pass
         
         return []
-