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

endoreg_db/views/anonymization/overview.py

@@ -1,21 +1,28 @@
 # endoreg_db/api/views/anonymization_overview.py
 
+import logging
+
+from django.http import JsonResponse
 from rest_framework import status
 from rest_framework.decorators import api_view, permission_classes
-from rest_framework.response import Response
-from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
-from endoreg_db.services.anonymization import AnonymizationService
-from endoreg_db.services.polling_coordinator import PollingCoordinator, ProcessingLockContext
 from rest_framework.generics import ListAPIView
 from rest_framework.pagination import PageNumberPagination
-from endoreg_db.models import VideoFile, RawPdfFile
+from rest_framework.response import Response
+
+from endoreg_db.authz.permissions import PolicyPermission  # import RBAC
+from endoreg_db.models import RawPdfFile, VideoFile
+from endoreg_db.services.anonymization import AnonymizationService
+from endoreg_db.services.polling_coordinator import (
+    PollingCoordinator,
+    ProcessingLockContext,
+)
+from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
+
 from ...serializers import FileOverviewSerializer, VoPPatientDataSerializer
-from django.http import JsonResponse
 
-from endoreg_db.authz.permissions import PolicyPermission  #  import RBAC
-import logging
 logger = logging.getLogger(__name__)
-PERMS = DEBUG_PERMISSIONS   # shorten
+PERMS = DEBUG_PERMISSIONS  # shorten
+
 
 # ---------- overview ----------------------------------------------------
 class NoPagination(PageNumberPagination):
@@ -26,10 +33,11 @@ class AnonymizationOverviewView(ListAPIView):
     """
     GET /api/anonymization/items/overview/
     --------------------------------------
-    Returns a flat list (Video + PDF) ordered by newest upload first.
+    Returns a flat list (Video + report) ordered by newest upload first.
     """
+
     serializer_class = FileOverviewSerializer
-    #permission_classes = DEBUG_PERMISSIONS   
+    # permission_classes = DEBUG_PERMISSIONS
     permission_classes = [PolicyPermission]
     pagination_class = NoPagination
 
@@ -39,23 +47,25 @@ class AnonymizationOverviewView(ListAPIView):
         """
         # 1) VideoFile queryset - only fields that exist on VideoFile
         qs_video = (
-            VideoFile.objects
-            .select_related("state", "sensitive_meta")
+            VideoFile.objects.select_related("state", "sensitive_meta")
             .prefetch_related("label_video_segments__state")
-            .only("id", "original_file_name", "raw_file", "uploaded_at", "state", "sensitive_meta")
+            .only(
+                "id",
+                "original_file_name",
+                "raw_file",
+                "uploaded_at",
+                "state",
+                "sensitive_meta",
+            )
         )
         # 2) RawPdfFile queryset - only fields that exist on RawPdfFile
-        qs_pdf = (
-            RawPdfFile.objects
-            .select_related("sensitive_meta")
-            .only("id", "file", "date_created", 
-                "text", "anonymized_text",     
-                "sensitive_meta")
-
+        qs_pdf = RawPdfFile.objects.select_related("sensitive_meta").only(
+            "id", "file", "date_created", "text", "anonymized_text", "sensitive_meta"
         )
 
         return list(qs_video) + list(qs_pdf)
-    
+
+
 # ---------- status with polling protection ------------------------------
 @api_view(["GET"])
 @permission_classes(PERMS)
@@ -72,12 +82,14 @@ def anonymization_status(request, file_id: int):
 
     # Wende Rate-Limiting auf den echten Typ an (nicht auf einen evtl. falschen request-Parameter)
     if not PollingCoordinator.can_check_status(file_id, file_type):
-        remaining_seconds = PollingCoordinator.get_remaining_cooldown_seconds(file_id, file_type)
+        remaining_seconds = PollingCoordinator.get_remaining_cooldown_seconds(
+            file_id, file_type
+        )
         response_data = {
             "detail": "Status check rate limited. Please wait before checking again.",
             "file_id": file_id,
             "cooldown_active": True,
-            "retry_after": remaining_seconds
+            "retry_after": remaining_seconds,
         }
         response = Response(response_data, status=status.HTTP_429_TOO_MANY_REQUESTS)
         response["Retry-After"] = str(remaining_seconds)
@@ -86,15 +98,22 @@ def anonymization_status(request, file_id: int):
     status_val = info.get("anonymizationStatus") or info.get("status") or "not_started"
 
     # processing_locked als Ableitung des Status interpretieren
-    processing_statuses = {"processing_anonymization", "extracting_frames", "predicting_segments"}
+    processing_statuses = {
+        "processing_anonymization",
+        "extracting_frames",
+        "predicting_segments",
+    }
     processing_locked_derived = status_val in processing_statuses
 
-    return Response({
-        "file_id": file_id,
-        "file_type": file_type,
-        "anonymizationStatus": status_val,
-        "processing_locked": processing_locked_derived,
-    })
+    return Response(
+        {
+            "file_id": file_id,
+            "file_type": file_type,
+            "anonymizationStatus": status_val,
+            "processing_locked": processing_locked_derived,
+        }
+    )
+
 
 # ---------- start with processing lock ----------------------------------
 @api_view(["POST"])
@@ -107,9 +126,9 @@ def start_anonymization(request, file_id: int):
     info = AnonymizationService.get_status(file_id)
     if not info:
         return Response({"detail": "File not found"}, status=status.HTTP_404_NOT_FOUND)
-    
+
     file_type = info["mediaType"]
-    
+
     # Use processing lock context to prevent duplicate processing
     with ProcessingLockContext(file_id, file_type) as lock:
         if not lock.acquired:
@@ -118,27 +137,32 @@ def start_anonymization(request, file_id: int):
                     "detail": "File is already being processed by another request",
                     "file_id": file_id,
                     "file_type": file_type,
-                    "processing_locked": True
-                }, 
-                status=status.HTTP_409_CONFLICT
+                    "processing_locked": True,
+                },
+                status=status.HTTP_409_CONFLICT,
             )
-        
+
         # Proceed with starting anonymization
         service = AnonymizationService()
         kind = service.start(file_id)
         if not kind:
-            return Response({"detail": "Failed to start anonymization"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-        
-        return Response({
-            "detail": f"Anonymization started for {kind} file",
-            "file_id": file_id,
-            "file_type": kind,
-            "processing_locked": True
-        })
+            return Response(
+                {"detail": "Failed to start anonymization"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+        return Response(
+            {
+                "detail": f"Anonymization started for {kind} file",
+                "file_id": file_id,
+                "file_type": kind,
+                "processing_locked": True,
+            }
+        )
 
 
 # ---------- current with coordination ------------------------------------
-@api_view(['GET', 'POST', 'PUT'])
+@api_view(["GET", "POST", "PUT"])
 @permission_classes(DEBUG_PERMISSIONS)
 def anonymization_current(request, file_id):
     """
@@ -146,15 +170,15 @@ def anonymization_current(request, file_id):
     """
     # Try to find the file in VideoFile first
     try:
-        video_file = VideoFile.objects.select_related('sensitive_meta').get(id=file_id)
-        serializer = VoPPatientDataSerializer(video_file, context={'request': request})
+        video_file = VideoFile.objects.select_related("sensitive_meta").get(id=file_id)
+        serializer = VoPPatientDataSerializer(video_file, context={"request": request})
         return Response(serializer.data)
     except VideoFile.DoesNotExist:
         pass
     # Try to find the file in RawPdfFile
     try:
-        pdf_file = RawPdfFile.objects.select_related('sensitive_meta').get(id=file_id)
-        serializer = VoPPatientDataSerializer(pdf_file, context={'request': request})
+        pdf_file = RawPdfFile.objects.select_related("sensitive_meta").get(id=file_id)
+        serializer = VoPPatientDataSerializer(pdf_file, context={"request": request})
         return Response(serializer.data)
 
     except RawPdfFile.DoesNotExist:
@@ -162,12 +186,13 @@ def anonymization_current(request, file_id):
 
     except (ValueError, TypeError, AttributeError) as e:
         logger.error(f"Error in set_current_for_validation: {e}")
-        return JsonResponse({'status': 'error', 'message': str(e)}, status=500)
+        return JsonResponse({"status": "error", "message": str(e)}, status=500)
+
+    return JsonResponse({"status": "error", "message": "File not found"}, status=404)
 
-    return JsonResponse({'status': 'error', 'message': 'File not found'}, status=404)
 
 # ---------- polling coordinator info ------------------------------------
-@api_view(['GET'])
+@api_view(["GET"])
 @permission_classes(DEBUG_PERMISSIONS)
 def polling_coordinator_info(request):
     """
@@ -180,12 +205,13 @@ def polling_coordinator_info(request):
     except Exception as e:
         logger.error(f"Error getting polling coordinator info: {e}")
         return Response(
-            {"error": "Failed to get coordinator info"}, 
-            status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            {"error": "Failed to get coordinator info"},
+            status=status.HTTP_500_INTERNAL_SERVER_ERROR,
         )
 
+
 # ---------- emergency lock management -----------------------------------
-@api_view(['DELETE'])
+@api_view(["DELETE"])
 @permission_classes(DEBUG_PERMISSIONS)
 def clear_processing_locks(request):
     """
@@ -193,22 +219,25 @@ def clear_processing_locks(request):
     Emergency endpoint to clear all processing locks
     """
     try:
-        file_type = request.query_params.get('type', None)
+        file_type = request.query_params.get("type", None)
         cleared_count = PollingCoordinator.clear_all_locks(file_type)
-        
-        return Response({
-            "detail": "Processing locks cleared",
-            "cleared_count": cleared_count,
-            "file_type_filter": file_type
-        })
+
+        return Response(
+            {
+                "detail": "Processing locks cleared",
+                "cleared_count": cleared_count,
+                "file_type_filter": file_type,
+            }
+        )
     except Exception as e:
         logger.error(f"Error clearing processing locks: {e}")
         return Response(
-            {"error": "Failed to clear locks"}, 
-            status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            {"error": "Failed to clear locks"},
+            status=status.HTTP_500_INTERNAL_SERVER_ERROR,
         )
-        
-@api_view(['GET'])
+
+
+@api_view(["GET"])
 @permission_classes(DEBUG_PERMISSIONS)
 def has_raw_video_file(request, file_id):
     """
@@ -216,4 +245,4 @@ def has_raw_video_file(request, file_id):
     Check if a raw video file exists for the given file ID
     """
     exists = VideoFile.objects.filter(id=file_id, raw_file__isnull=False).exists()
-    return Response({"file_id": file_id, "has_raw_file": exists})
+    return Response({"file_id": file_id, "has_raw_file": exists})

endoreg_db/views/anonymization/validate.py

@@ -16,11 +16,11 @@ logger = logging.getLogger(__name__)
 class AnonymizationValidateView(APIView):
     """
     POST /api/anonymization/<int:file_id>/validate/
-    
+
     Validiert und aktualisiert SensitiveMeta-Felder für Videos oder PDFs.
-    
+
     DATA HERE IS COMING FROM THE ANONYIZATION VALIDATION COMPONENT
-    
+
     Body (Datumsfelder bevorzugt in deutschem Format DD.MM.YYYY; ISO YYYY-MM-DD ebenfalls akzeptiert):
     {
       "patient_first_name": "Max",
@@ -32,12 +32,12 @@ class AnonymizationValidateView(APIView):
       "casenumber":         "12345",
       "anonymized_text":    "...",             // nur für PDFs; Videos ignorieren
       "is_verified":        true               // optional; default true
-      "file_type":        "video"            // optional; "video" oder "pdf"; wenn nicht angegeben, wird zuerst Video, dann PDF versucht
+      "file_type":        "video"            // optional; "video" oder "pdf"; wenn nicht angegeben, wird zuerst Video, dann report versucht
       "center_name":       editedPatient.value.centerName || '',
       "external_id":       editedPatient.value.externalId || '',
-      "external_id_origin":editedPatient.value.externalIdOrigin || '', 
+      "external_id_origin":editedPatient.value.externalIdOrigin || '',
     }
-    
+
     Rückwärtskompatibilität: ISO-Format (YYYY-MM-DD) wird ebenfalls akzeptiert.
     """
 
@@ -56,10 +56,12 @@ class AnonymizationValidateView(APIView):
         file_type = payload.get("file_type")
 
         with transaction.atomic():
-            # Try Video first (unless explicitly requesting PDF)
+            # Try Video first (unless explicitly requesting report)
             if file_type in (None, "video"):
                 video = (
-                    VideoFile.objects.select_related("center", "sensitive_meta", "state")
+                    VideoFile.objects.select_related(
+                        "center", "sensitive_meta", "state"
+                    )
                     .filter(pk=file_id)
                     .first()
                 )
@@ -96,14 +98,13 @@ class AnonymizationValidateView(APIView):
                         video.sensitive_meta.create_anonymized_record()
                     else:
                         return Response(
-                            {
-                                "message": "Video not validated, failed to create State."
-                            },
+                            {"message": "Video not validated, failed to create State."},
                             status=status.HTTP_500_INTERNAL_SERVER_ERROR,
                         )
 
                     if video.state is not None:
-                        video.state.anonymized = True
+                        video.state.state.anonymization_status.mark_anonymized()
+                        video.state.save(update_fields=["anonymized"])
                         video.sensitive_meta.state.save()
 
                     return Response(
@@ -117,10 +118,12 @@ class AnonymizationValidateView(APIView):
                         status=status.HTTP_404_NOT_FOUND,
                     )
 
-            # Then PDF (unless explicitly requesting Video)
+            # Then report (unless explicitly requesting Video)
             if file_type in (None, "pdf"):
                 pdf = (
-                    RawPdfFile.objects.select_related("center", "sensitive_meta", "state")
+                    RawPdfFile.objects.select_related(
+                        "center", "sensitive_meta", "state"
+                    )
                     .filter(pk=file_id)
                     .first()
                 )
@@ -129,10 +132,10 @@ class AnonymizationValidateView(APIView):
                     try:
                         ok = pdf.validate_metadata_annotation(prepared_payload)
                     except Exception:  # pragma: no cover - defensive safety net
-                        logger.exception("PDF validation crashed for id=%s", file_id)
+                        logger.exception("report validation crashed for id=%s", file_id)
                         return Response(
                             {
-                                "error": "PDF validation encountered an unexpected error."
+                                "error": "report validation encountered an unexpected error."
                             },
                             status=status.HTTP_500_INTERNAL_SERVER_ERROR,
                         )
@@ -146,7 +149,7 @@ class AnonymizationValidateView(APIView):
 
                     if not ok:
                         return Response(
-                            {"error": "PDF validation failed."},
+                            {"error": "report validation failed."},
                             status=status.HTTP_400_BAD_REQUEST,
                         )
                     else:
@@ -166,24 +169,25 @@ class AnonymizationValidateView(APIView):
                             pdf.sensitive_meta.state.mark_dob_verified()
                             pdf.sensitive_meta.state.mark_names_verified()
                             pdf.sensitive_meta.create_anonymized_record()
-                            pdf.state.anonymized = True
+                            pdf.state.state.anonymization_status.mark_anonymized()
+                            pdf.state.save(update_fields=["anonymized"])
                             pdf.sensitive_meta.state.save()
                         else:
                             return Response(
                                 {
-                                    "message": "PDF not validated, failed to create State."
+                                    "message": "report not validated, failed to create State."
                                 },
                                 status=status.HTTP_500_INTERNAL_SERVER_ERROR,
                             )
 
                     return Response(
-                        {"message": "PDF validated."},
+                        {"message": "report validated."},
                         status=status.HTTP_200_OK,
                     )
 
                 if file_type == "pdf":
                     return Response(
-                        {"error": f"PDF {file_id} not found."},
+                        {"error": f"report {file_id} not found."},
                         status=status.HTTP_404_NOT_FOUND,
                     )
 

endoreg_db/views/media/__init__.py

@@ -3,17 +3,9 @@
 from .video_media import VideoMediaView
 from .pdf_media import PdfMediaView
 from ..video.reimport import VideoReimportView
-from ..pdf.reimport import PdfReimportView
-from .segments import video_segments_by_pk
-from .video_segments import (
-    video_segments_collection,
-    video_segments_by_video,
-    video_segment_detail,
-    video_segments_stats,
-    video_segment_validate,
-    video_segments_validate_bulk,
-    video_segments_validation_status,
-)
+from ..report.reimport import ReportReimportView
+from ..ai.label import label_list
+
 from .sensitive_metadata import (
     get_sensitive_metadata_pk,
     video_sensitive_metadata,
@@ -28,20 +20,13 @@ __all__ = [
     'VideoMediaView',
     'PdfMediaView',
     'VideoReimportView',
-    'PdfReimportView',
+    'ReportReimportView',
     'get_sensitive_metadata_pk',
-    'video_segments_by_pk',
-    'video_segments_collection',
-    'video_segments_by_video',
-    'video_segment_detail',
-    'video_segments_stats',
-    'video_segment_validate',
-    'video_segments_validate_bulk',
-    'video_segments_validation_status',
     'video_sensitive_metadata',
     'video_sensitive_metadata_verify',
     'pdf_sensitive_metadata',
     'pdf_sensitive_metadata_verify',
     'sensitive_metadata_list',
     'pdf_sensitive_metadata_list',
+    'label_list',
 ]