django-cfg 1.4.116__py3-none-any.whl → 1.5.14__py3-none-any.whl

django_cfg/apps/integrations/rq/_cfg/dependencies.py

@@ -0,0 +1,313 @@
+#!/usr/bin/env python
+"""
+Django-RQ dependency checker.
+
+Validates that all required dependencies for django-rq are installed.
+Provides beautiful Rich-formatted error messages with installation instructions.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+from typing import Dict
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+
+class RQDependencyError(ImportError):
+    """Raised when required RQ dependencies are missing."""
+    pass
+
+
+class DependencyChecker:
+    """
+    Check and validate RQ dependencies.
+
+    Required dependencies:
+    - django-rq: Django integration for RQ
+    - redis: Python Redis client
+    - rq: Redis Queue library
+
+    Optional dependencies:
+    - rq-scheduler: Cron-style scheduling
+    - hiredis: High-performance Redis protocol parser
+    """
+
+    # Required dependencies
+    REQUIRED_DEPS = {
+        "django_rq": "django-rq>=3.0.0",
+        "redis": "redis>=4.0.0",
+        "rq": "rq>=1.10.0",
+    }
+
+    # Optional dependencies
+    OPTIONAL_DEPS = {
+        "rq_scheduler": "rq-scheduler>=0.13.0",
+        "hiredis": "hiredis>=2.0.0",
+    }
+
+    # Package descriptions
+    DESCRIPTIONS = {
+        "django_rq": "Django integration for RQ",
+        "redis": "Python Redis client",
+        "rq": "Redis Queue (RQ) library",
+        "rq_scheduler": "Cron-style scheduling for RQ",
+        "hiredis": "High-performance Redis parser",
+    }
+
+    @classmethod
+    def check_package(cls, package_name: str) -> bool:
+        """
+        Check if a package is installed.
+
+        Args:
+            package_name: Python package name (import name)
+
+        Returns:
+            True if installed, False otherwise
+        """
+        return importlib.util.find_spec(package_name) is not None
+
+    @classmethod
+    def check_all(cls, raise_on_missing: bool = True) -> Dict[str, bool]:
+        """
+        Check all RQ dependencies.
+
+        Args:
+            raise_on_missing: If True, raise exception when required deps missing
+
+        Returns:
+            Dictionary mapping package names to availability status
+
+        Raises:
+            RQDependencyError: If required dependencies are missing and raise_on_missing=True
+        """
+        status = {}
+
+        # Check required dependencies
+        for package_name in cls.REQUIRED_DEPS:
+            status[package_name] = cls.check_package(package_name)
+
+        # Check optional dependencies
+        for package_name in cls.OPTIONAL_DEPS:
+            status[package_name] = cls.check_package(package_name)
+
+        # Check if any required dependencies are missing
+        missing_required = [
+            pkg for pkg in cls.REQUIRED_DEPS if not status.get(pkg, False)
+        ]
+
+        missing_optional = [
+            pkg for pkg in cls.OPTIONAL_DEPS if not status.get(pkg, False)
+        ]
+
+        if missing_required and raise_on_missing:
+            cls._raise_missing_error(missing_required, missing_optional)
+
+        return status
+
+    @classmethod
+    def _raise_missing_error(
+        cls,
+        missing_required: list[str],
+        missing_optional: list[str],
+    ) -> None:
+        """
+        Raise a formatted error for missing dependencies.
+
+        Args:
+            missing_required: List of missing required packages
+            missing_optional: List of missing optional packages
+        """
+        console = Console()
+
+        # Header
+        console.print()
+        console.print(Panel(
+            "[bold red]MISSING Django-RQ DEPENDENCIES[/bold red]",
+            expand=True,
+        ))
+        console.print()
+        console.print("Django-CFG's RQ integration requires additional dependencies")
+        console.print()
+
+        # Required dependencies table
+        if missing_required:
+            table = Table(title="📦 REQUIRED Dependencies (Missing)", show_header=True)
+            table.add_column("Package", style="cyan")
+            table.add_column("Description", style="white")
+
+            for pkg in missing_required:
+                pip_name = cls.REQUIRED_DEPS[pkg].split(">=")[0]
+                desc = cls.DESCRIPTIONS.get(pkg, "")
+                table.add_row(f"❌ {pip_name}", desc)
+
+            console.print(table)
+            console.print()
+
+        # Optional dependencies table
+        if missing_optional:
+            table = Table(title="📦 OPTIONAL Dependencies (Missing)", show_header=True)
+            table.add_column("Package", style="cyan")
+            table.add_column("Description", style="white")
+
+            for pkg in missing_optional:
+                pip_name = cls.OPTIONAL_DEPS[pkg].split(">=")[0]
+                desc = cls.DESCRIPTIONS.get(pkg, "")
+                table.add_row(f"⚠️  {pip_name}", desc)
+
+            console.print(table)
+            console.print()
+
+        # Installation instructions
+        pkg_manager = _detect_package_manager()
+
+        if pkg_manager == "poetry":
+            console.print(Panel(
+                "[bold green]🔧 HOW TO FIX (POETRY)[/bold green]\n\n"
+                "Install all dependencies (RECOMMENDED)\n\n"
+                "[cyan]poetry add django-cfg[rq][/cyan]",
+                expand=False,
+            ))
+            console.print()
+            console.print(Panel(
+                "Or install manually:\n\n"
+                "[cyan]poetry add django-rq redis rq[/cyan]\n\n"
+                "Optional:\n"
+                "[dim]poetry add rq-scheduler hiredis[/dim]",
+                expand=False,
+            ))
+        else:  # pip
+            console.print(Panel(
+                "[bold green]🔧 HOW TO FIX (PIP)[/bold green]\n\n"
+                "Install all dependencies (RECOMMENDED)\n\n"
+                "[cyan]pip install django-cfg[rq][/cyan]",
+                expand=False,
+            ))
+            console.print()
+            console.print(Panel(
+                "Or install manually:\n\n"
+                "[cyan]pip install django-rq redis rq[/cyan]\n\n"
+                "Optional:\n"
+                "[dim]pip install rq-scheduler hiredis[/dim]",
+                expand=False,
+            ))
+
+        console.print()
+        console.print(Panel(
+            "[bold]📚 MORE INFORMATION[/bold]\n\n"
+            "Documentation: https://djangocfg.com/rq\n"
+            "Report Issues: https://github.com/django-cfg/django-cfg/issues",
+            title="📚 MORE INFORMATION",
+            expand=False,
+        ))
+        console.print()
+
+        raise RQDependencyError("Django-RQ dependencies are missing. See details above.")
+
+    @classmethod
+    def print_status(cls) -> None:
+        """Print dependency status in a nice table."""
+        console = Console()
+        status = cls.check_all(raise_on_missing=False)
+
+        table = Table(title="Django-RQ Dependency Status", show_header=True)
+        table.add_column("Package", style="cyan")
+        table.add_column("Status", style="white")
+        table.add_column("Type", style="white")
+
+        # Required dependencies
+        for pkg, spec in cls.REQUIRED_DEPS.items():
+            pip_name = spec.split(">=")[0]
+            status_str = "✅ Installed" if status.get(pkg, False) else "❌ Missing"
+            table.add_row(pip_name, status_str, "Required")
+
+        # Optional dependencies
+        for pkg, spec in cls.OPTIONAL_DEPS.items():
+            pip_name = spec.split(">=")[0]
+            status_str = "✅ Installed" if status.get(pkg, False) else "⚠️  Missing"
+            table.add_row(pip_name, status_str, "Optional")
+
+        console.print(table)
+
+
+def _detect_package_manager() -> str:
+    """
+    Detect which package manager is being used.
+
+    Returns:
+        'poetry' if poetry.lock exists, 'pip' otherwise
+    """
+    current = os.getcwd()
+
+    # Check up to 5 parent directories for poetry.lock
+    for _ in range(5):
+        if os.path.exists(os.path.join(current, 'poetry.lock')):
+            return 'poetry'
+
+        parent = os.path.dirname(current)
+        if parent == current:  # Reached root
+            break
+        current = parent
+
+    return 'pip'
+
+
+def check_rq_available() -> bool:
+    """
+    Lightweight check if RQ is available.
+
+    Returns:
+        True if all required RQ dependencies are installed
+    """
+    try:
+        status = DependencyChecker.check_all(raise_on_missing=False)
+        required_deps = ['django_rq', 'redis', 'rq']
+        return all(status.get(dep, False) for dep in required_deps)
+    except Exception:
+        # Fallback to simple import check
+        try:
+            import django_rq  # noqa: F401
+            import redis  # noqa: F401
+            import rq  # noqa: F401
+            return True
+        except ImportError:
+            return False
+
+
+def require_rq_feature() -> None:
+    """
+    Require RQ dependencies with detailed error message.
+
+    Raises:
+        ImportError: If required dependencies are missing
+    """
+    try:
+        if not check_rq_available():
+            DependencyChecker.check_all(raise_on_missing=True)
+    except RQDependencyError as e:
+        raise ImportError(str(e)) from e
+
+
+def check_rq_dependencies(raise_on_missing: bool = True) -> Dict[str, bool]:
+    """
+    Check RQ dependencies and optionally raise if missing.
+
+    Args:
+        raise_on_missing: If True, raise exception when required deps missing
+
+    Returns:
+        Dictionary mapping package names to availability status
+
+    Raises:
+        RQDependencyError: If dependencies missing and raise_on_missing=True
+    """
+    return DependencyChecker.check_all(raise_on_missing=raise_on_missing)
+
+
+def print_dependency_status() -> None:
+    """Print RQ dependency status table."""
+    DependencyChecker.print_status()

django_cfg/apps/integrations/rq/apps.py

@@ -0,0 +1,157 @@
+"""
+AppConfig for Django-RQ integration with monitoring and API capabilities.
+
+This app provides REST API endpoints for Django-RQ task queue monitoring,
+management, and statistics. It wraps django-rq's functionality with modern
+DRF ViewSets and unified django-cfg patterns.
+
+Features:
+- REST API for monitoring queues, workers, and jobs
+- Prometheus metrics integration
+- Enhanced monitoring interfaces
+- Job management (view, requeue, delete)
+- Integration with django-cfg ecosystem (Centrifugo, auth)
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from django.apps import AppConfig
+
+
+class RQAppConfig(AppConfig):
+    """
+    AppConfig for Django-RQ monitoring and management application.
+
+    Provides:
+    - REST API endpoints for monitoring
+    - Prometheus metrics export
+    - Job and queue management
+    - Worker statistics
+    - Integration with django-cfg authentication
+
+    Usage:
+        Add to INSTALLED_APPS:
+        INSTALLED_APPS = [
+            ...
+            'django_rq',  # Required: django-rq core
+            'django_cfg.apps.integrations.rq',  # Django-CFG RQ monitoring
+        ]
+
+        Configure in django-cfg config:
+        class MyConfig(BaseConfig):
+            django_rq: DjangoRQConfig = DjangoRQConfig(
+                enabled=True,
+                queues={
+                    'default': {
+                        'host': 'localhost',
+                        'port': 6379,
+                        'db': 0,
+                    }
+                },
+                prometheus_enabled=True,
+            )
+    """
+
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_cfg.apps.integrations.rq'
+    verbose_name = 'Django-CFG RQ Monitoring'
+    label = 'django_cfg_rq'
+
+    def ready(self):
+        """
+        Initialize the app when Django starts.
+
+        Registers:
+        - Admin interfaces (if not already registered)
+        - Signal handlers for monitoring
+        - Scheduled jobs from config
+        - Validates RQ dependencies if needed
+        """
+        # Check dependencies if running RQ-related commands
+        self._check_dependencies_if_needed()
+
+        # Import admin to register custom admin classes
+        try:
+            from . import admin  # noqa: F401
+        except ImportError:
+            pass
+
+        # Register scheduled jobs from config (runs once on startup)
+        try:
+            from .services import register_schedules_from_config
+            register_schedules_from_config()
+        except Exception as e:
+            from django_cfg.modules.django_logging import get_logger
+            logger = get_logger("rq.apps")
+            logger.warning(f"Failed to register schedules: {e}")
+
+    def _check_dependencies_if_needed(self):
+        """
+        Check RQ dependencies only when running RQ-related commands.
+
+        Skips check for:
+        - Migrations (makemigrations, migrate)
+        - Shell commands (shell, shell_plus)
+        - Test discovery (test --help)
+        - Django checks (check)
+        - Management command listing (help)
+        """
+        # Get command name from sys.argv
+        if len(sys.argv) < 2:
+            return
+
+        command = sys.argv[1]
+
+        # Commands that don't need RQ dependencies
+        skip_commands = [
+            'makemigrations',
+            'migrate',
+            'shell',
+            'shell_plus',
+            'check',
+            'help',
+            'test',
+            'collectstatic',
+            'createsuperuser',
+            'changepassword',
+            'showmigrations',
+            'sqlmigrate',
+            'inspectdb',
+        ]
+
+        # Skip check for these commands
+        if command in skip_commands:
+            return
+
+        # Also skip if running tests (pytest, nose, etc.)
+        if 'test' in sys.argv or 'pytest' in sys.argv[0]:
+            return
+
+        # Skip if DJANGO_SKIP_RQ_CHECK environment variable is set
+        if os.environ.get('DJANGO_SKIP_RQ_CHECK', '').lower() in ('1', 'true', 'yes'):
+            return
+
+        # For RQ-related commands, perform strict check
+        rq_commands = ['rqworker', 'rqscheduler', 'rqenqueue', 'rqstats']
+        if command in rq_commands:
+            from ._cfg import check_rq_dependencies
+            try:
+                check_rq_dependencies(raise_on_missing=True)
+            except Exception as e:
+                # Print error and exit
+                print(str(e))
+                sys.exit(1)
+
+        # For other commands, perform silent check (just import validation)
+        # This ensures basic imports work but doesn't block the command
+        else:
+            from ._cfg import check_rq_dependencies
+            try:
+                # Silent check - only validates that checker itself works
+                check_rq_dependencies(raise_on_missing=False)
+            except Exception:
+                # Silently ignore - don't break other commands
+                pass

django_cfg/apps/integrations/rq/management/__init__.py

@@ -0,0 +1 @@
+"""Management commands for Django-RQ integration."""

django_cfg/apps/integrations/rq/management/commands/__init__.py

@@ -0,0 +1 @@
+"""Django-RQ management commands for django-cfg."""

django_cfg/apps/integrations/rq/management/commands/rqscheduler.py

@@ -0,0 +1,31 @@
+"""
+Django-CFG wrapper for django-rq rqscheduler command.
+
+Runs the RQ scheduler daemon for scheduled/periodic jobs.
+
+Example:
+    python manage.py rqscheduler
+    python manage.py rqscheduler --queue default
+"""
+
+from django_rq.management.commands.rqscheduler import Command as DjangoRQSchedulerCommand
+
+
+class Command(DjangoRQSchedulerCommand):
+    """
+    Runs the RQ scheduler daemon.
+
+    The scheduler handles:
+    - Scheduled jobs (enqueue at specific time)
+    - Periodic jobs (cron-like scheduling)
+    - Delayed job execution
+
+    Inherits all functionality from django-rq's rqscheduler command.
+
+    Common options:
+        --queue QUEUE        Queue to schedule jobs on (default: 'default')
+        --interval SECONDS   Polling interval (default: 1)
+        --pid FILE          Write PID to file
+    """
+
+    help = 'Runs RQ scheduler daemon for django-cfg (wrapper for django-rq rqscheduler)'

django_cfg/apps/integrations/rq/management/commands/rqstats.py

@@ -0,0 +1,33 @@
+"""
+Django-CFG wrapper for django-rq rqstats command.
+
+Displays real-time statistics about RQ queues and workers.
+
+Example:
+    python manage.py rqstats
+    python manage.py rqstats --interval 5
+"""
+
+from django_rq.management.commands.rqstats import Command as DjangoRQStatsCommand
+
+
+class Command(DjangoRQStatsCommand):
+    """
+    Displays real-time RQ statistics in terminal.
+
+    Shows:
+    - Queue sizes (queued, started, finished, failed)
+    - Worker count and status
+    - Job processing rates
+    - Updates in real-time
+
+    Inherits all functionality from django-rq's rqstats command.
+
+    Common options:
+        --interval SECONDS   Update interval (default: 1)
+        --raw               Show raw numbers (no colors)
+        --only-queues       Show only queue statistics
+        --only-workers      Show only worker statistics
+    """
+
+    help = 'Shows real-time RQ statistics for django-cfg (wrapper for django-rq rqstats)'

django_cfg/apps/integrations/rq/management/commands/rqworker.py

@@ -0,0 +1,31 @@
+"""
+Django-CFG wrapper for django-rq rqworker command.
+
+This is a simple proxy that inherits all functionality from django-rq's rqworker.
+Allows running: python manage.py rqworker [queues]
+
+Example:
+    python manage.py rqworker default
+    python manage.py rqworker high default low
+    python manage.py rqworker default --with-scheduler
+"""
+
+from django_rq.management.commands.rqworker import Command as DjangoRQWorkerCommand
+
+
+class Command(DjangoRQWorkerCommand):
+    """
+    Runs RQ workers on specified queues.
+
+    Inherits all functionality from django-rq's rqworker command.
+    See django-rq documentation for available options.
+
+    Common options:
+        --burst              Run in burst mode (exit when queue is empty)
+        --with-scheduler     Run worker with embedded scheduler
+        --name NAME          Custom worker name
+        --worker-ttl SEC     Worker timeout (default: 420)
+        --sentry-dsn DSN     Report exceptions to Sentry
+    """
+
+    help = 'Runs RQ workers for django-cfg (wrapper for django-rq rqworker)'

django_cfg/apps/integrations/rq/management/commands/rqworker_pool.py

@@ -0,0 +1,27 @@
+"""
+Django-CFG wrapper for django-rq rqworker-pool command.
+
+Runs multiple RQ workers in a pool for better performance.
+
+Example:
+    python manage.py rqworker_pool default --num-workers 4
+    python manage.py rqworker_pool high default --num-workers 8
+"""
+
+from django_rq.management.commands.rqworker_pool import Command as DjangoRQWorkerPoolCommand
+
+
+class Command(DjangoRQWorkerPoolCommand):
+    """
+    Runs a pool of RQ workers for improved throughput.
+
+    Inherits all functionality from django-rq's rqworker-pool command.
+    Creates multiple worker processes to handle jobs in parallel.
+
+    Common options:
+        --num-workers N      Number of worker processes (default: CPU count)
+        --burst              Run in burst mode
+        --name NAME          Worker name prefix
+    """
+
+    help = 'Runs a pool of RQ workers for django-cfg (wrapper for django-rq rqworker-pool)'

django_cfg/apps/integrations/rq/serializers/__init__.py

@@ -0,0 +1,40 @@
+"""
+DRF serializers for Django-RQ monitoring API.
+"""
+
+from .health import HealthCheckSerializer, RQConfigSerializer
+from .queue import QueueStatsSerializer, QueueDetailSerializer
+from .worker import WorkerSerializer, WorkerStatsSerializer
+from .job import JobListSerializer, JobDetailSerializer, JobActionResponseSerializer
+from .schedule import (
+    ScheduleCreateSerializer,
+    ScheduledJobSerializer,
+    ScheduleActionResponseSerializer,
+)
+from .testing import (
+    TestScenarioSerializer,
+    RunDemoRequestSerializer,
+    StressTestRequestSerializer,
+    TestingActionResponseSerializer,
+    CleanupRequestSerializer,
+)
+
+__all__ = [
+    'HealthCheckSerializer',
+    'RQConfigSerializer',
+    'QueueStatsSerializer',
+    'QueueDetailSerializer',
+    'WorkerSerializer',
+    'WorkerStatsSerializer',
+    'JobListSerializer',
+    'JobDetailSerializer',
+    'JobActionResponseSerializer',
+    'ScheduleCreateSerializer',
+    'ScheduledJobSerializer',
+    'ScheduleActionResponseSerializer',
+    'TestScenarioSerializer',
+    'RunDemoRequestSerializer',
+    'StressTestRequestSerializer',
+    'TestingActionResponseSerializer',
+    'CleanupRequestSerializer',
+]