django-cfg 1.1.59__py3-none-any.whl → 1.1.62__py3-none-any.whl

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/management/commands/rundramatiq.py

@@ -1,244 +1,241 @@
 """
 Django management command for running Dramatiq workers.
 
-This command provides a Django-integrated way to start Dramatiq workers
-with configuration from Django-CFG TaskConfig.
+Based on django_dramatiq.management.commands.rundramatiq with Django-CFG integration.
+Simple, clean, and working approach.
 """
 
-from django.core.management.base import BaseCommand, CommandError
-from django.conf import settings
-from typing import Any, Optional, List
-import logging
-import sys
+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
 
-logger = logging.getLogger(__name__)
+
+# Default values
+NPROCS = multiprocessing.cpu_count()
+NTHREADS = 8
 
 
 class Command(BaseCommand):
-    """
-    Run Dramatiq workers with Django-CFG configuration.
-    
-    This command starts Dramatiq workers using the configuration
-    defined in Django-CFG TaskConfig, with support for custom
-    process counts, queue selection, and worker options.
-    """
-    
-    help = "Run Dramatiq workers for background task processing"
-    
+    help = "Run Dramatiq workers with Django-CFG configuration."
+
     def add_arguments(self, parser):
-        """Add command line arguments."""
+        parser.formatter_class = argparse.ArgumentDefaultsHelpFormatter
+        
         parser.add_argument(
-            "--processes",
+            "--processes", "-p",
+            default=NPROCS,
             type=int,
-            help="Number of worker processes (overrides config)",
+            help="The number of processes to run",
         )
         parser.add_argument(
-            "--threads", 
+            "--threads", "-t",
+            default=NTHREADS,
             type=int,
-            help="Number of threads per process (overrides config)",
+            help="The number of threads per process to use",
         )
         parser.add_argument(
-            "--queues",
+            "--queues", "-Q",
+            nargs="*",
             type=str,
-            help="Comma-separated list of queues to process (overrides config)",
+            help="Listen to a subset of queues, or all when empty",
         )
         parser.add_argument(
-            "--log-level",
-            choices=["DEBUG", "INFO", "WARNING", "ERROR"],
-            help="Log level for workers (overrides config)",
+            "--watch",
+            dest="watch_dir",
+            help="Reload workers when changes are detected in the given directory",
         )
         parser.add_argument(
-            "--watch",
+            "--pid-file",
             type=str,
-            help="Watch directory for code changes and auto-reload",
+            help="Write the PID of the master process to this file",
         )
         parser.add_argument(
-            "--pid-file",
+            "--log-file",
             type=str,
-            help="Write process ID to file",
+            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, *args, **options):
-        """Handle the command execution."""
-        try:
-            # Get task service
-            task_service = get_task_service()
+
+    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),
+            ]
             
-            # Check if task system is enabled
-            if not task_service.is_enabled():
-                raise CommandError(
-                    "Task system is not enabled. "
-                    "Please configure 'tasks' in your Django-CFG configuration."
-                )
+            if watch_dir:
+                process_args.extend(["--watch", watch_dir])
             
-            # Validate configuration
-            if not task_service.validate_configuration():
-                raise CommandError(
-                    "Task system configuration is invalid. "
-                    "Please check your Redis connection and task settings."
-                )
+            verbosity_args = ["-v"] * (verbosity - 1)
+            process_args.extend(verbosity_args)
             
-            # Get effective configuration
-            config = task_service.config
-            if not config:
-                raise CommandError("Task configuration not available")
+            if queues:
+                process_args.extend(["--queues", *queues])
             
-            # Build worker arguments
-            worker_args = self._build_worker_args(config, options)
+            if pid_file:
+                process_args.extend(["--pid-file", pid_file])
             
-            if options["dry_run"]:
-                self._show_configuration(config, worker_args)
-                return
+            if log_file:
+                process_args.extend(["--log-file", log_file])
             
-            # Start workers
-            self._start_workers(worker_args, options)
+            process_args.extend(tasks_modules)
             
-        except ImportError:
-            raise CommandError(
-                "Dramatiq dependencies not installed. "
-                "Install with: pip install django-cfg[tasks]"
-            )
-        except Exception as e:
-            logger.exception("Failed to start Dramatiq workers")
-            raise CommandError(f"Failed to start workers: {e}")
-    
-    def _build_worker_args(self, config, options) -> List[str]:
-        """Build command line arguments for Dramatiq workers."""
-        args = ["dramatiq"]
-        
-        # Process count
-        processes = options.get("processes") or config.get_effective_processes()
-        args.extend(["--processes", str(processes)])
-        
-        # Thread count
-        threads = options.get("threads") or config.dramatiq.threads
-        args.extend(["--threads", str(threads)])
-        
-        # Queues
-        if options.get("queues"):
-            queues = [q.strip() for q in options["queues"].split(",")]
-        else:
-            queues = config.get_effective_queues()
-        
-        for queue in queues:
-            args.extend(["--queues", queue])
-        
-        # Log level (not supported by standard dramatiq CLI)
-        # log_level = options.get("log_level") or config.worker.log_level
-        # args.extend(["--log-level", log_level])
-        
-        # Watch directory
-        if options.get("watch"):
-            args.extend(["--watch", options["watch"]])
-        
-        # PID file
-        if options.get("pid_file"):
-            args.extend(["--pid-file", options["pid_file"]])
-        
-        # Note: Using Python API instead of CLI, so no broker argument needed
-        
-        # Add discovered task modules
-        discovered_modules = get_task_service().discover_tasks()
-        for module in discovered_modules:
-            args.append(module)
-        
-        # If no modules discovered, add default patterns
-        if not discovered_modules:
-            # Add common task module patterns
-            for app in settings.INSTALLED_APPS:
-                if not app.startswith("django.") and not app.startswith("django_"):
-                    args.append(f"{app}.tasks")
-        
-        return args
-    
-    def _show_configuration(self, config, worker_args):
-        """Show worker configuration without starting."""
-        self.stdout.write(
-            self.style.SUCCESS("Dramatiq Worker Configuration:")
-        )
-        
-        self.stdout.write(f"  Processes: {config.get_effective_processes()}")
-        self.stdout.write(f"  Threads: {config.dramatiq.threads}")
-        self.stdout.write(f"  Queues: {', '.join(config.get_effective_queues())}")
-        self.stdout.write(f"  Log Level: {config.worker.log_level}")
-        self.stdout.write(f"  Redis DB: {config.dramatiq.redis_db}")
-        
-        self.stdout.write("\nDiscovered task modules:")
-        discovered = get_task_service().discover_tasks()
-        if discovered:
-            for module in discovered:
-                self.stdout.write(f"  - {module}")
-        else:
-            self.stdout.write("  (none found)")
-        
-        self.stdout.write(f"\nCommand that would be executed:")
-        self.stdout.write(f"  {' '.join(worker_args)}")
-    
-    def _start_workers(self, worker_args, options):
-        """Start Dramatiq workers using Python API instead of CLI."""
-        self.stdout.write(
-            self.style.SUCCESS("Starting Dramatiq workers...")
-        )
+            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()
-        config = task_service.config
         
-        processes = options.get("processes") or config.get_effective_processes()
-        threads = options.get("threads") or config.dramatiq.threads
-        queues = config.get_effective_queues()
-        if options.get("queues"):
-            queues = [q.strip() for q in options["queues"].split(",")]
+        # 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)
         
-        self.stdout.write(f"Processes: {processes}")
-        self.stdout.write(f"Threads: {threads}")
-        self.stdout.write(f"Queues: {', '.join(queues)}")
-        
-        # Write PID file if requested
-        if options.get("pid_file"):
-            with open(options["pid_file"], "w") as f:
-                f.write(str(os.getpid()))
-            self.stdout.write(f"PID written to: {options['pid_file']}")
-        
-        try:
-            # Import dramatiq and get broker FIRST
-            import dramatiq
-            from dramatiq.worker import Worker
-            from django_cfg.modules.django_tasks import get_dramatiq_broker
-            
-            # Get the configured broker
-            broker = get_dramatiq_broker()
+        # Fallback: use django_dramatiq discovery logic
+        if len(tasks_modules) == 1:  # Only broker module found
+            task_module_names = getattr(settings, "DRAMATIQ_AUTODISCOVER_MODULES", ("tasks",))
             
-            # CRITICAL: Set the broker as the global default BEFORE importing tasks
-            dramatiq.set_broker(broker)
-            
-            # Now discover and import task modules with the correct broker set
-            discovered_modules = get_task_service().discover_tasks()
-            for module_name in discovered_modules:
-                try:
-                    __import__(module_name)
-                    self.stdout.write(f"Loaded tasks from: {module_name}")
-                except ImportError as e:
-                    self.stdout.write(f"Warning: Could not import {module_name}: {e}")
-            
-            # Verify broker is set correctly
-            current_broker = dramatiq.get_broker()
-            self.stdout.write(f"Using broker: {current_broker}")
-            
-            # Create and start worker
-            worker = Worker(broker, worker_timeout=600000)
-            worker.start()
-                
-        except KeyboardInterrupt:
-            self.stdout.write("\nShutting down workers...")
-        except Exception as e:
-            logger.exception("Worker execution failed")
-            raise CommandError(f"Worker execution failed: {e}")
+            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/modules/django_tasks.py

@@ -1,18 +1,16 @@
 """
 Django-CFG Task Service Module.
 
-This module provides the service layer for background task processing with Dramatiq,
-including task management, worker control, monitoring, and Django integration.
+Simplified and focused task service for Dramatiq integration.
+Provides essential functionality without unnecessary complexity.
 """
 
-from typing import Optional, Dict, Any, List, Union
+from typing import Optional, Dict, Any, List
 import logging
-import subprocess
-import time
 from urllib.parse import urlparse
 
 from django_cfg.modules.base import BaseModule
-from django_cfg.models.tasks import TaskConfig, DramatiqConfig, validate_task_config
+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)
@@ -26,15 +24,8 @@ except ImportError:
 # Optional imports
 try:
     import dramatiq
-    from dramatiq.brokers.redis import RedisBroker
 except ImportError:
     dramatiq = None
-    RedisBroker = None
-
-try:
-    import django_dramatiq
-except ImportError:
-    django_dramatiq = None
 
 try:
     import redis
@@ -44,294 +35,121 @@ except ImportError:
 logger = logging.getLogger(__name__)
 
 
-class TaskManager:
-    """
-    Task management and worker control.
-    
-    Provides high-level interface for managing Dramatiq workers,
-    monitoring task queues, and controlling task execution.
-    """
-    
-    def __init__(self, config: DramatiqConfig):
-        self.config = config
-        self._broker = None
-        self._workers = []
-    
-    @property
-    def broker(self):
-        """Get Dramatiq broker instance (lazy-loaded)."""
-        if self._broker is None:
-            if dramatiq is None:
-                logger.error("Dramatiq not available")
-                return None
-            
-            try:
-                # This will be configured by Django settings
-                self._broker = dramatiq.get_broker()
-            except Exception as e:
-                logger.error(f"Failed to get Dramatiq broker: {e}")
-                return None
-        
-        return self._broker
-    
-    def get_queue_stats(self) -> List[Dict[str, Any]]:
-        """Get statistics for all configured queues."""
-        if not self.broker:
-            return []
-        
-        stats = []
-        for queue_name in self.config.dramatiq.queues:
-            try:
-                # Get queue statistics from broker
-                queue_stats = {
-                    "name": queue_name,
-                    "pending": 0,  # Will be populated by actual broker stats
-                    "running": 0,
-                    "completed": 0,
-                    "failed": 0,
-                }
-                
-                # TODO: Implement actual queue statistics retrieval
-                # This depends on the specific broker implementation
-                
-                stats.append(queue_stats)
-            except Exception as e:
-                logger.error(f"Failed to get stats for queue {queue_name}: {e}")
-        
-        return stats
-    
-    def get_worker_stats(self) -> List[Dict[str, Any]]:
-        """Get statistics for all active workers."""
-        # TODO: Implement worker statistics retrieval
-        # This would typically involve checking process status,
-        # memory usage, and current task information
-        
-        return []
-    
-    def clear_queue(self, queue_name: str) -> bool:
-        """Clear all messages from a specific queue."""
-        if not self.broker:
-            return False
-        
-        try:
-            # TODO: Implement queue clearing
-            logger.info(f"Cleared queue: {queue_name}")
-            return True
-        except Exception as e:
-            logger.error(f"Failed to clear queue {queue_name}: {e}")
-            return False
-    
-    def retry_failed_tasks(self, queue_name: Optional[str] = None) -> int:
-        """Retry failed tasks in specified queue or all queues."""
-        if not self.broker:
-            return 0
-        
-        try:
-            # TODO: Implement failed task retry logic
-            retried_count = 0
-            logger.info(f"Retried {retried_count} failed tasks")
-            return retried_count
-        except Exception as e:
-            logger.error(f"Failed to retry tasks: {e}")
-            return 0
-
-
 class DjangoTasks(BaseModule):
     """
-    Main Django-CFG task service.
+    Simplified Django-CFG task service.
     
-    Provides the primary interface for task system integration,
-    configuration management, and service coordination.
+    Focuses on essential functionality:
+    - Configuration management
+    - Task discovery
+    - Health checks
+    - Constance integration
     """
     
     def __init__(self):
         super().__init__()
         self._config: Optional[TaskConfig] = None
-        self._manager: Optional[TaskManager] = None
         self._redis_url: Optional[str] = None
     
     @property
     def config(self) -> Optional[TaskConfig]:
         """Get task configuration (lazy-loaded)."""
-        # Always try to get fresh config to avoid stale cache issues
-        try:
-            # First try the base class method
-            django_config = self.get_config()  # This returns full DjangoConfig
-            if django_config and hasattr(django_config, 'tasks'):
-                task_config = django_config.tasks
-                if task_config and isinstance(task_config, TaskConfig):
-                    # Update cache with fresh config
-                    self._config = task_config
-                    logger.debug(f"Loaded TaskConfig: enabled={task_config.enabled}")
-                    return self._config
-                elif task_config is None:
-                    logger.debug("Tasks configuration is None in Django config")
-                else:
-                    logger.error(f"Expected TaskConfig, got {type(task_config)}")
-            else:
-                logger.debug("No tasks attribute found in Django config")
-            
-            # Fallback: try to import config directly
-            try:
-                from api.config import config as api_config
-                if hasattr(api_config, 'tasks') and api_config.tasks:
-                    task_config = api_config.tasks
-                    if isinstance(task_config, TaskConfig):
-                        self._config = task_config
-                        logger.debug(f"Loaded TaskConfig from api.config: enabled={task_config.enabled}")
-                        return self._config
-            except ImportError:
-                logger.debug("Could not import api.config")
-            
-            return None
-        except Exception as e:
-            logger.warning(f"Failed to get task config: {e}")
-            # Fallback to cached version if available
-            return self._config
-    
-    @property
-    def manager(self) -> Optional[TaskManager]:
-        """Get task manager (lazy-loaded)."""
-        if self._manager is None and self.config:
+        if self._config is None:
             try:
-                self._manager = TaskManager(self.config.dramatiq)
+                # 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.error(f"Failed to create task manager: {e}")
-                return None
-        return self._manager
+                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:
-            return False
-        
-        if not self.config.enabled:
+        if not self.config or not self.config.enabled:
             return False
         
         # Check if required dependencies are available
-        if dramatiq is None or django_dramatiq is None:
-            logger.warning("Dramatiq dependencies not 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."""
-        # Always try to get the URL if not cached
         if self._redis_url is None:
             try:
-                # Use get_current_config from django_cfg.core.config
                 from django_cfg.core.config import get_current_config
                 django_config = get_current_config()
                 
-                # If that fails, try to import directly from api.config
                 if not django_config:
                     try:
                         from api.config import config
                         django_config = config
-                        logger.debug("Got Django config from direct import")
                     except ImportError:
                         logger.warning("Could not import config from api.config")
                 
-                logger.debug(f"Django config type: {type(django_config)}")
-                logger.debug(f"Has cache_default: {hasattr(django_config, 'cache_default') if django_config else False}")
-                
                 if django_config and hasattr(django_config, 'cache_default') and django_config.cache_default:
                     cache_config = django_config.cache_default
-                    logger.debug(f"Cache config type: {type(cache_config)}")
-                    logger.debug(f"Cache config redis_url: {getattr(cache_config, 'redis_url', 'NOT_FOUND')}")
-                    
                     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}")
-                    else:
-                        logger.warning("Cache config exists but no redis_url or location found")
-                else:
-                    logger.warning("No cache_default configuration found")
             except Exception as e:
                 logger.warning(f"Failed to get Redis URL: {e}")
-                import traceback
-                logger.warning(f"Traceback: {traceback.format_exc()}")
         
         return self._redis_url
     
-    def check_redis_connection(self) -> bool:
-        """Check if Redis connection is available."""
-        redis_url = self.get_redis_url()
-        if not redis_url:
-            return False
-        
-        if redis is None:
-            logger.error("Redis library not available")
-            return False
-        
-        try:
-            parsed = urlparse(redis_url)
-            r = 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
-            )
-            
-            # Test connection
-            r.ping()
-            return True
-        except Exception as e:
-            logger.error(f"Redis connection failed: {e}")
-            return False
-    
     def get_redis_client(self):
         """Get Redis client instance."""
         redis_url = self.get_redis_url()
-        if not redis_url:
-            logger.warning("No Redis URL available for client")
-            return None
-        
-        if redis is None:
-            logger.error("Redis library not available")
+        if not redis_url or redis is None:
             return None
         
         try:
             parsed = urlparse(redis_url)
-            # Get redis_db from config, with fallback
-            redis_db = 1  # default
-            try:
-                task_config = self.config  # This should return TaskConfig
-                if task_config:
-                    logger.debug(f"TaskConfig type: {type(task_config)}")
-                    if hasattr(task_config, 'dramatiq') and task_config.dramatiq:
-                        redis_db = task_config.dramatiq.redis_db
-                        logger.debug(f"Using redis_db: {redis_db}")
-                    else:
-                        logger.warning("No dramatiq config found in TaskConfig")
-                else:
-                    logger.warning("No TaskConfig available")
-            except Exception as e:
-                logger.error(f"Error getting redis_db: {e}")
-            
-            client = redis.Redis(
+            return redis.Redis(
                 host=parsed.hostname or 'localhost',
                 port=parsed.port or 6379,
-                db=redis_db,
+                db=self.config.dramatiq.redis_db if self.config else 1,
                 password=parsed.password,
                 socket_timeout=5
             )
-            
-            logger.debug(f"Created Redis client: host={parsed.hostname}, port={parsed.port}, db={redis_db}")
-            return client
-            
         except Exception as e:
             logger.error(f"Failed to create Redis client: {e}")
             return None
     
-    def _get_current_timestamp(self) -> int:
-        """Get current timestamp."""
-        return int(time.time())
+    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."""
@@ -346,38 +164,6 @@ class DjangoTasks(BaseModule):
         
         return validate_task_config(self.config, redis_url)
     
-    def get_dramatiq_settings(self) -> Dict[str, Any]:
-        """Generate Django settings for Dramatiq integration."""
-        if not self.config or not self.is_enabled():
-            return {}
-        
-        redis_url = self.get_redis_url()
-        if not redis_url:
-            logger.error("Cannot generate Dramatiq settings: Redis URL not available")
-            return {}
-        
-        try:
-            return self.config.get_dramatiq_settings(redis_url)
-        except Exception as e:
-            logger.error(f"Failed to generate Dramatiq settings: {e}")
-            return {}
-    
-    
-    def get_installed_apps(self) -> List[str]:
-        """Get Django apps required for task system."""
-        if not self.is_enabled():
-            return []
-        
-        apps = ["django_dramatiq"]
-        
-        # Add optional apps based on configuration
-        if self.config and self.config.dramatiq.admin_enabled:
-            # Admin integration is included in django_dramatiq
-            # Add our custom tasks app for enhanced admin interface
-            apps.append("django_cfg.apps.tasks")
-        
-        return apps
-    
     def discover_tasks(self) -> List[str]:
         """Discover task modules in Django apps."""
         if not self.config or not self.config.auto_discover_tasks:
@@ -402,19 +188,13 @@ class DjangoTasks(BaseModule):
                         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.
-        
-        Returns:
-            List of ConstanceField objects for dynamic task configuration
-        """
+        """Get Constance fields for Dramatiq configuration."""
         if not self.is_enabled():
             return []
         
@@ -460,84 +240,18 @@ class DjangoTasks(BaseModule):
         logger.debug(f"Generated {len(fields)} Constance fields for Dramatiq")
         return fields
     
-    def start_workers(self, processes: Optional[int] = None, queues: Optional[List[str]] = None) -> bool:
-        """Start Dramatiq workers programmatically."""
-        logger.warning("Auto-start workers functionality has been removed. Please start workers manually using: python manage.py rundramatiq")
-        return False
-    
-    def stop_workers(self, graceful: bool = True) -> bool:
-        """Stop all Dramatiq workers."""
-        try:
-            timeout = self.config.dramatiq.worker.shutdown_timeout if self.config else 30
-            logger.info(f"Stopping workers (graceful={graceful}, timeout={timeout}s)")
-            
-            # Find and kill Dramatiq worker processes
-            try:
-                # Find worker processes
-                result = subprocess.run(
-                    ["pgrep", "-f", "rundramatiq"],
-                    capture_output=True,
-                    text=True
-                )
-                
-                if result.returncode == 0:
-                    pids = result.stdout.strip().split('\n')
-                    pids = [pid.strip() for pid in pids if pid.strip()]
-                    
-                    if pids:
-                        logger.info(f"Found {len(pids)} worker processes: {pids}")
-                        
-                        # Send appropriate signal
-                        signal = "TERM" if graceful else "KILL"
-                        
-                        for pid in pids:
-                            try:
-                                subprocess.run(["kill", f"-{signal}", pid], check=True)
-                                logger.info(f"Sent {signal} signal to worker process {pid}")
-                            except subprocess.CalledProcessError:
-                                logger.warning(f"Failed to send {signal} signal to process {pid}")
-                        
-                        # Wait for graceful shutdown if requested
-                        if graceful:
-                            logger.info(f"Waiting up to {timeout}s for graceful shutdown...")
-                            # TODO: Could implement actual waiting logic here
-                        
-                        logger.info("✅ Dramatiq workers stopped successfully")
-                        return True
-                    else:
-                        logger.info("No worker processes found")
-                        return True
-                else:
-                    logger.info("No worker processes found")
-                    return True
-                    
-            except Exception as e:
-                logger.error(f"Failed to find/stop worker processes: {e}")
-                return False
-            
-        except Exception as e:
-            logger.error(f"Failed to stop workers: {e}")
-            return False
-    
     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,
-            "workers": [],
-            "queues": [],
             "discovered_modules": [],
         }
         
         if self.is_enabled():
             status["redis_connection"] = self.check_redis_connection()
             status["configuration_valid"] = self.validate_configuration()
-            
-            if self.manager:
-                status["workers"] = self.manager.get_worker_stats()
-                status["queues"] = self.manager.get_queue_stats()
-            
             status["discovered_modules"] = self.discover_tasks()
         
         return status
@@ -549,12 +263,7 @@ _task_service_instance: Optional[DjangoTasks] = None
 
 
 def get_task_service() -> DjangoTasks:
-    """
-    Get the global task service instance.
-    
-    Returns:
-        DjangoTasks: The singleton task service instance
-    """
+    """Get the global task service instance."""
     global _task_service_instance
     
     if _task_service_instance is None:
@@ -594,79 +303,6 @@ def get_task_health() -> Dict[str, Any]:
         }
 
 
-def enqueue_task(actor_name: str, *args, queue_name: str = "default", **kwargs) -> bool:
-    """
-    Enqueue a task for processing.
-    
-    Args:
-        actor_name: Name of the Dramatiq actor
-        *args: Task arguments
-        queue_name: Queue to send task to
-        **kwargs: Task keyword arguments
-    
-    Returns:
-        bool: True if task was successfully enqueued
-    """
-    try:
-        service = get_task_service()
-        if not service.is_enabled():
-            logger.error("Task system not enabled")
-            return False
-        
-        # TODO: Implement actual task enqueueing
-        # This would involve getting the actor and calling send()
-        
-        logger.info(f"Enqueued task {actor_name} to queue {queue_name}")
-        return True
-    except Exception as e:
-        logger.error(f"Failed to enqueue task {actor_name}: {e}")
-        return False
-
-
-def clear_dramatiq_queues() -> bool:
-    """
-    Clear all Dramatiq queues on startup.
-    
-    Returns:
-        bool: True if queues were cleared successfully
-    """
-    try:
-        service = get_task_service()
-        if not service.is_enabled():
-            logger.debug("Task system not enabled, skipping queue clearing")
-            return True
-        
-        # Get broker and clear all queues
-        if hasattr(service, 'manager') and service.manager and service.manager.broker:
-            broker = service.manager.broker
-            queue_names = service.config.dramatiq.queues
-            
-            for queue_name in queue_names:
-                try:
-                    # Clear the queue
-                    if hasattr(broker, 'flush'):
-                        broker.flush(queue_name)
-                        logger.info(f"Cleared Dramatiq queue: {queue_name}")
-                    elif hasattr(broker, 'client'):
-                        # For Redis broker, clear using Redis client
-                        redis_client = broker.client
-                        queue_key = f"dramatiq:queue:{queue_name}"
-                        redis_client.delete(queue_key)
-                        logger.info(f"Cleared Redis queue: {queue_name}")
-                except Exception as e:
-                    logger.warning(f"Failed to clear queue {queue_name}: {e}")
-            
-            logger.info("✅ Dramatiq queues cleared on startup")
-            return True
-        else:
-            logger.debug("Broker not available, skipping queue clearing")
-            return True
-            
-    except Exception as e:
-        logger.error(f"Failed to clear Dramatiq queues: {e}")
-        return False
-
-
 def initialize_task_system():
     """
     Initialize the task system during Django app startup.
@@ -682,14 +318,19 @@ def initialize_task_system():
         if config and config.enabled:
             logger.info("🔧 Initializing Django-CFG task system...")
             
-            # CRITICAL: Set up global broker for task sending
+            # Set up Dramatiq broker from Django settings
             try:
                 import dramatiq
-                broker = get_dramatiq_broker()
-                dramatiq.set_broker(broker)
-                logger.debug(f"Set global Dramatiq broker: {broker}")
+                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 set global broker: {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")
@@ -703,9 +344,6 @@ def initialize_task_system():
 def extend_constance_config_with_tasks():
     """
     Extend Constance configuration with Dramatiq task fields if tasks are enabled.
-    
-    This function should be called during Django configuration setup to automatically
-    add task-related Constance fields when the task system is enabled.
     """
     try:
         service = get_task_service()
@@ -722,85 +360,14 @@ def extend_constance_config_with_tasks():
         return []
 
 
-# === Broker Creation ===
-
-def create_dramatiq_broker():
-    """
-    Create and configure Dramatiq broker from Django settings.
-    
-    This function creates a broker instance that can be used directly
-    by the Dramatiq CLI without requiring a separate broker.py file.
-    
-    Returns:
-        dramatiq.Broker: Configured Dramatiq broker instance
-    """
-    try:
-        from django.conf import settings
-        
-        if not hasattr(settings, 'DRAMATIQ_BROKER'):
-            raise RuntimeError("DRAMATIQ_BROKER not configured in Django settings")
-        
-        broker_config = settings.DRAMATIQ_BROKER
-        
-        # Create broker from Django settings
-        broker = RedisBroker(**broker_config['OPTIONS'])
-        
-        # Add middleware (only if not already present)
-        existing_middleware_types = {type(mw).__name__ for mw in broker.middleware}
-        
-        for middleware_path in broker_config['MIDDLEWARE']:
-            try:
-                module_path, class_name = middleware_path.rsplit('.', 1)
-                
-                # Skip if middleware of this type already exists
-                if class_name in existing_middleware_types:
-                    continue
-                    
-                module = __import__(module_path, fromlist=[class_name])
-                middleware_class = getattr(module, class_name)
-                broker.add_middleware(middleware_class())
-            except Exception as e:
-                logger.warning(f"Failed to add middleware {middleware_path}: {e}")
-        
-        return broker
-        
-    except Exception as e:
-        logger.error(f"Failed to create Dramatiq broker: {e}")
-        raise
-
-
-# Global broker instance (lazy-loaded)
-_broker_instance = None
-
-
-def get_dramatiq_broker():
-    """
-    Get the global Dramatiq broker instance.
-    
-    Returns:
-        dramatiq.Broker: The singleton broker instance
-    """
-    global _broker_instance
-    
-    if _broker_instance is None:
-        _broker_instance = create_dramatiq_broker()
-    
-    return _broker_instance
-
-
 # === Exports ===
 
 __all__ = [
     "DjangoTasks",
-    "TaskManager", 
     "get_task_service",
     "reset_task_service",
     "is_task_system_available",
     "get_task_health",
-    "enqueue_task",
     "extend_constance_config_with_tasks",
     "initialize_task_system",
-    "clear_dramatiq_queues",
-    "create_dramatiq_broker",
-    "get_dramatiq_broker",
-]
+]

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()

{django_cfg-1.1.59.dist-info → django_cfg-1.1.62.dist-info}/METADATA

@@ -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.dist-info → django_cfg-1.1.62.dist-info}/RECORD

@@ -1,4 +1,4 @@
-django_cfg/__init__.py,sha256=9_vseCVwoJ7CXG8_EjpsdPmqrw021qouoH-wvSSGNwA,14288
+django_cfg/__init__.py,sha256=hKbPbaVNg7IaLQ4vE3n3Y7U-mkn0685XzcnlerGqy-s,14288
 django_cfg/apps.py,sha256=k84brkeXJI7EgKZLEpTkM9YFZofKI4PzhFOn1cl9Msc,1656
 django_cfg/exceptions.py,sha256=RTQEoU3PfR8lqqNNv5ayd_HY2yJLs3eioqUy8VM6AG4,10378
 django_cfg/integration.py,sha256=-7hvd-4ohLdzH4eufCZTOe3yTzPoQyB_HCfvsSm9AAw,5218
@@ -156,7 +156,7 @@ django_cfg/management/commands/create_token.py,sha256=beHtUTuyFZhG97F9vSkaX-u7ti
 django_cfg/management/commands/generate.py,sha256=w0BF7IMftxNjxTxFuY8cw5pNKGW-LmTScJ8kZpxHu_8,4248
 django_cfg/management/commands/list_urls.py,sha256=D8ikInA3uE1LbQGLWmfdLnEqPg7wqrI3caQA6iTe_-0,11009
 django_cfg/management/commands/migrator.py,sha256=mhMM63uv_Jp9zHVVM7TMwCB90uv3iFZn1vOG-rXyi3s,16191
-django_cfg/management/commands/rundramatiq.py,sha256=y9LYzko8ppZw_nQZPIIQ3v5-gqxFz6U0Yx35eQzc5Ag,9117
+django_cfg/management/commands/rundramatiq.py,sha256=1e07PWrtSnxTPZ8RCpgY_yxwV2y-EAduVZDZ34DRqoI,8896
 django_cfg/management/commands/runserver_ngrok.py,sha256=mcTioDIzHgha6sGo5eazlJhdKr8y5-uEQIc3qG3AvCI,5237
 django_cfg/management/commands/script.py,sha256=I6zOEQEGaED0HoLxl2EqKz39HwbKg9HhdxnGKybfH5s,16974
 django_cfg/management/commands/show_config.py,sha256=0YJ99P1XvymT3fWritaNmn_HJ-PVb0I-yBy757M_bn8,8337
@@ -189,8 +189,9 @@ django_cfg/modules/base.py,sha256=X90X-0iBfnaUSaC7S8_ULa_rdT41tqTVJnT05_RuyK4,47
 django_cfg/modules/django_email.py,sha256=uBvvqRVe1DG73Qq2d2IBYTjhFRdvHgsIbkVw3ge9OW8,16586
 django_cfg/modules/django_logger.py,sha256=VfcPCurTdU3iI593EJNs3wUoWQowu7-ykJGuHNkE79M,6325
 django_cfg/modules/django_ngrok.py,sha256=OAvir2pBFHfko-XaVgZTjeJwyZw-NSEILaKNlqQziqA,10476
-django_cfg/modules/django_tasks.py,sha256=qulUuE76sgTykHLaBp6k9A29ULHnp-lUNdsZfNBFZC0,29048
+django_cfg/modules/django_tasks.py,sha256=Vo45h4x8UHieAYdjp3g79efMns0cotkwp5ko4Fbt_pI,12868
 django_cfg/modules/django_telegram.py,sha256=Mun2tAm0P2cUyQlAs8FaPe-FVgcrv7L_-FPTXQQEUT0,16356
+django_cfg/modules/dramatiq_setup.py,sha256=Jke4aO_L1t6F3OAc4pl12zppKzL0gb1p6ilfQ3zUIZ8,454
 django_cfg/modules/logger.py,sha256=4_zeasNehr8LGz8r_ckv15-fQS63zCodiqD4CYIEyFI,10546
 django_cfg/modules/django_currency/README.md,sha256=Ox3jgRtsbOIaMuYDkIhrs9ijLGLbn-2R7mD9n2tjAVE,8512
 django_cfg/modules/django_currency/__init__.py,sha256=SLzzYkkqoz9EsspkzEK0yZ4_Q3JKmb3e_c1GfdYF3GY,1294
@@ -251,8 +252,8 @@ django_cfg/templates/emails/base_email.html,sha256=TWcvYa2IHShlF_E8jf1bWZStRO0v8
 django_cfg/utils/__init__.py,sha256=64wwXJuXytvwt8Ze_erSR2HmV07nGWJ6DV5wloRBvYE,435
 django_cfg/utils/path_resolution.py,sha256=eML-6-RIGTs5TePktIQN8nxfDUEFJ3JA0AzWBcihAbs,13894
 django_cfg/utils/smart_defaults.py,sha256=iL6_n3jGDW5812whylWAwXik0xBSYihdLp4IJ26T5eA,20547
-django_cfg-1.1.59.dist-info/METADATA,sha256=fhstTU5UCjrxQMKM692CCMivv-FNyiZleZBBPkQTyKw,38953
-django_cfg-1.1.59.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-django_cfg-1.1.59.dist-info/entry_points.txt,sha256=Ucmde4Z2wEzgb4AggxxZ0zaYDb9HpyE5blM3uJ0_VNg,56
-django_cfg-1.1.59.dist-info/licenses/LICENSE,sha256=xHuytiUkSZCRG3N11nk1X6q1_EGQtv6aL5O9cqNRhKE,1071
-django_cfg-1.1.59.dist-info/RECORD,,
+django_cfg-1.1.62.dist-info/METADATA,sha256=kN7aAQBvL6bjI5WJrhev0tknRjeiRBoNfFhtQscS74o,38953
+django_cfg-1.1.62.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+django_cfg-1.1.62.dist-info/entry_points.txt,sha256=Ucmde4Z2wEzgb4AggxxZ0zaYDb9HpyE5blM3uJ0_VNg,56
+django_cfg-1.1.62.dist-info/licenses/LICENSE,sha256=xHuytiUkSZCRG3N11nk1X6q1_EGQtv6aL5O9cqNRhKE,1071
+django_cfg-1.1.62.dist-info/RECORD,,