django-cfg 1.1.59__tar.gz → 1.1.62__tar.gz

{django_cfg-1.1.59 → django_cfg-1.1.62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-cfg
-Version: 1.1.59
+Version: 1.1.62
 Summary: 🚀 Production-ready Django configuration framework with type-safe settings, smart automation, and modern developer experience
 Project-URL: Homepage, https://github.com/markolofsen/django-cfg
 Project-URL: Documentation, https://django-cfg.readthedocs.io

{django_cfg-1.1.59 → django_cfg-1.1.62}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-cfg"
-version = "1.1.59"
+version = "1.1.62"
 description = "🚀 Production-ready Django configuration framework with type-safe settings, smart automation, and modern developer experience"
 readme = "README.md"
 license = {text = "MIT"}

{django_cfg-1.1.59 → django_cfg-1.1.62}/src/django_cfg/__init__.py

@@ -38,7 +38,7 @@ default_app_config = "django_cfg.apps.DjangoCfgConfig"
 from typing import TYPE_CHECKING
 
 # Version information
-__version__ = "1.1.59"
+__version__ = "1.1.62"
 __author__ = "Unrealos Team"
 __email__ = "info@unrealos.com"
 __license__ = "MIT"

django_cfg-1.1.62/src/django_cfg/management/commands/rundramatiq.py

@@ -0,0 +1,241 @@
+"""
+Django management command for running Dramatiq workers.
+
+Based on django_dramatiq.management.commands.rundramatiq with Django-CFG integration.
+Simple, clean, and working approach.
+"""
+
+import argparse
+import importlib
+import multiprocessing
+import os
+import sys
+
+from django.apps import apps
+from django.conf import settings
+from django.core.management.base import BaseCommand
+from django.utils.module_loading import module_has_submodule
+
+from django_cfg.modules.django_tasks import get_task_service
+
+
+# Default values
+NPROCS = multiprocessing.cpu_count()
+NTHREADS = 8
+
+
+class Command(BaseCommand):
+    help = "Run Dramatiq workers with Django-CFG configuration."
+
+    def add_arguments(self, parser):
+        parser.formatter_class = argparse.ArgumentDefaultsHelpFormatter
+        
+        parser.add_argument(
+            "--processes", "-p",
+            default=NPROCS,
+            type=int,
+            help="The number of processes to run",
+        )
+        parser.add_argument(
+            "--threads", "-t",
+            default=NTHREADS,
+            type=int,
+            help="The number of threads per process to use",
+        )
+        parser.add_argument(
+            "--queues", "-Q",
+            nargs="*",
+            type=str,
+            help="Listen to a subset of queues, or all when empty",
+        )
+        parser.add_argument(
+            "--watch",
+            dest="watch_dir",
+            help="Reload workers when changes are detected in the given directory",
+        )
+        parser.add_argument(
+            "--pid-file",
+            type=str,
+            help="Write the PID of the master process to this file",
+        )
+        parser.add_argument(
+            "--log-file",
+            type=str,
+            help="Write all logs to a file, or stderr when empty",
+        )
+        parser.add_argument(
+            "--worker-shutdown-timeout", 
+            type=int, 
+            default=600000,
+            help="Timeout for worker shutdown, in milliseconds"
+        )
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Show configuration without starting workers",
+        )
+
+    def handle(self, watch_dir, processes, threads, verbosity, queues, 
+               pid_file, log_file, worker_shutdown_timeout, dry_run, **options):
+        
+        # Get task service and validate
+        task_service = get_task_service()
+        if not task_service.is_enabled():
+            self.stdout.write(
+                self.style.ERROR("Task system is not enabled in Django-CFG configuration")
+            )
+            return
+        
+        # Discover task modules
+        tasks_modules = self._discover_tasks_modules()
+        
+        # Show configuration info
+        self.stdout.write(self.style.SUCCESS("Dramatiq Worker Configuration:"))
+        self.stdout.write(f"Processes: {processes}")
+        self.stdout.write(f"Threads: {threads}")
+        if queues:
+            self.stdout.write(f"Queues: {', '.join(queues)}")
+        else:
+            self.stdout.write("Queues: all")
+        
+        self.stdout.write(f"\nDiscovered task modules:")
+        for module in tasks_modules:
+            self.stdout.write(f"  - {module}")
+        
+        # If dry run, show command and exit
+        if dry_run:
+            executable_name = "dramatiq"
+            process_args = [
+                executable_name,
+                "--processes", str(processes),
+                "--threads", str(threads),
+                "--worker-shutdown-timeout", str(worker_shutdown_timeout),
+            ]
+            
+            if watch_dir:
+                process_args.extend(["--watch", watch_dir])
+            
+            verbosity_args = ["-v"] * (verbosity - 1)
+            process_args.extend(verbosity_args)
+            
+            if queues:
+                process_args.extend(["--queues", *queues])
+            
+            if pid_file:
+                process_args.extend(["--pid-file", pid_file])
+            
+            if log_file:
+                process_args.extend(["--log-file", log_file])
+            
+            process_args.extend(tasks_modules)
+            
+            self.stdout.write(f"\nCommand that would be executed:")
+            self.stdout.write(f'  {" ".join(process_args)}')
+            return
+        
+        # Show startup info
+        self.stdout.write(self.style.SUCCESS("\nStarting Dramatiq workers..."))
+        
+        # Build dramatiq command
+        executable_name = "dramatiq"
+        executable_path = self._resolve_executable(executable_name)
+        
+        # Build process arguments exactly like django_dramatiq
+        process_args = [
+            executable_name,
+            "--processes", str(processes),
+            "--threads", str(threads),
+            "--worker-shutdown-timeout", str(worker_shutdown_timeout),
+        ]
+        
+        # Add watch directory if specified
+        if watch_dir:
+            process_args.extend(["--watch", watch_dir])
+        
+        # Add verbosity
+        verbosity_args = ["-v"] * (verbosity - 1)
+        process_args.extend(verbosity_args)
+        
+        # Add queues if specified
+        if queues:
+            process_args.extend(["--queues", *queues])
+        
+        # Add PID file if specified
+        if pid_file:
+            process_args.extend(["--pid-file", pid_file])
+        
+        # Add log file if specified
+        if log_file:
+            process_args.extend(["--log-file", log_file])
+        
+        # Add task modules (broker module first, then discovered modules)
+        process_args.extend(tasks_modules)
+        
+        self.stdout.write(f'Running dramatiq: "{" ".join(process_args)}"\n')
+        
+        # Ensure DJANGO_SETTINGS_MODULE is set for worker processes
+        if not os.environ.get('DJANGO_SETTINGS_MODULE'):
+            if hasattr(settings, 'SETTINGS_MODULE'):
+                os.environ['DJANGO_SETTINGS_MODULE'] = settings.SETTINGS_MODULE
+            else:
+                # Try to detect from manage.py or current settings
+                import django
+                from django.conf import settings as django_settings
+                if hasattr(django_settings, '_wrapped') and hasattr(django_settings._wrapped, '__module__'):
+                    module_name = django_settings._wrapped.__module__
+                    os.environ['DJANGO_SETTINGS_MODULE'] = module_name
+                else:
+                    self.stdout.write(
+                        self.style.WARNING("Could not detect DJANGO_SETTINGS_MODULE")
+                    )
+        
+        # Use os.execvp like django_dramatiq to preserve environment
+        if sys.platform == "win32":
+            import subprocess
+            command = [executable_path] + process_args[1:]
+            sys.exit(subprocess.run(command))
+        
+        os.execvp(executable_path, process_args)
+
+    def _discover_tasks_modules(self):
+        """Discover task modules like django_dramatiq does."""
+        # Always include our broker setup module first
+        tasks_modules = ["django_cfg.modules.dramatiq_setup"]
+        
+        # Get task service for configuration
+        task_service = get_task_service()
+        
+        # Try to get task modules from Django-CFG config
+        if task_service.config and task_service.config.auto_discover_tasks:
+            discovered = task_service.discover_tasks()
+            for module_name in discovered:
+                self.stdout.write(f"Discovered tasks module: '{module_name}'")
+                tasks_modules.append(module_name)
+        
+        # Fallback: use django_dramatiq discovery logic
+        if len(tasks_modules) == 1:  # Only broker module found
+            task_module_names = getattr(settings, "DRAMATIQ_AUTODISCOVER_MODULES", ("tasks",))
+            
+            for app_config in apps.get_app_configs():
+                for task_module in task_module_names:
+                    if module_has_submodule(app_config.module, task_module):
+                        module_name = f"{app_config.name}.{task_module}"
+                        try:
+                            importlib.import_module(module_name)
+                            self.stdout.write(f"Discovered tasks module: '{module_name}'")
+                            tasks_modules.append(module_name)
+                        except ImportError:
+                            # Module exists but has import errors, skip it
+                            pass
+        
+        return tasks_modules
+
+    def _resolve_executable(self, exec_name):
+        """Resolve executable path like django_dramatiq does."""
+        bin_dir = os.path.dirname(sys.executable)
+        if bin_dir:
+            for d in [bin_dir, os.path.join(bin_dir, "Scripts")]:
+                exec_path = os.path.join(d, exec_name)
+                if os.path.isfile(exec_path):
+                    return exec_path
+        return exec_name

django_cfg-1.1.62/src/django_cfg/modules/django_tasks.py

@@ -0,0 +1,373 @@
+"""
+Django-CFG Task Service Module.
+
+Simplified and focused task service for Dramatiq integration.
+Provides essential functionality without unnecessary complexity.
+"""
+
+from typing import Optional, Dict, Any, List
+import logging
+from urllib.parse import urlparse
+
+from django_cfg.modules.base import BaseModule
+from django_cfg.models.tasks import TaskConfig, validate_task_config
+from django_cfg.models.constance import ConstanceField
+
+# Django imports (will be available when Django is configured)
+try:
+    from django.conf import settings
+    from django.apps import apps
+except ImportError:
+    settings = None
+    apps = None
+
+# Optional imports
+try:
+    import dramatiq
+except ImportError:
+    dramatiq = None
+
+try:
+    import redis
+except ImportError:
+    redis = None
+
+logger = logging.getLogger(__name__)
+
+
+class DjangoTasks(BaseModule):
+    """
+    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:
+                # Get config from django-cfg
+                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
+        
+        # Check if required dependencies are available
+        if dramatiq is None:
+            logger.warning("Dramatiq not available")
+            return False
+        
+        return True
+    
+    def get_redis_url(self) -> Optional[str]:
+        """Get Redis URL from Django-CFG cache configuration."""
+        if self._redis_url is None:
+            try:
+                from django_cfg.core.config import get_current_config
+                django_config = get_current_config()
+                
+                if not django_config:
+                    try:
+                        from api.config import config
+                        django_config = config
+                    except ImportError:
+                        logger.warning("Could not import config from api.config")
+                
+                if django_config and hasattr(django_config, 'cache_default') and django_config.cache_default:
+                    cache_config = django_config.cache_default
+                    if hasattr(cache_config, 'redis_url') and cache_config.redis_url:
+                        self._redis_url = cache_config.redis_url
+                        logger.debug(f"Got Redis URL: {self._redis_url}")
+                    elif hasattr(cache_config, 'location') and cache_config.location:
+                        self._redis_url = cache_config.location
+                        logger.debug(f"Got Redis URL from location: {self._redis_url}")
+            except Exception as e:
+                logger.warning(f"Failed to get Redis URL: {e}")
+        
+        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)
+            return redis.Redis(
+                host=parsed.hostname or 'localhost',
+                port=parsed.port or 6379,
+                db=self.config.dramatiq.redis_db if self.config else 1,
+                password=parsed.password,
+                socket_timeout=5
+            )
+        except Exception as e:
+            logger.error(f"Failed to create Redis client: {e}")
+            return None
+    
+    def _get_current_timestamp(self) -> str:
+        """Get current timestamp in ISO format."""
+        from datetime import datetime
+        return datetime.now().isoformat()
+    
+    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:
+                        # Module doesn't exist, which is fine
+                        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
+
+
+# === Service Factory ===
+
+_task_service_instance: Optional[DjangoTasks] = None
+
+
+def get_task_service() -> DjangoTasks:
+    """Get the global task service instance."""
+    global _task_service_instance
+    
+    if _task_service_instance is None:
+        _task_service_instance = DjangoTasks()
+    
+    return _task_service_instance
+
+
+def reset_task_service():
+    """Reset the global task service instance (useful for testing)."""
+    global _task_service_instance
+    _task_service_instance = None
+
+
+# === Utility Functions ===
+
+def is_task_system_available() -> bool:
+    """Check if task system is available and properly configured."""
+    try:
+        service = get_task_service()
+        return service.is_enabled()
+    except Exception:
+        return False
+
+
+def get_task_health() -> Dict[str, Any]:
+    """Get task system health status."""
+    try:
+        service = get_task_service()
+        return service.get_health_status()
+    except Exception as e:
+        return {
+            "enabled": False,
+            "error": str(e),
+            "redis_connection": False,
+            "configuration_valid": False,
+        }
+
+
+def initialize_task_system():
+    """
+    Initialize the task system during Django app startup.
+    This function is called from Django AppConfig.ready() method.
+    """
+    try:
+        service = get_task_service()
+        
+        # Force config reload to ensure we have fresh config
+        service._config = None
+        config = service.config
+        
+        if config and config.enabled:
+            logger.info("🔧 Initializing Django-CFG task system...")
+            
+            # Set up Dramatiq broker from Django settings
+            try:
+                import dramatiq
+                from django.conf import settings
+                
+                # Django-dramatiq automatically configures the broker from DRAMATIQ_BROKER setting
+                if hasattr(settings, 'DRAMATIQ_BROKER'):
+                    logger.debug("✅ Dramatiq broker configured from Django settings")
+                else:
+                    logger.warning("DRAMATIQ_BROKER not found in Django settings")
+                    
+            except Exception as e:
+                logger.warning(f"Failed to configure Dramatiq: {e}")
+            
+            logger.info("✅ Task system initialized successfully")
+            logger.info("💡 To start workers, run: python manage.py rundramatiq")
+        else:
+            logger.debug(f"Task system not enabled (config: {config}), skipping initialization")
+            
+    except Exception as e:
+        logger.error(f"Failed to initialize task system: {e}")
+
+
+def extend_constance_config_with_tasks():
+    """
+    Extend Constance configuration with Dramatiq task fields if tasks are enabled.
+    """
+    try:
+        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 []
+
+
+# === Exports ===
+
+__all__ = [
+    "DjangoTasks",
+    "get_task_service",
+    "reset_task_service",
+    "is_task_system_available",
+    "get_task_health",
+    "extend_constance_config_with_tasks",
+    "initialize_task_system",
+]

django_cfg-1.1.62/src/django_cfg/modules/dramatiq_setup.py

@@ -0,0 +1,16 @@
+"""
+Dramatiq broker module for django-cfg CLI integration.
+
+This module provides the broker instance required by Dramatiq CLI.
+It's a thin wrapper around django_dramatiq.setup with broker export.
+
+Usage:
+    dramatiq django_cfg.modules.dramatiq_setup [task_modules...]
+"""
+
+# Import django_dramatiq setup (handles Django initialization)
+import django_dramatiq.setup
+
+# Re-export the broker for Dramatiq CLI
+import dramatiq
+broker = dramatiq.get_broker()