django-cfg 1.3.13__py3-none-any.whl → 1.4.3__py3-none-any.whl

django_cfg/models/{logging.py → infrastructure/logging.py}

@@ -7,7 +7,7 @@ Django logging settings with Pydantic 2.
 from typing import Dict, Any, List, Optional
 from pathlib import Path
 from pydantic import Field, field_validator
-from .base import BaseConfig
+from ..base import BaseConfig
 
 
 class LoggerConfig(BaseConfig):

django_cfg/models/{security.py → infrastructure/security.py}

@@ -6,7 +6,7 @@ Django security settings with Pydantic 2.
 
 from typing import List, Dict, Any
 from pydantic import Field, field_validator
-from .base import BaseConfig
+from ..base import BaseConfig
 
 
 class SecurityConfig(BaseConfig):
@@ -103,7 +103,7 @@ class SecurityConfig(BaseConfig):
             })
             
             # Add corsheaders to middleware if not present
-            # This will be handled by the main ConfigToolkit
+            # This will be handled by the main DjangoConfig
         
         # CSRF settings
         settings.update({

django_cfg/models/ngrok/__init__.py

@@ -0,0 +1,11 @@
+"""
+Ngrok configuration models.
+
+Simplified flat configuration without unnecessary nesting.
+"""
+
+from .config import NgrokConfig
+
+__all__ = [
+    "NgrokConfig",
+]

django_cfg/models/ngrok/auth.py

@@ -0,0 +1,37 @@
+"""
+Ngrok authentication configuration.
+"""
+
+from typing import Optional
+from pydantic import BaseModel, Field
+import os
+
+
+class NgrokAuthConfig(BaseModel):
+    """Ngrok authentication configuration."""
+
+    authtoken: Optional[str] = Field(
+        default=None,
+        description="Ngrok auth token (loaded from NGROK_AUTHTOKEN env var if not provided)",
+        repr=False  # Don't show in repr for security
+    )
+
+    authtoken_from_env: bool = Field(
+        default=True,  # Try to load from env var by default
+        description="Load auth token from NGROK_AUTHTOKEN environment variable"
+    )
+
+    def get_authtoken(self) -> Optional[str]:
+        """Get auth token from config or environment."""
+        if self.authtoken:
+            return self.authtoken
+
+        if self.authtoken_from_env:
+            return os.environ.get("NGROK_AUTHTOKEN")
+
+        return None
+
+
+__all__ = [
+    "NgrokAuthConfig",
+]

django_cfg/models/ngrok/config.py

@@ -0,0 +1,77 @@
+"""
+Main ngrok configuration for django_cfg.
+
+Simplified flat structure - only essential fields.
+Domain and schemes are auto-determined from api_url in config.
+"""
+
+from typing import Optional, List
+from pydantic import BaseModel, Field, field_validator
+import os
+
+
+class NgrokConfig(BaseModel):
+    """Simplified flat ngrok configuration for django-cfg.
+
+    Key simplifications:
+    - No domain field (uses api_url from DjangoConfig automatically)
+    - No schemes field (auto-determined from api_url: http:// -> http, https:// -> https)
+    - Flat structure (no nested NgrokAuthConfig/NgrokTunnelConfig)
+    """
+
+    model_config = {
+        "str_strip_whitespace": True,
+        "validate_assignment": True,
+        "extra": "forbid"
+    }
+
+    # Control
+    enabled: bool = Field(
+        default=False,
+        description="Enable ngrok integration (only works in DEBUG mode)"
+    )
+
+    # Authentication
+    authtoken: Optional[str] = Field(
+        default=None,
+        description="Ngrok auth token. If None, will try NGROK_AUTHTOKEN env var",
+        repr=False  # Don't show in repr for security
+    )
+
+    # Optional tunnel features
+    basic_auth: Optional[List[str]] = Field(
+        default=None,
+        description="Basic auth credentials in format ['user:pass']"
+    )
+
+    compression: bool = Field(
+        default=True,
+        description="Enable gzip compression"
+    )
+
+    @field_validator("enabled")
+    @classmethod
+    def validate_enabled_in_debug_only(cls, v: bool) -> bool:
+        """Ensure ngrok is only enabled in debug mode."""
+        if v:
+            # Only check if Django is available and fully configured
+            try:
+                from django.conf import settings
+                # Only validate if settings are configured and DEBUG attribute exists
+                if settings.configured and hasattr(settings, 'DEBUG') and not settings.DEBUG:
+                    raise ValueError("Ngrok can only be enabled in DEBUG mode")
+            except (ImportError, AttributeError, RuntimeError):
+                # Django not available, not configured, or settings not ready - skip validation
+                pass
+        return v
+
+    def get_authtoken(self) -> Optional[str]:
+        """Get auth token from config or environment."""
+        if self.authtoken:
+            return self.authtoken
+        return os.environ.get("NGROK_AUTHTOKEN")
+
+
+__all__ = [
+    "NgrokConfig",
+]

django_cfg/models/ngrok/tunnel.py

@@ -0,0 +1,35 @@
+"""
+Ngrok tunnel configuration.
+"""
+
+from typing import Optional, List, Literal
+from pydantic import BaseModel, Field
+
+
+class NgrokTunnelConfig(BaseModel):
+    """Configuration for ngrok tunnel."""
+
+    domain: Optional[str] = Field(
+        default=None,
+        description="Custom domain for tunnel (requires paid ngrok plan)"
+    )
+
+    schemes: List[Literal["http", "https"]] = Field(
+        default_factory=lambda: ["http", "https"],
+        description="URL schemes to tunnel"
+    )
+
+    basic_auth: Optional[List[str]] = Field(
+        default=None,
+        description="Basic auth credentials in format ['user:pass']"
+    )
+
+    compression: bool = Field(
+        default=True,
+        description="Enable gzip compression"
+    )
+
+
+__all__ = [
+    "NgrokTunnelConfig",
+]

django_cfg/models/payments/__init__.py

@@ -0,0 +1,20 @@
+"""
+Payment configuration models for django_cfg.
+
+Provides type-safe configuration for payment providers and API keys:
+- PaymentsConfig: Main payments configuration
+- ProviderAPIKeysConfig: API keys management
+- BaseProviderConfig: Base provider configuration
+- NowPaymentsProviderConfig: NowPayments provider
+"""
+
+from .config import PaymentsConfig
+from .api_keys import ProviderAPIKeysConfig
+from .providers import BaseProviderConfig, NowPaymentsProviderConfig
+
+__all__ = [
+    "PaymentsConfig",
+    "ProviderAPIKeysConfig",
+    "BaseProviderConfig",
+    "NowPaymentsProviderConfig",
+]

django_cfg/models/payments/api_keys.py

@@ -0,0 +1,57 @@
+"""
+API keys configuration for payment providers.
+"""
+
+from pydantic import BaseModel, Field
+from typing import List, Dict, Optional
+from .providers.base import BaseProviderConfig
+
+
+class ProviderAPIKeysConfig(BaseModel):
+    """
+    API keys configuration for payment providers.
+
+    Stores list of provider configurations.
+    """
+
+    providers: List[BaseProviderConfig] = Field(
+        default_factory=list,
+        description="List of provider configurations"
+    )
+
+    def add_provider(self, provider_config: BaseProviderConfig):
+        """Add a provider configuration."""
+        # Remove existing provider with same name
+        self.providers = [p for p in self.providers if p.provider_name != provider_config.provider_name]
+        self.providers.append(provider_config)
+
+    def get_provider_config(self, provider: str) -> Dict[str, any]:
+        """Get provider-specific configuration."""
+        provider_lower = provider.lower()
+
+        for provider_config in self.providers:
+            if provider_config.provider_name.lower() == provider_lower:
+                return provider_config.get_provider_config()
+
+        return {'enabled': False, 'provider_name': provider}
+
+    def get_enabled_providers(self) -> List[str]:
+        """Get list of enabled providers."""
+        enabled = []
+        for provider_config in self.providers:
+            config = provider_config.get_provider_config()
+            if config.get('enabled', False):
+                enabled.append(provider_config.provider_name)
+        return enabled
+
+    def get_provider_by_name(self, provider_name: str) -> Optional[BaseProviderConfig]:
+        """Get provider configuration by name."""
+        for provider_config in self.providers:
+            if provider_config.provider_name.lower() == provider_name.lower():
+                return provider_config
+        return None
+
+
+__all__ = [
+    "ProviderAPIKeysConfig",
+]

django_cfg/models/{payments.py → payments/config.py}

@@ -1,135 +1,41 @@
 """
-Payments configuration model for Django-CFG.
+Main payments configuration for django_cfg.
 
-Simple, clean configuration following django-cfg philosophy.
+Payments app configuration with middleware, rate limiting, and usage tracking.
 """
 
 from pydantic import BaseModel, Field
-from typing import List, Dict, Optional
-from django_cfg.models.cfg import BaseCfgAutoModule
-
-
-class BaseProviderConfig(BaseModel):
-    """Base configuration for payment providers."""
-    
-    provider_name: str = Field(..., description="Provider name")
-    enabled: bool = Field(default=True, description="Whether provider is enabled")
-    
-    def get_provider_config(self) -> Dict[str, any]:
-        """Get provider-specific configuration."""
-        return {
-            'provider_name': self.provider_name,
-            'enabled': self.enabled,
-        }
-
-
-class NowPaymentsProviderConfig(BaseProviderConfig):
-    """NowPayments provider configuration."""
-    
-    provider_name: str = Field(default="nowpayments", description="Provider name")
-    api_key: str = Field(default="", description="NowPayments API key")
-    ipn_secret: str = Field(default="", description="NowPayments IPN secret for webhook validation")
-    sandbox_mode: bool = Field(default=True, description="NowPayments sandbox mode")
-    
-    def get_provider_config(self) -> Dict[str, any]:
-        """Get NowPayments-specific configuration."""
-        return {
-            'provider_name': self.provider_name,
-            'enabled': self.enabled and bool(self.api_key.strip()),
-            'api_key': self.api_key,
-            'ipn_secret': self.ipn_secret,
-            'sandbox_mode': self.sandbox_mode,
-        }
-
-
-# Future provider configs (commented out for now)
-# class StripeProviderConfig(BaseProviderConfig):
-#     """Stripe provider configuration."""
-#     
-#     provider_name: str = Field(default="stripe", description="Provider name")
-#     api_key: str = Field(default="", description="Stripe API key")
-#     webhook_secret: str = Field(default="", description="Stripe webhook secret")
-#     
-#     def get_provider_config(self) -> Dict[str, any]:
-#         return {
-#             'provider_name': self.provider_name,
-#             'enabled': self.enabled and bool(self.api_key.strip()),
-#             'api_key': self.api_key,
-#             'webhook_secret': self.webhook_secret,
-#         }
-
-
-class ProviderAPIKeysConfig(BaseModel):
-    """
-    API keys configuration for payment providers.
-    
-    Stores list of provider configurations.
-    """
-    
-    providers: List[BaseProviderConfig] = Field(
-        default_factory=list,
-        description="List of provider configurations"
-    )
-    
-    def add_provider(self, provider_config: BaseProviderConfig):
-        """Add a provider configuration."""
-        # Remove existing provider with same name
-        self.providers = [p for p in self.providers if p.provider_name != provider_config.provider_name]
-        self.providers.append(provider_config)
-    
-    def get_provider_config(self, provider: str) -> Dict[str, any]:
-        """Get provider-specific configuration."""
-        provider_lower = provider.lower()
-        
-        for provider_config in self.providers:
-            if provider_config.provider_name.lower() == provider_lower:
-                return provider_config.get_provider_config()
-        
-        return {'enabled': False, 'provider_name': provider}
-    
-    def get_enabled_providers(self) -> List[str]:
-        """Get list of enabled providers."""
-        enabled = []
-        for provider_config in self.providers:
-            config = provider_config.get_provider_config()
-            if config.get('enabled', False):
-                enabled.append(provider_config.provider_name)
-        return enabled
-    
-    def get_provider_by_name(self, provider_name: str) -> Optional[BaseProviderConfig]:
-        """Get provider configuration by name."""
-        for provider_config in self.providers:
-            if provider_config.provider_name.lower() == provider_name.lower():
-                return provider_config
-        return None
+from typing import List, Dict
+from django_cfg.models.base import BaseCfgAutoModule
+from .api_keys import ProviderAPIKeysConfig
 
 
 class PaymentsConfig(BaseModel, BaseCfgAutoModule):
     """
     Payments app configuration for django-cfg.
-    
+
     Includes both static configuration and API keys.
     API keys are now managed through BaseCfgAutoModule instead of Constance.
     """
-    
+
     # Core settings
     enabled: bool = Field(
-        default=False, 
+        default=False,
         description="Enable payments app"
     )
-    
+
     # API keys configuration
     api_keys: ProviderAPIKeysConfig = Field(
         default_factory=ProviderAPIKeysConfig,
         description="API keys and secrets for payment providers"
     )
-    
+
     # Middleware settings
     middleware_enabled: bool = Field(
         default=True,
         description="Enable payments middleware"
     )
-    
+
     # Whitelist approach - only these paths require API key
     protected_paths: List[str] = Field(
         default=[
@@ -139,22 +45,22 @@ class PaymentsConfig(BaseModel, BaseCfgAutoModule):
         ],
         description="Paths that require API key authentication (whitelist approach)"
     )
-    
+
     protected_patterns: List[str] = Field(
         default=[
             r'^/api/admin/.*$',  # All admin API endpoints
-            r'^/api/private/.*$',  # All private API endpoints  
+            r'^/api/private/.*$',  # All private API endpoints
             r'^/api/secure/.*$',  # All secure API endpoints
         ],
         description="Regex patterns for paths that require API key authentication"
     )
-    
+
     # Rate limiting defaults
     rate_limiting_enabled: bool = Field(
         default=True,
         description="Enable rate limiting middleware"
     )
-    
+
     default_rate_limits: Dict[str, int] = Field(
         default={
             'anonymous': 60,
@@ -166,18 +72,18 @@ class PaymentsConfig(BaseModel, BaseCfgAutoModule):
         },
         description="Default rate limits (requests per minute) by tier"
     )
-    
+
     # Usage tracking
     usage_tracking_enabled: bool = Field(
         default=True,
         description="Enable usage tracking middleware"
     )
-    
+
     track_anonymous_usage: bool = Field(
         default=False,
         description="Track anonymous user requests"
     )
-    
+
     # Cache settings
     cache_timeouts: Dict[str, int] = Field(
         default={
@@ -188,94 +94,94 @@ class PaymentsConfig(BaseModel, BaseCfgAutoModule):
         },
         description="Cache timeout settings in seconds"
     )
-    
+
     def get_middleware_classes(self) -> List[str]:
         """
         Get middleware classes to add to Django MIDDLEWARE setting.
-        
+
         Returns:
             List of middleware class paths
         """
         if not self.enabled or not self.middleware_enabled:
             return []
-        
+
         middleware = []
-        
+
         # Always add API access middleware first
         middleware.append('django_cfg.apps.payments.middleware.APIAccessMiddleware')
-        
+
         # Add rate limiting if enabled
         if self.rate_limiting_enabled:
             middleware.append('django_cfg.apps.payments.middleware.RateLimitingMiddleware')
-        
+
         # Add usage tracking if enabled
         if self.usage_tracking_enabled:
             middleware.append('django_cfg.apps.payments.middleware.UsageTrackingMiddleware')
-        
+
         return middleware
-    
+
     def should_enable_tasks(self) -> bool:
         """
         Check if payments app requires Celery tasks.
-        
+
         Returns:
             True if tasks should be enabled
         """
         return self.enabled  # Enable tasks if payments is enabled
-    
+
     # Navigation and UI feature checks
     def show_webhook_dashboard(self) -> bool:
         """Check if webhook dashboard should be shown in navigation."""
         return self.enabled
-    
+
     def show_payment_creation(self) -> bool:
         """Check if payment creation should be shown in navigation."""
         return self.enabled
-    
+
     def show_currency_converter(self) -> bool:
         """Check if currency converter should be shown in navigation."""
         return self.enabled
-    
+
     def show_api_management(self) -> bool:
         """Check if API key management should be shown in navigation."""
         return self.enabled
-    
+
     def show_subscription_management(self) -> bool:
         """Check if subscription management should be shown in navigation."""
         return self.enabled
-    
+
     def show_balance_management(self) -> bool:
         """Check if balance management should be shown in navigation."""
         return self.enabled
-    
+
     def show_transaction_history(self) -> bool:
         """Check if transaction history should be shown in navigation."""
         return self.enabled
-    
+
     def show_currency_management(self) -> bool:
         """Check if currency management should be shown in navigation."""
         return self.enabled
-    
+
     def show_rate_limiting_features(self) -> bool:
         """Check if rate limiting features should be shown."""
         return self.enabled and self.rate_limiting_enabled
-    
+
     def show_usage_tracking_features(self) -> bool:
         """Check if usage tracking features should be shown."""
         return self.enabled and self.usage_tracking_enabled
-    
+
     def get_enabled_navigation_items(self) -> List[str]:
         """
         Get list of enabled navigation items for dynamic UI generation.
-        
+
         Returns:
             List of enabled navigation item identifiers
         """
         items = []
-        
+
         if not self.enabled:
             return items
-        
+
         # Core features (always enabled if payments is enabled)
         items.extend([
             'payment_dashboard',
@@ -284,59 +190,59 @@ class PaymentsConfig(BaseModel, BaseCfgAutoModule):
             'networks_admin',
             'provider_currencies_admin',
         ])
-        
+
         # Optional features based on configuration
         if self.show_webhook_dashboard():
             items.append('webhook_dashboard')
-        
+
         if self.show_payment_creation():
             items.append('payment_creation')
-        
+
         if self.show_currency_converter():
             items.append('currency_converter')
-        
+
         if self.show_api_management():
             items.extend(['api_keys_admin', 'endpoint_groups_admin'])
-        
+
         if self.show_subscription_management():
             items.extend(['subscriptions_admin', 'tariffs_admin'])
-        
+
         if self.show_balance_management():
             items.append('balances_admin')
-        
+
         if self.show_transaction_history():
             items.append('transactions_admin')
-        
+
         return items
-    
+
     # API Keys access methods
     def get_provider_api_config(self, provider: str) -> Dict[str, any]:
         """Get provider-specific API configuration."""
         return self.api_keys.get_provider_config(provider)
-    
+
     def get_enabled_providers(self) -> List[str]:
         """Get list of enabled providers (those with API keys configured)."""
         return self.api_keys.get_enabled_providers()
-    
+
     def is_provider_enabled(self, provider: str) -> bool:
         """Check if a specific provider is enabled (has API keys configured)."""
         config = self.api_keys.get_provider_config(provider)
         return config.get('enabled', False)
-    
+
     # BaseCfgAutoModule implementation
     def get_smart_defaults(self):
         """Get smart default configuration for this module."""
         return PaymentsConfig()
-    
+
     def get_module_config(self):
         """Get the final configuration for this module."""
         return self
-    
+
     @classmethod
     def get_current_config(cls) -> 'PaymentsConfig':
         """
         Get current payments configuration from django-cfg.
-        
+
         Uses PaymentsConfigManager for consistent access.
         """
         try:
@@ -347,10 +253,6 @@ class PaymentsConfig(BaseModel, BaseCfgAutoModule):
             return cls()
 
 
-# Export all payment configuration classes
 __all__ = [
-    "BaseProviderConfig",
-    "NowPaymentsProviderConfig", 
-    "ProviderAPIKeysConfig",
     "PaymentsConfig",
 ]

django_cfg/models/payments/providers/__init__.py

@@ -0,0 +1,15 @@
+"""
+Payment provider configurations.
+
+Provides type-safe configuration for payment providers:
+- BaseProviderConfig: Base class for all providers
+- NowPaymentsProviderConfig: NowPayments provider
+"""
+
+from .base import BaseProviderConfig
+from .nowpayments import NowPaymentsProviderConfig
+
+__all__ = [
+    "BaseProviderConfig",
+    "NowPaymentsProviderConfig",
+]