intentkit 0.8.6.dev2__py3-none-any.whl → 0.8.17__py3-none-any.whl

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
+
+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[dict[str, Any] | None, dict[str, Any] | None]
+
+
+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: dict[str, Any] | None = 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

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Type
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -39,7 +39,7 @@ class GetPairInfo(DexScreenerBaseTool):
         "market cap, FDV, transaction counts, and social links. "
         "Use this tool when you have a specific pair address and need detailed trading metrics."
     )
-    args_schema: Type[BaseModel] = GetPairInfoInput
+    args_schema: type[BaseModel] = GetPairInfoInput
 
     async def _arun(
         self,
@@ -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

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Type
+from typing import Any
 
 from pydantic import BaseModel, Field, ValidationError
 
@@ -44,7 +44,7 @@ class GetTokenPairs(DexScreenerBaseTool):
         "DEX information, liquidity, volume, and pricing data for each pair. "
         "Use this tool to analyze all available trading venues and liquidity sources for a specific token."
     )
-    args_schema: Type[BaseModel] = GetTokenPairsInput
+    args_schema: type[BaseModel] = GetTokenPairsInput
 
     async def _arun(
         self,
@@ -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

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, List, Type
+from typing import Any
 
 from pydantic import BaseModel, Field, ValidationError, field_validator
 
@@ -29,14 +29,14 @@ class GetTokensInfoInput(BaseModel):
     chain_id: str = Field(
         description="The blockchain chain ID (e.g., 'ethereum', 'solana', 'bsc', 'polygon', 'arbitrum', 'base', 'avalanche')"
     )
-    token_addresses: List[str] = Field(
+    token_addresses: list[str] = Field(
         description=f"List of token contract addresses to retrieve info for (maximum {MAX_TOKENS_BATCH} addresses). "
         "Each address should be in the format '0x1234...abcd' for Ethereum-based chains."
     )
 
     @field_validator("token_addresses")
     @classmethod
-    def validate_token_addresses(cls, v: List[str]) -> List[str]:
+    def validate_token_addresses(cls, v: list[str]) -> list[str]:
         if not v:
             raise ValueError("At least one token address is required")
         if len(v) > MAX_TOKENS_BATCH:
@@ -64,21 +64,20 @@ class GetTokensInfo(DexScreenerBaseTool):
         "This is more efficient than making individual calls when you need info for multiple tokens. "
         "Use this tool for portfolio analysis or comparing multiple tokens at once."
     )
-    args_schema: Type[BaseModel] = GetTokensInfoInput
+    args_schema: type[BaseModel] = GetTokensInfoInput
 
     async def _arun(
         self,
         chain_id: str,
-        token_addresses: List[str],
+        token_addresses: list[str],
         **kwargs: Any,
     ) -> str:
         """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/model/search_token_response.py

@@ -1,82 +1,80 @@
-from typing import List, Optional
-
-from pydantic import BaseModel
-
-
-class TokenModel(BaseModel):
-    address: Optional[str] = None
-    name: Optional[str] = None
-    symbol: Optional[str] = None
-
-
-class TxnsDetailsModel(BaseModel):
-    buys: Optional[int] = None
-    sells: Optional[int] = None
-
-
-class TxnsModel(BaseModel):
-    m5: Optional[TxnsDetailsModel] = None
-    h1: Optional[TxnsDetailsModel] = None
-    h6: Optional[TxnsDetailsModel] = None
-    h24: Optional[TxnsDetailsModel] = None
-
-
-class VolumeModel(BaseModel):
-    h24: Optional[float] = None
-    h6: Optional[float] = None
-    h1: Optional[float] = None
-    m5: Optional[float] = None
-
-
-class PriceChangeModel(BaseModel):
-    m5: Optional[float] = None
-    h1: Optional[float] = None
-    h6: Optional[float] = None
-    h24: Optional[float] = None
-
-
-class LiquidityModel(BaseModel):
-    usd: Optional[float] = None
-    base: Optional[float] = None
-    quote: Optional[float] = None
-
-
-class WebsiteModel(BaseModel):
-    label: Optional[str] = None
-    url: Optional[str] = None
-
-
-class SocialModel(BaseModel):
-    type: Optional[str] = None
-    url: Optional[str] = None
-
-
-class InfoModel(BaseModel):
-    imageUrl: Optional[str] = None
-    websites: Optional[List[Optional[WebsiteModel]]] = None
-    socials: Optional[List[Optional[SocialModel]]] = None
-
-
-class PairModel(BaseModel):
-    chainId: Optional[str] = None
-    dexId: Optional[str] = None
-    url: Optional[str] = None
-    pairAddress: Optional[str] = None
-    labels: Optional[List[Optional[str]]] = None
-    baseToken: Optional[TokenModel] = None
-    quoteToken: Optional[TokenModel] = None
-    priceNative: Optional[str] = None
-    priceUsd: Optional[str] = None
-    txns: Optional[TxnsModel] = None
-    volume: Optional[VolumeModel] = None
-    priceChange: Optional[PriceChangeModel] = None
-    liquidity: Optional[LiquidityModel] = None
-    fdv: Optional[float] = None
-    marketCap: Optional[float] = None
-    pairCreatedAt: Optional[int] = None
-    info: Optional[InfoModel] = None
-
-
-class SearchTokenResponseModel(BaseModel):
-    schemaVersion: Optional[str] = None
-    pairs: Optional[List[Optional[PairModel]]] = None
+from pydantic import BaseModel
+
+
+class TokenModel(BaseModel):
+    address: str | None = None
+    name: str | None = None
+    symbol: str | None = None
+
+
+class TxnsDetailsModel(BaseModel):
+    buys: int | None = None
+    sells: int | None = None
+
+
+class TxnsModel(BaseModel):
+    m5: TxnsDetailsModel | None = None
+    h1: TxnsDetailsModel | None = None
+    h6: TxnsDetailsModel | None = None
+    h24: TxnsDetailsModel | None = None
+
+
+class VolumeModel(BaseModel):
+    h24: float | None = None
+    h6: float | None = None
+    h1: float | None = None
+    m5: float | None = None
+
+
+class PriceChangeModel(BaseModel):
+    m5: float | None = None
+    h1: float | None = None
+    h6: float | None = None
+    h24: float | None = None
+
+
+class LiquidityModel(BaseModel):
+    usd: float | None = None
+    base: float | None = None
+    quote: float | None = None
+
+
+class WebsiteModel(BaseModel):
+    label: str | None = None
+    url: str | None = None
+
+
+class SocialModel(BaseModel):
+    type: str | None = None
+    url: str | None = None
+
+
+class InfoModel(BaseModel):
+    imageUrl: str | None = None
+    websites: list[WebsiteModel | None] | None = None
+    socials: list[SocialModel | None] | None = None
+
+
+class PairModel(BaseModel):
+    chainId: str | None = None
+    dexId: str | None = None
+    url: str | None = None
+    pairAddress: str | None = None
+    labels: list[str | None] | None = None
+    baseToken: TokenModel | None = None
+    quoteToken: TokenModel | None = None
+    priceNative: str | None = None
+    priceUsd: str | None = None
+    txns: TxnsModel | None = None
+    volume: VolumeModel | None = None
+    priceChange: PriceChangeModel | None = None
+    liquidity: LiquidityModel | None = None
+    fdv: float | None = None
+    marketCap: float | None = None
+    pairCreatedAt: int | None = None
+    info: InfoModel | None = None
+
+
+class SearchTokenResponseModel(BaseModel):
+    schemaVersion: str | None = None
+    pairs: list[PairModel | None] | None = None