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

django_cfg/apps/payments/services/__init__.py

@@ -6,41 +6,38 @@ Business logic services with Pydantic validation and type safety.
 
 # Core services
 from .core import (
+    BalanceService,
     BaseService,
+    CurrencyService,
     PaymentService,
-    BalanceService,
     SubscriptionService,
     WebhookService,
-    CurrencyService,
 )
 
 # Service types
 from .types import (
-    # Request types
-    PaymentCreateRequest,
-    PaymentStatusRequest,
+    BalanceData,
+    BalanceResult,
     BalanceUpdateRequest,
-    SubscriptionCreateRequest,
-    SubscriptionUpdateRequest,
     CurrencyConversionRequest,
-    
-    # Response types
-    PaymentResult,
-    BalanceResult,
-    SubscriptionResult,
     CurrencyConversionResult,
-    ServiceOperationResult,
-    
+    CurrencyData,
+    NowPaymentsWebhook,
+    # Request types
+    PaymentCreateRequest,
     # Data types
     PaymentData,
-    BalanceData,
+    # Response types
+    PaymentResult,
+    PaymentStatusRequest,
+    ServiceOperationResult,
+    SubscriptionCreateRequest,
     SubscriptionData,
+    SubscriptionResult,
+    SubscriptionUpdateRequest,
     TransactionData,
-    CurrencyData,
-    
     # Webhook types
     WebhookData,
-    NowPaymentsWebhook,
     WebhookProcessingResult,
 )
 
@@ -52,7 +49,7 @@ __all__ = [
     'SubscriptionService',
     'WebhookService',
     'CurrencyService',
-    
+
     # Request types
     'PaymentCreateRequest',
     'PaymentStatusRequest',
@@ -60,21 +57,21 @@ __all__ = [
     'SubscriptionCreateRequest',
     'SubscriptionUpdateRequest',
     'CurrencyConversionRequest',
-    
+
     # Response types
     'PaymentResult',
     'BalanceResult',
     'SubscriptionResult',
     'CurrencyConversionResult',
     'ServiceOperationResult',
-    
+
     # Data types
     'PaymentData',
     'BalanceData',
     'SubscriptionData',
     'TransactionData',
     'CurrencyData',
-    
+
     # Webhook types
     'WebhookData',
     'NowPaymentsWebhook',
@@ -89,44 +86,44 @@ class ServiceRegistry:
     
     Provides singleton access to services and health monitoring.
     """
-    
+
     _instances = {}
-    
+
     @classmethod
     def get_payment_service(cls) -> PaymentService:
         """Get PaymentService instance."""
         if 'payment' not in cls._instances:
             cls._instances['payment'] = PaymentService()
         return cls._instances['payment']
-    
+
     @classmethod
     def get_balance_service(cls) -> BalanceService:
         """Get BalanceService instance."""
         if 'balance' not in cls._instances:
             cls._instances['balance'] = BalanceService()
         return cls._instances['balance']
-    
+
     @classmethod
     def get_subscription_service(cls) -> SubscriptionService:
         """Get SubscriptionService instance."""
         if 'subscription' not in cls._instances:
             cls._instances['subscription'] = SubscriptionService()
         return cls._instances['subscription']
-    
+
     @classmethod
     def get_webhook_service(cls) -> WebhookService:
         """Get WebhookService instance."""
         if 'webhook' not in cls._instances:
             cls._instances['webhook'] = WebhookService()
         return cls._instances['webhook']
-    
+
     @classmethod
     def get_currency_service(cls) -> CurrencyService:
         """Get CurrencyService instance."""
         if 'currency' not in cls._instances:
             cls._instances['currency'] = CurrencyService()
         return cls._instances['currency']
-    
+
     @classmethod
     def get_all_services(cls) -> dict:
         """Get all service instances."""
@@ -137,13 +134,13 @@ class ServiceRegistry:
             'webhook': cls.get_webhook_service(),
             'currency': cls.get_currency_service(),
         }
-    
+
     @classmethod
     def health_check_all(cls) -> dict:
         """Perform health check on all services."""
         services = cls.get_all_services()
         results = {}
-        
+
         for name, service in services.items():
             try:
                 health_result = service.health_check()
@@ -158,22 +155,22 @@ class ServiceRegistry:
                     'message': f"Health check failed: {e}",
                     'data': {}
                 }
-        
+
         return results
-    
+
     @classmethod
     def clear_cache_all(cls):
         """Clear cache for all services."""
         for service in cls._instances.values():
             if hasattr(service, '_cache_clear'):
                 service._cache_clear()
-    
+
     @classmethod
     def get_stats_all(cls) -> dict:
         """Get statistics from all services."""
         services = cls.get_all_services()
         stats = {}
-        
+
         for name, service in services.items():
             try:
                 service_stats = service.get_service_stats()
@@ -183,7 +180,7 @@ class ServiceRegistry:
                     'error': str(e),
                     'service_name': service.__class__.__name__
                 }
-        
+
         return stats
 
 

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

@@ -4,7 +4,13 @@ Cache services for the Universal Payment System v2.0.
 Redis-backed caching with type safety and automatic key management.
 """
 
-from ..cache_service import CacheService, get_cache_service, SimpleCache, ApiKeyCache, RateLimitCache
+from ..cache_service import (
+    ApiKeyCache,
+    CacheService,
+    RateLimitCache,
+    SimpleCache,
+    get_cache_service,
+)
 
 __all__ = [
     'CacheService',

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

@@ -6,15 +6,17 @@ Based on proven solutions from payments_old with improvements.
 ONLY for API access control - NOT payment data!
 """
 
-from typing import Dict, Any
+from typing import Any, Dict
+
 from django.core.cache import cache
+
 from django_cfg.modules.django_logging import get_logger
 
-from .interfaces import CacheInterface
-from .simple_cache import SimpleCache
 from .api_key_cache import ApiKeyCache
-from .rate_limit_cache import RateLimitCache
+from .interfaces import CacheInterface
 from .keys import CacheKeys
+from .rate_limit_cache import RateLimitCache
+from .simple_cache import SimpleCache
 
 logger = get_logger(__name__)
 
@@ -25,7 +27,7 @@ class CacheService:
     
     Provides centralized access to different cache types.
     """
-    
+
     def __init__(self):
         """Initialize cache service with specialized caches."""
         self.simple_cache = SimpleCache()
@@ -34,24 +36,24 @@ class CacheService:
         # Backward compatibility attributes
         self.default_timeout = 300
         self.key_prefix = "payments"
-    
+
     # Backward compatibility methods - delegate to simple_cache
     def get(self, key: str):
         """Get value from cache."""
         return self.simple_cache.get(key)
-    
+
     def set(self, key: str, value, timeout=None):
         """Set value in cache."""
         return self.simple_cache.set(key, value, timeout)
-    
+
     def delete(self, key: str):
         """Delete value from cache."""
         return self.simple_cache.delete(key)
-    
+
     def exists(self, key: str):
         """Check if key exists in cache."""
         return self.simple_cache.exists(key)
-    
+
     def get_or_set(self, key: str, default, timeout=None):
         """Get value or set default if not exists."""
         value = self.get(key)
@@ -62,12 +64,12 @@ class CacheService:
                 value = default
             self.set(key, value, timeout)
         return value
-    
+
     def set_many(self, data: dict, timeout=None):
         """Set multiple values."""
         for key, value in data.items():
             self.set(key, value, timeout)
-    
+
     def get_many(self, keys: list):
         """Get multiple values."""
         result = {}
@@ -76,33 +78,33 @@ class CacheService:
             if value is not None:
                 result[key] = value
         return result
-    
+
     def delete_many(self, keys: list):
         """Delete multiple values."""
         for key in keys:
             self.delete(key)
-    
+
     def clear(self):
         """Clear all cache (not implemented for safety)."""
-        # For safety, we don't implement cache.clear() 
+        # For safety, we don't implement cache.clear()
         # as it would clear the entire cache backend
         # Instead, we clear Django's cache which is safe for tests
         from django.core.cache import cache
         cache.clear()
-    
+
     def health_check(self) -> Dict[str, Any]:
         """Check cache health."""
         try:
             test_key = "health_check"
             test_value = "ok"
-            
+
             # Test set/get/delete
             self.simple_cache.set(test_key, test_value, 10)
             retrieved = self.simple_cache.get(test_key)
             self.simple_cache.delete(test_key)
-            
+
             is_healthy = retrieved == test_value
-            
+
             return {
                 'healthy': is_healthy,
                 'backend': cache.__class__.__name__,
@@ -134,7 +136,7 @@ def get_cache_service() -> CacheService:
 # Export main classes for backward compatibility
 __all__ = [
     'CacheService',
-    'CacheInterface', 
+    'CacheInterface',
     'SimpleCache',
     'ApiKeyCache',
     'RateLimitCache',

django_cfg/apps/payments/services/cache_service/api_key_cache.py

@@ -5,16 +5,17 @@ Specialized caching for API key operations and validation.
 """
 
 from typing import Optional
+
 from .simple_cache import SimpleCache
 
 
 class ApiKeyCache:
     """Specialized cache for API key operations."""
-    
+
     def __init__(self):
         self.cache = SimpleCache("api_keys")
         self.default_timeout = self._get_cache_timeout('api_key')
-    
+
     def _get_cache_timeout(self, cache_type: str) -> int:
         """Get cache timeout from PaymentsConfig."""
         try:
@@ -23,15 +24,15 @@ class ApiKeyCache:
             return config.cache_timeouts.get(cache_type, 300)
         except Exception:
             return 300  # 5 minutes default
-    
+
     def get_api_key_data(self, api_key: str) -> Optional[dict]:
         """Get cached API key data."""
         return self.cache.get(f"key:{api_key}")
-    
+
     def cache_api_key_data(self, api_key: str, data: dict) -> bool:
         """Cache API key data."""
         return self.cache.set(f"key:{api_key}", data, self.default_timeout)
-    
+
     def invalidate_api_key(self, api_key: str) -> bool:
         """Invalidate cached API key."""
         return self.cache.delete(f"key:{api_key}")

django_cfg/apps/payments/services/cache_service/interfaces.py

@@ -5,27 +5,27 @@ Abstract interfaces for cache implementations.
 """
 
 from abc import ABC, abstractmethod
-from typing import Optional, Any
+from typing import Any, Optional
 
 
 class CacheInterface(ABC):
     """Abstract cache interface."""
-    
+
     @abstractmethod
     def get(self, key: str) -> Optional[Any]:
         """Get value from cache."""
         pass
-    
+
     @abstractmethod
     def set(self, key: str, value: Any, timeout: Optional[int] = None) -> bool:
         """Set value in cache."""
         pass
-    
+
     @abstractmethod
     def delete(self, key: str) -> bool:
         """Delete value from cache."""
         pass
-    
+
     @abstractmethod
     def exists(self, key: str) -> bool:
         """Check if key exists in cache."""

django_cfg/apps/payments/services/cache_service/keys.py

@@ -7,42 +7,42 @@ Centralized cache key generation for consistency and testing.
 
 class CacheKeys:
     """Cache key generation utilities."""
-    
+
     @staticmethod
     def user_balance(user_id: int) -> str:
         """Generate cache key for user balance."""
         return f"payments:user_balance:{user_id}"
-    
+
     @staticmethod
     def payment(payment_id: str) -> str:
         """Generate cache key for payment data."""
         return f"payments:payment:{payment_id}"
-    
+
     @staticmethod
     def payment_status(payment_id: str) -> str:
         """Generate cache key for payment status."""
         return f"payments:payment_status:{payment_id}"
-    
+
     @staticmethod
     def currency_rates(from_currency: str, to_currency: str) -> str:
         """Generate cache key for currency exchange rates."""
         return f"payments:currency_rates:{from_currency}:{to_currency}"
-    
+
     @staticmethod
     def provider_currencies(provider: str) -> str:
         """Generate cache key for provider supported currencies."""
         return f"payments:provider_currencies:{provider}"
-    
+
     @staticmethod
     def api_key_validation(api_key: str) -> str:
         """Generate cache key for API key validation data."""
         return f"payments:api_key_validation:{api_key}"
-    
+
     @staticmethod
     def user_subscription(user_id: int) -> str:
         """Generate cache key for user subscription data."""
         return f"payments:user_subscription:{user_id}"
-    
+
     @staticmethod
     def rate_limit(user_id: int, action: str) -> str:
         """Generate cache key for rate limiting."""

django_cfg/apps/payments/services/cache_service/rate_limit_cache.py

@@ -5,29 +5,30 @@ Specialized caching for API rate limiting and usage tracking.
 """
 
 from typing import Optional
+
 from .simple_cache import SimpleCache
 
 
 class RateLimitCache:
     """Specialized cache for rate limiting."""
-    
+
     def __init__(self):
         self.cache = SimpleCache("rate_limit")
-    
+
     def get_usage_count(self, user_id: int, endpoint_group: str, window: str = "hour") -> int:
         """Get current usage count for rate limiting."""
         key = f"usage:{user_id}:{endpoint_group}:{window}"
         count = self.cache.get(key)
         return count if count is not None else 0
-    
+
     def increment_usage(self, user_id: int, endpoint_group: str, window: str = "hour", ttl: Optional[int] = None) -> int:
         """Increment usage count and return new count."""
         key = f"usage:{user_id}:{endpoint_group}:{window}"
-        
+
         # Get current count
         current = self.get_usage_count(user_id, endpoint_group, window)
         new_count = current + 1
-        
+
         # Get TTL from config or use defaults
         if ttl is None:
             try:
@@ -36,11 +37,11 @@ class RateLimitCache:
                 ttl = config.cache_timeouts.get('rate_limit', 3600)
             except Exception:
                 ttl = 3600 if window == "hour" else 86400  # 1 hour or 1 day
-        
+
         # Set new count with TTL
         self.cache.set(key, new_count, ttl)
         return new_count
-    
+
     def reset_usage(self, user_id: int, endpoint_group: str, window: str = "hour") -> bool:
         """Reset usage count."""
         key = f"usage:{user_id}:{endpoint_group}:{window}"

django_cfg/apps/payments/services/cache_service/simple_cache.py

@@ -4,8 +4,10 @@ Simple cache implementation for the Universal Payment System v2.0.
 Basic cache functionality with graceful fallback.
 """
 
-from typing import Optional, Any
+from typing import Any, Optional
+
 from django.core.cache import cache
+
 from django_cfg.modules.django_logging import get_logger
 
 from .interfaces import CacheInterface
@@ -20,16 +22,17 @@ class SimpleCache(CacheInterface):
     Falls back gracefully when cache is unavailable.
     Based on proven solution from payments_old.
     """
-    
+
     def __init__(self, prefix: str = "payments"):
         self.prefix = prefix
         self.enabled = self._is_cache_enabled()
-    
+
     def _is_cache_enabled(self) -> bool:
         """Check if cache is enabled via PaymentsConfig."""
-        from django.conf import settings
-        import sys
         import os
+        import sys
+
+        from django.conf import settings
 
         # For tests, always enable cache (detect test environment)
         # Check multiple ways to detect test environment
@@ -50,28 +53,28 @@ class SimpleCache(CacheInterface):
         except Exception as e:
             logger.debug(f"PaymentsConfig not available, enabling cache by default: {e}")
             return True  # Default to enabled with graceful fallback
-        
+
     def _make_key(self, key: str) -> str:
         """Create prefixed cache key."""
         return f"{self.prefix}:{key}"
-    
+
     def get(self, key: str) -> Optional[Any]:
         """Get value from cache."""
         if not self.enabled:
             return None
-            
+
         try:
             cache_key = self._make_key(key)
             return cache.get(cache_key)
         except Exception as e:
             logger.warning(f"Cache get failed for key {key}: {e}")
             return None
-    
+
     def set(self, key: str, value: Any, timeout: Optional[int] = None) -> bool:
         """Set value in cache."""
         if not self.enabled:
             return False
-            
+
         try:
             cache_key = self._make_key(key)
             cache.set(cache_key, value, timeout)
@@ -79,12 +82,12 @@ class SimpleCache(CacheInterface):
         except Exception as e:
             logger.warning(f"Cache set failed for key {key}: {e}")
             return False
-    
+
     def delete(self, key: str) -> bool:
         """Delete value from cache."""
         if not self.enabled:
             return False
-            
+
         try:
             cache_key = self._make_key(key)
             cache.delete(cache_key)
@@ -92,12 +95,12 @@ class SimpleCache(CacheInterface):
         except Exception as e:
             logger.warning(f"Cache delete failed for key {key}: {e}")
             return False
-    
+
     def exists(self, key: str) -> bool:
         """Check if key exists in cache."""
         if not self.enabled:
             return False
-            
+
         try:
             cache_key = self._make_key(key)
             return cache.get(cache_key) is not None

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

@@ -4,17 +4,17 @@ Core services for the Universal Payment System v2.0.
 Business logic services with Pydantic validation.
 """
 
+from .balance_service import BalanceService
 from .base import BaseService
+from .currency_service import CurrencyService
 from .payment_service import PaymentService
-from .balance_service import BalanceService
 from .subscription_service import SubscriptionService
-from .currency_service import CurrencyService
 from .webhook_service import WebhookService
 
 __all__ = [
     'BaseService',
     'PaymentService',
-    'BalanceService', 
+    'BalanceService',
     'SubscriptionService',
     'CurrencyService',
     'WebhookService',