django-cfg 1.4.20__py3-none-any.whl → 1.4.23__py3-none-any.whl

django_cfg/apps/knowbase/signals/archive_signals.py

@@ -2,12 +2,13 @@
 Archive processing signals.
 """
 
-from django.db.models.signals import post_save, post_delete
-from django.dispatch import receiver
-from django.core.cache import cache
 import logging
 
-from ..models import DocumentArchive, ArchiveItem, ArchiveItemChunk
+from django.core.cache import cache
+from django.db.models.signals import post_delete, post_save
+from django.dispatch import receiver
+
+from ..models import ArchiveItem, ArchiveItemChunk, DocumentArchive
 
 logger = logging.getLogger(__name__)
 
@@ -15,43 +16,43 @@ logger = logging.getLogger(__name__)
 @receiver(post_save, sender=DocumentArchive)
 def archive_post_save(sender, instance, created, **kwargs):
     """Handle archive creation and updates."""
-    
+
     # Clear user's archive cache on any archive change
     cache_key = f"user_archives:{instance.user.id}"
     cache.delete(cache_key)
-    
+
     if created and instance.archive_file:
         # New archive with file - start processing
         logger.info(f"📦 New archive created: {instance.title} (ID: {instance.id})")
         _start_archive_processing(instance)
-        
+
     elif not created:
         # Archive update - check what changed
         update_fields = kwargs.get('update_fields')
-        
+
         # Define fields that, if updated alone, should NOT trigger reprocessing
         processing_fields = {
             'processing_status', 'processed_at', 'processing_duration_ms',
             'processing_error', 'total_items', 'processed_items', 'total_chunks',
             'vectorized_chunks', 'total_tokens', 'total_cost_usd'
         }
-        
+
         # If specific fields were updated, check if they are only processing-related
         if update_fields is not None:
             update_fields_set = set(update_fields) if update_fields else set()
-            
+
             if update_fields_set and update_fields_set.issubset(processing_fields):
                 # This is just a processing status update - don't reprocess
                 logger.debug(f"📊 Archive stats updated: {instance.title}")
                 return
-            
+
             # Check if archive file was updated
             if 'archive_file' in update_fields_set and instance.archive_file:
                 logger.info(f"📦 Archive file updated: {instance.title} (ID: {instance.id})")
-                
+
                 # Clear existing items and reset processing state
                 _reset_archive_processing(instance)
-                
+
                 # Start new processing
                 _start_archive_processing(instance)
             else:
@@ -66,10 +67,10 @@ def archive_post_save(sender, instance, created, **kwargs):
 def _reset_archive_processing(archive):
     """Reset archive processing state and clear items."""
     logger.debug(f"🧹 Clearing items for archive: {archive.title}")
-    
+
     # Delete existing items (cascades to chunks)
     archive.items.all().delete()
-    
+
     # Reset processing fields
     archive.processing_status = "pending"
     archive.processed_at = None
@@ -81,7 +82,7 @@ def _reset_archive_processing(archive):
     archive.vectorized_chunks = 0
     archive.total_tokens = 0
     archive.total_cost_usd = 0
-    
+
     # Save with explicit update_fields to avoid triggering this signal again
     archive.save(update_fields=[
         'processing_status', 'processed_at', 'processing_duration_ms',
@@ -97,10 +98,10 @@ def _start_archive_processing(archive):
         from ..tasks.archive_tasks import process_archive_task
         process_archive_task.send(str(archive.id), str(archive.user.id))
         logger.info(f"🚀 Started async processing for archive: {archive.id}")
-        
+
     except Exception as e:
         logger.error(f"❌ Failed to start archive processing: {e}")
-        
+
         # Update archive status to failed
         archive.processing_status = "failed"
         archive.processing_error = f"Failed to start processing: {e}"
@@ -112,7 +113,7 @@ def archive_item_post_save(sender, instance, created, **kwargs):
     """Handle archive item creation."""
     if created:
         logger.debug(f"📄 New archive item created: {instance.archive.title} - {instance.item_name}")
-        
+
         # Update archive item count
         archive = instance.archive
         archive.total_items = archive.items.count()
@@ -130,13 +131,13 @@ def archive_item_post_delete(sender, instance, **kwargs):
         except (AttributeError, DocumentArchive.DoesNotExist):
             logger.debug("⚠️ Archive already deleted, skipping item count update")
             return
-            
+
         logger.debug(f"🗑️ Archive item deleted: {archive_title} - {instance.item_name}")
-        
+
         # Update archive item count
         archive.total_items = archive.items.count()
         archive.save(update_fields=['total_items'])
-        
+
     except DocumentArchive.DoesNotExist:
         # Archive was already deleted
         logger.debug("Archive already deleted, skipping item count update")
@@ -150,17 +151,17 @@ def archive_chunk_post_save(sender, instance, created, **kwargs):
     """Handle archive chunk creation."""
     if created:
         logger.debug(f"🧩 New archive chunk created: {instance.item.item_name} chunk {instance.chunk_index}")
-        
+
         # Update archive chunk count
         archive = instance.archive
         archive.total_chunks = ArchiveItemChunk.objects.filter(archive=archive).count()
-        
+
         # Update vectorized chunks count
         archive.vectorized_chunks = ArchiveItemChunk.objects.filter(
-            archive=archive, 
+            archive=archive,
             embedding__isnull=False
         ).count()
-        
+
         archive.save(update_fields=['total_chunks', 'vectorized_chunks'])
 
 
@@ -173,9 +174,9 @@ def archive_chunk_post_delete(sender, instance, **kwargs):
             item_name = instance.item.item_name if hasattr(instance, 'item') and instance.item else "unknown"
         except (AttributeError, ArchiveItem.DoesNotExist):
             item_name = "unknown"
-            
+
         logger.debug(f"🗑️ Archive chunk deleted: {item_name} chunk {instance.chunk_index}")
-        
+
         # Update archive chunk counts - get archive through item if available
         try:
             if hasattr(instance, 'item') and instance.item:
@@ -184,18 +185,18 @@ def archive_chunk_post_delete(sender, instance, **kwargs):
                 # If item is already deleted, we can't update counts safely
                 logger.debug("⚠️ Cannot update chunk counts - parent item already deleted")
                 return
-                
+
             archive.total_chunks = ArchiveItemChunk.objects.filter(item__archive=archive).count()
             archive.vectorized_chunks = ArchiveItemChunk.objects.filter(
-                item__archive=archive, 
+                item__archive=archive,
                 embedding__isnull=False
             ).count()
-            
+
             archive.save(update_fields=['total_chunks', 'vectorized_chunks'])
-            
+
         except (AttributeError, ArchiveItem.DoesNotExist, DocumentArchive.DoesNotExist):
             logger.debug("⚠️ Cannot update chunk counts - related objects already deleted")
-        
+
     except Exception as e:
         logger.error(f"❌ Error in archive chunk post-delete signal: {e}")
         # Don't re-raise to avoid breaking deletion
@@ -207,5 +208,5 @@ def archive_post_delete(sender, instance, **kwargs):
     # Clear user's archive cache
     cache_key = f"user_archives:{instance.user.id}"
     cache.delete(cache_key)
-    
+
     logger.info(f"🗑️ Archive deleted: {instance.title} (ID: {instance.id})")

django_cfg/apps/knowbase/signals/chat_signals.py

@@ -2,12 +2,13 @@
 Chat and messaging related signals.
 """
 
-from django.db.models.signals import post_save, post_delete
+import logging
+
 from django.db import models
+from django.db.models.signals import post_delete, post_save
 from django.dispatch import receiver
-import logging
 
-from ..models import ChatSession, ChatMessage
+from ..models import ChatMessage, ChatSession
 
 logger = logging.getLogger(__name__)
 
@@ -17,7 +18,7 @@ def message_post_save(sender, instance, created, **kwargs):
     """Handle chat message creation."""
     if created:
         logger.debug(f"💬 New message: {instance.session.title} - {instance.role}")
-        
+
         # Update session statistics
         session = instance.session
         session.messages_count = session.messages.count()
@@ -27,7 +28,7 @@ def message_post_save(sender, instance, created, **kwargs):
         session.total_cost_usd = session.messages.aggregate(
             total=models.Sum('cost_usd')
         )['total'] or 0
-        
+
         session.save(update_fields=['messages_count', 'total_tokens_used', 'total_cost_usd'])
 
 

django_cfg/apps/knowbase/signals/document_signals.py

@@ -2,12 +2,12 @@
 Document and DocumentChunk related signals.
 """
 
-from django.db.models.signals import post_save, post_delete
-from django.db import models
-from django.dispatch import receiver
-from django.core.cache import cache
 import logging
 
+from django.core.cache import cache
+from django.db.models.signals import post_delete, post_save
+from django.dispatch import receiver
+
 from ..models import Document, DocumentChunk, ProcessingStatus
 
 logger = logging.getLogger(__name__)
@@ -16,43 +16,43 @@ logger = logging.getLogger(__name__)
 @receiver(post_save, sender=Document)
 def document_post_save(sender, instance, created, **kwargs):
     """Handle document creation and updates."""
-    
+
     # Clear user's document cache on any document change
     cache_key = f"user_documents:{instance.user.id}"
     cache.delete(cache_key)
-    
+
     if created:
         # New document - always process
         logger.info(f"📄 New document created: {instance.title} (ID: {instance.id})")
         _start_document_processing(instance)
-        
+
     else:
         # Document update - check what changed
         update_fields = kwargs.get('update_fields')
-        
+
         # Define fields that, if updated alone, should NOT trigger reprocessing
         processing_fields = {
             'processing_status', 'processing_started_at', 'processing_completed_at',
             'processing_error', 'chunks_count', 'total_tokens', 'total_cost_usd'
         }
-        
+
         # If specific fields were updated, check if they are only processing-related
         if update_fields is not None:
             update_fields_set = set(update_fields) if update_fields else set()
-            
+
             if update_fields_set and update_fields_set.issubset(processing_fields):
                 # This is just a processing status update - don't reprocess
                 logger.debug(f"📊 Document stats updated: {instance.title}")
                 return
-            
+
             # Check if content actually changed
             content_fields = {'content', 'content_hash'}
             if content_fields.intersection(update_fields_set):
                 logger.info(f"📝 Document content updated: {instance.title} (ID: {instance.id})")
-                
+
                 # Clear existing chunks and reset processing state
                 _reset_document_processing(instance)
-                
+
                 # Start new processing
                 _start_document_processing(instance)
             else:
@@ -68,10 +68,10 @@ def document_post_save(sender, instance, created, **kwargs):
 def _reset_document_processing(document):
     """Reset document processing state and clear chunks."""
     logger.debug(f"🧹 Clearing chunks for document: {document.title}")
-    
+
     # Delete existing chunks
     document.chunks.all().delete()
-    
+
     # Reset processing fields
     document.processing_status = "pending"
     document.processing_started_at = None
@@ -80,7 +80,7 @@ def _reset_document_processing(document):
     document.chunks_count = 0
     document.total_tokens = 0
     document.total_cost_usd = 0
-    
+
     # Save with explicit update_fields to avoid triggering this signal again
     document.save(update_fields=[
         'processing_status', 'processing_started_at', 'processing_completed_at',
@@ -95,10 +95,10 @@ def _start_document_processing(document):
         from ..tasks.document_processing import process_document_async
         process_document_async.send(str(document.id))
         logger.info(f"🚀 Started async processing for document: {document.id}")
-        
+
     except Exception as e:
         logger.error(f"❌ Failed to start document processing: {e}")
-        
+
         # Update document status to failed
         document.processing_status = ProcessingStatus.FAILED
         document.processing_error = f"Failed to start processing: {e}"
@@ -110,7 +110,7 @@ def chunk_post_save(sender, instance, created, **kwargs):
     """Handle chunk creation."""
     if created:
         logger.debug(f"🧩 New chunk created: {instance.document.title} chunk {instance.chunk_index}")
-        
+
         # Update document chunk count (this will trigger document save with update_fields)
         document = instance.document
         document.chunks_count = document.chunks.count()
@@ -122,12 +122,12 @@ def chunk_post_delete(sender, instance, **kwargs):
     """Handle chunk deletion."""
     try:
         logger.debug(f"🗑️ Chunk deleted: {instance.document.title} chunk {instance.chunk_index}")
-        
+
         # Update document chunk count
         document = instance.document
         document.chunks_count = document.chunks.count()
         document.save(update_fields=['chunks_count'])
-        
+
     except Document.DoesNotExist:
         # Document was already deleted
         logger.debug("Document already deleted, skipping chunk count update")
@@ -139,5 +139,5 @@ def document_post_delete(sender, instance, **kwargs):
     # Clear user's document cache
     cache_key = f"user_documents:{instance.user.id}"
     cache.delete(cache_key)
-    
+
     logger.info(f"🗑️ Document deleted: {instance.title} (ID: {instance.id})")

django_cfg/apps/knowbase/signals/external_data_signals.py

@@ -2,12 +2,12 @@
 External Data and ExternalDataChunk related signals.
 """
 
-from django.db.models.signals import post_save, post_delete
-from django.db import models
-from django.dispatch import receiver
-from django.core.cache import cache
 import logging
 
+from django.core.cache import cache
+from django.db.models.signals import post_delete, post_save
+from django.dispatch import receiver
+
 from ..models.external_data import ExternalData, ExternalDataChunk, ExternalDataStatus
 
 logger = logging.getLogger(__name__)
@@ -16,11 +16,11 @@ logger = logging.getLogger(__name__)
 @receiver(post_save, sender=ExternalData)
 def external_data_post_save(sender, instance, created, **kwargs):
     """Handle external data creation and updates."""
-    
+
     # Clear user's external data cache on any change
     cache_key = f"user_external_data:{instance.user.id}"
     cache.delete(cache_key)
-    
+
     if created:
         # New external data - process if has content
         logger.info(f"🔗 New external data created: {instance.title} (ID: {instance.id})")
@@ -28,36 +28,36 @@ def external_data_post_save(sender, instance, created, **kwargs):
             _start_external_data_processing(instance)
         else:
             logger.debug(f"📝 External data created without content: {instance.title}")
-        
+
     else:
         # External data update - check what changed
         update_fields = kwargs.get('update_fields')
-        
+
         # Define fields that, if updated alone, should NOT trigger reprocessing
         processing_fields = {
             'status', 'processed_at', 'source_updated_at', 'processing_error',
             'total_chunks', 'total_tokens', 'processing_cost'
         }
-        
+
         # If specific fields were updated, check if they are only processing-related
         if update_fields is not None:
             update_fields_set = set(update_fields) if update_fields else set()
-            
+
             if update_fields_set and update_fields_set.issubset(processing_fields):
                 # This is just a processing status update - don't reprocess
                 logger.debug(f"📊 External data stats updated: {instance.title}")
                 return
-            
+
             # Check if content actually changed
             content_fields = {'content', 'content_hash', 'source_config', 'chunk_size', 'overlap_size', 'embedding_model'}
             if content_fields.intersection(update_fields_set):
                 logger.info(f"📝 External data content updated: {instance.title} (ID: {instance.id})")
-                
+
                 # Only reprocess if there's content
                 if instance.content and instance.content.strip():
                     # Clear existing chunks and reset processing state
                     _reset_external_data_processing(instance)
-                    
+
                     # Start new processing
                     _start_external_data_processing(instance)
                 else:
@@ -83,10 +83,10 @@ def external_data_post_save(sender, instance, created, **kwargs):
 def _reset_external_data_processing(external_data):
     """Reset external data processing state and clear chunks."""
     logger.debug(f"🧹 Clearing chunks for external data: {external_data.title}")
-    
+
     # Delete existing chunks
     external_data.chunks.all().delete()
-    
+
     # Reset processing fields
     external_data.status = ExternalDataStatus.PENDING
     external_data.processed_at = None
@@ -94,7 +94,7 @@ def _reset_external_data_processing(external_data):
     external_data.total_chunks = 0
     external_data.total_tokens = 0
     external_data.processing_cost = 0.0
-    
+
     # Save with explicit update_fields to avoid triggering this signal again
     external_data.save(update_fields=[
         'status', 'processed_at', 'processing_error',
@@ -109,10 +109,10 @@ def _start_external_data_processing(external_data):
         from ..tasks.external_data_tasks import process_external_data_async
         process_external_data_async.send(str(external_data.id))
         logger.info(f"🚀 Started async processing for external data: {external_data.id}")
-        
+
     except Exception as e:
         logger.error(f"❌ Failed to start external data processing: {e}")
-        
+
         # Update external data status to failed
         external_data.status = ExternalDataStatus.FAILED
         external_data.processing_error = f"Failed to start processing: {e}"
@@ -124,7 +124,7 @@ def external_data_chunk_post_save(sender, instance, created, **kwargs):
     """Handle external data chunk creation."""
     if created:
         logger.debug(f"🧩 New external data chunk created: {instance.external_data.title} chunk {instance.chunk_index}")
-        
+
         # Update external data chunk count (this will trigger external data save with update_fields)
         external_data = instance.external_data
         external_data.total_chunks = external_data.chunks.count()
@@ -136,12 +136,12 @@ def external_data_chunk_post_delete(sender, instance, **kwargs):
     """Handle external data chunk deletion."""
     try:
         logger.debug(f"🗑️ External data chunk deleted: {instance.external_data.title} chunk {instance.chunk_index}")
-        
+
         # Update external data chunk count
         external_data = instance.external_data
         external_data.total_chunks = external_data.chunks.count()
         external_data.save(update_fields=['total_chunks'])
-        
+
     except ExternalData.DoesNotExist:
         # External data was already deleted
         logger.debug("External data already deleted, skipping chunk count update")
@@ -153,5 +153,5 @@ def external_data_post_delete(sender, instance, **kwargs):
     # Clear user's external data cache
     cache_key = f"user_external_data:{instance.user.id}"
     cache.delete(cache_key)
-    
+
     logger.info(f"🗑️ External data deleted: {instance.title} (ID: {instance.id})")

django_cfg/apps/knowbase/tasks/__init__.py

@@ -4,18 +4,17 @@ Knowledge Base Background Tasks
 Dramatiq tasks for document processing and maintenance.
 """
 
-from .document_processing import *
-from .maintenance import *
 from .archive_tasks import *
+from .document_processing import *
 from .external_data_tasks import *
-
+from .maintenance import *
 
 __all__ = [
     # Document processing
     'process_document_async',
     'reprocess_document_chunks',
     'generate_embeddings_batch',
-    
+
     # Archive processing
     'process_archive_task',
     'vectorize_archive_items_task',
@@ -23,17 +22,17 @@ __all__ = [
     'generate_archive_statistics_task',
     'archive_health_check_task',
     'test_archive_task',
-    
+
     # External data processing
     'process_external_data_async',
     'bulk_process_external_data_async',
     'cleanup_failed_external_data_async',
-    
+
     # Maintenance
     'cleanup_old_embeddings',
     'optimize_vector_indexes',
     'health_check_knowledge_base',
-    
+
     # Test tasks
     'test_simple_task',
 ]