intentkit 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

intentkit/skills/cryptocompare/__init__.py

@@ -0,0 +1,130 @@
+"""CryptoCompare skills."""
+
+import logging
+from typing import TypedDict
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import SkillConfig, SkillState
+from intentkit.skills.cryptocompare.base import CryptoCompareBaseTool
+from intentkit.skills.cryptocompare.fetch_news import CryptoCompareFetchNews
+from intentkit.skills.cryptocompare.fetch_price import CryptoCompareFetchPrice
+from intentkit.skills.cryptocompare.fetch_top_exchanges import (
+    CryptoCompareFetchTopExchanges,
+)
+from intentkit.skills.cryptocompare.fetch_top_market_cap import (
+    CryptoCompareFetchTopMarketCap,
+)
+from intentkit.skills.cryptocompare.fetch_top_volume import CryptoCompareFetchTopVolume
+from intentkit.skills.cryptocompare.fetch_trading_signals import (
+    CryptoCompareFetchTradingSignals,
+)
+
+# Cache skills at the system level, because they are stateless
+_cache: dict[str, CryptoCompareBaseTool] = {}
+
+logger = logging.getLogger(__name__)
+
+
+class SkillStates(TypedDict):
+    fetch_news: SkillState
+    fetch_price: SkillState
+    fetch_trading_signals: SkillState
+    fetch_top_market_cap: SkillState
+    fetch_top_exchanges: SkillState
+    fetch_top_volume: SkillState
+
+
+class Config(SkillConfig):
+    """Configuration for CryptoCompare skills."""
+
+    states: SkillStates
+    api_key: str
+
+
+async def get_skills(
+    config: "Config",
+    is_private: bool,
+    store: SkillStoreABC,
+    **_,
+) -> list[CryptoCompareBaseTool]:
+    """Get all CryptoCompare skills.
+
+    Args:
+        config: The configuration for CryptoCompare skills.
+        is_private: Whether to include private skills.
+        store: The skill store for persisting data.
+
+    Returns:
+        A list of CryptoCompare 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)
+
+    # Get each skill using the cached getter
+    result = []
+    for name in available_skills:
+        skill = get_cryptocompare_skill(name, store)
+        if skill:
+            result.append(skill)
+    return result
+
+
+def get_cryptocompare_skill(
+    name: str,
+    store: SkillStoreABC,
+) -> CryptoCompareBaseTool:
+    """Get a CryptoCompare skill by name.
+
+    Args:
+        name: The name of the skill to get
+        store: The skill store for persisting data
+
+    Returns:
+        The requested CryptoCompare skill
+    """
+
+    if name == "fetch_news":
+        if name not in _cache:
+            _cache[name] = CryptoCompareFetchNews(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_price":
+        if name not in _cache:
+            _cache[name] = CryptoCompareFetchPrice(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_trading_signals":
+        if name not in _cache:
+            _cache[name] = CryptoCompareFetchTradingSignals(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_top_market_cap":
+        if name not in _cache:
+            _cache[name] = CryptoCompareFetchTopMarketCap(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_top_exchanges":
+        if name not in _cache:
+            _cache[name] = CryptoCompareFetchTopExchanges(
+                skill_store=store,
+            )
+        return _cache[name]
+    elif name == "fetch_top_volume":
+        if name not in _cache:
+            _cache[name] = CryptoCompareFetchTopVolume(
+                skill_store=store,
+            )
+        return _cache[name]
+    else:
+        logger.warning(f"Unknown CryptoCompare skill: {name}")
+        return None

intentkit/skills/cryptocompare/api.py

@@ -0,0 +1,159 @@
+"""CryptoCompare API implementation and shared schemas."""
+
+import time
+from typing import List
+
+import httpx
+from pydantic import BaseModel, Field
+
+CRYPTO_COMPARE_BASE_URL = "https://min-api.cryptocompare.com"
+
+
+# Input Schemas
+class FetchNewsInput(BaseModel):
+    """Input schema for fetching news."""
+
+    token: str = Field(
+        ..., description="Token symbol to fetch news for (e.g., BTC, ETH, SOL)"
+    )
+
+
+class FetchPriceInput(BaseModel):
+    """Input schema for fetching crypto prices."""
+
+    from_symbol: str = Field(
+        ...,
+        description="Base cryptocurrency symbol to get prices for (e.g., 'BTC', 'ETH')",
+    )
+    to_symbols: List[str] = Field(
+        ...,
+        description="List of target currencies (fiat or crypto) (e.g., ['USD', 'EUR', 'JPY'])",
+    )
+
+
+class FetchTradingSignalsInput(BaseModel):
+    """Input schema for fetching trading signals."""
+
+    from_symbol: str = Field(
+        ...,
+        description="Cryptocurrency symbol to fetch trading signals for (e.g., 'BTC')",
+    )
+
+
+class FetchTopMarketCapInput(BaseModel):
+    """Input schema for fetching top cryptocurrencies by market cap."""
+
+    to_symbol: str = Field(
+        "USD",
+        description="Quote currency for market cap calculation (e.g., 'USD', 'EUR')",
+    )
+
+
+class FetchTopExchangesInput(BaseModel):
+    """Input schema for fetching top exchanges for a trading pair."""
+
+    from_symbol: str = Field(
+        ..., description="Base cryptocurrency symbol for the trading pair (e.g., 'BTC')"
+    )
+    to_symbol: str = Field(
+        "USD",
+        description="Quote currency symbol for the trading pair. Defaults to 'USD'",
+    )
+
+
+class FetchTopVolumeInput(BaseModel):
+    """Input schema for fetching top cryptocurrencies by trading volume."""
+
+    to_symbol: str = Field(
+        "USD", description="Quote currency for volume calculation. Defaults to 'USD'"
+    )
+
+
+# API Functions
+async def fetch_price(api_key: str, from_symbol: str, to_symbols: List[str]) -> dict:
+    """
+    Fetch current price for a cryptocurrency in multiple currencies.
+    """
+    url = f"{CRYPTO_COMPARE_BASE_URL}/data/price"
+    headers = {"Accept": "application/json", "Authorization": f"Bearer {api_key}"}
+    params = {"fsym": from_symbol.upper(), "tsyms": ",".join(to_symbols)}
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, params=params, headers=headers)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_trading_signals(api_key: str, from_symbol: str) -> dict:
+    """
+    Fetch the latest trading signals.
+    """
+    url = f"{CRYPTO_COMPARE_BASE_URL}/data/tradingsignals/intotheblock/latest"
+    headers = {"Accept": "application/json", "Authorization": f"Bearer {api_key}"}
+    params = {"fsym": from_symbol.upper()}
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, params=params, headers=headers)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_top_market_cap(
+    api_key: str, limit: int, to_symbol: str = "USD"
+) -> dict:
+    """
+    Fetch top cryptocurrencies by market cap.
+    """
+    url = f"{CRYPTO_COMPARE_BASE_URL}/data/top/mktcapfull"
+    headers = {"Accept": "application/json", "Authorization": f"Bearer {api_key}"}
+    params = {"limit": limit, "tsym": to_symbol.upper()}
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, params=params, headers=headers)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_top_exchanges(
+    api_key: str, from_symbol: str, to_symbol: str = "USD"
+) -> dict:
+    """
+    Fetch top exchanges for a cryptocurrency pair.
+    """
+    url = f"{CRYPTO_COMPARE_BASE_URL}/data/top/exchanges"
+    headers = {"Accept": "application/json", "Authorization": f"Bearer {api_key}"}
+    params = {"fsym": from_symbol.upper(), "tsym": to_symbol.upper()}
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, params=params, headers=headers)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_top_volume(api_key: str, limit: int, to_symbol: str = "USD") -> dict:
+    """
+    Fetch top cryptocurrencies by total volume.
+    """
+    url = f"{CRYPTO_COMPARE_BASE_URL}/data/top/totalvolfull"
+    headers = {"Accept": "application/json", "Authorization": f"Bearer {api_key}"}
+    params = {"limit": limit, "tsym": to_symbol.upper()}
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, params=params, headers=headers)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()
+
+
+async def fetch_news(api_key: str, token: str, timestamp: int = None) -> dict:
+    """
+    Fetch news for a specific token and timestamp.
+    """
+    if timestamp is None:
+        timestamp = int(time.time())
+    url = f"{CRYPTO_COMPARE_BASE_URL}/data/v2/news/?lang=EN&lTs={timestamp}&categories={token}&sign=true"
+    headers = {"Accept": "application/json", "Authorization": f"Bearer {api_key}"}
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, headers=headers)
+    if response.status_code != 200:
+        return {"error": f"API returned status code {response.status_code}"}
+    return response.json()

intentkit/skills/cryptocompare/base.py

@@ -0,0 +1,303 @@
+"""Base class for all CryptoCompare tools."""
+
+import logging
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, List, Type
+
+import httpx
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.exception import RateLimitExceeded
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill
+
+CRYPTO_COMPARE_BASE_URL = "https://min-api.cryptocompare.com"
+
+logger = logging.getLogger(__name__)
+
+
+class CryptoCompareBaseTool(IntentKitSkill):
+    """Base class for CryptoCompare tools.
+
+    This class provides common functionality for all CryptoCompare API tools:
+    - Rate limiting
+    - API client handling
+    - State management through skill_store
+    """
+
+    name: str = Field(description="The name of the tool")
+    description: str = Field(description="A description of what the tool does")
+    args_schema: Type[BaseModel]
+    skill_store: SkillStoreABC = Field(
+        description="The skill store for persisting data"
+    )
+
+    @property
+    def category(self) -> str:
+        return "cryptocompare"
+
+    async def check_rate_limit(
+        self, agent_id: str, max_requests: int = 1, interval: int = 15
+    ) -> None:
+        """Check if the rate limit has been exceeded.
+
+        Args:
+            agent_id: The ID of the agent.
+            max_requests: Maximum number of requests allowed within the rate limit window.
+            interval: Time interval in minutes for the rate limit window.
+
+        Raises:
+            RateLimitExceeded: If the rate limit has been exceeded.
+        """
+        rate_limit = await self.skill_store.get_agent_skill_data(
+            agent_id, self.name, "rate_limit"
+        )
+
+        current_time = datetime.now(tz=timezone.utc)
+
+        if (
+            rate_limit
+            and rate_limit.get("reset_time")
+            and rate_limit["count"] is not None
+            and datetime.fromisoformat(rate_limit["reset_time"]) > current_time
+        ):
+            if rate_limit["count"] >= max_requests:
+                raise RateLimitExceeded("Rate limit exceeded")
+
+            rate_limit["count"] += 1
+            await self.skill_store.save_agent_skill_data(
+                agent_id, self.name, "rate_limit", rate_limit
+            )
+
+            return
+
+        # If no rate limit exists or it has expired, create a new one
+        new_rate_limit = {
+            "count": 1,
+            "reset_time": (current_time + timedelta(minutes=interval)).isoformat(),
+        }
+        await self.skill_store.save_agent_skill_data(
+            agent_id, self.name, "rate_limit", new_rate_limit
+        )
+        return
+
+    async def fetch_price(
+        self, api_key: str, from_symbol: str, to_symbols: List[str]
+    ) -> dict:
+        """Fetch current price for a cryptocurrency in multiple currencies.
+
+        Args:
+            api_key: The CryptoCompare API key
+            from_symbol: Base cryptocurrency symbol to get prices for (e.g., 'BTC', 'ETH')
+            to_symbols: List of target currencies (fiat or crypto) (e.g., ['USD', 'EUR', 'JPY'])
+
+        Returns:
+            Dict containing the price data
+        """
+        url = f"{CRYPTO_COMPARE_BASE_URL}/data/price"
+        headers = {"Accept": "application/json", "Authorization": f"Bearer {api_key}"}
+
+        # Ensure from_symbol is a string, not a list
+        if isinstance(from_symbol, list):
+            from_symbol = from_symbol[0] if from_symbol else ""
+
+        # Ensure to_symbols is a list
+        if not isinstance(to_symbols, list):
+            to_symbols = [to_symbols] if to_symbols else ["USD"]
+
+        params = {
+            "fsym": from_symbol.upper(),
+            "tsyms": ",".join([s.upper() for s in to_symbols]),
+        }
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url, params=params, headers=headers)
+        if response.status_code != 200:
+            logger.error(f"API returned status code {response.status_code}")
+            return {"error": f"API returned status code {response.status_code}"}
+        return response.json()
+
+    async def fetch_trading_signals(self, api_key: str, from_symbol: str) -> dict:
+        """Fetch the latest trading signals.
+
+        Args:
+            api_key: The CryptoCompare API key
+            from_symbol: Cryptocurrency symbol to fetch trading signals for (e.g., 'BTC')
+
+        Returns:
+            Dict containing the trading signals data
+        """
+        url = f"{CRYPTO_COMPARE_BASE_URL}/data/tradingsignals/intotheblock/latest"
+        headers = {"Accept": "application/json", "Authorization": f"Bearer {api_key}"}
+
+        # Ensure from_symbol is a string, not a list
+        if isinstance(from_symbol, list):
+            from_symbol = from_symbol[0] if from_symbol else ""
+
+        params = {"fsym": from_symbol.upper()}
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url, params=params, headers=headers)
+        if response.status_code != 200:
+            logger.error(f"API returned status code {response.status_code}")
+            return {"error": f"API returned status code {response.status_code}"}
+        return response.json()
+
+    async def fetch_top_market_cap(
+        self, api_key: str, limit: int, to_symbol: str = "USD"
+    ) -> dict:
+        """Fetch top cryptocurrencies by market cap.
+
+        Args:
+            api_key: The CryptoCompare API key
+            limit: Number of cryptocurrencies to fetch
+            to_symbol: Quote currency for market cap calculation (e.g., 'USD', 'EUR')
+
+        Returns:
+            Dict containing the top market cap data
+        """
+        url = f"{CRYPTO_COMPARE_BASE_URL}/data/top/mktcapfull"
+        headers = {"Accept": "application/json", "Authorization": f"Bearer {api_key}"}
+
+        # Ensure to_symbol is a string, not a list
+        if isinstance(to_symbol, list):
+            to_symbol = to_symbol[0] if to_symbol else "USD"
+
+        params = {"limit": limit, "tsym": to_symbol.upper()}
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url, params=params, headers=headers)
+        if response.status_code != 200:
+            logger.error(f"API returned status code {response.status_code}")
+            return {"error": f"API returned status code {response.status_code}"}
+        return response.json()
+
+    async def fetch_top_exchanges(
+        self, api_key: str, from_symbol: str, to_symbol: str = "USD"
+    ) -> dict:
+        """Fetch top exchanges for a cryptocurrency pair.
+
+        Args:
+            api_key: The CryptoCompare API key
+            from_symbol: Base cryptocurrency symbol for the trading pair (e.g., 'BTC')
+            to_symbol: Quote currency symbol for the trading pair. Defaults to 'USD'
+
+        Returns:
+            Dict containing the top exchanges data
+        """
+        url = f"{CRYPTO_COMPARE_BASE_URL}/data/top/exchanges"
+        headers = {"Accept": "application/json", "Authorization": f"Bearer {api_key}"}
+
+        # Ensure from_symbol and to_symbol are strings, not lists
+        if isinstance(from_symbol, list):
+            from_symbol = from_symbol[0] if from_symbol else ""
+        if isinstance(to_symbol, list):
+            to_symbol = to_symbol[0] if to_symbol else "USD"
+
+        params = {"fsym": from_symbol.upper(), "tsym": to_symbol.upper()}
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url, params=params, headers=headers)
+        if response.status_code != 200:
+            logger.error(f"API returned status code {response.status_code}")
+            return {"error": f"API returned status code {response.status_code}"}
+        return response.json()
+
+    async def fetch_top_volume(
+        self, api_key: str, limit: int, to_symbol: str = "USD"
+    ) -> dict:
+        """Fetch top cryptocurrencies by total volume.
+
+        Args:
+            api_key: The CryptoCompare API key
+            limit: Number of cryptocurrencies to fetch
+            to_symbol: Quote currency for volume calculation. Defaults to 'USD'
+
+        Returns:
+            Dict containing the top volume data
+        """
+        url = f"{CRYPTO_COMPARE_BASE_URL}/data/top/totalvolfull"
+        headers = {"Accept": "application/json", "Authorization": f"Bearer {api_key}"}
+
+        # Ensure to_symbol is a string, not a list
+        if isinstance(to_symbol, list):
+            to_symbol = to_symbol[0] if to_symbol else "USD"
+
+        params = {"limit": limit, "tsym": to_symbol.upper()}
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url, params=params, headers=headers)
+        if response.status_code != 200:
+            logger.error(f"API returned status code {response.status_code}")
+            return {"error": f"API returned status code {response.status_code}"}
+        return response.json()
+
+    async def fetch_news(self, api_key: str, token: str, timestamp: int = None) -> dict:
+        """Fetch news for a specific token and timestamp.
+
+        Args:
+            api_key: The CryptoCompare API key
+            token: Token symbol to fetch news for (e.g., BTC, ETH, SOL)
+            timestamp: Optional timestamp for fetching news
+
+        Returns:
+            Dict containing the news data
+        """
+        url = f"{CRYPTO_COMPARE_BASE_URL}/data/v2/news/"
+        headers = {"Accept": "application/json", "Authorization": f"Bearer {api_key}"}
+
+        # Ensure token is a string, not a list
+        if isinstance(token, list):
+            token = token[0] if token else ""
+
+        params = {"categories": token.upper()}
+        if timestamp:
+            params["lTs"] = timestamp
+
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url, params=params, headers=headers)
+        if response.status_code != 200:
+            logger.error(f"API returned status code {response.status_code}")
+            return {"error": f"API returned status code {response.status_code}"}
+        return response.json()
+
+
+# Response Models
+class CryptoPrice(BaseModel):
+    """Model representing a cryptocurrency price."""
+
+    from_symbol: str
+    to_symbol: str
+    price: float
+
+
+class CryptoNews(BaseModel):
+    """Model representing a cryptocurrency news article."""
+
+    id: str
+    published_on: int
+    title: str
+    url: str
+    body: str
+    tags: str
+    categories: str
+    source: str
+    source_info: Dict[str, Any] = Field(default_factory=dict)
+
+
+class CryptoExchange(BaseModel):
+    """Model representing a cryptocurrency exchange."""
+
+    exchange: str
+    from_symbol: str
+    to_symbol: str
+    volume24h: float
+    volume24h_to: float
+
+
+class CryptoCurrency(BaseModel):
+    """Model representing a cryptocurrency."""
+
+    id: str
+    name: str
+    symbol: str
+    full_name: str
+    market_cap: float = 0
+    volume24h: float = 0
+    price: float = 0
+    change24h: float = 0

intentkit/skills/cryptocompare/fetch_news.py

@@ -0,0 +1,96 @@
+"""Tool for fetching cryptocurrency news via CryptoCompare API."""
+
+import logging
+from typing import List, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.cryptocompare.base import CryptoCompareBaseTool, CryptoNews
+
+logger = logging.getLogger(__name__)
+
+
+class CryptoCompareFetchNewsInput(BaseModel):
+    """Input for CryptoCompareFetchNews tool."""
+
+    token: str = Field(
+        ..., description="Token symbol to fetch news for (e.g., BTC, ETH, SOL)"
+    )
+
+
+class CryptoCompareFetchNews(CryptoCompareBaseTool):
+    """Tool for fetching cryptocurrency news from CryptoCompare.
+
+    This tool uses the CryptoCompare API to retrieve the latest news articles
+    related to a specific cryptocurrency token.
+
+    Attributes:
+        name: The name of the tool.
+        description: A description of what the tool does.
+        args_schema: The schema for the tool's input arguments.
+    """
+
+    name: str = "cryptocompare_fetch_news"
+    description: str = "Fetch the latest cryptocurrency news for a specific token"
+    args_schema: Type[BaseModel] = CryptoCompareFetchNewsInput
+
+    async def _arun(
+        self,
+        token: str,
+        config: RunnableConfig,
+        **kwargs,
+    ) -> List[CryptoNews]:
+        """Async implementation of the tool to fetch cryptocurrency news.
+
+        Args:
+            token: Token symbol to fetch news for (e.g., BTC, ETH, SOL)
+            config: The configuration for the runnable, containing agent context.
+
+        Returns:
+            List[CryptoNews]: A list of cryptocurrency news articles.
+
+        Raises:
+            Exception: If there's an error accessing the CryptoCompare API.
+        """
+        try:
+            context = self.context_from_config(config)
+
+            # Check rate limit
+            await self.check_rate_limit(context.agent.id, max_requests=5, interval=60)
+
+            # Get API key from context
+            api_key = context.config.get("api_key")
+            if not api_key:
+                raise ValueError("CryptoCompare API key not found in configuration")
+
+            # Fetch news data directly
+            news_data = await self.fetch_news(api_key, token)
+
+            # Check for errors
+            if "error" in news_data:
+                raise ValueError(news_data["error"])
+
+            # Convert to list of CryptoNews objects
+            result = []
+            if "Data" in news_data and news_data["Data"]:
+                for article in news_data["Data"]:
+                    result.append(
+                        CryptoNews(
+                            id=str(article["id"]),
+                            published_on=article["published_on"],
+                            title=article["title"],
+                            url=article["url"],
+                            body=article["body"],
+                            tags=article.get("tags", ""),
+                            categories=article.get("categories", ""),
+                            source=article["source"],
+                            source_info=article.get("source_info", {}),
+                        )
+                    )
+
+            return result
+
+        except Exception as e:
+            logger.error("Error fetching news: %s", str(e))
+            raise type(e)(f"[agent:{context.agent.id}]: {e}") from e