django-cfg 1.3.7__py3-none-any.whl → 1.3.11__py3-none-any.whl

django_cfg/apps/accounts/admin/user.py

@@ -1,300 +0,0 @@
-"""
-User admin configuration.
-"""
-
-from django.contrib import admin
-from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
-from django.utils.html import format_html
-from django.contrib.humanize.templatetags.humanize import naturaltime, naturalday
-from django.shortcuts import redirect
-from django.urls import reverse
-from unfold.admin import ModelAdmin
-from unfold.forms import AdminPasswordChangeForm, UserChangeForm, UserCreationForm
-from unfold.decorators import action
-from unfold.enums import ActionVariant
-from django_cfg import ImportExportModelAdmin
-
-from ..models import CustomUser
-from .filters import UserStatusFilter
-from .inlines import UserRegistrationSourceInline, UserActivityInline, UserEmailLogInline, UserSupportTicketsInline
-from .resources import CustomUserResource
-
-
-@admin.register(CustomUser)
-class CustomUserAdmin(BaseUserAdmin, ModelAdmin, ImportExportModelAdmin):
-    # Import/Export configuration
-    resource_class = CustomUserResource
-    
-    # Forms loaded from `unfold.forms`
-    form = UserChangeForm
-    add_form = UserCreationForm
-    change_password_form = AdminPasswordChangeForm
-
-    list_display = [
-        "avatar",
-        "email",
-        "full_name",
-        "status",
-        "sources_count",
-        "activity_count",
-        "emails_count",
-        "tickets_count",
-        "last_login_display",
-        "date_joined_display",
-    ]
-    list_display_links = ["avatar", "email", "full_name"]
-    search_fields = ["email", "first_name", "last_name"]
-    list_filter = [UserStatusFilter, "is_staff", "is_active", "date_joined"]
-    ordering = ["-date_joined"]
-    readonly_fields = ["date_joined", "last_login"]
-    def get_inlines(self, request, obj):
-        """Get inlines based on enabled apps."""
-        inlines = [UserRegistrationSourceInline, UserActivityInline]
-        
-        # Add email log inline if newsletter app is enabled
-        try:
-            from django_cfg.modules.base import BaseCfgModule
-            base_module = BaseCfgModule()
-            if base_module.is_newsletter_enabled():
-                inlines.append(UserEmailLogInline)
-            if base_module.is_support_enabled():
-                inlines.append(UserSupportTicketsInline)
-        except Exception:
-            pass
-            
-        return inlines
-    
-    # Static actions for Unfold - always show, but check inside methods
-    actions_detail = ["view_user_emails", "view_user_tickets"]
-
-    fieldsets = (
-        (
-            "Personal Information",
-            {
-                "fields": ("email", "first_name", "last_name", "avatar"),
-            },
-        ),
-        (
-            "Contact Information",
-            {
-                "fields": ("company", "phone", "position"),
-            },
-        ),
-        (
-            "Authentication",
-            {
-                "fields": ("password",),
-                "classes": ("collapse",),
-            },
-        ),
-        (
-            "Permissions & Status",
-            {
-                "fields": (
-                    ("is_active", "is_staff", "is_superuser"),
-                    ("groups",),
-                    ("user_permissions",),
-                ),
-            },
-        ),
-        (
-            "Important Dates",
-            {
-                "fields": ("last_login", "date_joined"),
-                "classes": ("collapse",),
-            },
-        ),
-    )
-
-    add_fieldsets = (
-        (
-            None,
-            {
-                "classes": ("wide",),
-                "fields": ("email", "password1", "password2"),
-            },
-        ),
-    )
-
-    def full_name(self, obj):
-        """Get user's full name."""
-        return obj.__class__.objects.get_full_name(obj) or "—"
-
-    full_name.short_description = "Full Name"
-
-    def status(self, obj):
-        """Enhanced status display with icons."""
-        if obj.is_superuser:
-            return format_html('<span style="color: #dc3545;">👑 Superuser</span>')
-        elif obj.is_staff:
-            return format_html('<span style="color: #fd7e14;">⚙️ Staff</span>')
-        elif obj.is_active:
-            return format_html('<span style="color: #198754;">✅ Active</span>')
-        else:
-            return format_html('<span style="color: #6c757d;">❌ Inactive</span>')
-
-    status.short_description = "Status"
-
-    def sources_count(self, obj):
-        """Show count of sources for user."""
-        count = obj.user_registration_sources.count()
-        if count == 0:
-            return "—"
-        return f"{count} source{'s' if count != 1 else ''}"
-
-    sources_count.short_description = "Sources"
-
-    def activity_count(self, obj):
-        """Show count of user activities."""
-        count = obj.activities.count()
-        if count == 0:
-            return "—"
-        return f"{count} activit{'ies' if count != 1 else 'y'}"
-
-    activity_count.short_description = "Activities"
-
-    def emails_count(self, obj):
-        """Show count of emails sent to user (if newsletter app is enabled)."""
-        try:
-            from django_cfg.modules.base import BaseCfgModule
-            base_module = BaseCfgModule()
-            
-            if not base_module.is_newsletter_enabled():
-                return "—"
-            
-            from django_cfg.apps.newsletter.models import EmailLog
-            count = EmailLog.objects.filter(user=obj).count()
-            if count == 0:
-                return "—"
-            return f"{count} email{'s' if count != 1 else ''}"
-        except (ImportError, Exception):
-            return "—"
-
-    emails_count.short_description = "Emails"
-
-    def tickets_count(self, obj):
-        """Show count of support tickets for user (if support app is enabled)."""
-        try:
-            from django_cfg.modules.base import BaseCfgModule
-            base_module = BaseCfgModule()
-            
-            if not base_module.is_support_enabled():
-                return "—"
-            
-            from django_cfg.apps.support.models import Ticket
-            count = Ticket.objects.filter(user=obj).count()
-            if count == 0:
-                return "—"
-            return f"{count} ticket{'s' if count != 1 else ''}"
-        except (ImportError, Exception):
-            return "—"
-
-    tickets_count.short_description = "Tickets"
-
-    def last_login_display(self, obj):
-        """Last login with natural time."""
-        if obj.last_login:
-            return naturaltime(obj.last_login)
-        return "Never"
-
-    last_login_display.short_description = "Last Login"
-
-    def date_joined_display(self, obj):
-        """Join date with natural day."""
-        return naturalday(obj.date_joined)
-
-    date_joined_display.short_description = "Joined"
-
-    def avatar(self, obj):
-        """Enhanced avatar display."""
-        if obj.avatar:
-            return format_html(
-                '<img src="{}" style="width: 32px; height: 32px; border-radius: 50%; object-fit: cover;" />',
-                obj.avatar.url,
-            )
-        else:
-            initials = obj.__class__.objects.get_initials(obj)
-            return format_html(
-                '<div style="width: 32px; height: 32px; border-radius: 50%; background: #6c757d; '
-                "color: white; display: flex; align-items: center; justify-content: center; "
-                'font-weight: bold; font-size: 12px;">{}</div>',
-                initials,
-            )
-
-    avatar.short_description = "Avatar"
-    
-    @action(
-        description="📧 View Email History",
-        icon="mail_outline",
-        variant=ActionVariant.INFO
-    )
-    def view_user_emails(self, request, object_id):
-        """View all emails sent to this user."""
-        try:
-            # Get the user object
-            user = self.get_object(request, object_id)
-            if not user:
-                self.message_user(request, "User not found.", level='error')
-                return redirect(request.META.get('HTTP_REFERER', '/admin/'))
-            
-            # Check if newsletter app is enabled
-            from django_cfg.modules.base import BaseCfgModule
-            base_module = BaseCfgModule()
-            
-            if not base_module.is_newsletter_enabled():
-                self.message_user(
-                    request, 
-                    "Newsletter app is not enabled.", 
-                    level='warning'
-                )
-                return redirect(request.META.get('HTTP_REFERER', '/admin/'))
-            
-            # Redirect to EmailLog changelist filtered by this user
-            url = reverse('admin:django_cfg_newsletter_emaillog_changelist')
-            return redirect(f"{url}?user__id__exact={user.id}")
-            
-        except Exception as e:
-            self.message_user(
-                request, 
-                f"Error accessing email history: {e}", 
-                level='error'
-            )
-            return redirect(request.META.get('HTTP_REFERER', '/admin/'))
-    
-    @action(
-        description="🎫 View Support Tickets",
-        icon="support_agent",
-        variant=ActionVariant.SUCCESS
-    )
-    def view_user_tickets(self, request, object_id):
-        """View all support tickets for this user."""
-        try:
-            # Get the user object
-            user = self.get_object(request, object_id)
-            if not user:
-                self.message_user(request, "User not found.", level='error')
-                return redirect(request.META.get('HTTP_REFERER', '/admin/'))
-            
-            # Check if support app is enabled
-            from django_cfg.modules.base import BaseCfgModule
-            base_module = BaseCfgModule()
-            
-            if not base_module.is_support_enabled():
-                self.message_user(
-                    request, 
-                    "Support app is not enabled.", 
-                    level='warning'
-                )
-                return redirect(request.META.get('HTTP_REFERER', '/admin/'))
-            
-            # Redirect to Ticket changelist filtered by this user
-            url = reverse('admin:django_cfg_support_ticket_changelist')
-            return redirect(f"{url}?user__id__exact={user.id}")
-            
-        except Exception as e:
-            self.message_user(
-                request, 
-                f"Error accessing support tickets: {e}", 
-                level='error'
-            )
-            return redirect(request.META.get('HTTP_REFERER', '/admin/'))

django_cfg/apps/agents/core/agent.py

@@ -1,281 +0,0 @@
-"""
-Django Agent - Wrapper around Pydantic AI Agent with Django integration.
-"""
-
-import time
-import logging
-from typing import TypeVar, Generic, Type, Any, Optional, Dict, Callable
-from dataclasses import dataclass
-
-from pydantic_ai import Agent
-from pydantic_ai.models import Model
-
-from .exceptions import ExecutionError, ConfigurationError
-from .models import ExecutionResult
-
-# Type variables for generic typing
-DepsT = TypeVar('DepsT')
-OutputT = TypeVar('OutputT')
-
-logger = logging.getLogger(__name__)
-
-
-class DjangoAgent(Generic[DepsT, OutputT]):
-    """
-    Django-integrated agent wrapper around Pydantic AI Agent.
-    
-    Provides Django-specific functionality like:
-    - Integration with django_llm module
-    - Caching support
-    - Metrics collection
-    - Error handling
-    - Type safety
-    """
-    
-    def __init__(
-        self,
-        name: str,
-        deps_type: Type[DepsT],
-        output_type: Type[OutputT],
-        instructions: str,
-        model: Optional[str] = None,
-        llm_client: Optional[Any] = None,
-        timeout: int = 300,
-        max_retries: int = 3,
-        enable_caching: bool = True
-    ):
-        """
-        Initialize Django Agent.
-        
-        Args:
-            name: Unique agent identifier
-            deps_type: Type for dependency injection (must be dataclass)
-            output_type: Pydantic model for output validation
-            instructions: System prompt for the agent
-            model: Override model (uses client default if None)
-            llm_client: Optional LLM client (uses default if None)
-            timeout: Execution timeout in seconds
-            max_retries: Maximum retry attempts
-            enable_caching: Whether to enable result caching
-        """
-        self.name = name
-        self.deps_type = deps_type
-        self.output_type = output_type
-        self.instructions = instructions
-        self.timeout = timeout
-        self.max_retries = max_retries
-        self.enable_caching = enable_caching
-        
-        # Get LLM client
-        self.llm_client = llm_client or self._get_default_llm_client()
-        
-        # Determine model to use
-        model_name = model or self._get_default_model()
-        
-        # Create Pydantic AI agent
-        self.agent = Agent[DepsT, OutputT](
-            model=model_name,
-            deps_type=deps_type,
-            output_type=output_type,
-            instructions=instructions,
-            retries=max_retries
-        )
-        
-        # Initialize metrics
-        self._execution_count = 0
-        self._total_execution_time = 0.0
-        self._error_count = 0
-        self._cache_hits = 0
-        
-        logger.info(f"Initialized DjangoAgent '{name}' with model '{model_name}'")
-    
-    async def run(self, prompt: str, deps: DepsT, **kwargs) -> ExecutionResult:
-        """
-        Run agent with Django-specific enhancements.
-        
-        Args:
-            prompt: User prompt/instruction
-            deps: Dependencies instance
-            **kwargs: Additional Pydantic AI parameters
-            
-        Returns:
-            ExecutionResult with output, usage, and metadata
-        """
-        start_time = time.time()
-        self._execution_count += 1
-        
-        # Check cache if enabled
-        if self.enable_caching:
-            cached_result = await self._check_cache(prompt, deps)
-            if cached_result:
-                self._cache_hits += 1
-                logger.debug(f"Cache hit for agent '{self.name}'")
-                return ExecutionResult(
-                    agent_name=self.name,
-                    output=cached_result,
-                    execution_time=0.0,
-                    cached=True
-                )
-        
-        try:
-            # Execute agent
-            logger.debug(f"Executing agent '{self.name}' with prompt: {prompt[:100]}...")
-            
-            result = await self.agent.run(prompt, deps=deps, **kwargs)
-            
-            execution_time = time.time() - start_time
-            self._total_execution_time += execution_time
-            
-            # Extract metrics
-            tokens_used = 0
-            cost = 0.0
-            if hasattr(result, 'usage') and result.usage:
-                tokens_used = getattr(result.usage, 'total_tokens', 0)
-                # Calculate cost based on model and tokens (implement based on your pricing)
-                cost = self._calculate_cost(tokens_used)
-            
-            execution_result = ExecutionResult(
-                agent_name=self.name,
-                output=result.output,
-                execution_time=execution_time,
-                tokens_used=tokens_used,
-                cost=cost
-            )
-            
-            # Cache result if enabled
-            if self.enable_caching:
-                await self._cache_result(prompt, deps, result.output)
-            
-            logger.info(
-                f"Agent '{self.name}' executed successfully in {execution_time:.2f}s "
-                f"(tokens: {tokens_used}, cost: ${cost:.4f})"
-            )
-            
-            return execution_result
-            
-        except Exception as e:
-            self._error_count += 1
-            execution_time = time.time() - start_time
-            
-            logger.error(f"Agent '{self.name}' execution failed: {e}")
-            
-            raise ExecutionError(
-                f"Agent '{self.name}' execution failed: {str(e)}",
-                agent_name=self.name,
-                original_error=e
-            )
-    
-    def tool(self, func: Callable) -> Callable:
-        """
-        Register tool with agent.
-        
-        Args:
-            func: Function to register as agent tool
-            
-        Returns:
-            Decorated function
-        """
-        return self.agent.tool(func)
-    
-    def get_metrics(self) -> Dict[str, Any]:
-        """Get agent execution metrics."""
-        return {
-            'name': self.name,
-            'execution_count': self._execution_count,
-            'total_execution_time': self._total_execution_time,
-            'average_execution_time': (
-                self._total_execution_time / self._execution_count 
-                if self._execution_count > 0 else 0
-            ),
-            'error_count': self._error_count,
-            'success_rate': (
-                (self._execution_count - self._error_count) / self._execution_count
-                if self._execution_count > 0 else 0
-            ),
-            'cache_hits': self._cache_hits,
-            'cache_hit_rate': (
-                self._cache_hits / self._execution_count
-                if self._execution_count > 0 else 0
-            )
-        }
-    
-    def reset_metrics(self):
-        """Reset agent metrics."""
-        self._execution_count = 0
-        self._total_execution_time = 0.0
-        self._error_count = 0
-        self._cache_hits = 0
-    
-    def _get_default_llm_client(self):
-        """Get default LLM client from django_llm module."""
-        try:
-            from django_cfg.modules.django_llm import DjangoLLM
-            llm_service = DjangoLLM()
-            if llm_service.is_configured:
-                return llm_service.client
-        except ImportError:
-            logger.warning("django_llm module not available, using default client")
-        
-        return None
-    
-    def _get_default_model(self) -> str:
-        """Get default model name."""
-        if self.llm_client and hasattr(self.llm_client, 'primary_provider'):
-            if self.llm_client.primary_provider == 'openrouter':
-                return 'openai:gpt-4o-mini'
-            elif self.llm_client.primary_provider == 'openai':
-                return 'openai:gpt-4o-mini'
-        
-        return 'openai:gpt-4o-mini'  # Default fallback
-    
-    async def _check_cache(self, prompt: str, deps: DepsT) -> Optional[Any]:
-        """Check cache for existing result."""
-        if not self.llm_client or not hasattr(self.llm_client, 'cache'):
-            return None
-        
-        try:
-            cache_key = self._generate_cache_key(prompt, deps)
-            return self.llm_client.cache.get(cache_key)
-        except Exception as e:
-            logger.warning(f"Cache check failed: {e}")
-            return None
-    
-    async def _cache_result(self, prompt: str, deps: DepsT, result: Any):
-        """Cache execution result."""
-        if not self.llm_client or not hasattr(self.llm_client, 'cache'):
-            return
-        
-        try:
-            cache_key = self._generate_cache_key(prompt, deps)
-            self.llm_client.cache.set(cache_key, result)
-        except Exception as e:
-            logger.warning(f"Cache storage failed: {e}")
-    
-    def _generate_cache_key(self, prompt: str, deps: DepsT) -> str:
-        """Generate cache key for prompt and dependencies."""
-        # Create a simple hash-based key
-        import hashlib
-        
-        # Include agent name, prompt, and relevant deps data
-        key_data = f"{self.name}:{prompt}"
-        
-        # Add user info if available
-        if hasattr(deps, 'user') and deps.user:
-            key_data += f":user_{deps.user.id}"
-        
-        # Add other relevant dependency data
-        if hasattr(deps, 'to_dict'):
-            deps_str = str(sorted(deps.to_dict().items()))
-            key_data += f":deps_{deps_str}"
-        
-        return hashlib.md5(key_data.encode()).hexdigest()
-    
-    def _calculate_cost(self, tokens_used: int) -> float:
-        """Calculate cost based on tokens used."""
-        # Implement based on your pricing model
-        # This is a simple example
-        cost_per_1k_tokens = 0.002  # Example: $0.002 per 1K tokens
-        return (tokens_used / 1000) * cost_per_1k_tokens
-    
-    def __repr__(self) -> str:
-        return f"DjangoAgent(name='{self.name}', deps_type={self.deps_type.__name__}, output_type={self.output_type.__name__})"