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

django_cfg/__init__.py

@@ -32,7 +32,7 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.2.23"
+__version__ = "1.2.27"
 __license__ = "MIT"
 
 # Import registry for organized lazy loading

django_cfg/apps/knowbase/tasks/archive_tasks.py

@@ -23,7 +23,7 @@ User = get_user_model()
 
 
 @dramatiq.actor(
-    queue_name="knowledge",
+    queue_name="knowbase",
     max_retries=3,
     min_backoff=1000,  # 1 second
     max_backoff=30000,  # 30 seconds
@@ -96,7 +96,7 @@ def process_archive_task(archive_id: str, user_id: str) -> bool:
 
 
 @dramatiq.actor(
-    queue_name="knowledge",
+    queue_name="knowbase",
     max_retries=2,
     min_backoff=2000,  # 2 seconds
     max_backoff=60000,  # 60 seconds
@@ -154,7 +154,7 @@ def vectorize_archive_items_task(archive_id: str, user_id: str) -> int:
 
 
 @dramatiq.actor(
-    queue_name="knowledge",
+    queue_name="knowbase",
     max_retries=1,
     priority=2
 )
@@ -193,7 +193,7 @@ def cleanup_failed_archives_task(days_old: int = 7) -> int:
 
 
 @dramatiq.actor(
-    queue_name="knowledge",
+    queue_name="knowbase",
     max_retries=1,
     priority=1
 )
@@ -239,7 +239,7 @@ def generate_archive_statistics_task(user_id: str) -> Dict[str, Any]:
 
 
 @dramatiq.actor(
-    queue_name="knowledge",
+    queue_name="knowbase",
     max_retries=1,
     priority=1
 )
@@ -297,7 +297,7 @@ def archive_health_check_task() -> Dict[str, Any]:
 
 # Test task for development
 @dramatiq.actor(
-    queue_name="knowledge",
+    queue_name="knowbase",
     max_retries=0,
     priority=1
 )

django_cfg/apps/knowbase/tasks/document_processing.py

@@ -20,7 +20,7 @@ logger = logging.getLogger(__name__)
 
 
 @dramatiq.actor(
-    queue_name="knowledge",
+    queue_name="knowbase",
     max_retries=3,
     min_backoff=1000,  # 1 second
     max_backoff=30000,  # 30 seconds
@@ -239,7 +239,7 @@ def generate_embeddings_batch(
 
 
 @dramatiq.actor(
-    queue_name="knowledge",
+    queue_name="knowbase",
     max_retries=2,
     priority=7  # Higher priority for reprocessing
 )
@@ -291,7 +291,7 @@ def reprocess_document_chunks(
 
 
 @dramatiq.actor(
-    queue_name="knowledge",
+    queue_name="knowbase",
     max_retries=2,
     priority=4
 )

django_cfg/apps/knowbase/tasks/external_data_tasks.py

@@ -16,7 +16,7 @@ logger = logging.getLogger(__name__)
 
 
 @dramatiq.actor(
-    queue_name="knowledge",
+    queue_name="knowbase",
     max_retries=3,
     min_backoff=1000,  # 1 second
     max_backoff=30000,  # 30 seconds
@@ -158,7 +158,7 @@ def process_external_data_async(
 
 
 @dramatiq.actor(
-    queue_name="knowledge",
+    queue_name="knowbase",
     max_retries=2,
     min_backoff=5000,  # 5 seconds
     max_backoff=60000,  # 60 seconds

django_cfg/apps/knowbase/tasks/maintenance.py

@@ -18,7 +18,7 @@ logger = logging.getLogger(__name__)
 
 
 @dramatiq.actor(
-    queue_name="knowledge",
+    queue_name="knowbase",
     max_retries=1,
     priority=2
 )
@@ -72,7 +72,7 @@ def cleanup_old_embeddings(days_old: int = 90) -> Dict[str, Any]:
 
 
 @dramatiq.actor(
-    queue_name="knowledge",
+    queue_name="knowbase",
     max_retries=1,
     priority=1
 )
@@ -119,7 +119,7 @@ def optimize_vector_indexes() -> Dict[str, Any]:
 
 
 @dramatiq.actor(
-    queue_name="knowledge",
+    queue_name="knowbase",
     max_retries=1,
     priority=1
 )

django_cfg/apps/payments/config/__init__.py

@@ -5,25 +5,27 @@ Modular configuration system for the payments module.
 """
 
 # Core configuration classes
-from .settings import (
-    PaymentsSettings,
+from .settings import PaymentsSettings
+
+# Import unified settings from models.payments
+from django_cfg.models.payments import (
     SecuritySettings,
     RateLimitSettings,
-    BillingSettings,
-    CacheSettings,
-    NotificationSettings
+    NotificationSettings,
+    SubscriptionSettings
 )
 
-# Provider configurations
-from .providers import (
+# Provider configurations - import from models.payments
+from django_cfg.models.payments import (
     PaymentProviderConfig,
     NowPaymentsConfig,
     StripeConfig,
-    CryptAPIConfig,
-    get_provider_config_class,
-    PROVIDER_CONFIGS
+    CryptAPIConfig
 )
 
+# Local provider configs (additional to models.payments)
+from .providers import CryptomusConfig
+
 # Configuration module
 from .module import PaymentsCfgModule
 
@@ -31,18 +33,7 @@ from .module import PaymentsCfgModule
 from .utils import (
     get_payments_config,
     get_provider_config,
-    get_nowpayments_config,
-    get_stripe_config,
-    is_payments_enabled,
-    is_feature_enabled,
-    get_enabled_providers,
-    get_provider_settings,
-    validate_provider_config,
-    get_rate_limit_settings,
-    get_cache_settings,
-    get_billing_settings,
-    reset_config_cache,
-    reload_config
+    is_payments_enabled
 )
 
 # Backwards compatibility exports
@@ -53,17 +44,15 @@ __all__ = [
     'PaymentsSettings',
     'SecuritySettings',
     'RateLimitSettings',
-    'BillingSettings',
-    'CacheSettings',
     'NotificationSettings',
+    'SubscriptionSettings',
     
     # Provider configurations
     'PaymentProviderConfig',
     'NowPaymentsConfig',
     'StripeConfig',
     'CryptAPIConfig',
-    'get_provider_config_class',
-    'PROVIDER_CONFIGS',
+    'CryptomusConfig',
     
     # Configuration module
     'PaymentsCfgModule',
@@ -72,16 +61,5 @@ __all__ = [
     # Utility functions
     'get_payments_config',
     'get_provider_config',
-    'get_nowpayments_config',
-    'get_stripe_config',
     'is_payments_enabled',
-    'is_feature_enabled',
-    'get_enabled_providers',
-    'get_provider_settings',
-    'validate_provider_config',
-    'get_rate_limit_settings',
-    'get_cache_settings',
-    'get_billing_settings',
-    'reset_config_cache',
-    'reload_config',
 ]

django_cfg/apps/payments/config/module.py

@@ -5,12 +5,10 @@ Handles loading and managing payment configurations from project settings.
 """
 
 from typing import Optional
-from pydantic import SecretStr
 import logging
 
 from django_cfg.modules.base import BaseCfgModule
 from .settings import PaymentsSettings
-from .providers import NowPaymentsConfig, StripeConfig, CryptAPIConfig, get_provider_config_class
 
 logger = logging.getLogger(__name__)
 
@@ -39,124 +37,34 @@ class PaymentsCfgModule(BaseCfgModule):
     
     def load_from_project_config(self, config) -> PaymentsSettings:
         """Load payments configuration from main project config."""
-        # Get base settings
-        settings_dict = {}
         
-        # Load from django-cfg config if available
-        if hasattr(config, 'enable_payments'):
-            settings_dict['enabled'] = config.enable_payments
-        
-        if hasattr(config, 'debug'):
-            settings_dict['debug_mode'] = config.debug
-        
-        # Load provider configurations from environment/config
-        providers = {}
-        
-        # Load NowPayments configuration
-        if self._has_provider_config(config, 'nowpayments'):
-            nowpayments_config = self._get_provider_config(config, 'nowpayments')
-            if nowpayments_config:
-                providers['nowpayments'] = nowpayments_config
-        
-        # Load Stripe configuration
-        if self._has_provider_config(config, 'stripe'):
-            stripe_config = self._get_provider_config(config, 'stripe')
-            if stripe_config:
-                providers['stripe'] = stripe_config
-        
-        # Load CryptAPI configuration
-        if self._has_provider_config(config, 'cryptapi'):
-            cryptapi_config = self._get_provider_config(config, 'cryptapi')
-            if cryptapi_config:
-                providers['cryptapi'] = cryptapi_config
-        
-        
-        settings_dict['providers'] = providers
-        
-        return PaymentsSettings(**settings_dict)
-    
-    def _has_provider_config(self, config, provider_name: str) -> bool:
-        """Check if provider configuration exists."""
-        return (
-            hasattr(config, 'api_keys') and 
-            hasattr(config.api_keys, provider_name)
-        )
-    
-    def _get_provider_config(self, config, provider_name: str) -> Optional[object]:
-        """Get provider configuration."""
-        try:
-            if provider_name == 'nowpayments':
-                return self._load_nowpayments_config(config)
-            elif provider_name == 'stripe':
-                return self._load_stripe_config(config)
-            elif provider_name == 'cryptapi':
-                return self._load_cryptapi_config(config)
-            else:
-                logger.warning(f"Unknown provider: {provider_name}")
-                return None
-        except Exception as e:
-            logger.error(f"Error loading {provider_name} config: {e}")
-            return None
-    
-    def _load_nowpayments_config(self, config) -> Optional[NowPaymentsConfig]:
-        """Load NowPayments configuration."""
-        nowpayments_config = config.api_keys.nowpayments
-        if not hasattr(nowpayments_config, 'api_key'):
-            return None
-        
-        return NowPaymentsConfig(
-            api_key=SecretStr(nowpayments_config.api_key),
-            public_key=SecretStr(nowpayments_config.public_key) if hasattr(nowpayments_config, 'public_key') else None,
-            sandbox=getattr(config, 'debug', True),
-            callback_url=self._build_callback_url(config, 'nowpayments'),
-            success_url=self._build_success_url(config),
-            cancel_url=self._build_cancel_url(config)
-        )
-    
-    def _load_stripe_config(self, config) -> Optional[StripeConfig]:
-        """Load Stripe configuration."""
-        stripe_config = config.api_keys.stripe
-        if not hasattr(stripe_config, 'secret_key'):
-            return None
-        
-        return StripeConfig(
-            api_key=SecretStr(stripe_config.secret_key),
-            publishable_key=SecretStr(stripe_config.publishable_key) if hasattr(stripe_config, 'publishable_key') else None,
-            webhook_secret=SecretStr(stripe_config.webhook_secret) if hasattr(stripe_config, 'webhook_secret') else None,
-            sandbox=getattr(config, 'debug', True)
-        )
-    
-    def _load_cryptapi_config(self, config) -> Optional[CryptAPIConfig]:
-        """Load CryptAPI configuration."""
-        cryptapi_config = config.api_keys.cryptapi
-        if not hasattr(cryptapi_config, 'own_address'):
-            return None
-        
-        return CryptAPIConfig(
-            api_key=SecretStr('dummy'),  # CryptAPI doesn't require API key
-            own_address=cryptapi_config.own_address,
-            callback_url=self._build_callback_url(config, 'cryptapi'),
-            convert_payments=getattr(cryptapi_config, 'convert_payments', True),
-            multi_token=getattr(cryptapi_config, 'multi_token', True),
-            priority=getattr(cryptapi_config, 'priority', 'default'),
-            sandbox=getattr(config, 'debug', True)
-        )
-    
-    
-    def _build_callback_url(self, config, provider: str) -> Optional[str]:
-        """Build webhook callback URL for provider."""
-        if hasattr(config, 'api_url') and config.api_url:
-            return f"{config.api_url}/api/payments/webhook/{provider}/"
-        return None
-    
-    def _build_success_url(self, config) -> Optional[str]:
-        """Build payment success URL."""
-        if hasattr(config, 'site_url') and config.site_url:
-            return f"{config.site_url}/payments/success/"
-        return None
-    
-    def _build_cancel_url(self, config) -> Optional[str]:
-        """Build payment cancel URL."""
-        if hasattr(config, 'site_url') and config.site_url:
-            return f"{config.site_url}/payments/cancel/"
-        return None
+        # Load from new PaymentsConfig if available
+        if hasattr(config, 'payments') and config.payments:
+            # Convert List[PaymentProviderConfig] to Dict[str, PaymentProviderConfig]
+            providers = {}
+            for provider in config.payments.providers:
+                providers[provider.name] = provider
+            
+            return PaymentsSettings(
+                enabled=config.payments.enabled,
+                debug_mode=getattr(config, 'debug', False),
+                providers=providers,
+                security=config.payments.security,
+                rate_limits=config.payments.rate_limits,
+                notifications=config.payments.notifications,
+                subscriptions=config.payments.subscriptions,
+                enable_crypto_payments=config.payments.enable_crypto_payments,
+                enable_fiat_payments=config.payments.enable_fiat_payments,
+                enable_subscription_system=config.payments.enable_subscription_system,
+                enable_balance_system=config.payments.enable_balance_system,
+                enable_api_key_system=config.payments.enable_api_key_system,
+                enable_webhook_processing=config.payments.enable_webhook_processing,
+                enable_billing_utils=config.payments.enable_billing_utils
+            )
+        else:
+            # Fallback: Return default settings if no PaymentsConfig found
+            logger.warning("No PaymentsConfig found, using default settings")
+            return PaymentsSettings(
+                enabled=False,
+                debug_mode=getattr(config, 'debug', False)
+            )

django_cfg/apps/payments/config/providers.py

@@ -7,23 +7,13 @@ Defines configuration classes for different payment providers.
 from typing import Dict, Any, Optional
 from pydantic import BaseModel, Field, SecretStr
 
+# Import the base PaymentProviderConfig from models.payments
+from django_cfg.models.payments import PaymentProviderConfig as BasePaymentProviderConfig
 
-class PaymentProviderConfig(BaseModel):
-    """Base configuration for payment providers."""
-    enabled: bool = True
-    sandbox: bool = Field(default=True, description="Use sandbox mode")
-    api_key: SecretStr = Field(description="Provider API key")
-    timeout: int = Field(default=30, description="Request timeout in seconds")
-    max_retries: int = Field(default=3, description="Maximum retry attempts")
-    
-    def get_config_dict(self) -> Dict[str, Any]:
-        """Get configuration as dictionary for provider initialization."""
-        return {
-            'api_key': self.api_key.get_secret_value(),
-            'sandbox': self.sandbox,
-            'timeout': self.timeout,
-            'max_retries': self.max_retries
-        }
+
+class PaymentProviderConfig(BasePaymentProviderConfig):
+    """Extended base configuration for payment providers."""
+    pass
 
 
 class NowPaymentsConfig(PaymentProviderConfig):
@@ -80,11 +70,33 @@ class CryptAPIConfig(PaymentProviderConfig):
         return config
 
 
+class CryptomusConfig(PaymentProviderConfig):
+    """Cryptomus provider configuration."""
+    merchant_uuid: str = Field(description="Cryptomus merchant UUID")
+    callback_url: Optional[str] = Field(default=None, description="Webhook callback URL")
+    success_url: Optional[str] = Field(default=None, description="Payment success URL")
+    fail_url: Optional[str] = Field(default=None, description="Payment fail URL")
+    network: Optional[str] = Field(default=None, description="Default network for payments")
+    
+    def get_config_dict(self) -> Dict[str, Any]:
+        """Get configuration as dictionary for provider initialization."""
+        config = super().get_config_dict()
+        config.update({
+            'merchant_uuid': self.merchant_uuid,
+            'callback_url': self.callback_url,
+            'success_url': self.success_url,
+            'fail_url': self.fail_url,
+            'network': self.network,
+        })
+        return config
+
+
 # Provider registry for easy access
 PROVIDER_CONFIGS = {
     'nowpayments': NowPaymentsConfig,
     'stripe': StripeConfig,
     'cryptapi': CryptAPIConfig,
+    'cryptomus': CryptomusConfig,
 }
 
 

django_cfg/apps/payments/config/settings.py

@@ -1,83 +1,49 @@
 """
 Universal payments module settings.
 
-Core settings for the payments system including security, rate limiting, billing, etc.
+Core settings for the payments system - now using unified models from django_cfg.models.payments.
 """
 
-from typing import Dict
+from typing import Dict, List
 from pydantic import BaseModel, Field
 
-from .providers import PaymentProviderConfig
-
-
-class SecuritySettings(BaseModel):
-    """Security-related payment settings."""
-    api_key_length: int = Field(default=32, description="API key length in characters")
-    api_key_prefix: str = Field(default="ak_", description="API key prefix")
-    min_balance_threshold: float = Field(default=0.0, description="Minimum balance threshold")
-    auto_create_api_keys: bool = Field(default=True, description="Auto-create API keys for new users")
-
-
-class RateLimitSettings(BaseModel):
-    """Rate limiting settings."""
-    default_rate_limit_per_hour: int = Field(default=1000, description="Default API rate limit per hour")
-    default_rate_limit_per_day: int = Field(default=10000, description="Default API rate limit per day")
-    burst_limit_multiplier: float = Field(default=2.0, description="Burst limit multiplier")
-    sliding_window_size: int = Field(default=3600, description="Sliding window size in seconds")
-
-
-class BillingSettings(BaseModel):
-    """Billing and subscription settings."""
-    auto_bill_subscriptions: bool = Field(default=True, description="Automatically bill subscriptions")
-    billing_grace_period_hours: int = Field(default=24, description="Grace period for failed billing")
-    retry_failed_payments: bool = Field(default=True, description="Retry failed payments")
-    max_payment_retries: int = Field(default=3, description="Maximum payment retry attempts")
-    min_payment_amount_usd: float = Field(default=1.0, description="Minimum payment amount in USD")
-    max_payment_amount_usd: float = Field(default=50000.0, description="Maximum payment amount in USD")
-
-
-class CacheSettings(BaseModel):
-    """Cache timeout settings."""
-    cache_timeout_access_check: int = Field(default=60, description="Cache timeout for access checks (seconds)")
-    cache_timeout_user_balance: int = Field(default=300, description="Cache timeout for user balance (seconds)")
-    cache_timeout_subscriptions: int = Field(default=600, description="Cache timeout for subscriptions (seconds)")
-    cache_timeout_provider_status: int = Field(default=1800, description="Cache timeout for provider status (seconds)")
-    cache_timeout_currency_rates: int = Field(default=3600, description="Cache timeout for currency rates (seconds)")
-
-
-class NotificationSettings(BaseModel):
-    """Notification settings."""
-    send_payment_confirmations: bool = Field(default=True, description="Send payment confirmation emails")
-    send_subscription_renewals: bool = Field(default=True, description="Send subscription renewal notifications")
-    send_balance_alerts: bool = Field(default=True, description="Send low balance alerts")
-    send_api_key_alerts: bool = Field(default=True, description="Send API key security alerts")
-    webhook_timeout: int = Field(default=30, description="Webhook timeout in seconds")
+# Import unified types from models/payments.py
+from django_cfg.models.payments import (
+    PaymentProviderConfig, 
+    SecuritySettings, 
+    RateLimitSettings, 
+    NotificationSettings,
+    SubscriptionSettings
+)
 
 
 class PaymentsSettings(BaseModel):
-    """Universal payments module settings."""
+    """Universal payments module settings - unified with PaymentsConfig."""
     
     # General settings
     enabled: bool = Field(default=True, description="Enable payments module")
     debug_mode: bool = Field(default=False, description="Enable debug mode for payments")
     
-    # Component settings
+    # Component settings - using unified models
     security: SecuritySettings = Field(default_factory=SecuritySettings)
     rate_limits: RateLimitSettings = Field(default_factory=RateLimitSettings)
-    billing: BillingSettings = Field(default_factory=BillingSettings)
-    cache: CacheSettings = Field(default_factory=CacheSettings)
     notifications: NotificationSettings = Field(default_factory=NotificationSettings)
+    subscriptions: SubscriptionSettings = Field(default_factory=SubscriptionSettings)
     
-    # Provider configurations
-    providers: Dict[str, PaymentProviderConfig] = Field(default_factory=dict, description="Payment provider configurations")
+    # Provider configurations - now accepts List instead of Dict
+    providers: Dict[str, PaymentProviderConfig] = Field(
+        default_factory=dict, 
+        description="Payment provider configurations (Dict for backwards compatibility)"
+    )
     
-    # Feature flags
+    # Feature flags - copied from PaymentsConfig for consistency
     enable_crypto_payments: bool = Field(default=True, description="Enable cryptocurrency payments")
     enable_fiat_payments: bool = Field(default=True, description="Enable fiat currency payments")
     enable_subscription_system: bool = Field(default=True, description="Enable subscription system")
     enable_balance_system: bool = Field(default=True, description="Enable user balance system")
     enable_api_key_system: bool = Field(default=True, description="Enable API key system")
     enable_webhook_processing: bool = Field(default=True, description="Enable webhook processing")
+    enable_billing_utils: bool = Field(default=True, description="Enable billing utility functions")
     
     # Backwards compatibility properties
     @property
@@ -86,51 +52,45 @@ class PaymentsSettings(BaseModel):
         return self.security.auto_create_api_keys
     
     @property
-    def min_balance_threshold(self) -> float:
-        """Backwards compatibility for min_balance_threshold."""
-        return self.security.min_balance_threshold
+    def require_api_key(self) -> bool:
+        """Backwards compatibility for require_api_key."""
+        return self.security.require_api_key
     
     @property
-    def default_rate_limit_per_hour(self) -> int:
-        """Backwards compatibility for default_rate_limit_per_hour."""
-        return self.rate_limits.default_rate_limit_per_hour
-    
-    @property
-    def default_rate_limit_per_day(self) -> int:
-        """Backwards compatibility for default_rate_limit_per_day."""
-        return self.rate_limits.default_rate_limit_per_day
-    
-    @property
-    def api_key_length(self) -> int:
-        """Backwards compatibility for api_key_length."""
-        return self.security.api_key_length
-    
-    @property
-    def api_key_prefix(self) -> str:
-        """Backwards compatibility for api_key_prefix."""
-        return self.security.api_key_prefix
+    def min_balance_threshold(self) -> float:
+        """Backwards compatibility for min_balance_threshold."""
+        return float(self.security.min_balance_threshold)
     
     @property
-    def auto_bill_subscriptions(self) -> bool:
-        """Backwards compatibility for auto_bill_subscriptions."""
-        return self.billing.auto_bill_subscriptions
+    def requests_per_hour(self) -> int:
+        """Backwards compatibility for requests_per_hour."""
+        return self.rate_limits.requests_per_hour
     
     @property
-    def billing_grace_period_hours(self) -> int:
-        """Backwards compatibility for billing_grace_period_hours."""
-        return self.billing.billing_grace_period_hours
+    def webhook_timeout(self) -> int:
+        """Backwards compatibility for webhook_timeout."""
+        return self.notifications.webhook_timeout
     
-    @property
-    def cache_timeout_access_check(self) -> int:
-        """Backwards compatibility for cache_timeout_access_check."""
-        return self.cache.cache_timeout_access_check
+    # Utility methods
+    def is_provider_enabled(self, provider_name: str) -> bool:
+        """Check if a specific provider is enabled."""
+        provider = self.providers.get(provider_name)
+        return provider and provider.enabled if provider else False
     
-    @property
-    def cache_timeout_user_balance(self) -> int:
-        """Backwards compatibility for cache_timeout_user_balance."""
-        return self.cache.cache_timeout_user_balance
+    def get_enabled_providers(self) -> List[str]:
+        """Get list of enabled provider names."""
+        return [name for name, config in self.providers.items() if config.enabled]
     
-    @property
-    def cache_timeout_subscriptions(self) -> int:
-        """Backwards compatibility for cache_timeout_subscriptions."""
-        return self.cache.cache_timeout_subscriptions
+    def get_provider_config(self, provider_name: str) -> PaymentProviderConfig:
+        """Get configuration for a specific provider."""
+        return self.providers.get(provider_name)
+
+
+__all__ = [
+    'PaymentsSettings',
+    'SecuritySettings',
+    'RateLimitSettings', 
+    'NotificationSettings',
+    'SubscriptionSettings',
+    'PaymentProviderConfig'
+]