spice-mcp 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

spice_mcp/adapters/dune/__init__.py

@@ -2,9 +2,11 @@
 
 This module provides a thin façade used by the new service layer while
 keeping the battle-tested logic that the original spice client offered.
+
+Only synchronous interfaces are exposed.
 """
 
 from . import urls  # re-export for callers needing low-level helpers
-from .extract import async_query, query  # noqa: F401
+from .extract import query  # noqa: F401
 
-__all__ = ["query", "async_query", "urls"]
+__all__ = ["query", "urls"]

spice_mcp/adapters/dune/cache.py

@@ -51,39 +51,7 @@ def load_from_cache(
         return None, execution
 
 
-async def async_load_from_cache(
-    execute_kwargs: _extract.ExecuteKwargs,
-    result_kwargs: _extract.RetrievalKwargs,
-    output_kwargs: _extract.OutputKwargs,
-) -> tuple[
-    pl.DataFrame | tuple[pl.DataFrame, Execution] | None, Execution | None
-]:
-    # get latest execution
-    execution = await _extract.async_get_latest_execution(execute_kwargs)
-    if execution is None:
-        return None, None
-
-    # build cache path
-    cache_path = _build_cache_path(
-        execution=execution,
-        execute_kwargs=execute_kwargs,
-        result_kwargs=result_kwargs,
-        cache_dir=output_kwargs['cache_dir'],
-    )
-
-    # load cache result
-    if os.path.exists(cache_path):
-        import polars as pl
-
-        if result_kwargs['verbose']:
-            print('loading dune query result from cache')
-        df = await pl.scan_parquet(cache_path).collect_async()
-        if output_kwargs['include_execution']:
-            return (df, execution), execution
-        else:
-            return df, execution
-    else:
-        return None, execution
+## Removed async cache loader; synchronous load_from_cache should be used exclusively.
 
 
 def save_to_cache(
@@ -113,7 +81,7 @@ def save_to_cache(
     # save to cache
     tmp_path = (
         cache_path + '_tmp_' + secrets.token_hex(8)
-    )  # add for if running in parallel
+    )  # add tmp suffix to avoid conflicts during writes
     df.write_parquet(tmp_path)
     shutil.move(tmp_path, cache_path)
 

spice_mcp/adapters/dune/client.py

@@ -24,6 +24,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."""
@@ -47,7 +51,7 @@ class DuneAdapter(QueryExecutor, CatalogExplorer):
             q_rewritten = _maybe_rewrite_show_sql(q)
             if q_rewritten is not None:
                 q = q_rewritten
-        result = extract.query(
+        result = _execute_dune_query(
             query_or_execution=q,
             verbose=False,
             refresh=request.refresh,
@@ -123,9 +127,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)
@@ -196,8 +201,8 @@ class DuneAdapter(QueryExecutor, CatalogExplorer):
     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,
+        df = _execute_dune_query(
+            query_or_execution=sql_eff,
             verbose=False,
             performance="medium",
             timeout_seconds=self.config.default_timeout_seconds,