django-cfg 1.3.13__py3-none-any.whl → 1.4.0__py3-none-any.whl

django_cfg/modules/django_tasks/factory.py

@@ -0,0 +1,127 @@
+"""
+Task service factory and utilities.
+
+Provides singleton instance and utility functions.
+"""
+
+from typing import Optional, Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Lazy import to avoid circular dependency
+_task_service_instance = None
+
+
+def get_task_service():
+    """Get the global task service instance."""
+    global _task_service_instance
+
+    if _task_service_instance is None:
+        from .service import DjangoTasks
+        _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
+
+
+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'):
+                    # Configure broker with middleware
+                    broker_config = settings.DRAMATIQ_BROKER
+                    middleware_list = getattr(settings, 'DRAMATIQ_MIDDLEWARE', [])
+
+                    # Import and instantiate middleware
+                    middleware_instances = []
+                    for middleware_path in middleware_list:
+                        try:
+                            module_path, class_name = middleware_path.rsplit('.', 1)
+                            module = __import__(module_path, fromlist=[class_name])
+                            middleware_class = getattr(module, class_name)
+                            middleware_instances.append(middleware_class())
+                        except Exception as e:
+                            logger.warning(f"Failed to load middleware {middleware_path}: {e}")
+
+                    # Create broker with middleware
+                    broker_class_path = broker_config['BROKER']
+                    module_path, class_name = broker_class_path.rsplit('.', 1)
+                    module = __import__(module_path, fromlist=[class_name])
+                    broker_class = getattr(module, class_name)
+
+                    broker_options = broker_config.get('OPTIONS', {})
+                    broker = broker_class(middleware=middleware_instances, **broker_options)
+
+                    # Set as default broker
+                    dramatiq.set_broker(broker)
+
+                    logger.debug(f"✅ Dramatiq broker configured with {len(middleware_instances)} middleware")
+                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}")
+
+
+__all__ = [
+    "get_task_service",
+    "reset_task_service",
+    "is_task_system_available",
+    "get_task_health",
+    "initialize_task_system",
+]

django_cfg/modules/{django_tasks.py → django_tasks/service.py}

@@ -1,19 +1,18 @@
 """
-Django-CFG Task Service Module.
+Django-CFG Task Service.
 
-Simplified and focused task service for Dramatiq integration.
-Provides essential functionality without unnecessary complexity.
+Main DjangoTasks class for Dramatiq integration.
 """
 
 from typing import Optional, Dict, Any, List
 import logging
 from urllib.parse import urlparse
 
-from . import BaseCfgModule
+from ..base import BaseCfgModule
 from django_cfg.models.tasks import TaskConfig, validate_task_config
-from django_cfg.models.constance import ConstanceField
+from django_cfg.models.django.constance import ConstanceField
 
-# Django imports (will be available when Django is configured)
+# Django imports
 try:
     from django.apps import apps
 except ImportError:
@@ -36,25 +35,24 @@ logger = logging.getLogger(__name__)
 class DjangoTasks(BaseCfgModule):
     """
     Simplified Django-CFG task service.
-    
+
     Focuses on essential functionality:
     - Configuration management
     - Task discovery
     - Health checks
     - Constance integration
     """
-    
+
     def __init__(self):
         super().__init__()
         self._config: Optional[TaskConfig] = None
         self._redis_url: Optional[str] = None
-    
+
     @property
     def config(self) -> Optional[TaskConfig]:
         """Get task configuration (lazy-loaded)."""
         if self._config is None:
             try:
-                # Get config from django-cfg
                 django_config = self.get_config()
                 if django_config and hasattr(django_config, 'tasks'):
                     self._config = django_config.tasks
@@ -70,38 +68,36 @@ class DjangoTasks(BaseCfgModule):
                         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 using the same logic as Dramatiq settings generation."""
         if self._redis_url is None:
-            # Use BaseCfgModule to get config (same as generate_dramatiq_settings_from_config)
             config = self.get_config()
-            
+
             if not config:
                 raise RuntimeError("No Django-CFG configuration available")
-            
-            # Get Redis URL from cache config (same logic as generate_dramatiq_settings_from_config)
+
+            # Get Redis URL from cache config
             if hasattr(config, 'cache_default') and config.cache_default:
                 self._redis_url = getattr(config.cache_default, 'redis_url', None)
                 if self._redis_url:
                     logger.debug(f"Got Redis URL from cache config: {self._redis_url}")
                     return self._redis_url
-            
-            # If no cache_default, try to get from Django cache settings
+
+            # If no cache_default, try Django cache settings
             try:
                 from django.conf import settings
                 if hasattr(settings, 'CACHES') and 'default' in settings.CACHES:
@@ -113,8 +109,8 @@ class DjangoTasks(BaseCfgModule):
                             return self._redis_url
             except Exception as e:
                 logger.debug(f"Could not get Redis URL from Django settings: {e}")
-            
-            # Try to get from DRAMATIQ_BROKER settings
+
+            # Try DRAMATIQ_BROKER settings
             try:
                 from django.conf import settings
                 if hasattr(settings, 'DRAMATIQ_BROKER'):
@@ -126,22 +122,21 @@ class DjangoTasks(BaseCfgModule):
                             return self._redis_url
             except Exception as e:
                 logger.debug(f"Could not get Redis URL from DRAMATIQ_BROKER settings: {e}")
-            
-            # If still no Redis URL found, raise error (no fallbacks)
+
             raise RuntimeError("No Redis URL found in cache configuration, Django settings, or DRAMATIQ_BROKER")
-        
+
         return self._redis_url
-    
+
     def get_redis_client(self):
         """Get Redis client instance."""
         redis_url = self.get_redis_url()
         if not redis_url or redis is None:
             return None
-        
+
         try:
             parsed = urlparse(redis_url)
-            
-            # Extract database from URL path, fallback to config or default
+
+            # Extract database from URL path
             db = 1  # Default
             if parsed.path and parsed.path != "/":
                 try:
@@ -150,9 +145,9 @@ class DjangoTasks(BaseCfgModule):
                     pass
             elif self.config and self.config.dramatiq:
                 db = self.config.dramatiq.redis_db
-            
+
             logger.debug(f"Using Redis DB: {db} from URL: {redis_url}")
-            
+
             return redis.Redis(
                 host=parsed.hostname or 'localhost',
                 port=parsed.port or 6379,
@@ -163,49 +158,44 @@ class DjangoTasks(BaseCfgModule):
         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:
@@ -215,20 +205,19 @@ class DjangoTasks(BaseCfgModule):
                         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",
@@ -267,10 +256,10 @@ class DjangoTasks(BaseCfgModule):
                 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 = {
@@ -279,231 +268,13 @@ class DjangoTasks(BaseCfgModule):
             "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'):
-                    # Configure broker with middleware
-                    broker_config = settings.DRAMATIQ_BROKER
-                    middleware_list = getattr(settings, 'DRAMATIQ_MIDDLEWARE', [])
-                    
-                    # Import and instantiate middleware
-                    middleware_instances = []
-                    for middleware_path in middleware_list:
-                        try:
-                            module_path, class_name = middleware_path.rsplit('.', 1)
-                            module = __import__(module_path, fromlist=[class_name])
-                            middleware_class = getattr(module, class_name)
-                            middleware_instances.append(middleware_class())
-                        except Exception as e:
-                            logger.warning(f"Failed to load middleware {middleware_path}: {e}")
-                    
-                    # Create broker with middleware
-                    broker_class_path = broker_config['BROKER']
-                    module_path, class_name = broker_class_path.rsplit('.', 1)
-                    module = __import__(module_path, fromlist=[class_name])
-                    broker_class = getattr(module, class_name)
-                    
-                    broker_options = broker_config.get('OPTIONS', {})
-                    broker = broker_class(middleware=middleware_instances, **broker_options)
-                    
-                    # Set as default broker
-                    dramatiq.set_broker(broker)
-                    
-                    logger.debug(f"✅ Dramatiq broker configured with {len(middleware_instances)} middleware")
-                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 generate_dramatiq_settings_from_config(config):
-    """
-    Generate Dramatiq settings from DjangoConfig instance.
-    
-    Args:
-        config: DjangoConfig instance with tasks configuration
-        
-    Returns:
-        Dict[str, Any]: Dramatiq settings dictionary or empty dict if not enabled
-    """
-    try:
-        if not hasattr(config, "tasks") or not config.tasks or not config.tasks.enabled:
-            return {}
-            
-        # Get Redis URL from cache configuration
-        redis_url = None
-        if config.cache_default and hasattr(config.cache_default, 'redis_url'):
-            redis_url = config.cache_default.redis_url
-        elif config.cache_default and hasattr(config.cache_default, 'location'):
-            redis_url = config.cache_default.location
-        else:
-            # Fallback to default Redis URL
-            redis_url = "redis://localhost:6379"
-        
-        if redis_url:
-            dramatiq_settings = config.tasks.get_dramatiq_settings(redis_url)
-            logger.debug(f"Generated Dramatiq settings with Redis URL: {redis_url}")
-            return dramatiq_settings
-        else:
-            logger.warning("Tasks enabled but no Redis URL available for Dramatiq")
-            return {}
-            
-    except Exception as e:
-        logger.error(f"Failed to generate Dramatiq settings: {e}")
-        return {}
-
-
-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 []
 
+        return status
 
-# === Exports ===
 
-def generate_dramatiq_settings_from_config() -> Optional[Dict[str, Any]]:
-    """
-    Generate Dramatiq settings from auto-discovered DjangoConfig.
-    
-    Returns:
-        Dictionary of Dramatiq settings or None if tasks disabled
-    """
-    try:
-        # Get config through BaseCfgModule
-        base_module = BaseCfgModule()
-        config = base_module.get_config()
-        
-        if not config or not hasattr(config, 'tasks') or not config.tasks or not config.tasks.enabled:
-            return None
-        
-        # Get Redis URL from cache config or environment
-        redis_url = None
-        if hasattr(config, 'cache_default') and config.cache_default:
-            redis_url = getattr(config.cache_default, 'redis_url', None)
-        
-        if not redis_url:
-            # Fallback to environment or default
-            import os
-            redis_url = os.getenv('REDIS_URL', 'redis://localhost:6379/1')
-        
-        # Generate Dramatiq settings
-        dramatiq_settings = config.tasks.get_dramatiq_settings(redis_url)
-        
-        # Ensure we only use Redis broker (no RabbitMQ)
-        if 'DRAMATIQ_BROKER' in dramatiq_settings:
-            dramatiq_settings['DRAMATIQ_BROKER']['BROKER'] = 'dramatiq.brokers.redis.RedisBroker'
-        
-        logger.info(f"✅ Generated Dramatiq settings with Redis broker and {len(config.tasks.dramatiq.queues)} queues")
-        return dramatiq_settings
-        
-    except Exception as e:
-        logger.error(f"Failed to generate Dramatiq settings: {e}")
-        return None
-
-
-__all__ = [
-    "DjangoTasks",
-    "get_task_service",
-    "reset_task_service",
-    "is_task_system_available",
-    "get_task_health",
-    "generate_dramatiq_settings_from_config",
-    "extend_constance_config_with_tasks",
-    "initialize_task_system",
-]
+__all__ = ["DjangoTasks"]