intentkit 0.8.12rc0__py3-none-any.whl → 0.8.13.dev1__py3-none-any.whl

intentkit/skills/dexscreener/__init__.py

@@ -1,102 +1,97 @@
-import logging
-from typing import Optional, TypedDict
-
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.skills.base import SkillConfig, SkillState
-from intentkit.skills.dexscreener.base import DexScreenerBaseTool
-from intentkit.skills.dexscreener.get_pair_info import GetPairInfo
-from intentkit.skills.dexscreener.get_token_pairs import GetTokenPairs
-from intentkit.skills.dexscreener.get_tokens_info import GetTokensInfo
-from intentkit.skills.dexscreener.search_token import SearchToken
-
-# Cache skills at the system level, because they are stateless
-_cache: dict[str, DexScreenerBaseTool] = {}
-
-logger = logging.getLogger(__name__)
-
-
-class SkillStates(TypedDict):
-    search_token: SkillState
-    get_pair_info: SkillState
-    get_token_pairs: SkillState
-    get_tokens_info: SkillState
-
-
-_SKILL_NAME_TO_CLASS_MAP: dict[str, type[DexScreenerBaseTool]] = {
-    "search_token": SearchToken,
-    "get_pair_info": GetPairInfo,
-    "get_token_pairs": GetTokenPairs,
-    "get_tokens_info": GetTokensInfo,
-}
-
-
-class Config(SkillConfig):
-    """Configuration for DexScreener skills."""
-
-    enabled: bool
-    states: SkillStates
-
-
-async def get_skills(
-    config: "Config",
-    is_private: bool,
-    store: SkillStoreABC,
-    **_,
-) -> list[DexScreenerBaseTool]:
-    """Get all DexScreener skills.
-
-    Args:
-        config: The configuration for DexScreener skills.
-        is_private: Whether to include private skills.
-        store: The skill store for persisting data.
-
-    Returns:
-        A list of DexScreener skills.
-    """
-
-    available_skills = []
-
-    # Include skills based on their state
-    for skill_name, state in config["states"].items():
-        if state == "disabled":
-            continue
-        elif state == "public" or (state == "private" and is_private):
-            available_skills.append(skill_name)
-
-    logger.debug(f"Available Skills {available_skills}")
-    logger.debug(f"Hardcoded Skills {_SKILL_NAME_TO_CLASS_MAP}")
-
-    # Get each skill using the cached getter
-    result = []
-    for name in available_skills:
-        skill = get_dexscreener_skills(name, store)
-        if skill:
-            result.append(skill)
-    return result
-
-
-def get_dexscreener_skills(
-    name: str,
-    store: SkillStoreABC,
-) -> Optional[DexScreenerBaseTool]:
-    """Get a DexScreener skill by name.
-
-    Args:
-        name: The name of the skill to get
-        store: The skill store for persisting data
-
-    Returns:
-        The requested DexScreener skill
-    """
-
-    # Return from cache immediately if already exists
-    if name in _cache:
-        return _cache[name]
-
-    skill_class = _SKILL_NAME_TO_CLASS_MAP.get(name)
-    if not skill_class:
-        logger.warning(f"Unknown Dexscreener skill: {name}")
-        return None
-
-    _cache[name] = skill_class(skill_store=store)
-    return _cache[name]
+import logging
+from typing import Optional, TypedDict
+
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.dexscreener.base import DexScreenerBaseTool
+from intentkit.skills.dexscreener.get_pair_info import GetPairInfo
+from intentkit.skills.dexscreener.get_token_pairs import GetTokenPairs
+from intentkit.skills.dexscreener.get_tokens_info import GetTokensInfo
+from intentkit.skills.dexscreener.search_token import SearchToken
+
+# Cache skills at the system level, because they are stateless
+_cache: dict[str, DexScreenerBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+class SkillStates(TypedDict):
+    search_token: SkillState
+    get_pair_info: SkillState
+    get_token_pairs: SkillState
+    get_tokens_info: SkillState
+
+
+_SKILL_NAME_TO_CLASS_MAP: dict[str, type[DexScreenerBaseTool]] = {
+    "search_token": SearchToken,
+    "get_pair_info": GetPairInfo,
+    "get_token_pairs": GetTokenPairs,
+    "get_tokens_info": GetTokensInfo,
+}
+
+
+class Config(SkillConfig):
+    """Configuration for DexScreener skills."""
+
+    enabled: bool
+    states: SkillStates
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    **_,
+) -> list[DexScreenerBaseTool]:
+    """Get all DexScreener skills.
+
+    Args:
+        config: The configuration for DexScreener skills.
+        is_private: Whether to include private skills.
+
+    Returns:
+        A list of DexScreener skills.
+    """
+
+    available_skills = []
+
+    # Include skills based on their state
+    for skill_name, state in config["states"].items():
+        if state == "disabled":
+            continue
+        elif state == "public" or (state == "private" and is_private):
+            available_skills.append(skill_name)
+
+    logger.debug(f"Available Skills {available_skills}")
+    logger.debug(f"Hardcoded Skills {_SKILL_NAME_TO_CLASS_MAP}")
+
+    # Get each skill using the cached getter
+    result = []
+    for name in available_skills:
+        skill = get_dexscreener_skills(name)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_dexscreener_skills(
+    name: str,
+) -> Optional[DexScreenerBaseTool]:
+    """Get a DexScreener skill by name.
+
+    Args:
+        name: The name of the skill to get
+
+    Returns:
+        The requested DexScreener skill
+    """
+
+    # Return from cache immediately if already exists
+    if name in _cache:
+        return _cache[name]
+
+    skill_class = _SKILL_NAME_TO_CLASS_MAP.get(name)
+    if not skill_class:
+        logger.warning(f"Unknown Dexscreener skill: {name}")
+        return None
+
+    _cache[name] = skill_class()
+    return _cache[name]

intentkit/skills/dexscreener/base.py

@@ -1,130 +1,125 @@
-import json
-import logging
-from typing import Any, Dict, Optional, Tuple
-
-import httpx
-from pydantic import Field
-
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.skills.base import IntentKitSkill
-from intentkit.skills.dexscreener.utils import DEXSCREENER_BASE_URL
-
-logger = logging.getLogger(__name__)
-
-# ApiResult still represents (success_data, error_data)
-ApiResult = Tuple[Optional[Dict[str, Any]], Optional[Dict[str, Any]]]
-
-
-class DexScreenerBaseTool(IntentKitSkill):
-    """
-    Generic base class for tools interacting with the Dex Screener API.
-    Handles shared logic like API calls and error reporting via return values.
-    """
-
-    skill_store: SkillStoreABC = Field(
-        description="The skill store for persisting data and configs."
-    )
-    base_url: str = DEXSCREENER_BASE_URL
-
-    @property
-    def category(self) -> str:
-        return "dexscreener"
-
-    async def _get(
-        self,
-        path: str,
-        params: Optional[Dict[str, Any]] = None,
-    ) -> ApiResult:
-        """
-        Makes an asynchronous GET request to the DexScreener API.
-
-        Args:
-            path: The API endpoint path (e.g., "/dex/search").
-            params: Optional dictionary of query parameters.
-
-        Returns:
-            A tuple (data, error_details):
-            - (dict, None): On HTTP 2xx success with valid JSON response.
-            - (None, dict): On any error (API error, connection error,
-                            JSON parsing error, unexpected error). The dict
-                            contains details including an 'error_type'.
-        """
-        if not path.startswith("/"):
-            path = "/" + path
-
-        url = f"{self.base_url}{path}"
-        headers = {"Accept": "application/json"}
-        method = "GET"
-
-        logger.debug(f"Calling DexScreener API: {method} {url} with params: {params}")
-        response = None  # Define response outside try block for access in except
-
-        try:
-            async with httpx.AsyncClient() as client:
-                response = await client.request(
-                    method, url, params=params, headers=headers
-                )
-
-                # Attempt to parse JSON response text
-                try:
-                    response_data = response.json()
-                except json.JSONDecodeError as json_err:
-                    logger.error(
-                        f"Failed to parse JSON response from {url}. Status: {response.status_code}. Response text: {response.text}",
-                        exc_info=True,
-                    )
-                    error_details = {
-                        "error": "Failed to parse DexScreener API response",
-                        "error_type": "parsing_error",
-                        "status_code": response.status_code,
-                        "details": response.text,  # Raw text causing the error
-                        "original_exception": str(json_err),
-                        "url": url,
-                    }
-                    return None, error_details  # Return parsing error
-
-                # Check HTTP status *after* attempting JSON parse
-                if response.is_success:  # 2xx
-                    logger.debug(
-                        f"DexScreener API success response status: {response.status_code}"
-                    )
-                    return response_data, None  # Success
-                else:  # 4xx/5xx
-                    logger.warning(
-                        f"DexScreener API returned error status: {response.status_code} - {response.text}"
-                    )
-                    error_details = {
-                        "error": "DexScreener API request failed",
-                        "error_type": "api_error",
-                        "status_code": response.status_code,
-                        "response_body": response_data,  # Parsed error body if available
-                        "url": url,
-                    }
-                    return None, error_details  # Return API error
-
-        except httpx.RequestError as req_err:
-            logger.error(
-                f"Request error connecting to DexScreener API: {req_err}", exc_info=True
-            )
-            error_details = {
-                "error": "Failed to connect to DexScreener API",
-                "error_type": "connection_error",
-                "details": str(req_err),
-                "url": url,
-            }
-            return None, error_details  # Return connection error
-
-        except Exception as e:
-            # Catch any other unexpected errors during the process
-            logger.exception(
-                f"An unexpected error occurred during DexScreener API GET call: {e}"
-            )
-            status_code = response.status_code if response else None
-            error_details = {
-                "error": "An unexpected error occurred during API call",
-                "error_type": "unexpected_error",
-                "status_code": status_code,  # Include if available
-                "details": str(e),
-                "url": url,
-            }
-            return None, error_details  # Return unexpected error
+import json
+import logging
+from typing import Any, Dict, Optional, Tuple
+
+import httpx
+
+from intentkit.skills.base import IntentKitSkill
+from intentkit.skills.dexscreener.utils import DEXSCREENER_BASE_URL
+
+logger = logging.getLogger(__name__)
+
+# ApiResult still represents (success_data, error_data)
+ApiResult = Tuple[Optional[Dict[str, Any]], Optional[Dict[str, Any]]]
+
+
+class DexScreenerBaseTool(IntentKitSkill):
+    """
+    Generic base class for tools interacting with the Dex Screener API.
+    Handles shared logic like API calls and error reporting via return values.
+    """
+
+    base_url: str = DEXSCREENER_BASE_URL
+
+    @property
+    def category(self) -> str:
+        return "dexscreener"
+
+    async def _get(
+        self,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> ApiResult:
+        """
+        Makes an asynchronous GET request to the DexScreener API.
+
+        Args:
+            path: The API endpoint path (e.g., "/dex/search").
+            params: Optional dictionary of query parameters.
+
+        Returns:
+            A tuple (data, error_details):
+            - (dict, None): On HTTP 2xx success with valid JSON response.
+            - (None, dict): On any error (API error, connection error,
+                            JSON parsing error, unexpected error). The dict
+                            contains details including an 'error_type'.
+        """
+        if not path.startswith("/"):
+            path = "/" + path
+
+        url = f"{self.base_url}{path}"
+        headers = {"Accept": "application/json"}
+        method = "GET"
+
+        logger.debug(f"Calling DexScreener API: {method} {url} with params: {params}")
+        response = None  # Define response outside try block for access in except
+
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.request(
+                    method, url, params=params, headers=headers
+                )
+
+                # Attempt to parse JSON response text
+                try:
+                    response_data = response.json()
+                except json.JSONDecodeError as json_err:
+                    logger.error(
+                        f"Failed to parse JSON response from {url}. Status: {response.status_code}. Response text: {response.text}",
+                        exc_info=True,
+                    )
+                    error_details = {
+                        "error": "Failed to parse DexScreener API response",
+                        "error_type": "parsing_error",
+                        "status_code": response.status_code,
+                        "details": response.text,  # Raw text causing the error
+                        "original_exception": str(json_err),
+                        "url": url,
+                    }
+                    return None, error_details  # Return parsing error
+
+                # Check HTTP status *after* attempting JSON parse
+                if response.is_success:  # 2xx
+                    logger.debug(
+                        f"DexScreener API success response status: {response.status_code}"
+                    )
+                    return response_data, None  # Success
+                else:  # 4xx/5xx
+                    logger.warning(
+                        f"DexScreener API returned error status: {response.status_code} - {response.text}"
+                    )
+                    error_details = {
+                        "error": "DexScreener API request failed",
+                        "error_type": "api_error",
+                        "status_code": response.status_code,
+                        "response_body": response_data,  # Parsed error body if available
+                        "url": url,
+                    }
+                    return None, error_details  # Return API error
+
+        except httpx.RequestError as req_err:
+            logger.error(
+                f"Request error connecting to DexScreener API: {req_err}", exc_info=True
+            )
+            error_details = {
+                "error": "Failed to connect to DexScreener API",
+                "error_type": "connection_error",
+                "details": str(req_err),
+                "url": url,
+            }
+            return None, error_details  # Return connection error
+
+        except Exception as e:
+            # Catch any other unexpected errors during the process
+            logger.exception(
+                f"An unexpected error occurred during DexScreener API GET call: {e}"
+            )
+            status_code = response.status_code if response else None
+            error_details = {
+                "error": "An unexpected error occurred during API call",
+                "error_type": "unexpected_error",
+                "status_code": status_code,  # Include if available
+                "details": str(e),
+                "url": url,
+            }
+            return None, error_details  # Return unexpected error

intentkit/skills/dexscreener/get_pair_info.py

@@ -50,10 +50,9 @@ class GetPairInfo(DexScreenerBaseTool):
         """Implementation to get specific pair information."""
 
         # Apply rate limiting
-        await self.user_rate_limit_by_category(
-            user_id=f"{self.category}{self.name}",
+        await self.global_rate_limit_by_skill(
             limit=RATE_LIMITS["pairs"],
-            minutes=1,
+            seconds=60,
         )
 
         logger.info(

intentkit/skills/dexscreener/get_token_pairs.py

@@ -55,10 +55,9 @@ class GetTokenPairs(DexScreenerBaseTool):
         """Implementation to get all pairs for a specific token."""
 
         # Apply rate limiting
-        await self.user_rate_limit_by_category(
-            user_id=f"{self.category}{self.name}",
+        await self.global_rate_limit_by_skill(
             limit=RATE_LIMITS["token_pairs"],
-            minutes=1,
+            seconds=60,
         )
 
         logger.info(

intentkit/skills/dexscreener/get_tokens_info.py

@@ -75,10 +75,9 @@ class GetTokensInfo(DexScreenerBaseTool):
         """Implementation to get information for multiple tokens."""
 
         # Apply rate limiting
-        await self.user_rate_limit_by_category(
-            user_id=f"{self.category}{self.name}",
+        await self.global_rate_limit_by_skill(
             limit=RATE_LIMITS["tokens"],
-            minutes=1,
+            seconds=60,
         )
 
         logger.info(

intentkit/skills/dexscreener/search_token.py

@@ -72,11 +72,9 @@ class SearchToken(DexScreenerBaseTool):
 
         # dexscreener 300 request per minute (across all user) based on dexscreener docs
         # https://docs.dexscreener.com/api/reference#get-latest-dex-search
-        await self.user_rate_limit_by_category(
-            # using hardcoded user_id to make sure it limit across all users
-            user_id=f"{self.category}{self.name}",
+        await self.global_rate_limit_by_skill(
             limit=300,
-            minutes=1,
+            seconds=60,
         )
 
         sort_by = sort_by or SortBy.LIQUIDITY

intentkit/skills/dune_analytics/__init__.py

@@ -6,7 +6,6 @@ Loads and initializes skills for fetching data from Dune Analytics API.
 import logging
 from typing import Dict, List, Optional, TypedDict
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.base import SkillConfig, SkillState
 from intentkit.skills.dune_analytics.base import DuneBaseTool
 
@@ -33,7 +32,6 @@ class Config(SkillConfig):
 async def get_skills(
     config: Config,
     is_private: bool,
-    store: SkillStoreABC,
     **kwargs,
 ) -> List[DuneBaseTool]:
     """Load Dune Analytics skills based on configuration.
@@ -59,7 +57,7 @@ async def get_skills(
 
     loaded_skills = []
     for name in available_skills:
-        skill = get_dune_skill(name, store)
+        skill = get_dune_skill(name)
         if skill:
             logger.info("Successfully loaded skill: %s", name)
             loaded_skills.append(skill)
@@ -69,7 +67,7 @@ async def get_skills(
     return loaded_skills
 
 
-def get_dune_skill(name: str, store: SkillStoreABC) -> Optional[DuneBaseTool]:
+def get_dune_skill(name: str) -> Optional[DuneBaseTool]:
     """Retrieve a Dune Analytics skill instance by name.
 
     Args:
@@ -87,11 +85,11 @@ def get_dune_skill(name: str, store: SkillStoreABC) -> Optional[DuneBaseTool]:
         if name == "fetch_nation_metrics":
             from .fetch_nation_metrics import FetchNationMetrics
 
-            _skill_cache[name] = FetchNationMetrics(skill_store=store)
+            _skill_cache[name] = FetchNationMetrics()
         elif name == "fetch_kol_buys":
             from .fetch_kol_buys import FetchKOLBuys
 
-            _skill_cache[name] = FetchKOLBuys(skill_store=store)
+            _skill_cache[name] = FetchKOLBuys()
         else:
             logger.warning("Unknown Dune Analytics skill: %s", name)
             return None