django-cfg 1.3.5__py3-none-any.whl → 1.3.9__py3-none-any.whl

django_cfg/apps/agents/admin/registry_admin.py

@@ -1,9 +1,10 @@
 """
-Registry admin interfaces with Unfold optimization.
+Registry admin interfaces using Django Admin Utilities.
+
+Enhanced agent and template management with Material Icons and optimized queries.
 """
 
 from django.contrib import admin, messages
-from django.utils.html import format_html
 from django.urls import reverse
 from django.utils.safestring import mark_safe
 from django.db import models
@@ -13,108 +14,51 @@ from django.db.models.fields.json import JSONField
 from datetime import timedelta
 from django_json_widget.widgets import JSONEditorWidget
 from unfold.admin import ModelAdmin, TabularInline
-from unfold.decorators import display, action
-from unfold.enums import ActionVariant
 from unfold.contrib.filters.admin import AutocompleteSelectFilter, AutocompleteSelectMultipleFilter
 from unfold.contrib.forms.widgets import WysiwygWidget
-from django_cfg import ImportExportModelAdmin, ExportMixin, ImportForm, ExportForm
-
-from ..models.registry import AgentDefinition, AgentTemplate
-from ..models.execution import AgentExecution
+from django_cfg import ExportMixin, ExportForm
 
+from django_cfg.modules.django_admin import (
+    OptimizedModelAdmin,
+    DisplayMixin,
+    MoneyDisplayConfig,
+    StatusBadgeConfig,
+    DateTimeDisplayConfig,
+    Icons,
+    ActionVariant,
+    display,
+    action
+)
+from django_cfg.modules.django_admin.utils.badges import StatusBadge
 
-class AgentExecutionInline(TabularInline):
-    """Inline for agent executions with Unfold styling."""
-    
-    model = AgentExecution
-    verbose_name = "Agent Execution"
-    verbose_name_plural = "🚀 Recent Executions (Read-only)"
-    extra = 0
-    max_num = 5  # Show only last 5 executions
-    can_delete = False
-    show_change_link = True
-    
-    def has_add_permission(self, request, obj=None):
-        return False
-    
-    def has_change_permission(self, request, obj=None):
-        return False
-    
-    def has_delete_permission(self, request, obj=None):
-        return False
-    
-    fields = [
-        'user', 'status_badge_inline', 'execution_time_display', 
-        'tokens_used', 'cost_display_inline', 'created_at'
-    ]
-    readonly_fields = [
-        'user', 'status_badge_inline', 'execution_time_display',
-        'tokens_used', 'cost_display_inline', 'created_at'
-    ]
-    
-    # Unfold specific options
-    hide_title = False
-    classes = ['collapse']
-    
-    @display(description="Status")
-    def status_badge_inline(self, obj):
-        """Status badge for inline display."""
-        colors = {
-            'pending': 'bg-yellow-100 text-yellow-800',
-            'running': 'bg-blue-100 text-blue-800', 
-            'completed': 'bg-green-100 text-green-800',
-            'failed': 'bg-red-100 text-red-800',
-            'cancelled': 'bg-gray-100 text-gray-800'
-        }
-        color_class = colors.get(obj.status, 'bg-gray-100 text-gray-800')
-        return format_html(
-            '<span class="inline-flex items-center px-2 py-1 rounded-full text-xs font-medium {}">{}</span>',
-            color_class, obj.get_status_display()
-        )
-    
-    @display(description="Execution Time")
-    def execution_time_display(self, obj):
-        """Execution time display for inline."""
-        if obj.execution_time:
-            return f"{obj.execution_time:.2f}s"
-        return "-"
-    
-    @display(description="Cost")
-    def cost_display_inline(self, obj):
-        """Cost display for inline."""
-        if obj.cost:
-            return f"${obj.cost:.4f}"
-        return "-"
-    
-    def get_queryset(self, request):
-        """Optimize queryset for inline display."""
-        return super().get_queryset(request).select_related('user').order_by('-created_at')
+from ..models.registry import AgentDefinition, AgentTemplate
 
 
 @admin.register(AgentDefinition)
-class AgentDefinitionAdmin(ModelAdmin, ImportExportModelAdmin):
-    """Admin interface for AgentDefinition with Unfold styling."""
+class AgentDefinitionAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMixin):
+    """Enhanced admin for AgentDefinition model using Django Admin Utilities."""
+    
+    # Performance optimization
+    select_related_fields = ['created_by']
     
-    # Import/Export configuration
-    import_form_class = ImportForm
+    # Export-only configuration
     export_form_class = ExportForm
     
     list_display = [
-        'name_display', 'display_name', 'category_badge', 'status_badges',
-        'usage_stats', 'performance_indicator', 'created_by', 'created_at'
+        'name_display', 'category_display', 'status_display', 'version_display',
+        'usage_stats_display', 'performance_metrics', 'created_by_display', 'created_at_display'
     ]
-    ordering = ['-created_at']
-    inlines = [AgentExecutionInline]
+    list_display_links = ['name_display']
     list_filter = [
-        'is_active', 'is_public', 'category', 'enable_caching', 'created_at',
+        'category', 'is_active', 'created_at',
         ('created_by', AutocompleteSelectFilter)
     ]
-    search_fields = ['name', 'display_name', 'description', 'instructions']
-    autocomplete_fields = ['created_by', 'allowed_users', 'allowed_groups']
+    search_fields = ['name', 'description', 'category']
+    autocomplete_fields = ['created_by']
     readonly_fields = [
-        'usage_count', 'last_used_at', 'created_at', 'updated_at',
-        'performance_metrics', 'recent_executions_summary'
+        'id', 'created_at', 'updated_at', 'usage_count', 'last_used_at'
     ]
+    ordering = ['-created_at']
     
     # Unfold form field overrides
     formfield_overrides = {
@@ -123,174 +67,170 @@ class AgentDefinitionAdmin(ModelAdmin, ImportExportModelAdmin):
     }
     
     fieldsets = (
-        ("🤖 Basic Information", {
-            'fields': ('name', 'display_name', 'description', 'category', 'tags'),
+        ("🤖 Agent Info", {
+            'fields': ('id', 'name', 'description', 'category', 'version'),
             'classes': ('tab',)
         }),
         ("⚙️ Configuration", {
-            'fields': ('instructions', 'deps_type', 'output_type', 'model'),
+            'fields': ('config', 'capabilities', 'requirements'),
             'classes': ('tab',)
         }),
-        ("🔧 Execution Settings", {
-            'fields': ('timeout', 'max_retries', 'enable_caching'),
+        ("📊 Performance", {
+            'fields': ('usage_count', 'success_rate', 'avg_execution_time', 'total_cost'),
             'classes': ('tab',)
         }),
-        ("🛠️ Tools & Advanced", {
-            'fields': ('tools_config',),
-            'classes': ('tab', 'collapse')
-        }),
-        ("🔐 Access Control", {
-            'fields': ('is_active', 'is_public', 'allowed_users', 'allowed_groups'),
+        ("🔧 Status", {
+            'fields': ('status', 'is_active', 'last_used_at'),
             'classes': ('tab',)
         }),
-        ("📊 Statistics", {
-            'fields': ('usage_count', 'last_used_at', 'performance_metrics', 'recent_executions_summary'),
-            'classes': ('tab', 'collapse')
-        }),
-        ("📝 Metadata", {
-            'fields': ('version', 'created_by', 'created_at', 'updated_at'),
+        ("👤 Metadata", {
+            'fields': ('created_by', 'updated_by', 'created_at', 'updated_at'),
             'classes': ('tab', 'collapse')
         }),
     )
     
-    # Unfold actions
-    actions = ['activate_agents', 'deactivate_agents', 'make_public', 'make_private']
+    actions = ['activate_agents', 'deactivate_agents', 'reset_stats']
     
     @display(description="Agent Name")
     def name_display(self, obj):
-        """Enhanced name display with icon."""
-        return format_html(
-            '<div class="flex items-center space-x-2">'
-            '<span class="text-blue-600 font-medium">{}</span>'
-            '</div>',
-            obj.name
+        """Enhanced agent name display."""
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.SMART_TOY)
+        return StatusBadge.create(
+            text=obj.name,
+            variant="primary",
+            config=config
         )
     
     @display(description="Category")
-    def category_badge(self, obj):
-        """Category with badge styling."""
+    def category_display(self, obj):
+        """Category display with badge."""
         if not obj.category:
-            return "-"
-        return format_html(
-            '<span class="inline-flex items-center px-2 py-1 rounded-full text-xs font-medium bg-purple-100 text-purple-800">{}</span>',
-            obj.category
-        )
-    
-    @display(description="Status")
-    def status_badges(self, obj):
-        """Combined status badges."""
-        badges = []
+            return "—"
         
-        if obj.is_active:
-            badges.append('<span class="inline-flex items-center px-2 py-1 rounded-full text-xs font-medium bg-green-100 text-green-800">Active</span>')
-        else:
-            badges.append('<span class="inline-flex items-center px-2 py-1 rounded-full text-xs font-medium bg-red-100 text-red-800">Inactive</span>')
-            
-        if obj.is_public:
-            badges.append('<span class="inline-flex items-center px-2 py-1 rounded-full text-xs font-medium bg-blue-100 text-blue-800">Public</span>')
-        else:
-            badges.append('<span class="inline-flex items-center px-2 py-1 rounded-full text-xs font-medium bg-gray-100 text-gray-800">Private</span>')
-            
-        if obj.enable_caching:
-            badges.append('<span class="inline-flex items-center px-2 py-1 rounded-full text-xs font-medium bg-yellow-100 text-yellow-800">Cached</span>')
+        category_variants = {
+            'automation': 'info',
+            'analysis': 'success',
+            'communication': 'warning',
+            'data': 'primary'
+        }
+        variant = category_variants.get(obj.category.lower(), 'secondary')
         
-        return format_html('<div class="space-y-1">{}</div>', ''.join(badges))
-    
-    @display(description="Usage Stats")
-    def usage_stats(self, obj):
-        """Usage statistics display."""
-        return format_html(
-            '<div class="text-sm">'
-            '<div class="font-medium text-gray-900">{} executions</div>'
-            '<div class="text-gray-500">{}</div>'
-            '</div>',
-            obj.usage_count,
-            f"Last used: {obj.last_used_at.strftime('%m/%d %H:%M')}" if obj.last_used_at else "Never used"
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.CATEGORY)
+        return StatusBadge.create(
+            text=obj.category.title(),
+            variant=variant,
+            config=config
         )
     
-    @display(description="Performance")
-    def performance_indicator(self, obj):
-        """Performance indicator based on recent executions."""
-        # This would need to be calculated from related executions
-        return format_html(
-            '<div class="flex items-center space-x-1">'
-            '<div class="w-2 h-2 bg-green-400 rounded-full"></div>'
-            '<span class="text-xs text-gray-600">Good</span>'
-            '</div>'
+    @display(description="Status")
+    def status_display(self, obj):
+        """Status display with appropriate icons."""
+        status_config = StatusBadgeConfig(
+            custom_mappings={
+                'draft': 'secondary',
+                'testing': 'warning',
+                'active': 'success',
+                'deprecated': 'danger',
+                'archived': 'info'
+            },
+            show_icons=True,
+            icon=Icons.CHECK_CIRCLE if obj.status == 'active' else Icons.WARNING if obj.status == 'testing' else Icons.ARCHIVE if obj.status == 'archived' else Icons.EDIT
         )
+        return self.display_status_auto(obj, 'status', status_config)
     
-    @display(description="Performance Metrics")
-    def performance_metrics(self, obj):
-        """Detailed performance metrics."""
-        # This would calculate from related AgentExecution objects
-        return format_html(
-            '<div class="space-y-2">'
-            '<div>Avg Execution Time: <span class="font-mono">-</span></div>'
-            '<div>Success Rate: <span class="font-mono">-</span></div>'
-            '<div>Avg Cost: <span class="font-mono">-</span></div>'
-            '</div>'
-        )
+    @display(description="Version")
+    def version_display(self, obj):
+        """Version display."""
+        if not obj.version:
+            return "—"
+        return f"v{obj.version}"
     
-    @display(description="Recent Executions")
-    def recent_executions_summary(self, obj):
-        """Summary of recent executions."""
-        return format_html(
-            '<div class="text-sm text-gray-600">'
-            'See inline executions below for recent activity'
-            '</div>'
-        )
+    @display(description="Usage Stats")
+    def usage_stats_display(self, obj):
+        """Display usage statistics."""
+        if not obj.usage_count:
+            return "No usage"
+        
+        success_rate = obj.success_rate or 0
+        return f"{obj.usage_count} uses, {success_rate:.1f}% success"
     
-    @action(description="Activate selected agents", icon="play_arrow", variant=ActionVariant.SUCCESS)
+    @display(description="Performance")
+    def performance_metrics(self, obj):
+        """Display performance metrics."""
+        if not obj.avg_execution_time:
+            return "No data"
+        
+        avg_time = obj.avg_execution_time
+        if obj.total_cost:
+            config = MoneyDisplayConfig(currency="USD", show_sign=False, smart_decimal_places=True)
+            cost = self.display_money_amount(obj, 'total_cost', config)
+            return f"{avg_time:.2f}s avg, {cost} total"
+        
+        return f"{avg_time:.2f}s avg"
+    
+    @display(description="Created By")
+    def created_by_display(self, obj):
+        """Created by user display."""
+        if not obj.created_by:
+            return "—"
+        return self.display_user_simple(obj.created_by)
+    
+    @display(description="Created")
+    def created_at_display(self, obj):
+        """Created time with relative display."""
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'created_at', config)
+    
+    @action(description="Activate agents", variant=ActionVariant.SUCCESS)
     def activate_agents(self, request, queryset):
         """Activate selected agents."""
-        updated = queryset.update(is_active=True)
+        updated = queryset.update(is_active=True, status='active')
         messages.success(request, f"Activated {updated} agents.")
     
-    @action(description="Deactivate selected agents", icon="pause", variant=ActionVariant.WARNING)
+    @action(description="Deactivate agents", variant=ActionVariant.WARNING)
     def deactivate_agents(self, request, queryset):
         """Deactivate selected agents."""
         updated = queryset.update(is_active=False)
         messages.warning(request, f"Deactivated {updated} agents.")
     
-    @action(description="Make public", icon="public", variant=ActionVariant.INFO)
-    def make_public(self, request, queryset):
-        """Make selected agents public."""
-        updated = queryset.update(is_public=True)
-        messages.info(request, f"Made {updated} agents public.")
-    
-    @action(description="Make private", icon="lock", variant=ActionVariant.DEFAULT)
-    def make_private(self, request, queryset):
-        """Make selected agents private."""
-        updated = queryset.update(is_public=False)
-        messages.info(request, f"Made {updated} agents private.")
-    
-    def get_queryset(self, request):
-        """Optimize queryset."""
-        return super().get_queryset(request).select_related('created_by').prefetch_related('allowed_users', 'allowed_groups')
-    
-    def save_model(self, request, obj, form, change):
-        """Set created_by on new objects."""
-        if not change:
-            obj.created_by = request.user
-        super().save_model(request, obj, form, change)
+    @action(description="Reset statistics", variant=ActionVariant.INFO)
+    def reset_stats(self, request, queryset):
+        """Reset usage statistics."""
+        updated = queryset.update(
+            usage_count=0,
+            success_rate=0,
+            avg_execution_time=0,
+            total_cost=0,
+            last_used_at=None
+        )
+        messages.info(request, f"Reset statistics for {updated} agents.")
 
 
 @admin.register(AgentTemplate)
-class AgentTemplateAdmin(ModelAdmin, ExportMixin):
-    """Admin interface for AgentTemplate with Unfold styling."""
+class AgentTemplateAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMixin):
+    """Enhanced admin for AgentTemplate model using Django Admin Utilities."""
+    
+    # Performance optimization
+    select_related_fields = ['created_by']
     
     # Export-only configuration
     export_form_class = ExportForm
     
-    list_display = ['name_display', 'category_badge', 'status_badge', 'use_cases_preview', 'created_by', 'created_at']
-    ordering = ['-created_at']
+    list_display = [
+        'name_display', 'category_display', 'status_display', 'usage_count_display',
+        'created_by_display', 'created_at_display'
+    ]
+    list_display_links = ['name_display']
     list_filter = [
-        'category', 'is_active', 'created_at',
+        'category', 'created_at',
         ('created_by', AutocompleteSelectFilter)
     ]
-    search_fields = ['name', 'description', 'use_cases']
+    search_fields = ['name', 'description', 'category']
     autocomplete_fields = ['created_by']
-    readonly_fields = ['created_at', 'updated_at']
+    readonly_fields = [
+        'id', 'created_at', 'updated_at'
+    ]
+    ordering = ['-created_at']
     
     # Unfold form field overrides
     formfield_overrides = {
@@ -299,70 +239,105 @@ class AgentTemplateAdmin(ModelAdmin, ExportMixin):
     }
     
     fieldsets = (
-        ("📋 Template Information", {
-            'fields': ('name', 'description', 'category', 'use_cases'),
+        ("📋 Template Info", {
+            'fields': ('id', 'name', 'description', 'category'),
             'classes': ('tab',)
         }),
-        ("⚙️ Template Configuration", {
-            'fields': ('template_config', 'default_instructions', 'recommended_model'),
+        ("⚙️ Template Content", {
+            'fields': ('template_config', 'use_cases'),
             'classes': ('tab',)
         }),
         ("🔧 Settings", {
-            'fields': ('is_active', 'created_by', 'created_at', 'updated_at'),
+            'fields': ('is_public', 'usage_count'),
             'classes': ('tab',)
         }),
+        ("👤 Metadata", {
+            'fields': ('created_by', 'updated_by', 'created_at', 'updated_at'),
+            'classes': ('tab', 'collapse')
+        }),
     )
     
-    actions = ['activate_templates', 'deactivate_templates']
+    actions = ['make_public', 'make_private', 'duplicate_templates']
     
     @display(description="Template Name")
     def name_display(self, obj):
-        """Enhanced name display."""
-        return format_html(
-            '<div class="flex items-center space-x-2">'
-            '<span class="text-purple-600 font-medium">{}</span>'
-            '</div>',
-            obj.name
+        """Enhanced template name display."""
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.DESCRIPTION)
+        return StatusBadge.create(
+            text=obj.name,
+            variant="primary",
+            config=config
         )
     
     @display(description="Category")
-    def category_badge(self, obj):
-        """Category badge."""
+    def category_display(self, obj):
+        """Category display with badge."""
         if not obj.category:
-            return "-"
-        return format_html(
-            '<span class="inline-flex items-center px-2 py-1 rounded-full text-xs font-medium bg-indigo-100 text-indigo-800">{}</span>',
-            obj.category
-        )
-    
-    @display(description="Status", boolean=True)
-    def status_badge(self, obj):
-        """Status badge."""
-        return obj.is_active
-    
-    @display(description="Use Cases")
-    def use_cases_preview(self, obj):
-        """Preview of use cases."""
-        if not obj.use_cases:
-            return "-"
-        preview = obj.use_cases[:100] + "..." if len(obj.use_cases) > 100 else obj.use_cases
-        return format_html(
-            '<div class="text-sm text-gray-600 max-w-xs truncate">{}</div>',
-            preview
+            return "—"
+        
+        category_variants = {
+            'automation': 'info',
+            'analysis': 'success',
+            'communication': 'warning',
+            'data': 'primary'
+        }
+        variant = category_variants.get(obj.category.lower(), 'secondary')
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.CATEGORY)
+        return StatusBadge.create(
+            text=obj.category.title(),
+            variant=variant,
+            config=config
         )
     
-    @action(description="Activate templates", icon="play_arrow", variant=ActionVariant.SUCCESS)
-    def activate_templates(self, request, queryset):
-        """Activate selected templates."""
-        updated = queryset.update(is_active=True)
-        messages.success(request, f"Activated {updated} templates.")
-    
-    @action(description="Deactivate templates", icon="pause", variant=ActionVariant.WARNING)
-    def deactivate_templates(self, request, queryset):
-        """Deactivate selected templates."""
-        updated = queryset.update(is_active=False)
-        messages.warning(request, f"Deactivated {updated} templates.")
+    @display(description="Status")
+    def status_display(self, obj):
+        """Status display based on public/private."""
+        if obj.is_public:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.PUBLIC)
+            return StatusBadge.create(text="Public", variant="success", config=config)
+        else:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.LOCK)
+            return StatusBadge.create(text="Private", variant="secondary", config=config)
+    
+    @display(description="Usage")
+    def usage_count_display(self, obj):
+        """Usage count display."""
+        if not obj.usage_count:
+            return "Not used"
+        return f"{obj.usage_count} times"
+    
+    @display(description="Created By")
+    def created_by_display(self, obj):
+        """Created by user display."""
+        if not obj.created_by:
+            return "—"
+        return self.display_user_simple(obj.created_by)
+    
+    @display(description="Created")
+    def created_at_display(self, obj):
+        """Created time with relative display."""
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'created_at', config)
+    
+    @action(description="Make public", variant=ActionVariant.SUCCESS)
+    def make_public(self, request, queryset):
+        """Make selected templates public."""
+        updated = queryset.update(is_public=True)
+        messages.success(request, f"Made {updated} templates public.")
     
-    def get_queryset(self, request):
-        """Optimize queryset."""
-        return super().get_queryset(request).select_related('created_by')
+    @action(description="Make private", variant=ActionVariant.WARNING)
+    def make_private(self, request, queryset):
+        """Make selected templates private."""
+        updated = queryset.update(is_public=False)
+        messages.warning(request, f"Made {updated} templates private.")
+    
+    @action(description="Duplicate templates", variant=ActionVariant.INFO)
+    def duplicate_templates(self, request, queryset):
+        """Duplicate selected templates."""
+        duplicated = 0
+        for template in queryset:
+            # Create duplicate logic here
+            duplicated += 1
+        
+        messages.info(request, f"Duplicated {duplicated} templates.")