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

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

@@ -1,246 +0,0 @@
-"""
-Management command to populate initial currency data.
-
-This is a simpler version of update_currencies designed for initial setup.
-Use this when you need to populate an empty currency database.
-
-Usage:
-    python manage.py populate_currencies
-    python manage.py populate_currencies --quick
-    python manage.py populate_currencies --crypto-only
-    python manage.py populate_currencies --fiat-only
-"""
-
-import logging
-from typing import List
-
-from django.core.management.base import BaseCommand, CommandError
-from django.db import transaction
-from django.utils import timezone
-
-from django_cfg.modules.django_currency.database.database_loader import (
-    create_database_loader,
-    DatabaseLoaderConfig
-)
-from django_cfg.apps.payments.models.currencies import Currency
-
-logger = logging.getLogger(__name__)
-
-
-class Command(BaseCommand):
-    """
-    Simple command to populate initial currency data.
-    
-    Optimized for first-time setup with sensible defaults.
-    """
-    
-    help = 'Populate initial currency data (for empty database)'
-    
-    def add_arguments(self, parser):
-        """Add command line arguments."""
-        parser.add_argument(
-            '--quick',
-            action='store_true',
-            help='Quick setup with top 50 cryptocurrencies and 20 fiat currencies'
-        )
-        
-        parser.add_argument(
-            '--crypto-only',
-            action='store_true',
-            help='Only populate cryptocurrencies'
-        )
-        
-        parser.add_argument(
-            '--fiat-only',
-            action='store_true',
-            help='Only populate fiat currencies'
-        )
-        
-        parser.add_argument(
-            '--skip-existing',
-            action='store_true',
-            help='Skip currencies that already exist in database'
-        )
-    
-    def handle(self, *args, **options):
-        """Main command handler."""
-        
-        self.stdout.write(
-            self.style.SUCCESS('🪙 Populating currency database...')
-        )
-        
-        # Check if database is empty
-        existing_count = Currency.objects.count()
-        if existing_count > 0 and not options['skip_existing']:
-            self.stdout.write(
-                self.style.WARNING(f'⚠️ Database already contains {existing_count} currencies')
-            )
-            response = input('Continue anyway? [y/N]: ')
-            if response.lower() != 'y':
-                self.stdout.write('Cancelled by user')
-                return
-        
-        try:
-            # Configure loader based on options
-            if options['quick']:
-                config = DatabaseLoaderConfig(
-                    max_cryptocurrencies=50,
-                    max_fiat_currencies=20,
-                    min_market_cap_usd=10_000_000,  # Top coins only
-                    coingecko_delay=1.0,  # Faster for initial setup
-                )
-                self.stdout.write("⚡ Quick setup mode: top 50 crypto + 20 fiat")
-            else:
-                config = DatabaseLoaderConfig(
-                    max_cryptocurrencies=200,
-                    max_fiat_currencies=30,
-                    min_market_cap_usd=1_000_000,
-                    coingecko_delay=1.5,
-                )
-                self.stdout.write("📈 Standard setup: top 200 crypto + 30 fiat")
-            
-            loader = create_database_loader(
-                max_cryptocurrencies=config.max_cryptocurrencies,
-                max_fiat_currencies=config.max_fiat_currencies,
-                min_market_cap_usd=config.min_market_cap_usd,
-                coingecko_delay=config.coingecko_delay
-            )
-            
-            # Get statistics
-            stats = loader.get_statistics()
-            self.stdout.write(f"📊 Available: {stats['total_currencies']} currencies")
-            
-            # Load currency data
-            self.stdout.write("🌐 Fetching currency data from APIs...")
-            fresh_currencies = loader.build_currency_database_data()
-            
-            # Filter by type if requested
-            if options['crypto_only']:
-                fresh_currencies = [c for c in fresh_currencies if c.currency_type == 'crypto']
-                self.stdout.write(f"🔗 Crypto only: {len(fresh_currencies)} cryptocurrencies")
-            elif options['fiat_only']:
-                fresh_currencies = [c for c in fresh_currencies if c.currency_type == 'fiat']
-                self.stdout.write(f"💵 Fiat only: {len(fresh_currencies)} fiat currencies")
-            else:
-                crypto_count = sum(1 for c in fresh_currencies if c.currency_type == 'crypto')
-                fiat_count = sum(1 for c in fresh_currencies if c.currency_type == 'fiat')
-                self.stdout.write(f"💰 Mixed: {crypto_count} crypto + {fiat_count} fiat")
-            
-            # Populate database
-            self._populate_database(fresh_currencies, options)
-            
-        except KeyboardInterrupt:
-            self.stdout.write(
-                self.style.WARNING('\n⚠️ Population interrupted by user')
-            )
-            raise CommandError("Population cancelled")
-            
-        except Exception as e:
-            logger.exception("Currency population failed")
-            self.stdout.write(
-                self.style.ERROR(f'❌ Population failed: {str(e)}')
-            )
-            raise CommandError(f"Population failed: {str(e)}")
-    
-    def _populate_database(self, currencies: List, options: dict):
-        """Populate the database with currencies."""
-        
-        created_count = 0
-        updated_count = 0
-        skipped_count = 0
-        
-        try:
-            with transaction.atomic():
-                self.stdout.write("💾 Populating database...")
-                
-                for i, currency_data in enumerate(currencies):
-                    try:
-                        # Check if exists and should skip
-                        if options['skip_existing']:
-                            if Currency.objects.filter(code=currency_data.code).exists():
-                                skipped_count += 1
-                                continue
-                        
-                        # Create or update
-                        currency, created = Currency.objects.update_or_create(
-                            code=currency_data.code,
-                            defaults={
-                                'name': currency_data.name,
-                                'symbol': currency_data.symbol,
-                                'currency_type': currency_data.currency_type,
-                                'decimal_places': currency_data.decimal_places,
-                                'usd_rate': currency_data.usd_rate,
-                                'min_payment_amount': currency_data.min_payment_amount,
-                                'is_active': currency_data.is_active,
-                                'rate_updated_at': timezone.now()
-                            }
-                        )
-                        
-                        if created:
-                            created_count += 1
-                        else:
-                            updated_count += 1
-                        
-                        # Progress indicator every 25 currencies
-                        if (i + 1) % 25 == 0:
-                            self.stdout.write(f"   📊 Progress: {i + 1}/{len(currencies)}")
-                    
-                    except Exception as e:
-                        self.stdout.write(
-                            self.style.WARNING(f'⚠️ Failed to create {currency_data.code}: {e}')
-                        )
-                        continue
-                
-                # Final summary
-                total_processed = created_count + updated_count
-                self.stdout.write(f"\n🎉 Population completed!")
-                self.stdout.write(f"   ✅ Created: {created_count} currencies")
-                self.stdout.write(f"   🔄 Updated: {updated_count} currencies")
-                self.stdout.write(f"   ⏭️ Skipped: {skipped_count} currencies")
-                self.stdout.write(f"   📊 Total: {total_processed} currencies processed")
-                
-                # Show some examples
-                self._show_examples()
-                
-                self.stdout.write(
-                    self.style.SUCCESS('\n✅ Currency database is ready for payments!')
-                )
-                
-        except Exception as e:
-            self.stdout.write(
-                self.style.ERROR(f'❌ Population failed and rolled back: {str(e)}')
-            )
-            raise
-    
-    def _show_examples(self):
-        """Show some example currencies that were created."""
-        
-        # Show top cryptocurrencies
-        crypto_examples = Currency.objects.filter(
-            currency_type=Currency.CurrencyType.CRYPTO
-        ).order_by('-usd_rate')[:3]
-        
-        if crypto_examples:
-            self.stdout.write(f"\n🔗 Top cryptocurrencies:")
-            for currency in crypto_examples:
-                self.stdout.write(f"   • {currency.code}: ${currency.usd_rate:.2f}")
-        
-        # Show fiat currencies
-        fiat_examples = Currency.objects.filter(
-            currency_type=Currency.CurrencyType.FIAT
-        ).order_by('code')[:5]
-        
-        if fiat_examples:
-            self.stdout.write(f"\n💵 Fiat currencies:")
-            for currency in fiat_examples:
-                self.stdout.write(f"   • {currency.code}: {currency.name} ({currency.symbol})")
-        
-        # Total counts
-        total = Currency.objects.count()
-        crypto_count = Currency.objects.filter(currency_type=Currency.CurrencyType.CRYPTO).count()
-        fiat_count = Currency.objects.filter(currency_type=Currency.CurrencyType.FIAT).count()
-        
-        self.stdout.write(f"\n📊 Database now contains:")
-        self.stdout.write(f"   • Total: {total} currencies")
-        self.stdout.write(f"   • Crypto: {crypto_count} currencies")
-        self.stdout.write(f"   • Fiat: {fiat_count} currencies")

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

@@ -1,336 +0,0 @@
-"""
-Management command to update currency data using django_currency database loader.
-
-This command automatically populates and updates the payments Currency model
-with fresh data from external APIs (CoinGecko, YFinance).
-
-Usage:
-    python manage.py update_currencies
-    python manage.py update_currencies --max-crypto 100 --max-fiat 20
-    python manage.py update_currencies --dry-run
-    python manage.py update_currencies --force-update
-"""
-
-import logging
-from typing import Dict, List, Optional
-from datetime import datetime, timedelta
-
-from django.core.management.base import BaseCommand, CommandError
-from django.db import transaction
-from django.utils import timezone
-from django.conf import settings
-
-from django_cfg.modules.django_currency.database.database_loader import (
-    CurrencyDatabaseLoader,
-    DatabaseLoaderConfig,
-    create_database_loader
-)
-from django_cfg.apps.payments.models.currencies import Currency
-
-logger = logging.getLogger(__name__)
-
-
-class Command(BaseCommand):
-    """
-    Management command to update currency data.
-    
-    Features:
-    - Automatic detection of new currencies
-    - Rate updates for existing currencies
-    - Dry-run mode for testing
-    - Configurable limits for API calls
-    - Progress reporting
-    - Error handling and rollback
-    """
-    
-    help = 'Update currency data from external APIs (CoinGecko, YFinance)'
-    
-    def add_arguments(self, parser):
-        """Add command line arguments."""
-        parser.add_argument(
-            '--max-crypto',
-            type=int,
-            default=500,
-            help='Maximum number of cryptocurrencies to load (default: 500)'
-        )
-        
-        parser.add_argument(
-            '--max-fiat',
-            type=int,
-            default=50,
-            help='Maximum number of fiat currencies to load (default: 50)'
-        )
-        
-        parser.add_argument(
-            '--min-market-cap',
-            type=float,
-            default=1000000,
-            help='Minimum market cap in USD for cryptocurrencies (default: 1M)'
-        )
-        
-        parser.add_argument(
-            '--dry-run',
-            action='store_true',
-            help='Show what would be updated without making changes'
-        )
-        
-        parser.add_argument(
-            '--force-update',
-            action='store_true',
-            help='Force update all currencies even if recently updated'
-        )
-        
-        parser.add_argument(
-            '--exclude-stablecoins',
-            action='store_true',
-            help='Exclude stablecoins from cryptocurrency updates'
-        )
-        
-        parser.add_argument(
-            '--update-threshold-hours',
-            type=int,
-            default=6,
-            help='Only update currencies older than N hours (default: 6)'
-        )
-        
-        parser.add_argument(
-            '--verbose',
-            action='store_true',
-            help='Verbose output with detailed progress'
-        )
-    
-    def handle(self, *args, **options):
-        """Main command handler."""
-        
-        # Configure logging
-        log_level = logging.INFO if options['verbose'] else logging.WARNING
-        logging.getLogger('django_cfg.modules.django_currency').setLevel(log_level)
-        
-        self.stdout.write(
-            self.style.SUCCESS('🏦 Starting currency database update...')
-        )
-        
-        try:
-            # Create database loader with options
-            config = DatabaseLoaderConfig(
-                max_cryptocurrencies=options['max_crypto'],
-                max_fiat_currencies=options['max_fiat'],
-                min_market_cap_usd=options['min_market_cap'],
-                exclude_stablecoins=options['exclude_stablecoins'],
-                coingecko_delay=1.5,  # Be respectful to APIs
-                yfinance_delay=0.5
-            )
-            
-            loader = CurrencyDatabaseLoader(config)
-            
-            # Get statistics
-            stats = loader.get_statistics()
-            self.stdout.write(f"📊 Loader config: {stats['total_currencies']} currencies available")
-            self.stdout.write(f"   • {stats['total_fiat_currencies']} fiat currencies")
-            self.stdout.write(f"   • {stats['total_cryptocurrencies']} cryptocurrencies")
-            
-            # Check existing currencies
-            existing_count = Currency.objects.count()
-            self.stdout.write(f"📋 Current database: {existing_count} currencies")
-            
-            # Determine update strategy
-            if options['force_update']:
-                currencies_to_update = Currency.objects.all()
-                self.stdout.write("🔄 Force update mode: updating all currencies")
-            else:
-                threshold = timezone.now() - timedelta(hours=options['update_threshold_hours'])
-                currencies_to_update = Currency.objects.filter(
-                    rate_updated_at__lt=threshold
-                ) | Currency.objects.filter(rate_updated_at__isnull=True)
-                
-                self.stdout.write(
-                    f"⏰ Updating currencies older than {options['update_threshold_hours']} hours: "
-                    f"{currencies_to_update.count()} currencies"
-                )
-            
-            # Load fresh currency data
-            self.stdout.write("🌐 Fetching fresh currency data from APIs...")
-            fresh_currencies = loader.build_currency_database_data()
-            
-            if options['dry_run']:
-                self._handle_dry_run(fresh_currencies, currencies_to_update)
-            else:
-                self._handle_update(fresh_currencies, currencies_to_update, options)
-            
-        except KeyboardInterrupt:
-            self.stdout.write(
-                self.style.WARNING('\n⚠️ Update interrupted by user')
-            )
-            raise CommandError("Update cancelled by user")
-            
-        except Exception as e:
-            logger.exception("Currency update failed")
-            self.stdout.write(
-                self.style.ERROR(f'❌ Currency update failed: {str(e)}')
-            )
-            raise CommandError(f"Update failed: {str(e)}")
-    
-    def _handle_dry_run(self, fresh_currencies: List, currencies_to_update):
-        """Handle dry-run mode - show what would be updated."""
-        self.stdout.write(
-            self.style.WARNING('🧪 DRY RUN MODE - No changes will be made')
-        )
-        
-        # Analyze changes
-        existing_codes = set(Currency.objects.values_list('code', flat=True))
-        fresh_codes = {curr.code for curr in fresh_currencies}
-        
-        new_currencies = fresh_codes - existing_codes
-        existing_currencies = fresh_codes & existing_codes
-        
-        self.stdout.write(f"\n📈 Analysis:")
-        self.stdout.write(f"   • Would add {len(new_currencies)} new currencies")
-        self.stdout.write(f"   • Would update {len(existing_currencies)} existing currencies")
-        
-        if new_currencies:
-            self.stdout.write(f"\n➕ New currencies to add:")
-            for code in sorted(list(new_currencies)[:10]):  # Show first 10
-                currency = next(c for c in fresh_currencies if c.code == code)
-                self.stdout.write(f"   • {code}: {currency.name} ({currency.currency_type})")
-            if len(new_currencies) > 10:
-                self.stdout.write(f"   ... and {len(new_currencies) - 10} more")
-        
-        if existing_currencies:
-            self.stdout.write(f"\n🔄 Existing currencies to update:")
-            for code in sorted(list(existing_currencies)[:10]):  # Show first 10
-                currency = next(c for c in fresh_currencies if c.code == code)
-                try:
-                    existing = Currency.objects.get(code=code)
-                    rate_diff = abs(existing.usd_rate - currency.usd_rate)
-                    if rate_diff > 0.01:  # Significant change
-                        change_pct = ((currency.usd_rate - existing.usd_rate) / existing.usd_rate) * 100
-                        self.stdout.write(
-                            f"   • {code}: ${existing.usd_rate:.6f} → ${currency.usd_rate:.6f} "
-                            f"({change_pct:+.2f}%)"
-                        )
-                except Currency.DoesNotExist:
-                    pass
-        
-        self.stdout.write(
-            self.style.SUCCESS('\n✅ Dry run completed - use --force-update to apply changes')
-        )
-    
-    def _handle_update(self, fresh_currencies: List, currencies_to_update, options: Dict):
-        """Handle actual database update."""
-        
-        updated_count = 0
-        created_count = 0
-        errors = []
-        
-        # Create lookup for fresh data
-        fresh_data_map = {curr.code: curr for curr in fresh_currencies}
-        
-        try:
-            with transaction.atomic():
-                self.stdout.write("💾 Updating database...")
-                
-                # Process currencies
-                for i, fresh_currency in enumerate(fresh_currencies):
-                    try:
-                        currency, created = Currency.objects.update_or_create(
-                            code=fresh_currency.code,
-                            defaults={
-                                'name': fresh_currency.name,
-                                'symbol': fresh_currency.symbol,
-                                'currency_type': fresh_currency.currency_type,
-                                'decimal_places': fresh_currency.decimal_places,
-                                'usd_rate': fresh_currency.usd_rate,
-                                'min_payment_amount': fresh_currency.min_payment_amount,
-                                'is_active': fresh_currency.is_active,
-                                'rate_updated_at': timezone.now()
-                            }
-                        )
-                        
-                        if created:
-                            created_count += 1
-                            if options['verbose']:
-                                self.stdout.write(f"   ➕ Created {fresh_currency.code}")
-                        else:
-                            updated_count += 1
-                            if options['verbose']:
-                                self.stdout.write(f"   🔄 Updated {fresh_currency.code}")
-                        
-                        # Progress indicator
-                        if (i + 1) % 50 == 0:
-                            self.stdout.write(f"   Progress: {i + 1}/{len(fresh_currencies)} currencies processed")
-                    
-                    except Exception as e:
-                        error_msg = f"Failed to update {fresh_currency.code}: {str(e)}"
-                        errors.append(error_msg)
-                        logger.error(error_msg)
-                        
-                        # Continue with other currencies unless it's a critical error
-                        if len(errors) > 10:  # Too many errors
-                            raise CommandError(f"Too many errors ({len(errors)}), aborting")
-                
-                # Summary
-                total_processed = created_count + updated_count
-                self.stdout.write(f"\n📊 Update Summary:")
-                self.stdout.write(f"   ✅ Successfully processed: {total_processed} currencies")
-                self.stdout.write(f"   ➕ Created new: {created_count}")
-                self.stdout.write(f"   🔄 Updated existing: {updated_count}")
-                
-                if errors:
-                    self.stdout.write(f"   ⚠️ Errors: {len(errors)}")
-                    for error in errors[:5]:  # Show first 5 errors
-                        self.stdout.write(f"      • {error}")
-                    if len(errors) > 5:
-                        self.stdout.write(f"      ... and {len(errors) - 5} more errors")
-                
-                # Deactivate currencies not in fresh data (optional)
-                fresh_codes = {curr.code for curr in fresh_currencies}
-                stale_currencies = Currency.objects.filter(is_active=True).exclude(
-                    code__in=fresh_codes
-                )
-                
-                if stale_currencies.exists():
-                    self.stdout.write(f"   📋 Found {stale_currencies.count()} currencies not in fresh data")
-                    # Optionally deactivate them
-                    # stale_currencies.update(is_active=False)
-                
-                self.stdout.write(
-                    self.style.SUCCESS('✅ Currency database update completed successfully!')
-                )
-        
-        except Exception as e:
-            self.stdout.write(
-                self.style.ERROR(f'❌ Update failed and rolled back: {str(e)}')
-            )
-            raise
-    
-    def _show_statistics(self):
-        """Show current currency statistics."""
-        total = 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()
-        
-        # Recent updates
-        recent_threshold = timezone.now() - timedelta(hours=24)
-        recent_updates = Currency.objects.filter(rate_updated_at__gte=recent_threshold).count()
-        
-        self.stdout.write(f"\n📊 Current Database Statistics:")
-        self.stdout.write(f"   • Total currencies: {total}")
-        self.stdout.write(f"   • Fiat currencies: {fiat_count}")
-        self.stdout.write(f"   • Cryptocurrencies: {crypto_count}")
-        self.stdout.write(f"   • Active currencies: {active_count}")
-        self.stdout.write(f"   • Updated in last 24h: {recent_updates}")
-        
-        # Show some examples
-        recent_currencies = Currency.objects.filter(
-            rate_updated_at__gte=recent_threshold
-        ).order_by('-rate_updated_at')[:5]
-        
-        if recent_currencies:
-            self.stdout.write(f"\n🕒 Recently updated currencies:")
-            for currency in recent_currencies:
-                age = timezone.now() - currency.rate_updated_at
-                hours_ago = int(age.total_seconds() / 3600)
-                self.stdout.write(
-                    f"   • {currency.code}: ${currency.usd_rate:.6f} ({hours_ago}h ago)"
-                )