endoreg-db 0.8.5.4__py3-none-any.whl → 0.8.5.6__py3-none-any.whl

endoreg_db/urls/__init__.py

@@ -1,36 +1,39 @@
-from django.urls import path, include
 from django.conf import settings
 from django.conf.urls.static import static
+from django.urls import include, path
 from rest_framework.routers import DefaultRouter
 
-# Phase 1.2: Media Management URLs ✅ IMPLEMENTED  
-from .media import urlpatterns as media_url_patterns
-
 from endoreg_db.views import (
-    VideoViewSet,
     ExaminationViewSet,
-    VideoExaminationViewSet,
+    FindingClassificationViewSet,
     FindingViewSet,
-    FindingClassificationViewSet, 
+    PatientExaminationViewSet,
     PatientFindingViewSet,
-    PatientExaminationViewSet
+    VideoExaminationViewSet,
+    VideoViewSet,
 )
 
 from .anonymization import url_patterns as anonymization_url_patterns
-from .classification import url_patterns as classification_url_patterns
 from .auth import urlpatterns as auth_url_patterns
+from .classification import url_patterns as classification_url_patterns
 from .examination import urlpatterns as examination_url_patterns
 from .files import urlpatterns as files_url_patterns
+from .label_video_segment_validate import (
+    url_patterns as label_video_segment_validate_url_patterns,
+)
 from .label_video_segments import url_patterns as label_video_segments_url_patterns
-from .label_video_segment_validate import url_patterns as label_video_segment_validate_url_patterns
+
+# Phase 1.2: Media Management URLs ✅ IMPLEMENTED
+from .media import urlpatterns as media_url_patterns
+from .patient import urlpatterns as patient_url_patterns
+
 # TODO Phase 1.2: Implement VideoMediaView and PDFMediaView before enabling
 # from .media import urlpatterns as media_url_patterns
 from .report import url_patterns as report_url_patterns
-from .upload import urlpatterns as upload_url_patterns
-from .video import url_patterns as video_url_patterns
 from .requirements import urlpatterns as requirements_url_patterns
-from .patient import urlpatterns as patient_url_patterns
 from .stats import url_patterns as stats_url_patterns
+from .upload import urlpatterns as upload_url_patterns
+from .video import url_patterns as video_url_patterns
 
 api_urls = []
 api_urls += classification_url_patterns
@@ -50,21 +53,31 @@ api_urls += patient_url_patterns
 api_urls += stats_url_patterns
 
 router = DefaultRouter()
-router.register(r'videos', VideoViewSet, basename='videos')  
-router.register(r'examinations', ExaminationViewSet)
-router.register(r'video-examinations', VideoExaminationViewSet, basename='video-examinations')
-router.register(r'findings', FindingViewSet)
-router.register(r'classifications', FindingClassificationViewSet)
-router.register(r'patient-findings', PatientFindingViewSet)
-router.register(r'patient-examinations', PatientExaminationViewSet)
+router.register(r"videos", VideoViewSet, basename="videos")
+router.register(r"examinations", ExaminationViewSet)
+router.register(
+    r"video-examinations", VideoExaminationViewSet, basename="video-examinations"
+)
+router.register(r"findings", FindingViewSet)
+router.register(r"classifications", FindingClassificationViewSet)
+router.register(r"patient-findings", PatientFindingViewSet)
+router.register(r"patient-examinations", PatientExaminationViewSet)
+
+# Additional custom video examination routes
+# Frontend expects: GET /api/video/{id}/examinations/
+video_examinations_list = VideoExaminationViewSet.as_view({"get": "by_video"})
 
 # Export raw API urlpatterns (no prefix). The project-level endoreg_db/urls.py mounts these under /api/.
 urlpatterns = [
-    path('', include(api_urls)),  # Specific routes first
-    path('', include(router.urls)),  # Generic router routes second
+    path(
+        "video/<int:video_id>/examinations/",
+        video_examinations_list,
+        name="video-examinations-by-video",
+    ),
+    path("", include(api_urls)),  # Specific routes first
+    path("", include(router.urls)),  # Generic router routes second
 ]
 
 if settings.DEBUG:
     urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
     urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
-

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,
+                )