endoreg-db 0.8.4.4__py3-none-any.whl → 0.8.6.1__py3-none-any.whl

endoreg_db/views/pdf/__init__.py

@@ -1,11 +1,8 @@
-from .pdf_media import (
-    PDFMediaView,
-    UpdateSensitiveMetaView,
-    ClosingFileWrapper
-)
+from .reimport import PdfReimportView
+from .pdf_stream import PdfStreamView
+
 
 __all__ = [
-    "PDFMediaView",
-    "UpdateSensitiveMetaView",
-    "ClosingFileWrapper",
+    "PdfReimportView",
+    "PdfStreamView",
 ]

endoreg_db/views/pdf/pdf_stream.py

@@ -0,0 +1,187 @@
+import logging
+import os
+import re
+
+from django.http import FileResponse, Http404, StreamingHttpResponse
+from django.views.decorators.clickjacking import xframe_options_sameorigin
+from rest_framework.views import APIView
+
+from endoreg_db.models import RawPdfFile
+
+from ...utils.permissions import EnvironmentAwarePermission
+
+logger = logging.getLogger(__name__)
+_RANGE_RE = re.compile(r"bytes=(\d+)-(\d*)")
+
+
+class ClosingFileWrapper:
+    """Custom file wrapper that ensures file is closed after streaming"""
+
+    def __init__(self, file_handle, blksize=8192):
+        self.file_handle = file_handle
+        self.blksize = blksize
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        data = self.file_handle.read(self.blksize)
+        if not data:
+            self.file_handle.close()
+            raise StopIteration
+        return data
+
+    def close(self):
+        if hasattr(self.file_handle, "close"):
+            self.file_handle.close()
+
+
+class PdfStreamView(APIView):
+    """
+    Streams a PDF file with correct HTTP range support and proper file handle management.
+
+    Supports streaming both raw (original) and anonymized PDF files.
+
+    Query Parameters:
+        type: 'raw' (default) or 'anonymized' - Selects which PDF file to stream
+
+    Examples:
+        GET /api/media/pdf/1/?type=raw - Stream original raw PDF
+        GET /api/media/pdf/1/?type=anonymized - Stream anonymized PDF
+    """
+
+    permission_classes = [EnvironmentAwarePermission]
+
+    @xframe_options_sameorigin
+    def get(self, request, pdf_id: int, *args, **kwargs):
+        file_type = "raw"  # Initialize for error logging
+        try:
+            pdf_obj = RawPdfFile.objects.filter(pk=pdf_id).first()
+            if not pdf_obj:
+                logger.warning(f"PDF not found: ID {pdf_id}")
+                raise Http404("PDF not found")
+
+            # Parse query parameters to determine which file to stream
+            file_type = request.query_params.get("type", "raw").lower()
+            if file_type not in ["raw", "anonymized"]:
+                logger.warning(f"Invalid file_type '{file_type}', defaulting to 'raw'")
+                file_type = "raw"
+
+            # Determine which file field to use
+            if file_type == "raw":
+                file_field = pdf_obj.file
+                if not file_field:
+                    logger.warning(f"No raw PDF file available for PDF ID {pdf_id}")
+                    raise Http404("Raw PDF file not available")
+            else:  # anonymized
+                file_field = pdf_obj.anonymized_file
+                if not file_field:
+                    logger.warning(
+                        f"No anonymized PDF file available for PDF ID {pdf_id}"
+                    )
+                    raise Http404("Anonymized PDF file not available")
+
+            # Check if file exists on filesystem
+            try:
+                file_path = file_field.path
+                if not os.path.exists(file_path):
+                    logger.error(f"PDF file does not exist on filesystem: {file_path}")
+                    raise Http404(
+                        f"{file_type.capitalize()} PDF file not found on filesystem"
+                    )
+
+                file_size = os.path.getsize(file_path)
+            except (OSError, IOError, AttributeError) as e:
+                logger.error(f"Error accessing {file_type} PDF file {pdf_id}: {e}")
+                raise Http404(f"{file_type.capitalize()} PDF file not accessible")
+
+            # Generate safe filename
+            base_filename = (
+                os.path.basename(file_field.name)
+                if file_field.name
+                else f"document_{pdf_id}.pdf"
+            )
+            if not base_filename.endswith(".pdf"):
+                base_filename += ".pdf"
+
+            # Add type indicator to filename for clarity
+            if file_type == "anonymized":
+                name_parts = base_filename.rsplit(".", 1)
+                safe_filename = f"{name_parts[0]}_anonymized.{name_parts[1]}"
+            else:
+                safe_filename = base_filename
+
+            # Handle Range requests
+            range_header = request.headers.get("Range")
+            if range_header:
+                logger.debug(
+                    f"Range request for {file_type} PDF {pdf_id}: {range_header}"
+                )
+                match = _RANGE_RE.match(range_header)
+                if match:
+                    start = int(match.group(1))
+                    end = int(match.group(2) or file_size - 1)
+
+                    # Validate range
+                    if start >= file_size or start < 0:
+                        logger.warning(
+                            f"Invalid range start {start} for file size {file_size}"
+                        )
+                        raise Http404("Invalid range")
+
+                    if end >= file_size:
+                        end = file_size - 1
+
+                    chunk_size = end - start + 1
+
+                    try:
+                        file_handle = open(file_path, "rb")
+                        file_handle.seek(start)
+
+                        logger.debug(
+                            f"Serving {file_type} PDF {pdf_id} range {start}-{end}/{file_size}"
+                        )
+
+                        response = StreamingHttpResponse(
+                            ClosingFileWrapper(file_handle, blksize=8192),
+                            status=206,
+                            content_type="application/pdf",
+                        )
+                        response["Content-Length"] = str(chunk_size)
+                        response["Content-Range"] = f"bytes {start}-{end}/{file_size}"
+                        response["Accept-Ranges"] = "bytes"
+                        response["Content-Disposition"] = (
+                            f'inline; filename="{safe_filename}"'
+                        )
+
+                        return response
+                    except (OSError, IOError) as e:
+                        logger.error(
+                            f"Error opening {file_type} PDF file for range request: {e}"
+                        )
+                        raise Http404(f"Error accessing {file_type} PDF file")
+                else:
+                    logger.warning(f"Invalid Range header format: {range_header}")
+
+            # Serve entire file using FileResponse (automatically handles file closing)
+            logger.debug(f"Serving full {file_type} PDF {pdf_id} ({file_size} bytes)")
+
+            try:
+                file_handle = open(file_path, "rb")
+                response = FileResponse(file_handle, content_type="application/pdf")
+                response["Content-Length"] = str(file_size)
+                response["Accept-Ranges"] = "bytes"
+                response["Content-Disposition"] = f'inline; filename="{safe_filename}"'
+
+                # FileResponse will take ownership of file_handle and close it after response
+                return response
+            except (OSError, IOError) as e:
+                logger.error(f"Error opening {file_type} PDF file: {e}")
+                raise Http404(f"Error accessing {file_type} PDF file")
+
+        except Exception as e:
+            logger.error(
+                f"Unexpected error streaming {file_type if 'file_type' in locals() else 'PDF'} {pdf_id}: {e}",
+                exc_info=True,
+            )
+            raise Http404("Error streaming PDF")

endoreg_db/views/pdf/reimport.py

@@ -1,19 +1,22 @@
-from rest_framework.views import APIView
-from rest_framework.response import Response
-from rest_framework import status
 import logging
-from pathlib import Path
+
 from django.db import transaction
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
 from ...models import RawPdfFile, SensitiveMeta
 from ...services.pdf_import import PdfImportService
+
 logger = logging.getLogger(__name__)
 
+
 class PdfReimportView(APIView):
     """
     API endpoint to re-import a pdf file and regenerate metadata.
     This is useful when OCR failed or metadata is incomplete.
     """
-    
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.pdf_service = PdfImportService()
@@ -22,140 +25,153 @@ class PdfReimportView(APIView):
         """
         Re-import a pdf file to regenerate SensitiveMeta and other metadata.
         Instead of creating a new pdf, this updates the existing one.
-        
+
         Args:
             request: HTTP request object
             pk: PDF primary key (ID)
         """
         pdf_id = pk  # Align with media framework naming convention
-        
+
         # Validate pdf_id parameter
         if not pdf_id or not isinstance(pdf_id, int):
             return Response(
-                {"error": "Invalid PDF ID provided."}, 
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": "Invalid PDF ID provided."},
+                status=status.HTTP_400_BAD_REQUEST,
             )
 
         try:
             pdf = RawPdfFile.objects.get(id=pdf_id)
-            logger.info(f"Found PDF {pdf.uuid} (ID: {pdf_id}) for re-import")
+            logger.info(f"Found PDF {pdf.pdf_hash} (ID: {pdf_id}) for re-import")
         except RawPdfFile.DoesNotExist:
             logger.warning(f"PDF with ID {pdf_id} not found")
             return Response(
-                {"error": f"PDF with ID {pdf_id} not found."}, 
-                status=status.HTTP_404_NOT_FOUND
+                {"error": f"PDF with ID {pdf_id} not found."},
+                status=status.HTTP_404_NOT_FOUND,
             )
 
+        # Get raw file path using the model method
+        raw_file_path = pdf.get_raw_file_path()
 
-
-        # Check if the raw file actually exists on disk
-        raw_file_path = Path(pdf.file.path)
-        if not raw_file_path.exists():
-            logger.error(f"Raw file not found on disk: {raw_file_path}")
+        if not raw_file_path or not raw_file_path.exists():
+            logger.error(
+                f"Raw PDF file not found for hash {pdf.pdf_hash}: {raw_file_path}"
+            )
             return Response(
-                {"error": f"PDF file not found on server: {raw_file_path.name}"}, 
-                status=status.HTTP_400_BAD_REQUEST
+                {
+                    "error": f"Raw PDF file not found for PDF {pdf.pdf_hash}. Please upload the original file again."
+                },
+                status=status.HTTP_404_NOT_FOUND,
             )
 
         # Check if PDF has required relationships
         if not pdf.center:
-            logger.warning(f"PDF {pdf.uuid} has no associated center")
+            logger.warning(f"PDF {pdf.pdf_hash} has no associated center")
             return Response(
-                {"error": "Video has no associated center."}, 
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": "PDF has no associated center."},
+                status=status.HTTP_400_BAD_REQUEST,
             )
 
         try:
-            logger.info(f"Starting in-place re-import for pdf {pdf.uuid} (ID: {pdf_id})")
-            
+            logger.info(f"Starting re-import for PDF {pdf.pdf_hash} (ID: {pdf_id})")
+
             with transaction.atomic():
                 # Clear existing metadata to force regeneration
                 old_meta_id = None
                 if pdf.sensitive_meta:
-                    old_meta_id = pdf.sensitive_meta.id
-                    logger.info(f"Clearing existing SensitiveMeta {old_meta_id} for pdf {pdf.uuid}")
-                    pdf.sensitive_meta = None
-                    pdf.save(update_fields=['sensitive_meta'])
-                    
+                    old_meta_id = pdf.sensitive_meta.pk
+                    logger.info(
+                        f"Clearing existing SensitiveMeta {old_meta_id} for PDF {pdf.pdf_hash}"
+                    )
+                    pdf.sensitive_meta = None  # type: ignore
+                    pdf.save(update_fields=["sensitive_meta"])
+
                     # Delete the old SensitiveMeta record
                     try:
-                        SensitiveMeta.objects.filter(id=old_meta_id).delete()
+                        SensitiveMeta.objects.filter(pk=old_meta_id).delete()
                         logger.info(f"Deleted old SensitiveMeta {old_meta_id}")
                     except Exception as e:
-                        logger.warning(f"Could not delete old SensitiveMeta {old_meta_id}: {e}")
-      
-                
-        
-                
-                
-                # Ensure minimum patient data is available
-                logger.info(f"Ensuring minimum patient data for {pdf.uuid}")
-                self.pdf_service._ensure_default_patient_data(pdf)
-                
-                # Refresh from database to get updated data
-                pdf.refresh_from_db()
-                
-                # Use VideoImportService for anonymization
+                        logger.warning(
+                            f"Could not delete old SensitiveMeta {old_meta_id}: {e}"
+                        )
+
+                # Use PdfImportService for reprocessing
                 try:
-                    
-                    logger.info(f"Starting anonymization using VideoImportService for {pdf.uuid}")
+                    logger.info(
+                        f"Starting reprocessing using PdfImportService for {pdf.pdf_hash}"
+                    )
                     self.pdf_service.import_and_anonymize(
                         file_path=raw_file_path,
                         center_name=pdf.center.name,
-                        processor_name=pdf.processor.name if pdf.processor else "Unknown",
-                        save_video=True,
-                        delete_source=False
+                        delete_source=False,  # Don't delete during reimport
+                        retry=True,  # Mark as retry attempt
                     )
-                    
-                    logger.info(f"VideoImportService anonymization completed for {pdf.uuid}")
-                    
-                    
-                    return Response({
-                        "message": "Video re-import with VideoImportService completed successfully.",
-                        "pdf_id": pdf_id,
-                        "uuid": str(pdf.uuid),
-                        "frame_cleaning_applied": True,
-                        "sensitive_meta_created": pdf.sensitive_meta is not None,
-                        "sensitive_meta_id": pdf.sensitive_meta.id if pdf.sensitive_meta else None,
-                        "updated_in_place": True,
-                        "status": "done"
-                    }, status=status.HTTP_200_OK)
-                    
+
+                    logger.info(
+                        f"PdfImportService reprocessing completed for {pdf.pdf_hash}"
+                    )
+
+                    # Refresh to get updated state
+                    pdf.refresh_from_db()
+
+                    return Response(
+                        {
+                            "message": "PDF re-import completed successfully.",
+                            "pdf_id": pdf_id,
+                            "pdf_hash": str(pdf.pdf_hash),
+                            "sensitive_meta_created": pdf.sensitive_meta is not None,
+                            "sensitive_meta_id": pdf.sensitive_meta.pk
+                            if pdf.sensitive_meta
+                            else None,
+                            "text_extracted": bool(pdf.text),
+                            "anonymized": pdf.anonymized,
+                            "status": "done",
+                        },
+                        status=status.HTTP_200_OK,
+                    )
+
                 except Exception as e:
-                    logger.exception(f"VideoImportService anonymization failed for pdf {pdf.uuid}: {e}")
-                    logger.warning("Continuing without anonymization due to error")
-                
-            # Refresh from database to get final state
-            pdf.refresh_from_db()
-            
-            return Response({
-                "message": "PDF re-import completed successfully.",
-                "pdf_id": pdf_id,
-                "uuid": str(pdf.uuid),
-                "sensitive_meta_created": pdf.sensitive_meta is not None,
-                "sensitive_meta_id": pdf.sensitive_meta.id if pdf.sensitive_meta else None,
-                "updated_in_place": True,
-                "status": "done"
-            }, status=status.HTTP_200_OK)
+                    logger.exception(
+                        f"PdfImportService reprocessing failed for PDF {pdf.pdf_hash}: {e}"
+                    )
+                    return Response(
+                        {
+                            "error": f"Reprocessing failed: {str(e)}",
+                            "error_type": "processing_error",
+                            "pdf_id": pdf_id,
+                            "pdf_hash": str(pdf.pdf_hash),
+                        },
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    )
 
         except Exception as e:
-            logger.error(f"Failed to re-import pdf {pdf.uuid}: {str(e)}", exc_info=True)
-            
+            logger.error(
+                f"Failed to re-import PDF {pdf.pdf_hash}: {str(e)}", exc_info=True
+            )
+
             # Handle specific error types
             error_msg = str(e)
-            if any(phrase in error_msg.lower() for phrase in ["insufficient storage", "no space left", "disk full"]):
+            if any(
+                phrase in error_msg.lower()
+                for phrase in ["insufficient storage", "no space left", "disk full"]
+            ):
                 # Storage error - return specific error message
-                return Response({
-                    "error": f"Storage error during re-import: {error_msg}",
-                    "error_type": "storage_error",
-                    "pdf_id": pdf_id,
-                    "uuid": str(pdf.uuid)
-                }, status=status.HTTP_507_INSUFFICIENT_STORAGE)
+                return Response(
+                    {
+                        "error": f"Storage error during re-import: {error_msg}",
+                        "error_type": "storage_error",
+                        "pdf_id": pdf_id,
+                        "pdf_hash": str(pdf.pdf_hash),
+                    },
+                    status=status.HTTP_507_INSUFFICIENT_STORAGE,
+                )
             else:
                 # Other errors
-                return Response({
-                    "error": f"Re-import failed: {error_msg}",
-                    "error_type": "processing_error", 
-                    "pdf_id": pdf_id,
-                    "uuid": str(pdf.uuid)
-                }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+                return Response(
+                    {
+                        "error": f"Re-import failed: {error_msg}",
+                        "error_type": "processing_error",
+                        "pdf_id": pdf_id,
+                        "pdf_hash": str(pdf.pdf_hash),
+                    },
+                    status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                )