django-cfg 1.2.23__py3-none-any.whl → 1.2.25__py3-none-any.whl

django_cfg/modules/django_currency/clients/coingecko_client.py

@@ -0,0 +1,257 @@
+"""
+CoinGecko client for crypto rates only.
+"""
+
+import logging
+import time
+from datetime import datetime
+from typing import Dict, Set, Optional
+from cachetools import TTLCache
+from pycoingecko import CoinGeckoAPI
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
+from ..core.models import Rate
+from ..core.exceptions import RateFetchError
+
+logger = logging.getLogger(__name__)
+
+
+class CoinGeckoClient:
+    """Client for fetching crypto rates from CoinGecko."""
+    
+    def __init__(self, cache_ttl: int = 3600, rate_limit_delay: float = 1.2):
+        """Initialize CoinGecko client with TTL cache and rate limiting."""
+        self.client = CoinGeckoAPI()
+        self._crypto_cache = TTLCache(maxsize=2, ttl=cache_ttl)  # Cache crypto data for 1 hour
+        self._rate_cache = TTLCache(maxsize=1000, ttl=600)  # Cache rates for 10 minutes
+        self._last_request_time = 0.0
+        self._rate_limit_delay = rate_limit_delay  # Delay between requests to avoid 429
+    
+    def fetch_rate(self, base: str, quote: str) -> Rate:
+        """
+        Fetch crypto exchange rate from CoinGecko with caching.
+        
+        Args:
+            base: Base currency code (crypto)
+            quote: Quote currency code
+            
+        Returns:
+            Rate object with exchange rate data
+            
+        Raises:
+            RateFetchError: If rate fetch fails
+        """
+        cache_key = f"{base}_{quote}"
+        
+        # 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:
+            rate = self._fetch_rate_with_retry(base, quote)
+            
+            # Cache the result
+            self._rate_cache[cache_key] = rate
+            
+            return rate
+            
+        except Exception as e:
+            logger.error(f"Failed to fetch rate for {base}/{quote}: {e}")
+            raise RateFetchError(f"CoinGecko fetch failed: {e}")
+
+    @retry(
+        stop=stop_after_attempt(4),  # More retries for CoinGecko due to rate limits
+        wait=wait_exponential(multiplier=2, min=2, max=30),  # Longer waits for rate-limited API
+        retry=retry_if_exception_type((ConnectionError, TimeoutError, Exception)),
+        reraise=True
+    )
+    def _fetch_rate_with_retry(self, base: str, quote: str) -> Rate:
+        """
+        Fetch rate with retry logic and exponential backoff.
+        
+        Args:
+            base: Base currency code (crypto)
+            quote: Quote currency code
+            
+        Returns:
+            Rate object with exchange rate data
+        """
+        base_id = self._get_crypto_id(base)
+        quote_currency = quote.lower()
+        
+        vs_currencies = self.get_vs_currencies()
+        if quote_currency not in vs_currencies:
+            raise RateFetchError(f"Quote currency {quote} not supported by CoinGecko")
+        
+        logger.debug(f"Fetching rate for {base_id} vs {quote_currency}")
+        
+        # Fetch price from CoinGecko with rate limiting
+        self._rate_limit()
+        price_data = self.client.get_price(
+            ids=base_id,
+            vs_currencies=quote_currency,
+            include_last_updated_at=True
+        )
+        
+        if base_id not in price_data:
+            raise RateFetchError(f"No data for {base}")
+        
+        rate_value = price_data[base_id][quote_currency]
+        
+        return Rate(
+            source="coingecko",
+            base_currency=base.upper(),
+            quote_currency=quote.upper(),
+            rate=float(rate_value),
+            timestamp=datetime.now()
+        )
+    
+    def get_crypto_ids(self) -> Dict[str, str]:
+        """Get all supported cryptocurrencies dynamically with caching."""
+        cache_key = "crypto_ids"
+        
+        # Try cache first
+        if cache_key in self._crypto_cache:
+            logger.debug("Retrieved crypto IDs from cache")
+            return self._crypto_cache[cache_key]
+        
+        try:
+            crypto_ids = self._get_coins_list_with_retry()
+            
+            # Cache the result
+            self._crypto_cache[cache_key] = crypto_ids
+            logger.info(f"Loaded and cached {len(crypto_ids)} cryptocurrencies from CoinGecko")
+            
+            return crypto_ids
+            
+        except Exception as e:
+            logger.error(f"Failed to load cryptocurrencies: {e}")
+            raise RateFetchError(f"Failed to load cryptocurrencies from CoinGecko: {e}")
+    
+    def get_vs_currencies(self) -> Set[str]:
+        """Get all supported quote currencies dynamically with caching."""
+        cache_key = "vs_currencies"
+        
+        # Try cache first
+        if cache_key in self._crypto_cache:
+            logger.debug("Retrieved vs_currencies from cache")
+            return self._crypto_cache[cache_key]
+        
+        try:
+            vs_currencies_set = self._get_vs_currencies_with_retry()
+            
+            # Cache the result
+            self._crypto_cache[cache_key] = vs_currencies_set
+            logger.info(f"Loaded and cached {len(vs_currencies_set)} vs_currencies from CoinGecko")
+            
+            return vs_currencies_set
+            
+        except Exception as e:
+            logger.error(f"Failed to load vs_currencies: {e}")
+            raise RateFetchError(f"Failed to load vs_currencies from CoinGecko: {e}")
+    
+    def _get_crypto_id(self, currency: str) -> str:
+        """Get CoinGecko crypto ID from currency code."""
+        currency = currency.upper()
+        crypto_ids = self.get_crypto_ids()
+        
+        if currency in crypto_ids:
+            return crypto_ids[currency]
+        
+        raise RateFetchError(f"Unknown cryptocurrency: {currency}")
+    
+    def _rate_limit(self):
+        """Enforce rate limiting to prevent API throttling."""
+        current_time = time.time()
+        time_since_last = current_time - self._last_request_time
+        
+        if time_since_last < self._rate_limit_delay:
+            sleep_time = self._rate_limit_delay - time_since_last
+            logger.debug(f"Rate limiting: sleeping for {sleep_time:.2f}s")
+            time.sleep(sleep_time)
+        
+        self._last_request_time = time.time()
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=2, min=2, max=15),
+        retry=retry_if_exception_type((ConnectionError, TimeoutError, Exception)),
+        reraise=True
+    )
+    def _get_coins_list_with_retry(self) -> Dict[str, str]:
+        """Get coins list with retry logic."""
+        self._rate_limit()
+        coins_list = self.client.get_coins_list()
+        crypto_ids = {}
+        
+        for coin in coins_list:
+            symbol = coin['symbol'].upper()
+            crypto_ids[symbol] = coin['id']
+        
+        return crypto_ids
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=2, min=2, max=15),
+        retry=retry_if_exception_type((ConnectionError, TimeoutError, Exception)),
+        reraise=True
+    )
+    def _get_vs_currencies_with_retry(self) -> Set[str]:
+        """Get vs currencies with retry logic."""
+        self._rate_limit()
+        vs_currencies = self.client.get_supported_vs_currencies()
+        return set(vs_currencies)
+
+    def fetch_multiple_rates(self, pairs: list) -> Dict[str, Rate]:
+        """
+        Fetch multiple currency rates in parallel.
+        
+        Args:
+            pairs: List of tuples (base, quote) to fetch
+            
+        Returns:
+            Dictionary mapping "BASE_QUOTE" to Rate objects
+        """
+        results = {}
+        
+        def fetch_single_rate(pair):
+            base, quote = pair
+            try:
+                rate = self.fetch_rate(base, quote)
+                return f"{base}_{quote}", rate
+            except Exception as e:
+                logger.warning(f"Failed to fetch {base}/{quote}: {e}")
+                return f"{base}_{quote}", None
+        
+        # Use ThreadPoolExecutor for parallel fetching with rate limiting
+        with ThreadPoolExecutor(max_workers=3) as executor:  # Limited workers to respect rate limits
+            future_to_pair = {executor.submit(fetch_single_rate, pair): pair for pair in pairs}
+            
+            for future in as_completed(future_to_pair):
+                try:
+                    key, rate = future.result(timeout=30)
+                    if rate:
+                        results[key] = rate
+                except Exception as e:
+                    pair = future_to_pair[future]
+                    logger.error(f"Failed to fetch rate for {pair}: {e}")
+        
+        logger.info(f"Successfully fetched {len(results)}/{len(pairs)} rates")
+        return results
+    
+    def supports_pair(self, base: str, quote: str) -> bool:
+        """Check if crypto currency pair is supported."""
+        try:
+            # Base must be a crypto
+            crypto_ids = self.get_crypto_ids()
+            if base.upper() not in crypto_ids:
+                return False
+            
+            # Quote must be a supported vs_currency
+            vs_currencies = self.get_vs_currencies()
+            return quote.lower() in vs_currencies
+            
+        except Exception:
+            return False

django_cfg/modules/django_currency/clients/yfinance_client.py

@@ -0,0 +1,246 @@
+"""
+YFinance client for fiat currencies only.
+"""
+
+import logging
+import yfinance as yf
+from datetime import datetime
+from typing import Set, Optional
+from cachetools import TTLCache
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import time
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
+from ..core.models import Rate
+from ..core.exceptions import RateFetchError
+
+logger = logging.getLogger(__name__)
+
+
+class YFinanceClient:
+    """Client for fetching fiat currency rates from Yahoo Finance."""
+    
+    def __init__(self, cache_ttl: int = 3600):
+        """Initialize YFinance client with TTL cache."""
+        self._currency_cache = TTLCache(maxsize=1, ttl=cache_ttl)  # Cache currencies for 1 hour
+        self._rate_cache = TTLCache(maxsize=1000, ttl=300)  # Cache rates for 5 minutes
+    
+    def fetch_rate(self, base: str, quote: str) -> Rate:
+        """
+        Fetch exchange rate from YFinance with caching.
+        
+        Args:
+            base: Base currency code
+            quote: Quote currency code
+            
+        Returns:
+            Rate object with exchange rate data
+            
+        Raises:
+            RateFetchError: If rate fetch fails
+        """
+        cache_key = f"{base}_{quote}"
+        
+        # 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:
+            rate = self._fetch_rate_with_retry(base, quote)
+            
+            # Cache the result
+            self._rate_cache[cache_key] = rate
+            
+            return rate
+            
+        except Exception as e:
+            logger.error(f"Failed to fetch rate for {base}/{quote}: {e}")
+            raise RateFetchError(f"YFinance fetch failed: {e}")
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=1, max=10),
+        retry=retry_if_exception_type((ConnectionError, TimeoutError, Exception)),
+        reraise=True
+    )
+    def _fetch_rate_with_retry(self, base: str, quote: str) -> Rate:
+        """
+        Fetch rate with retry logic and exponential backoff.
+        
+        Args:
+            base: Base currency code
+            quote: Quote currency code
+            
+        Returns:
+            Rate object with exchange rate data
+        """
+        symbol = self._build_symbol(base, quote)
+        logger.debug(f"Fetching rate for {symbol}")
+        
+        ticker = yf.Ticker(symbol)
+        
+        # Try to get current price from info
+        info = ticker.info
+        if 'regularMarketPrice' in info and info['regularMarketPrice']:
+            rate_value = float(info['regularMarketPrice'])
+            logger.debug(f"Got rate from info: {rate_value}")
+        else:
+            # Fallback to history
+            hist = ticker.history(period="1d")
+            if hist.empty:
+                raise RateFetchError(f"No data available for {symbol}")
+            rate_value = float(hist['Close'].iloc[-1])
+            logger.debug(f"Got rate from history: {rate_value}")
+        
+        return Rate(
+            source="yfinance",
+            base_currency=base,
+            quote_currency=quote,
+            rate=rate_value,
+            timestamp=datetime.now()
+        )
+    
+    def get_fiat_currencies(self) -> Set[str]:
+        """Get all supported fiat currencies dynamically with caching."""
+        cache_key = "fiat_currencies"
+        
+        # Try cache first
+        if cache_key in self._currency_cache:
+            logger.debug("Retrieved fiat currencies from cache")
+            return self._currency_cache[cache_key]
+        
+        # Load currencies dynamically
+        currencies = self._discover_fiat_currencies()
+        
+        # Cache the result
+        self._currency_cache[cache_key] = currencies
+        logger.info(f"Loaded and cached {len(currencies)} fiat currencies from YFinance")
+        
+        return currencies
+    
+    def _discover_fiat_currencies(self) -> Set[str]:
+        """Discover available fiat currencies dynamically using YFinance with multithreading."""
+        currencies = set()
+        
+        try:
+            # Known major currencies to test efficiently
+            test_currencies = [
+                "USD", "EUR", "GBP", "JPY", "CAD", "AUD", "CHF", "CNY", "KRW", "RUB",
+                "SGD", "HKD", "INR", "THB", "MYR", "PHP", "IDR", "VND", "BRL", "MXN", 
+                "ZAR", "TRY", "PLN", "CZK", "HUF", "DKK", "SEK", "NOK", "NZD", "TWD"
+            ]
+            
+            logger.debug(f"Testing {len(test_currencies)} currency pairs with multithreading...")
+            
+            @retry(
+                stop=stop_after_attempt(2),
+                wait=wait_exponential(multiplier=1, min=1, max=5),
+                retry=retry_if_exception_type((ConnectionError, TimeoutError)),
+                reraise=False  # Don't reraise for currency discovery
+            )
+            def test_currency(base_currency):
+                """Test a single currency pair with retry logic."""
+                try:
+                    # Test against USD
+                    symbol = f"{base_currency}USD=X" if base_currency != "USD" else "EURUSD=X"
+                    ticker = yf.Ticker(symbol)
+                    info = ticker.info
+                    
+                    # If ticker has valid data, return the currencies
+                    if info and 'symbol' in info:
+                        result_currencies = set()
+                        if base_currency != "USD":
+                            result_currencies.add(base_currency)
+                        result_currencies.add("USD")
+                        logger.debug(f"Verified: {symbol}")
+                        return result_currencies
+                    return set()
+                    
+                except Exception as e:
+                    logger.debug(f"Failed to verify {base_currency}: {e}")
+                    return set()
+            
+            # Use ThreadPoolExecutor for parallel testing
+            with ThreadPoolExecutor(max_workers=5) as executor:
+                # Submit all tasks
+                future_to_currency = {
+                    executor.submit(test_currency, currency): currency 
+                    for currency in test_currencies
+                }
+                
+                # Collect results as they complete
+                for future in as_completed(future_to_currency):
+                    try:
+                        result = future.result(timeout=10)  # 10 second timeout per request
+                        currencies.update(result)
+                    except Exception as e:
+                        currency = future_to_currency[future]
+                        logger.debug(f"Future failed for {currency}: {e}")
+                        
+            logger.info(f"Discovered {len(currencies)} fiat currencies dynamically with multithreading")
+            return currencies if currencies else {"USD", "EUR", "GBP", "JPY"}  # Fallback to major currencies
+            
+        except Exception as e:
+            logger.warning(f"Failed to discover currencies dynamically: {e}")
+            # Return minimal set as fallback
+            return {"USD", "EUR", "GBP", "JPY", "CAD", "AUD"}
+
+    def fetch_multiple_rates(self, pairs: list) -> dict:
+        """
+        Fetch multiple currency rates in parallel.
+        
+        Args:
+            pairs: List of tuples (base, quote) to fetch
+            
+        Returns:
+            Dictionary mapping "BASE_QUOTE" to Rate objects
+        """
+        results = {}
+        
+        def fetch_single_rate(pair):
+            base, quote = pair
+            try:
+                rate = self.fetch_rate(base, quote)
+                return f"{base}_{quote}", rate
+            except Exception as e:
+                logger.warning(f"Failed to fetch {base}/{quote}: {e}")
+                return f"{base}_{quote}", None
+        
+        # Use ThreadPoolExecutor for parallel fetching
+        with ThreadPoolExecutor(max_workers=8) as executor:  # YFinance can handle more parallel requests
+            future_to_pair = {executor.submit(fetch_single_rate, pair): pair for pair in pairs}
+            
+            for future in as_completed(future_to_pair):
+                try:
+                    key, rate = future.result(timeout=15)
+                    if rate:
+                        results[key] = rate
+                except Exception as e:
+                    pair = future_to_pair[future]
+                    logger.error(f"Failed to fetch rate for {pair}: {e}")
+        
+        logger.info(f"Successfully fetched {len(results)}/{len(pairs)} rates")
+        return results
+    
+    def _build_symbol(self, base: str, quote: str) -> str:
+        """Build YFinance symbol from currency pair."""
+        base = base.upper()
+        quote = quote.upper()
+        
+        # Only handle fiat pairs
+        fiat_currencies = self.get_fiat_currencies()
+        if base in fiat_currencies and quote in fiat_currencies:
+            if base == quote:
+                raise RateFetchError("Same currency conversion not needed")
+            return f"{base}{quote}=X"
+        
+        raise RateFetchError(f"Unsupported fiat currency pair: {base}/{quote}")
+    
+    def supports_pair(self, base: str, quote: str) -> bool:
+        """Check if fiat currency pair is supported."""
+        base = base.upper()
+        quote = quote.upper()
+        
+        fiat_currencies = self.get_fiat_currencies()
+        return base in fiat_currencies and quote in fiat_currencies and base != quote

django_cfg/modules/django_currency/core/__init__.py

@@ -0,0 +1,42 @@
+"""
+Core currency conversion functionality.
+"""
+
+from .models import (
+    Rate,
+    ConversionRequest,
+    ConversionResult,
+    YFinanceCurrencies,
+    CoinGeckoCurrencies,
+    SupportedCurrencies
+)
+
+from .exceptions import (
+    CurrencyError,
+    CurrencyNotFoundError,
+    RateFetchError,
+    ConversionError,
+    CacheError
+)
+
+from .converter import CurrencyConverter
+
+__all__ = [
+    # Models
+    'Rate',
+    'ConversionRequest', 
+    'ConversionResult',
+    'YFinanceCurrencies',
+    'CoinGeckoCurrencies',
+    'SupportedCurrencies',
+    
+    # Exceptions
+    'CurrencyError',
+    'CurrencyNotFoundError',
+    'RateFetchError',
+    'ConversionError',
+    'CacheError',
+    
+    # Main converter
+    'CurrencyConverter'
+]