django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

django_cfg/models/services/email.py

@@ -58,6 +58,11 @@ class EmailConfig(BaseConfig):
         description="Use SSL for SMTP"
     )
 
+    ssl_verify: bool = Field(
+        default=True,
+        description="Verify SSL certificates (set False for self-signed certs in dev)"
+    )
+
     timeout: int = Field(
         default=30,
         ge=1,
@@ -111,7 +116,12 @@ class EmailConfig(BaseConfig):
     def to_django_settings(self) -> Dict[str, Any]:
         """Convert to Django email settings."""
         if self.backend == 'smtp':
-            backend_class = 'django.core.mail.backends.smtp.EmailBackend'
+            # Choose backend based on SSL verification setting
+            if self.ssl_verify:
+                backend_class = 'django.core.mail.backends.smtp.EmailBackend'
+            else:
+                # Use custom backend that accepts self-signed SSL certs
+                backend_class = 'django_cfg.core.backends.smtp.UnverifiedSSLEmailBackend'
 
             settings = {
                 'EMAIL_BACKEND': backend_class,

django_cfg/modules/base.py

@@ -156,16 +156,14 @@ class BaseCfgModule(ABC):
         """
         return self._get_config_key('enable_knowbase', False)
 
-    def should_enable_tasks(self) -> bool:
+    def should_enable_rq(self) -> bool:
         """
-        Check if django-cfg Tasks is enabled.
-        Auto-enables if knowbase or agents are enabled.
+        Check if django-cfg RQ is enabled.
         
         Returns:
-            True if Tasks is enabled, False otherwise
+            True if RQ is enabled, False otherwise
         """
-
-        return self.get_config().should_enable_tasks()
+        return self.get_config().should_enable_rq()
 
     def is_maintenance_enabled(self) -> bool:
         """
@@ -191,18 +189,33 @@ class BaseCfgModule(ABC):
 
         return False
 
-    def is_rpc_enabled(self) -> bool:
+    def is_centrifugo_enabled(self) -> bool:
+        """
+        Check if django-cfg Centrifugo is enabled.
+
+        Returns:
+            True if Centrifugo is enabled, False otherwise
+        """
+        centrifugo_config = self._get_config_key('centrifugo', None)
+
+        # Check if centrifugo config exists and is enabled
+        if centrifugo_config and hasattr(centrifugo_config, 'enabled'):
+            return centrifugo_config.enabled
+
+        return False
+
+    def is_grpc_enabled(self) -> bool:
         """
-        Check if django-cfg RPC Client is enabled.
+        Check if django-cfg gRPC is enabled.
 
         Returns:
-            True if RPC Client is enabled, False otherwise
+            True if gRPC is enabled, False otherwise
         """
-        rpc_config = self._get_config_key('django_ipc', None)
+        grpc_config = self._get_config_key('grpc', None)
 
-        # Only handle DjangoCfgRPCConfig model
-        if rpc_config and hasattr(rpc_config, 'enabled'):
-            return rpc_config.enabled
+        # Check if grpc config exists and is enabled
+        if grpc_config and hasattr(grpc_config, 'enabled'):
+            return grpc_config.enabled
 
         return False
 

django_cfg/modules/django_admin/__init__.py

@@ -46,13 +46,18 @@ Example:
 from .config import (
     ActionConfig,
     AdminConfig,
+    BackgroundTaskConfig,
     BadgeField,
     BooleanField,
     CurrencyField,
     DateTimeField,
+    DocumentationConfig,
     FieldConfig,
     FieldsetConfig,
     ImageField,
+    MarkdownField,
+    ResourceConfig,
+    ShortUUIDField,
     TextField,
     UserField,
 )
@@ -71,6 +76,7 @@ from .icons import IconCategories, Icons
 from .utils import (
     CounterBadge,
     DateTimeDisplay,
+    MarkdownRenderer,
     MoneyDisplay,
     ProgressBadge,
     StatusBadge,
@@ -101,12 +107,17 @@ __all__ = [
     "FieldConfig",
     "FieldsetConfig",
     "ActionConfig",
+    "ResourceConfig",
+    "BackgroundTaskConfig",
+    "DocumentationConfig",
     # Specialized Field Types
     "BadgeField",
     "BooleanField",
     "CurrencyField",
     "DateTimeField",
     "ImageField",
+    "MarkdownField",
+    "ShortUUIDField",
     "TextField",
     "UserField",
     # Advanced
@@ -121,6 +132,7 @@ __all__ = [
     "StatusBadge",
     "ProgressBadge",
     "CounterBadge",
+    "MarkdownRenderer",
     # Decorators
     "computed_field",
     "badge_field",

django_cfg/modules/django_admin/apps.py

@@ -0,0 +1,19 @@
+"""
+Django app configuration for django_admin module.
+
+This makes django_admin a proper Django app so templates are automatically discovered.
+"""
+from django.apps import AppConfig
+
+
+class DjangoAdminConfig(AppConfig):
+    """Configuration for django_admin module."""
+
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "django_cfg.modules.django_admin"
+    label = "django_cfg_admin"
+    verbose_name = "Django Admin (django-cfg)"
+
+    def ready(self):
+        """Called when Django is ready."""
+        pass

django_cfg/modules/django_admin/base/pydantic_admin.py

@@ -3,6 +3,7 @@ PydanticAdmin - Declarative admin base class.
 """
 
 import logging
+from pathlib import Path
 from typing import Any, List, Optional
 
 from django.utils.safestring import mark_safe
@@ -24,17 +25,24 @@ def _get_base_admin_class():
 
     MRO (Method Resolution Order):
         UnfoldImportExportModelAdmin
-          └─ ImportExportModelAdmin  # Import/Export functionality
-          └─ UnfoldModelAdmin        # Unfold UI
+          └─ UnfoldModelAdmin        # Unfold UI (first for template priority)
+          └─ ImportExportMixin       # Import/Export functionality (django_cfg custom)
                └─ Django ModelAdmin
 
     This ensures both Unfold UI and Import/Export work together seamlessly.
+
+    Uses django_cfg's custom ImportExportMixin which includes:
+    - Custom templates for proper Unfold styling
+    - Unfold forms (ImportForm, ExportForm)
+    - Properly styled import/export buttons
     """
-    from import_export.admin import ImportExportModelAdmin
+    # Use original ImportExportModelAdmin with Unfold
+    from import_export.admin import ImportExportModelAdmin as BaseImportExportModelAdmin
     from unfold.admin import ModelAdmin as UnfoldModelAdmin
 
-    class UnfoldImportExportModelAdmin(ImportExportModelAdmin, UnfoldModelAdmin):
-        """Combined Unfold + Import/Export admin base class."""
+    class UnfoldImportExportModelAdmin(BaseImportExportModelAdmin, UnfoldModelAdmin):
+        """Combined Import/Export + Unfold admin base class."""
+        # Import/Export should come FIRST in MRO to get its get_urls() method
         pass
 
     return UnfoldImportExportModelAdmin
@@ -122,8 +130,170 @@ class PydanticAdminMixin:
         cls.preserve_filters = config.preserve_filters
 
         # Import/Export configuration
-        if config.import_export_enabled and config.resource_class:
-            cls.resource_class = config.resource_class
+        if config.import_export_enabled:
+            # Set import/export template
+            cls.change_list_template = 'admin/import_export/change_list_import_export.html'
+
+            if config.resource_class:
+                # Use provided resource class
+                cls.resource_class = config.resource_class
+            else:
+                # Auto-generate resource class
+                cls.resource_class = cls._generate_resource_class(config)
+
+            # Override changelist_view to add import/export context
+            original_changelist_view = cls.changelist_view
+
+            def changelist_view_with_import_export(self, request, extra_context=None):
+                if extra_context is None:
+                    extra_context = {}
+                extra_context['has_import_permission'] = self.has_import_permission(request)
+                extra_context['has_export_permission'] = self.has_export_permission(request)
+                return original_changelist_view(self, request, extra_context)
+
+            cls.changelist_view = changelist_view_with_import_export
+
+        # Documentation configuration
+        if config.documentation:
+            cls._setup_documentation(config)
+
+    @classmethod
+    def _setup_documentation(cls, config: AdminConfig):
+        """
+        Setup documentation using unfold's template hooks.
+
+        Uses unfold's built-in hooks:
+        - list_before_template: Shows documentation before changelist table
+        - change_form_before_template: Shows documentation before fieldsets
+        """
+        doc_config = config.documentation
+
+        # Set unfold template hooks
+        if doc_config.show_on_changelist:
+            cls.list_before_template = "django_admin/documentation_block.html"
+
+        if doc_config.show_on_changeform:
+            cls.change_form_before_template = "django_admin/documentation_block.html"
+
+        # Store documentation config for access in views
+        cls.documentation_config = doc_config
+
+    def _get_app_path(self) -> Optional[Path]:
+        """
+        Detect the app path for relative file resolution.
+
+        Returns:
+            Path to the app directory or None
+        """
+        if not self.model:
+            return None
+
+        try:
+            # Get app label from model
+            app_label = self.model._meta.app_label
+
+            # Try to get app config
+            from django.apps import apps
+            app_config = apps.get_app_config(app_label)
+
+            if app_config and hasattr(app_config, 'path'):
+                return Path(app_config.path)
+        except Exception as e:
+            logger.warning(f"Could not detect app path for {self.model}: {e}")
+
+        return None
+
+    @classmethod
+    def _generate_resource_class(cls, config: AdminConfig):
+        """
+        Auto-generate a ModelResource class for import/export.
+
+        Uses ResourceConfig if provided, otherwise generates basic Resource.
+        """
+        from import_export import resources
+
+        target_model = config.model
+        resource_config = config.resource_config
+
+        # Determine fields to include
+        if resource_config and resource_config.fields:
+            # Use explicitly specified fields
+            model_fields = resource_config.fields
+        else:
+            # Auto-detect fields from model
+            model_fields = []
+            for field in target_model._meta.get_fields():
+                # Skip relations and auto fields that shouldn't be imported
+                if field.concrete and not field.many_to_many:
+                    # Skip password fields for security
+                    if 'password' not in field.name.lower():
+                        model_fields.append(field.name)
+
+        # Apply exclusions if specified
+        if resource_config and resource_config.exclude:
+            model_fields = [f for f in model_fields if f not in resource_config.exclude]
+
+        # Build Meta attributes
+        meta_attrs = {
+            'model': target_model,
+            'fields': tuple(model_fields),
+        }
+
+        # Add ResourceConfig settings
+        if resource_config:
+            meta_attrs['import_id_fields'] = resource_config.import_id_fields
+            meta_attrs['skip_unchanged'] = resource_config.skip_unchanged
+            meta_attrs['report_skipped'] = resource_config.report_skipped
+            meta_attrs['use_transactions'] = resource_config.use_transactions
+
+            if resource_config.export_order:
+                meta_attrs['export_order'] = tuple(resource_config.export_order)
+        else:
+            # Default settings
+            meta_attrs['import_id_fields'] = ['id'] if 'id' in model_fields else []
+            meta_attrs['skip_unchanged'] = True
+            meta_attrs['report_skipped'] = True
+
+        # Create Meta class
+        ResourceMeta = type('Meta', (), meta_attrs)
+
+        # Build Resource class attributes (methods + Meta)
+        resource_attrs = {'Meta': ResourceMeta}
+
+        # Add hooks from ResourceConfig
+        if resource_config:
+            # before_import hook
+            if resource_config.before_import:
+                hook = resource_config.get_callable('before_import')
+                if hook:
+                    resource_attrs['before_import'] = hook
+
+            # after_import hook
+            if resource_config.after_import:
+                hook = resource_config.get_callable('after_import')
+                if hook:
+                    resource_attrs['after_import'] = hook
+
+            # before_import_row hook
+            if resource_config.before_import_row:
+                hook = resource_config.get_callable('before_import_row')
+                if hook:
+                    resource_attrs['before_import_row'] = hook
+
+            # after_import_row hook
+            if resource_config.after_import_row:
+                hook = resource_config.get_callable('after_import_row')
+                if hook:
+                    resource_attrs['after_import_row'] = hook
+
+        # Create Resource class
+        AutoGeneratedResource = type(
+            f'{target_model.__name__}Resource',
+            (resources.ModelResource,),
+            resource_attrs
+        )
+
+        return AutoGeneratedResource
 
     @classmethod
     def _build_list_display(cls, config: AdminConfig) -> List[str]:
@@ -333,6 +503,106 @@ class PydanticAdminMixin:
 
         return tuple(filtered_fieldsets)
 
+    def changelist_view(self, request, extra_context=None):
+        """Override to add documentation context to changelist."""
+        if extra_context is None:
+            extra_context = {}
+
+        # Add documentation context if configured
+        if hasattr(self, 'documentation_config') and self.documentation_config:
+            doc_config = self.documentation_config
+            app_path = self._get_app_path()
+
+            if doc_config.show_on_changelist:
+                extra_context['documentation_config'] = doc_config
+                extra_context['documentation_sections'] = doc_config.get_sections(app_path)
+
+                # Add management commands if enabled
+                if doc_config.show_management_commands:
+                    extra_context['management_commands'] = doc_config._discover_management_commands(app_path)
+
+                # Add Mermaid resources if plugins enabled
+                if doc_config.enable_plugins:
+                    from django_cfg.modules.django_admin.utils.markdown.mermaid_plugin import get_mermaid_resources
+                    extra_context['mermaid_resources'] = get_mermaid_resources()
+
+        return super().changelist_view(request, extra_context)
+
+    def changeform_view(self, request, object_id=None, form_url='', extra_context=None):
+        """Override to add documentation context to changeform."""
+        if extra_context is None:
+            extra_context = {}
+
+        # Add documentation context if configured
+        if hasattr(self, 'documentation_config') and self.documentation_config:
+            doc_config = self.documentation_config
+            app_path = self._get_app_path()
+
+            if doc_config.show_on_changeform:
+                extra_context['documentation_config'] = doc_config
+                extra_context['documentation_sections'] = doc_config.get_sections(app_path)
+
+                # Add management commands if enabled
+                if doc_config.show_management_commands:
+                    extra_context['management_commands'] = doc_config._discover_management_commands(app_path)
+
+                # Add Mermaid resources if plugins enabled
+                if doc_config.enable_plugins:
+                    from django_cfg.modules.django_admin.utils.markdown.mermaid_plugin import get_mermaid_resources
+                    extra_context['mermaid_resources'] = get_mermaid_resources()
+
+        return super().changeform_view(request, object_id, form_url, extra_context)
+
+    def formfield_for_dbfield(self, db_field, request, **kwargs):
+        """
+        Override form field for specific database field types.
+
+        Automatically detects and customizes encrypted fields from django-crypto-fields.
+        Respects the show_encrypted_fields_as_plain_text setting from AdminConfig.
+        Uses custom widgets with copy-to-clipboard functionality.
+        """
+        # Check if this is an EncryptedTextField or EncryptedCharField
+        field_class_name = db_field.__class__.__name__
+        if 'Encrypted' in field_class_name and ('TextField' in field_class_name or 'CharField' in field_class_name):
+            from django import forms
+            from ..widgets import EncryptedFieldWidget, EncryptedPasswordWidget
+
+            # Determine placeholder based on field name
+            placeholder = "Enter value"
+            if 'key' in db_field.name.lower():
+                placeholder = "Enter API Key"
+            elif 'secret' in db_field.name.lower():
+                placeholder = "Enter API Secret"
+            elif 'passphrase' in db_field.name.lower():
+                placeholder = "Enter Passphrase (if required)"
+
+            # Widget attributes
+            widget_attrs = {
+                'placeholder': placeholder,
+            }
+
+            # Decide widget based on config
+            show_plain_text = getattr(self.config, 'show_encrypted_fields_as_plain_text', False)
+
+            if show_plain_text:
+                # Show as plain text with copy button
+                widget = EncryptedFieldWidget(attrs=widget_attrs, show_copy_button=True)
+            else:
+                # Show as password (masked) with copy button
+                # render_value=True shows masked value (••••••) after save
+                widget = EncryptedPasswordWidget(attrs=widget_attrs, render_value=True, show_copy_button=True)
+
+            # Return CharField with appropriate widget
+            return forms.CharField(
+                widget=widget,
+                required=not db_field.blank and not db_field.null,
+                help_text=db_field.help_text or "This field is encrypted at rest",
+                label=db_field.verbose_name if hasattr(db_field, 'verbose_name') else db_field.name.replace('_', ' ').title()
+            )
+
+        # Fall back to default Django behavior
+        return super().formfield_for_dbfield(db_field, request, **kwargs)
+
 
 class PydanticAdmin(PydanticAdminMixin, _get_base_admin_class()):
     """

django_cfg/modules/django_admin/config/__init__.py

@@ -4,6 +4,8 @@ Configuration models for declarative Django Admin.
 
 from .action_config import ActionConfig
 from .admin_config import AdminConfig
+from .background_task_config import BackgroundTaskConfig
+from .documentation_config import DocumentationConfig, DocumentationSection
 from .field_config import (
     FieldConfig,
     BadgeField,
@@ -11,22 +13,31 @@ from .field_config import (
     CurrencyField,
     DateTimeField,
     ImageField,
+    MarkdownField,
+    ShortUUIDField,
     TextField,
     UserField,
 )
 from .fieldset_config import FieldsetConfig
+from .resource_config import ResourceConfig
 
 __all__ = [
     "AdminConfig",
     "FieldConfig",
     "FieldsetConfig",
     "ActionConfig",
+    "ResourceConfig",
+    "BackgroundTaskConfig",
+    "DocumentationConfig",
+    "DocumentationSection",
     # Specialized Field Types
     "BadgeField",
     "BooleanField",
     "CurrencyField",
     "DateTimeField",
     "ImageField",
+    "MarkdownField",
+    "ShortUUIDField",
     "TextField",
     "UserField",
 ]

django_cfg/modules/django_admin/config/admin_config.py

@@ -8,8 +8,11 @@ from django.db import models
 from pydantic import BaseModel, ConfigDict, Field
 
 from .action_config import ActionConfig
+from .background_task_config import BackgroundTaskConfig
+from .documentation_config import DocumentationConfig
 from .field_config import FieldConfig
 from .fieldset_config import FieldsetConfig
+from .resource_config import ResourceConfig
 
 
 class AdminConfig(BaseModel):
@@ -96,6 +99,14 @@ class AdminConfig(BaseModel):
         default_factory=list,
         description="Fields with raw ID widget"
     )
+    filter_horizontal: List[str] = Field(
+        default_factory=list,
+        description="M2M fields with horizontal filter widget"
+    )
+    filter_vertical: List[str] = Field(
+        default_factory=list,
+        description="M2M fields with vertical filter widget"
+    )
     prepopulated_fields: Dict[str, tuple] = Field(
         default_factory=dict,
         description="Auto-populate fields (e.g., {'slug': ('name',)})"
@@ -119,7 +130,30 @@ class AdminConfig(BaseModel):
 
     # Import/Export options
     import_export_enabled: bool = Field(False, description="Enable import/export functionality")
-    resource_class: Optional[Type] = Field(None, description="Resource class for import/export")
+    resource_class: Optional[Type] = Field(None, description="Custom Resource class for import/export")
+    resource_config: Optional[ResourceConfig] = Field(
+        None,
+        description="Declarative resource configuration (alternative to resource_class)"
+    )
+
+    # Background task processing
+    background_task_config: Optional[BackgroundTaskConfig] = Field(
+        None,
+        description="Configuration for background task processing"
+    )
+
+    # Documentation
+    documentation: Optional[DocumentationConfig] = Field(
+        None,
+        description="Markdown documentation configuration"
+    )
+
+    # Encrypted fields options
+    show_encrypted_fields_as_plain_text: bool = Field(
+        False,
+        description="Show encrypted fields (django-crypto-fields) as plain text instead of password masked. "
+                    "WARNING: This exposes sensitive data in the admin interface. Use only in trusted environments."
+    )
 
     def get_display_field_config(self, field_name: str) -> Optional[FieldConfig]:
         """Get FieldConfig for a specific field."""

django_cfg/modules/django_admin/config/background_task_config.py

@@ -0,0 +1,76 @@
+"""
+Background task configuration for async operations.
+"""
+
+from typing import Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class BackgroundTaskConfig(BaseModel):
+    """
+    Configuration for background task processing.
+
+    Used for async operations like testing imported items,
+    bulk processing, or long-running operations.
+
+    Example:
+        ```python
+        background_config = BackgroundTaskConfig(
+            enabled=True,
+            task_runner='django_rq',
+            batch_size=100,
+            timeout=300,
+        )
+        ```
+    """
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid"
+    )
+
+    enabled: bool = Field(
+        True,
+        description="Enable background task processing"
+    )
+
+    task_runner: Literal['django_rq', 'sync'] = Field(
+        'sync',
+        description="Task runner to use for background operations (django_rq or sync)"
+    )
+
+    batch_size: int = Field(
+        100,
+        ge=1,
+        le=10000,
+        description="Number of items to process in each batch"
+    )
+
+    timeout: int = Field(
+        300,
+        ge=1,
+        le=3600,
+        description="Task timeout in seconds (max 1 hour)"
+    )
+
+    retry_on_failure: bool = Field(
+        True,
+        description="Automatically retry failed tasks"
+    )
+
+    max_retries: int = Field(
+        3,
+        ge=0,
+        le=10,
+        description="Maximum number of retry attempts"
+    )
+
+    priority: Literal['high', 'normal', 'low'] = Field(
+        'normal',
+        description="Task priority in queue"
+    )
+
+    def should_use_background(self) -> bool:
+        """Check if background processing should be used."""
+        return self.enabled and self.task_runner != 'sync'