django-cfg 1.5.1__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",
-]

django_cfg/modules/django_q2/README.md

@@ -1,140 +0,0 @@
-# Django-Q2 Module
-
-Автоматическая синхронизация расписаний Django-Q2 из конфига в базу данных.
-
-## Зачем это нужно?
-
-Django-Q2 хранит расписания в базе данных, но **не создаёт их автоматически** из конфига.
-Этот модуль решает эту проблему - синхронизирует расписания после каждой миграции.
-
-## Использование
-
-### 1. Включи Django-Q2 в конфиге
-
-```python
-# config.py
-from django_cfg.models.django import DjangoQ2Config
-
-django_q2 = DjangoQ2Config(
-    enabled=True,  # ← Автоматически добавит django_q и django_cfg.modules.django_q2 в INSTALLED_APPS
-    schedules=[...]
-)
-```
-
-**Модуль подключается автоматически!** Не нужно вручную добавлять в INSTALLED_APPS.
-
-### 2. Определи расписания в конфиге
-
-```python
-from django_cfg.models.django import DjangoQ2Config, DjangoQ2ScheduleConfig
-
-django_q2 = DjangoQ2Config(
-    enabled=True,
-    schedules=[
-        DjangoQ2ScheduleConfig(
-            name="Sync balances hourly",
-            schedule_type="hourly",
-            command="sync_account_balances",
-            command_args=["--verbose"],
-        ),
-        DjangoQ2ScheduleConfig(
-            name="Cleanup daily",
-            schedule_type="cron",
-            cron="0 2 * * *",  # 2 AM каждый день
-            command="cleanup_old_data",
-            command_kwargs={"days": 30},
-        ),
-    ],
-)
-```
-
-### 3. Запусти миграции
-
-```bash
-python manage.py migrate
-```
-
-**Вывод:**
-```
-Running migrations:
-  ...
-  Syncing 2 Django-Q2 schedule(s)...
-    ✓ Created schedule: Sync balances hourly
-    ✓ Created schedule: Cleanup daily
-  ✅ Django-Q2 schedules synced: 2 created, 0 updated
-```
-
-### 4. Запусти qcluster
-
-```bash
-python manage.py qcluster
-```
-
-Готово! Расписания автоматически синхронизированы и работают.
-
-## Как это работает?
-
-1. **Модуль подключается** к сигналу `post_migrate`
-2. **После миграций** автоматически:
-   - Читает расписания из конфига
-   - Создаёт/обновляет их в базе данных (Schedule model)
-3. **Django-Q2 читает** расписания из базы и выполняет задачи
-
-## Ручная синхронизация (опционально)
-
-Если нужно синхронизировать без миграций:
-
-```bash
-python manage.py sync_django_q_schedules
-
-# Или с --dry-run для проверки:
-python manage.py sync_django_q_schedules --dry-run
-```
-
-## Безопасность
-
-- ✅ **Идемпотентность**: можно запускать много раз, не создаст дубликаты
-- ✅ **Без race conditions**: синхронизация происходит один раз за цикл миграций
-- ✅ **Graceful degradation**: если Django-Q2 не установлен, модуль просто молча пропустит синхронизацию
-- ✅ **Logging**: все операции логируются для отладки
-
-## Преимущества перед ручной синхронизацией
-
-| Аспект | Ручная синхронизация | Модуль |
-|--------|---------------------|--------|
-| Автоматизация | Нужно помнить запускать | Автоматически |
-| Деплой | Легко забыть | Всегда синхронизировано |
-| CI/CD | Нужно добавлять в скрипты | Работает из коробки |
-| Ошибки | Легко пропустить | Логи миграций |
-
-## Troubleshooting
-
-### Расписания не создаются
-
-Проверь:
-1. Модуль добавлен в INSTALLED_APPS
-2. `django_q2.enabled = True` в конфиге
-3. В конфиге есть расписания
-4. Миграции запущены: `python manage.py migrate`
-
-### Расписания не обновляются
-
-Запусти миграции повторно или используй ручную синхронизацию:
-```bash
-python manage.py migrate --run-syncdb
-# или
-python manage.py sync_django_q_schedules
-```
-
-### Логи синхронизации
-
-Включи DEBUG логи:
-```python
-LOGGING = {
-    'loggers': {
-        'django_cfg.modules.django_q2': {
-            'level': 'DEBUG',
-        },
-    },
-}
-```

django_cfg/modules/django_q2/__init__.py

@@ -1,8 +0,0 @@
-"""
-Django-Q2 module for django-cfg.
-
-Provides automatic schedule synchronization from config to database.
-"""
-from .apps import DjangoQ2ModuleConfig
-
-__all__ = ['DjangoQ2ModuleConfig']

django_cfg/modules/django_q2/apps.py

@@ -1,107 +0,0 @@
-"""
-AppConfig for Django-Q2 module with automatic schedule synchronization.
-"""
-import logging
-from django.apps import AppConfig
-from django.db.models.signals import post_migrate
-
-logger = logging.getLogger(__name__)
-
-
-def sync_schedules_after_migrate(sender, **kwargs):
-    """
-    Automatically sync Django-Q2 schedules after migrations.
-
-    This ensures schedules are always up-to-date after deployment.
-    Runs only once per migration cycle, safe from race conditions.
-    """
-    # Only run for the django_cfg_django_q2 app itself
-    if sender.name != 'django_cfg.modules.django_q2':
-        return
-
-    # Import here to avoid circular imports and ensure Django is ready
-    try:
-        from django_q.models import Schedule
-        from django_cfg.core.config import get_current_config
-    except ImportError as e:
-        logger.warning(f"Could not import Django-Q2 dependencies: {e}")
-        return
-
-    config = get_current_config()
-
-    if not config or not hasattr(config, 'django_q2') or not config.django_q2 or not config.django_q2.enabled:
-        logger.debug("Django-Q2 not enabled, skipping schedule sync")
-        return
-
-    enabled_schedules = config.django_q2.get_enabled_schedules()
-
-    if not enabled_schedules:
-        logger.debug("No Django-Q2 schedules found in config")
-        return
-
-    logger.info(f"Syncing {len(enabled_schedules)} Django-Q2 schedule(s)...")
-
-    created = 0
-    updated = 0
-
-    for schedule_config in enabled_schedules:
-        schedule_dict = schedule_config.to_django_q_format()
-        name = schedule_dict['name']
-
-        try:
-            schedule, created_flag = Schedule.objects.update_or_create(
-                name=name,
-                defaults=schedule_dict
-            )
-
-            if created_flag:
-                created += 1
-                logger.info(f"  ✓ Created schedule: {name}")
-            else:
-                updated += 1
-                logger.debug(f"  ✓ Updated schedule: {name}")
-
-        except Exception as e:
-            logger.error(f"  ✗ Failed to sync schedule '{name}': {e}")
-
-    logger.info(f"✅ Django-Q2 schedules synced: {created} created, {updated} updated")
-
-
-class DjangoQ2ModuleConfig(AppConfig):
-    """
-    AppConfig for Django-Q2 module.
-
-    Automatically syncs schedules from config to database after migrations.
-    This eliminates the need for manual `sync_django_q_schedules` command.
-
-    Features:
-    - Automatic schedule sync after migrations
-    - Safe from race conditions (runs only once)
-    - Logs all sync operations
-    - Gracefully handles missing dependencies
-
-    Usage:
-        Add to INSTALLED_APPS:
-        INSTALLED_APPS = [
-            ...
-            'django_cfg.modules.django_q2',  # Auto-syncs schedules
-        ]
-    """
-
-    default_auto_field = 'django.db.models.BigAutoField'
-    name = 'django_cfg.modules.django_q2'
-    verbose_name = 'Django-CFG Django-Q2 Module'
-
-    def ready(self):
-        """
-        Connect post_migrate signal to automatically sync schedules.
-
-        This runs after all migrations are complete, ensuring:
-        1. Database tables exist
-        2. Config is loaded
-        3. Schedules are synced only once per migration cycle
-        """
-        # Connect the signal
-        post_migrate.connect(sync_schedules_after_migrate, sender=self)
-
-        logger.debug(f"{self.verbose_name} initialized - auto-sync enabled")

django_cfg/modules/django_q2/management/commands/sync_django_q_schedules.py

@@ -1,74 +0,0 @@
-"""
-Management command to sync Django-Q2 schedules from config.
-
-Usage:
-    python manage.py sync_django_q_schedules           # Create/update schedules
-    python manage.py sync_django_q_schedules --dry-run # Show what would be created
-"""
-from django.core.management.base import BaseCommand
-from django_q.models import Schedule
-from django_cfg.core.config import get_current_config
-
-
-class Command(BaseCommand):
-    help = 'Sync Django-Q2 schedules from config to database'
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            '--dry-run',
-            action='store_true',
-            help='Show what would be created without actually creating',
-        )
-
-    def handle(self, *args, **options):
-        config = get_current_config()
-        
-        if not config:
-            self.stdout.write(self.style.ERROR('❌ No config found'))
-            return
-            
-        # Check if Django-Q2 is enabled
-        if not hasattr(config, 'django_q2') or not config.django_q2 or not config.django_q2.enabled:
-            self.stdout.write(self.style.WARNING('⚠️  Django-Q2 is not enabled in config'))
-            return
-        
-        enabled_schedules = config.django_q2.get_enabled_schedules()
-        
-        if not enabled_schedules:
-            self.stdout.write(self.style.WARNING('⚠️  No schedules found in config'))
-            return
-        
-        self.stdout.write(f'📋 Found {len(enabled_schedules)} schedule(s) in config\n')
-        
-        created = 0
-        updated = 0
-        
-        for schedule_config in enabled_schedules:
-            schedule_dict = schedule_config.to_django_q_format()
-            name = schedule_dict['name']
-            
-            if options['dry_run']:
-                self.stdout.write(f'  [DRY RUN] Would create/update: {name}')
-                continue
-            
-            # Update or create schedule
-            schedule, created_flag = Schedule.objects.update_or_create(
-                name=name,
-                defaults=schedule_dict
-            )
-            
-            if created_flag:
-                created += 1
-                self.stdout.write(self.style.SUCCESS(f'  ✓ Created: {name}'))
-            else:
-                updated += 1
-                self.stdout.write(self.style.SUCCESS(f'  ✓ Updated: {name}'))
-        
-        if not options['dry_run']:
-            self.stdout.write(self.style.SUCCESS(
-                f'\n✅ Summary: {created} created, {updated} updated'
-            ))
-        else:
-            self.stdout.write(self.style.WARNING(
-                f'\n[DRY RUN] Would create {len(enabled_schedules)} schedule(s)'
-            ))