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

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

@@ -1,293 +0,0 @@
-"""
-NowPayments provider implementation.
-
-Enhanced crypto payment provider with minimal typing.
-"""
-
-import logging
-import requests
-import hashlib
-import hmac
-from typing import Optional, List
-from decimal import Decimal
-from pydantic import BaseModel, Field
-
-from .base import PaymentProvider
-from ..internal_types import ProviderResponse, WebhookData
-
-logger = logging.getLogger(__name__)
-
-
-class NowPaymentsConfig(BaseModel):
-    """NowPayments provider configuration."""
-    api_key: str = Field(..., description="NowPayments API key")
-    sandbox: bool = Field(default=False, description="Use sandbox mode")
-    ipn_secret: Optional[str] = Field(default=None, description="IPN secret for webhook validation")
-    callback_url: Optional[str] = Field(default=None, description="Webhook callback URL")
-    success_url: Optional[str] = Field(default=None, description="Payment success redirect URL")
-    cancel_url: Optional[str] = Field(default=None, description="Payment cancel redirect URL")
-    enabled: bool = Field(default=True, description="Provider enabled")
-
-
-class NowPaymentsProvider(PaymentProvider):
-    """NowPayments cryptocurrency payment provider."""
-    
-    def __init__(self, config: NowPaymentsConfig):
-        """Initialize NowPayments provider."""
-        super().__init__(config.dict())
-        self.config = config
-        self.api_key = config.api_key
-        self.sandbox = config.sandbox
-        self.ipn_secret = config.ipn_secret or ''
-        self.base_url = self._get_base_url()
-        
-        # Configurable URLs 
-        self.callback_url = config.callback_url
-        self.success_url = config.success_url
-        self.cancel_url = config.cancel_url
-        
-        self.headers = {
-            'x-api-key': self.api_key,
-            'Content-Type': 'application/json'
-        }
-    
-    def _get_base_url(self) -> str:
-        """Get base URL based on sandbox mode."""
-        if self.sandbox:
-            return 'https://api-sandbox.nowpayments.io/v1'
-        return 'https://api.nowpayments.io/v1'
-    
-    def _make_request(self, method: str, endpoint: str, data: Optional[dict] = None) -> Optional[dict]:
-        """Make HTTP request to NowPayments API with error handling."""
-        try:
-            url = f"{self.base_url}/{endpoint}"
-            
-            response = requests.request(
-                method=method,
-                url=url,
-                headers=self.headers,
-                json=data,
-                timeout=30
-            )
-            
-            response.raise_for_status()
-            return response.json()
-            
-        except requests.exceptions.RequestException as e:
-            logger.error(f"NowPayments API request failed: {e}")
-            return None
-        except Exception as e:
-            logger.error(f"Unexpected error in NowPayments request: {e}")
-            return None
-    
-    def create_payment(self, payment_data: dict) -> ProviderResponse:
-        """Create payment via NowPayments API."""
-        try:
-            amount = Decimal(str(payment_data['amount']))
-            currency = payment_data['currency']
-            order_id = payment_data.get('order_id', f'payment_{int(amount * 100)}_{currency}')
-            
-            payment_request = {
-                'price_amount': float(amount),
-                'price_currency': 'usd',  # Base currency
-                'pay_currency': currency,
-                'order_id': order_id,
-                'order_description': payment_data.get('description', f'Payment {order_id}'),
-            }
-            
-            # Add optional URLs
-            if self.success_url:
-                payment_request['success_url'] = self.success_url
-            if self.cancel_url:
-                payment_request['cancel_url'] = self.cancel_url
-            if self.callback_url:
-                payment_request['ipn_callback_url'] = self.callback_url
-            
-            response = self._make_request('POST', 'payment', payment_request)
-            
-            if response:
-                return ProviderResponse(
-                    success=True,
-                    provider_payment_id=response.get('payment_id'),
-                    payment_url=response.get('invoice_url'),
-                    pay_address=response.get('pay_address'),
-                    amount=Decimal(str(response.get('pay_amount', 0))),
-                    currency=response.get('pay_currency'),
-                    status='pending'
-                )
-            else:
-                return ProviderResponse(
-                    success=False,
-                    error_message='Failed to create payment'
-                )
-                
-        except Exception as e:
-            logger.error(f"NowPayments create_payment error: {e}")
-            return ProviderResponse(
-                success=False,
-                error_message=str(e)
-            )
-    
-    def check_payment_status(self, payment_id: str) -> ProviderResponse:
-        """Check payment status via NowPayments API."""
-        try:
-            response = self._make_request('GET', f'payment/{payment_id}')
-            
-            if response:
-                # Map NowPayments status to universal status
-                status_mapping = {
-                    'waiting': 'pending',
-                    'confirming': 'processing',
-                    'confirmed': 'completed',
-                    'sending': 'processing',
-                    'partially_paid': 'pending',
-                    'finished': 'completed',
-                    'failed': 'failed',
-                    'refunded': 'refunded',
-                    'expired': 'expired'
-                }
-                
-                provider_status = response.get('payment_status', 'unknown')
-                universal_status = status_mapping.get(provider_status, 'unknown')
-                
-                return ProviderResponse(
-                    success=True,
-                    provider_payment_id=response.get('payment_id'),
-                    status=universal_status,
-                    pay_address=response.get('pay_address'),
-                    amount=Decimal(str(response.get('pay_amount', 0))),
-                    currency=response.get('pay_currency')
-                )
-            else:
-                return ProviderResponse(
-                    success=False,
-                    error_message='Payment not found'
-                )
-                
-        except Exception as e:
-            logger.error(f"NowPayments check_payment_status error: {e}")
-            return ProviderResponse(
-                success=False,
-                error_message=str(e)
-            )
-    
-    def process_webhook(self, payload: dict) -> WebhookData:
-        """Process NowPayments webhook."""
-        try:
-            # Map status
-            status_mapping = {
-                'waiting': 'pending',
-                'confirming': 'processing', 
-                'confirmed': 'completed',
-                'sending': 'processing',
-                'partially_paid': 'pending',
-                'finished': 'completed',
-                'failed': 'failed',
-                'refunded': 'refunded',
-                'expired': 'expired'
-            }
-            
-            provider_status = payload.get('payment_status', 'unknown')
-            universal_status = status_mapping.get(provider_status, 'unknown')
-            
-            return WebhookData(
-                provider_payment_id=str(payload.get('payment_id', '')),
-                status=universal_status,
-                pay_amount=Decimal(str(payload.get('pay_amount', 0))),
-                actually_paid=Decimal(str(payload.get('actually_paid', 0))),
-                order_id=payload.get('order_id'),
-                signature=payload.get('signature')
-            )
-            
-        except Exception as e:
-            logger.error(f"NowPayments webhook processing error: {e}")
-            raise
-    
-    def get_supported_currencies(self) -> List[str]:
-        """Get list of supported currencies."""
-        try:
-            response = self._make_request('GET', 'currencies')
-            
-            if response and 'currencies' in response:
-                return response['currencies']
-            else:
-                # Fallback currencies
-                return ['BTC', 'ETH', 'LTC', 'BCH', 'XMR', 'TRX', 'BNB']
-                
-        except Exception as e:
-            logger.error(f"Error getting supported currencies: {e}")
-            return ['BTC', 'ETH', 'LTC']  # Minimal fallback
-    
-    def get_minimum_payment_amount(self, currency_from: str, currency_to: str = 'usd') -> Optional[Decimal]:
-        """Get minimum payment amount for currency pair."""
-        try:
-            response = self._make_request('GET', 'min-amount', {
-                'currency_from': currency_from,
-                'currency_to': currency_to
-            })
-            
-            if response and 'min_amount' in response:
-                return Decimal(str(response['min_amount']))
-            
-            return None
-            
-        except Exception as e:
-            logger.error(f"Error getting minimum amount: {e}")
-            return None
-    
-    def estimate_payment_amount(self, amount: Decimal, currency_code: str) -> Optional[dict]:
-        """Estimate payment amount in target currency."""
-        try:
-            response = self._make_request('GET', 'estimate', {
-                'amount': float(amount),
-                'currency_from': 'usd',
-                'currency_to': currency_code
-            })
-            
-            if response and 'estimated_amount' in response:
-                return {
-                    'estimated_amount': Decimal(str(response['estimated_amount'])),
-                    'currency_from': response.get('currency_from'),
-                    'currency_to': response.get('currency_to'),
-                    'fee_amount': Decimal(str(response.get('fee_amount', 0)))
-                }
-            
-            return None
-            
-        except Exception as e:
-            logger.error(f"Error estimating payment amount: {e}")
-            return None
-    
-    def validate_webhook(self, payload: dict, headers: Optional[dict] = None) -> bool:
-        """Validate NowPayments webhook signature."""
-        try:
-            if not self.ipn_secret:
-                logger.warning("IPN secret not configured, skipping webhook validation")
-                return True
-            
-            if not headers:
-                logger.warning("No headers provided for webhook validation")
-                return False
-            
-            # Get signature from headers
-            signature = headers.get('x-nowpayments-sig')
-            if not signature:
-                logger.warning("No signature found in webhook headers")
-                return False
-            
-            # TODO: Implement proper HMAC signature validation
-            # This requires the raw payload body for proper validation
-            logger.info("Webhook signature validation placeholder")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Webhook validation error: {e}")
-            return False
-    
-    def check_api_status(self) -> bool:
-        """Check if NowPayments API is available."""
-        try:
-            response = self._make_request('GET', 'status')
-            return response is not None and response.get('message') == 'OK'
-        except:
-            return False

django_cfg/apps/payments/services/validators/__init__.py

@@ -1,8 +0,0 @@
-"""
-Validators for payment services.
-
-TODO: Implement payment validators when needed.
-"""
-
-# Placeholder for future validators
-__all__ = []

django_cfg/modules/django_currency/clients/coingecko_client.py

@@ -1,257 +0,0 @@
-"""
-CoinGecko client for crypto rates only.
-"""
-
-import logging
-import time
-from datetime import datetime
-from typing import Dict, Set, Optional
-from cachetools import TTLCache
-from pycoingecko import CoinGeckoAPI
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
-
-from ..core.models import Rate
-from ..core.exceptions import RateFetchError
-
-logger = logging.getLogger(__name__)
-
-
-class CoinGeckoClient:
-    """Client for fetching crypto rates from CoinGecko."""
-    
-    def __init__(self, cache_ttl: int = 3600, rate_limit_delay: float = 1.2):
-        """Initialize CoinGecko client with TTL cache and rate limiting."""
-        self.client = CoinGeckoAPI()
-        self._crypto_cache = TTLCache(maxsize=2, ttl=cache_ttl)  # Cache crypto data for 1 hour
-        self._rate_cache = TTLCache(maxsize=1000, ttl=600)  # Cache rates for 10 minutes
-        self._last_request_time = 0.0
-        self._rate_limit_delay = rate_limit_delay  # Delay between requests to avoid 429
-    
-    def fetch_rate(self, base: str, quote: str) -> Rate:
-        """
-        Fetch crypto exchange rate from CoinGecko with caching.
-        
-        Args:
-            base: Base currency code (crypto)
-            quote: Quote currency code
-            
-        Returns:
-            Rate object with exchange rate data
-            
-        Raises:
-            RateFetchError: If rate fetch fails
-        """
-        cache_key = f"{base}_{quote}"
-        
-        # Try cache first
-        if cache_key in self._rate_cache:
-            logger.debug(f"Retrieved rate {base}/{quote} from cache")
-            return self._rate_cache[cache_key]
-        
-        try:
-            rate = self._fetch_rate_with_retry(base, quote)
-            
-            # Cache the result
-            self._rate_cache[cache_key] = rate
-            
-            return rate
-            
-        except Exception as e:
-            logger.error(f"Failed to fetch rate for {base}/{quote}: {e}")
-            raise RateFetchError(f"CoinGecko fetch failed: {e}")
-
-    @retry(
-        stop=stop_after_attempt(4),  # More retries for CoinGecko due to rate limits
-        wait=wait_exponential(multiplier=2, min=2, max=30),  # Longer waits for rate-limited API
-        retry=retry_if_exception_type((ConnectionError, TimeoutError, Exception)),
-        reraise=True
-    )
-    def _fetch_rate_with_retry(self, base: str, quote: str) -> Rate:
-        """
-        Fetch rate with retry logic and exponential backoff.
-        
-        Args:
-            base: Base currency code (crypto)
-            quote: Quote currency code
-            
-        Returns:
-            Rate object with exchange rate data
-        """
-        base_id = self._get_crypto_id(base)
-        quote_currency = quote.lower()
-        
-        vs_currencies = self.get_vs_currencies()
-        if quote_currency not in vs_currencies:
-            raise RateFetchError(f"Quote currency {quote} not supported by CoinGecko")
-        
-        logger.debug(f"Fetching rate for {base_id} vs {quote_currency}")
-        
-        # Fetch price from CoinGecko with rate limiting
-        self._rate_limit()
-        price_data = self.client.get_price(
-            ids=base_id,
-            vs_currencies=quote_currency,
-            include_last_updated_at=True
-        )
-        
-        if base_id not in price_data:
-            raise RateFetchError(f"No data for {base}")
-        
-        rate_value = price_data[base_id][quote_currency]
-        
-        return Rate(
-            source="coingecko",
-            base_currency=base.upper(),
-            quote_currency=quote.upper(),
-            rate=float(rate_value),
-            timestamp=datetime.now()
-        )
-    
-    def get_crypto_ids(self) -> Dict[str, str]:
-        """Get all supported cryptocurrencies dynamically with caching."""
-        cache_key = "crypto_ids"
-        
-        # Try cache first
-        if cache_key in self._crypto_cache:
-            logger.debug("Retrieved crypto IDs from cache")
-            return self._crypto_cache[cache_key]
-        
-        try:
-            crypto_ids = self._get_coins_list_with_retry()
-            
-            # Cache the result
-            self._crypto_cache[cache_key] = crypto_ids
-            logger.info(f"Loaded and cached {len(crypto_ids)} cryptocurrencies from CoinGecko")
-            
-            return crypto_ids
-            
-        except Exception as e:
-            logger.error(f"Failed to load cryptocurrencies: {e}")
-            raise RateFetchError(f"Failed to load cryptocurrencies from CoinGecko: {e}")
-    
-    def get_vs_currencies(self) -> Set[str]:
-        """Get all supported quote currencies dynamically with caching."""
-        cache_key = "vs_currencies"
-        
-        # Try cache first
-        if cache_key in self._crypto_cache:
-            logger.debug("Retrieved vs_currencies from cache")
-            return self._crypto_cache[cache_key]
-        
-        try:
-            vs_currencies_set = self._get_vs_currencies_with_retry()
-            
-            # Cache the result
-            self._crypto_cache[cache_key] = vs_currencies_set
-            logger.info(f"Loaded and cached {len(vs_currencies_set)} vs_currencies from CoinGecko")
-            
-            return vs_currencies_set
-            
-        except Exception as e:
-            logger.error(f"Failed to load vs_currencies: {e}")
-            raise RateFetchError(f"Failed to load vs_currencies from CoinGecko: {e}")
-    
-    def _get_crypto_id(self, currency: str) -> str:
-        """Get CoinGecko crypto ID from currency code."""
-        currency = currency.upper()
-        crypto_ids = self.get_crypto_ids()
-        
-        if currency in crypto_ids:
-            return crypto_ids[currency]
-        
-        raise RateFetchError(f"Unknown cryptocurrency: {currency}")
-    
-    def _rate_limit(self):
-        """Enforce rate limiting to prevent API throttling."""
-        current_time = time.time()
-        time_since_last = current_time - self._last_request_time
-        
-        if time_since_last < self._rate_limit_delay:
-            sleep_time = self._rate_limit_delay - time_since_last
-            logger.debug(f"Rate limiting: sleeping for {sleep_time:.2f}s")
-            time.sleep(sleep_time)
-        
-        self._last_request_time = time.time()
-
-    @retry(
-        stop=stop_after_attempt(3),
-        wait=wait_exponential(multiplier=2, min=2, max=15),
-        retry=retry_if_exception_type((ConnectionError, TimeoutError, Exception)),
-        reraise=True
-    )
-    def _get_coins_list_with_retry(self) -> Dict[str, str]:
-        """Get coins list with retry logic."""
-        self._rate_limit()
-        coins_list = self.client.get_coins_list()
-        crypto_ids = {}
-        
-        for coin in coins_list:
-            symbol = coin['symbol'].upper()
-            crypto_ids[symbol] = coin['id']
-        
-        return crypto_ids
-
-    @retry(
-        stop=stop_after_attempt(3),
-        wait=wait_exponential(multiplier=2, min=2, max=15),
-        retry=retry_if_exception_type((ConnectionError, TimeoutError, Exception)),
-        reraise=True
-    )
-    def _get_vs_currencies_with_retry(self) -> Set[str]:
-        """Get vs currencies with retry logic."""
-        self._rate_limit()
-        vs_currencies = self.client.get_supported_vs_currencies()
-        return set(vs_currencies)
-
-    def fetch_multiple_rates(self, pairs: list) -> Dict[str, Rate]:
-        """
-        Fetch multiple currency rates in parallel.
-        
-        Args:
-            pairs: List of tuples (base, quote) to fetch
-            
-        Returns:
-            Dictionary mapping "BASE_QUOTE" to Rate objects
-        """
-        results = {}
-        
-        def fetch_single_rate(pair):
-            base, quote = pair
-            try:
-                rate = self.fetch_rate(base, quote)
-                return f"{base}_{quote}", rate
-            except Exception as e:
-                logger.warning(f"Failed to fetch {base}/{quote}: {e}")
-                return f"{base}_{quote}", None
-        
-        # Use ThreadPoolExecutor for parallel fetching with rate limiting
-        with ThreadPoolExecutor(max_workers=3) as executor:  # Limited workers to respect rate limits
-            future_to_pair = {executor.submit(fetch_single_rate, pair): pair for pair in pairs}
-            
-            for future in as_completed(future_to_pair):
-                try:
-                    key, rate = future.result(timeout=30)
-                    if rate:
-                        results[key] = rate
-                except Exception as e:
-                    pair = future_to_pair[future]
-                    logger.error(f"Failed to fetch rate for {pair}: {e}")
-        
-        logger.info(f"Successfully fetched {len(results)}/{len(pairs)} rates")
-        return results
-    
-    def supports_pair(self, base: str, quote: str) -> bool:
-        """Check if crypto currency pair is supported."""
-        try:
-            # Base must be a crypto
-            crypto_ids = self.get_crypto_ids()
-            if base.upper() not in crypto_ids:
-                return False
-            
-            # Quote must be a supported vs_currency
-            vs_currencies = self.get_vs_currencies()
-            return quote.lower() in vs_currencies
-            
-        except Exception:
-            return False