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

django_cfg/modules/django_currency/core/converter.py

@@ -0,0 +1,169 @@
+"""
+Main currency converter with intelligent routing.
+"""
+
+import logging
+from typing import Optional
+
+from .models import Rate, ConversionRequest, ConversionResult, SupportedCurrencies, YFinanceCurrencies, CoinGeckoCurrencies
+from .exceptions import ConversionError, CurrencyNotFoundError
+from ..clients import YFinanceClient, CoinGeckoClient
+from ..utils.cache import CacheManager
+
+logger = logging.getLogger(__name__)
+
+
+class CurrencyConverter:
+    """Main currency converter with provider routing."""
+    
+    def __init__(self, cache_ttl: int = 300):
+        """
+        Initialize converter.
+        
+        Args:
+            cache_ttl: Cache TTL in seconds
+        """
+        self.yfinance = YFinanceClient()
+        self.coingecko = CoinGeckoClient()
+        self.cache = CacheManager(ttl=cache_ttl)
+        
+    def convert(self, amount: float, from_currency: str, to_currency: str) -> ConversionResult:
+        """
+        Convert amount from one currency to another.
+        
+        Args:
+            amount: Amount to convert
+            from_currency: Source currency
+            to_currency: Target currency
+            
+        Returns:
+            ConversionResult with converted amount and rate info
+            
+        Raises:
+            ConversionError: If conversion fails
+        """
+        try:
+            # Validate input
+            request = ConversionRequest(
+                amount=amount,
+                from_currency=from_currency.upper(),
+                to_currency=to_currency.upper()
+            )
+            
+            # Same currency check
+            if request.from_currency == request.to_currency:
+                rate = Rate(
+                    source="internal",
+                    base_currency=request.from_currency,
+                    quote_currency=request.to_currency,
+                    rate=1.0
+                )
+                return ConversionResult(
+                    request=request,
+                    result=amount,
+                    rate=rate
+                )
+            
+            # Get exchange rate
+            rate = self._get_rate(request.from_currency, request.to_currency)
+            
+            # Calculate result
+            result = amount * rate.rate
+            
+            return ConversionResult(
+                request=request,
+                result=result,
+                rate=rate
+            )
+            
+        except Exception as e:
+            logger.error(f"Conversion failed: {e}")
+            raise ConversionError(f"Failed to convert {amount} {from_currency} to {to_currency}: {e}")
+    
+    def _get_rate(self, base: str, quote: str) -> Rate:
+        """
+        Get exchange rate using provider routing.
+        
+        Args:
+            base: Base currency
+            quote: Quote currency
+            
+        Returns:
+            Rate object
+            
+        Raises:
+            CurrencyNotFoundError: If no provider supports the pair
+        """
+        # Try cache first
+        for source in ["yfinance", "coingecko"]:
+            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:
+                rate = self.yfinance.fetch_rate(base, quote)
+                self.cache.set_rate(rate)
+                return rate
+            except Exception as e:
+                logger.warning(f"YFinance failed for {base}/{quote}: {e}")
+        
+        # Try CoinGecko (good for crypto)
+        if self.coingecko.supports_pair(base, quote):
+            try:
+                rate = self.coingecko.fetch_rate(base, quote)
+                self.cache.set_rate(rate)
+                return rate
+            except Exception as e:
+                logger.warning(f"CoinGecko failed for {base}/{quote}: {e}")
+        
+        # Try indirect conversion via USD
+        if base != "USD" and quote != "USD":
+            try:
+                return self._indirect_conversion(base, quote)
+            except Exception as e:
+                logger.warning(f"Indirect conversion failed for {base}/{quote}: {e}")
+        
+        raise CurrencyNotFoundError(f"No provider supports {base}/{quote}")
+    
+    def _indirect_conversion(self, base: str, quote: str) -> Rate:
+        """
+        Perform indirect conversion via USD.
+        
+        Args:
+            base: Base currency
+            quote: Quote currency
+            
+        Returns:
+            Rate object with combined rate
+        """
+        logger.debug(f"Attempting indirect conversion {base} -> USD -> {quote}")
+        
+        # Get base/USD rate
+        base_usd_rate = self._get_rate(base, "USD")
+        
+        # Get USD/quote rate  
+        usd_quote_rate = self._get_rate("USD", quote)
+        
+        # Calculate combined rate
+        combined_rate = base_usd_rate.rate * usd_quote_rate.rate
+        
+        return Rate(
+            source=f"{base_usd_rate.source}+{usd_quote_rate.source}",
+            base_currency=base,
+            quote_currency=quote,
+            rate=combined_rate
+        )
+    
+    def get_supported_currencies(self) -> SupportedCurrencies:
+        """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())
+            )
+        )

django_cfg/modules/django_currency/core/exceptions.py

@@ -0,0 +1,28 @@
+"""
+Custom exceptions for currency conversion.
+"""
+
+
+class CurrencyError(Exception):
+    """Base currency conversion error."""
+    pass
+
+
+class CurrencyNotFoundError(CurrencyError):
+    """Currency not supported by any provider."""
+    pass
+
+
+class RateFetchError(CurrencyError):
+    """Failed to fetch exchange rate."""
+    pass
+
+
+class CacheError(CurrencyError):
+    """Cache operation failed."""
+    pass
+
+
+class ConversionError(CurrencyError):
+    """Currency conversion failed."""
+    pass

django_cfg/modules/django_currency/core/models.py

@@ -0,0 +1,54 @@
+"""
+Simple data models for currency conversion.
+"""
+
+from datetime import datetime
+from typing import Optional, List, Set
+from pydantic import BaseModel, Field
+
+
+class Rate(BaseModel):
+    """Currency exchange rate model."""
+    
+    source: str = Field(description="Data source (yfinance, coingecko)")
+    base_currency: str = Field(description="Base currency code")
+    quote_currency: str = Field(description="Quote currency code") 
+    rate: float = Field(description="Exchange rate")
+    timestamp: datetime = Field(default_factory=datetime.now, description="Rate timestamp")
+
+
+class ConversionRequest(BaseModel):
+    """Currency conversion request model."""
+    
+    amount: float = Field(gt=0, description="Amount to convert")
+    from_currency: str = Field(description="Source currency code")
+    to_currency: str = Field(description="Target currency code")
+
+
+class ConversionResult(BaseModel):
+    """Currency conversion result model."""
+    
+    request: ConversionRequest = Field(description="Original request")
+    result: float = Field(description="Converted amount")
+    rate: Rate = Field(description="Exchange rate used")
+    path: Optional[str] = Field(default=None, description="Conversion path if indirect")
+
+
+class YFinanceCurrencies(BaseModel):
+    """YFinance supported currencies model."""
+    
+    fiat: List[str] = Field(description="Supported fiat currencies")
+
+
+class CoinGeckoCurrencies(BaseModel):
+    """CoinGecko supported currencies model."""
+    
+    crypto: List[str] = Field(description="Supported cryptocurrencies")
+    vs_currencies: List[str] = Field(description="Supported quote currencies")
+
+
+class SupportedCurrencies(BaseModel):
+    """All supported currencies model."""
+    
+    yfinance: YFinanceCurrencies = Field(description="YFinance currencies")
+    coingecko: CoinGeckoCurrencies = Field(description="CoinGecko currencies")

django_cfg/modules/django_currency/database/__init__.py

@@ -0,0 +1,25 @@
+"""
+Database utilities for currency management.
+"""
+
+from .database_loader import (
+    CurrencyDatabaseLoader,
+    DatabaseLoaderConfig,
+    CoinGeckoCoinInfo,
+    YFinanceCurrencyInfo,
+    CurrencyRateInfo,
+    RateLimiter,
+    create_database_loader,
+    load_currencies_to_database_format
+)
+
+__all__ = [
+    'CurrencyDatabaseLoader',
+    'DatabaseLoaderConfig', 
+    'CoinGeckoCoinInfo',
+    'YFinanceCurrencyInfo',
+    'CurrencyRateInfo',
+    'RateLimiter',
+    'create_database_loader',
+    'load_currencies_to_database_format'
+]