django-cfg 1.4.21__py3-none-any.whl → 1.4.23__py3-none-any.whl

django_cfg/models/api/limits.py

@@ -8,7 +8,8 @@ Following CRITICAL_REQUIREMENTS.md:
 - Simplified configuration with smart defaults
 """
 
-from typing import Optional, Dict, Any, List
+from typing import Any, Dict, List, Optional
+
 from pydantic import BaseModel, Field, field_validator, model_validator
 
 
@@ -19,13 +20,13 @@ class LimitsConfig(BaseModel):
     All file sizes are specified in megabytes for convenience.
     Django-cfg handles all the conversion and smart defaults.
     """
-    
+
     model_config = {
         "str_strip_whitespace": True,
         "validate_assignment": True,
         "extra": "forbid",
     }
-    
+
     # File upload limits (in MB)
     max_upload_mb: float = Field(
         default=10.0,
@@ -33,14 +34,14 @@ class LimitsConfig(BaseModel):
         ge=0.1,  # At least 100KB
         le=1024.0,  # Max 1GB
     )
-    
+
     max_memory_mb: float = Field(
         default=2.0,
         description="Maximum size for in-memory file uploads in megabytes",
         ge=0.1,
         le=100.0,
     )
-    
+
     # Request limits (in MB)
     max_request_mb: float = Field(
         default=50.0,
@@ -48,18 +49,18 @@ class LimitsConfig(BaseModel):
         ge=0.1,
         le=1024.0,
     )
-    
+
     # Simple file security
     allowed_extensions: Optional[List[str]] = Field(
         default=None,
         description="List of allowed file extensions (without dots). If None, uses smart defaults.",
     )
-    
+
     blocked_extensions: Optional[List[str]] = Field(
         default=None,
         description="List of blocked file extensions for security. If None, uses smart defaults.",
     )
-    
+
     # Request timeout
     request_timeout: int = Field(
         default=30,
@@ -67,40 +68,40 @@ class LimitsConfig(BaseModel):
         ge=1,
         le=3600,
     )
-    
+
     # Global settings
     enabled: bool = Field(
         default=True,
         description="Whether limits are enforced",
     )
-    
+
     strict_mode: bool = Field(
         default=False,
         description="Whether to use strict validation (fail on limit violations)",
     )
-    
+
     @field_validator('allowed_extensions', 'blocked_extensions')
     @classmethod
     def validate_extensions(cls, v: Optional[List[str]]) -> Optional[List[str]]:
         """Validate file extensions format."""
         if v is None:
             return v
-        
+
         validated = []
         for ext in v:
             # Remove leading dots and convert to lowercase
             clean_ext = ext.lstrip('.').lower().strip()
             if not clean_ext:
                 continue
-            
+
             # Basic validation - only alphanumeric characters
             if not clean_ext.replace('_', '').replace('-', '').isalnum():
                 raise ValueError(f"Invalid file extension: {ext}")
-            
+
             validated.append(clean_ext)
-        
+
         return validated
-    
+
     @model_validator(mode='after')
     def validate_limits(self) -> 'LimitsConfig':
         """Validate limits consistency."""
@@ -109,7 +110,7 @@ class LimitsConfig(BaseModel):
             raise ValueError(
                 "max_memory_mb cannot be larger than max_upload_mb"
             )
-        
+
         # Check for conflicts between allowed and blocked extensions
         if self.allowed_extensions and self.blocked_extensions:
             conflicts = set(self.allowed_extensions) & set(self.blocked_extensions)
@@ -117,9 +118,9 @@ class LimitsConfig(BaseModel):
                 raise ValueError(
                     f"Extensions cannot be both allowed and blocked: {conflicts}"
                 )
-        
+
         return self
-    
+
     def _get_smart_allowed_extensions(self) -> List[str]:
         """Get smart default allowed extensions."""
         return [
@@ -134,7 +135,7 @@ class LimitsConfig(BaseModel):
             # Media
             "mp3", "mp4", "avi", "mov", "wav",
         ]
-    
+
     def _get_smart_blocked_extensions(self) -> List[str]:
         """Get smart default blocked extensions for security."""
         return [
@@ -148,7 +149,7 @@ class LimitsConfig(BaseModel):
             # Potentially dangerous
             "hta", "reg", "inf", "cab", "cpl",
         ]
-    
+
     def to_django_settings(self) -> Dict[str, Any]:
         """
         Convert limits configuration to Django settings.
@@ -158,30 +159,30 @@ class LimitsConfig(BaseModel):
         """
         if not self.enabled:
             return {}
-        
+
         # Convert MB to bytes
         max_upload_bytes = int(self.max_upload_mb * 1024 * 1024)
         max_memory_bytes = int(self.max_memory_mb * 1024 * 1024)
         max_request_bytes = int(self.max_request_mb * 1024 * 1024)
-        
+
         settings = {}
-        
+
         # Core Django file upload settings
         settings.update({
             'FILE_UPLOAD_MAX_MEMORY_SIZE': max_memory_bytes,
             'DATA_UPLOAD_MAX_MEMORY_SIZE': min(max_memory_bytes, max_request_bytes),
             'DATA_UPLOAD_MAX_NUMBER_FIELDS': 1000,  # Reasonable default
         })
-        
+
         # File extension security
         allowed_exts = self.allowed_extensions or self._get_smart_allowed_extensions()
         blocked_exts = self.blocked_extensions or self._get_smart_blocked_extensions()
-        
+
         settings.update({
             'ALLOWED_FILE_EXTENSIONS': allowed_exts,
             'BLOCKED_FILE_EXTENSIONS': blocked_exts,
         })
-        
+
         # Custom settings for middleware/validators
         settings.update({
             'LIMITS_CONFIG': {
@@ -195,14 +196,14 @@ class LimitsConfig(BaseModel):
                 'strict_mode': self.strict_mode,
             }
         })
-        
+
         return settings
-    
+
     def get_validator_config(self) -> Dict[str, Any]:
         """Get configuration for validation middleware."""
         allowed_exts = self.allowed_extensions or self._get_smart_allowed_extensions()
         blocked_exts = self.blocked_extensions or self._get_smart_blocked_extensions()
-        
+
         return {
             'max_upload_bytes': int(self.max_upload_mb * 1024 * 1024),
             'max_memory_bytes': int(self.max_memory_mb * 1024 * 1024),

django_cfg/models/base/config.py

@@ -6,16 +6,15 @@ Foundation for all Django configuration models using Pydantic 2.
 
 import os
 from pathlib import Path
-from typing import Dict, Any, Optional
+from typing import Any, Dict, Optional
 
-from pydantic import BaseModel, ConfigDict, Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
 from pydantic_settings.sources import DotEnvSettingsSource
 
 
 class ConfigValidationError(Exception):
     """Configuration validation error with helpful developer messages."""
-    
+
     def __init__(self, field: str, value: Any, message: str):
         self.field = field
         self.value = value
@@ -34,25 +33,25 @@ class BaseConfig(BaseSettings):
     - Helpful error messages for developers
     - Environment-specific configuration
     """
-    
+
     model_config = SettingsConfigDict(
         # Environment file settings
         env_file='.env',
         env_file_encoding='utf-8',
         env_nested_delimiter='__',
         case_sensitive=False,
-        
+
         # Validation settings
         validate_assignment=True,
         validate_default=True,
         extra='ignore',
-        
+
         # Performance settings
         frozen=False,
         arbitrary_types_allowed=False,
         use_enum_values=True,
     )
-    
+
     @classmethod
     def settings_customise_sources(
         cls,
@@ -66,11 +65,11 @@ class BaseConfig(BaseSettings):
         env_file = cls._detect_env_file()
         if env_file:
             dotenv_settings = DotEnvSettingsSource(
-                settings_cls, 
+                settings_cls,
                 env_file=env_file,
                 env_file_encoding='utf-8'
             )
-        
+
         return (
             init_settings,
             env_settings,
@@ -85,7 +84,7 @@ class BaseConfig(BaseSettings):
         except Exception as e:
             self._handle_validation_error(e)
             raise
-    
+
     @classmethod
     def _detect_env_file(cls) -> Optional[str]:
         """
@@ -101,52 +100,52 @@ class BaseConfig(BaseSettings):
         env_files = [
             '.env.local',
             '.env.dev',
-            '.env.development', 
+            '.env.development',
             '.env.prod',
             '.env.production',
             'config.env.dev',
             'config.env.prod',
             '.env'
         ]
-        
+
         for env_file in env_files:
             if Path(env_file).exists():
                 return env_file
-        
+
         return None
-    
+
     def _show_debug(self) -> bool:
         """Check if we should show debug info."""
         return os.getenv('DEBUG', 'false').lower() in ('true', '1', 'yes')
-    
+
     def _handle_validation_error(self, error: Exception):
         """Provide helpful validation error messages for developers."""
         if hasattr(error, 'errors'):
             print("❌ Django Configuration Validation Errors:")
             print("=" * 50)
-            
+
             for err in error.errors():
                 field = '.'.join(str(x) for x in err['loc'])
                 message = err['msg']
                 input_val = err.get('input', 'N/A')
-                
+
                 print(f"🔴 Field: {field}")
                 print(f"   Error: {message}")
                 print(f"   Value: {input_val}")
-                print(f"   💡 Fix: Check your .env file or environment variables")
+                print("   💡 Fix: Check your .env file or environment variables")
                 print()
-            
+
             print("📚 Documentation: https://django-config-toolkit.readthedocs.io/")
             print("=" * 50)
-    
+
     def to_django_settings(self) -> Dict[str, Any]:
         """Convert configuration to Django-compatible settings dictionary."""
         return self.model_dump(exclude_none=True, by_alias=True)
-    
+
     def get_field_info(self) -> Dict[str, Dict[str, Any]]:
         """Get detailed field information for developers."""
         field_info = {}
-        
+
         for field_name, field in self.model_fields.items():
             field_info[field_name] = {
                 'description': field.description or f"Configuration for {field_name}",
@@ -155,23 +154,23 @@ class BaseConfig(BaseSettings):
                 'required': field.is_required(),
                 'env_var': field_name.upper(),
             }
-        
+
         return field_info
-    
+
     def print_field_help(self):
         """Print helpful field information for developers."""
         print(f"📋 {self.__class__.__name__} Configuration Fields:")
         print("=" * 60)
-        
+
         for field_name, info in self.get_field_info().items():
             current_value = getattr(self, field_name, None)
-            
+
             # Hide sensitive values
             if any(word in field_name.lower() for word in ['secret', 'password', 'key', 'token']):
                 display_value = "***HIDDEN***" if current_value else "Not set"
             else:
                 display_value = current_value
-            
+
             print(f"🔧 {field_name}:")
             print(f"   📝 {info['description']}")
             print(f"   🏷️  Type: {info['type']}")
@@ -180,9 +179,9 @@ class BaseConfig(BaseSettings):
             if info['default'] is not None:
                 print(f"   🎯 Default: {info['default']}")
             if info['required']:
-                print(f"   ⚠️  Required: Yes")
+                print("   ⚠️  Required: Yes")
             print()
-    
+
     @classmethod
     def create_env_example(cls, filename: str = ".env.example") -> None:
         """
@@ -199,7 +198,7 @@ class BaseConfig(BaseSettings):
             f"# === {cls.__name__} Configuration ===",
             "",
         ]
-        
+
         # Create temporary instance to get field info
         try:
             temp_instance = cls()
@@ -213,11 +212,11 @@ class BaseConfig(BaseSettings):
                     'default': field.default if field.default is not ... else None,
                     'env_var': field_name.upper(),
                 }
-        
+
         for field_name, info in field_info.items():
             # Add description
             lines.append(f"# {info['description']}")
-            
+
             # Generate example value
             default_val = info.get('default')
             if default_val is not None:
@@ -241,19 +240,19 @@ class BaseConfig(BaseSettings):
                 example_value = "30"
             else:
                 example_value = "change-me"
-            
+
             # Add environment variable
             lines.append(f"{info['env_var']}={example_value}")
             lines.append("")
-        
+
         # Write file
         with open(filename, 'w', encoding='utf-8') as f:
             f.write('\n'.join(lines))
-        
+
         print(f"✅ Created example environment file: {filename}")
-        print(f"💡 Copy it to .env and customize your settings!")
-        print(f"📚 More info: https://django-config-toolkit.readthedocs.io/")
-    
+        print("💡 Copy it to .env and customize your settings!")
+        print("📚 More info: https://django-config-toolkit.readthedocs.io/")
+
     def validate_for_environment(self, environment: str = "development") -> bool:
         """
         🧪 Validate configuration for specific environment
@@ -275,13 +274,13 @@ class BaseConfig(BaseSettings):
         except Exception as e:
             print(f"❌ Validation failed for {environment}: {e}")
             return False
-    
+
     def _validate_production(self) -> bool:
         """Validate production-specific requirements."""
         # Override in subclasses for specific validation
         return True
-    
+
     def _validate_development(self) -> bool:
         """Validate development-specific requirements."""
-        # Override in subclasses for specific validation  
+        # Override in subclasses for specific validation
         return True

django_cfg/models/base/module.py

@@ -4,8 +4,8 @@ Base Configuration Module for Django CFG
 Provides a unified base class for all auto-configuration modules.
 """
 
-from typing import Optional, TYPE_CHECKING
 from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
     from django_cfg.core.config import DjangoConfig
@@ -18,7 +18,7 @@ class BaseCfgAutoModule(ABC):
     Provides unified configuration access and smart defaults.
     Designed to be used in generation.py without circular imports.
     """
-    
+
     def __init__(self, config: Optional["DjangoConfig"] = None):
         """
         Initialize the auto-configuration module.
@@ -27,7 +27,7 @@ class BaseCfgAutoModule(ABC):
             config: DjangoConfig instance (passed from generation.py)
         """
         self._config = config
-    
+
     def set_config(self, config: "DjangoConfig") -> None:
         """
         Set the configuration instance.
@@ -36,11 +36,11 @@ class BaseCfgAutoModule(ABC):
             config: The DjangoConfig instance
         """
         self._config = config
-    
+
     def get_config(self) -> Optional["DjangoConfig"]:
         """Get the current configuration instance."""
         return self._config
-    
+
     def has_config_field(self, field_name: str) -> bool:
         """
         Check if config has a specific field with a non-None value.
@@ -54,7 +54,7 @@ class BaseCfgAutoModule(ABC):
         if not self._config:
             return False
         return hasattr(self._config, field_name) and getattr(self._config, field_name) is not None
-    
+
     def get_config_field(self, field_name: str, default=None):
         """
         Get a field value from config with fallback.
@@ -69,7 +69,7 @@ class BaseCfgAutoModule(ABC):
         if not self._config:
             return default
         return getattr(self._config, field_name, default)
-    
+
     @abstractmethod
     def get_smart_defaults(self):
         """
@@ -79,7 +79,7 @@ class BaseCfgAutoModule(ABC):
             Configuration object with intelligent defaults
         """
         pass
-    
+
     @abstractmethod
     def get_module_config(self):
         """

django_cfg/models/django/__init__.py

@@ -4,8 +4,8 @@ Django-specific configuration models for django_cfg.
 Django integrations and extensions.
 """
 
-from .environment import EnvironmentConfig
 from .constance import ConstanceConfig, ConstanceField
+from .environment import EnvironmentConfig
 from .openapi import OpenAPIClientConfig
 
 __all__ = [

django_cfg/models/django/constance.py

@@ -5,9 +5,10 @@ Type-safe configuration for django-constance with automatic
 Unfold admin integration and smart field grouping.
 """
 
-from typing import Dict, List, Optional, Any, Union, Literal
+from typing import Any, Dict, List, Literal, Optional, Union
+
 from pydantic import BaseModel, Field, field_validator
-import traceback
+
 from django_cfg.models.base import BaseCfgAutoModule
 
 
@@ -150,16 +151,16 @@ class ConstanceConfig(BaseModel, BaseCfgAutoModule):
         default_factory=list,
         description="List of Constance fields",
     )
-    
+
     # Cache for app fields to avoid multiple calls
     _app_fields_cache: Optional[List[ConstanceField]] = None
- 
+
     def _get_app_constance_fields(self) -> List[ConstanceField]:
         """Automatically collect constance fields from django-cfg apps."""
         # Return cached result if available
         if self._app_fields_cache is not None:
             return self._app_fields_cache
-            
+
         app_fields = []
         config = self.get_config()
 
@@ -171,7 +172,7 @@ class ConstanceConfig(BaseModel, BaseCfgAutoModule):
                 app_fields.extend(tasks_fields)
             except (ImportError, Exception):
                 pass
-        
+
         # Get fields from knowbase app (only if enabled)
         if config and config.enable_knowbase:
             try:
@@ -180,7 +181,7 @@ class ConstanceConfig(BaseModel, BaseCfgAutoModule):
                 app_fields.extend(knowbase_fields)
             except (ImportError, Exception):
                 pass
-        
+
         # Cache the result
         self._app_fields_cache = app_fields
         return app_fields

django_cfg/models/django/environment.py

@@ -6,8 +6,10 @@ Core Django environment settings with Pydantic 2.
 
 import os
 from pathlib import Path
-from typing import List, Dict, Any
-from pydantic import Field, field_validator, computed_field
+from typing import Any, Dict, List
+
+from pydantic import Field, computed_field, field_validator
+
 from ..base import BaseConfig
 
 
@@ -71,7 +73,7 @@ class EnvironmentConfig(BaseConfig):
         for insecure in insecure_keys:
             if insecure in v.lower():
                 raise ValueError(
-                    f"Please change the secret key from default/example value"
+                    "Please change the secret key from default/example value"
                 )
 
         return v

django_cfg/models/django/openapi.py

@@ -7,8 +7,10 @@ TypeScript and Python client generation from Django REST Framework endpoints.
 This replaces django-revolution with a cleaner, faster, type-safe implementation.
 """
 
-from typing import Dict, Any, Optional
+from typing import Any, Dict, Optional
+
 from pydantic import Field
+
 from django_cfg.modules.django_client.core.config import OpenAPIConfig, OpenAPIGroupConfig
 
 
@@ -103,23 +105,11 @@ class OpenAPIClientConfig(OpenAPIConfig):
 
     def get_groups_with_defaults(self) -> Dict[str, OpenAPIGroupConfig]:
         """
-        Get groups with django-cfg default groups automatically added.
-        
-        Automatically adds the 'cfg' group with all django-cfg apps if not explicitly defined.
+        Get groups as a dictionary.
 
         Returns:
-            Dict of groups including default django-cfg groups
+            Dict of groups from configuration
         """
         # Convert list to dict for compatibility
-        groups_dict = {group.name: group for group in self.groups}
-
-        # Add default 'cfg' group if not explicitly defined
-        if 'cfg' not in groups_dict:
-            try:
-                from django_cfg.apps.urls import get_default_cfg_group
-                groups_dict['cfg'] = get_default_cfg_group()
-            except Exception:
-                pass
-
-        return groups_dict
+        return {group.name: group for group in self.groups}