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

django_cfg/models/revolution.py

@@ -83,13 +83,16 @@ class ExtendedRevolutionConfig(BaseDjangoRevolutionConfig):
         
         # Add default django-cfg zones if enabled
         try:
-            from django_cfg.modules.base import BaseModule
-            base_module = BaseModule()
+            from django_cfg.modules.base import BaseCfgModule
+            base_module = BaseCfgModule()
             
             support_enabled = base_module.is_support_enabled()
             accounts_enabled = base_module.is_accounts_enabled()
             newsletter_enabled = base_module.is_newsletter_enabled()
             leads_enabled = base_module.is_leads_enabled()
+            knowbase_enabled = base_module.is_knowbase_enabled()
+            agents_enabled = base_module.is_agents_enabled()
+            tasks_enabled = base_module.is_tasks_enabled()
             
             # Add Support zone if enabled
             default_support_zone = 'cfg_support'
@@ -138,6 +141,42 @@ class ExtendedRevolutionConfig(BaseDjangoRevolutionConfig):
                     auth_required=False,
                     version="v1",
                 )
+            
+            # Add Knowbase zone if enabled
+            default_knowbase_zone = 'cfg_knowbase'
+            if knowbase_enabled and default_knowbase_zone not in zones:
+                zones[default_knowbase_zone] = ZoneConfig(
+                    apps=["django_cfg.apps.knowbase"],
+                    title="Knowbase API",
+                    description="Knowledge base, AI chat, embeddings, and search API",
+                    public=False,
+                    auth_required=True,
+                    version="v1",
+                )
+            
+            # Add Agents zone if enabled
+            default_agents_zone = 'cfg_agents'
+            if agents_enabled and default_agents_zone not in zones:
+                zones[default_agents_zone] = ZoneConfig(
+                    apps=["django_cfg.apps.agents"],
+                    title="Agents API",
+                    description="Agent definitions, executions, workflows, and tools API",
+                    public=False,
+                    auth_required=True,
+                    version="v1",
+                )
+            
+            # Add Tasks zone if enabled
+            default_tasks_zone = 'cfg_tasks'
+            if tasks_enabled and default_tasks_zone not in zones:
+                zones[default_tasks_zone] = ZoneConfig(
+                    apps=["django_cfg.apps.tasks"],
+                    title="Tasks API",
+                    description="Tasks, workflows, and automation API",
+                    public=False,
+                    auth_required=True,
+                    version="v1",
+                )
         except Exception:
             pass
             

django_cfg/models/security.py

@@ -0,0 +1,125 @@
+"""
+Security Configuration Model
+
+Django security settings with Pydantic 2.
+"""
+
+from typing import List, Dict, Any
+from pydantic import Field, field_validator
+from .base import BaseConfig
+
+
+class SecurityConfig(BaseConfig):
+    """
+    🔒 Security Configuration - Django security settings
+    
+    Handles CORS, CSRF, SSL, sessions, and other security configurations
+    with environment-aware defaults.
+    """
+    
+    # CORS settings
+    cors_enabled: bool = Field(default=True, description="Enable CORS support")
+    cors_allow_all_origins: bool = Field(default=False, description="Allow all origins (dev only)")
+    cors_allowed_origins: List[str] = Field(default_factory=list, description="Allowed CORS origins")
+    cors_allow_credentials: bool = Field(default=True, description="Allow CORS credentials")
+    
+    # CSRF settings
+    csrf_enabled: bool = Field(default=True, description="Enable CSRF protection")
+    csrf_trusted_origins: List[str] = Field(default_factory=list, description="CSRF trusted origins")
+    csrf_cookie_secure: bool = Field(default=False, description="Secure CSRF cookies")
+    
+    # SSL/HTTPS settings
+    ssl_redirect: bool = Field(default=False, description="Redirect HTTP to HTTPS")
+    hsts_enabled: bool = Field(default=False, description="Enable HTTP Strict Transport Security")
+    hsts_max_age: int = Field(default=31536000, description="HSTS max age in seconds")
+    
+    # Session settings
+    session_cookie_secure: bool = Field(default=False, description="Secure session cookies")
+    session_cookie_age: int = Field(default=86400, description="Session cookie age in seconds")
+    
+    # Production domains for auto-configuration
+    production_domains: List[str] = Field(
+        default_factory=lambda: [
+            "https://carapis.com",
+            "https://api2.carapis.com",
+            "https://djangocfg.com",
+        ],
+        description="Production domains for security configuration"
+    )
+    
+    @field_validator('hsts_max_age')
+    @classmethod
+    def validate_hsts_max_age(cls, v: int) -> int:
+        """Validate HSTS max age."""
+        if v < 0:
+            raise ValueError("HSTS max age must be non-negative")
+        return v
+    
+    def configure_for_production(self) -> None:
+        """Configure security settings for production."""
+        self.cors_allow_all_origins = False
+        self.cors_allowed_origins = self.production_domains
+        self.csrf_cookie_secure = True
+        self.csrf_trusted_origins = self.production_domains
+        self.ssl_redirect = True
+        self.hsts_enabled = True
+        self.session_cookie_secure = True
+    
+    def configure_for_development(self) -> None:
+        """Configure security settings for development."""
+        self.cors_allow_all_origins = True
+        self.cors_allowed_origins = []
+        self.csrf_cookie_secure = False
+        self.csrf_trusted_origins = []
+        self.ssl_redirect = False
+        self.hsts_enabled = False
+        self.session_cookie_secure = False
+    
+    def to_django_settings(self) -> Dict[str, Any]:
+        """Convert to Django security settings."""
+        settings = {}
+        
+        # CORS settings
+        if self.cors_enabled:
+            settings.update({
+                'CORS_ALLOW_ALL_ORIGINS': self.cors_allow_all_origins,
+                'CORS_ALLOWED_ORIGINS': self.cors_allowed_origins,
+                'CORS_ALLOW_CREDENTIALS': self.cors_allow_credentials,
+            })
+            
+            # Add corsheaders to middleware if not present
+            # This will be handled by the main ConfigToolkit
+        
+        # CSRF settings
+        settings.update({
+            'CSRF_TRUSTED_ORIGINS': self.csrf_trusted_origins,
+            'CSRF_COOKIE_SECURE': self.csrf_cookie_secure,
+        })
+        
+        # SSL/HTTPS settings
+        if self.ssl_redirect:
+            settings['SECURE_SSL_REDIRECT'] = True
+        
+        if self.hsts_enabled:
+            settings.update({
+                'SECURE_HSTS_SECONDS': self.hsts_max_age,
+                'SECURE_HSTS_INCLUDE_SUBDOMAINS': True,
+                'SECURE_HSTS_PRELOAD': True,
+            })
+        
+        # Session settings
+        settings.update({
+            'SESSION_COOKIE_SECURE': self.session_cookie_secure,
+            'SESSION_COOKIE_AGE': self.session_cookie_age,
+            'SESSION_COOKIE_HTTPONLY': True,
+            'SESSION_COOKIE_SAMESITE': 'Lax',
+        })
+        
+        # Additional security headers
+        settings.update({
+            'SECURE_CONTENT_TYPE_NOSNIFF': True,
+            'SECURE_BROWSER_XSS_FILTER': True,
+            'X_FRAME_OPTIONS': 'DENY',
+        })
+        
+        return settings

django_cfg/models/services.py

@@ -12,7 +12,7 @@ from typing import Dict, Optional, Any, Literal, List
 from pydantic import BaseModel, Field, field_validator, model_validator, EmailStr
 from pathlib import Path
 
-from django_cfg.exceptions import ConfigurationError, ValidationError
+from django_cfg.core.exceptions import ConfigurationError, ValidationError
 
 
 class EmailConfig(BaseModel):

django_cfg/modules/__init__.py

@@ -6,61 +6,7 @@ All modules automatically receive configuration from the DjangoConfig instance
 without requiring manual parameter passing.
 """
 
-from typing import TYPE_CHECKING, Optional, Any
-import importlib
-import os
-
-if TYPE_CHECKING:
-    from django_cfg.core.config import DjangoConfig
-
-
-class BaseModule:
-    """
-    Base class for auto-configuring django_cfg modules.
-
-    All modules inherit from this to automatically receive
-    configuration from the DjangoConfig instance.
-    """
-
-    _config_instance: Optional["DjangoConfig"] = None
-
-    @classmethod
-    def get_config(cls) -> "DjangoConfig":
-        """Get the DjangoConfig instance automatically."""
-        if cls._config_instance is None:
-            cls._config_instance = cls._discover_config()
-        return cls._config_instance
-
-    @classmethod
-    def _discover_config(cls) -> "DjangoConfig":
-        """Discover the DjangoConfig instance from Django settings."""
-        try:
-            # Try to get config from Django settings module
-            settings_module = os.environ.get("DJANGO_SETTINGS_MODULE")
-            if settings_module:
-                settings_mod = importlib.import_module(settings_module)
-                if hasattr(settings_mod, "config"):
-                    return settings_mod.config
-
-            # Fallback: try to create minimal config from Django settings
-            from django.conf import settings
-            from django_cfg import DjangoConfig
-
-            return DjangoConfig(
-                project_name=getattr(settings, "PROJECT_NAME", "Django Project"),
-                secret_key=settings.SECRET_KEY,
-                debug=settings.DEBUG,
-                allowed_hosts=settings.ALLOWED_HOSTS,
-            )
-
-        except Exception as e:
-            raise RuntimeError(f"Could not discover DjangoConfig instance: {e}")
-
-    @classmethod
-    def reset_config(cls):
-        """Reset the cached config instance (useful for testing)."""
-        cls._config_instance = None
-
+from .base import BaseCfgModule
 
 # Export the base module
-__all__ = ["BaseModule"]
+__all__ = ["BaseCfgModule"]

django_cfg/modules/base.py

@@ -4,56 +4,69 @@ Base Module for Django CFG
 Provides base functionality for all auto-configuring modules.
 """
 
-from typing import Any, Optional
+from typing import Any, Optional, TYPE_CHECKING
 from abc import ABC
+import importlib
+import os
 
+if TYPE_CHECKING:
+    from django_cfg.core.config import DjangoConfig
 
-class BaseModule(ABC):
+
+class BaseCfgModule(ABC):
     """
     Base class for all django_cfg modules.
     
     Provides common functionality and configuration access.
+    Auto-discovers configuration from Django settings.
     """
     
+    _config_instance: Optional["DjangoConfig"] = None
+    
     def __init__(self):
         """Initialize the base module."""
         self._config = None
     
-    def get_config(self) -> Optional[Any]:
-        """
-        Get the current Django configuration instance.
-        
-        Returns:
-            The current DjangoConfig instance or None
-        """
-        if self._config is None:
+    @classmethod
+    def get_config(cls) -> Optional["DjangoConfig"]:
+        """Get the DjangoConfig instance automatically."""
+        if cls._config_instance is None:
             try:
-                # Try to get config from the current context first
-                from django_cfg.core.config import get_current_config
-                self._config = get_current_config()
-                
-                # If that fails, try to import directly from Django settings
-                if self._config is None:
-                    try:
-                        from django.conf import settings
-                        if hasattr(settings, 'DJANGO_SETTINGS_MODULE'):
-                            # Import the config module directly
-                            import importlib
-                            settings_module_name = settings.DJANGO_SETTINGS_MODULE
-                            if settings_module_name:
-                                # Get the config module (usually api.config)
-                                config_module_name = settings_module_name.replace('.settings', '.config')
-                                config_module = importlib.import_module(config_module_name)
-                                if hasattr(config_module, 'config'):
-                                    self._config = config_module.config
-                    except Exception:
-                        pass
-                        
-            except (ImportError, AttributeError):
-                # Fallback - config might not be available yet
-                pass
-        
-        return self._config
+                cls._config_instance = cls._discover_config()
+            except Exception:
+                # Return None if config discovery fails (e.g., during Django startup)
+                return None
+        return cls._config_instance
+
+    @classmethod
+    def _discover_config(cls) -> "DjangoConfig":
+        """Discover the DjangoConfig instance from Django settings."""
+        try:
+            # Try to get config from Django settings module
+            settings_module = os.environ.get("DJANGO_SETTINGS_MODULE")
+            if settings_module:
+                settings_mod = importlib.import_module(settings_module)
+                if hasattr(settings_mod, "config"):
+                    return settings_mod.config
+
+            # Fallback: try to create minimal config from Django settings
+            from django.conf import settings
+            from django_cfg.core.config import DjangoConfig
+
+            return DjangoConfig(
+                project_name=getattr(settings, "PROJECT_NAME", "Django Project"),
+                secret_key=settings.SECRET_KEY,
+                debug=settings.DEBUG,
+                allowed_hosts=settings.ALLOWED_HOSTS,
+            )
+
+        except Exception as e:
+            raise RuntimeError(f"Could not discover DjangoConfig instance: {e}")
+
+    @classmethod
+    def reset_config(cls):
+        """Reset the cached config instance (useful for testing)."""
+        cls._config_instance = None
     
     def set_config(self, config: Any) -> None:
         """
@@ -73,13 +86,12 @@ class BaseModule(ABC):
             default: The default value to return if the key is not found
         """
         try:
-            # Try to get config if not already set
-            if self._config is None:
-                self._config = self.get_config()
+            # Get config using class method
+            config = self.get_config()
             
             # If config is available, get the key
-            if self._config is not None:
-                result = getattr(self._config, key, default)
+            if config is not None:
+                result = getattr(config, key, default)
                 return bool(result)
             
             # Fallback to default if no config available
@@ -125,25 +137,39 @@ class BaseModule(ABC):
         """
         return self._get_config_key('enable_leads', False)
     
+    def is_agents_enabled(self) -> bool:
+        """
+        Check if django-cfg Agents is enabled.
+        
+        Returns:
+            True if Agents is enabled, False otherwise
+        """
+        return self._get_config_key('enable_agents', False)
+    
+    def is_knowbase_enabled(self) -> bool:
+        """
+        Check if django-cfg Knowbase is enabled.
+        
+        Returns:
+            True if Knowbase is enabled, False otherwise
+        """
+        return self._get_config_key('enable_knowbase', False)
+    
     def is_tasks_enabled(self) -> bool:
         """
-        Check if django-cfg Tasks (Dramatiq) is enabled.
+        Check if django-cfg Tasks is enabled.
+        Auto-enables if knowbase or agents are enabled.
         
         Returns:
             True if Tasks is enabled, False otherwise
         """
-        try:
-            config = self.get_config()
-            if config is not None and hasattr(config, 'tasks'):
-                tasks_config = getattr(config, 'tasks', None)
-                if tasks_config is not None:
-                    return getattr(tasks_config, 'enabled', False)
-            return False
-        except Exception:
-            return False
+        # Auto-enable if knowbase or agents are enabled
+        if self.is_knowbase_enabled() or self.is_agents_enabled():
+            return True
+        return self._get_config_key('enable_tasks', False)
 
 
 # Export the base class
 __all__ = [
-    "BaseModule",
+    "BaseCfgModule",
 ]

django_cfg/modules/django_currency/service.py

@@ -9,7 +9,7 @@ from typing import Optional, Dict, Any, Union, List
 from datetime import datetime, date
 from pathlib import Path
 
-from django_cfg.modules import BaseModule
+from django_cfg.modules import BaseCfgModule
 from .converter import CurrencyConverter
 from .cache import CurrencyCache
 
@@ -31,7 +31,7 @@ class CurrencyConversionError(CurrencyError):
     pass
 
 
-class DjangoCurrency(BaseModule):
+class DjangoCurrency(BaseCfgModule):
     """
     Currency Service for django_cfg, configured via DjangoConfig.
 

django_cfg/modules/django_email.py

@@ -11,10 +11,10 @@ from django.template.loader import render_to_string
 from django.utils.html import strip_tags
 from django.conf import settings
 
-from . import BaseModule
+from . import BaseCfgModule
 
 
-class DjangoEmailService(BaseModule):
+class DjangoEmailService(BaseCfgModule):
     """
     Auto-configuring email service that gets settings from DjangoConfig.