django-cfg 1.4.120__py3-none-any.whl → 1.5.2__py3-none-any.whl

django_cfg/models/tasks/config.py

@@ -1,209 +0,0 @@
-"""
-Main task configuration models.
-
-Contains TaskConfig class (main entry point) and related enums.
-Size: ~250 lines (focused on main configuration)
-"""
-
-import logging
-import os
-from enum import Enum
-from typing import Any, Dict, List, Optional
-
-from pydantic import BaseModel, Field, field_validator
-
-from django_cfg.models.base import BaseCfgAutoModule
-
-logger = logging.getLogger(__name__)
-
-
-class TaskBackend(str, Enum):
-    """Supported task backends."""
-    REARQ = "rearq"
-
-
-class QueuePriority(str, Enum):
-    """Standard queue priorities."""
-    CRITICAL = "critical"
-    HIGH = "high"
-    DEFAULT = "default"
-    LOW = "low"
-    BACKGROUND = "background"
-
-
-class TaskConfig(BaseModel, BaseCfgAutoModule):
-    """
-    High-level task system configuration.
-
-    Main entry point for configuring background task processing in Django-CFG.
-    Provides environment-aware defaults and automatic Redis integration.
-
-    Example:
-        ```python
-        from django_cfg.models.tasks import TaskConfig
-
-        tasks = TaskConfig(
-            enabled=True,
-            backend=TaskBackend.DRAMATIQ,
-        )
-        ```
-    """
-
-    # === Core Settings ===
-    enabled: bool = Field(
-        default=True,
-        description="Enable background task processing"
-    )
-    backend: TaskBackend = Field(
-        default=TaskBackend.REARQ,
-        description="Task processing backend"
-    )
-
-    def __init__(self, **data):
-        """Initialize TaskConfig with BaseCfgAutoModule support."""
-        super().__init__(**data)
-        # Initialize _config attribute for BaseCfgAutoModule
-        self._config = None
-
-    # === Backend-Specific Configuration ===
-    rearq: 'RearqConfig' = Field(
-        default_factory=lambda: None,
-        description="ReArq-specific configuration"
-    )
-
-    def model_post_init(self, __context: Any) -> None:
-        """Initialize backend configs with defaults after model creation."""
-        if self.rearq is None:
-            from .backends import RearqConfig
-            self.rearq = RearqConfig()
-
-    # === Environment-Specific Overrides ===
-    dev_processes: Optional[int] = Field(
-        default=2,
-        description="Number of processes in development environment"
-    )
-    prod_processes: Optional[int] = Field(
-        default=None,
-        description="Number of processes in production environment"
-    )
-
-    # === Auto-Configuration ===
-    auto_discover_tasks: bool = Field(
-        default=True,
-        description="Automatically discover tasks in Django apps"
-    )
-    task_modules: List[str] = Field(
-        default=["tasks"],
-        description="Module names to search for tasks"
-    )
-
-    @field_validator("enabled")
-    @classmethod
-    def validate_enabled_with_environment(cls, v: bool) -> bool:
-        """Validate task system can be enabled in current environment."""
-        if v:
-            # Check if we're in a test environment
-            if os.getenv("DJANGO_SETTINGS_MODULE", "").endswith("test"):
-                logger.info("Task system disabled in test environment")
-                return False
-
-            # Additional environment checks can be added here
-            # For example, checking if Redis is available
-
-        return v
-
-    def to_django_settings(self) -> Dict[str, Any]:
-        """
-        Generate Django settings for task system.
-
-        Returns:
-            Dictionary with task configuration for Django settings
-
-        Example:
-            >>> config = TaskConfig()
-            >>> settings = config.to_django_settings()
-            >>> "REARQ_REDIS_URL" in settings
-            True
-        """
-        if not self.enabled:
-            return {}
-
-        if self.backend == TaskBackend.REARQ:
-            return self.rearq.to_django_settings()
-
-        return {}
-
-    def get_smart_defaults(self):
-        """
-        Get smart default configuration for this module.
-
-        Returns:
-            TaskConfig with smart defaults based on environment
-        """
-        from .utils import get_default_task_config
-
-        config = self.get_config()
-        debug = getattr(config, 'debug', False) if config else False
-        return get_default_task_config(debug=debug)
-
-    def get_module_config(self):
-        """
-        Get the final configuration for this module.
-
-        Returns:
-            Self (TaskConfig instance)
-        """
-        return self
-
-    @classmethod
-    def auto_initialize_if_needed(cls) -> Optional['TaskConfig']:
-        """
-        Auto-initialize TaskConfig if needed based on config flags.
-
-        Returns:
-            TaskConfig instance if should be initialized, None otherwise
-
-        Example:
-            >>> task_config = TaskConfig.auto_initialize_if_needed()
-            >>> if task_config:
-            ...     print("Tasks enabled")
-        """
-        # Get config through BaseCfgModule
-        from django_cfg.modules import BaseCfgModule
-        base_module = BaseCfgModule()
-        config = base_module.get_config()
-
-        if not config:
-            return None
-
-        # Check if TaskConfig already exists
-        if hasattr(config, 'tasks') and config.tasks is not None:
-            # Set config reference and return existing
-            config.tasks.set_config(config)
-            return config.tasks
-
-        # Check if tasks should be enabled
-        if config.should_enable_tasks():
-            # Auto-initialize with smart defaults
-            task_config = cls().get_smart_defaults()
-            task_config.set_config(config)
-            config.tasks = task_config
-
-            logger.info("🚀 Auto-initialized TaskConfig (enabled by knowbase/agents/tasks flags)")
-
-            return task_config
-
-        return None
-
-
-# Resolve forward references for Pydantic v2
-from .backends import RearqConfig
-
-TaskConfig.model_rebuild()
-
-__all__ = [
-    "TaskConfig",
-    "TaskBackend",
-    "QueuePriority",
-    "RearqConfig",
-]

django_cfg/models/tasks/utils.py

@@ -1,162 +0,0 @@
-"""
-Task configuration utilities.
-
-Contains utility functions for task configuration:
-- Smart queue detection
-- Environment-aware defaults
-- Configuration validation
-
-Size: ~120 lines (focused on utilities)
-"""
-
-import logging
-from typing import TYPE_CHECKING, List, Optional
-
-if TYPE_CHECKING:
-    from .config import TaskConfig
-
-logger = logging.getLogger(__name__)
-
-
-def get_smart_queues(debug: bool = False) -> List[str]:
-    """
-    Get smart default queues based on enabled modules.
-
-    Automatically detects which django-cfg modules are enabled and adds
-    their corresponding queues to the default queue list.
-
-    Args:
-        debug: Whether running in debug mode (affects base queues)
-
-    Returns:
-        List of queue names appropriate for enabled modules
-
-    Example:
-        >>> queues = get_smart_queues(debug=True)
-        >>> "default" in queues
-        True
-    """
-    # Base queues
-    if debug:
-        base_queues = ["default"]
-    else:
-        base_queues = ["critical", "high", "default", "low", "background"]
-
-    # Try to detect enabled modules and add their queues
-    try:
-        from django_cfg.modules.base import BaseCfgModule
-        base_module = BaseCfgModule()
-
-        # Check for knowbase module (requires "knowbase" queue)
-        if base_module.is_knowbase_enabled():
-            if "knowbase" not in base_queues:
-                base_queues.append("knowbase")
-
-        # Check for payments module (requires "payments" queue)
-        if base_module.is_payments_enabled():
-            if "payments" not in base_queues:
-                base_queues.append("payments")
-
-        # Check for agents module (may require "agents" queue in future)
-        if base_module.is_agents_enabled():
-            if "agents" not in base_queues:
-                base_queues.append("agents")
-
-        logger.info(f"🎯 Smart queue detection: {base_queues}")
-
-    except Exception as e:
-        logger.warning(f"Failed to auto-detect queues, using defaults: {e}")
-
-    return base_queues
-
-
-def get_default_task_config(debug: bool = False) -> 'TaskConfig':
-    """
-    Get default task configuration based on environment.
-
-    Creates a TaskConfig with sensible defaults for development or production.
-
-    Args:
-        debug: Whether in debug/development mode
-
-    Returns:
-        TaskConfig with environment-appropriate defaults
-
-    Example:
-        >>> config = get_default_task_config(debug=True)
-        >>> config.rearq.max_jobs
-        10
-    """
-    from .backends import RearqConfig
-    from .config import TaskConfig
-
-    if debug:
-        # Development defaults
-        return TaskConfig(
-            rearq=RearqConfig(
-                redis_url="redis://localhost:6379/0",
-                db_url="sqlite://./rearq.db",
-                max_jobs=5,
-                job_timeout=300,
-            )
-        )
-    else:
-        # Production defaults
-        return TaskConfig(
-            rearq=RearqConfig(
-                redis_url="redis://localhost:6379/0",
-                db_url="postgresql://localhost/rearq",
-                max_jobs=20,
-                job_timeout=600,
-            )
-        )
-
-
-def validate_task_config(config: 'TaskConfig', redis_url: Optional[str] = None) -> bool:
-    """
-    Validate task configuration and dependencies.
-
-    Checks if the task configuration is valid and all required dependencies are available.
-
-    Args:
-        config: TaskConfig to validate
-        redis_url: Optional Redis URL to validate
-
-    Returns:
-        True if configuration is valid, False otherwise
-
-    Example:
-        >>> config = get_default_task_config()
-        >>> validate_task_config(config, "redis://localhost:6379/0")
-        True
-    """
-    if not config.enabled:
-        return True
-
-    # Check Redis URL if provided
-    if redis_url:
-        try:
-            from urllib.parse import urlparse
-            parsed = urlparse(redis_url)
-            if not parsed.scheme.startswith("redis"):
-                logger.error(f"Invalid Redis URL scheme: {parsed.scheme}")
-                return False
-        except Exception as e:
-            logger.error(f"Invalid Redis URL: {e}")
-            return False
-
-    # Check if ReArq is available
-    try:
-        import rearq
-    except ImportError as e:
-        logger.error(f"ReArq dependencies not available: {e}")
-        return False
-
-    return True
-
-
-__all__ = [
-    "get_smart_queues",
-    "get_default_task_config",
-    "validate_task_config",
-]