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

django_cfg/modules/django_currency/clients/coingecko_client.py

@@ -1,257 +0,0 @@
-"""
-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

@@ -1,246 +0,0 @@
-"""
-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/template_archive/.gitignore

@@ -1 +0,0 @@
-*.zip

django_cfg/urls.py

@@ -1,33 +0,0 @@
-"""
-URL Configuration for Django Config Toolkit
-
-Provides URL patterns for health checks and other toolkit endpoints.
-"""
-
-from django.urls import path, include
-from .health import HealthCheckView, SimpleHealthView
-
-
-app_name = 'django_cfg'
-
-urlpatterns = [
-    # Health check endpoints
-    path('health/', HealthCheckView.as_view(), name='health-check'),
-    path('health/simple/', SimpleHealthView.as_view(), name='simple-health'),
-]
-
-
-def get_toolkit_urls():
-    """
-    Get URL patterns for Django Config Toolkit.
-    
-    Include in your main urls.py:
-    
-        from django_cfg.urls import get_toolkit_urls
-        
-        urlpatterns = [
-            path('admin/', admin.site.urls),
-            path('toolkit/', include(get_toolkit_urls())),
-        ]
-    """
-    return urlpatterns