django-cfg 1.3.7__py3-none-any.whl → 1.3.11__py3-none-any.whl

django_cfg/models/api_keys.py

@@ -0,0 +1,115 @@
+"""
+API Keys configuration models for django-cfg.
+
+Simple model for OpenAI and OpenRouter API keys.
+Following CRITICAL_REQUIREMENTS.md:
+- No raw Dict/Any usage - everything through Pydantic models
+- Proper type annotations for all fields
+- No mutable default arguments
+"""
+
+from typing import Optional
+from pydantic import BaseModel, Field, field_validator, SecretStr
+
+
+class ApiKeys(BaseModel):
+    """
+    API keys configuration for LLM services.
+    
+    Simple model for storing OpenAI and OpenRouter API keys.
+    
+    Example:
+        ```python
+        api_keys = ApiKeys(
+            openai="${OPENAI_API_KEY}",
+            openrouter="${OPENROUTER_API_KEY}"
+        )
+        ```
+    """
+    
+    model_config = {
+        "validate_assignment": True,
+        "extra": "forbid",
+        "str_strip_whitespace": True,
+        "validate_default": True,
+    }
+    
+    # === LLM Provider Keys ===
+    openai: Optional[SecretStr] = Field(
+        default=None,
+        description="OpenAI API key for GPT models and embeddings"
+    )
+    
+    openrouter: Optional[SecretStr] = Field(
+        default=None,
+        description="OpenRouter API key for access to multiple LLM providers"
+    )
+    
+    @field_validator("openai")
+    @classmethod
+    def validate_openai_key(cls, v: Optional[SecretStr]) -> Optional[SecretStr]:
+        """Validate OpenAI API key format."""
+        if v is None:
+            return v
+        
+        key_str = v.get_secret_value()
+        if not key_str.startswith(("sk-", "sk-proj-")):
+            raise ValueError("OpenAI API key must start with 'sk-' or 'sk-proj-'")
+        
+        if len(key_str) < 20:
+            raise ValueError("OpenAI API key appears to be too short")
+        
+        return v
+    
+    @field_validator("openrouter")
+    @classmethod
+    def validate_openrouter_key(cls, v: Optional[SecretStr]) -> Optional[SecretStr]:
+        """Validate OpenRouter API key format."""
+        if v is None:
+            return v
+        
+        key_str = v.get_secret_value()
+        if not key_str.startswith(("sk-or-", "sk-proj-")):
+            raise ValueError("OpenRouter API key must start with 'sk-or-' or 'sk-proj-'")
+        
+        if len(key_str) < 20:
+            raise ValueError("OpenRouter API key appears to be too short")
+        
+        return v
+    
+    def get_openai_key(self) -> Optional[str]:
+        """Get OpenAI API key as string."""
+        return self.openai.get_secret_value() if self.openai else None
+    
+    def get_openrouter_key(self) -> Optional[str]:
+        """Get OpenRouter API key as string."""
+        return self.openrouter.get_secret_value() if self.openrouter else None
+    
+    def has_openai(self) -> bool:
+        """Check if OpenAI key is configured."""
+        return self.openai is not None
+    
+    def has_openrouter(self) -> bool:
+        """Check if OpenRouter key is configured."""
+        return self.openrouter is not None
+    
+    def get_preferred_provider(self) -> Optional[str]:
+        """
+        Get preferred provider based on availability.
+        
+        Priority: OpenRouter (default) > OpenAI
+        
+        Returns:
+            "openrouter" or "openai" or None
+        """
+        if self.has_openrouter():
+            return "openrouter"
+        elif self.has_openai():
+            return "openai"
+        return None
+
+
+# Export the main class
+__all__ = [
+    "ApiKeys",
+]

django_cfg/models/constance.py

@@ -181,17 +181,6 @@ class ConstanceConfig(BaseModel, BaseCfgAutoModule):
             except (ImportError, Exception):
                 pass
         
-        # Get fields from payments app (only if enabled)
-        if config and config.payments and config.payments.enabled:
-            try:
-                from django_cfg.apps.payments.config import get_django_cfg_payments_constance_fields
-                payments_fields = get_django_cfg_payments_constance_fields()
-                app_fields.extend(payments_fields)
-                print(f"✅ Added {len(payments_fields)} payments fields to Constance")
-            except (ImportError, Exception) as e:
-                print(f"❌ Failed to load payments constance fields: {e}")
-                traceback.print_exc()
-        
         # Cache the result
         self._app_fields_cache = app_fields
         return app_fields

django_cfg/models/payments.py

@@ -6,14 +6,110 @@ Simple, clean configuration following django-cfg philosophy.
 
 from pydantic import BaseModel, Field
 from typing import List, Dict, Optional
+from django_cfg.models.cfg import BaseCfgAutoModule
 
 
-class PaymentsConfig(BaseModel):
+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
+
+
+class PaymentsConfig(BaseModel, BaseCfgAutoModule):
     """
     Payments app configuration for django-cfg.
     
-    Static configuration that doesn't change at runtime.
-    Dynamic settings (API keys, secrets) are handled by Constance.
+    Includes both static configuration and API keys.
+    API keys are now managed through BaseCfgAutoModule instead of Constance.
     """
     
     # Core settings
@@ -22,6 +118,12 @@ class PaymentsConfig(BaseModel):
         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,
@@ -207,6 +309,29 @@ class PaymentsConfig(BaseModel):
         
         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':
         """
@@ -220,3 +345,12 @@ class PaymentsConfig(BaseModel):
             return PaymentsConfigManager.get_payments_config_safe()
         except Exception:
             return cls()
+
+
+# Export all payment configuration classes
+__all__ = [
+    "BaseProviderConfig",
+    "NowPaymentsProviderConfig", 
+    "ProviderAPIKeysConfig",
+    "PaymentsConfig",
+]

django_cfg/modules/django_admin/__init__.py

@@ -0,0 +1,64 @@
+"""
+Django Admin Utilities - Universal HTML Builder System
+
+Clean, type-safe admin utilities with no HTML duplication.
+"""
+
+# Core utilities
+from .utils.displays import UserDisplay, MoneyDisplay, StatusDisplay, DateTimeDisplay
+from .utils.badges import StatusBadge, ProgressBadge, CounterBadge
+
+# Icons
+from .icons import Icons, IconCategories
+
+# Admin mixins
+from .mixins.display_mixin import DisplayMixin
+from .mixins.optimization_mixin import OptimizedModelAdmin
+from .mixins.standalone_actions_mixin import StandaloneActionsMixin, standalone_action
+
+# Configuration models
+from .models.display_models import UserDisplayConfig, MoneyDisplayConfig, DateTimeDisplayConfig
+from .models.badge_models import BadgeConfig, BadgeVariant, StatusBadgeConfig
+from .models.action_models import ActionVariant, ActionConfig
+
+# Decorators
+from .decorators import display, action
+
+__version__ = "1.0.0"
+
+__all__ = [
+    # Display utilities
+    "UserDisplay",
+    "MoneyDisplay", 
+    "StatusDisplay",
+    "DateTimeDisplay",
+    
+    # Badge utilities
+    "StatusBadge",
+    "ProgressBadge",
+    "CounterBadge",
+    
+    # Icons
+    "Icons",
+    "IconCategories",
+    
+    # Admin mixins
+    "OptimizedModelAdmin",
+    "DisplayMixin",
+    "StandaloneActionsMixin",
+    "standalone_action",
+    
+    # Configuration models
+    "UserDisplayConfig",
+    "MoneyDisplayConfig",
+    "DateTimeDisplayConfig",
+    "BadgeConfig",
+    "BadgeVariant",
+    "StatusBadgeConfig",
+    "ActionVariant",
+    "ActionConfig",
+    
+    # Decorators
+    "display",
+    "action",
+]

django_cfg/modules/django_admin/decorators/__init__.py

@@ -0,0 +1,13 @@
+"""
+Django Admin Decorators - Wrappers for Unfold decorators.
+
+Provides consistent, type-safe decorators with our admin utilities integration.
+"""
+
+from .display import display
+from .actions import action
+
+__all__ = [
+    'display',
+    'action',
+]

django_cfg/modules/django_admin/decorators/actions.py

@@ -0,0 +1,106 @@
+"""
+Action decorator wrapper for Unfold integration.
+
+Provides type-safe action decorators with consistent styling.
+"""
+
+from typing import Optional, Callable, Any
+from functools import wraps
+from unfold.decorators import action as unfold_action
+from unfold.enums import ActionVariant as UnfoldActionVariant
+
+from django_cfg.modules.django_logger import get_logger
+from ..models.action_models import ActionVariant
+
+
+logger = get_logger("django_admin.decorators.actions")
+
+def action(
+    description: str,
+    variant: Optional[ActionVariant] = None,
+    icon: Optional[str] = None,
+    permissions: Optional[list] = None,
+    url_path: Optional[str] = None,
+    attrs: Optional[dict] = None
+) -> Callable:
+    """
+    Enhanced action decorator with Django Admin Utilities integration.
+    
+    Args:
+        description: Action description shown in admin
+        variant: Action style variant (ActionVariant enum)
+        icon: Material icon name
+        permissions: Required permissions list
+        url_path: URL path for standalone action buttons (creates separate button)
+        attrs: Additional attributes for the action
+    
+    Usage:
+        # Bulk action (works on selected items)
+        @action(description="Activate items", variant=ActionVariant.SUCCESS)
+        def activate_items(self, request, queryset):
+            updated = queryset.update(is_active=True)
+            self.message_user(request, f"Activated {updated} items.")
+        
+        # Standalone action button (url_path creates separate button)
+        @action(
+            description="Update Rates",
+            variant=ActionVariant.SUCCESS,
+            url_path="update-rates",
+            icon="sync"
+        )
+        def update_rates(self, request):
+            # Standalone action logic (no queryset parameter)
+            pass
+    """
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(self, request: Any, *args, **kwargs) -> Any:
+            try:
+                # For url_path actions, there's no queryset parameter
+                if url_path:
+                    return func(self, request, *args, **kwargs)
+                else:
+                    # For bulk actions, pass queryset as second parameter
+                    queryset = args[0] if args else kwargs.get('queryset')
+                    return func(self, request, queryset, *args[1:], **kwargs)
+            except Exception as e:
+                # Log error and show user message
+                logger.error(f"Error in action {func.__name__}: {e}")
+                
+                self.message_user(
+                    request,
+                    f"Error executing action: {str(e)}",
+                    level='ERROR'
+                )
+        
+        # Convert our ActionVariant to Unfold ActionVariant
+        action_variant = None
+        if variant:
+            # Direct mapping since values are the same
+            unfold_variant_mapping = {
+                ActionVariant.DEFAULT: UnfoldActionVariant.DEFAULT,
+                ActionVariant.PRIMARY: UnfoldActionVariant.PRIMARY,
+                ActionVariant.SUCCESS: UnfoldActionVariant.SUCCESS,
+                ActionVariant.INFO: UnfoldActionVariant.INFO,
+                ActionVariant.WARNING: UnfoldActionVariant.WARNING,
+                ActionVariant.DANGER: UnfoldActionVariant.DANGER,
+            }
+            action_variant = unfold_variant_mapping.get(variant, UnfoldActionVariant.DEFAULT)
+        
+        # Build decorator kwargs
+        decorator_kwargs = {'description': description}
+        if action_variant:
+            decorator_kwargs['variant'] = action_variant
+        if icon:
+            decorator_kwargs['icon'] = icon
+        if permissions:
+            decorator_kwargs['permissions'] = permissions
+        if url_path:
+            decorator_kwargs['url_path'] = url_path
+        if attrs:
+            decorator_kwargs['attrs'] = attrs
+        
+        # Apply Unfold decorator
+        return unfold_action(**decorator_kwargs)(wrapper)
+    
+    return decorator

django_cfg/modules/django_admin/decorators/display.py

@@ -0,0 +1,106 @@
+"""
+Display decorator wrapper for Unfold integration.
+
+Provides type-safe display decorators with our admin utilities.
+"""
+
+from typing import Optional, Callable, Any, Union
+from functools import wraps
+from django.utils.safestring import SafeString, mark_safe
+from unfold.decorators import display as unfold_display
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger('django_admin.decorators.display')
+
+def display(
+    function: Optional[Callable] = None,
+    *,
+    boolean: Optional[bool] = None,
+    image: Optional[bool] = None,
+    ordering: Optional[str] = None,
+    description: Optional[str] = None,
+    empty_value: Optional[str] = None,
+    dropdown: Optional[bool] = None,
+    label: Union[bool, str, dict, None] = None,
+    header: Optional[bool] = None
+) -> Callable:
+    """
+    Enhanced display decorator with Django Admin Utilities integration.
+    
+    This decorator wraps unfold.decorators.display with additional features:
+    - Automatic HTML safety detection and marking
+    - Empty value handling with customizable fallback
+    - Error handling with logging
+    
+    Args:
+        function: Function to decorate (for direct usage)
+        boolean: Show as boolean icon (True/False icons)
+        image: Show as image thumbnail
+        ordering: Field name for sorting
+        description: Column header text
+        empty_value: Default value for empty/None fields
+        dropdown: Show as dropdown menu
+        label: Show as label badge (bool, str, or dict for styling)
+        header: Show as header with avatar
+    
+    Usage:
+        @display(description="User", header=True)
+        def user_display(self, obj):
+            return self.display_user_with_avatar(obj, 'user')
+        
+        @display(description="Status", label=True)
+        def status_display(self, obj):
+            return self.display_status_auto(obj, 'status')
+            
+        @display(description="Has Embedding", boolean=True)
+        def has_embedding_display(self, obj):
+            return obj.has_embedding
+            
+        @display(description="Avatar", image=True)
+        def avatar_display(self, obj):
+            return obj.avatar.url if obj.avatar else None
+    """
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(self, obj: Any) -> Any:
+            try:
+                result = func(self, obj)
+                
+                # Handle empty values (use our default if unfold's empty_value is None)
+                if result is None or result == "":
+                    return empty_value if empty_value is not None else "—"
+                
+                # Auto-mark HTML as safe if it contains HTML tags
+                if isinstance(result, str) and ('<' in result and '>' in result):
+                    return mark_safe(result)
+                
+                # SafeString is already safe
+                if isinstance(result, SafeString):
+                    return result
+                
+                return result
+            except Exception as e:
+                # Log error and return safe fallback
+                logger.error(f"Error in display method {func.__name__}: {e}")
+                return empty_value if empty_value is not None else "—"
+        
+        # Apply Unfold decorator with all parameters
+        return unfold_display(
+            function=None,  # We handle the function ourselves
+            boolean=boolean,
+            image=image,
+            ordering=ordering,
+            description=description,
+            empty_value=empty_value,
+            dropdown=dropdown,
+            label=label,
+            header=header
+        )(wrapper)
+    
+    # Support both @display and @display(...) usage
+    if function is not None:
+        # Direct usage: @display
+        return decorator(function)
+    else:
+        # Parametrized usage: @display(...)
+        return decorator

django_cfg/modules/django_admin/mixins/__init__.py

@@ -0,0 +1,14 @@
+"""
+Admin mixins for easy integration.
+"""
+
+from .display_mixin import DisplayMixin
+from .optimization_mixin import OptimizedModelAdmin
+from .standalone_actions_mixin import StandaloneActionsMixin, standalone_action
+
+__all__ = [
+    "DisplayMixin",
+    "OptimizedModelAdmin",
+    "StandaloneActionsMixin",
+    "standalone_action",
+]

django_cfg/modules/django_admin/mixins/display_mixin.py

@@ -0,0 +1,81 @@
+"""
+Display mixin for convenient wrapper methods.
+"""
+
+from typing import Optional, Any
+from django.utils.safestring import SafeString
+
+from ..utils.displays import UserDisplay, MoneyDisplay, StatusDisplay, DateTimeDisplay
+from ..utils.badges import StatusBadge, CounterBadge
+from ..models.display_models import UserDisplayConfig, MoneyDisplayConfig, DateTimeDisplayConfig
+from ..models.badge_models import StatusBadgeConfig
+
+
+class DisplayMixin:
+    """Mixin for Django ModelAdmin classes with convenient display methods."""
+    
+    def display_user_with_avatar(self, obj: Any, user_field: str = 'user',
+                                config: Optional[UserDisplayConfig] = None) -> list:
+        """Display user with avatar for @display(header=True)."""
+        user = getattr(obj, user_field, None)
+        return UserDisplay.with_avatar(user, config)
+    
+    def display_user_simple(self, obj: Any, user_field: str = 'user',
+                           config: Optional[UserDisplayConfig] = None) -> SafeString:
+        """Simple user display."""
+        user = getattr(obj, user_field, None)
+        return UserDisplay.simple(user, config)
+    
+    def display_money_amount(self, obj: Any, amount_field: str,
+                            config: Optional[MoneyDisplayConfig] = None) -> SafeString:
+        """Display money amount."""
+        amount = getattr(obj, amount_field, None)
+        return MoneyDisplay.amount(amount, config)
+    
+    def display_money_breakdown(self, obj: Any, main_field: str, breakdown_fields: dict,
+                               config: Optional[MoneyDisplayConfig] = None) -> SafeString:
+        """Display money with breakdown."""
+        main_amount = getattr(obj, main_field, 0)
+        
+        breakdown_items = []
+        for label, field_name in breakdown_fields.items():
+            amount = getattr(obj, field_name, 0)
+            breakdown_items.append({
+                'label': label,
+                'amount': amount,
+                'color': 'warning' if amount > 0 else 'secondary'
+            })
+        
+        return MoneyDisplay.with_breakdown(main_amount, breakdown_items, config)
+    
+    def display_status_auto(self, obj: Any, status_field: str = 'status',
+                           config: Optional[StatusBadgeConfig] = None) -> SafeString:
+        """Display status with auto color mapping."""
+        status = getattr(obj, status_field, '')
+        return StatusBadge.auto(status, config)
+    
+    def display_datetime_relative(self, obj: Any, datetime_field: str,
+                                 config: Optional[DateTimeDisplayConfig] = None) -> SafeString:
+        """Display datetime with relative time."""
+        dt = getattr(obj, datetime_field, None)
+        return DateTimeDisplay.relative(dt, config)
+    
+    def display_datetime_compact(self, obj: Any, datetime_field: str,
+                                config: Optional[DateTimeDisplayConfig] = None) -> SafeString:
+        """Display datetime compact."""
+        dt = getattr(obj, datetime_field, None)
+        return DateTimeDisplay.compact(dt, config)
+    
+    def display_count_simple(self, obj: Any, count_field: str, label: str = None) -> SafeString:
+        """Display count as badge."""
+        count = getattr(obj, count_field, 0)
+        return CounterBadge.simple(count, label)
+    
+    def display_related_count(self, obj: Any, related_name: str, label: str = None) -> SafeString:
+        """Display count of related objects."""
+        try:
+            related_manager = getattr(obj, related_name)
+            count = related_manager.count()
+            return CounterBadge.simple(count, label)
+        except AttributeError:
+            return CounterBadge.simple(0, label)