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

django_cfg/apps/accounts/views/otp.py

@@ -42,7 +42,7 @@ class OTPViewSet(viewsets.GenericViewSet):
             500: OTPErrorResponseSerializer,
         },
     )
-    @action(detail=False, methods=["post"], url_path="request")
+    @action(detail=False, methods=["post"], url_path="request", url_name="request")
     def request_otp(self, request):
         """Request OTP code to email or phone."""
         serializer = OTPRequestSerializer(data=request.data)
@@ -111,7 +111,7 @@ class OTPViewSet(viewsets.GenericViewSet):
             410: OTPErrorResponseSerializer,
         },
     )
-    @action(detail=False, methods=["post"], url_path="verify")
+    @action(detail=False, methods=["post"], url_path="verify", url_name="verify")
     def verify_otp(self, request):
         """Verify OTP code and return JWT tokens."""
         serializer = OTPVerifySerializer(data=request.data)

django_cfg/apps/accounts/views/webhook.py

@@ -20,7 +20,7 @@ from drf_spectacular.utils import extend_schema, OpenApiParameter
 from drf_spectacular.types import OpenApiTypes
 from twilio.request_validator import RequestValidator
 
-from django_cfg.core.config import get_current_config
+from django_cfg.core.state import get_current_config
 from ..models import TwilioResponse, OTPSecret
 from ..serializers.webhook import TwilioWebhookSerializer
 

django_cfg/apps/agents/core/django_agent.py

@@ -14,7 +14,7 @@ from pydantic_ai.models.openai import OpenAIChatModel
 from pydantic_ai.providers.openrouter import OpenRouterProvider
 from pydantic_ai.providers.openai import OpenAIProvider
 
-from django_cfg.modules.django_logger import get_logger
+from django_cfg.modules.django_logging import get_logger
 from django_cfg.modules.base import BaseCfgModule
 from .exceptions import ExecutionError, ConfigurationError
 

django_cfg/apps/agents/examples/__init__.py

@@ -0,0 +1,3 @@
+"""
+Examples for Django Orchestrator.
+"""

django_cfg/apps/agents/examples/simple_example.py

@@ -0,0 +1,161 @@
+"""
+Simple example demonstrating Django Orchestrator usage.
+"""
+
+import asyncio
+from dataclasses import dataclass
+from pydantic import BaseModel
+from django.contrib.auth.models import User
+
+from django_cfg.modules.django_orchestrator import DjangoAgent, SimpleOrchestrator, DjangoDeps, RunContext
+
+
+# Define output model
+class GreetingResult(BaseModel):
+    """Result from greeting agent."""
+    greeting: str
+    personalized: bool
+    user_info: str
+
+
+# Create agent
+greeting_agent = DjangoAgent[DjangoDeps, GreetingResult](
+    name="greeting_agent",
+    deps_type=DjangoDeps,
+    output_type=GreetingResult,
+    instructions="Generate personalized greetings for users"
+)
+
+
+# Add tools to agent
+@greeting_agent.tool
+async def get_user_info(ctx: RunContext[DjangoDeps]) -> str:
+    """Get user information for personalization."""
+    user = ctx.deps.user
+    return f"User: {user.username}, Email: {user.email}, Joined: {user.date_joined}"
+
+
+@greeting_agent.tool
+async def get_time_of_day(ctx: RunContext[DjangoDeps]) -> str:
+    """Get current time of day for greeting."""
+    from datetime import datetime
+    hour = datetime.now().hour
+    
+    if hour < 12:
+        return "morning"
+    elif hour < 17:
+        return "afternoon"
+    else:
+        return "evening"
+
+
+async def simple_example():
+    """Run simple orchestrator example."""
+    print("🤖 Django Orchestrator Simple Example")
+    print("=" * 50)
+    
+    # Create test user (in real app, get from request)
+    try:
+        user = await User.objects.aget(username='testuser')
+    except User.DoesNotExist:
+        user = await User.objects.acreate_user(
+            username='testuser',
+            email='test@example.com',
+            first_name='Test',
+            last_name='User'
+        )
+    
+    # Create dependencies
+    deps = DjangoDeps(user=user)
+    
+    # Create orchestrator
+    orchestrator = SimpleOrchestrator()
+    orchestrator.register_agent(greeting_agent)
+    
+    # Execute single agent
+    print("\n1. Single Agent Execution:")
+    results = await orchestrator.execute(
+        pattern="sequential",
+        agents=["greeting_agent"],
+        prompt="Create a personalized greeting",
+        deps=deps
+    )
+    
+    result = results[0]
+    print(f"✅ Agent: {result.agent_name}")
+    print(f"✅ Output: {result.output}")
+    print(f"✅ Execution Time: {result.execution_time:.2f}s")
+    print(f"✅ Tokens Used: {result.tokens_used}")
+    
+    # Get metrics
+    print("\n2. Agent Metrics:")
+    metrics = greeting_agent.get_metrics()
+    for key, value in metrics.items():
+        print(f"📊 {key}: {value}")
+    
+    # Get orchestrator metrics
+    print("\n3. Orchestrator Metrics:")
+    orch_metrics = orchestrator.get_metrics()
+    for key, value in orch_metrics.items():
+        print(f"📈 {key}: {value}")
+
+
+async def multi_agent_example():
+    """Run multi-agent orchestrator example."""
+    print("\n🤖 Multi-Agent Example")
+    print("=" * 30)
+    
+    # Create additional agents
+    analyzer_agent = DjangoAgent[DjangoDeps, BaseModel](
+        name="content_analyzer",
+        deps_type=DjangoDeps,
+        output_type=BaseModel,
+        instructions="Analyze content sentiment and topics"
+    )
+    
+    formatter_agent = DjangoAgent[DjangoDeps, BaseModel](
+        name="content_formatter",
+        deps_type=DjangoDeps,
+        output_type=BaseModel,
+        instructions="Format content for display"
+    )
+    
+    # Create orchestrator
+    orchestrator = SimpleOrchestrator()
+    orchestrator.register_agent(analyzer_agent)
+    orchestrator.register_agent(formatter_agent)
+    
+    # Get user
+    user = await User.objects.aget(username='testuser')
+    deps = DjangoDeps(user=user)
+    
+    # Execute sequential workflow
+    print("\n1. Sequential Workflow:")
+    results = await orchestrator.execute(
+        pattern="sequential",
+        agents=["content_analyzer", "content_formatter"],
+        prompt="Analyze and format this content: Hello world!",
+        deps=deps
+    )
+    
+    for i, result in enumerate(results, 1):
+        print(f"Step {i} - {result.agent_name}: {result.success}")
+    
+    # Execute parallel workflow
+    print("\n2. Parallel Workflow:")
+    results = await orchestrator.execute(
+        pattern="parallel",
+        agents=["content_analyzer", "content_formatter"],
+        prompt="Process content in parallel",
+        deps=deps,
+        max_concurrent=2
+    )
+    
+    successful = sum(1 for r in results if r.success)
+    print(f"✅ {successful}/{len(results)} agents completed successfully")
+
+
+if __name__ == "__main__":
+    # Run examples
+    asyncio.run(simple_example())
+    asyncio.run(multi_agent_example())

django_cfg/apps/api/commands/views.py

@@ -21,13 +21,13 @@ from django.utils import timezone
 logger = logging.getLogger(__name__)
 
 
-def is_superuser(user):
-    """Check if user is superuser."""
-    return user.is_authenticated and user.is_superuser
+def is_staff_user(user):
+    """Check if user is staff member."""
+    return user.is_authenticated and user.is_staff
 
 
 @require_http_methods(["GET"])
-@user_passes_test(is_superuser)
+@user_passes_test(is_staff_user)
 def list_commands_view(request):
     """
     List all available Django management commands.
@@ -81,7 +81,7 @@ def list_commands_view(request):
 
 @csrf_exempt
 @require_http_methods(["POST"])
-@user_passes_test(is_superuser)
+@user_passes_test(is_staff_user)
 def execute_command_view(request):
     """
     Execute a Django management command and stream output in real-time.
@@ -117,106 +117,89 @@ def execute_command_view(request):
                 "error": f"Command '{command_name}' not found",
                 "available_commands": list(available_commands.keys()),
             }, status=400)
-        
-        # Security check - block dangerous commands
-        dangerous_commands = [
-            "flush", "sqlflush", "dbshell", "shell", "shell_plus",
-            "reset_db", "migrate", "makemigrations", "loaddata"
-        ]
-        
-        if command_name in dangerous_commands:
+
+        # Security check - use same filtering as dashboard
+        from django_cfg.modules.django_unfold.callbacks.base import is_command_allowed
+
+        app_name = available_commands.get(command_name)
+        if not is_command_allowed(command_name, app_name):
             return JsonResponse({
-                "status": "error", 
-                "error": f"Command '{command_name}' is not allowed via API for security reasons",
-                "suggestion": "Use django_cfg management commands instead: show_config, test_email",
+                "status": "error",
+                "error": f"Command '{command_name}' is not allowed via web interface for security reasons",
+                "suggestion": "Only safe django_cfg commands and whitelisted utilities can be executed via web.",
             }, status=403)
         
         # Create streaming response generator
         def stream_command_execution():
             """Generator that yields command output in SSE format."""
             start_time = time.time()
-            
+
             # Send start event
             yield f"data: {json.dumps({'type': 'start', 'command': command_name, 'args': args})}\n\n"
-            
+
             try:
-                # Execute command with subprocess for real-time output
-                import subprocess
+                # Capture command output using StringIO
+                from io import StringIO
                 import sys
-                import os
-                
-                # Find Django project root and manage.py
-                from django.conf import settings
-                
-                # Try to find manage.py in project root
-                if hasattr(settings, 'BASE_DIR'):
-                    project_root = settings.BASE_DIR
-                    manage_py_path = os.path.join(project_root, 'manage.py')
-                else:
-                    # Fallback: search for manage.py
-                    current_dir = os.path.dirname(os.path.abspath(__file__))
-                    while current_dir != '/':
-                        manage_py_path = os.path.join(current_dir, 'manage.py')
-                        if os.path.exists(manage_py_path):
-                            project_root = current_dir
-                            break
-                        current_dir = os.path.dirname(current_dir)
-                    else:
-                        raise Exception("Could not find manage.py")
-                
-                # Build command
-                cmd = [sys.executable, manage_py_path, command_name] + args
-                
-                # Add options to command
-                for key, value in options.items():
-                    if key.startswith('--'):
-                        cmd.append(key)
-                        if value is not True:  # Boolean flags don't need values
-                            cmd.append(str(value))
-                    else:
-                        cmd.append(f"--{key}")
-                        if value is not True:
-                            cmd.append(str(value))
-                
-                # Start process
-                process = subprocess.Popen(
-                    cmd,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.STDOUT,
-                    universal_newlines=True,
-                    bufsize=1,
-                    cwd=project_root
-                )
-                
+
+                # Create output buffer
+                output_buffer = StringIO()
+
+                # Redirect stdout/stderr to buffer
+                old_stdout = sys.stdout
+                old_stderr = sys.stderr
+                sys.stdout = output_buffer
+                sys.stderr = output_buffer
+
+                try:
+                    # Execute Django command directly using call_command
+                    call_command(command_name, *args, **options)
+                    return_code = 0
+                except Exception as e:
+                    # Command execution failed
+                    output_buffer.write(f"\nError: {str(e)}\n")
+                    return_code = 1
+                finally:
+                    # Restore stdout/stderr
+                    sys.stdout = old_stdout
+                    sys.stderr = old_stderr
+
+                # Get all output
+                output = output_buffer.getvalue()
+
                 # Stream output line by line
-                for line in iter(process.stdout.readline, ''):
-                    if line:
-                        line = line.rstrip('\n\r')
-                        yield f"data: {json.dumps({'type': 'output', 'line': line})}\n\n"
-                
-                # Wait for process to complete
-                return_code = process.wait()
+                if output:
+                    for line in output.split('\n'):
+                        if line.strip():
+                            yield f"data: {json.dumps({'type': 'output', 'line': line})}\n\n"
+
                 execution_time = time.time() - start_time
-                
+
                 # Send completion event
                 yield f"data: {json.dumps({'type': 'complete', 'return_code': return_code, 'execution_time': round(execution_time, 2)})}\n\n"
-                
+
                 # Log command execution
-                logger.info(
-                    f"Command executed: {command_name} {' '.join(args)} "
-                    f"by user {request.user.username} in {execution_time:.2f}s with exit code {return_code}"
-                )
-                
+                if return_code == 0:
+                    logger.info(
+                        f"Command executed: {command_name} {' '.join(args)} "
+                        f"by user {request.user.username} in {execution_time:.2f}s"
+                    )
+                else:
+                    logger.error(
+                        f"Command failed: {command_name} {' '.join(args)} "
+                        f"by user {request.user.username} in {execution_time:.2f}s"
+                    )
+
             except Exception as cmd_error:
                 execution_time = time.time() - start_time
-                
+
                 logger.error(
                     f"Command failed: {command_name} {' '.join(args)} "
                     f"by user {request.user.username}: {cmd_error}"
                 )
-                
+
                 # Send error event
-                yield f"data: {json.dumps({'type': 'error', 'error': str(cmd_error), 'execution_time': round(execution_time, 2)})}\n\n"
+                yield f"data: {json.dumps({'type': 'error', 'message': str(cmd_error), 'execution_time': round(execution_time, 2)})}\n\n"
         
         # Return streaming response
         response = StreamingHttpResponse(
@@ -243,7 +226,7 @@ def execute_command_view(request):
 
 
 @require_http_methods(["GET"])
-@user_passes_test(is_superuser)
+@user_passes_test(is_staff_user)
 def command_help_view(request, command_name):
     """
     Get help information for a specific command.

django_cfg/apps/api/health/drf_views.py

@@ -0,0 +1,269 @@
+"""
+Django CFG Health Check DRF Views
+
+DRF browsable API views with Tailwind theme support.
+"""
+
+import os
+import time
+import psutil
+from datetime import datetime
+from typing import Dict, Any
+
+from django.conf import settings
+from django.db import connections
+from django.core.cache import cache
+from django.utils import timezone
+
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from rest_framework.permissions import AllowAny
+
+from django_cfg.core.integration import get_current_version
+from .serializers import HealthCheckSerializer, QuickHealthSerializer
+
+
+class DRFHealthCheckView(APIView):
+    """
+    Django CFG comprehensive health check endpoint with DRF Browsable API.
+
+    Auto-discovers configuration from DjangoConfig and checks:
+    - All configured databases
+    - Cache connectivity
+    - System resources
+    - Configuration status
+
+    This endpoint uses DRF Browsable API with Tailwind CSS theme! 🎨
+    """
+
+    permission_classes = [AllowAny]  # Public endpoint
+    serializer_class = HealthCheckSerializer  # For schema generation
+
+    def get(self, request):
+        """Return comprehensive health check data."""
+        # Get DjangoConfig instance
+        try:
+            config = getattr(settings, 'config', None)
+
+            health_data = {
+                "status": "healthy",
+                "timestamp": timezone.now(),
+                "service": config.project_name if config else "Django CFG",
+                "version": get_current_version(),
+                "checks": {}
+            }
+        except Exception:
+            health_data = {
+                "status": "healthy",
+                "timestamp": timezone.now(),
+                "service": "Django CFG",
+                "version": get_current_version(),
+                "checks": {}
+            }
+
+        # Database connectivity check
+        try:
+            db_status = self._check_databases()
+            health_data["checks"]["databases"] = db_status
+        except Exception as e:
+            health_data["checks"]["databases"] = {
+                "status": "error",
+                "error": str(e)
+            }
+            health_data["status"] = "unhealthy"
+
+        # Cache availability 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)
+            }
+            if health_data["status"] != "unhealthy":
+                health_data["status"] = "degraded"
+
+        # System resources check
+        try:
+            system_status = self._check_system_resources()
+            health_data["checks"]["system"] = system_status
+        except Exception as e:
+            health_data["checks"]["system"] = {
+                "status": "error",
+                "error": str(e)
+            }
+
+        # Environment info
+        health_data["environment"] = {
+            "debug": getattr(settings, 'DEBUG', False),
+            "django_env": os.getenv("DJANGO_ENV", "development"),
+            "python_version": f"{os.sys.version_info.major}.{os.sys.version_info.minor}.{os.sys.version_info.micro}",
+        }
+
+        # Return appropriate HTTP status
+        http_status = status.HTTP_200_OK
+        if health_data["status"] == "unhealthy":
+            http_status = status.HTTP_503_SERVICE_UNAVAILABLE
+        elif health_data["status"] == "degraded":
+            http_status = status.HTTP_200_OK  # Still operational
+
+        return Response(health_data, status=http_status)
+
+    def _check_databases(self) -> Dict[str, Any]:
+        """Check all configured database connections."""
+        db_results = {}
+
+        # Get all configured databases
+        database_names = list(getattr(settings, 'DATABASES', {}).keys())
+
+        for db_name in database_names:
+            try:
+                start_time = time.time()
+                conn = connections[db_name]
+
+                with conn.cursor() as cursor:
+                    cursor.execute("SELECT 1")
+                    cursor.fetchone()
+
+                response_time = (time.time() - start_time) * 1000  # ms
+
+                db_results[db_name] = {
+                    "status": "healthy",
+                    "response_time_ms": round(response_time, 2),
+                    "engine": conn.settings_dict.get("ENGINE", "unknown"),
+                }
+
+            except Exception as e:
+                db_results[db_name] = {
+                    "status": "error",
+                    "error": str(e)[:100],  # Truncate long errors
+                }
+
+        # Overall database status
+        all_healthy = all(
+            db["status"] == "healthy"
+            for db in db_results.values()
+        ) if db_results else False
+
+        return {
+            "status": "healthy" if all_healthy else "error",
+            "databases": db_results,
+            "total_databases": len(db_results),
+        }
+
+    def _check_cache(self) -> Dict[str, Any]:
+        """Check cache connectivity and performance."""
+        try:
+            test_key = "django_cfg_health_check"
+            test_value = f"test_{int(time.time())}"
+
+            # Test cache write
+            start_time = time.time()
+            cache.set(test_key, test_value, timeout=60)
+            write_time = (time.time() - start_time) * 1000
+
+            # Test cache read
+            start_time = time.time()
+            cached_value = cache.get(test_key)
+            read_time = (time.time() - start_time) * 1000
+
+            # Cleanup
+            cache.delete(test_key)
+
+            if cached_value == test_value:
+                return {
+                    "status": "healthy",
+                    "write_time_ms": round(write_time, 2),
+                    "read_time_ms": round(read_time, 2),
+                    "backend": getattr(settings, "CACHES", {}).get("default", {}).get("BACKEND", "unknown"),
+                }
+            else:
+                return {
+                    "status": "error",
+                    "error": "Cache read/write mismatch"
+                }
+
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": str(e)
+            }
+
+    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()
+
+            # Disk usage
+            disk = psutil.disk_usage('/')
+
+            # System uptime
+            boot_time = datetime.fromtimestamp(psutil.boot_time())
+            uptime = datetime.now() - boot_time
+
+            return {
+                "status": "healthy",
+                "cpu": {
+                    "percent": cpu_percent,
+                    "count": psutil.cpu_count(),
+                },
+                "memory": {
+                    "percent": memory.percent,
+                    "used_gb": round(memory.used / (1024**3), 2),
+                    "total_gb": round(memory.total / (1024**3), 2),
+                },
+                "disk": {
+                    "percent": round((disk.used / disk.total) * 100, 2),
+                    "used_gb": round(disk.used / (1024**3), 2),
+                    "total_gb": round(disk.total / (1024**3), 2),
+                },
+                "uptime": {
+                    "days": uptime.days,
+                    "hours": uptime.seconds // 3600,
+                    "boot_time": boot_time.isoformat(),
+                },
+                "process_count": len(psutil.pids()),
+            }
+
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": str(e)
+            }
+
+
+class DRFQuickHealthView(APIView):
+    """
+    Quick health check for load balancers with DRF Browsable API.
+
+    This endpoint uses DRF Browsable API with Tailwind CSS theme! 🎨
+    """
+
+    permission_classes = [AllowAny]  # Public endpoint
+    serializer_class = QuickHealthSerializer  # For schema generation
+
+    def get(self, request):
+        """Return minimal health status."""
+        try:
+            # Just check main database
+            conn = connections["default"]
+            with conn.cursor() as cursor:
+                cursor.execute("SELECT 1")
+
+            return Response({
+                "status": "ok",
+                "timestamp": timezone.now(),
+            })
+
+        except Exception as e:
+            return Response({
+                "status": "error",
+                "error": str(e),
+                "timestamp": timezone.now(),
+            }, status=status.HTTP_503_SERVICE_UNAVAILABLE)