django-cfg 1.4.20__py3-none-any.whl → 1.4.23__py3-none-any.whl

django_cfg/modules/django_currency/core/models.py

@@ -3,23 +3,24 @@ Data models for currency conversion and API responses.
 """
 
 from datetime import datetime
-from typing import Optional, List, Set, Dict, Any
+from typing import List, Optional
+
 from pydantic import BaseModel, Field, RootModel
 
 
 class Rate(BaseModel):
     """Currency exchange rate model."""
-    
+
     source: str = Field(description="Data source (yahoo, coinpaprika)")
     base_currency: str = Field(description="Base currency code")
-    quote_currency: str = Field(description="Quote 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")
@@ -27,7 +28,7 @@ class ConversionRequest(BaseModel):
 
 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")
@@ -36,19 +37,19 @@ class ConversionResult(BaseModel):
 
 class YahooFinanceCurrencies(BaseModel):
     """Yahoo Finance supported currencies model."""
-    
+
     fiat: List[str] = Field(description="Supported fiat currencies")
 
 
 class CoinPaprikaCurrencies(BaseModel):
     """CoinPaprika supported currencies model."""
-    
+
     crypto: List[str] = Field(description="Supported cryptocurrencies")
 
 
 class SupportedCurrencies(BaseModel):
     """All supported currencies model."""
-    
+
     yahoo: YahooFinanceCurrencies = Field(description="Yahoo Finance currencies")
     coinpaprika: CoinPaprikaCurrencies = Field(description="CoinPaprika currencies")
 

django_cfg/modules/django_currency/database/__init__.py

@@ -3,19 +3,19 @@ Database utilities for currency management.
 """
 
 from .database_loader import (
+    CoinPaprikaCoinInfo,
     CurrencyDatabaseLoader,
+    CurrencyRateInfo,
     DatabaseLoaderConfig,
-    CoinPaprikaCoinInfo,
     HybridCurrencyInfo,
-    CurrencyRateInfo,
     RateLimiter,
     create_database_loader,
-    load_currencies_to_database_format
+    load_currencies_to_database_format,
 )
 
 __all__ = [
     'CurrencyDatabaseLoader',
-    'DatabaseLoaderConfig', 
+    'DatabaseLoaderConfig',
     'CoinPaprikaCoinInfo',
     'HybridCurrencyInfo',
     'CurrencyRateInfo',

django_cfg/modules/django_currency/database/database_loader.py

@@ -4,15 +4,11 @@ Database loader for populating currency data using Yahoo Finance + CoinPaprika.
 
 import logging
 import time
-from datetime import datetime, timedelta
-from typing import List, Dict, Optional, Set
-from dataclasses import dataclass
+from datetime import datetime
+from typing import Dict, List, Optional
 
-from pydantic import BaseModel, Field, validator
 from cachetools import TTLCache
-
-# Our new clients
-from ..clients import HybridCurrencyClient, CoinPaprikaClient
+from pydantic import BaseModel, Field
 
 logger = logging.getLogger(__name__)
 
@@ -49,31 +45,31 @@ class CurrencyRateInfo(BaseModel):
 
 class RateLimiter:
     """Simple rate limiter for API calls."""
-    
+
     def __init__(self, max_requests_per_minute: int = 30):
         self.max_requests = max_requests_per_minute
         self.request_times = []
-        
+
     def __call__(self):
         """Wait if necessary to respect rate limits."""
         now = time.time()
-        
+
         # Remove requests older than 1 minute
         self.request_times = [t for t in self.request_times if now - t < 60]
-        
+
         # If we're at the limit, wait
         if len(self.request_times) >= self.max_requests:
             sleep_time = 60 - (now - self.request_times[0]) + 1
             if sleep_time > 0:
                 logger.debug(f"Rate limiting: sleeping for {sleep_time:.1f}s")
                 time.sleep(sleep_time)
-                
+
         self.request_times.append(now)
 
 
 class DatabaseLoaderConfig(BaseModel):
     """Configuration for database loader."""
-    
+
     yahoo_delay: float = Field(default=1.0, description="Delay between Yahoo requests")
     coinpaprika_delay: float = Field(default=0.5, description="Delay between CoinPaprika requests")
     max_requests_per_minute: int = Field(default=30, description="Max requests per minute")
@@ -88,26 +84,29 @@ class CurrencyDatabaseLoader:
     """
     Database loader for populating currency data from Yahoo Finance and CoinPaprika.
     """
-    
+
     def __init__(self, config: DatabaseLoaderConfig = None):
         """Initialize the database loader."""
+        # Lazy import to avoid circular dependency
+        from ..clients import CoinPaprikaClient, HybridCurrencyClient
+
         self.config = config or DatabaseLoaderConfig()
-        
+
         # Initialize clients
         self.hybrid = HybridCurrencyClient(cache_ttl=self.config.cache_ttl_hours * 3600)
         self.coinpaprika = CoinPaprikaClient(cache_ttl=self.config.cache_ttl_hours * 3600)
-        
+
         # Rate limiters
         self.yahoo_limiter = RateLimiter(self.config.max_requests_per_minute)
         self.coinpaprika_limiter = RateLimiter(self.config.max_requests_per_minute)
-        
+
         # Caches
         cache_ttl = self.config.cache_ttl_hours * 3600
         self.crypto_cache = TTLCache(maxsize=1000, ttl=cache_ttl)
         self.fiat_cache = TTLCache(maxsize=100, ttl=cache_ttl)
-        
+
         logger.info(f"Initialized CurrencyDatabaseLoader with config: {self.config}")
-    
+
     def get_hybrid_currency_list(self) -> List[HybridCurrencyInfo]:
         """
         Get list of supported currencies from hybrid client.
@@ -116,19 +115,19 @@ class CurrencyDatabaseLoader:
             List of currency info objects
         """
         cache_key = "hybrid_currencies"
-        
+
         if cache_key in self.fiat_cache:
             logger.debug("Retrieved hybrid currencies from cache")
             return self.fiat_cache[cache_key]
-        
+
         # Get supported currencies from Hybrid client
         supported_currencies = self.hybrid.get_all_supported_currencies()
-        
+
         # Convert to our format
         hybrid_currencies = []
         for code, name in supported_currencies.items():
             # Determine currency type based on code
-            if code in ['BTC', 'ETH', 'BNB', 'XRP', 'ADA', 'SOL', 'DOT', 'MATIC', 
+            if code in ['BTC', 'ETH', 'BNB', 'XRP', 'ADA', 'SOL', 'DOT', 'MATIC',
                        'LTC', 'BCH', 'LINK', 'UNI', 'ATOM', 'XLM', 'VET', 'FIL',
                        'TRX', 'ETC', 'THETA', 'AAVE', 'MKR', 'COMP', 'SUSHI',
                        'USDT', 'USDC', 'BUSD', 'DAI', 'TUSD', 'USDP']:
@@ -137,7 +136,7 @@ class CurrencyDatabaseLoader:
                 currency_type = "metal"
             else:
                 currency_type = "fiat"
-            
+
             currency_info = HybridCurrencyInfo(
                 code=code,
                 name=name,
@@ -145,12 +144,12 @@ class CurrencyDatabaseLoader:
                 currency_type=currency_type
             )
             hybrid_currencies.append(currency_info)
-        
+
         self.fiat_cache[cache_key] = hybrid_currencies
         logger.info(f"Loaded {len(hybrid_currencies)} currencies from hybrid client")
-        
+
         return hybrid_currencies
-    
+
     def get_cryptocurrency_list(self) -> List[CoinPaprikaCoinInfo]:
         """
         Get list of supported cryptocurrencies from CoinPaprika.
@@ -159,45 +158,45 @@ class CurrencyDatabaseLoader:
             List of cryptocurrency info objects
         """
         cache_key = "crypto_currencies"
-        
+
         if cache_key in self.crypto_cache:
             logger.debug("Retrieved cryptocurrencies from cache")
             return self.crypto_cache[cache_key]
-        
+
         try:
             # Get all tickers from CoinPaprika
             all_tickers = self.coinpaprika._fetch_all_tickers()
-            
+
             crypto_currencies = []
             for symbol, data in all_tickers.items():
                 # Skip if no price data
                 if data.get('price_usd') is None:
                     continue
-                
+
                 # Apply market cap filter if needed
                 # Note: CoinPaprika doesn't provide market cap in tickers endpoint
                 # We'd need to use a different endpoint for that
-                
+
                 coin_info = CoinPaprikaCoinInfo(
                     id=data['id'],
                     symbol=symbol,
                     name=data['name']
                 )
                 crypto_currencies.append(coin_info)
-                
+
                 # Limit count
                 if len(crypto_currencies) >= self.config.max_cryptocurrencies:
                     break
-            
+
             self.crypto_cache[cache_key] = crypto_currencies
             logger.info(f"Loaded {len(crypto_currencies)} cryptocurrencies")
-            
+
             return crypto_currencies
-            
+
         except Exception as e:
             logger.error(f"Failed to get cryptocurrency list: {e}")
             return []
-    
+
     def get_currency_rates(self, currency_ids: List[str], quote: str = 'usd') -> Dict[str, float]:
         """
         Get current rates for multiple cryptocurrencies.
@@ -210,24 +209,24 @@ class CurrencyDatabaseLoader:
             Dict mapping currency ID to rate
         """
         self.coinpaprika_limiter()
-        
+
         try:
             rates = {}
             all_tickers = self.coinpaprika._fetch_all_tickers()
-            
+
             for currency_id in currency_ids:
                 if currency_id.upper() in all_tickers:
                     price = all_tickers[currency_id.upper()].get('price_usd')
                     if price is not None:
                         rates[currency_id] = price
-            
+
             logger.debug(f"Retrieved rates for {len(rates)} currencies")
             return rates
-            
+
         except Exception as e:
             logger.error(f"Failed to get currency rates: {e}")
             return {}
-    
+
     def get_fiat_rate(self, base: str, quote: str) -> Optional[float]:
         """
         Get exchange rate for fiat currency pair.
@@ -242,16 +241,16 @@ class CurrencyDatabaseLoader:
         # Handle same currency
         if base.upper() == quote.upper():
             return 1.0
-        
+
         self.yahoo_limiter()
-        
+
         try:
             rate_obj = self.hybrid.fetch_rate(base, quote)
             return rate_obj.rate
         except Exception as e:
             logger.debug(f"Failed to get fiat rate {base}/{quote}: {e}")
             return None
-    
+
     def build_currency_database_data(self) -> List[CurrencyRateInfo]:
         """
         Build complete currency database data using hybrid client.
@@ -260,11 +259,11 @@ class CurrencyDatabaseLoader:
             List of currency rate info objects
         """
         currencies = []
-        
+
         # Get currencies from hybrid client
         logger.info("Loading currencies from hybrid client...")
         hybrid_currencies = self.get_hybrid_currency_list()
-        
+
         for currency in hybrid_currencies:
             # Get USD rate
             if currency.code == 'USD':
@@ -274,7 +273,7 @@ class CurrencyDatabaseLoader:
                 if usd_rate is None:
                     logger.warning(f"Could not get USD rate for {currency.code}")
                     continue
-            
+
             # Set decimal places based on currency type and value
             if currency.currency_type == "fiat":
                 decimal_places = 2
@@ -290,7 +289,7 @@ class CurrencyDatabaseLoader:
             else:  # metal
                 decimal_places = 4
                 min_payment = 0.001
-            
+
             currency_info = CurrencyRateInfo(
                 code=currency.code,
                 name=currency.name,
@@ -301,28 +300,28 @@ class CurrencyDatabaseLoader:
                 min_payment_amount=min_payment
             )
             currencies.append(currency_info)
-        
+
         # Get additional cryptocurrencies from CoinPaprika (for extended crypto coverage)
         logger.info("Loading additional cryptocurrencies from CoinPaprika...")
         crypto_currencies = self.get_cryptocurrency_list()
-        
+
         # Filter out cryptos that are already in hybrid client
         hybrid_crypto_codes = {c.code for c in hybrid_currencies if c.currency_type == "crypto"}
-        
+
         if crypto_currencies:
             # Get rates for all cryptos
-            crypto_symbols = [crypto.symbol for crypto in crypto_currencies 
+            crypto_symbols = [crypto.symbol for crypto in crypto_currencies
                             if crypto.symbol not in hybrid_crypto_codes]
             rates = self.get_currency_rates(crypto_symbols, 'usd')
-            
+
             for crypto in crypto_currencies:
                 # Skip if already covered by hybrid client
                 if crypto.symbol in hybrid_crypto_codes:
                     continue
-                    
+
                 if crypto.symbol in rates:
                     usd_rate = rates[crypto.symbol]
-                    
+
                     # Calculate appropriate decimal places based on USD value
                     if usd_rate >= 1:
                         decimal_places = 2
@@ -330,10 +329,10 @@ class CurrencyDatabaseLoader:
                         decimal_places = 4
                     else:
                         decimal_places = 8
-                    
+
                     # Calculate minimum payment amount (roughly $1 worth)
                     min_payment = max(1.0 / usd_rate, 0.000001)
-                    
+
                     currency_info = CurrencyRateInfo(
                         code=crypto.symbol,
                         name=crypto.name,
@@ -344,26 +343,26 @@ class CurrencyDatabaseLoader:
                         min_payment_amount=min_payment
                     )
                     currencies.append(currency_info)
-        
+
         logger.info(f"Built database data for {len(currencies)} currencies")
         return currencies
-    
+
     def get_statistics(self) -> Dict[str, int]:
         """Get loader statistics."""
         hybrid_currencies = self.get_hybrid_currency_list()
         coinpaprika_cryptos = self.get_cryptocurrency_list()
-        
+
         # Count by type from hybrid client
         fiat_count = len([c for c in hybrid_currencies if c.currency_type == "fiat"])
         hybrid_crypto_count = len([c for c in hybrid_currencies if c.currency_type == "crypto"])
         metal_count = len([c for c in hybrid_currencies if c.currency_type == "metal"])
-        
+
         # Additional cryptos from CoinPaprika (excluding duplicates)
         hybrid_crypto_codes = {c.code for c in hybrid_currencies if c.currency_type == "crypto"}
         additional_crypto_count = len([c for c in coinpaprika_cryptos if c.symbol not in hybrid_crypto_codes])
-        
+
         total_crypto_count = hybrid_crypto_count + additional_crypto_count
-        
+
         return {
             'total_fiat_currencies': fiat_count,
             'total_cryptocurrencies': total_crypto_count,
@@ -420,7 +419,7 @@ def load_currencies_to_database_format() -> List[Dict]:
     """
     loader = create_database_loader()
     currencies = loader.build_currency_database_data()
-    
+
     # Convert to dict format
     result = []
     for currency in currencies:
@@ -435,5 +434,5 @@ def load_currencies_to_database_format() -> List[Dict]:
             'rate_updated_at': datetime.now()
         }
         result.append(currency_dict)
-    
+
     return result

django_cfg/modules/django_currency/examples/example_database_usage.py

@@ -3,11 +3,12 @@ Example usage of the database loader for populating currency data.
 """
 
 import logging
+
 from .database_loader import (
-    CurrencyDatabaseLoader, 
+    CurrencyDatabaseLoader,
     DatabaseLoaderConfig,
     create_database_loader,
-    load_currencies_to_database_format
+    load_currencies_to_database_format,
 )
 
 # Configure logging
@@ -17,7 +18,7 @@ logging.basicConfig(level=logging.INFO, format='%(name)s:%(levelname)s: %(messag
 def example_basic_usage():
     """Basic example of using the database loader."""
     print("🔄 Creating database loader...")
-    
+
     # Create loader with default settings
     loader = create_database_loader(
         max_cryptocurrencies=100,  # Limit to top 100 cryptos
@@ -25,38 +26,38 @@ def example_basic_usage():
         min_market_cap_usd=10_000_000,  # 10M USD minimum
         coingecko_delay=2.0        # 2 second delay between requests
     )
-    
+
     # Get statistics
     print("📊 Statistics:")
     stats = loader.get_statistics()
     for key, value in stats.items():
         print(f"   {key}: {value}")
-    
+
     print("\n🪙 Building currency database data...")
-    
+
     # Build complete currency data
     currencies = loader.build_currency_database_data()
-    
+
     print(f"\n✅ Successfully loaded {len(currencies)} currencies")
-    
+
     # Show sample data
     print("\n📋 Sample currencies:")
     for i, currency in enumerate(currencies[:10]):
         print(f"   {i+1}. {currency.code} ({currency.currency_type}): "
               f"{currency.name} = ${currency.usd_rate:.6f}")
-    
+
     return currencies
 
 
 def example_django_integration():
     """Example of how to integrate with Django ORM."""
     print("🔄 Loading currencies in Django format...")
-    
+
     # Get currencies in Django-ready format
     currency_dicts = load_currencies_to_database_format()
-    
+
     print(f"✅ Ready to insert {len(currency_dicts)} currencies into Django ORM")
-    
+
     # This is how you would use it in Django:
     print("\n💡 Django integration example:")
     print("""
@@ -77,67 +78,67 @@ def example_django_integration():
     Currency.objects.bulk_create(currencies_to_create, ignore_conflicts=True)
     print(f"Inserted {len(currencies_to_create)} currencies")
     """)
-    
+
     return currency_dicts
 
 
 def example_advanced_config():
     """Example with advanced configuration."""
     print("🔧 Advanced configuration example...")
-    
+
     # Custom configuration
     config = DatabaseLoaderConfig(
         # Rate limiting
         coingecko_delay=3.0,           # Slower requests for stability
         yfinance_delay=1.0,
         max_requests_per_minute=20,    # Conservative rate limit
-        
+
         # Limits
         max_cryptocurrencies=50,       # Smaller set
         max_fiat_currencies=20,
-        
+
         # Filtering
         min_market_cap_usd=50_000_000, # Higher threshold - 50M USD
         exclude_stablecoins=True,      # Skip stablecoins
-        
+
         # Cache
         cache_ttl_hours=12            # Cache for 12 hours
     )
-    
+
     loader = CurrencyDatabaseLoader(config)
-    
-    print(f"📊 Configuration:")
+
+    print("📊 Configuration:")
     print(f"   Max cryptocurrencies: {config.max_cryptocurrencies}")
     print(f"   Min market cap: ${config.min_market_cap_usd:,.0f}")
     print(f"   Exclude stablecoins: {config.exclude_stablecoins}")
     print(f"   CoinGecko delay: {config.coingecko_delay}s")
-    
+
     return loader
 
 
 if __name__ == "__main__":
     print("🧪 CURRENCY DATABASE LOADER EXAMPLES")
     print("=" * 50)
-    
+
     try:
         # Basic usage
         print("\n1️⃣ BASIC USAGE:")
         currencies = example_basic_usage()
-        
+
         print("\n" + "=" * 50)
-        
+
         # Django integration
         print("\n2️⃣ DJANGO INTEGRATION:")
         django_data = example_django_integration()
-        
+
         print("\n" + "=" * 50)
-        
+
         # Advanced config
         print("\n3️⃣ ADVANCED CONFIGURATION:")
         advanced_loader = example_advanced_config()
-        
+
         print("\n🎉 All examples completed successfully!")
-        
+
     except Exception as e:
         print(f"❌ Error: {e}")
         import traceback

django_cfg/modules/django_currency/utils/cache.py

@@ -3,19 +3,18 @@ Simple cache manager for currency rates.
 """
 
 import logging
-from datetime import datetime, timedelta
-from typing import Optional, Dict, Any
+from typing import Any, Dict, Optional
+
 from cachetools import TTLCache
 
 from ..core.models import Rate
-from ..core.exceptions import CacheError
 
 logger = logging.getLogger(__name__)
 
 
 class CacheManager:
     """Simple TTL cache for currency rates."""
-    
+
     def __init__(self, ttl: int = 300, maxsize: int = 1000):
         """
         Initialize cache manager.
@@ -26,7 +25,7 @@ class CacheManager:
         """
         self.cache = TTLCache(maxsize=maxsize, ttl=ttl)
         self.ttl = ttl
-        
+
     def get_rate(self, base: str, quote: str, source: str) -> Optional[Rate]:
         """
         Get cached rate.
@@ -40,7 +39,7 @@ class CacheManager:
             Cached Rate or None
         """
         key = self._make_key(base, quote, source)
-        
+
         try:
             cached_rate = self.cache.get(key)
             if cached_rate:
@@ -52,7 +51,7 @@ class CacheManager:
         except Exception as e:
             logger.error(f"Cache get error: {e}")
             return None
-    
+
     def set_rate(self, rate: Rate) -> bool:
         """
         Cache rate.
@@ -64,7 +63,7 @@ class CacheManager:
             True if cached successfully
         """
         key = self._make_key(rate.base_currency, rate.quote_currency, rate.source)
-        
+
         try:
             self.cache[key] = rate
             logger.debug(f"Cached rate for {key}")
@@ -72,16 +71,16 @@ class CacheManager:
         except Exception as e:
             logger.error(f"Cache set error: {e}")
             return False
-    
+
     def _make_key(self, base: str, quote: str, source: str) -> str:
         """Make cache key."""
         return f"{source}:{base}:{quote}".upper()
-    
+
     def clear(self) -> None:
         """Clear all cached rates."""
         self.cache.clear()
         logger.info("Cache cleared")
-    
+
     def get_stats(self) -> Dict[str, Any]:
         """Get cache statistics."""
         return {