Skip to content

jeremylongshore/tons-of-skills-marketplace / plugins/crypto/market-price-tracker/skills/tracking-crypto-prices

tracking-crypto-prices

Flagged

Track real-time cryptocurrency prices across exchanges with historical data and alerts. Provides price data infrastructure for dependent skills (portfolio, tax, DeFi, arbitrage). Use when checking crypto prices, monitoring markets, or fetching historical price data. Trigger with phrases like "check price", "BTC price", "crypto prices", "price history", "get quote for", "what's ETH trading at", "show me top coins", or "track my watchlist".

FileKindSize
ARD.mdmarkdown26.8 KB
PRD.mdmarkdown19.0 KB
SKILL.mdskill md4.4 KB
config/settings.yamlconfig4.0 KB
references/errors.mdmarkdown5.7 KB
references/examples.mdmarkdown10.1 KB
references/implementation.mdmarkdown3.9 KB
scripts/api_client.pyscript15.8 KB
scripts/cache_manager.pyscript10.7 KB
scripts/formatters.pyscript12.4 KB
scripts/price_tracker.pyscript11.6 KB

scripts/cache_manager.py

View on GitHub
#!/usr/bin/env python3
"""
Cache Manager - TTL-Based Caching for Price Data

Provides intelligent caching with configurable TTL for spot prices
and historical data to minimize API calls and improve response times.

Author: Jeremy Longshore <jeremy@intentsolutions.io>
Version: 2.0.0
License: MIT
"""

import json
import time
from pathlib import Path
from typing import Optional, Dict, Any, List
from dataclasses import dataclass
import threading


@dataclass
class CacheEntry:
    """Represents a cached item with metadata."""

    data: Any
    timestamp: float
    ttl: int
    key: str

    @property
    def is_expired(self) -> bool:
        """Check if cache entry has expired."""
        return time.time() - self.timestamp > self.ttl

    @property
    def age(self) -> float:
        """Get age of cache entry in seconds."""
        return time.time() - self.timestamp

    def to_dict(self) -> dict:
        """Convert to dictionary for JSON serialization."""
        return {"data": self.data, "timestamp": self.timestamp, "ttl": self.ttl, "key": self.key}

    @classmethod
    def from_dict(cls, d: dict) -> "CacheEntry":
        """Create CacheEntry from dictionary."""
        return cls(data=d["data"], timestamp=d["timestamp"], ttl=d["ttl"], key=d["key"])


class CacheManager:
    """
    TTL-based cache manager for cryptocurrency price data.

    Features:
    - Separate TTLs for spot prices (short) and historical data (long)
    - File-based persistence
    - Thread-safe operations
    - Automatic cleanup of expired entries
    - Stale data access for fallback scenarios
    """

    def __init__(self, cache_dir: Optional[Path] = None, spot_ttl: int = 30, historical_ttl: int = 3600):
        """
        Initialize the cache manager.

        Args:
            cache_dir: Directory for cache files (default: ./data)
            spot_ttl: TTL for spot prices in seconds (default: 30)
            historical_ttl: TTL for historical data in seconds (default: 3600)
        """
        self.cache_dir = Path(cache_dir) if cache_dir else Path("./data")
        self.spot_ttl = spot_ttl
        self.historical_ttl = historical_ttl

        # Ensure cache directory exists
        self.cache_dir.mkdir(parents=True, exist_ok=True)

        # In-memory cache
        self._memory_cache: Dict[str, CacheEntry] = {}
        self._lock = threading.RLock()

        # File paths
        self._spot_cache_file = self.cache_dir / "spot_cache.json"
        self._historical_cache_file = self.cache_dir / "historical_cache.json"

        # Load existing cache
        self._load_cache()

    def _load_cache(self) -> None:
        """Load cache from disk."""
        with self._lock:
            # Load spot cache
            if self._spot_cache_file.exists():
                try:
                    with open(self._spot_cache_file, "r") as f:
                        data = json.load(f)
                        for key, entry_data in data.items():
                            entry = CacheEntry.from_dict(entry_data)
                            if not entry.is_expired:
                                self._memory_cache[key] = entry
                except (json.JSONDecodeError, KeyError):
                    pass

            # Load historical cache
            if self._historical_cache_file.exists():
                try:
                    with open(self._historical_cache_file, "r") as f:
                        data = json.load(f)
                        for key, entry_data in data.items():
                            entry = CacheEntry.from_dict(entry_data)
                            if not entry.is_expired:
                                self._memory_cache[key] = entry
                except (json.JSONDecodeError, KeyError):
                    pass

    def _save_cache(self) -> None:
        """Persist cache to disk."""
        with self._lock:
            spot_data = {}
            historical_data = {}

            for key, entry in self._memory_cache.items():
                if key.startswith("spot:"):
                    spot_data[key] = entry.to_dict()
                elif key.startswith("hist:"):
                    historical_data[key] = entry.to_dict()

            # Write spot cache
            try:
                with open(self._spot_cache_file, "w") as f:
                    json.dump(spot_data, f, indent=2)
            except IOError:
                pass

            # Write historical cache
            try:
                with open(self._historical_cache_file, "w") as f:
                    json.dump(historical_data, f, indent=2)
            except IOError:
                pass

    def _make_key(self, prefix: str, *parts: str) -> str:
        """
        Create a cache key from parts.

        Args:
            prefix: Key prefix (e.g., "spot", "hist")
            *parts: Key components

        Returns:
            Cache key string
        """
        key_str = ":".join([prefix] + [str(p).lower() for p in parts])
        return key_str

    def get_spot_price(self, symbol: str, currency: str, allow_stale: bool = False) -> Optional[dict]:
        """
        Get cached spot price.

        Args:
            symbol: Cryptocurrency symbol
            currency: Fiat currency
            allow_stale: Return stale data if no fresh data available

        Returns:
            Cached price data or None
        """
        key = self._make_key("spot", symbol, currency)

        with self._lock:
            entry = self._memory_cache.get(key)

            if entry is None:
                return None

            if entry.is_expired:
                if allow_stale:
                    # Return stale data with warning flag
                    data = entry.data.copy() if isinstance(entry.data, dict) else entry.data
                    if isinstance(data, dict):
                        data["_cache_stale"] = True
                        data["_cache_age"] = entry.age
                    return data
                return None

            data = entry.data.copy() if isinstance(entry.data, dict) else entry.data
            if isinstance(data, dict):
                data["_cached"] = True
                data["_cache_age"] = entry.age
            return data

    def set_spot_price(self, symbol: str, currency: str, data: dict) -> None:
        """
        Cache spot price data.

        Args:
            symbol: Cryptocurrency symbol
            currency: Fiat currency
            data: Price data to cache
        """
        key = self._make_key("spot", symbol, currency)

        with self._lock:
            self._memory_cache[key] = CacheEntry(data=data, timestamp=time.time(), ttl=self.spot_ttl, key=key)
            self._save_cache()

    def get_historical(self, cache_key: str, allow_stale: bool = False) -> Optional[List[dict]]:
        """
        Get cached historical data.

        Args:
            cache_key: Unique key for the historical query
            allow_stale: Return stale data if no fresh data available

        Returns:
            Cached historical data or None
        """
        key = self._make_key("hist", cache_key)

        with self._lock:
            entry = self._memory_cache.get(key)

            if entry is None:
                return None

            if entry.is_expired:
                if allow_stale:
                    return entry.data
                return None

            return entry.data

    def set_historical(self, cache_key: str, data: List[dict]) -> None:
        """
        Cache historical data.

        Args:
            cache_key: Unique key for the historical query
            data: Historical data to cache
        """
        key = self._make_key("hist", cache_key)

        with self._lock:
            self._memory_cache[key] = CacheEntry(data=data, timestamp=time.time(), ttl=self.historical_ttl, key=key)
            self._save_cache()

    def invalidate(self, pattern: Optional[str] = None) -> int:
        """
        Invalidate cache entries matching a pattern.

        Args:
            pattern: Key pattern to match (None = all)

        Returns:
            Number of entries invalidated
        """
        with self._lock:
            if pattern is None:
                count = len(self._memory_cache)
                self._memory_cache.clear()
            else:
                pattern_lower = pattern.lower()
                keys_to_remove = [k for k in self._memory_cache if pattern_lower in k.lower()]
                count = len(keys_to_remove)
                for key in keys_to_remove:
                    del self._memory_cache[key]

            self._save_cache()
            return count

    def clear(self) -> None:
        """Clear all cached data."""
        with self._lock:
            self._memory_cache.clear()

            # Remove cache files
            if self._spot_cache_file.exists():
                self._spot_cache_file.unlink()
            if self._historical_cache_file.exists():
                self._historical_cache_file.unlink()

    def cleanup(self) -> int:
        """
        Remove all expired entries.

        Returns:
            Number of entries removed
        """
        with self._lock:
            expired_keys = [k for k, v in self._memory_cache.items() if v.is_expired]
            for key in expired_keys:
                del self._memory_cache[key]

            if expired_keys:
                self._save_cache()

            return len(expired_keys)

    def get_stats(self) -> dict:
        """
        Get cache statistics.

        Returns:
            Dictionary with cache stats
        """
        with self._lock:
            spot_entries = [e for k, e in self._memory_cache.items() if k.startswith("spot:")]
            hist_entries = [e for k, e in self._memory_cache.items() if k.startswith("hist:")]

            spot_expired = sum(1 for e in spot_entries if e.is_expired)
            hist_expired = sum(1 for e in hist_entries if e.is_expired)

            return {
                "total_entries": len(self._memory_cache),
                "spot_entries": len(spot_entries),
                "spot_expired": spot_expired,
                "historical_entries": len(hist_entries),
                "historical_expired": hist_expired,
                "cache_dir": str(self.cache_dir),
                "spot_ttl": self.spot_ttl,
                "historical_ttl": self.historical_ttl,
            }

    def get_all_symbols(self) -> List[str]:
        """
        Get all symbols currently in cache.

        Returns:
            List of cached symbols
        """
        with self._lock:
            symbols = set()
            for key in self._memory_cache.keys():
                if key.startswith("spot:"):
                    parts = key.split(":")
                    if len(parts) >= 2:
                        symbols.add(parts[1].upper())
            return sorted(list(symbols))
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 323kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 118kUpdated Claude CodeCodexVerifiedInstall