django-cfg 1.1.81__py3-none-any.whl → 1.2.0__py3-none-any.whl

django_cfg/apps/accounts/views/otp.py

@@ -16,7 +16,6 @@ from ..serializers.otp import (
 )
 from ..serializers.profile import UserSerializer
 from django.contrib.auth import get_user_model
-from ..utils.notifications import AccountNotifications
 
 logger = logging.getLogger(__name__)
 
@@ -25,7 +24,6 @@ class OTPViewSet(viewsets.GenericViewSet):
     """OTP authentication ViewSet with nested router support."""
 
     permission_classes = [permissions.AllowAny]
-    serializer_class = OTPRequestSerializer  # Default serializer for OPTIONS requests
 
     @extend_schema(
         request=OTPRequestSerializer,
@@ -37,20 +35,27 @@ class OTPViewSet(viewsets.GenericViewSet):
     )
     @action(detail=False, methods=["post"], url_path="request")
     def request_otp(self, request):
-        """Request OTP code to email."""
+        """Request OTP code to email or phone."""
         serializer = OTPRequestSerializer(data=request.data)
         serializer.is_valid(raise_exception=True)
 
         identifier = serializer.validated_data["identifier"]
         channel = serializer.validated_data.get("channel")
         source_url = serializer.validated_data.get("source_url")
-        logger.debug(f"Starting OTP request for {identifier} via {channel}, source: {source_url}")
+        
+        # Auto-detect channel if not provided
+        if not channel:
+            channel = 'email' if '@' in identifier else 'phone'
+        
+        logger.debug(f"Starting OTP request for {channel}: {identifier}, source: {source_url}")
 
         try:
-            if channel == 'phone':
-                success, error_type = OTPService.request_phone_otp(identifier, source_url)
-            else:  # email channel (default)
-                success, error_type = OTPService.request_email_otp(identifier, source_url)
+            if channel == 'email':
+                success, error_type = OTPService.request_otp(identifier, source_url)
+            else:
+                # For phone OTP, we'll need to implement phone OTP service
+                # For now, fallback to email-based service
+                success, error_type = OTPService.request_otp(identifier, source_url)
         except Exception as e:
             # Log the full traceback for debugging
             logger.error(f"OTP request failed with exception: {str(e)}")
@@ -61,21 +66,20 @@ class OTPViewSet(viewsets.GenericViewSet):
             )
 
         if success:
-            channel_name = "phone number" if channel == 'phone' else "email address"
             return Response(
-                {"message": f"OTP sent to your {channel_name}"}, status=status.HTTP_200_OK
+                {"message": "OTP sent to your email address"}, status=status.HTTP_200_OK
             )
         else:
-            if error_type in ["invalid_email", "invalid_phone"]:
-                field_name = "phone number" if error_type == "invalid_phone" else "email address"
-                logger.warning(f"Invalid {field_name} provided: {identifier}")
+            if error_type == "invalid_email":
+                logger.warning(f"Invalid identifier provided: {identifier}")
                 return Response(
-                    {"error": f"Invalid {field_name}"},
+                    {"error": "Invalid identifier format"},
                     status=status.HTTP_400_BAD_REQUEST,
                 )
             elif error_type == "user_creation_failed":
                 # Log additional details for user creation failure
-                logger.error(f"User creation failed for {identifier}: {error_type}")
+                logger.error(f"User creation failed for identifier: {identifier}")
+                logger.error(f"Error type: {error_type}")
                 logger.error(
                     f"Full traceback for user creation failure: {traceback.format_exc()}"
                 )
@@ -84,7 +88,7 @@ class OTPViewSet(viewsets.GenericViewSet):
                     status=status.HTTP_500_INTERNAL_SERVER_ERROR,
                 )
             else:
-                logger.error(f"Unknown error type: {error_type} for {identifier}")
+                logger.error(f"Unknown error type: {error_type} for identifier: {identifier}")
                 return Response(
                     {"error": "Failed to send OTP"},
                     status=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -108,27 +112,19 @@ class OTPViewSet(viewsets.GenericViewSet):
         otp = serializer.validated_data["otp"]
         channel = serializer.validated_data.get("channel")
         source_url = serializer.validated_data.get("source_url")
+        
+        # Auto-detect channel if not provided
+        if not channel:
+            channel = 'email' if '@' in identifier else 'phone'
 
-        if channel == 'phone':
-            user = OTPService.verify_phone_otp(identifier, otp, source_url)
-        else:  # email channel (default)
-            user = OTPService.verify_email_otp(identifier, otp, source_url)
+        if channel == 'email':
+            user = OTPService.verify_otp(identifier, otp, source_url)
+        else:
+            # For phone OTP, we'll need to implement phone OTP verification
+            # For now, fallback to email-based service
+            user = OTPService.verify_otp(identifier, otp, source_url)
 
         if user:
-            # Check if this is a new user (created recently, within last 5 minutes)
-            from django.utils import timezone
-            from datetime import timedelta
-            
-            is_new_user = (timezone.now() - user.date_joined) < timedelta(minutes=5)
-            
-            # Send welcome email only for new users
-            if is_new_user:
-                try:
-                    AccountNotifications.send_welcome_email(user, send_email=True, send_telegram=False)
-                    logger.info(f"Welcome email sent to new user: {user.email}")
-                except Exception as e:
-                    logger.error(f"Failed to send welcome email to {user.email}: {e}")
-            
             refresh = RefreshToken.for_user(user)
             return Response(
                 {
@@ -142,9 +138,12 @@ class OTPViewSet(viewsets.GenericViewSet):
             # Check if user was deleted after OTP was sent
             try:
                 User = get_user_model()
-                if channel == 'phone':
-                    User.objects.get(phone=identifier)
+                # For email identifiers, check by email; for phone, we'd need phone field
+                if '@' in identifier:
+                    User.objects.get(email=identifier)
                 else:
+                    # For phone numbers, we'd need to implement phone field lookup
+                    # For now, assume email-based lookup
                     User.objects.get(email=identifier)
                 # User exists but OTP is invalid
                 return Response(

django_cfg/apps/agents/README.md

@@ -0,0 +1,129 @@
+# Django Orchestrator
+
+Universal agent orchestration system for Django applications using Pydantic AI.
+
+## Quick Start
+
+```python
+from django_cfg.modules.django_orchestrator import DjangoAgent, SimpleOrchestrator, DjangoDeps
+from pydantic import BaseModel
+
+# Define output model
+class GreetingResult(BaseModel):
+    greeting: str
+    personalized: bool
+
+# Create agent
+agent = DjangoAgent[DjangoDeps, GreetingResult](
+    name="greeter",
+    deps_type=DjangoDeps,
+    output_type=GreetingResult,
+    instructions="Generate personalized greetings"
+)
+
+# Use orchestrator
+orchestrator = SimpleOrchestrator()
+orchestrator.register_agent(agent)
+
+# Execute
+deps = await DjangoDeps.from_user_id(user_id)
+results = await orchestrator.execute(
+    pattern="sequential",
+    agents=["greeter"],
+    prompt="Say hello",
+    deps=deps
+)
+```
+
+## Features
+
+- 🎯 **Type-Safe Agents** - Full typing with `Agent[DepsT, OutputT]`
+- 🔧 **Django Integration** - Native ORM, signals, and task support
+- 📊 **Multiple Patterns** - Sequential, parallel, conditional execution
+- ⚡ **KISS Design** - Simple, clean, no overengineering
+- 🔄 **Reuses Existing** - Built on django_llm module
+- 🧪 **Easy Testing** - Mock-friendly design
+
+## Installation
+
+Add to your Django settings:
+
+```python
+INSTALLED_APPS = [
+    'django_cfg.modules.django_orchestrator',
+]
+```
+
+Run migrations:
+
+```bash
+python manage.py migrate django_orchestrator
+```
+
+## Documentation
+
+See the complete documentation in the `@docs2/` directory:
+
+- **[index.md](@docs2/index.md)** - Module overview
+- **[quick-start.md](@docs2/quick-start.md)** - Get started in 5 minutes
+- **[api.md](@docs2/api.md)** - Complete API reference
+- **[examples.md](@docs2/examples.md)** - Real-world usage patterns
+
+## Architecture
+
+```
+django_orchestrator/
+├── core/
+│   ├── agent.py           # DjangoAgent wrapper
+│   ├── orchestrator.py    # Main orchestrator
+│   ├── dependencies.py    # Dependency injection
+│   ├── models.py          # Data models
+│   └── exceptions.py      # Custom exceptions
+├── models/
+│   ├── execution.py       # Execution tracking
+│   ├── registry.py        # Agent registry
+│   └── toolsets.py        # Tool management
+├── examples/
+│   └── simple_example.py  # Working examples
+└── tests/
+    └── test_core.py        # Test suite
+```
+
+## Examples
+
+### Basic Agent
+
+```python
+@agent.tool
+async def get_user_data(ctx: RunContext[DjangoDeps]) -> str:
+    user = await User.objects.aget(id=ctx.deps.user.id)
+    return f"User: {user.username}"
+
+result = await agent.run("Get user info", deps=deps)
+```
+
+### Multi-Agent Pipeline
+
+```python
+orchestrator.register_agent(analyzer)
+orchestrator.register_agent(processor)
+
+results = await orchestrator.execute(
+    pattern="sequential",
+    agents=["analyzer", "processor"],
+    prompt="Process content",
+    deps=deps
+)
+```
+
+## Testing
+
+Run tests:
+
+```bash
+python -m pytest django_cfg/modules/django_orchestrator/tests/
+```
+
+## License
+
+Part of django-cfg package.

django_cfg/apps/agents/__init__.py

@@ -0,0 +1,68 @@
+"""
+Django Agents - Universal AI agent system for Django applications.
+
+Built on Pydantic AI with KISS principles and proper decomposition.
+"""
+
+__version__ = "0.1.0"
+__author__ = "Django-CFG Team"
+
+# Set default app config
+default_app_config = 'django_cfg.apps.agents.apps.AgentsConfig'
+
+__all__ = [
+    # Core classes
+    "DjangoAgent",
+    "SimpleOrchestrator",
+    "DjangoDeps",
+    "RunContext",
+    
+    # Models
+    "ExecutionResult",
+    "WorkflowConfig",
+    "ProcessResult",
+    "AnalysisResult",
+    
+    # Exceptions
+    "AgentError",
+    "AgentNotFoundError", 
+    "ExecutionError",
+]
+
+def __getattr__(name):
+    """Lazy import for agents components."""
+    if name == "DjangoAgent":
+        from .core.agent import DjangoAgent
+        return DjangoAgent
+    elif name == "SimpleOrchestrator":
+        from .core.orchestrator import SimpleOrchestrator
+        return SimpleOrchestrator
+    elif name == "DjangoDeps":
+        from .core.dependencies import DjangoDeps
+        return DjangoDeps
+    elif name == "RunContext":
+        from .core.dependencies import RunContext
+        return RunContext
+    elif name == "ExecutionResult":
+        from .core.models import ExecutionResult
+        return ExecutionResult
+    elif name == "WorkflowConfig":
+        from .core.models import WorkflowConfig
+        return WorkflowConfig
+    elif name == "ProcessResult":
+        from .core.models import ProcessResult
+        return ProcessResult
+    elif name == "AnalysisResult":
+        from .core.models import AnalysisResult
+        return AnalysisResult
+    elif name == "AgentError":
+        from .core.exceptions import AgentError
+        return AgentError
+    elif name == "AgentNotFoundError":
+        from .core.exceptions import AgentNotFoundError
+        return AgentNotFoundError
+    elif name == "ExecutionError":
+        from .core.exceptions import ExecutionError
+        return ExecutionError
+    else:
+        raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

django_cfg/apps/agents/admin/__init__.py

@@ -0,0 +1,17 @@
+"""
+Django admin interfaces for Django Orchestrator.
+"""
+
+from .registry_admin import AgentDefinitionAdmin, AgentTemplateAdmin
+from .execution_admin import AgentExecutionAdmin, WorkflowExecutionAdmin
+from .toolsets_admin import ToolExecutionAdmin, ApprovalLogAdmin, ToolsetConfigurationAdmin
+
+__all__ = [
+    'AgentDefinitionAdmin',
+    'AgentTemplateAdmin', 
+    'AgentExecutionAdmin',
+    'WorkflowExecutionAdmin',
+    'ToolExecutionAdmin',
+    'ApprovalLogAdmin',
+    'ToolsetConfigurationAdmin',
+]