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

django_cfg/apps/knowbase/views/archive_views.py

@@ -2,41 +2,40 @@
 Document archive management API views.
 """
 
-from rest_framework import status, viewsets, parsers
+import logging
+
+from django.utils.decorators import method_decorator
+from django_ratelimit.decorators import ratelimit
+from drf_spectacular.utils import extend_schema
+from rest_framework import parsers, status
 from rest_framework.decorators import action
+from rest_framework.permissions import IsAdminUser, IsAuthenticated
 from rest_framework.response import Response
-from rest_framework.permissions import IsAuthenticated, IsAdminUser
-from django_ratelimit.decorators import ratelimit
-from django.utils.decorators import method_decorator
-from django.db import models
-from drf_spectacular.utils import extend_schema, OpenApiExample, OpenApiParameter
-from typing import Dict, Any
-import logging
 
-from ..models.archive import DocumentArchive, ArchiveItem, ArchiveItemChunk
-from ..services.archive import (
-    DocumentArchiveService, 
-    ArchiveVectorizationService,
-    ArchiveProcessingError,
-    ArchiveValidationError
-)
+from ..models.archive import ArchiveItem, ArchiveItemChunk, DocumentArchive
 from ..serializers.archive_serializers import (
-    DocumentArchiveCreateSerializer,
-    DocumentArchiveSerializer,
-    DocumentArchiveDetailSerializer,
-    DocumentArchiveListSerializer,
-    ArchiveItemSerializer,
-    ArchiveItemDetailSerializer,
-    ArchiveItemChunkSerializer,
     ArchiveItemChunkDetailSerializer,
+    ArchiveItemChunkSerializer,
+    ArchiveItemDetailSerializer,
+    ArchiveItemSerializer,
     ArchiveProcessingResultSerializer,
     ArchiveSearchRequestSerializer,
     ArchiveSearchResultSerializer,
     ArchiveStatisticsSerializer,
-    VectorizationStatisticsSerializer,
     ArchiveUploadSerializer,
     ChunkRevectorizationRequestSerializer,
-    VectorizationResultSerializer
+    DocumentArchiveCreateSerializer,
+    DocumentArchiveDetailSerializer,
+    DocumentArchiveListSerializer,
+    DocumentArchiveSerializer,
+    VectorizationResultSerializer,
+    VectorizationStatisticsSerializer,
+)
+from ..services.archive import (
+    ArchiveProcessingError,
+    ArchiveValidationError,
+    ArchiveVectorizationService,
+    DocumentArchiveService,
 )
 from .base import BaseKnowledgeViewSet
 
@@ -45,13 +44,13 @@ logger = logging.getLogger(__name__)
 
 class DocumentArchiveViewSet(BaseKnowledgeViewSet):
     """Document archive management endpoints - Admin only."""
-    
+
     queryset = DocumentArchive.objects.all()
     serializer_class = DocumentArchiveSerializer
     service_class = DocumentArchiveService
     permission_classes = [IsAuthenticated, IsAdminUser]
     parser_classes = [parsers.MultiPartParser, parsers.JSONParser]
-    
+
     def get_serializer_class(self):
         """Return appropriate serializer based on action."""
         if self.action == 'create':
@@ -67,7 +66,7 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
         elif self.action == 'statistics':
             return ArchiveStatisticsSerializer
         return DocumentArchiveSerializer
-    
+
     @extend_schema(
         summary="Upload and process archive",
         description="Upload archive file and process it synchronously",
@@ -94,7 +93,7 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
     @method_decorator(ratelimit(key='user', rate='5/hour', method='POST'))
     def create(self, request, *args, **kwargs):
         """Upload and process archive file."""
-        
+
         # Validate file upload
         file_serializer = ArchiveUploadSerializer(data=request.FILES)
         if not file_serializer.is_valid():
@@ -102,7 +101,7 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
                 file_serializer.errors,
                 status=status.HTTP_400_BAD_REQUEST
             )
-        
+
         # Validate metadata
         metadata_serializer = DocumentArchiveCreateSerializer(data=request.data)
         if not metadata_serializer.is_valid():
@@ -110,24 +109,24 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
                 metadata_serializer.errors,
                 status=status.HTTP_400_BAD_REQUEST
             )
-        
+
         try:
             service = self.get_service()
             uploaded_file = file_serializer.validated_data['file']
-            
+
             # Process archive
             result = service.create_and_process_archive(
                 uploaded_file=uploaded_file,
                 request_data=metadata_serializer.validated_data
             )
-            
+
             # Return processing result
             result_serializer = ArchiveProcessingResultSerializer(result)
             return Response(
                 result_serializer.data,
                 status=status.HTTP_201_CREATED
             )
-            
+
         except ArchiveValidationError as e:
             return Response(
                 {
@@ -157,7 +156,7 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
                 },
                 status=status.HTTP_500_INTERNAL_SERVER_ERROR
             )
-    
+
     @extend_schema(
         summary="Get archive items",
         description="Get all items in the archive",
@@ -166,13 +165,13 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
     @action(detail=True, methods=['get'])
     def items(self, request, pk=None):
         """Get archive items."""
-        
+
         archive = self.get_object()
         items = archive.items.all().order_by('relative_path')
-        
+
         serializer = ArchiveItemSerializer(items, many=True)
         return Response(serializer.data)
-    
+
     @extend_schema(
         summary="Get archive file tree",
         description="Get hierarchical file tree structure",
@@ -181,12 +180,12 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
     @action(detail=True, methods=['get'])
     def file_tree(self, request, pk=None):
         """Get archive file tree structure."""
-        
+
         archive = self.get_object()
         file_tree = archive.get_file_tree()
-        
+
         return Response({'file_tree': file_tree})
-    
+
     @extend_schema(
         summary="Search archive chunks",
         description="Semantic search within archive chunks",
@@ -196,9 +195,9 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
     @action(detail=True, methods=['post'])
     def search(self, request, pk=None):
         """Search within archive chunks."""
-        
+
         archive = self.get_object()
-        
+
         # Validate search request
         search_serializer = ArchiveSearchRequestSerializer(data=request.data)
         if not search_serializer.is_valid():
@@ -206,16 +205,20 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
                 search_serializer.errors,
                 status=status.HTTP_400_BAD_REQUEST
             )
-        
+
         search_data = search_serializer.validated_data
-        
+
         try:
             # Perform search using vectorization service
             vectorization_service = ArchiveVectorizationService(request.user)
-            
+
             # Generate query embedding
+            from django_cfg.apps.knowbase.config.settings import (
+                get_cache_settings,
+                get_openai_api_key,
+                get_openrouter_api_key,
+            )
             from django_cfg.modules.django_llm.llm.client import LLMClient
-            from django_cfg.apps.knowbase.config.settings import get_openai_api_key, get_openrouter_api_key, get_cache_settings
             cache_settings = get_cache_settings()
             llm_client = LLMClient(
                 apikey_openai=get_openai_api_key(),
@@ -231,7 +234,7 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
                 text=search_data['query'],
                 model=embedding_model
             )
-            
+
             # Search chunks using manager's semantic_search method
             chunks = ArchiveItemChunk.objects.semantic_search(
                 query_embedding=embedding_result.embedding,
@@ -244,7 +247,7 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
                 user=request.user,
                 chunk_types=search_data.get('chunk_types')
             )
-            
+
             # Build search results
             results = []
             for chunk in chunks:
@@ -263,17 +266,17 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
                     }
                 }
                 results.append(result_data)
-            
+
             serializer = ArchiveSearchResultSerializer(results, many=True)
             return Response(serializer.data)
-            
+
         except Exception as e:
             logger.error(f"Archive search error: {e}", exc_info=True)
             return Response(
                 {'error': 'Search failed', 'message': str(e)},
                 status=status.HTTP_500_INTERNAL_SERVER_ERROR
             )
-    
+
     @extend_schema(
         summary="Get archive statistics",
         description="Get processing and vectorization statistics",
@@ -282,19 +285,19 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
     @action(detail=False, methods=['get'])
     def statistics(self, request):
         """Get user's archive statistics."""
-        
+
         service = self.get_service()
-        
+
         # Get archive statistics from manager
         from ..managers.archive import DocumentArchiveManager
         archive_manager = DocumentArchiveManager()
         archive_manager.model = DocumentArchive
-        
+
         stats = archive_manager.get_processing_statistics(user=request.user)
-        
+
         serializer = ArchiveStatisticsSerializer(stats)
         return Response(serializer.data)
-    
+
     @extend_schema(
         summary="Get vectorization statistics",
         description="Get vectorization statistics for archives",
@@ -303,13 +306,13 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
     @action(detail=False, methods=['get'])
     def vectorization_stats(self, request):
         """Get vectorization statistics."""
-        
+
         vectorization_service = ArchiveVectorizationService(request.user)
         stats = vectorization_service.get_vectorization_statistics()
-        
+
         serializer = VectorizationStatisticsSerializer(stats)
         return Response(serializer.data)
-    
+
     @extend_schema(
         summary="Re-vectorize chunks",
         description="Re-vectorize specific chunks",
@@ -319,24 +322,24 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
     @action(detail=False, methods=['post'])
     def revectorize(self, request):
         """Re-vectorize specific chunks."""
-        
+
         serializer = ChunkRevectorizationRequestSerializer(data=request.data)
         if not serializer.is_valid():
             return Response(
                 serializer.errors,
                 status=status.HTTP_400_BAD_REQUEST
             )
-        
+
         try:
             vectorization_service = ArchiveVectorizationService(request.user)
             result = vectorization_service.revectorize_chunks(
                 chunk_ids=serializer.validated_data['chunk_ids'],
                 force=serializer.validated_data['force']
             )
-            
+
             result_serializer = VectorizationResultSerializer(result)
             return Response(result_serializer.data)
-            
+
         except Exception as e:
             logger.error(f"Re-vectorization error: {e}", exc_info=True)
             return Response(
@@ -347,27 +350,27 @@ class DocumentArchiveViewSet(BaseKnowledgeViewSet):
 
 class ArchiveItemViewSet(BaseKnowledgeViewSet):
     """Archive item management endpoints - Admin only."""
-    
+
     queryset = ArchiveItem.objects.all()
     serializer_class = ArchiveItemSerializer
     permission_classes = [IsAuthenticated, IsAdminUser]
-    
+
     def get_queryset(self):
         """Filter items by user and optional archive."""
         queryset = super().get_queryset()
-        
+
         archive_id = self.request.query_params.get('archive_id')
         if archive_id:
             queryset = queryset.filter(archive_id=archive_id)
-        
+
         return queryset
-    
+
     def get_serializer_class(self):
         """Return appropriate serializer based on action."""
         if self.action in ['retrieve', 'content']:
             return ArchiveItemDetailSerializer
         return ArchiveItemSerializer
-    
+
     @extend_schema(
         summary="Get item content",
         description="Get full content of archive item",
@@ -376,11 +379,11 @@ class ArchiveItemViewSet(BaseKnowledgeViewSet):
     @action(detail=True, methods=['get'])
     def content(self, request, pk=None):
         """Get item content."""
-        
+
         item = self.get_object()
         serializer = ArchiveItemDetailSerializer(item)
         return Response(serializer.data)
-    
+
     @extend_schema(
         summary="Get item chunks",
         description="Get all chunks for this item",
@@ -389,48 +392,48 @@ class ArchiveItemViewSet(BaseKnowledgeViewSet):
     @action(detail=True, methods=['get'])
     def chunks(self, request, pk=None):
         """Get item chunks."""
-        
+
         item = self.get_object()
         chunks = item.chunks.all().order_by('chunk_index')
-        
+
         serializer = ArchiveItemChunkSerializer(chunks, many=True)
         return Response(serializer.data)
 
 
 class ArchiveItemChunkViewSet(BaseKnowledgeViewSet):
     """Archive item chunk management endpoints - Admin only."""
-    
+
     queryset = ArchiveItemChunk.objects.all()
     serializer_class = ArchiveItemChunkSerializer
     permission_classes = [IsAuthenticated, IsAdminUser]
-    
+
     def get_queryset(self):
         """Filter chunks by user and optional filters."""
         queryset = super().get_queryset()
-        
+
         # Filter by archive
         archive_id = self.request.query_params.get('archive_id')
         if archive_id:
             queryset = queryset.filter(archive_id=archive_id)
-        
+
         # Filter by item
         item_id = self.request.query_params.get('item_id')
         if item_id:
             queryset = queryset.filter(item_id=item_id)
-        
+
         # Filter by chunk type
         chunk_type = self.request.query_params.get('chunk_type')
         if chunk_type:
             queryset = queryset.filter(chunk_type=chunk_type)
-        
+
         return queryset
-    
+
     def get_serializer_class(self):
         """Return appropriate serializer based on action."""
         if self.action in ['retrieve', 'context']:
             return ArchiveItemChunkDetailSerializer
         return ArchiveItemChunkSerializer
-    
+
     @extend_schema(
         summary="Get chunk context",
         description="Get full context metadata for chunk",
@@ -439,11 +442,11 @@ class ArchiveItemChunkViewSet(BaseKnowledgeViewSet):
     @action(detail=True, methods=['get'])
     def context(self, request, pk=None):
         """Get chunk context metadata."""
-        
+
         chunk = self.get_object()
         serializer = ArchiveItemChunkDetailSerializer(chunk)
         return Response(serializer.data)
-    
+
     @extend_schema(
         summary="Vectorize chunk",
         description="Generate embedding for specific chunk",
@@ -452,15 +455,15 @@ class ArchiveItemChunkViewSet(BaseKnowledgeViewSet):
     @action(detail=True, methods=['post'])
     def vectorize(self, request, pk=None):
         """Vectorize specific chunk."""
-        
+
         chunk = self.get_object()
-        
+
         try:
             vectorization_service = ArchiveVectorizationService(request.user)
             result = vectorization_service.vectorize_single_chunk(str(chunk.id))
-            
+
             return Response(result)
-            
+
         except Exception as e:
             logger.error(f"Chunk vectorization error: {e}", exc_info=True)
             return Response(

django_cfg/apps/knowbase/views/base.py

@@ -2,33 +2,30 @@
 Base views for knowledge base API.
 """
 
-from rest_framework import viewsets, status
-from rest_framework.response import Response
-from rest_framework.permissions import IsAuthenticated
-from django_ratelimit.decorators import ratelimit
-from django.utils.decorators import method_decorator
-from typing import Type, Any
 import logging
 
+from rest_framework import viewsets
+from rest_framework.permissions import IsAuthenticated
+
 logger = logging.getLogger(__name__)
 
 
 class BaseKnowledgeViewSet(viewsets.ModelViewSet):
     """Base ViewSet with common knowledge base functionality."""
-    
+
     permission_classes = [IsAuthenticated]
     lookup_field = 'pk'
-    
+
     def get_queryset(self):
         """Filter queryset by authenticated user."""
         if hasattr(self, 'queryset') and self.queryset is not None:
             return self.queryset.filter(user=self.request.user)
         return super().get_queryset()
-    
+
     def perform_create(self, serializer):
         """Automatically set user on creation."""
         serializer.save(user=self.request.user)
-    
+
     def handle_exception(self, exc):
         """Enhanced error handling with logging."""
         logger.error(
@@ -41,9 +38,9 @@ class BaseKnowledgeViewSet(viewsets.ModelViewSet):
             }
         )
         return super().handle_exception(exc)
-    
+
     def get_service(self):
         """Get service instance for this view."""
         if not hasattr(self, 'service_class'):
             raise NotImplementedError("ViewSet must define service_class")
-        return self.service_class(user=self.request.user)
+        return self.service_class(user=self.request.user)