django-cfg 1.2.27__py3-none-any.whl → 1.2.31__py3-none-any.whl

django_cfg/core/config.py

@@ -11,6 +11,7 @@ Following CRITICAL_REQUIREMENTS.md:
 from typing import Dict, List, Optional, Any, Union
 from pathlib import Path
 from pydantic import BaseModel, Field, field_validator, model_validator, PrivateAttr
+from enum import Enum
 import os
 from pathlib import Path
 from urllib.parse import urlparse
@@ -66,6 +67,18 @@ DEFAULT_APPS = [
 ]
 
 
+class EnvironmentMode(str, Enum):
+    """Environment mode enumeration."""
+    DEVELOPMENT = "development" 
+    PRODUCTION = "production"
+    TEST = "test"
+    
+    @classmethod
+    def from_debug(cls, debug: bool) -> "EnvironmentMode":
+        """Get environment mode from debug flag."""
+        return cls.DEVELOPMENT if debug else cls.PRODUCTION
+
+
 class DjangoConfig(BaseModel):
     """
     Base configuration class for Django projects.
@@ -105,6 +118,12 @@ class DjangoConfig(BaseModel):
         "str_strip_whitespace": True,
     }
 
+    # === Environment Configuration ===
+    env_mode: EnvironmentMode = Field(
+        default=EnvironmentMode.PRODUCTION,
+        description="Environment mode: development, production, or test",
+    )
+
     # === Project Information ===
     project_name: str = Field(
         ...,
@@ -401,6 +420,22 @@ class DjangoConfig(BaseModel):
 
         return self
 
+    # === Environment Mode Properties ===
+    @property
+    def is_development(self) -> bool:
+        """Check if running in development mode."""
+        return self.env_mode == EnvironmentMode.DEVELOPMENT
+
+    @property  
+    def is_production(self) -> bool:
+        """Check if running in production mode."""
+        return self.env_mode == EnvironmentMode.PRODUCTION
+
+    @property
+    def is_test(self) -> bool:
+        """Check if running in test mode."""
+        return self.env_mode == EnvironmentMode.TEST
+
     def _detect_environment(self) -> None:
         """Detect current environment from various sources."""
         from django_cfg.core.environment import EnvironmentDetector

django_cfg/models/payments.py

@@ -457,7 +457,6 @@ class PaymentsConfig(BaseModel):
 # Helper function for easy provider configuration
 def create_nowpayments_config(
     api_key: str,
-    sandbox: bool = True,
     ipn_secret: Optional[str] = None,
     **kwargs
 ) -> NowPaymentsConfig:
@@ -465,7 +464,6 @@ def create_nowpayments_config(
     return NowPaymentsConfig(
         name="nowpayments",
         api_key=SecretStr(api_key),
-        sandbox=sandbox,
         ipn_secret=SecretStr(ipn_secret) if ipn_secret else None,
         **kwargs
     )
@@ -489,16 +487,14 @@ def create_stripe_config(
     api_key: str,
     publishable_key: Optional[str] = None,
     webhook_endpoint_secret: Optional[str] = None,
-    sandbox: bool = True,
     **kwargs
 ) -> StripeConfig:
-    """Helper to create Stripe configuration."""
+    """Helper to create Stripe configuration with automatic sandbox detection."""
     return StripeConfig(
         name="stripe",
         api_key=SecretStr(api_key),
         publishable_key=publishable_key,
         webhook_endpoint_secret=SecretStr(webhook_endpoint_secret) if webhook_endpoint_secret else None,
-        sandbox=sandbox,
         **kwargs
     )
 
@@ -506,13 +502,12 @@ def create_stripe_config(
 def create_cryptomus_config(
     api_key: str,
     merchant_uuid: str,
-    sandbox: bool = True,
     callback_url: Optional[str] = None,
     success_url: Optional[str] = None,
     fail_url: Optional[str] = None,
     **kwargs
 ):
-    """Helper to create Cryptomus configuration."""
+    """Helper to create Cryptomus configuration with automatic sandbox detection."""
     # Import here to avoid circular imports
     from django_cfg.apps.payments.config.providers import CryptomusConfig
     
@@ -520,7 +515,6 @@ def create_cryptomus_config(
         name="cryptomus",
         api_key=SecretStr(api_key),
         merchant_uuid=merchant_uuid,
-        sandbox=sandbox,
         callback_url=callback_url,
         success_url=success_url,
         fail_url=fail_url,

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',