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

django_cfg/apps/payments/services/core/currency_service.py

@@ -4,19 +4,21 @@ Currency service for the Universal Payment System v2.0.
 Handles currency conversion and rate management using django_currency module.
 """
 
-from typing import Optional, List
-from django.utils import timezone
+from typing import List, Optional
+
 from django.db import models
+from django.utils import timezone
 
-from .base import BaseService
+from django_cfg.modules.django_currency import CurrencyError, convert_currency, get_exchange_rate
+
+from ...models import Currency, Network, ProviderCurrency
 from ..types import (
-    CurrencyConversionRequest, CurrencyConversionResult, CurrencyData,
-    ServiceOperationResult
-)
-from ...models import Currency, ProviderCurrency, Network
-from django_cfg.modules.django_currency import (
-    convert_currency, get_exchange_rate, CurrencyError
+    CurrencyConversionRequest,
+    CurrencyConversionResult,
+    CurrencyData,
+    ServiceOperationResult,
 )
+from .base import BaseService
 
 
 class CurrencyService(BaseService):
@@ -25,7 +27,7 @@ class CurrencyService(BaseService):
     
     Integrates with django_currency module for real-time rates.
     """
-    
+
     def convert_currency(self, request: CurrencyConversionRequest) -> CurrencyConversionResult:
         """
         Convert amount between currencies.
@@ -40,16 +42,16 @@ class CurrencyService(BaseService):
             # Validate request
             if isinstance(request, dict):
                 request = CurrencyConversionRequest(**request)
-            
+
             self.logger.debug("Converting currency", extra={
                 'amount': request.amount,
                 'from_currency': request.from_currency,
                 'to_currency': request.to_currency
             })
-            
+
             # Check if currencies are supported
             validation_result = self._validate_currencies(
-                request.from_currency, 
+                request.from_currency,
                 request.to_currency
             )
             if not validation_result.success:
@@ -58,7 +60,7 @@ class CurrencyService(BaseService):
                     message=validation_result.message,
                     error_code=validation_result.error_code
                 )
-            
+
             # Perform conversion using django_currency
             try:
                 converted_amount = convert_currency(
@@ -66,12 +68,12 @@ class CurrencyService(BaseService):
                     request.from_currency,
                     request.to_currency
                 )
-                
+
                 exchange_rate = get_exchange_rate(
                     request.from_currency,
                     request.to_currency
                 )
-                
+
                 self._log_operation(
                     "convert_currency",
                     True,
@@ -81,7 +83,7 @@ class CurrencyService(BaseService):
                     converted_amount=converted_amount,
                     exchange_rate=exchange_rate
                 )
-                
+
                 return CurrencyConversionResult(
                     success=True,
                     message="Currency converted successfully",
@@ -92,7 +94,7 @@ class CurrencyService(BaseService):
                     exchange_rate=exchange_rate,
                     rate_timestamp=timezone.now()
                 )
-                
+
             except CurrencyError as e:
                 return CurrencyConversionResult(
                     success=False,
@@ -102,14 +104,14 @@ class CurrencyService(BaseService):
                     from_currency=request.from_currency,
                     to_currency=request.to_currency
                 )
-                
+
         except Exception as e:
             return CurrencyConversionResult(**self._handle_exception(
                 "convert_currency", e,
                 from_currency=request.from_currency if hasattr(request, 'from_currency') else None,
                 to_currency=request.to_currency if hasattr(request, 'to_currency') else None
             ).model_dump())
-    
+
     def get_exchange_rate(self, base_currency: str, quote_currency: str) -> ServiceOperationResult:
         """
         Get current exchange rate between currencies.
@@ -126,16 +128,16 @@ class CurrencyService(BaseService):
                 'base_currency': base_currency,
                 'quote_currency': quote_currency
             })
-            
+
             # Validate currencies
             validation_result = self._validate_currencies(base_currency, quote_currency)
             if not validation_result.success:
                 return validation_result
-            
+
             # Get rate using django_currency
             try:
                 rate = get_exchange_rate(base_currency, quote_currency)
-                
+
                 return self._create_success_result(
                     "Exchange rate retrieved successfully",
                     {
@@ -146,20 +148,20 @@ class CurrencyService(BaseService):
                         'pair': f"{base_currency}/{quote_currency}"
                     }
                 )
-                
+
             except CurrencyError as e:
                 return self._create_error_result(
                     f"Failed to get exchange rate: {e}",
                     "rate_fetch_failed"
                 )
-                
+
         except Exception as e:
             return self._handle_exception(
                 "get_exchange_rate", e,
                 base_currency=base_currency,
                 quote_currency=quote_currency
             )
-    
+
     def get_supported_currencies(self, provider: Optional[str] = None, currency_type: str = 'all') -> ServiceOperationResult:
         """
         Get list of supported currencies.
@@ -176,29 +178,29 @@ class CurrencyService(BaseService):
                 'provider': provider,
                 'currency_type': currency_type
             })
-            
+
             # Get currencies from database
             queryset = Currency.objects.filter(is_active=True)
-            
+
             # Filter by currency type
             if currency_type and currency_type != 'all':
                 queryset = queryset.filter(currency_type=currency_type)
-            
+
             if provider:
                 # Filter by provider support
                 queryset = queryset.filter(
                     provider_configs__provider=provider,
                     provider_configs__is_enabled=True
                 ).distinct()
-            
+
             currencies = queryset.order_by('code')
-            
+
             # Convert to data
             currency_data = []
             for currency in currencies:
                 data = CurrencyData.model_validate(currency)
                 currency_info = data.model_dump()
-                
+
                 # Add provider-specific info if requested
                 if provider:
                     try:
@@ -217,9 +219,9 @@ class CurrencyService(BaseService):
                             }
                     except Exception:
                         pass
-                
+
                 currency_data.append(currency_info)
-            
+
             return self._create_success_result(
                 f"Retrieved {len(currency_data)} supported currencies",
                 {
@@ -228,13 +230,13 @@ class CurrencyService(BaseService):
                     'provider': provider
                 }
             )
-            
+
         except Exception as e:
             return self._handle_exception(
                 "get_supported_currencies", e,
                 provider=provider
             )
-    
+
     def get_currency_networks(self, currency_code: str) -> ServiceOperationResult:
         """
         Get available networks for a currency.
@@ -249,7 +251,7 @@ class CurrencyService(BaseService):
             self.logger.debug("Getting currency networks", extra={
                 'currency_code': currency_code
             })
-            
+
             # Get currency
             try:
                 currency = Currency.objects.get(code=currency_code, is_active=True)
@@ -258,13 +260,13 @@ class CurrencyService(BaseService):
                     f"Currency {currency_code} not found or disabled",
                     "currency_not_found"
                 )
-            
+
             # Get networks
             networks = Network.objects.filter(
                 currency_code=currency_code,
                 is_active=True
             ).order_by('name')
-            
+
             network_data = []
             for network in networks:
                 network_info = {
@@ -277,7 +279,7 @@ class CurrencyService(BaseService):
                     'estimated_confirmation_time': network.estimated_confirmation_time()
                 }
                 network_data.append(network_info)
-            
+
             return self._create_success_result(
                 f"Retrieved {len(network_data)} networks for {currency_code}",
                 {
@@ -286,13 +288,13 @@ class CurrencyService(BaseService):
                     'count': len(network_data)
                 }
             )
-            
+
         except Exception as e:
             return self._handle_exception(
                 "get_currency_networks", e,
                 currency_code=currency_code
             )
-    
+
     def update_currency_rates(self, currency_codes: Optional[List[str]] = None) -> ServiceOperationResult:
         """
         Update currency rates from external sources.
@@ -307,7 +309,7 @@ class CurrencyService(BaseService):
             self.logger.info("Updating currency rates", extra={
                 'currency_codes': currency_codes
             })
-            
+
             # Get currencies to update
             if currency_codes:
                 currencies = Currency.objects.filter(
@@ -316,11 +318,11 @@ class CurrencyService(BaseService):
                 )
             else:
                 currencies = Currency.objects.filter(is_active=True)
-            
+
             updated_count = 0
             failed_count = 0
             errors = []
-            
+
             # Update rates for each currency against USD
             for currency in currencies:
                 try:
@@ -328,7 +330,7 @@ class CurrencyService(BaseService):
                         # Test rate fetch
                         rate = get_exchange_rate('USD', currency.code)
                         updated_count += 1
-                        
+
                         self.logger.debug(f"Updated rate for {currency.code}", extra={
                             'currency_code': currency.code,
                             'usd_rate': rate
@@ -337,19 +339,19 @@ class CurrencyService(BaseService):
                     failed_count += 1
                     error_msg = f"{currency.code}: {str(e)}"
                     errors.append(error_msg)
-                    
+
                     self.logger.warning(f"Failed to update rate for {currency.code}", extra={
                         'currency_code': currency.code,
                         'error': str(e)
                     })
-            
+
             self._log_operation(
                 "update_currency_rates",
                 failed_count == 0,
                 updated_count=updated_count,
                 failed_count=failed_count
             )
-            
+
             return self._create_success_result(
                 f"Updated rates for {updated_count} currencies, {failed_count} failed",
                 {
@@ -359,13 +361,13 @@ class CurrencyService(BaseService):
                     'total_currencies': currencies.count()
                 }
             )
-            
+
         except Exception as e:
             return self._handle_exception(
                 "update_currency_rates", e,
                 currency_codes=currency_codes
             )
-    
+
     def get_currency_stats(self) -> ServiceOperationResult:
         """
         Get currency statistics.
@@ -385,21 +387,21 @@ class CurrencyService(BaseService):
                 currency_type=Currency.CurrencyType.FIAT,
                 is_active=True
             ).count()
-            
+
             # Provider support
             provider_stats = ProviderCurrency.objects.filter(
                 is_enabled=True
             ).values('provider').annotate(
                 currency_count=models.Count('currency', distinct=True)
             ).order_by('-currency_count')
-            
+
             # Network stats
             network_stats = Network.objects.filter(
                 is_active=True
             ).values('currency_code').annotate(
                 network_count=models.Count('id')
             ).order_by('-network_count')
-            
+
             stats = {
                 'total_currencies': total_currencies,
                 'enabled_currencies': enabled_currencies,
@@ -409,15 +411,15 @@ class CurrencyService(BaseService):
                 'network_support': list(network_stats),
                 'generated_at': timezone.now().isoformat()
             }
-            
+
             return self._create_success_result(
                 "Currency statistics retrieved",
                 stats
             )
-            
+
         except Exception as e:
             return self._handle_exception("get_currency_stats", e)
-    
+
     def _validate_currencies(self, from_currency: str, to_currency: str) -> ServiceOperationResult:
         """Validate that currencies are supported."""
         try:
@@ -427,40 +429,40 @@ class CurrencyService(BaseService):
                     f"Currency {from_currency} not supported",
                     "from_currency_not_supported"
                 )
-            
+
             # Check to_currency
             if not Currency.objects.filter(code=to_currency, is_active=True).exists():
                 return self._create_error_result(
                     f"Currency {to_currency} not supported",
                     "to_currency_not_supported"
                 )
-            
+
             return self._create_success_result("Currencies are valid")
-            
+
         except Exception as e:
             return self._create_error_result(
                 f"Currency validation error: {e}",
                 "validation_error"
             )
-    
+
     def health_check(self) -> ServiceOperationResult:
         """Perform currency service health check."""
         try:
             # Check database connectivity
             currency_count = Currency.objects.filter(is_active=True).count()
-            
+
             # Test currency conversion
             try:
                 test_rate = get_exchange_rate('USD', 'BTC')
                 conversion_healthy = True
             except CurrencyError:
                 conversion_healthy = False
-            
+
             # Check provider currencies
             provider_currency_count = ProviderCurrency.objects.filter(
                 is_enabled=True
             ).count()
-            
+
             stats = {
                 'service_name': 'CurrencyService',
                 'enabled_currencies': currency_count,
@@ -468,7 +470,7 @@ class CurrencyService(BaseService):
                 'conversion_service_healthy': conversion_healthy,
                 'django_currency_module': 'available'
             }
-            
+
             if conversion_healthy and currency_count > 0:
                 return self._create_success_result(
                     "CurrencyService is healthy",
@@ -480,6 +482,6 @@ class CurrencyService(BaseService):
                     "service_unhealthy",
                     stats
                 )
-                
+
         except Exception as e:
             return self._handle_exception("health_check", e)

django_cfg/apps/payments/services/core/operations/__init__.py

@@ -4,8 +4,8 @@ Payment operations.
 Core payment business logic operations.
 """
 
-from .payment_creator import PaymentCreator
 from .payment_canceller import PaymentCanceller
+from .payment_creator import PaymentCreator
 from .status_checker import StatusChecker
 
 __all__ = [

django_cfg/apps/payments/services/core/operations/payment_canceller.py

@@ -5,11 +5,12 @@ Handles payment cancellation with validation.
 """
 
 from typing import TYPE_CHECKING
+
 from ...types import PaymentResult
 from ..utils import DataConverter
 
 if TYPE_CHECKING:
-    from ....models import UniversalPayment
+    pass
 
 
 class PaymentCanceller:

django_cfg/apps/payments/services/core/operations/payment_creator.py

@@ -5,6 +5,7 @@ Handles payment creation with full validation and provider integration.
 """
 
 from typing import TYPE_CHECKING
+
 from django.contrib.auth import get_user_model
 from django.utils import timezone
 
@@ -12,8 +13,8 @@ from ...types import PaymentCreateRequest, PaymentResult
 from ..utils import DataConverter
 
 if TYPE_CHECKING:
-    from ..currency import CurrencyValidator
     from ...providers import ProviderRegistry
+    from ..currency import CurrencyValidator
 
 User = get_user_model()
 

django_cfg/apps/payments/services/core/operations/status_checker.py

@@ -5,7 +5,8 @@ Handles payment status retrieval with optional provider verification.
 """
 
 from typing import TYPE_CHECKING
-from ...types import PaymentStatusRequest, PaymentResult
+
+from ...types import PaymentResult, PaymentStatusRequest
 from ..utils import DataConverter
 
 if TYPE_CHECKING:

django_cfg/apps/payments/services/core/payment_service.py

@@ -5,21 +5,24 @@ Coordinates payment operations using specialized components.
 """
 
 from typing import Optional
+
 from django.contrib.auth import get_user_model
 
-from .base import BaseService
-from ..types import (
-    PaymentCreateRequest, PaymentStatusRequest, PaymentResult,
-    ServiceOperationResult
-)
 from ...models import UniversalPayment
 from ..providers import get_provider_registry
+from ..types import (
+    PaymentCreateRequest,
+    PaymentResult,
+    PaymentStatusRequest,
+    ServiceOperationResult,
+)
+from .base import BaseService
 
 # Import specialized components
-from .currency import CurrencyValidator, CurrencyConverter
+from .currency import CurrencyConverter, CurrencyValidator
+from .operations import PaymentCanceller, PaymentCreator, StatusChecker
 from .providers import ProviderClient, StatusMapper
 from .utils import DataConverter, StatisticsCalculator
-from .operations import PaymentCreator, PaymentCanceller, StatusChecker
 
 User = get_user_model()
 

django_cfg/apps/payments/services/core/providers/provider_client.py

@@ -5,11 +5,11 @@ Handles interactions with payment providers including status checks.
 """
 
 from typing import TYPE_CHECKING
+
 from django.db import transaction
-from django.utils import timezone
 
-from ...types import ServiceOperationResult
 from ....models.managers.payment_managers import PaymentStatusUpdateFields
+from ...types import ServiceOperationResult
 from .status_mapper import StatusMapper
 
 if TYPE_CHECKING: