django-cfg 1.4.106__py3-none-any.whl → 1.4.108__py3-none-any.whl

django_cfg/modules/django_tasks/management/commands/task_status.py

@@ -1,257 +0,0 @@
-"""
-Django management command for checking task system status.
-
-This command provides comprehensive status information about the
-Dramatiq task system, including queue statistics, worker status,
-and configuration details.
-"""
-
-import json
-from typing import Any, Dict
-
-from django.core.management.base import BaseCommand, CommandError
-
-from django_cfg.modules.django_logging import get_logger
-
-logger = get_logger('task_status')
-
-
-class Command(BaseCommand):
-    """
-    Display comprehensive task system status.
-
-    Shows information about:
-    - Task system configuration
-    - Redis connection status
-    - Queue statistics
-    - Worker status
-    - Discovered task modules
-    """
-
-    # Web execution metadata
-    web_executable = True
-    requires_input = False
-    is_destructive = False
-
-    help = "Display task system status and statistics"
-
-    def add_arguments(self, parser):
-        """Add command line arguments."""
-        parser.add_argument(
-            "--format",
-            choices=["text", "json"],
-            default="text",
-            help="Output format (default: text)",
-        )
-        parser.add_argument(
-            "--verbose",
-            action="store_true",
-            help="Show detailed information",
-        )
-
-    def handle(self, *args, **options):
-        """Handle the command execution."""
-        logger.info("Starting task_status command")
-        try:
-            # Import here to avoid issues if dramatiq is not installed
-            from django_cfg.modules.django_tasks import get_task_service
-
-            # Get task service
-            task_service = get_task_service()
-
-            # Get comprehensive health status
-            status = task_service.get_health_status()
-
-            # Format and display output
-            if options["format"] == "json":
-                self._output_json(status)
-            else:
-                self._output_text(status, options["verbose"])
-
-        except ImportError:
-            raise CommandError(
-                "Dramatiq dependencies not installed. "
-                "Install with: pip install django-cfg[tasks]"
-            )
-        except Exception as e:
-            logger.exception("Failed to get task status")
-            raise CommandError(f"Failed to get status: {e}")
-
-    def _output_json(self, status: Dict[str, Any]):
-        """Output status in JSON format."""
-        self.stdout.write(json.dumps(status, indent=2, default=str))
-
-    def _output_text(self, status: Dict[str, Any], verbose: bool):
-        """Output status in human-readable text format."""
-        # Header
-        self.stdout.write(
-            self.style.SUCCESS("=== Django-CFG Task System Status ===")
-        )
-        self.stdout.write()
-
-        # Basic status
-        enabled = status.get("enabled", False)
-        if enabled:
-            self.stdout.write(
-                self.style.SUCCESS("✓ Task system is ENABLED")
-            )
-        else:
-            self.stdout.write(
-                self.style.ERROR("✗ Task system is DISABLED")
-            )
-            return
-
-        # Redis connection
-        redis_ok = status.get("redis_connection", False)
-        if redis_ok:
-            self.stdout.write(
-                self.style.SUCCESS("✓ Redis connection is OK")
-            )
-        else:
-            self.stdout.write(
-                self.style.ERROR("✗ Redis connection FAILED")
-            )
-
-        # Configuration validation
-        config_valid = status.get("configuration_valid", False)
-        if config_valid:
-            self.stdout.write(
-                self.style.SUCCESS("✓ Configuration is VALID")
-            )
-        else:
-            self.stdout.write(
-                self.style.ERROR("✗ Configuration is INVALID")
-            )
-
-        self.stdout.write()
-
-        # Configuration details (if verbose)
-        if verbose:
-            self._show_configuration_details()
-
-        # Queue statistics
-        queues = status.get("queues", [])
-        if queues:
-            self.stdout.write(
-                self.style.SUCCESS("=== Queue Statistics ===")
-            )
-            for queue in queues:
-                name = queue.get("name", "unknown")
-                pending = queue.get("pending", 0)
-                running = queue.get("running", 0)
-                completed = queue.get("completed", 0)
-                failed = queue.get("failed", 0)
-
-                self.stdout.write(f"Queue: {name}")
-                self.stdout.write(f"  Pending: {pending}")
-                self.stdout.write(f"  Running: {running}")
-                self.stdout.write(f"  Completed: {completed}")
-                self.stdout.write(f"  Failed: {failed}")
-                self.stdout.write()
-
-        # Worker status
-        workers = status.get("workers", [])
-        if workers:
-            self.stdout.write(
-                self.style.SUCCESS("=== Worker Status ===")
-            )
-            for worker in workers:
-                worker_id = worker.get("id", "unknown")
-                worker_status = worker.get("status", "unknown")
-                current_task = worker.get("current_task")
-                processed = worker.get("processed_tasks", 0)
-
-                status_style = (
-                    self.style.SUCCESS if worker_status == "active"
-                    else self.style.WARNING if worker_status == "idle"
-                    else self.style.ERROR
-                )
-
-                self.stdout.write(f"Worker: {worker_id}")
-                self.stdout.write(f"  Status: {status_style(worker_status)}")
-                if current_task:
-                    self.stdout.write(f"  Current Task: {current_task}")
-                self.stdout.write(f"  Processed: {processed}")
-                self.stdout.write()
-        else:
-            self.stdout.write(
-                self.style.WARNING("No active workers found")
-            )
-
-        # Discovered modules
-        modules = status.get("discovered_modules", [])
-        if modules:
-            self.stdout.write(
-                self.style.SUCCESS("=== Discovered Task Modules ===")
-            )
-            for module in modules:
-                self.stdout.write(f"  - {module}")
-            self.stdout.write()
-        else:
-            self.stdout.write(
-                self.style.WARNING("No task modules discovered")
-            )
-
-        # Error information
-        if "error" in status:
-            self.stdout.write(
-                self.style.ERROR(f"Error: {status['error']}")
-            )
-
-    def _show_configuration_details(self):
-        """Show detailed configuration information."""
-        try:
-            from django_cfg.modules.django_tasks import get_task_service
-
-            task_service = get_task_service()
-            config = task_service.config
-
-            if not config:
-                self.stdout.write(
-                    self.style.WARNING("Configuration not available")
-                )
-                return
-
-            self.stdout.write(
-                self.style.SUCCESS("=== Configuration Details ===")
-            )
-
-            # Basic settings
-            self.stdout.write(f"Backend: {config.backend}")
-            self.stdout.write(f"Enabled: {config.enabled}")
-            self.stdout.write(f"Auto-discover: {config.auto_discover_tasks}")
-            self.stdout.write()
-
-            # Dramatiq settings
-            dramatiq = config.dramatiq
-            self.stdout.write("Dramatiq Configuration:")
-            self.stdout.write(f"  Redis DB: {dramatiq.redis_db}")
-            self.stdout.write(f"  Max Retries: {dramatiq.max_retries}")
-            self.stdout.write(f"  Processes: {dramatiq.processes}")
-            self.stdout.write(f"  Threads: {dramatiq.threads}")
-            self.stdout.write(f"  Queues: {', '.join(dramatiq.queues)}")
-            self.stdout.write(f"  Time Limit: {dramatiq.time_limit_seconds}s")
-            self.stdout.write(f"  Max Age: {dramatiq.max_age_seconds}s")
-            self.stdout.write()
-
-            # Worker settings
-            worker = config.worker
-            self.stdout.write("Worker Configuration:")
-            self.stdout.write(f"  Log Level: {worker.log_level}")
-            self.stdout.write(f"  Shutdown Timeout: {worker.shutdown_timeout}s")
-            self.stdout.write(f"  Health Check: {worker.health_check_enabled}")
-            if worker.max_memory_mb:
-                self.stdout.write(f"  Memory Limit: {worker.max_memory_mb}MB")
-            self.stdout.write()
-
-            # Middleware
-            if dramatiq.middleware:
-                self.stdout.write("Middleware Stack:")
-                for middleware in dramatiq.middleware:
-                    self.stdout.write(f"  - {middleware}")
-                self.stdout.write()
-
-        except Exception as e:
-            self.stdout.write(
-                self.style.ERROR(f"Failed to show configuration: {e}")
-            )

django_cfg/modules/django_tasks/service.py

@@ -1,281 +0,0 @@
-"""
-Django-CFG Task Service.
-
-Main DjangoTasks class for Dramatiq integration.
-"""
-
-import logging
-from typing import Any, Dict, List, Optional
-from urllib.parse import urlparse
-
-from django_cfg.models.django.constance import ConstanceField
-from django_cfg.models.tasks import TaskConfig, validate_task_config
-
-from ..base import BaseCfgModule
-
-# Django imports
-try:
-    from django.apps import apps
-except ImportError:
-    apps = None
-
-# Optional imports
-try:
-    import dramatiq
-except ImportError:
-    dramatiq = None
-
-try:
-    import redis
-except ImportError:
-    redis = None
-
-logger = logging.getLogger(__name__)
-
-
-class DjangoTasks(BaseCfgModule):
-    """
-    Simplified Django-CFG task service.
-
-    Focuses on essential functionality:
-    - Configuration management
-    - Task discovery
-    - Health checks
-    - Constance integration
-    """
-
-    def __init__(self):
-        super().__init__()
-        self._config: Optional[TaskConfig] = None
-        self._redis_url: Optional[str] = None
-
-    @property
-    def config(self) -> Optional[TaskConfig]:
-        """Get task configuration (lazy-loaded)."""
-        if self._config is None:
-            try:
-                django_config = self.get_config()
-                if django_config and hasattr(django_config, 'tasks'):
-                    self._config = django_config.tasks
-                    logger.debug(f"Loaded TaskConfig: enabled={self._config.enabled if self._config else False}")
-                else:
-                    # Fallback: try direct import
-                    try:
-                        from api.config import config as api_config
-                        if hasattr(api_config, 'tasks') and api_config.tasks:
-                            self._config = api_config.tasks
-                            logger.debug(f"Loaded TaskConfig from api.config: enabled={self._config.enabled}")
-                    except ImportError:
-                        logger.debug("Could not import api.config")
-            except Exception as e:
-                logger.warning(f"Failed to get task config: {e}")
-
-        return self._config
-
-    def is_enabled(self) -> bool:
-        """Check if task system is enabled and properly configured."""
-        if not self.config or not self.config.enabled:
-            return False
-
-        if dramatiq is None:
-            logger.warning("Dramatiq not available")
-            return False
-
-        return True
-
-    def get_redis_url(self) -> Optional[str]:
-        """Get Redis URL using the same logic as Dramatiq settings generation."""
-        if self._redis_url is None:
-            config = self.get_config()
-
-            if not config:
-                raise RuntimeError("No Django-CFG configuration available")
-
-            # Get Redis URL from cache config
-            if hasattr(config, 'cache_default') and config.cache_default:
-                self._redis_url = getattr(config.cache_default, 'redis_url', None)
-                if self._redis_url:
-                    logger.debug(f"Got Redis URL from cache config: {self._redis_url}")
-                    return self._redis_url
-
-            # If no cache_default, try Django cache settings
-            try:
-                from django.conf import settings
-                if hasattr(settings, 'CACHES') and 'default' in settings.CACHES:
-                    cache_config = settings.CACHES['default']
-                    if cache_config.get('BACKEND') == 'django_redis.cache.RedisCache':
-                        self._redis_url = cache_config.get('LOCATION')
-                        if self._redis_url:
-                            logger.debug(f"Got Redis URL from Django cache settings: {self._redis_url}")
-                            return self._redis_url
-            except Exception as e:
-                logger.debug(f"Could not get Redis URL from Django settings: {e}")
-
-            # Try DRAMATIQ_BROKER settings
-            try:
-                from django.conf import settings
-                if hasattr(settings, 'DRAMATIQ_BROKER'):
-                    dramatiq_config = settings.DRAMATIQ_BROKER
-                    if isinstance(dramatiq_config, dict) and 'OPTIONS' in dramatiq_config:
-                        self._redis_url = dramatiq_config['OPTIONS'].get('url')
-                        if self._redis_url:
-                            logger.debug(f"Got Redis URL from DRAMATIQ_BROKER settings: {self._redis_url}")
-                            return self._redis_url
-            except Exception as e:
-                logger.debug(f"Could not get Redis URL from DRAMATIQ_BROKER settings: {e}")
-
-            raise RuntimeError("No Redis URL found in cache configuration, Django settings, or DRAMATIQ_BROKER")
-
-        return self._redis_url
-
-    def get_redis_client(self):
-        """Get Redis client instance."""
-        redis_url = self.get_redis_url()
-        if not redis_url or redis is None:
-            return None
-
-        try:
-            parsed = urlparse(redis_url)
-
-            # Extract database from URL path
-            db = 1  # Default
-            if parsed.path and parsed.path != "/":
-                try:
-                    db = int(parsed.path.lstrip('/'))
-                except ValueError:
-                    pass
-            elif self.config and self.config.dramatiq:
-                db = self.config.dramatiq.redis_db
-
-            logger.debug(f"Using Redis DB: {db} from URL: {redis_url}")
-
-            return redis.Redis(
-                host=parsed.hostname or 'localhost',
-                port=parsed.port or 6379,
-                db=db,
-                password=parsed.password,
-                socket_timeout=5
-            )
-        except Exception as e:
-            logger.error(f"Failed to create Redis client: {e}")
-            return None
-
-    def check_redis_connection(self) -> bool:
-        """Check if Redis connection is available."""
-        redis_client = self.get_redis_client()
-        if not redis_client:
-            return False
-
-        try:
-            redis_client.ping()
-            return True
-        except Exception as e:
-            logger.error(f"Redis connection failed: {e}")
-            return False
-
-    def validate_configuration(self) -> bool:
-        """Validate complete task system configuration."""
-        if not self.config:
-            logger.error("Task configuration not available")
-            return False
-
-        redis_url = self.get_redis_url()
-        if not redis_url:
-            logger.error("Redis URL not configured")
-            return False
-
-        return validate_task_config(self.config, redis_url)
-
-    def discover_tasks(self) -> List[str]:
-        """Discover task modules in Django apps."""
-        if not self.config or not self.config.auto_discover_tasks:
-            return []
-
-        discovered = []
-
-        if apps is None:
-            logger.warning("Django apps not available")
-            return []
-
-        try:
-            for app_config in apps.get_app_configs():
-                for module_name in self.config.task_modules:
-                    module_path = f"{app_config.name}.{module_name}"
-                    try:
-                        __import__(module_path)
-                        discovered.append(module_path)
-                        logger.debug(f"Discovered task module: {module_path}")
-                    except ImportError:
-                        pass
-                    except Exception as e:
-                        logger.warning(f"Error importing task module {module_path}: {e}")
-        except Exception as e:
-            logger.error(f"Task discovery failed: {e}")
-
-        return discovered
-
-    def get_constance_fields(self) -> List[ConstanceField]:
-        """Get Constance fields for Dramatiq configuration."""
-        if not self.is_enabled():
-            return []
-
-        fields = [
-            ConstanceField(
-                name="DRAMATIQ_WORKER_PROCESSES",
-                default=self.config.dramatiq.processes if self.config else 2,
-                help_text="Number of worker processes for Dramatiq",
-                field_type="int",
-                group="Tasks",
-            ),
-            ConstanceField(
-                name="DRAMATIQ_WORKER_THREADS",
-                default=self.config.dramatiq.threads if self.config else 4,
-                help_text="Number of threads per worker process",
-                field_type="int",
-                group="Tasks",
-            ),
-            ConstanceField(
-                name="DRAMATIQ_MAX_RETRIES",
-                default=3,
-                help_text="Maximum number of retries for failed tasks",
-                field_type="int",
-                group="Tasks",
-            ),
-            ConstanceField(
-                name="DRAMATIQ_TASK_TIMEOUT",
-                default=600,
-                help_text="Task timeout in seconds (10 minutes default)",
-                field_type="int",
-                group="Tasks",
-            ),
-            ConstanceField(
-                name="DRAMATIQ_PROMETHEUS_ENABLED",
-                default=int(self.config.dramatiq.prometheus_enabled if self.config else False),
-                help_text="Enable Prometheus metrics for Dramatiq (0=disabled, 1=enabled)",
-                field_type="bool",
-                group="Tasks",
-                required=False,
-            ),
-        ]
-
-        logger.debug(f"Generated {len(fields)} Constance fields for Dramatiq")
-        return fields
-
-    def get_health_status(self) -> Dict[str, Any]:
-        """Get comprehensive health status of task system."""
-        status = {
-            "enabled": self.is_enabled(),
-            "redis_connection": False,
-            "configuration_valid": False,
-            "discovered_modules": [],
-        }
-
-        if self.is_enabled():
-            status["redis_connection"] = self.check_redis_connection()
-            status["configuration_valid"] = self.validate_configuration()
-            status["discovered_modules"] = self.discover_tasks()
-
-        return status
-
-
-__all__ = ["DjangoTasks"]

django_cfg/modules/django_tasks/settings.py

@@ -1,107 +0,0 @@
-"""
-Dramatiq settings generation.
-
-Functions to generate Dramatiq settings from DjangoConfig.
-"""
-
-import logging
-from typing import Any, Dict, Optional
-
-logger = logging.getLogger(__name__)
-
-
-def generate_dramatiq_settings_from_config(config=None) -> Optional[Dict[str, Any]]:
-    """
-    Generate Dramatiq settings from DjangoConfig instance.
-
-    Args:
-        config: DjangoConfig instance (optional, will auto-discover if not provided)
-
-    Returns:
-        Dict[str, Any]: Dramatiq settings dictionary or None if not enabled
-    """
-    # If config provided, use it directly
-    if config is not None:
-        try:
-            if not hasattr(config, "tasks") or not config.tasks or not config.tasks.enabled:
-                return None
-
-            # Get Redis URL from cache configuration
-            redis_url = None
-            if config.cache_default and hasattr(config.cache_default, 'redis_url'):
-                redis_url = config.cache_default.redis_url
-            elif config.cache_default and hasattr(config.cache_default, 'location'):
-                redis_url = config.cache_default.location
-            else:
-                redis_url = "redis://localhost:6379"
-
-            if redis_url:
-                dramatiq_settings = config.tasks.get_dramatiq_settings(redis_url)
-                logger.debug(f"Generated Dramatiq settings with Redis URL: {redis_url}")
-                return dramatiq_settings
-            else:
-                logger.warning("Tasks enabled but no Redis URL available for Dramatiq")
-                return None
-
-        except Exception as e:
-            logger.error(f"Failed to generate Dramatiq settings: {e}")
-            return None
-
-    # Auto-discover config if not provided
-    try:
-        from ..base import BaseCfgModule
-
-        base_module = BaseCfgModule()
-        config = base_module.get_config()
-
-        if not config or not hasattr(config, 'tasks') or not config.tasks or not config.tasks.enabled:
-            return None
-
-        # Get Redis URL from cache config or environment
-        redis_url = None
-        if hasattr(config, 'cache_default') and config.cache_default:
-            redis_url = getattr(config.cache_default, 'redis_url', None)
-
-        if not redis_url:
-            # Fallback to environment or default
-            import os
-            redis_url = os.getenv('REDIS_URL', 'redis://localhost:6379/1')
-
-        # Generate Dramatiq settings
-        dramatiq_settings = config.tasks.get_dramatiq_settings(redis_url)
-
-        # Ensure we only use Redis broker (no RabbitMQ)
-        if 'DRAMATIQ_BROKER' in dramatiq_settings:
-            dramatiq_settings['DRAMATIQ_BROKER']['BROKER'] = 'dramatiq.brokers.redis.RedisBroker'
-
-        logger.info(f"✅ Generated Dramatiq settings with Redis broker and {len(config.tasks.dramatiq.queues)} queues")
-        return dramatiq_settings
-
-    except Exception as e:
-        logger.error(f"Failed to generate Dramatiq settings: {e}")
-        return None
-
-
-def extend_constance_config_with_tasks():
-    """Extend Constance configuration with Dramatiq task fields if tasks are enabled."""
-    try:
-        from .factory import get_task_service
-
-        service = get_task_service()
-        if not service.is_enabled():
-            logger.debug("Task system not enabled, skipping Constance extension")
-            return []
-
-        fields = service.get_constance_fields()
-        logger.info(f"🔧 Extended Constance with {len(fields)} task configuration fields")
-        return fields
-
-    except Exception as e:
-        logger.error(f"Failed to extend Constance config with tasks: {e}")
-        return []
-
-
-__all__ = [
-    "generate_dramatiq_settings_from_config",
-    "extend_constance_config_with_tasks",
-]