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

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

@@ -0,0 +1,17 @@
+"""
+Admin helper modules for knowbase.
+
+Provides shared display methods, configurations, and utilities.
+"""
+
+from .configs import DocumentAdminConfigs
+from .display_helpers import DocumentDisplayHelpers
+from .statistics import DocumentStatistics, ChunkStatistics, CategoryStatistics
+
+__all__ = [
+    'DocumentAdminConfigs',
+    'DocumentDisplayHelpers',
+    'DocumentStatistics',
+    'ChunkStatistics',
+    'CategoryStatistics',
+]

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

@@ -0,0 +1,72 @@
+"""
+Shared configuration objects for admin displays.
+
+Provides pre-configured StatusBadgeConfig, MoneyDisplayConfig, etc.
+for consistent display across all document admin interfaces.
+"""
+
+from django_cfg.modules.django_admin import (
+    MoneyDisplayConfig,
+    StatusBadgeConfig,
+    DateTimeDisplayConfig,
+    Icons,
+)
+
+
+class DocumentAdminConfigs:
+    """Shared configuration objects for document admins."""
+
+    # Visibility badges
+    VISIBILITY_PUBLIC = StatusBadgeConfig(show_icons=True, icon=Icons.PUBLIC)
+    VISIBILITY_PRIVATE = StatusBadgeConfig(show_icons=True, icon=Icons.LOCK)
+
+    # Vectorization status badges
+    VECTORIZED = StatusBadgeConfig(show_icons=True, icon=Icons.CHECK_CIRCLE)
+    NOT_VECTORIZED = StatusBadgeConfig(show_icons=True, icon=Icons.ERROR)
+
+    # Entity type badges
+    DOCUMENT_TITLE = StatusBadgeConfig(show_icons=True, icon=Icons.DESCRIPTION)
+    CHUNK = StatusBadgeConfig(show_icons=True, icon=Icons.ARTICLE)
+    CATEGORY = StatusBadgeConfig(show_icons=True, icon=Icons.FOLDER)
+
+    # Processing status
+    PROCESSING_STATUS = StatusBadgeConfig(
+        custom_mappings={
+            'pending': 'warning',
+            'processing': 'info',
+            'completed': 'success',
+            'failed': 'danger',
+            'cancelled': 'secondary'
+        },
+        show_icons=True
+    )
+
+    # Money display configuration
+    COST_USD = MoneyDisplayConfig(
+        currency="USD",
+        decimal_places=6,
+        show_sign=False
+    )
+
+    # DateTime display configuration
+    CREATED_AT = DateTimeDisplayConfig(show_relative=True)
+
+    @classmethod
+    def get_processing_status_icon(cls, status: str) -> str:
+        """
+        Get appropriate icon for processing status.
+
+        Args:
+            status: Processing status value
+
+        Returns:
+            Icon constant
+        """
+        status_icons = {
+            'completed': Icons.CHECK_CIRCLE,
+            'failed': Icons.ERROR,
+            'processing': Icons.SCHEDULE,
+            'pending': Icons.SCHEDULE,
+            'cancelled': Icons.CANCEL
+        }
+        return status_icons.get(status, Icons.SCHEDULE)

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

@@ -0,0 +1,156 @@
+"""
+Shared display helper methods for document admins.
+
+Provides reusable display methods to eliminate duplication across
+DocumentAdmin, DocumentChunkAdmin, and DocumentCategoryAdmin.
+"""
+
+from django_cfg.modules.django_admin import display
+from django_cfg.modules.django_admin.utils.badges import StatusBadge
+
+from .configs import DocumentAdminConfigs
+
+
+class DocumentDisplayHelpers:
+    """Shared display methods for document admin interfaces."""
+
+    @staticmethod
+    @display(description="User")
+    def display_user(obj, display_mixin):
+        """
+        Display user with standard formatting.
+
+        Args:
+            obj: Model instance with user field
+            display_mixin: DisplayMixin instance for formatting
+
+        Returns:
+            Formatted user display or "—" if no user
+        """
+        if not obj.user:
+            return "—"
+        return display_mixin.display_user_simple(obj.user)
+
+    @staticmethod
+    @display(description="Visibility")
+    def display_visibility(obj):
+        """
+        Display visibility status (public/private).
+
+        Args:
+            obj: Model instance with is_public field
+
+        Returns:
+            Status badge showing public or private status
+        """
+        if obj.is_public:
+            return StatusBadge.create(
+                text="Public",
+                variant="success",
+                config=DocumentAdminConfigs.VISIBILITY_PUBLIC
+            )
+        else:
+            return StatusBadge.create(
+                text="Private",
+                variant="danger",
+                config=DocumentAdminConfigs.VISIBILITY_PRIVATE
+            )
+
+    @staticmethod
+    @display(description="Tokens")
+    def display_token_count(obj, field_name='token_count'):
+        """
+        Display token count with K formatting.
+
+        Args:
+            obj: Model instance with token count field
+            field_name: Name of the token count field
+
+        Returns:
+            Formatted token count (e.g., "1.5K" or "500")
+        """
+        tokens = getattr(obj, field_name, 0)
+        if tokens > 1000:
+            return f"{tokens/1000:.1f}K"
+        return str(tokens)
+
+    @staticmethod
+    @display(description="Cost (USD)")
+    def display_cost_usd(obj, display_mixin, field_name='total_cost_usd'):
+        """
+        Display cost with currency formatting.
+
+        Args:
+            obj: Model instance with cost field
+            display_mixin: DisplayMixin instance for formatting
+            field_name: Name of the cost field
+
+        Returns:
+            Formatted cost with currency
+        """
+        return display_mixin.display_money_amount(
+            obj, field_name, DocumentAdminConfigs.COST_USD
+        )
+
+    @staticmethod
+    @display(description="Created")
+    def display_created_at(obj, display_mixin):
+        """
+        Display created time with relative display.
+
+        Args:
+            obj: Model instance with created_at field
+            display_mixin: DisplayMixin instance for formatting
+
+        Returns:
+            Formatted datetime with relative time
+        """
+        return display_mixin.display_datetime_relative(
+            obj, 'created_at', DocumentAdminConfigs.CREATED_AT
+        )
+
+    @staticmethod
+    @display(description="Embedding")
+    def display_embedding_status(obj):
+        """
+        Display embedding vectorization status.
+
+        Args:
+            obj: Model instance with embedding field
+
+        Returns:
+            Status badge showing vectorization status
+        """
+        has_embedding = obj.embedding is not None and len(obj.embedding) > 0
+        if has_embedding:
+            return StatusBadge.create(
+                text="✓ Vectorized",
+                variant="success",
+                config=DocumentAdminConfigs.VECTORIZED
+            )
+        else:
+            return StatusBadge.create(
+                text="✗ Not vectorized",
+                variant="danger",
+                config=DocumentAdminConfigs.NOT_VECTORIZED
+            )
+
+    @staticmethod
+    @display(description="Content Preview")
+    def display_content_preview(obj, max_length=200):
+        """
+        Display content preview with truncation.
+
+        Args:
+            obj: Model instance with content field
+            max_length: Maximum length before truncation
+
+        Returns:
+            Truncated content preview
+        """
+        if not obj.content:
+            return "—"
+        content = obj.content
+        if len(content) > max_length:
+            return content[:max_length] + "..."
+        return content

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

@@ -0,0 +1,108 @@
+"""
+Statistics calculation for document admin changelist views.
+
+Provides reusable statistics aggregation logic for admin interfaces.
+"""
+
+from django.db.models import Count, Sum, Avg, Q
+
+
+class DocumentStatistics:
+    """Calculate statistics for document admin."""
+
+    @staticmethod
+    def get_document_stats(queryset):
+        """
+        Calculate document statistics.
+
+        Args:
+            queryset: Document queryset to aggregate
+
+        Returns:
+            dict: Statistics including counts, tokens, and costs
+        """
+        stats = queryset.aggregate(
+            total_documents=Count('id'),
+            total_chunks=Sum('chunks_count'),
+            total_tokens=Sum('total_tokens'),
+            total_cost=Sum('total_cost_usd')
+        )
+
+        status_counts = dict(
+            queryset.values_list('processing_status').annotate(
+                count=Count('id')
+            )
+        )
+
+        return {
+            'total_documents': stats['total_documents'] or 0,
+            'total_chunks': stats['total_chunks'] or 0,
+            'total_tokens': stats['total_tokens'] or 0,
+            'total_cost': f"${(stats['total_cost'] or 0):.6f}",
+            'status_counts': status_counts
+        }
+
+
+class ChunkStatistics:
+    """Calculate statistics for chunk admin."""
+
+    @staticmethod
+    def get_chunk_stats(queryset):
+        """
+        Calculate chunk statistics.
+
+        Args:
+            queryset: DocumentChunk queryset to aggregate
+
+        Returns:
+            dict: Statistics including counts, tokens, and costs
+        """
+        stats = queryset.aggregate(
+            total_chunks=Count('id'),
+            total_tokens=Sum('token_count'),
+            total_characters=Sum('character_count'),
+            total_embedding_cost=Sum('embedding_cost'),
+            avg_tokens_per_chunk=Avg('token_count')
+        )
+
+        model_counts = dict(
+            queryset.values_list('embedding_model').annotate(
+                count=Count('id')
+            )
+        )
+
+        return {
+            'total_chunks': stats['total_chunks'] or 0,
+            'total_tokens': stats['total_tokens'] or 0,
+            'total_characters': stats['total_characters'] or 0,
+            'total_embedding_cost': f"${(stats['total_embedding_cost'] or 0):.6f}",
+            'avg_tokens_per_chunk': f"{(stats['avg_tokens_per_chunk'] or 0):.0f}",
+            'model_counts': model_counts
+        }
+
+
+class CategoryStatistics:
+    """Calculate statistics for category admin."""
+
+    @staticmethod
+    def get_category_stats(queryset):
+        """
+        Calculate category statistics.
+
+        Args:
+            queryset: DocumentCategory queryset to aggregate
+
+        Returns:
+            dict: Statistics including public/private counts
+        """
+        stats = queryset.aggregate(
+            total_categories=Count('id'),
+            public_categories=Count('id', filter=Q(is_public=True)),
+            private_categories=Count('id', filter=Q(is_public=False))
+        )
+
+        return {
+            'total_categories': stats['total_categories'] or 0,
+            'public_categories': stats['public_categories'] or 0,
+            'private_categories': stats['private_categories'] or 0
+        }

django_cfg/apps/knowbase/config/constance_fields.py

@@ -9,7 +9,7 @@ to ensure consistency across the application.
 """
 
 from typing import List
-from django_cfg.models.constance import ConstanceField
+from django_cfg.models.django.constance import ConstanceField
 from .settings import KnowledgeBaseConfig, get_openai_api_key, get_openrouter_api_key
 
 

django_cfg/apps/knowbase/config/settings.py

@@ -258,7 +258,7 @@ class KnowledgeBaseConfig(BaseModel):
     def get_openai_api_key(self) -> Optional[str]:
         """Get OpenAI API key from django-cfg configuration."""
         try:
-            from django_cfg.core.config import get_current_config
+            from django_cfg.core.state import get_current_config
             config = get_current_config()
             if config and hasattr(config, 'api_keys') and config.api_keys:
                 return config.api_keys.get_openai_key()
@@ -271,7 +271,7 @@ class KnowledgeBaseConfig(BaseModel):
     def get_openrouter_api_key(self) -> Optional[str]:
         """Get OpenRouter API key from django-cfg configuration."""
         try:
-            from django_cfg.core.config import get_current_config
+            from django_cfg.core.state import get_current_config
             config = get_current_config()
             if config and hasattr(config, 'api_keys') and config.api_keys:
                 return config.api_keys.get_openrouter_key()

django_cfg/apps/knowbase/examples/__init__.py

@@ -0,0 +1,3 @@
+"""
+Examples for using the External Data system in django_cfg.apps.knowbase.
+"""

django_cfg/apps/knowbase/examples/external_data_usage.py

@@ -0,0 +1,191 @@
+"""
+Примеры использования нового ExternalDataManager.
+
+Этот файл показывает, как легко интегрировать внешние данные в knowbase
+после рефакторинга.
+"""
+
+from django.contrib.auth import get_user_model
+from django_cfg.apps.knowbase.utils.external_data_manager import ExternalDataManager, quick_add_model, quick_search
+from django_cfg.apps.knowbase.models.external_data import ExternalDataType
+
+User = get_user_model()
+
+
+def example_add_django_model():
+    """Пример добавления Django модели как внешнего источника данных."""
+    
+    # Получаем пользователя
+    user = User.objects.first()
+    if not user:
+        print("❌ No users found")
+        return
+    
+    # Создаем менеджер
+    manager = ExternalDataManager(user)
+    
+    # Добавляем модель Vehicle (если она существует)
+    try:
+        from apps.vehicles_data.models import Vehicle
+        
+        external_data = manager.add_django_model(
+            model_class=Vehicle,
+            title="Vehicle Database",
+            fields=['brand__name', 'model', 'year', 'description'],
+            description="All vehicles from the database",
+            search_fields=['brand__name', 'model'],
+            chunk_size=800,
+            overlap_size=150,
+            auto_vectorize=True
+        )
+        
+        print(f"✅ Added Vehicle model as external data: {external_data.id}")
+        print(f"   Status: {external_data.status}")
+        print(f"   Total chunks: {external_data.total_chunks}")
+        
+    except ImportError:
+        print("⚠️ Vehicle model not found, using example data instead")
+        
+        # Добавляем произвольные данные
+        external_data = manager.add_custom_data(
+            title="Sample Car Data",
+            identifier="sample_cars",
+            content="""
+            Toyota Camry 2023: Reliable sedan with excellent fuel economy
+            Honda Civic 2023: Compact car perfect for city driving
+            BMW X5 2023: Luxury SUV with advanced features
+            Tesla Model 3 2023: Electric vehicle with autopilot
+            """,
+            description="Sample car data for testing",
+            tags=['cars', 'vehicles', 'sample']
+        )
+        
+        print(f"✅ Added sample car data: {external_data.id}")
+
+
+def example_search_external_data():
+    """Пример поиска по внешним данным."""
+    
+    user = User.objects.first()
+    if not user:
+        print("❌ No users found")
+        return
+    
+    manager = ExternalDataManager(user)
+    
+    # Поиск по запросу
+    results = manager.search(
+        query="reliable car with good fuel economy",
+        limit=3,
+        threshold=0.6
+    )
+    
+    print(f"🔍 Search results ({len(results)} found):")
+    for i, result in enumerate(results, 1):
+        print(f"  {i}. {result['source_title']} (similarity: {result['similarity']:.3f})")
+        print(f"     Content: {result['content'][:100]}...")
+        print()
+
+
+def example_get_statistics():
+    """Пример получения статистики."""
+    
+    user = User.objects.first()
+    if not user:
+        print("❌ No users found")
+        return
+    
+    manager = ExternalDataManager(user)
+    stats = manager.get_statistics()
+    
+    print("📊 External Data Statistics:")
+    print(f"   Total sources: {stats.total_sources}")
+    print(f"   Active sources: {stats.active_sources}")
+    print(f"   Processed sources: {stats.processed_sources}")
+    print(f"   Failed sources: {stats.failed_sources}")
+    print(f"   Total chunks: {stats.total_chunks}")
+    print(f"   Total tokens: {stats.total_tokens}")
+    print(f"   Total cost: ${stats.total_cost:.4f}")
+    print(f"   Source types: {stats.source_type_counts}")
+
+
+def example_health_check():
+    """Пример проверки здоровья системы."""
+    
+    user = User.objects.first()
+    if not user:
+        print("❌ No users found")
+        return
+    
+    manager = ExternalDataManager(user)
+    health = manager.health_check()
+    
+    print("🏥 System Health Check:")
+    print(f"   Status: {health.status}")
+    print(f"   Healthy: {'✅' if health.healthy else '❌'}")
+    print(f"   Database: {'✅' if health.database_healthy else '❌'}")
+    print(f"   Embedding Service: {'✅' if health.embedding_service_healthy else '❌'}")
+    print(f"   Processing: {'✅' if health.processing_healthy else '❌'}")
+    print(f"   Response time: {health.response_time_ms:.2f}ms")
+    print(f"   Active sources: {health.active_sources}")
+    print(f"   Pending processing: {health.pending_processing}")
+    print(f"   Failed processing: {health.failed_processing}")
+    
+    if health.issues:
+        print(f"   Issues: {health.issues}")
+    if health.warnings:
+        print(f"   Warnings: {health.warnings}")
+
+
+def example_quick_functions():
+    """Пример использования быстрых функций."""
+    
+    user = User.objects.first()
+    if not user:
+        print("❌ No users found")
+        return
+    
+    # Быстрый поиск
+    results = quick_search(
+        user=user,
+        query="electric vehicle",
+        limit=2
+    )
+    
+    print(f"⚡ Quick search results: {len(results)} found")
+    for result in results:
+        print(f"   - {result['source_title']}: {result['similarity']:.3f}")
+
+
+def run_all_examples():
+    """Запустить все примеры."""
+    
+    print("🚀 Running External Data Manager Examples")
+    print("=" * 50)
+    
+    try:
+        print("\n1. Adding Django Model:")
+        example_add_django_model()
+        
+        print("\n2. Searching External Data:")
+        example_search_external_data()
+        
+        print("\n3. Getting Statistics:")
+        example_get_statistics()
+        
+        print("\n4. Health Check:")
+        example_health_check()
+        
+        print("\n5. Quick Functions:")
+        example_quick_functions()
+        
+        print("\n✅ All examples completed successfully!")
+        
+    except Exception as e:
+        print(f"\n❌ Error running examples: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    run_all_examples()

django_cfg/apps/knowbase/mixins/__init__.py

@@ -3,13 +3,30 @@ Mixins for knowbase integration.
 """
 
 from .external_data_mixin import ExternalDataMixin
-from .config import ExternalDataConfig
+from .config import ExternalDataMetaConfig, ExternalDataMetaParser, ExternalDataDefaults
 from .creator import ExternalDataCreator
 from .service import ExternalDataService
+from .generators import (
+    ExternalDataContentGenerator,
+    ExternalDataMetadataGenerator,
+    ExternalDataFieldAnalyzer,
+)
 
 __all__ = [
+    # Core mixin
     'ExternalDataMixin',
-    'ExternalDataConfig',
+
+    # Configuration
+    'ExternalDataMetaConfig',
+    'ExternalDataMetaParser',
+    'ExternalDataDefaults',
+
+    # Service layer
     'ExternalDataCreator',
     'ExternalDataService',
+
+    # Generators (for advanced usage)
+    'ExternalDataContentGenerator',
+    'ExternalDataMetadataGenerator',
+    'ExternalDataFieldAnalyzer',
 ]

django_cfg/apps/knowbase/mixins/config/__init__.py

@@ -0,0 +1,14 @@
+"""
+Configuration utilities for ExternalData.
+
+Parsing and defaults for ExternalDataMeta configuration.
+"""
+
+from .meta_config import ExternalDataMetaConfig, ExternalDataMetaParser
+from .defaults import ExternalDataDefaults
+
+__all__ = [
+    'ExternalDataMetaConfig',
+    'ExternalDataMetaParser',
+    'ExternalDataDefaults',
+]