endoreg-db 0.8.8.0__py3-none-any.whl → 0.8.8.9__py3-none-any.whl

endoreg_db/views/misc/upload_views.py

@@ -1,64 +1,66 @@
 import mimetypes
+
 from django.http import Http404
 from django.urls import reverse
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
 from rest_framework import status
-from rest_framework.views import APIView
-from rest_framework.response import Response
-from rest_framework.parsers import MultiPartParser, FormParser
+from rest_framework.parsers import FormParser, MultiPartParser
 from rest_framework.permissions import AllowAny
-from django.views.decorators.csrf import csrf_exempt
-from django.utils.decorators import method_decorator
+from rest_framework.response import Response
+from rest_framework.views import APIView
 
 # Try to import python-magic, but provide fallback if not available
 try:
     import magic
+
     MAGIC_AVAILABLE = True
 except ImportError:
     MAGIC_AVAILABLE = False
 
 from endoreg_db.models.upload_job import UploadJob
-from endoreg_db.serializers.misc.upload_job import (
-    UploadJobStatusSerializer,
-)
+from endoreg_db.serializers.misc.upload_job import UploadJobStatusSerializer
 
 # Try to import celery task, but provide fallback
 try:
     from endoreg_db.tasks.upload_tasks import process_upload_job
+
     CELERY_AVAILABLE = True
 except ImportError:
     CELERY_AVAILABLE = False
+
     # Define a dummy function for development
     def process_upload_job(job_id):
         pass
 
 
-@method_decorator(csrf_exempt, name='dispatch')
+@method_decorator(csrf_exempt, name="dispatch")
 class UploadFileView(APIView):
     """
     Handle file uploads (POST /api/upload/).
-    
-    Accepts multipart/form-data with a 'file' field containing PDF or video files.
+
+    Accepts multipart/form-data with a 'file' field containing report or video files.
     Creates an UploadJob and starts asynchronous processing.
-    
+
     Returns:
         201 Created: {"upload_id": "<uuid>", "status_url": "/api/upload/<uuid>/status/"}
         400 Bad Request: File validation errors
     """
-    
+
     parser_classes = [MultiPartParser, FormParser]
     permission_classes = [AllowAny]  # Adjust based on your auth requirements
-    
+
     # Maximum file size (1 GiB)
     MAX_FILE_SIZE = 1024 * 1024 * 1024  # 1 GiB in bytes
-    
+
     # Allowed MIME types
     ALLOWED_MIME_TYPES = {
-        'application/pdf',
-        'video/mp4',
-        'video/avi', 
-        'video/quicktime',
-        'video/x-msvideo',
-        'video/x-ms-wmv'
+        "application/pdf",
+        "video/mp4",
+        "video/avi",
+        "video/quicktime",
+        "video/x-msvideo",
+        "video/x-ms-wmv",
     }
 
     def post(self, request, *args, **kwargs):
@@ -66,93 +68,95 @@ class UploadFileView(APIView):
         Handle file upload and create processing job.
         """
         # Validate file presence
-        if 'file' not in request.FILES:
+        if "file" not in request.FILES:
             return Response(
-                {'error': 'No file provided. Please include a file in the "file" field.'},
-                status=status.HTTP_400_BAD_REQUEST
+                {
+                    "error": 'No file provided. Please include a file in the "file" field.'
+                },
+                status=status.HTTP_400_BAD_REQUEST,
             )
-        
-        uploaded_file = request.FILES['file']
-        
+
+        uploaded_file = request.FILES["file"]
+
         # Validate file is not empty
         if not uploaded_file or uploaded_file.size == 0:
             return Response(
-                {'error': 'Uploaded file is empty. Please select a valid file.'},
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": "Uploaded file is empty. Please select a valid file."},
+                status=status.HTTP_400_BAD_REQUEST,
             )
-        
+
         # Validate file size
         if uploaded_file.size > self.MAX_FILE_SIZE:
             return Response(
-                {'error': f'File too large. Maximum size is {self.MAX_FILE_SIZE // (1024**3)} GB.'},
-                status=status.HTTP_400_BAD_REQUEST
+                {
+                    "error": f"File too large. Maximum size is {self.MAX_FILE_SIZE // (1024**3)} GB."
+                },
+                status=status.HTTP_400_BAD_REQUEST,
             )
-        
+
         # Validate filename
-        if not uploaded_file.name or uploaded_file.name.strip() == '':
+        if not uploaded_file.name or uploaded_file.name.strip() == "":
             return Response(
-                {'error': 'Invalid filename. Please ensure the file has a valid name.'},
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": "Invalid filename. Please ensure the file has a valid name."},
+                status=status.HTTP_400_BAD_REQUEST,
             )
-        
+
         # Detect MIME type
         try:
             content_type = self._detect_mime_type(uploaded_file)
         except Exception as e:
             return Response(
-                {'error': f'Could not determine file type: {str(e)}'},
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": f"Could not determine file type: {str(e)}"},
+                status=status.HTTP_400_BAD_REQUEST,
             )
-        
+
         # Validate MIME type
         if content_type not in self.ALLOWED_MIME_TYPES:
             return Response(
-                {'error': f'Unsupported file type: {content_type}. Allowed types: PDF, MP4, AVI, MOV, WMV.'},
-                status=status.HTTP_400_BAD_REQUEST
+                {
+                    "error": f"Unsupported file type: {content_type}. Allowed types: report, MP4, AVI, MOV, WMV."
+                },
+                status=status.HTTP_400_BAD_REQUEST,
             )
-        
+
         try:
             # Create upload job
             upload_job = UploadJob.objects.create(
-                file=uploaded_file,
-                content_type=content_type
+                file=uploaded_file, content_type=content_type
             )
-            
+
             # Start asynchronous processing if Celery is available
             if CELERY_AVAILABLE:
                 try:
                     process_upload_job.delay(str(upload_job.id))
                 except Exception as e:
                     # If Celery task fails to start, mark job as failed
-                    upload_job.mark_failed(f'Failed to start processing: {str(e)}')
+                    upload_job.mark_failed(f"Failed to start processing: {str(e)}")
                     return Response(
-                        {'error': f'Failed to start processing: {str(e)}'},
-                        status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                        {"error": f"Failed to start processing: {str(e)}"},
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR,
                     )
             else:
                 # For development without Celery, mark as processing immediately
                 upload_job.mark_processing()
                 # In production, this would be handled by Celery
                 # For now, just leave it in processing state
-            
+
             # Prepare response
-            status_url = reverse('upload_status', kwargs={'id': upload_job.id})
+            status_url = reverse("upload_status", kwargs={"id": upload_job.id})
             response_data = {
-                'upload_id': str(upload_job.id),  # Ensure UUID is converted to string
-                'status_url': status_url,
-                'message': 'Upload job created successfully'
+                "upload_id": str(upload_job.id),  # Ensure UUID is converted to string
+                "status_url": status_url,
+                "message": "Upload job created successfully",
             }
-            
+
             # Return the response data directly since serializer fields are read-only
-            return Response(
-                response_data,
-                status=status.HTTP_201_CREATED
-            )
-            
+            return Response(response_data, status=status.HTTP_201_CREATED)
+
         except Exception as e:
             return Response(
-                {'error': f'Failed to create upload job: {str(e)}'},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                {"error": f"Failed to create upload job: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
 
     def _detect_mime_type(self, uploaded_file) -> str:
@@ -163,39 +167,39 @@ class UploadFileView(APIView):
         try:
             # Reset file pointer
             uploaded_file.seek(0)
-            
+
             # Try python-magic first (more reliable) if available
             if MAGIC_AVAILABLE:
                 try:
                     # Read first chunk for magic detection
                     chunk = uploaded_file.read(2048)
                     uploaded_file.seek(0)  # Reset again
-                    
+
                     mime_type = magic.from_buffer(chunk, mime=True)
-                    if mime_type and mime_type != 'application/octet-stream':
+                    if mime_type and mime_type != "application/octet-stream":
                         return mime_type
                 except Exception:
                     pass  # Fall back to mimetypes
-            
+
             # Fallback to mimetypes module
             mime_type, _ = mimetypes.guess_type(uploaded_file.name)
             if mime_type:
                 return mime_type
-            
+
             # Last resort - check file extension
-            if uploaded_file.name.lower().endswith('.pdf'):
-                return 'application/pdf'
-            elif uploaded_file.name.lower().endswith(('.mp4', '.m4v')):
-                return 'video/mp4'
-            elif uploaded_file.name.lower().endswith('.avi'):
-                return 'video/avi'
-            elif uploaded_file.name.lower().endswith(('.mov', '.qt')):
-                return 'video/quicktime'
-            elif uploaded_file.name.lower().endswith('.wmv'):
-                return 'video/x-ms-wmv'
-            
+            if uploaded_file.name.lower().endswith(".pdf"):
+                return "application/pdf"
+            elif uploaded_file.name.lower().endswith((".mp4", ".m4v")):
+                return "video/mp4"
+            elif uploaded_file.name.lower().endswith(".avi"):
+                return "video/avi"
+            elif uploaded_file.name.lower().endswith((".mov", ".qt")):
+                return "video/quicktime"
+            elif uploaded_file.name.lower().endswith(".wmv"):
+                return "video/x-ms-wmv"
+
             raise ValueError("Could not determine file type")
-            
+
         finally:
             # Ensure file pointer is reset
             uploaded_file.seek(0)
@@ -204,15 +208,15 @@ class UploadFileView(APIView):
 class UploadStatusView(APIView):
     """
     Get upload job status (GET /api/upload/<uuid>/status/).
-    
+
     Returns current processing status and relevant metadata.
     Should be polled every 2 seconds by the frontend.
-    
+
     Returns:
         200 OK: Status information
         404 Not Found: Upload job not found
     """
-    
+
     permission_classes = [AllowAny]  # Adjust based on your auth requirements
 
     def get(self, request, id, *args, **kwargs):
@@ -221,20 +225,17 @@ class UploadStatusView(APIView):
         """
         try:
             # Look up upload job by UUID
-            upload_job = UploadJob.objects.select_related('sensitive_meta').get(id=id)
-            
+            upload_job = UploadJob.objects.select_related("sensitive_meta").get(id=id)
+
             # Serialize the response
             serializer = UploadJobStatusSerializer(upload_job)
-            
-            return Response(
-                serializer.data,
-                status=status.HTTP_200_OK
-            )
-            
+
+            return Response(serializer.data, status=status.HTTP_200_OK)
+
         except UploadJob.DoesNotExist:
             raise Http404("Upload job not found")
         except Exception as e:
             return Response(
-                {'error': f'Failed to get upload status: {str(e)}'},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )
+                {"error": f"Failed to get upload status: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

endoreg_db/views/report/__init__.py

@@ -0,0 +1,7 @@
+from .reimport import ReportReimportView
+from .report_stream import ReportStreamView
+
+__all__ = [
+    "ReportReimportView",
+    "ReportStreamView",
+]

endoreg_db/views/{pdf → report}/reimport.py

@@ -6,12 +6,12 @@ from rest_framework.response import Response
 from rest_framework.views import APIView
 
 from ...models import RawPdfFile, SensitiveMeta
-from ...services.pdf_import import PdfImportService
+from endoreg_db.services.report_import import ReportImportService
 
 logger = logging.getLogger(__name__)
 
 
-class PdfReimportView(APIView):
+class  ReportReimportView(APIView):
     """
     API endpoint to re-import a pdf file and regenerate metadata.
     This is useful when OCR failed or metadata is incomplete.
@@ -19,7 +19,7 @@ class PdfReimportView(APIView):
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.pdf_service = PdfImportService()
+        self.pdf_service = ReportImportService()
 
     def post(self, request, pk):
         """
@@ -28,24 +28,24 @@ class PdfReimportView(APIView):
 
         Args:
             request: HTTP request object
-            pk: PDF primary key (ID)
+            pk: report 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."},
+                {"error": "Invalid report ID provided."},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
         try:
             pdf = RawPdfFile.objects.get(id=pdf_id)
-            logger.info(f"Found PDF {pdf.pdf_hash} (ID: {pdf_id}) for re-import")
+            logger.info(f"Found report {pdf.pdf_hash} (ID: {pdf_id}) for re-import")
         except RawPdfFile.DoesNotExist:
-            logger.warning(f"PDF with ID {pdf_id} not found")
+            logger.warning(f"report with ID {pdf_id} not found")
             return Response(
-                {"error": f"PDF with ID {pdf_id} not found."},
+                {"error": f"report with ID {pdf_id} not found."},
                 status=status.HTTP_404_NOT_FOUND,
             )
 
@@ -53,29 +53,35 @@ class PdfReimportView(APIView):
         raw_file_path = pdf.get_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}")
+            logger.error(
+                f"Raw report file not found for hash {pdf.pdf_hash}: {raw_file_path}"
+            )
             return Response(
-                {"error": f"Raw PDF file not found for PDF {pdf.pdf_hash}. Please upload the original file again."},
+                {
+                    "error": f"Raw report file not found for report {pdf.pdf_hash}. Please upload the original file again."
+                },
                 status=status.HTTP_404_NOT_FOUND,
             )
 
-        # Check if PDF has required relationships
+        # Check if report has required relationships
         if not pdf.center:
-            logger.warning(f"PDF {pdf.pdf_hash} has no associated center")
+            logger.warning(f"report {pdf.pdf_hash} has no associated center")
             return Response(
-                {"error": "PDF has no associated center."},
+                {"error": "report has no associated center."},
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
         try:
-            logger.info(f"Starting re-import for PDF {pdf.pdf_hash} (ID: {pdf_id})")
+            logger.info(f"Starting re-import for report {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.pk
-                    logger.info(f"Clearing existing SensitiveMeta {old_meta_id} for PDF {pdf.pdf_hash}")
+                    logger.info(
+                        f"Clearing existing SensitiveMeta {old_meta_id} for report {pdf.pdf_hash}"
+                    )
                     pdf.sensitive_meta = None
                     pdf.save(update_fields=["sensitive_meta"])
 
@@ -84,11 +90,15 @@ class PdfReimportView(APIView):
                         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}")
+                        logger.warning(
+                            f"Could not delete old SensitiveMeta {old_meta_id}: {e}"
+                        )
 
-                # Use PdfImportService for reprocessing
+                # Use ReportImportService for reprocessing
                 try:
-                    logger.info(f"Starting reprocessing using PdfImportService for {pdf.pdf_hash}")
+                    logger.info(
+                        f"Starting reprocessing using ReportImportService for {pdf.pdf_hash}"
+                    )
                     self.pdf_service.import_and_anonymize(
                         file_path=raw_file_path,
                         center_name=pdf.center.name,
@@ -96,18 +106,22 @@ class PdfReimportView(APIView):
                         retry=True,  # Mark as retry attempt
                     )
 
-                    logger.info(f"PdfImportService reprocessing completed for {pdf.pdf_hash}")
+                    logger.info(
+                        f"ReportImportService reprocessing completed for {pdf.pdf_hash}"
+                    )
 
                     # Refresh to get updated state
                     pdf.refresh_from_db()
 
                     return Response(
                         {
-                            "message": "PDF re-import completed successfully.",
+                            "message": "report 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,
+                            "sensitive_meta_id": pdf.sensitive_meta.pk
+                            if pdf.sensitive_meta
+                            else None,
                             "text_extracted": bool(pdf.text),
                             "anonymized": pdf.anonymized,
                             "status": "done",
@@ -116,7 +130,9 @@ class PdfReimportView(APIView):
                     )
 
                 except Exception as e:
-                    logger.exception(f"PdfImportService reprocessing failed for PDF {pdf.pdf_hash}: {e}")
+                    logger.exception(
+                        f"ReportImportService reprocessing failed for report {pdf.pdf_hash}: {e}"
+                    )
                     return Response(
                         {
                             "error": f"Reprocessing failed: {str(e)}",
@@ -128,11 +144,16 @@ class PdfReimportView(APIView):
                     )
 
         except Exception as e:
-            logger.error(f"Failed to re-import PDF {pdf.pdf_hash}: {str(e)}", exc_info=True)
+            logger.error(
+                f"Failed to re-import report {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(
                     {

endoreg_db/views/{pdf/pdf_stream.py → report/report_stream.py}

@@ -3,7 +3,10 @@ import os
 import re
 
 from django.http import FileResponse, Http404, StreamingHttpResponse
-from django.views.decorators.clickjacking import xframe_options_exempt, xframe_options_sameorigin
+from django.views.decorators.clickjacking import (
+    xframe_options_exempt,
+    xframe_options_sameorigin,
+)
 from rest_framework.views import APIView
 
 from endoreg_db.models import RawPdfFile
@@ -36,29 +39,30 @@ class ClosingFileWrapper:
             self.file_handle.close()
 
 
-class PdfStreamView(APIView):
+class ReportStreamView(APIView):
     """
-    Streams a PDF file with correct HTTP range support and proper file handle management.
+    Streams a report file with correct HTTP range support and proper file handle management.
 
-    Supports streaming both raw (original) and processed PDF files.
+    Supports streaming both raw (original) and processed report files.
 
     Query Parameters:
-        type: 'raw' (default) or 'processed' - Selects which PDF file to stream
+        type: 'raw' (default) or 'processed' - Selects which report file to stream
 
     Examples:
-        GET /api/media/pdf/1/?type=raw - Stream original raw PDF
-        GET /api/media/pdf/1/?type=processed - Stream processed PDF
+        GET /api/media/pdf/1/?type=raw - Stream original raw report
+        GET /api/media/pdf/1/?type=processed - Stream processed report
     """
 
     permission_classes = [EnvironmentAwarePermission]
+
     @xframe_options_exempt
     def get(self, request, pk: int, *args, **kwargs):
         file_type = "raw"  # Initialize for error logging
         try:
             pdf_obj = RawPdfFile.objects.filter(pk=pk).first()
             if not pdf_obj:
-                logger.warning(f"PDF not found: ID {pk}")
-                raise Http404("PDF not found")
+                logger.warning(f"report not found: ID {pk}")
+                raise Http404("report not found")
 
             # Parse query parameters to determine which file to stream
             file_type = request.query_params.get("type", "raw").lower()
@@ -70,29 +74,31 @@ class PdfStreamView(APIView):
             if file_type == "raw":
                 file_field = pdf_obj.file
                 if not file_field:
-                    logger.warning(f"No raw PDF file available for PDF ID {pk}")
-                    raise Http404("Raw PDF file not available")
+                    logger.warning(f"No raw report file available for report ID {pk}")
+                    raise Http404("Raw report file not available")
             else:  # anonymized
-                file_field = pdf_obj.anonymized_file
+                file_field = pdf_obj.processed_file
                 if not file_field:
                     logger.warning(
-                        f"No processed PDF file available for PDF ID {pk}"
+                        f"No processed report file available for report ID {pk}"
                     )
-                    raise Http404("Processed PDF file not available")
+                    raise Http404("Processed report 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}")
+                    logger.error(
+                        f"report file does not exist on filesystem: {file_path}"
+                    )
                     raise Http404(
-                        f"{file_type.capitalize()} PDF file not found on filesystem"
+                        f"{file_type.capitalize()} report 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 {pk}: {e}")
-                raise Http404(f"{file_type.capitalize()} PDF file not accessible")
+                logger.error(f"Error accessing {file_type} report file {pk}: {e}")
+                raise Http404(f"{file_type.capitalize()} report file not accessible")
 
             # Generate safe filename
             base_filename = (
@@ -114,7 +120,7 @@ class PdfStreamView(APIView):
             range_header = request.headers.get("Range")
             if range_header:
                 logger.debug(
-                    f"Range request for {file_type} PDF {pk}: {range_header}"
+                    f"Range request for {file_type} report {pk}: {range_header}"
                 )
                 match = _RANGE_RE.match(range_header)
                 if match:
@@ -138,7 +144,7 @@ class PdfStreamView(APIView):
                         file_handle.seek(start)
 
                         logger.debug(
-                            f"Serving {file_type} PDF {pk} range {start}-{end}/{file_size}"
+                            f"Serving {file_type} report {pk} range {start}-{end}/{file_size}"
                         )
 
                         response = StreamingHttpResponse(
@@ -156,31 +162,33 @@ class PdfStreamView(APIView):
                         return response
                     except (OSError, IOError) as e:
                         logger.error(
-                            f"Error opening {file_type} PDF file for range request: {e}"
+                            f"Error opening {file_type} report file for range request: {e}"
                         )
-                        raise Http404(f"Error accessing {file_type} PDF file")
+                        raise Http404(f"Error accessing {file_type} report 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 {pk} ({file_size} bytes)")
+            logger.debug(f"Serving full {file_type} report {pk} ({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}"'
+                with open(file_path, "rb") as file_handle:
+                    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")
+                logger.error(f"Error opening {file_type} report file: {e}")
+                raise Http404(f"Error accessing {file_type} report file")
 
         except Exception as e:
             logger.error(
-                f"Unexpected error streaming {file_type if 'file_type' in locals() else 'PDF'} {pk}: {e}",
+                f"Unexpected error streaming {file_type if 'file_type' in locals() else 'report'} {pk}: {e}",
                 exc_info=True,
             )
-            raise Http404("Error streaming PDF")
+            raise Http404("Error streaming report")