django-cfg 1.1.82__py3-none-any.whl → 1.2.1__py3-none-any.whl

django_cfg/modules/django_health.py

@@ -0,0 +1,267 @@
+"""
+Health Check Views for Django Config Toolkit
+
+Provides health check endpoints for monitoring system status.
+"""
+
+from typing import Dict, Any
+from django.http import JsonResponse
+from django.views import View
+from django.db import connections
+from django.core.cache import cache
+from django.conf import settings
+import time
+import psutil
+import os
+from datetime import datetime
+
+
+class HealthCheckView(View):
+    """
+    Health check endpoint that validates system components.
+    
+    GET /health/ returns:
+    - Database connectivity
+    - Cache availability
+    - System resources
+    - Configuration status
+    """
+    
+    def get(self, request):
+        """Return comprehensive health check data."""
+        health_data = {
+            "status": "healthy",
+            "timestamp": datetime.now().isoformat(),
+            "checks": {}
+        }
+        
+        # Database check
+        try:
+            db_status = self._check_databases()
+            health_data["checks"]["database"] = db_status
+        except Exception as e:
+            health_data["checks"]["database"] = {
+                "status": "error",
+                "error": str(e)
+            }
+            health_data["status"] = "unhealthy"
+        
+        # Cache check
+        try:
+            cache_status = self._check_cache()
+            health_data["checks"]["cache"] = cache_status
+        except Exception as e:
+            health_data["checks"]["cache"] = {
+                "status": "error", 
+                "error": str(e)
+            }
+        
+        # System resources
+        try:
+            system_status = self._check_system_resources()
+            health_data["checks"]["system"] = system_status
+        except Exception as e:
+            health_data["checks"]["system"] = {
+                "status": "warning",
+                "error": str(e)
+            }
+        
+        # Configuration check
+        config_status = self._check_configuration()
+        health_data["checks"]["configuration"] = config_status
+        
+        # Overall status
+        if any(check.get("status") == "error" for check in health_data["checks"].values()):
+            health_data["status"] = "unhealthy"
+        elif any(check.get("status") == "warning" for check in health_data["checks"].values()):
+            health_data["status"] = "degraded"
+        
+        return JsonResponse(health_data)
+    
+    def _check_databases(self) -> Dict[str, Any]:
+        """Check database connectivity."""
+        db_status = {
+            "status": "healthy",
+            "databases": {}
+        }
+        
+        for db_name in connections:
+            try:
+                start_time = time.time()
+                connection = connections[db_name]
+                
+                # Test connection
+                with connection.cursor() as cursor:
+                    cursor.execute("SELECT 1")
+                    cursor.fetchone()
+                
+                response_time = (time.time() - start_time) * 1000
+                
+                db_status["databases"][db_name] = {
+                    "status": "healthy",
+                    "response_time_ms": round(response_time, 2),
+                    "engine": connection.settings_dict.get('ENGINE', 'unknown')
+                }
+                
+            except Exception as e:
+                db_status["databases"][db_name] = {
+                    "status": "error",
+                    "error": str(e)
+                }
+                db_status["status"] = "error"
+        
+        return db_status
+    
+    def _check_cache(self) -> Dict[str, Any]:
+        """Check cache availability."""
+        cache_status = {
+            "status": "healthy"
+        }
+        
+        try:
+            # Test cache write/read
+            test_key = "health_check"
+            test_value = "ok"
+            
+            start_time = time.time()
+            cache.set(test_key, test_value, 30)
+            retrieved_value = cache.get(test_key)
+            response_time = (time.time() - start_time) * 1000
+            
+            if retrieved_value == test_value:
+                cache_status.update({
+                    "status": "healthy",
+                    "response_time_ms": round(response_time, 2),
+                    "backend": getattr(settings, 'CACHES', {}).get('default', {}).get('BACKEND', 'unknown')
+                })
+            else:
+                cache_status = {
+                    "status": "error",
+                    "error": "Cache read/write test failed"
+                }
+                
+        except Exception as e:
+            cache_status = {
+                "status": "error",
+                "error": str(e)
+            }
+        
+        return cache_status
+    
+    def _check_system_resources(self) -> Dict[str, Any]:
+        """Check system resource usage."""
+        try:
+            # CPU usage
+            cpu_percent = psutil.cpu_percent(interval=1)
+            
+            # Memory usage
+            memory = psutil.virtual_memory()
+            memory_percent = memory.percent
+            
+            # Disk usage
+            disk = psutil.disk_usage('/')
+            disk_percent = (disk.used / disk.total) * 100
+            
+            # Load average (Unix-like systems)
+            try:
+                load_avg = os.getloadavg()
+            except (AttributeError, OSError):
+                load_avg = None
+            
+            system_status = {
+                "status": "healthy",
+                "cpu": {
+                    "usage_percent": cpu_percent,
+                    "status": "warning" if cpu_percent > 80 else "healthy"
+                },
+                "memory": {
+                    "usage_percent": memory_percent,
+                    "total_gb": round(memory.total / (1024**3), 2),
+                    "available_gb": round(memory.available / (1024**3), 2),
+                    "status": "warning" if memory_percent > 80 else "healthy"
+                },
+                "disk": {
+                    "usage_percent": round(disk_percent, 2),
+                    "total_gb": round(disk.total / (1024**3), 2),
+                    "free_gb": round(disk.free / (1024**3), 2),
+                    "status": "warning" if disk_percent > 80 else "healthy"
+                }
+            }
+            
+            if load_avg:
+                system_status["load_average"] = {
+                    "1min": load_avg[0],
+                    "5min": load_avg[1], 
+                    "15min": load_avg[2]
+                }
+            
+            # Overall system status
+            if (cpu_percent > 90 or memory_percent > 90 or disk_percent > 90):
+                system_status["status"] = "warning"
+                
+            return system_status
+            
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": f"Failed to get system resources: {str(e)}"
+            }
+    
+    def _check_configuration(self) -> Dict[str, Any]:
+        """Check Django Config Toolkit configuration."""
+        try:
+            from django_cfg import ConfigToolkit
+            
+            toolkit = ConfigToolkit()
+            
+            config_status = {
+                "status": "healthy",
+                "toolkit": {
+                    "version": "1.0.0",
+                    "init_time_ms": toolkit._init_time_ms,
+                    "config_count": toolkit._config_count,
+                    "environment": toolkit.environment,
+                    "debug": toolkit.debug
+                },
+                "features": {
+                    "unfold": toolkit.unfold_enabled,
+                    "revolution": toolkit.revolution_enabled,
+                    "constance": toolkit.constance_enabled,
+                    "logging": toolkit.logging_enabled
+                }
+            }
+            
+            # Validate configuration
+            if not toolkit.secret_key or len(toolkit.secret_key) < 50:
+                config_status["status"] = "warning"
+                config_status["warnings"] = ["Secret key is too short"]
+            
+            return config_status
+            
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": f"Configuration check failed: {str(e)}"
+            }
+
+
+class SimpleHealthView(View):
+    """Simple health check endpoint that just returns OK."""
+    
+    def get(self, request):
+        """Return simple OK response."""
+        return JsonResponse({
+            "status": "ok",
+            "timestamp": datetime.now().isoformat()
+        })
+
+
+# URL patterns for health checks
+def get_health_urls():
+    """Get URL patterns for health check endpoints."""
+    from django.urls import path
+    
+    return [
+        path('health/', HealthCheckView.as_view(), name='health-check'),
+        path('health/simple/', SimpleHealthView.as_view(), name='simple-health'),
+    ]

django_cfg/modules/django_llm/llm/client.py

@@ -37,11 +37,12 @@ from .models import (
     CacheInfo,
     LLMError
 )
+from ...base import BaseCfgModule
 
 logger = logging.getLogger(__name__)
 
 
-class LLMClient:
+class LLMClient(BaseCfgModule):
     """Universal LLM client with caching and token optimization."""
     
     def __init__(
@@ -52,33 +53,40 @@ class LLMClient:
         cache_ttl: int = 3600,
         max_cache_size: int = 1000,
         models_cache_ttl: int = 86400,
-        config: Optional[Any] = None
+        config: Optional[Any] = None,
+        preferred_provider: Optional[str] = None
     ):
         """
         Initialize LLM client.
         
         Args:
-            apikey_openrouter: API key for OpenRouter
-            apikey_openai: API key for OpenAI
+            apikey_openrouter: API key for OpenRouter (auto-detected if not provided)
+            apikey_openai: API key for OpenAI (auto-detected if not provided)
             cache_dir: Cache directory path
             cache_ttl: Cache TTL in seconds
             max_cache_size: Maximum cache size
             models_cache_ttl: Models cache TTL in seconds (default: 24 hours)
             config: DjangoConfig instance for getting headers and settings
+            preferred_provider: Preferred provider ("openai" or "openrouter"). 
+                               If None, defaults to "openai" for embeddings, "openrouter" for chat
         """
-        # Store API keys
+        super().__init__()
+        
+        # Auto-detect API keys from config if not provided
+        django_config = self.get_config()
+        if django_config:
+            if apikey_openai is None:
+                apikey_openai = getattr(django_config, 'openai_api_key', None)
+            # Add other API keys as needed
+        
+        # Store API keys and preferred provider
         self.apikey_openrouter = apikey_openrouter
         self.apikey_openai = apikey_openai
+        self.preferred_provider = preferred_provider
         
-        # Determine primary provider based on available keys
-        if apikey_openrouter:
-            self.primary_provider = "openrouter"
-            self.primary_api_key = apikey_openrouter
-        elif apikey_openai:
-            self.primary_provider = "openai"
-            self.primary_api_key = apikey_openai
-        else:
-            raise ValueError("At least one API key (openrouter or openai) must be provided")
+        # Determine primary provider based on preference and available keys
+        self.primary_provider = self._determine_primary_provider()
+        self.primary_api_key = self._get_primary_api_key()
         
         self.cache = LLMCache(cache_dir=cache_dir, ttl=cache_ttl, max_size=max_cache_size)
         self.django_config = config
@@ -161,7 +169,7 @@ class LLMClient:
         
         config = base_configs[self.provider].copy()
 
-        site_url = getattr(self.django_config, 'site_url', 'https://unrealos.com')
+        site_url = getattr(self.django_config, 'site_url', 'https://djangocfg.com')
         project_name = getattr(self.django_config, 'project_name', 'UnrealOS LLM Client')
         
         # Get headers from django config if available
@@ -245,6 +253,11 @@ class LLMClient:
         if model is None:
             model = self.default_models[self.primary_provider]
         
+        # For OpenAI, remove provider prefix if present
+        api_model = model
+        if self.primary_provider == "openai" and model.startswith("openai/"):
+            api_model = model.replace("openai/", "")
+        
         # Generate cache key
         request_hash = self.cache.generate_request_hash(
             messages=messages,
@@ -275,7 +288,7 @@ class LLMClient:
         try:
             # Prepare parameters
             params = {
-                "model": model,
+                "model": api_model,
                 "messages": messages,
                 "stream": False
             }
@@ -514,9 +527,12 @@ class LLMClient:
         
         start_time = time.time()
         try:
+            # Get the best provider for embedding task
+            embedding_provider = self.get_provider_for_task("embedding")
+            
             # For OpenRouter, we need to use a different model for embeddings
             # OpenRouter doesn't support OpenAI embedding models directly
-            if self.primary_provider == "openrouter":
+            if embedding_provider == "openrouter":
                 # Use a text generation model to simulate embeddings
                 # This is a workaround since OpenRouter doesn't have embedding endpoints
                 logger.warning("OpenRouter doesn't support embedding models, using text generation as fallback")
@@ -561,9 +577,15 @@ class LLMClient:
                 )
             else:
                 # Use real OpenAI embedding API
-                response = self.client.embeddings.create(
+                embedding_client = self.clients[embedding_provider]
+                # For OpenAI, remove provider prefix if present
+                api_model = model
+                if embedding_provider == "openai" and model.startswith("openai/"):
+                    api_model = model.replace("openai/", "")
+                
+                response = embedding_client.embeddings.create(
                     input=text,
-                    model=model
+                    model=api_model
                 )
                 
                 # Extract embedding data
@@ -600,4 +622,54 @@ class LLMClient:
             error_msg = f"Embedding generation failed: {e}"
             logger.error(error_msg)
             raise RuntimeError(error_msg) from e
+    
+    def _determine_primary_provider(self) -> str:
+        """
+        Determine primary provider based on preference and available keys.
+        
+        Returns:
+            Primary provider name
+        """
+        # If preferred provider is explicitly set and available, use it
+        if self.preferred_provider:
+            if self.preferred_provider == "openai" and self.apikey_openai:
+                return "openai"
+            elif self.preferred_provider == "openrouter" and self.apikey_openrouter:
+                return "openrouter"
+            else:
+                logger.warning(f"Preferred provider '{self.preferred_provider}' not available, falling back to auto-detection")
+        
+        # Auto-detection: prefer OpenAI for embeddings, OpenRouter for chat
+        if self.apikey_openai:
+            return "openai"
+        elif self.apikey_openrouter:
+            return "openrouter"
+        else:
+            raise ValueError("At least one API key (openrouter or openai) must be provided")
+    
+    def _get_primary_api_key(self) -> str:
+        """Get API key for the primary provider."""
+        if self.primary_provider == "openai":
+            return self.apikey_openai
+        elif self.primary_provider == "openrouter":
+            return self.apikey_openrouter
+        else:
+            raise ValueError(f"Unknown primary provider: {self.primary_provider}")
+    
+    def get_provider_for_task(self, task: str = "chat") -> str:
+        """
+        Get the best provider for a specific task.
+        
+        Args:
+            task: Task type ("chat", "embedding", "completion")
+            
+        Returns:
+            Provider name for the task
+        """
+        # For embeddings, always prefer OpenAI if available
+        if task == "embedding" and "openai" in self.clients:
+            return "openai"
+        
+        # For other tasks, use primary provider or preferred
+        return self.primary_provider
     

django_cfg/modules/django_llm/translator/translator.py

@@ -12,7 +12,7 @@ from typing import Dict, List, Optional, Any, Set
 from datetime import datetime
 from pathlib import Path
 
-from django_cfg.modules import BaseModule
+from django_cfg.modules import BaseCfgModule
 from ..llm.client import LLMClient
 from ..llm.cache import LLMCache
 from .cache import TranslationCacheManager
@@ -30,7 +30,7 @@ class LanguageDetectionError(TranslationError):
     pass
 
 
-class DjangoTranslator(BaseModule):
+class DjangoTranslator(BaseCfgModule):
     """
     Translation Service for django_cfg, configured via DjangoConfig.
 

django_cfg/modules/django_logger.py

@@ -9,10 +9,10 @@ import logging
 from typing import Optional, Dict, Any, Union
 from pathlib import Path
 
-from . import BaseModule
+from . import BaseCfgModule
 
 
-class DjangoLogger(BaseModule):
+class DjangoLogger(BaseCfgModule):
     """
     Auto-configuring logger that gets settings from DjangoConfig.
     

django_cfg/modules/django_ngrok.py

@@ -8,7 +8,7 @@ import os
 import logging
 import atexit
 from typing import Optional
-from django_cfg.modules.base import BaseModule
+from django_cfg.modules.base import BaseCfgModule
 from django_cfg.models.ngrok import NgrokConfig
 
 logger = logging.getLogger(__name__)
@@ -100,7 +100,7 @@ class NgrokManager:
             self.stop_tunnel()
 
 
-class DjangoNgrok(BaseModule):
+class DjangoNgrok(BaseCfgModule):
     """Main ngrok service for django-cfg."""
     
     def __init__(self):

django_cfg/modules/django_tasks.py

@@ -9,7 +9,7 @@ from typing import Optional, Dict, Any, List
 import logging
 from urllib.parse import urlparse
 
-from django_cfg.modules.base import BaseModule
+from django_cfg.modules.base import BaseCfgModule
 from django_cfg.models.tasks import TaskConfig, validate_task_config
 from django_cfg.models.constance import ConstanceField
 
@@ -35,7 +35,7 @@ except ImportError:
 logger = logging.getLogger(__name__)
 
 
-class DjangoTasks(BaseModule):
+class DjangoTasks(BaseCfgModule):
     """
     Simplified Django-CFG task service.
     
@@ -325,7 +325,34 @@ def initialize_task_system():
                 
                 # Django-dramatiq automatically configures the broker from DRAMATIQ_BROKER setting
                 if hasattr(settings, 'DRAMATIQ_BROKER'):
-                    logger.debug("✅ Dramatiq broker configured from Django settings")
+                    # 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")
                     
@@ -341,6 +368,43 @@ def initialize_task_system():
         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.
@@ -368,6 +432,7 @@ __all__ = [
     "reset_task_service",
     "is_task_system_available",
     "get_task_health",
+    "generate_dramatiq_settings_from_config",
     "extend_constance_config_with_tasks",
     "initialize_task_system",
 ]

django_cfg/modules/django_telegram.py

@@ -9,8 +9,8 @@ import time
 from typing import Optional, Dict, Any, Union, List, BinaryIO
 from enum import Enum
 import yaml
-from django_cfg.modules import BaseModule
-from django_cfg.exceptions import ConfigurationError
+from django_cfg.modules import BaseCfgModule
+from django_cfg.core.exceptions import ConfigurationError
 import telebot
 
 logger = logging.getLogger(__name__)
@@ -42,7 +42,7 @@ class TelegramSendError(TelegramError):
     pass
 
 
-class DjangoTelegram(BaseModule):
+class DjangoTelegram(BaseCfgModule):
     """
     Telegram Service for django_cfg, configured via DjangoConfig.
 

django_cfg/modules/django_twilio/sendgrid_service.py

@@ -19,7 +19,7 @@ from asgiref.sync import sync_to_async
 from django.template.loader import render_to_string
 from django.utils.html import strip_tags
 
-from django_cfg.modules.base import BaseModule
+from django_cfg.modules.base import BaseCfgModule
 from django_cfg.modules.django_twilio.models import TwilioConfig, SendGridConfig
 from django_cfg.modules.django_twilio.exceptions import (
     TwilioConfigurationError,
@@ -34,7 +34,7 @@ except ImportError:
 logger = logging.getLogger(__name__)
 
 
-class SendGridService(BaseModule):
+class SendGridService(BaseCfgModule):
     """
     SendGrid service for email delivery.
     

django_cfg/modules/django_twilio/service.py

@@ -27,7 +27,7 @@ from sendgrid.helpers.mail import Mail
 from asgiref.sync import sync_to_async, async_to_sync
 
 # Django CFG imports
-from django_cfg.modules.base import BaseModule
+from django_cfg.modules.base import BaseCfgModule
 from django_cfg.modules.django_twilio.models import (
     TwilioConfig,
     TwilioChannelType,
@@ -55,7 +55,7 @@ def is_async_context() -> bool:
         return False
 
 
-class BaseTwilioService(BaseModule):
+class BaseTwilioService(BaseCfgModule):
     """
     Base service class for all Twilio operations.
     

django_cfg/modules/django_twilio/simple_service.py

@@ -10,7 +10,7 @@ from typing import Optional, Dict, Any
 from twilio.rest import Client
 from twilio.base.exceptions import TwilioException
 
-from django_cfg.modules.base import BaseModule
+from django_cfg.modules.base import BaseCfgModule
 from django_cfg.modules.django_twilio.models import TwilioConfig
 from django_cfg.modules.django_twilio.exceptions import (
     TwilioError,
@@ -21,7 +21,7 @@ from django_cfg.modules.django_twilio.exceptions import (
 logger = logging.getLogger(__name__)
 
 
-class SimpleTwilioService(BaseModule):
+class SimpleTwilioService(BaseCfgModule):
     """
     Simplified Twilio service for basic messaging operations.