django-cfg 1.1.82__py3-none-any.whl → 1.2.0__py3-none-any.whl

django_cfg/models/constance.py

@@ -9,8 +9,6 @@ from typing import Dict, List, Optional, Any, Union, Literal
 from pydantic import BaseModel, Field, field_validator
 from pathlib import Path
 
-from unfold.contrib.constance.settings import UNFOLD_CONSTANCE_ADDITIONAL_FIELDS
-
 
 class ConstanceField(BaseModel):
     """
@@ -39,7 +37,7 @@ class ConstanceField(BaseModel):
         max_length=500,
     )
 
-    field_type: Literal["str", "int", "float", "bool", "choice", "longtext", "description"] = Field(
+    field_type: Literal["str", "int", "float", "bool", "choice"] = Field(
         default="str",
         description="Field type for form rendering and validation",
     )
@@ -68,21 +66,9 @@ class ConstanceField(BaseModel):
             raise ValueError("Choices must be provided for choice field type")
         return v
 
-    def to_constance_config(self) -> tuple[Any, str, type]:
+    def to_constance_config(self) -> tuple[Any, str]:
         """Convert to Constance configuration format."""
-        # Map field types to Python types
-        type_mapping = {
-            "str": str,
-            "int": int,
-            "float": float,
-            "bool": int,  # Use int for boolean (0/1)
-            "choice": str,  # Choices are typically strings
-            "longtext": str,  # Long text fields are strings
-            "description": str,  # Description fields are strings
-        }
-        
-        field_python_type = type_mapping.get(self.field_type, str)
-        return (self.default, self.help_text, field_python_type)
+        return (self.default, self.help_text)
 
     def to_constance_field_config(self) -> Dict[str, Any]:
         """Convert to Constance additional fields configuration."""
@@ -109,21 +95,10 @@ class ConstanceField(BaseModel):
                 "django.forms.FloatField",
                 {"widget": "unfold.widgets.UnfoldAdminTextInputWidget"},
             ],
-            "longtext": [
-                "django.forms.CharField",
-                {
-                    "widget": "unfold.widgets.UnfoldAdminTextareaWidget",
-                    "attrs": {"rows": 4, "cols": 80, "class": "max-w-4xl"},
-                },
-            ],
-            "description": [
-                "django.forms.CharField",
-                {
-                    "widget": "unfold.widgets.UnfoldAdminTextareaWidget",
-                    "attrs": {"rows": 3, "cols": 60, "class": "max-w-3xl"},
-                },
+            "bool": [
+                "django.forms.BooleanField",
+                {"widget": "unfold.widgets.UnfoldBooleanSwitchWidget"},
             ],
-            # Boolean fields will use default Unfold configuration from UNFOLD_CONSTANCE_ADDITIONAL_FIELDS
         }
 
         return field_mapping.get(self.field_type, field_mapping["str"])
@@ -171,12 +146,12 @@ class ConstanceConfig(BaseModel):
         description="List of Constance fields",
     )
 
-    def get_config_dict(self) -> Dict[str, tuple[Any, str, type]]:
+    def get_config_dict(self) -> Dict[str, tuple[Any, str]]:
         """Generate CONSTANCE_CONFIG dictionary."""
         return {field.name: field.to_constance_config() for field in self.fields}
 
-    def get_fieldsets_dict(self) -> Dict[str, tuple]:
-        """Generate CONSTANCE_CONFIG_FIELDSETS dictionary grouped by field groups."""
+    def get_fieldsets_dict(self) -> Dict[str, List[str]]:
+        """Generate CONSTANCE_FIELDSETS dictionary grouped by field groups."""
         fieldsets = {}
 
         for field in self.fields:
@@ -185,60 +160,19 @@ class ConstanceConfig(BaseModel):
                 fieldsets[group] = []
             fieldsets[group].append(field.name)
 
-        # Convert lists to tuples as required by Constance
-        return {group: tuple(fields) for group, fields in fieldsets.items()}
+        return fieldsets
 
     def get_additional_fields_dict(self) -> Dict[str, List[Any]]:
-        """Generate CONSTANCE_ADDITIONAL_FIELDS dictionary with enhanced widgets."""
+        """Generate CONSTANCE_ADDITIONAL_FIELDS dictionary."""
+        # Start with Unfold base fields
         from unfold.contrib.constance.settings import UNFOLD_CONSTANCE_ADDITIONAL_FIELDS
 
         additional_fields = dict(UNFOLD_CONSTANCE_ADDITIONAL_FIELDS)
 
-        # Add custom field configurations for better text handling
-        additional_fields.update({
-            "text": [
-                "django.forms.CharField",
-                {
-                    "widget": "unfold.widgets.UnfoldAdminTextInputWidget",
-                    "attrs": {"class": "max-w-2xl"},
-                },
-            ],
-            "longtext": [
-                "django.forms.CharField",
-                {
-                    "widget": "unfold.widgets.UnfoldAdminTextareaWidget",
-                    "attrs": {"rows": 4, "cols": 80, "class": "max-w-4xl"},
-                },
-            ],
-            "description": [
-                "django.forms.CharField",
-                {
-                    "widget": "unfold.widgets.UnfoldAdminTextareaWidget",
-                    "attrs": {"rows": 3, "cols": 60, "class": "max-w-3xl"},
-                },
-            ],
-        })
-        
-        # Override specific fields with custom widgets
+        # Add custom field configurations
         for field in self.fields:
-            if field.field_type == "choice" and field.choices:
-                additional_fields[field.name] = field.to_constance_field_config()
-            elif field.field_type in ["longtext", "description"]:
-                # Use field-specific configuration to override Unfold defaults
-                additional_fields[field.name] = field.to_constance_field_config()
-        
-        # CRITICAL FIX: Override fields that should use textarea based on field_type
-        # This ensures longtext and description fields use textarea regardless of their Python type
-        for field in self.fields:
-            if field.field_type in ["longtext", "description"]:
-                # Force textarea widget for these field types, overriding any type-based defaults
-                additional_fields[field.name] = [
-                    "django.forms.CharField",
-                    {
-                        "widget": "unfold.widgets.UnfoldAdminTextareaWidget",
-                        "attrs": field.to_constance_field_config()[1]["attrs"],
-                    },
-                ]
+            if field.field_type == "choice" or field.choices:
+                additional_fields[f"{field.name.lower()}_field"] = field.to_constance_field_config()
 
         return additional_fields
 
@@ -247,23 +181,26 @@ class ConstanceConfig(BaseModel):
         if not self.fields:
             return {}
 
-        config_dict = self.get_config_dict()
-        fieldsets_dict = self.get_fieldsets_dict()
-        additional_fields_dict = self.get_additional_fields_dict()
-
         settings = {
-            "CONSTANCE_CONFIG": config_dict,
-            "CONSTANCE_CONFIG_FIELDSETS": fieldsets_dict,
+            # Main configuration
+            "CONSTANCE_CONFIG": self.get_config_dict(),
+            "CONSTANCE_FIELDSETS": self.get_fieldsets_dict(),
+            # Backend settings (using default database backend)
             "CONSTANCE_BACKEND": "constance.backends.database.DatabaseBackend",
+            # Cache settings
             "CONSTANCE_DATABASE_CACHE_BACKEND": self.database_cache_backend,
             "CONSTANCE_DATABASE_PREFIX": self.cache_prefix,
             "CONSTANCE_DATABASE_CACHE_AUTOFILL_TIMEOUT": self.cache_autofill_timeout,
+            # Redis settings (if using Redis backend)
             "CONSTANCE_REDIS_CONNECTION_CLASS": self.redis_connection_class,
             "CONSTANCE_REDIS_PREFIX": self.redis_prefix,
-            "CONSTANCE_ADDITIONAL_FIELDS": additional_fields_dict,
+            # Additional fields with Unfold widgets
+            "CONSTANCE_ADDITIONAL_FIELDS": self.get_additional_fields_dict(),
+            # Ignore admin version check
             "CONSTANCE_IGNORE_ADMIN_VERSION_CHECK": True,
         }
 
+        # Remove None values
         return {k: v for k, v in settings.items() if v is not None}
 
 

django_cfg/models/database.py

@@ -13,10 +13,10 @@ from pathlib import Path
 from pydantic import BaseModel, Field, field_validator, model_validator, PrivateAttr
 from urllib.parse import urlparse
 
-from django_cfg.exceptions import DatabaseError, ValidationError
+from django_cfg.core.exceptions import DatabaseError, ValidationError
 
 
-class DatabaseConnection(BaseModel):
+class DatabaseConfig(BaseModel):
     """
     Type-safe database connection configuration.
 
@@ -193,7 +193,7 @@ class DatabaseConnection(BaseModel):
         return values
 
     @model_validator(mode="after")
-    def validate_connection_after(self) -> "DatabaseConnection":
+    def validate_connection_after(self) -> "DatabaseConfig":
         """Validate connection after model creation."""
         # Parse connection string if present
         if "://" in self.name:
@@ -440,9 +440,9 @@ class DatabaseConnection(BaseModel):
         operations: Optional[List[Literal["read", "write", "migrate"]]] = None,
         routing_description: str = "",
         **kwargs
-    ) -> "DatabaseConnection":
+    ) -> "DatabaseConfig":
         """
-        Create DatabaseConnection from URL with automatic engine detection.
+        Create DatabaseConfig from URL with automatic engine detection.
         
         Args:
             url: Database URL (e.g., 'postgresql://user:pass@host:port/db')
@@ -452,14 +452,14 @@ class DatabaseConnection(BaseModel):
             **kwargs: Additional parameters to override defaults
             
         Returns:
-            DatabaseConnection instance with auto-detected engine
+            DatabaseConfig instance with auto-detected engine
             
         Example:
             # Simple SQLite database
-            db = DatabaseConnection.from_url("sqlite:///db.sqlite3")
+            db = DatabaseConfig.from_url("sqlite:///db.sqlite3")
             
             # PostgreSQL with routing
-            blog_db = DatabaseConnection.from_url(
+            blog_db = DatabaseConfig.from_url(
                 "postgresql://user:pass@localhost:5432/blog",
                 apps=["apps.blog"],
                 routing_description="Blog posts and comments"
@@ -476,5 +476,5 @@ class DatabaseConnection(BaseModel):
 
 # Export all models
 __all__ = [
-    "DatabaseConnection",
+    "DatabaseConfig",
 ]

django_cfg/models/drf.py

@@ -103,18 +103,7 @@ class SpectacularConfig(BaseModel):
     # Schema Settings
     schema_path_prefix: str = Field(default="/api", description="Schema path prefix")
     serve_include_schema: bool = Field(default=False, description="Include schema in UI")
-    schema_coerce_path_pk_suffix: bool = Field(default=True, description="Coerce path PK suffix")
-    schema_coerce_method_names: Dict[str, str] = Field(
-        default_factory=lambda: {
-            "retrieve": "get",
-            "destroy": "delete",
-            "partial_update": "patch",
-            "update": "put",
-        },
-        description="Coerce method names for stable operation IDs"
-    )
-    # component_split_request: bool = Field(default=False, description="Split request components")
-    # component_no_read_only_required: bool = Field(default=True, description="No read-only required")
+    component_split_request: bool = Field(default=True, description="Split request components")
     sort_operations: bool = Field(default=False, description="Sort operations")
     
     # UI Settings
@@ -125,24 +114,13 @@ class SpectacularConfig(BaseModel):
         default_factory=RedocUISettings, description="Redoc UI settings"
     )
 
-    # Processing hooks
+    # Post-processing
     postprocessing_hooks: List[str] = Field(
         default_factory=lambda: [
             'drf_spectacular.contrib.djangorestframework_camel_case.camelize_serializer_fields'
         ],
         description="Post-processing hooks"
     )
-    preprocessing_hooks: List[str] = Field(
-        default_factory=list,
-        description="Pre-processing hooks"
-    )
-    
-    # Additional stability settings
-    disable_errors_and_warnings: bool = Field(default=False, description="Disable errors and warnings")
-    operation_id_generator_class: Optional[str] = Field(
-        default=None, 
-        description="Custom operation ID generator class"
-    )
     
     # Enum overrides
     enum_name_overrides: Dict[str, str] = Field(
@@ -161,27 +139,16 @@ class SpectacularConfig(BaseModel):
             "VERSION": self.version,
             "SERVE_INCLUDE_SCHEMA": self.serve_include_schema,
             "SCHEMA_PATH_PREFIX": self.schema_path_prefix,
-            # Schema stability settings
-            "SCHEMA_COERCE_PATH_PK_SUFFIX": self.schema_coerce_path_pk_suffix,
-            "SCHEMA_COERCE_METHOD_NAMES": self.schema_coerce_method_names,
-            'COMPONENT_SPLIT_REQUEST': False,
-            'COMPONENT_NO_READ_ONLY_REQUIRED': False,
+            "COMPONENT_SPLIT_REQUEST": self.component_split_request,
             "SORT_OPERATIONS": self.sort_operations,
             # UI Settings
             "SWAGGER_UI_SETTINGS": self.swagger_ui_settings.to_dict(),
             "REDOC_UI_SETTINGS": self.redoc_ui_settings.to_dict(),
             # Processing
             "POSTPROCESSING_HOOKS": self.postprocessing_hooks,
-            "PREPROCESSING_HOOKS": self.preprocessing_hooks,
             "ENUM_NAME_OVERRIDES": self.enum_name_overrides,
-            # Stability settings
-            "DISABLE_ERRORS_AND_WARNINGS": self.disable_errors_and_warnings,
         }
         
-        # Add optional operation ID generator
-        if self.operation_id_generator_class:
-            settings["OPERATION_ID_GENERATOR_CLASS"] = self.operation_id_generator_class
-        
         # Add optional fields if present
         if self.terms_of_service:
             settings["TERMS_OF_SERVICE"] = self.terms_of_service

django_cfg/models/email.py

@@ -0,0 +1,163 @@
+"""
+Email Configuration Model
+
+Django email settings with Pydantic 2.
+"""
+
+from typing import Dict, Any, Optional
+from pydantic import Field, field_validator
+from .base import BaseConfig
+
+
+class EmailConfig(BaseConfig):
+    """
+    📧 Email Configuration - Django email settings
+    
+    Supports SMTP, console, file, and other email backends
+    with environment-aware defaults.
+    """
+    
+    # Email backend
+    backend: str = Field(
+        default="console",
+        description="Email backend (smtp/console/file/memory)"
+    )
+    
+    # SMTP settings
+    host: str = Field(
+        default="localhost",
+        description="SMTP server host"
+    )
+    
+    port: int = Field(
+        default=587,
+        ge=1,
+        le=65535,
+        description="SMTP server port"
+    )
+    
+    username: Optional[str] = Field(
+        default=None,
+        description="SMTP username"
+    )
+    
+    password: Optional[str] = Field(
+        default=None,
+        description="SMTP password"
+    )
+    
+    use_tls: bool = Field(
+        default=True,
+        description="Use TLS for SMTP"
+    )
+    
+    use_ssl: bool = Field(
+        default=False,
+        description="Use SSL for SMTP"
+    )
+    
+    timeout: int = Field(
+        default=30,
+        ge=1,
+        le=300,
+        description="SMTP timeout in seconds"
+    )
+    
+    # Email addresses
+    default_from: str = Field(
+        default="noreply@example.com",
+        description="Default 'from' email address"
+    )
+    
+    admin_email: Optional[str] = Field(
+        default=None,
+        description="Admin email for error notifications"
+    )
+    
+    # File backend settings
+    file_path: str = Field(
+        default="emails/",
+        description="Path for file-based email backend"
+    )
+    
+    @field_validator('backend')
+    @classmethod
+    def validate_backend(cls, v: str) -> str:
+        """Validate email backend."""
+        valid_backends = ['smtp', 'console', 'file', 'memory', 'dummy']
+        if v not in valid_backends:
+            raise ValueError(f"Email backend must be one of: {valid_backends}")
+        return v
+    
+    @field_validator('default_from', 'admin_email')
+    @classmethod
+    def validate_email(cls, v: Optional[str]) -> Optional[str]:
+        """Validate email address format."""
+        if v and '@' not in v:
+            raise ValueError("Invalid email address format")
+        return v
+    
+    @field_validator('use_tls', 'use_ssl', mode='after')
+    @classmethod
+    def validate_tls_ssl(cls, v, info):
+        """Ensure TLS and SSL are not both enabled."""
+        data = info.data
+        if data.get('use_tls') and data.get('use_ssl'):
+            raise ValueError("Cannot use both TLS and SSL simultaneously")
+        return v
+    
+    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'
+            
+            settings = {
+                'EMAIL_BACKEND': backend_class,
+                'EMAIL_HOST': self.host,
+                'EMAIL_PORT': self.port,
+                'EMAIL_USE_TLS': self.use_tls,
+                'EMAIL_USE_SSL': self.use_ssl,
+                'EMAIL_TIMEOUT': self.timeout,
+                'DEFAULT_FROM_EMAIL': self.default_from,
+            }
+            
+            if self.username:
+                settings['EMAIL_HOST_USER'] = self.username
+            
+            if self.password:
+                settings['EMAIL_HOST_PASSWORD'] = self.password
+        
+        elif self.backend == 'console':
+            settings = {
+                'EMAIL_BACKEND': 'django.core.mail.backends.console.EmailBackend',
+                'DEFAULT_FROM_EMAIL': self.default_from,
+            }
+        
+        elif self.backend == 'file':
+            settings = {
+                'EMAIL_BACKEND': 'django.core.mail.backends.filebased.EmailBackend',
+                'EMAIL_FILE_PATH': self.file_path,
+                'DEFAULT_FROM_EMAIL': self.default_from,
+            }
+        
+        elif self.backend == 'memory':
+            settings = {
+                'EMAIL_BACKEND': 'django.core.mail.backends.locmem.EmailBackend',
+                'DEFAULT_FROM_EMAIL': self.default_from,
+            }
+        
+        elif self.backend == 'dummy':
+            settings = {
+                'EMAIL_BACKEND': 'django.core.mail.backends.dummy.EmailBackend',
+                'DEFAULT_FROM_EMAIL': self.default_from,
+            }
+        
+        else:
+            raise ValueError(f"Unsupported email backend: {self.backend}")
+        
+        # Add admin email if provided
+        if self.admin_email:
+            settings['ADMINS'] = [('Admin', self.admin_email)]
+            settings['MANAGERS'] = [('Manager', self.admin_email)]
+        
+        return settings