django-cfg 1.2.29__py3-none-any.whl → 1.3.1__py3-none-any.whl

django_cfg/modules/django_currency/__init__.py

@@ -11,9 +11,6 @@ from .core import (
     Rate,
     ConversionRequest,
     ConversionResult,
-    SupportedCurrencies,
-    YFinanceCurrencies,
-    CoinGeckoCurrencies,
     CurrencyError,
     CurrencyNotFoundError,
     RateFetchError,
@@ -25,7 +22,7 @@ from .core import (
 from .utils import CacheManager
 
 # Clients
-from .clients import YFinanceClient, CoinGeckoClient
+from .clients import YahooFinanceClient, CoinPaprikaClient
 
 # Database tools
 from .database import (
@@ -35,6 +32,17 @@ from .database import (
     load_currencies_to_database_format
 )
 
+# Shared global converter instance for caching efficiency
+_global_converter = None
+
+def _get_converter() -> CurrencyConverter:
+    """Get or create shared converter instance."""
+    global _global_converter
+    if _global_converter is None:
+        _global_converter = CurrencyConverter(cache_ttl=3600)  # 1 hour cache
+    return _global_converter
+
+
 # Simple public API
 def convert_currency(amount: float, from_currency: str, to_currency: str) -> float:
     """
@@ -48,7 +56,7 @@ def convert_currency(amount: float, from_currency: str, to_currency: str) -> flo
     Returns:
         Converted amount
     """
-    converter = CurrencyConverter()
+    converter = _get_converter()
     result = converter.convert(amount, from_currency, to_currency)
     return result.result
 
@@ -64,7 +72,7 @@ def get_exchange_rate(base: str, quote: str) -> float:
     Returns:
         Exchange rate
     """
-    converter = CurrencyConverter()
+    converter = _get_converter()
     result = converter.convert(1.0, base, quote)
     return result.rate.rate
 
@@ -75,9 +83,6 @@ __all__ = [
     "Rate", 
     "ConversionRequest",
     "ConversionResult",
-    "SupportedCurrencies",
-    "YFinanceCurrencies", 
-    "CoinGeckoCurrencies",
     
     # Exceptions
     "CurrencyError",
@@ -90,8 +95,8 @@ __all__ = [
     "CacheManager",
     
     # Clients
-    "YFinanceClient",
-    "CoinGeckoClient",
+    "YahooFinanceClient",
+    "CoinPaprikaClient",
     
     # Database tools
     "CurrencyDatabaseLoader",

django_cfg/modules/django_currency/clients/__init__.py

@@ -2,10 +2,10 @@
 Currency data clients for fetching rates from external APIs.
 """
 
-from .yfinance_client import YFinanceClient
-from .coingecko_client import CoinGeckoClient
+from .yahoo_client import YahooFinanceClient
+from .coinpaprika_client import CoinPaprikaClient
 
 __all__ = [
-    'YFinanceClient', 
-    'CoinGeckoClient'
+    'YahooFinanceClient', 
+    'CoinPaprikaClient'
 ]

django_cfg/modules/django_currency/clients/coinpaprika_client.py

@@ -0,0 +1,289 @@
+"""
+CoinPaprika client for crypto rates - much simpler and more reliable than CoinGecko.
+
+CoinPaprika API provides all crypto rates in a single request without rate limits.
+"""
+
+import logging
+import time
+import requests
+from datetime import datetime
+from typing import Dict, Set, Optional, List
+from cachetools import TTLCache
+
+from ..core.models import Rate, CoinPaprikaTicker, CoinPaprikaTickersResponse
+from ..core.exceptions import RateFetchError
+
+logger = logging.getLogger(__name__)
+
+
+class CoinPaprikaClient:
+    """Client for fetching crypto rates from CoinPaprika API."""
+    
+    def __init__(self, cache_ttl: int = 600):
+        """Initialize CoinPaprika client with TTL cache."""
+        self.base_url = "https://api.coinpaprika.com/v1"
+        self._rate_cache = TTLCache(maxsize=5000, ttl=cache_ttl)  # Cache rates for 10 minutes
+        self._all_rates_cache = TTLCache(maxsize=1, ttl=300)  # Cache all rates for 5 minutes
+        self._session = requests.Session()
+        self._session.headers.update({
+            'User-Agent': 'django-cfg-currency-client/1.0',
+            'Accept': 'application/json'
+        })
+    
+    def fetch_rate(self, base: str, quote: str) -> Rate:
+        """
+        Fetch crypto exchange rate from CoinPaprika.
+        
+        Args:
+            base: Base currency code (crypto)
+            quote: Quote currency code (usually USD)
+            
+        Returns:
+            Rate object with exchange rate data
+            
+        Raises:
+            RateFetchError: If rate fetch fails
+        """
+        if quote.upper() != 'USD':
+            raise RateFetchError(f"CoinPaprika only supports USD quotes, got {quote}")
+        
+        cache_key = f"{base.upper()}_{quote.upper()}"
+        
+        # Try cache first
+        if cache_key in self._rate_cache:
+            logger.debug(f"Retrieved rate {base}/{quote} from cache")
+            return self._rate_cache[cache_key]
+        
+        try:
+            # Get all rates and find our currency
+            all_rates = self._fetch_all_rates()
+            
+            base_upper = base.upper()
+            for ticker in all_rates:
+                if ticker.symbol == base_upper:
+                    price = ticker.quotes.USD.price
+                    
+                    # Parse ISO format: 2021-01-01T00:00:00Z
+                    timestamp = datetime.fromisoformat(ticker.last_updated.replace('Z', '+00:00'))
+                    
+                    rate = Rate(
+                        source="coinpaprika",
+                        base_currency=base.upper(),
+                        quote_currency="USD",
+                        rate=float(price),
+                        timestamp=timestamp
+                    )
+                    
+                    # Cache the result
+                    self._rate_cache[cache_key] = rate
+                    
+                    return rate
+            
+            raise RateFetchError(f"Currency {base} not found in CoinPaprika data")
+            
+        except Exception as e:
+            logger.error(f"Failed to fetch rate for {base}/{quote}: {e}")
+            raise RateFetchError(f"CoinPaprika fetch failed: {e}")
+    
+    def _fetch_all_tickers(self) -> Dict[str, dict]:
+        """
+        Fetch all tickers from CoinPaprika API.
+        
+        Returns:
+            Dict with symbol as key and ticker data as value
+        """
+        cache_key = "all_tickers"
+        if cache_key in self._all_rates_cache:
+            logger.debug("Retrieved all tickers from CoinPaprika cache")
+            return self._all_rates_cache[cache_key]
+
+        try:
+            response = requests.get(f"{self.base_url}/tickers")
+            response.raise_for_status()
+            tickers_data = response.json()
+            
+            # Process data into a more accessible format: {symbol: {id: ..., price: ...}}
+            processed_tickers = {}
+            for ticker in tickers_data:
+                symbol = ticker['symbol'].upper()
+                processed_tickers[symbol] = {
+                    'id': ticker['id'],
+                    'name': ticker['name'],
+                    'price_usd': ticker['quotes']['USD']['price'] if 'USD' in ticker['quotes'] else None,
+                    'last_updated': ticker['last_updated']
+                }
+            
+            self._all_rates_cache[cache_key] = processed_tickers
+            logger.info(f"Fetched and cached {len(processed_tickers)} tickers from CoinPaprika")
+            return processed_tickers
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Failed to fetch all tickers from CoinPaprika: {e}")
+            raise RateFetchError(f"CoinPaprika API error: {e}")
+
+    def _fetch_all_rates(self) -> List[CoinPaprikaTicker]:
+        """
+        Fetch all cryptocurrency rates from CoinPaprika.
+        
+        Returns:
+            List of CoinPaprikaTicker objects
+        """
+        cache_key = "all_rates"
+        
+        # Try cache first
+        if cache_key in self._all_rates_cache:
+            logger.debug("Retrieved all rates from cache")
+            return self._all_rates_cache[cache_key]
+        
+        try:
+            url = f"{self.base_url}/tickers"
+            logger.debug(f"Fetching all rates from {url}")
+            
+            response = self._session.get(url, timeout=30)
+            response.raise_for_status()
+            
+            raw_data = response.json()
+            
+            # Validate response using Pydantic model
+            try:
+                tickers_response = CoinPaprikaTickersResponse(raw_data)
+                tickers = tickers_response.root
+            except Exception as e:
+                raise RateFetchError(f"Invalid CoinPaprika response format: {e}")
+            
+            # Cache the result
+            self._all_rates_cache[cache_key] = tickers
+            logger.info(f"Fetched {len(tickers)} cryptocurrencies from CoinPaprika")
+            
+            return tickers
+            
+        except requests.RequestException as e:
+            logger.error(f"HTTP error fetching from CoinPaprika: {e}")
+            raise RateFetchError(f"Failed to fetch data from CoinPaprika: {e}")
+        except Exception as e:
+            logger.error(f"Unexpected error fetching from CoinPaprika: {e}")
+            raise RateFetchError(f"CoinPaprika fetch failed: {e}")
+    
+    def get_supported_cryptocurrencies(self) -> Set[str]:
+        """
+        Get all supported cryptocurrency symbols.
+        
+        Returns:
+            Set of supported crypto symbols
+        """
+        try:
+            all_rates = self._fetch_all_rates()
+            symbols = {ticker.symbol for ticker in all_rates}
+            logger.debug(f"Found {len(symbols)} supported cryptocurrencies")
+            return symbols
+        except Exception as e:
+            logger.error(f"Failed to get supported cryptocurrencies: {e}")
+            return set()
+
+    def get_all_supported_currencies(self) -> Dict[str, str]:
+        """Get all supported cryptocurrencies from CoinPaprika."""
+        all_tickers = self._fetch_all_tickers()
+        return {symbol: data['name'] for symbol, data in all_tickers.items() if data['price_usd'] is not None}
+    
+    def supports_pair(self, base: str, quote: str) -> bool:
+        """
+        Check if a currency pair is supported.
+        
+        Args:
+            base: Base currency code
+            quote: Quote currency code
+            
+        Returns:
+            True if supported, False otherwise
+        """
+        if quote.upper() != 'USD':
+            return False
+        
+        supported_cryptos = self.get_supported_cryptocurrencies()
+        return base.upper() in supported_cryptos
+    
+    def fetch_multiple_rates(self, currency_codes: List[str], quote: str = 'USD') -> Dict[str, Rate]:
+        """
+        Fetch multiple cryptocurrency rates efficiently.
+        
+        Args:
+            currency_codes: List of crypto currency codes
+            quote: Quote currency (default: USD)
+            
+        Returns:
+            Dictionary mapping currency codes to Rate objects
+        """
+        if quote.upper() != 'USD':
+            raise RateFetchError(f"CoinPaprika only supports USD quotes, got {quote}")
+        
+        results = {}
+        
+        try:
+            # Fetch all rates once
+            all_rates = self._fetch_all_rates()
+            
+            # Create lookup dictionary
+            rates_by_symbol = {ticker.symbol: ticker for ticker in all_rates}
+            
+            # Process requested currencies
+            for currency_code in currency_codes:
+                currency_upper = currency_code.upper()
+                
+                if currency_upper in rates_by_symbol:
+                    ticker = rates_by_symbol[currency_upper]
+                    price = ticker.quotes.USD.price
+                    
+                    # Parse ISO format: 2021-01-01T00:00:00Z
+                    timestamp = datetime.fromisoformat(ticker.last_updated.replace('Z', '+00:00'))
+                    
+                    rate = Rate(
+                        source="coinpaprika",
+                        base_currency=currency_upper,
+                        quote_currency="USD",
+                        rate=float(price),
+                        timestamp=timestamp
+                    )
+                    
+                    results[currency_upper] = rate
+                    
+                    # Cache individual rate
+                    cache_key = f"{currency_upper}_USD"
+                    self._rate_cache[cache_key] = rate
+                else:
+                    logger.warning(f"Currency {currency_code} not found in CoinPaprika data")
+            
+            logger.info(f"Successfully fetched {len(results)} rates from CoinPaprika")
+            return results
+            
+        except Exception as e:
+            logger.error(f"Failed to fetch multiple rates: {e}")
+            raise RateFetchError(f"CoinPaprika batch fetch failed: {e}")
+    
+    def get_top_cryptocurrencies(self, limit: int = 100) -> List[Dict]:
+        """
+        Get top cryptocurrencies by market cap rank.
+        
+        Args:
+            limit: Maximum number of currencies to return
+            
+        Returns:
+            List of cryptocurrency data dictionaries
+        """
+        try:
+            all_rates = self._fetch_all_rates()
+            
+            # Filter and sort by rank
+            valid_tickers = [
+                ticker for ticker in all_rates 
+                if ticker.rank and ticker.quotes.USD.price
+            ]
+            
+            # Sort by rank and limit
+            top_tickers = sorted(valid_tickers, key=lambda x: x.rank)[:limit]
+            
+            logger.info(f"Retrieved top {len(top_tickers)} cryptocurrencies")
+            return top_tickers
+            
+        except Exception as e:
+            logger.error(f"Failed to get top cryptocurrencies: {e}")
+            return []

django_cfg/modules/django_currency/clients/yahoo_client.py

@@ -0,0 +1,157 @@
+import logging
+import requests
+import time
+from datetime import datetime
+from typing import Dict, Set, Optional
+from cachetools import TTLCache
+
+from ..core.models import Rate, YahooFinanceResponse
+from ..core.exceptions import RateFetchError
+
+logger = logging.getLogger(__name__)
+
+
+class YahooFinanceClient:
+    """Simple Yahoo Finance client without yfinance dependency."""
+
+    BASE_URL = "https://query1.finance.yahoo.com/v8/finance/chart"
+    
+    def __init__(self, cache_ttl: int = 3600):
+        """Initialize Yahoo Finance client with TTL cache."""
+        self._rate_cache = TTLCache(maxsize=500, ttl=cache_ttl)
+        self._session = requests.Session()
+        self._session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+        })
+        self._last_request_time = 0
+        self._rate_limit_delay = 1.0  # 1 second between requests
+
+    def _get_yahoo_symbol(self, base: str, quote: str) -> str:
+        """Convert currency pair to Yahoo Finance symbol format."""
+        # Yahoo uses format like EURUSD=X for forex pairs
+        return f"{base}{quote}=X"
+
+    def fetch_rate(self, base: str, quote: str) -> Rate:
+        """
+        Fetch forex rate from Yahoo Finance with caching.
+        
+        Args:
+            base: Base currency code (e.g., EUR)
+            quote: Quote currency code (e.g., USD)
+            
+        Returns:
+            Rate object with exchange rate data
+            
+        Raises:
+            RateFetchError: If rate fetch fails
+        """
+        base = base.upper()
+        quote = quote.upper()
+        cache_key = f"{base}_{quote}"
+
+        # Try cache first
+        if cache_key in self._rate_cache:
+            logger.debug(f"Retrieved rate {base}/{quote} from Yahoo cache")
+            return self._rate_cache[cache_key]
+
+        symbol = self._get_yahoo_symbol(base, quote)
+        
+        # Rate limiting
+        current_time = time.time()
+        time_since_last_request = current_time - self._last_request_time
+        if time_since_last_request < self._rate_limit_delay:
+            sleep_time = self._rate_limit_delay - time_since_last_request
+            logger.debug(f"Rate limiting: sleeping for {sleep_time:.2f}s")
+            time.sleep(sleep_time)
+        
+        try:
+            response = self._session.get(f"{self.BASE_URL}/{symbol}")
+            self._last_request_time = time.time()
+            response.raise_for_status()
+            
+            raw_data = response.json()
+            
+            # Validate response using Pydantic model
+            try:
+                yahoo_response = YahooFinanceResponse(**raw_data)
+            except Exception as e:
+                raise RateFetchError(f"Invalid Yahoo Finance response format: {e}")
+
+            if not yahoo_response.chart.result:
+                raise RateFetchError(f"No data returned for {symbol}")
+
+            meta = yahoo_response.chart.result[0].meta
+            rate_value = meta.regularMarketPrice
+            timestamp = datetime.fromtimestamp(meta.regularMarketTime)
+            
+            rate = Rate(
+                source="yahoo",
+                base_currency=base,
+                quote_currency=quote,
+                rate=float(rate_value),
+                timestamp=timestamp
+            )
+            
+            self._rate_cache[cache_key] = rate
+            logger.info(f"Fetched rate {base}/{quote} = {rate_value} from Yahoo Finance")
+            return rate
+            
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Failed to fetch rate from Yahoo Finance: {e}")
+            raise RateFetchError(f"Yahoo Finance API error: {e}")
+        except (KeyError, TypeError, ValueError) as e:
+            logger.error(f"Failed to parse Yahoo Finance response: {e}")
+            raise RateFetchError(f"Invalid response format: {e}")
+        except Exception as e:
+            logger.error(f"Unexpected error fetching from Yahoo Finance: {e}")
+            raise RateFetchError(f"Yahoo Finance fetch failed: {e}")
+
+    def supports_pair(self, base: str, quote: str) -> bool:
+        """
+        Check if Yahoo Finance supports the given currency pair.
+        
+        Yahoo Finance primarily supports major forex pairs.
+        """
+        base = base.upper()
+        quote = quote.upper()
+        
+        # Major currencies supported by Yahoo Finance
+        major_currencies = {
+            'USD', 'EUR', 'GBP', 'JPY', 'CHF', 'CAD', 'AUD', 'NZD',
+            'SEK', 'NOK', 'DKK', 'PLN', 'CZK', 'HUF', 'RUB', 'CNY',
+            'INR', 'KRW', 'SGD', 'HKD', 'THB', 'MXN', 'BRL', 'ZAR',
+            'TRY', 'ILS'
+        }
+        
+        return base in major_currencies and quote in major_currencies
+
+    def get_all_supported_currencies(self) -> Dict[str, str]:
+        """Get all major currencies supported by Yahoo Finance."""
+        return {
+            'USD': 'US Dollar',
+            'EUR': 'Euro',
+            'GBP': 'British Pound',
+            'JPY': 'Japanese Yen',
+            'CHF': 'Swiss Franc',
+            'CAD': 'Canadian Dollar',
+            'AUD': 'Australian Dollar',
+            'NZD': 'New Zealand Dollar',
+            'SEK': 'Swedish Krona',
+            'NOK': 'Norwegian Krone',
+            'DKK': 'Danish Krone',
+            'PLN': 'Polish Zloty',
+            'CZK': 'Czech Koruna',
+            'HUF': 'Hungarian Forint',
+            'RUB': 'Russian Ruble',
+            'CNY': 'Chinese Yuan',
+            'INR': 'Indian Rupee',
+            'KRW': 'South Korean Won',
+            'SGD': 'Singapore Dollar',
+            'HKD': 'Hong Kong Dollar',
+            'THB': 'Thai Baht',
+            'MXN': 'Mexican Peso',
+            'BRL': 'Brazilian Real',
+            'ZAR': 'South African Rand',
+            'TRY': 'Turkish Lira',
+            'ILS': 'Israeli Shekel'
+        }

django_cfg/modules/django_currency/core/__init__.py

@@ -5,10 +5,7 @@ Core currency conversion functionality.
 from .models import (
     Rate,
     ConversionRequest,
-    ConversionResult,
-    YFinanceCurrencies,
-    CoinGeckoCurrencies,
-    SupportedCurrencies
+    ConversionResult
 )
 
 from .exceptions import (
@@ -26,9 +23,6 @@ __all__ = [
     'Rate',
     'ConversionRequest', 
     'ConversionResult',
-    'YFinanceCurrencies',
-    'CoinGeckoCurrencies',
-    'SupportedCurrencies',
     
     # Exceptions
     'CurrencyError',

django_cfg/modules/django_currency/core/converter.py

@@ -5,9 +5,9 @@ Main currency converter with intelligent routing.
 import logging
 from typing import Optional
 
-from .models import Rate, ConversionRequest, ConversionResult, SupportedCurrencies, YFinanceCurrencies, CoinGeckoCurrencies
+from .models import Rate, ConversionRequest, ConversionResult
 from .exceptions import ConversionError, CurrencyNotFoundError
-from ..clients import YFinanceClient, CoinGeckoClient
+from ..clients import YahooFinanceClient, CoinPaprikaClient
 from ..utils.cache import CacheManager
 
 logger = logging.getLogger(__name__)
@@ -23,8 +23,8 @@ class CurrencyConverter:
         Args:
             cache_ttl: Cache TTL in seconds
         """
-        self.yfinance = YFinanceClient()
-        self.coingecko = CoinGeckoClient()
+        self.yahoo = YahooFinanceClient(cache_ttl=cache_ttl)
+        self.coinpaprika = CoinPaprikaClient(cache_ttl=cache_ttl)
         self.cache = CacheManager(ttl=cache_ttl)
         
     def convert(self, amount: float, from_currency: str, to_currency: str) -> ConversionResult:
@@ -95,28 +95,28 @@ class CurrencyConverter:
             CurrencyNotFoundError: If no provider supports the pair
         """
         # Try cache first
-        for source in ["yfinance", "coingecko"]:
+        for source in ["yahoo", "coinpaprika"]:
             cached_rate = self.cache.get_rate(base, quote, source)
             if cached_rate:
                 return cached_rate
         
-        # Try YFinance first (good for fiat and major crypto)
-        if self.yfinance.supports_pair(base, quote):
+        # Try CoinPaprika first (excellent for crypto, no rate limits)
+        if self.coinpaprika.supports_pair(base, quote):
             try:
-                rate = self.yfinance.fetch_rate(base, quote)
+                rate = self.coinpaprika.fetch_rate(base, quote)
                 self.cache.set_rate(rate)
                 return rate
             except Exception as e:
-                logger.warning(f"YFinance failed for {base}/{quote}: {e}")
+                logger.warning(f"CoinPaprika failed for {base}/{quote}: {e}")
         
-        # Try CoinGecko (good for crypto)
-        if self.coingecko.supports_pair(base, quote):
+        # Try Yahoo Finance next (good for fiat and major forex pairs)
+        if self.yahoo.supports_pair(base, quote):
             try:
-                rate = self.coingecko.fetch_rate(base, quote)
+                rate = self.yahoo.fetch_rate(base, quote)
                 self.cache.set_rate(rate)
                 return rate
             except Exception as e:
-                logger.warning(f"CoinGecko failed for {base}/{quote}: {e}")
+                logger.warning(f"Yahoo Finance failed for {base}/{quote}: {e}")
         
         # Try indirect conversion via USD
         if base != "USD" and quote != "USD":
@@ -156,14 +156,9 @@ class CurrencyConverter:
             rate=combined_rate
         )
     
-    def get_supported_currencies(self) -> SupportedCurrencies:
+    def get_supported_currencies(self) -> dict:
         """Get list of supported currencies by provider."""
-        return SupportedCurrencies(
-            yfinance=YFinanceCurrencies(
-                fiat=list(self.yfinance.get_fiat_currencies())
-            ),
-            coingecko=CoinGeckoCurrencies(
-                crypto=list(self.coingecko.get_crypto_ids().keys()),
-                vs_currencies=list(self.coingecko.get_vs_currencies())
-            )
-        )
+        return {
+            "yahoo": self.yahoo.get_all_supported_currencies(),
+            "coinpaprika": self.coinpaprika.get_all_supported_currencies()
+        }