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

django_cfg/apps/payments/services/providers/nowpayments/sync.py

@@ -4,13 +4,15 @@ NowPayments currency synchronization service.
 Handles syncing currencies from NowPayments API to database.
 """
 
-from typing import Optional, Tuple, List
+from typing import List, Optional, Tuple
+
 from django.db import transaction
 from django.utils import timezone
 
-from django_cfg.modules.django_logging import get_logger
 from django_cfg.apps.payments.models import Currency, Network, ProviderCurrency
-from ..models import UniversalCurrency, CurrencySyncResult
+from django_cfg.modules.django_logging import get_logger
+
+from ..models import CurrencySyncResult, UniversalCurrency
 from .config import NowPaymentsConfig as Config
 
 logger = get_logger("nowpayments_sync")
@@ -18,11 +20,11 @@ logger = get_logger("nowpayments_sync")
 
 class NowPaymentsCurrencySync:
     """Service for synchronizing NowPayments currencies to database."""
-    
+
     def __init__(self, provider_name: str = 'nowpayments'):
         """Initialize currency sync service."""
         self.provider_name = provider_name
-        
+
     def sync_currencies_to_db(self, currencies: List[UniversalCurrency]) -> CurrencySyncResult:
         """
         Sync universal currencies to database.
@@ -34,7 +36,7 @@ class NowPaymentsCurrencySync:
             CurrencySyncResult: Sync operation results
         """
         result = CurrencySyncResult(total_processed=len(currencies))
-        
+
         try:
             with transaction.atomic():
                 for currency in currencies:
@@ -44,24 +46,24 @@ class NowPaymentsCurrencySync:
                         error_msg = f"Failed to sync {currency.provider_currency_code}: {e}"
                         logger.error(error_msg)
                         result.errors.append(error_msg)
-                        
+
             logger.info(
                 f"Currency sync completed: {result.currencies_created} created, "
                 f"{result.currencies_updated} updated, "
                 f"{result.provider_currencies_created} provider currencies created, "
                 f"{len(result.errors)} errors"
             )
-            
+
             return result
-            
+
         except Exception as e:
             logger.error(f"Currency sync transaction failed: {e}")
             result.errors.append(f"Transaction failed: {e}")
             return result
-    
+
     def _sync_single_currency(self, currency: UniversalCurrency, result: CurrencySyncResult):
         """Sync a single currency to database."""
-        
+
         # 1. Ensure base currency exists
         base_currency, currency_created = self._get_or_create_currency(currency)
         if currency_created:
@@ -71,19 +73,19 @@ class NowPaymentsCurrencySync:
             updated = self._update_currency_if_needed(base_currency, currency)
             if updated:
                 result.currencies_updated += 1
-        
+
         # 2. Ensure network exists (if applicable)
         network = None
         if currency.network_code:
             network, network_created = self._get_or_create_network(currency, base_currency)
             if network_created:
                 result.networks_created += 1
-        
+
         # 3. Create or update provider currency
         provider_currency, pc_created = self._get_or_create_provider_currency(
             currency, base_currency, network
         )
-        
+
         if pc_created:
             result.provider_currencies_created += 1
         else:
@@ -91,10 +93,10 @@ class NowPaymentsCurrencySync:
             updated = self._update_provider_currency_if_needed(provider_currency, currency)
             if updated:
                 result.provider_currencies_updated += 1
-    
+
     def _get_or_create_currency(self, currency: UniversalCurrency) -> Tuple[Currency, bool]:
         """Get or create base currency."""
-        
+
         defaults = {
             'name': currency.name,
             'currency_type': currency.currency_type,
@@ -103,88 +105,88 @@ class NowPaymentsCurrencySync:
             'usd_rate_updated_at': None,
             'decimal_places': self._get_decimal_places(currency),
         }
-        
+
         return Currency.objects.get_or_create(
             code=currency.base_currency_code,
             defaults=defaults
         )
-    
+
     def _update_currency_if_needed(self, base_currency: Currency, currency: UniversalCurrency) -> bool:
         """Update currency if needed."""
         updated = False
-        
+
         # Always update name to use the proper generated name
         if base_currency.name != currency.name:
             base_currency.name = currency.name
             updated = True
-        
+
         # Update activity status
         if base_currency.is_active != currency.is_enabled:
             base_currency.is_active = currency.is_enabled
             updated = True
-        
+
         if updated:
             base_currency.save()
-            
+
         return updated
-    
+
     def _get_or_create_network(self, currency: UniversalCurrency, base_currency: Currency) -> Tuple[Network, bool]:
         """Get or create network for currency."""
-        
+
         network_name = Config.get_network_name(currency.network_code)
-        
+
         defaults = {
             'name': network_name,
             'native_currency': base_currency,
             'is_active': True,
             'confirmation_blocks': Config.get_confirmation_blocks(currency.network_code),
         }
-        
+
         return Network.objects.get_or_create(
             code=currency.network_code,
             defaults=defaults
         )
-    
+
     def _get_or_create_provider_currency(
-        self, 
-        currency: UniversalCurrency, 
-        base_currency: Currency, 
+        self,
+        currency: UniversalCurrency,
+        base_currency: Currency,
         network: Optional[Network]
     ) -> Tuple[ProviderCurrency, bool]:
         """Get or create provider currency."""
-        
+
         defaults = {
             'currency': base_currency,
             'network': network,
             'is_enabled': currency.is_enabled,
         }
-        
+
         return ProviderCurrency.objects.get_or_create(
             provider=self.provider_name,
             provider_currency_code=currency.provider_currency_code,
             defaults=defaults
         )
-    
+
     def _update_provider_currency_if_needed(
-        self, 
-        provider_currency: ProviderCurrency, 
+        self,
+        provider_currency: ProviderCurrency,
         currency: UniversalCurrency
     ) -> bool:
         """Update provider currency if needed."""
         updated = False
-        
+
         # Update enabled status
         if provider_currency.is_enabled != currency.is_enabled:
             provider_currency.is_enabled = currency.is_enabled
             updated = True
-        
+
         # Update timestamps
         if updated:
             provider_currency.updated_at = timezone.now()
             provider_currency.save()
-            
+
         return updated
-    
+
     def _get_decimal_places(self, currency: UniversalCurrency) -> int:
         """Get appropriate decimal places for currency."""
         if currency.currency_type == 'fiat':
@@ -193,4 +195,3 @@ class NowPaymentsCurrencySync:
             return 6  # Stablecoins
         else:
             return 8  # Regular crypto
-    

django_cfg/apps/payments/services/providers/registry.py

@@ -4,8 +4,10 @@ Provider registry for the Universal Payment System v2.0.
 Centralized management of payment providers with health monitoring and fallbacks.
 """
 
-from typing import Dict, List, Optional, Type, Any
+from typing import Any, Dict, List, Optional, Type
+
 from django_cfg.modules.django_logging import get_logger
+
 # ConfigService removed - using direct Constance access
 from ..types import ServiceOperationResult
 from .base import BaseProvider
@@ -21,7 +23,7 @@ class ProviderRegistry:
     Provides centralized access to providers with health monitoring,
     configuration management, and fallback mechanisms.
     """
-    
+
     def __init__(self):
         """Initialize provider registry."""
         # Use PaymentsConfigManager for configuration from BaseCfgAutoModule
@@ -36,10 +38,10 @@ class ProviderRegistry:
         self._provider_configs: Dict[str, Type[ProviderConfig]] = {
             ProviderEnum.NOWPAYMENTS.value: NowPaymentsProviderConfig,
         }
-        
+
         self._health_status: Dict[str, bool] = {}
         self._initialized = False
-    
+
     def initialize(self) -> ServiceOperationResult:
         """
         Initialize all configured providers.
@@ -49,7 +51,7 @@ class ProviderRegistry:
         """
         try:
             logger.info("Initializing provider registry")
-            
+
             # Get all provider configurations from BaseCfgAutoModule
             try:
                 provider_configs = self.config_manager.get_all_provider_configs()
@@ -59,17 +61,17 @@ class ProviderRegistry:
                     message=f"Failed to get provider configurations: {e}",
                     error_code="config_failed"
                 )
-            
+
             # provider_configs is already a dict from get_all_provider_configs()
             initialized_count = 0
             failed_providers = []
-            
+
             # Initialize each configured provider
             for provider_name, config_data in provider_configs.items():
                 if not config_data.get('enabled', False):
                     logger.debug(f"Skipping disabled provider: {provider_name}")
                     continue
-                
+
                 try:
                     provider = self._create_provider(provider_name, config_data)
                     if provider:
@@ -78,20 +80,20 @@ class ProviderRegistry:
                         logger.info(f"Initialized provider: {provider_name}")
                     else:
                         failed_providers.append(provider_name)
-                        
+
                 except Exception as e:
                     logger.error(f"Failed to initialize provider {provider_name}: {e}")
                     failed_providers.append(provider_name)
-            
+
             self._initialized = True
-            
+
             # Perform initial health check
             self.health_check_all()
-            
+
             result_message = f"Initialized {initialized_count} providers"
             if failed_providers:
                 result_message += f", failed: {', '.join(failed_providers)}"
-            
+
             return ServiceOperationResult(
                 success=True,
                 message=result_message,
@@ -102,7 +104,7 @@ class ProviderRegistry:
                     'initialized_count': initialized_count
                 }
             )
-            
+
         except Exception as e:
             logger.error(f"Provider registry initialization failed: {e}")
             return ServiceOperationResult(
@@ -110,7 +112,7 @@ class ProviderRegistry:
                 message=f"Registry initialization failed: {e}",
                 error_code="initialization_failed"
             )
-    
+
     def get_provider(self, provider_name: str) -> Optional[BaseProvider]:
         """
         Get provider by name.
@@ -124,18 +126,18 @@ class ProviderRegistry:
         if not self._initialized:
             logger.warning("Registry not initialized, initializing now")
             self.initialize()
-        
+
         provider = self._providers.get(provider_name)
         if not provider:
             logger.warning(f"Provider not found: {provider_name}")
             return None
-        
+
         # Check if provider is healthy
         if not self._health_status.get(provider_name, False):
             logger.warning(f"Provider {provider_name} is unhealthy")
-        
+
         return provider
-    
+
     def get_available_providers(self) -> List[str]:
         """
         Get list of available (healthy) providers.
@@ -145,12 +147,12 @@ class ProviderRegistry:
         """
         if not self._initialized:
             self.initialize()
-        
+
         return [
             name for name, provider in self._providers.items()
             if self._health_status.get(name, False)
         ]
-    
+
     def get_primary_provider(self) -> Optional[BaseProvider]:
         """
         Get primary (preferred) provider.
@@ -159,21 +161,21 @@ class ProviderRegistry:
             Optional[BaseProvider]: Primary provider or None
         """
         available_providers = self.get_available_providers()
-        
+
         if not available_providers:
             logger.warning("No healthy providers available")
             return None
-        
+
         # Priority order: nowpayments first, then others
         priority_order = ProviderEnum.get_priority_order()
-        
+
         for provider_name in priority_order:
             if provider_name in available_providers:
                 return self._providers[provider_name]
-        
+
         # Fallback to first available
         return self._providers[available_providers[0]]
-    
+
     def get_provider_for_currency(self, currency_code: str) -> Optional[BaseProvider]:
         """
         Get best provider for specific currency.
@@ -185,21 +187,21 @@ class ProviderRegistry:
             Optional[BaseProvider]: Best provider for currency or None
         """
         available_providers = self.get_available_providers()
-        
+
         # Find providers that support the currency
         supporting_providers = []
         for provider_name in available_providers:
             provider = self._providers[provider_name]
             if currency_code in provider.config.supported_currencies:
                 supporting_providers.append(provider)
-        
+
         if not supporting_providers:
             logger.warning(f"No providers support currency: {currency_code}")
             return None
-        
+
         # Return first supporting provider (could be enhanced with more logic)
         return supporting_providers[0]
-    
+
     def health_check_all(self) -> ServiceOperationResult:
         """
         Perform health check on all providers.
@@ -209,34 +211,34 @@ class ProviderRegistry:
         """
         try:
             logger.debug("Performing health check on all providers")
-            
+
             if not self._providers:
                 return ServiceOperationResult(
                     success=False,
                     message="No providers initialized",
                     error_code="no_providers"
                 )
-            
+
             health_results = {}
             healthy_count = 0
-            
+
             for provider_name, provider in self._providers.items():
                 try:
                     health_result = provider.health_check()
                     is_healthy = health_result.success
-                    
+
                     self._health_status[provider_name] = is_healthy
                     health_results[provider_name] = {
                         'healthy': is_healthy,
                         'message': health_result.message,
                         'data': health_result.data
                     }
-                    
+
                     if is_healthy:
                         healthy_count += 1
-                    
+
                     logger.debug(f"Provider {provider_name} health: {is_healthy}")
-                    
+
                 except Exception as e:
                     logger.error(f"Health check failed for {provider_name}: {e}")
                     self._health_status[provider_name] = False
@@ -245,9 +247,9 @@ class ProviderRegistry:
                         'message': f"Health check error: {e}",
                         'data': {}
                     }
-            
+
             overall_healthy = healthy_count > 0
-            
+
             return ServiceOperationResult(
                 success=overall_healthy,
                 message=f"{healthy_count}/{len(self._providers)} providers healthy",
@@ -259,7 +261,7 @@ class ProviderRegistry:
                     'available_providers': self.get_available_providers()
                 }
             )
-            
+
         except Exception as e:
             logger.error(f"Health check failed: {e}")
             return ServiceOperationResult(
@@ -267,7 +269,7 @@ class ProviderRegistry:
                 message=f"Health check error: {e}",
                 error_code="health_check_error"
             )
-    
+
     def refresh_configurations(self) -> ServiceOperationResult:
         """
         Refresh provider configurations from config service.
@@ -277,18 +279,18 @@ class ProviderRegistry:
         """
         try:
             logger.info("Refreshing provider configurations")
-            
+
             # Clear current providers
             self._providers.clear()
             self._health_status.clear()
             self._initialized = False
-            
+
             # Refresh config service
             self.config_service.refresh_configuration()
-            
+
             # Re-initialize providers
             return self.initialize()
-            
+
         except Exception as e:
             logger.error(f"Configuration refresh failed: {e}")
             return ServiceOperationResult(
@@ -296,7 +298,7 @@ class ProviderRegistry:
                 message=f"Configuration refresh failed: {e}",
                 error_code="refresh_failed"
             )
-    
+
     def get_registry_stats(self) -> ServiceOperationResult:
         """
         Get registry statistics.
@@ -313,13 +315,13 @@ class ProviderRegistry:
                 'configured_providers': list(self._providers.keys()),
                 'health_status': dict(self._health_status)
             }
-            
+
             return ServiceOperationResult(
                 success=True,
                 message="Registry statistics",
                 data=stats
             )
-            
+
         except Exception as e:
             logger.error(f"Failed to get registry stats: {e}")
             return ServiceOperationResult(
@@ -327,7 +329,7 @@ class ProviderRegistry:
                 message=f"Stats error: {e}",
                 error_code="stats_error"
             )
-    
+
     def _create_provider(self, provider_name: str, config_data: Dict[str, Any]) -> Optional[BaseProvider]:
         """
         Create provider instance from configuration.
@@ -345,29 +347,29 @@ class ProviderRegistry:
             if not provider_class:
                 logger.error(f"Unknown provider class: {provider_name}")
                 return None
-            
+
             # Get config class
             config_class = self._provider_configs.get(provider_name)
             if not config_class:
                 logger.error(f"Unknown provider config class: {provider_name}")
                 return None
-            
+
             # Create configuration
             config = config_class(**config_data)
-            
+
             # Create provider
             provider = provider_class(config)
-            
+
             logger.debug(f"Created provider: {provider}")
             return provider
-            
+
         except Exception as e:
             logger.error(f"Failed to create provider {provider_name}: {e}")
             return None
-    
+
     def register_provider_class(
-        self, 
-        provider_name: str, 
+        self,
+        provider_name: str,
         provider_class: Type[BaseProvider],
         config_class: Type[ProviderConfig]
     ):
@@ -382,7 +384,7 @@ class ProviderRegistry:
         self._provider_classes[provider_name] = provider_class
         self._provider_configs[provider_name] = config_class
         logger.info(f"Registered provider class: {provider_name}")
-    
+
     def register_provider(self, provider_name: str, provider_instance: BaseProvider):
         """
         Register provider instance directly (for testing).
@@ -393,24 +395,24 @@ class ProviderRegistry:
         """
         self._providers[provider_name] = provider_instance
         logger.info(f"Registered provider instance: {provider_name}")
-    
+
     @property
     def providers(self) -> Dict[str, BaseProvider]:
         """Get dictionary of registered providers."""
         return self._providers.copy()
-    
+
     def list_providers(self) -> List[str]:
         """Get list of registered provider names."""
         return list(self._providers.keys())
-    
+
     def __len__(self) -> int:
         """Get number of initialized providers."""
         return len(self._providers)
-    
+
     def __contains__(self, provider_name: str) -> bool:
         """Check if provider is initialized."""
         return provider_name in self._providers
-    
+
     def __iter__(self):
         """Iterate over provider names."""
         return iter(self._providers.keys())