django-cfg 1.4.21__py3-none-any.whl → 1.4.24__py3-none-any.whl

django_cfg/apps/knowbase/admin/external_data_admin.py

@@ -5,39 +5,37 @@ Enhanced external data management with Material Icons and optimized queries.
 """
 
 from django.contrib import admin, messages
-from django.urls import reverse
-from django.utils.http import urlencode
-from django.shortcuts import redirect
 from django.db import models
-from django.db.models import Count, Sum, Avg, Q
+from django.db.models import Count, Q, Sum
 from django.db.models.fields.json import JSONField
-from django.utils import timezone
-from django import forms
 from django_json_widget.widgets import JSONEditorWidget
 from unfold.admin import ModelAdmin, TabularInline
-from unfold.contrib.filters.admin import AutocompleteSelectFilter, AutocompleteSelectMultipleFilter
+from unfold.contrib.filters.admin import AutocompleteSelectFilter
 from unfold.contrib.forms.widgets import WysiwygWidget
-from django_cfg import ExportMixin
 
+from django_cfg import ExportMixin
 from django_cfg.modules.django_admin import (
-    OptimizedModelAdmin,
+    ActionVariant,
+    DateTimeDisplayConfig,
     DisplayMixin,
+    Icons,
     MoneyDisplayConfig,
+    OptimizedModelAdmin,
     StatusBadgeConfig,
-    DateTimeDisplayConfig,
-    Icons,
-    ActionVariant,
+    action,
     display,
-    action
 )
 from django_cfg.modules.django_admin.utils.badges import StatusBadge
 
-from ..models.external_data import ExternalData, ExternalDataChunk, ExternalDataType, ExternalDataStatus
+from ..models.external_data import (
+    ExternalData,
+    ExternalDataChunk,
+)
 
 
 class ExternalDataChunkInline(TabularInline):
     """Inline for external data chunks with Unfold styling."""
-    
+
     model = ExternalDataChunk
     verbose_name = "External Data Chunk"
     verbose_name_plural = "🔗 External Data Chunks (Read-only)"
@@ -45,40 +43,40 @@ class ExternalDataChunkInline(TabularInline):
     max_num = 0
     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 = [
-        'short_uuid', 'chunk_index', 'content_preview_inline', 'token_count', 
+        'short_uuid', 'chunk_index', 'content_preview_inline', 'token_count',
         'has_embedding_inline', 'embedding_cost'
     ]
     readonly_fields = [
         'short_uuid', 'chunk_index', 'content_preview_inline', 'token_count', 'character_count',
         'has_embedding_inline', 'embedding_cost', 'created_at'
     ]
-    
+
     hide_title = False
     classes = ['collapse']
-    
+
     @display(description="Content Preview")
     def content_preview_inline(self, obj):
         """Shortened content preview for inline display."""
         if not obj.content:
             return "—"
         return obj.content[:100] + "..." if len(obj.content) > 100 else obj.content
-    
+
     @display(description="Has Embedding", boolean=True)
     def has_embedding_inline(self, obj):
         """Check if chunk has embedding vector for inline."""
         return obj.embedding is not None and len(obj.embedding) > 0
-    
+
     def get_queryset(self, request):
         """Optimize queryset for inline display."""
         return super().get_queryset(request).select_related('external_data', 'user')
@@ -87,10 +85,10 @@ class ExternalDataChunkInline(TabularInline):
 @admin.register(ExternalData)
 class ExternalDataAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMixin):
     """Admin interface for ExternalData model using Django Admin Utilities."""
-    
+
     # Performance optimization
     select_related_fields = ['user', 'category']
-    
+
     list_display = [
         'title_display', 'source_type_display', 'source_identifier_display', 'user_display',
         'status_display', 'chunks_count_display', 'tokens_display', 'cost_display',
@@ -113,7 +111,7 @@ class ExternalDataAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMix
         'total_chunks', 'total_tokens', 'processing_cost',
         'created_at', 'updated_at'
     ]
-    
+
     fieldsets = (
         ('🔗 External Data Info', {
             'fields': ('id', 'title', 'description', 'user', 'category'),
@@ -140,39 +138,39 @@ class ExternalDataAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMix
             'classes': ('tab', 'collapse')
         })
     )
-    
+
     # Unfold configuration
     compressed_fields = True
     warn_unsaved_form = True
-    
+
     # Form field overrides
     formfield_overrides = {
         models.TextField: {"widget": WysiwygWidget},
         JSONField: {"widget": JSONEditorWidget}
     }
-    
+
     actions = ['reprocess_data', 'activate_data', 'deactivate_data', 'mark_as_public', 'mark_as_private']
-    
+
     @display(description="Title", ordering="title")
     def title_display(self, obj):
         """Display external data title."""
         title = obj.title or "Untitled External Data"
         if len(title) > 50:
             title = title[:47] + "..."
-        
+
         config = StatusBadgeConfig(show_icons=True, icon=Icons.CLOUD)
         return StatusBadge.create(
             text=title,
             variant="primary",
             config=config
         )
-    
+
     @display(description="Source Type")
     def source_type_display(self, obj):
         """Display source type with badge."""
         if not obj.source_type:
             return "—"
-        
+
         type_variants = {
             'api': 'info',
             'webhook': 'success',
@@ -180,7 +178,7 @@ class ExternalDataAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMix
             'file': 'secondary'
         }
         variant = type_variants.get(obj.source_type.lower(), 'secondary')
-        
+
         type_icons = {
             'api': Icons.API,
             'webhook': Icons.WEBHOOK,
@@ -188,33 +186,33 @@ class ExternalDataAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMix
             'file': Icons.INSERT_DRIVE_FILE
         }
         icon = type_icons.get(obj.source_type.lower(), Icons.CLOUD)
-        
+
         config = StatusBadgeConfig(show_icons=True, icon=icon)
         return StatusBadge.create(
             text=obj.source_type.upper(),
             variant=variant,
             config=config
         )
-    
+
     @display(description="Source ID", ordering="source_identifier")
     def source_identifier_display(self, obj):
         """Display source identifier with truncation."""
         if not obj.source_identifier:
             return "—"
-        
+
         identifier = obj.source_identifier
         if len(identifier) > 30:
             identifier = identifier[:27] + "..."
-        
+
         return identifier
-    
+
     @display(description="User")
     def user_display(self, obj):
         """User display."""
         if not obj.user:
             return "—"
         return self.display_user_simple(obj.user)
-    
+
     @display(description="Status")
     def status_display(self, obj):
         """Display processing status."""
@@ -230,13 +228,13 @@ class ExternalDataAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMix
             icon=Icons.CHECK_CIRCLE if obj.status == 'completed' else Icons.ERROR if obj.status == 'failed' else Icons.SCHEDULE
         )
         return self.display_status_auto(obj, 'status', status_config)
-    
+
     @display(description="Chunks", ordering="chunks_count")
     def chunks_count_display(self, obj):
         """Display chunks count."""
         count = obj.chunks_count or 0
         return f"{count} chunks"
-    
+
     @display(description="Tokens", ordering="total_tokens")
     def tokens_display(self, obj):
         """Display token count with formatting."""
@@ -244,7 +242,7 @@ class ExternalDataAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMix
         if tokens > 1000:
             return f"{tokens/1000:.1f}K"
         return str(tokens)
-    
+
     @display(description="Cost (USD)", ordering="processing_cost")
     def cost_display(self, obj):
         """Display cost with currency formatting."""
@@ -254,7 +252,7 @@ class ExternalDataAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMix
             show_sign=False
         )
         return self.display_money_amount(obj, 'processing_cost', config)
-    
+
     @display(description="Visibility")
     def visibility_display(self, obj):
         """Display visibility status."""
@@ -264,7 +262,7 @@ class ExternalDataAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMix
         else:
             config = StatusBadgeConfig(show_icons=True, icon=Icons.LOCK)
             return StatusBadge.create(text="Private", variant="danger", config=config)
-    
+
     @display(description="Processed", ordering="processed_at")
     def processed_at_display(self, obj):
         """Processed time with relative display."""
@@ -272,47 +270,47 @@ class ExternalDataAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMix
             return "—"
         config = DateTimeDisplayConfig(show_relative=True)
         return self.display_datetime_relative(obj, 'processed_at', config)
-    
+
     @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="Reprocess data", variant=ActionVariant.INFO)
     def reprocess_data(self, request, queryset):
         """Reprocess selected external data."""
         count = queryset.count()
         messages.info(request, f"Reprocess functionality not implemented yet. {count} items selected.")
-    
+
     @action(description="Activate data", variant=ActionVariant.SUCCESS)
     def activate_data(self, request, queryset):
         """Activate selected external data."""
         updated = queryset.update(is_active=True)
         messages.success(request, f"Activated {updated} external data items.")
-    
+
     @action(description="Deactivate data", variant=ActionVariant.WARNING)
     def deactivate_data(self, request, queryset):
         """Deactivate selected external data."""
         updated = queryset.update(is_active=False)
         messages.warning(request, f"Deactivated {updated} external data items.")
-    
+
     @action(description="Mark as public", variant=ActionVariant.SUCCESS)
     def mark_as_public(self, request, queryset):
         """Mark selected data as public."""
         updated = queryset.update(is_public=True)
         messages.success(request, f"Marked {updated} items as public.")
-    
+
     @action(description="Mark as private", variant=ActionVariant.WARNING)
     def mark_as_private(self, request, queryset):
         """Mark selected data as private."""
         updated = queryset.update(is_public=False)
         messages.warning(request, f"Marked {updated} items as private.")
-    
+
     def changelist_view(self, request, extra_context=None):
         """Add external data statistics to changelist."""
         extra_context = extra_context or {}
-        
+
         queryset = self.get_queryset(request)
         stats = queryset.aggregate(
             total_items=Count('id'),
@@ -322,14 +320,14 @@ class ExternalDataAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMix
             total_tokens=Sum('total_tokens'),
             total_cost=Sum('processing_cost')
         )
-        
+
         # Source type breakdown
         source_type_counts = dict(
             queryset.values_list('source_type').annotate(
                 count=Count('id')
             )
         )
-        
+
         extra_context['external_data_stats'] = {
             'total_items': stats['total_items'] or 0,
             'active_items': stats['active_items'] or 0,
@@ -339,17 +337,17 @@ class ExternalDataAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMix
             'total_cost': f"${(stats['total_cost'] or 0):.6f}",
             'source_type_counts': source_type_counts
         }
-        
+
         return super().changelist_view(request, extra_context)
 
 
 @admin.register(ExternalDataChunk)
 class ExternalDataChunkAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMixin):
     """Admin interface for ExternalDataChunk model using Django Admin Utilities."""
-    
+
     # Performance optimization
     select_related_fields = ['external_data', 'user']
-    
+
     list_display = [
         'chunk_display', 'external_data_display', 'user_display', 'token_count_display',
         'embedding_status', 'embedding_cost_display', 'created_at_display'
@@ -367,7 +365,7 @@ class ExternalDataChunkAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, Expo
         'id', 'token_count', 'character_count', 'embedding_cost',
         'created_at', 'updated_at', 'content_preview'
     ]
-    
+
     fieldsets = (
         ('🔗 Chunk Info', {
             'fields': ('id', 'external_data', 'user', 'chunk_index'),
@@ -390,9 +388,9 @@ class ExternalDataChunkAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, Expo
             'classes': ('tab', 'collapse')
         })
     )
-    
+
     actions = ['regenerate_embeddings', 'clear_embeddings']
-    
+
     @display(description="Chunk", ordering="chunk_index")
     def chunk_display(self, obj):
         """Display chunk identifier."""
@@ -402,19 +400,19 @@ class ExternalDataChunkAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, Expo
             variant="info",
             config=config
         )
-    
+
     @display(description="External Data", ordering="external_data__title")
     def external_data_display(self, obj):
         """Display external data title."""
         return obj.external_data.title or "Untitled External Data"
-    
+
     @display(description="User")
     def user_display(self, obj):
         """User display."""
         if not obj.user:
             return "—"
         return self.display_user_simple(obj.user)
-    
+
     @display(description="Tokens", ordering="token_count")
     def token_count_display(self, obj):
         """Display token count with formatting."""
@@ -422,7 +420,7 @@ class ExternalDataChunkAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, Expo
         if tokens > 1000:
             return f"{tokens/1000:.1f}K"
         return str(tokens)
-    
+
     @display(description="Embedding")
     def embedding_status(self, obj):
         """Display embedding status."""
@@ -433,7 +431,7 @@ class ExternalDataChunkAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, Expo
         else:
             config = StatusBadgeConfig(show_icons=True, icon=Icons.ERROR)
             return StatusBadge.create(text="✗ Not vectorized", variant="danger", config=config)
-    
+
     @display(description="Cost (USD)", ordering="embedding_cost")
     def embedding_cost_display(self, obj):
         """Display embedding cost with currency formatting."""
@@ -443,24 +441,24 @@ class ExternalDataChunkAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, Expo
             show_sign=False
         )
         return self.display_money_amount(obj, 'embedding_cost', config)
-    
+
     @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)
-    
+
     @display(description="Content Preview")
     def content_preview(self, obj):
         """Display content preview with truncation."""
         return obj.content[:200] + "..." if len(obj.content) > 200 else obj.content
-    
+
     @action(description="Regenerate embeddings", variant=ActionVariant.INFO)
     def regenerate_embeddings(self, request, queryset):
         """Regenerate embeddings for selected chunks."""
         count = queryset.count()
         messages.info(request, f"Regenerate embeddings functionality not implemented yet. {count} chunks selected.")
-    
+
     @action(description="Clear embeddings", variant=ActionVariant.WARNING)
     def clear_embeddings(self, request, queryset):
         """Clear embeddings for selected chunks."""

django_cfg/apps/knowbase/admin/helpers/__init__.py

@@ -6,7 +6,7 @@ Provides shared display methods, configurations, and utilities.
 
 from .configs import DocumentAdminConfigs
 from .display_helpers import DocumentDisplayHelpers
-from .statistics import DocumentStatistics, ChunkStatistics, CategoryStatistics
+from .statistics import CategoryStatistics, ChunkStatistics, DocumentStatistics
 
 __all__ = [
     'DocumentAdminConfigs',

django_cfg/apps/knowbase/admin/helpers/configs.py

@@ -6,10 +6,10 @@ for consistent display across all document admin interfaces.
 """
 
 from django_cfg.modules.django_admin import (
-    MoneyDisplayConfig,
-    StatusBadgeConfig,
     DateTimeDisplayConfig,
     Icons,
+    MoneyDisplayConfig,
+    StatusBadgeConfig,
 )
 
 

django_cfg/apps/knowbase/admin/helpers/statistics.py

@@ -4,7 +4,7 @@ Statistics calculation for document admin changelist views.
 Provides reusable statistics aggregation logic for admin interfaces.
 """
 
-from django.db.models import Count, Sum, Avg, Q
+from django.db.models import Avg, Count, Q, Sum
 
 
 class DocumentStatistics:

django_cfg/apps/knowbase/apps.py

@@ -8,20 +8,19 @@ from django.db.models.signals import post_migrate
 
 class KnowbaseConfig(AppConfig):
     """Knowledge Base application configuration."""
-    
+
     default_auto_field = 'django.db.models.BigAutoField'
     name = 'django_cfg.apps.knowbase'
     label = 'django_cfg_knowbase'
     verbose_name = 'Django CFG Knowledge Base'
-    
+
     def ready(self):
         """Initialize app when Django starts."""
         # Import signals to register them
-        from . import signals
-        
+
         # Connect post-migrate signal for database setup
         post_migrate.connect(self.create_pgvector_extension, sender=self)
-        
+
         # Initialize task system and auto-start worker if configured
         try:
             from django_cfg.modules.django_tasks import initialize_task_system
@@ -30,20 +29,21 @@ class KnowbaseConfig(AppConfig):
             import logging
             logger = logging.getLogger(__name__)
             logger.warning(f"Failed to initialize task system: {e}")
-    
+
     def create_pgvector_extension(self, sender, **kwargs):
         """Create pgvector extension and indexes if they don't exist."""
-        from django.db import connection
         import logging
+
+        from django.db import connection
         logger = logging.getLogger(__name__)
-        
+
         try:
             with connection.cursor() as cursor:
                 # Create extensions
                 cursor.execute("CREATE EXTENSION IF NOT EXISTS vector;")
                 cursor.execute("CREATE EXTENSION IF NOT EXISTS pg_trgm;")  # For text search
                 logger.info("✅ pgvector extensions created/verified")
-                
+
                 # Create vector index for cosine similarity if table exists
                 cursor.execute("""
                     SELECT EXISTS (
@@ -52,7 +52,7 @@ class KnowbaseConfig(AppConfig):
                     );
                 """)
                 table_exists = cursor.fetchone()[0]
-                
+
                 if table_exists:
                     # Check if index already exists
                     cursor.execute("""
@@ -62,7 +62,7 @@ class KnowbaseConfig(AppConfig):
                         );
                     """)
                     index_exists = cursor.fetchone()[0]
-                    
+
                     if not index_exists:
                         cursor.execute("""
                             CREATE INDEX CONCURRENTLY IF NOT EXISTS embedding_cosine_idx 
@@ -75,7 +75,7 @@ class KnowbaseConfig(AppConfig):
                         logger.debug("✅ embedding_cosine_idx index already exists")
                 else:
                     logger.debug("⏳ django_cfg_knowbase_document_chunks table not yet created, skipping index creation")
-                    
+
         except Exception as e:
             # Log warning but don't fail - extension/index might already exist
-            logger.warning(f"Could not create pgvector extension/indexes: {e}")
+            logger.warning(f"Could not create pgvector extension/indexes: {e}")

django_cfg/apps/knowbase/config/__init__.py

@@ -8,15 +8,16 @@ including Pydantic-based settings and optional Constance field definitions.
 # Import the main Pydantic configuration
 from .settings import (
     KnowledgeBaseConfig,
+    get_archive_chunk_size,
+    get_chunking_params_for_type,
     get_config,
-    reload_config,
     get_document_chunk_size,
-    get_archive_chunk_size,
-    get_embedding_model,
     get_embedding_batch_size,
-    get_chunking_params_for_type,
+    get_embedding_model,
+    reload_config,
 )
 
+
 # Constance-related imports are optional and only loaded when needed
 # to avoid django_cfg dependency issues
 def get_django_cfg_knowbase_constance_fields():
@@ -40,12 +41,12 @@ __all__ = [
     "get_config",
     "reload_config",
     "get_document_chunk_size",
-    "get_archive_chunk_size", 
+    "get_archive_chunk_size",
     "get_embedding_model",
     "get_embedding_batch_size",
     "get_chunking_params_for_type",
     # Constance configuration (lazy loaded)
     "get_django_cfg_knowbase_constance_fields",
-    "get_django_cfg_knowbase_field_validation_rules", 
+    "get_django_cfg_knowbase_field_validation_rules",
     "get_all_django_cfg_knowbase_constance_config",
 ]