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

endoreg_db/utils/video/video_splitter.py

@@ -1,21 +1,25 @@
-import os
 import subprocess
 import pathlib
 import math
 import logging
-import json
 
 # Setup basic logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
 
 def get_video_duration(video_path: pathlib.Path) -> float:
     """Gets the duration of a video file using ffprobe."""
     cmd = [
         "ffprobe",
-        "-v", "error",
-        "-show_entries", "format=duration",
-        "-of", "default=noprint_wrappers=1:nokey=1",
-        str(video_path)
+        "-v",
+        "error",
+        "-show_entries",
+        "format=duration",
+        "-of",
+        "default=noprint_wrappers=1:nokey=1",
+        str(video_path),
     ]
     try:
         result = subprocess.run(cmd, capture_output=True, text=True, check=True)
@@ -28,6 +32,7 @@ def get_video_duration(video_path: pathlib.Path) -> float:
         logging.error(f"Could not parse duration from ffprobe output: {result.stdout}")
         raise
 
+
 def split_video(input_path: str, interval: int):
     """
     Splits a video into segments of a specified interval using ffmpeg.
@@ -54,11 +59,13 @@ def split_video(input_path: str, interval: int):
         return
 
     num_segments = math.ceil(duration / interval)
-    logging.info(f"Splitting into {num_segments} segments of approximately {interval} seconds each.")
+    logging.info(
+        f"Splitting into {num_segments} segments of approximately {interval} seconds each."
+    )
 
     for i in range(num_segments):
         start_time = i * interval
-        output_filename = output_dir / f"segment_{i+1:03d}{input_file.suffix}"
+        output_filename = output_dir / f"segment_{i + 1:03d}{input_file.suffix}"
 
         # Use -t for interval duration. For the last segment, ffmpeg with -c copy
         # might automatically stop at the end, or we could calculate exact duration.
@@ -69,26 +76,30 @@ def split_video(input_path: str, interval: int):
 
         cmd = [
             "ffmpeg",
-            "-i", str(input_file),
-            "-ss", str(start_time),
-            "-t", str(interval),
-            "-c", "copy",  # Fast, lossless splitting
-            "-avoid_negative_ts", "make_zero", # Avoids issues with negative timestamps
-            str(output_filename)
+            "-i",
+            str(input_file),
+            "-ss",
+            str(start_time),
+            "-t",
+            str(interval),
+            "-c",
+            "copy",  # Fast, lossless splitting
+            "-avoid_negative_ts",
+            "make_zero",  # Avoids issues with negative timestamps
+            str(output_filename),
         ]
 
         logging.info(f"Running command: {' '.join(cmd)}")
         try:
             result = subprocess.run(cmd, capture_output=True, text=True, check=True)
             logging.info(f"Successfully created segment: {output_filename}")
-            if result.stderr: # ffmpeg often outputs info to stderr
-                 logging.debug(f"ffmpeg output for segment {i+1}:\n{result.stderr}")
+            if result.stderr:  # ffmpeg often outputs info to stderr
+                logging.debug(f"ffmpeg output for segment {i + 1}:\n{result.stderr}")
         except subprocess.CalledProcessError as e:
-            logging.error(f"Error creating segment {i+1}: {output_filename}")
+            logging.error(f"Error creating segment {i + 1}: {output_filename}")
             logging.error(f"Command failed: {' '.join(cmd)}")
             logging.error(f"ffmpeg stderr:\n{e.stderr}")
             # Decide if you want to stop on error or continue
             # return # Uncomment to stop on first error
 
     logging.info("Video splitting completed.")
-

endoreg_db/views/Frames_NICE_and_PARIS_classifications_views.py

@@ -4,19 +4,17 @@ from rest_framework import status
 from endoreg_db.models import VideoFile
 from ..serializers.Frames_NICE_and_PARIS_classifications import (
     ForNiceClassificationSerializer,
-    ForParisClassificationSerializer
+    ForParisClassificationSerializer,
 )
 
-import logging
-
 
 class ForNiceClassificationView(APIView):
     """
     NICE Classification API View
-    
+
     GET: Führt NICE-Klassifikation für alle Videos durch
     POST: Führt NICE-Klassifikation für spezifizierte Videos durch
-    
+
     POST Body: {"video_ids": [1, 2, 3]} oder leerer Body für alle Videos
     """
 
@@ -34,12 +32,14 @@ class ForNiceClassificationView(APIView):
         try:
             # Handle POST data for specific video IDs
             video_ids = None
-            if request.method == 'POST' and hasattr(request, 'data'):
-                video_ids = request.data.get('video_ids', None)
+            if request.method == "POST" and hasattr(request, "data"):
+                video_ids = request.data.get("video_ids", None)
 
             if video_ids:
                 videos = VideoFile.objects.filter(id__in=video_ids)
-                print(f"[DEBUG] Processing NICE classification for specific videos: {video_ids}")
+                print(
+                    f"[DEBUG] Processing NICE classification for specific videos: {video_ids}"
+                )
             else:
                 videos = VideoFile.objects.all()
                 print("[DEBUG] Processing NICE classification for all videos")
@@ -51,7 +51,7 @@ class ForNiceClassificationView(APIView):
             if not videos.exists():
                 return Response(
                     {"error": "No videos found in the database."},
-                    status=status.HTTP_404_NOT_FOUND
+                    status=status.HTTP_404_NOT_FOUND,
                 )
 
             serializer = ForNiceClassificationSerializer()
@@ -60,7 +60,7 @@ class ForNiceClassificationView(APIView):
             if not response_data:
                 return Response(
                     {"error": "No valid segments for NICE classification."},
-                    status=status.HTTP_404_NOT_FOUND
+                    status=status.HTTP_404_NOT_FOUND,
                 )
 
             return Response(response_data, status=status.HTTP_200_OK)
@@ -68,17 +68,17 @@ class ForNiceClassificationView(APIView):
         except Exception as e:
             return Response(
                 {"error": f"Internal server error: {str(e)}"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
 
 
 class ForParisClassificationView(APIView):
     """
     PARIS Classification API View
-    
+
     GET: Führt PARIS-Klassifikation für alle Videos durch
     POST: Führt PARIS-Klassifikation für spezifizierte Videos durch
-    
+
     POST Body: {"video_ids": [1, 2, 3]} oder leerer Body für alle Videos
     """
 
@@ -96,27 +96,32 @@ class ForParisClassificationView(APIView):
         try:
             # Handle POST data for specific video IDs
             video_ids = None
-            if request.method == 'POST' and hasattr(request, 'data'):
-                video_ids = request.data.get('video_ids', None)
+            if request.method == "POST" and hasattr(request, "data"):
+                video_ids = request.data.get("video_ids", None)
 
             if video_ids:
                 videos = VideoFile.objects.filter(id__in=video_ids)
-                print(f"[DEBUG] Processing PARIS classification for specific videos: {video_ids}")
+                print(
+                    f"[DEBUG] Processing PARIS classification for specific videos: {video_ids}"
+                )
             else:
                 videos = VideoFile.objects.all()
-                print(f"[DEBUG] Processing PARIS classification for all videos")
+                print("[DEBUG] Processing PARIS classification for all videos")
 
             print(f"[DEBUG] Total videos found: {videos.count()}")
 
             filtered_videos = [
-                video for video in videos
-                if getattr(video, "frame_dir", None)  # no more readable_predictions check
+                video
+                for video in videos
+                if getattr(
+                    video, "frame_dir", None
+                )  # no more readable_predictions check
             ]
 
             if not filtered_videos:
                 return Response(
                     {"error": "No videos with valid frame_dir found."},
-                    status=status.HTTP_404_NOT_FOUND
+                    status=status.HTTP_404_NOT_FOUND,
                 )
 
             serializer = ForParisClassificationSerializer()
@@ -125,7 +130,7 @@ class ForParisClassificationView(APIView):
             if not response_data:
                 return Response(
                     {"error": "No valid PARIS segments found."},
-                    status=status.HTTP_404_NOT_FOUND
+                    status=status.HTTP_404_NOT_FOUND,
                 )
 
             return Response(response_data, status=status.HTTP_200_OK)
@@ -133,16 +138,16 @@ class ForParisClassificationView(APIView):
         except Exception as e:
             return Response(
                 {"error": f"Internal server error: {str(e)}"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
 
 
 class BatchClassificationView(APIView):
     """
     Batch Classification API View
-    
+
     POST: Führt beide Klassifikationstypen (NICE und PARIS) für spezifizierte Videos durch
-    
+
     POST Body: {
         "video_ids": [1, 2, 3],
         "types": ["nice", "paris"]  # Optional, default beide
@@ -151,8 +156,8 @@ class BatchClassificationView(APIView):
 
     def post(self, request):
         try:
-            video_ids = request.data.get('video_ids', None)
-            classification_types = request.data.get('types', ['nice', 'paris'])
+            video_ids = request.data.get("video_ids", None)
+            classification_types = request.data.get("types", ["nice", "paris"])
 
             if video_ids:
                 videos = VideoFile.objects.filter(id__in=video_ids)
@@ -161,67 +166,71 @@ class BatchClassificationView(APIView):
 
             if not videos.exists():
                 return Response(
-                    {"error": "No videos found."},
-                    status=status.HTTP_404_NOT_FOUND
+                    {"error": "No videos found."}, status=status.HTTP_404_NOT_FOUND
                 )
 
             results = {}
 
-            if 'nice' in classification_types:
+            if "nice" in classification_types:
                 nice_serializer = ForNiceClassificationSerializer()
-                results['nice'] = nice_serializer.to_representation(videos)
+                results["nice"] = nice_serializer.to_representation(videos)
 
-            if 'paris' in classification_types:
+            if "paris" in classification_types:
                 # Filter videos for PARIS (need frame_dir)
                 filtered_videos = [
-                    video for video in videos
-                    if getattr(video, "frame_dir", None)
+                    video for video in videos if getattr(video, "frame_dir", None)
                 ]
-                
+
                 if filtered_videos:
                     paris_serializer = ForParisClassificationSerializer()
-                    results['paris'] = paris_serializer.to_representation(filtered_videos)
+                    results["paris"] = paris_serializer.to_representation(
+                        filtered_videos
+                    )
                 else:
-                    results['paris'] = {"error": "No videos with valid frame_dir found for PARIS classification."}
+                    results["paris"] = {
+                        "error": "No videos with valid frame_dir found for PARIS classification."
+                    }
 
-            return Response({
-                "message": "Batch classification completed.",
-                "results": results
-            }, status=status.HTTP_200_OK)
+            return Response(
+                {"message": "Batch classification completed.", "results": results},
+                status=status.HTTP_200_OK,
+            )
 
         except Exception as e:
             return Response(
                 {"error": f"Internal server error: {str(e)}"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
 
 
 class ClassificationStatusView(APIView):
     """
     Classification Status API View
-    
+
     GET: Gibt den Status der Klassifikationen für ein Video zurück
     """
 
     def get(self, request, video_id):
         try:
             video = VideoFile.objects.get(id=video_id)
-            
+
             # Check if classifications exist for this video
             # This would typically check for saved classification results in the database
             # For now, we'll return basic status information
-            
+
             status_info = {
                 "video_id": video_id,
-                "video_name": getattr(video, 'original_file_name', 'Unknown'),
+                "video_name": getattr(video, "original_file_name", "Unknown"),
                 "has_frame_dir": bool(getattr(video, "frame_dir", None)),
                 "nice_classification_available": True,  # Always available for NICE
-                "paris_classification_available": bool(getattr(video, "frame_dir", None)),
+                "paris_classification_available": bool(
+                    getattr(video, "frame_dir", None)
+                ),
                 "last_processed": None,  # Would come from classification results table
                 "classification_results": {
                     "nice": None,  # Would contain saved NICE results
-                    "paris": None   # Would contain saved PARIS results
-                }
+                    "paris": None,  # Would contain saved PARIS results
+                },
             }
 
             return Response(status_info, status=status.HTTP_200_OK)
@@ -229,10 +238,10 @@ class ClassificationStatusView(APIView):
         except VideoFile.DoesNotExist:
             return Response(
                 {"error": f"Video with ID {video_id} not found."},
-                status=status.HTTP_404_NOT_FOUND
+                status=status.HTTP_404_NOT_FOUND,
             )
         except Exception as e:
             return Response(
                 {"error": f"Internal server error: {str(e)}"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )

endoreg_db/views/__init__.py

@@ -43,20 +43,11 @@ from .media import (
 )
 from .meta import SensitiveMetaListView, SensitiveMetaVerificationView
 from .misc import (
-    MODELTRANSLATION_SETTINGS,
     CenterViewSet,
     ExaminationStatsView,
-    ExaminationTranslationOptions,
-    FindingClassificationChoiceTranslationOptions,
-    FindingClassificationTranslationOptions,
-    FindingTranslationOptions,
     GenderViewSet,
     GeneralStatsView,
-    InterventionTranslationOptions,
     SensitiveMetaStatsView,
-    TranslatedFieldMixin,
-    TranslatedFixtureLoader,
-    TranslationMigrationHelper,
     UploadFileView,
     UploadStatusView,
     VideoSegmentStatsView,
@@ -77,7 +68,6 @@ from .video import (  # Video Correction (Phase 1.1) - Implemented; Existing vie
     VideoApplyMaskView,
     VideoCorrectionView,
     VideoExaminationViewSet,
-    VideoProcessingHistoryView,
     VideoReimportView,
     VideoRemoveFramesView,
     VideoStreamView,
@@ -127,16 +117,7 @@ __all__ = [
     "VideoSegmentStatsView",
     "SensitiveMetaStatsView",
     "GeneralStatsView",
-    "ExaminationTranslationOptions",
-    "FindingTranslationOptions",
-    "FindingClassificationTranslationOptions",
-    "FindingClassificationChoiceTranslationOptions",
-    "InterventionTranslationOptions",
-    "TranslatedFieldMixin",
-    "TranslationMigrationHelper",
-    "TranslatedFixtureLoader",
     "build_multilingual_response",
-    "MODELTRANSLATION_SETTINGS",
     "UploadFileView",
     "UploadStatusView",
     # Patient Views
@@ -158,7 +139,6 @@ __all__ = [
     "evaluate_requirements",
     "LookupViewSet",
     # Video Views (Phase 1.1 - Implemented)
-    "VideoProcessingHistoryView",
     "VideoApplyMaskView",
     "VideoRemoveFramesView",
     "VideoCorrectionView",

endoreg_db/views/anonymization/__init__.py

@@ -10,7 +10,11 @@ from .overview import (
 
 from .validate import AnonymizationValidateView
 
-from .media_management import MediaManagementView, force_remove_media, reset_processing_status
+from .media_management import (
+    MediaManagementView,
+    force_remove_media,
+    reset_processing_status,
+)
 
 __all__ = [
     "AnonymizationOverviewView",
@@ -24,4 +28,4 @@ __all__ = [
     "force_remove_media",
     "reset_processing_status",
     "has_raw_video_file",
-]
+]

endoreg_db/views/anonymization/media_management.py

@@ -5,9 +5,7 @@ from datetime import timedelta
 from typing import Any, Dict
 
 from django.db import transaction
-from django.db.models import Q
 from django.utils import timezone
-from numpy import delete
 from rest_framework import status
 from rest_framework.decorators import api_view, permission_classes
 from rest_framework.response import Response
@@ -195,12 +193,10 @@ class MediaManagementView(APIView):
         pdf_file_obj = None
 
         if media_type == "video":
-            video_file_obj = (
-                VideoFile.get_video_by_pk(pk=file_id) if file_id else None
-            )
+            video_file_obj = VideoFile.get_video_by_pk(pk=file_id) if file_id else None
 
         elif media_type == "pdf":
-            pdf_file_obj = RawPdfFile.get_pdf_by_pk(pk=file_id) if file_id else None
+            pdf_file_obj = RawPdfFile.get_report_by_pk(pk=file_id) if file_id else None
 
         with transaction.atomic():
             if video_file_obj:

endoreg_db/views/anonymization/overview.py

@@ -19,6 +19,8 @@ from endoreg_db.services.polling_coordinator import (
 from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
 
 from ...serializers import FileOverviewSerializer, VoPPatientDataSerializer
+from endoreg_db.utils.operation_log import record_operation
+
 
 logger = logging.getLogger(__name__)
 PERMS = DEBUG_PERMISSIONS  # shorten
@@ -127,7 +129,10 @@ def start_anonymization(request, file_id: int):
     if not info:
         return Response({"detail": "File not found"}, status=status.HTTP_404_NOT_FOUND)
 
-    file_type = info["mediaType"]
+    file_type = info.get("mediaType") or "unknown"
+    status_before = (
+        info.get("anonymizationStatus") or info.get("status") or "not_started"
+    )
 
     # Use processing lock context to prevent duplicate processing
     with ProcessingLockContext(file_id, file_type) as lock:
@@ -151,6 +156,34 @@ def start_anonymization(request, file_id: int):
                 status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
 
+        # Re-read status AFTER starting
+        try:
+            info_after = AnonymizationService.get_status(file_id) or {}
+        except Exception:
+            logger.exception(
+                "Failed to refresh anonymization status for file %s", file_id
+            )
+            info_after = {}
+
+        status_after = (
+            info_after.get("anonymizationStatus")
+            or info_after.get("status")
+            or status_before
+        )
+
+        # 🔐 Write operation log
+        record_operation(
+            request,
+            action="anonymization.start",
+            resource_type=kind,  # 'video' or 'pdf' as returned by service.start
+            resource_id=file_id,
+            status_before=str(status_before),
+            status_after=str(status_after),
+            meta={
+                "file_type_from_status": file_type,
+            },
+        )
+
         return Response(
             {
                 "detail": f"Anonymization started for {kind} file",

endoreg_db/views/anonymization/validate.py

@@ -9,6 +9,9 @@ from rest_framework.views import APIView
 from endoreg_db.models import RawPdfFile, VideoFile
 from endoreg_db.models.metadata import SensitiveMeta
 from endoreg_db.serializers.anonymization import SensitiveMetaValidateSerializer
+from endoreg_db.utils.operation_log import (
+    record_operation,  # only touched the parts where validation succeeds
+)
 
 logger = logging.getLogger(__name__)
 
@@ -17,7 +20,7 @@ class AnonymizationValidateView(APIView):
     """
     POST /api/anonymization/<int:file_id>/validate/
 
-    Validiert und aktualisiert SensitiveMeta-Felder für Videos oder PDFs.
+    Validiert und aktualisiert SensitiveMeta-Felder für Videos oder reports.
 
     DATA HERE IS COMING FROM THE ANONYIZATION VALIDATION COMPONENT
 
@@ -30,7 +33,7 @@ class AnonymizationValidateView(APIView):
       "examination_date":   "15.02.2024",      // DD.MM.YYYY bevorzugt
 
       "casenumber":         "12345",
-      "anonymized_text":    "...",             // nur für PDFs; Videos ignorieren
+      "anonymized_text":    "...",             // nur für reports; Videos ignorieren
       "is_verified":        true               // optional; default true
       "file_type":        "video"            // optional; "video" oder "pdf"; wenn nicht angegeben, wird zuerst Video, dann report versucht
       "center_name":       editedPatient.value.centerName || '',
@@ -54,6 +57,7 @@ class AnonymizationValidateView(APIView):
             payload["is_verified"] = True
 
         file_type = payload.get("file_type")
+        status_before = None
 
         with transaction.atomic():
             # Try Video first (unless explicitly requesting report)
@@ -65,6 +69,7 @@ class AnonymizationValidateView(APIView):
                     .filter(pk=file_id)
                     .first()
                 )
+                # TODO: The state for video will be none when no state is set and the state for pdf will always be none. After status needs to be inferred after calling the sensitive meta state update functions
                 if video is not None:
                     prepared_payload = self._prepare_payload(payload, video)
                     try:
@@ -103,9 +108,43 @@ class AnonymizationValidateView(APIView):
                         )
 
                     if video.state is not None:
-                        video.state.state.anonymization_status.mark_anonymized()
-                        video.state.save(update_fields=["anonymized"])
+                        video.state.anonymized = True
                         video.sensitive_meta.state.save()
+                    try:
+                        if video.state is not None:
+                            st = getattr(video.state, "anonymization_status", None)
+                            if st is not None:
+                                status_before = str(getattr(st, "value", st))
+                    except Exception:
+                        logger.exception(
+                            "Failed to read video anonymization_status before validation"
+                        )
+
+                        # --- NEW: status AFTER validation ---
+                    status_after = status_before
+                    try:
+                        if video.state is not None:
+                            video.state.refresh_from_db()
+                            st_after = getattr(
+                                video.state, "anonymization_status", None
+                            )
+                            if st_after is not None:
+                                status_after = str(getattr(st_after, "value", st_after))
+                    except Exception:
+                        logger.exception(
+                            "Failed to read video anonymization_status after validation"
+                        )
+
+                    # --- write operation log ---
+                    # TODO: update the function call bases on the status , once merged
+                    record_operation(
+                        request,
+                        action="anonymization.validated",
+                        resource_type="video",
+                        resource_id=file_id,
+                        status_before=status_before,
+                        status_after=status_after,
+                    )
 
                     return Response(
                         {"message": "Video validated."},
@@ -161,25 +200,47 @@ class AnonymizationValidateView(APIView):
                         pdf.save(update_fields=["sensitive_meta"])
                         pdf.sensitive_meta.get_or_create_state()
                         if (
-                            pdf.sensitive_meta
-                            and pdf.sensitive_meta.state
-                            and pdf.state
-                        ):
-                            pdf.sensitive_meta.state.refresh_from_db()
-                            pdf.sensitive_meta.state.mark_dob_verified()
-                            pdf.sensitive_meta.state.mark_names_verified()
-                            pdf.sensitive_meta.create_anonymized_record()
-                            pdf.state.state.anonymization_status.mark_anonymized()
-                            pdf.state.save(update_fields=["anonymized"])
-                            pdf.sensitive_meta.state.save()
+                                pdf.sensitive_meta
+                                and pdf.sensitive_meta.state
+                            ):
+                                pdf.sensitive_meta.state.refresh_from_db()
+                                pdf.sensitive_meta.state.mark_dob_verified()
+                                pdf.sensitive_meta.state.mark_names_verified()
+                                pdf.sensitive_meta.create_anonymized_record()
+                                
+                                if pdf.state:
+                                    pdf.state.mark_anonymized()
+                                    pdf.state.save(update_fields=["anonymized"])
+                                    
+                                pdf.sensitive_meta.state.save()
                         else:
                             return Response(
-                                {
-                                    "message": "report not validated, failed to create State."
-                                },
+                                {"message": "report not validated, failed to create State."},
                                 status=status.HTTP_500_INTERNAL_SERVER_ERROR,
                             )
 
+                    status_after = status_before
+                    try:
+                        if pdf.state is not None:
+                            pdf.state.refresh_from_db()
+                            st_after = getattr(pdf.state, "anonymization_status", None)
+                            if st_after is not None:
+                                status_after = str(getattr(st_after, "value", st_after))
+                    except Exception:
+                        logger.exception(
+                            "Failed to read pdf anonymization_status after validation"
+                        )
+
+                    # --- NEW: write operation log ---
+                    record_operation(
+                        request,
+                        action="anonymization.validated",
+                        resource_type="pdf",
+                        resource_id=file_id,
+                        status_before=status_before,
+                        status_after=status_after,
+                    )
+
                     return Response(
                         {"message": "report validated."},
                         status=status.HTTP_200_OK,

endoreg_db/views/auth/__init__.py

@@ -10,4 +10,4 @@ __all__ = [
     "keycloak_login",
     "keycloak_callback",
     "public_home",
-]
+]