django-cfg 1.3.7__py3-none-any.whl → 1.3.9__py3-none-any.whl

django_cfg/apps/payments/management/commands/manage_currencies.py

@@ -1,370 +1,332 @@
 """
 Currency management command for Universal Payment System v2.0.
 
-Integrates with django_currency module for automatic rate updates and population.
+Simple and reliable currency management using hybrid client.
 """
 
 from django.core.management.base import BaseCommand, CommandError
-from django.db import transaction
+from django.db import transaction, models
 from django.utils import timezone
-from django.db.models import Q
 from datetime import timedelta
-from typing import List, Optional
 import time
+import concurrent.futures
+from threading import Lock
 
 from django_cfg.modules.django_logger import get_logger
-from django_cfg.modules.django_currency import (
-    CurrencyConverter, convert_currency, get_exchange_rate,
-    CurrencyError, CurrencyNotFoundError
-)
-from django_cfg.apps.payments.models import Currency, Network, ProviderCurrency
+from django_cfg.modules.django_currency import CurrencyConverter, CurrencyError
+from django_cfg.apps.payments.models import Currency
 
 logger = get_logger("manage_currencies")
 
 
 class Command(BaseCommand):
-    """
-    Universal currency management command using ready modules.
+    """Simple currency management command using hybrid client."""
     
-    Features:
-    - Population of missing currencies
-    - USD rate updates using django_currency
-    - Provider currency synchronization
-    - Flexible filtering and options
-    """
-    
-    help = 'Manage currencies and exchange rates for the payment system'
+    help = 'Manage currencies and exchange rates using hybrid client'
     
     def add_arguments(self, parser):
         """Add command arguments."""
-        
-        # Main operation modes
         parser.add_argument(
             '--populate',
             action='store_true',
-            help='Populate missing base currencies'
+            help='Populate all supported currencies from hybrid client'
         )
-        
         parser.add_argument(
             '--rates-only',
             action='store_true',
-            help='Update USD exchange rates only (no population)'
+            help='Update USD rates only (no population)'
         )
-        
-        parser.add_argument(
-            '--sync-providers',
-            action='store_true',
-            help='Sync provider currencies after rate updates'
-        )
-        
-        # Filtering options
         parser.add_argument(
             '--currency',
             type=str,
-            help='Update specific currency code (e.g., BTC, ETH)'
-        )
-        
-        parser.add_argument(
-            '--currency-type',
-            choices=['fiat', 'crypto'],
-            help='Filter by currency type'
-        )
-        
-        parser.add_argument(
-            '--provider',
-            type=str,
-            help='Filter by provider name'
+            help='Update specific currency only'
         )
-        
-        # Behavior options
         parser.add_argument(
             '--force',
             action='store_true',
-            help='Force refresh rates even if recently updated'
+            help='Force update even if rates are fresh'
         )
-        
         parser.add_argument(
-            '--skip-existing',
-            action='store_true',
-            help='Skip currencies that already exist during population'
+            '--limit',
+            type=int,
+            default=500,
+            help='Limit number of currencies to process'
         )
-        
         parser.add_argument(
-            '--dry-run',
-            action='store_true',
-            help='Show what would be done without making changes'
+            '--batch-size',
+            type=int,
+            default=20,
+            help='Number of currencies to process in parallel (default: 20)'
         )
-        
         parser.add_argument(
-            '--limit',
+            '--max-workers',
             type=int,
-            default=100,
-            help='Limit number of currencies to process (default: 100)'
+            default=10,
+            help='Maximum number of worker threads (default: 10)'
         )
     
     def handle(self, *args, **options):
         """Main command handler."""
-        
         start_time = time.time()
         
         try:
-            self.stdout.write(
-                self.style.SUCCESS('🚀 Starting Universal Currency Management')
-            )
+            self.stdout.write(self.style.SUCCESS('🚀 Starting Universal Currency Management'))
+            
+            # Initialize converter
+            self.converter = CurrencyConverter(cache_ttl=3600)
             
-            # Determine operation mode
             if options['populate']:
-                result = self._populate_currencies(options)
+                self._populate_all_currencies(options)
             elif options['rates_only']:
-                result = self._update_rates_only(options)
+                self._update_rates_only(options)
             else:
                 # Default: populate + rates
-                self.stdout.write("📋 Running full currency management (populate + rates)")
-                populate_result = self._populate_currencies(options)
-                rates_result = self._update_rates_only(options)
-                result = populate_result + rates_result
-            
-            # Optional provider sync
-            if options['sync_providers']:
-                self._sync_provider_currencies(options)
+                self._populate_all_currencies(options)
+                self._update_rates_only(options)
             
             # Show summary
             elapsed = time.time() - start_time
-            self.stdout.write(
-                self.style.SUCCESS(
-                    f'✅ Currency management completed in {elapsed:.1f}s'
-                )
-            )
-            
-            if not options['dry_run']:
-                self._show_final_stats()
+            self.stdout.write(self.style.SUCCESS(f'✅ Currency management completed in {elapsed:.1f}s'))
+            self._show_final_stats()
             
         except Exception as e:
-            self.stdout.write(
-                self.style.ERROR(f'❌ Currency management failed: {e}')
-            )
+            self.stdout.write(self.style.ERROR(f'❌ Currency management failed: {e}'))
             logger.error(f"Currency management command failed: {e}")
             raise CommandError(f"Command failed: {e}")
     
-    def _populate_currencies(self, options) -> int:
-        """Populate missing base currencies."""
-        
+    def _populate_all_currencies(self, options):
+        """Populate all supported currencies from hybrid client."""
         self.stdout.write("📦 Populating base currencies...")
         
-        # Define standard currencies to populate
-        standard_currencies = [
-            # Major fiat currencies
-            ('USD', 'US Dollar', Currency.CurrencyType.FIAT, '$', 2),
-            ('EUR', 'Euro', Currency.CurrencyType.FIAT, '€', 2),
-            ('GBP', 'British Pound', Currency.CurrencyType.FIAT, '£', 2),
-            ('JPY', 'Japanese Yen', Currency.CurrencyType.FIAT, '¥', 0),
-            ('CNY', 'Chinese Yuan', Currency.CurrencyType.FIAT, '¥', 2),
-            ('RUB', 'Russian Ruble', Currency.CurrencyType.FIAT, '₽', 2),
+        try:
+            # Get all supported currencies from hybrid client
+            supported_currencies = self.converter.hybrid.get_all_supported_currencies()
+            self.stdout.write(f"Found {len(supported_currencies)} supported currencies")
             
-            # Major cryptocurrencies
-            ('BTC', 'Bitcoin', Currency.CurrencyType.CRYPTO, '₿', 8),
-            ('ETH', 'Ethereum', Currency.CurrencyType.CRYPTO, 'Ξ', 8),
-            ('USDT', 'Tether USD', Currency.CurrencyType.CRYPTO, '₮', 6),
-            ('USDC', 'USD Coin', Currency.CurrencyType.CRYPTO, '', 6),
-            ('BNB', 'Binance Coin', Currency.CurrencyType.CRYPTO, '', 8),
-            ('ADA', 'Cardano', Currency.CurrencyType.CRYPTO, '', 6),
-            ('SOL', 'Solana', Currency.CurrencyType.CRYPTO, '', 8),
-            ('DOT', 'Polkadot', Currency.CurrencyType.CRYPTO, '', 8),
-            ('MATIC', 'Polygon', Currency.CurrencyType.CRYPTO, '', 8),
-            ('LTC', 'Litecoin', Currency.CurrencyType.CRYPTO, 'Ł', 8),
-            ('TRX', 'TRON', Currency.CurrencyType.CRYPTO, '', 6),
-            ('XRP', 'Ripple', Currency.CurrencyType.CRYPTO, '', 6),
-        ]
-        
-        # Apply currency type filter
-        if options['currency_type']:
-            currency_type_filter = Currency.CurrencyType.FIAT if options['currency_type'] == 'fiat' else Currency.CurrencyType.CRYPTO
-            standard_currencies = [
-                c for c in standard_currencies 
-                if c[2] == currency_type_filter
-            ]
-        
-        # Apply specific currency filter
-        if options['currency']:
-            currency_code = options['currency'].upper()
-            standard_currencies = [
-                c for c in standard_currencies 
-                if c[0] == currency_code
-            ]
+            # Apply limit
+            if options['limit'] and len(supported_currencies) > options['limit']:
+                # Take first N currencies (sorted alphabetically)
+                limited_currencies = dict(list(supported_currencies.items())[:options['limit']])
+                supported_currencies = limited_currencies
+                self.stdout.write(f"Limited to {len(supported_currencies)} currencies")
             
-            if not standard_currencies:
-                raise CommandError(f"Currency '{currency_code}' not in standard list")
-        
-        created_count = 0
-        skipped_count = 0
-        
-        for code, name, currency_type, symbol, decimal_places in standard_currencies:
-            
-            if options['dry_run']:
-                exists = Currency.objects.filter(code=code).exists()
-                if exists and options['skip_existing']:
-                    self.stdout.write(f"   [DRY RUN] Would skip existing {code}")
-                    skipped_count += 1
+            # Apply specific currency filter
+            if options['currency']:
+                currency_code = options['currency'].upper()
+                if currency_code in supported_currencies:
+                    supported_currencies = {currency_code: supported_currencies[currency_code]}
                 else:
-                    self.stdout.write(f"   [DRY RUN] Would create/update {code}")
-                continue
+                    raise CommandError(f"Currency '{currency_code}' not supported by hybrid client")
             
-            try:
-                currency, created = Currency.objects.get_or_create(
-                    code=code,
-                    defaults={
-                        'name': name,
-                        'currency_type': currency_type,
-                        'symbol': symbol,
-                        'decimal_places': decimal_places,
-                        'is_active': True
-                    }
-                )
-                
-                if created:
-                    self.stdout.write(f"   ✅ Created {code} - {name}")
-                    created_count += 1
-                    logger.info(f"Created currency: {code}")
-                elif not options['skip_existing']:
-                    # Update existing currency if not skipping
-                    currency.name = name
-                    currency.symbol = symbol
-                    currency.decimal_places = decimal_places
-                    currency.save()
-                    self.stdout.write(f"   🔄 Updated {code} - {name}")
-                else:
-                    self.stdout.write(f"   ⏭️  Skipped existing {code}")
-                    skipped_count += 1
+            created_count = 0
+            updated_count = 0
+            skipped_count = 0
+            
+            for code, name in supported_currencies.items():
+                try:
+                    # Determine currency type based on code
+                    currency_type = self._determine_currency_type(code)
+                    decimal_places = self._get_decimal_places(code, currency_type)
+                    symbol = self._get_currency_symbol(code)
                     
-            except Exception as e:
-                self.stdout.write(f"   ❌ Failed to create {code}: {e}")
-                logger.error(f"Failed to create currency {code}: {e}")
-        
-        self.stdout.write(f"📦 Population complete: {created_count} created, {skipped_count} skipped")
-        return created_count
+                    currency, created = Currency.objects.get_or_create(
+                        code=code,
+                        defaults={
+                            'name': name,
+                            'currency_type': currency_type,
+                            'symbol': symbol,
+                            'decimal_places': decimal_places,
+                            'is_active': True
+                        }
+                    )
+                    
+                    if created:
+                        self.stdout.write(f"   ✅ Created {code} - {name}")
+                        created_count += 1
+                        logger.info(f"Created currency: {code}")
+                    else:
+                        # Update name if it's different
+                        if currency.name != name:
+                            currency.name = name
+                            currency.save()
+                            self.stdout.write(f"   🔄 Updated {code} - {name}")
+                            updated_count += 1
+                        else:
+                            self.stdout.write(f"   ⏭️  Skipped existing {code}")
+                            skipped_count += 1
+                            
+                except Exception as e:
+                    self.stdout.write(f"   ❌ Failed to create {code}: {e}")
+                    logger.error(f"Failed to create currency {code}: {e}")
+            
+            self.stdout.write(f"📦 Population complete: {created_count} created, {updated_count} updated, {skipped_count} skipped")
+            
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"Failed to populate currencies: {e}"))
+            logger.error(f"Currency population failed: {e}")
+            raise
     
-    def _update_rates_only(self, options) -> int:
-        """Update USD exchange rates using django_currency module."""
-        
+    def _update_rates_only(self, options):
+        """Update USD exchange rates for existing currencies using batch processing."""
         self.stdout.write("💱 Updating USD exchange rates...")
         
-        # Build queryset based on options
-        queryset = Currency.objects.all()
+        # Get currencies to update
+        queryset = Currency.objects.filter(is_active=True)
         
         if options['currency']:
-            queryset = queryset.filter(code__iexact=options['currency'])
+            currency_code = options['currency'].upper()
+            queryset = queryset.filter(code=currency_code)
             if not queryset.exists():
-                raise CommandError(f"Currency '{options['currency']}' not found")
+                raise CommandError(f"Currency '{currency_code}' not found in database")
         
-        if options['currency_type']:
-            currency_type = Currency.CurrencyType.FIAT if options['currency_type'] == 'fiat' else Currency.CurrencyType.CRYPTO
-            queryset = queryset.filter(currency_type=currency_type)
-        
-        # Filter by staleness unless forced
+        # Apply freshness filter unless forced
         if not options['force']:
-            # For now, skip staleness check since rate fields don't exist
-            # TODO: Implement proper rate tracking fields
-            pass
+            # Only update rates older than 1 hour
+            stale_threshold = timezone.now() - timedelta(hours=1)
+            queryset = queryset.filter(
+                models.Q(usd_rate_updated_at__isnull=True) |
+                models.Q(usd_rate_updated_at__lt=stale_threshold)
+            )
+        
+        currencies = list(queryset[:options['limit']])
+        self.stdout.write(f"📊 Processing {len(currencies)} currencies...")
         
-        # Apply limit
-        queryset = queryset[:options['limit']]
+        # Handle USD separately (always 1.0)
+        usd_currencies = [c for c in currencies if c.code == 'USD']
+        other_currencies = [c for c in currencies if c.code != 'USD']
         
         updated_count = 0
         error_count = 0
         
-        self.stdout.write(f"📊 Processing {queryset.count()} currencies...")
-        
-        for currency in queryset:
+        # Update USD currencies first (instant)
+        for currency in usd_currencies:
+            currency.usd_rate = 1.0
+            currency.usd_rate_updated_at = timezone.now()
+            currency.save()
+            self.stdout.write(f"   ✅ USD: $1.00000000")
+            updated_count += 1
+        
+        # Process other currencies in batches with threading
+        if other_currencies:
+            batch_size = options['batch_size']
+            max_workers = min(options['max_workers'], len(other_currencies))
             
-            if options['dry_run']:
-                self.stdout.write(f"   [DRY RUN] Would update {currency.code}")
-                continue
+            self.stdout.write(f"🚀 Using {max_workers} workers, batch size: {batch_size}")
             
-            try:
-                # Use django_currency module to get rate
-                if currency.code == 'USD':
-                    # USD is the base currency
-                    usd_rate = 1.0
-                else:
-                    # Get rate from django_currency
-                    usd_rate = get_exchange_rate(currency.code, 'USD')
+            # Thread-safe counters
+            self._lock = Lock()
+            self._updated_count = 0
+            self._error_count = 0
+            
+            # Process in batches
+            for i in range(0, len(other_currencies), batch_size):
+                batch = other_currencies[i:i + batch_size]
+                self.stdout.write(f"📦 Processing batch {i//batch_size + 1}/{(len(other_currencies) + batch_size - 1)//batch_size} ({len(batch)} currencies)")
                 
-                if usd_rate and usd_rate > 0:
-                    # Update rate in ProviderCurrency (create if doesn't exist)
-                    provider_currency, created = ProviderCurrency.objects.get_or_create(
-                        currency=currency,
-                        provider='system',  # System-level rate
-                        provider_currency_code=currency.code,
-                        defaults={
-                            'is_enabled': True
-                        }
-                    )
-                    
-                    if not created:
-                        # TODO: Add rate tracking fields to ProviderCurrency model
-                        provider_currency.save()  # Touch the record to update timestamp
-                    
-                    # Update currency's exchange rate source
-                    currency.exchange_rate_source = 'django_currency'
-                    currency.save(update_fields=['exchange_rate_source'])
-                    
-                    self.stdout.write(f"   ✅ {currency.code}: ${usd_rate:.8f}")
-                    updated_count += 1
-                    
-                else:
-                    self.stdout.write(f"   ⚠️  {currency.code}: No rate available")
+                with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+                    # Submit all tasks in current batch
+                    future_to_currency = {
+                        executor.submit(self._update_single_rate, currency): currency 
+                        for currency in batch
+                    }
                     
-            except (CurrencyError, CurrencyNotFoundError) as e:
-                self.stdout.write(f"   ⚠️  {currency.code}: {str(e)}")
-                error_count += 1
-            except Exception as e:
-                self.stdout.write(f"   ❌ {currency.code}: {str(e)}")
-                error_count += 1
-                logger.error(f"Failed to update rate for {currency.code}: {e}")
+                    # Process completed tasks
+                    for future in concurrent.futures.as_completed(future_to_currency):
+                        currency = future_to_currency[future]
+                        try:
+                            success = future.result()
+                            if success:
+                                with self._lock:
+                                    self._updated_count += 1
+                            else:
+                                with self._lock:
+                                    self._error_count += 1
+                        except Exception as e:
+                            self.stdout.write(f"   ❌ {currency.code}: Thread error: {e}")
+                            with self._lock:
+                                self._error_count += 1
+                
+                # Show batch progress
+                with self._lock:
+                    self.stdout.write(f"   📊 Batch complete: {self._updated_count} updated, {self._error_count} errors so far")
+            
+            updated_count += self._updated_count
+            error_count += self._error_count
         
         self.stdout.write(f"💱 Rate update complete: {updated_count} updated, {error_count} errors")
-        return updated_count
     
-    def _sync_provider_currencies(self, options):
-        """Sync provider currencies after rate updates."""
-        
-        self.stdout.write("🔄 Syncing provider currencies...")
-        
+    def _update_single_rate(self, currency):
+        """Update rate for a single currency (thread-safe)."""
         try:
-            from django.core.management import call_command
+            # Get rate from hybrid client
+            rate_obj = self.converter.hybrid.fetch_rate(currency.code, 'USD')
             
-            if options['provider']:
-                call_command('manage_providers', '--provider', options['provider'])
-            else:
-                call_command('manage_providers', '--all')
-                
-            self.stdout.write("🔄 Provider sync completed")
+            # Update database (Django ORM is thread-safe for individual operations)
+            currency.usd_rate = rate_obj.rate
+            currency.usd_rate_updated_at = timezone.now()
+            currency.save()
+            
+            self.stdout.write(f"   ✅ {currency.code}: ${rate_obj.rate:.8f}")
+            return True
             
         except Exception as e:
-            self.stdout.write(f"⚠️  Provider sync failed: {e}")
-            logger.warning(f"Provider sync failed: {e}")
+            self.stdout.write(f"   ⚠️  {currency.code}: Failed to convert 1.0 {currency.code} to USD: {e}")
+            logger.warning(f"Rate update failed for {currency.code}: {e}")
+            return False
+    
+    def _determine_currency_type(self, code: str) -> str:
+        """Determine currency type based on code."""
+        crypto_currencies = {
+            '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'
+        }
+        
+        metal_currencies = {'XAU', 'XAG', 'XPT', 'XPD'}
+        
+        if code in crypto_currencies:
+            return Currency.CurrencyType.CRYPTO
+        elif code in metal_currencies:
+            return Currency.CurrencyType.FIAT  # Metals are treated as fiat for now
+        else:
+            return Currency.CurrencyType.FIAT
+    
+    def _get_decimal_places(self, code: str, currency_type: str) -> int:
+        """Get appropriate decimal places for currency."""
+        if currency_type == Currency.CurrencyType.CRYPTO:
+            # Most cryptos use 8 decimal places, stablecoins use 6
+            stablecoins = {'USDT', 'USDC', 'BUSD', 'DAI', 'TUSD', 'USDP'}
+            return 6 if code in stablecoins else 8
+        elif code == 'JPY':
+            # Japanese Yen has no decimal places
+            return 0
+        else:
+            # Most fiat currencies use 2 decimal places
+            return 2
+    
+    def _get_currency_symbol(self, code: str) -> str:
+        """Get currency symbol if known."""
+        symbols = {
+            'USD': '$', 'EUR': '€', 'GBP': '£', 'JPY': '¥', 'CNY': '¥', 'RUB': '₽',
+            'BTC': '₿', 'ETH': 'Ξ', 'LTC': 'Ł', 'USDT': '₮'
+        }
+        return symbols.get(code, '')
     
     def _show_final_stats(self):
         """Show final statistics."""
-        
-        try:
-            total_currencies = Currency.objects.count()
-            fiat_count = Currency.objects.filter(currency_type=Currency.CurrencyType.FIAT).count()
-            crypto_count = Currency.objects.filter(currency_type=Currency.CurrencyType.CRYPTO).count()
-            active_count = Currency.objects.filter(is_active=True).count()
-            
-            # Count currencies with provider configs (simplified since rate fields don't exist)
-            currencies_with_rates = Currency.objects.filter(
-                provider_configs__isnull=False
-            ).distinct().count()
-            
-            rate_coverage = (currencies_with_rates / total_currencies * 100) if total_currencies > 0 else 0
-            
-            self.stdout.write("\n📊 Final Statistics:")
-            self.stdout.write(f"   Total currencies: {total_currencies}")
-            self.stdout.write(f"   Fiat: {fiat_count}, Crypto: {crypto_count}")
-            self.stdout.write(f"   Active: {active_count}")
-            self.stdout.write(f"   With USD rates: {currencies_with_rates} ({rate_coverage:.1f}%)")
-            
-        except Exception as e:
-            logger.warning(f"Failed to show final stats: {e}")
+        total_currencies = Currency.objects.count()
+        active_currencies = Currency.objects.filter(is_active=True).count()
+        
+        # Count by type
+        fiat_count = Currency.objects.filter(currency_type=Currency.CurrencyType.FIAT).count()
+        crypto_count = Currency.objects.filter(currency_type=Currency.CurrencyType.CRYPTO).count()
+        
+        # Count with USD rates
+        with_rates = Currency.objects.filter(usd_rate__isnull=False, usd_rate__gt=0).count()
+        rate_percentage = (with_rates / total_currencies * 100) if total_currencies > 0 else 0
+        
+        self.stdout.write("\n📊 Final Statistics:")
+        self.stdout.write(f"   Total currencies: {total_currencies}")
+        self.stdout.write(f"   Fiat: {fiat_count}, Crypto: {crypto_count}")
+        self.stdout.write(f"   Active: {active_currencies}")
+        self.stdout.write(f"   With USD rates: {with_rates} ({rate_percentage:.1f}%)")

django_cfg/apps/payments/management/commands/manage_providers.py

@@ -13,7 +13,10 @@ import time
 
 from django_cfg.modules.django_logger import get_logger
 from django_cfg.apps.payments.models import Currency, Network, ProviderCurrency
-from django_cfg.apps.payments.services.providers import get_provider_registry
+from django_cfg.apps.payments.services.providers import (
+    get_provider_registry, 
+    get_provider_sync_service
+)
 
 logger = get_logger("manage_providers")