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

django_cfg/modules/django_currency/converter.py

@@ -1,324 +0,0 @@
-"""
-Currency Converter for django_currency.
-
-Handles actual currency conversion using multiple data sources with fallback support.
-"""
-
-import logging
-import requests
-from datetime import datetime, date
-from typing import Dict, Optional, Union, Any
-from pathlib import Path
-
-from .cache import CurrencyCache
-
-logger = logging.getLogger(__name__)
-
-
-class CurrencyConverter:
-    """
-    Currency converter with multiple data sources and caching.
-    
-    Data sources (in priority order):
-    1. Central Bank of Russia (CBR) API - for RUB-based conversions
-    2. European Central Bank (ECB) API - for EUR-based conversions  
-    3. currency_converter library - fallback for other conversions
-    """
-    
-    # API endpoints
-    CBR_API_URL = "https://www.cbr-xml-daily.ru/daily_json.js"
-    ECB_API_URL = "https://api.exchangerate-api.com/v4/latest/EUR"
-    
-    def __init__(self, cache_dir: Optional[Path] = None):
-        """
-        Initialize currency converter.
-        
-        Args:
-            cache_dir: Optional cache directory path
-        """
-        self.cache = CurrencyCache(cache_dir=cache_dir)
-        self._fallback_converter = None
-        self._cbr_rates = {}
-        self._ecb_rates = {}
-        
-        # Initialize fallback converter
-        self._init_fallback_converter()
-    
-    def _init_fallback_converter(self):
-        """Initialize fallback currency converter."""
-        try:
-            from currency_converter import CurrencyConverter as FallbackConverter
-            self._fallback_converter = FallbackConverter(
-                fallback_on_wrong_date=True,
-                fallback_on_missing_rate=True
-            )
-            # Test the converter
-            _ = self._fallback_converter.convert(1, 'USD', 'EUR')
-            logger.info("Fallback currency converter initialized")
-        except ImportError:
-            logger.warning("currency_converter library not available - install with: pip install CurrencyConverter")
-            self._fallback_converter = None
-        except Exception as e:
-            logger.error(f"Failed to initialize fallback converter: {e}")
-            self._fallback_converter = None
-    
-    def convert(
-        self,
-        amount: float,
-        from_currency: str,
-        to_currency: str,
-        date_obj: Optional[Union[datetime, date]] = None,
-        round_to: Optional[int] = 2,
-    ) -> float:
-        """
-        Convert amount from one currency to another.
-        
-        Args:
-            amount: Amount to convert
-            from_currency: Source currency code
-            to_currency: Target currency code
-            date_obj: Optional date for historical rates
-            round_to: Number of decimal places to round to
-            
-        Returns:
-            Converted amount
-        """
-        from_curr = from_currency.upper()
-        to_curr = to_currency.upper()
-        
-        # Same currency - no conversion needed
-        if from_curr == to_curr:
-            return float(amount)
-        
-        result = 0.0
-        conversion_successful = False
-        
-        # Try CBR rates first (best for RUB conversions)
-        if not conversion_successful:
-            try:
-                result = self._convert_via_cbr(amount, from_curr, to_curr)
-                if result > 0:
-                    conversion_successful = True
-                    logger.debug(f"Converted via CBR: {amount} {from_curr} = {result} {to_curr}")
-            except Exception as e:
-                logger.debug(f"CBR conversion failed: {e}")
-        
-        # Try ECB rates (good for EUR conversions)
-        if not conversion_successful:
-            try:
-                result = self._convert_via_ecb(amount, from_curr, to_curr)
-                if result > 0:
-                    conversion_successful = True
-                    logger.debug(f"Converted via ECB: {amount} {from_curr} = {result} {to_curr}")
-            except Exception as e:
-                logger.debug(f"ECB conversion failed: {e}")
-        
-        # Fallback to currency_converter library
-        if not conversion_successful and self._fallback_converter:
-            try:
-                fallback_date = date_obj.date() if isinstance(date_obj, datetime) else date_obj
-                result = float(self._fallback_converter.convert(
-                    amount, from_curr, to_curr, date=fallback_date
-                ))
-                conversion_successful = True
-                logger.debug(f"Converted via fallback: {amount} {from_curr} = {result} {to_curr}")
-            except Exception as e:
-                logger.debug(f"Fallback conversion failed: {e}")
-        
-        if not conversion_successful:
-            raise ValueError(f"Unable to convert {from_curr} to {to_curr}")
-        
-        # Apply rounding
-        if round_to is not None:
-            result = round(result, round_to)
-        
-        return result
-    
-    def _convert_via_cbr(self, amount: float, from_curr: str, to_curr: str) -> float:
-        """Convert using CBR (Central Bank of Russia) rates."""
-        # Get CBR rates
-        cbr_rates = self._get_cbr_rates()
-        if not cbr_rates:
-            raise ValueError("CBR rates not available")
-        
-        # Check if both currencies are available
-        if from_curr not in cbr_rates or to_curr not in cbr_rates:
-            raise ValueError(f"Currency pair {from_curr}/{to_curr} not available in CBR rates")
-        
-        # Convert via RUB
-        from_rate = cbr_rates[from_curr]  # How many RUB for 1 unit of from_curr
-        to_rate = cbr_rates[to_curr]      # How many RUB for 1 unit of to_curr
-        
-        # amount * from_rate = RUB amount
-        # RUB amount / to_rate = to_curr amount
-        result = amount * (from_rate / to_rate)
-        return result
-    
-    def _convert_via_ecb(self, amount: float, from_curr: str, to_curr: str) -> float:
-        """Convert using ECB (European Central Bank) rates."""
-        # Get ECB rates
-        ecb_rates = self._get_ecb_rates()
-        if not ecb_rates:
-            raise ValueError("ECB rates not available")
-        
-        # ECB rates are EUR-based
-        if from_curr == 'EUR':
-            if to_curr not in ecb_rates:
-                raise ValueError(f"Currency {to_curr} not available in ECB rates")
-            return amount * ecb_rates[to_curr]
-        
-        elif to_curr == 'EUR':
-            if from_curr not in ecb_rates:
-                raise ValueError(f"Currency {from_curr} not available in ECB rates")
-            return amount / ecb_rates[from_curr]
-        
-        else:
-            # Convert via EUR
-            if from_curr not in ecb_rates or to_curr not in ecb_rates:
-                raise ValueError(f"Currency pair {from_curr}/{to_curr} not available in ECB rates")
-            
-            # Convert to EUR first, then to target currency
-            eur_amount = amount / ecb_rates[from_curr]
-            result = eur_amount * ecb_rates[to_curr]
-            return result
-    
-    def _get_cbr_rates(self) -> Dict[str, float]:
-        """Get CBR rates from cache or API."""
-        # Try cache first
-        cached_rates = self.cache.get_rates("cbr")
-        if cached_rates:
-            self._cbr_rates = cached_rates
-            return cached_rates
-        
-        # Fetch from API
-        try:
-            response = requests.get(self.CBR_API_URL, timeout=10)
-            response.raise_for_status()
-            data = response.json()
-            
-            valutes = data.get("Valute", {})
-            rates = {}
-            
-            # Add RUB as base currency
-            rates["RUB"] = 1.0
-            
-            # Process other currencies
-            for currency_code, item in valutes.items():
-                if "Value" in item and "Nominal" in item:
-                    # CBR gives rate as: Nominal units of currency = Value RUB
-                    # We want: 1 unit of currency = X RUB
-                    rate = float(item["Value"]) / float(item["Nominal"])
-                    rates[currency_code] = rate
-            
-            # Cache the rates
-            self.cache.set_rates(rates, "cbr")
-            self._cbr_rates = rates
-            
-            logger.info(f"Fetched {len(rates)} CBR rates")
-            return rates
-            
-        except Exception as e:
-            logger.error(f"Failed to fetch CBR rates: {e}")
-            return {}
-    
-    def _get_ecb_rates(self) -> Dict[str, float]:
-        """Get ECB rates from cache or API."""
-        # Try cache first
-        cached_rates = self.cache.get_rates("ecb")
-        if cached_rates:
-            self._ecb_rates = cached_rates
-            return cached_rates
-        
-        # Fetch from API
-        try:
-            response = requests.get(self.ECB_API_URL, timeout=10)
-            response.raise_for_status()
-            data = response.json()
-            
-            rates = data.get("rates", {})
-            if rates:
-                # Add EUR as base currency
-                rates["EUR"] = 1.0
-                
-                # Cache the rates
-                self.cache.set_rates(rates, "ecb")
-                self._ecb_rates = rates
-                
-                logger.info(f"Fetched {len(rates)} ECB rates")
-                return rates
-            
-        except Exception as e:
-            logger.error(f"Failed to fetch ECB rates: {e}")
-        
-        return {}
-    
-    def get_available_currencies(self) -> set:
-        """Get set of all available currency codes."""
-        currencies = set()
-        
-        # Add CBR currencies
-        cbr_rates = self._get_cbr_rates()
-        currencies.update(cbr_rates.keys())
-        
-        # Add ECB currencies
-        ecb_rates = self._get_ecb_rates()
-        currencies.update(ecb_rates.keys())
-        
-        # Add fallback currencies
-        if self._fallback_converter:
-            try:
-                currencies.update(self._fallback_converter.currencies)
-            except Exception as e:
-                logger.error(f"Failed to get fallback currencies: {e}")
-        
-        return currencies
-    
-    def refresh_rates(self) -> bool:
-        """Force refresh all currency rates."""
-        success = True
-        
-        # Clear cache
-        self.cache.clear_cache()
-        
-        # Refresh CBR rates
-        try:
-            cbr_rates = self._get_cbr_rates()
-            if not cbr_rates:
-                success = False
-        except Exception as e:
-            logger.error(f"Failed to refresh CBR rates: {e}")
-            success = False
-        
-        # Refresh ECB rates
-        try:
-            ecb_rates = self._get_ecb_rates()
-            if not ecb_rates:
-                success = False
-        except Exception as e:
-            logger.error(f"Failed to refresh ECB rates: {e}")
-            success = False
-        
-        logger.info(f"Currency rates refresh {'successful' if success else 'failed'}")
-        return success
-    
-    def get_converter_info(self) -> Dict[str, Any]:
-        """Get information about converter status."""
-        return {
-            "cbr_rates_count": len(self._cbr_rates),
-            "ecb_rates_count": len(self._ecb_rates),
-            "fallback_available": self._fallback_converter is not None,
-            "total_currencies": len(self.get_available_currencies()),
-            "data_sources": {
-                "cbr": {
-                    "url": self.CBR_API_URL,
-                    "available": len(self._cbr_rates) > 0
-                },
-                "ecb": {
-                    "url": self.ECB_API_URL,
-                    "available": len(self._ecb_rates) > 0
-                },
-                "fallback": {
-                    "available": self._fallback_converter is not None
-                }
-            }
-        }

django_cfg/modules/django_currency/service.py

@@ -1,277 +0,0 @@
-"""
-Django Currency Service for django_cfg.
-
-Auto-configuring currency conversion service that integrates with DjangoConfig.
-"""
-
-import logging
-from typing import Optional, Dict, Any, Union, List
-from datetime import datetime, date
-from pathlib import Path
-
-from django_cfg.modules import BaseCfgModule
-from .converter import CurrencyConverter
-from .cache import CurrencyCache
-
-logger = logging.getLogger(__name__)
-
-
-class CurrencyError(Exception):
-    """Base exception for currency-related errors."""
-    pass
-
-
-class CurrencyConfigError(CurrencyError):
-    """Raised when configuration is missing or invalid."""
-    pass
-
-
-class CurrencyConversionError(CurrencyError):
-    """Raised when currency conversion fails."""
-    pass
-
-
-class DjangoCurrency(BaseCfgModule):
-    """
-    Currency Service for django_cfg, configured via DjangoConfig.
-
-    Provides currency conversion functionality with automatic configuration
-    from the main DjangoConfig instance.
-    """
-
-    def __init__(self):
-        self._converter = None
-        self._is_configured = None
-
-    @property
-    def config(self):
-        """Get the DjangoConfig instance."""
-        return self.get_config()
-
-    @property
-    def is_configured(self) -> bool:
-        """Check if currency service is properly configured."""
-        if self._is_configured is None:
-            try:
-                # Currency service is always available with fallback
-                self._is_configured = True
-            except Exception:
-                self._is_configured = False
-
-        return self._is_configured
-
-    @property
-    def converter(self) -> CurrencyConverter:
-        """Get currency converter instance."""
-        if self._converter is None:
-            # Let CurrencyConverter handle its own cache
-            cache_dir = None
-            try:
-                # Only override if explicitly configured
-                if hasattr(self.config, 'currency_cache_dir'):
-                    cache_dir = Path(self.config.currency_cache_dir)
-            except Exception:
-                pass
-            
-            self._converter = CurrencyConverter(cache_dir=cache_dir)
-        return self._converter
-
-    @property
-    def cache(self) -> CurrencyCache:
-        """Get currency cache instance from converter."""
-        return self.converter.cache
-
-
-    def convert(
-        self,
-        amount: float,
-        from_currency: str,
-        to_currency: str,
-        date_obj: Optional[Union[datetime, date]] = None,
-        round_to: Optional[int] = 2,
-        fail_silently: bool = False,
-    ) -> float:
-        """
-        Convert amount from one currency to another.
-
-        Args:
-            amount: Amount to convert
-            from_currency: Source currency code (e.g., 'USD')
-            to_currency: Target currency code (e.g., 'EUR')
-            date_obj: Optional date for historical rates
-            round_to: Number of decimal places to round to
-            fail_silently: Don't raise exceptions on failure
-
-        Returns:
-            Converted amount
-
-        Raises:
-            CurrencyConversionError: If conversion fails and fail_silently is False
-        """
-        try:
-            if not self.is_configured:
-                error_msg = "Currency service is not configured"
-                logger.error(error_msg)
-                if not fail_silently:
-                    raise CurrencyConfigError(error_msg)
-                return 0.0
-
-            result = self.converter.convert(
-                amount=amount,
-                from_currency=from_currency,
-                to_currency=to_currency,
-                date_obj=date_obj,
-                round_to=round_to
-            )
-
-            logger.debug(f"Converted {amount} {from_currency} to {result} {to_currency}")
-            return result
-
-        except Exception as e:
-            error_msg = f"Failed to convert {amount} {from_currency} to {to_currency}: {e}"
-            logger.error(error_msg)
-            if not fail_silently:
-                raise CurrencyConversionError(error_msg) from e
-            return 0.0
-
-    def get_rate(
-        self,
-        from_currency: str,
-        to_currency: str,
-        date_obj: Optional[Union[datetime, date]] = None,
-        fail_silently: bool = False,
-    ) -> float:
-        """
-        Get exchange rate between two currencies.
-
-        Args:
-            from_currency: Source currency code
-            to_currency: Target currency code
-            date_obj: Optional date for historical rates
-            fail_silently: Don't raise exceptions on failure
-
-        Returns:
-            Exchange rate (1 unit of from_currency = X units of to_currency)
-        """
-        return self.convert(
-            amount=1.0,
-            from_currency=from_currency,
-            to_currency=to_currency,
-            date_obj=date_obj,
-            fail_silently=fail_silently
-        )
-
-    def get_available_currencies(self) -> set:
-        """
-        Get set of available currency codes.
-
-        Returns:
-            Set of available currency codes
-        """
-        try:
-            return self.converter.get_available_currencies()
-        except Exception as e:
-            logger.error(f"Failed to get available currencies: {e}")
-            return set()
-
-    def refresh_rates(self, fail_silently: bool = False) -> bool:
-        """
-        Force refresh currency rates from external APIs.
-
-        Args:
-            fail_silently: Don't raise exceptions on failure
-
-        Returns:
-            True if refresh was successful, False otherwise
-        """
-        try:
-            success = self.converter.refresh_rates()
-            if success:
-                logger.info("Currency rates refreshed successfully")
-            else:
-                logger.warning("Failed to refresh currency rates")
-            return success
-
-        except Exception as e:
-            error_msg = f"Failed to refresh currency rates: {e}"
-            logger.error(error_msg)
-            if not fail_silently:
-                raise CurrencyError(error_msg) from e
-            return False
-
-    def get_config_info(self) -> Dict[str, Any]:
-        """Get currency service configuration information."""
-        try:
-            cache_info = self.cache.get_cache_info()
-            converter_info = self.converter.get_converter_info()
-            
-            return {
-                "configured": self.is_configured,
-                "cache_directory": str(self.cache.cache_dir),
-                "cache_info": cache_info,
-                "converter_info": converter_info,
-                "available_currencies_count": len(self.get_available_currencies()),
-            }
-        except Exception as e:
-            logger.error(f"Failed to get config info: {e}")
-            return {
-                "configured": False,
-                "error": str(e)
-            }
-
-    def convert_multiple(
-        self,
-        amounts: List[float],
-        from_currencies: List[str],
-        to_currencies: List[str],
-        fail_silently: bool = True,
-    ) -> List[float]:
-        """
-        Convert multiple currency amounts in batch.
-
-        Args:
-            amounts: List of amounts to convert
-            from_currencies: List of source currency codes
-            to_currencies: List of target currency codes
-            fail_silently: Don't raise exceptions on individual failures
-
-        Returns:
-            List of converted amounts (0.0 for failed conversions)
-        """
-        if not (len(amounts) == len(from_currencies) == len(to_currencies)):
-            raise ValueError("All input lists must have the same length")
-
-        results = []
-        for amount, from_curr, to_curr in zip(amounts, from_currencies, to_currencies):
-            try:
-                result = self.convert(
-                    amount=amount,
-                    from_currency=from_curr,
-                    to_currency=to_curr,
-                    fail_silently=fail_silently
-                )
-                results.append(result)
-            except Exception as e:
-                logger.error(f"Failed to convert {amount} {from_curr} to {to_curr}: {e}")
-                results.append(0.0)
-
-        return results
-
-    @classmethod
-    def send_currency_alert(cls, message: str, rates: Optional[Dict[str, float]] = None) -> None:
-        """Send currency alert via configured notification services."""
-        try:
-            # Try to send via Telegram if available
-            from django_cfg.modules.django_telegram import DjangoTelegram
-            telegram = DjangoTelegram()
-            
-            text = f"💱 <b>Currency Alert</b>\n\n{message}"
-            if rates:
-                text += "\n\n<b>Current Rates:</b>\n"
-                for pair, rate in rates.items():
-                    text += f"• {pair}: {rate:.4f}\n"
-            
-            telegram.send_message(text, parse_mode="HTML", fail_silently=True)
-            
-        except Exception as e:
-            logger.error(f"Failed to send currency alert: {e}")