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

django_cfg/apps/knowbase/models/archive.py

@@ -4,15 +4,15 @@ Archive models for universal document processing.
 Supports any type of compressed document collections with context-aware chunking.
 """
 
-from django.db import models
-from pgvector.django import VectorField
-from typing import Optional, List, Dict, Any
 import hashlib
 import mimetypes
 from pathlib import Path
-from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from django.db import models
+from pgvector.django import VectorField
 
-from .base import UserScopedModel, ProcessingStatus, TimestampedModel
+from .base import ProcessingStatus, UserScopedModel
 from .document import DocumentCategory
 
 
@@ -46,11 +46,11 @@ class ChunkType(models.TextChoices):
 
 class DocumentArchive(UserScopedModel):
     """Universal archive entity for any document collection."""
-    
+
     # Custom managers
     from ..managers.archive import DocumentArchiveManager
     objects = DocumentArchiveManager()
-    
+
     title = models.CharField(
         max_length=512,
         help_text="Archive title"
@@ -59,7 +59,7 @@ class DocumentArchive(UserScopedModel):
         blank=True,
         help_text="Archive description"
     )
-    
+
     # Categories relationship (reuse existing DocumentCategory)
     categories = models.ManyToManyField(
         DocumentCategory,
@@ -67,18 +67,18 @@ class DocumentArchive(UserScopedModel):
         related_name='archives',
         help_text="Archive categories (supports multiple)"
     )
-    
+
     is_public = models.BooleanField(
         default=True,
         help_text="Whether this archive is publicly accessible"
     )
-    
+
     # Archive file storage
     archive_file = models.FileField(
         upload_to='archives/%Y/%m/%d/',
         help_text="Uploaded archive file"
     )
-    
+
     # Archive metadata
     original_filename = models.CharField(
         max_length=255,
@@ -98,7 +98,7 @@ class DocumentArchive(UserScopedModel):
         db_index=True,
         help_text="SHA-256 hash for duplicate detection"
     )
-    
+
     # Processing status (synchronous processing)
     processing_status = models.CharField(
         max_length=20,
@@ -107,12 +107,12 @@ class DocumentArchive(UserScopedModel):
         db_index=True
     )
     processed_at = models.DateTimeField(
-        null=True, 
+        null=True,
         blank=True,
         help_text="When processing completed"
     )
     processing_error = models.TextField(
-        blank=True, 
+        blank=True,
         default="",
         help_text="Error message if processing failed"
     )
@@ -120,7 +120,7 @@ class DocumentArchive(UserScopedModel):
         default=0,
         help_text="Processing time in milliseconds"
     )
-    
+
     # Statistics
     total_items = models.PositiveIntegerField(
         default=0,
@@ -146,7 +146,7 @@ class DocumentArchive(UserScopedModel):
         default=0.0,
         help_text="Total processing cost in USD"
     )
-    
+
     # Metadata
     metadata = models.JSONField(
         default=dict,
@@ -154,7 +154,7 @@ class DocumentArchive(UserScopedModel):
         null=True,
         help_text="Additional archive metadata"
     )
-    
+
     class Meta:
         db_table = 'django_cfg_knowbase_document_archives'
         indexes = [
@@ -172,48 +172,48 @@ class DocumentArchive(UserScopedModel):
         verbose_name = 'Document Archive'
         verbose_name_plural = 'Document Archives'
         ordering = ['-created_at']
-    
+
     def save(self, *args, **kwargs):
         """Override save to generate content_hash if not provided."""
         # content_hash will be set by the service when processing file
         super().save(*args, **kwargs)
-    
+
     def __str__(self) -> str:
         return f"{self.title} ({self.user.username})"
-    
+
     @property
     def is_processed(self) -> bool:
         """Check if archive processing is completed."""
         return self.processing_status == ProcessingStatus.COMPLETED
-    
+
     @property
     def processing_progress(self) -> float:
         """Calculate processing progress as percentage."""
         if self.total_items == 0:
             return 0.0
         return (self.processed_items / self.total_items) * 100
-    
+
     @property
     def vectorization_progress(self) -> float:
         """Calculate vectorization progress as percentage."""
         if self.total_chunks == 0:
             return 0.0
         return (self.vectorized_chunks / self.total_chunks) * 100
-    
+
     def get_file_tree(self) -> Dict[str, Any]:
         """Build hierarchical file tree structure."""
         items = self.items.all().order_by('relative_path')
         tree: Dict[str, Any] = {}
-        
+
         for item in items:
             parts = item.relative_path.split('/')
             current = tree
-            
+
             for part in parts[:-1]:  # All except filename
                 if part not in current:
                     current[part] = {'type': 'directory', 'children': {}}
                 current = current[part]['children']
-            
+
             # Add file
             filename = parts[-1]
             current[filename] = {
@@ -225,24 +225,24 @@ class DocumentArchive(UserScopedModel):
                 'is_processable': item.is_processable,
                 'chunks_count': item.chunks_count
             }
-        
+
         return tree
 
 
 class ArchiveItem(UserScopedModel):
     """Individual file/document within archive."""
-    
+
     # Custom managers
     from ..managers.archive import ArchiveItemManager
     objects = ArchiveItemManager()
-    
+
     archive = models.ForeignKey(
         DocumentArchive,
         on_delete=models.CASCADE,
         related_name='items',
         help_text="Parent archive"
     )
-    
+
     # File metadata
     relative_path = models.CharField(
         max_length=1024,
@@ -270,7 +270,7 @@ class ArchiveItem(UserScopedModel):
         max_length=64,
         help_text="SHA-256 hash of item content"
     )
-    
+
     # Content processing
     raw_content = models.TextField(
         blank=True,
@@ -280,7 +280,7 @@ class ArchiveItem(UserScopedModel):
         default=False,
         help_text="Whether item can be processed for chunks"
     )
-    
+
     # Metadata for context
     language = models.CharField(
         max_length=50,
@@ -292,7 +292,7 @@ class ArchiveItem(UserScopedModel):
         default='utf-8',
         help_text="Character encoding"
     )
-    
+
     # Processing results
     chunks_count = models.PositiveIntegerField(
         default=0,
@@ -306,7 +306,7 @@ class ArchiveItem(UserScopedModel):
         default=0.0,
         help_text="Processing cost for this item"
     )
-    
+
     # Additional metadata
     metadata = models.JSONField(
         default=dict,
@@ -314,7 +314,7 @@ class ArchiveItem(UserScopedModel):
         null=True,
         help_text="Item-specific metadata"
     )
-    
+
     class Meta:
         db_table = 'django_cfg_knowbase_archive_items'
         indexes = [
@@ -332,29 +332,29 @@ class ArchiveItem(UserScopedModel):
         ordering = ['archive', 'relative_path']
         verbose_name = 'Archive Item'
         verbose_name_plural = 'Archive Items'
-    
+
     def save(self, *args, **kwargs):
         """Override save to set computed fields."""
         if self.raw_content and not self.content_hash:
             self.content_hash = hashlib.sha256(self.raw_content.encode()).hexdigest()
-        
+
         # Detect item type and programming language
         if not self.item_type:
             self.item_type, _ = mimetypes.guess_type(self.item_name)
             if not self.item_type:
                 self.item_type = 'application/octet-stream'
-        
+
         if not self.language:
             self.language = self.detect_programming_language()
-        
+
         if not self.content_type or self.content_type == ContentType.UNKNOWN:
             self.content_type = self.detect_content_type()
-        
+
         super().save(*args, **kwargs)
-    
+
     def __str__(self) -> str:
         return f"{self.relative_path} in {self.archive.title}"
-    
+
     def detect_programming_language(self) -> str:
         """Detect programming language from file extension."""
         LANGUAGE_MAP = {
@@ -383,48 +383,48 @@ class ArchiveItem(UserScopedModel):
             '.dockerfile': 'dockerfile',
             '.tf': 'terraform',
         }
-        
+
         file_path = Path(self.item_name)
         extension = file_path.suffix.lower()
-        
+
         # Special cases
         if file_path.name.lower() in ['dockerfile', 'makefile']:
             return file_path.name.lower()
-        
+
         return LANGUAGE_MAP.get(extension, '')
-    
+
     def detect_content_type(self) -> str:
         """Detect content type from file extension and MIME type."""
         file_path = Path(self.item_name)
         extension = file_path.suffix.lower()
-        
+
         # Code files
         code_extensions = {
             '.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.go', '.rs',
             '.cpp', '.c', '.h', '.hpp', '.php', '.rb', '.cs', '.swift',
             '.kt', '.scala', '.clj', '.hs', '.ml', '.fs', '.elm'
         }
-        
+
         # Document files
         document_extensions = {
             '.md', '.txt', '.rst', '.adoc', '.pdf', '.docx', '.doc'
         }
-        
+
         # Data files
         data_extensions = {
             '.json', '.csv', '.xml', '.yml', '.yaml', '.toml', '.ini'
         }
-        
+
         # Image files
         image_extensions = {
             '.jpg', '.jpeg', '.png', '.gif', '.bmp', '.svg', '.webp'
         }
-        
+
         # Archive files
         archive_extensions = {
             '.zip', '.tar', '.gz', '.bz2', '.7z', '.rar'
         }
-        
+
         if extension in code_extensions:
             return ContentType.CODE
         elif extension in document_extensions:
@@ -437,17 +437,17 @@ class ArchiveItem(UserScopedModel):
             return ContentType.ARCHIVE
         else:
             return ContentType.UNKNOWN
-    
+
     @property
     def file_extension(self) -> str:
         """Get file extension."""
         return Path(self.item_name).suffix.lower()
-    
+
     @property
     def is_code_file(self) -> bool:
         """Check if item is a code file."""
         return self.content_type == ContentType.CODE
-    
+
     @property
     def is_document_file(self) -> bool:
         """Check if item is a document file."""
@@ -456,11 +456,11 @@ class ArchiveItem(UserScopedModel):
 
 class ArchiveItemChunk(UserScopedModel):
     """Context-aware chunk with rich parent references."""
-    
+
     # Custom managers
     from ..managers.archive import ArchiveItemChunkManager
     objects = ArchiveItemChunkManager()
-    
+
     # Parent references
     archive = models.ForeignKey(
         DocumentArchive,
@@ -474,7 +474,7 @@ class ArchiveItemChunk(UserScopedModel):
         related_name='chunks',
         help_text="Parent item"
     )
-    
+
     # Chunk content
     content = models.TextField(
         help_text="Chunk text content"
@@ -488,20 +488,20 @@ class ArchiveItemChunk(UserScopedModel):
         default=ChunkType.TEXT,
         help_text="Type of content in chunk"
     )
-    
+
     # Context preservation - rich metadata for AI understanding
     context_metadata = models.JSONField(
         default=dict,
         help_text="Rich context information for AI processing"
     )
-    
+
     # Vector embedding (1536 dimensions for OpenAI text-embedding-ada-002)
     embedding = VectorField(
         dimensions=1536,
         null=True,
         help_text="Vector embedding for semantic search"
     )
-    
+
     # Chunk statistics
     token_count = models.PositiveIntegerField(
         default=0,
@@ -511,7 +511,7 @@ class ArchiveItemChunk(UserScopedModel):
         default=0,
         help_text="Number of characters in chunk"
     )
-    
+
     # Processing metadata
     embedding_model = models.CharField(
         max_length=100,
@@ -522,7 +522,7 @@ class ArchiveItemChunk(UserScopedModel):
         default=0.0,
         help_text="Cost in USD for embedding generation"
     )
-    
+
     class Meta:
         db_table = 'django_cfg_knowbase_archive_item_chunks'
         indexes = [
@@ -540,17 +540,17 @@ class ArchiveItemChunk(UserScopedModel):
         ordering = ['item', 'chunk_index']
         verbose_name = 'Archive Item Chunk'
         verbose_name_plural = 'Archive Item Chunks'
-    
+
     def save(self, *args, **kwargs):
         """Override save to set computed fields."""
         if self.content and not self.character_count:
             self.character_count = len(self.content)
-        
+
         super().save(*args, **kwargs)
-    
+
     def __str__(self) -> str:
         return f"Chunk {self.chunk_index} of {self.item.relative_path}"
-    
+
     @classmethod
     def semantic_search(
         cls,
@@ -563,30 +563,30 @@ class ArchiveItemChunk(UserScopedModel):
     ):
         """Perform semantic search using pgvector with context filtering."""
         from pgvector.django import CosineDistance
-        
+
         queryset = cls.objects.filter(
             user=user,
             embedding__isnull=False
         )
-        
+
         # Apply content type filter
         if content_types:
             queryset = queryset.filter(
                 item__content_type__in=content_types
             )
-        
+
         # Apply language filter
         if languages:
             queryset = queryset.filter(
                 item__language__in=languages
             )
-        
+
         return queryset.annotate(
             similarity=1 - CosineDistance('embedding', query_embedding)
         ).filter(
             similarity__gte=similarity_threshold
         ).order_by('-similarity')[:limit]
-    
+
     def get_context_summary(self) -> Dict[str, Any]:
         """Get summary of chunk context for display."""
         return {

django_cfg/apps/knowbase/models/base.py

@@ -2,12 +2,11 @@
 Base models for knowledge base application.
 """
 
-from django.db import models
-from django.contrib.auth import get_user_model
-from django.conf import settings
-from enum import Enum
 import uuid
 
+from django.conf import settings
+from django.db import models
+
 
 class ProcessingStatus(models.TextChoices):
     """Document processing status enumeration."""
@@ -20,21 +19,21 @@ class ProcessingStatus(models.TextChoices):
 
 class TimestampedModel(models.Model):
     """Base model with automatic timestamps."""
-    
+
     id = models.UUIDField(
-        primary_key=True, 
-        default=uuid.uuid4, 
+        primary_key=True,
+        default=uuid.uuid4,
         editable=False
     )
     created_at = models.DateTimeField(auto_now_add=True, db_index=True)
     updated_at = models.DateTimeField(auto_now=True)
-    
+
     class Meta:
         abstract = True
         indexes = [
             models.Index(fields=['-created_at']),
         ]
-    
+
     @property
     def short_uuid(self) -> str:
         """Return first 6 characters of UUID for display."""
@@ -43,14 +42,14 @@ class TimestampedModel(models.Model):
 
 class UserScopedModel(TimestampedModel):
     """Base model with user isolation."""
-    
+
     user = models.ForeignKey(
-        settings.AUTH_USER_MODEL, 
-        on_delete=models.CASCADE, 
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
         db_index=True,
         help_text="Owner of this record"
     )
-    
+
     class Meta:
         abstract = True
         indexes = [

django_cfg/apps/knowbase/models/chat.py

@@ -3,16 +3,17 @@ Chat models for RAG-powered conversations.
 """
 
 from django.db import models
+
 from .base import UserScopedModel
 
 
 class ChatSession(UserScopedModel):
     """User chat session for conversation tracking."""
-    
+
     # Custom managers
     from ..managers.chat import ChatSessionManager
     objects = ChatSessionManager()
-    
+
     title = models.CharField(
         max_length=255,
         blank=True,
@@ -22,7 +23,7 @@ class ChatSession(UserScopedModel):
         default=True,
         help_text="Whether session accepts new messages"
     )
-    
+
     # Session statistics
     messages_count = models.PositiveIntegerField(default=0)
     total_tokens_used = models.PositiveIntegerField(default=0)
@@ -30,7 +31,7 @@ class ChatSession(UserScopedModel):
         default=0.0,
         help_text="Total session cost for monitoring"
     )
-    
+
     # Configuration
     model_name = models.CharField(
         max_length=100,
@@ -45,17 +46,17 @@ class ChatSession(UserScopedModel):
         default=5,
         help_text="Maximum chunks to include in context"
     )
-    
+
     class Meta:
         db_table = 'django_cfg_knowbase_chat_sessions'
         indexes = [
             models.Index(fields=['user', '-created_at']),
             models.Index(fields=['is_active']),
         ]
-    
+
     def __str__(self) -> str:
         return self.title or f"Session {self.id}"
-    
+
     def generate_title_if_empty(self) -> None:
         """Auto-generate title based on first message."""
         if not self.title and self.messages.exists():
@@ -66,17 +67,17 @@ class ChatSession(UserScopedModel):
                 # Take first 50 characters as title
                 self.title = first_message.content[:50] + "..."
                 self.save(update_fields=['title'])
-    
+
     def archive(self) -> None:
         """Archive (deactivate) this session."""
         self.is_active = False
         self.save(update_fields=['is_active'])
-    
+
     def activate(self) -> None:
         """Activate this session."""
         self.is_active = True
         self.save(update_fields=['is_active'])
-    
+
     @property
     def is_archived(self) -> bool:
         """Check if session is archived."""
@@ -85,23 +86,23 @@ class ChatSession(UserScopedModel):
 
 class ChatMessage(UserScopedModel):
     """Individual chat message with context tracking."""
-    
+
     # Custom managers
     from ..managers.chat import ChatMessageManager
     objects = ChatMessageManager()
-    
+
     class MessageRole(models.TextChoices):
         USER = 'user', 'User'
         ASSISTANT = 'assistant', 'Assistant'
         SYSTEM = 'system', 'System'
-    
+
     session = models.ForeignKey(
         ChatSession,
         on_delete=models.CASCADE,
         related_name='messages',
         help_text="Parent chat session"
     )
-    
+
     role = models.CharField(
         max_length=10,
         choices=MessageRole.choices,
@@ -110,13 +111,13 @@ class ChatMessage(UserScopedModel):
     content = models.TextField(
         help_text="Message content"
     )
-    
+
     # Context tracking
     context_chunks = models.JSONField(
         default=list,
         help_text="IDs of chunks used for context"
     )
-    
+
     # Usage tracking (for monitoring, not billing)
     tokens_used = models.PositiveIntegerField(
         default=0,
@@ -130,7 +131,7 @@ class ChatMessage(UserScopedModel):
         default=0,
         help_text="Processing time in milliseconds"
     )
-    
+
     # Response metadata
     model_name = models.CharField(
         max_length=100,
@@ -142,7 +143,7 @@ class ChatMessage(UserScopedModel):
         blank=True,
         help_text="Why the model stopped generating"
     )
-    
+
     class Meta:
         db_table = 'django_cfg_knowbase_chat_messages'
         indexes = [
@@ -151,7 +152,7 @@ class ChatMessage(UserScopedModel):
             models.Index(fields=['-created_at']),
         ]
         ordering = ['created_at']
-    
+
     def __str__(self) -> str:
         preview = self.content[:50] + "..." if len(self.content) > 50 else self.content
         return f"{self.role}: {preview}"