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

endoreg_db/models/media/video/video_file.py

@@ -523,8 +523,13 @@ class VideoFile(models.Model):
         """
         Validate the metadata of the VideoFile instance.
 
-        Called after annotation in the frontend, this method deletes the associated active file, updates the sensitive meta data with the user annotated data.
-        It also ensures the video file is properly saved after the metadata update.
+        Called after annotation in the frontend, this method:
+        1. Updates sensitive metadata with user-annotated data
+        2. Deletes the RAW video file (keeping only the anonymized version)
+        3. Marks the video as validated
+
+        **IMPORTANT:** Only the raw video is deleted. The processed (anonymized)
+        video is preserved as the final validated output.
         """
         from datetime import date as dt_date
 
@@ -541,9 +546,22 @@ class VideoFile(models.Model):
             }
             self.sensitive_meta = SensitiveMeta.create_from_dict(default_data)
 
-        # Delete the active file to ensure it is reprocessed with the new metadata
-        if self.active_file_path.exists():
-            self.active_file_path.unlink(missing_ok=True)
+        # CRITICAL FIX: Delete RAW video file, not the processed (anonymized) one
+        # After validation, only the anonymized video should remain
+        from .video_file_io import _get_raw_file_path
+
+        raw_path = _get_raw_file_path(self)
+        if raw_path and raw_path.exists():
+            logger.info(f"Deleting raw video file after validation: {raw_path}")
+            raw_path.unlink(missing_ok=True)
+            # Clear the raw_file field in database (use delete() to avoid save issues)
+            if self.raw_file:
+                self.raw_file.delete(save=False)
+            logger.info(
+                f"Raw video deleted for {self.uuid}. Anonymized video preserved."
+            )
+        else:
+            logger.warning(f"Raw video file not found for deletion: {self.uuid}")
 
         # Update sensitive metadata with user annotations
         sensitive_meta = _update_text_metadata(

endoreg_db/serializers/__init__.py

@@ -1,81 +1,60 @@
 from .administration import (
+    ActiveModelSerializer,
+    AiModelSerializer,
     CenterSerializer,
     GenderSerializer,
-    ActiveModelSerializer,
     ModelTypeSerializer,
-    AiModelSerializer
 )
-
 from .examination import (
+    ExaminationDropdownSerializer,
     ExaminationSerializer,
     ExaminationTypeSerializer,
-    ExaminationDropdownSerializer
 )
-
 from .finding import FindingSerializer
-
 from .finding_classification import (
     FindingClassificationChoiceSerializer,
-    FindingClassificationSerializer
+    FindingClassificationSerializer,
 )
-
-from .label import (
-    LabelSerializer,
-    ImageClassificationAnnotationSerializer
-)
-
+from .label import ImageClassificationAnnotationSerializer, LabelSerializer
 from .label_video_segment import (
-    LabelVideoSegmentSerializer,
     LabelVideoSegmentAnnotationSerializer,
+    LabelVideoSegmentSerializer,
 )
-
 from .meta import (
-    ReportMetaSerializer,
     PDFFileForMetaSerializer,
+    ReportMetaSerializer,
     SensitiveMetaDetailSerializer,
     SensitiveMetaUpdateSerializer,
     SensitiveMetaVerificationSerializer,
     VideoMetaSerializer,
 )
-
 from .misc import (
     FileOverviewSerializer,
-    VoPPatientDataSerializer,
     StatsSerializer,
-    UploadJobStatusSerializer,
+    TranslatableFieldMixin,
     UploadCreateResponseSerializer,
-    TranslatableFieldMixin
-)
-
-from .patient import (
-    PatientSerializer,
-    PatientDropdownSerializer,
-)
-
-from .patient_examination import (
-    PatientExaminationSerializer,
+    UploadJobStatusSerializer,
+    VoPPatientDataSerializer,
 )
-
+from .patient import PatientDropdownSerializer, PatientSerializer
+from .patient_examination import PatientExaminationSerializer
 from .patient_finding import (
-    PatientFindingSerializer,
     PatientFindingClassificationSerializer,
     PatientFindingDetailSerializer,
     PatientFindingInterventionSerializer,
     PatientFindingListSerializer,
+    PatientFindingSerializer,
     PatientFindingWriteSerializer,
 )
-
-from .pdf import (
-    RawPdfAnonyTextSerializer
-)
-from .report import (
-    ReportListSerializer,
-    ReportDataSerializer,
-    SecureFileUrlSerializer
-)
-
+from .pdf import RawPdfAnonyTextSerializer
+from .report import ReportDataSerializer, ReportListSerializer, SecureFileUrlSerializer
 from .video.video_metadata import VideoMetadataSerializer
 from .video.video_processing_history import VideoProcessingHistorySerializer
+from .video_examination import (
+    VideoExaminationCreateSerializer,
+    VideoExaminationSerializer,
+    VideoExaminationUpdateSerializer,
+)
 
 __all__ = [
     # Administration
@@ -84,24 +63,19 @@ __all__ = [
     "ActiveModelSerializer",
     "ModelTypeSerializer",
     "AiModelSerializer",
-
     # Examination
     "ExaminationSerializer",
     "ExaminationTypeSerializer",
     "ExaminationDropdownSerializer",
-
     # Finding
-    'FindingSerializer',
-    'FindingClassificationSerializer',
+    "FindingSerializer",
+    "FindingClassificationSerializer",
     "FindingClassificationChoiceSerializer",
-
     "LabelSerializer",
     "ImageClassificationAnnotationSerializer",
-
     # LabelVideoSegment
     "LabelVideoSegmentSerializer",
     "LabelVideoSegmentAnnotationSerializer",
-
     # Meta
     "PDFFileForMetaSerializer",
     "ReportMetaSerializer",
@@ -109,7 +83,6 @@ __all__ = [
     "SensitiveMetaUpdateSerializer",
     "SensitiveMetaVerificationSerializer",
     "VideoMetaSerializer",
-
     # Misc
     "FileOverviewSerializer",
     "VoPPatientDataSerializer",
@@ -117,14 +90,11 @@ __all__ = [
     "UploadJobStatusSerializer",
     "UploadCreateResponseSerializer",
     "TranslatableFieldMixin",
-
     # Patient
     "PatientSerializer",
     "PatientDropdownSerializer",
-
     # Patient Examination
     "PatientExaminationSerializer",
-
     # Patient Finding
     "PatientFindingSerializer",
     "PatientFindingClassificationSerializer",
@@ -132,16 +102,17 @@ __all__ = [
     "PatientFindingInterventionSerializer",
     "PatientFindingListSerializer",
     "PatientFindingWriteSerializer",
-
     # PDF
     "RawPdfAnonyTextSerializer",
-
     # Report
     "ReportListSerializer",
     "ReportDataSerializer",
     "SecureFileUrlSerializer",
-
     # Video Correction (Phase 1.1)
     "VideoMetadataSerializer",
     "VideoProcessingHistorySerializer",
+    # Video Examination
+    "VideoExaminationSerializer",
+    "VideoExaminationCreateSerializer",
+    "VideoExaminationUpdateSerializer",
 ]

endoreg_db/serializers/video_examination.py

@@ -0,0 +1,198 @@
+"""
+Video Examination Serializer
+
+Serializes PatientExamination instances that are associated with VideoFile records.
+This allows frontend components like VideoExaminationAnnotation.vue to display
+and manage examinations within the video annotation workflow.
+"""
+
+from rest_framework import serializers
+
+from ..models import Examination, PatientExamination, VideoFile
+
+
+class VideoExaminationSerializer(serializers.ModelSerializer):
+    """
+    Serializer for video-based patient examinations.
+
+    Exposes examination data within the context of video annotation:
+    - Basic examination metadata (type, date, hash)
+    - Related patient information (anonymized)
+    - Video reference
+    - Associated findings
+    """
+
+    # Custom fields for frontend compatibility
+    examination_name = serializers.CharField(source="examination.name", read_only=True)
+    examination_id = serializers.IntegerField(source="examination.id", read_only=True)
+    video_id = serializers.IntegerField(source="video.id", read_only=True)
+    patient_hash = serializers.CharField(source="patient.patient_hash", read_only=True)
+
+    # Nested findings data
+    findings = serializers.SerializerMethodField()
+
+    class Meta:
+        model = PatientExamination
+        fields = [
+            "id",
+            "hash",
+            "examination_id",
+            "examination_name",
+            "video_id",
+            "patient_hash",
+            "date_start",
+            "date_end",
+            "findings",
+        ]
+        read_only_fields = ["hash", "patient_hash"]
+
+    def get_findings(self, obj):
+        """
+        Return serialized findings associated with this examination.
+
+        Args:
+            obj: PatientExamination instance
+
+        Returns:
+            List of finding dictionaries with basic metadata
+        """
+        patient_findings = obj.patient_findings.all()
+        return [
+            {
+                "id": pf.id,
+                "finding_id": pf.finding.id if pf.finding else None,
+                "finding_name": pf.finding.name if pf.finding else None,
+                "created_at": pf.created_at if hasattr(pf, "created_at") else None,
+            }
+            for pf in patient_findings
+        ]
+
+
+class VideoExaminationCreateSerializer(serializers.Serializer):
+    """
+    Serializer for creating video examinations via API.
+
+    Handles the complex creation logic required to link:
+    - VideoFile (must exist)
+    - Examination type (must exist)
+    - Patient (derived from video's SensitiveMeta)
+    - New PatientExamination record
+    """
+
+    video_id = serializers.IntegerField(required=True)
+    examination_id = serializers.IntegerField(required=True)
+    date_start = serializers.DateField(required=False, allow_null=True)
+    date_end = serializers.DateField(required=False, allow_null=True)
+
+    def validate_video_id(self, value):
+        """Ensure video exists"""
+        if not VideoFile.objects.filter(id=value).exists():
+            raise serializers.ValidationError(f"Video with id {value} does not exist")
+        return value
+
+    def validate_examination_id(self, value):
+        """Ensure examination type exists"""
+        if not Examination.objects.filter(id=value).exists():
+            raise serializers.ValidationError(
+                f"Examination with id {value} does not exist"
+            )
+        return value
+
+    def create(self, validated_data):
+        """
+        Create PatientExamination record.
+
+        Links video to examination through patient relationship:
+        1. Get video and extract patient from SensitiveMeta
+        2. Get examination type
+        3. Create PatientExamination linking patient, examination, video
+
+        Raises:
+            ValidationError: If video has no patient or sensitive_meta
+        """
+        video = VideoFile.objects.get(id=validated_data["video_id"])
+        examination = Examination.objects.get(id=validated_data["examination_id"])
+
+        # Get patient from video's sensitive metadata
+        if not hasattr(video, "sensitive_meta") or not video.sensitive_meta:
+            raise serializers.ValidationError(
+                "Video must have sensitive metadata with patient information"
+            )
+
+        sensitive_meta = video.sensitive_meta
+        if not sensitive_meta.pseudo_patient:
+            raise serializers.ValidationError(
+                "Video's sensitive metadata must have an associated pseudo patient"
+            )
+
+        patient = sensitive_meta.pseudo_patient
+
+        # Check if PatientExamination already exists for this video
+        existing_exam = PatientExamination.objects.filter(video=video).first()
+        if existing_exam:
+            # Update existing
+            patient_exam = existing_exam
+            patient_exam.examination = examination
+            if "date_start" in validated_data:
+                patient_exam.date_start = validated_data["date_start"]
+            if "date_end" in validated_data:
+                patient_exam.date_end = validated_data["date_end"]
+            patient_exam.save()
+        else:
+            # Create new
+            patient_exam = PatientExamination.objects.create(
+                patient=patient,
+                examination=examination,
+                video=video,
+                date_start=validated_data.get("date_start"),
+                date_end=validated_data.get("date_end"),
+            )
+
+        return patient_exam
+
+
+class VideoExaminationUpdateSerializer(serializers.Serializer):
+    """
+    Serializer for updating video examinations.
+
+    Allows modification of:
+    - Examination type
+    - Date range
+    - Associated findings (via separate endpoint)
+    """
+
+    examination_id = serializers.IntegerField(required=False)
+    date_start = serializers.DateField(required=False, allow_null=True)
+    date_end = serializers.DateField(required=False, allow_null=True)
+
+    def validate_examination_id(self, value):
+        """Ensure examination type exists if provided"""
+        if value is not None and not Examination.objects.filter(id=value).exists():
+            raise serializers.ValidationError(
+                f"Examination with id {value} does not exist"
+            )
+        return value
+
+    def update(self, instance, validated_data):
+        """
+        Update PatientExamination fields.
+
+        Args:
+            instance: Existing PatientExamination
+            validated_data: Validated update data
+
+        Returns:
+            Updated PatientExamination instance
+        """
+        if "examination_id" in validated_data:
+            examination = Examination.objects.get(id=validated_data["examination_id"])
+            instance.examination = examination
+
+        if "date_start" in validated_data:
+            instance.date_start = validated_data["date_start"]
+
+        if "date_end" in validated_data:
+            instance.date_end = validated_data["date_end"]
+
+        instance.save()
+        return instance